From 3b45a1634819b31163e22e8ce92aa67f1e7ae8aa Mon Sep 17 00:00:00 2001 From: Judyxujj Date: Wed, 15 May 2024 17:26:48 +0800 Subject: [PATCH 001/227] Add swb PyTorch ctc setup (#219) * add initial setup * rm binary files * rm binary files --------- Co-authored-by: Jingjing Xu --- .../ctc/lbs_960/configs/baseline_config.py | 2 +- users/jxu/experiments/ctc/swb/__init__.py | 0 .../experiments/ctc/swb/configs/__init__.py | 0 .../ctc/swb/configs/baseline/__init__.py | 0 .../baseline/config_01_ctc_torch_conformer.py | 168 +++++++++++ .../baseline/config_01b_ctc_conformer.py | 263 ++++++++++++++++++ .../jxu/experiments/ctc/swb/data/__init__.py | 0 .../jxu/experiments/ctc/swb/data/ctc_data.py | 161 +++++++++++ users/jxu/experiments/ctc/swb/data/data.py | 160 +++++++++++ users/jxu/experiments/ctc/swb/data/lm_data.py | 13 + ...er_ctc_d_model_386_num_layers_12_logmel.py | 262 +++++++++++++++++ .../train_steps/baseline_ctc.py | 55 ++++ .../ctc/swb/pytorch_networks/util.py | 14 + .../._i6_conformer_downsample_3.py | Bin 4096 -> 0 bytes 14 files changed, 1097 insertions(+), 1 deletion(-) create mode 100644 users/jxu/experiments/ctc/swb/__init__.py create mode 100644 users/jxu/experiments/ctc/swb/configs/__init__.py create mode 100644 users/jxu/experiments/ctc/swb/configs/baseline/__init__.py create mode 100644 users/jxu/experiments/ctc/swb/configs/baseline/config_01_ctc_torch_conformer.py create mode 100644 users/jxu/experiments/ctc/swb/configs/baseline/config_01b_ctc_conformer.py create mode 100644 users/jxu/experiments/ctc/swb/data/__init__.py create mode 100644 users/jxu/experiments/ctc/swb/data/ctc_data.py create mode 100644 users/jxu/experiments/ctc/swb/data/data.py create mode 100644 users/jxu/experiments/ctc/swb/data/lm_data.py create mode 100644 users/jxu/experiments/ctc/swb/pytorch_networks/baseline/conformer_ctc_d_model_386_num_layers_12_logmel.py create mode 100644 users/jxu/experiments/ctc/swb/pytorch_networks/train_steps/baseline_ctc.py create mode 100644 users/jxu/experiments/ctc/swb/pytorch_networks/util.py delete mode 100644 users/jxu/experiments/hybrid/switchboard/pytorch_networks/._i6_conformer_downsample_3.py diff --git a/users/jxu/experiments/ctc/lbs_960/configs/baseline_config.py b/users/jxu/experiments/ctc/lbs_960/configs/baseline_config.py index 9b684a96b..8d9f991a5 100644 --- a/users/jxu/experiments/ctc/lbs_960/configs/baseline_config.py +++ b/users/jxu/experiments/ctc/lbs_960/configs/baseline_config.py @@ -33,7 +33,7 @@ # tools.rasr_binary_path = tk.Path("/u/berger/repositories/rasr_versions/onnx/arch/linux-x86_64-standard") # tools.returnn_root = tk.Path("/u/berger/repositories/MiniReturnn") SCTK_BINARY_PATH = compile_sctk() # use last published version -SCTK_BINARY_PATH.hash_overwrite = "LBS_DEFAULT_SCTK_BINARY_PATH" +SCTK_BINARY_PATH.hash_overwrite = "SWB_DEFAULT_SCTK_BINARY_PATH" # ********** Return Config generators ********** diff --git a/users/jxu/experiments/ctc/swb/__init__.py b/users/jxu/experiments/ctc/swb/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/users/jxu/experiments/ctc/swb/configs/__init__.py b/users/jxu/experiments/ctc/swb/configs/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/users/jxu/experiments/ctc/swb/configs/baseline/__init__.py b/users/jxu/experiments/ctc/swb/configs/baseline/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/users/jxu/experiments/ctc/swb/configs/baseline/config_01_ctc_torch_conformer.py b/users/jxu/experiments/ctc/swb/configs/baseline/config_01_ctc_torch_conformer.py new file mode 100644 index 000000000..fdbe2c492 --- /dev/null +++ b/users/jxu/experiments/ctc/swb/configs/baseline/config_01_ctc_torch_conformer.py @@ -0,0 +1,168 @@ +import copy +from typing import Dict, Tuple + +from i6_core.returnn.config import ReturnnConfig +import i6_core.rasr as rasr +from i6_core.returnn import Checkpoint +from i6_core.recognition import Hub5ScoreJob +from i6_experiments.common.tools.sctk import compile_sctk + +from i6_experiments.users.berger.args.experiments import ctc as exp_args +from i6_experiments.users.berger.args.returnn.config import get_returnn_config, Backend +from i6_experiments.users.berger.util import default_tools_v2 +from i6_experiments.users.berger.args.returnn.learning_rates import LearningRateSchedules, Optimizers +from i6_experiments.users.berger.systems.dataclasses import AlignmentData, FeatureType, ReturnnConfigs, ConfigVariant + +from i6_experiments.users.berger.recipe.summary.report import SummaryReport +import i6_experiments.users.jxu.experiments.ctc.swb.pytorch_networks.baseline.conformer_ctc_d_model_386_num_layers_12_logmel as conformer_ctc +from i6_experiments.users.jxu.experiments.ctc.swb.data.ctc_data import get_switchboard_data +from i6_experiments.users.berger.systems.returnn_seq2seq_system import ( + ReturnnSeq2SeqSystem, +) +from sisyphus import gs, tk + + +# ********** Settings ********** +rasr.flow.FlowNetwork.default_flags = {"cache_mode": "task_dependent"} + +num_classes = 88 +num_subepochs = 600 + +tools = copy.deepcopy(default_tools_v2) +tools.rasr_binary_path = tk.Path( + "/u/berger/repositories/rasr_versions/gen_seq2seq_dev/arch/linux-x86_64-standard", + hash_overwrite="/u/berger/repositories/rasr_versions/gen_seq2seq_dev/arch/linux-x86_64-standard" +) +tools.returnn_root = tk.Path("/u/jxu/setups/tedlium2/2023-07-11--ctc-tedlium/tools/20240509_returnn/returnn", + hash_overwrite="/u/berger/repositories/returnn") +SCTK_BINARY_PATH = compile_sctk() # use last published version +SCTK_BINARY_PATH.hash_overwrite = "LBS_DEFAULT_SCTK_BINARY_PATH" + +# ********** Return Config generators ********** + + +def generate_returnn_config(variant: ConfigVariant, train_data_config: dict, dev_data_config: dict, lr: dict, + batch_size: int, network_args:dict) -> ReturnnConfig: + network_args["num_outputs"] = num_classes + model_config = conformer_ctc.get_default_config_v1(**network_args) + + extra_config = { + "train": train_data_config, + "dev": dev_data_config, + } + if variant == ConfigVariant.RECOG: + extra_config["model_outputs"] = {"classes": {"dim": num_classes}} + + return get_returnn_config( + num_epochs=num_subepochs, + num_inputs=1, + num_outputs=num_classes, + target="targets", + extra_python=[conformer_ctc.get_serializer(model_config, variant=variant)], + extern_data_config=True, + backend=Backend.PYTORCH, + grad_noise=0.0, + grad_clip=0.0, + optimizer=Optimizers.AdamW, + schedule=LearningRateSchedules.OCLR, + max_seqs=60, + initial_lr=lr["initial_lr"], + peak_lr=lr["peak_lr"], + final_lr=lr["final_lr"], + batch_size=batch_size, + use_chunking=False, + extra_config=extra_config, + ) + + +def run_exp() -> Tuple[SummaryReport, Checkpoint, Dict[str, AlignmentData]]: + assert tools.returnn_root is not None + assert tools.returnn_python_exe is not None + assert tools.rasr_binary_path is not None + + data = get_switchboard_data( + returnn_root=tools.returnn_root, + feature_type=FeatureType.SAMPLES, + augmented_lexicon=True, + test_keys=["hub5e01"], + ) + + # ********** Step args ********** + + train_args = exp_args.get_ctc_train_step_args( + num_epochs=300, + # gpu_mem_rqmt=11, + ) + + recog_args = exp_args.get_ctc_recog_step_args(num_classes) + align_args = exp_args.get_ctc_align_step_args(num_classes) + recog_args["epochs"] = [160, 300, "best"] + recog_args["feature_type"] = FeatureType.SAMPLES + recog_args["prior_scales"] = [0.3, 0.5] + recog_args["lm_scales"] = [0.5, 0.7, 0.9] + align_args["feature_type"] = FeatureType.SAMPLES + + recog_am_args = copy.deepcopy(exp_args.ctc_recog_am_args) + recog_am_args.update( + { + "tying_type": "global-and-nonword", + "nonword_phones": ["[NOISE]", "[VOCALIZEDNOISE]", "[LAUGHTER]"], + } + ) + # ********** System ********** + + system = ReturnnSeq2SeqSystem(tools) + + system.init_corpora( + dev_keys=data.dev_keys, + test_keys=data.test_keys, + align_keys=data.align_keys, + corpus_data=data.data_inputs, + am_args=recog_am_args, + ) + system.setup_scoring( + scorer_type=Hub5ScoreJob, + # stm_kwargs={"non_speech_tokens": ["[NOISE]", "[LAUGHTER]", "[VOCALIZED-NOISE]"]}, + stm_kwargs={"stm_paths": {key: tk.Path("/u/corpora/speech/hub5e_00/xml/hub5e_00.stm") for key in data.dev_keys}}, + score_kwargs={ + "glm": tk.Path("/u/corpora/speech/hub5e_00/xml/glm"), + # "glm": tk.Path("/u/corpora/speech/hub-5-00/raw/transcriptions/reference/en20000405_hub5.glm"), + }, + ) + + # ********** Returnn Configs ********** + + network_args = {} + lr ={"initial_lr": 7e-6, "peak_lr": 7e-4, "final_lr": 1e-7} + + for ordering in [ + # "laplace:.1000", + "laplace:.384", + # "laplace:.100", + # "laplace:.50", + # "laplace:.25", + # "laplace:.10", + # "random", + ]: + mod_train_data_config = copy.deepcopy(data.train_data_config) + mod_train_data_config["seq_ordering"] = ordering + + train_config = generate_returnn_config( + ConfigVariant.TRAIN, train_data_config=data.train_data_config, dev_data_config=data.cv_data_config, lr=lr, batch_size=18000*160, network_args=network_args + ) + recog_config = generate_returnn_config( + ConfigVariant.RECOG, train_data_config=data.train_data_config, dev_data_config=data.cv_data_config, lr=lr, batch_size=18000*160, network_args=network_args + ) + + returnn_configs = ReturnnConfigs( + train_config=train_config, + recog_configs={"recog": recog_config}, + ) + + system.add_experiment_configs(f"Conformer_CTC_order-{ordering}", returnn_configs) + + system.run_train_step(**train_args) + system.run_dev_recog_step(**recog_args) + # system.run_test_recog_step(**recog_args) + assert system.summary_report + return system.summary_report diff --git a/users/jxu/experiments/ctc/swb/configs/baseline/config_01b_ctc_conformer.py b/users/jxu/experiments/ctc/swb/configs/baseline/config_01b_ctc_conformer.py new file mode 100644 index 000000000..ff2d7734c --- /dev/null +++ b/users/jxu/experiments/ctc/swb/configs/baseline/config_01b_ctc_conformer.py @@ -0,0 +1,263 @@ +import copy +import os +from typing import Dict, Tuple + +import i6_core.rasr as rasr +from i6_core.recognition import Hub5ScoreJob +from i6_core.returnn import Checkpoint +from i6_core.returnn.config import ReturnnConfig +from i6_experiments.users.berger.args.experiments import ctc as exp_args +from i6_experiments.users.berger.args.returnn.config import get_returnn_config +from i6_experiments.users.berger.args.returnn.learning_rates import ( + LearningRateSchedules, +) +import i6_experiments.users.berger.network.models.fullsum_ctc as ctc_model +from i6_experiments.users.berger.recipe.summary.report import SummaryReport +from i6_experiments.users.berger.systems.returnn_seq2seq_system import ( + ReturnnSeq2SeqSystem, +) +from i6_experiments.users.berger.systems.dataclasses import AlignmentData, FeatureType, ReturnnConfigs +from i6_experiments.users.berger.util import default_tools_v2 as tools +from i6_private.users.vieting.helpers.returnn import serialize_dim_tags +from i6_experiments.users.berger.corpus.switchboard.ctc_data import ( + get_switchboard_data, +) +from sisyphus import gs, tk + +# ********** Settings ********** + +rasr.flow.FlowNetwork.default_flags = {"cache_mode": "task_dependent"} + + +num_classes = 88 + + +# ********** Return Config generators ********** + + +def generate_returnn_config( + train: bool, + *, + loss_corpus: tk.Path, + loss_lexicon: tk.Path, + am_args: dict, + train_data_config: dict, + dev_data_config: dict, + num_epochs: int = 300, +) -> ReturnnConfig: + if train: + network_dict, extra_python = ctc_model.make_conformer_fullsum_ctc_model( + num_outputs=num_classes, + specaug_args={ + "max_time_num": 1, + "max_time": 15, + "max_feature_num": 5, + "max_feature": 4, + }, + conformer_args={ + "num_blocks": 12, + "size": 512, + "dropout": 0.1, + "l2": 1e-04, + }, + output_args={ + "rasr_binary_path": tools.rasr_binary_path, + "loss_corpus_path": loss_corpus, + "loss_lexicon_path": loss_lexicon, + "am_args": am_args, + }, + ) + else: + network_dict, extra_python = ctc_model.make_conformer_ctc_recog_model( + num_outputs=num_classes, + conformer_args={ + "num_blocks": 12, + "size": 512, + }, + ) + + returnn_config = get_returnn_config( + network=network_dict, + target=None, + num_epochs=num_epochs, + num_inputs=40, + python_prolog=[ + "import sys", + "sys.setrecursionlimit(10 ** 6)", + ], + extra_python=extra_python, + extern_data_config=True, + grad_noise=0.0, + grad_clip=0.0, + schedule=LearningRateSchedules.OCLR, + initial_lr=1e-05, + peak_lr=4e-04, + final_lr=1e-05, + cycle_epoch=160 if num_epochs == 400 else 135, + batch_size=10000, + use_chunking=False, + extra_config={ + "train": train_data_config, + "dev": dev_data_config, + }, + ) + returnn_config = serialize_dim_tags(returnn_config) + + return returnn_config + + +def run_exp() -> Tuple[SummaryReport, Checkpoint, Dict[str, AlignmentData]]: + assert tools.returnn_root is not None + assert tools.returnn_python_exe is not None + assert tools.rasr_binary_path is not None + + data = get_switchboard_data( + returnn_root=tools.returnn_root, + returnn_python_exe=tools.returnn_python_exe, + rasr_binary_path=tools.rasr_binary_path, + feature_type=FeatureType.GAMMATONE_8K, + augmented_lexicon=True, + test_keys=["hub5e01"], + ) + + # ********** Step args ********** + + train_args = exp_args.get_ctc_train_step_args( + num_epochs=300, + # gpu_mem_rqmt=11, + ) + + recog_args = exp_args.get_ctc_recog_step_args(num_classes) + align_args = exp_args.get_ctc_align_step_args(num_classes) + recog_args["epochs"] = [160, 300, "best"] + recog_args["feature_type"] = FeatureType.GAMMATONE_8K + recog_args["prior_scales"] = [0.3, 0.5] + recog_args["lm_scales"] = [0.5, 0.7, 0.9] + align_args["feature_type"] = FeatureType.GAMMATONE_8K + + recog_am_args = copy.deepcopy(exp_args.ctc_recog_am_args) + recog_am_args.update( + { + "tying_type": "global-and-nonword", + "nonword_phones": ["[NOISE]", "[VOCALIZEDNOISE]", "[LAUGHTER]"], + } + ) + loss_am_args = copy.deepcopy(exp_args.ctc_loss_am_args) + loss_am_args.update( + { + "state_tying": "lookup", + "state_tying_file": tk.Path("/work/asr4/berger/dependencies/switchboard/state_tying/eow-state-tying"), + "tying_type": "global-and-nonword", + "nonword_phones": ["[NOISE]", "[VOCALIZEDNOISE]", "[LAUGHTER]"], + "phon_history_length": 0, + "phon_future_length": 0, + } + ) + + # ********** System ********** + + system = ReturnnSeq2SeqSystem(tools) + + system.init_corpora( + dev_keys=data.dev_keys, + test_keys=data.test_keys, + align_keys=data.align_keys, + corpus_data=data.data_inputs, + am_args=recog_am_args, + ) + system.setup_scoring( + scorer_type=Hub5ScoreJob, + # stm_kwargs={"non_speech_tokens": ["[NOISE]", "[LAUGHTER]", "[VOCALIZED-NOISE]"]}, + stm_kwargs={"stm_paths": {key: tk.Path("/u/corpora/speech/hub5e_00/xml/hub5e_00.stm") for key in data.dev_keys}}, + score_kwargs={ + "glm": tk.Path("/u/corpora/speech/hub5e_00/xml/glm"), + # "glm": tk.Path("/u/corpora/speech/hub-5-00/raw/transcriptions/reference/en20000405_hub5.glm"), + }, + ) + + # ********** Returnn Configs ********** + + config_generator_kwargs = { + "loss_corpus": data.loss_corpus, + "loss_lexicon": data.loss_lexicon, + "am_args": loss_am_args, + "dev_data_config": data.cv_data_config, + } + + for ordering in [ + # "laplace:.1000", + "laplace:.384", + # "laplace:.100", + # "laplace:.50", + # "laplace:.25", + # "laplace:.10", + # "random", + ]: + mod_train_data_config = copy.deepcopy(data.train_data_config) + mod_train_data_config["seq_ordering"] = ordering + + train_config = generate_returnn_config( + train=True, train_data_config=mod_train_data_config, **config_generator_kwargs + ) + recog_config = generate_returnn_config( + train=False, train_data_config=mod_train_data_config, **config_generator_kwargs + ) + + returnn_configs = ReturnnConfigs( + train_config=train_config, + recog_configs={"recog": recog_config}, + ) + + system.add_experiment_configs(f"Conformer_CTC_order-{ordering}", returnn_configs) + + system.run_train_step(**train_args) + system.run_dev_recog_step(**recog_args) + # system.run_test_recog_step(**recog_args) + alignments = next( + iter(system.run_align_step(exp_names=["Conformer_CTC_order-laplace:.384"], **align_args).values()) + ) + + model = system.get_train_job("Conformer_CTC_order-laplace:.384").out_checkpoints[300] + assert isinstance(model, Checkpoint) + + system.cleanup_experiments() + + mod_train_data_config = copy.deepcopy(data.train_data_config) + mod_train_data_config["seq_ordering"] = "laplace:.384" + train_config = generate_returnn_config( + train=True, + train_data_config=mod_train_data_config, + num_epochs=400, + **config_generator_kwargs, + ) + recog_config = generate_returnn_config( + train=False, train_data_config=mod_train_data_config, **config_generator_kwargs + ) + + returnn_configs = ReturnnConfigs( + train_config=train_config, + recog_configs={"recog": recog_config}, + ) + + system.add_experiment_configs(f"Conformer_CTC_order-laplace:.384_400ep", returnn_configs) + train_args = exp_args.get_ctc_train_step_args( + num_epochs=400, + # gpu_mem_rqmt=11, + ) + system.run_train_step(**train_args) + recog_args["epochs"] = [160, 320, 400, "best"] + system.run_dev_recog_step(**recog_args) + + assert system.summary_report + return system.summary_report, model, alignments + + +def py() -> Tuple[SummaryReport, Checkpoint, Dict[str, AlignmentData]]: + filename_handle = os.path.splitext(os.path.basename(__file__))[0][len("config_") :] + gs.ALIAS_AND_OUTPUT_SUBDIR = f"{filename_handle}/" + + summary_report, model, alignments = run_exp() + + tk.register_report(f"{gs.ALIAS_AND_OUTPUT_SUBDIR}/summary.report", summary_report) + + return summary_report, model, alignments diff --git a/users/jxu/experiments/ctc/swb/data/__init__.py b/users/jxu/experiments/ctc/swb/data/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/users/jxu/experiments/ctc/swb/data/ctc_data.py b/users/jxu/experiments/ctc/swb/data/ctc_data.py new file mode 100644 index 000000000..238abd0f7 --- /dev/null +++ b/users/jxu/experiments/ctc/swb/data/ctc_data.py @@ -0,0 +1,161 @@ +from typing import List, Optional +import copy + +from i6_core import corpus +from i6_core.returnn.hdf import BlissToPcmHDFJob +from i6_core.lexicon.modification import AddEowPhonemesToLexiconJob +from i6_experiments.users.berger.systems.dataclasses import FeatureType +from i6_experiments.users.jxu.experiments.ctc.swb.data import data +from i6_experiments.users.berger.args.returnn.dataset import MetaDatasetBuilder, hdf_config_dict_for_files +from i6_experiments.users.berger.recipe.returnn.hdf import BlissCorpusToTargetHdfJob +from i6_experiments.users.berger.corpus.general.experiment_data import PytorchCTCSetupData + +from sisyphus import tk + + +def get_switchboard_data( + returnn_root: tk.Path, + train_key: str = "train", + cv_keys: Optional[List[str]] = None, + dev_keys: Optional[List[str]] = None, + test_keys: Optional[List[str]] = None, + feature_type: FeatureType = FeatureType.SAMPLES, + dc_detection: bool = False, + add_unknown: bool = False, + augmented_lexicon: bool = False, + **kwargs, +) -> PytorchCTCSetupData: + if cv_keys is None: + cv_keys = ["hub5e00"] + if dev_keys is None: + dev_keys = ["hub5e00"] + if test_keys is None: + test_keys = ["hub5e01", "rt03s"] + + # ********** Data inputs ********** + + train_data_inputs, cv_data_inputs, dev_data_inputs, test_data_inputs = data.get_data_inputs( + train_key=train_key, + cv_keys=cv_keys, + dev_keys=dev_keys, + test_keys=test_keys, + ctc_lexicon=True, + add_all_allophones=True, + augmented_lexicon=augmented_lexicon, + **kwargs, + ) + + # ********** Train data ********** + train_corpus_object = train_data_inputs[train_key].corpus_object + eow_lexicon = AddEowPhonemesToLexiconJob(train_data_inputs[train_key].lexicon.filename, + nonword_phones=["[NOISE]", "[VOCALIZEDNOISE]", "[LAUGHTER]"]).out_lexicon + assert train_corpus_object is not None + + if not add_unknown and not augmented_lexicon: + train_corpus_object.corpus_file = corpus.FilterCorpusRemoveUnknownWordSegmentsJob( + train_corpus_object.corpus_file, + eow_lexicon, + all_unknown=False, + ).out_corpus + + train_dataset_builder = MetaDatasetBuilder() + + if feature_type is not FeatureType.SAMPLES: + raise NotImplementedError("Currently only support feature types sample") + + bliss_to_pcm_hdf_job = BlissToPcmHDFJob( + train_corpus_object.corpus_file, + rounding=BlissToPcmHDFJob.RoundingScheme.rasr_compatible, + returnn_root=returnn_root, + ) + bliss_to_pcm_hdf_job.rqmt = {"cpu": 2, "mem": 8, "time": 8} + train_feature_hdf = bliss_to_pcm_hdf_job.out_hdf + + train_dataset_builder.add_dataset( + name="features", + key_mapping={"data": "data"}, + dataset_config=hdf_config_dict_for_files( + [train_feature_hdf], + { + "partition_epoch": 6, + "seq_ordering": "laplace:.1000", + }), + control=True, + ) + + train_targets_hdf = BlissCorpusToTargetHdfJob( + train_corpus_object.corpus_file, + bliss_lexicon=eow_lexicon, + returnn_root=returnn_root, + ).out_hdf + train_dataset_builder.add_dataset( + name="targets", + dataset_config=hdf_config_dict_for_files([train_targets_hdf]), + key_mapping={"data": "targets"}, + control=False, + ) + train_data_config = train_dataset_builder.get_dict() + + # ********** CV data ********** + cv_dataset_builder = MetaDatasetBuilder() + cv_feature_hdf = [] + + cv_data_inputs = copy.deepcopy(cv_data_inputs) + for key in dev_keys: + if not add_unknown: + for corpus_object in [cv_data_inputs[key].corpus_object for key in dev_keys]: + assert corpus_object.corpus_file is not None + corpus_object.corpus_file = corpus.FilterCorpusRemoveUnknownWordSegmentsJob( + corpus_object.corpus_file, + eow_lexicon, + all_unknown=False, + ).out_corpus + + bliss_to_pcm_hdf_job = BlissToPcmHDFJob( + cv_data_inputs[key].corpus_object.corpus_file, + rounding=BlissToPcmHDFJob.RoundingScheme.rasr_compatible, + returnn_root=returnn_root, + ) + cv_feature_hdf.append(bliss_to_pcm_hdf_job.out_hdf) + + cv_dataset_builder.add_dataset( + name="features", + key_mapping={"data": "data"}, + dataset_config=hdf_config_dict_for_files( + cv_feature_hdf, + { + "partition_epoch": 1, + "seq_ordering": "laplace:.1000", + }), + control=True, + ) + + cv_targets_hdf = [] + for key in dev_keys: + cv_targets_hdf.append(BlissCorpusToTargetHdfJob( + cv_data_inputs[key].corpus_object.corpus_file, + bliss_lexicon=eow_lexicon, + returnn_root=returnn_root, + ).out_hdf) + + cv_dataset_builder.add_dataset( + name="targets", + dataset_config=hdf_config_dict_for_files(cv_targets_hdf), + key_mapping={"data": "targets"}, + control=False, + ) + cv_data_config = cv_dataset_builder.get_dict() + + return PytorchCTCSetupData( + train_key=train_key, + dev_keys=list(dev_data_inputs.keys()), + test_keys=list(test_data_inputs.keys()), + align_keys=["train", "hub5e00_zoltan_4gram", "hub5e01_zoltan_4gram"], + train_data_config=train_data_config, + cv_data_config=cv_data_config, + data_inputs={ + **train_data_inputs, + **dev_data_inputs, + **test_data_inputs, + }, + ) diff --git a/users/jxu/experiments/ctc/swb/data/data.py b/users/jxu/experiments/ctc/swb/data/data.py new file mode 100644 index 000000000..d02af37ca --- /dev/null +++ b/users/jxu/experiments/ctc/swb/data/data.py @@ -0,0 +1,160 @@ +from sisyphus import tk +import copy +from typing import Dict, List, Tuple, Optional +from i6_core.corpus import FilterCorpusBySegmentsJob, FilterSegmentsByListJob, SegmentCorpusJob +import i6_experiments.common.datasets.switchboard as swb_dataset +from i6_experiments.common.datasets.switchboard.constants import concurrent +from i6_experiments.common.setups.rasr import util as rasr_util + +from i6_experiments.users.berger.recipe.corpus.transform import TransformTranscriptionsJob, TranscriptionTransform +from i6_experiments.users.berger.corpus.general.helpers import filter_unk_in_corpus_object +from i6_experiments.users.berger.helpers.rasr import convert_legacy_corpus_object_dict_to_scorable +from .lm_data import get_lm +from i6_experiments.users.berger import helpers +from i6_experiments.users.berger.recipe.lexicon.modification import ( + EnsureSilenceFirstJob, + DeleteEmptyOrthJob, + MakeBlankLexiconJob, +) + + +def get_data_inputs( + train_key: str = "train", + cv_keys: Optional[List[str]] = None, + dev_keys: Optional[List[str]] = None, + test_keys: Optional[List[str]] = None, + lm_names: Optional[List[str]] = None, + ctc_lexicon: bool = False, + augmented_lexicon: bool = False, + add_all_allophones: bool = False, +) -> Tuple[Dict[str, helpers.RasrDataInput], ...]: + if cv_keys is None: + cv_keys = ["hub5e00"] + if dev_keys is None: + dev_keys = ["hub5e00"] + if test_keys is None: + test_keys = ["hub5e01"] + if lm_names is None: + lm_names = ["zoltan_4gram"] + + corpus_object_dict = { + "train": swb_dataset.get_train_corpus_object_i6_legacy(), + "hub5e00": swb_dataset.get_hub5e00_corpus_object(), + "hub5e01": swb_dataset.get_hub5e01_corpus_object(), + "rt03s": swb_dataset.get_rt03s_corpus_object(), + } + + corpus_object_dict = convert_legacy_corpus_object_dict_to_scorable(corpus_object_dict) + corpus_object_dict["hub5e00"].stm = tk.Path("/u/corpora/speech/hub5e_00/xml/hub5e_00.stm") + corpus_object_dict["hub5e00"].glm = tk.Path("/u/corpora/speech/hub5e_00/xml/glm") + # corpus_object_dict["hub5e00"].stm = swb_dataset.get_hub5e00().stm + # corpus_object_dict["hub5e00"].glm = swb_dataset.get_hub5e00().glm + corpus_object_dict["hub5e01"].stm = swb_dataset.get_hub5e01().stm + corpus_object_dict["hub5e01"].glm = tk.Path("/u/corpora/speech/hub5e_00/xml/glm") + # corpus_object_dict["hub5e01"].glm = swb_dataset.get_hub5e01().glm + + lms = {lm_name: get_lm(lm_name) for lm_name in lm_names} + + if augmented_lexicon: + bliss_lexicon = tk.Path("/work/asr4/berger/dependencies/switchboard/lexicon/wei_train_ctc.lexicon.orig.xml") + else: + bliss_lexicon = swb_dataset.get_bliss_lexicon() + bliss_lexicon = EnsureSilenceFirstJob(bliss_lexicon).out_lexicon + + if ctc_lexicon: + bliss_lexicon = DeleteEmptyOrthJob(bliss_lexicon).out_lexicon + bliss_lexicon = MakeBlankLexiconJob(bliss_lexicon).out_lexicon + + lexicon_config = helpers.LexiconConfig( + filename=bliss_lexicon, + normalize_pronunciation=False, + add_all_allophones=add_all_allophones, + add_allophones_from_lexicon=not add_all_allophones, + ) + + train_data_inputs = {} + cv_data_inputs = {} + dev_data_inputs = {} + test_data_inputs = {} + + train_corpus_object = copy.deepcopy(corpus_object_dict[train_key]) + # if filter_unk_from_corpus: + # filter_unk_in_corpus_object(train_corpus_object, bliss_lexicon) + + segment_files = SegmentCorpusJob(train_corpus_object.corpus_file, 1).out_single_segment_files + filtered_segment_files = FilterSegmentsByListJob( + segment_files, + filter_list=[ + "switchboard-1/sw04118A/sw4118A-ms98-a-0045", + "switchboard-1/sw02663A/sw2663A-ms98-a-0022", + "switchboard-1/sw02986A/sw2986A-ms98-a-0013", + ], + ).out_single_segment_files + train_corpus_object.corpus_file = FilterCorpusBySegmentsJob( + train_corpus_object.corpus_file, segment_file=filtered_segment_files[1] + ).out_corpus + + train_data_inputs[train_key] = helpers.RasrDataInput( + corpus_object=train_corpus_object, + concurrent=concurrent[train_key], + lexicon=lexicon_config, + ) + + for cv_key in cv_keys: + cv_corpus_object = copy.deepcopy(corpus_object_dict[cv_key]) + filter_unk_in_corpus_object(cv_corpus_object, bliss_lexicon) + + segment_files = SegmentCorpusJob(cv_corpus_object.corpus_file, 1).out_single_segment_files + filtered_segment_files = FilterSegmentsByListJob( + segment_files, + filter_list=[ + "hub5e_00/en_6189a/36", + "hub5e_00/en_4852b/77", + "hub5e_00/en_6189b/66", + ], + ).out_single_segment_files + cv_corpus_object.corpus_file = FilterCorpusBySegmentsJob( + cv_corpus_object.corpus_file, segment_file=filtered_segment_files[1] + ).out_corpus + + cv_corpus_object.corpus_file = TransformTranscriptionsJob( + cv_corpus_object.corpus_file, TranscriptionTransform.ALL_LOWERCASE + ).out_corpus_file + cv_data_inputs[cv_key] = helpers.RasrDataInput( + corpus_object=cv_corpus_object, + concurrent=concurrent[cv_key], + lexicon=lexicon_config, + ) + + for dev_key in dev_keys: + for lm_name, lm in lms.items(): + dev_data_inputs[f"{dev_key}_{lm_name}"] = helpers.RasrDataInput( + corpus_object=corpus_object_dict[dev_key], + concurrent=concurrent[dev_key], + lexicon=lexicon_config, + lm=lm, + ) + + for test_key in test_keys: + for lm_name, lm in lms.items(): + test_data_inputs[f"{test_key}_{lm_name}"] = helpers.RasrDataInput( + corpus_object=corpus_object_dict[test_key], + concurrent=concurrent[test_key], + lexicon=lexicon_config, + lm=lm, + ) + + return train_data_inputs, cv_data_inputs, dev_data_inputs, test_data_inputs + + +def get_final_gmm_output(): + output_args = rasr_util.OutputArgs("final") + + output_args.define_corpus_type("train", "train") + output_args.define_corpus_type("hub5e00", "dev") + for tc in ("hub5e01", "rt03s"): + output_args.define_corpus_type(tc, "test") + + output_args.add_feature_to_extract("gt") + + return output_args diff --git a/users/jxu/experiments/ctc/swb/data/lm_data.py b/users/jxu/experiments/ctc/swb/data/lm_data.py new file mode 100644 index 000000000..cd566bd73 --- /dev/null +++ b/users/jxu/experiments/ctc/swb/data/lm_data.py @@ -0,0 +1,13 @@ +from sisyphus import tk + +from i6_experiments.users.berger.helpers import rasr_lm_config + + +def get_lm(name: str) -> rasr_lm_config.LMData: + if name == "zoltan_4gram": + return rasr_lm_config.ArpaLMData(10, tk.Path("/work/asr4/berger/dependencies/switchboard/lm/zoltan_4gram.gz")) + elif name == "fisher_4gram": + return rasr_lm_config.ArpaLMData( + 10, tk.Path("/home/tuske/work/ASR/switchboard/corpus/lm/data/mylm/swb.fsh.4gr.voc30k.LM.gz") + ) + raise ValueError diff --git a/users/jxu/experiments/ctc/swb/pytorch_networks/baseline/conformer_ctc_d_model_386_num_layers_12_logmel.py b/users/jxu/experiments/ctc/swb/pytorch_networks/baseline/conformer_ctc_d_model_386_num_layers_12_logmel.py new file mode 100644 index 000000000..4f5f2f321 --- /dev/null +++ b/users/jxu/experiments/ctc/swb/pytorch_networks/baseline/conformer_ctc_d_model_386_num_layers_12_logmel.py @@ -0,0 +1,262 @@ +from dataclasses import dataclass +from enum import Enum, auto +from i6_core.returnn.config import CodeWrapper +from i6_experiments.users.berger.systems.dataclasses import ConfigVariant + +import torch +from i6_experiments.common.setups.returnn_pytorch.serialization import Collection +from i6_experiments.common.setups.serialization import Import, PartialImport +from i6_experiments.users.berger.pytorch.serializers.basic import ( + get_basic_pt_network_serializer, +) +from i6_models.parts.frontend.vgg_act import VGG4LayerActFrontendV1, VGG4LayerActFrontendV1Config + +from i6_models.primitives.feature_extraction import LogMelFeatureExtractionV1, LogMelFeatureExtractionV1Config +from i6_models.parts.frontend.generic_frontend import ( + GenericFrontendV1, + GenericFrontendV1Config, + FrontendLayerType, +) +import i6_models.parts.conformer as conformer_parts_i6 +import i6_models.assemblies.conformer as conformer_i6 +import i6_experiments.users.berger.pytorch.custom_parts as custom_parts +from i6_models.config import ModelConfiguration, ModuleFactoryV1 +from i6_models.parts.conformer.norm import LayerNormNC +from ..util import lengths_to_padding_mask +from i6_models.primitives.specaugment import specaugment_v1_by_length +from i6_models.assemblies.conformer import ( + ConformerEncoderV1Config, +) + +@dataclass +class SpecaugmentByLengthConfigV1(ModelConfiguration): + time_min_num_masks: int + time_max_mask_per_n_frames: int + time_mask_max_size: int + freq_min_num_masks: int + freq_max_num_masks: int + freq_mask_max_size: int + + +@dataclass +class ConformerCTCConfig(ModelConfiguration): + feature_extraction: ModuleFactoryV1 + specaugment_cfg: SpecaugmentByLengthConfigV1 + conformer: ModuleFactoryV1 + dim: int + target_size: int + dropout: float + + +class ConformerCTCModel(torch.nn.Module): + def __init__(self, cfg: ConformerCTCConfig, **_): + super().__init__() + self.feature_extraction = cfg.feature_extraction() + self.specaugment_cfg = cfg.specaugment_cfg + self.conformer = cfg.conformer() + self.dropout = torch.nn.Dropout(cfg.dropout) + self.final_linear = torch.nn.Linear(cfg.dim, cfg.target_size) + + def forward(self, audio_features: torch.Tensor, audio_features_len: torch.Tensor): + with torch.no_grad(): + audio_features = audio_features.squeeze(-1) + x, input_len = self.feature_extraction(audio_features, audio_features_len) + sequence_mask = lengths_to_padding_mask(input_len) + x = specaugment_v1_by_length(x, + time_min_num_masks=self.specaugment_cfg.time_min_num_masks, + time_max_mask_per_n_frames=self.specaugment_cfg.time_max_mask_per_n_frames, + time_mask_max_size=self.specaugment_cfg.time_mask_max_size, + freq_min_num_masks=self.specaugment_cfg.freq_min_num_masks, + freq_max_num_masks=self.specaugment_cfg.freq_max_num_masks, + freq_mask_max_size=self.specaugment_cfg.freq_mask_max_size) # [B, T, F] + + x, sequence_mask = self.conformer(x, sequence_mask) # [B, T, F] + x = self.dropout(x) + logits = self.final_linear(x) # [B, T, F] + log_probs = torch.log_softmax(logits, dim=2) + + return log_probs, torch.sum(sequence_mask, dim=1).type(torch.int32) + + +def get_train_serializer( + model_config: ConformerCTCConfig, + **_, +) -> Collection: + return get_basic_pt_network_serializer( + module_import_path=f"{__name__}.{ConformerCTCModel.__name__}", + model_config=model_config, + additional_serializer_objects=[ + Import("i6_experiments.users.jxu.experiments.ctc.swb.pytorch_networks.train_steps.baseline_ctc.train_step"), + ], + ) + + +def get_prior_serializer( + model_config: ConformerCTCConfig, + **_, +) -> Collection: + pytorch_package = __package__.rpartition(".")[0] + return get_basic_pt_network_serializer( + module_import_path=f"{__name__}.{ConformerCTCModel.__name__}", + model_config=model_config, + additional_serializer_objects=[ + Import(f"{pytorch_package}.forward.basic.forward_step"), + Import(f"{pytorch_package}.forward.prior_callback.ComputePriorCallback", import_as="forward_callback"), + ], + ) + + +class RecogType(Enum): + RASR = auto() + FLASHLIGHT = auto() + + +def get_rasr_recog_serializer( + model_config: ConformerCTCConfig, + **_, +) -> Collection: + pytorch_package = __package__.rpartition(".")[0] + return get_basic_pt_network_serializer( + module_import_path=f"{__name__}.{ConformerCTCModel.__name__}", + model_config=model_config, + additional_serializer_objects=[Import(f"{pytorch_package}.forward.basic.forward_step")], + ) + + +def get_recog_serializer( + model_config: ConformerCTCConfig, +) -> Collection: + pytorch_package = __package__.rpartition(".")[0] + return get_basic_pt_network_serializer( + module_import_path=f"{__name__}.{ConformerCTCModel.__name__}", + model_config=model_config, + additional_serializer_objects=[ + Import(f"{__name__}.export"), + ], + ) + + +def get_serializer(model_config: ConformerCTCConfig, variant: ConfigVariant, **kwargs) -> Collection: + if variant == ConfigVariant.TRAIN: + return get_train_serializer(model_config, **kwargs) + if variant == ConfigVariant.PRIOR: + return get_prior_serializer(model_config, **kwargs) + if variant == ConfigVariant.ALIGN: + return get_recog_serializer(model_config, **kwargs) + if variant == ConfigVariant.RECOG: + return get_recog_serializer(model_config, **kwargs) + raise NotImplementedError + + +def get_default_config_v1(num_outputs: int) -> ConformerCTCConfig: + feature_extraction = ModuleFactoryV1( + module_class=LogMelFeatureExtractionV1, + cfg=LogMelFeatureExtractionV1Config( + sample_rate=16000, + win_size=0.025, + hop_size=0.01, + f_min=60, + f_max=7600, + min_amp=1e-10, + num_filters=80, + center=False, + n_fft=400, + ), + ) + + specaug_cfg = SpecaugmentByLengthConfigV1( + time_min_num_masks=2, + time_max_mask_per_n_frames=25, + time_mask_max_size=20, + freq_min_num_masks=2, + freq_max_num_masks=16, + freq_mask_max_size=5, + ) + + # frontend = ModuleFactoryV1( + # GenericFrontendV1, + # GenericFrontendV1Config( + # in_features=80, + # layer_ordering=[ + # FrontendLayerType.Conv2d, + # FrontendLayerType.Conv2d, + # FrontendLayerType.Pool2d, + # FrontendLayerType.Conv2d, + # FrontendLayerType.Conv2d, + # FrontendLayerType.Pool2d, + # FrontendLayerType.Activation, + # ], + # conv_kernel_sizes=[(3, 3), (3, 3), (3, 3), (3, 3)], + # conv_paddings=None, + # conv_out_dims=[32, 64, 64, 32], + # conv_strides=[(1, 1), (1, 1), (1, 1), (1, 1)], + # pool_kernel_sizes=[(2, 1), (2, 1)], + # pool_strides=None, + # pool_paddings=None, + # activations=[torch.nn.ReLU()], + # out_features=384, + # ), + # ) + + frontend_cfg = VGG4LayerActFrontendV1Config( + in_features=80, + conv1_channels=32, + conv2_channels=64, + conv3_channels=64, + conv4_channels=32, + conv_kernel_size=(3, 3), + conv_padding=None, + pool1_kernel_size=(2, 1), + pool1_stride=(2, 1), + pool1_padding=None, + pool2_kernel_size=(2, 1), + pool2_stride=(2, 1), + pool2_padding=None, + activation=torch.nn.ReLU(), + out_features=384, + ) + + frontend = ModuleFactoryV1(VGG4LayerActFrontendV1, frontend_cfg) + + ff_cfg = conformer_parts_i6.ConformerPositionwiseFeedForwardV1Config( + input_dim=384, + hidden_dim=1536, + dropout=0.2, + activation=torch.nn.SiLU(), + ) + + mhsa_cfg = conformer_parts_i6.ConformerMHSAV1Config( + input_dim=384, + num_att_heads=6, + att_weights_dropout=0.1, + dropout=0.1, + ) + + conv_cfg = conformer_parts_i6.ConformerConvolutionV1Config( + channels=384, + kernel_size=31, + dropout=0.2, + activation=torch.nn.SiLU(), + norm=LayerNormNC(384), + ) + + block_cfg = conformer_i6.ConformerBlockV1Config( + ff_cfg=ff_cfg, + mhsa_cfg=mhsa_cfg, + conv_cfg=conv_cfg, + ) + + conformer_cfg = conformer_i6.ConformerEncoderV1Config( + num_layers=12, + frontend=frontend, + block_cfg=block_cfg, + ) + + return ConformerCTCConfig( + feature_extraction=feature_extraction, + specaugment_cfg=specaug_cfg, + conformer=ModuleFactoryV1(conformer_i6.ConformerEncoderV1, cfg=conformer_cfg), + dim=384, + target_size=num_outputs, + dropout=0.1, + ) \ No newline at end of file diff --git a/users/jxu/experiments/ctc/swb/pytorch_networks/train_steps/baseline_ctc.py b/users/jxu/experiments/ctc/swb/pytorch_networks/train_steps/baseline_ctc.py new file mode 100644 index 000000000..bfd3a8b24 --- /dev/null +++ b/users/jxu/experiments/ctc/swb/pytorch_networks/train_steps/baseline_ctc.py @@ -0,0 +1,55 @@ +import torch +from returnn.tensor.tensor_dict import TensorDict + + +def map_tensor_to_minus1_plus1_interval(tensor: torch.Tensor) -> torch.Tensor: + if torch.is_floating_point(tensor): + return tensor + + dtype = tensor.dtype + info = torch.iinfo(dtype) + min_val = info.min + max_val = info.max + + return 2.0 * (tensor.float() - min_val) / (max_val - min_val) - 1.0 + +def train_step(*, model: torch.nn.Module, extern_data: TensorDict, **kwargs): + audio_features = extern_data["data"].raw_tensor + audio_features = audio_features.squeeze(-1) + audio_features = map_tensor_to_minus1_plus1_interval(audio_features) + assert extern_data["data"].dims[1].dyn_size_ext is not None + + audio_features_len = extern_data["data"].dims[1].dyn_size_ext.raw_tensor + assert audio_features_len is not None + + assert extern_data["targets"].raw_tensor is not None + targets = extern_data["targets"].raw_tensor.long() + + targets_len_rf = extern_data["targets"].dims[1].dyn_size_ext + assert targets_len_rf is not None + targets_len = targets_len_rf.raw_tensor + assert targets_len is not None + + log_probs, sequence_lengths = model( + audio_features=audio_features, + audio_features_len=audio_features_len.to("cuda"), + ) + + log_probs = torch.transpose(log_probs, 0, 1) # [T, B, F] + + loss = torch.nn.functional.ctc_loss( + log_probs=log_probs, + targets=targets, + input_lengths=sequence_lengths, + target_lengths=targets_len, + blank=0, + reduction="sum", + zero_infinity=True, + ) + + from returnn.tensor import batch_dim + import returnn.frontend as rf + + rf.get_run_ctx().mark_as_loss( + name="CTC", loss=loss, custom_inv_norm_factor=rf.reduce_sum(targets_len_rf, axis=batch_dim) + ) \ No newline at end of file diff --git a/users/jxu/experiments/ctc/swb/pytorch_networks/util.py b/users/jxu/experiments/ctc/swb/pytorch_networks/util.py new file mode 100644 index 000000000..082865328 --- /dev/null +++ b/users/jxu/experiments/ctc/swb/pytorch_networks/util.py @@ -0,0 +1,14 @@ +import torch + +def lengths_to_padding_mask(lengths: torch.Tensor) -> torch.Tensor: + """ + Convert lengths to an equivalent boolean mask + + :param lengths: [B] + :return: B x T, where 1 means within sequence and 0 means outside sequence + """ + max_length = torch.max(lengths) + index_range = torch.arange(max_length, device=lengths.device, dtype=lengths.dtype) + sequence_mask = torch.less(index_range[None, :], lengths[:, None]) + + return sequence_mask \ No newline at end of file diff --git a/users/jxu/experiments/hybrid/switchboard/pytorch_networks/._i6_conformer_downsample_3.py b/users/jxu/experiments/hybrid/switchboard/pytorch_networks/._i6_conformer_downsample_3.py deleted file mode 100644 index 9347483ceb674f5fed371bbe88004c2d3b429271..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 4096 zcmZQz6=P>$Vqox1Ojhs@R)|o50+1L3ClDJkFz{^v(m+1nBL)UWIUt(=a103vVqnmB zgy>+H0aVV7riBs6hl-0P=jZAr78K;9>J=2_m!;+<<|U^x02QqGA$-d2Xr2|C)=} Date: Wed, 15 May 2024 14:58:23 +0000 Subject: [PATCH 002/227] add conformer enc with more weight dropout --- .../asr/encoder/conformer_encoder_v2.py | 1391 +++++++++++++++++ 1 file changed, 1391 insertions(+) create mode 100644 users/zeineldeen/models/asr/encoder/conformer_encoder_v2.py diff --git a/users/zeineldeen/models/asr/encoder/conformer_encoder_v2.py b/users/zeineldeen/models/asr/encoder/conformer_encoder_v2.py new file mode 100644 index 000000000..4633e7665 --- /dev/null +++ b/users/zeineldeen/models/asr/encoder/conformer_encoder_v2.py @@ -0,0 +1,1391 @@ +""" +Conformer encoder + +Other implementations: + +https://github.com/facebookresearch/fairseq/blob/main/fairseq/models/speech_to_text/modules/emformer.py +https://pytorch.org/audio/main/_modules/torchaudio/models/emformer.html#Emformer +""" + +from __future__ import annotations +from typing import Optional, Union, List, Tuple +from dataclasses import dataclass +from returnn.tensor import Dim +from returnn.tf.util.data import SpatialDim, FeatureDim +from i6_experiments.users.zeineldeen.modules.network import ReturnnNetwork + +from i6_core.returnn.config import CodeWrapper + + +class ConformerEncoder: + """ + Represents Conformer Encoder Architecture + + * Conformer: Convolution-augmented Transformer for Speech Recognition + * Ref: https://arxiv.org/abs/2005.08100 + """ + + def __init__( + self, + input="data", + input_layer="lstm-6", + input_layer_conv_act="relu", + add_abs_pos_enc_to_input=False, + frontend_conv_l2=0.0, + num_blocks=16, + conv_kernel_size=32, + specaug=True, + pos_enc="rel", + activation="swish", + block_final_norm=True, + ff_dim=512, + ff_bias=True, + ctc_loss_scale=None, + dropout=0.1, + att_dropout=0.1, + enc_key_dim=256, + att_num_heads=4, + target="bpe", + l2=0.0, + lstm_dropout=0.1, + rec_weight_dropout=0.0, + with_ctc=False, + native_ctc=False, + ctc_dropout=0.0, + ctc_l2=0.0, + ctc_opts=None, + ctc_self_align_delay: Optional[int] = None, + ctc_self_align_scale: float = 0.5, + subsample=None, + start_conv_init=None, + conv_module_init=None, + mhsa_init=None, + mhsa_out_init=None, + ff_init=None, + rel_pos_clipping=16, + dropout_in=0.1, + batch_norm_opts=None, + use_ln=False, + pooling_str=None, + self_att_l2=0.0, + sandwich_conv=False, + add_to_prefix_name=None, + output_layer_name="encoder", + create_only_blocks=False, + no_mhsa_module=False, + proj_input=False, + use_sqrd_relu=False, + use_causal_layers=False, + use_causal_conv=None, + conv_alternative_name: Optional[str] = None, + fix_merge_dims=False, + weight_noise=None, + weight_noise_layers=None, + convolution_first=False, + ff_weight_dropout=None, + mhsa_weight_dropout=None, + conv_weight_dropout=None, + memory_variant_opts: Optional[ConformerMemoryVariantOpts] = None, + ): + """ + :param str input: input layer name + :param str|None input_layer: type of input layer which does subsampling + :param int num_blocks: number of Conformer blocks + :param int conv_kernel_size: kernel size for conv layers in Convolution module + :param bool|None specaug: If true, then SpecAug is appliedi wi + :param str|None activation: activation used to sandwich modules + :param bool block_final_norm: if True, apply layer norm at the end of each conformer block + :param bool final_norm: if True, apply layer norm to the output of the encoder + :param int|None ff_dim: dimension of the first linear layer in FF module + :param str|None ff_init: FF layers initialization + :param bool|None ff_bias: If true, then bias is used for the FF layers + :param float embed_dropout: dropout applied to the source embedding + :param float dropout: general dropout + :param float att_dropout: dropout applied to attention weights + :param int enc_key_dim: encoder key dimension, also denoted as d_model, or d_key + :param int att_num_heads: the number of attention heads + :param str target: target labels key name + :param float l2: add L2 regularization for trainable weights parameters + :param float lstm_dropout: dropout applied to the input of the LSTMs in case they are used + :param float rec_weight_dropout: dropout applied to the hidden-to-hidden weight matrices of the LSTM in case used + :param bool with_ctc: if true, CTC loss is used + :param bool native_ctc: if true, use returnn native ctc implementation instead of TF implementation + :param float ctc_dropout: dropout applied on input to ctc + :param float ctc_l2: L2 applied to the weight matrix of CTC softmax + :param dict[str] ctc_opts: options for CTC + """ + + self.input = input + self.input_layer = input_layer + self.input_layer_conv_act = input_layer_conv_act + self.add_abs_pos_enc_to_input = add_abs_pos_enc_to_input + self.frontend_conv_l2 = frontend_conv_l2 + + self.num_blocks = num_blocks + self.conv_kernel_size = conv_kernel_size + + self.pos_enc = pos_enc + self.rel_pos_clipping = rel_pos_clipping + + self.ff_bias = ff_bias + + self.specaug = specaug + + self.activation = activation + + self.block_final_norm = block_final_norm + + self.dropout = dropout + self.att_dropout = att_dropout + self.lstm_dropout = lstm_dropout + + self.dropout_in = dropout_in + + # key and value dimensions are the same + self.enc_key_dim = enc_key_dim + self.enc_value_dim = enc_key_dim + self.att_num_heads = att_num_heads + self.enc_key_per_head_dim = enc_key_dim // att_num_heads + self.enc_val_per_head_dim = enc_key_dim // att_num_heads + + self.ff_dim = ff_dim + if self.ff_dim is None: + self.ff_dim = 2 * self.enc_key_dim + + self.target = target + + self.l2 = l2 + self.self_att_l2 = self_att_l2 + self.rec_weight_dropout = rec_weight_dropout + + if batch_norm_opts is None: + batch_norm_opts = {} + + bn_momentum = batch_norm_opts.pop("momentum", 0.1) + bn_eps = batch_norm_opts.pop("epsilon", 1e-3) + bn_update_sample_only_in_train = batch_norm_opts.pop("update_sample_only_in_training", True) + bn_delay_sample_update = batch_norm_opts.pop("delay_sample_update", True) + self.batch_norm_opts = { + "momentum": bn_momentum, + "epsilon": bn_eps, + "update_sample_only_in_training": bn_update_sample_only_in_train, + "delay_sample_update": bn_delay_sample_update, + } + self.batch_norm_opts.update(**batch_norm_opts) + + self.with_ctc = with_ctc + self.native_ctc = native_ctc + self.ctc_dropout = ctc_dropout + self.ctc_loss_scale = ctc_loss_scale + self.ctc_l2 = ctc_l2 + self.ctc_opts = ctc_opts + if not self.ctc_opts: + self.ctc_opts = {} + self.ctc_self_align_delay = ctc_self_align_delay + self.ctc_self_align_scale = ctc_self_align_scale + + self.start_conv_init = start_conv_init + self.conv_module_init = conv_module_init + self.mhsa_init = mhsa_init + self.mhsa_out_init = mhsa_out_init + self.ff_init = ff_init + + self.sandwich_conv = sandwich_conv + + # add maxpooling layers + self.subsample = subsample + self.subsample_list = [1] * num_blocks + if subsample: + for idx, s in enumerate(map(int, subsample.split("_")[:num_blocks])): + self.subsample_list[idx] = s + + self.network = ReturnnNetwork() + + self.use_ln = use_ln + + self.pooling_str = pooling_str + + self.add_to_prefix_name = add_to_prefix_name + self.output_layer_name = output_layer_name + + self.create_only_blocks = create_only_blocks + + self.no_mhsa_module = no_mhsa_module + self.proj_input = proj_input + + self.use_sqrd_relu = use_sqrd_relu + + self.use_causal_layers = use_causal_layers + self.use_causal_conv = use_causal_conv if use_causal_conv is not None else self.use_causal_layers + + self.conv_alternative_name = conv_alternative_name + self.fix_merge_dims = fix_merge_dims + + self.weight_noise = weight_noise + self.weight_noise_layers = weight_noise_layers + if self.weight_noise_layers is None: + self.weight_noise_layers = [] + for layer in self.weight_noise_layers: + assert layer in ["mhsa", "conv", "frontend_conv"] + + self.convolution_first = convolution_first + + self.ff_weight_drop = ff_weight_dropout + self.conv_weight_drop = conv_weight_dropout + self.mhsa_weight_drop = mhsa_weight_dropout + + self.memory_variant_opts = memory_variant_opts + if self.memory_variant_opts: + self.concat_window_dim = SpatialDim("concat-window") # W*N + self.enc_att_num_heads_dim = SpatialDim("enc-att-num-heads", att_num_heads) + self.enc_per_head_dim = FeatureDim("enc-dim-per-head", self.enc_key_per_head_dim) + if self.memory_variant_opts.conv_cache_size: + self.conv_cache_concat_dim = SpatialDim("conv-cache-concat") + if self.memory_variant_opts.use_emformer_mem: + self.emformer_mem_bank_dim = SpatialDim("emformer-mem-bank") # M, the same as C but different tag + self.emformer_ext_query_dim = SpatialDim("emformer-ext-query") # W+1 + self.concat_window_with_mem_dim = SpatialDim("concat-window-with-mem") # W*N+M + + def _create_ff_module(self, prefix_name, i, source, layer_index): + """ + Add Feed Forward Module: + LN -> FFN -> Swish -> Dropout -> FFN -> Dropout + + :param str prefix_name: some prefix name + :param int i: FF module index + :param str source: name of source layer + :param int layer_index: index of layer + :return: last layer name of this module + :rtype: str + """ + prefix_name = prefix_name + "_ffmod_{}".format(i) + + ln = self.network.add_layer_norm_layer("{}_ln".format(prefix_name), source) + + ff1 = self.network.add_linear_layer( + "{}_ff1".format(prefix_name), + ln, + n_out=self.ff_dim, + l2=self.l2, + forward_weights_init=self.ff_init, + with_bias=self.ff_bias, + param_dropout=self.ff_weight_drop, + param_dropout_min_ndim=2, + ) + + if self.use_sqrd_relu: + swish_act = self.network.add_activation_layer("{}_relu".format(prefix_name), ff1, activation="relu") + swish_act = self.network.add_eval_layer( + "{}_square_relu".format(prefix_name), swish_act, eval="source(0) ** 2" + ) + else: + swish_act = self.network.add_activation_layer( + "{}_swish".format(prefix_name), ff1, activation=self.activation + ) + + drop1 = self.network.add_dropout_layer("{}_drop1".format(prefix_name), swish_act, dropout=self.dropout) + + ff2 = self.network.add_linear_layer( + "{}_ff2".format(prefix_name), + drop1, + n_out=self.enc_key_dim, + l2=self.l2, + forward_weights_init=self.ff_init, + with_bias=self.ff_bias, + param_dropout=self.ff_weight_drop, + param_dropout_min_ndim=2, + ) + + drop2 = self.network.add_dropout_layer("{}_drop2".format(prefix_name), ff2, dropout=self.dropout) + + half_step_ff = self.network.add_eval_layer("{}_half_step".format(prefix_name), drop2, eval="0.5 * source(0)") + + res_inputs = [half_step_ff, source] + + ff_module_res = self.network.add_combine_layer( + "{}_res".format(prefix_name), kind="add", source=res_inputs, n_out=self.enc_key_dim + ) + + return ff_module_res + + def _get_mem_chunks(self, prefix_name: str, input_layer: str, mem_size: int) -> List[Tuple[str, Union[str, Dim]]]: + """ + :param name: layer prefix name + :param input_layer: name of input layer to shift of shape [B*C, W, D] + :return: arg for the ConcatLayer, i.e. list of tuple (layer_name, axis) + """ + input_layer_splitted = self.network.add_generic_layer( + f"{prefix_name}_split_chunk", + cls="split_batch_time", + source=input_layer, + base=self.memory_variant_opts.split_batch_time_base, + ) # [B, C, W, D], C = chunked_time_dim + mem_chunks = [] + for mem_idx in range(mem_size): + chunk_shifted = self.network.add_generic_layer( + f"{prefix_name}_chunk_shifted" + (f"_{mem_idx}" if mem_idx > 0 else ""), + cls="shift_axis", + source=input_layer_splitted, + axis=self.memory_variant_opts.chunked_time_dim, # C + amount=mem_idx + 1, + pad=True, + adjust_size_info=False, # no change in dim tag, C stays the same + ) # [B, C, W, D] + # Merge batch and chunk dim again. + chunk_shifted = self.network.add_generic_layer( + f"{prefix_name}_chunk_shifted_" + (f"_{mem_idx}" if mem_idx > 0 else ""), + cls="merge_dims", + source=chunk_shifted, + axes=("B", self.memory_variant_opts.chunked_time_dim), + ) # [B*C, W, D] + # Make sure the time_dim_axis (T) is set to the correct dim (W). + chunk_shifted = self.network.add_generic_layer( + f"{prefix_name}_chunk_shifted__" + (f"_{mem_idx}" if mem_idx > 0 else ""), + cls="reinterpret_data", + source=chunk_shifted, + set_axes={"T": "spatial"}, + ) # [B*C, W, D] but not time_dim_axis is set to W + + if self.memory_variant_opts.mem_slice_start is not None: + assert self.memory_variant_opts.mem_slice_size is not None + chunk_shifted = self.network.add_generic_layer( + f"{prefix_name}_chunk_shifted__" + (f"_{mem_idx}" if mem_idx > 0 else "") + "_sliced", + cls="slice", + source=chunk_shifted, + axis="T", + slice_start=self.memory_variant_opts.mem_slice_start, + slice_end=self.memory_variant_opts.mem_slice_start + self.memory_variant_opts.mem_slice_size, + ) + + mem_chunks.append((chunk_shifted, "T")) + + # reverse to concat left-most first + mem_chunks.reverse() + return mem_chunks + + def _self_att_v2( + self, prefix_name: str, *, input_layer: str, concat_prev_chunks_inputs: str, layer_index: int + ) -> str: + """ + Self-Attention implementation via RETURNN layers instead of using RETURNN SelfAttentionLayer + + :param prefix_name: layer prefix name + :param input_layer: name of input layer + :param concat_prev_chunks_inputs: + """ + + if self.memory_variant_opts.use_cached_prev_kv: + assert concat_prev_chunks_inputs is None, "Should use cached keys and values instead." + + K = self.network.add_generic_layer( + f"{prefix_name}_ln_K", + cls="linear", + source=input_layer if self.memory_variant_opts.use_cached_prev_kv else concat_prev_chunks_inputs, + n_out=self.enc_key_dim, + forward_weights_init=self.mhsa_init, + with_bias=False, + L2=self.self_att_l2, + param_dropout=self.mhsa_weight_drop, + param_dropout_min_ndim=2, + ) # [B*C, W*N, D] or [B*C, W, D] (use_cached_prev_kv) + + V = self.network.add_generic_layer( + f"{prefix_name}_ln_V", + cls="linear", + source=input_layer if self.memory_variant_opts.use_cached_prev_kv else concat_prev_chunks_inputs, + n_out=self.enc_value_dim, + forward_weights_init=self.mhsa_init, + with_bias=False, + L2=self.self_att_l2, + param_dropout=self.mhsa_weight_drop, + param_dropout_min_ndim=2, + ) # [B*C, W*N, D] or [B*C, W, D] (use_cached_prev_kv) + + if self.memory_variant_opts.use_emformer_mem and layer_index > 1: + # Take memory from the previous layer. + # f"{prefix_name}_emformer_mem" has shape [B*C, D] + # I.e. one vector per batch and chunk. + # We effectively convert it to [B,M,D] with M=C but being a separate tag, + # and then expand it to [B*C,M,D]. + # This expansion is maybe not optimal, however, the attention still is only per chunk, + # which would be difficult otherwise. + # C is approx 15-20. + # Then we can concat it to K and V. + # Note on prefix_name: The outer _create_mhsa_module adds the additional "_self_att" prefix. + mem_bank = self._block_prefix_name(layer_index - 1) + "_self_att_emformer_mem" # [B*C, D] + + # Same projection which is usually applied to get back to the residual stream. + mem_bank = self.network.add_generic_layer( + f"{prefix_name}_emformer_mem_proj", + cls="linear", + source=mem_bank, + n_out=self.enc_key_dim, + with_bias=False, + reuse_params=self._block_prefix_name(layer_index - 1) + "_self_att_linear", + param_dropout=self.ff_weight_drop, + param_dropout_min_ndim=2, + ) # [B*C, D] + mem_bank = self.network.add_dropout_layer( + f"{prefix_name}_emformer_mem_proj_drop", mem_bank, dropout=self.dropout + ) + + if self.memory_variant_opts.apply_tanh_on_emformer_mem: + mem_bank = self.network.add_generic_layer( + f"{prefix_name}_emformer_mem_tanh", cls="activation", source=mem_bank, activation="tanh" + ) + else: + mem_bank = self.network.add_generic_layer( + f"{prefix_name}_emformer_mem_clipped", + cls="eval", + source=mem_bank, + eval="tf.clip_by_value(source(0), -10, 10)", + ) + + mem_bank = self.network.add_generic_layer( + f"{prefix_name}_emformer_mem_split_batch_time", + cls="split_batch_time", + source=mem_bank, + base=self.memory_variant_opts.split_batch_time_base, + ) # [B, C, D] + mem_bank = self.network.add_generic_layer( + f"{prefix_name}_emformer_mem_set_new_dim", + cls="reinterpret_data", + source=mem_bank, + set_dim_tags=[(self.memory_variant_opts.chunked_time_dim, self.emformer_mem_bank_dim)], + ) # [B, M, D] + + mem_bank_K = self.network.add_generic_layer( + f"{prefix_name}_emformer_mem_K", + cls="linear", + source=mem_bank, + n_out=self.enc_key_dim, + with_bias=False, + reuse_params=K, + ) # [B, M, D] + mem_bank_V = self.network.add_generic_layer( + f"{prefix_name}_emformer_mem_V", + cls="linear", + source=mem_bank, + n_out=self.enc_value_dim, + with_bias=False, + reuse_params=V, + ) # [B, M, D] + + mem_bank_K = self.network.add_generic_layer( + f"{prefix_name}_emformer_mem_K_expand_chunks", + cls="expand_dims", + source=mem_bank_K, + axis="T", + dim=self.memory_variant_opts.chunked_time_dim, + ) # [B, M, C, D] + mem_bank_K = self.network.add_generic_layer( + f"{prefix_name}_emformer_mem_K_expanded_merged", + cls="merge_dims", + source=mem_bank_K, + axes=("B", self.memory_variant_opts.chunked_time_dim), + ) # [B*C, M, D] + + mem_bank_V = self.network.add_generic_layer( + f"{prefix_name}_emformer_mem_V_expand_chunks", + cls="expand_dims", + source=mem_bank_V, + axis="T", + dim=self.memory_variant_opts.chunked_time_dim, + ) # [B, M, C, D] + mem_bank_V = self.network.add_generic_layer( + f"{prefix_name}_emformer_mem_V_expanded_merged", + cls="merge_dims", + source=mem_bank_V, + axes=("B", self.memory_variant_opts.chunked_time_dim), + ) # [B*C, M, D] + else: + mem_bank_K, mem_bank_V = None, None + + kv_dim = self.concat_window_with_mem_dim if mem_bank_K else self.concat_window_dim # W*N [+M] + + if self.memory_variant_opts.use_cached_prev_kv or mem_bank_K: + # concat previous cached keys and values + concat_keys = self._get_mem_chunks(f"{prefix_name}_ln_K_", K, self.memory_variant_opts.mem_size) + concat_keys.append((K, "T")) + if mem_bank_K: + concat_keys.append((mem_bank_K, self.emformer_mem_bank_dim)) + + K = self.network.add_generic_layer( + f"{prefix_name}_ln_K_concat", + cls="concat", + source=concat_keys, + out_dim=kv_dim, + ) # [B*C, W*N [+M], D] + + K_H = self.network.add_generic_layer( + f"{prefix_name}_ln_K_H", + cls="split_dims", + source=K, + axis="f", + dims=(self.enc_att_num_heads_dim, self.enc_per_head_dim), + ) # [B*C, W*N, H, D/H] + + if self.memory_variant_opts.use_cached_prev_kv or mem_bank_V: + concat_values = self._get_mem_chunks(f"{prefix_name}_ln_V_", V, self.memory_variant_opts.mem_size) + concat_values.append((V, "T")) + if mem_bank_V: + concat_values.append((mem_bank_V, self.emformer_mem_bank_dim)) + + V = self.network.add_generic_layer( + f"{prefix_name}_ln_V_concat", + cls="concat", + source=concat_values, + out_dim=kv_dim, + ) # [B*C, W*N, D] + + V_H = self.network.add_generic_layer( + f"{prefix_name}_ln_V_H", + cls="split_dims", + source=V, + axis="f", + dims=(self.enc_att_num_heads_dim, self.enc_per_head_dim), + ) # [B*C, W*N, H, D/H] + Q = self.network.add_generic_layer( + f"{prefix_name}_ln_Q", + cls="linear", + source=input_layer, + n_out=self.enc_key_dim, + forward_weights_init=self.mhsa_init, + with_bias=False, + L2=self.self_att_l2, + param_dropout=self.mhsa_weight_drop, + param_dropout_min_ndim=2, + ) # second half of shape [B*C, W, D] + query_dim = self.memory_variant_opts.chunk_size_dim # W + + if self.memory_variant_opts.use_emformer_mem: + assert ( + self.memory_variant_opts.mem_slice_start is not None + and self.memory_variant_opts.mem_slice_size is not None + ) + # Q = Wq * [C,R] of shape [B*C, W, D] + + # s_mean = mean(Q[:C]) = mean(Wq * C) <=> Wq * mean(C) + Q_summary_slice = self.network.add_generic_layer( + f"{prefix_name}_ln_Q_summary_slice", + cls="slice", + source=Q, + axis="T", # W + slice_start=self.memory_variant_opts.mem_slice_start, # skip L context if it exists + slice_end=self.memory_variant_opts.mem_slice_size, # this should be always equal to C + ) + Q_summary_mean = self.network.add_generic_layer( + f"{prefix_name}_ln_Q_summary_mean", + cls="reduce", + source=Q_summary_slice, + mode="mean", + axis="T", + keep_dims=True, + ) # [B*C, 1, D] + + Q = self.network.add_generic_layer( + f"{prefix_name}_ln_Q_concat_summary_mean", + cls="concat", + source=[(Q, "T"), (Q_summary_mean, "T")], + out_dim=self.emformer_ext_query_dim, + ) # [B*C, W+1, D] + query_dim = self.emformer_ext_query_dim # W+1 + + Q_H_ = self.network.add_generic_layer( + f"{prefix_name}_ln_Q_H_", + cls="split_dims", + source=Q, + axis="f", + dims=(self.enc_att_num_heads_dim, self.enc_per_head_dim), + ) # [B*C, W [+1], H, D/H] + + # this scaling is actually a bug in self_attention layer. so to be comparable, we do same here. + dim_per_head_const = self.network.add_generic_layer( + f"{prefix_name}_dim_per_head_const", + cls="constant", + value=self.enc_key_per_head_dim, + source=None, + dtype="float32", + ) # [1] + Q_energy_factor = self.network.add_generic_layer( + f"{prefix_name}_Q_energy_factor", cls="eval", source=dim_per_head_const, eval="source(0) ** -0.5" + ) # [1] + Q_H = self.network.add_generic_layer( + f"{prefix_name}_ln_Q_H", + cls="combine", + kind="mul", + source=[Q_H_, Q_energy_factor], + ) # [B*C, W [+1], H, D/H] + + energy = self.network.add_generic_layer( + f"{prefix_name}_ln_energy", + cls="dot", + source=[K_H, Q_H], + reduce=self.enc_per_head_dim, # D/H + var1="auto", + var2="auto", + ) # [B*C, H, W*N [+M], W [+1]] + + if self.memory_variant_opts.use_cached_prev_kv: + # input does not matter for rel pos enc, so we need to make sure the shape is correct + rel_pos_inputs = K # [B*C, W*N [+M], D] + else: + # just to not break hashes... + rel_pos_inputs = concat_prev_chunks_inputs # [B*C, W*N, D] + + ln_rel_pos_enc = self.network.add_generic_layer( + f"{prefix_name}_ln_rel_pos_enc", + cls="relative_positional_encoding", + source=rel_pos_inputs, + out_dim=self.enc_per_head_dim, # D/H + forward_weights_init=self.ff_init, + clipping=self.rel_pos_clipping, + query_spatial_dim=query_dim, # W+1 or W + key_value_spatial_dim=kv_dim, # W*N [+M] + query_offset=self.memory_variant_opts.chunk_size * self.memory_variant_opts.mem_size, + ) # [queries (W [+1]), kvs (W*N [+M]), D/H] + + if self.memory_variant_opts.use_emformer_mem: # -> have summary, i.e. [W+1] + mask_query = "emformer_mask_query_dim" + if mask_query not in self.network: + range_in_query_dim = self.network.add_generic_layer( + "emformer_range_query_dim", cls="range_in_axis", source=Q, axis=self.emformer_ext_query_dim + ) # [W+1] + mask_query = self.network.add_eval_layer( + mask_query, + range_in_query_dim, + eval=f"tf.less(source(0), {self.memory_variant_opts.chunk_size})", + out_type={"dtype": "bool"}, + ) # [W+1] + ln_rel_pos_enc = self.network.add_eval_layer( + f"{prefix_name}_ln_rel_pos_enc_masked_query", + [ln_rel_pos_enc, mask_query], + eval="tf.where(source(1), source(0), 0.)", + ) + + if mem_bank_K: + mask_kv = "emformer_mask_kv_dim" + if mask_kv not in self.network: + range_in_kv_dim = self.network.add_generic_layer( + "emformer_range_kv_dim", cls="range_in_axis", source=K, axis=kv_dim + ) # [W*N + M] + kv_dim_len = self.network.add_generic_layer("kv_dim_len", cls="length", source=K, axis=kv_dim) + mem_len = self.network.add_generic_layer( + "mem_len", cls="length", source=mem_bank_K, axis=self.emformer_mem_bank_dim + ) + mask_kv = self.network.add_eval_layer( + mask_kv, + [range_in_kv_dim, kv_dim_len, mem_len], + eval=f"tf.less(source(0), source(1) - source(2))", + out_type={"dtype": "bool"}, + ) + ln_rel_pos_enc = self.network.add_eval_layer( + f"{prefix_name}_ln_rel_pos_enc_masked_kv", + [ln_rel_pos_enc, mask_kv], + eval="tf.where(source(1), source(0), 0.)", + ) + + energy_rel_pos = self.network.add_generic_layer( + f"{prefix_name}_ln_energy_rel_pos", + cls="dot", + source=[Q_H, ln_rel_pos_enc], + reduce=self.enc_per_head_dim, # D/H + var1="auto", + var2="auto", + ) # [B*C, H, W[+1], W*N [+M]] + + energy = self.network.add_generic_layer( + f"{prefix_name}_ln_energy_", + cls="combine", + source=[energy, energy_rel_pos], + kind="add", + allow_broadcast_all_sources=False, + ) # [B*C, H, W*N [+M], W [+1]] + + if mem_bank_K: + energy = self.network.add_eval_layer( + f"{prefix_name}_ln_energy_emformer_mem_masked", + energy, + eval=_energy_mask_emformer_mem, + eval_locals=dict( + chunked_time_dim=self.memory_variant_opts.chunked_time_dim, # C + chunk_size_dim=self.memory_variant_opts.chunk_size_dim, # W + att_num_heads_dim=self.enc_att_num_heads_dim, # H + query_dim=query_dim, # W+1 + kv_dim=kv_dim, # W*N+M + mem_bank_dim=self.emformer_mem_bank_dim, # M + neg_inf=-1e8, + ), + ) + + weights = self.network.add_generic_layer( + f"{prefix_name}_ln_weights", + cls="softmax_over_spatial", + source=energy, + ) # [B*C, H, W, W*N] + weights_drop = self.network.add_generic_layer( + f"{prefix_name}_ln_weights_drop", + cls="dropout", + source=weights, + dropout=self.att_dropout, + dropout_noise_shape={"*": None}, + ) # [B*C, H, W, W*N] + att0 = self.network.add_generic_layer( + f"{prefix_name}_ln_att0", + cls="dot", + source=[weights_drop, V_H], + reduce=kv_dim, # W*N + var1="auto", + var2="auto", + ) # [B*C, H, W [+1], D/H] + mhsa_ = self.network.add_generic_layer( + f"{prefix_name}_ln_att_", + cls="merge_dims", + source=att0, + axes=(self.enc_att_num_heads_dim, self.enc_per_head_dim), + ) # [B*C, W [+1], D] + mhsa = self.network.add_generic_layer( + f"{prefix_name}_ln_att", + cls="reinterpret_data", + source=mhsa_, + # TODO: is this safe? find a better way + set_axes={ + "T": f"dim:" + + str(self.memory_variant_opts.chunk_size + (1 if self.memory_variant_opts.use_emformer_mem else 0)) + }, + ) # [B*C, W [+1], D] + + if self.memory_variant_opts.use_emformer_mem: + # used later by shift layer to collect a memory bank + self.network.add_generic_layer( + f"{prefix_name}_emformer_mem", + cls="gather", + source=mhsa, + axis="T", + position=self.memory_variant_opts.chunk_size, + ) # [B*C, D] + mhsa = self.network.add_generic_layer( + f"{prefix_name}_ln_att_slice", + cls="slice", + source=mhsa, + axis="T", + slice_start=0, + slice_end=self.memory_variant_opts.chunk_size, + ) # [B*C, W, D] + + return mhsa + + def _create_mhsa_module(self, prefix_name, source, layer_index): + """ + Add Multi-Headed Selft-Attention Module: + LN + MHSA + Dropout + + :param str prefix: some prefix name + :param str source: name of source layer + :param int layer_index: index of layer + :return: last layer name of this module + :rtype: str + """ + prefix_name = "{}_self_att".format(prefix_name) + ln = self.network.add_layer_norm_layer("{}_ln".format(prefix_name), source) + ln_rel_pos_enc = None + + if self.pos_enc == "rel": + ln_rel_pos_enc = self.network.add_relative_pos_encoding_layer( + "{}_ln_rel_pos_enc".format(prefix_name), + ln, + n_out=self.enc_key_per_head_dim, + forward_weights_init=self.ff_init, + clipping=self.rel_pos_clipping, + ) + + if self.memory_variant_opts is not None: + # ln: [B*C, W, D] + + if self.memory_variant_opts.use_cached_prev_kv is False: + # shifted inputs + current chunk + ln_concat_chunks = self._get_mem_chunks( + prefix_name=f"{prefix_name}_ln", input_layer=ln, mem_size=self.memory_variant_opts.mem_size + ) + ln_concat_chunks += [(ln, "T")] + ln_ = self.network.add_generic_layer( + f"{prefix_name}_ln_concat", + cls="concat", + source=ln_concat_chunks, + out_dim=self.concat_window_dim, + ) # [B*C, W*N, D] + else: + ln_ = None + + if self.memory_variant_opts.self_att_version == 0: + assert self.memory_variant_opts.use_cached_prev_kv is False, "Not implemented." + # this implementation is not efficient. + ln_rel_pos_enc = self.network.add_relative_pos_encoding_layer( + f"{prefix_name}_ln_rel_pos_enc", + ln_, + n_out=self.enc_key_per_head_dim, + forward_weights_init=self.ff_init, + clipping=self.rel_pos_clipping, + ) # [B*C, W*N, D/H] + # same param name as before + mhsa_ = self.network.add_self_att_layer( + name=prefix_name, + source=ln_, + n_out=self.enc_value_dim, + num_heads=self.att_num_heads, + total_key_dim=self.enc_key_dim, + att_dropout=self.att_dropout, + forward_weights_init=self.mhsa_init, + key_shift=ln_rel_pos_enc if ln_rel_pos_enc is not None else None, + l2=self.self_att_l2, + attention_left_only=self.use_causal_layers, + param_variational_noise=self.weight_noise if "mhsa" in self.weight_noise_layers else None, + param_dropout=self.mhsa_weight_drop, + param_dropout_min_ndim=2, + ) # [B*C, W*N, D] + mhsa_splits = self.network.add_generic_layer( + f"{prefix_name}_splits", + cls="split", + source=mhsa_, + axis="T", + num_splits=2, + ) # two tensors of shape [B*C, W, D] + mhsa = self.network.add_generic_layer( + f"{prefix_name}_split_2", + cls="copy", + source=mhsa_splits + "/1", # select second half + ) # [B*C, W, D] + else: + # For efficient computation: + # We cannot use SelfAttentionLayer on the concatenated tensor, + # because it would waste compute time for the frames of the last chunk. + # So reimplement the SelfAttentionLayer here explicitly. + # key, value: via concatenated, [B*C, W*N, D] + # + # in case use_cached_prev_kv is enabled: + # - ln_ contains the cached keys and values only + # - project only current chunk + mhsa = self._self_att_v2( + prefix_name, input_layer=ln, concat_prev_chunks_inputs=ln_, layer_index=layer_index + ) + else: + mhsa = self.network.add_self_att_layer( + name=prefix_name, + source=ln, + n_out=self.enc_value_dim, + num_heads=self.att_num_heads, + total_key_dim=self.enc_key_dim, + att_dropout=self.att_dropout, + forward_weights_init=self.mhsa_init, + key_shift=ln_rel_pos_enc if ln_rel_pos_enc is not None else None, + l2=self.self_att_l2, + attention_left_only=self.use_causal_layers, + param_variational_noise=self.weight_noise if "mhsa" in self.weight_noise_layers else None, + param_dropout=self.mhsa_weight_drop, + param_dropout_min_ndim=2, + ) + + mhsa_linear = self.network.add_linear_layer( + "{}_linear".format(prefix_name), + mhsa, + n_out=self.enc_key_dim, + l2=self.l2, + forward_weights_init=self.mhsa_out_init, + with_bias=False, + param_dropout=self.mhsa_weight_drop, + param_dropout_min_ndim=2, + ) + + drop = self.network.add_dropout_layer("{}_dropout".format(prefix_name), mhsa_linear, dropout=self.dropout) + + res_inputs = [drop, source] + + mhsa_res = self.network.add_combine_layer( + "{}_res".format(prefix_name), kind="add", source=res_inputs, n_out=self.enc_value_dim + ) + return mhsa_res + + def _create_convolution_module(self, prefix_name, source, layer_index, half_step=False): + """ + Add Convolution Module: + LN + point-wise-conv + GLU + depth-wise-conv + BN + Swish + point-wise-conv + Dropout + + :param str prefix_name: some prefix name + :param str source: name of source layer + :param int layer_index: index of layer + :return: last layer name of this module + :rtype: str + """ + prefix_name = "{}_conv_mod".format(prefix_name) + + ln = self.network.add_layer_norm_layer("{}_ln".format(prefix_name), source) + + pointwise_conv1 = self.network.add_linear_layer( + "{}_pointwise_conv1".format(prefix_name), + ln, + n_out=2 * self.enc_key_dim, + activation=None, + l2=self.l2, + with_bias=self.ff_bias, + forward_weights_init=self.conv_module_init, + param_dropout=self.conv_weight_drop, + param_dropout_min_ndim=2, + ) + + glu_act = self.network.add_gating_layer("{}_glu".format(prefix_name), pointwise_conv1) + + if self.memory_variant_opts is not None and self.memory_variant_opts.conv_cache_size: + mem_chunks = self._get_mem_chunks( + prefix_name=f"{prefix_name}_glu_act", + input_layer=glu_act, + mem_size=self.memory_variant_opts.conv_cache_size, + ) + glu_act_ = self.network.add_generic_layer( + f"{prefix_name}_glu_act_concat", + cls="concat", + source=[*mem_chunks, (glu_act, "T")], + out_dim=self.conv_cache_concat_dim, + ) # [B*C, W*N, D] + else: + glu_act_ = glu_act + + if self.use_causal_conv: + # pad to the left to make it causal + depthwise_conv_input_padded = self.network.add_pad_layer( + "{}_depthwise_conv_input_padded".format(prefix_name), + glu_act_, + axes="T", + padding=(self.conv_kernel_size - 1, 0), + ) + + depthwise_conv = self.network.add_conv_layer( + prefix_name + "_" + (self.conv_alternative_name or "depthwise_conv2"), + depthwise_conv_input_padded, + n_out=self.enc_key_dim, + filter_size=(self.conv_kernel_size,), + groups=self.enc_key_dim, + l2=self.l2, + forward_weights_init=self.conv_module_init, + padding="valid", + param_dropout=self.conv_weight_drop, + param_dropout_min_ndim=2, + ) + + # Fix time dim, match with the original input + depthwise_conv = self.network.add_reinterpret_data_layer( + "{}_depthwise_conv2_".format(prefix_name), + depthwise_conv, + size_base=glu_act, + ) + else: + depthwise_conv = self.network.add_conv_layer( + prefix_name + "_" + (self.conv_alternative_name or "depthwise_conv2"), + glu_act_, + n_out=self.enc_key_dim, + filter_size=(self.conv_kernel_size,), + groups=self.enc_key_dim, + l2=self.l2, + forward_weights_init=self.conv_module_init, + param_dropout=self.conv_weight_drop, + param_dropout_min_ndim=2, + ) + + if self.memory_variant_opts is not None and self.memory_variant_opts.conv_cache_size: + # we apply convolution over the concatenated chunks but we only need the output of the current + # chunk, thus, we need to slice from [B*C, W*N, D] to [B*C, W, D] + assert self.memory_variant_opts.mem_slice_size, "mem_slice_size must be set." + depthwise_conv = self.network.add_generic_layer( + f"{prefix_name}_depthwise_conv_slice", + cls="slice", + source=depthwise_conv, + axis="T", + slice_start=self.memory_variant_opts.mem_slice_size * self.memory_variant_opts.conv_cache_size, + ) + + if self.use_ln: + bn = self.network.add_layer_norm_layer("{}_layer_norm".format(prefix_name), depthwise_conv) + else: + bn = self.network.add_batch_norm_layer( + "{}_bn".format(prefix_name), depthwise_conv, opts=self.batch_norm_opts + ) + + swish_act = self.network.add_activation_layer("{}_swish".format(prefix_name), bn, activation="swish") + + pointwise_conv2 = self.network.add_linear_layer( + "{}_pointwise_conv2".format(prefix_name), + swish_act, + n_out=self.enc_key_dim, + activation=None, + l2=self.l2, + with_bias=self.ff_bias, + forward_weights_init=self.conv_module_init, + param_dropout=self.conv_weight_drop, + param_dropout_min_ndim=2, + ) + + drop = self.network.add_dropout_layer("{}_drop".format(prefix_name), pointwise_conv2, dropout=self.dropout) + + if half_step: + drop = self.network.add_eval_layer("{}_half_step".format(prefix_name), drop, eval="0.5 * source(0)") + + res_inputs = [drop, source] + + res = self.network.add_combine_layer( + "{}_res".format(prefix_name), kind="add", source=res_inputs, n_out=self.enc_key_dim + ) + return res + + def _block_prefix_name(self, layer_index: int) -> str: + assert layer_index >= 1 + if self.add_to_prefix_name: + prefix_name = "conformer_block_%s_%02i" % (self.add_to_prefix_name, layer_index) + else: + prefix_name = "conformer_block_%02i" % layer_index + return prefix_name + + def _create_conformer_block(self, i, source): + """ + Add the whole Conformer block: + x1 = x0 + 1/2 * FFN(x0) (FFN module 1) + x2 = x1 + MHSA(x1) (MHSA) + x3 = x2 + Conv(x2) (Conv module) + x4 = LayerNorm(x3 + 1/2 * FFN(x3)) (FFN module 2) + + :param int i: layer index + :param str source: name of source layer + :return: last layer name of this module + :rtype: str + """ + prefix_name = self._block_prefix_name(i) + ff_module1 = self._create_ff_module(prefix_name, 1, source, i) + + if self.convolution_first: + conv_module_ = self._create_convolution_module(prefix_name, ff_module1, i) + mhsa_module = self._create_mhsa_module(prefix_name, conv_module_, i) + ff_module2_input = mhsa_module + else: + if self.no_mhsa_module: + mhsa = ff_module1 # use FF1 module output as input to conv module + else: + mhsa_input = ff_module1 + if self.sandwich_conv: + conv_module1 = self._create_convolution_module( + prefix_name + "_sandwich", ff_module1, i, half_step=True + ) + mhsa_input = conv_module1 + mhsa = self._create_mhsa_module(prefix_name, mhsa_input, i) + + conv_module = self._create_convolution_module(prefix_name, mhsa, i, half_step=self.sandwich_conv) + ff_module2_input = conv_module + + ff_module2 = self._create_ff_module(prefix_name, 2, ff_module2_input, i) + res = ff_module2 + if self.block_final_norm: + res = self.network.add_layer_norm_layer("{}_ln".format(prefix_name), res) + if self.subsample: + assert 0 <= i - 1 < len(self.subsample) + subsample_factor = self.subsample_list[i - 1] + if subsample_factor > 1: + res = self.network.add_pool_layer(res + "_pool{}".format(i), res, pool_size=(subsample_factor,)) + res = self.network.add_copy_layer(prefix_name, res) + return res + + def _create_all_network_parts(self): + """ + ConvSubsampling/LSTM -> Linear -> Dropout -> [Conformer Blocks] x N + """ + data = self.input + if self.specaug: + data = self.network.add_eval_layer( + "source", + data, + eval="self.network.get_config().typed_value('transform')(source(0, as_data=True), network=self.network)", + ) + + subsampled_input = None + if self.input_layer is None: + subsampled_input = data + elif self.input_layer.startswith("stack"): + stack_size = int(self.input_layer.split("-")[1]) + stack_window = self.network.add_window_layer( + "stack_window", data, window_size=stack_size, stride=stack_size + ) # [B,C,W,F] + subsampled_input = self.network.add_merge_dims_layer( + "stack_window_merge_dim", + stack_window, + axes=["static:0", "f"], + keep_order=True, + ) # [B,C,W*F] + elif "lstm" in self.input_layer: + sample_factor = int(self.input_layer.split("-")[1]) + pool_sizes = None + if sample_factor == 2: + pool_sizes = [2, 1] + elif sample_factor == 4: + pool_sizes = [2, 2] + elif sample_factor == 6: + pool_sizes = [3, 2] + # add 2 LSTM layers with max pooling to subsample and encode positional information + subsampled_input = self.network.add_lstm_layers( + data, + num_layers=2, + lstm_dim=self.enc_key_dim, + dropout=self.lstm_dropout, + bidirectional=True, + rec_weight_dropout=self.rec_weight_dropout, + l2=self.l2, + pool_sizes=pool_sizes, + ) + elif self.input_layer == "conv-4": + # conv-layer-1: 3x3x32 followed by max pool layer on feature axis (1, 2) + # conv-layer-2: 3x3x64 with striding (2, 1) on time axis + # conv-layer-3: 3x3x64 with striding (2, 1) on time axis + + # TODO: make this more generic + + conv_input = self.network.add_conv_block( + "conv_out", + data, + hwpc_sizes=[((3, 3), (1, 2), 32)], + l2=self.frontend_conv_l2, + activation=self.input_layer_conv_act, + init=self.start_conv_init, + merge_out=False, + param_variational_noise=self.weight_noise if "frontend_conv" in self.weight_noise_layers else None, + ) + + subsampled_input = self.network.add_conv_block( + "conv_merged", + conv_input, + hwpc_sizes=[((3, 3), (2, 1), 64), ((3, 3), (2, 1), 64)], + l2=self.frontend_conv_l2, + activation=self.input_layer_conv_act, + init=self.start_conv_init, + use_striding=True, + split_input=False, + prefix_name="subsample_", + merge_out_fixed=self.fix_merge_dims, + param_variational_noise=self.weight_noise if "frontend_conv" in self.weight_noise_layers else None, + ) + elif self.input_layer == "conv-6": + conv_input = self.network.add_conv_block( + "conv_out", + data, + hwpc_sizes=[((3, 3), (1, 2), 32)], + l2=self.frontend_conv_l2, + activation=self.input_layer_conv_act, + init=self.start_conv_init, + merge_out=False, + param_variational_noise=self.weight_noise if "frontend_conv" in self.weight_noise_layers else None, + ) + + subsampled_input = self.network.add_conv_block( + "conv_merged", + conv_input, + hwpc_sizes=[((3, 3), (3, 1), 64), ((3, 3), (2, 1), 64)], + l2=self.frontend_conv_l2, + activation=self.input_layer_conv_act, + init=self.start_conv_init, + use_striding=True, + split_input=False, + prefix_name="subsample_", + merge_out_fixed=self.fix_merge_dims, + param_variational_noise=self.weight_noise if "frontend_conv" in self.weight_noise_layers else None, + ) + + assert subsampled_input is not None + + source_linear = self.network.add_linear_layer( + "source_linear", + subsampled_input, + n_out=self.enc_key_dim, + l2=self.l2, + forward_weights_init=self.ff_init, + with_bias=False, + param_dropout=self.ff_weight_drop, + param_dropout_min_ndim=2, + ) + + if self.add_abs_pos_enc_to_input: + source_linear = self.network.add_pos_encoding_layer("input_abs_pos_enc", source_linear, add_to_input=True) + + if self.dropout_in: + source_linear = self.network.add_dropout_layer("source_dropout", source_linear, dropout=self.dropout_in) + + conformer_block_src = source_linear + for i in range(1, self.num_blocks + 1): + conformer_block_src = self._create_conformer_block(i, conformer_block_src) + + encoder = self.network.add_copy_layer(self.output_layer_name, conformer_block_src) + + if self.with_ctc: + default_ctc_loss_opts = {"beam_width": 1} + if self.native_ctc: + default_ctc_loss_opts["use_native"] = True + else: + self.ctc_opts.update({"ignore_longer_outputs_than_inputs": True}) # always enable + if self.ctc_opts: + default_ctc_loss_opts["ctc_opts"] = self.ctc_opts + self.network.add_softmax_layer( + "ctc", + encoder, + l2=self.ctc_l2, + target=self.target, + loss="ctc", + dropout=self.ctc_dropout, + loss_opts=default_ctc_loss_opts, + ) + if self.ctc_loss_scale or self.ctc_self_align_delay: + self.network["ctc"]["loss_scale"] = (self.ctc_loss_scale or 1.0) * ( + (1.0 - self.ctc_self_align_scale) if self.ctc_self_align_delay else 1.0 + ) + + if self.ctc_self_align_delay: + # http://arxiv.org/abs/2105.05005 + assert self.ctc_self_align_delay > 0 # not implemented otherwise, but also not sure if meaningful + self.network["ctc_log_prob"] = {"class": "activation", "from": "ctc", "activation": "safe_log"} + # Cut off first N frames. + self.network[f"ctc_log_prob_slice{self.ctc_self_align_delay}"] = { + "class": "slice", + "from": "ctc_log_prob", + "axis": "T", + "slice_start": self.ctc_self_align_delay, + } + # Forced alignment using that. + self.network[f"ctc_forced_alignment_slice{self.ctc_self_align_delay}"] = { + "class": "forced_align", + "align_target": f"data:{self.target}", + "topology": "ctc", + "from": f"ctc_log_prob_slice{self.ctc_self_align_delay}", + "input_type": "log_prob", + } + # Add blanks at the end. + self.network["_blank_idx"] = { + "class": "length", + "from": f"data:{self.target}", + "axis": "sparse_dim", + "sparse": True, + } + self.network[f"ctc_forced_alignment_shift{self.ctc_self_align_delay}"] = { + "class": "postfix_in_time", + "from": f"ctc_forced_alignment_slice{self.ctc_self_align_delay}", + "postfix": "_blank_idx", + "repeat": self.ctc_self_align_delay, + } + # Now CE loss to those targets. + self.network[f"ctc_ce_shift{self.ctc_self_align_delay}"] = { + "class": "copy", + "from": "ctc", + "loss": "ce", + "loss_scale": (self.ctc_loss_scale or 1.0) * self.ctc_self_align_scale, + "target": f"layer:ctc_forced_alignment_shift{self.ctc_self_align_delay}", + } + + return encoder + + def _create_conformer_blocks(self, input): + if self.proj_input: + conformer_block_src = self.network.add_linear_layer( + "encoder_proj", input, n_out=self.enc_key_dim, activation=None, with_bias=False + ) + else: + conformer_block_src = input + for i in range(1, self.num_blocks + 1): + conformer_block_src = self._create_conformer_block(i, conformer_block_src) + encoder = self.network.add_copy_layer(self.output_layer_name, conformer_block_src) + return encoder + + def create_network(self): + # create only conformer blocks without front-end, etc + if self.create_only_blocks: + return self._create_conformer_blocks(input=self.input) + return self._create_all_network_parts() + + +@dataclass +class ConformerMemoryVariantOpts: + split_batch_time_base: str + chunked_time_dim: Dim # C, number of chunks + chunk_size_dim: Dim # W, including extended left/right, excluding Emformer summary or so + chunk_size: int + self_att_version: int # TODO: just for testing + mem_size: int + mem_slice_start: int + mem_slice_size: int + conv_cache_size: int + use_cached_prev_kv: bool + use_emformer_mem: bool # https://arxiv.org/abs/2010.10759 + apply_tanh_on_emformer_mem: bool + + +def _energy_mask_emformer_mem( + *, + self, + source, + chunked_time_dim: Dim, # C + chunk_size_dim: Dim, # W + att_num_heads_dim: Dim, # H + query_dim: Dim, # W+1 + kv_dim: Dim, # W*N+M, M=C + mem_bank_dim: Dim, # M, M=C + neg_inf: float, + **_kwargs, +): + import numpy + import tensorflow as tf + from returnn.tensor import Tensor, Dim, batch_dim + from returnn.tf.util.data import BatchInfo + + chunk_size_dim # unused # noqa + + energy_data: Tensor = source(0, as_data=True) # [B*C, H, W*N+M, W+1], M=C, dims not necessarily that order + + assert len(energy_data.batch.virtual_dims) == 2 + batch_virtual_dim0, batch_virtual_dim1 = energy_data.batch.virtual_dims + assert isinstance(batch_virtual_dim0, BatchInfo.GlobalBatchDim) + assert isinstance(batch_virtual_dim1, BatchInfo.FixedDim) + assert batch_virtual_dim1.dim_tag == chunked_time_dim + + energy_shape = [] + energy_dims = [] + for d in energy_data.dims: + if d.is_batch_dim(): + energy_dims += [batch_dim, chunked_time_dim] + energy_shape += [batch_virtual_dim0.size, chunked_time_dim.get_dim_value()] + continue + energy_dims.append(d) + energy_shape.append(d.get_dim_value()) + energy: tf.Tensor = tf.reshape(energy_data.raw_tensor, energy_shape) # [B, C, H, W*N [+M], W+1] + assert set(energy_dims) == {batch_dim, chunked_time_dim, att_num_heads_dim, query_dim, kv_dim} + assert len(energy_dims) == len(energy_shape) == energy.shape.rank == 5 + + def _bc_shape(d_: Dim): + ls = [(a_, d__) for a_, d__ in enumerate(energy_dims) if d__ == d_] + if not ls: + raise Exception(f"dim {d_} not found in {energy_dims}") + if len(ls) > 1: + raise Exception(f"dim {d_} found multiple times in {energy_dims}: {ls}") + a = ls[0][0] + return [1] * a + [d_.get_dim_value()] + [1] * (len(energy_dims) - a - 1) + + c_range: tf.Tensor = tf.range(chunked_time_dim.get_dim_value()) # [C] + c_range: tf.Tensor = tf.reshape(c_range, _bc_shape(chunked_time_dim)) # [..C..] + q_range: tf.Tensor = tf.range(query_dim.get_dim_value()) # [W+1] + q_range: tf.Tensor = tf.reshape(q_range, _bc_shape(query_dim)) # [..W+1..] + q_s_idx = query_dim.get_dim_value() - 1 # W + kv_range: tf.Tensor = tf.range(kv_dim.get_dim_value()) # [W*N+M] + kv_range: tf.Tensor = tf.reshape(kv_range, _bc_shape(kv_dim)) # [..W*N+M..] + kv_m_start_idx = kv_dim.get_dim_value() - mem_bank_dim.get_dim_value() # W*N + # In chunk c, we only allow to attend to the previous chunk memories m < c. + mask0 = tf.less(kv_range, kv_m_start_idx + c_range) # [..C.., ..W*N+M..] + # In summary, we do not attend to any memories. + mask1 = tf.less(q_range, q_s_idx) | ( + tf.equal(q_range, q_s_idx) & tf.less(kv_range, kv_m_start_idx) + ) # [..W+1.., ..W*N+M..] + mask = mask0 & mask1 # [..C.., ..W+1.., ..W*N+M..] + energy = tf.where(mask, energy, neg_inf) + + energy = tf.reshape(energy, [d.get_dim_value() for d in energy_data.dims]) # [B*C, H, W*N+M, W+1] + if numpy.isinf(neg_inf): + self.allow_inf_in_output = True + return energy From fe549d67e71f4f292cfa36186668ed343027d64a Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Wed, 15 May 2024 14:59:06 +0000 Subject: [PATCH 003/227] fix --- users/zeineldeen/models/asr/encoder/conformer_encoder_v2.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/users/zeineldeen/models/asr/encoder/conformer_encoder_v2.py b/users/zeineldeen/models/asr/encoder/conformer_encoder_v2.py index 4633e7665..3c31072f9 100644 --- a/users/zeineldeen/models/asr/encoder/conformer_encoder_v2.py +++ b/users/zeineldeen/models/asr/encoder/conformer_encoder_v2.py @@ -17,7 +17,7 @@ from i6_core.returnn.config import CodeWrapper -class ConformerEncoder: +class ConformerEncoderV2: """ Represents Conformer Encoder Architecture From f1c35d15b4881bc4f87703e1eae6ea71e9dcff4a Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Wed, 15 May 2024 15:12:21 +0000 Subject: [PATCH 004/227] add more weight noise opts --- .../asr/encoder/conformer_encoder_v2.py | 54 +++++++++++++------ users/zeineldeen/modules/network.py | 3 ++ 2 files changed, 40 insertions(+), 17 deletions(-) diff --git a/users/zeineldeen/models/asr/encoder/conformer_encoder_v2.py b/users/zeineldeen/models/asr/encoder/conformer_encoder_v2.py index 3c31072f9..110b74553 100644 --- a/users/zeineldeen/models/asr/encoder/conformer_encoder_v2.py +++ b/users/zeineldeen/models/asr/encoder/conformer_encoder_v2.py @@ -1,5 +1,6 @@ """ Conformer encoder +Same as conformer_encoder.py but with more regularizations Other implementations: @@ -14,8 +15,6 @@ from returnn.tf.util.data import SpatialDim, FeatureDim from i6_experiments.users.zeineldeen.modules.network import ReturnnNetwork -from i6_core.returnn.config import CodeWrapper - class ConformerEncoderV2: """ @@ -28,7 +27,7 @@ class ConformerEncoderV2: def __init__( self, input="data", - input_layer="lstm-6", + input_layer="conv-6", input_layer_conv_act="relu", add_abs_pos_enc_to_input=False, frontend_conv_l2=0.0, @@ -79,12 +78,15 @@ def __init__( use_causal_conv=None, conv_alternative_name: Optional[str] = None, fix_merge_dims=False, - weight_noise=None, - weight_noise_layers=None, + ff_weight_noise=None, + mhsa_weight_noise=None, + conv_weight_noise=None, + frontend_conv_weight_noise=None, convolution_first=False, ff_weight_dropout=None, mhsa_weight_dropout=None, conv_weight_dropout=None, + frontend_conv_weight_dropout=None, memory_variant_opts: Optional[ConformerMemoryVariantOpts] = None, ): """ @@ -221,18 +223,17 @@ def __init__( self.conv_alternative_name = conv_alternative_name self.fix_merge_dims = fix_merge_dims - self.weight_noise = weight_noise - self.weight_noise_layers = weight_noise_layers - if self.weight_noise_layers is None: - self.weight_noise_layers = [] - for layer in self.weight_noise_layers: - assert layer in ["mhsa", "conv", "frontend_conv"] + self.ff_weight_noise = ff_weight_noise + self.conv_weight_noise = conv_weight_noise + self.mhsa_weight_noise = mhsa_weight_noise + self.frontend_conv_weight_noise = frontend_conv_weight_noise self.convolution_first = convolution_first self.ff_weight_drop = ff_weight_dropout self.conv_weight_drop = conv_weight_dropout self.mhsa_weight_drop = mhsa_weight_dropout + self.frontend_conv_weight_drop = frontend_conv_weight_dropout self.memory_variant_opts = memory_variant_opts if self.memory_variant_opts: @@ -271,6 +272,7 @@ def _create_ff_module(self, prefix_name, i, source, layer_index): with_bias=self.ff_bias, param_dropout=self.ff_weight_drop, param_dropout_min_ndim=2, + param_variational_noise=self.ff_weight_noise, ) if self.use_sqrd_relu: @@ -294,6 +296,7 @@ def _create_ff_module(self, prefix_name, i, source, layer_index): with_bias=self.ff_bias, param_dropout=self.ff_weight_drop, param_dropout_min_ndim=2, + param_variational_noise=self.ff_weight_noise, ) drop2 = self.network.add_dropout_layer("{}_drop2".format(prefix_name), ff2, dropout=self.dropout) @@ -387,6 +390,7 @@ def _self_att_v2( L2=self.self_att_l2, param_dropout=self.mhsa_weight_drop, param_dropout_min_ndim=2, + param_variational_noise=self.mhsa_weight_noise, ) # [B*C, W*N, D] or [B*C, W, D] (use_cached_prev_kv) V = self.network.add_generic_layer( @@ -399,6 +403,7 @@ def _self_att_v2( L2=self.self_att_l2, param_dropout=self.mhsa_weight_drop, param_dropout_min_ndim=2, + param_variational_noise=self.mhsa_weight_noise, ) # [B*C, W*N, D] or [B*C, W, D] (use_cached_prev_kv) if self.memory_variant_opts.use_emformer_mem and layer_index > 1: @@ -555,6 +560,7 @@ def _self_att_v2( L2=self.self_att_l2, param_dropout=self.mhsa_weight_drop, param_dropout_min_ndim=2, + param_variational_noise=self.mhsa_weight_noise, ) # second half of shape [B*C, W, D] query_dim = self.memory_variant_opts.chunk_size_dim # W @@ -839,7 +845,7 @@ def _create_mhsa_module(self, prefix_name, source, layer_index): key_shift=ln_rel_pos_enc if ln_rel_pos_enc is not None else None, l2=self.self_att_l2, attention_left_only=self.use_causal_layers, - param_variational_noise=self.weight_noise if "mhsa" in self.weight_noise_layers else None, + param_variational_noise=self.mhsa_weight_noise, param_dropout=self.mhsa_weight_drop, param_dropout_min_ndim=2, ) # [B*C, W*N, D] @@ -880,7 +886,7 @@ def _create_mhsa_module(self, prefix_name, source, layer_index): key_shift=ln_rel_pos_enc if ln_rel_pos_enc is not None else None, l2=self.self_att_l2, attention_left_only=self.use_causal_layers, - param_variational_noise=self.weight_noise if "mhsa" in self.weight_noise_layers else None, + param_variational_noise=self.mhsa_weight_noise, param_dropout=self.mhsa_weight_drop, param_dropout_min_ndim=2, ) @@ -894,6 +900,7 @@ def _create_mhsa_module(self, prefix_name, source, layer_index): with_bias=False, param_dropout=self.mhsa_weight_drop, param_dropout_min_ndim=2, + param_variational_noise=self.mhsa_weight_noise, ) drop = self.network.add_dropout_layer("{}_dropout".format(prefix_name), mhsa_linear, dropout=self.dropout) @@ -930,6 +937,7 @@ def _create_convolution_module(self, prefix_name, source, layer_index, half_step forward_weights_init=self.conv_module_init, param_dropout=self.conv_weight_drop, param_dropout_min_ndim=2, + param_variational_noise=self.conv_weight_noise, ) glu_act = self.network.add_gating_layer("{}_glu".format(prefix_name), pointwise_conv1) @@ -969,6 +977,7 @@ def _create_convolution_module(self, prefix_name, source, layer_index, half_step padding="valid", param_dropout=self.conv_weight_drop, param_dropout_min_ndim=2, + param_variational_noise=self.conv_weight_noise, ) # Fix time dim, match with the original input @@ -988,6 +997,7 @@ def _create_convolution_module(self, prefix_name, source, layer_index, half_step forward_weights_init=self.conv_module_init, param_dropout=self.conv_weight_drop, param_dropout_min_ndim=2, + param_variational_noise=self.conv_weight_noise, ) if self.memory_variant_opts is not None and self.memory_variant_opts.conv_cache_size: @@ -1021,6 +1031,7 @@ def _create_convolution_module(self, prefix_name, source, layer_index, half_step forward_weights_init=self.conv_module_init, param_dropout=self.conv_weight_drop, param_dropout_min_ndim=2, + param_variational_noise=self.conv_weight_noise, ) drop = self.network.add_dropout_layer("{}_drop".format(prefix_name), pointwise_conv2, dropout=self.dropout) @@ -1151,7 +1162,9 @@ def _create_all_network_parts(self): activation=self.input_layer_conv_act, init=self.start_conv_init, merge_out=False, - param_variational_noise=self.weight_noise if "frontend_conv" in self.weight_noise_layers else None, + param_dropout=self.frontend_conv_weight_drop, + param_dropout_min_ndim=2, + param_variational_noise=self.frontend_conv_weight_noise, ) subsampled_input = self.network.add_conv_block( @@ -1165,7 +1178,9 @@ def _create_all_network_parts(self): split_input=False, prefix_name="subsample_", merge_out_fixed=self.fix_merge_dims, - param_variational_noise=self.weight_noise if "frontend_conv" in self.weight_noise_layers else None, + param_dropout=self.frontend_conv_weight_drop, + param_dropout_min_ndim=2, + param_variational_noise=self.frontend_conv_weight_noise, ) elif self.input_layer == "conv-6": conv_input = self.network.add_conv_block( @@ -1176,7 +1191,9 @@ def _create_all_network_parts(self): activation=self.input_layer_conv_act, init=self.start_conv_init, merge_out=False, - param_variational_noise=self.weight_noise if "frontend_conv" in self.weight_noise_layers else None, + param_dropout=self.frontend_conv_weight_drop, + param_dropout_min_ndim=2, + param_variational_noise=self.frontend_conv_weight_noise, ) subsampled_input = self.network.add_conv_block( @@ -1190,7 +1207,9 @@ def _create_all_network_parts(self): split_input=False, prefix_name="subsample_", merge_out_fixed=self.fix_merge_dims, - param_variational_noise=self.weight_noise if "frontend_conv" in self.weight_noise_layers else None, + param_dropout=self.frontend_conv_weight_drop, + param_dropout_min_ndim=2, + param_variational_noise=self.frontend_conv_weight_noise, ) assert subsampled_input is not None @@ -1204,6 +1223,7 @@ def _create_all_network_parts(self): with_bias=False, param_dropout=self.ff_weight_drop, param_dropout_min_ndim=2, + param_variational_noise=self.ff_weight_noise, ) if self.add_abs_pos_enc_to_input: diff --git a/users/zeineldeen/modules/network.py b/users/zeineldeen/modules/network.py index 1278f1029..f763da614 100644 --- a/users/zeineldeen/modules/network.py +++ b/users/zeineldeen/modules/network.py @@ -85,6 +85,7 @@ def add_linear_layer( forward_weights_init=None, param_dropout=None, param_dropout_min_ndim=None, + param_variational_noise=None, **kwargs, ): d = {"class": "linear", "activation": activation, "with_bias": with_bias, "from": source} @@ -102,6 +103,8 @@ def add_linear_layer( d["param_dropout"] = param_dropout if param_dropout_min_ndim is not None: d["param_dropout_min_ndim"] = param_dropout_min_ndim + if param_variational_noise: + d["param_variational_noise"] = param_variational_noise d.update(kwargs) self._net[name] = d return name From 4fe365a15f2c78f7f2b3b710cd12053022f529fc Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Wed, 15 May 2024 15:15:53 +0000 Subject: [PATCH 005/227] black formatting --- .../models/asr/decoder/conformer_decoder.py | 827 ++++++++++-------- .../models/asr/decoder/transformer_decoder.py | 624 +++++++------ 2 files changed, 850 insertions(+), 601 deletions(-) diff --git a/users/zeineldeen/models/asr/decoder/conformer_decoder.py b/users/zeineldeen/models/asr/decoder/conformer_decoder.py index 0bca298ec..1ba8cd4bb 100644 --- a/users/zeineldeen/models/asr/decoder/conformer_decoder.py +++ b/users/zeineldeen/models/asr/decoder/conformer_decoder.py @@ -2,351 +2,488 @@ class ConformerDecoder: - """ - Represents Conformer Decoder with causal convolution modules and masked self-attention - """ - - def __init__(self, - base_model, target='bpe', num_layers=6, beam_size=12, ff_init=None, ff_dim=2048, - ff_bias=True, activation='swish', use_sqrd_relu=False, conv_kernel_size=32, conv_module_init=None, - att_num_heads=8, dropout=0.1, att_dropout=0.1, softmax_dropout=0.0, embed_dropout=0.1, l2=0.0, - self_att_l2=0.0, apply_embed_weight=False, label_smoothing=0.1, mhsa_init=None, half_step=True, - mhsa_out_init=None, pos_enc=None, rel_pos_clipping=16, length_normalization=True, - replace_cross_att_w_masked_self_att=False, create_ilm_decoder=False, ilm_type=None, ilm_args=None): - - self.base_model = base_model - self.enc_value_dim = base_model.enc_value_dim - self.enc_key_dim = base_model.enc_key_dim - self.enc_att_num_heads = base_model.att_num_heads - self.enc_key_per_head_dim = base_model.enc_key_per_head_dim - self.enc_val_per_head_dim = base_model.enc_val_per_head_dim - - self.att_num_heads = att_num_heads - - self.target = target - self.num_layers = num_layers - self.beam_size = beam_size - - self.ff_init = ff_init - self.ff_dim = ff_dim - self.ff_bias = ff_bias - - self.conv_kernel_size = conv_kernel_size - self.conv_module_init = conv_module_init - - self.activation = activation - self.use_sqrd_relu = use_sqrd_relu - - self.mhsa_init = mhsa_init - self.mhsa_out_init = mhsa_out_init - - self.pos_enc = pos_enc - self.rel_pos_clipping = rel_pos_clipping - self.half_step = half_step - - self.dropout = dropout - self.softmax_dropout = softmax_dropout - self.att_dropout = att_dropout - self.label_smoothing = label_smoothing - - self.l2 = l2 - self.self_att_l2 = self_att_l2 - - self.embed_dropout = embed_dropout - self.embed_weight = None - - if apply_embed_weight: - self.embed_weight = self.enc_value_dim ** 0.5 - - self.decision_layer_name = None - self.length_normalization = length_normalization - - self.replace_cross_att_w_masked_self_att = replace_cross_att_w_masked_self_att # used to train ILM - - # used for recognition with ILM - self.create_ilm_decoder = create_ilm_decoder - self.ilm_type = ilm_type - self.ilm_args = ilm_args or {} - if self.create_ilm_decoder: - self.replace_cross_att_w_masked_self_att = False # keep original decoder as-is - - self.network = ReturnnNetwork() - self.subnet_unit = ReturnnNetwork() - self.output_prob = None - - def _create_masked_mhsa(self, prefix, source, **kwargs): - prefix_name = '{}_self_att'.format(prefix) - - # for tuning mini-self-att ILM - att_num_heads = kwargs.get('att_num_heads', self.att_num_heads) - enc_key_dim = kwargs.get('enc_key_dim', self.enc_key_dim) - enc_key_per_head_dim = enc_key_dim // att_num_heads - - ln = self.subnet_unit.add_layer_norm_layer('{}_ln'.format(prefix_name), source) - ln_rel_pos_enc = None - - if self.pos_enc == 'rel': - ln_rel_pos_enc = self.subnet_unit.add_relative_pos_encoding_layer( - '{}_ln_rel_pos_enc'.format(prefix_name), ln, n_out=enc_key_per_head_dim, forward_weights_init=self.ff_init, - clipping=self.rel_pos_clipping) - - mhsa = self.subnet_unit.add_self_att_layer( - '{}'.format(prefix_name), ln, n_out=self.enc_value_dim, num_heads=att_num_heads, attention_left_only=True, - total_key_dim=enc_key_dim, att_dropout=self.att_dropout, forward_weights_init=self.mhsa_init, - key_shift=ln_rel_pos_enc if ln_rel_pos_enc is not None else None, l2=self.self_att_l2) - - mhsa_linear = self.subnet_unit.add_linear_layer( - '{}_linear'.format(prefix_name), mhsa, n_out=enc_key_dim, l2=self.l2, - forward_weights_init=self.mhsa_out_init, - with_bias=False) - - drop = self.subnet_unit.add_dropout_layer('{}_dropout'.format(prefix_name), mhsa_linear, dropout=self.dropout) - - res_inputs = [drop, source] - - mhsa_res = self.subnet_unit.add_combine_layer( - '{}_res'.format(prefix_name), kind='add', source=res_inputs, n_out=self.enc_value_dim) - return mhsa_res - - - def _create_mhsa(self, prefix, source): - ln = self.subnet_unit.add_layer_norm_layer('{}_att_ln'.format(prefix), source) - - att_query0 = self.subnet_unit.add_linear_layer( - '{}_att_query0'.format(prefix), ln, with_bias=False, n_out=self.enc_value_dim, - forward_weights_init=self.mhsa_init, l2=self.l2) - - # (B, H, D/H) - att_query = self.subnet_unit.add_split_dim_layer( - '{}_att_query'.format(prefix), att_query0, axis='F', dims=(self.enc_att_num_heads, self.enc_key_per_head_dim)) - - # --------------- Add to the encoder network --------------- # - att_key0 = self.base_model.network.add_linear_layer( - '{}_att_key0'.format(prefix), 'encoder', with_bias=False, n_out=self.enc_key_dim, - forward_weights_init=self.mhsa_init, l2=self.l2) - - # (B, enc-T, H, D/H) - att_key = self.base_model.network.add_split_dim_layer( - '{}_att_key'.format(prefix), att_key0, axis='F', dims=(self.enc_att_num_heads, self.enc_key_per_head_dim)) - - att_value0 = self.base_model.network.add_linear_layer( - '{}_att_value0'.format(prefix), 'encoder', with_bias=False, n_out=self.enc_value_dim, - forward_weights_init=self.mhsa_init, l2=self.l2) - - # (B, enc-T, H, D'/H) - att_value = self.base_model.network.add_split_dim_layer( - '{}_att_value'.format(prefix), att_value0, axis='F', dims=(self.enc_att_num_heads, self.enc_val_per_head_dim)) - # ----------------------------------------------------------- # - - # (B, H, enc-T, 1) - att_energy = self.subnet_unit.add_dot_layer( - '{}_att_energy'.format(prefix), source=['base:' + att_key, att_query], red1=-1, red2=-1, var1='T', var2='T?') - - att_weights = self.subnet_unit.add_softmax_over_spatial_layer( - '{}_att_weights'.format(prefix), att_energy, energy_factor=self.enc_key_per_head_dim ** -0.5) - - att_weights_drop = self.subnet_unit.add_dropout_layer( - '{}_att_weights_drop'.format(prefix), att_weights, dropout=self.att_dropout, dropout_noise_shape={"*": None}) - - # (B, H, V) - att0 = self.subnet_unit.add_generic_att_layer( - '{}_att0'.format(prefix), weights=att_weights_drop, base='base:' + att_value) - - att = self.subnet_unit.add_merge_dims_layer('{}_att'.format(prefix), att0, axes='static') # (B, H*V) except_batch - - # output projection - att_linear = self.subnet_unit.add_linear_layer( - '{}_att_linear'.format(prefix), att, with_bias=False, n_out=self.enc_value_dim, - forward_weights_init=self.mhsa_out_init, l2=self.l2) - - att_drop = self.subnet_unit.add_dropout_layer('{}_att_drop'.format(prefix), att_linear, dropout=self.dropout) - - out = self.subnet_unit.add_combine_layer( - '{}_att_out'.format(prefix), [att_drop, source], kind='add', n_out=self.enc_value_dim) - return out - - def _create_convolution_module(self, prefix_name, source): """ - Add Convolution Module: - LN + point-wise-conv + GLU + depth-wise-conv + Swish + point-wise-conv + Dropout - Note that BN is disabled here because it uses full sequence. - - :param str prefix_name: some prefix name - :param str source: name of source layer - :return: last layer name of this module - :rtype: str + Represents Conformer Decoder with causal convolution modules and masked self-attention """ - prefix_name = '{}_conv_mod'.format(prefix_name) - - ln = self.subnet_unit.add_layer_norm_layer('{}_ln'.format(prefix_name), source) - - pointwise_conv1 = self.subnet_unit.add_linear_layer( - '{}_pointwise_conv1'.format(prefix_name), ln, n_out=2 * self.enc_key_dim, activation=None, l2=self.l2, - with_bias=self.ff_bias, forward_weights_init=self.conv_module_init) - - glu_act = self.subnet_unit.add_gating_layer('{}_glu'.format(prefix_name), pointwise_conv1) - - # Pad to make causal conv - # TODO: This currently does not work inside a recurrent subnetwork. Need to be fixed. - depthwise_conv_input_padded = self.subnet_unit.add_pad_layer( - '{}_depthwise_conv_input_padded'.format(prefix_name), - glu_act, axes='T', padding=(self.conv_kernel_size - 1, 0) - ) - - depthwise_conv = self.subnet_unit.add_conv_layer( - '{}_depthwise_conv2'.format(prefix_name), depthwise_conv_input_padded, n_out=self.enc_key_dim, - filter_size=(self.conv_kernel_size,), groups=self.enc_key_dim, l2=self.l2, - forward_weights_init=self.conv_module_init, padding='valid') - - swish_act = self.subnet_unit.add_activation_layer( - '{}_swish'.format(prefix_name), depthwise_conv, activation='swish') - - pointwise_conv2 = self.subnet_unit.add_linear_layer( - '{}_pointwise_conv2'.format(prefix_name), swish_act, n_out=self.enc_key_dim, activation=None, l2=self.l2, - with_bias=self.ff_bias, forward_weights_init=self.conv_module_init) - - drop = self.subnet_unit.add_dropout_layer('{}_drop'.format(prefix_name), pointwise_conv2, dropout=self.dropout) - - res_inputs = [drop, source] - - res = self.subnet_unit.add_combine_layer( - '{}_res'.format(prefix_name), kind='add', source=res_inputs, n_out=self.enc_key_dim) - return res - - def _create_ff_module(self, prefix_name, i, source): - """ - Add Feed Forward Module: - LN -> FFN -> Swish -> Dropout -> FFN -> Dropout - - :param str prefix_name: some prefix name - :param int i: FF module index - :param str source: name of source layer - :return: last layer name of this module - :rtype: str - """ - prefix_name = prefix_name + '_ffmod_{}'.format(i) - - ln = self.subnet_unit.add_layer_norm_layer('{}_ln'.format(prefix_name), source) - - ff1 = self.subnet_unit.add_linear_layer( - '{}_ff1'.format(prefix_name), ln, n_out=self.ff_dim, l2=self.l2, forward_weights_init=self.ff_init, - with_bias=self.ff_bias) - - if self.use_sqrd_relu: - swish_act = self.subnet_unit.add_activation_layer('{}_relu'.format(prefix_name), ff1, activation='relu') - swish_act = self.subnet_unit.add_eval_layer('{}_square_relu'.format(prefix_name), swish_act, eval='source(0) ** 2') - else: - swish_act = self.subnet_unit.add_activation_layer('{}_swish'.format(prefix_name), ff1, activation=self.activation) - - drop1 = self.subnet_unit.add_dropout_layer('{}_drop1'.format(prefix_name), swish_act, dropout=self.dropout) - - ff2 = self.subnet_unit.add_linear_layer( - '{}_ff2'.format(prefix_name), drop1, n_out=self.enc_key_dim, l2=self.l2, forward_weights_init=self.ff_init, - with_bias=self.ff_bias) - - drop2 = self.subnet_unit.add_dropout_layer('{}_drop2'.format(prefix_name), ff2, dropout=self.dropout) - - if self.half_step: - drop2 = self.subnet_unit.add_eval_layer('{}_half_step'.format(prefix_name), drop2, eval='0.5 * source(0)') - - res_inputs = [drop2, source] - - ff_module_res = self.subnet_unit.add_combine_layer( - '{}_res'.format(prefix_name), kind='add', source=res_inputs, n_out=self.enc_key_dim) - - return ff_module_res - - def _create_decoder_block(self, source, i): - """FF + Masked-MHSA + Causal-Conv + Cross-MHA + FF""" - - prefix = 'conformer_decoder_%02i' % i - - ff1 = self._create_ff_module(prefix, 1, source) - masked_mhsa = self._create_masked_mhsa(prefix, ff1) - conv_module = self._create_convolution_module(prefix, masked_mhsa) - - if self.replace_cross_att_w_masked_self_att: - mhsa = self._create_masked_mhsa('ilm_' + prefix, conv_module, **self.ilm_args) - else: - mhsa = self._create_mhsa(prefix, conv_module) - - ff2 = self._create_ff_module(prefix, 2, mhsa) - ff2_norm = self.subnet_unit.add_layer_norm_layer('{}_ln'.format(prefix), ff2) - out = self.subnet_unit.add_copy_layer(prefix, ff2_norm) - return out - - def _create_ilm_decoder_block(self, source, i): - prefix = 'conformer_decoder_%02i' % i - - ff1 = self._create_ff_module('prior_' + prefix, 1, source) - masked_mhsa = self._create_masked_mhsa('prior_' + prefix, ff1) - conv_module = self._create_convolution_module('prior_' + prefix, masked_mhsa) - - if self.ilm_type == 'mini_lstm': - mhsa = self._create_masked_mhsa('mini_ilm_' + prefix, conv_module, **self.ilm_args) - else: - assert self.ilm_type == 'zero' - mhsa = self.subnet_unit.add_eval_layer('zero_att_%02i' % i, conv_module, eval='tf.zeros_like(source(0))') - - ff2 = self._create_ff_module('prior_' + prefix, 2, mhsa) - ff2_norm = self.subnet_unit.add_layer_norm_layer('{}_ln'.format('prior_' + prefix), ff2) - out = self.subnet_unit.add_copy_layer('prior_' + prefix, ff2_norm) - return out - - def _create_decoder(self): - - self.output_prob = self.subnet_unit.add_softmax_layer( - 'output_prob', 'decoder', loss='ce', - loss_opts={'label_smoothing': self.label_smoothing}, target=self.target, dropout=self.softmax_dropout, - forward_weights_init=self.ff_init, l2=self.l2) - - if self.length_normalization: - output = self.subnet_unit.add_choice_layer( - 'output', self.output_prob, target=self.target, beam_size=self.beam_size, initial_output=0) - else: - output = self.subnet_unit.add_choice_layer( - 'output', self.output_prob, target=self.target, beam_size=self.beam_size, initial_output=0, - length_normalization=self.length_normalization) - - self.subnet_unit.add_compare_layer('end', output, value=0) - - target_embed_raw = self.subnet_unit.add_linear_layer( - 'target_embed_raw', 'prev:' + output, with_bias=False, n_out=self.enc_value_dim, - forward_weights_init=self.ff_init, l2=self.l2) - - if self.embed_weight: - target_embed_raw = self.subnet_unit.add_eval_layer( - 'target_embed_weighted', target_embed_raw, eval='source(0) * %f' % self.embed_weight) - - target_embed = self.subnet_unit.add_dropout_layer( - 'target_embed', target_embed_raw, dropout=self.embed_dropout, dropout_noise_shape={"*": None}) - - x = target_embed - for i in range(1, self.num_layers + 1): - x = self._create_decoder_block(x, i) - self.subnet_unit.add_copy_layer('decoder', x) - - if self.create_ilm_decoder: - x = target_embed - for i in range(1, self.num_layers + 1): - x = self._create_ilm_decoder_block( x, i) - self.subnet_unit.add_copy_layer('prior_decoder', x) - - self.subnet_unit.add_softmax_layer( - 'prior_output_prob', 'prior_decoder', loss='ce', - loss_opts={'label_smoothing': self.label_smoothing}, target=self.target, dropout=self.softmax_dropout, - forward_weights_init=self.ff_init, l2=self.l2 - ) - - dec_output = self.network.add_subnet_rec_layer('output', unit=self.subnet_unit.get_net(), target=self.target) - - return dec_output - - def create_network(self): - dec_output = self._create_decoder() - - # recurrent subnetwork - decision_layer_name = self.base_model.network.add_decide_layer('decision', dec_output, target=self.target) - self.decision_layer_name = decision_layer_name - return dec_output + def __init__( + self, + base_model, + target="bpe", + num_layers=6, + beam_size=12, + ff_init=None, + ff_dim=2048, + ff_bias=True, + activation="swish", + use_sqrd_relu=False, + conv_kernel_size=32, + conv_module_init=None, + att_num_heads=8, + dropout=0.1, + att_dropout=0.1, + softmax_dropout=0.0, + embed_dropout=0.1, + l2=0.0, + self_att_l2=0.0, + apply_embed_weight=False, + label_smoothing=0.1, + mhsa_init=None, + half_step=True, + mhsa_out_init=None, + pos_enc=None, + rel_pos_clipping=16, + length_normalization=True, + replace_cross_att_w_masked_self_att=False, + create_ilm_decoder=False, + ilm_type=None, + ilm_args=None, + ): + self.base_model = base_model + self.enc_value_dim = base_model.enc_value_dim + self.enc_key_dim = base_model.enc_key_dim + self.enc_att_num_heads = base_model.att_num_heads + self.enc_key_per_head_dim = base_model.enc_key_per_head_dim + self.enc_val_per_head_dim = base_model.enc_val_per_head_dim + + self.att_num_heads = att_num_heads + + self.target = target + self.num_layers = num_layers + self.beam_size = beam_size + + self.ff_init = ff_init + self.ff_dim = ff_dim + self.ff_bias = ff_bias + + self.conv_kernel_size = conv_kernel_size + self.conv_module_init = conv_module_init + + self.activation = activation + self.use_sqrd_relu = use_sqrd_relu + + self.mhsa_init = mhsa_init + self.mhsa_out_init = mhsa_out_init + + self.pos_enc = pos_enc + self.rel_pos_clipping = rel_pos_clipping + self.half_step = half_step + + self.dropout = dropout + self.softmax_dropout = softmax_dropout + self.att_dropout = att_dropout + self.label_smoothing = label_smoothing + + self.l2 = l2 + self.self_att_l2 = self_att_l2 + + self.embed_dropout = embed_dropout + self.embed_weight = None + + if apply_embed_weight: + self.embed_weight = self.enc_value_dim**0.5 + + self.decision_layer_name = None + self.length_normalization = length_normalization + + self.replace_cross_att_w_masked_self_att = replace_cross_att_w_masked_self_att # used to train ILM + + # used for recognition with ILM + self.create_ilm_decoder = create_ilm_decoder + self.ilm_type = ilm_type + self.ilm_args = ilm_args or {} + if self.create_ilm_decoder: + self.replace_cross_att_w_masked_self_att = False # keep original decoder as-is + + self.network = ReturnnNetwork() + self.subnet_unit = ReturnnNetwork() + self.output_prob = None + + def _create_masked_mhsa(self, prefix, source, **kwargs): + prefix_name = "{}_self_att".format(prefix) + + # for tuning mini-self-att ILM + att_num_heads = kwargs.get("att_num_heads", self.att_num_heads) + enc_key_dim = kwargs.get("enc_key_dim", self.enc_key_dim) + enc_key_per_head_dim = enc_key_dim // att_num_heads + + ln = self.subnet_unit.add_layer_norm_layer("{}_ln".format(prefix_name), source) + ln_rel_pos_enc = None + + if self.pos_enc == "rel": + ln_rel_pos_enc = self.subnet_unit.add_relative_pos_encoding_layer( + "{}_ln_rel_pos_enc".format(prefix_name), + ln, + n_out=enc_key_per_head_dim, + forward_weights_init=self.ff_init, + clipping=self.rel_pos_clipping, + ) + + mhsa = self.subnet_unit.add_self_att_layer( + "{}".format(prefix_name), + ln, + n_out=self.enc_value_dim, + num_heads=att_num_heads, + attention_left_only=True, + total_key_dim=enc_key_dim, + att_dropout=self.att_dropout, + forward_weights_init=self.mhsa_init, + key_shift=ln_rel_pos_enc if ln_rel_pos_enc is not None else None, + l2=self.self_att_l2, + ) + + mhsa_linear = self.subnet_unit.add_linear_layer( + "{}_linear".format(prefix_name), + mhsa, + n_out=enc_key_dim, + l2=self.l2, + forward_weights_init=self.mhsa_out_init, + with_bias=False, + ) + + drop = self.subnet_unit.add_dropout_layer("{}_dropout".format(prefix_name), mhsa_linear, dropout=self.dropout) + + res_inputs = [drop, source] + + mhsa_res = self.subnet_unit.add_combine_layer( + "{}_res".format(prefix_name), kind="add", source=res_inputs, n_out=self.enc_value_dim + ) + return mhsa_res + + def _create_mhsa(self, prefix, source): + ln = self.subnet_unit.add_layer_norm_layer("{}_att_ln".format(prefix), source) + + att_query0 = self.subnet_unit.add_linear_layer( + "{}_att_query0".format(prefix), + ln, + with_bias=False, + n_out=self.enc_value_dim, + forward_weights_init=self.mhsa_init, + l2=self.l2, + ) + + # (B, H, D/H) + att_query = self.subnet_unit.add_split_dim_layer( + "{}_att_query".format(prefix), + att_query0, + axis="F", + dims=(self.enc_att_num_heads, self.enc_key_per_head_dim), + ) + + # --------------- Add to the encoder network --------------- # + att_key0 = self.base_model.network.add_linear_layer( + "{}_att_key0".format(prefix), + "encoder", + with_bias=False, + n_out=self.enc_key_dim, + forward_weights_init=self.mhsa_init, + l2=self.l2, + ) + + # (B, enc-T, H, D/H) + att_key = self.base_model.network.add_split_dim_layer( + "{}_att_key".format(prefix), att_key0, axis="F", dims=(self.enc_att_num_heads, self.enc_key_per_head_dim) + ) + + att_value0 = self.base_model.network.add_linear_layer( + "{}_att_value0".format(prefix), + "encoder", + with_bias=False, + n_out=self.enc_value_dim, + forward_weights_init=self.mhsa_init, + l2=self.l2, + ) + + # (B, enc-T, H, D'/H) + att_value = self.base_model.network.add_split_dim_layer( + "{}_att_value".format(prefix), + att_value0, + axis="F", + dims=(self.enc_att_num_heads, self.enc_val_per_head_dim), + ) + # ----------------------------------------------------------- # + + # (B, H, enc-T, 1) + att_energy = self.subnet_unit.add_dot_layer( + "{}_att_energy".format(prefix), source=["base:" + att_key, att_query], red1=-1, red2=-1, var1="T", var2="T?" + ) + + att_weights = self.subnet_unit.add_softmax_over_spatial_layer( + "{}_att_weights".format(prefix), att_energy, energy_factor=self.enc_key_per_head_dim**-0.5 + ) + + att_weights_drop = self.subnet_unit.add_dropout_layer( + "{}_att_weights_drop".format(prefix), att_weights, dropout=self.att_dropout, dropout_noise_shape={"*": None} + ) + + # (B, H, V) + att0 = self.subnet_unit.add_generic_att_layer( + "{}_att0".format(prefix), weights=att_weights_drop, base="base:" + att_value + ) + + att = self.subnet_unit.add_merge_dims_layer( + "{}_att".format(prefix), att0, axes="static" + ) # (B, H*V) except_batch + + # output projection + att_linear = self.subnet_unit.add_linear_layer( + "{}_att_linear".format(prefix), + att, + with_bias=False, + n_out=self.enc_value_dim, + forward_weights_init=self.mhsa_out_init, + l2=self.l2, + ) + + att_drop = self.subnet_unit.add_dropout_layer("{}_att_drop".format(prefix), att_linear, dropout=self.dropout) + + out = self.subnet_unit.add_combine_layer( + "{}_att_out".format(prefix), [att_drop, source], kind="add", n_out=self.enc_value_dim + ) + return out + + def _create_convolution_module(self, prefix_name, source): + """ + Add Convolution Module: + LN + point-wise-conv + GLU + depth-wise-conv + Swish + point-wise-conv + Dropout + Note that BN is disabled here because it uses full sequence. + + :param str prefix_name: some prefix name + :param str source: name of source layer + :return: last layer name of this module + :rtype: str + """ + prefix_name = "{}_conv_mod".format(prefix_name) + + ln = self.subnet_unit.add_layer_norm_layer("{}_ln".format(prefix_name), source) + + pointwise_conv1 = self.subnet_unit.add_linear_layer( + "{}_pointwise_conv1".format(prefix_name), + ln, + n_out=2 * self.enc_key_dim, + activation=None, + l2=self.l2, + with_bias=self.ff_bias, + forward_weights_init=self.conv_module_init, + ) + + glu_act = self.subnet_unit.add_gating_layer("{}_glu".format(prefix_name), pointwise_conv1) + + # Pad to make causal conv + # TODO: This currently does not work inside a recurrent subnetwork. Need to be fixed. + depthwise_conv_input_padded = self.subnet_unit.add_pad_layer( + "{}_depthwise_conv_input_padded".format(prefix_name), + glu_act, + axes="T", + padding=(self.conv_kernel_size - 1, 0), + ) + + depthwise_conv = self.subnet_unit.add_conv_layer( + "{}_depthwise_conv2".format(prefix_name), + depthwise_conv_input_padded, + n_out=self.enc_key_dim, + filter_size=(self.conv_kernel_size,), + groups=self.enc_key_dim, + l2=self.l2, + forward_weights_init=self.conv_module_init, + padding="valid", + ) + + swish_act = self.subnet_unit.add_activation_layer( + "{}_swish".format(prefix_name), depthwise_conv, activation="swish" + ) + + pointwise_conv2 = self.subnet_unit.add_linear_layer( + "{}_pointwise_conv2".format(prefix_name), + swish_act, + n_out=self.enc_key_dim, + activation=None, + l2=self.l2, + with_bias=self.ff_bias, + forward_weights_init=self.conv_module_init, + ) + + drop = self.subnet_unit.add_dropout_layer("{}_drop".format(prefix_name), pointwise_conv2, dropout=self.dropout) + + res_inputs = [drop, source] + + res = self.subnet_unit.add_combine_layer( + "{}_res".format(prefix_name), kind="add", source=res_inputs, n_out=self.enc_key_dim + ) + return res + + def _create_ff_module(self, prefix_name, i, source): + """ + Add Feed Forward Module: + LN -> FFN -> Swish -> Dropout -> FFN -> Dropout + + :param str prefix_name: some prefix name + :param int i: FF module index + :param str source: name of source layer + :return: last layer name of this module + :rtype: str + """ + prefix_name = prefix_name + "_ffmod_{}".format(i) + + ln = self.subnet_unit.add_layer_norm_layer("{}_ln".format(prefix_name), source) + + ff1 = self.subnet_unit.add_linear_layer( + "{}_ff1".format(prefix_name), + ln, + n_out=self.ff_dim, + l2=self.l2, + forward_weights_init=self.ff_init, + with_bias=self.ff_bias, + ) + + if self.use_sqrd_relu: + swish_act = self.subnet_unit.add_activation_layer("{}_relu".format(prefix_name), ff1, activation="relu") + swish_act = self.subnet_unit.add_eval_layer( + "{}_square_relu".format(prefix_name), swish_act, eval="source(0) ** 2" + ) + else: + swish_act = self.subnet_unit.add_activation_layer( + "{}_swish".format(prefix_name), ff1, activation=self.activation + ) + + drop1 = self.subnet_unit.add_dropout_layer("{}_drop1".format(prefix_name), swish_act, dropout=self.dropout) + + ff2 = self.subnet_unit.add_linear_layer( + "{}_ff2".format(prefix_name), + drop1, + n_out=self.enc_key_dim, + l2=self.l2, + forward_weights_init=self.ff_init, + with_bias=self.ff_bias, + ) + + drop2 = self.subnet_unit.add_dropout_layer("{}_drop2".format(prefix_name), ff2, dropout=self.dropout) + + if self.half_step: + drop2 = self.subnet_unit.add_eval_layer("{}_half_step".format(prefix_name), drop2, eval="0.5 * source(0)") + + res_inputs = [drop2, source] + + ff_module_res = self.subnet_unit.add_combine_layer( + "{}_res".format(prefix_name), kind="add", source=res_inputs, n_out=self.enc_key_dim + ) + + return ff_module_res + + def _create_decoder_block(self, source, i): + """FF + Masked-MHSA + Causal-Conv + Cross-MHA + FF""" + + prefix = "conformer_decoder_%02i" % i + + ff1 = self._create_ff_module(prefix, 1, source) + masked_mhsa = self._create_masked_mhsa(prefix, ff1) + conv_module = self._create_convolution_module(prefix, masked_mhsa) + + if self.replace_cross_att_w_masked_self_att: + mhsa = self._create_masked_mhsa("ilm_" + prefix, conv_module, **self.ilm_args) + else: + mhsa = self._create_mhsa(prefix, conv_module) + + ff2 = self._create_ff_module(prefix, 2, mhsa) + ff2_norm = self.subnet_unit.add_layer_norm_layer("{}_ln".format(prefix), ff2) + out = self.subnet_unit.add_copy_layer(prefix, ff2_norm) + return out + + def _create_ilm_decoder_block(self, source, i): + prefix = "conformer_decoder_%02i" % i + + ff1 = self._create_ff_module("prior_" + prefix, 1, source) + masked_mhsa = self._create_masked_mhsa("prior_" + prefix, ff1) + conv_module = self._create_convolution_module("prior_" + prefix, masked_mhsa) + + if self.ilm_type == "mini_lstm": + mhsa = self._create_masked_mhsa("mini_ilm_" + prefix, conv_module, **self.ilm_args) + else: + assert self.ilm_type == "zero" + mhsa = self.subnet_unit.add_eval_layer("zero_att_%02i" % i, conv_module, eval="tf.zeros_like(source(0))") + + ff2 = self._create_ff_module("prior_" + prefix, 2, mhsa) + ff2_norm = self.subnet_unit.add_layer_norm_layer("{}_ln".format("prior_" + prefix), ff2) + out = self.subnet_unit.add_copy_layer("prior_" + prefix, ff2_norm) + return out + + def _create_decoder(self): + self.output_prob = self.subnet_unit.add_softmax_layer( + "output_prob", + "decoder", + loss="ce", + loss_opts={"label_smoothing": self.label_smoothing}, + target=self.target, + dropout=self.softmax_dropout, + forward_weights_init=self.ff_init, + l2=self.l2, + ) + + if self.length_normalization: + output = self.subnet_unit.add_choice_layer( + "output", self.output_prob, target=self.target, beam_size=self.beam_size, initial_output=0 + ) + else: + output = self.subnet_unit.add_choice_layer( + "output", + self.output_prob, + target=self.target, + beam_size=self.beam_size, + initial_output=0, + length_normalization=self.length_normalization, + ) + + self.subnet_unit.add_compare_layer("end", output, value=0) + + target_embed_raw = self.subnet_unit.add_linear_layer( + "target_embed_raw", + "prev:" + output, + with_bias=False, + n_out=self.enc_value_dim, + forward_weights_init=self.ff_init, + l2=self.l2, + ) + + if self.embed_weight: + target_embed_raw = self.subnet_unit.add_eval_layer( + "target_embed_weighted", target_embed_raw, eval="source(0) * %f" % self.embed_weight + ) + + target_embed = self.subnet_unit.add_dropout_layer( + "target_embed", target_embed_raw, dropout=self.embed_dropout, dropout_noise_shape={"*": None} + ) + + x = target_embed + for i in range(1, self.num_layers + 1): + x = self._create_decoder_block(x, i) + self.subnet_unit.add_copy_layer("decoder", x) + + if self.create_ilm_decoder: + x = target_embed + for i in range(1, self.num_layers + 1): + x = self._create_ilm_decoder_block(x, i) + self.subnet_unit.add_copy_layer("prior_decoder", x) + + self.subnet_unit.add_softmax_layer( + "prior_output_prob", + "prior_decoder", + loss="ce", + loss_opts={"label_smoothing": self.label_smoothing}, + target=self.target, + dropout=self.softmax_dropout, + forward_weights_init=self.ff_init, + l2=self.l2, + ) + + dec_output = self.network.add_subnet_rec_layer("output", unit=self.subnet_unit.get_net(), target=self.target) + + return dec_output + + def create_network(self): + dec_output = self._create_decoder() + + # recurrent subnetwork + decision_layer_name = self.base_model.network.add_decide_layer("decision", dec_output, target=self.target) + self.decision_layer_name = decision_layer_name + + return dec_output diff --git a/users/zeineldeen/models/asr/decoder/transformer_decoder.py b/users/zeineldeen/models/asr/decoder/transformer_decoder.py index 42a74331f..da4dc7850 100644 --- a/users/zeineldeen/models/asr/decoder/transformer_decoder.py +++ b/users/zeineldeen/models/asr/decoder/transformer_decoder.py @@ -2,259 +2,371 @@ class TransformerDecoder: - """ - Represents standard Transformer decoder - - * Attention Is All You Need - * Ref: https://arxiv.org/abs/1706.03762 - """ - - def __init__(self, - base_model, target='bpe', num_layers=6, beam_size=12, ff_init=None, ff_dim=2048, ff_act='relu', att_num_heads=8, - dropout=0.1, att_dropout=0.0, softmax_dropout=0.0, embed_dropout=0.1, l2=0.0, embed_pos_enc=False, - apply_embed_weight=False, label_smoothing=0.1, mhsa_init=None, mhsa_out_init=None, - pos_enc=None, rel_pos_clipping=16, length_normalization=True, - replace_cross_att_w_masked_self_att=False, create_ilm_decoder=False, ilm_type=None, ilm_args=None): - - self.base_model = base_model - self.enc_value_dim = base_model.enc_value_dim - self.enc_key_dim = base_model.enc_key_dim - self.enc_att_num_heads = base_model.att_num_heads - self.enc_key_per_head_dim = base_model.enc_key_per_head_dim - self.enc_val_per_head_dim = base_model.enc_val_per_head_dim - - self.att_num_heads = att_num_heads - - self.target = target - self.num_layers = num_layers - self.beam_size = beam_size - - self.ff_init = ff_init - self.ff_dim = ff_dim - self.ff_act = ff_act - - self.mhsa_init = mhsa_init - self.mhsa_init_out = mhsa_out_init - - self.pos_enc = pos_enc - self.rel_pos_clipping = rel_pos_clipping - - self.dropout = dropout - self.softmax_dropout = softmax_dropout - self.att_dropout = att_dropout - self.label_smoothing = label_smoothing - - self.l2 = l2 - - self.embed_dropout = embed_dropout - self.embed_pos_enc = embed_pos_enc - - self.embed_weight = None - - if apply_embed_weight: - self.embed_weight = self.enc_value_dim ** 0.5 - - self.decision_layer_name = None - - self.length_normalization = length_normalization - - self.replace_cross_att_w_masked_self_att = replace_cross_att_w_masked_self_att # used to train ILM - - # used for recognition with ILM - self.create_ilm_decoder = create_ilm_decoder - self.ilm_type = ilm_type - self.ilm_args = ilm_args or {} - if self.create_ilm_decoder: - self.replace_cross_att_w_masked_self_att = False # keep original decoder as-is - - self.network = ReturnnNetwork() - self.subnet_unit = ReturnnNetwork() - self.output_prob = None - - def _create_masked_mhsa(self, subnet_unit: ReturnnNetwork, prefix, source, **kwargs): - prefix = '{}_self_att'.format(prefix) - - # for tuning mini-self-att ILM - att_num_heads = kwargs.get('att_num_heads', self.att_num_heads) - enc_key_dim = kwargs.get('enc_key_dim', self.enc_key_dim) - enc_key_per_head_dim = enc_key_dim // att_num_heads - - ln = subnet_unit.add_layer_norm_layer('{}_ln'.format(prefix), source) - - ln_rel_pos_enc = None - if self.pos_enc == 'rel': - ln_rel_pos_enc = self.subnet_unit.add_relative_pos_encoding_layer( - '{}_ln_rel_pos_enc'.format(prefix), ln, n_out=enc_key_per_head_dim, forward_weights_init=self.ff_init, - clipping=self.rel_pos_clipping) - - att = subnet_unit.add_self_att_layer( - '{}_att'.format(prefix), ln, num_heads=att_num_heads, total_key_dim=enc_key_dim, - n_out=self.enc_value_dim, attention_left_only=True, att_dropout=self.att_dropout, - forward_weights_init=self.mhsa_init, l2=self.l2, key_shift=ln_rel_pos_enc if ln_rel_pos_enc is not None else None) - - linear = subnet_unit.add_linear_layer( - '{}_linear'.format(prefix), att, activation=None, with_bias=False, n_out=self.enc_value_dim, - forward_weights_init=self.mhsa_init_out, l2=self.l2) - - drop = subnet_unit.add_dropout_layer('{}_drop'.format(prefix), linear, dropout=self.dropout) - - out = subnet_unit.add_combine_layer('{}_out'.format(prefix), [drop, source], kind='add', n_out=self.enc_value_dim) - - return out - - def _create_mhsa(self, subnet_unit: ReturnnNetwork, prefix, source): - ln = subnet_unit.add_layer_norm_layer('{}_att_ln'.format(prefix), source) - - att_query0 = subnet_unit.add_linear_layer( - '{}_att_query0'.format(prefix), ln, with_bias=False, n_out=self.enc_value_dim, - forward_weights_init=self.mhsa_init, l2=self.l2) - - # (B, H, D/H) - att_query = subnet_unit.add_split_dim_layer( - '{}_att_query'.format(prefix), att_query0, axis='F', dims=(self.enc_att_num_heads, self.enc_key_per_head_dim)) - - # --------------- Add to the encoder network --------------- # - att_key0 = self.base_model.network.add_linear_layer( - '{}_att_key0'.format(prefix), 'encoder', with_bias=False, n_out=self.enc_key_dim, - forward_weights_init=self.mhsa_init, l2=self.l2) - - # (B, enc-T, H, D/H) - att_key = self.base_model.network.add_split_dim_layer( - '{}_att_key'.format(prefix), att_key0, axis='F', dims=(self.enc_att_num_heads, self.enc_key_per_head_dim)) - - att_value0 = self.base_model.network.add_linear_layer( - '{}_att_value0'.format(prefix), 'encoder', with_bias=False, n_out=self.enc_value_dim, - forward_weights_init=self.mhsa_init, l2=self.l2) - - # (B, enc-T, H, D'/H) - att_value = self.base_model.network.add_split_dim_layer( - '{}_att_value'.format(prefix), att_value0, axis='F', dims=(self.enc_att_num_heads, self.enc_val_per_head_dim)) - # ----------------------------------------------------------- # - - # (B, H, enc-T, 1) - att_energy = subnet_unit.add_dot_layer( - '{}_att_energy'.format(prefix), source=['base:' + att_key, att_query], red1=-1, red2=-1, var1='T', var2='T?') - - att_weights = subnet_unit.add_softmax_over_spatial_layer( - '{}_att_weights'.format(prefix), att_energy, energy_factor=self.enc_key_per_head_dim ** -0.5) - - att_weights_drop = subnet_unit.add_dropout_layer( - '{}_att_weights_drop'.format(prefix), att_weights, dropout=self.att_dropout, dropout_noise_shape={"*": None}) - - # (B, H, V) - att0 = subnet_unit.add_generic_att_layer( - '{}_att0'.format(prefix), weights=att_weights_drop, base='base:' + att_value) - - att = subnet_unit.add_merge_dims_layer('{}_att'.format(prefix), att0, axes='static') # (B, H*V) except_batch - - # output projection - att_linear = subnet_unit.add_linear_layer( - '{}_att_linear'.format(prefix), att, with_bias=False, n_out=self.enc_value_dim, - forward_weights_init=self.mhsa_init_out, l2=self.l2) - - att_drop = subnet_unit.add_dropout_layer('{}_att_drop'.format(prefix), att_linear, dropout=self.dropout) - - out = subnet_unit.add_combine_layer( - '{}_att_out'.format(prefix), [att_drop, source], kind='add', n_out=self.enc_value_dim) - return out - - def _create_ff_module(self, subnet_unit: ReturnnNetwork, prefix, source): - ff_ln = subnet_unit.add_layer_norm_layer('{}_ff_ln'.format(prefix), source) - - ff1 = subnet_unit.add_linear_layer( - '{}_ff_conv1'.format(prefix), ff_ln, activation=self.ff_act, forward_weights_init=self.ff_init, n_out=self.ff_dim, - with_bias=True, l2=self.l2) - - ff2 = subnet_unit.add_linear_layer( - '{}_ff_conv2'.format(prefix), ff1, activation=None, forward_weights_init=self.ff_init, n_out=self.enc_value_dim, - dropout=self.dropout, with_bias=True, l2=self.l2) - - drop = subnet_unit.add_dropout_layer('{}_ff_drop'.format(prefix), ff2, dropout=self.dropout) - - out = subnet_unit.add_combine_layer( - '{}_ff_out'.format(prefix), [drop, source], kind='add', n_out=self.enc_value_dim) - return out - - def _create_decoder_block(self, subnet_unit: ReturnnNetwork, source, i): - prefix = 'transformer_decoder_%02i' % i - masked_mhsa = self._create_masked_mhsa(subnet_unit, prefix, source) - if self.replace_cross_att_w_masked_self_att: - mhsa = self._create_masked_mhsa(subnet_unit, 'ilm_' + prefix, masked_mhsa, **self.ilm_args) - else: - mhsa = self._create_mhsa(subnet_unit, prefix, masked_mhsa) - ff = self._create_ff_module(subnet_unit, prefix, mhsa) - out = subnet_unit.add_copy_layer(prefix, ff) - return out - - def _create_ilm_decoder_block(self, subnet_unit: ReturnnNetwork, source, i): - prefix = 'transformer_decoder_%02i' % i - masked_mhsa = self._create_masked_mhsa(subnet_unit, 'prior_' + prefix, source) - if self.ilm_type == 'mini_lstm': - mhsa = self._create_masked_mhsa(subnet_unit, 'mini_ilm_' + prefix, masked_mhsa, **self.ilm_args) - else: - assert self.ilm_type == 'zero' - mhsa = subnet_unit.add_eval_layer('zero_att_%02i' % i, masked_mhsa, eval='tf.zeros_like(source(0))') - ff = self._create_ff_module(subnet_unit, 'prior_' + prefix, mhsa) - out = subnet_unit.add_copy_layer('prior_' + prefix, ff) - return out - - def _create_decoder(self, subnet_unit: ReturnnNetwork): - - self.output_prob = subnet_unit.add_softmax_layer( - 'output_prob', 'decoder', loss='ce', - loss_opts={'label_smoothing': self.label_smoothing}, target=self.target, dropout=self.softmax_dropout, - forward_weights_init=self.ff_init, l2=self.l2) - - if self.length_normalization: - output = subnet_unit.add_choice_layer( - 'output', self.output_prob, target=self.target, beam_size=self.beam_size, initial_output=0) - else: - output = subnet_unit.add_choice_layer( - 'output', self.output_prob, target=self.target, beam_size=self.beam_size, initial_output=0, - length_normalization=self.length_normalization) - - subnet_unit.add_compare_layer('end', output, value=0) - - target_embed_raw = subnet_unit.add_linear_layer( - 'target_embed_raw', 'prev:' + output, with_bias=False, n_out=self.enc_value_dim, - forward_weights_init=self.ff_init, l2=self.l2) - - if self.embed_weight: - target_embed_raw = subnet_unit.add_eval_layer( - 'target_embed_weighted', target_embed_raw, eval='source(0) * %f' % self.embed_weight) - - if self.embed_pos_enc: - target_embed_raw = subnet_unit.add_pos_encoding_layer('target_embed_pos_enc', target_embed_raw) - - target_embed = subnet_unit.add_dropout_layer( - 'target_embed', target_embed_raw, dropout=self.embed_dropout, dropout_noise_shape={"*": None}) - - x = target_embed - for i in range(1, self.num_layers + 1): - x = self._create_decoder_block(subnet_unit, x, i) - subnet_unit.add_layer_norm_layer('decoder', x) - - if self.create_ilm_decoder: - x = target_embed - for i in range(1, self.num_layers + 1): - x = self._create_ilm_decoder_block(subnet_unit, x, i) - subnet_unit.add_layer_norm_layer('prior_decoder', x) - - subnet_unit.add_softmax_layer( - 'prior_output_prob', 'prior_decoder', loss='ce', - loss_opts={'label_smoothing': self.label_smoothing}, target=self.target, dropout=self.softmax_dropout, - forward_weights_init=self.ff_init, l2=self.l2 - ) - - dec_output = self.network.add_subnet_rec_layer('output', unit=subnet_unit.get_net(), target=self.target) - - return dec_output - - def create_network(self): - dec_output = self._create_decoder(self.subnet_unit) - - # recurrent subnetwork - decision_layer_name = self.base_model.network.add_decide_layer('decision', dec_output, target=self.target) - self.decision_layer_name = decision_layer_name - - return dec_output + """ + Represents standard Transformer decoder + + * Attention Is All You Need + * Ref: https://arxiv.org/abs/1706.03762 + """ + + def __init__( + self, + base_model, + target="bpe", + num_layers=6, + beam_size=12, + ff_init=None, + ff_dim=2048, + ff_act="relu", + att_num_heads=8, + dropout=0.1, + att_dropout=0.0, + softmax_dropout=0.0, + embed_dropout=0.1, + l2=0.0, + embed_pos_enc=False, + apply_embed_weight=False, + label_smoothing=0.1, + mhsa_init=None, + mhsa_out_init=None, + pos_enc=None, + rel_pos_clipping=16, + length_normalization=True, + replace_cross_att_w_masked_self_att=False, + create_ilm_decoder=False, + ilm_type=None, + ilm_args=None, + ): + self.base_model = base_model + self.enc_value_dim = base_model.enc_value_dim + self.enc_key_dim = base_model.enc_key_dim + self.enc_att_num_heads = base_model.att_num_heads + self.enc_key_per_head_dim = base_model.enc_key_per_head_dim + self.enc_val_per_head_dim = base_model.enc_val_per_head_dim + + self.att_num_heads = att_num_heads + + self.target = target + self.num_layers = num_layers + self.beam_size = beam_size + + self.ff_init = ff_init + self.ff_dim = ff_dim + self.ff_act = ff_act + + self.mhsa_init = mhsa_init + self.mhsa_init_out = mhsa_out_init + + self.pos_enc = pos_enc + self.rel_pos_clipping = rel_pos_clipping + + self.dropout = dropout + self.softmax_dropout = softmax_dropout + self.att_dropout = att_dropout + self.label_smoothing = label_smoothing + + self.l2 = l2 + + self.embed_dropout = embed_dropout + self.embed_pos_enc = embed_pos_enc + + self.embed_weight = None + + if apply_embed_weight: + self.embed_weight = self.enc_value_dim**0.5 + + self.decision_layer_name = None + + self.length_normalization = length_normalization + + self.replace_cross_att_w_masked_self_att = replace_cross_att_w_masked_self_att # used to train ILM + + # used for recognition with ILM + self.create_ilm_decoder = create_ilm_decoder + self.ilm_type = ilm_type + self.ilm_args = ilm_args or {} + if self.create_ilm_decoder: + self.replace_cross_att_w_masked_self_att = False # keep original decoder as-is + + self.network = ReturnnNetwork() + self.subnet_unit = ReturnnNetwork() + self.output_prob = None + + def _create_masked_mhsa(self, subnet_unit: ReturnnNetwork, prefix, source, **kwargs): + prefix = "{}_self_att".format(prefix) + + # for tuning mini-self-att ILM + att_num_heads = kwargs.get("att_num_heads", self.att_num_heads) + enc_key_dim = kwargs.get("enc_key_dim", self.enc_key_dim) + enc_key_per_head_dim = enc_key_dim // att_num_heads + + ln = subnet_unit.add_layer_norm_layer("{}_ln".format(prefix), source) + + ln_rel_pos_enc = None + if self.pos_enc == "rel": + ln_rel_pos_enc = self.subnet_unit.add_relative_pos_encoding_layer( + "{}_ln_rel_pos_enc".format(prefix), + ln, + n_out=enc_key_per_head_dim, + forward_weights_init=self.ff_init, + clipping=self.rel_pos_clipping, + ) + + att = subnet_unit.add_self_att_layer( + "{}_att".format(prefix), + ln, + num_heads=att_num_heads, + total_key_dim=enc_key_dim, + n_out=self.enc_value_dim, + attention_left_only=True, + att_dropout=self.att_dropout, + forward_weights_init=self.mhsa_init, + l2=self.l2, + key_shift=ln_rel_pos_enc if ln_rel_pos_enc is not None else None, + ) + + linear = subnet_unit.add_linear_layer( + "{}_linear".format(prefix), + att, + activation=None, + with_bias=False, + n_out=self.enc_value_dim, + forward_weights_init=self.mhsa_init_out, + l2=self.l2, + ) + + drop = subnet_unit.add_dropout_layer("{}_drop".format(prefix), linear, dropout=self.dropout) + + out = subnet_unit.add_combine_layer( + "{}_out".format(prefix), [drop, source], kind="add", n_out=self.enc_value_dim + ) + + return out + + def _create_mhsa(self, subnet_unit: ReturnnNetwork, prefix, source): + ln = subnet_unit.add_layer_norm_layer("{}_att_ln".format(prefix), source) + + att_query0 = subnet_unit.add_linear_layer( + "{}_att_query0".format(prefix), + ln, + with_bias=False, + n_out=self.enc_value_dim, + forward_weights_init=self.mhsa_init, + l2=self.l2, + ) + + # (B, H, D/H) + att_query = subnet_unit.add_split_dim_layer( + "{}_att_query".format(prefix), + att_query0, + axis="F", + dims=(self.enc_att_num_heads, self.enc_key_per_head_dim), + ) + + # --------------- Add to the encoder network --------------- # + att_key0 = self.base_model.network.add_linear_layer( + "{}_att_key0".format(prefix), + "encoder", + with_bias=False, + n_out=self.enc_key_dim, + forward_weights_init=self.mhsa_init, + l2=self.l2, + ) + + # (B, enc-T, H, D/H) + att_key = self.base_model.network.add_split_dim_layer( + "{}_att_key".format(prefix), att_key0, axis="F", dims=(self.enc_att_num_heads, self.enc_key_per_head_dim) + ) + + att_value0 = self.base_model.network.add_linear_layer( + "{}_att_value0".format(prefix), + "encoder", + with_bias=False, + n_out=self.enc_value_dim, + forward_weights_init=self.mhsa_init, + l2=self.l2, + ) + + # (B, enc-T, H, D'/H) + att_value = self.base_model.network.add_split_dim_layer( + "{}_att_value".format(prefix), + att_value0, + axis="F", + dims=(self.enc_att_num_heads, self.enc_val_per_head_dim), + ) + # ----------------------------------------------------------- # + + # (B, H, enc-T, 1) + att_energy = subnet_unit.add_dot_layer( + "{}_att_energy".format(prefix), source=["base:" + att_key, att_query], red1=-1, red2=-1, var1="T", var2="T?" + ) + + att_weights = subnet_unit.add_softmax_over_spatial_layer( + "{}_att_weights".format(prefix), att_energy, energy_factor=self.enc_key_per_head_dim**-0.5 + ) + + att_weights_drop = subnet_unit.add_dropout_layer( + "{}_att_weights_drop".format(prefix), att_weights, dropout=self.att_dropout, dropout_noise_shape={"*": None} + ) + + # (B, H, V) + att0 = subnet_unit.add_generic_att_layer( + "{}_att0".format(prefix), weights=att_weights_drop, base="base:" + att_value + ) + + att = subnet_unit.add_merge_dims_layer("{}_att".format(prefix), att0, axes="static") # (B, H*V) except_batch + + # output projection + att_linear = subnet_unit.add_linear_layer( + "{}_att_linear".format(prefix), + att, + with_bias=False, + n_out=self.enc_value_dim, + forward_weights_init=self.mhsa_init_out, + l2=self.l2, + ) + + att_drop = subnet_unit.add_dropout_layer("{}_att_drop".format(prefix), att_linear, dropout=self.dropout) + + out = subnet_unit.add_combine_layer( + "{}_att_out".format(prefix), [att_drop, source], kind="add", n_out=self.enc_value_dim + ) + return out + + def _create_ff_module(self, subnet_unit: ReturnnNetwork, prefix, source): + ff_ln = subnet_unit.add_layer_norm_layer("{}_ff_ln".format(prefix), source) + + ff1 = subnet_unit.add_linear_layer( + "{}_ff_conv1".format(prefix), + ff_ln, + activation=self.ff_act, + forward_weights_init=self.ff_init, + n_out=self.ff_dim, + with_bias=True, + l2=self.l2, + ) + + ff2 = subnet_unit.add_linear_layer( + "{}_ff_conv2".format(prefix), + ff1, + activation=None, + forward_weights_init=self.ff_init, + n_out=self.enc_value_dim, + dropout=self.dropout, + with_bias=True, + l2=self.l2, + ) + + drop = subnet_unit.add_dropout_layer("{}_ff_drop".format(prefix), ff2, dropout=self.dropout) + + out = subnet_unit.add_combine_layer( + "{}_ff_out".format(prefix), [drop, source], kind="add", n_out=self.enc_value_dim + ) + return out + + def _create_decoder_block(self, subnet_unit: ReturnnNetwork, source, i): + prefix = "transformer_decoder_%02i" % i + masked_mhsa = self._create_masked_mhsa(subnet_unit, prefix, source) + if self.replace_cross_att_w_masked_self_att: + mhsa = self._create_masked_mhsa(subnet_unit, "ilm_" + prefix, masked_mhsa, **self.ilm_args) + else: + mhsa = self._create_mhsa(subnet_unit, prefix, masked_mhsa) + ff = self._create_ff_module(subnet_unit, prefix, mhsa) + out = subnet_unit.add_copy_layer(prefix, ff) + return out + + def _create_ilm_decoder_block(self, subnet_unit: ReturnnNetwork, source, i): + prefix = "transformer_decoder_%02i" % i + masked_mhsa = self._create_masked_mhsa(subnet_unit, "prior_" + prefix, source) + if self.ilm_type == "mini_lstm": + mhsa = self._create_masked_mhsa(subnet_unit, "mini_ilm_" + prefix, masked_mhsa, **self.ilm_args) + else: + assert self.ilm_type == "zero" + mhsa = subnet_unit.add_eval_layer("zero_att_%02i" % i, masked_mhsa, eval="tf.zeros_like(source(0))") + ff = self._create_ff_module(subnet_unit, "prior_" + prefix, mhsa) + out = subnet_unit.add_copy_layer("prior_" + prefix, ff) + return out + + def _create_decoder(self, subnet_unit: ReturnnNetwork): + self.output_prob = subnet_unit.add_softmax_layer( + "output_prob", + "decoder", + loss="ce", + loss_opts={"label_smoothing": self.label_smoothing}, + target=self.target, + dropout=self.softmax_dropout, + forward_weights_init=self.ff_init, + l2=self.l2, + ) + + if self.length_normalization: + output = subnet_unit.add_choice_layer( + "output", self.output_prob, target=self.target, beam_size=self.beam_size, initial_output=0 + ) + else: + output = subnet_unit.add_choice_layer( + "output", + self.output_prob, + target=self.target, + beam_size=self.beam_size, + initial_output=0, + length_normalization=self.length_normalization, + ) + + subnet_unit.add_compare_layer("end", output, value=0) + + target_embed_raw = subnet_unit.add_linear_layer( + "target_embed_raw", + "prev:" + output, + with_bias=False, + n_out=self.enc_value_dim, + forward_weights_init=self.ff_init, + l2=self.l2, + ) + + if self.embed_weight: + target_embed_raw = subnet_unit.add_eval_layer( + "target_embed_weighted", target_embed_raw, eval="source(0) * %f" % self.embed_weight + ) + + if self.embed_pos_enc: + target_embed_raw = subnet_unit.add_pos_encoding_layer("target_embed_pos_enc", target_embed_raw) + + target_embed = subnet_unit.add_dropout_layer( + "target_embed", target_embed_raw, dropout=self.embed_dropout, dropout_noise_shape={"*": None} + ) + + x = target_embed + for i in range(1, self.num_layers + 1): + x = self._create_decoder_block(subnet_unit, x, i) + subnet_unit.add_layer_norm_layer("decoder", x) + + if self.create_ilm_decoder: + x = target_embed + for i in range(1, self.num_layers + 1): + x = self._create_ilm_decoder_block(subnet_unit, x, i) + subnet_unit.add_layer_norm_layer("prior_decoder", x) + + subnet_unit.add_softmax_layer( + "prior_output_prob", + "prior_decoder", + loss="ce", + loss_opts={"label_smoothing": self.label_smoothing}, + target=self.target, + dropout=self.softmax_dropout, + forward_weights_init=self.ff_init, + l2=self.l2, + ) + + dec_output = self.network.add_subnet_rec_layer("output", unit=subnet_unit.get_net(), target=self.target) + + return dec_output + + def create_network(self): + dec_output = self._create_decoder(self.subnet_unit) + + # recurrent subnetwork + decision_layer_name = self.base_model.network.add_decide_layer("decision", dec_output, target=self.target) + self.decision_layer_name = decision_layer_name + + return dec_output From e7d6f351e3d2e2c35cf29d5ca785de418975f289 Mon Sep 17 00:00:00 2001 From: Judyxujj Date: Wed, 15 May 2024 23:25:24 +0800 Subject: [PATCH 006/227] Jing tedlium independent softmax (#220) * tedlium ctc pytorch * rm empty files --------- Co-authored-by: Jingjing Xu --- users/jxu/corpus/__init__.py | 0 users/jxu/corpus/general/__init__.py | 4 + .../jxu/corpus/general/corpus_preparation.py | 77 ++++++ users/jxu/corpus/general/experiment_data.py | 43 ++++ users/jxu/corpus/general/hdf.py | 216 +++++++++++++++++ users/jxu/corpus/general/helpers.py | 37 +++ users/jxu/corpus/tedlium2/__init__.py | 0 users/jxu/corpus/tedlium2/data.py | 136 +++++++++++ users/jxu/corpus/tedlium2/lm_data.py | 13 + .../baseline/config_01_ctc_torch_conformer.py | 2 +- .../conformer_baseline_with_log_mel.py | 135 +++++++++++ .../ctc/tedlium2/configs/configs_helper.py | 93 ++++++++ .../experiments/ctc/tedlium2/data/ctc_data.py | 155 ++++++++++++ .../baseline/conformer_size_384_log_mel.py | 224 ++++++++++++++++++ .../utils/dump_log_prob_forward_callback.py | 152 ++++++++++++ 15 files changed, 1286 insertions(+), 1 deletion(-) create mode 100644 users/jxu/corpus/__init__.py create mode 100644 users/jxu/corpus/general/__init__.py create mode 100644 users/jxu/corpus/general/corpus_preparation.py create mode 100644 users/jxu/corpus/general/experiment_data.py create mode 100644 users/jxu/corpus/general/hdf.py create mode 100644 users/jxu/corpus/general/helpers.py create mode 100644 users/jxu/corpus/tedlium2/__init__.py create mode 100644 users/jxu/corpus/tedlium2/data.py create mode 100644 users/jxu/corpus/tedlium2/lm_data.py create mode 100644 users/jxu/experiments/ctc/tedlium2/configs/baseline/conformer_baseline_with_log_mel.py create mode 100644 users/jxu/experiments/ctc/tedlium2/configs/configs_helper.py create mode 100644 users/jxu/experiments/ctc/tedlium2/data/ctc_data.py create mode 100644 users/jxu/experiments/ctc/tedlium2/pytorch_networks/baseline/conformer_size_384_log_mel.py create mode 100644 users/jxu/experiments/ctc/tedlium2/utils/dump_log_prob_forward_callback.py diff --git a/users/jxu/corpus/__init__.py b/users/jxu/corpus/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/users/jxu/corpus/general/__init__.py b/users/jxu/corpus/general/__init__.py new file mode 100644 index 000000000..15ec5f2b1 --- /dev/null +++ b/users/jxu/corpus/general/__init__.py @@ -0,0 +1,4 @@ +from .corpus_preparation import * +from .experiment_data import * +from .hdf import * +from .helpers import * diff --git a/users/jxu/corpus/general/corpus_preparation.py b/users/jxu/corpus/general/corpus_preparation.py new file mode 100644 index 000000000..0153f5ada --- /dev/null +++ b/users/jxu/corpus/general/corpus_preparation.py @@ -0,0 +1,77 @@ +import re +from typing import List, Tuple, Optional + + +def clean_string(s: str, custom_subs: Optional[List[Tuple[str, str]]] = None) -> str: + for pattern, substitution in list( + { + r"[\!\"\%\,\/\:\;\?\{\}\&]": "", + "`": "'", + r"\.(\w)": r"\g<1>", + r"(\s|\A)\'": r"\g<1>", + r"(\s|\A)\(": r"\g<1>", + r"(\s|\A)\)": r"\g<1>", + r"\(\S*\)": "", + r"\[\S*\]": "", + "-HYPHEN": "HYPHEN", + "--DASH": "DASH", + r" *": "", + r" *": "", + r" *<.*> *": "", + r" *< *": "", + r" *> *": "", + r" *\* *": "", + r" *, *": "", + r" *\^ *": "", + r" *\\ *": "", + r" *\| *": "", + r" *~ *": "", + r" *\[.*\] *": "", + r" *\[ *": "", + r" *\] *": "", + r" *\. *": "", + r" *# *": "", + r"\$": "dollars", + r"(.)\1+": r"\1\1", + }.items() + ) + (custom_subs or []): + s = re.sub(pattern, substitution, s) + + s = " ".join(s.split()) + return s + + +def lm_cleaning(s: str): + from returnn.datasets.lm import english_cleaners + + remove_regexes = [ + re.compile(expr) + for expr in [ + r" *", + r" *", + r" *<.*> *", + r" *< *", + r" *> *", + r" *\* *", + r" *, *", + r" *\^ *", + r" *\\ *", + r" *\| *", + r" *~ *", + r" *\[.*\] *", + r" *\[ *", + r" *\] *", + r" *\. *", + r" *# *", + ] + ] + replace_regexes = [ + (re.compile(r"\$"), "dollars"), + (r"(.)\1+", r"\1\1"), + ] + sentence_clean = english_cleaners(s) + for expr in remove_regexes: + sentence_clean = re.sub(expr, "", sentence_clean) + for expr, repl in replace_regexes: + sentence_clean = re.sub(expr, repl, sentence_clean) + return sentence_clean diff --git a/users/jxu/corpus/general/experiment_data.py b/users/jxu/corpus/general/experiment_data.py new file mode 100644 index 000000000..1811e96f5 --- /dev/null +++ b/users/jxu/corpus/general/experiment_data.py @@ -0,0 +1,43 @@ +from dataclasses import dataclass, field +from typing import Dict, List +from i6_experiments.users.berger import helpers +from sisyphus import tk + + +@dataclass +class BasicSetupData: + train_key: str + dev_keys: List[str] + test_keys: List[str] + align_keys: List[str] + train_data_config: Dict + cv_data_config: Dict + data_inputs: Dict[str, helpers.RasrDataInput] + + +@dataclass +class CTCSetupData(BasicSetupData): + loss_corpus: tk.Path + loss_lexicon: tk.Path + + +@dataclass +class PytorchCTCSetupData(BasicSetupData): + pass + + +@dataclass +class HybridSetupData(BasicSetupData): + pass + + +@dataclass +class SMSHybridSetupData(BasicSetupData): + scoring_corpora: Dict[str, tk.Path] + python_prolog: Dict + num_classes: int + + +@dataclass +class ReturnnSearchSetupData(BasicSetupData): + forward_data_config: Dict[str, Dict] diff --git a/users/jxu/corpus/general/hdf.py b/users/jxu/corpus/general/hdf.py new file mode 100644 index 000000000..41df1e7e8 --- /dev/null +++ b/users/jxu/corpus/general/hdf.py @@ -0,0 +1,216 @@ +from typing import Optional, List +from i6_core.corpus import SegmentCorpusJob + +from i6_core.returnn.hdf import BlissToPcmHDFJob +from i6_experiments.users.berger.recipe.returnn.hdf import BlissCorpusToTargetHdfJob +from i6_experiments.users.berger.args.returnn.dataset import MetaDatasetBuilder, hdf_config_dict_for_files +from i6_experiments.users.berger.systems.dataclasses import AlignmentData, FeatureType +from sisyphus import tk +from i6_experiments.users.berger.args.jobs.rasr_init_args import ( + get_feature_extraction_args_16kHz, + get_feature_extraction_args_8kHz, +) +from i6_experiments.users.berger.helpers import build_rasr_feature_hdfs, RasrDataInput, SeparatedCorpusObject +from i6_experiments.users.berger.recipe.corpus.transform import ReplaceUnknownWordsJob + + +def build_feature_hdf_dataset_config( + data_inputs: List[RasrDataInput], + feature_type: FeatureType, + returnn_root: tk.Path, + returnn_python_exe: tk.Path, + rasr_binary_path: tk.Path, + rasr_arch: str = "linux-x86_64-standard", + dc_detection: bool = False, + single_hdf: bool = False, + extra_config: Optional[dict] = None, +) -> dict: + feature_hdfs = [] + + if feature_type in { + FeatureType.GAMMATONE_16K, + FeatureType.GAMMATONE_CACHED_16K, + FeatureType.GAMMATONE_8K, + FeatureType.GAMMATONE_CACHED_8K, + }: + if feature_type == FeatureType.GAMMATONE_16K or feature_type == FeatureType.GAMMATONE_CACHED_16K: + gt_args = get_feature_extraction_args_16kHz(dc_detection=dc_detection)["gt"] + elif feature_type == FeatureType.GAMMATONE_8K or feature_type == FeatureType.GAMMATONE_CACHED_8K: + gt_args = get_feature_extraction_args_8kHz(dc_detection=dc_detection)["gt"] + else: + raise NotImplementedError + + for data_input in data_inputs: + feature_hdfs += build_rasr_feature_hdfs( + data_input.corpus_object, + split=data_input.concurrent, + feature_type="gt", + feature_extraction_args=gt_args, + returnn_python_exe=returnn_python_exe, + returnn_root=returnn_root, + rasr_binary_path=rasr_binary_path, + rasr_arch=rasr_arch, + single_hdf=single_hdf, + ) + + elif feature_type == FeatureType.SAMPLES: + for data_input in data_inputs: + if single_hdf: + segment_files = [None] + else: + segment_files = list( + SegmentCorpusJob( + data_input.corpus_object.corpus_file, data_input.concurrent + ).out_single_segment_files.values() + ) + + for segment_file in segment_files: + feature_hdf_job = BlissToPcmHDFJob( + data_input.corpus_object.corpus_file, + segment_file=segment_file, + rounding=BlissToPcmHDFJob.RoundingScheme.rasr_compatible, + returnn_root=returnn_root, + ) + feature_hdf_job.rqmt["mem"] = 8 + feature_hdf_job.rqmt["time"] = 24 + feature_hdfs.append(feature_hdf_job.out_hdf) + else: + raise NotImplementedError + + return hdf_config_dict_for_files(files=feature_hdfs, extra_config=extra_config) + + +def build_feature_alignment_meta_dataset_config( + data_inputs: List[RasrDataInput], + feature_type: FeatureType, + alignments: List[AlignmentData], + returnn_root: tk.Path, + returnn_python_exe: tk.Path, + rasr_binary_path: tk.Path, + rasr_arch: str = "linux-x86_64-standard", + dc_detection: bool = False, + single_hdf: bool = False, + extra_config: Optional[dict] = None, +) -> dict: + feature_hdf_config = build_feature_hdf_dataset_config( + data_inputs=data_inputs, + feature_type=feature_type, + returnn_root=returnn_root, + returnn_python_exe=returnn_python_exe, + rasr_binary_path=rasr_binary_path, + rasr_arch=rasr_arch, + dc_detection=dc_detection, + single_hdf=single_hdf, + ) + + dataset_builder = MetaDatasetBuilder() + dataset_builder.add_dataset( + name="data", dataset_config=feature_hdf_config, key_mapping={"data": "data"}, control=False + ) + + alignment_hdf_files = [ + alignment.get_hdf(returnn_python_exe=returnn_python_exe, returnn_root=returnn_root) for alignment in alignments + ] + alignment_hdf_config = hdf_config_dict_for_files(files=alignment_hdf_files, extra_config=extra_config) + dataset_builder.add_dataset( + name="classes", dataset_config=alignment_hdf_config, key_mapping={"data": "classes"}, control=True + ) + return dataset_builder.get_dict() + + +def build_multi_speaker_feature_hdf_files( + data_inputs: List[RasrDataInput], + feature_type: FeatureType, + returnn_root: tk.Path, + returnn_python_exe: tk.Path, + rasr_binary_path: tk.Path, + rasr_arch: str = "linux-x86_64-standard", + dc_detection: bool = False, + single_hdf: bool = False, +) -> dict: + feature_hdfs = {} + + if feature_type in { + FeatureType.CONCAT_SEC_GAMMATONE_16K, + FeatureType.CONCAT_MIX_GAMMATONE_16K, + FeatureType.CONCAT_SEC_MIX_GAMMATONE_16K, + }: + gt_args = get_feature_extraction_args_16kHz(dc_detection=dc_detection)["gt"] + + feature_hdfs_prim = [] + feature_hdfs_sec = [] + feature_hdfs_mix = [] + + for data_input in data_inputs: + assert isinstance(data_input.corpus_object, SeparatedCorpusObject) + for hdfs_list, subobject in [ + (feature_hdfs_prim, data_input.corpus_object.get_primary_corpus_object()), + (feature_hdfs_sec, data_input.corpus_object.get_secondary_corpus_object()), + (feature_hdfs_mix, data_input.corpus_object.get_mix_corpus_object()), + ]: + hdfs_list += build_rasr_feature_hdfs( + subobject, + split=data_input.concurrent, + feature_type="gt", + feature_extraction_args=gt_args, + returnn_python_exe=returnn_python_exe, + returnn_root=returnn_root, + rasr_binary_path=rasr_binary_path, + rasr_arch=rasr_arch, + single_hdf=single_hdf, + ) + feature_hdfs["primary"] = feature_hdfs_prim + if feature_type in {FeatureType.CONCAT_SEC_GAMMATONE_16K, FeatureType.CONCAT_SEC_MIX_GAMMATONE_16K}: + feature_hdfs["secondary"] = feature_hdfs_sec + if feature_type in {FeatureType.CONCAT_MIX_GAMMATONE_16K, FeatureType.CONCAT_SEC_MIX_GAMMATONE_16K}: + feature_hdfs["mix"] = feature_hdfs_sec + else: + raise NotImplementedError + + return feature_hdfs + + +def build_feature_label_meta_dataset_config( + data_inputs: List[RasrDataInput], + feature_type: FeatureType, + lexicon: tk.Path, + label_dim: int, + returnn_root: tk.Path, + returnn_python_exe: tk.Path, + rasr_binary_path: tk.Path, + rasr_arch: str = "linux-x86_64-standard", + dc_detection: bool = False, + single_hdf: bool = False, + extra_config: Optional[dict] = None, +) -> dict: + feature_hdf_config = build_feature_hdf_dataset_config( + data_inputs=data_inputs, + feature_type=feature_type, + returnn_root=returnn_root, + returnn_python_exe=returnn_python_exe, + rasr_binary_path=rasr_binary_path, + rasr_arch=rasr_arch, + dc_detection=dc_detection, + single_hdf=single_hdf, + extra_config=extra_config, + ) + + dataset_builder = MetaDatasetBuilder() + dataset_builder.add_dataset( + name="data", dataset_config=feature_hdf_config, key_mapping={"data": "data"}, control=True + ) + + label_hdf_files = [ + BlissCorpusToTargetHdfJob( + ReplaceUnknownWordsJob(data_input.corpus_object.corpus_file, lexicon_file=lexicon).out_corpus_file, + bliss_lexicon=lexicon, + returnn_root=returnn_root, + dim=label_dim, + ).out_hdf + for data_input in data_inputs + ] + label_hdf_config = hdf_config_dict_for_files(files=label_hdf_files) + dataset_builder.add_dataset( + name="classes", dataset_config=label_hdf_config, key_mapping={"data": "classes"}, control=False + ) + return dataset_builder.get_dict() diff --git a/users/jxu/corpus/general/helpers.py b/users/jxu/corpus/general/helpers.py new file mode 100644 index 000000000..f4aabc02c --- /dev/null +++ b/users/jxu/corpus/general/helpers.py @@ -0,0 +1,37 @@ +from typing import Union +from sisyphus import tk +from i6_core.corpus import FilterCorpusRemoveUnknownWordSegmentsJob +from i6_experiments.users.berger.helpers import SeparatedCorpusObject, ScorableCorpusObject +from i6_core.meta.system import CorpusObject as metaCorpusObject +from i6_experiments.common.datasets.util import CorpusObject as i6CorpusObject + + +def filter_unk_in_corpus_object( + corpus_object: Union[metaCorpusObject, i6CorpusObject, ScorableCorpusObject, SeparatedCorpusObject], + lexicon: tk.Path, +) -> None: + if isinstance(corpus_object, (metaCorpusObject, i6CorpusObject, ScorableCorpusObject)): + assert corpus_object.corpus_file is not None + corpus_object.corpus_file = FilterCorpusRemoveUnknownWordSegmentsJob( + bliss_corpus=corpus_object.corpus_file, + bliss_lexicon=lexicon, + all_unknown=False, + ).out_corpus + elif isinstance(corpus_object, SeparatedCorpusObject): + corpus_object.primary_corpus_file = FilterCorpusRemoveUnknownWordSegmentsJob( + bliss_corpus=corpus_object.primary_corpus_file, + bliss_lexicon=lexicon, + all_unknown=False, + ).out_corpus + corpus_object.secondary_corpus_file = FilterCorpusRemoveUnknownWordSegmentsJob( + bliss_corpus=corpus_object.secondary_corpus_file, + bliss_lexicon=lexicon, + all_unknown=False, + ).out_corpus + corpus_object.mix_corpus_file = FilterCorpusRemoveUnknownWordSegmentsJob( + bliss_corpus=corpus_object.mix_corpus_file, + bliss_lexicon=lexicon, + all_unknown=False, + ).out_corpus + else: + raise NotImplementedError diff --git a/users/jxu/corpus/tedlium2/__init__.py b/users/jxu/corpus/tedlium2/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/users/jxu/corpus/tedlium2/data.py b/users/jxu/corpus/tedlium2/data.py new file mode 100644 index 000000000..445c927bc --- /dev/null +++ b/users/jxu/corpus/tedlium2/data.py @@ -0,0 +1,136 @@ +import copy +from sisyphus import tk +from typing import Dict, List, Optional, Tuple + +from i6_core.bpe.train import ReturnnTrainBpeJob +from i6_core.tools import CloneGitRepositoryJob +from i6_experiments.common.datasets.tedlium2.textual_data import get_text_data_dict +import i6_experiments.common.datasets.tedlium2.lexicon as tdl_lexicon +from i6_experiments.common.baselines.tedlium2.data import get_corpus_data_inputs +from i6_experiments.common.setups.rasr import util as rasr_util +from i6_experiments.users.berger import helpers +from i6_experiments.users.berger.recipe import lexicon +from i6_experiments.users.berger.corpus.general.helpers import filter_unk_in_corpus_object +from .lm_data import get_lm + + +def get_data_inputs( + train_key: str = "train", + cv_keys: Optional[List[str]] = None, + dev_keys: Optional[List[str]] = None, + test_keys: Optional[List[str]] = None, + lm_names: Optional[List[str]] = None, + add_unknown_phoneme_and_mapping: bool = False, + ctc_lexicon: bool = False, + filter_unk_from_corpus: bool = False, + use_augmented_lexicon: bool = True, + add_all_allophones: bool = False, +) -> Tuple[Dict[str, helpers.RasrDataInput], ...]: + if cv_keys is None: + cv_keys = ["dev"] + if dev_keys is None: + dev_keys = ["dev"] + if test_keys is None: + test_keys = ["test"] + if lm_names is None: + lm_names = ["4gram"] + + data_inputs = get_corpus_data_inputs(add_unknown_phoneme_and_mapping=add_unknown_phoneme_and_mapping) + + assert data_inputs["dev"]["dev"].lm + + lms = {key: get_lm(key) for key in lm_names} + + original_bliss_lexicon = tdl_lexicon.get_bliss_lexicon( + add_unknown_phoneme_and_mapping=add_unknown_phoneme_and_mapping + ) + + if use_augmented_lexicon: + bliss_lexicon = tdl_lexicon.get_g2p_augmented_bliss_lexicon( + add_unknown_phoneme_and_mapping=add_unknown_phoneme_and_mapping + ) + else: + bliss_lexicon = original_bliss_lexicon + + bliss_lexicon = lexicon.EnsureSilenceFirstJob(bliss_lexicon).out_lexicon + + if ctc_lexicon: + bliss_lexicon = lexicon.DeleteEmptyOrthJob(bliss_lexicon).out_lexicon + bliss_lexicon = lexicon.MakeBlankLexiconJob(bliss_lexicon).out_lexicon + + lexicon_config = helpers.LexiconConfig( + filename=bliss_lexicon, + normalize_pronunciation=False, + add_all_allophones=add_all_allophones, + add_allophones_from_lexicon=not add_all_allophones, + ) + + train_data_inputs = {} + cv_data_inputs = {} + dev_data_inputs = {} + test_data_inputs = {} + + train_corpus_object = data_inputs[train_key][train_key].corpus_object + if filter_unk_from_corpus: + train_corpus_object = copy.deepcopy(train_corpus_object) + filter_unk_in_corpus_object(train_corpus_object, bliss_lexicon) + + train_data_inputs[train_key] = helpers.RasrDataInput( + corpus_object=helpers.convert_legacy_corpus_object_to_scorable(train_corpus_object), + concurrent=data_inputs[train_key][train_key].concurrent, + lexicon=lexicon_config, + ) + + for cv_key in cv_keys: + cv_corpus_object = data_inputs[cv_key][cv_key].corpus_object + if filter_unk_from_corpus: + cv_corpus_object = copy.deepcopy(cv_corpus_object) + filter_unk_in_corpus_object(cv_corpus_object, bliss_lexicon) + cv_data_inputs[cv_key] = helpers.RasrDataInput( + corpus_object=helpers.convert_legacy_corpus_object_to_scorable(cv_corpus_object), + concurrent=data_inputs[cv_key][cv_key].concurrent, + lexicon=lexicon_config, + ) + + for dev_key in dev_keys: + for lm_name, lm in lms.items(): + dev_data_inputs[f"{dev_key}_{lm_name}"] = helpers.RasrDataInput( + corpus_object=helpers.convert_legacy_corpus_object_to_scorable( + data_inputs[dev_key][dev_key].corpus_object + ), + concurrent=data_inputs[dev_key][dev_key].concurrent, + lexicon=lexicon_config, + lm=lm, + ) + + for test_key in test_keys: + for lm_name, lm in lms.items(): + test_data_inputs[f"{test_key}_{lm_name}"] = helpers.RasrDataInput( + corpus_object=helpers.convert_legacy_corpus_object_to_scorable( + data_inputs[test_key][test_key].corpus_object + ), + concurrent=data_inputs[test_key][test_key].concurrent, + lexicon=lexicon_config, + lm=lm, + ) + + return train_data_inputs, cv_data_inputs, dev_data_inputs, test_data_inputs + + +def get_final_gmm_output(): + output_args = rasr_util.OutputArgs("final") + + for ck in ["train", "dev", "test"]: + output_args.define_corpus_type(ck, ck) + + output_args.add_feature_to_extract("gt") + + return output_args + + +def get_bpe(size: int, subword_nmt_repo: Optional[tk.Path] = None) -> ReturnnTrainBpeJob: + txt_file = get_text_data_dict()["background-data"] + if subword_nmt_repo is None: + subword_nmt_repo = CloneGitRepositoryJob("https://github.com/albertz/subword-nmt.git").out_repository + + return ReturnnTrainBpeJob(txt_file, size, subword_nmt_repo=subword_nmt_repo) diff --git a/users/jxu/corpus/tedlium2/lm_data.py b/users/jxu/corpus/tedlium2/lm_data.py new file mode 100644 index 000000000..6253f9830 --- /dev/null +++ b/users/jxu/corpus/tedlium2/lm_data.py @@ -0,0 +1,13 @@ +from i6_experiments.users.berger.helpers import rasr_lm_config +from i6_experiments.common.baselines.tedlium2.data import get_corpus_data_inputs + + +def get_lm(name: str) -> rasr_lm_config.LMData: + lm_dict = {} + + ted_4gram = get_corpus_data_inputs()["dev"]["dev"].lm + assert ted_4gram is not None + + lm_dict["4gram"] = rasr_lm_config.ArpaLMData(filename=ted_4gram["filename"], scale=ted_4gram.get("scale", 1.0)) + + return lm_dict[name] diff --git a/users/jxu/experiments/ctc/swb/configs/baseline/config_01_ctc_torch_conformer.py b/users/jxu/experiments/ctc/swb/configs/baseline/config_01_ctc_torch_conformer.py index fdbe2c492..d55b45da1 100644 --- a/users/jxu/experiments/ctc/swb/configs/baseline/config_01_ctc_torch_conformer.py +++ b/users/jxu/experiments/ctc/swb/configs/baseline/config_01_ctc_torch_conformer.py @@ -33,7 +33,7 @@ "/u/berger/repositories/rasr_versions/gen_seq2seq_dev/arch/linux-x86_64-standard", hash_overwrite="/u/berger/repositories/rasr_versions/gen_seq2seq_dev/arch/linux-x86_64-standard" ) -tools.returnn_root = tk.Path("/u/jxu/setups/tedlium2/2023-07-11--ctc-tedlium/tools/20240509_returnn/returnn", +tools.returnn_root = tk.Path("/u/jxu/setups/tedlium2/2023-07-11--ctc-tedlium2/tools/20240509_returnn/returnn", hash_overwrite="/u/berger/repositories/returnn") SCTK_BINARY_PATH = compile_sctk() # use last published version SCTK_BINARY_PATH.hash_overwrite = "LBS_DEFAULT_SCTK_BINARY_PATH" diff --git a/users/jxu/experiments/ctc/tedlium2/configs/baseline/conformer_baseline_with_log_mel.py b/users/jxu/experiments/ctc/tedlium2/configs/baseline/conformer_baseline_with_log_mel.py new file mode 100644 index 000000000..20281ceb7 --- /dev/null +++ b/users/jxu/experiments/ctc/tedlium2/configs/baseline/conformer_baseline_with_log_mel.py @@ -0,0 +1,135 @@ +import functools +from typing import Any, Dict, List, Optional, Union +import copy + +import numpy as np + +import i6_core.returnn as returnn +import i6_experiments.users.jxu.experiments.ctc.tedlium2.configs.configs_helper as configs_helper +from i6_experiments.users.berger.systems.dataclasses import ReturnnConfigs +from i6_experiments.common.setups.returnn_pytorch.serialization import Collection +from i6_experiments.users.berger.systems.dataclasses import ConfigVariant + +# ********** Constant values ********** + +num_outputs = 79 +num_subepochs = 250 + + +# ********** Settings ********** + +def get_returnn_config( + network: Optional[Dict] = None, + *, + target: Optional[str] = "classes", + num_inputs: Optional[int] = None, + num_outputs: Optional[int] = None, + python_prolog: Optional[Union[List, Dict]] = None, + extern_data_config: bool = False, + extra_python: Optional[List] = None, + extra_config: Optional[Dict] = None, + hash_full_python_code: bool = False, + **kwargs, +) -> returnn.ReturnnConfig: + python_prolog = python_prolog or ["import numpy as np"] + extra_python = extra_python or [] + config_dict: dict[str, Any] = {"target": target} + if num_inputs is not None: + config_dict["num_inputs"] = num_inputs + if num_outputs is not None: + config_dict["num_outputs"] = {target: num_outputs} + if extern_data_config: + config_dict.update( + configs_helper.get_extern_data_config(num_inputs=1, num_outputs=num_outputs, target=target, + **kwargs) + ) + config_dict.update(configs_helper.get_base_config()) + + if network: + config_dict.update({"network:": network}) + + lrate_config = configs_helper.get_oclr_config(**kwargs) + config_dict.update(lrate_config) + + config_dict.update(configs_helper.get_base_regularization_config(**kwargs)) + + if extra_config: + config_dict.update(extra_config) + + post_config_dict = {} + post_config_dict.update(configs_helper.get_base_post_config(**kwargs)) + + return returnn.ReturnnConfig( + config=config_dict, + post_config=post_config_dict, + hash_full_python_code=hash_full_python_code, + python_prolog=python_prolog, + python_epilog=extra_python, + pprint_kwargs={"sort_dicts": False}, + ) + +def get_serializer(model_config, variant: ConfigVariant, in_dim: int = 1) -> Collection: + from i6_experiments.users.jxu.experiments.ctc.tedlium2.pytorch_networks.baseline.conformer_size_384_log_mel import \ + get_train_serializer, get_recog_serializer, get_prior_serializer + if variant == ConfigVariant.TRAIN: + return get_train_serializer(model_config) + if variant == ConfigVariant.PRIOR: + return get_prior_serializer(model_config) + if variant == ConfigVariant.RECOG: + return get_recog_serializer(model_config) + raise NotImplementedError + +def returnn_config_generator(train_data_config: dict, dev_data_config: dict, peak_lr: float) -> dict: + from i6_experiments.users.jxu.experiments.ctc.tedlium2.pytorch_networks.baseline.conformer_size_384_log_mel import get_default_config_v1 + + extra_config = { + "train": train_data_config, + "dev": dev_data_config, + } + recog_extra_config = copy.deepcopy(extra_config) + recog_extra_config["model_outputs"] = {"classes": {"dim": num_outputs}} + + config_partial = functools.partial( + get_returnn_config, + num_epochs=num_subepochs, + num_inputs=50, + num_outputs=num_outputs, + target="targets", + extern_data_config=True, + grad_noise=0.0, + grad_clip=0.0, + cycle_epoch=110, + lr_1= peak_lr / 100, + lr_2 = peak_lr / 10, + peak_lr=peak_lr, + final_lr=1e-08, + batch_size=18000 * 160, + extra_config=extra_config, + ) + + def get_returnn_configs(train_config, recog_config): + return ReturnnConfigs( + train_config=config_partial( + extra_python=[get_serializer(train_config, ConfigVariant.TRAIN)], + extra_config=extra_config), + prior_config=config_partial(extra_python=[get_serializer(recog_config, ConfigVariant.PRIOR)], + extra_config=extra_config), + recog_configs={ + "recog": config_partial(extra_python=[get_serializer(recog_config, ConfigVariant.RECOG)], + extra_config=recog_extra_config)}, + ) + + experiments = {} + network_args = {"specaug_args": {"time_min_num_masks": 2, + "time_max_mask_per_n_frames": 25, + "time_mask_max_size": 20, + "freq_min_num_masks": 2, + "freq_mask_max_size": 5, + "freq_max_num_masks": 16}, "final_dropout": 0.2, "att_weights_dropout": 0.2} + + config = get_default_config_v1(num_inputs=80, num_outputs=num_outputs, + network_args=network_args) + num_layers_12_experiment_name = f"conformer_logmel_{peak_lr}" + experiments[num_layers_12_experiment_name] = get_returnn_configs(config, config) + + return experiments \ No newline at end of file diff --git a/users/jxu/experiments/ctc/tedlium2/configs/configs_helper.py b/users/jxu/experiments/ctc/tedlium2/configs/configs_helper.py new file mode 100644 index 000000000..f1a6e5d04 --- /dev/null +++ b/users/jxu/experiments/ctc/tedlium2/configs/configs_helper.py @@ -0,0 +1,93 @@ +from typing import Any, Dict, List, Optional, Union +import numpy as np + +def get_base_config() -> Dict[str, Any]: + result = { + # "debug_print_layer_output_template": True, + "log_batch_size": True, + "tf_log_memory_usage": True, + "cache_size": "0", + "batching": "random", + "window": 1, + "update_on_device": True, + "backend": "torch", + "optimizer": {"class": "adamw", "epsilon": 1e-16, "weight_decay": 1e-3} + } + + return result + + +def get_extern_data_config( + num_inputs: Optional[int], + num_outputs: Optional[int], + extern_data_kwargs: Dict = {}, + extern_target_kwargs: Dict = {}, + target: Optional[str] = "classes", + **kwargs, +) -> Dict[str, Any]: + result = {} + if num_inputs is not None: + result["data"] = {"dim": num_inputs, **extern_data_kwargs} + if num_outputs is not None and target is not None: + result[target] = {"dim": num_outputs, "sparse": True, **extern_target_kwargs} + return {"extern_data": result} + + +def get_base_regularization_config( + batch_size: int = 10000, + max_seqs: int = 128, + accum_grad: int = 1, + grad_noise: Optional[float] = 0.1, + grad_clip: Optional[float] = None, + grad_clip_global_norm: Optional[float] = None, + **kwargs, +) -> Dict[str, Any]: + result = {"batch_size": batch_size, "max_seqs": max_seqs} + if grad_noise is not None: + result["gradient_noise"] = grad_noise + if grad_clip is not None: + result["gradient_clip"] = grad_clip + if grad_clip_global_norm is not None: + result["gradient_clip_global_norm"] = grad_clip_global_norm + if accum_grad > 1: + result["accum_grad_multiple_step"] = accum_grad + return result + + +def get_base_post_config(keep_last_n: Optional[int] = None, keep_best_n: Optional[int] = None, keep: Optional[List[int]] = None, **kwargs) -> Dict[str, Any]: + if keep_last_n is None and keep_best_n is None and keep is None: + post_config = {"cleanup_old_models": True} + else: + cleanup_opts = {} + if keep_last_n is not None: + cleanup_opts["keep_last_n"] = keep_last_n + if keep_best_n is not None: + cleanup_opts["keep_best_n"] = keep_best_n + if keep is not None: + cleanup_opts["keep"] = keep + post_config = {"cleanup_old_models": cleanup_opts} + return post_config + + +def get_oclr_config( + num_epochs: int, + peak_lr: float = 1e-03, + cycle_epoch: Optional[int] = None, + lr_1: Optional[float] = None, + lr_2: Optional[float] = None, + final_lr: Optional[float] = None, + **kwargs, +) -> dict: + lr_1 = lr_1 or peak_lr / 10 + lr_2 = lr_2 or peak_lr / 10 + final_lr = final_lr or lr_1 / 5 + cycle_epoch = cycle_epoch or (num_epochs * 9) // 20 # 45% of the training + lr_list = ( + list(np.linspace(lr_1, peak_lr, cycle_epoch, endpoint=False)) + + list(np.linspace(peak_lr, lr_2, cycle_epoch, endpoint=False)) + + list(np.linspace(lr_2, final_lr, num_epochs - 2 * cycle_epoch)) + ) + + return { + "learning_rates": lr_list, + } \ No newline at end of file diff --git a/users/jxu/experiments/ctc/tedlium2/data/ctc_data.py b/users/jxu/experiments/ctc/tedlium2/data/ctc_data.py new file mode 100644 index 000000000..447517e77 --- /dev/null +++ b/users/jxu/experiments/ctc/tedlium2/data/ctc_data.py @@ -0,0 +1,155 @@ +import copy +from i6_core import corpus +from i6_core.lexicon.modification import AddEowPhonemesToLexiconJob +from i6_core.returnn.hdf import BlissToPcmHDFJob +from i6_experiments.users.berger.args.jobs.rasr_init_args import ( + get_feature_extraction_args_16kHz, +) +from i6_experiments.users.berger.args.returnn.dataset import MetaDatasetBuilder, hdf_config_dict_for_files +from i6_experiments.users.berger.corpus.general.experiment_data import ( + CTCSetupData, + PytorchCTCSetupData, +) +from i6_experiments.users.berger.helpers.hdf import build_rasr_feature_hdfs +from i6_experiments.users.berger.recipe.returnn.hdf import BlissCorpusToTargetHdfJob +from i6_experiments.users.berger.systems.dataclasses import FeatureType +from i6_experiments.users.jxu.corpus.tedlium2 import data +from sisyphus import tk + + +def get_tedlium2_pytorch_data( + returnn_root: tk.Path, + returnn_python_exe: tk.Path, + rasr_binary_path: tk.Path, + rasr_arch: str = "linux-x86_64-standard", + add_unknown: bool = False, + augmented_lexicon: bool = True, + feature_type: FeatureType = FeatureType.GAMMATONE_16K, +) -> PytorchCTCSetupData: + # ********** Data inputs ********** + train_data_inputs, cv_data_inputs, dev_data_inputs, test_data_inputs = copy.deepcopy( + data.get_data_inputs( + ctc_lexicon=True, + use_augmented_lexicon=augmented_lexicon, + add_all_allophones=True, + add_unknown_phoneme_and_mapping=add_unknown, + ) + ) + + # ********** Train data ********** + train_corpus_object = train_data_inputs["train"].corpus_object + eow_lexicon = AddEowPhonemesToLexiconJob(train_data_inputs["train"].lexicon.filename).out_lexicon + assert train_corpus_object.corpus_file is not None + + if not add_unknown and not augmented_lexicon: + train_corpus_object.corpus_file = corpus.FilterCorpusRemoveUnknownWordSegmentsJob( + train_corpus_object.corpus_file, + eow_lexicon, + all_unknown=False, + ).out_corpus + + train_dataset_builder = MetaDatasetBuilder() + if feature_type == FeatureType.GAMMATONE_16K: + gt_args = get_feature_extraction_args_16kHz()["gt"] + train_feature_hdf = build_rasr_feature_hdfs( + train_corpus_object, + split=train_data_inputs["train"].concurrent, + feature_type="gt", + feature_extraction_args=gt_args, + returnn_python_exe=returnn_python_exe, + returnn_root=returnn_root, + rasr_binary_path=rasr_binary_path, + rasr_arch=rasr_arch, + ) + elif feature_type == FeatureType.SAMPLES: + train_feature_hdf = BlissToPcmHDFJob(train_corpus_object.corpus_file, returnn_root=returnn_root).out_hdf + else: + raise NotImplementedError + + train_dataset_builder.add_dataset( + dataset_config=hdf_config_dict_for_files([train_feature_hdf]), + name="features", + key_mapping={"data": "data"}, + ) + + train_targets_hdf = BlissCorpusToTargetHdfJob( + train_corpus_object.corpus_file, + bliss_lexicon=eow_lexicon, + returnn_root=returnn_root, + ).out_hdf + train_dataset_builder.add_dataset( + dataset_config=hdf_config_dict_for_files([train_targets_hdf], {"partition_epoch": 5, "seq_ordering":"laplace:.1000"}), + name="targets", + key_mapping={"data": "targets"}, + control=True, + ) + + train_data_config = train_dataset_builder.get_dict() + + # ********** CV data ********** + cv_corpus_object = copy.deepcopy(dev_data_inputs["dev_4gram"].corpus_object) + + if not add_unknown: + cv_corpus_object.corpus_file = corpus.FilterCorpusRemoveUnknownWordSegmentsJob( + cv_corpus_object.corpus_file, + eow_lexicon, + all_unknown=False, + ).out_corpus + + cv_dataset_builder = MetaDatasetBuilder() + + if feature_type == FeatureType.GAMMATONE_16K: + gt_args = get_feature_extraction_args_16kHz()["gt"] + cv_feature_hdf = build_rasr_feature_hdfs( + cv_corpus_object, + split=1, + feature_type="gt", + feature_extraction_args=gt_args, + returnn_python_exe=returnn_python_exe, + returnn_root=returnn_root, + rasr_binary_path=rasr_binary_path, + rasr_arch=rasr_arch, + ) + elif feature_type == FeatureType.SAMPLES: + cv_feature_hdf = BlissToPcmHDFJob(cv_corpus_object.corpus_file, returnn_root=returnn_root).out_hdf + else: + raise NotImplementedError + + cv_dataset_builder.add_dataset( + dataset_config=hdf_config_dict_for_files([cv_feature_hdf]), + name="features", + key_mapping={"data": "data"}, + ) + + cv_targets_hdf = BlissCorpusToTargetHdfJob( + cv_corpus_object.corpus_file, + bliss_lexicon=eow_lexicon, + returnn_root=returnn_root, + ).out_hdf + cv_dataset_builder.add_dataset( + dataset_config=hdf_config_dict_for_files([cv_targets_hdf], {"partition_epoch": 1, "seq_ordering": "sorted"}), + name="targets", + key_mapping={"data": "targets"}, + control=True, + ) + + cv_data_config = cv_dataset_builder.get_dict() + + # ********** Recog lexicon ********** + + for rasr_input in {**dev_data_inputs, **test_data_inputs}.values(): + rasr_input.lexicon.filename = eow_lexicon + + return PytorchCTCSetupData( + train_key="train", + dev_keys=["dev_4gram"], + test_keys=["test_4gram"], + align_keys=["train", "dev"], + train_data_config=train_data_config, + cv_data_config=cv_data_config, + data_inputs={ + **train_data_inputs, + **dev_data_inputs, + **test_data_inputs, + }, + ) diff --git a/users/jxu/experiments/ctc/tedlium2/pytorch_networks/baseline/conformer_size_384_log_mel.py b/users/jxu/experiments/ctc/tedlium2/pytorch_networks/baseline/conformer_size_384_log_mel.py new file mode 100644 index 000000000..1b44b4463 --- /dev/null +++ b/users/jxu/experiments/ctc/tedlium2/pytorch_networks/baseline/conformer_size_384_log_mel.py @@ -0,0 +1,224 @@ +from dataclasses import dataclass +from typing import Optional +from i6_experiments.users.berger.systems.dataclasses import ConfigVariant + +import torch +from torch import nn + +from i6_models.parts.frontend.vgg_act import VGG4LayerActFrontendV1, VGG4LayerActFrontendV1Config +from i6_models.parts.conformer.convolution import ConformerConvolutionV1Config, ConformerConvolutionV1 +from i6_models.parts.conformer.mhsa import ConformerMHSAV1Config, ConformerMHSAV1 +from i6_models.parts.conformer.feedforward import ConformerPositionwiseFeedForwardV1Config, \ + ConformerPositionwiseFeedForwardV1 +from i6_experiments.users.berger.pytorch.models.util import lengths_to_padding_mask +from i6_experiments.common.setups.serialization import Import +from i6_experiments.common.setups.returnn_pytorch.serialization import Collection +from i6_experiments.users.berger.pytorch.serializers.basic import ( + get_basic_pt_network_serializer, +) +from i6_models.assemblies.conformer.conformer_v2 import ConformerBlockV2Config, ConformerEncoderV2Config, ConformerBlockV2, ConformerEncoderV2 +from i6_models.primitives.specaugment import specaugment_v1_by_length +from i6_models.primitives.feature_extraction import LogMelFeatureExtractionV1, LogMelFeatureExtractionV1Config +from i6_models.config import ModelConfiguration, ModuleFactoryV1 + + +@dataclass +class ConformerCTCConfig(ModelConfiguration): + feature_extraction_cfg: LogMelFeatureExtractionV1Config + specaug_args: dict + conformer_cfg: ConformerEncoderV2Config + final_dropout: float + target_size: int + + +class ConformerCTCModel(torch.nn.Module): + def __init__(self, step: int, cfg: ConformerCTCConfig, **kwargs): + super().__init__() + self.logmel_feat_extraction = LogMelFeatureExtractionV1(cfg=cfg.feature_extraction_cfg) + self.specaug_args = cfg.specaug_args + self.conformer = ConformerEncoderV2(cfg.conformer_cfg) + self.final_linear = torch.nn.Linear(cfg.conformer_cfg.block_cfg.ff_cfg.input_dim, cfg.target_size) + self.final_dropout = nn.Dropout(p=cfg.final_dropout) + self.export_mode = False + + def forward( + self, + audio_features: torch.Tensor, + audio_features_len: Optional[torch.Tensor] = None, + ): + with torch.no_grad(): + squeezed_features = torch.squeeze(audio_features) + if self.export_mode: + squeezed_features = squeezed_features.type(torch.FloatTensor) + else: + squeezed_features = squeezed_features.type(torch.cuda.FloatTensor) + + audio_features, audio_features_len = self.logmel_feat_extraction(squeezed_features, audio_features_len) + + if self.training: + x = specaugment_v1_by_length(audio_features,**self.specaug_args) # [B, T, F] + else: + x = audio_features + # sequence_mask = None if self.export_mode else lengths_to_padding_mask(audio_features_len) + sequence_mask = lengths_to_padding_mask(audio_features_len) + # sequence_mask = lengths_to_padding_mask((audio_features_len + 2) // 3) + x, sequence_mask = self.conformer(x, sequence_mask) # [B, T, F] + x = self.final_dropout(x) + logits = self.final_linear(x) # [B, T, F] + log_probs = torch.log_softmax(logits, dim=2) + + if self.training: + return log_probs, sequence_mask + return log_probs + + +def get_default_config_v1(num_inputs: int, num_outputs: int, network_args: dict) -> ConformerCTCConfig: + dropout = 0.2 if "dropout" not in network_args else network_args["dropout"] + num_att_heads = 6 if "num_att_heads" not in network_args else network_args["num_att_heads"] + att_weights_dropout = 0.1 if "att_weights_dropout" not in network_args else network_args["att_weights_dropout"] + num_layers = 12 if "num_layers" not in network_args else network_args["num_layers"] + kernel_size = 31 if "kernel_size" not in network_args else network_args["kernel_size"] + specaug_args = {"time_min_num_masks": 2, + "time_max_mask_per_n_frames": 25, + "time_mask_max_size": 20, + "freq_min_num_masks": 2, + "freq_mask_max_size": 5, + "freq_max_num_masks": 10} if "specaug_args" not in network_args else network_args["specaug_args"] + final_dropout = 0 if "final_dropout" not in network_args else network_args["final_dropout"] + + feature_extraction_cfg = LogMelFeatureExtractionV1Config( + sample_rate=16000, + win_size=0.025, + hop_size=0.01, + f_min=60, + f_max=7600, + min_amp=1e-10, + num_filters=80, + center=False, + ) + + frontend_cfg = VGG4LayerActFrontendV1Config( + in_features=num_inputs, + conv1_channels=32, + conv2_channels=64, + conv3_channels=64, + conv4_channels=32, + conv_kernel_size=(3, 3), + conv_padding=None, + pool1_kernel_size=(2, 1), + pool1_stride=(2, 1), + pool1_padding=None, + pool2_kernel_size=(2, 1), + pool2_stride=(2, 1), + pool2_padding=None, + activation=torch.nn.ReLU(), + out_features=384, + ) + + frontend = ModuleFactoryV1(VGG4LayerActFrontendV1, frontend_cfg) + + ff_cfg = ConformerPositionwiseFeedForwardV1Config( + input_dim=384, + hidden_dim=1536, + dropout=dropout, + activation=torch.nn.SiLU(), + ) + + mhsa_cfg = ConformerMHSAV1Config( + input_dim=384, + num_att_heads=num_att_heads, + att_weights_dropout=att_weights_dropout, + dropout=dropout, + ) + + conv_cfg = ConformerConvolutionV1Config( + channels=384, + kernel_size=kernel_size, + dropout=dropout, + activation=torch.nn.SiLU(), + norm=torch.nn.LayerNorm(384), + ) + + block_cfg = ConformerBlockV2Config( + ff_cfg=ff_cfg, + mhsa_cfg=mhsa_cfg, + conv_cfg=conv_cfg, + modules=["ff", "conv", "mhsa", "ff"], + ) + + conformer_cfg = ConformerEncoderV2Config( + num_layers=num_layers, + frontend=frontend, + block_cfg=block_cfg, + ) + + return ConformerCTCConfig( + feature_extraction_cfg=feature_extraction_cfg, + specaug_args=specaug_args, + conformer_cfg=conformer_cfg, + target_size=num_outputs, + final_dropout=final_dropout + ) + + +def export(*, model: torch.nn.Module, model_filename: str): + dummy_data = torch.randn(1, 30 * 160, 1, device="cpu") + dummy_data_len = torch.ones((1,), dtype=torch.int32) * 30 * 160 + + model.export_mode = True + torch.onnx.export( + model=model.eval(), + args=(dummy_data, dummy_data_len), + f=model_filename, + verbose=True, + input_names=["data", "data_len"], + output_names=["classes"], + opset_version=17, + dynamic_axes={ + # dict value: manually named axes + "data": {0: "batch", 1: "time"}, + "data_len": {0: "batch"}, + "targets": {0: "batch", 1: "time"}, + }, + ) + + +def get_recog_serializer( + model_config: ConformerCTCConfig, +) -> Collection: + return get_basic_pt_network_serializer( + module_import_path=f"{__name__}.ConformerCTCModel", + model_config=model_config, + additional_serializer_objects=[ + Import(f"{__name__}.export"), + ], + ) + + +def get_prior_serializer( + model_config: ConformerCTCConfig, +) -> Collection: + berger_pytorch_package = "i6_experiments.users.berger.pytorch" + return get_basic_pt_network_serializer( + module_import_path=f"{__name__}.ConformerCTCModel", + model_config=model_config, + additional_serializer_objects=[ + Import(f"{berger_pytorch_package}.forward.basic.forward_step"), + Import(f"{berger_pytorch_package}.forward.prior_callback.ComputePriorCallback", + import_as="forward_callback"), + ], + ) + + +def get_train_serializer( + model_config: ConformerCTCConfig, +) -> Collection: + # pytorch_package = __package__.rpartition(".")[0] + pytorch_package = "i6_experiments.users.berger.pytorch" + return get_basic_pt_network_serializer( + module_import_path=f"{__name__}.{ConformerCTCModel.__name__}", + model_config=model_config, + additional_serializer_objects=[ + Import(f"{__name__}.train_step"), + ], + ) \ No newline at end of file diff --git a/users/jxu/experiments/ctc/tedlium2/utils/dump_log_prob_forward_callback.py b/users/jxu/experiments/ctc/tedlium2/utils/dump_log_prob_forward_callback.py new file mode 100644 index 000000000..407a05ec2 --- /dev/null +++ b/users/jxu/experiments/ctc/tedlium2/utils/dump_log_prob_forward_callback.py @@ -0,0 +1,152 @@ +import copy +import os +import subprocess as sp +from typing import Optional, Union + +import numpy +import numpy as np +import torch +import h5py + +from returnn.forward_iface import ForwardCallbackIface +from returnn.tensor.tensor_dict import TensorDict +from sisyphus import Job, Task, tk + +from i6_core import util +from i6_core.returnn.config import ReturnnConfig +from i6_core.returnn.training import Checkpoint, PtCheckpoint + + + +class DumpLogProbCallback(ForwardCallbackIface): + def init(self, *, model: torch.nn.Module): + self.n = 1 + self.inputs = [] + self.seqLengths = [] + self.seqTags = [] + + def process_seq(self, *, seq_tag: str, outputs: TensorDict): + log_prob_tensor = outputs["log_probs"].raw_tensor + assert log_prob_tensor is not None + self.inputs.extend(list(log_prob_tensor.cpu().numpy())) + self.seqLengths.extend([[len(list(log_prob_tensor.cpu().numpy())), 0]]) + self.seqTags.extend([seq_tag]) + + + def finish(self): + with h5py.File("../output/log_probs.hdf", 'w') as hf: + hf.create_dataset('inputs', data=np.array(self.inputs)) + hf.create_dataset('seqLengths', data=np.array(self.seqLengths)) + utf8_type = h5py.string_dtype('utf-8', 100) + asciiList = numpy.array([n.encode("utf-8") for n in self.seqTags], dtype=utf8_type) + hf.create_dataset('seqTags', data=asciiList) + + + +class ReturnnForwardComputePriorJob(Job): + def __init__( + self, + model_checkpoint: Optional[Union[Checkpoint, PtCheckpoint]], + returnn_config: ReturnnConfig, + returnn_python_exe: tk.Path, + returnn_root: tk.Path, + *, # args below are keyword only + log_verbosity: int = 5, + device: str = "gpu", + time_rqmt: float = 4, + mem_rqmt: float = 4, + cpu_rqmt: int = 2, + ): + self.returnn_config = returnn_config + self.model_checkpoint = model_checkpoint + self.returnn_python_exe = returnn_python_exe + self.returnn_root = returnn_root + self.log_verbosity = log_verbosity + self.device = device + + self.out_returnn_config_file = self.output_path("returnn.config") + + self.out_log_prob = self.output_path("log_probs.hdf") + + self.rqmt = { + "gpu": 1 if device == "gpu" else 0, + "cpu": cpu_rqmt, + "mem": mem_rqmt, + "time": time_rqmt, + } + + def tasks(self): + yield Task("create_files", mini_task=True) + yield Task("run", resume="run", rqmt=self.rqmt) + + def create_files(self): + config = self.create_returnn_config( + model_checkpoint=self.model_checkpoint, + returnn_config=self.returnn_config, + log_verbosity=self.log_verbosity, + device=self.device, + ) + config.write(self.out_returnn_config_file.get_path()) + + cmd = [ + self.returnn_python_exe.get_path(), + os.path.join(self.returnn_root.get_path(), "rnn.py"), + self.out_returnn_config_file.get_path(), + ] + util.create_executable("rnn.sh", cmd) + + # check here if model actually exists + if self.model_checkpoint is not None: + assert self.model_checkpoint.exists(), "Provided model does not exists: %s" % str(self.model_checkpoint) + + def run(self): + sp.check_call( + [ + self.returnn_python_exe.get_path(), + self.returnn_root.join_right("rnn.py").get_path(), + self.out_returnn_config_file.get_path(), + ] + ) + + @classmethod + def create_returnn_config( + cls, + model_checkpoint: Optional[Union[Checkpoint, PtCheckpoint]], + returnn_config: ReturnnConfig, + log_verbosity: int, + device: str, + **kwargs, + ): + assert device in ["gpu", "cpu"] + assert "task" not in returnn_config.config + assert "load" not in returnn_config.config + assert "model" not in returnn_config.config + + res = copy.deepcopy(returnn_config) + + config = {"load": model_checkpoint, "task": "forward", "forward_data": "train"} + + post_config = { + "device": device, + "log": ["./returnn.log"], + "log_verbosity": log_verbosity, + } + + config.update(returnn_config.config) + post_config.update(returnn_config.post_config) + + res.config = config + res.post_config = post_config + res.check_consistency() + + return res + + @classmethod + def hash(cls, kwargs): + d = { + "returnn_config": ReturnnForwardComputePriorJob.create_returnn_config(**kwargs), + "returnn_python_exe": kwargs["returnn_python_exe"], + "returnn_root": kwargs["returnn_root"], + } + + return super().hash(d) From 2042ccaad8c3759d433e0fafa0673157cd47ccf2 Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Wed, 15 May 2024 15:36:06 +0000 Subject: [PATCH 007/227] use ff regs for mhsa out --- users/zeineldeen/models/asr/encoder/conformer_encoder_v2.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/users/zeineldeen/models/asr/encoder/conformer_encoder_v2.py b/users/zeineldeen/models/asr/encoder/conformer_encoder_v2.py index 110b74553..bef0dad64 100644 --- a/users/zeineldeen/models/asr/encoder/conformer_encoder_v2.py +++ b/users/zeineldeen/models/asr/encoder/conformer_encoder_v2.py @@ -898,9 +898,9 @@ def _create_mhsa_module(self, prefix_name, source, layer_index): l2=self.l2, forward_weights_init=self.mhsa_out_init, with_bias=False, - param_dropout=self.mhsa_weight_drop, + param_dropout=self.ff_weight_drop, param_dropout_min_ndim=2, - param_variational_noise=self.mhsa_weight_noise, + param_variational_noise=self.ff_weight_noise, ) drop = self.network.add_dropout_layer("{}_dropout".format(prefix_name), mhsa_linear, dropout=self.dropout) From 0ab509fe7dc0208b4f700e35abd5216df7f096c7 Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Wed, 15 May 2024 15:40:13 +0000 Subject: [PATCH 008/227] add more regularized trafo dec --- .../asr/decoder/transformer_decoder_v2.py | 414 ++++++++++++++++++ 1 file changed, 414 insertions(+) create mode 100644 users/zeineldeen/models/asr/decoder/transformer_decoder_v2.py diff --git a/users/zeineldeen/models/asr/decoder/transformer_decoder_v2.py b/users/zeineldeen/models/asr/decoder/transformer_decoder_v2.py new file mode 100644 index 000000000..30d8624f2 --- /dev/null +++ b/users/zeineldeen/models/asr/decoder/transformer_decoder_v2.py @@ -0,0 +1,414 @@ +from i6_experiments.users.zeineldeen.modules.network import ReturnnNetwork + + +class TransformerDecoder: + """ + Represents standard Transformer decoder + + * Attention Is All You Need + * Ref: https://arxiv.org/abs/1706.03762 + """ + + def __init__( + self, + base_model, + target="bpe", + num_layers=6, + beam_size=12, + ff_init=None, + ff_dim=2048, + ff_act="relu", + att_num_heads=8, + dropout=0.1, + att_dropout=0.0, + softmax_dropout=0.0, + embed_dropout=0.1, + l2=0.0, + self_att_l2=0.0, + embed_pos_enc=False, + apply_embed_weight=False, + label_smoothing=0.1, + mhsa_init=None, + mhsa_out_init=None, + pos_enc=None, + rel_pos_clipping=16, + length_normalization=True, + replace_cross_att_w_masked_self_att=False, + create_ilm_decoder=False, + ilm_type=None, + ilm_args=None, + ff_weight_noise=None, + mhsa_weight_noise=None, + ff_weight_dropout=None, + mhsa_weight_dropout=None, + ): + self.base_model = base_model + self.enc_value_dim = base_model.enc_value_dim + self.enc_key_dim = base_model.enc_key_dim + self.enc_att_num_heads = base_model.att_num_heads + self.enc_key_per_head_dim = base_model.enc_key_per_head_dim + self.enc_val_per_head_dim = base_model.enc_val_per_head_dim + + self.att_num_heads = att_num_heads + + self.target = target + self.num_layers = num_layers + self.beam_size = beam_size + + self.ff_init = ff_init + self.ff_dim = ff_dim + self.ff_act = ff_act + + self.mhsa_init = mhsa_init + self.mhsa_init_out = mhsa_out_init + + self.pos_enc = pos_enc + self.rel_pos_clipping = rel_pos_clipping + + self.dropout = dropout + self.softmax_dropout = softmax_dropout + self.att_dropout = att_dropout + self.label_smoothing = label_smoothing + + self.l2 = l2 + self.self_att_l2 = self_att_l2 + + self.embed_dropout = embed_dropout + self.embed_pos_enc = embed_pos_enc + + self.embed_weight = None + + if apply_embed_weight: + self.embed_weight = self.enc_value_dim**0.5 + + self.decision_layer_name = None + + self.length_normalization = length_normalization + + self.replace_cross_att_w_masked_self_att = replace_cross_att_w_masked_self_att # used to train ILM + + self.ff_weight_drop = ff_weight_dropout + self.mhsa_weight_drop = mhsa_weight_dropout + self.ff_weight_noise = ff_weight_noise + self.mhsa_weight_noise = mhsa_weight_noise + + # used for recognition with ILM + self.create_ilm_decoder = create_ilm_decoder + self.ilm_type = ilm_type + self.ilm_args = ilm_args or {} + if self.create_ilm_decoder: + self.replace_cross_att_w_masked_self_att = False # keep original decoder as-is + + self.network = ReturnnNetwork() + self.subnet_unit = ReturnnNetwork() + self.output_prob = None + + def _create_masked_mhsa(self, subnet_unit: ReturnnNetwork, prefix, source, **kwargs): + prefix = "{}_self_att".format(prefix) + + # for tuning mini-self-att ILM + att_num_heads = kwargs.get("att_num_heads", self.att_num_heads) + enc_key_dim = kwargs.get("enc_key_dim", self.enc_key_dim) + enc_key_per_head_dim = enc_key_dim // att_num_heads + + ln = subnet_unit.add_layer_norm_layer("{}_ln".format(prefix), source) + + ln_rel_pos_enc = None + if self.pos_enc == "rel": + ln_rel_pos_enc = self.subnet_unit.add_relative_pos_encoding_layer( + "{}_ln_rel_pos_enc".format(prefix), + ln, + n_out=enc_key_per_head_dim, + forward_weights_init=self.ff_init, + clipping=self.rel_pos_clipping, + ) + + att = subnet_unit.add_self_att_layer( + "{}_att".format(prefix), + ln, + num_heads=att_num_heads, + total_key_dim=enc_key_dim, + n_out=self.enc_value_dim, + attention_left_only=True, + att_dropout=self.att_dropout, + forward_weights_init=self.mhsa_init, + l2=self.self_att_l2, + key_shift=ln_rel_pos_enc if ln_rel_pos_enc is not None else None, + param_dropout=self.mhsa_weight_drop, + param_dropout_min_ndim=2, + param_variational_noise=self.mhsa_weight_noise, + ) + + linear = subnet_unit.add_linear_layer( + "{}_linear".format(prefix), + att, + activation=None, + with_bias=False, + n_out=self.enc_value_dim, + forward_weights_init=self.mhsa_init_out, + l2=self.l2, + param_dropout=self.ff_weight_drop, + param_dropout_min_ndim=2, + param_variational_noise=self.ff_weight_noise, + ) + + drop = subnet_unit.add_dropout_layer("{}_drop".format(prefix), linear, dropout=self.dropout) + + out = subnet_unit.add_combine_layer( + "{}_out".format(prefix), [drop, source], kind="add", n_out=self.enc_value_dim + ) + + return out + + def _create_mhsa(self, subnet_unit: ReturnnNetwork, prefix, source): + ln = subnet_unit.add_layer_norm_layer("{}_att_ln".format(prefix), source) + + att_query0 = subnet_unit.add_linear_layer( + "{}_att_query0".format(prefix), + ln, + with_bias=False, + n_out=self.enc_value_dim, + forward_weights_init=self.mhsa_init, + l2=self.self_att_l2, + param_dropout=self.mhsa_weight_drop, + param_dropout_min_ndim=2, + param_variational_noise=self.mhsa_weight_noise, + ) + + # (B, H, D/H) + att_query = subnet_unit.add_split_dim_layer( + "{}_att_query".format(prefix), + att_query0, + axis="F", + dims=(self.enc_att_num_heads, self.enc_key_per_head_dim), + ) + + # --------------- Add to the encoder network --------------- # + att_key0 = self.base_model.network.add_linear_layer( + "{}_att_key0".format(prefix), + "encoder", + with_bias=False, + n_out=self.enc_key_dim, + forward_weights_init=self.mhsa_init, + l2=self.self_att_l2, + param_dropout=self.mhsa_weight_drop, + param_dropout_min_ndim=2, + param_variational_noise=self.mhsa_weight_noise, + ) + + # (B, enc-T, H, D/H) + att_key = self.base_model.network.add_split_dim_layer( + "{}_att_key".format(prefix), att_key0, axis="F", dims=(self.enc_att_num_heads, self.enc_key_per_head_dim) + ) + + att_value0 = self.base_model.network.add_linear_layer( + "{}_att_value0".format(prefix), + "encoder", + with_bias=False, + n_out=self.enc_value_dim, + forward_weights_init=self.mhsa_init, + l2=self.self_att_l2, + param_dropout=self.mhsa_weight_drop, + param_dropout_min_ndim=2, + param_variational_noise=self.mhsa_weight_noise, + ) + + # (B, enc-T, H, D'/H) + att_value = self.base_model.network.add_split_dim_layer( + "{}_att_value".format(prefix), + att_value0, + axis="F", + dims=(self.enc_att_num_heads, self.enc_val_per_head_dim), + ) + # ----------------------------------------------------------- # + + # (B, H, enc-T, 1) + att_energy = subnet_unit.add_dot_layer( + "{}_att_energy".format(prefix), source=["base:" + att_key, att_query], red1=-1, red2=-1, var1="T", var2="T?" + ) + + att_weights = subnet_unit.add_softmax_over_spatial_layer( + "{}_att_weights".format(prefix), att_energy, energy_factor=self.enc_key_per_head_dim**-0.5 + ) + + att_weights_drop = subnet_unit.add_dropout_layer( + "{}_att_weights_drop".format(prefix), att_weights, dropout=self.att_dropout, dropout_noise_shape={"*": None} + ) + + # (B, H, V) + att0 = subnet_unit.add_generic_att_layer( + "{}_att0".format(prefix), weights=att_weights_drop, base="base:" + att_value + ) + + att = subnet_unit.add_merge_dims_layer("{}_att".format(prefix), att0, axes="static") # (B, H*V) except_batch + + # output projection + att_linear = subnet_unit.add_linear_layer( + "{}_att_linear".format(prefix), + att, + with_bias=False, + n_out=self.enc_value_dim, + forward_weights_init=self.mhsa_init_out, + l2=self.l2, + param_dropout=self.ff_weight_drop, + param_dropout_min_ndim=2, + param_variational_noise=self.ff_weight_noise, + ) + + att_drop = subnet_unit.add_dropout_layer("{}_att_drop".format(prefix), att_linear, dropout=self.dropout) + + out = subnet_unit.add_combine_layer( + "{}_att_out".format(prefix), [att_drop, source], kind="add", n_out=self.enc_value_dim + ) + return out + + def _create_ff_module(self, subnet_unit: ReturnnNetwork, prefix, source): + ff_ln = subnet_unit.add_layer_norm_layer("{}_ff_ln".format(prefix), source) + + ff1 = subnet_unit.add_linear_layer( + "{}_ff_conv1".format(prefix), + ff_ln, + activation=self.ff_act, + forward_weights_init=self.ff_init, + n_out=self.ff_dim, + with_bias=True, + l2=self.l2, + param_dropout=self.ff_weight_drop, + param_dropout_min_ndim=2, + param_variational_noise=self.ff_weight_noise, + ) + + ff2 = subnet_unit.add_linear_layer( + "{}_ff_conv2".format(prefix), + ff1, + activation=None, + forward_weights_init=self.ff_init, + n_out=self.enc_value_dim, + dropout=self.dropout, + with_bias=True, + l2=self.l2, + param_dropout=self.ff_weight_drop, + param_dropout_min_ndim=2, + param_variational_noise=self.ff_weight_noise, + ) + + drop = subnet_unit.add_dropout_layer("{}_ff_drop".format(prefix), ff2, dropout=self.dropout) + + out = subnet_unit.add_combine_layer( + "{}_ff_out".format(prefix), [drop, source], kind="add", n_out=self.enc_value_dim + ) + return out + + def _create_decoder_block(self, subnet_unit: ReturnnNetwork, source, i): + prefix = "transformer_decoder_%02i" % i + masked_mhsa = self._create_masked_mhsa(subnet_unit, prefix, source) + if self.replace_cross_att_w_masked_self_att: + mhsa = self._create_masked_mhsa(subnet_unit, "ilm_" + prefix, masked_mhsa, **self.ilm_args) + else: + mhsa = self._create_mhsa(subnet_unit, prefix, masked_mhsa) + ff = self._create_ff_module(subnet_unit, prefix, mhsa) + out = subnet_unit.add_copy_layer(prefix, ff) + return out + + def _create_ilm_decoder_block(self, subnet_unit: ReturnnNetwork, source, i): + prefix = "transformer_decoder_%02i" % i + masked_mhsa = self._create_masked_mhsa(subnet_unit, "prior_" + prefix, source) + if self.ilm_type == "mini_lstm": + mhsa = self._create_masked_mhsa(subnet_unit, "mini_ilm_" + prefix, masked_mhsa, **self.ilm_args) + else: + assert self.ilm_type == "zero" + mhsa = subnet_unit.add_eval_layer("zero_att_%02i" % i, masked_mhsa, eval="tf.zeros_like(source(0))") + ff = self._create_ff_module(subnet_unit, "prior_" + prefix, mhsa) + out = subnet_unit.add_copy_layer("prior_" + prefix, ff) + return out + + def _create_decoder(self, subnet_unit: ReturnnNetwork): + self.output_prob = subnet_unit.add_softmax_layer( + "output_prob", + "decoder", + loss="ce", + loss_opts={"label_smoothing": self.label_smoothing}, + target=self.target, + dropout=self.softmax_dropout, + forward_weights_init=self.ff_init, + l2=self.l2, + param_dropout=self.ff_weight_drop, + param_dropout_min_ndim=2, + param_variational_noise=self.ff_weight_noise, + ) + + if self.length_normalization: + output = subnet_unit.add_choice_layer( + "output", self.output_prob, target=self.target, beam_size=self.beam_size, initial_output=0 + ) + else: + output = subnet_unit.add_choice_layer( + "output", + self.output_prob, + target=self.target, + beam_size=self.beam_size, + initial_output=0, + length_normalization=self.length_normalization, + ) + + subnet_unit.add_compare_layer("end", output, value=0) + + target_embed_raw = subnet_unit.add_linear_layer( + "target_embed_raw", + "prev:" + output, + with_bias=False, + n_out=self.enc_value_dim, + forward_weights_init=self.ff_init, + l2=self.l2, + param_dropout=self.ff_weight_drop, + param_dropout_min_ndim=2, + param_variational_noise=self.ff_weight_noise, + ) + + if self.embed_weight: + # note that this probably only makes sense when using embed_pos_enc + target_embed_raw = subnet_unit.add_eval_layer( + "target_embed_weighted", target_embed_raw, eval="source(0) * %f" % self.embed_weight + ) + + if self.embed_pos_enc: + target_embed_raw = subnet_unit.add_pos_encoding_layer("target_embed_pos_enc", target_embed_raw) + + target_embed = subnet_unit.add_dropout_layer( + "target_embed", target_embed_raw, dropout=self.embed_dropout, dropout_noise_shape={"*": None} + ) + + x = target_embed + for i in range(1, self.num_layers + 1): + x = self._create_decoder_block(subnet_unit, x, i) + subnet_unit.add_layer_norm_layer("decoder", x) + + if self.create_ilm_decoder: + x = target_embed + for i in range(1, self.num_layers + 1): + x = self._create_ilm_decoder_block(subnet_unit, x, i) + subnet_unit.add_layer_norm_layer("prior_decoder", x) + + subnet_unit.add_softmax_layer( + "prior_output_prob", + "prior_decoder", + loss="ce", + loss_opts={"label_smoothing": self.label_smoothing}, + target=self.target, + dropout=self.softmax_dropout, + forward_weights_init=self.ff_init, + l2=self.l2, + ) + + dec_output = self.network.add_subnet_rec_layer("output", unit=subnet_unit.get_net(), target=self.target) + + return dec_output + + def create_network(self): + dec_output = self._create_decoder(self.subnet_unit) + + # recurrent subnetwork + decision_layer_name = self.base_model.network.add_decide_layer("decision", dec_output, target=self.target) + self.decision_layer_name = decision_layer_name + + return dec_output From f93337b3a88e943d22ede1e95120da24ad3383ed Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Wed, 15 May 2024 15:41:45 +0000 Subject: [PATCH 009/227] update --- .../models/asr/decoder/transformer_decoder.py | 50 ++- .../asr/decoder/transformer_decoder_v2.py | 414 ------------------ 2 files changed, 46 insertions(+), 418 deletions(-) delete mode 100644 users/zeineldeen/models/asr/decoder/transformer_decoder_v2.py diff --git a/users/zeineldeen/models/asr/decoder/transformer_decoder.py b/users/zeineldeen/models/asr/decoder/transformer_decoder.py index da4dc7850..30d8624f2 100644 --- a/users/zeineldeen/models/asr/decoder/transformer_decoder.py +++ b/users/zeineldeen/models/asr/decoder/transformer_decoder.py @@ -24,6 +24,7 @@ def __init__( softmax_dropout=0.0, embed_dropout=0.1, l2=0.0, + self_att_l2=0.0, embed_pos_enc=False, apply_embed_weight=False, label_smoothing=0.1, @@ -36,6 +37,10 @@ def __init__( create_ilm_decoder=False, ilm_type=None, ilm_args=None, + ff_weight_noise=None, + mhsa_weight_noise=None, + ff_weight_dropout=None, + mhsa_weight_dropout=None, ): self.base_model = base_model self.enc_value_dim = base_model.enc_value_dim @@ -66,6 +71,7 @@ def __init__( self.label_smoothing = label_smoothing self.l2 = l2 + self.self_att_l2 = self_att_l2 self.embed_dropout = embed_dropout self.embed_pos_enc = embed_pos_enc @@ -81,6 +87,11 @@ def __init__( self.replace_cross_att_w_masked_self_att = replace_cross_att_w_masked_self_att # used to train ILM + self.ff_weight_drop = ff_weight_dropout + self.mhsa_weight_drop = mhsa_weight_dropout + self.ff_weight_noise = ff_weight_noise + self.mhsa_weight_noise = mhsa_weight_noise + # used for recognition with ILM self.create_ilm_decoder = create_ilm_decoder self.ilm_type = ilm_type @@ -121,8 +132,11 @@ def _create_masked_mhsa(self, subnet_unit: ReturnnNetwork, prefix, source, **kwa attention_left_only=True, att_dropout=self.att_dropout, forward_weights_init=self.mhsa_init, - l2=self.l2, + l2=self.self_att_l2, key_shift=ln_rel_pos_enc if ln_rel_pos_enc is not None else None, + param_dropout=self.mhsa_weight_drop, + param_dropout_min_ndim=2, + param_variational_noise=self.mhsa_weight_noise, ) linear = subnet_unit.add_linear_layer( @@ -133,6 +147,9 @@ def _create_masked_mhsa(self, subnet_unit: ReturnnNetwork, prefix, source, **kwa n_out=self.enc_value_dim, forward_weights_init=self.mhsa_init_out, l2=self.l2, + param_dropout=self.ff_weight_drop, + param_dropout_min_ndim=2, + param_variational_noise=self.ff_weight_noise, ) drop = subnet_unit.add_dropout_layer("{}_drop".format(prefix), linear, dropout=self.dropout) @@ -152,7 +169,10 @@ def _create_mhsa(self, subnet_unit: ReturnnNetwork, prefix, source): with_bias=False, n_out=self.enc_value_dim, forward_weights_init=self.mhsa_init, - l2=self.l2, + l2=self.self_att_l2, + param_dropout=self.mhsa_weight_drop, + param_dropout_min_ndim=2, + param_variational_noise=self.mhsa_weight_noise, ) # (B, H, D/H) @@ -170,7 +190,10 @@ def _create_mhsa(self, subnet_unit: ReturnnNetwork, prefix, source): with_bias=False, n_out=self.enc_key_dim, forward_weights_init=self.mhsa_init, - l2=self.l2, + l2=self.self_att_l2, + param_dropout=self.mhsa_weight_drop, + param_dropout_min_ndim=2, + param_variational_noise=self.mhsa_weight_noise, ) # (B, enc-T, H, D/H) @@ -184,7 +207,10 @@ def _create_mhsa(self, subnet_unit: ReturnnNetwork, prefix, source): with_bias=False, n_out=self.enc_value_dim, forward_weights_init=self.mhsa_init, - l2=self.l2, + l2=self.self_att_l2, + param_dropout=self.mhsa_weight_drop, + param_dropout_min_ndim=2, + param_variational_noise=self.mhsa_weight_noise, ) # (B, enc-T, H, D'/H) @@ -224,6 +250,9 @@ def _create_mhsa(self, subnet_unit: ReturnnNetwork, prefix, source): n_out=self.enc_value_dim, forward_weights_init=self.mhsa_init_out, l2=self.l2, + param_dropout=self.ff_weight_drop, + param_dropout_min_ndim=2, + param_variational_noise=self.ff_weight_noise, ) att_drop = subnet_unit.add_dropout_layer("{}_att_drop".format(prefix), att_linear, dropout=self.dropout) @@ -244,6 +273,9 @@ def _create_ff_module(self, subnet_unit: ReturnnNetwork, prefix, source): n_out=self.ff_dim, with_bias=True, l2=self.l2, + param_dropout=self.ff_weight_drop, + param_dropout_min_ndim=2, + param_variational_noise=self.ff_weight_noise, ) ff2 = subnet_unit.add_linear_layer( @@ -255,6 +287,9 @@ def _create_ff_module(self, subnet_unit: ReturnnNetwork, prefix, source): dropout=self.dropout, with_bias=True, l2=self.l2, + param_dropout=self.ff_weight_drop, + param_dropout_min_ndim=2, + param_variational_noise=self.ff_weight_noise, ) drop = subnet_unit.add_dropout_layer("{}_ff_drop".format(prefix), ff2, dropout=self.dropout) @@ -297,6 +332,9 @@ def _create_decoder(self, subnet_unit: ReturnnNetwork): dropout=self.softmax_dropout, forward_weights_init=self.ff_init, l2=self.l2, + param_dropout=self.ff_weight_drop, + param_dropout_min_ndim=2, + param_variational_noise=self.ff_weight_noise, ) if self.length_normalization: @@ -322,9 +360,13 @@ def _create_decoder(self, subnet_unit: ReturnnNetwork): n_out=self.enc_value_dim, forward_weights_init=self.ff_init, l2=self.l2, + param_dropout=self.ff_weight_drop, + param_dropout_min_ndim=2, + param_variational_noise=self.ff_weight_noise, ) if self.embed_weight: + # note that this probably only makes sense when using embed_pos_enc target_embed_raw = subnet_unit.add_eval_layer( "target_embed_weighted", target_embed_raw, eval="source(0) * %f" % self.embed_weight ) diff --git a/users/zeineldeen/models/asr/decoder/transformer_decoder_v2.py b/users/zeineldeen/models/asr/decoder/transformer_decoder_v2.py deleted file mode 100644 index 30d8624f2..000000000 --- a/users/zeineldeen/models/asr/decoder/transformer_decoder_v2.py +++ /dev/null @@ -1,414 +0,0 @@ -from i6_experiments.users.zeineldeen.modules.network import ReturnnNetwork - - -class TransformerDecoder: - """ - Represents standard Transformer decoder - - * Attention Is All You Need - * Ref: https://arxiv.org/abs/1706.03762 - """ - - def __init__( - self, - base_model, - target="bpe", - num_layers=6, - beam_size=12, - ff_init=None, - ff_dim=2048, - ff_act="relu", - att_num_heads=8, - dropout=0.1, - att_dropout=0.0, - softmax_dropout=0.0, - embed_dropout=0.1, - l2=0.0, - self_att_l2=0.0, - embed_pos_enc=False, - apply_embed_weight=False, - label_smoothing=0.1, - mhsa_init=None, - mhsa_out_init=None, - pos_enc=None, - rel_pos_clipping=16, - length_normalization=True, - replace_cross_att_w_masked_self_att=False, - create_ilm_decoder=False, - ilm_type=None, - ilm_args=None, - ff_weight_noise=None, - mhsa_weight_noise=None, - ff_weight_dropout=None, - mhsa_weight_dropout=None, - ): - self.base_model = base_model - self.enc_value_dim = base_model.enc_value_dim - self.enc_key_dim = base_model.enc_key_dim - self.enc_att_num_heads = base_model.att_num_heads - self.enc_key_per_head_dim = base_model.enc_key_per_head_dim - self.enc_val_per_head_dim = base_model.enc_val_per_head_dim - - self.att_num_heads = att_num_heads - - self.target = target - self.num_layers = num_layers - self.beam_size = beam_size - - self.ff_init = ff_init - self.ff_dim = ff_dim - self.ff_act = ff_act - - self.mhsa_init = mhsa_init - self.mhsa_init_out = mhsa_out_init - - self.pos_enc = pos_enc - self.rel_pos_clipping = rel_pos_clipping - - self.dropout = dropout - self.softmax_dropout = softmax_dropout - self.att_dropout = att_dropout - self.label_smoothing = label_smoothing - - self.l2 = l2 - self.self_att_l2 = self_att_l2 - - self.embed_dropout = embed_dropout - self.embed_pos_enc = embed_pos_enc - - self.embed_weight = None - - if apply_embed_weight: - self.embed_weight = self.enc_value_dim**0.5 - - self.decision_layer_name = None - - self.length_normalization = length_normalization - - self.replace_cross_att_w_masked_self_att = replace_cross_att_w_masked_self_att # used to train ILM - - self.ff_weight_drop = ff_weight_dropout - self.mhsa_weight_drop = mhsa_weight_dropout - self.ff_weight_noise = ff_weight_noise - self.mhsa_weight_noise = mhsa_weight_noise - - # used for recognition with ILM - self.create_ilm_decoder = create_ilm_decoder - self.ilm_type = ilm_type - self.ilm_args = ilm_args or {} - if self.create_ilm_decoder: - self.replace_cross_att_w_masked_self_att = False # keep original decoder as-is - - self.network = ReturnnNetwork() - self.subnet_unit = ReturnnNetwork() - self.output_prob = None - - def _create_masked_mhsa(self, subnet_unit: ReturnnNetwork, prefix, source, **kwargs): - prefix = "{}_self_att".format(prefix) - - # for tuning mini-self-att ILM - att_num_heads = kwargs.get("att_num_heads", self.att_num_heads) - enc_key_dim = kwargs.get("enc_key_dim", self.enc_key_dim) - enc_key_per_head_dim = enc_key_dim // att_num_heads - - ln = subnet_unit.add_layer_norm_layer("{}_ln".format(prefix), source) - - ln_rel_pos_enc = None - if self.pos_enc == "rel": - ln_rel_pos_enc = self.subnet_unit.add_relative_pos_encoding_layer( - "{}_ln_rel_pos_enc".format(prefix), - ln, - n_out=enc_key_per_head_dim, - forward_weights_init=self.ff_init, - clipping=self.rel_pos_clipping, - ) - - att = subnet_unit.add_self_att_layer( - "{}_att".format(prefix), - ln, - num_heads=att_num_heads, - total_key_dim=enc_key_dim, - n_out=self.enc_value_dim, - attention_left_only=True, - att_dropout=self.att_dropout, - forward_weights_init=self.mhsa_init, - l2=self.self_att_l2, - key_shift=ln_rel_pos_enc if ln_rel_pos_enc is not None else None, - param_dropout=self.mhsa_weight_drop, - param_dropout_min_ndim=2, - param_variational_noise=self.mhsa_weight_noise, - ) - - linear = subnet_unit.add_linear_layer( - "{}_linear".format(prefix), - att, - activation=None, - with_bias=False, - n_out=self.enc_value_dim, - forward_weights_init=self.mhsa_init_out, - l2=self.l2, - param_dropout=self.ff_weight_drop, - param_dropout_min_ndim=2, - param_variational_noise=self.ff_weight_noise, - ) - - drop = subnet_unit.add_dropout_layer("{}_drop".format(prefix), linear, dropout=self.dropout) - - out = subnet_unit.add_combine_layer( - "{}_out".format(prefix), [drop, source], kind="add", n_out=self.enc_value_dim - ) - - return out - - def _create_mhsa(self, subnet_unit: ReturnnNetwork, prefix, source): - ln = subnet_unit.add_layer_norm_layer("{}_att_ln".format(prefix), source) - - att_query0 = subnet_unit.add_linear_layer( - "{}_att_query0".format(prefix), - ln, - with_bias=False, - n_out=self.enc_value_dim, - forward_weights_init=self.mhsa_init, - l2=self.self_att_l2, - param_dropout=self.mhsa_weight_drop, - param_dropout_min_ndim=2, - param_variational_noise=self.mhsa_weight_noise, - ) - - # (B, H, D/H) - att_query = subnet_unit.add_split_dim_layer( - "{}_att_query".format(prefix), - att_query0, - axis="F", - dims=(self.enc_att_num_heads, self.enc_key_per_head_dim), - ) - - # --------------- Add to the encoder network --------------- # - att_key0 = self.base_model.network.add_linear_layer( - "{}_att_key0".format(prefix), - "encoder", - with_bias=False, - n_out=self.enc_key_dim, - forward_weights_init=self.mhsa_init, - l2=self.self_att_l2, - param_dropout=self.mhsa_weight_drop, - param_dropout_min_ndim=2, - param_variational_noise=self.mhsa_weight_noise, - ) - - # (B, enc-T, H, D/H) - att_key = self.base_model.network.add_split_dim_layer( - "{}_att_key".format(prefix), att_key0, axis="F", dims=(self.enc_att_num_heads, self.enc_key_per_head_dim) - ) - - att_value0 = self.base_model.network.add_linear_layer( - "{}_att_value0".format(prefix), - "encoder", - with_bias=False, - n_out=self.enc_value_dim, - forward_weights_init=self.mhsa_init, - l2=self.self_att_l2, - param_dropout=self.mhsa_weight_drop, - param_dropout_min_ndim=2, - param_variational_noise=self.mhsa_weight_noise, - ) - - # (B, enc-T, H, D'/H) - att_value = self.base_model.network.add_split_dim_layer( - "{}_att_value".format(prefix), - att_value0, - axis="F", - dims=(self.enc_att_num_heads, self.enc_val_per_head_dim), - ) - # ----------------------------------------------------------- # - - # (B, H, enc-T, 1) - att_energy = subnet_unit.add_dot_layer( - "{}_att_energy".format(prefix), source=["base:" + att_key, att_query], red1=-1, red2=-1, var1="T", var2="T?" - ) - - att_weights = subnet_unit.add_softmax_over_spatial_layer( - "{}_att_weights".format(prefix), att_energy, energy_factor=self.enc_key_per_head_dim**-0.5 - ) - - att_weights_drop = subnet_unit.add_dropout_layer( - "{}_att_weights_drop".format(prefix), att_weights, dropout=self.att_dropout, dropout_noise_shape={"*": None} - ) - - # (B, H, V) - att0 = subnet_unit.add_generic_att_layer( - "{}_att0".format(prefix), weights=att_weights_drop, base="base:" + att_value - ) - - att = subnet_unit.add_merge_dims_layer("{}_att".format(prefix), att0, axes="static") # (B, H*V) except_batch - - # output projection - att_linear = subnet_unit.add_linear_layer( - "{}_att_linear".format(prefix), - att, - with_bias=False, - n_out=self.enc_value_dim, - forward_weights_init=self.mhsa_init_out, - l2=self.l2, - param_dropout=self.ff_weight_drop, - param_dropout_min_ndim=2, - param_variational_noise=self.ff_weight_noise, - ) - - att_drop = subnet_unit.add_dropout_layer("{}_att_drop".format(prefix), att_linear, dropout=self.dropout) - - out = subnet_unit.add_combine_layer( - "{}_att_out".format(prefix), [att_drop, source], kind="add", n_out=self.enc_value_dim - ) - return out - - def _create_ff_module(self, subnet_unit: ReturnnNetwork, prefix, source): - ff_ln = subnet_unit.add_layer_norm_layer("{}_ff_ln".format(prefix), source) - - ff1 = subnet_unit.add_linear_layer( - "{}_ff_conv1".format(prefix), - ff_ln, - activation=self.ff_act, - forward_weights_init=self.ff_init, - n_out=self.ff_dim, - with_bias=True, - l2=self.l2, - param_dropout=self.ff_weight_drop, - param_dropout_min_ndim=2, - param_variational_noise=self.ff_weight_noise, - ) - - ff2 = subnet_unit.add_linear_layer( - "{}_ff_conv2".format(prefix), - ff1, - activation=None, - forward_weights_init=self.ff_init, - n_out=self.enc_value_dim, - dropout=self.dropout, - with_bias=True, - l2=self.l2, - param_dropout=self.ff_weight_drop, - param_dropout_min_ndim=2, - param_variational_noise=self.ff_weight_noise, - ) - - drop = subnet_unit.add_dropout_layer("{}_ff_drop".format(prefix), ff2, dropout=self.dropout) - - out = subnet_unit.add_combine_layer( - "{}_ff_out".format(prefix), [drop, source], kind="add", n_out=self.enc_value_dim - ) - return out - - def _create_decoder_block(self, subnet_unit: ReturnnNetwork, source, i): - prefix = "transformer_decoder_%02i" % i - masked_mhsa = self._create_masked_mhsa(subnet_unit, prefix, source) - if self.replace_cross_att_w_masked_self_att: - mhsa = self._create_masked_mhsa(subnet_unit, "ilm_" + prefix, masked_mhsa, **self.ilm_args) - else: - mhsa = self._create_mhsa(subnet_unit, prefix, masked_mhsa) - ff = self._create_ff_module(subnet_unit, prefix, mhsa) - out = subnet_unit.add_copy_layer(prefix, ff) - return out - - def _create_ilm_decoder_block(self, subnet_unit: ReturnnNetwork, source, i): - prefix = "transformer_decoder_%02i" % i - masked_mhsa = self._create_masked_mhsa(subnet_unit, "prior_" + prefix, source) - if self.ilm_type == "mini_lstm": - mhsa = self._create_masked_mhsa(subnet_unit, "mini_ilm_" + prefix, masked_mhsa, **self.ilm_args) - else: - assert self.ilm_type == "zero" - mhsa = subnet_unit.add_eval_layer("zero_att_%02i" % i, masked_mhsa, eval="tf.zeros_like(source(0))") - ff = self._create_ff_module(subnet_unit, "prior_" + prefix, mhsa) - out = subnet_unit.add_copy_layer("prior_" + prefix, ff) - return out - - def _create_decoder(self, subnet_unit: ReturnnNetwork): - self.output_prob = subnet_unit.add_softmax_layer( - "output_prob", - "decoder", - loss="ce", - loss_opts={"label_smoothing": self.label_smoothing}, - target=self.target, - dropout=self.softmax_dropout, - forward_weights_init=self.ff_init, - l2=self.l2, - param_dropout=self.ff_weight_drop, - param_dropout_min_ndim=2, - param_variational_noise=self.ff_weight_noise, - ) - - if self.length_normalization: - output = subnet_unit.add_choice_layer( - "output", self.output_prob, target=self.target, beam_size=self.beam_size, initial_output=0 - ) - else: - output = subnet_unit.add_choice_layer( - "output", - self.output_prob, - target=self.target, - beam_size=self.beam_size, - initial_output=0, - length_normalization=self.length_normalization, - ) - - subnet_unit.add_compare_layer("end", output, value=0) - - target_embed_raw = subnet_unit.add_linear_layer( - "target_embed_raw", - "prev:" + output, - with_bias=False, - n_out=self.enc_value_dim, - forward_weights_init=self.ff_init, - l2=self.l2, - param_dropout=self.ff_weight_drop, - param_dropout_min_ndim=2, - param_variational_noise=self.ff_weight_noise, - ) - - if self.embed_weight: - # note that this probably only makes sense when using embed_pos_enc - target_embed_raw = subnet_unit.add_eval_layer( - "target_embed_weighted", target_embed_raw, eval="source(0) * %f" % self.embed_weight - ) - - if self.embed_pos_enc: - target_embed_raw = subnet_unit.add_pos_encoding_layer("target_embed_pos_enc", target_embed_raw) - - target_embed = subnet_unit.add_dropout_layer( - "target_embed", target_embed_raw, dropout=self.embed_dropout, dropout_noise_shape={"*": None} - ) - - x = target_embed - for i in range(1, self.num_layers + 1): - x = self._create_decoder_block(subnet_unit, x, i) - subnet_unit.add_layer_norm_layer("decoder", x) - - if self.create_ilm_decoder: - x = target_embed - for i in range(1, self.num_layers + 1): - x = self._create_ilm_decoder_block(subnet_unit, x, i) - subnet_unit.add_layer_norm_layer("prior_decoder", x) - - subnet_unit.add_softmax_layer( - "prior_output_prob", - "prior_decoder", - loss="ce", - loss_opts={"label_smoothing": self.label_smoothing}, - target=self.target, - dropout=self.softmax_dropout, - forward_weights_init=self.ff_init, - l2=self.l2, - ) - - dec_output = self.network.add_subnet_rec_layer("output", unit=subnet_unit.get_net(), target=self.target) - - return dec_output - - def create_network(self): - dec_output = self._create_decoder(self.subnet_unit) - - # recurrent subnetwork - decision_layer_name = self.base_model.network.add_decide_layer("decision", dec_output, target=self.target) - self.decision_layer_name = decision_layer_name - - return dec_output From 884f762f393a28a26f02dad54a118568585e6a6c Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Wed, 15 May 2024 15:46:59 +0000 Subject: [PATCH 010/227] add regs to rnn decoder --- .../models/asr/decoder/rnn_decoder.py | 39 +++++++++++++++++-- 1 file changed, 36 insertions(+), 3 deletions(-) diff --git a/users/zeineldeen/models/asr/decoder/rnn_decoder.py b/users/zeineldeen/models/asr/decoder/rnn_decoder.py index ae88168a0..d7f82fdb4 100644 --- a/users/zeineldeen/models/asr/decoder/rnn_decoder.py +++ b/users/zeineldeen/models/asr/decoder/rnn_decoder.py @@ -48,6 +48,8 @@ def __init__( use_monotonic_att_weights_loss_in_recog=False, att_weights_variance_loss_scale=None, include_eos_in_search_output=False, + ff_weight_dropout=None, + ff_weight_noise=None, ): """ :param base_model: base/encoder model instance @@ -137,6 +139,9 @@ def __init__( self.use_zoneout_output = use_zoneout_output + self.ff_weight_drop = ff_weight_dropout + self.ff_weight_noise = ff_weight_noise + self.monotonic_att_weights_loss_opts = monotonic_att_weights_loss_opts self.use_monotonic_att_weights_loss_in_recog = use_monotonic_att_weights_loss_in_recog @@ -161,6 +166,9 @@ def add_decoder_subnetwork(self, subnet_unit: ReturnnNetwork): with_bias=False, l2=self.l2, forward_weights_init=self.embed_weight_init, + param_dropout=self.ff_weight_drop, + param_dropout_min_ndim=2, + param_variational_noise=self.ff_weight_noise, ) subnet_unit.add_dropout_layer( @@ -194,7 +202,14 @@ def add_decoder_subnetwork(self, subnet_unit: ReturnnNetwork): ) if self.lstm_lm_dim != self.enc_value_dim: lstm_lm_component_proj = subnet_unit.add_linear_layer( - "lm_like_s_proj", lstm_lm_component, n_out=self.enc_value_dim, l2=self.l2, dropout=self.dropout + "lm_like_s_proj", + lstm_lm_component, + n_out=self.enc_value_dim, + l2=self.l2, + dropout=self.dropout, + param_dropout=self.ff_weight_drop, + param_dropout_min_ndim=2, + param_variational_noise=self.ff_weight_noise, ) else: lstm_lm_component_proj = lstm_lm_component @@ -235,7 +250,14 @@ def add_decoder_subnetwork(self, subnet_unit: ReturnnNetwork): if self.add_lstm_lm: # s_transformed (query) has 1024 dim s_proj = subnet_unit.add_linear_layer( - "s_proj", "s_transformed", n_out=self.enc_value_dim, l2=self.l2, dropout=self.dropout + "s_proj", + "s_transformed", + n_out=self.enc_value_dim, + l2=self.l2, + dropout=self.dropout, + param_dropout=self.ff_weight_drop, + param_dropout_min_ndim=2, + param_variational_noise=self.ff_weight_noise, ) # back-lstm (query) + context readout_in_src = subnet_unit.add_combine_layer( @@ -244,7 +266,15 @@ def add_decoder_subnetwork(self, subnet_unit: ReturnnNetwork): else: readout_in_src = ["s", "prev:target_embed", "att"] - subnet_unit.add_linear_layer("readout_in", readout_in_src, n_out=self.dec_output_num_units, l2=self.l2) + subnet_unit.add_linear_layer( + "readout_in", + readout_in_src, + n_out=self.dec_output_num_units, + l2=self.l2, + param_dropout=self.ff_weight_drop, + param_dropout_min_ndim=2, + param_variational_noise=self.ff_weight_noise, + ) if self.reduceout: subnet_unit.add_reduceout_layer("readout", "readout_in") @@ -263,6 +293,9 @@ def add_decoder_subnetwork(self, subnet_unit: ReturnnNetwork): loss_opts=ce_loss_opts, target=self.target, dropout=self.softmax_dropout, + param_dropout=self.ff_weight_drop, + param_dropout_min_ndim=2, + param_variational_noise=self.ff_weight_noise, ) self.output_prob_with_coverage = None From 3c8b576b2b62de87217e1d8fe598a5606470122a Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Wed, 15 May 2024 15:50:12 +0000 Subject: [PATCH 011/227] more --- users/zeineldeen/models/asr/encoder/conformer_encoder_v2.py | 3 +++ users/zeineldeen/modules/network.py | 3 +++ 2 files changed, 6 insertions(+) diff --git a/users/zeineldeen/models/asr/encoder/conformer_encoder_v2.py b/users/zeineldeen/models/asr/encoder/conformer_encoder_v2.py index bef0dad64..89d0d2557 100644 --- a/users/zeineldeen/models/asr/encoder/conformer_encoder_v2.py +++ b/users/zeineldeen/models/asr/encoder/conformer_encoder_v2.py @@ -1254,6 +1254,9 @@ def _create_all_network_parts(self): loss="ctc", dropout=self.ctc_dropout, loss_opts=default_ctc_loss_opts, + param_dropout=self.ff_weight_drop, + param_dropout_min_ndim=2, + param_variational_noise=self.ff_weight_noise, ) if self.ctc_loss_scale or self.ctc_self_align_delay: self.network["ctc"]["loss_scale"] = (self.ctc_loss_scale or 1.0) * ( diff --git a/users/zeineldeen/modules/network.py b/users/zeineldeen/modules/network.py index f763da614..33d87e898 100644 --- a/users/zeineldeen/modules/network.py +++ b/users/zeineldeen/modules/network.py @@ -219,6 +219,7 @@ def add_softmax_layer( loss_scale=None, param_dropout=None, param_dropout_min_ndim=None, + param_variational_noise=None, **kwargs, ): d = {"class": "softmax", "from": source} @@ -238,6 +239,8 @@ def add_softmax_layer( d["param_dropout"] = param_dropout if param_dropout_min_ndim is not None: d["param_dropout_min_ndim"] = param_dropout_min_ndim + if param_variational_noise: + d["param_variational_noise"] = param_variational_noise if loss_scale: d["loss_scale"] = loss_scale d.update(kwargs) From 1c14be1cad3a09789117df7481e4bfd6a2046ceb Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Wed, 15 May 2024 15:57:14 +0000 Subject: [PATCH 012/227] add more regs to rnn dec --- .../models/asr/decoder/rnn_decoder.py | 2 + users/zeineldeen/modules/attention.py | 66 ++++++++++++++++--- 2 files changed, 59 insertions(+), 9 deletions(-) diff --git a/users/zeineldeen/models/asr/decoder/rnn_decoder.py b/users/zeineldeen/models/asr/decoder/rnn_decoder.py index d7f82fdb4..b292d2ed8 100644 --- a/users/zeineldeen/models/asr/decoder/rnn_decoder.py +++ b/users/zeineldeen/models/asr/decoder/rnn_decoder.py @@ -183,6 +183,8 @@ def add_decoder_subnetwork(self, subnet_unit: ReturnnNetwork): l2=self.l2, loc_filter_size=self.loc_conv_att_filter_size, loc_num_channels=self.enc_key_dim, + weight_drop=self.ff_weight_drop, + weight_noise=self.ff_weight_noise, ) subnet_unit.update(att.create()) diff --git a/users/zeineldeen/modules/attention.py b/users/zeineldeen/modules/attention.py index e13ebd1c7..d0350a622 100644 --- a/users/zeineldeen/modules/attention.py +++ b/users/zeineldeen/modules/attention.py @@ -7,12 +7,14 @@ class ConvLocAwareness(AbsModule): Attention convolution location awareness """ - def __init__(self, enc_key_dim, filter_size, num_channels, l2): + def __init__(self, enc_key_dim, filter_size, num_channels, l2, weight_drop, weight_noise): super().__init__() self.enc_key_dim = enc_key_dim self.filter_size = filter_size self.num_channels = num_channels self.l2 = l2 + self.weight_drop = weight_drop + self.weight_noise = weight_noise def create(self): out_net = ReturnnNetwork() @@ -35,10 +37,20 @@ def create(self): padding="valid", n_out=self.num_channels, l2=self.l2, + param_dropout=self.weight_drop, + param_dropout_min_ndim=2, + param_variational_noise=self.weight_noise, ) self.name = out_net.add_linear_layer( - "weight_feedback", loc_att_conv, activation=None, with_bias=False, n_out=self.enc_key_dim + "weight_feedback", + loc_att_conv, + activation=None, + with_bias=False, + n_out=self.enc_key_dim, + param_dropout=self.weight_drop, + param_dropout_min_ndim=2, + param_variational_noise=self.weight_noise, ) return out_net.get_net() @@ -49,11 +61,14 @@ class AdditiveLocAwareness(AbsModule): Attention additive location awareness """ - def __init__(self, enc_key_dim, att_num_heads): + def __init__(self, enc_key_dim, att_num_heads, weight_drop, weight_noise): super().__init__() self.enc_key_dim = enc_key_dim self.att_num_heads = att_num_heads + self.weight_drop = weight_drop + self.weight_noise = weight_noise + def create(self): out_net = ReturnnNetwork() @@ -65,7 +80,13 @@ def create(self): ) self.name = out_net.add_linear_layer( - "weight_feedback", "prev:accum_att_weights", n_out=self.enc_key_dim, with_bias=False + "weight_feedback", + "prev:accum_att_weights", + n_out=self.enc_key_dim, + with_bias=False, + param_dropout=self.weight_drop, + param_dropout_min_ndim=2, + param_variational_noise=self.weight_noise, ) return out_net.get_net() @@ -76,7 +97,9 @@ class AttentionMechanism(AbsModule): Single-head or Multi-head attention mechanism """ - def __init__(self, enc_key_dim, att_num_heads, att_dropout, l2, loc_filter_size, loc_num_channels): + def __init__( + self, enc_key_dim, att_num_heads, att_dropout, l2, loc_filter_size, loc_num_channels, weight_drop, weight_noise + ): super().__init__() self.enc_key_dim = enc_key_dim self.att_num_heads = att_num_heads @@ -84,15 +107,26 @@ def __init__(self, enc_key_dim, att_num_heads, att_dropout, l2, loc_filter_size, self.att_dropout = att_dropout self.l2 = l2 + self.weight_drop = weight_drop + self.weight_noise = weight_noise + self.loc_filter_size = loc_filter_size self.loc_num_channels = loc_num_channels def create(self): out_net = ReturnnNetwork() + # project query out_net.add_linear_layer( - "s_transformed", "s", n_out=self.enc_key_dim, with_bias=False, l2=self.l2 - ) # project query + "s_transformed", + "s", + n_out=self.enc_key_dim, + with_bias=False, + l2=self.l2, + param_dropout=self.weight_drop, + param_dropout_min_ndim=2, + param_variational_noise=self.weight_noise, + ) if self.loc_filter_size is not None: assert self.loc_filter_size is not None @@ -101,10 +135,17 @@ def create(self): filter_size=self.loc_filter_size, num_channels=self.loc_num_channels, l2=self.l2, + weight_drop=self.weight_drop, + weight_noise=self.weight_noise, ) else: # additive - weight_feedback = AdditiveLocAwareness(enc_key_dim=self.enc_key_dim, att_num_heads=self.att_num_heads) + weight_feedback = AdditiveLocAwareness( + enc_key_dim=self.enc_key_dim, + att_num_heads=self.att_num_heads, + weight_drop=self.weight_drop, + weight_noise=self.weight_noise, + ) out_net.update(weight_feedback.create()) # add att weight feedback @@ -115,7 +156,14 @@ def create(self): # compute energies out_net.add_activation_layer("energy_tanh", "energy_in", activation="tanh") energy = out_net.add_linear_layer( - "energy", "energy_tanh", n_out=self.att_num_heads, with_bias=False, l2=self.l2 + "energy", + "energy_tanh", + n_out=self.att_num_heads, + with_bias=False, + l2=self.l2, + param_dropout=self.weight_drop, + param_dropout_min_ndim=2, + param_variational_noise=self.weight_noise, ) if self.att_dropout: From 84686ed232fbb6337b09695e357d0024b5850925 Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Wed, 15 May 2024 15:58:50 +0000 Subject: [PATCH 013/227] black formatting --- .../asr/encoder/ebranchformer_encoder.py | 371 ++++++++++++------ 1 file changed, 255 insertions(+), 116 deletions(-) diff --git a/users/zeineldeen/models/asr/encoder/ebranchformer_encoder.py b/users/zeineldeen/models/asr/encoder/ebranchformer_encoder.py index b0859bc24..3f06572c9 100644 --- a/users/zeineldeen/models/asr/encoder/ebranchformer_encoder.py +++ b/users/zeineldeen/models/asr/encoder/ebranchformer_encoder.py @@ -7,14 +7,47 @@ class EBranchformerEncoder: * Ref: https://arxiv.org/pdf/2210.00077.pdf """ - def __init__(self, input='data', input_layer='conv-6', input_layer_conv_act='relu', num_blocks=16, - conv_kernel_size=32, specaug=True, pos_enc='rel', activation='swish', ff_dim=512, - ff_bias=True, ctc_loss_scale=None, dropout=0.1, att_dropout=0.1, enc_key_dim=256, att_num_heads=4, - target='bpe', l2=0.0, lstm_dropout=0.1, rec_weight_dropout=0., with_ctc=False, native_ctc=False, - ctc_dropout=0., ctc_l2=0., ctc_opts=None, subsample=None, start_conv_init=None, conv_module_init=None, - mhsa_init=None, mhsa_out_init=None, ff_init=None, rel_pos_clipping=16, dropout_in=0.1, - batch_norm_opts=None, self_att_l2=0.0, sandwich_conv=False, - add_to_prefix_name=None, output_layer_name='encoder', rezero=False): + def __init__( + self, + input="data", + input_layer="conv-6", + input_layer_conv_act="relu", + num_blocks=16, + conv_kernel_size=32, + specaug=True, + pos_enc="rel", + activation="swish", + ff_dim=512, + ff_bias=True, + ctc_loss_scale=None, + dropout=0.1, + att_dropout=0.1, + enc_key_dim=256, + att_num_heads=4, + target="bpe", + l2=0.0, + lstm_dropout=0.1, + rec_weight_dropout=0.0, + with_ctc=False, + native_ctc=False, + ctc_dropout=0.0, + ctc_l2=0.0, + ctc_opts=None, + subsample=None, + start_conv_init=None, + conv_module_init=None, + mhsa_init=None, + mhsa_out_init=None, + ff_init=None, + rel_pos_clipping=16, + dropout_in=0.1, + batch_norm_opts=None, + self_att_l2=0.0, + sandwich_conv=False, + add_to_prefix_name=None, + output_layer_name="encoder", + rezero=False, + ): """ :param str input: input layer name :param str input_layer: type of input layer which does subsampling @@ -85,15 +118,15 @@ def __init__(self, input='data', input_layer='conv-6', input_layer_conv_act='rel if batch_norm_opts is None: batch_norm_opts = {} - bn_momentum = batch_norm_opts.pop('momentum', 0.1) - bn_eps = batch_norm_opts.pop('epsilon', 1e-3) - bn_update_sample_only_in_train = batch_norm_opts.pop('update_sample_only_in_training', True) - bn_delay_sample_update = batch_norm_opts.pop('delay_sample_update', True) + bn_momentum = batch_norm_opts.pop("momentum", 0.1) + bn_eps = batch_norm_opts.pop("epsilon", 1e-3) + bn_update_sample_only_in_train = batch_norm_opts.pop("update_sample_only_in_training", True) + bn_delay_sample_update = batch_norm_opts.pop("delay_sample_update", True) self.batch_norm_opts = { - 'momentum': bn_momentum, - 'epsilon': bn_eps, - 'update_sample_only_in_training': bn_update_sample_only_in_train, - 'delay_sample_update': bn_delay_sample_update, + "momentum": bn_momentum, + "epsilon": bn_eps, + "update_sample_only_in_training": bn_update_sample_only_in_train, + "delay_sample_update": bn_delay_sample_update, } self.batch_norm_opts.update(**batch_norm_opts) @@ -118,7 +151,7 @@ def __init__(self, input='data', input_layer='conv-6', input_layer_conv_act='rel self.subsample = subsample self.subsample_list = [1] * num_blocks if subsample: - for idx, s in enumerate(map(int, subsample.split('_')[:num_blocks])): + for idx, s in enumerate(map(int, subsample.split("_")[:num_blocks])): self.subsample_list[idx] = s self.network = ReturnnNetwork() @@ -128,7 +161,6 @@ def __init__(self, input='data', input_layer='conv-6', input_layer_conv_act='rel self.rezero = rezero - def _create_ff_module(self, prefix_name, i, source, block_scale_var): """ Add Feed Forward Module: @@ -139,126 +171,192 @@ def _create_ff_module(self, prefix_name, i, source, block_scale_var): :return: last layer name of this module :rtype: str """ - prefix_name = prefix_name + '_ffmod_{}'.format(i) + prefix_name = prefix_name + "_ffmod_{}".format(i) - ln = self.network.add_layer_norm_layer('{}_ln'.format(prefix_name), source) + ln = self.network.add_layer_norm_layer("{}_ln".format(prefix_name), source) ff1 = self.network.add_linear_layer( - '{}_ff1'.format(prefix_name), ln, n_out=self.ff_dim, l2=self.l2, forward_weights_init=self.ff_init, - with_bias=self.ff_bias) + "{}_ff1".format(prefix_name), + ln, + n_out=self.ff_dim, + l2=self.l2, + forward_weights_init=self.ff_init, + with_bias=self.ff_bias, + ) - swish_act = self.network.add_activation_layer('{}_swish'.format(prefix_name), ff1, activation='swish') + swish_act = self.network.add_activation_layer("{}_swish".format(prefix_name), ff1, activation="swish") - drop1 = self.network.add_dropout_layer('{}_drop1'.format(prefix_name), swish_act, dropout=self.dropout) + drop1 = self.network.add_dropout_layer("{}_drop1".format(prefix_name), swish_act, dropout=self.dropout) ff2 = self.network.add_linear_layer( - '{}_ff2'.format(prefix_name), drop1, n_out=self.enc_key_dim, l2=self.l2, forward_weights_init=self.ff_init, - with_bias=self.ff_bias) + "{}_ff2".format(prefix_name), + drop1, + n_out=self.enc_key_dim, + l2=self.l2, + forward_weights_init=self.ff_init, + with_bias=self.ff_bias, + ) - drop2 = self.network.add_dropout_layer('{}_drop2'.format(prefix_name), ff2, dropout=self.dropout) + drop2 = self.network.add_dropout_layer("{}_drop2".format(prefix_name), ff2, dropout=self.dropout) if self.rezero: - drop2 = self.network.add_eval_layer('{}_scaled_dropout'.format(prefix_name), [block_scale_var, drop2], eval='source(0) * source(1)') + drop2 = self.network.add_eval_layer( + "{}_scaled_dropout".format(prefix_name), [block_scale_var, drop2], eval="source(0) * source(1)" + ) + + half_step_ff = self.network.add_eval_layer("{}_half_step".format(prefix_name), drop2, eval="0.5 * source(0)") - half_step_ff = self.network.add_eval_layer('{}_half_step'.format(prefix_name), drop2, eval='0.5 * source(0)') - ff_module_res = self.network.add_combine_layer( - '{}_res'.format(prefix_name), kind='add', source=[half_step_ff, source], n_out=self.enc_key_dim) + "{}_res".format(prefix_name), kind="add", source=[half_step_ff, source], n_out=self.enc_key_dim + ) return ff_module_res - def _create_global_extractor(self, prefix_name, source): - prefix_name = '{}_global_extractor'.format(prefix_name) + prefix_name = "{}_global_extractor".format(prefix_name) + + ln = self.network.add_layer_norm_layer("{}_ln".format(prefix_name), source) - ln = self.network.add_layer_norm_layer('{}_ln'.format(prefix_name), source) - ln_rel_pos_enc = self.network.add_relative_pos_encoding_layer( - '{}_ln_rel_pos_enc'.format(prefix_name), ln, n_out=self.enc_key_per_head_dim, forward_weights_init=self.ff_init) - + "{}_ln_rel_pos_enc".format(prefix_name), + ln, + n_out=self.enc_key_per_head_dim, + forward_weights_init=self.ff_init, + ) + mhsa = self.network.add_self_att_layer( - '{}'.format(prefix_name), ln, n_out=self.enc_value_dim, num_heads=self.att_num_heads, - total_key_dim=self.enc_key_dim, att_dropout=self.att_dropout, forward_weights_init=self.ff_init, - key_shift=ln_rel_pos_enc if ln_rel_pos_enc is not None else None) - + "{}".format(prefix_name), + ln, + n_out=self.enc_value_dim, + num_heads=self.att_num_heads, + total_key_dim=self.enc_key_dim, + att_dropout=self.att_dropout, + forward_weights_init=self.ff_init, + key_shift=ln_rel_pos_enc if ln_rel_pos_enc is not None else None, + ) + mhsa_linear = self.network.add_linear_layer( - '{}_linear'.format(prefix_name), mhsa, n_out=self.enc_key_dim, l2=self.l2, forward_weights_init=self.ff_init, - with_bias=False) - - dropout = self.network.add_dropout_layer('{}_dropout'.format(prefix_name), mhsa_linear, dropout=self.dropout) + "{}_linear".format(prefix_name), + mhsa, + n_out=self.enc_key_dim, + l2=self.l2, + forward_weights_init=self.ff_init, + with_bias=False, + ) + + dropout = self.network.add_dropout_layer("{}_dropout".format(prefix_name), mhsa_linear, dropout=self.dropout) return dropout - def _create_local_extractor(self, prefix_name, source): - prefix_name = '{}_local_extractor'.format(prefix_name) + prefix_name = "{}_local_extractor".format(prefix_name) - ln = self.network.add_layer_norm_layer('{}_ln'.format(prefix_name), source) + ln = self.network.add_layer_norm_layer("{}_ln".format(prefix_name), source) ff1 = self.network.add_linear_layer( - '{}_ff_1'.format(prefix_name), ln, n_out=6*self.enc_key_dim, l2=self.l2, forward_weights_init=self.ff_init, - with_bias=False) - - gelu_act = self.network.add_activation_layer('{}_gelu'.format(prefix_name), ff1, activation='gelu') + "{}_ff_1".format(prefix_name), + ln, + n_out=6 * self.enc_key_dim, + l2=self.l2, + forward_weights_init=self.ff_init, + with_bias=False, + ) + + gelu_act = self.network.add_activation_layer("{}_gelu".format(prefix_name), ff1, activation="gelu") - br_part_A = self.network.add_slice_layer('{}_branch_a'.format(prefix_name), gelu_act, 'F', slice_start=0, slice_end =self.enc_key_dim*3) + br_part_A = self.network.add_slice_layer( + "{}_branch_a".format(prefix_name), gelu_act, "F", slice_start=0, slice_end=self.enc_key_dim * 3 + ) - br_part_B = self.network.add_slice_layer('{}_branch_b'.format(prefix_name), gelu_act, 'F', slice_start =self.enc_key_dim*3) + br_part_B = self.network.add_slice_layer( + "{}_branch_b".format(prefix_name), gelu_act, "F", slice_start=self.enc_key_dim * 3 + ) - br_part_B_ln = self.network.add_layer_norm_layer('{}_branch_b_ln'.format(prefix_name), br_part_B) + br_part_B_ln = self.network.add_layer_norm_layer("{}_branch_b_ln".format(prefix_name), br_part_B) br_part_B_dpt_conv = self.network.add_conv_layer( - '{}_branch_b_dpt_conv'.format(prefix_name), br_part_B_ln, n_out=self.enc_key_dim*3, - filter_size=(self.conv_kernel_size,), groups=self.enc_key_dim*3, l2=self.l2) - - br_merge = self.network.add_eval_layer('{}_branch_merge'.format(prefix_name), [br_part_A,br_part_B_dpt_conv], 'source(0)*source(1)') + "{}_branch_b_dpt_conv".format(prefix_name), + br_part_B_ln, + n_out=self.enc_key_dim * 3, + filter_size=(self.conv_kernel_size,), + groups=self.enc_key_dim * 3, + l2=self.l2, + ) + + br_merge = self.network.add_eval_layer( + "{}_branch_merge".format(prefix_name), [br_part_A, br_part_B_dpt_conv], "source(0)*source(1)" + ) - dropout = self.network.add_dropout_layer('{}_dropout'.format(prefix_name), br_merge, dropout=self.dropout) + dropout = self.network.add_dropout_layer("{}_dropout".format(prefix_name), br_merge, dropout=self.dropout) br_merge_ff = self.network.add_linear_layer( - '{}_ff_2'.format(prefix_name), dropout, n_out=self.enc_key_dim, l2=self.l2, forward_weights_init=self.ff_init, - with_bias=False) - + "{}_ff_2".format(prefix_name), + dropout, + n_out=self.enc_key_dim, + l2=self.l2, + forward_weights_init=self.ff_init, + with_bias=False, + ) + return br_merge_ff - def _create_merge_mod(self, prefix_name, source, block_scale_var): - prefix_name = '{}_merge_mod'.format(prefix_name) + prefix_name = "{}_merge_mod".format(prefix_name) glb_ext = self._create_global_extractor(prefix_name, source) lcl_ext = self._create_local_extractor(prefix_name, source) - glb_lcl_merge = self.network.add_copy_layer('{}_global_local_merge'.format(prefix_name), [glb_ext, lcl_ext]) + glb_lcl_merge = self.network.add_copy_layer("{}_global_local_merge".format(prefix_name), [glb_ext, lcl_ext]) dpt_conv = self.network.add_conv_layer( - '{}_dpt_conv'.format(prefix_name), glb_lcl_merge, n_out= 2*self.enc_key_dim, - filter_size=(self.conv_kernel_size,), groups= 2*self.enc_key_dim, l2=self.l2) - + "{}_dpt_conv".format(prefix_name), + glb_lcl_merge, + n_out=2 * self.enc_key_dim, + filter_size=(self.conv_kernel_size,), + groups=2 * self.enc_key_dim, + l2=self.l2, + ) + dpt_conv_res = self.network.add_combine_layer( - '{}_dpt_conv_res'.format(prefix_name), kind='add', source=[glb_lcl_merge, dpt_conv], n_out=2*self.enc_key_dim) - + "{}_dpt_conv_res".format(prefix_name), + kind="add", + source=[glb_lcl_merge, dpt_conv], + n_out=2 * self.enc_key_dim, + ) + ff = self.network.add_linear_layer( - '{}_ff'.format(prefix_name), dpt_conv_res, n_out=self.enc_key_dim, l2=self.l2, forward_weights_init=self.ff_init, - with_bias=False) - - dropout = self.network.add_dropout_layer('{}_dropout'.format(prefix_name), ff, dropout=self.dropout) + "{}_ff".format(prefix_name), + dpt_conv_res, + n_out=self.enc_key_dim, + l2=self.l2, + forward_weights_init=self.ff_init, + with_bias=False, + ) + + dropout = self.network.add_dropout_layer("{}_dropout".format(prefix_name), ff, dropout=self.dropout) if self.rezero: - dropout = self.network.add_eval_layer('{}_scaled_dropout'.format(prefix_name), [block_scale_var, dropout], eval='source(0) * source(1)') + dropout = self.network.add_eval_layer( + "{}_scaled_dropout".format(prefix_name), [block_scale_var, dropout], eval="source(0) * source(1)" + ) merge_mod_res = self.network.add_combine_layer( - '{}_res'.format(prefix_name), kind='add', source=[source, dropout], n_out=self.enc_key_dim) - - return merge_mod_res + "{}_res".format(prefix_name), kind="add", source=[source, dropout], n_out=self.enc_key_dim + ) + return merge_mod_res def _create_e_branchformer_block(self, i, source): - prefix_name = 'ebranchformer_block_%02i' % i + prefix_name = "ebranchformer_block_%02i" % i if self.rezero: self.network["mod_%02i_var" % i] = { - "class": "variable", "init":1e-8, "trainable":True, "add_batch_axis":True, "shape":(1,) + "class": "variable", + "init": 1e-8, + "trainable": True, + "add_batch_axis": True, + "shape": (1,), } ff_module1 = self._create_ff_module(prefix_name, 1, source, "mod_%02i_var" % i) @@ -267,29 +365,30 @@ def _create_e_branchformer_block(self, i, source): ff_module2 = self._create_ff_module(prefix_name, 2, merge_module, "mod_%02i_var" % i) - block_ln = self.network.add_layer_norm_layer('{}_ln'.format(prefix_name), ff_module2) + block_ln = self.network.add_layer_norm_layer("{}_ln".format(prefix_name), ff_module2) block_ln = self.network.add_copy_layer(prefix_name, block_ln) - - return block_ln + return block_ln def _create_all_network_parts(self): """ - ConvSubsampling/LSTM -> Linear -> Dropout -> [Conformer Blocks] x N + ConvSubsampling/LSTM -> Linear -> Dropout -> [Conformer Blocks] x N """ data = self.input if self.specaug: data = self.network.add_eval_layer( - 'source', data, - eval="self.network.get_config().typed_value('transform')(source(0, as_data=True), network=self.network)") + "source", + data, + eval="self.network.get_config().typed_value('transform')(source(0, as_data=True), network=self.network)", + ) subsampled_input = None if self.input_layer is None: subsampled_input = data - elif 'lstm' in self.input_layer: - sample_factor = int(self.input_layer.split('-')[1]) + elif "lstm" in self.input_layer: + sample_factor = int(self.input_layer.split("-")[1]) pool_sizes = None if sample_factor == 2: pool_sizes = [2, 1] @@ -299,9 +398,16 @@ def _create_all_network_parts(self): pool_sizes = [3, 2] # add 2 LSTM layers with max pooling to subsample and encode positional information subsampled_input = self.network.add_lstm_layers( - data, num_layers=2, lstm_dim=self.enc_key_dim, dropout=self.lstm_dropout, bidirectional=True, - rec_weight_dropout=self.rec_weight_dropout, l2=self.l2, pool_sizes=pool_sizes) - elif self.input_layer == 'conv-4': + data, + num_layers=2, + lstm_dim=self.enc_key_dim, + dropout=self.lstm_dropout, + bidirectional=True, + rec_weight_dropout=self.rec_weight_dropout, + l2=self.l2, + pool_sizes=pool_sizes, + ) + elif self.input_layer == "conv-4": # conv-layer-1: 3x3x32 followed by max pool layer on feature axis (1, 2) # conv-layer-2: 3x3x64 with striding (2, 1) on time axis # conv-layer-3: 3x3x64 with striding (2, 1) on time axis @@ -309,31 +415,62 @@ def _create_all_network_parts(self): # TODO: make this more generic conv_input = self.network.add_conv_block( - 'conv_out', data, hwpc_sizes=[((3, 3), (1, 2), 32)], - l2=self.l2, activation=self.input_layer_conv_act, init=self.start_conv_init, merge_out=False) + "conv_out", + data, + hwpc_sizes=[((3, 3), (1, 2), 32)], + l2=self.l2, + activation=self.input_layer_conv_act, + init=self.start_conv_init, + merge_out=False, + ) subsampled_input = self.network.add_conv_block( - 'conv_merged', conv_input, hwpc_sizes=[((3, 3), (2, 1), 64), ((3, 3), (2, 1), 64)], - l2=self.l2, activation=self.input_layer_conv_act, init=self.start_conv_init, use_striding=True, - split_input=False, prefix_name='subsample_') - elif self.input_layer == 'conv-6': + "conv_merged", + conv_input, + hwpc_sizes=[((3, 3), (2, 1), 64), ((3, 3), (2, 1), 64)], + l2=self.l2, + activation=self.input_layer_conv_act, + init=self.start_conv_init, + use_striding=True, + split_input=False, + prefix_name="subsample_", + ) + elif self.input_layer == "conv-6": conv_input = self.network.add_conv_block( - 'conv_out', data, hwpc_sizes=[((3, 3), (1, 2), 32)], - l2=self.l2, activation=self.input_layer_conv_act, init=self.start_conv_init, merge_out=False) + "conv_out", + data, + hwpc_sizes=[((3, 3), (1, 2), 32)], + l2=self.l2, + activation=self.input_layer_conv_act, + init=self.start_conv_init, + merge_out=False, + ) subsampled_input = self.network.add_conv_block( - 'conv_merged', conv_input, hwpc_sizes=[((3, 3), (3, 1), 64), ((3, 3), (2, 1), 64)], - l2=self.l2, activation=self.input_layer_conv_act, init=self.start_conv_init, use_striding=True, - split_input=False, prefix_name='subsample_') + "conv_merged", + conv_input, + hwpc_sizes=[((3, 3), (3, 1), 64), ((3, 3), (2, 1), 64)], + l2=self.l2, + activation=self.input_layer_conv_act, + init=self.start_conv_init, + use_striding=True, + split_input=False, + prefix_name="subsample_", + ) assert subsampled_input is not None source_linear = self.network.add_linear_layer( - 'source_linear', subsampled_input, n_out=self.enc_key_dim, l2=self.l2, forward_weights_init=self.ff_init, - with_bias=False) + "source_linear", + subsampled_input, + n_out=self.enc_key_dim, + l2=self.l2, + forward_weights_init=self.ff_init, + with_bias=False, + ) if self.dropout_in: - source_linear = self.network.add_dropout_layer('source_dropout', source_linear, dropout=self.dropout_in) + source_linear = self.network.add_dropout_layer("source_dropout", source_linear, dropout=self.dropout_in) conformer_block_src = source_linear for i in range(1, self.num_blocks + 1): @@ -342,20 +479,26 @@ def _create_all_network_parts(self): encoder = self.network.add_copy_layer(self.output_layer_name, conformer_block_src) if self.with_ctc: - default_ctc_loss_opts = {'beam_width': 1} + default_ctc_loss_opts = {"beam_width": 1} if self.native_ctc: - default_ctc_loss_opts['use_native'] = True + default_ctc_loss_opts["use_native"] = True else: self.ctc_opts.update({"ignore_longer_outputs_than_inputs": True}) # always enable if self.ctc_opts: - default_ctc_loss_opts['ctc_opts'] = self.ctc_opts + default_ctc_loss_opts["ctc_opts"] = self.ctc_opts self.network.add_softmax_layer( - 'ctc', encoder, l2=self.ctc_l2, target=self.target, loss='ctc', dropout=self.ctc_dropout, - loss_opts=default_ctc_loss_opts, loss_scale=self.ctc_loss_scale) + "ctc", + encoder, + l2=self.ctc_l2, + target=self.target, + loss="ctc", + dropout=self.ctc_dropout, + loss_opts=default_ctc_loss_opts, + loss_scale=self.ctc_loss_scale, + ) return encoder - def _create_e_branchformer_blocks(self, input): conformer_block_src = input for i in range(1, self.num_blocks + 1): @@ -363,9 +506,5 @@ def _create_e_branchformer_blocks(self, input): encoder = self.network.add_copy_layer(self.output_layer_name, conformer_block_src) return encoder - def create_network(self): return self._create_all_network_parts() - - - From 974b7de55f4d38ca13c5c34753abbb4445c430f4 Mon Sep 17 00:00:00 2001 From: Simon Berger Date: Wed, 15 May 2024 19:50:39 +0200 Subject: [PATCH 014/227] Update users/berger --- users/berger/args/jobs/rasr_init_args.py | 25 ++ users/berger/args/returnn/config.py | 1 + .../20230602_rescale_baselines/__init__.py | 2 + .../config_01_conformer_ctc.py | 1 + .../config_01b_conformer_ctc_logmel.py | 1 + .../config_04a_conformer_transducer_bpe.py | 3 +- ...onfig_04a_conformer_transducer_bpe_rasr.py | 225 +++++++++++++ .../config_04b_conformer_transducer_phon.py | 68 ++-- users/berger/helpers/returnn.py | 25 +- users/berger/pytorch/forward/transducer.py | 42 ++- .../pytorch/forward/transducer_beam_search.py | 4 + users/berger/pytorch/models/conformer_ctc.py | 13 +- .../pytorch/models/conformer_transducer_v2.py | 307 +++++++++++------- .../berger/pytorch/train_steps/transducer.py | 5 +- .../recipe/rasr/label_tree_and_scorer.py | 7 +- users/berger/settings.py | 23 +- users/berger/systems/dataclasses.py | 1 + users/berger/systems/functors/rasr_base.py | 11 +- .../functors/recognition/returnn_search.py | 1 + .../functors/recognition/seq2seq_search.py | 2 + users/berger/systems/functors/seq2seq_base.py | 22 +- 21 files changed, 585 insertions(+), 204 deletions(-) create mode 100644 users/berger/configs/tedlium2/20230602_rescale_baselines/config_04a_conformer_transducer_bpe_rasr.py diff --git a/users/berger/args/jobs/rasr_init_args.py b/users/berger/args/jobs/rasr_init_args.py index 40b956324..c5cb4ab2b 100644 --- a/users/berger/args/jobs/rasr_init_args.py +++ b/users/berger/args/jobs/rasr_init_args.py @@ -91,6 +91,7 @@ def get_feature_extraction_args_16kHz( gt_args: Optional[Dict] = None, ) -> Dict: mfcc_filter_width = features.filter_width_from_channels(channels=20, f_max=8000) # = 16000 / 2 + filterbank_filter_width = features.filter_width_from_channels(channels=80, f_max=8000) # = 16000 / 2 if mfcc_cepstrum_options is None: mfcc_cepstrum_options = { @@ -142,6 +143,30 @@ def get_feature_extraction_args_16kHz( "normalization_options": {}, } }, + "filterbank": { + "filterbank_options": { + "warping_function": "mel", + "filter_width": filterbank_filter_width, + "normalize": False, + "normalization_options": {}, + "without_samples": False, + "samples_options": { + "audio_format": "wav", + # "scale_input": 2**-15, + "dc_detection": dc_detection, + }, + "fft_options": { + "preemphasis": 0.97, + "window_type": "hanning", + "window_shift": 0.01, + "window_length": 0.025, + }, + "apply_log": True, + "add_epsilon": True, + "add_features_output": True, + # "warp_differential_unit": False, + }, + }, "energy": { "energy_options": { "without_samples": False, diff --git a/users/berger/args/returnn/config.py b/users/berger/args/returnn/config.py index 694f9844d..3578d45cb 100644 --- a/users/berger/args/returnn/config.py +++ b/users/berger/args/returnn/config.py @@ -21,6 +21,7 @@ def get_base_config(backend: Backend) -> Dict[str, Any]: elif backend == Backend.PYTORCH: result["backend"] = "torch" result["use_lovely_tensors"] = True + # result["torch_amp"] = {"dtype": "bfloat16"} else: raise NotImplementedError return result diff --git a/users/berger/configs/tedlium2/20230602_rescale_baselines/__init__.py b/users/berger/configs/tedlium2/20230602_rescale_baselines/__init__.py index 7f4f1e0a3..949f5fa7d 100644 --- a/users/berger/configs/tedlium2/20230602_rescale_baselines/__init__.py +++ b/users/berger/configs/tedlium2/20230602_rescale_baselines/__init__.py @@ -7,6 +7,7 @@ from .config_01_conformer_ctc import py as py_01 from .config_04a_conformer_transducer_bpe import py as py_04a +from .config_04a_conformer_transducer_bpe_rasr import py as py_04a_rasr from .config_04b_conformer_transducer_phon import py as py_04b @@ -88,6 +89,7 @@ def worker_wrapper(job, task_name, call): copy.deepcopy(py_01()), copy.deepcopy(py_01b()), copy.deepcopy(py_04a()), + copy.deepcopy(py_04a_rasr()), copy.deepcopy(py_04b()), ]: subreport.collapse([SummaryKey.CORPUS.value], best_selector_key=SummaryKey.ERR.value) diff --git a/users/berger/configs/tedlium2/20230602_rescale_baselines/config_01_conformer_ctc.py b/users/berger/configs/tedlium2/20230602_rescale_baselines/config_01_conformer_ctc.py index 7b8e38745..f2c222a29 100644 --- a/users/berger/configs/tedlium2/20230602_rescale_baselines/config_01_conformer_ctc.py +++ b/users/berger/configs/tedlium2/20230602_rescale_baselines/config_01_conformer_ctc.py @@ -114,6 +114,7 @@ def run_exp() -> SummaryReport: prior_scales=[0.5], lm_scales=[1.1], feature_type=FeatureType.GAMMATONE_16K, + search_stats=True, ) # ********** System ********** diff --git a/users/berger/configs/tedlium2/20230602_rescale_baselines/config_01b_conformer_ctc_logmel.py b/users/berger/configs/tedlium2/20230602_rescale_baselines/config_01b_conformer_ctc_logmel.py index 5bffbc40d..2e62a39cb 100644 --- a/users/berger/configs/tedlium2/20230602_rescale_baselines/config_01b_conformer_ctc_logmel.py +++ b/users/berger/configs/tedlium2/20230602_rescale_baselines/config_01b_conformer_ctc_logmel.py @@ -42,6 +42,7 @@ def returnn_config_generator( extra_config = { "train": train_data_config, "dev": dev_data_config, + "torch_amp": {"dtype": "bfloat16"}, } if variant == ConfigVariant.TRAIN: diff --git a/users/berger/configs/tedlium2/20230602_rescale_baselines/config_04a_conformer_transducer_bpe.py b/users/berger/configs/tedlium2/20230602_rescale_baselines/config_04a_conformer_transducer_bpe.py index 3b09d9869..301506b5c 100644 --- a/users/berger/configs/tedlium2/20230602_rescale_baselines/config_04a_conformer_transducer_bpe.py +++ b/users/berger/configs/tedlium2/20230602_rescale_baselines/config_04a_conformer_transducer_bpe.py @@ -59,6 +59,7 @@ def returnn_config_generator( "train": train_data_config, "dev": dev_data_config, "max_seq_length": {"audio_features": 560000}, + "torch_amp": {"dtype": "bfloat16"}, } serializer = model.get_train_serializer(model_config, **kwargs) @@ -159,7 +160,7 @@ def run_exp() -> SummaryReport: data.train_data_config, data.cv_data_config, data.forward_data_config, - beam_sizes=[1, 2, 4], + beam_sizes=[1, 2, 3], ), ) diff --git a/users/berger/configs/tedlium2/20230602_rescale_baselines/config_04a_conformer_transducer_bpe_rasr.py b/users/berger/configs/tedlium2/20230602_rescale_baselines/config_04a_conformer_transducer_bpe_rasr.py new file mode 100644 index 000000000..ddd8a5a6f --- /dev/null +++ b/users/berger/configs/tedlium2/20230602_rescale_baselines/config_04a_conformer_transducer_bpe_rasr.py @@ -0,0 +1,225 @@ +import copy +import os +from typing import List, Optional +from i6_core.returnn.config import ReturnnConfig + +from sisyphus import gs, tk + +import i6_core.rasr as rasr +from i6_experiments.users.berger.args.experiments import transducer as exp_args +from i6_experiments.users.berger.args.returnn.config import get_returnn_config, Backend +from i6_experiments.users.berger.args.returnn.learning_rates import LearningRateSchedules, Optimizers +from i6_experiments.users.berger.corpus.tedlium2.bpe_transducer_data import get_tedlium2_data_dumped_bpe_labels +from i6_experiments.users.berger.pytorch.models import conformer_transducer_v2 as model +from i6_experiments.users.berger.recipe.summary.report import SummaryReport +from i6_experiments.users.berger.systems.dataclasses import ConfigVariant, EncDecConfig, FeatureType, ReturnnConfigs +from i6_experiments.users.berger.systems.returnn_seq2seq_system import ReturnnSeq2SeqSystem +from i6_experiments.users.berger.util import default_tools_v2 +from i6_experiments.users.berger.systems.functors.recognition.returnn_search import LexiconType +from i6_experiments.users.berger.systems.functors.rasr_base import RecognitionScoringType + +# ********** Settings ********** + +rasr.flow.FlowNetwork.default_flags = {"cache_mode": "task_dependent"} + +num_outputs = 1068 +num_subepochs = 500 + +tools = copy.deepcopy(default_tools_v2) +tools.rasr_binary_path = tk.Path("/u/berger/repositories/rasr_versions/gen_seq2seq_dev/arch/linux-x86_64-standard") + + +# ********** Return Config generators ********** + + +def returnn_config_generator( + train_data_config: dict, + dev_data_config: dict, + **kwargs, +) -> ReturnnConfig: + model_config = model.get_default_config_v1(num_outputs=num_outputs) + + extra_config = { + "train": train_data_config, + "dev": dev_data_config, + "max_seq_length": {"audio_features": 560000}, + "torch_amp": {"dtype": "bfloat16"}, + } + serializer = model.get_train_serializer(model_config, **kwargs) + + return get_returnn_config( + num_epochs=num_subepochs, + num_inputs=1, + num_outputs=num_outputs, + target="classes", + extra_python=[serializer], + extern_data_config=True, + backend=Backend.PYTORCH, + grad_noise=0.0, + grad_clip=0.0, + optimizer=Optimizers.AdamW, + schedule=LearningRateSchedules.OCLR, + initial_lr=1e-06, + peak_lr=8e-05, + decayed_lr=1e-05, + final_lr=1e-08, + batch_size=10000 * 160, + use_chunking=False, + extra_config=extra_config, + ) + + +def recog_returnn_configs_generator( + **kwargs, +) -> EncDecConfig[ReturnnConfig]: + model_config = model.get_default_config_v1(num_outputs=num_outputs) + + enc_extra_config = { + "extern_data": { + "sources": {"dim": 80, "dtype": "float32"}, + }, + "model_outputs": { + "source_encodings": { + "dim": 384, + "dtype": "float32", + }, + }, + } + dec_extra_config = { + "extern_data": { + "source_encodings": { + "dim": 384, + "time_dim_axis": None, + "dtype": "float32", + }, + "targets": { + "dim": num_outputs, + "time_dim_axis": None, + "sparse": True, + "shape": (1,), + "dtype": "int32", + }, + }, + "model_outputs": { + "log_probs": { + "dim": num_outputs, + "time_dim_axis": None, + "dtype": "float32", + } + }, + } + enc_serializer = model.get_encoder_recog_serializer(model_config, **kwargs) + dec_serializer = model.get_decoder_recog_serializer(model_config, **kwargs) + + return EncDecConfig( + encoder_config=get_returnn_config( + num_inputs=80, + num_outputs=num_outputs, + target=None, + extra_python=[enc_serializer], + extern_data_config=False, + backend=Backend.PYTORCH, + extra_config=enc_extra_config, + ), + decoder_config=get_returnn_config( + num_inputs=1, + num_outputs=num_outputs, + target=None, + # python_prolog=["from returnn.tensor.dim import Dim, batch_dim"], + extra_python=[dec_serializer], + extern_data_config=False, + backend=Backend.PYTORCH, + extra_config=dec_extra_config, + ), + ) + + +def get_returnn_config_collection( + train_data_config: dict, + dev_data_config: dict, + **kwargs, +) -> ReturnnConfigs[ReturnnConfig]: + return ReturnnConfigs( + train_config=returnn_config_generator( + train_data_config=train_data_config, + dev_data_config=dev_data_config, + blank_id=0, + **kwargs, + ), + recog_configs={ + "recog": recog_returnn_configs_generator( + train_data_config=train_data_config, + dev_data_config=dev_data_config, + **kwargs, + ) + }, + ) + + +def run_exp() -> SummaryReport: + assert tools.returnn_root + assert tools.returnn_python_exe + assert tools.rasr_binary_path + data = get_tedlium2_data_dumped_bpe_labels( + num_classes=num_outputs, + returnn_root=tools.returnn_root, + returnn_python_exe=tools.returnn_python_exe, + rasr_binary_path=tools.rasr_binary_path, + augmented_lexicon=True, + feature_type=FeatureType.SAMPLES, + ) + + # ********** Step args ********** + + train_args = exp_args.get_transducer_train_step_args(num_epochs=num_subepochs, gpu_mem_rqmt=24) + recog_args = exp_args.get_transducer_recog_step_args( + num_classes=num_outputs, + epochs=[500], + lm_scales=[0.5], + label_scorer_type="onnx-ffnn-transducer", + label_scorer_args={"extra_args": {"start_label_index": 0}}, + reduction_subtrahend=3, + reduction_factor=4, + feature_type=FeatureType.LOGMEL_16K, + ) + + # ********** System ********** + + system = ReturnnSeq2SeqSystem(tools) + + system.init_corpora( + dev_keys=data.dev_keys, + test_keys=data.test_keys, + corpus_data=data.data_inputs, + am_args=exp_args.transducer_recog_am_args, + ) + system.setup_scoring() + + # ********** Returnn Configs ********** + + system.add_experiment_configs( + "Conformer_Transducer", + get_returnn_config_collection( + data.train_data_config, + data.cv_data_config, + ), + ) + + system.run_train_step(**train_args) + system.run_dev_recog_step(**recog_args) + + assert system.summary_report + return system.summary_report + + +def py() -> SummaryReport: + filename_handle = os.path.splitext(os.path.basename(__file__))[0][len("config_") :] + gs.ALIAS_AND_OUTPUT_SUBDIR = f"{filename_handle}/" + + summary_report = SummaryReport() + + summary_report.merge_report(run_exp(), update_structure=True) + + tk.register_report(f"{gs.ALIAS_AND_OUTPUT_SUBDIR}/summary.report", summary_report) + + return summary_report diff --git a/users/berger/configs/tedlium2/20230602_rescale_baselines/config_04b_conformer_transducer_phon.py b/users/berger/configs/tedlium2/20230602_rescale_baselines/config_04b_conformer_transducer_phon.py index 3e220f3bc..b6c026453 100644 --- a/users/berger/configs/tedlium2/20230602_rescale_baselines/config_04b_conformer_transducer_phon.py +++ b/users/berger/configs/tedlium2/20230602_rescale_baselines/config_04b_conformer_transducer_phon.py @@ -1,13 +1,10 @@ import copy import os -from typing import List, Optional -from i6_core.returnn.config import ReturnnConfig - -from sisyphus import gs, tk import i6_core.rasr as rasr +from i6_core.returnn.config import CodeWrapper, ReturnnConfig from i6_experiments.users.berger.args.experiments import transducer as exp_args -from i6_experiments.users.berger.args.returnn.config import get_returnn_config, Backend +from i6_experiments.users.berger.args.returnn.config import Backend, get_returnn_config from i6_experiments.users.berger.args.returnn.learning_rates import LearningRateSchedules, Optimizers from i6_experiments.users.berger.corpus.tedlium2.phon_transducer_data import get_tedlium2_data_dumped_labels from i6_experiments.users.berger.pytorch.models import conformer_transducer_v2 as model @@ -20,7 +17,7 @@ ) from i6_experiments.users.berger.systems.returnn_seq2seq_system import ReturnnSeq2SeqSystem from i6_experiments.users.berger.util import default_tools_v2 -from i6_experiments.users.berger.systems.functors.recognition.returnn_search import LexiconType +from sisyphus import gs, tk # ********** Settings ********** @@ -47,6 +44,7 @@ def returnn_config_generator( "train": train_data_config, "dev": dev_data_config, "max_seq_length": {"audio_features": 560000}, + "torch_amp": {"dtype": "bfloat16"}, } serializer = model.get_train_serializer(model_config, **kwargs) @@ -78,16 +76,36 @@ def recog_returnn_configs_generator( model_config = model.get_default_config_v1(num_outputs=num_outputs) enc_extra_config = { + "extern_data": { + "sources": {"dim": 80, "dtype": "float32"}, + }, "model_outputs": { - "encoder": { - "dim": model_config.transcriber_cfg.dim, - } + "source_encodings": { + "dim": 384, + "dtype": "float32", + }, }, } dec_extra_config = { + "extern_data": { + "source_encodings": { + "dim": 384, + "time_dim_axis": None, + "dtype": "float32", + }, + "targets": { + "dim": num_outputs, + "time_dim_axis": None, + "sparse": True, + "shape": (1,), + "dtype": "int32", + }, + }, "model_outputs": { "log_probs": { "dim": num_outputs, + "time_dim_axis": None, + "dtype": "float32", } }, } @@ -96,11 +114,11 @@ def recog_returnn_configs_generator( return EncDecConfig( encoder_config=get_returnn_config( - num_inputs=1, + num_inputs=80, num_outputs=num_outputs, target=None, extra_python=[enc_serializer], - extern_data_config=True, + extern_data_config=False, backend=Backend.PYTORCH, extra_config=enc_extra_config, ), @@ -108,8 +126,9 @@ def recog_returnn_configs_generator( num_inputs=1, num_outputs=num_outputs, target=None, + # python_prolog=["from returnn.tensor.dim import Dim, batch_dim"], extra_python=[dec_serializer], - extern_data_config=True, + extern_data_config=False, backend=Backend.PYTORCH, extra_config=dec_extra_config, ), @@ -148,11 +167,15 @@ def run_exp() -> SummaryReport: # ********** Step args ********** train_args = exp_args.get_transducer_train_step_args(num_epochs=num_subepochs, gpu_mem_rqmt=24) - recog_args = { - "epochs": [500], - "prior_scales": [0.0], - "lm_scales": [0.0], - } + recog_args = exp_args.get_transducer_recog_step_args( + num_classes=num_outputs, + epochs=[num_subepochs], + label_scorer_type="onnx-ffnn-transducer", + label_scorer_args={"extra_args": {"start_label_index": 0}}, + reduction_subtrahend=3, + reduction_factor=4, + feature_type=FeatureType.LOGMEL_16K, + ) # ********** System ********** @@ -193,16 +216,7 @@ def run_exp() -> SummaryReport: system.run_train_step(**train_args) - system.run_dev_recog_step( - recog_exp_names={ - exp_name: [ - recog_exp_name for recog_exp_name in system.get_recog_exp_names()[exp_name] if dev_key in recog_exp_name - ] - for dev_key in data.dev_keys - for exp_name in system.get_exp_names() - }, - **recog_args, - ) + system.run_dev_recog_step(**recog_args) assert system.summary_report return system.summary_report diff --git a/users/berger/helpers/returnn.py b/users/berger/helpers/returnn.py index 65887972c..86d5d6a38 100644 --- a/users/berger/helpers/returnn.py +++ b/users/berger/helpers/returnn.py @@ -1,4 +1,6 @@ +from typing import Any from i6_core import returnn +from i6_core.returnn.config import CodeWrapper from sisyphus import tk from i6_experiments.users.berger.util import ToolPaths from i6_core.returnn import ReturnnConfig @@ -16,6 +18,23 @@ def get_native_lstm_op(tool_paths: ToolPaths) -> tk.Path: return compile_job.out_op +def _replace_proxies_by_code_wrappers(obj: Any) -> Any: + """ + A ReturnnDimTagsProxy.DimRefProxy can currently not be hashed and sisyphus' extract_paths() also does not work, + because the parent attribute contains a set which again contains the original object which leads to recursion errors. + We could fix this in ReturnnDimTagsProxy.DimRefProxy, but for now just replace them with a CodeWrapper. + """ + from returnn_common.nn.naming import ReturnnDimTagsProxy + + if isinstance(obj, (ReturnnDimTagsProxy.SetProxy, ReturnnDimTagsProxy.DimRefProxy)): + return CodeWrapper(str(obj)) + elif isinstance(obj, dict): + return {k: _replace_proxies_by_code_wrappers(v) for k, v in obj.items()} + elif isinstance(obj, (list, tuple)): + return type(obj)([_replace_proxies_by_code_wrappers(x) for x in obj]) + return obj + + def serialize_dim_tags(config: ReturnnConfig) -> ReturnnConfig: """ Serialize dim tags in a given RETURNN config. @@ -26,8 +45,10 @@ def serialize_dim_tags(config: ReturnnConfig) -> ReturnnConfig: dim_tags_proxy = ReturnnDimTagsProxy() config_serialized = dim_tags_proxy.collect_dim_tags_and_transform_config(config.config) if dim_tags_proxy.py_code_str(): - config.config["network"] = _replace_proxies_by_code_wrappers(config_serialized["network"]) - config.config["extern_data"] = _replace_proxies_by_code_wrappers(config_serialized["extern_data"]) + if "network" in config.config: + config.config["network"] = _replace_proxies_by_code_wrappers(config_serialized["network"]) + if "extern_data" in config.config: + config.config["extern_data"] = _replace_proxies_by_code_wrappers(config_serialized["extern_data"]) python_prolog_ext = ( "from returnn.tf.util.data import Dim, batch_dim, single_step_dim, SpatialDim, FeatureDim\n\n" + dim_tags_proxy.py_code_str() diff --git a/users/berger/pytorch/forward/transducer.py b/users/berger/pytorch/forward/transducer.py index d084d4b6c..b9b1caaf4 100644 --- a/users/berger/pytorch/forward/transducer.py +++ b/users/berger/pytorch/forward/transducer.py @@ -14,48 +14,45 @@ def encoder_forward_step(*, model: FFNNTransducerEncoderOnly, extern_data: TensorDict, **_): - audio_features = extern_data["data"].raw_tensor - assert audio_features is not None - audio_features = map_tensor_to_minus1_plus1_interval(audio_features) + sources = extern_data["sources"].raw_tensor + assert sources is not None - audio_feature_lengths = extern_data["data"].dims[1].dyn_size_ext.raw_tensor - assert audio_feature_lengths is not None + source_lengths = extern_data["sources"].dims[1].dyn_size_ext.raw_tensor + assert source_lengths is not None device = torch.device("cuda" if torch.cuda.is_available() else "cpu") - encoder_outputs, encoder_output_lengths = model( - features=audio_features.to(device), - features_size=audio_feature_lengths.to(device), + source_encodings, source_lengths = model( + sources=sources.to(device), + source_lengths=source_lengths.to(device), ) # [B, T, E], [B] import returnn.frontend as rf run_ctx = rf.get_run_ctx() if run_ctx.expected_outputs is not None: - run_ctx.expected_outputs["encoder_outputs"].dims[1].dyn_size_ext.raw_tensor = encoder_output_lengths - run_ctx.mark_as_output(encoder_outputs, name="encoder_outputs") + run_ctx.expected_outputs["source_encodings"].dims[1].dyn_size_ext.raw_tensor = source_lengths + run_ctx.mark_as_output(source_encodings, name="source_encodings") def decoder_forward_step(*, model: FFNNTransducerDecoderOnly, extern_data: TensorDict, **_): - encoder = extern_data["encoder"].raw_tensor - assert encoder is not None + source_encodings = extern_data["source_encodings"].raw_tensor + assert source_encodings is not None - history = extern_data["history"].raw_tensor - assert history is not None + targets = extern_data["targets"].raw_tensor + assert targets is not None device = torch.device("cuda" if torch.cuda.is_available() else "cpu") - encoder_outputs, encoder_output_lengths = model( - features=encoder.to(device), - features_size=audio_feature_lengths.to(device), - ) # [B, T, E], [B] + log_probs = model( + source_encodings=source_encodings.to(device), + targets=targets.to(device), + ) # [B, C] import returnn.frontend as rf run_ctx = rf.get_run_ctx() - if run_ctx.expected_outputs is not None: - run_ctx.expected_outputs["encoder_outputs"].dims[1].dyn_size_ext.raw_tensor = encoder_output_lengths - run_ctx.mark_as_output(encoder_outputs, name="encoder_outputs") + run_ctx.mark_as_output(log_probs, name="log_probs") def monotonic_timesync_beam_search_forward_step( @@ -63,7 +60,8 @@ def monotonic_timesync_beam_search_forward_step( ): audio_features = extern_data["data"].raw_tensor assert audio_features is not None - audio_features = map_tensor_to_minus1_plus1_interval(audio_features) + # audio_features = map_tensor_to_minus1_plus1_interval(audio_features) + audio_features = audio_features.float() assert extern_data["data"].dims[1].dyn_size_ext is not None audio_feature_lengths = extern_data["data"].dims[1].dyn_size_ext.raw_tensor diff --git a/users/berger/pytorch/forward/transducer_beam_search.py b/users/berger/pytorch/forward/transducer_beam_search.py index 0d09c3fdc..0b8de6cb2 100644 --- a/users/berger/pytorch/forward/transducer_beam_search.py +++ b/users/berger/pytorch/forward/transducer_beam_search.py @@ -41,6 +41,8 @@ def monotonic_timesync_beam_search( # Compute encoder once enc, enc_lengths = model.transcribe(features, feature_lengths) # [1, T, E], [1] + print("encoder outputs:") + print(enc[0, :3, :5]) T = int(enc_lengths[0].cpu().item()) def predict_next( @@ -85,6 +87,7 @@ def predict_next( assert new_pred_history_state is not None + print("Predict with encoder state ", enc_state[0, 0, :5], "token", recent_token) log_probs, _, _ = model.join( # [1, C] (packed) or [1, 1, 1, C] (not packed)) source_encodings=enc_state, source_lengths=torch.tensor([1], device=enc.device), @@ -92,6 +95,7 @@ def predict_next( target_lengths=torch.tensor([1], device=enc.device), ) log_probs = log_probs.squeeze() # [C] + print("Probs: ", torch.exp(log_probs[:5])) # extend hypothesis with all possible next classes for c in range(log_probs.size(0)): diff --git a/users/berger/pytorch/models/conformer_ctc.py b/users/berger/pytorch/models/conformer_ctc.py index 36939c210..370bf4ea1 100644 --- a/users/berger/pytorch/models/conformer_ctc.py +++ b/users/berger/pytorch/models/conformer_ctc.py @@ -9,7 +9,10 @@ from i6_experiments.users.berger.pytorch.serializers.basic import ( get_basic_pt_network_serializer, ) -from i6_models.primitives.feature_extraction import LogMelFeatureExtractionV1, LogMelFeatureExtractionV1Config +from i6_models.primitives.feature_extraction import ( + RasrCompatibleLogMelFeatureExtractionV1, + RasrCompatibleLogMelFeatureExtractionV1Config, +) from i6_models.parts.frontend.generic_frontend import ( GenericFrontendV1, GenericFrontendV1Config, @@ -314,17 +317,13 @@ def get_default_config_v2(num_inputs: int, num_outputs: int) -> ConformerCTCConf def get_default_config_v3(num_outputs: int) -> ConformerCTCConfig: feature_extraction = ModuleFactoryV1( - module_class=LogMelFeatureExtractionV1, - cfg=LogMelFeatureExtractionV1Config( + module_class=RasrCompatibleLogMelFeatureExtractionV1, + cfg=RasrCompatibleLogMelFeatureExtractionV1Config( sample_rate=16000, win_size=0.025, hop_size=0.01, - f_min=60, - f_max=7600, min_amp=1e-10, num_filters=80, - center=False, - n_fft=400, ), ) specaugment = ModuleFactoryV1( diff --git a/users/berger/pytorch/models/conformer_transducer_v2.py b/users/berger/pytorch/models/conformer_transducer_v2.py index 1f47d0b9e..32ab9d10f 100644 --- a/users/berger/pytorch/models/conformer_transducer_v2.py +++ b/users/berger/pytorch/models/conformer_transducer_v2.py @@ -1,27 +1,28 @@ from dataclasses import dataclass from enum import Enum, auto -from typing import List, Optional, Union, Callable, Tuple +from typing import Callable, List, Optional, Tuple, Union +import i6_models.assemblies.conformer as conformer_i6 +import i6_models.parts.conformer as conformer_parts_i6 import torch -from torchaudio.models import rnnt - from i6_core.returnn.config import CodeWrapper from i6_experiments.common.setups.returnn_pytorch.serialization import Collection from i6_experiments.common.setups.serialization import Import, PartialImport from i6_experiments.users.berger.pytorch.serializers.basic import ( get_basic_pt_network_serializer, ) -from i6_models.parts.frontend.vgg_act import VGG4LayerActFrontendV1, VGG4LayerActFrontendV1Config -import i6_models.parts.conformer as conformer_parts_i6 -import i6_models.assemblies.conformer as conformer_i6 from i6_models.config import ModelConfiguration, ModuleFactoryV1 -from i6_models.primitives.feature_extraction import LogMelFeatureExtractionV1, LogMelFeatureExtractionV1Config -from .util import lengths_to_padding_mask +from i6_models.parts.frontend.generic_frontend import FrontendLayerType, GenericFrontendV1, GenericFrontendV1Config +from i6_models.primitives.feature_extraction import ( + RasrCompatibleLogMelFeatureExtractionV1, + RasrCompatibleLogMelFeatureExtractionV1Config, +) from ..custom_parts.specaugment import ( - SpecaugmentConfigV1, - SpecaugmentModuleV1, + SpecaugmentByLengthConfigV1, + SpecaugmentByLengthModuleV1, ) +from .util import lengths_to_padding_mask @dataclass @@ -29,42 +30,52 @@ class TransducerTranscriberConfig(ModelConfiguration): feature_extraction: ModuleFactoryV1 specaugment: ModuleFactoryV1 encoder: ModuleFactoryV1 - dim: int - target_size: int -class TransducerTranscriber(rnnt._Transcriber, torch.nn.Module): +class TransducerTranscriber(torch.nn.Module): def __init__(self, cfg: TransducerTranscriberConfig, **_) -> None: super().__init__() self.feature_extraction = cfg.feature_extraction() self.specaugment = cfg.specaugment() self.encoder = cfg.encoder() - self.final_linear = torch.nn.Linear(cfg.dim, cfg.target_size) def forward( self, - input: torch.Tensor, # [B, T, F] - lengths: torch.Tensor, # [B] + sources: torch.Tensor, # [B, T, F] + source_lengths: torch.Tensor, # [B] ) -> Tuple[torch.Tensor, torch.Tensor]: # [B, T, C], [B] with torch.no_grad(): - input = input.squeeze(-1) - x, lengths = self.feature_extraction(input, lengths) - sequence_mask = lengths_to_padding_mask(lengths) + sources = sources.squeeze(-1) + x, source_lengths = self.feature_extraction(sources, source_lengths) + print("Features: ", x[0, :3, :5]) + sequence_mask = lengths_to_padding_mask(source_lengths) x = self.specaugment(x) # [B, T, F] x, sequence_mask = self.encoder(x, sequence_mask) # [B, T, E], [B, T] - x = self.final_linear(x) # [B, T, C] return x, torch.sum(sequence_mask, dim=1).to(torch.int32) # [B, T, C], [B] - def infer( + +class TransducerTranscriberNoFeatExtr(torch.nn.Module): + def __init__(self, cfg: TransducerTranscriberConfig, **_) -> None: + super().__init__() + self.specaugment = cfg.specaugment() + self.encoder = cfg.encoder() + + def forward( self, - input: torch.Tensor, # [B, T, F], - lengths: torch.Tensor, # [B] - states: Optional[List[List[torch.Tensor]]], - ) -> Tuple[torch.Tensor, torch.Tensor, List[List[torch.Tensor]]]: - raise NotImplementedError + sources: torch.Tensor, # [B, T, F] + source_lengths: torch.Tensor, # [B] + ) -> Tuple[torch.Tensor, torch.Tensor]: # [B, T, C], [B] + with torch.no_grad(): + sequence_mask = lengths_to_padding_mask(source_lengths) + + x = self.specaugment(sources) # [B, T, F] + + x, sequence_mask = self.encoder(x, sequence_mask) # [B, T, E], [B, T] + + return x, torch.sum(sequence_mask, dim=1).to(torch.int32) # [B, T, C], [B] @dataclass @@ -82,10 +93,10 @@ class FFNNTransducerPredictorConfig(ModelConfiguration): class FFNNTransducerPredictor(torch.nn.Module): def __init__(self, cfg: FFNNTransducerPredictorConfig, **_) -> None: super().__init__() - self.embedding = torch.nn.Embedding(num_embeddings=cfg.target_size, embedding_dim=cfg.context_embedding_size) - self.blank_id = cfg.blank_id - + self.embedding = torch.nn.Embedding( + num_embeddings=cfg.target_size, embedding_dim=cfg.context_embedding_size, padding_idx=self.blank_id + ) self.context_history_size = cfg.context_history_size prediction_layers = [] prev_size = self.context_history_size * cfg.context_embedding_size @@ -95,14 +106,12 @@ def __init__(self, cfg: FFNNTransducerPredictorConfig, **_) -> None: prediction_layers.append(cfg.activation) prev_size = cfg.layer_size - self.network = torch.nn.Sequential( - *prediction_layers, torch.nn.Dropout(cfg.dropout), torch.nn.Linear(prev_size, cfg.target_size) - ) + self.network = torch.nn.Sequential(*prediction_layers) def forward( self, - input: torch.Tensor, # [B, S], - lengths: torch.Tensor, # [B], + targets: torch.Tensor, # [B, S], + target_lengths: torch.Tensor, # [B], state: Optional[ List[List[torch.Tensor]] ] = None, # Most recently fed inputs, used for higher order context, shape [[[B, H-1]]]; list of lists for compatibility with torchaudio @@ -114,23 +123,23 @@ def forward( # extend input by prepending either the state if it's given or some history consisting of blanks if state is None: prepend = torch.full( - (input.size(0), self.context_history_size - 1), + (targets.size(0), self.context_history_size - 1), fill_value=self.blank_id, - dtype=input.dtype, - device=input.device, + dtype=targets.dtype, + device=targets.device, ) # [B, H-1] # print("Predictor received no state. Use", prepend.deeper()) else: prepend = state[0][0] # [B, H-1] # print("Predictor received state", prepend.deeper()) - extended_input = torch.concat([prepend, input], dim=1) # [B, S+H-1] + extended_input = torch.concat([prepend, targets], dim=1) # [B, S+H-1] # print("extended input", extended_input.deeper()) if self.context_history_size > 1: return_state = extended_input[:, -(self.context_history_size - 1) :] # [B, H-1] else: return_state = torch.empty( - size=(input.size(0), 0), dtype=input.dtype, device=input.device + size=(targets.size(0), 0), dtype=targets.dtype, device=targets.device ) # [B, 0] = [B, H-1] # print("New state is ", return_state.deeper()) @@ -158,7 +167,7 @@ def forward( # "Repeat probabilities:", # torch.gather(torch.nn.functional.softmax(a, dim=-1), dim=-1, index=context[:, :, -2:-1]).deeper(), # ) - return a, lengths, [[return_state]] + return a, target_lengths, [[return_state]] class CombinationMode(Enum): @@ -170,6 +179,7 @@ class CombinationMode(Enum): class TransducerJoinerConfig(ModelConfiguration): layer_size: int act: torch.nn.Module + input_size: int target_size: int combination_mode: CombinationMode @@ -178,7 +188,7 @@ class TransducerJoiner(torch.nn.Module): def __init__(self, cfg: TransducerJoinerConfig, **_) -> None: super().__init__() self.network = torch.nn.Sequential( - torch.nn.Linear(cfg.target_size, cfg.layer_size), + torch.nn.Linear(cfg.input_size, cfg.layer_size), cfg.act, torch.nn.Linear(cfg.layer_size, cfg.target_size), ) @@ -213,7 +223,7 @@ class PackedTransducerJoiner(torch.nn.Module): def __init__(self, cfg: TransducerJoinerConfig, **_) -> None: super().__init__() self.network = torch.nn.Sequential( - torch.nn.Linear(cfg.target_size, cfg.layer_size), + torch.nn.Linear(cfg.input_size, cfg.layer_size), cfg.act, torch.nn.Linear(cfg.layer_size, cfg.target_size), ) @@ -260,62 +270,104 @@ class FFNNTransducerConfig(ModelConfiguration): joiner_cfg: TransducerJoinerConfig -class FFNNTransducer(rnnt.RNNT): +class FFNNTransducer(torch.nn.Module): def __init__(self, step: int, cfg: FFNNTransducerConfig, **_): - super().__init__( - transcriber=TransducerTranscriber(cfg.transcriber_cfg), - predictor=FFNNTransducerPredictor(cfg.predictor_cfg), - joiner=PackedTransducerJoiner(cfg.joiner_cfg), + super().__init__() + self.transcriber = TransducerTranscriber(cfg.transcriber_cfg) + self.predictor = FFNNTransducerPredictor(cfg.predictor_cfg) + self.joiner = PackedTransducerJoiner(cfg.joiner_cfg) + + def transcribe(self, sources: torch.Tensor, source_lengths: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]: + return self.transcriber(sources=sources, source_lengths=source_lengths) + + def predict( + self, targets: torch.Tensor, target_lengths: torch.Tensor, state: Optional[List[List[torch.Tensor]]] + ) -> Tuple[torch.Tensor, torch.Tensor, List[List[torch.Tensor]]]: + return self.predictor(targets=targets, target_lengths=target_lengths, state=state) + + def join( + self, + source_encodings: torch.Tensor, + source_lengths: torch.Tensor, + target_encodings: torch.Tensor, + target_lengths: torch.Tensor, + ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]: + return self.joiner( + source_encodings=source_encodings, + source_lengths=source_lengths, + target_encodings=target_encodings, + target_lengths=target_lengths, + ) + + def forward( + self, + sources: torch.Tensor, + source_lengths: torch.Tensor, + targets: torch.Tensor, + target_lengths: torch.Tensor, + predictor_state: Optional[List[List[torch.Tensor]]] = None, + ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor, List[List[torch.Tensor]]]: + source_encodings, source_lengths = self.transcribe(sources=sources, source_lengths=source_lengths) + target_encodings, target_lengths, state = self.predict( + targets=targets, target_lengths=target_lengths, state=predictor_state ) + output, source_lengths, target_lengths = self.join( + source_encodings=source_encodings, + source_lengths=source_lengths, + target_encodings=target_encodings, + target_lengths=target_lengths, + ) -class FFNNTransducerEncoderOnly(rnnt.RNNT): + return output, source_lengths, target_lengths, state + + +class FFNNTransducerEncoderOnly(torch.nn.Module): def __init__(self, step: int, cfg: FFNNTransducerConfig, **_): - super().__init__( - transcriber=TransducerTranscriber(cfg.transcriber_cfg), - predictor=None, - joiner=None, - ) + super().__init__() + self.transcriber = TransducerTranscriberNoFeatExtr(cfg.transcriber_cfg) def forward( self, - features: torch.Tensor, # [B, T, F] - features_size: torch.Tensor, # [B] + sources: torch.Tensor, # [B, T, F] + source_lengths: torch.Tensor, # [B] ) -> Tuple[torch.Tensor, torch.Tensor]: # [B, T', E] - return self.transcribe(sources=features, source_lengths=features_size) + return self.transcriber(sources=sources, source_lengths=source_lengths) -class FFNNTransducerDecoderOnly(rnnt.RNNT): +class FFNNTransducerDecoderOnly(torch.nn.Module): def __init__(self, step: int, cfg: FFNNTransducerConfig, **_): - super().__init__( - transcriber=None, - predictor=FFNNTransducerPredictor(cfg.predictor_cfg), - joiner=TransducerJoiner(cfg.joiner_cfg), - ) + super().__init__() + self.predictor = FFNNTransducerPredictor(cfg.predictor_cfg) + self.joiner = TransducerJoiner(cfg.joiner_cfg) def forward( self, - encoder: torch.Tensor, # [B, E] - history: torch.Tensor, # [B, H] + source_encodings: torch.Tensor, # [B, E] + targets: torch.Tensor, # [B, H] ) -> torch.Tensor: # [B, C] - dec_history_state = [[history[:, :-1]]] # [[[B, H-1]]] - dec_current_label = history[:, -1:] # [B, 1] - dec_length = torch.tensor([1] * history.size(0), device=history.device) # [B] + dec_state = [[targets[:, :-1]]] # [[[B, H-1]]] + dec_current_label = targets[:, -1:] # [B, 1] + dec_length = torch.tensor([1] * targets.size(0), device=targets.device) # [B] - decoder, _, _ = self.predict( - targets=dec_current_label, target_lengths=dec_length, state=dec_history_state + decoder, _, _ = self.predictor( + targets=dec_current_label, target_lengths=dec_length, state=dec_state ) # [B, 1, P] - encoder = encoder.unsqueeze(1) # [B, 1, E] + source_encodings = source_encodings.unsqueeze(1) # [B, 1, E] - joint_output, _, _ = self.join( - source_encodings=encoder, source_lengths=dec_length, target_encodings=decoder, target_lengths=dec_length + joint_output, _, _ = self.joiner( + source_encodings=source_encodings, + source_lengths=dec_length, + target_encodings=decoder, + target_lengths=dec_length, ) # [B, 1, 1, C] - return joint_output.squeeze((1, 2)) # [B, C] + return joint_output.squeeze(2).squeeze(1) # [B, C] def get_train_serializer(model_config: FFNNTransducerConfig, **kwargs) -> Collection: + assert __package__ is not None pytorch_package = __package__.rpartition(".")[0] return get_basic_pt_network_serializer( module_import_path=f"{__name__}.{FFNNTransducer.__name__}", @@ -332,6 +384,7 @@ def get_train_serializer(model_config: FFNNTransducerConfig, **kwargs) -> Collec def get_torchaudio_train_serializer(model_config: FFNNTransducerConfig, **kwargs) -> Collection: + assert __package__ is not None pytorch_package = __package__.rpartition(".")[0] return get_basic_pt_network_serializer( module_import_path=f"{__name__}.{FFNNTransducer.__name__}", @@ -348,6 +401,7 @@ def get_torchaudio_train_serializer(model_config: FFNNTransducerConfig, **kwargs def get_k2_train_serializer(model_config: FFNNTransducerConfig, **kwargs) -> Collection: + assert __package__ is not None pytorch_package = __package__.rpartition(".")[0] return get_basic_pt_network_serializer( module_import_path=f"{__name__}.{FFNNTransducer.__name__}", @@ -365,6 +419,7 @@ def get_k2_train_serializer(model_config: FFNNTransducerConfig, **kwargs) -> Col def get_pruned_k2_train_serializer(model_config: FFNNTransducerConfig, **kwargs) -> Collection: + assert __package__ is not None pytorch_package = __package__.rpartition(".")[0] return get_basic_pt_network_serializer( module_import_path=f"{__name__}.{FFNNTransducer.__name__}", @@ -382,24 +437,31 @@ def get_pruned_k2_train_serializer(model_config: FFNNTransducerConfig, **kwargs) def get_encoder_recog_serializer(model_config: FFNNTransducerConfig, **_) -> Collection: + assert __package__ is not None pytorch_package = __package__.rpartition(".")[0] return get_basic_pt_network_serializer( module_import_path=f"{__name__}.{FFNNTransducerEncoderOnly.__name__}", model_config=model_config, - additional_serializer_objects=[Import(f"{pytorch_package}.forward.transducer.encoder_forward_step")], + additional_serializer_objects=[ + Import(f"{pytorch_package}.forward.transducer.encoder_forward_step", import_as="forward_step") + ], ) def get_decoder_recog_serializer(model_config: FFNNTransducerConfig, **_) -> Collection: + assert __package__ is not None pytorch_package = __package__.rpartition(".")[0] return get_basic_pt_network_serializer( module_import_path=f"{__name__}.{FFNNTransducerDecoderOnly.__name__}", model_config=model_config, - additional_serializer_objects=[Import(f"{pytorch_package}.forward.transducer.decoder_forward_step")], + additional_serializer_objects=[ + Import(f"{pytorch_package}.forward.transducer.decoder_forward_step", import_as="forward_step") + ], ) def get_beam_search_serializer(model_config: FFNNTransducerConfig, **kwargs) -> Collection: + assert __package__ is not None pytorch_package = __package__.rpartition(".")[0] kwargs.setdefault("lexicon_file", CodeWrapper("lexicon_file")) return get_basic_pt_network_serializer( @@ -420,72 +482,74 @@ def get_beam_search_serializer(model_config: FFNNTransducerConfig, **kwargs) -> def get_default_config_v1(num_outputs: int) -> FFNNTransducerConfig: feature_extraction = ModuleFactoryV1( - module_class=LogMelFeatureExtractionV1, - cfg=LogMelFeatureExtractionV1Config( + module_class=RasrCompatibleLogMelFeatureExtractionV1, + cfg=RasrCompatibleLogMelFeatureExtractionV1Config( sample_rate=16000, win_size=0.025, hop_size=0.01, - f_min=60, - f_max=7600, - min_amp=1e-10, + min_amp=1.175494e-38, num_filters=80, - center=False, - n_fft=400, + alpha=0.97, ), ) specaugment = ModuleFactoryV1( - module_class=SpecaugmentModuleV1, - cfg=SpecaugmentConfigV1( - time_min_num_masks=1, - time_max_num_masks=1, - time_mask_max_size=15, - freq_min_num_masks=1, - freq_max_num_masks=8, + module_class=SpecaugmentByLengthModuleV1, + cfg=SpecaugmentByLengthConfigV1( + time_min_num_masks=2, + time_max_mask_per_n_frames=25, + time_mask_max_size=20, + freq_min_num_masks=2, + freq_max_num_masks=16, freq_mask_max_size=5, ), ) - frontend_cfg = VGG4LayerActFrontendV1Config( - in_features=80, - conv1_channels=32, - conv2_channels=32, - conv3_channels=64, - conv4_channels=64, - conv_kernel_size=(3, 3), - conv_padding=None, - pool1_kernel_size=(2, 2), - pool1_stride=None, - pool1_padding=None, - pool2_kernel_size=(2, 1), - pool2_stride=None, - pool2_padding=None, - activation=torch.nn.SiLU(), - out_features=512, + frontend = ModuleFactoryV1( + GenericFrontendV1, + GenericFrontendV1Config( + in_features=80, + layer_ordering=[ + FrontendLayerType.Conv2d, + FrontendLayerType.Conv2d, + FrontendLayerType.Pool2d, + FrontendLayerType.Conv2d, + FrontendLayerType.Conv2d, + FrontendLayerType.Pool2d, + FrontendLayerType.Activation, + ], + conv_kernel_sizes=[(3, 3), (3, 3), (3, 3), (3, 3)], + conv_paddings=None, + conv_out_dims=[32, 64, 64, 32], + conv_strides=[(1, 1), (1, 1), (1, 1), (1, 1)], + pool_kernel_sizes=[(2, 1), (2, 1)], + pool_strides=None, + pool_paddings=None, + activations=[torch.nn.ReLU()], + out_features=384, + ), ) - frontend = ModuleFactoryV1(VGG4LayerActFrontendV1, frontend_cfg) - ff_cfg = conformer_parts_i6.ConformerPositionwiseFeedForwardV1Config( - input_dim=512, - hidden_dim=2048, - dropout=0.1, + input_dim=384, + hidden_dim=1536, + dropout=0.2, activation=torch.nn.SiLU(), ) mhsa_cfg = conformer_parts_i6.ConformerMHSAV1Config( - input_dim=512, - num_att_heads=8, - att_weights_dropout=0.1, - dropout=0.1, + input_dim=384, + num_att_heads=6, + att_weights_dropout=0.2, + dropout=0.2, ) conv_cfg = conformer_parts_i6.ConformerConvolutionV1Config( - channels=512, + channels=384, kernel_size=31, - dropout=0.1, + dropout=0.2, activation=torch.nn.SiLU(), - norm=torch.nn.BatchNorm1d(num_features=512, affine=False), + norm=torch.nn.BatchNorm1d(num_features=384, affine=False), ) block_cfg = conformer_i6.ConformerBlockV1Config( @@ -504,26 +568,25 @@ def get_default_config_v1(num_outputs: int) -> FFNNTransducerConfig: feature_extraction=feature_extraction, specaugment=specaugment, encoder=ModuleFactoryV1(module_class=conformer_i6.ConformerEncoderV1, cfg=conformer_cfg), - dim=512, - target_size=num_outputs, ) predictor_cfg = FFNNTransducerPredictorConfig( layers=2, layer_size=640, activation=torch.nn.Tanh(), - dropout=0.1, + dropout=0.2, context_history_size=1, context_embedding_size=256, - target_size=num_outputs, blank_id=0, + target_size=num_outputs, ) joiner_cfg = TransducerJoinerConfig( + input_size=1024, layer_size=1024, act=torch.nn.Tanh(), target_size=num_outputs, - combination_mode=CombinationMode.SUM, + combination_mode=CombinationMode.CONCAT, ) return FFNNTransducerConfig( diff --git a/users/berger/pytorch/train_steps/transducer.py b/users/berger/pytorch/train_steps/transducer.py index a9e1ea4bb..ceaae3809 100644 --- a/users/berger/pytorch/train_steps/transducer.py +++ b/users/berger/pytorch/train_steps/transducer.py @@ -8,7 +8,8 @@ def train_step(*, model: torch.nn.Module, extern_data: TensorDict, blank_idx: in audio_features = extern_data["data"].raw_tensor assert audio_features is not None - audio_features = map_tensor_to_minus1_plus1_interval(audio_features) + audio_features = audio_features.float() + # audio_features = map_tensor_to_minus1_plus1_interval(audio_features) assert extern_data["data"].dims[1].dyn_size_ext is not None audio_feature_lengths = extern_data["data"].dims[1].dyn_size_ext.raw_tensor @@ -34,7 +35,7 @@ def train_step(*, model: torch.nn.Module, extern_data: TensorDict, blank_idx: in ) loss = monotonic_rnnt_loss( - acts=model_logits, + acts=model_logits.to(dtype=torch.float32), labels=targets, input_lengths=input_lengths, label_lengths=target_lengths, diff --git a/users/berger/recipe/rasr/label_tree_and_scorer.py b/users/berger/recipe/rasr/label_tree_and_scorer.py index 1b0c89493..cd1451d55 100644 --- a/users/berger/recipe/rasr/label_tree_and_scorer.py +++ b/users/berger/recipe/rasr/label_tree_and_scorer.py @@ -1,11 +1,13 @@ __all__ = ["LabelTree", "LabelScorer"] from typing import Any, Dict, Optional + +from i6_core import rasr from i6_experiments.users.berger import helpers -from sisyphus import * +from sisyphus import tk, setup_path +assert __package__ is not None Path = setup_path(__package__) -from i6_core import rasr class LabelTree: @@ -62,6 +64,7 @@ def apply_config( "tf-attention", "tf-rnn-transducer", "tf-ffnn-transducer", + "onnx-ffnn-transducer", ] diff --git a/users/berger/settings.py b/users/berger/settings.py index ed5e6899f..04308e1af 100644 --- a/users/berger/settings.py +++ b/users/berger/settings.py @@ -1,3 +1,4 @@ +import getpass import sys sys.path.append("/u/beck/dev/cachemanager/") @@ -10,6 +11,13 @@ def file_caching(path, is_output=False): return "`cf %s`" % path +CPU_SLOW_JOBLIST = [ + "ScliteJob", + "Hub5ScoreJob", + "PipelineJob", +] + + def check_engine_limits(current_rqmt, task): """ i6 support for gpu_mem @@ -20,6 +28,10 @@ def check_engine_limits(current_rqmt, task): current_rqmt["sbatch_args"] = ["-p", "gpu_24gb"] else: current_rqmt["sbatch_args"] = ["-p", "gpu_11gb"] + + if task._job.__class__.__name__ in CPU_SLOW_JOBLIST: + current_rqmt["sbatch_args"] = ["-p", "cpu_slow"] + return current_rqmt @@ -39,7 +51,7 @@ def engine(): return EngineSelector( engines={ - "short": LocalEngine(cpus=4, mem=8), + "short": LocalEngine(cpus=4, mem=16), "long": SimpleLinuxUtilityForResourceManagementEngine(default_rqmt=default_rqmt), }, default_engine="long", @@ -148,4 +160,11 @@ def worker_wrapper(job, task_name, call): ) TMP_PREFIX = "/var/tmp/" -DEFAULT_ENVIRONMENT_SET["TMPDIR"] = TMP_PREFIX +DEFAULT_ENVIRONMENT_SET.update( + { + "TMPDIR": TMP_PREFIX, + "TMP": TMP_PREFIX, + "NUMBA_CACHE_DIR": f"{TMP_PREFIX}/numba_cache_{getpass.getuser()}", # used for librosa + "PYTORCH_KERNEL_CACHE_PATH": f"{TMP_PREFIX}/pt_kernel_cache_{getpass.getuser()}", # used for cuda pytorch + } +) diff --git a/users/berger/systems/dataclasses.py b/users/berger/systems/dataclasses.py index ba2a4b831..4af5faf99 100644 --- a/users/berger/systems/dataclasses.py +++ b/users/berger/systems/dataclasses.py @@ -98,6 +98,7 @@ class FeatureType(Enum): CONCAT_SEC_GAMMATONE_16K = auto() CONCAT_MIX_GAMMATONE_16K = auto() CONCAT_SEC_MIX_GAMMATONE_16K = auto() + LOGMEL_16K = auto() @dataclass diff --git a/users/berger/systems/functors/rasr_base.py b/users/berger/systems/functors/rasr_base.py index 6f81dc284..b14fac1dd 100644 --- a/users/berger/systems/functors/rasr_base.py +++ b/users/berger/systems/functors/rasr_base.py @@ -117,6 +117,7 @@ def _make_base_feature_flow( feature_type.CONCAT_SEC_MIX_GAMMATONE_16K: partial( self._make_cached_concatenated_gt_feature_flow_16k, use_sec=True, use_mix=True ), + feature_type.LOGMEL_16K: self._make_base_logmel_feature_flow_16k, }[feature_type](corpus_info=corpus_info, **kwargs) def _make_base_sample_feature_flow(self, corpus_info: dataclasses.CorpusInfo, dc_detection: bool = False, **kwargs): @@ -218,11 +219,13 @@ def _make_cached_concatenated_gt_feature_flow_16k( return features.basic_cache_flow(cache_files=cache_files) def _make_base_logmel_feature_flow_16k(self, corpus_info: dataclasses.CorpusInfo, dc_detection: bool = False, **_): - gt_options = copy.deepcopy(get_feature_extraction_args_16kHz(dc_detection=dc_detection)["gt"]["gt_options"]) + filterbank_options = copy.deepcopy( + get_feature_extraction_args_16kHz(dc_detection=dc_detection)["filterbank"]["filterbank_options"] + ) audio_format = corpus_info.crp.audio_format - gt_options["samples_options"]["audio_format"] = audio_format - gt_options["add_features_output"] = True - return features.gammatone_flow(**gt_options) + filterbank_options["samples_options"]["audio_format"] = audio_format + filterbank_options["add_features_output"] = True + return features.filterbank_flow(**filterbank_options) @lru_cache_with_signature def _get_checkpoint( diff --git a/users/berger/systems/functors/recognition/returnn_search.py b/users/berger/systems/functors/recognition/returnn_search.py index c9ece62d8..fa2691880 100644 --- a/users/berger/systems/functors/recognition/returnn_search.py +++ b/users/berger/systems/functors/recognition/returnn_search.py @@ -137,6 +137,7 @@ def __call__( returnn_root=self.returnn_root, returnn_python_exe=self.returnn_python_exe, output_files=["search_out.py"], + mem_rqmt=8, ) if isinstance(epoch, str): diff --git a/users/berger/systems/functors/recognition/seq2seq_search.py b/users/berger/systems/functors/recognition/seq2seq_search.py index ba70e8200..7190de29d 100644 --- a/users/berger/systems/functors/recognition/seq2seq_search.py +++ b/users/berger/systems/functors/recognition/seq2seq_search.py @@ -112,6 +112,7 @@ def __call__( label_scorer=label_scorer, base_feature_flow=base_feature_flow, onnx_model=onnx_model, + feature_type=feature_type, **model_flow_args, ) else: @@ -128,6 +129,7 @@ def __call__( base_feature_flow=base_feature_flow, enc_onnx_model=enc_model, dec_onnx_model=dec_model, + feature_type=feature_type, **model_flow_args, ) else: diff --git a/users/berger/systems/functors/seq2seq_base.py b/users/berger/systems/functors/seq2seq_base.py index 3e63d22ac..ee897cae3 100644 --- a/users/berger/systems/functors/seq2seq_base.py +++ b/users/berger/systems/functors/seq2seq_base.py @@ -34,20 +34,17 @@ def _make_onnx_enc_dec_config_for_label_scorer( label_scorer: custom_rasr.LabelScorer, enc_onnx_model: tk.Path, dec_onnx_model: tk.Path, - enc_features_name: str = "features", - enc_features_size: str = "features:size1", - enc_output_name: str = "encoder", - enc_output_size: str = "encoder:size1", - dec_features_name: str = "encoder", - dec_features_size: str = "encoder:size1", - dec_history_name: str = "history", + enc_features_name: str = "sources", + enc_features_size: str = "sources:size1", + enc_output_name: str = "source_encodings", + dec_features_name: str = "source_encodings", + dec_history_name: str = "targets", dec_output_name: str = "log_probs", ) -> None: encoder_io_map = rasr.RasrConfig() encoder_io_map.features = enc_features_name encoder_io_map.features_size = enc_features_size encoder_io_map.encoder_output = enc_output_name - encoder_io_map.encoder_output_size = enc_output_size encoder_session = rasr.RasrConfig() encoder_session.file = enc_onnx_model @@ -56,7 +53,6 @@ def _make_onnx_enc_dec_config_for_label_scorer( decoder_io_map = rasr.RasrConfig() decoder_io_map.encoder_output = dec_features_name - decoder_io_map.encoder_output_size = dec_features_size decoder_io_map.feedback = dec_history_name decoder_io_map.output = dec_output_name @@ -65,10 +61,10 @@ def _make_onnx_enc_dec_config_for_label_scorer( decoder_session.inter_op_num_threads = 2 decoder_session.intra_op_num_threads = 2 - label_scorer.apply_config("encoder-io-map", encoder_io_map) - label_scorer.apply_config("encoder-session", encoder_session) - label_scorer.apply_config("decoder-io-map", decoder_io_map) - label_scorer.apply_config("decoder-session", decoder_session) + label_scorer.config.encoder_io_map = encoder_io_map + label_scorer.config.encoder_session = encoder_session + label_scorer.config.decoder_io_map = decoder_io_map + label_scorer.config.decoder_session = decoder_session def _get_tf_feature_flow_for_label_scorer( self, From 53ac13b5026d5dc65f20b3be65fba262eb292a73 Mon Sep 17 00:00:00 2001 From: schmitt Date: Thu, 16 May 2024 10:19:52 +0200 Subject: [PATCH 015/227] update --- .../returnn/config_builder_rf/base.py | 6 +- .../returnn/network_builder_rf/base.py | 144 +---- .../returnn/network_builder_rf/base_old.py | 203 +++++++ .../network_builder_rf/encoder/__init__.py | 0 .../network_builder_rf/encoder/global_.py | 157 ++++++ .../network_builder_rf/global_/decoder.py | 85 +++ .../network_builder_rf/global_/model.py | 137 ++--- .../global_/model_import.py | 172 ++++++ .../global_/model_old/README | 2 + .../global_/model_old/__init__.py | 0 .../global_/model_old/model.py | 220 ++++++++ .../global_/model_old/model_import.py | 172 ++++++ .../global_/model_old/recog.py | 315 +++++++++++ .../global_/model_old/train.py | 115 ++++ .../network_builder_rf/global_/recog.py | 39 +- .../network_builder_rf/global_/train.py | 12 +- .../network_builder_rf/segmental/model.py | 344 +++--------- .../segmental/model_new/__init__.py | 0 .../model_new/blank_model/__init__.py | 0 .../segmental/model_new/blank_model/model.py | 92 +++ .../segmental/model_new/blank_model/train.py | 55 ++ .../model_new/label_model/__init__.py | 0 .../segmental/model_new/label_model/model.py | 246 ++++++++ .../segmental/model_new/label_model/train.py | 75 +++ .../segmental/model_old/README | 2 + .../segmental/model_old/__init__.py | 0 .../segmental/model_old/model.py | 434 +++++++++++++++ .../segmental/{ => model_old}/model_import.py | 0 .../segmental/model_old/recog.py | 527 ++++++++++++++++++ .../segmental/model_old/train.py | 280 ++++++++++ .../network_builder_rf/segmental/recog.py | 66 +-- .../network_builder_rf/segmental/train.py | 182 ++---- .../network_builder_rf/segmental/utils.py | 43 +- .../center_window_att/baseline_v1/__init__.py | 51 +- .../center_window_att/baseline_v1/baseline.py | 9 +- .../center_window_att/train.py | 13 +- .../pipelines/pipeline_ls_conf/checkpoints.py | 4 +- .../global_att/baseline_v1/__init__.py | 15 +- 38 files changed, 3469 insertions(+), 748 deletions(-) create mode 100644 users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/base_old.py create mode 100644 users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/encoder/__init__.py create mode 100644 users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/encoder/global_.py create mode 100644 users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/decoder.py create mode 100644 users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/model_import.py create mode 100644 users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/model_old/README create mode 100644 users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/model_old/__init__.py create mode 100644 users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/model_old/model.py create mode 100644 users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/model_old/model_import.py create mode 100644 users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/model_old/recog.py create mode 100644 users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/model_old/train.py create mode 100644 users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/__init__.py create mode 100644 users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/blank_model/__init__.py create mode 100644 users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/blank_model/model.py create mode 100644 users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/blank_model/train.py create mode 100644 users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/label_model/__init__.py create mode 100644 users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/label_model/model.py create mode 100644 users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/label_model/train.py create mode 100644 users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_old/README create mode 100644 users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_old/__init__.py create mode 100644 users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_old/model.py rename users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/{ => model_old}/model_import.py (100%) create mode 100644 users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_old/recog.py create mode 100644 users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_old/train.py diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/config_builder_rf/base.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/config_builder_rf/base.py index 264a64b4f..156565816 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/config_builder_rf/base.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/config_builder_rf/base.py @@ -467,6 +467,7 @@ class SegmentalAttConfigBuilderRF(LibrispeechConformerConfigBuilderRF): def __init__( self, center_window_size: int, + decoder_version: Optional[int] = None, length_model_opts: Optional[Dict] = None, **kwargs ): @@ -476,8 +477,9 @@ def __init__( center_window_size=center_window_size, )) - if length_model_opts is not None: - self.config_dict["length_model_opts"] = length_model_opts + print(decoder_version) + if decoder_version: + self.config_dict["label_decoder_version"] = decoder_version def get_recog_config(self, opts: Dict): recog_config = super(SegmentalAttConfigBuilderRF, self).get_recog_config(opts) diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/base.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/base.py index 0f6fb5c3b..8f02d397a 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/base.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/base.py @@ -5,7 +5,6 @@ from returnn.tensor import Tensor, Dim, single_step_dim import returnn.frontend as rf -from returnn.frontend.encoder.conformer import ConformerEncoder, ConformerConvSubsample from i6_experiments.users.schmitt.returnn_frontend.model_interfaces.supports_label_scorer_torch import RFModelWithMakeLabelScorer @@ -13,55 +12,24 @@ _batch_size_factor = 160 -class BaseModel(rf.Module): +class BaseLabelDecoder(rf.Module): def __init__( self, - in_dim: Dim, *, - num_enc_layers: int = 12, + enc_out_dim: Dim, target_dim: Dim, - wb_target_dim: Optional[Dim] = None, blank_idx: int, - enc_aux_logits: Sequence[int] = (), # layers - enc_model_dim: Dim = Dim(name="enc", dimension=512), - enc_ff_dim: Dim = Dim(name="enc-ff", dimension=2048), - enc_att_num_heads: int = 4, - enc_conformer_layer_opts: Optional[Dict[str, Any]] = None, enc_key_total_dim: Dim = Dim(name="enc_key_total_dim", dimension=1024), att_num_heads: Dim = Dim(name="att_num_heads", dimension=1), att_dropout: float = 0.1, - enc_dropout: float = 0.1, - enc_att_dropout: float = 0.1, l2: float = 0.0001, language_model: Optional[RFModelWithMakeLabelScorer] = None, ): - super(BaseModel, self).__init__() - - from returnn.config import get_global_config - - config = get_global_config(return_empty_if_none=True) - - self.in_dim = in_dim - self.encoder = ConformerEncoder( - in_dim, - enc_model_dim, - ff_dim=enc_ff_dim, - input_layer=ConformerConvSubsample( - in_dim, - out_dims=[Dim(32, name="conv1"), Dim(64, name="conv2"), Dim(64, name="conv3")], - filter_sizes=[(3, 3), (3, 3), (3, 3)], - pool_sizes=[(1, 2)], - strides=[(1, 1), (3, 1), (2, 1)], - ), - encoder_layer_opts=enc_conformer_layer_opts, - num_layers=num_enc_layers, - num_heads=enc_att_num_heads, - dropout=enc_dropout, - att_dropout=enc_att_dropout, - ) + super(BaseLabelDecoder, self).__init__() self.target_dim = target_dim self.blank_idx = blank_idx + self.enc_out_dim = enc_out_dim self.enc_key_total_dim = enc_key_total_dim self.enc_key_per_head_dim = enc_key_total_dim.div_left(att_num_heads) @@ -69,16 +37,10 @@ def __init__( self.att_dropout = att_dropout self.dropout_broadcast = rf.dropout_broadcast_default() - self.enc_ctx = rf.Linear(self.encoder.out_dim, enc_key_total_dim) - self.enc_ctx_dropout = 0.2 - self.enc_win_dim = Dim(name="enc_win_dim", dimension=5) - - self.inv_fertility = rf.Linear(self.encoder.out_dim, att_num_heads, with_bias=False) - self.target_embed = rf.Embedding(target_dim, Dim(name="target_embed", dimension=640)) self.s = rf.ZoneoutLSTM( - self.target_embed.out_dim + att_num_heads * self.encoder.out_dim, + self.target_embed.out_dim + att_num_heads * enc_out_dim, Dim(name="lstm", dimension=1024), zoneout_factor_cell=0.15, zoneout_factor_output=0.05, @@ -93,7 +55,7 @@ def __init__( self.s_transformed = rf.Linear(self.s.out_dim, enc_key_total_dim, with_bias=False) self.energy = rf.Linear(enc_key_total_dim, att_num_heads, with_bias=False) self.readout_in = rf.Linear( - self.s.out_dim + self.target_embed.out_dim + att_num_heads * self.encoder.out_dim, + self.s.out_dim + self.target_embed.out_dim + att_num_heads * enc_out_dim, Dim(name="readout", dimension=1024), ) self.output_prob = rf.Linear(self.readout_in.out_dim // 2, target_dim) @@ -101,103 +63,9 @@ def __init__( for p in self.parameters(): p.weight_decay = l2 - if enc_aux_logits: - if not wb_target_dim: - wb_target_dim = target_dim + 1 - for i in enc_aux_logits: - setattr(self, f"enc_aux_logits_{i}", rf.Linear(self.encoder.out_dim, wb_target_dim)) - - self._specaugment_opts = { - "steps": config.typed_value("specaugment_steps") or (0, 1000, 2000), - "max_consecutive_spatial_dims": config.typed_value("specaugment_max_consecutive_spatial_dims") or 20, - "max_consecutive_feature_dims": config.typed_value("specaugment_max_consecutive_feature_dims") - or (_log_mel_feature_dim // 5), - "num_spatial_mask_factor": config.typed_value("specaugment_num_spatial_mask_factor") or 100, - } - - self._pretrain_opts: Optional[Dict[str, Any]] = config.typed_value("pretrain_opts") - - self._mixup = None - if config.typed_value("mixup", None) is not None: - from i6_experiments.users.schmitt.returnn_frontend.models.rf_mixup import Mixup, MixupOpts - - self._mixup = Mixup(feature_dim=self.in_dim, opts=MixupOpts(**config.typed_value("mixup"))) - # Note: Even though we have this here, it is not used in loop_step or decode_logits. # Instead, it is intended to make a separate label scorer for it. self.language_model = None self.language_model_make_label_scorer = None if language_model: self.language_model, self.language_model_make_label_scorer = language_model - - def encode( - self, - source: Tensor, - *, - in_spatial_dim: Dim, - collected_outputs: Optional[Dict[str, Tensor]] = None, - ) -> Tuple[Dict[str, Tensor], Dim]: - """encode, and extend the encoder output for things we need in the decoder""" - # log mel filterbank features - source, in_spatial_dim = rf.audio.log_mel_filterbank_from_raw( - source, - in_spatial_dim=in_spatial_dim, - out_dim=self.in_dim, - sampling_rate=16_000, - log_base=math.exp(2.3026), # almost 10.0 but not exactly... - ) - if self._mixup: - source = self._mixup(source, spatial_dim=in_spatial_dim) - # SpecAugment - source = rf.audio.specaugment( - source, - spatial_dim=in_spatial_dim, - feature_dim=self.in_dim, - **self._specaugment_opts, - ) - # Encoder including convolutional frontend - with _opt_apply_pretrain_to_encoder(self.encoder, collected_outputs, self._pretrain_opts): - enc, enc_spatial_dim = self.encoder( - source, in_spatial_dim=in_spatial_dim, collected_outputs=collected_outputs - ) - enc_ctx = self.enc_ctx(enc) - inv_fertility = rf.sigmoid(self.inv_fertility(enc)) - return dict(enc=enc, enc_ctx=enc_ctx, inv_fertility=inv_fertility), enc_spatial_dim - - -@contextlib.contextmanager -def _opt_apply_pretrain_to_encoder( - encoder: ConformerEncoder, collected_outputs: Optional[Dict[str, Tensor]], pretrain_opts: Optional[Dict[str, Any]] -): - """Function is run within RETURNN.""" - if not pretrain_opts: - yield - return - step = rf.get_run_ctx().step - steps: Union[Sequence[Tuple[int, Dict[str, Any]]], Dict[int, Dict[str, Any]]] = pretrain_opts["steps"] - if isinstance(steps, (list, tuple)): - steps_ = {} - step_bound = 0 - for step_bound_rel, opts in steps: - step_bound += step_bound_rel - steps_[step_bound] = opts - steps = steps_ - assert isinstance(steps, dict) - for step_bound, opts in sorted(steps.items()): - if step < step_bound: - assert isinstance(opts, dict) - opts_ = opts.copy() - # somewhat hacky but that is still the easiest way I can think of, without touching a lot of other code - pretrain_num_layers = opts_.pop("num_layers") - assert not opts_, f"unhandled opts: {opts_} in opts {opts} for step bound {step_bound}" - orig_layers = encoder.layers[:] - del encoder.layers[pretrain_num_layers:] - yield - encoder.layers[:] = orig_layers - if collected_outputs is not None: - assert len(collected_outputs) == pretrain_num_layers - for i in range(pretrain_num_layers, len(orig_layers)): - collected_outputs[str(i)] = collected_outputs[str(pretrain_num_layers - 1)] - return - yield - return diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/base_old.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/base_old.py new file mode 100644 index 000000000..0f6fb5c3b --- /dev/null +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/base_old.py @@ -0,0 +1,203 @@ +from typing import Optional, Dict, Any, Sequence, Tuple, List, Union, TYPE_CHECKING +import contextlib +import math +import functools + +from returnn.tensor import Tensor, Dim, single_step_dim +import returnn.frontend as rf +from returnn.frontend.encoder.conformer import ConformerEncoder, ConformerConvSubsample + +from i6_experiments.users.schmitt.returnn_frontend.model_interfaces.supports_label_scorer_torch import RFModelWithMakeLabelScorer + +_log_mel_feature_dim = 80 +_batch_size_factor = 160 + + +class BaseModel(rf.Module): + def __init__( + self, + in_dim: Dim, + *, + num_enc_layers: int = 12, + target_dim: Dim, + wb_target_dim: Optional[Dim] = None, + blank_idx: int, + enc_aux_logits: Sequence[int] = (), # layers + enc_model_dim: Dim = Dim(name="enc", dimension=512), + enc_ff_dim: Dim = Dim(name="enc-ff", dimension=2048), + enc_att_num_heads: int = 4, + enc_conformer_layer_opts: Optional[Dict[str, Any]] = None, + enc_key_total_dim: Dim = Dim(name="enc_key_total_dim", dimension=1024), + att_num_heads: Dim = Dim(name="att_num_heads", dimension=1), + att_dropout: float = 0.1, + enc_dropout: float = 0.1, + enc_att_dropout: float = 0.1, + l2: float = 0.0001, + language_model: Optional[RFModelWithMakeLabelScorer] = None, + ): + super(BaseModel, self).__init__() + + from returnn.config import get_global_config + + config = get_global_config(return_empty_if_none=True) + + self.in_dim = in_dim + self.encoder = ConformerEncoder( + in_dim, + enc_model_dim, + ff_dim=enc_ff_dim, + input_layer=ConformerConvSubsample( + in_dim, + out_dims=[Dim(32, name="conv1"), Dim(64, name="conv2"), Dim(64, name="conv3")], + filter_sizes=[(3, 3), (3, 3), (3, 3)], + pool_sizes=[(1, 2)], + strides=[(1, 1), (3, 1), (2, 1)], + ), + encoder_layer_opts=enc_conformer_layer_opts, + num_layers=num_enc_layers, + num_heads=enc_att_num_heads, + dropout=enc_dropout, + att_dropout=enc_att_dropout, + ) + + self.target_dim = target_dim + self.blank_idx = blank_idx + + self.enc_key_total_dim = enc_key_total_dim + self.enc_key_per_head_dim = enc_key_total_dim.div_left(att_num_heads) + self.att_num_heads = att_num_heads + self.att_dropout = att_dropout + self.dropout_broadcast = rf.dropout_broadcast_default() + + self.enc_ctx = rf.Linear(self.encoder.out_dim, enc_key_total_dim) + self.enc_ctx_dropout = 0.2 + self.enc_win_dim = Dim(name="enc_win_dim", dimension=5) + + self.inv_fertility = rf.Linear(self.encoder.out_dim, att_num_heads, with_bias=False) + + self.target_embed = rf.Embedding(target_dim, Dim(name="target_embed", dimension=640)) + + self.s = rf.ZoneoutLSTM( + self.target_embed.out_dim + att_num_heads * self.encoder.out_dim, + Dim(name="lstm", dimension=1024), + zoneout_factor_cell=0.15, + zoneout_factor_output=0.05, + use_zoneout_output=False, # like RETURNN/TF ZoneoutLSTM old default + # parts_order="icfo", # like RETURNN/TF ZoneoutLSTM + # parts_order="ifco", + parts_order="jifo", # NativeLSTM (the code above converts it...) + forget_bias=0.0, # the code above already adds it during conversion + ) + + self.weight_feedback = rf.Linear(att_num_heads, enc_key_total_dim, with_bias=False) + self.s_transformed = rf.Linear(self.s.out_dim, enc_key_total_dim, with_bias=False) + self.energy = rf.Linear(enc_key_total_dim, att_num_heads, with_bias=False) + self.readout_in = rf.Linear( + self.s.out_dim + self.target_embed.out_dim + att_num_heads * self.encoder.out_dim, + Dim(name="readout", dimension=1024), + ) + self.output_prob = rf.Linear(self.readout_in.out_dim // 2, target_dim) + + for p in self.parameters(): + p.weight_decay = l2 + + if enc_aux_logits: + if not wb_target_dim: + wb_target_dim = target_dim + 1 + for i in enc_aux_logits: + setattr(self, f"enc_aux_logits_{i}", rf.Linear(self.encoder.out_dim, wb_target_dim)) + + self._specaugment_opts = { + "steps": config.typed_value("specaugment_steps") or (0, 1000, 2000), + "max_consecutive_spatial_dims": config.typed_value("specaugment_max_consecutive_spatial_dims") or 20, + "max_consecutive_feature_dims": config.typed_value("specaugment_max_consecutive_feature_dims") + or (_log_mel_feature_dim // 5), + "num_spatial_mask_factor": config.typed_value("specaugment_num_spatial_mask_factor") or 100, + } + + self._pretrain_opts: Optional[Dict[str, Any]] = config.typed_value("pretrain_opts") + + self._mixup = None + if config.typed_value("mixup", None) is not None: + from i6_experiments.users.schmitt.returnn_frontend.models.rf_mixup import Mixup, MixupOpts + + self._mixup = Mixup(feature_dim=self.in_dim, opts=MixupOpts(**config.typed_value("mixup"))) + + # Note: Even though we have this here, it is not used in loop_step or decode_logits. + # Instead, it is intended to make a separate label scorer for it. + self.language_model = None + self.language_model_make_label_scorer = None + if language_model: + self.language_model, self.language_model_make_label_scorer = language_model + + def encode( + self, + source: Tensor, + *, + in_spatial_dim: Dim, + collected_outputs: Optional[Dict[str, Tensor]] = None, + ) -> Tuple[Dict[str, Tensor], Dim]: + """encode, and extend the encoder output for things we need in the decoder""" + # log mel filterbank features + source, in_spatial_dim = rf.audio.log_mel_filterbank_from_raw( + source, + in_spatial_dim=in_spatial_dim, + out_dim=self.in_dim, + sampling_rate=16_000, + log_base=math.exp(2.3026), # almost 10.0 but not exactly... + ) + if self._mixup: + source = self._mixup(source, spatial_dim=in_spatial_dim) + # SpecAugment + source = rf.audio.specaugment( + source, + spatial_dim=in_spatial_dim, + feature_dim=self.in_dim, + **self._specaugment_opts, + ) + # Encoder including convolutional frontend + with _opt_apply_pretrain_to_encoder(self.encoder, collected_outputs, self._pretrain_opts): + enc, enc_spatial_dim = self.encoder( + source, in_spatial_dim=in_spatial_dim, collected_outputs=collected_outputs + ) + enc_ctx = self.enc_ctx(enc) + inv_fertility = rf.sigmoid(self.inv_fertility(enc)) + return dict(enc=enc, enc_ctx=enc_ctx, inv_fertility=inv_fertility), enc_spatial_dim + + +@contextlib.contextmanager +def _opt_apply_pretrain_to_encoder( + encoder: ConformerEncoder, collected_outputs: Optional[Dict[str, Tensor]], pretrain_opts: Optional[Dict[str, Any]] +): + """Function is run within RETURNN.""" + if not pretrain_opts: + yield + return + step = rf.get_run_ctx().step + steps: Union[Sequence[Tuple[int, Dict[str, Any]]], Dict[int, Dict[str, Any]]] = pretrain_opts["steps"] + if isinstance(steps, (list, tuple)): + steps_ = {} + step_bound = 0 + for step_bound_rel, opts in steps: + step_bound += step_bound_rel + steps_[step_bound] = opts + steps = steps_ + assert isinstance(steps, dict) + for step_bound, opts in sorted(steps.items()): + if step < step_bound: + assert isinstance(opts, dict) + opts_ = opts.copy() + # somewhat hacky but that is still the easiest way I can think of, without touching a lot of other code + pretrain_num_layers = opts_.pop("num_layers") + assert not opts_, f"unhandled opts: {opts_} in opts {opts} for step bound {step_bound}" + orig_layers = encoder.layers[:] + del encoder.layers[pretrain_num_layers:] + yield + encoder.layers[:] = orig_layers + if collected_outputs is not None: + assert len(collected_outputs) == pretrain_num_layers + for i in range(pretrain_num_layers, len(orig_layers)): + collected_outputs[str(i)] = collected_outputs[str(pretrain_num_layers - 1)] + return + yield + return diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/encoder/__init__.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/encoder/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/encoder/global_.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/encoder/global_.py new file mode 100644 index 000000000..ea397b0c9 --- /dev/null +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/encoder/global_.py @@ -0,0 +1,157 @@ +from typing import Optional, Dict, Any, Sequence, Tuple, List, Union, TYPE_CHECKING +import contextlib +import math +import functools + +from returnn.tensor import Tensor, Dim, single_step_dim +import returnn.frontend as rf +from returnn.frontend.encoder.conformer import ConformerEncoder, ConformerConvSubsample + +_log_mel_feature_dim = 80 +_batch_size_factor = 160 + + +class GlobalConformerEncoder(ConformerEncoder): + def __init__( + self, + in_dim: Dim, + out_dim: Dim = Dim(name="enc", dimension=512), + *, + num_layers: int = 12, + target_dim: Dim, + wb_target_dim: Optional[Dim] = None, + aux_logits: Sequence[int] = (), # layers + ff_dim: Dim = Dim(name="enc-ff", dimension=2048), + num_heads: int = 4, + encoder_layer_opts: Optional[Dict[str, Any]] = None, + enc_key_total_dim: Dim = Dim(name="enc_key_total_dim", dimension=1024), + dec_att_num_heads: Dim = Dim(name="att_num_heads", dimension=1), + dropout: float = 0.1, + att_dropout: float = 0.1, + l2: float = 0.0001, + ): + super(GlobalConformerEncoder, self).__init__( + in_dim, + out_dim, + ff_dim=ff_dim, + input_layer=ConformerConvSubsample( + in_dim, + out_dims=[Dim(32, name="conv1"), Dim(64, name="conv2"), Dim(64, name="conv3")], + filter_sizes=[(3, 3), (3, 3), (3, 3)], + pool_sizes=[(1, 2)], + strides=[(1, 1), (3, 1), (2, 1)], + ), + encoder_layer_opts=encoder_layer_opts, + num_layers=num_layers, + num_heads=num_heads, + dropout=dropout, + att_dropout=att_dropout, + ) + + from returnn.config import get_global_config + + config = get_global_config(return_empty_if_none=True) + + # self.in_dim = in_dim + + self.enc_ctx = rf.Linear(self.out_dim, enc_key_total_dim) + self.enc_ctx_dropout = 0.2 + + self.inv_fertility = rf.Linear(self.out_dim, dec_att_num_heads, with_bias=False) + + for p in self.parameters(): + p.weight_decay = l2 + + if aux_logits: + if not wb_target_dim: + wb_target_dim = target_dim + 1 + for i in aux_logits: + setattr(self, f"enc_aux_logits_{i}", rf.Linear(self.out_dim, wb_target_dim)) + + self._specaugment_opts = { + "steps": config.typed_value("specaugment_steps") or (0, 1000, 2000), + "max_consecutive_spatial_dims": config.typed_value("specaugment_max_consecutive_spatial_dims") or 20, + "max_consecutive_feature_dims": config.typed_value("specaugment_max_consecutive_feature_dims") + or (_log_mel_feature_dim // 5), + "num_spatial_mask_factor": config.typed_value("specaugment_num_spatial_mask_factor") or 100, + } + + self._pretrain_opts: Optional[Dict[str, Any]] = config.typed_value("pretrain_opts") + + self._mixup = None + if config.typed_value("mixup", None) is not None: + from i6_experiments.users.schmitt.returnn_frontend.models.rf_mixup import Mixup, MixupOpts + + self._mixup = Mixup(feature_dim=self.in_dim, opts=MixupOpts(**config.typed_value("mixup"))) + + def encode( + self, + source: Tensor, + *, + in_spatial_dim: Dim, + collected_outputs: Optional[Dict[str, Tensor]] = None, + ) -> Tuple[Dict[str, Tensor], Dim]: + """encode, and extend the encoder output for things we need in the decoder""" + # log mel filterbank features + source, in_spatial_dim = rf.audio.log_mel_filterbank_from_raw( + source, + in_spatial_dim=in_spatial_dim, + out_dim=self.in_dim, + sampling_rate=16_000, + log_base=math.exp(2.3026), # almost 10.0 but not exactly... + ) + if self._mixup: + source = self._mixup(source, spatial_dim=in_spatial_dim) + # SpecAugment + source = rf.audio.specaugment( + source, + spatial_dim=in_spatial_dim, + feature_dim=self.in_dim, + **self._specaugment_opts, + ) + # Encoder including convolutional frontend + with _opt_apply_pretrain_to_encoder(self, collected_outputs, self._pretrain_opts): + enc, enc_spatial_dim = self( + source, in_spatial_dim=in_spatial_dim, collected_outputs=collected_outputs + ) + enc_ctx = self.enc_ctx(enc) + inv_fertility = rf.sigmoid(self.inv_fertility(enc)) + return dict(enc=enc, enc_ctx=enc_ctx, inv_fertility=inv_fertility), enc_spatial_dim + + +@contextlib.contextmanager +def _opt_apply_pretrain_to_encoder( + encoder: ConformerEncoder, collected_outputs: Optional[Dict[str, Tensor]], pretrain_opts: Optional[Dict[str, Any]] +): + """Function is run within RETURNN.""" + if not pretrain_opts: + yield + return + step = rf.get_run_ctx().step + steps: Union[Sequence[Tuple[int, Dict[str, Any]]], Dict[int, Dict[str, Any]]] = pretrain_opts["steps"] + if isinstance(steps, (list, tuple)): + steps_ = {} + step_bound = 0 + for step_bound_rel, opts in steps: + step_bound += step_bound_rel + steps_[step_bound] = opts + steps = steps_ + assert isinstance(steps, dict) + for step_bound, opts in sorted(steps.items()): + if step < step_bound: + assert isinstance(opts, dict) + opts_ = opts.copy() + # somewhat hacky but that is still the easiest way I can think of, without touching a lot of other code + pretrain_num_layers = opts_.pop("num_layers") + assert not opts_, f"unhandled opts: {opts_} in opts {opts} for step bound {step_bound}" + orig_layers = encoder.layers[:] + del encoder.layers[pretrain_num_layers:] + yield + encoder.layers[:] = orig_layers + if collected_outputs is not None: + assert len(collected_outputs) == pretrain_num_layers + for i in range(pretrain_num_layers, len(orig_layers)): + collected_outputs[str(i)] = collected_outputs[str(pretrain_num_layers - 1)] + return + yield + return diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/decoder.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/decoder.py new file mode 100644 index 000000000..d55b163ae --- /dev/null +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/decoder.py @@ -0,0 +1,85 @@ +from typing import Optional, Dict, Any, Sequence, Tuple, List +import functools + +from returnn.tensor import Tensor, Dim, single_step_dim +import returnn.frontend as rf + +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.base import BaseLabelDecoder + + +class GlobalAttDecoder(BaseLabelDecoder): + def __init__(self, eos_idx: int, **kwargs): + super(GlobalAttDecoder, self).__init__(**kwargs) + + self.eos_idx = eos_idx + self.bos_idx = eos_idx + + def decoder_default_initial_state(self, *, batch_dims: Sequence[Dim], enc_spatial_dim: Dim) -> rf.State: + """Default initial state""" + state = rf.State( + s=self.s.default_initial_state(batch_dims=batch_dims), + att=rf.zeros(list(batch_dims) + [self.att_num_heads * self.enc_out_dim]), + accum_att_weights=rf.zeros( + list(batch_dims) + [enc_spatial_dim, self.att_num_heads], feature_dim=self.att_num_heads + ), + ) + state.att.feature_dim_axis = len(state.att.dims) - 1 + return state + + def loop_step_output_templates(self, batch_dims: List[Dim]) -> Dict[str, Tensor]: + """loop step out""" + return { + "s": Tensor( + "s", dims=batch_dims + [self.s.out_dim], dtype=rf.get_default_float_dtype(), feature_dim_axis=-1 + ), + "att": Tensor( + "att", + dims=batch_dims + [self.att_num_heads * self.enc_out_dim], + dtype=rf.get_default_float_dtype(), + feature_dim_axis=-1, + ), + } + + def loop_step( + self, + *, + enc: rf.Tensor, + enc_ctx: rf.Tensor, + inv_fertility: rf.Tensor, + enc_spatial_dim: Dim, + input_embed: rf.Tensor, + state: Optional[rf.State] = None, + ) -> Tuple[Dict[str, rf.Tensor], rf.State]: + """step of the inner loop""" + if state is None: + batch_dims = enc.remaining_dims( + remove=(enc.feature_dim, enc_spatial_dim) if enc_spatial_dim != single_step_dim else (enc.feature_dim,) + ) + state = self.decoder_default_initial_state(batch_dims=batch_dims, enc_spatial_dim=enc_spatial_dim) + state_ = rf.State() + + prev_att = state.att + + s, state_.s = self.s(rf.concat_features(input_embed, prev_att), state=state.s, spatial_dim=single_step_dim) + + weight_feedback = self.weight_feedback(state.accum_att_weights) + s_transformed = self.s_transformed(s) + energy_in = enc_ctx + weight_feedback + s_transformed + energy = self.energy(rf.tanh(energy_in)) + att_weights = rf.softmax(energy, axis=enc_spatial_dim) + + state_.accum_att_weights = state.accum_att_weights + att_weights * inv_fertility * 0.5 + att0 = rf.dot(att_weights, enc, reduce=enc_spatial_dim, use_mask=False) + att0.feature_dim = self.enc_out_dim + att, _ = rf.merge_dims(att0, dims=(self.att_num_heads, self.enc_out_dim)) + state_.att = att + + return {"s": s, "att": att}, state_ + + def decode_logits(self, *, s: Tensor, input_embed: Tensor, att: Tensor) -> Tensor: + """logits for the decoder""" + readout_in = self.readout_in(rf.concat_features(s, input_embed, att)) + readout = rf.reduce_out(readout_in, mode="max", num_pieces=2, out_dim=self.output_prob.in_dim) + readout = rf.dropout(readout, drop_prob=0.3, axis=self.dropout_broadcast and readout.feature_dim) + logits = self.output_prob(readout) + return logits diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/model.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/model.py index 5021ff1a9..e9d4165ab 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/model.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/model.py @@ -5,85 +5,66 @@ import returnn.frontend as rf from i6_experiments.users.schmitt.returnn_frontend.model_interfaces.model import ModelDef -from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.base import BaseModel +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.global_.decoder import GlobalAttDecoder +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.encoder.global_ import GlobalConformerEncoder from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.base import _batch_size_factor, _log_mel_feature_dim +from i6_experiments.users.schmitt.returnn_frontend.model_interfaces.supports_label_scorer_torch import RFModelWithMakeLabelScorer -class GlobalAttentionModel(BaseModel): - def __init__(self, eos_idx: int, **kwargs): - super(GlobalAttentionModel, self).__init__(**kwargs) - self.eos_idx = eos_idx - self.bos_idx = eos_idx +class GlobalAttentionModel(rf.Module): + def __init__( + self, + *, + target_dim: Dim, + blank_idx: int, + enc_key_total_dim: Dim = Dim(name="enc_key_total_dim", dimension=1024), + att_dropout: float = 0.1, + l2: float = 0.0001, + language_model: Optional[RFModelWithMakeLabelScorer] = None, + enc_in_dim: Dim, + enc_out_dim: Dim = Dim(name="enc", dimension=512), + enc_num_layers: int = 12, + enc_aux_logits: Sequence[int] = (), # layers + enc_ff_dim: Dim = Dim(name="enc-ff", dimension=2048), + enc_num_heads: int = 4, + encoder_layer_opts: Optional[Dict[str, Any]] = None, + dec_att_num_heads: Dim = Dim(name="att_num_heads", dimension=1), + enc_dropout: float = 0.1, + eos_idx: int, + ): + super(GlobalAttentionModel, self).__init__() + + self.encoder = GlobalConformerEncoder( + enc_in_dim, + enc_out_dim, + num_layers=enc_num_layers, + target_dim=target_dim, + wb_target_dim=None, + aux_logits=enc_aux_logits, + ff_dim=enc_ff_dim, + num_heads=enc_num_heads, + encoder_layer_opts=encoder_layer_opts, + enc_key_total_dim=enc_key_total_dim, + dec_att_num_heads=dec_att_num_heads, + dropout=enc_dropout, + att_dropout=att_dropout, + l2=l2, + ) - def decoder_default_initial_state(self, *, batch_dims: Sequence[Dim], enc_spatial_dim: Dim) -> rf.State: - """Default initial state""" - state = rf.State( - s=self.s.default_initial_state(batch_dims=batch_dims), - att=rf.zeros(list(batch_dims) + [self.att_num_heads * self.encoder.out_dim]), - accum_att_weights=rf.zeros( - list(batch_dims) + [enc_spatial_dim, self.att_num_heads], feature_dim=self.att_num_heads - ), + self.label_decoder = GlobalAttDecoder( + enc_out_dim=self.encoder.out_dim, + target_dim=target_dim, + att_num_heads=dec_att_num_heads, + att_dropout=att_dropout, + blank_idx=blank_idx, + enc_key_total_dim=enc_key_total_dim, + l2=l2, + language_model=language_model, + eos_idx=eos_idx, ) - state.att.feature_dim_axis = len(state.att.dims) - 1 - return state - - def loop_step_output_templates(self, batch_dims: List[Dim]) -> Dict[str, Tensor]: - """loop step out""" - return { - "s": Tensor( - "s", dims=batch_dims + [self.s.out_dim], dtype=rf.get_default_float_dtype(), feature_dim_axis=-1 - ), - "att": Tensor( - "att", - dims=batch_dims + [self.att_num_heads * self.encoder.out_dim], - dtype=rf.get_default_float_dtype(), - feature_dim_axis=-1, - ), - } - def loop_step( - self, - *, - enc: rf.Tensor, - enc_ctx: rf.Tensor, - inv_fertility: rf.Tensor, - enc_spatial_dim: Dim, - input_embed: rf.Tensor, - state: Optional[rf.State] = None, - ) -> Tuple[Dict[str, rf.Tensor], rf.State]: - """step of the inner loop""" - if state is None: - batch_dims = enc.remaining_dims( - remove=(enc.feature_dim, enc_spatial_dim) if enc_spatial_dim != single_step_dim else (enc.feature_dim,) - ) - state = self.decoder_default_initial_state(batch_dims=batch_dims, enc_spatial_dim=enc_spatial_dim) - state_ = rf.State() - - prev_att = state.att - - s, state_.s = self.s(rf.concat_features(input_embed, prev_att), state=state.s, spatial_dim=single_step_dim) - - weight_feedback = self.weight_feedback(state.accum_att_weights) - s_transformed = self.s_transformed(s) - energy_in = enc_ctx + weight_feedback + s_transformed - energy = self.energy(rf.tanh(energy_in)) - att_weights = rf.softmax(energy, axis=enc_spatial_dim) - - state_.accum_att_weights = state.accum_att_weights + att_weights * inv_fertility * 0.5 - att0 = rf.dot(att_weights, enc, reduce=enc_spatial_dim, use_mask=False) - att0.feature_dim = self.encoder.out_dim - att, _ = rf.merge_dims(att0, dims=(self.att_num_heads, self.encoder.out_dim)) - state_.att = att - - return {"s": s, "att": att}, state_ - - def decode_logits(self, *, s: Tensor, input_embed: Tensor, att: Tensor) -> Tensor: - """logits for the decoder""" - readout_in = self.readout_in(rf.concat_features(s, input_embed, att)) - readout = rf.reduce_out(readout_in, mode="max", num_pieces=2, out_dim=self.output_prob.in_dim) - readout = rf.dropout(readout, drop_prob=0.3, axis=self.dropout_broadcast and readout.feature_dim) - logits = self.output_prob(readout) - return logits + self.blank_idx = blank_idx + self.target_dim = target_dim class MakeModel: @@ -132,12 +113,12 @@ def make_model( lm = (lm, functools.partial(trafo_lm.make_label_scorer_torch, model=lm)) return GlobalAttentionModel( - in_dim=in_dim, - num_enc_layers=num_enc_layers, - enc_model_dim=Dim(name="enc", dimension=512, kind=Dim.Types.Feature), + enc_in_dim=in_dim, + enc_num_layers=num_enc_layers, + enc_out_dim=Dim(name="enc", dimension=512, kind=Dim.Types.Feature), enc_ff_dim=Dim(name="enc-ff", dimension=2048, kind=Dim.Types.Feature), - enc_att_num_heads=8, - enc_conformer_layer_opts=dict( + enc_num_heads=8, + encoder_layer_opts=dict( conv_norm_opts=dict(use_mask=True), self_att_opts=dict( # Shawn et al 2018 style, old RETURNN way. diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/model_import.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/model_import.py new file mode 100644 index 000000000..041ab883a --- /dev/null +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/model_import.py @@ -0,0 +1,172 @@ +from typing import Dict +import numpy + +import returnn.frontend as rf + + +_ParamMapping = {} # type: Dict[str,str] + + +def _add_params(): + # frontend + for layer_idx in [0, 1, 2]: + orig_name = "conv0" if layer_idx == 0 else f"subsample_conv{layer_idx - 1}" + _ParamMapping.update( + { + f"encoder.input_layer.conv_layers.{layer_idx}.filter": f"{orig_name}/W", + f"encoder.input_layer.conv_layers.{layer_idx}.bias": f"{orig_name}/bias", + } + ) + _ParamMapping.update( + { + "encoder.input_projection.weight": "source_linear/W", + "encoder.enc_ctx.weight": "enc_ctx/W", + "encoder.enc_ctx.bias": "enc_ctx/b", + "encoder.inv_fertility.weight": "inv_fertility/W", + "label_decoder.target_embed.weight": "output/rec/target_embed0/W", + "label_decoder.weight_feedback.weight": "output/rec/weight_feedback/W", + "label_decoder.s_transformed.weight": "output/rec/s_transformed/W", + "label_decoder.energy.weight": "output/rec/energy/W", + "label_decoder.readout_in.weight": "output/rec/readout_in/W", + "label_decoder.readout_in.bias": "output/rec/readout_in/b", + "label_decoder.output_prob.weight": "output/rec/output_prob/W", + "label_decoder.output_prob.bias": "output/rec/output_prob/b", + } + ) + # conformer + for layer_idx in range(12): + # FF + for sub in [1, 2]: + _ParamMapping[ + f"encoder.layers.{layer_idx}.ffn{sub}.linear_ff.weight" + ] = f"conformer_block_{layer_idx + 1:02d}_ffmod_{sub}_ff1/W" + _ParamMapping[ + f"encoder.layers.{layer_idx}.ffn{sub}.linear_ff.bias" + ] = f"conformer_block_{layer_idx + 1:02d}_ffmod_{sub}_ff1/b" + _ParamMapping[ + f"encoder.layers.{layer_idx}.ffn{sub}.linear_out.weight" + ] = f"conformer_block_{layer_idx + 1:02d}_ffmod_{sub}_ff2/W" + _ParamMapping[ + f"encoder.layers.{layer_idx}.ffn{sub}.linear_out.bias" + ] = f"conformer_block_{layer_idx + 1:02d}_ffmod_{sub}_ff2/b" + _ParamMapping[ + f"encoder.layers.{layer_idx}.ffn{sub}_layer_norm.scale" + ] = f"conformer_block_{layer_idx + 1:02d}_ffmod_{sub}_ln/scale" + _ParamMapping[ + f"encoder.layers.{layer_idx}.ffn{sub}_layer_norm.bias" + ] = f"conformer_block_{layer_idx + 1:02d}_ffmod_{sub}_ln/bias" + # conv + _ParamMapping[ + f"encoder.layers.{layer_idx}.conv_block.positionwise_conv1.weight" + ] = f"conformer_block_{layer_idx + 1:02d}_conv_mod_pointwise_conv1/W" + _ParamMapping[ + f"encoder.layers.{layer_idx}.conv_block.positionwise_conv1.bias" + ] = f"conformer_block_{layer_idx + 1:02d}_conv_mod_pointwise_conv1/b" + _ParamMapping[ + f"encoder.layers.{layer_idx}.conv_block.depthwise_conv.filter" + ] = f"conformer_block_{layer_idx + 1:02d}_conv_mod_depthwise_conv2/W" + _ParamMapping[ + f"encoder.layers.{layer_idx}.conv_block.depthwise_conv.bias" + ] = f"conformer_block_{layer_idx + 1:02d}_conv_mod_depthwise_conv2/bias" + _ParamMapping[ + f"encoder.layers.{layer_idx}.conv_block.positionwise_conv2.weight" + ] = f"conformer_block_{layer_idx + 1:02d}_conv_mod_pointwise_conv2/W" + _ParamMapping[ + f"encoder.layers.{layer_idx}.conv_block.positionwise_conv2.bias" + ] = f"conformer_block_{layer_idx + 1:02d}_conv_mod_pointwise_conv2/b" + _ParamMapping[ + f"encoder.layers.{layer_idx}.conv_layer_norm.scale" + ] = f"conformer_block_{layer_idx + 1:02d}_conv_mod_ln/scale" + _ParamMapping[ + f"encoder.layers.{layer_idx}.conv_layer_norm.bias" + ] = f"conformer_block_{layer_idx + 1:02d}_conv_mod_ln/bias" + # self-att + _ParamMapping[ + f"encoder.layers.{layer_idx}.self_att.qkv.weight" + ] = f"conformer_block_{layer_idx + 1:02d}_self_att/QKV" + _ParamMapping[ + f"encoder.layers.{layer_idx}.self_att.proj.weight" + ] = f"conformer_block_{layer_idx + 1:02d}_self_att_linear/W" + _ParamMapping[ + f"encoder.layers.{layer_idx}.self_att_layer_norm.scale" + ] = f"conformer_block_{layer_idx + 1:02d}_self_att_ln/scale" + _ParamMapping[ + f"encoder.layers.{layer_idx}.self_att_layer_norm.bias" + ] = f"conformer_block_{layer_idx + 1:02d}_self_att_ln/bias" + _ParamMapping[ + f"encoder.layers.{layer_idx}.self_att.learned_pos_emb.pos_emb" + ] = f"conformer_block_{layer_idx + 1:02d}_self_att_ln_rel_pos_enc/encoding_matrix" + # final layer norm + _ParamMapping[ + f"encoder.layers.{layer_idx}.final_layer_norm.scale" + ] = f"conformer_block_{layer_idx + 1:02d}_ln/scale" + _ParamMapping[ + f"encoder.layers.{layer_idx}.final_layer_norm.bias" + ] = f"conformer_block_{layer_idx + 1:02d}_ln/bias" + + +_add_params() + + +def map_param_func_v2(reader, name: str, var: rf.Parameter) -> numpy.ndarray: + """map params, TF to RF""" + from tensorflow.python.training.py_checkpoint_reader import CheckpointReader + from i6_experiments.users.zeyer.returnn.convert.params import numpy as convert_params_np + from i6_experiments.users.zeyer.returnn.convert.params import tf_to_rf_np as convert_params_tf_to_rf_np + + assert isinstance(reader, CheckpointReader) + assert isinstance(var, rf.Parameter) + + tf_var_name = name.replace(".", "/") + if reader.has_tensor(tf_var_name): + return reader.get_tensor(tf_var_name) + + if name in _ParamMapping: + var_name = _ParamMapping[name] + assert reader.has_tensor(var_name) + value = reader.get_tensor(var_name) + assert isinstance(value, numpy.ndarray) + if name.endswith(".filter"): + value = convert_params_np.convert_tf_conv_to_pt_conv_filter(value) + assert ( + value.shape == var.batch_shape + ), f"new param {name} {var.batch_shape} vs ckpt param {var_name} {value.shape}" + assert value.dtype.name == var.dtype, f"new param {name} {var.dtype} vs ckpt param {var_name} {value.dtype}" + return value + + if name == "label_decoder.s.ff_weight": + value = reader.get_tensor("output/rec/s/rec/lstm_cell/kernel") + value = convert_params_np.convert_tf_lstm_to_native_lstm_ff(value) + assert value.shape == var.batch_shape, name + assert value.dtype.name == var.dtype, name + return value + + if name == "label_decoder.s.rec_weight": + value = reader.get_tensor("output/rec/s/rec/lstm_cell/kernel") + value = convert_params_np.convert_tf_lstm_to_native_lstm_rec(value) + assert value.shape == var.batch_shape, name + assert value.dtype.name == var.dtype, name + return value + + if name == "label_decoder.s.bias": + value = reader.get_tensor("output/rec/s/rec/lstm_cell/bias") + value = convert_params_np.convert_tf_lstm_to_native_lstm_bias(value, forget_gate_bias=1.0) + assert value.shape == var.batch_shape, name + assert value.dtype.name == var.dtype, name + return value + + if ".conv_block.norm." in name: + assert name.startswith("encoder.layers.") + layer_idx = int(name.split(".")[2]) + value = convert_params_tf_to_rf_np.convert_tf_batch_norm_to_rf( + reader=reader, + rf_name=name, + rf_prefix_name=f"encoder.layers.{layer_idx}.conv_block.norm.", + tf_prefix_name=f"conformer_block_{layer_idx + 1:02d}_conv_mod_bn/batch_norm/", + var=var, + ) + assert value.shape == var.batch_shape, name + assert value.dtype.name == var.dtype, name + return value + + raise NotImplementedError(f"cannot map {name!r} {var}") diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/model_old/README b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/model_old/README new file mode 100644 index 000000000..bab2e8d4e --- /dev/null +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/model_old/README @@ -0,0 +1,2 @@ +This package contains everything needed for doing viterbi training and recognition for the V1 baseline of our +global att model. It leads to the same scores, losses, speed and WER as our old RETURNN setup (net_dict style). \ No newline at end of file diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/model_old/__init__.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/model_old/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/model_old/model.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/model_old/model.py new file mode 100644 index 000000000..40a759309 --- /dev/null +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/model_old/model.py @@ -0,0 +1,220 @@ +from typing import Optional, Dict, Any, Sequence, Tuple, List +import functools + +from returnn.tensor import Tensor, Dim, single_step_dim +import returnn.frontend as rf + +from i6_experiments.users.schmitt.returnn_frontend.model_interfaces.model import ModelDef +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.base_old import BaseModel +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.base_old import _batch_size_factor, _log_mel_feature_dim + + +class GlobalAttentionModel(BaseModel): + def __init__(self, eos_idx: int, **kwargs): + super(GlobalAttentionModel, self).__init__(**kwargs) + self.eos_idx = eos_idx + self.bos_idx = eos_idx + + def decoder_default_initial_state(self, *, batch_dims: Sequence[Dim], enc_spatial_dim: Dim) -> rf.State: + """Default initial state""" + state = rf.State( + s=self.s.default_initial_state(batch_dims=batch_dims), + att=rf.zeros(list(batch_dims) + [self.att_num_heads * self.encoder.out_dim]), + accum_att_weights=rf.zeros( + list(batch_dims) + [enc_spatial_dim, self.att_num_heads], feature_dim=self.att_num_heads + ), + ) + state.att.feature_dim_axis = len(state.att.dims) - 1 + return state + + def loop_step_output_templates(self, batch_dims: List[Dim]) -> Dict[str, Tensor]: + """loop step out""" + return { + "s": Tensor( + "s", dims=batch_dims + [self.s.out_dim], dtype=rf.get_default_float_dtype(), feature_dim_axis=-1 + ), + "att": Tensor( + "att", + dims=batch_dims + [self.att_num_heads * self.encoder.out_dim], + dtype=rf.get_default_float_dtype(), + feature_dim_axis=-1, + ), + } + + def loop_step( + self, + *, + enc: rf.Tensor, + enc_ctx: rf.Tensor, + inv_fertility: rf.Tensor, + enc_spatial_dim: Dim, + input_embed: rf.Tensor, + state: Optional[rf.State] = None, + ) -> Tuple[Dict[str, rf.Tensor], rf.State]: + """step of the inner loop""" + if state is None: + batch_dims = enc.remaining_dims( + remove=(enc.feature_dim, enc_spatial_dim) if enc_spatial_dim != single_step_dim else (enc.feature_dim,) + ) + state = self.decoder_default_initial_state(batch_dims=batch_dims, enc_spatial_dim=enc_spatial_dim) + state_ = rf.State() + + prev_att = state.att + + s, state_.s = self.s(rf.concat_features(input_embed, prev_att), state=state.s, spatial_dim=single_step_dim) + + weight_feedback = self.weight_feedback(state.accum_att_weights) + s_transformed = self.s_transformed(s) + energy_in = enc_ctx + weight_feedback + s_transformed + energy = self.energy(rf.tanh(energy_in)) + att_weights = rf.softmax(energy, axis=enc_spatial_dim) + + state_.accum_att_weights = state.accum_att_weights + att_weights * inv_fertility * 0.5 + att0 = rf.dot(att_weights, enc, reduce=enc_spatial_dim, use_mask=False) + att0.feature_dim = self.encoder.out_dim + att, _ = rf.merge_dims(att0, dims=(self.att_num_heads, self.encoder.out_dim)) + state_.att = att + + return {"s": s, "att": att}, state_ + + def decode_logits(self, *, s: Tensor, input_embed: Tensor, att: Tensor) -> Tensor: + """logits for the decoder""" + readout_in = self.readout_in(rf.concat_features(s, input_embed, att)) + readout = rf.reduce_out(readout_in, mode="max", num_pieces=2, out_dim=self.output_prob.in_dim) + readout = rf.dropout(readout, drop_prob=0.3, axis=self.dropout_broadcast and readout.feature_dim) + logits = self.output_prob(readout) + return logits + + +class MakeModel: + """for import""" + + def __init__(self, in_dim: int, target_dim: int, *, eos_label: int = 0, num_enc_layers: int = 12): + self.in_dim = in_dim + self.target_dim = target_dim + self.eos_label = eos_label + self.num_enc_layers = num_enc_layers + + def __call__(self) -> GlobalAttentionModel: + from returnn.datasets.util.vocabulary import Vocabulary + + in_dim = Dim(name="in", dimension=self.in_dim, kind=Dim.Types.Feature) + target_dim = Dim(name="target", dimension=self.target_dim, kind=Dim.Types.Feature) + target_dim.vocab = Vocabulary.create_vocab_from_labels( + [str(i) for i in range(target_dim.dimension)], eos_label=self.eos_label + ) + + return self.make_model(in_dim, target_dim, num_enc_layers=self.num_enc_layers) + + @classmethod + def make_model( + cls, + in_dim: Dim, + target_dim: Dim, + *, + num_enc_layers: int = 12, + pos_emb_dropout: float = 0.0, + language_model: Optional[Dict[str, Any]] = None, + **extra, + ) -> GlobalAttentionModel: + """make""" + lm = None + if language_model: + assert isinstance(language_model, dict) + language_model = language_model.copy() + cls_name = language_model.pop("class") + assert cls_name == "TransformerDecoder" + language_model.pop("vocab_dim", None) # will just overwrite + + from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.lm.trafo import model as trafo_lm + + lm = trafo_lm.MakeModel(vocab_dim=target_dim, **language_model)() + lm = (lm, functools.partial(trafo_lm.make_label_scorer_torch, model=lm)) + + return GlobalAttentionModel( + in_dim=in_dim, + num_enc_layers=num_enc_layers, + enc_model_dim=Dim(name="enc", dimension=512, kind=Dim.Types.Feature), + enc_ff_dim=Dim(name="enc-ff", dimension=2048, kind=Dim.Types.Feature), + enc_att_num_heads=8, + enc_conformer_layer_opts=dict( + conv_norm_opts=dict(use_mask=True), + self_att_opts=dict( + # Shawn et al 2018 style, old RETURNN way. + with_bias=False, + with_linear_pos=False, + with_pos_bias=False, + learnable_pos_emb=True, + separate_pos_emb_per_head=False, + pos_emb_dropout=pos_emb_dropout, + ), + ff_activation=lambda x: rf.relu(x) ** 2.0, + ), + eos_idx=_get_eos_idx(target_dim), + target_dim=target_dim, + blank_idx=target_dim.dimension, + language_model=lm, + **extra, + ) + + +def _get_bos_idx(target_dim: Dim) -> int: + """for non-blank labels""" + assert target_dim.vocab + if target_dim.vocab.bos_label_id is not None: + bos_idx = target_dim.vocab.bos_label_id + elif target_dim.vocab.eos_label_id is not None: + bos_idx = target_dim.vocab.eos_label_id + elif "" in target_dim.vocab.user_defined_symbol_ids: + bos_idx = target_dim.vocab.user_defined_symbol_ids[""] + else: + raise Exception(f"cannot determine bos_idx from vocab {target_dim.vocab}") + return bos_idx + + +def _get_eos_idx(target_dim: Dim) -> int: + """for non-blank labels""" + assert target_dim.vocab + if target_dim.vocab.eos_label_id is not None: + eos_idx = target_dim.vocab.eos_label_id + else: + raise Exception(f"cannot determine eos_idx from vocab {target_dim.vocab}") + return eos_idx + + +def from_scratch_model_def(*, epoch: int, in_dim: Dim, target_dim: Dim) -> GlobalAttentionModel: + """Function is run within RETURNN.""" + from returnn.config import get_global_config + + in_dim, epoch # noqa + config = get_global_config() # noqa + enc_aux_logits = config.typed_value("aux_loss_layers") + pos_emb_dropout = config.float("pos_emb_dropout", 0.0) + # real input is raw audio, internally it does logmel + in_dim = Dim(name="logmel", dimension=_log_mel_feature_dim, kind=Dim.Types.Feature) + lm_opts = config.typed_value("external_lm") + return MakeModel.make_model( + in_dim, target_dim, enc_aux_logits=enc_aux_logits or (), pos_emb_dropout=pos_emb_dropout, language_model=lm_opts + ) + + +from_scratch_model_def: ModelDef[GlobalAttentionModel] +from_scratch_model_def.behavior_version = 16 +from_scratch_model_def.backend = "torch" +from_scratch_model_def.batch_size_factor = _batch_size_factor + + +def _returnn_v2_get_model(*, epoch: int, **_kwargs_unused): + from returnn.tensor import Tensor + from returnn.config import get_global_config + + config = get_global_config() + default_input_key = config.typed_value("default_input") + default_target_key = config.typed_value("target") + extern_data_dict = config.typed_value("extern_data") + data = Tensor(name=default_input_key, **extern_data_dict[default_input_key]) + targets = Tensor(name=default_target_key, **extern_data_dict[default_target_key]) + + model_def = config.typed_value("_model_def") + model = model_def(epoch=epoch, in_dim=data.feature_dim, target_dim=targets.sparse_dim) + return model diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/model_old/model_import.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/model_old/model_import.py new file mode 100644 index 000000000..3fd087957 --- /dev/null +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/model_old/model_import.py @@ -0,0 +1,172 @@ +from typing import Dict +import numpy + +import returnn.frontend as rf + + +_ParamMapping = {} # type: Dict[str,str] + + +def _add_params(): + # frontend + for layer_idx in [0, 1, 2]: + orig_name = "conv0" if layer_idx == 0 else f"subsample_conv{layer_idx - 1}" + _ParamMapping.update( + { + f"encoder.input_layer.conv_layers.{layer_idx}.filter": f"{orig_name}/W", + f"encoder.input_layer.conv_layers.{layer_idx}.bias": f"{orig_name}/bias", + } + ) + _ParamMapping.update( + { + "encoder.input_projection.weight": "source_linear/W", + "enc_ctx.weight": "enc_ctx/W", + "enc_ctx.bias": "enc_ctx/b", + "inv_fertility.weight": "inv_fertility/W", + "target_embed.weight": "output/rec/target_embed0/W", + "weight_feedback.weight": "output/rec/weight_feedback/W", + "s_transformed.weight": "output/rec/s_transformed/W", + "energy.weight": "output/rec/energy/W", + "readout_in.weight": "output/rec/readout_in/W", + "readout_in.bias": "output/rec/readout_in/b", + "output_prob.weight": "output/rec/output_prob/W", + "output_prob.bias": "output/rec/output_prob/b", + } + ) + # conformer + for layer_idx in range(12): + # FF + for sub in [1, 2]: + _ParamMapping[ + f"encoder.layers.{layer_idx}.ffn{sub}.linear_ff.weight" + ] = f"conformer_block_{layer_idx + 1:02d}_ffmod_{sub}_ff1/W" + _ParamMapping[ + f"encoder.layers.{layer_idx}.ffn{sub}.linear_ff.bias" + ] = f"conformer_block_{layer_idx + 1:02d}_ffmod_{sub}_ff1/b" + _ParamMapping[ + f"encoder.layers.{layer_idx}.ffn{sub}.linear_out.weight" + ] = f"conformer_block_{layer_idx + 1:02d}_ffmod_{sub}_ff2/W" + _ParamMapping[ + f"encoder.layers.{layer_idx}.ffn{sub}.linear_out.bias" + ] = f"conformer_block_{layer_idx + 1:02d}_ffmod_{sub}_ff2/b" + _ParamMapping[ + f"encoder.layers.{layer_idx}.ffn{sub}_layer_norm.scale" + ] = f"conformer_block_{layer_idx + 1:02d}_ffmod_{sub}_ln/scale" + _ParamMapping[ + f"encoder.layers.{layer_idx}.ffn{sub}_layer_norm.bias" + ] = f"conformer_block_{layer_idx + 1:02d}_ffmod_{sub}_ln/bias" + # conv + _ParamMapping[ + f"encoder.layers.{layer_idx}.conv_block.positionwise_conv1.weight" + ] = f"conformer_block_{layer_idx + 1:02d}_conv_mod_pointwise_conv1/W" + _ParamMapping[ + f"encoder.layers.{layer_idx}.conv_block.positionwise_conv1.bias" + ] = f"conformer_block_{layer_idx + 1:02d}_conv_mod_pointwise_conv1/b" + _ParamMapping[ + f"encoder.layers.{layer_idx}.conv_block.depthwise_conv.filter" + ] = f"conformer_block_{layer_idx + 1:02d}_conv_mod_depthwise_conv2/W" + _ParamMapping[ + f"encoder.layers.{layer_idx}.conv_block.depthwise_conv.bias" + ] = f"conformer_block_{layer_idx + 1:02d}_conv_mod_depthwise_conv2/bias" + _ParamMapping[ + f"encoder.layers.{layer_idx}.conv_block.positionwise_conv2.weight" + ] = f"conformer_block_{layer_idx + 1:02d}_conv_mod_pointwise_conv2/W" + _ParamMapping[ + f"encoder.layers.{layer_idx}.conv_block.positionwise_conv2.bias" + ] = f"conformer_block_{layer_idx + 1:02d}_conv_mod_pointwise_conv2/b" + _ParamMapping[ + f"encoder.layers.{layer_idx}.conv_layer_norm.scale" + ] = f"conformer_block_{layer_idx + 1:02d}_conv_mod_ln/scale" + _ParamMapping[ + f"encoder.layers.{layer_idx}.conv_layer_norm.bias" + ] = f"conformer_block_{layer_idx + 1:02d}_conv_mod_ln/bias" + # self-att + _ParamMapping[ + f"encoder.layers.{layer_idx}.self_att.qkv.weight" + ] = f"conformer_block_{layer_idx + 1:02d}_self_att/QKV" + _ParamMapping[ + f"encoder.layers.{layer_idx}.self_att.proj.weight" + ] = f"conformer_block_{layer_idx + 1:02d}_self_att_linear/W" + _ParamMapping[ + f"encoder.layers.{layer_idx}.self_att_layer_norm.scale" + ] = f"conformer_block_{layer_idx + 1:02d}_self_att_ln/scale" + _ParamMapping[ + f"encoder.layers.{layer_idx}.self_att_layer_norm.bias" + ] = f"conformer_block_{layer_idx + 1:02d}_self_att_ln/bias" + _ParamMapping[ + f"encoder.layers.{layer_idx}.self_att.learned_pos_emb.pos_emb" + ] = f"conformer_block_{layer_idx + 1:02d}_self_att_ln_rel_pos_enc/encoding_matrix" + # final layer norm + _ParamMapping[ + f"encoder.layers.{layer_idx}.final_layer_norm.scale" + ] = f"conformer_block_{layer_idx + 1:02d}_ln/scale" + _ParamMapping[ + f"encoder.layers.{layer_idx}.final_layer_norm.bias" + ] = f"conformer_block_{layer_idx + 1:02d}_ln/bias" + + +_add_params() + + +def map_param_func_v2(reader, name: str, var: rf.Parameter) -> numpy.ndarray: + """map params, TF to RF""" + from tensorflow.python.training.py_checkpoint_reader import CheckpointReader + from i6_experiments.users.zeyer.returnn.convert.params import numpy as convert_params_np + from i6_experiments.users.zeyer.returnn.convert.params import tf_to_rf_np as convert_params_tf_to_rf_np + + assert isinstance(reader, CheckpointReader) + assert isinstance(var, rf.Parameter) + + tf_var_name = name.replace(".", "/") + if reader.has_tensor(tf_var_name): + return reader.get_tensor(tf_var_name) + + if name in _ParamMapping: + var_name = _ParamMapping[name] + assert reader.has_tensor(var_name) + value = reader.get_tensor(var_name) + assert isinstance(value, numpy.ndarray) + if name.endswith(".filter"): + value = convert_params_np.convert_tf_conv_to_pt_conv_filter(value) + assert ( + value.shape == var.batch_shape + ), f"new param {name} {var.batch_shape} vs ckpt param {var_name} {value.shape}" + assert value.dtype.name == var.dtype, f"new param {name} {var.dtype} vs ckpt param {var_name} {value.dtype}" + return value + + if name == "s.ff_weight": + value = reader.get_tensor("output/rec/s/rec/lstm_cell/kernel") + value = convert_params_np.convert_tf_lstm_to_native_lstm_ff(value) + assert value.shape == var.batch_shape, name + assert value.dtype.name == var.dtype, name + return value + + if name == "s.rec_weight": + value = reader.get_tensor("output/rec/s/rec/lstm_cell/kernel") + value = convert_params_np.convert_tf_lstm_to_native_lstm_rec(value) + assert value.shape == var.batch_shape, name + assert value.dtype.name == var.dtype, name + return value + + if name == "s.bias": + value = reader.get_tensor("output/rec/s/rec/lstm_cell/bias") + value = convert_params_np.convert_tf_lstm_to_native_lstm_bias(value, forget_gate_bias=1.0) + assert value.shape == var.batch_shape, name + assert value.dtype.name == var.dtype, name + return value + + if ".conv_block.norm." in name: + assert name.startswith("encoder.layers.") + layer_idx = int(name.split(".")[2]) + value = convert_params_tf_to_rf_np.convert_tf_batch_norm_to_rf( + reader=reader, + rf_name=name, + rf_prefix_name=f"encoder.layers.{layer_idx}.conv_block.norm.", + tf_prefix_name=f"conformer_block_{layer_idx + 1:02d}_conv_mod_bn/batch_norm/", + var=var, + ) + assert value.shape == var.batch_shape, name + assert value.dtype.name == var.dtype, name + return value + + raise NotImplementedError(f"cannot map {name!r} {var}") diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/model_old/recog.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/model_old/recog.py new file mode 100644 index 000000000..644a637cd --- /dev/null +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/model_old/recog.py @@ -0,0 +1,315 @@ +from typing import Optional, Dict, Any, Tuple +import tree + +from returnn.tensor import Tensor, Dim +import returnn.frontend as rf +from returnn.frontend.tensor_array import TensorArray + +from i6_experiments.users.schmitt.returnn_frontend.model_interfaces.recog import RecogDef +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.base import _batch_size_factor +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.global_.model_old.model import GlobalAttentionModel + + +def model_recog( + *, + model: GlobalAttentionModel, + data: Tensor, + data_spatial_dim: Dim, + max_seq_len: Optional[int] = None, +) -> Tuple[Tensor, Tensor, Dim, Dim]: + """ + Function is run within RETURNN. + + Earlier we used the generic beam_search function, + but now we just directly perform the search here, + as this is overall simpler and shorter. + + :return: + recog results including beam {batch, beam, out_spatial}, + log probs {batch, beam}, + out_spatial_dim, + final beam_dim + """ + assert not model.language_model # not implemented here. use the pure PyTorch search instead + + batch_dims = data.remaining_dims((data_spatial_dim, data.feature_dim)) + enc_args, enc_spatial_dim = model.encode(data, in_spatial_dim=data_spatial_dim) + beam_size = 12 + length_normalization_exponent = 1.0 + if max_seq_len is None: + max_seq_len = enc_spatial_dim.get_size_tensor() + else: + max_seq_len = rf.convert_to_tensor(max_seq_len, dtype="int32") + print("** max seq len:", max_seq_len.raw_tensor) + + # Eager-mode implementation of beam search. + # Initial state. + beam_dim = Dim(1, name="initial-beam") + batch_dims_ = [beam_dim] + batch_dims + decoder_state = model.decoder_default_initial_state(batch_dims=batch_dims_, enc_spatial_dim=enc_spatial_dim) + target = rf.constant(model.bos_idx, dims=batch_dims_, sparse_dim=model.target_dim) + ended = rf.constant(False, dims=batch_dims_) + out_seq_len = rf.constant(0, dims=batch_dims_) + seq_log_prob = rf.constant(0.0, dims=batch_dims_) + + i = 0 + seq_targets = [] + seq_backrefs = [] + while True: + if i == 0: + input_embed = rf.zeros(batch_dims_ + [model.target_embed.out_dim], feature_dim=model.target_embed.out_dim) + else: + input_embed = model.target_embed(target) + step_out, decoder_state = model.loop_step( + **enc_args, + enc_spatial_dim=enc_spatial_dim, + input_embed=input_embed, + state=decoder_state, + ) + logits = model.decode_logits(input_embed=input_embed, **step_out) + label_log_prob = rf.log_softmax(logits, axis=model.target_dim) + # Filter out finished beams + label_log_prob = rf.where( + ended, + rf.sparse_to_dense(model.eos_idx, axis=model.target_dim, label_value=0.0, other_value=-1.0e30), + label_log_prob, + ) + seq_log_prob = seq_log_prob + label_log_prob # Batch, InBeam, Vocab + seq_log_prob, (backrefs, target), beam_dim = rf.top_k( + seq_log_prob, k_dim=Dim(beam_size, name=f"dec-step{i}-beam"), axis=[beam_dim, model.target_dim] + ) # seq_log_prob, backrefs, target: Batch, Beam + seq_targets.append(target) + seq_backrefs.append(backrefs) + decoder_state = tree.map_structure(lambda s: rf.gather(s, indices=backrefs), decoder_state) + ended = rf.gather(ended, indices=backrefs) + out_seq_len = rf.gather(out_seq_len, indices=backrefs) + i += 1 + + ended = rf.logical_or(ended, target == model.eos_idx) + ended = rf.logical_or(ended, rf.copy_to_device(i >= max_seq_len)) + if bool(rf.reduce_all(ended, axis=ended.dims).raw_tensor): + break + out_seq_len = out_seq_len + rf.where(ended, 0, 1) + + if i > 1 and length_normalization_exponent != 0: + # Length-normalized scores, so we evaluate score_t/len. + # If seq ended, score_i/i == score_{i-1}/(i-1), thus score_i = score_{i-1}*(i/(i-1)) + # Because we count with EOS symbol, shifted by one. + seq_log_prob *= rf.where( + ended, + (i / (i - 1)) ** length_normalization_exponent, + 1.0, + ) + + if i > 0 and length_normalization_exponent != 0: + seq_log_prob *= (1 / i) ** length_normalization_exponent + + # Backtrack via backrefs, resolve beams. + seq_targets_ = [] + indices = rf.range_over_dim(beam_dim) # FinalBeam -> FinalBeam + for backrefs, target in zip(seq_backrefs[::-1], seq_targets[::-1]): + # indices: FinalBeam -> Beam + # backrefs: Beam -> PrevBeam + seq_targets_.insert(0, rf.gather(target, indices=indices)) + indices = rf.gather(backrefs, indices=indices) # FinalBeam -> PrevBeam + + seq_targets__ = TensorArray(seq_targets_[0]) + for target in seq_targets_: + seq_targets__ = seq_targets__.push_back(target) + out_spatial_dim = Dim(out_seq_len, name="out-spatial") + seq_targets = seq_targets__.stack(axis=out_spatial_dim) + + return seq_targets, seq_log_prob, out_spatial_dim, beam_dim + + +# RecogDef API +model_recog: RecogDef[GlobalAttentionModel] +model_recog.output_with_beam = True +# output_blank_label=blank is actually wrong for AED, but now we don't change it anymore +# because it would change all recog hashes. +# Also, it does not matter too much -- it will just cause an extra SearchRemoveLabelJob, +# which will not have any effect here. +model_recog.output_blank_label = "" +model_recog.batch_size_dependent = False + + +def model_recog_pure_torch( + *, + model: GlobalAttentionModel, + data: Tensor, + data_spatial_dim: Dim, + max_seq_len: Optional[int] = None, +) -> Tuple[Tensor, Tensor, Dim, Dim]: + """ + Function is run within RETURNN. + + Earlier we used the generic beam_search function, + but now we just directly perform the search here, + as this is overall simpler and shorter. + + :return: + recog results including beam {batch, beam, out_spatial}, + log probs {batch, beam}, + recog results info: key -> {batch, beam}, + out_spatial_dim, + final beam_dim + """ + import torch + from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.beam_search.label_sync import BeamSearchOpts, label_sync_beam_search + from i6_experiments.users.schmitt.returnn_frontend.model_interfaces.label_scorer import ShallowFusedLabelScorers + from returnn.config import get_global_config + + config = get_global_config() + + torch.cuda.set_sync_debug_mode(1) # debug CUDA sync. does not hurt too much to leave this always in? + + data_concat_zeros = config.float("data_concat_zeros", 0) + if data_concat_zeros: + data_concat_zeros_dim = Dim(int(data_concat_zeros * _batch_size_factor * 100), name="data_concat_zeros") + data, data_spatial_dim = rf.concat( + (data, data_spatial_dim), (rf.zeros([data_concat_zeros_dim]), data_concat_zeros_dim), allow_broadcast=True + ) + + batch_dims = data.remaining_dims((data_spatial_dim, data.feature_dim)) + assert len(batch_dims) == 1, batch_dims # not implemented otherwise, simple to add... + batch_dim = batch_dims[0] + enc, enc_spatial_dim = model.encode(data, in_spatial_dim=data_spatial_dim) + if max_seq_len is None: + max_seq_len = enc_spatial_dim.get_size_tensor() + else: + max_seq_len = rf.convert_to_tensor(max_seq_len, dtype="int32") + + beam_search_opts = (config.typed_value("beam_search_opts", None) or {}).copy() + if beam_search_opts.get("beam_size") is None: + beam_search_opts["beam_size"] = config.int("beam_size", 12) + if beam_search_opts.get("length_normalization_exponent") is None: + beam_search_opts["length_normalization_exponent"] = config.float("length_normalization_exponent", 1.0) + + label_scorer = ShallowFusedLabelScorers() + label_scorer.label_scorers["decoder"] = ( + get_label_scorer_pure_torch(model=model, batch_dim=batch_dim, enc=enc, enc_spatial_dim=enc_spatial_dim), + 1.0, + ) + if model.language_model: + lm_scale = beam_search_opts.pop("lm_scale") # must be defined with LM + label_scorer.label_scorers["lm"] = (model.language_model_make_label_scorer(), lm_scale) + + print("** max seq len:", max_seq_len.raw_tensor) + + # Beam search happening here: + ( + seq_targets, # [Batch,FinalBeam,OutSeqLen] + seq_log_prob, # [Batch,FinalBeam] + out_seq_len, # [Batch,FinalBeam] + ) = label_sync_beam_search( + label_scorer, + batch_size=int(batch_dim.get_dim_value()), + max_seq_len=max_seq_len.copy_compatible_to_dims_raw([batch_dim]), + device=data.raw_tensor.device, + opts=BeamSearchOpts( + **beam_search_opts, + bos_label=model.bos_idx, + eos_label=model.eos_idx, + num_labels=model.target_dim.dimension, + ), + ) + + beam_dim = Dim(seq_log_prob.shape[1], name="beam") + out_spatial_dim = Dim(rf.convert_to_tensor(out_seq_len, dims=[batch_dim, beam_dim], name="out_spatial")) + seq_targets_t = rf.convert_to_tensor( + seq_targets, dims=[batch_dim, beam_dim, out_spatial_dim], sparse_dim=model.target_dim + ) + seq_log_prob_t = rf.convert_to_tensor(seq_log_prob, dims=[batch_dim, beam_dim]) + + return seq_targets_t, seq_log_prob_t, out_spatial_dim, beam_dim + + +# RecogDef API +model_recog_pure_torch: RecogDef[GlobalAttentionModel] +model_recog_pure_torch.output_with_beam = True +model_recog_pure_torch.output_blank_label = None +model_recog_pure_torch.batch_size_dependent = False + + +def get_label_scorer_pure_torch( + *, + model: GlobalAttentionModel, + batch_dim: Dim, + enc: Dict[str, Tensor], + enc_spatial_dim: Dim, +): + import torch + import functools + from i6_experiments.users.schmitt.returnn_frontend.model_interfaces.label_scorer import ( + LabelScorerIntf, + StateObjTensorExt, + StateObjIgnored, + ) + + class LabelScorer(LabelScorerIntf): + """label scorer""" + + def get_initial_state(self, *, batch_size: int, device: torch.device) -> Any: + """Initial state.""" + beam_dim = Dim(1, name="initial-beam") + batch_dims_ = [batch_dim, beam_dim] + decoder_state = model.decoder_default_initial_state(batch_dims=batch_dims_, enc_spatial_dim=enc_spatial_dim) + return tree.map_structure(functools.partial(self._map_tensor_to_raw, beam_dim=beam_dim), decoder_state) + + def score_and_update_state( + self, + *, + prev_state: Any, + prev_label: torch.Tensor, + prev_align_label: Optional[torch.Tensor] = None, # not used + t: Optional[int] = None, # not used + ) -> Tuple[torch.Tensor, Any]: + """update state""" + beam_dim = Dim(prev_label.shape[1], name="beam") + + def _map_raw_to_tensor(v): + if isinstance(v, StateObjTensorExt): + tensor: Tensor = v.extra + tensor = tensor.copy_template_new_dim_tags( + (batch_dim, beam_dim) + tensor.dims[2:], keep_special_axes=True + ) + tensor.raw_tensor = v.tensor + return tensor + elif isinstance(v, StateObjIgnored): + return v.content + else: + raise TypeError(f"_map_raw_to_tensor: unexpected {v} ({type(v).__name__})") + + input_embed = model.target_embed( + rf.convert_to_tensor(prev_label, dims=[batch_dim, beam_dim], sparse_dim=model.target_dim) + ) + decode_out, decoder_state = model.loop_step( + **enc, + enc_spatial_dim=enc_spatial_dim, + input_embed=input_embed, + state=tree.map_structure(_map_raw_to_tensor, prev_state), + ) + logits = model.decode_logits(input_embed=input_embed, **decode_out) + label_log_prob = rf.log_softmax(logits, axis=model.target_dim) + assert set(label_log_prob.dims) == {batch_dim, beam_dim, model.target_dim} + + return ( + self._map_tensor_to_raw(label_log_prob, beam_dim=beam_dim).tensor, + tree.map_structure(functools.partial(self._map_tensor_to_raw, beam_dim=beam_dim), decoder_state), + ) + + @staticmethod + def _map_tensor_to_raw(v, *, beam_dim: Dim): + if isinstance(v, Tensor): + if beam_dim not in v.dims: + return StateObjIgnored(v) + batch_dims_ = [batch_dim, beam_dim] + v = v.copy_transpose(batch_dims_ + [dim for dim in v.dims if dim not in batch_dims_]) + raw = v.raw_tensor + return StateObjTensorExt(raw, v.copy_template()) + elif isinstance(v, Dim): + return StateObjIgnored(v) + else: + raise TypeError(f"_map_tensor_to_raw: unexpected {v} ({type(v).__name__})") + + return LabelScorer() diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/model_old/train.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/model_old/train.py new file mode 100644 index 000000000..857880013 --- /dev/null +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/model_old/train.py @@ -0,0 +1,115 @@ +from returnn.tensor import TensorDict +from returnn.tensor import Tensor, Dim +import returnn.frontend as rf + +from i6_experiments.users.schmitt.returnn_frontend.model_interfaces.training import TrainDef +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.global_.model_old.model import GlobalAttentionModel + + +def _returnn_v2_train_step(*, model, extern_data: TensorDict, **_kwargs_unused): + from returnn.config import get_global_config + + config = get_global_config() + default_input_key = config.typed_value("default_input") + default_target_key = config.typed_value("target") + data = extern_data[default_input_key] + data_spatial_dim = data.get_time_dim_tag() + targets = extern_data[default_target_key] + targets_spatial_dim = targets.get_time_dim_tag() + train_def: TrainDef = config.typed_value("_train_def") + train_def( + model=model, + data=data, + data_spatial_dim=data_spatial_dim, + targets=targets, + targets_spatial_dim=targets_spatial_dim, + ) + + +def from_scratch_training( + *, + model: GlobalAttentionModel, + data: rf.Tensor, + data_spatial_dim: Dim, + targets: rf.Tensor, + targets_spatial_dim: Dim +): + """Function is run within RETURNN.""" + from returnn.config import get_global_config + + config = get_global_config() # noqa + aux_loss_layers = config.typed_value("aux_loss_layers") + aux_loss_scales = config.typed_value("aux_loss_scales", ([1.0] * len(aux_loss_layers)) if aux_loss_layers else None) + aed_loss_scale = config.float("aed_loss_scale", 1.0) + use_normalized_loss = config.bool("use_normalized_loss", True) + + if data.feature_dim and data.feature_dim.dimension == 1: + data = rf.squeeze(data, axis=data.feature_dim) + assert not data.feature_dim # raw audio + + collected_outputs = {} + enc_args, enc_spatial_dim = model.encode(data, in_spatial_dim=data_spatial_dim, collected_outputs=collected_outputs) + if aux_loss_layers: + for i, layer_idx in enumerate(aux_loss_layers): + if layer_idx > len(model.encoder.layers): + continue + linear = getattr(model, f"enc_aux_logits_{layer_idx}") + aux_logits = linear(collected_outputs[str(layer_idx - 1)]) + aux_loss = rf.ctc_loss( + logits=aux_logits, + targets=targets, + input_spatial_dim=enc_spatial_dim, + targets_spatial_dim=targets_spatial_dim, + blank_index=model.blank_idx, + ) + aux_loss.mark_as_loss( + f"ctc_{layer_idx}", + scale=aux_loss_scales[i], + custom_inv_norm_factor=targets_spatial_dim.get_size_tensor(), + use_normalized_loss=use_normalized_loss, + ) + + batch_dims = data.remaining_dims(data_spatial_dim) + input_embeddings = model.target_embed(targets) + input_embeddings = rf.shift_right(input_embeddings, axis=targets_spatial_dim, pad_value=0.0) + + def _body(input_embed: Tensor, state: rf.State): + new_state = rf.State() + loop_out_, new_state.decoder = model.loop_step( + **enc_args, + enc_spatial_dim=enc_spatial_dim, + input_embed=input_embed, + state=state.decoder, + ) + return loop_out_, new_state + + loop_out, _, _ = rf.scan( + spatial_dim=targets_spatial_dim, + xs=input_embeddings, + ys=model.loop_step_output_templates(batch_dims=batch_dims), + initial=rf.State( + decoder=model.decoder_default_initial_state(batch_dims=batch_dims, enc_spatial_dim=enc_spatial_dim), + ), + body=_body, + ) + + logits = model.decode_logits(input_embed=input_embeddings, **loop_out) + logits_packed, pack_dim = rf.pack_padded(logits, dims=batch_dims + [targets_spatial_dim], enforce_sorted=False) + targets_packed, _ = rf.pack_padded( + targets, dims=batch_dims + [targets_spatial_dim], enforce_sorted=False, out_dim=pack_dim + ) + + log_prob = rf.log_softmax(logits_packed, axis=model.target_dim) + log_prob = rf.label_smoothed_log_prob_gradient(log_prob, 0.1, axis=model.target_dim) + loss = rf.cross_entropy( + target=targets_packed, estimated=log_prob, estimated_type="log-probs", axis=model.target_dim + ) + loss.mark_as_loss("ce", scale=aed_loss_scale, use_normalized_loss=use_normalized_loss) + + best = rf.reduce_argmax(logits_packed, axis=model.target_dim) + frame_error = best != targets_packed + frame_error.mark_as_loss(name="fer", as_error=True) + + +from_scratch_training: TrainDef[GlobalAttentionModel] +from_scratch_training.learning_rate_control_error_measure = "dev_score_full_sum" diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/recog.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/recog.py index 396002fd2..8448a5744 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/recog.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/recog.py @@ -30,10 +30,10 @@ def model_recog( out_spatial_dim, final beam_dim """ - assert not model.language_model # not implemented here. use the pure PyTorch search instead + assert not model.label_decoder.language_model # not implemented here. use the pure PyTorch search instead batch_dims = data.remaining_dims((data_spatial_dim, data.feature_dim)) - enc_args, enc_spatial_dim = model.encode(data, in_spatial_dim=data_spatial_dim) + enc_args, enc_spatial_dim = model.encoder.encode(data, in_spatial_dim=data_spatial_dim) beam_size = 12 length_normalization_exponent = 1.0 if max_seq_len is None: @@ -46,8 +46,8 @@ def model_recog( # Initial state. beam_dim = Dim(1, name="initial-beam") batch_dims_ = [beam_dim] + batch_dims - decoder_state = model.decoder_default_initial_state(batch_dims=batch_dims_, enc_spatial_dim=enc_spatial_dim) - target = rf.constant(model.bos_idx, dims=batch_dims_, sparse_dim=model.target_dim) + decoder_state = model.label_decoder.decoder_default_initial_state(batch_dims=batch_dims_, enc_spatial_dim=enc_spatial_dim) + target = rf.constant(model.label_decoder.bos_idx, dims=batch_dims_, sparse_dim=model.target_dim) ended = rf.constant(False, dims=batch_dims_) out_seq_len = rf.constant(0, dims=batch_dims_) seq_log_prob = rf.constant(0.0, dims=batch_dims_) @@ -57,21 +57,22 @@ def model_recog( seq_backrefs = [] while True: if i == 0: - input_embed = rf.zeros(batch_dims_ + [model.target_embed.out_dim], feature_dim=model.target_embed.out_dim) + input_embed = rf.zeros( + batch_dims_ + [model.label_decoder.target_embed.out_dim], feature_dim=model.label_decoder.target_embed.out_dim) else: - input_embed = model.target_embed(target) - step_out, decoder_state = model.loop_step( + input_embed = model.label_decoder.target_embed(target) + step_out, decoder_state = model.label_decoder.loop_step( **enc_args, enc_spatial_dim=enc_spatial_dim, input_embed=input_embed, state=decoder_state, ) - logits = model.decode_logits(input_embed=input_embed, **step_out) + logits = model.label_decoder.decode_logits(input_embed=input_embed, **step_out) label_log_prob = rf.log_softmax(logits, axis=model.target_dim) # Filter out finished beams label_log_prob = rf.where( ended, - rf.sparse_to_dense(model.eos_idx, axis=model.target_dim, label_value=0.0, other_value=-1.0e30), + rf.sparse_to_dense(model.label_decoder.eos_idx, axis=model.target_dim, label_value=0.0, other_value=-1.0e30), label_log_prob, ) seq_log_prob = seq_log_prob + label_log_prob # Batch, InBeam, Vocab @@ -85,7 +86,7 @@ def model_recog( out_seq_len = rf.gather(out_seq_len, indices=backrefs) i += 1 - ended = rf.logical_or(ended, target == model.eos_idx) + ended = rf.logical_or(ended, rf.convert_to_tensor(target == model.label_decoder.eos_idx)) ended = rf.logical_or(ended, rf.copy_to_device(i >= max_seq_len)) if bool(rf.reduce_all(ended, axis=ended.dims).raw_tensor): break @@ -173,7 +174,7 @@ def model_recog_pure_torch( batch_dims = data.remaining_dims((data_spatial_dim, data.feature_dim)) assert len(batch_dims) == 1, batch_dims # not implemented otherwise, simple to add... batch_dim = batch_dims[0] - enc, enc_spatial_dim = model.encode(data, in_spatial_dim=data_spatial_dim) + enc, enc_spatial_dim = model.encoder.encode(data, in_spatial_dim=data_spatial_dim) if max_seq_len is None: max_seq_len = enc_spatial_dim.get_size_tensor() else: @@ -190,9 +191,9 @@ def model_recog_pure_torch( get_label_scorer_pure_torch(model=model, batch_dim=batch_dim, enc=enc, enc_spatial_dim=enc_spatial_dim), 1.0, ) - if model.language_model: + if model.label_decoder.language_model: lm_scale = beam_search_opts.pop("lm_scale") # must be defined with LM - label_scorer.label_scorers["lm"] = (model.language_model_make_label_scorer(), lm_scale) + label_scorer.label_scorers["lm"] = (model.label_decoder.language_model_make_label_scorer(), lm_scale) print("** max seq len:", max_seq_len.raw_tensor) @@ -208,8 +209,8 @@ def model_recog_pure_torch( device=data.raw_tensor.device, opts=BeamSearchOpts( **beam_search_opts, - bos_label=model.bos_idx, - eos_label=model.eos_idx, + bos_label=model.label_decoder.bos_idx, + eos_label=model.label_decoder.eos_idx, num_labels=model.target_dim.dimension, ), ) @@ -253,7 +254,7 @@ def get_initial_state(self, *, batch_size: int, device: torch.device) -> Any: """Initial state.""" beam_dim = Dim(1, name="initial-beam") batch_dims_ = [batch_dim, beam_dim] - decoder_state = model.decoder_default_initial_state(batch_dims=batch_dims_, enc_spatial_dim=enc_spatial_dim) + decoder_state = model.label_decoder.decoder_default_initial_state(batch_dims=batch_dims_, enc_spatial_dim=enc_spatial_dim) return tree.map_structure(functools.partial(self._map_tensor_to_raw, beam_dim=beam_dim), decoder_state) def score_and_update_state( @@ -280,16 +281,16 @@ def _map_raw_to_tensor(v): else: raise TypeError(f"_map_raw_to_tensor: unexpected {v} ({type(v).__name__})") - input_embed = model.target_embed( + input_embed = model.label_decoder.target_embed( rf.convert_to_tensor(prev_label, dims=[batch_dim, beam_dim], sparse_dim=model.target_dim) ) - decode_out, decoder_state = model.loop_step( + decode_out, decoder_state = model.label_decoder.loop_step( **enc, enc_spatial_dim=enc_spatial_dim, input_embed=input_embed, state=tree.map_structure(_map_raw_to_tensor, prev_state), ) - logits = model.decode_logits(input_embed=input_embed, **decode_out) + logits = model.label_decoder.decode_logits(input_embed=input_embed, **decode_out) label_log_prob = rf.log_softmax(logits, axis=model.target_dim) assert set(label_log_prob.dims) == {batch_dim, beam_dim, model.target_dim} diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/train.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/train.py index a8413320c..d81959356 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/train.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/train.py @@ -48,7 +48,7 @@ def from_scratch_training( assert not data.feature_dim # raw audio collected_outputs = {} - enc_args, enc_spatial_dim = model.encode(data, in_spatial_dim=data_spatial_dim, collected_outputs=collected_outputs) + enc_args, enc_spatial_dim = model.encoder.encode(data, in_spatial_dim=data_spatial_dim, collected_outputs=collected_outputs) if aux_loss_layers: for i, layer_idx in enumerate(aux_loss_layers): if layer_idx > len(model.encoder.layers): @@ -70,12 +70,12 @@ def from_scratch_training( ) batch_dims = data.remaining_dims(data_spatial_dim) - input_embeddings = model.target_embed(targets) + input_embeddings = model.label_decoder.target_embed(targets) input_embeddings = rf.shift_right(input_embeddings, axis=targets_spatial_dim, pad_value=0.0) def _body(input_embed: Tensor, state: rf.State): new_state = rf.State() - loop_out_, new_state.decoder = model.loop_step( + loop_out_, new_state.decoder = model.label_decoder.loop_step( **enc_args, enc_spatial_dim=enc_spatial_dim, input_embed=input_embed, @@ -86,14 +86,14 @@ def _body(input_embed: Tensor, state: rf.State): loop_out, _, _ = rf.scan( spatial_dim=targets_spatial_dim, xs=input_embeddings, - ys=model.loop_step_output_templates(batch_dims=batch_dims), + ys=model.label_decoder.loop_step_output_templates(batch_dims=batch_dims), initial=rf.State( - decoder=model.decoder_default_initial_state(batch_dims=batch_dims, enc_spatial_dim=enc_spatial_dim), + decoder=model.label_decoder.decoder_default_initial_state(batch_dims=batch_dims, enc_spatial_dim=enc_spatial_dim), ), body=_body, ) - logits = model.decode_logits(input_embed=input_embeddings, **loop_out) + logits = model.label_decoder.decode_logits(input_embed=input_embeddings, **loop_out) logits_packed, pack_dim = rf.pack_padded(logits, dims=batch_dims + [targets_spatial_dim], enforce_sorted=False) targets_packed, _ = rf.pack_padded( targets, dims=batch_dims + [targets_spatial_dim], enforce_sorted=False, out_dim=pack_dim diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model.py index ca03a65ce..da3bba4c0 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model.py @@ -6,282 +6,88 @@ from i6_experiments.users.schmitt.returnn_frontend.model_interfaces.model import ModelDef from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.base import _batch_size_factor, _log_mel_feature_dim -from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.base import BaseModel +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model_new.blank_model.model import BlankDecoder +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model_new.label_model.model import ( + SegmentalAttLabelDecoder, + SegmentalAttLabelDecoderWoCtxInState +) +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.encoder.global_ import GlobalConformerEncoder +from i6_experiments.users.schmitt.returnn_frontend.model_interfaces.supports_label_scorer_torch import RFModelWithMakeLabelScorer -class SegmentalAttentionModel(BaseModel): +class SegmentalAttentionModel(rf.Module): def __init__( self, + *, length_model_state_dim: Dim, length_model_embed_dim: Dim, center_window_size: int, align_target_dim: Dim, - **kwargs + target_dim: Dim, + blank_idx: int, + enc_key_total_dim: Dim = Dim(name="enc_key_total_dim", dimension=1024), + att_dropout: float = 0.1, + l2: float = 0.0001, + language_model: Optional[RFModelWithMakeLabelScorer] = None, + enc_in_dim: Dim, + enc_out_dim: Dim = Dim(name="enc", dimension=512), + enc_num_layers: int = 12, + enc_aux_logits: Sequence[int] = (), # layers + enc_ff_dim: Dim = Dim(name="enc-ff", dimension=2048), + enc_num_heads: int = 4, + encoder_layer_opts: Optional[Dict[str, Any]] = None, + dec_att_num_heads: Dim = Dim(name="att_num_heads", dimension=1), + enc_dropout: float = 0.1, + label_decoder_version: int = 1, ): - super(SegmentalAttentionModel, self).__init__(**kwargs) + super(SegmentalAttentionModel, self).__init__() - self.align_target_dim = align_target_dim - - self.length_model_state_dim = length_model_state_dim - self.length_model_embed_dim = length_model_embed_dim - self.emit_prob_dim = Dim(name="emit_prob", dimension=1) - self.center_window_size = center_window_size - self.accum_att_weights_dim = Dim(name="accum_att_weights", dimension=center_window_size) - - self.target_embed_length_model = rf.Embedding(align_target_dim, self.length_model_embed_dim) - # when using rf.LSTM, something with the parameter import from TF checkpoint was not right - # i.e. the import worked but the LSTM output was different than in TF even though the inputs were the same - # self.s_length_model = rf.LSTM(self.encoder.out_dim + self.length_model_embed_dim, self.length_model_state_dim) - self.s_length_model = rf.ZoneoutLSTM( - self.encoder.out_dim + self.length_model_embed_dim, - self.length_model_state_dim, - parts_order="jifo", - forget_bias=0.0, - ) - self.emit_prob = rf.Linear(self.length_model_state_dim, self.emit_prob_dim) - - def label_decoder_default_initial_state( - self, - *, - batch_dims: Sequence[Dim], - segment_starts_sparse_dim: Optional[Dim] = None, - segment_lens_sparse_dim: Optional[Dim] = None, - ) -> rf.State: - """Default initial state""" - state = rf.State( - s=self.s.default_initial_state(batch_dims=batch_dims), - att=rf.zeros(list(batch_dims) + [self.att_num_heads * self.encoder.out_dim]), - accum_att_weights=rf.zeros( - list(batch_dims) + [self.accum_att_weights_dim, self.att_num_heads], feature_dim=self.att_num_heads - ), - segment_starts=rf.zeros(batch_dims, sparse_dim=segment_starts_sparse_dim, dtype="int32"), - segment_lens=rf.zeros(batch_dims, sparse_dim=segment_lens_sparse_dim, dtype="int32"), - ) - state.att.feature_dim_axis = len(state.att.dims) - 1 - return state - - def label_loop_step_output_templates(self, batch_dims: List[Dim]) -> Dict[str, Tensor]: - """loop step out""" - return { - "s": Tensor( - "s", dims=batch_dims + [self.s.out_dim], dtype=rf.get_default_float_dtype(), feature_dim_axis=-1 - ), - "att": Tensor( - "att", - dims=batch_dims + [self.att_num_heads * self.encoder.out_dim], - dtype=rf.get_default_float_dtype(), - feature_dim_axis=-1, - ), - } - - def _get_prev_accum_att_weights_scattered( - self, - prev_accum_att_weights: Tensor, - segment_starts: Tensor, - prev_segment_starts: Tensor, - prev_segment_lens: Tensor, - ) -> Tensor: - - overlap_len = rf.cast(prev_segment_starts + prev_segment_lens - segment_starts, "int32") - overlap_len = rf.where( - rf.logical_or(overlap_len < 0, overlap_len > prev_segment_lens), - rf.convert_to_tensor(0), - overlap_len - ) - overlap_start = prev_segment_lens - overlap_len - - slice_dim = Dim(name="slice", dimension=overlap_len) - gather_positions = rf.range_over_dim(slice_dim) - gather_positions += overlap_start - prev_accum_att_weights_overlap = rf.gather( - prev_accum_att_weights, axis=self.accum_att_weights_dim, indices=gather_positions, clip_to_valid=True - ) - overlap_range = rf.range_over_dim(slice_dim) - - prev_accum_att_weights_scattered = rf.scatter( - prev_accum_att_weights_overlap, - out_dim=self.accum_att_weights_dim, - indices=overlap_range, - indices_dim=slice_dim, - ) - - return prev_accum_att_weights_scattered - - def _get_accum_att_weights( - self, - att_t_dim: Dim, - enc_spatial_dim: Dim, - inv_fertility: Tensor, - att_weights: Tensor, - prev_accum_att_weights_scattered: Tensor, - gather_positions: Tensor, - ) -> Tensor: - att_weights_range = rf.range_over_dim(att_t_dim) - att_weights_scattered = rf.scatter( - att_weights, - out_dim=self.accum_att_weights_dim, - indices=att_weights_range, - indices_dim=att_t_dim, - ) - - inv_fertility_sliced = rf.gather(inv_fertility, axis=enc_spatial_dim, indices=gather_positions, clip_to_valid=True) - inv_fertility_scattered = rf.scatter( - inv_fertility_sliced, - out_dim=self.accum_att_weights_dim, - indices=att_weights_range, - indices_dim=att_t_dim, - ) - - accum_att_weights = prev_accum_att_weights_scattered + att_weights_scattered * inv_fertility_scattered * 0.5 - - return accum_att_weights - - def _get_weight_feedback( - self, - prev_accum_att_weights_scattered: Tensor, - att_t_dim: Dim, - ) -> Tensor: - gather_positions = rf.range_over_dim(att_t_dim) - prev_accum_att_weights_sliced = rf.gather( - prev_accum_att_weights_scattered, - axis=self.accum_att_weights_dim, - indices=gather_positions, - clip_to_valid=True - ) - - return self.weight_feedback(prev_accum_att_weights_sliced) - - def label_sync_loop_step( - self, - *, - enc: rf.Tensor, - enc_ctx: rf.Tensor, - inv_fertility: rf.Tensor, - enc_spatial_dim: Dim, - input_embed: rf.Tensor, - segment_starts: rf.Tensor, - segment_lens: rf.Tensor, - state: Optional[rf.State] = None, - ) -> Tuple[Dict[str, rf.Tensor], rf.State]: - """step of the inner loop""" - if state is None: - batch_dims = enc.remaining_dims( - remove=(enc.feature_dim, enc_spatial_dim) if enc_spatial_dim != single_step_dim else (enc.feature_dim,) - ) - state = self.label_decoder_default_initial_state(batch_dims=batch_dims) - state_ = rf.State() - - # during search, these need to be the values from the previous "emit" step (not necessarily the previous time step) - prev_att = state.att - prev_s_state = state.s - prev_accum_att_weights = state.accum_att_weights - prev_segment_starts = state.segment_starts - prev_segment_lens = state.segment_lens - - s, state_.s = self.s(rf.concat_features(input_embed, prev_att), state=prev_s_state, spatial_dim=single_step_dim) - s_transformed = self.s_transformed(s) - - slice_dim = Dim(name="slice", dimension=segment_lens) - gather_positions = rf.range_over_dim(slice_dim) - gather_positions += segment_starts - - enc_ctx_sliced = rf.gather(enc_ctx, axis=enc_spatial_dim, indices=gather_positions, clip_to_valid=True) - enc_sliced = rf.gather(enc, axis=enc_spatial_dim, indices=gather_positions, clip_to_valid=True) - - prev_accum_att_weights_scattered = self._get_prev_accum_att_weights_scattered( - prev_accum_att_weights=prev_accum_att_weights, - segment_starts=segment_starts, - prev_segment_starts=prev_segment_starts, - prev_segment_lens=prev_segment_lens, - ) - weight_feedback = self._get_weight_feedback( - prev_accum_att_weights_scattered=prev_accum_att_weights_scattered, - att_t_dim=slice_dim, - ) - - energy_in = enc_ctx_sliced + weight_feedback + s_transformed - energy = self.energy(rf.tanh(energy_in)) - att_weights = rf.softmax(energy, axis=slice_dim) - # we do not need use_mask because the softmax output is already padded with zeros - att0 = rf.dot(att_weights, enc_sliced, reduce=slice_dim, use_mask=False) - att0.feature_dim = self.encoder.out_dim - att, _ = rf.merge_dims(att0, dims=(self.att_num_heads, self.encoder.out_dim)) - state_.att = att - - accum_att_weights = self._get_accum_att_weights( - att_t_dim=slice_dim, - enc_spatial_dim=enc_spatial_dim, - inv_fertility=inv_fertility, - att_weights=att_weights, - prev_accum_att_weights_scattered=prev_accum_att_weights_scattered, - gather_positions=gather_positions, + self.encoder = GlobalConformerEncoder( + enc_in_dim, + enc_out_dim, + num_layers=enc_num_layers, + target_dim=target_dim, + wb_target_dim=align_target_dim, + aux_logits=enc_aux_logits, + ff_dim=enc_ff_dim, + num_heads=enc_num_heads, + encoder_layer_opts=encoder_layer_opts, + enc_key_total_dim=enc_key_total_dim, + dec_att_num_heads=dec_att_num_heads, + dropout=enc_dropout, + att_dropout=att_dropout, + l2=l2, ) - accum_att_weights.feature_dim = self.att_num_heads - state_.accum_att_weights = accum_att_weights - - state_.segment_starts = segment_starts - state_.segment_lens = segment_lens - return {"s": s, "att": att}, state_ + print("using label_decoder_version", label_decoder_version) + if label_decoder_version == 1: + label_decoder_class = SegmentalAttLabelDecoder + else: + assert label_decoder_version == 2 + label_decoder_class = SegmentalAttLabelDecoderWoCtxInState - def decode_label_logits(self, *, s: Tensor, input_embed: Tensor, att: Tensor) -> Tensor: - """logits for the decoder""" - readout_in = self.readout_in(rf.concat_features(s, input_embed, att)) - readout = rf.reduce_out(readout_in, mode="max", num_pieces=2, out_dim=self.output_prob.in_dim) - readout = rf.dropout(readout, drop_prob=0.3, axis=self.dropout_broadcast and readout.feature_dim) - logits = self.output_prob(readout) - return logits - - def blank_decoder_default_initial_state(self, *, batch_dims: Sequence[Dim]) -> rf.State: - """Default initial state""" - state = rf.State( - s_length_model=self.s_length_model.default_initial_state(batch_dims=batch_dims), - i=rf.zeros(batch_dims, dtype="int32"), + self.label_decoder = label_decoder_class( + enc_out_dim=self.encoder.out_dim, + target_dim=target_dim, + att_num_heads=dec_att_num_heads, + att_dropout=att_dropout, + blank_idx=blank_idx, + enc_key_total_dim=enc_key_total_dim, + l2=l2, + center_window_size=center_window_size, + language_model=language_model, ) - return state - - def blank_loop_step_output_templates(self, batch_dims: List[Dim]) -> Dict[str, Tensor]: - """loop step out""" - return { - "s_length_model": Tensor( - "s_length_model", - dims=batch_dims + [self.s_length_model.out_dim], - dtype=rf.get_default_float_dtype(), - feature_dim_axis=-1 - ), - } - - def time_sync_loop_step( - self, - *, - enc: rf.Tensor, - enc_spatial_dim: Dim, - input_embed: rf.Tensor, - state: Optional[rf.State] = None, - ) -> Tuple[Dict[str, rf.Tensor], rf.State]: - """step of the inner loop""" - if state is None: - batch_dims = enc.remaining_dims( - remove=(enc.feature_dim, enc_spatial_dim) if enc_spatial_dim != single_step_dim else (enc.feature_dim,) - ) - state = self.blank_decoder_default_initial_state(batch_dims=batch_dims) - state_ = rf.State() - - am = rf.gather(enc, axis=enc_spatial_dim, indices=state.i, clip_to_valid=True) - s_length_model, state_.s_length_model = self.s_length_model( - rf.concat_features(am, input_embed), - state=state.s_length_model, - spatial_dim=single_step_dim + self.blank_decoder = BlankDecoder( + length_model_state_dim=length_model_state_dim, + length_model_embed_dim=length_model_embed_dim, + align_target_dim=align_target_dim, + encoder_out_dim=self.encoder.out_dim, ) - state_.i = state.i + 1 - - return {"s_length_model": s_length_model}, state_ - - def decode_blank_logits(self, *, s_length_model: Tensor) -> Tensor: - """logits for the decoder""" - logits = self.emit_prob(s_length_model) - return logits + self.blank_idx = self.label_decoder.blank_idx + self.center_window_size = center_window_size + self.target_dim = self.label_decoder.target_dim + self.align_target_dim = align_target_dim class MakeModel: @@ -318,6 +124,7 @@ def make_model( num_enc_layers: int = 12, pos_emb_dropout: float = 0.0, language_model: Optional[Dict[str, Any]] = None, + label_decoder_version: int, **extra, ) -> SegmentalAttentionModel: """make""" @@ -335,12 +142,12 @@ def make_model( lm = (lm, functools.partial(trafo_lm.make_time_sync_label_scorer_torch, model=lm, align_target_dim=align_target_dim)) return SegmentalAttentionModel( - in_dim=in_dim, - num_enc_layers=num_enc_layers, - enc_model_dim=Dim(name="enc", dimension=512, kind=Dim.Types.Feature), + enc_in_dim=in_dim, + enc_num_layers=num_enc_layers, + enc_out_dim=Dim(name="enc", dimension=512, kind=Dim.Types.Feature), enc_ff_dim=Dim(name="enc-ff", dimension=2048, kind=Dim.Types.Feature), - enc_att_num_heads=8, - enc_conformer_layer_opts=dict( + enc_num_heads=8, + encoder_layer_opts=dict( conv_norm_opts=dict(use_mask=True), self_att_opts=dict( # Shawn et al 2018 style, old RETURNN way. @@ -360,6 +167,7 @@ def make_model( length_model_state_dim=Dim(name="length_model_state", dimension=128, kind=Dim.Types.Feature), length_model_embed_dim=Dim(name="length_model_embed", dimension=128, kind=Dim.Types.Feature), center_window_size=center_window_size, + label_decoder_version=label_decoder_version, **extra, ) @@ -379,6 +187,9 @@ def from_scratch_model_def( center_window_size = config.typed_value("center_window_size") if center_window_size is None: raise ValueError("center_window_size is not set!") + + label_decoder_version = config.int("label_decoder_version", 1) + return MakeModel.make_model( in_dim, align_target_dim, @@ -386,7 +197,8 @@ def from_scratch_model_def( center_window_size=center_window_size, enc_aux_logits=enc_aux_logits or (), pos_emb_dropout=pos_emb_dropout, - language_model=lm_opts + language_model=lm_opts, + label_decoder_version=label_decoder_version, ) diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/__init__.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/blank_model/__init__.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/blank_model/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/blank_model/model.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/blank_model/model.py new file mode 100644 index 000000000..8b57923e8 --- /dev/null +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/blank_model/model.py @@ -0,0 +1,92 @@ +from typing import Optional, Dict, Any, Sequence, Tuple, List +import functools + +from returnn.tensor import Tensor, Dim, single_step_dim +import returnn.frontend as rf + +from i6_experiments.users.schmitt.returnn_frontend.model_interfaces.model import ModelDef +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.base import _batch_size_factor, _log_mel_feature_dim +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.base import BaseLabelDecoder + + +class BlankDecoder(rf.Module): + def __init__( + self, + length_model_state_dim: Dim, + length_model_embed_dim: Dim, + align_target_dim: Dim, + encoder_out_dim: Dim, + ): + super(BlankDecoder, self).__init__() + self.length_model_state_dim = length_model_state_dim + self.length_model_embed_dim = length_model_embed_dim + self.emit_prob_dim = Dim(name="emit_prob", dimension=1) + + self.target_embed = rf.Embedding(align_target_dim, self.length_model_embed_dim) + self.s = rf.LSTM( + encoder_out_dim + self.length_model_embed_dim, + self.length_model_state_dim, + ) + self.emit_prob = rf.Linear(self.length_model_state_dim, self.emit_prob_dim) + + def default_initial_state(self, *, batch_dims: Sequence[Dim]) -> rf.State: + """Default initial state""" + state = rf.State( + s_blank=self.s.default_initial_state(batch_dims=batch_dims), + i=rf.zeros(batch_dims, dtype="int32"), + ) + return state + + def loop_step_output_templates(self, batch_dims: List[Dim]) -> Dict[str, Tensor]: + """loop step out""" + return { + "s_blank": Tensor( + "s_blank", + dims=batch_dims + [self.s.out_dim], + dtype=rf.get_default_float_dtype(), + feature_dim_axis=-1 + ), + } + + def loop_step( + self, + *, + enc: rf.Tensor, + enc_spatial_dim: Dim, + input_embed: rf.Tensor, + state: Optional[rf.State] = None, + spatial_dim=single_step_dim + ) -> Tuple[Dict[str, rf.Tensor], rf.State]: + """step of the inner loop""" + if state is None: + batch_dims = enc.remaining_dims( + remove=(enc.feature_dim, enc_spatial_dim) if enc_spatial_dim != single_step_dim else (enc.feature_dim,) + ) + state = self.default_initial_state(batch_dims=batch_dims) + state_ = rf.State() + + if spatial_dim == single_step_dim: + i = state.i + clip_to_valid = True + else: + i = rf.range_over_dim(spatial_dim) + # do clipping here, because rf.gather complains that i.dims_set is not a superset of enc_spatial_dim.dims_set + seq_lens = rf.copy_to_device(enc_spatial_dim.dyn_size_ext, i.device) + i = rf.where(i < seq_lens, i, seq_lens - 1) + clip_to_valid = False + + am = rf.gather(enc, axis=enc_spatial_dim, indices=i, clip_to_valid=clip_to_valid) + s_blank, state_.s_blank = self.s( + rf.concat_features(am, input_embed), + state=state.s_blank, + spatial_dim=spatial_dim + ) + + state_.i = state.i + 1 + + return {"s_blank": s_blank}, state_ + + def decode_logits(self, *, s_blank: Tensor) -> Tensor: + """logits for the decoder""" + logits = self.emit_prob(s_blank) + return logits diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/blank_model/train.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/blank_model/train.py new file mode 100644 index 000000000..13daa8de3 --- /dev/null +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/blank_model/train.py @@ -0,0 +1,55 @@ +from typing import Optional, Dict, Any, Sequence, Tuple, List + +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model_new.blank_model.model import BlankDecoder + +from returnn.tensor import Dim +import returnn.frontend as rf + + +def viterbi_training( + *, + model: BlankDecoder, + enc_args: Dict, + enc_spatial_dim: Dim, + align_targets: rf.Tensor, + align_targets_spatial_dim: Dim, + emit_ground_truth: rf.Tensor, + emit_blank_target_dim: Dim, + batch_dims: List[Dim], +): + align_input_embeddings = model.target_embed(align_targets) + align_input_embeddings = rf.shift_right( + align_input_embeddings, axis=align_targets_spatial_dim, pad_value=0.0) + + blank_loop_out, _ = model.loop_step( + enc=enc_args["enc"], + enc_spatial_dim=enc_spatial_dim, + input_embed=align_input_embeddings, + state=model.default_initial_state(batch_dims=batch_dims,), + spatial_dim=align_targets_spatial_dim, + ) + + blank_logits = model.decode_logits(**blank_loop_out) + blank_logits_packed, pack_dim = rf.pack_padded( + blank_logits, dims=batch_dims + [align_targets_spatial_dim], enforce_sorted=False) + emit_ground_truth_packed, _ = rf.pack_padded( + emit_ground_truth, dims=batch_dims + [align_targets_spatial_dim], enforce_sorted=False, out_dim=pack_dim + ) + + # rf.log_sigmoid not implemented for torch backend + emit_log_prob = rf.log(rf.sigmoid(blank_logits_packed)) + blank_log_prob = rf.log(rf.sigmoid(-blank_logits_packed)) + blank_logit_dim = blank_logits_packed.remaining_dims((pack_dim,))[0] + emit_blank_log_prob, _ = rf.concat( + (blank_log_prob, blank_logit_dim), (emit_log_prob, blank_logit_dim), out_dim=emit_blank_target_dim) + blank_loss = rf.cross_entropy( + target=emit_ground_truth_packed, + estimated=emit_blank_log_prob, + estimated_type="log-probs", + axis=emit_blank_target_dim + ) + blank_loss.mark_as_loss("emit_blank_ce", scale=1.0, use_normalized_loss=True) + + best = rf.reduce_argmax(emit_blank_log_prob, axis=emit_blank_target_dim) + frame_error = best != emit_ground_truth_packed + frame_error.mark_as_loss(name="emit_blank_fer", as_error=True) diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/label_model/__init__.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/label_model/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/label_model/model.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/label_model/model.py new file mode 100644 index 000000000..2313ced51 --- /dev/null +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/label_model/model.py @@ -0,0 +1,246 @@ +from typing import Optional, Dict, Any, Sequence, Tuple, List +import functools + +from returnn.tensor import Tensor, Dim, single_step_dim +import returnn.frontend as rf + +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.base import BaseLabelDecoder + + +class SegmentalAttLabelDecoder(BaseLabelDecoder): + def __init__(self, center_window_size: int, **kwargs): + super(SegmentalAttLabelDecoder, self).__init__(**kwargs) + + self.center_window_size = center_window_size + self.accum_att_weights_dim = Dim(name="accum_att_weights", dimension=center_window_size) + + def default_initial_state( + self, + *, + batch_dims: Sequence[Dim], + segment_starts_sparse_dim: Optional[Dim] = None, + segment_lens_sparse_dim: Optional[Dim] = None, + ) -> rf.State: + """Default initial state""" + state = rf.State( + s=self._get_lstm().default_initial_state(batch_dims=batch_dims), + att=rf.zeros(list(batch_dims) + [self.att_num_heads * self.enc_out_dim]), + accum_att_weights=rf.zeros( + list(batch_dims) + [self.accum_att_weights_dim, self.att_num_heads], feature_dim=self.att_num_heads + ), + segment_starts=rf.zeros(batch_dims, sparse_dim=segment_starts_sparse_dim, dtype="int32"), + segment_lens=rf.zeros(batch_dims, sparse_dim=segment_lens_sparse_dim, dtype="int32"), + ) + state.att.feature_dim_axis = len(state.att.dims) - 1 + return state + + def loop_step_output_templates(self, batch_dims: List[Dim]) -> Dict[str, Tensor]: + """loop step out""" + return { + "s": Tensor( + "s", dims=batch_dims + [self._get_lstm().out_dim], dtype=rf.get_default_float_dtype(), feature_dim_axis=-1 + ), + "att": Tensor( + "att", + dims=batch_dims + [self.att_num_heads * self.enc_out_dim], + dtype=rf.get_default_float_dtype(), + feature_dim_axis=-1, + ), + } + + def _get_prev_accum_att_weights_scattered( + self, + prev_accum_att_weights: Tensor, + segment_starts: Tensor, + prev_segment_starts: Tensor, + prev_segment_lens: Tensor, + ) -> Tensor: + + overlap_len = rf.cast(prev_segment_starts + prev_segment_lens - segment_starts, "int32") + overlap_len = rf.where( + rf.logical_or(overlap_len < 0, overlap_len > prev_segment_lens), + rf.convert_to_tensor(0), + overlap_len + ) + overlap_start = prev_segment_lens - overlap_len + + slice_dim = Dim(name="slice", dimension=overlap_len) + gather_positions = rf.range_over_dim(slice_dim) + gather_positions += overlap_start + prev_accum_att_weights_overlap = rf.gather( + prev_accum_att_weights, axis=self.accum_att_weights_dim, indices=gather_positions, clip_to_valid=True + ) + overlap_range = rf.range_over_dim(slice_dim) + + prev_accum_att_weights_scattered = rf.scatter( + prev_accum_att_weights_overlap, + out_dim=self.accum_att_weights_dim, + indices=overlap_range, + indices_dim=slice_dim, + ) + + return prev_accum_att_weights_scattered + + def _get_accum_att_weights( + self, + att_t_dim: Dim, + enc_spatial_dim: Dim, + inv_fertility: Tensor, + att_weights: Tensor, + prev_accum_att_weights_scattered: Tensor, + gather_positions: Tensor, + ) -> Tensor: + att_weights_range = rf.range_over_dim(att_t_dim) + att_weights_scattered = rf.scatter( + att_weights, + out_dim=self.accum_att_weights_dim, + indices=att_weights_range, + indices_dim=att_t_dim, + ) + + inv_fertility_sliced = rf.gather(inv_fertility, axis=enc_spatial_dim, indices=gather_positions, clip_to_valid=True) + inv_fertility_scattered = rf.scatter( + inv_fertility_sliced, + out_dim=self.accum_att_weights_dim, + indices=att_weights_range, + indices_dim=att_t_dim, + ) + + accum_att_weights = prev_accum_att_weights_scattered + att_weights_scattered * inv_fertility_scattered * 0.5 + + return accum_att_weights + + def _get_weight_feedback( + self, + prev_accum_att_weights_scattered: Tensor, + att_t_dim: Dim, + ) -> Tensor: + gather_positions = rf.range_over_dim(att_t_dim) + prev_accum_att_weights_sliced = rf.gather( + prev_accum_att_weights_scattered, + axis=self.accum_att_weights_dim, + indices=gather_positions, + clip_to_valid=True + ) + + return self.weight_feedback(prev_accum_att_weights_sliced) + + def _update_state( + self, + input_embed: rf.Tensor, + prev_att: rf.Tensor, + prev_s_state: rf.LstmState, + ): + return self.s(rf.concat_features(input_embed, prev_att), state=prev_s_state, spatial_dim=single_step_dim) + + def _get_lstm(self): + return self.s + + def loop_step( + self, + *, + enc: rf.Tensor, + enc_ctx: rf.Tensor, + inv_fertility: rf.Tensor, + enc_spatial_dim: Dim, + input_embed: rf.Tensor, + segment_starts: rf.Tensor, + segment_lens: rf.Tensor, + state: Optional[rf.State] = None, + ) -> Tuple[Dict[str, rf.Tensor], rf.State]: + """step of the inner loop""" + if state is None: + batch_dims = enc.remaining_dims( + remove=(enc.feature_dim, enc_spatial_dim) if enc_spatial_dim != single_step_dim else (enc.feature_dim,) + ) + state = self.default_initial_state(batch_dims=batch_dims) + state_ = rf.State() + + # during search, these need to be the values from the previous "emit" step (not necessarily the previous time step) + prev_att = state.att + prev_s_state = state.s + prev_accum_att_weights = state.accum_att_weights + prev_segment_starts = state.segment_starts + prev_segment_lens = state.segment_lens + + s, state_.s = self._update_state(input_embed, prev_att, prev_s_state) + s_transformed = self.s_transformed(s) + + slice_dim = Dim(name="slice", dimension=segment_lens) + gather_positions = rf.range_over_dim(slice_dim) + gather_positions += segment_starts + + enc_ctx_sliced = rf.gather(enc_ctx, axis=enc_spatial_dim, indices=gather_positions, clip_to_valid=True) + enc_sliced = rf.gather(enc, axis=enc_spatial_dim, indices=gather_positions, clip_to_valid=True) + + prev_accum_att_weights_scattered = self._get_prev_accum_att_weights_scattered( + prev_accum_att_weights=prev_accum_att_weights, + segment_starts=segment_starts, + prev_segment_starts=prev_segment_starts, + prev_segment_lens=prev_segment_lens, + ) + weight_feedback = self._get_weight_feedback( + prev_accum_att_weights_scattered=prev_accum_att_weights_scattered, + att_t_dim=slice_dim, + ) + + energy_in = enc_ctx_sliced + weight_feedback + s_transformed + energy = self.energy(rf.tanh(energy_in)) + att_weights = rf.softmax(energy, axis=slice_dim) + # we do not need use_mask because the softmax output is already padded with zeros + att0 = rf.dot(att_weights, enc_sliced, reduce=slice_dim, use_mask=False) + att0.feature_dim = self.enc_out_dim + att, _ = rf.merge_dims(att0, dims=(self.att_num_heads, self.enc_out_dim)) + state_.att = att + + accum_att_weights = self._get_accum_att_weights( + att_t_dim=slice_dim, + enc_spatial_dim=enc_spatial_dim, + inv_fertility=inv_fertility, + att_weights=att_weights, + prev_accum_att_weights_scattered=prev_accum_att_weights_scattered, + gather_positions=gather_positions, + ) + accum_att_weights.feature_dim = self.att_num_heads + state_.accum_att_weights = accum_att_weights + + state_.segment_starts = segment_starts + state_.segment_lens = segment_lens + + return {"s": s, "att": att}, state_ + + def decode_logits(self, *, s: Tensor, input_embed: Tensor, att: Tensor) -> Tensor: + """logits for the decoder""" + readout_in = self.readout_in(rf.concat_features(s, input_embed, att)) + readout = rf.reduce_out(readout_in, mode="max", num_pieces=2, out_dim=self.output_prob.in_dim) + readout = rf.dropout(readout, drop_prob=0.3, axis=self.dropout_broadcast and readout.feature_dim) + logits = self.output_prob(readout) + return logits + + +class SegmentalAttLabelDecoderWoCtxInState(SegmentalAttLabelDecoder): + def __init__(self, **kwargs): + super(SegmentalAttLabelDecoderWoCtxInState, self).__init__(**kwargs) + + # replace old state with new one + self.s_wo_att = rf.ZoneoutLSTM( + self.target_embed.out_dim, + self.s.out_dim, + zoneout_factor_cell=0.15, + zoneout_factor_output=0.05, + use_zoneout_output=False, + parts_order="jifo", + forget_bias=0.0, + ) + delattr(self, "s") + + def _update_state( + self, + input_embed: rf.Tensor, + prev_att: rf.Tensor, + prev_s_state: rf.LstmState, + ): + return self.s_wo_att(rf.concat_features(input_embed), state=prev_s_state, spatial_dim=single_step_dim) + + def _get_lstm(self): + return self.s_wo_att diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/label_model/train.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/label_model/train.py new file mode 100644 index 000000000..fe2d14b7f --- /dev/null +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/label_model/train.py @@ -0,0 +1,75 @@ +from typing import Optional, Dict, Any, Sequence, Tuple, List + +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.utils import get_non_blank_mask, get_masked +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model_new.label_model.model import SegmentalAttLabelDecoder + +from returnn.tensor import Dim +import returnn.frontend as rf + +from i6_experiments.users.schmitt.returnn_frontend.model_interfaces.training import TrainDef + + +def viterbi_training( + *, + model: SegmentalAttLabelDecoder, + enc_args: Dict, + enc_spatial_dim: Dim, + non_blank_targets: rf.Tensor, + non_blank_targets_spatial_dim: Dim, + segment_starts: rf.Tensor, + segment_lens: rf.Tensor, + batch_dims: List[Dim], +): + non_blank_input_embeddings = model.target_embed(non_blank_targets) + non_blank_input_embeddings = rf.shift_right( + non_blank_input_embeddings, axis=non_blank_targets_spatial_dim, pad_value=0.0) + + # ------------------- label loop ------------------- + + def _label_loop_body(xs, state: rf.State): + new_state = rf.State() + loop_out_, new_state.decoder = model.loop_step( + **enc_args, + enc_spatial_dim=enc_spatial_dim, + input_embed=xs["input_embed"], + segment_starts=xs["segment_starts"], + segment_lens=xs["segment_lens"], + state=state.decoder, + ) + return loop_out_, new_state + + label_loop_out, _, _ = rf.scan( + spatial_dim=non_blank_targets_spatial_dim, + xs={ + "input_embed": non_blank_input_embeddings, + "segment_starts": segment_starts, + "segment_lens": segment_lens, + }, + ys=model.loop_step_output_templates(batch_dims=batch_dims), + initial=rf.State( + decoder=model.default_initial_state( + batch_dims=batch_dims, + # TODO: do we need these sparse dims? they are automatically added by rf.range_over_dim + segment_starts_sparse_dim=segment_starts.sparse_dim, + segment_lens_sparse_dim=segment_lens.sparse_dim, + ), + ), + body=_label_loop_body, + ) + + logits = model.decode_logits(input_embed=non_blank_input_embeddings, **label_loop_out) + logits_packed, pack_dim = rf.pack_padded(logits, dims=batch_dims + [non_blank_targets_spatial_dim], enforce_sorted=False) + non_blank_targets_packed, _ = rf.pack_padded( + non_blank_targets, dims=batch_dims + [non_blank_targets_spatial_dim], enforce_sorted=False, out_dim=pack_dim + ) + + log_prob = rf.log_softmax(logits_packed, axis=model.target_dim) + log_prob = rf.label_smoothed_log_prob_gradient(log_prob, 0.1, axis=model.target_dim) + loss = rf.cross_entropy( + target=non_blank_targets_packed, estimated=log_prob, estimated_type="log-probs", axis=model.target_dim + ) + loss.mark_as_loss("non_blank_ce", scale=1.0, use_normalized_loss=True) + + best = rf.reduce_argmax(logits_packed, axis=model.target_dim) + frame_error = best != non_blank_targets_packed + frame_error.mark_as_loss(name="non_blank_fer", as_error=True) diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_old/README b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_old/README new file mode 100644 index 000000000..5b7120b18 --- /dev/null +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_old/README @@ -0,0 +1,2 @@ +This package contains everything needed for doing viterbi training and recognition for the V1 baseline of our +segmental model. It leads to the same scores, losses, speed and WER as our old RETURNN setup (net_dict style). \ No newline at end of file diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_old/__init__.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_old/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_old/model.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_old/model.py new file mode 100644 index 000000000..32759b342 --- /dev/null +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_old/model.py @@ -0,0 +1,434 @@ +from typing import Optional, Dict, Any, Sequence, Tuple, List +import functools + +from returnn.tensor import Tensor, Dim, single_step_dim +import returnn.frontend as rf + +from i6_experiments.users.schmitt.returnn_frontend.model_interfaces.model import ModelDef +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.base_old import _batch_size_factor, _log_mel_feature_dim +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.base_old import BaseModel + + +class SegmentalAttentionModel(BaseModel): + def __init__( + self, + length_model_state_dim: Dim, + length_model_embed_dim: Dim, + center_window_size: int, + align_target_dim: Dim, + **kwargs + ): + super(SegmentalAttentionModel, self).__init__(**kwargs) + + self.align_target_dim = align_target_dim + + self.length_model_state_dim = length_model_state_dim + self.length_model_embed_dim = length_model_embed_dim + self.emit_prob_dim = Dim(name="emit_prob", dimension=1) + self.center_window_size = center_window_size + self.accum_att_weights_dim = Dim(name="accum_att_weights", dimension=center_window_size) + + self.target_embed_length_model = rf.Embedding(align_target_dim, self.length_model_embed_dim) + # when using rf.LSTM, something with the parameter import from TF checkpoint was not right + # i.e. the import worked but the LSTM output was different than in TF even though the inputs were the same + # self.s_length_model = rf.LSTM(self.encoder.out_dim + self.length_model_embed_dim, self.length_model_state_dim) + # self.s_length_model = rf.ZoneoutLSTM( + # self.encoder.out_dim + self.length_model_embed_dim, + # self.length_model_state_dim, + # parts_order="jifo", + # forget_bias=0.0, + # ) + self.s_length_model = rf.LSTM( + self.encoder.out_dim + self.length_model_embed_dim, + self.length_model_state_dim, + ) + self.emit_prob = rf.Linear(self.length_model_state_dim, self.emit_prob_dim) + + def label_decoder_default_initial_state( + self, + *, + batch_dims: Sequence[Dim], + segment_starts_sparse_dim: Optional[Dim] = None, + segment_lens_sparse_dim: Optional[Dim] = None, + ) -> rf.State: + """Default initial state""" + state = rf.State( + s=self.s.default_initial_state(batch_dims=batch_dims), + att=rf.zeros(list(batch_dims) + [self.att_num_heads * self.encoder.out_dim]), + accum_att_weights=rf.zeros( + list(batch_dims) + [self.accum_att_weights_dim, self.att_num_heads], feature_dim=self.att_num_heads + ), + segment_starts=rf.zeros(batch_dims, sparse_dim=segment_starts_sparse_dim, dtype="int32"), + segment_lens=rf.zeros(batch_dims, sparse_dim=segment_lens_sparse_dim, dtype="int32"), + ) + state.att.feature_dim_axis = len(state.att.dims) - 1 + return state + + def label_loop_step_output_templates(self, batch_dims: List[Dim]) -> Dict[str, Tensor]: + """loop step out""" + return { + "s": Tensor( + "s", dims=batch_dims + [self.s.out_dim], dtype=rf.get_default_float_dtype(), feature_dim_axis=-1 + ), + "att": Tensor( + "att", + dims=batch_dims + [self.att_num_heads * self.encoder.out_dim], + dtype=rf.get_default_float_dtype(), + feature_dim_axis=-1, + ), + } + + def _get_prev_accum_att_weights_scattered( + self, + prev_accum_att_weights: Tensor, + segment_starts: Tensor, + prev_segment_starts: Tensor, + prev_segment_lens: Tensor, + ) -> Tensor: + + overlap_len = rf.cast(prev_segment_starts + prev_segment_lens - segment_starts, "int32") + overlap_len = rf.where( + rf.logical_or(overlap_len < 0, overlap_len > prev_segment_lens), + rf.convert_to_tensor(0), + overlap_len + ) + overlap_start = prev_segment_lens - overlap_len + + slice_dim = Dim(name="slice", dimension=overlap_len) + gather_positions = rf.range_over_dim(slice_dim) + gather_positions += overlap_start + prev_accum_att_weights_overlap = rf.gather( + prev_accum_att_weights, axis=self.accum_att_weights_dim, indices=gather_positions, clip_to_valid=True + ) + overlap_range = rf.range_over_dim(slice_dim) + + prev_accum_att_weights_scattered = rf.scatter( + prev_accum_att_weights_overlap, + out_dim=self.accum_att_weights_dim, + indices=overlap_range, + indices_dim=slice_dim, + ) + + return prev_accum_att_weights_scattered + + def _get_accum_att_weights( + self, + att_t_dim: Dim, + enc_spatial_dim: Dim, + inv_fertility: Tensor, + att_weights: Tensor, + prev_accum_att_weights_scattered: Tensor, + gather_positions: Tensor, + ) -> Tensor: + att_weights_range = rf.range_over_dim(att_t_dim) + att_weights_scattered = rf.scatter( + att_weights, + out_dim=self.accum_att_weights_dim, + indices=att_weights_range, + indices_dim=att_t_dim, + ) + + inv_fertility_sliced = rf.gather(inv_fertility, axis=enc_spatial_dim, indices=gather_positions, clip_to_valid=True) + inv_fertility_scattered = rf.scatter( + inv_fertility_sliced, + out_dim=self.accum_att_weights_dim, + indices=att_weights_range, + indices_dim=att_t_dim, + ) + + accum_att_weights = prev_accum_att_weights_scattered + att_weights_scattered * inv_fertility_scattered * 0.5 + + return accum_att_weights + + def _get_weight_feedback( + self, + prev_accum_att_weights_scattered: Tensor, + att_t_dim: Dim, + ) -> Tensor: + gather_positions = rf.range_over_dim(att_t_dim) + prev_accum_att_weights_sliced = rf.gather( + prev_accum_att_weights_scattered, + axis=self.accum_att_weights_dim, + indices=gather_positions, + clip_to_valid=True + ) + + return self.weight_feedback(prev_accum_att_weights_sliced) + + def label_sync_loop_step( + self, + *, + enc: rf.Tensor, + enc_ctx: rf.Tensor, + inv_fertility: rf.Tensor, + enc_spatial_dim: Dim, + input_embed: rf.Tensor, + segment_starts: rf.Tensor, + segment_lens: rf.Tensor, + state: Optional[rf.State] = None, + ) -> Tuple[Dict[str, rf.Tensor], rf.State]: + """step of the inner loop""" + if state is None: + batch_dims = enc.remaining_dims( + remove=(enc.feature_dim, enc_spatial_dim) if enc_spatial_dim != single_step_dim else (enc.feature_dim,) + ) + state = self.label_decoder_default_initial_state(batch_dims=batch_dims) + state_ = rf.State() + + # during search, these need to be the values from the previous "emit" step (not necessarily the previous time step) + prev_att = state.att + prev_s_state = state.s + prev_accum_att_weights = state.accum_att_weights + prev_segment_starts = state.segment_starts + prev_segment_lens = state.segment_lens + + s, state_.s = self.s(rf.concat_features(input_embed, prev_att), state=prev_s_state, spatial_dim=single_step_dim) + s_transformed = self.s_transformed(s) + + slice_dim = Dim(name="slice", dimension=segment_lens) + gather_positions = rf.range_over_dim(slice_dim) + gather_positions += segment_starts + + enc_ctx_sliced = rf.gather(enc_ctx, axis=enc_spatial_dim, indices=gather_positions, clip_to_valid=True) + enc_sliced = rf.gather(enc, axis=enc_spatial_dim, indices=gather_positions, clip_to_valid=True) + + prev_accum_att_weights_scattered = self._get_prev_accum_att_weights_scattered( + prev_accum_att_weights=prev_accum_att_weights, + segment_starts=segment_starts, + prev_segment_starts=prev_segment_starts, + prev_segment_lens=prev_segment_lens, + ) + weight_feedback = self._get_weight_feedback( + prev_accum_att_weights_scattered=prev_accum_att_weights_scattered, + att_t_dim=slice_dim, + ) + + energy_in = enc_ctx_sliced + weight_feedback + s_transformed + energy = self.energy(rf.tanh(energy_in)) + att_weights = rf.softmax(energy, axis=slice_dim) + # we do not need use_mask because the softmax output is already padded with zeros + att0 = rf.dot(att_weights, enc_sliced, reduce=slice_dim, use_mask=False) + att0.feature_dim = self.encoder.out_dim + att, _ = rf.merge_dims(att0, dims=(self.att_num_heads, self.encoder.out_dim)) + state_.att = att + + accum_att_weights = self._get_accum_att_weights( + att_t_dim=slice_dim, + enc_spatial_dim=enc_spatial_dim, + inv_fertility=inv_fertility, + att_weights=att_weights, + prev_accum_att_weights_scattered=prev_accum_att_weights_scattered, + gather_positions=gather_positions, + ) + accum_att_weights.feature_dim = self.att_num_heads + state_.accum_att_weights = accum_att_weights + + state_.segment_starts = segment_starts + state_.segment_lens = segment_lens + + return {"s": s, "att": att}, state_ + + def decode_label_logits(self, *, s: Tensor, input_embed: Tensor, att: Tensor) -> Tensor: + """logits for the decoder""" + readout_in = self.readout_in(rf.concat_features(s, input_embed, att)) + readout = rf.reduce_out(readout_in, mode="max", num_pieces=2, out_dim=self.output_prob.in_dim) + readout = rf.dropout(readout, drop_prob=0.3, axis=self.dropout_broadcast and readout.feature_dim) + logits = self.output_prob(readout) + return logits + + def blank_decoder_default_initial_state(self, *, batch_dims: Sequence[Dim]) -> rf.State: + """Default initial state""" + state = rf.State( + s_length_model=self.s_length_model.default_initial_state(batch_dims=batch_dims), + i=rf.zeros(batch_dims, dtype="int32"), + ) + return state + + def blank_loop_step_output_templates(self, batch_dims: List[Dim]) -> Dict[str, Tensor]: + """loop step out""" + return { + "s_length_model": Tensor( + "s_length_model", + dims=batch_dims + [self.s_length_model.out_dim], + dtype=rf.get_default_float_dtype(), + feature_dim_axis=-1 + ), + } + + def time_sync_loop_step( + self, + *, + enc: rf.Tensor, + enc_spatial_dim: Dim, + input_embed: rf.Tensor, + state: Optional[rf.State] = None, + spatial_dim=single_step_dim + ) -> Tuple[Dict[str, rf.Tensor], rf.State]: + """step of the inner loop""" + if state is None: + batch_dims = enc.remaining_dims( + remove=(enc.feature_dim, enc_spatial_dim) if enc_spatial_dim != single_step_dim else (enc.feature_dim,) + ) + state = self.blank_decoder_default_initial_state(batch_dims=batch_dims) + state_ = rf.State() + + if spatial_dim == single_step_dim: + i = state.i + clip_to_valid = True + else: + i = rf.range_over_dim(spatial_dim) + # do clipping here, because rf.gather complains that i.dims_set is not a superset of enc_spatial_dim.dims_set + seq_lens = rf.copy_to_device(enc_spatial_dim.dyn_size_ext, i.device) + i = rf.where(i < seq_lens, i, seq_lens - 1) + clip_to_valid = False + + am = rf.gather(enc, axis=enc_spatial_dim, indices=i, clip_to_valid=clip_to_valid) + s_length_model, state_.s_length_model = self.s_length_model( + rf.concat_features(am, input_embed), + state=state.s_length_model, + spatial_dim=spatial_dim + ) + + state_.i = state.i + 1 + + return {"s_length_model": s_length_model}, state_ + + def decode_blank_logits(self, *, s_length_model: Tensor) -> Tensor: + """logits for the decoder""" + logits = self.emit_prob(s_length_model) + return logits + + +class MakeModel: + """for import""" + + def __init__(self, in_dim: int, align_target_dim: int, target_dim: int, *, center_window_size: int, eos_label: int = 0, num_enc_layers: int = 12): + self.in_dim = in_dim + self.align_target_dim = align_target_dim + self.target_dim = target_dim + self.center_window_size = center_window_size + self.eos_label = eos_label + self.num_enc_layers = num_enc_layers + + def __call__(self) -> SegmentalAttentionModel: + from returnn.datasets.util.vocabulary import Vocabulary + + in_dim = Dim(name="in", dimension=self.in_dim, kind=Dim.Types.Feature) + align_target_dim = Dim(name="align_target", dimension=self.align_target_dim, kind=Dim.Types.Feature) + target_dim = Dim(name="non_blank_target", dimension=self.target_dim, kind=Dim.Types.Feature) + target_dim.vocab = Vocabulary.create_vocab_from_labels( + [str(i) for i in range(target_dim.dimension)], eos_label=self.eos_label + ) + + return self.make_model(in_dim, align_target_dim, target_dim, center_window_size=self.center_window_size) + + @classmethod + def make_model( + cls, + in_dim: Dim, + align_target_dim: Dim, + target_dim: Dim, + *, + center_window_size: int, + num_enc_layers: int = 12, + pos_emb_dropout: float = 0.0, + language_model: Optional[Dict[str, Any]] = None, + **extra, + ) -> SegmentalAttentionModel: + """make""" + lm = None + if language_model: + assert isinstance(language_model, dict) + language_model = language_model.copy() + cls_name = language_model.pop("class") + assert cls_name == "TransformerDecoder" + language_model.pop("vocab_dim", None) # will just overwrite + + from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.lm.trafo import model as trafo_lm + + lm = trafo_lm.MakeModel(vocab_dim=target_dim, **language_model)() + lm = (lm, functools.partial(trafo_lm.make_time_sync_label_scorer_torch, model=lm, align_target_dim=align_target_dim)) + + return SegmentalAttentionModel( + in_dim=in_dim, + num_enc_layers=num_enc_layers, + enc_model_dim=Dim(name="enc", dimension=512, kind=Dim.Types.Feature), + enc_ff_dim=Dim(name="enc-ff", dimension=2048, kind=Dim.Types.Feature), + enc_att_num_heads=8, + enc_conformer_layer_opts=dict( + conv_norm_opts=dict(use_mask=True), + self_att_opts=dict( + # Shawn et al 2018 style, old RETURNN way. + with_bias=False, + with_linear_pos=False, + with_pos_bias=False, + learnable_pos_emb=True, + separate_pos_emb_per_head=False, + pos_emb_dropout=pos_emb_dropout, + ), + ff_activation=lambda x: rf.relu(x) ** 2.0, + ), + target_dim=target_dim, + align_target_dim=align_target_dim, + blank_idx=target_dim.dimension, + language_model=lm, + length_model_state_dim=Dim(name="length_model_state", dimension=128, kind=Dim.Types.Feature), + length_model_embed_dim=Dim(name="length_model_embed", dimension=128, kind=Dim.Types.Feature), + center_window_size=center_window_size, + **extra, + ) + + +def from_scratch_model_def( + *, epoch: int, in_dim: Dim, align_target_dim: Dim, target_dim: Dim) -> SegmentalAttentionModel: + """Function is run within RETURNN.""" + from returnn.config import get_global_config + + in_dim, epoch # noqa + config = get_global_config() # noqa + enc_aux_logits = config.typed_value("aux_loss_layers") + pos_emb_dropout = config.float("pos_emb_dropout", 0.0) + # real input is raw audio, internally it does logmel + in_dim = Dim(name="logmel", dimension=_log_mel_feature_dim, kind=Dim.Types.Feature) + lm_opts = config.typed_value("external_lm") + center_window_size = config.typed_value("center_window_size") + if center_window_size is None: + raise ValueError("center_window_size is not set!") + return MakeModel.make_model( + in_dim, + align_target_dim, + target_dim, + center_window_size=center_window_size, + enc_aux_logits=enc_aux_logits or (), + pos_emb_dropout=pos_emb_dropout, + language_model=lm_opts + ) + + +from_scratch_model_def: ModelDef[SegmentalAttentionModel] +from_scratch_model_def.behavior_version = 16 +from_scratch_model_def.backend = "torch" +from_scratch_model_def.batch_size_factor = _batch_size_factor + + +def _returnn_v2_get_model(*, epoch: int, **_kwargs_unused): + from returnn.tensor import Tensor, Dim + from returnn.config import get_global_config + + config = get_global_config() + default_input_key = config.typed_value("default_input") + default_target_key = config.typed_value("target") + extern_data_dict = config.typed_value("extern_data") + non_blank_vocab = config.typed_value("non_blank_vocab") + data = Tensor(name=default_input_key, **extern_data_dict[default_input_key]) + targets = Tensor(name=default_target_key, **extern_data_dict[default_target_key]) + non_blank_targets = Tensor( + name="non_blank_targets", + sparse_dim=Dim(description="non_blank_vocab", dimension=targets.sparse_dim.dimension - 1, kind=Dim.Types.Spatial), + vocab=non_blank_vocab, + ) + + model_def = config.typed_value("_model_def") + model = model_def( + epoch=epoch, in_dim=data.feature_dim, align_target_dim=targets.sparse_dim, target_dim=non_blank_targets.sparse_dim) + return model diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_import.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_old/model_import.py similarity index 100% rename from users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_import.py rename to users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_old/model_import.py diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_old/recog.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_old/recog.py new file mode 100644 index 000000000..bce5d47b6 --- /dev/null +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_old/recog.py @@ -0,0 +1,527 @@ +from typing import Optional, Dict, Any, Tuple +import tree + +from returnn.tensor import Tensor, Dim +import returnn.frontend as rf +from returnn.frontend.tensor_array import TensorArray + +from i6_experiments.users.schmitt.returnn_frontend.model_interfaces.recog import RecogDef +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.base import _batch_size_factor +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model_old.model import SegmentalAttentionModel +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.utils import get_masked, get_non_blank_mask + + +def model_recog( + *, + model: SegmentalAttentionModel, + data: Tensor, + data_spatial_dim: Dim, + max_seq_len: Optional[int] = None, +) -> Tuple[Tensor, Tensor, Dim, Dim]: + """ + Function is run within RETURNN. + + Earlier we used the generic beam_search function, + but now we just directly perform the search here, + as this is overall simpler and shorter. + + :return: + recog results including beam {batch, beam, out_spatial}, + log probs {batch, beam}, + out_spatial_dim, + final beam_dim + """ + assert not model.language_model # not implemented here. use the pure PyTorch search instead + + batch_dims = data.remaining_dims((data_spatial_dim, data.feature_dim)) + enc_args, enc_spatial_dim = model.encode(data, in_spatial_dim=data_spatial_dim) + beam_size = 12 + if max_seq_len is None: + max_seq_len = enc_spatial_dim.get_size_tensor() + else: + max_seq_len = rf.convert_to_tensor(max_seq_len, dtype="int32") + print("** max seq len:", max_seq_len.raw_tensor) + max_seq_len = rf.reduce_max(max_seq_len, axis=max_seq_len.dims) + + # Eager-mode implementation of beam search. + # Initial state. + beam_dim = Dim(1, name="initial-beam") + batch_dims_ = [beam_dim] + batch_dims + label_decoder_state = model.label_decoder_default_initial_state(batch_dims=batch_dims_,) + + blank_decoder_state = model.blank_decoder_default_initial_state(batch_dims=batch_dims_) + bos_idx = 0 + target = rf.constant(bos_idx, dims=batch_dims_, sparse_dim=model.align_target_dim) + target_non_blank = rf.constant(bos_idx, dims=batch_dims_, sparse_dim=model.target_dim) + # ended = rf.constant(False, dims=batch_dims_) + seq_log_prob = rf.constant(0.0, dims=batch_dims_) + + i = 0 + seq_targets = [] + seq_backrefs = [] + while i < max_seq_len.raw_tensor: + if i == 0: + input_embed = rf.zeros(batch_dims_ + [model.target_embed.out_dim], feature_dim=model.target_embed.out_dim, dtype="float32") + input_embed_length_model = rf.zeros( + batch_dims_ + [model.target_embed_length_model.out_dim], feature_dim=model.target_embed_length_model.out_dim) + else: + input_embed_length_model = model.target_embed_length_model(target) + + # ------------------- label step ------------------- + center_position = rf.minimum( + rf.full(dims=[beam_dim] + batch_dims, fill_value=i, dtype="int32"), + rf.copy_to_device(enc_spatial_dim.get_size_tensor() - 1, data.device) + ) + segment_starts = rf.maximum( + rf.convert_to_tensor(0, dtype="int32"), center_position - model.center_window_size // 2) + segment_ends = rf.minimum( + rf.copy_to_device(enc_spatial_dim.get_size_tensor() - 1, data.device), + center_position + model.center_window_size // 2 + ) + segment_lens = segment_ends - segment_starts + 1 + + label_step_out, label_decoder_state_updated = model.label_sync_loop_step( + **enc_args, + enc_spatial_dim=enc_spatial_dim, + input_embed=input_embed, + segment_lens=segment_lens, + segment_starts=segment_starts, + state=label_decoder_state, + ) + label_logits = model.decode_label_logits(input_embed=input_embed, **label_step_out) + label_log_prob = rf.log_softmax(label_logits, axis=model.target_dim) + + # ------------------- blank step ------------------- + + blank_step_out, blank_decoder_state = model.time_sync_loop_step( + enc=enc_args["enc"], + enc_spatial_dim=enc_spatial_dim, + input_embed=input_embed_length_model, + state=blank_decoder_state, + ) + blank_logits = model.decode_blank_logits(**blank_step_out) + emit_log_prob = rf.log(rf.sigmoid(blank_logits)) + emit_log_prob = rf.squeeze(emit_log_prob, axis=emit_log_prob.feature_dim) + blank_log_prob = rf.log(rf.sigmoid(-blank_logits)) + + # combine blank and label probs + label_log_prob += emit_log_prob + output_log_prob, _ = rf.concat( + (label_log_prob, model.target_dim), (blank_log_prob, blank_log_prob.feature_dim), + out_dim=model.align_target_dim + ) + + # top-k + seq_log_prob = seq_log_prob + output_log_prob # Batch, InBeam, Vocab + old_beam_dim = beam_dim.copy() + seq_log_prob, (backrefs, target), beam_dim = rf.top_k( + seq_log_prob, k_dim=Dim(beam_size, name=f"dec-step{i}-beam"), axis=[beam_dim, model.align_target_dim] + ) # seq_log_prob, backrefs, target: Batch, Beam + seq_targets.append(target) + seq_backrefs.append(backrefs) + + update_state_mask = rf.convert_to_tensor(target != model.blank_idx) + + def _get_masked_state(old, new, mask): + old = rf.gather(old, indices=backrefs, axis=old_beam_dim) + new = rf.gather(new, indices=backrefs, axis=old_beam_dim) + return rf.where(mask, new, old) + + label_decoder_state = tree.map_structure( + lambda old_state, new_state: _get_masked_state(old_state, new_state, update_state_mask), + label_decoder_state, label_decoder_state_updated + ) + + target_non_blank = rf.where(update_state_mask, target, rf.gather(target_non_blank, indices=backrefs)) + target_non_blank.sparse_dim = model.target_embed.in_dim + input_embed = rf.where( + update_state_mask, + model.target_embed(target_non_blank), + rf.gather(input_embed, indices=backrefs, axis=old_beam_dim) + ) + + blank_decoder_state = tree.map_structure(lambda s: rf.gather(s, indices=backrefs), blank_decoder_state) + + i += 1 + + # Backtrack via backrefs, resolve beams. + seq_targets_ = [] + indices = rf.range_over_dim(beam_dim) # FinalBeam -> FinalBeam + for backrefs, target in zip(seq_backrefs[::-1], seq_targets[::-1]): + # indices: FinalBeam -> Beam + # backrefs: Beam -> PrevBeam + seq_targets_.insert(0, rf.gather(target, indices=indices)) + indices = rf.gather(backrefs, indices=indices) # FinalBeam -> PrevBeam + + seq_targets__ = TensorArray(seq_targets_[0]) + for target in seq_targets_: + seq_targets__ = seq_targets__.push_back(target) + seq_targets = seq_targets__.stack(axis=enc_spatial_dim) + + non_blank_targets, non_blank_targets_spatial_dim = get_masked( + seq_targets, + get_non_blank_mask(seq_targets, model.blank_idx), + enc_spatial_dim, + [beam_dim] + batch_dims, + ) + non_blank_targets.sparse_dim = model.target_dim + + return non_blank_targets, seq_log_prob, non_blank_targets_spatial_dim, beam_dim + + +# RecogDef API +model_recog: RecogDef[SegmentalAttentionModel] +model_recog.output_with_beam = True +# output_blank_label=blank is actually wrong for AED, but now we don't change it anymore +# because it would change all recog hashes. +# Also, it does not matter too much -- it will just cause an extra SearchRemoveLabelJob, +# which will not have any effect here. +model_recog.output_blank_label = "" +model_recog.batch_size_dependent = False + + +def model_recog_pure_torch( + *, + model: SegmentalAttentionModel, + data: Tensor, + data_spatial_dim: Dim, + max_seq_len: Optional[int] = None, +) -> Tuple[Tensor, Tensor, Dim, Dim]: + """ + Function is run within RETURNN. + + Earlier we used the generic beam_search function, + but now we just directly perform the search here, + as this is overall simpler and shorter. + + :return: + recog results including beam {batch, beam, out_spatial}, + log probs {batch, beam}, + recog results info: key -> {batch, beam}, + out_spatial_dim, + final beam_dim + """ + import torch + from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.beam_search.time_sync import BeamSearchOpts, time_sync_beam_search + from i6_experiments.users.schmitt.returnn_frontend.model_interfaces.label_scorer import ShallowFusedLabelScorers + from returnn.config import get_global_config + + config = get_global_config() + + torch.cuda.set_sync_debug_mode(1) # debug CUDA sync. does not hurt too much to leave this always in? + + data_concat_zeros = config.float("data_concat_zeros", 0) + if data_concat_zeros: + data_concat_zeros_dim = Dim(int(data_concat_zeros * _batch_size_factor * 100), name="data_concat_zeros") + data, data_spatial_dim = rf.concat( + (data, data_spatial_dim), (rf.zeros([data_concat_zeros_dim]), data_concat_zeros_dim), allow_broadcast=True + ) + + batch_dims = data.remaining_dims((data_spatial_dim, data.feature_dim)) + assert len(batch_dims) == 1, batch_dims # not implemented otherwise, simple to add... + batch_dim = batch_dims[0] + enc, enc_spatial_dim = model.encode(data, in_spatial_dim=data_spatial_dim) + if max_seq_len is None: + max_seq_len = enc_spatial_dim.get_size_tensor() + else: + max_seq_len = rf.convert_to_tensor(max_seq_len, dtype="int32") + + beam_search_opts = (config.typed_value("beam_search_opts", None) or {}).copy() + if beam_search_opts.get("beam_size") is None: + beam_search_opts["beam_size"] = config.int("beam_size", 12) + if beam_search_opts.get("length_normalization_exponent") is None: + beam_search_opts["length_normalization_exponent"] = config.float("length_normalization_exponent", 1.0) + + label_scorer = ShallowFusedLabelScorers() + label_scorer.label_scorers["label_sync_decoder"] = ( + get_label_sync_scorer_pure_torch(model=model, batch_dim=batch_dim, enc=enc, enc_spatial_dim=enc_spatial_dim), + 1.0, + ) + label_scorer.label_scorers["time_sync_decoder"] = ( + get_time_sync_scorer_pure_torch(model=model, batch_dim=batch_dim, enc=enc, enc_spatial_dim=enc_spatial_dim), + 1.0, + ) + if model.language_model: + lm_scale = beam_search_opts.pop("lm_scale") # must be defined with LM + label_scorer.label_scorers["lm"] = (model.language_model_make_label_scorer(), lm_scale) + + print("** max seq len:", max_seq_len.raw_tensor) + + # Beam search happening here: + ( + seq_targets, # [Batch,FinalBeam,OutSeqLen] + seq_log_prob, # [Batch,FinalBeam] + ) = time_sync_beam_search( + label_scorer, + label_sync_keys=["label_sync_decoder", "lm"] if model.language_model else ["label_sync_decoder"], + time_sync_keys=["time_sync_decoder"], + batch_size=int(batch_dim.get_dim_value()), + blank_idx=model.blank_idx, + max_seq_len=max_seq_len.copy_compatible_to_dims_raw([batch_dim]), + device=data.raw_tensor.device, + opts=BeamSearchOpts( + **beam_search_opts, + bos_label=0, + eos_label=0, + num_labels=model.target_dim.dimension, + ), + ) + + beam_dim = Dim(seq_log_prob.shape[1], name="beam") + seq_targets_t = rf.convert_to_tensor( + seq_targets, dims=[batch_dim, beam_dim, enc_spatial_dim], sparse_dim=model.target_dim + ) + seq_log_prob_t = rf.convert_to_tensor(seq_log_prob, dims=[batch_dim, beam_dim]) + + non_blank_targets, non_blank_targets_spatial_dim = get_masked( + seq_targets_t, + get_non_blank_mask(seq_targets_t, model.blank_idx), + enc_spatial_dim, + [beam_dim] + batch_dims, + ) + non_blank_targets.sparse_dim = model.target_dim + + return non_blank_targets, seq_log_prob_t, non_blank_targets_spatial_dim, beam_dim + + +# RecogDef API +model_recog_pure_torch: RecogDef[SegmentalAttentionModel] +model_recog_pure_torch.output_with_beam = True +model_recog_pure_torch.output_blank_label = None +model_recog_pure_torch.batch_size_dependent = False + + +def get_label_sync_scorer_pure_torch( + *, + model: SegmentalAttentionModel, + batch_dim: Dim, + enc: Dict[str, Tensor], + enc_spatial_dim: Dim, +): + import torch + import functools + from i6_experiments.users.schmitt.returnn_frontend.model_interfaces.label_scorer import ( + LabelScorerIntf, + StateObjTensorExt, + StateObjIgnored, + ) + + class LabelScorer(LabelScorerIntf): + """label scorer""" + + def get_initial_state(self, *, batch_size: int, device: torch.device) -> Any: + """Initial state.""" + beam_dim = Dim(1, name="initial-beam") + batch_dims_ = [batch_dim, beam_dim] + decoder_state = model.label_decoder_default_initial_state(batch_dims=batch_dims_,) + return tree.map_structure(functools.partial(self._map_tensor_to_raw, beam_dim=beam_dim), decoder_state) + + def score_and_update_state( + self, + *, + prev_state: Any, + prev_label: torch.Tensor, + prev_align_label: Optional[torch.Tensor] = None, + t: Optional[int] = None, + ) -> Tuple[torch.Tensor, Any]: + """update state""" + beam_dim = Dim(prev_label.shape[1], name="beam") + assert t is not None + + def _map_raw_to_tensor(v): + if isinstance(v, StateObjTensorExt): + tensor: Tensor = v.extra + tensor = tensor.copy_template_new_dim_tags( + (batch_dim, beam_dim) + tensor.dims[2:], keep_special_axes=True + ) + tensor.raw_tensor = v.tensor + return tensor + elif isinstance(v, StateObjIgnored): + return v.content + else: + raise TypeError(f"_map_raw_to_tensor: unexpected {v} ({type(v).__name__})") + + center_position = rf.minimum( + rf.full(dims=[beam_dim, batch_dim], fill_value=t, dtype="int32"), + rf.copy_to_device(enc_spatial_dim.get_size_tensor() - 1, enc["enc"].device) + ) + segment_starts = rf.maximum( + rf.convert_to_tensor(0, dtype="int32"), center_position - model.center_window_size // 2) + segment_ends = rf.minimum( + rf.copy_to_device(enc_spatial_dim.get_size_tensor() - 1, enc["enc"].device), + center_position + model.center_window_size // 2 + ) + segment_lens = segment_ends - segment_starts + 1 + + zeros_embed = rf.zeros( + [batch_dim, beam_dim, model.target_embed.out_dim], + feature_dim=model.target_embed.out_dim, + dtype="float32" + ) + initial_output_mask = rf.convert_to_tensor(prev_label == -1, dims=[batch_dim, beam_dim]) + prev_label = rf.convert_to_tensor(prev_label, dims=[batch_dim, beam_dim], sparse_dim=model.target_dim) + prev_label = rf.where( + initial_output_mask, + rf.zeros_like(prev_label), + prev_label + ) + input_embed = rf.where( + initial_output_mask, + zeros_embed, + model.target_embed(prev_label) + ) + + decode_out, decoder_state = model.label_sync_loop_step( + **enc, + enc_spatial_dim=enc_spatial_dim, + input_embed=input_embed, + segment_lens=segment_lens, + segment_starts=segment_starts, + state=tree.map_structure(_map_raw_to_tensor, prev_state), + ) + logits = model.decode_label_logits(input_embed=input_embed, **decode_out) + label_log_prob = rf.log_softmax(logits, axis=model.target_dim) + + blank_log_prob = rf.zeros( + [Dim(1, name="blank_log_prob_label_scorer")], + dtype="float32" + ) + output_log_prob, _ = rf.concat( + (label_log_prob, model.target_dim), (blank_log_prob, blank_log_prob.dims[0]), + out_dim=model.align_target_dim, + allow_broadcast=True + ) + assert set(output_log_prob.dims) == {batch_dim, beam_dim, model.align_target_dim} + + return ( + self._map_tensor_to_raw(output_log_prob, beam_dim=beam_dim).tensor, + tree.map_structure(functools.partial(self._map_tensor_to_raw, beam_dim=beam_dim), decoder_state), + ) + + @staticmethod + def _map_tensor_to_raw(v, *, beam_dim: Dim): + if isinstance(v, Tensor): + if beam_dim not in v.dims: + return StateObjIgnored(v) + batch_dims_ = [batch_dim, beam_dim] + v = v.copy_transpose(batch_dims_ + [dim for dim in v.dims if dim not in batch_dims_]) + raw = v.raw_tensor + return StateObjTensorExt(raw, v.copy_template()) + elif isinstance(v, Dim): + return StateObjIgnored(v) + else: + raise TypeError(f"_map_tensor_to_raw: unexpected {v} ({type(v).__name__})") + + return LabelScorer() + + +def get_time_sync_scorer_pure_torch( + *, + model: SegmentalAttentionModel, + batch_dim: Dim, + enc: Dict[str, Tensor], + enc_spatial_dim: Dim, +): + import torch + import functools + from i6_experiments.users.schmitt.returnn_frontend.model_interfaces.label_scorer import ( + LabelScorerIntf, + StateObjTensorExt, + StateObjIgnored, + ) + + class LabelScorer(LabelScorerIntf): + """label scorer""" + + def get_initial_state(self, *, batch_size: int, device: torch.device) -> Any: + """Initial state.""" + beam_dim = Dim(1, name="initial-beam") + batch_dims_ = [batch_dim, beam_dim] + decoder_state = model.blank_decoder_default_initial_state(batch_dims=batch_dims_,) + return tree.map_structure(functools.partial(self._map_tensor_to_raw, beam_dim=beam_dim), decoder_state) + + def score_and_update_state( + self, + *, + prev_state: Any, + prev_label: torch.Tensor, + prev_align_label: Optional[torch.Tensor] = None, + t: Optional[int] = None, + ) -> Tuple[torch.Tensor, Any]: + """update state""" + beam_dim = Dim(prev_label.shape[1], name="beam") + assert prev_align_label is not None + + def _map_raw_to_tensor(v): + if isinstance(v, StateObjTensorExt): + tensor: Tensor = v.extra + tensor = tensor.copy_template_new_dim_tags( + (batch_dim, beam_dim) + tensor.dims[2:], keep_special_axes=True + ) + tensor.raw_tensor = v.tensor + return tensor + elif isinstance(v, StateObjIgnored): + return v.content + else: + raise TypeError(f"_map_raw_to_tensor: unexpected {v} ({type(v).__name__})") + + zeros_embed = rf.zeros( + [batch_dim, beam_dim, model.target_embed_length_model.out_dim], + feature_dim=model.target_embed_length_model.out_dim, + dtype="float32" + ) + initial_output_mask = rf.convert_to_tensor(prev_align_label == -1, dims=[batch_dim, beam_dim]) + prev_align_label = rf.convert_to_tensor(prev_align_label, dims=[batch_dim, beam_dim], sparse_dim=model.align_target_dim) + prev_align_label = rf.where( + initial_output_mask, + rf.zeros_like(prev_align_label), + prev_align_label + ) + input_embed = rf.where( + initial_output_mask, + zeros_embed, + model.target_embed_length_model(prev_align_label) + ) + + decode_out, decoder_state = model.time_sync_loop_step( + enc=enc["enc"], + enc_spatial_dim=enc_spatial_dim, + input_embed=input_embed, + state=tree.map_structure(_map_raw_to_tensor, prev_state), + ) + blank_logits = model.decode_blank_logits(**decode_out) + emit_log_prob = rf.log(rf.sigmoid(blank_logits)) + emit_log_prob = rf.squeeze(emit_log_prob, axis=emit_log_prob.feature_dim) + blank_log_prob = rf.log(rf.sigmoid(-blank_logits)) + + label_log_prob = rf.zeros( + dims=[batch_dim, beam_dim, model.target_dim], + dtype="float32" + ) + label_log_prob += emit_log_prob + output_log_prob, _ = rf.concat( + (label_log_prob, model.target_dim), (blank_log_prob, blank_log_prob.feature_dim), + out_dim=model.align_target_dim + ) + assert set(output_log_prob.dims) == {batch_dim, beam_dim, model.align_target_dim} + + return ( + self._map_tensor_to_raw(output_log_prob, beam_dim=beam_dim).tensor, + tree.map_structure(functools.partial(self._map_tensor_to_raw, beam_dim=beam_dim), decoder_state), + ) + + @staticmethod + def _map_tensor_to_raw(v, *, beam_dim: Dim): + if isinstance(v, Tensor): + if beam_dim not in v.dims: + return StateObjIgnored(v) + batch_dims_ = [batch_dim, beam_dim] + v = v.copy_transpose(batch_dims_ + [dim for dim in v.dims if dim not in batch_dims_]) + raw = v.raw_tensor + return StateObjTensorExt(raw, v.copy_template()) + elif isinstance(v, Dim): + return StateObjIgnored(v) + else: + raise TypeError(f"_map_tensor_to_raw: unexpected {v} ({type(v).__name__})") + + return LabelScorer() diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_old/train.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_old/train.py new file mode 100644 index 000000000..3b62b32c2 --- /dev/null +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_old/train.py @@ -0,0 +1,280 @@ +from typing import Dict, List + +from i6_experiments.users.schmitt.returnn_frontend.model_interfaces.training import FramewiseTrainDef + +from returnn.tensor import TensorDict + +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.utils import get_non_blank_mask, get_masked +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model_old.model import SegmentalAttentionModel + +from returnn.tensor import Dim +import returnn.frontend as rf + +from i6_experiments.users.schmitt.returnn_frontend.model_interfaces.training import TrainDef + + +def _returnn_v2_train_step(*, model, extern_data: TensorDict, **_kwargs_unused): + from returnn.config import get_global_config + + config = get_global_config() + default_input_key = config.typed_value("default_input") + default_target_key = config.typed_value("target") + data = extern_data[default_input_key] + data_spatial_dim = data.get_time_dim_tag() + targets = extern_data[default_target_key] + targets_spatial_dim = targets.get_time_dim_tag() + train_def: FramewiseTrainDef = config.typed_value("_train_def") + train_def( + model=model, + data=data, + data_spatial_dim=data_spatial_dim, + align_targets=targets, + align_targets_spatial_dim=targets_spatial_dim, + ) + + +def get_blank_loop_out_unoptimized( + model: SegmentalAttentionModel, + enc_args: Dict, + enc_spatial_dim: Dim, + align_targets_spatial_dim: Dim, + align_input_embeddings: rf.Tensor, + batch_dims: List[Dim] +): + def _blank_loop_body(xs, state: rf.State): + new_state = rf.State() + loop_out_, new_state.decoder = model.time_sync_loop_step( + enc=enc_args["enc"], + enc_spatial_dim=enc_spatial_dim, + input_embed=xs["input_embed"], + state=state.decoder, + ) + return loop_out_, new_state + + blank_loop_out, _, _ = rf.scan( + spatial_dim=align_targets_spatial_dim, + xs={ + "input_embed": align_input_embeddings, + }, + ys=model.blank_loop_step_output_templates(batch_dims=batch_dims), + initial=rf.State( + decoder=model.blank_decoder_default_initial_state( + batch_dims=batch_dims, + ), + ), + body=_blank_loop_body, + ) + return blank_loop_out + + +def get_blank_loop_out_optimized( + model: SegmentalAttentionModel, + enc_args: Dict, + enc_spatial_dim: Dim, + align_input_embeddings: rf.Tensor, + batch_dims: List[Dim], + align_targets_spatial_dim: Dim +): + blank_loop_out, _ = model.time_sync_loop_step( + enc=enc_args["enc"], + enc_spatial_dim=enc_spatial_dim, + input_embed=align_input_embeddings, + state=model.blank_decoder_default_initial_state(batch_dims=batch_dims,), + spatial_dim=align_targets_spatial_dim, + ) + return blank_loop_out + + +def from_scratch_training( + *, + model: SegmentalAttentionModel, + data: rf.Tensor, + data_spatial_dim: Dim, + align_targets: rf.Tensor, + align_targets_spatial_dim: Dim +): + """ + Here + """ + from returnn.config import get_global_config + import torch + + config = get_global_config() # noqa + aux_loss_layers = config.typed_value("aux_loss_layers") + aux_loss_scales = config.typed_value("aux_loss_scales", ([1.0] * len(aux_loss_layers)) if aux_loss_layers else None) + aed_loss_scale = config.float("aed_loss_scale", 1.0) + use_normalized_loss = config.bool("use_normalized_loss", True) + use_optimized_length_model_loop = config.bool("use_optimized_length_model_loop", True) + + if data.feature_dim and data.feature_dim.dimension == 1: + data = rf.squeeze(data, axis=data.feature_dim) + assert not data.feature_dim # raw audio + + batch_dims = data.remaining_dims(data_spatial_dim) + + def _get_segment_starts_and_lens(out_spatial_dim: Dim): + non_blank_mask = get_non_blank_mask(align_targets, model.blank_idx) + targets_range = rf.range_over_dim(align_targets_spatial_dim, dtype="int32") + targets_range = rf.expand_dim(targets_range, batch_dims[0]) + non_blank_positions, _ = get_masked( + targets_range, non_blank_mask, align_targets_spatial_dim, batch_dims, out_spatial_dim + ) + starts = rf.maximum( + rf.convert_to_tensor(0, dtype="int32"), non_blank_positions - model.center_window_size // 2) + ends = rf.minimum( + rf.copy_to_device(align_targets_spatial_dim.get_size_tensor() - 1, non_blank_positions.device), + non_blank_positions + model.center_window_size // 2 + ) + lens = ends - starts + 1 + + return starts, lens + + def _get_emit_ground_truth(): + non_blank_mask = get_non_blank_mask(align_targets, model.blank_idx) + result = rf.where(non_blank_mask, rf.convert_to_tensor(1), rf.convert_to_tensor(0)) + sparse_dim = Dim(name="emit_ground_truth", dimension=2) + # result = rf.expand_dim(result, sparse_dim) + result.sparse_dim = sparse_dim + torch.set_printoptions(threshold=10000) + + return result, sparse_dim + + non_blank_targets, non_blank_targets_spatial_dim = get_masked( + align_targets, get_non_blank_mask(align_targets, model.blank_idx), align_targets_spatial_dim, batch_dims + ) + non_blank_targets.sparse_dim = model.target_dim + segment_starts, segment_lens = _get_segment_starts_and_lens(non_blank_targets_spatial_dim) + + # ------------------- encoder aux loss ------------------- + + collected_outputs = {} + enc_args, enc_spatial_dim = model.encode(data, in_spatial_dim=data_spatial_dim, collected_outputs=collected_outputs) + + if aux_loss_layers: + for i, layer_idx in enumerate(aux_loss_layers): + if layer_idx > len(model.encoder.layers): + continue + linear = getattr(model, f"enc_aux_logits_{layer_idx}") + aux_logits = linear(collected_outputs[str(layer_idx - 1)]) + aux_loss = rf.ctc_loss( + logits=aux_logits, + targets=non_blank_targets, + input_spatial_dim=enc_spatial_dim, + targets_spatial_dim=non_blank_targets_spatial_dim, + blank_index=model.blank_idx, + ) + aux_loss.mark_as_loss( + f"ctc_{layer_idx}", + scale=aux_loss_scales[i], + custom_inv_norm_factor=align_targets_spatial_dim.get_size_tensor(), + use_normalized_loss=use_normalized_loss, + ) + + non_blank_input_embeddings = model.target_embed(non_blank_targets) + non_blank_input_embeddings = rf.shift_right( + non_blank_input_embeddings, axis=non_blank_targets_spatial_dim, pad_value=0.0) + + align_input_embeddings = model.target_embed_length_model(align_targets) + align_input_embeddings = rf.shift_right( + align_input_embeddings, axis=align_targets_spatial_dim, pad_value=0.0) + + # ------------------- label loop ------------------- + + def _label_loop_body(xs, state: rf.State): + new_state = rf.State() + loop_out_, new_state.decoder = model.label_sync_loop_step( + **enc_args, + enc_spatial_dim=enc_spatial_dim, + input_embed=xs["input_embed"], + segment_starts=xs["segment_starts"], + segment_lens=xs["segment_lens"], + state=state.decoder, + ) + return loop_out_, new_state + + label_loop_out, _, _ = rf.scan( + spatial_dim=non_blank_targets_spatial_dim, + xs={ + "input_embed": non_blank_input_embeddings, + "segment_starts": segment_starts, + "segment_lens": segment_lens, + }, + ys=model.label_loop_step_output_templates(batch_dims=batch_dims), + initial=rf.State( + decoder=model.label_decoder_default_initial_state( + batch_dims=batch_dims, + # TODO: do we need these sparse dims? they are automatically added by rf.range_over_dim + segment_starts_sparse_dim=segment_starts.sparse_dim, + segment_lens_sparse_dim=segment_lens.sparse_dim, + ), + ), + body=_label_loop_body, + ) + + logits = model.decode_label_logits(input_embed=non_blank_input_embeddings, **label_loop_out) + logits_packed, pack_dim = rf.pack_padded(logits, dims=batch_dims + [non_blank_targets_spatial_dim], enforce_sorted=False) + non_blank_targets_packed, _ = rf.pack_padded( + non_blank_targets, dims=batch_dims + [non_blank_targets_spatial_dim], enforce_sorted=False, out_dim=pack_dim + ) + + log_prob = rf.log_softmax(logits_packed, axis=model.target_dim) + # deactivate to compare to old returnn training (label smoothing is done differently) + # log_prob = rf.label_smoothed_log_prob_gradient(log_prob, 0.1, axis=model.target_dim) + loss = rf.cross_entropy( + target=non_blank_targets_packed, estimated=log_prob, estimated_type="log-probs", axis=model.target_dim + ) + loss.mark_as_loss("non_blank_ce", scale=aed_loss_scale, use_normalized_loss=use_normalized_loss) + + best = rf.reduce_argmax(logits_packed, axis=model.target_dim) + frame_error = best != non_blank_targets_packed + frame_error.mark_as_loss(name="non_blank_fer", as_error=True) + + # ------------------- blank loop ------------------- + + if use_optimized_length_model_loop: + blank_loop_out = get_blank_loop_out_optimized( + model=model, + enc_args=enc_args, + enc_spatial_dim=enc_spatial_dim, + align_targets_spatial_dim=align_targets_spatial_dim, + align_input_embeddings=align_input_embeddings, + batch_dims=batch_dims + ) + else: + blank_loop_out = get_blank_loop_out_unoptimized( + model=model, + enc_args=enc_args, + enc_spatial_dim=enc_spatial_dim, + align_targets_spatial_dim=align_targets_spatial_dim, + align_input_embeddings=align_input_embeddings, + batch_dims=batch_dims + ) + + blank_logits = model.decode_blank_logits(**blank_loop_out) + blank_logits_packed, pack_dim = rf.pack_padded(blank_logits, dims=batch_dims + [align_targets_spatial_dim], enforce_sorted=False) + emit_ground_truth, emit_blank_target_dim = _get_emit_ground_truth() + emit_ground_truth_packed, _ = rf.pack_padded( + emit_ground_truth, dims=batch_dims + [align_targets_spatial_dim], enforce_sorted=False, out_dim=pack_dim + ) + + # rf.log_sigmoid not implemented for torch backend + emit_log_prob = rf.log(rf.sigmoid(blank_logits_packed)) + blank_log_prob = rf.log(rf.sigmoid(-blank_logits_packed)) + blank_logit_dim = blank_logits_packed.remaining_dims((pack_dim,))[0] + emit_blank_log_prob, _ = rf.concat( + (blank_log_prob, blank_logit_dim), (emit_log_prob, blank_logit_dim), out_dim=emit_blank_target_dim) + blank_loss = rf.cross_entropy( + target=emit_ground_truth_packed, + estimated=emit_blank_log_prob, + estimated_type="log-probs", + axis=emit_blank_target_dim + ) + blank_loss.mark_as_loss("emit_blank_ce", scale=aed_loss_scale, use_normalized_loss=use_normalized_loss) + + best = rf.reduce_argmax(emit_blank_log_prob, axis=emit_blank_target_dim) + frame_error = best != emit_ground_truth_packed + frame_error.mark_as_loss(name="emit_blank_fer", as_error=True) + + +from_scratch_training: TrainDef[SegmentalAttentionModel] +from_scratch_training.learning_rate_control_error_measure = "dev_score_full_sum" diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/recog.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/recog.py index eb03bebcd..4245362d5 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/recog.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/recog.py @@ -31,10 +31,10 @@ def model_recog( out_spatial_dim, final beam_dim """ - assert not model.language_model # not implemented here. use the pure PyTorch search instead + assert not model.label_decoder.language_model # not implemented here. use the pure PyTorch search instead batch_dims = data.remaining_dims((data_spatial_dim, data.feature_dim)) - enc_args, enc_spatial_dim = model.encode(data, in_spatial_dim=data_spatial_dim) + enc_args, enc_spatial_dim = model.encoder.encode(data, in_spatial_dim=data_spatial_dim) beam_size = 12 if max_seq_len is None: max_seq_len = enc_spatial_dim.get_size_tensor() @@ -47,9 +47,9 @@ def model_recog( # Initial state. beam_dim = Dim(1, name="initial-beam") batch_dims_ = [beam_dim] + batch_dims - label_decoder_state = model.label_decoder_default_initial_state(batch_dims=batch_dims_,) + label_decoder_state = model.label_decoder.default_initial_state(batch_dims=batch_dims_, ) - blank_decoder_state = model.blank_decoder_default_initial_state(batch_dims=batch_dims_) + blank_decoder_state = model.blank_decoder.default_initial_state(batch_dims=batch_dims_) bos_idx = 0 target = rf.constant(bos_idx, dims=batch_dims_, sparse_dim=model.align_target_dim) target_non_blank = rf.constant(bos_idx, dims=batch_dims_, sparse_dim=model.target_dim) @@ -61,11 +61,15 @@ def model_recog( seq_backrefs = [] while i < max_seq_len.raw_tensor: if i == 0: - input_embed = rf.zeros(batch_dims_ + [model.target_embed.out_dim], feature_dim=model.target_embed.out_dim, dtype="float32") + input_embed = rf.zeros( + batch_dims_ + [model.label_decoder.target_embed.out_dim], + feature_dim=model.label_decoder.target_embed.out_dim, + dtype="float32" + ) input_embed_length_model = rf.zeros( - batch_dims_ + [model.target_embed_length_model.out_dim], feature_dim=model.target_embed_length_model.out_dim) + batch_dims_ + [model.blank_decoder.target_embed.out_dim], feature_dim=model.blank_decoder.target_embed.out_dim) else: - input_embed_length_model = model.target_embed_length_model(target) + input_embed_length_model = model.blank_decoder.target_embed(target) # ------------------- label step ------------------- center_position = rf.minimum( @@ -80,7 +84,7 @@ def model_recog( ) segment_lens = segment_ends - segment_starts + 1 - label_step_out, label_decoder_state_updated = model.label_sync_loop_step( + label_step_out, label_decoder_state_updated = model.label_decoder.loop_step( **enc_args, enc_spatial_dim=enc_spatial_dim, input_embed=input_embed, @@ -88,18 +92,18 @@ def model_recog( segment_starts=segment_starts, state=label_decoder_state, ) - label_logits = model.decode_label_logits(input_embed=input_embed, **label_step_out) + label_logits = model.label_decoder.decode_logits(input_embed=input_embed, **label_step_out) label_log_prob = rf.log_softmax(label_logits, axis=model.target_dim) # ------------------- blank step ------------------- - blank_step_out, blank_decoder_state = model.time_sync_loop_step( + blank_step_out, blank_decoder_state = model.blank_decoder.loop_step( enc=enc_args["enc"], enc_spatial_dim=enc_spatial_dim, input_embed=input_embed_length_model, state=blank_decoder_state, ) - blank_logits = model.decode_blank_logits(**blank_step_out) + blank_logits = model.blank_decoder.decode_logits(**blank_step_out) emit_log_prob = rf.log(rf.sigmoid(blank_logits)) emit_log_prob = rf.squeeze(emit_log_prob, axis=emit_log_prob.feature_dim) blank_log_prob = rf.log(rf.sigmoid(-blank_logits)) @@ -133,10 +137,10 @@ def _get_masked_state(old, new, mask): ) target_non_blank = rf.where(update_state_mask, target, rf.gather(target_non_blank, indices=backrefs)) - target_non_blank.sparse_dim = model.target_embed.in_dim + target_non_blank.sparse_dim = model.label_decoder.target_embed.in_dim input_embed = rf.where( update_state_mask, - model.target_embed(target_non_blank), + model.label_decoder.target_embed(target_non_blank), rf.gather(input_embed, indices=backrefs, axis=old_beam_dim) ) @@ -172,10 +176,6 @@ def _get_masked_state(old, new, mask): # RecogDef API model_recog: RecogDef[SegmentalAttentionModel] model_recog.output_with_beam = True -# output_blank_label=blank is actually wrong for AED, but now we don't change it anymore -# because it would change all recog hashes. -# Also, it does not matter too much -- it will just cause an extra SearchRemoveLabelJob, -# which will not have any effect here. model_recog.output_blank_label = "" model_recog.batch_size_dependent = False @@ -220,7 +220,7 @@ def model_recog_pure_torch( batch_dims = data.remaining_dims((data_spatial_dim, data.feature_dim)) assert len(batch_dims) == 1, batch_dims # not implemented otherwise, simple to add... batch_dim = batch_dims[0] - enc, enc_spatial_dim = model.encode(data, in_spatial_dim=data_spatial_dim) + enc, enc_spatial_dim = model.encoder.encode(data, in_spatial_dim=data_spatial_dim) if max_seq_len is None: max_seq_len = enc_spatial_dim.get_size_tensor() else: @@ -241,9 +241,9 @@ def model_recog_pure_torch( get_time_sync_scorer_pure_torch(model=model, batch_dim=batch_dim, enc=enc, enc_spatial_dim=enc_spatial_dim), 1.0, ) - if model.language_model: + if model.label_decoder.language_model: lm_scale = beam_search_opts.pop("lm_scale") # must be defined with LM - label_scorer.label_scorers["lm"] = (model.language_model_make_label_scorer(), lm_scale) + label_scorer.label_scorers["lm"] = (model.label_decoder.language_model_make_label_scorer(), lm_scale) print("** max seq len:", max_seq_len.raw_tensor) @@ -253,7 +253,7 @@ def model_recog_pure_torch( seq_log_prob, # [Batch,FinalBeam] ) = time_sync_beam_search( label_scorer, - label_sync_keys=["label_sync_decoder", "lm"] if model.language_model else ["label_sync_decoder"], + label_sync_keys=["label_sync_decoder", "lm"] if model.label_decoder.language_model else ["label_sync_decoder"], time_sync_keys=["time_sync_decoder"], batch_size=int(batch_dim.get_dim_value()), blank_idx=model.blank_idx, @@ -313,7 +313,7 @@ def get_initial_state(self, *, batch_size: int, device: torch.device) -> Any: """Initial state.""" beam_dim = Dim(1, name="initial-beam") batch_dims_ = [batch_dim, beam_dim] - decoder_state = model.label_decoder_default_initial_state(batch_dims=batch_dims_,) + decoder_state = model.label_decoder.default_initial_state(batch_dims=batch_dims_, ) return tree.map_structure(functools.partial(self._map_tensor_to_raw, beam_dim=beam_dim), decoder_state) def score_and_update_state( @@ -354,8 +354,8 @@ def _map_raw_to_tensor(v): segment_lens = segment_ends - segment_starts + 1 zeros_embed = rf.zeros( - [batch_dim, beam_dim, model.target_embed.out_dim], - feature_dim=model.target_embed.out_dim, + [batch_dim, beam_dim, model.label_decoder.target_embed.out_dim], + feature_dim=model.label_decoder.target_embed.out_dim, dtype="float32" ) initial_output_mask = rf.convert_to_tensor(prev_label == -1, dims=[batch_dim, beam_dim]) @@ -368,10 +368,10 @@ def _map_raw_to_tensor(v): input_embed = rf.where( initial_output_mask, zeros_embed, - model.target_embed(prev_label) + model.label_decoder.target_embed(prev_label) ) - decode_out, decoder_state = model.label_sync_loop_step( + decode_out, decoder_state = model.label_decoder.loop_step( **enc, enc_spatial_dim=enc_spatial_dim, input_embed=input_embed, @@ -379,7 +379,7 @@ def _map_raw_to_tensor(v): segment_starts=segment_starts, state=tree.map_structure(_map_raw_to_tensor, prev_state), ) - logits = model.decode_label_logits(input_embed=input_embed, **decode_out) + logits = model.label_decoder.decode_logits(input_embed=input_embed, **decode_out) label_log_prob = rf.log_softmax(logits, axis=model.target_dim) blank_log_prob = rf.zeros( @@ -437,7 +437,7 @@ def get_initial_state(self, *, batch_size: int, device: torch.device) -> Any: """Initial state.""" beam_dim = Dim(1, name="initial-beam") batch_dims_ = [batch_dim, beam_dim] - decoder_state = model.blank_decoder_default_initial_state(batch_dims=batch_dims_,) + decoder_state = model.blank_decoder.default_initial_state(batch_dims=batch_dims_, ) return tree.map_structure(functools.partial(self._map_tensor_to_raw, beam_dim=beam_dim), decoder_state) def score_and_update_state( @@ -466,8 +466,8 @@ def _map_raw_to_tensor(v): raise TypeError(f"_map_raw_to_tensor: unexpected {v} ({type(v).__name__})") zeros_embed = rf.zeros( - [batch_dim, beam_dim, model.target_embed_length_model.out_dim], - feature_dim=model.target_embed_length_model.out_dim, + [batch_dim, beam_dim, model.blank_decoder.target_embed.out_dim], + feature_dim=model.blank_decoder.target_embed.out_dim, dtype="float32" ) initial_output_mask = rf.convert_to_tensor(prev_align_label == -1, dims=[batch_dim, beam_dim]) @@ -480,16 +480,16 @@ def _map_raw_to_tensor(v): input_embed = rf.where( initial_output_mask, zeros_embed, - model.target_embed_length_model(prev_align_label) + model.blank_decoder.target_embed(prev_align_label) ) - decode_out, decoder_state = model.time_sync_loop_step( + decode_out, decoder_state = model.blank_decoder.loop_step( enc=enc["enc"], enc_spatial_dim=enc_spatial_dim, input_embed=input_embed, state=tree.map_structure(_map_raw_to_tensor, prev_state), ) - blank_logits = model.decode_blank_logits(**decode_out) + blank_logits = model.blank_decoder.decode_logits(**decode_out) emit_log_prob = rf.log(rf.sigmoid(blank_logits)) emit_log_prob = rf.squeeze(emit_log_prob, axis=emit_log_prob.feature_dim) blank_log_prob = rf.log(rf.sigmoid(-blank_logits)) diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/train.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/train.py index 592f06a0d..599aa6ef8 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/train.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/train.py @@ -2,8 +2,19 @@ from returnn.tensor import TensorDict -from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.utils import get_non_blank_mask, get_masked +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.utils import ( + get_non_blank_mask, + get_masked, + get_emit_ground_truth, + get_segment_starts_and_lens +) from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model import SegmentalAttentionModel +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model_new.label_model.train import ( + viterbi_training as label_model_viterbi_training +) +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model_new.blank_model.train import ( + viterbi_training as blank_model_viterbi_training +) from returnn.tensor import Dim import returnn.frontend as rf @@ -31,7 +42,7 @@ def _returnn_v2_train_step(*, model, extern_data: TensorDict, **_kwargs_unused): ) -def from_scratch_training( +def viterbi_training( *, model: SegmentalAttentionModel, data: rf.Tensor, @@ -41,13 +52,10 @@ def from_scratch_training( ): """Function is run within RETURNN.""" from returnn.config import get_global_config - import torch config = get_global_config() # noqa aux_loss_layers = config.typed_value("aux_loss_layers") aux_loss_scales = config.typed_value("aux_loss_scales", ([1.0] * len(aux_loss_layers)) if aux_loss_layers else None) - aed_loss_scale = config.float("aed_loss_scale", 1.0) - use_normalized_loss = config.bool("use_normalized_loss", True) if data.feature_dim and data.feature_dim.dimension == 1: data = rf.squeeze(data, axis=data.feature_dim) @@ -55,43 +63,23 @@ def from_scratch_training( batch_dims = data.remaining_dims(data_spatial_dim) - def _get_segment_starts_and_lens(out_spatial_dim: Dim): - non_blank_mask = get_non_blank_mask(align_targets, model.blank_idx) - targets_range = rf.range_over_dim(align_targets_spatial_dim, dtype="int32") - targets_range = rf.expand_dim(targets_range, batch_dims[0]) - non_blank_positions, _ = get_masked( - targets_range, non_blank_mask, align_targets_spatial_dim, batch_dims, out_spatial_dim - ) - starts = rf.maximum( - rf.convert_to_tensor(0, dtype="int32"), non_blank_positions - model.center_window_size // 2) - ends = rf.minimum( - rf.copy_to_device(align_targets_spatial_dim.get_size_tensor() - 1, non_blank_positions.device), - non_blank_positions + model.center_window_size // 2 - ) - lens = ends - starts + 1 - - return starts, lens - - def _get_emit_ground_truth(): - non_blank_mask = get_non_blank_mask(align_targets, model.blank_idx) - result = rf.where(non_blank_mask, rf.convert_to_tensor(1), rf.convert_to_tensor(0)) - sparse_dim = Dim(name="emit_ground_truth", dimension=2) - # result = rf.expand_dim(result, sparse_dim) - result.sparse_dim = sparse_dim - torch.set_printoptions(threshold=10000) - - return result, sparse_dim - non_blank_targets, non_blank_targets_spatial_dim = get_masked( align_targets, get_non_blank_mask(align_targets, model.blank_idx), align_targets_spatial_dim, batch_dims ) non_blank_targets.sparse_dim = model.target_dim - segment_starts, segment_lens = _get_segment_starts_and_lens(non_blank_targets_spatial_dim) + segment_starts, segment_lens = get_segment_starts_and_lens( + align_targets, + align_targets_spatial_dim, + model, + batch_dims, + non_blank_targets_spatial_dim + ) # ------------------- encoder aux loss ------------------- collected_outputs = {} - enc_args, enc_spatial_dim = model.encode(data, in_spatial_dim=data_spatial_dim, collected_outputs=collected_outputs) + enc_args, enc_spatial_dim = model.encoder.encode( + data, in_spatial_dim=data_spatial_dim, collected_outputs=collected_outputs) if aux_loss_layers: for i, layer_idx in enumerate(aux_loss_layers): @@ -110,118 +98,36 @@ def _get_emit_ground_truth(): f"ctc_{layer_idx}", scale=aux_loss_scales[i], custom_inv_norm_factor=align_targets_spatial_dim.get_size_tensor(), - use_normalized_loss=use_normalized_loss, + use_normalized_loss=True, ) - non_blank_input_embeddings = model.target_embed(non_blank_targets) - non_blank_input_embeddings = rf.shift_right( - non_blank_input_embeddings, axis=non_blank_targets_spatial_dim, pad_value=0.0) - - align_input_embeddings = model.target_embed_length_model(align_targets) - align_input_embeddings = rf.shift_right( - align_input_embeddings, axis=align_targets_spatial_dim, pad_value=0.0) - # ------------------- label loop ------------------- - def _label_loop_body(xs, state: rf.State): - new_state = rf.State() - loop_out_, new_state.decoder = model.label_sync_loop_step( - **enc_args, - enc_spatial_dim=enc_spatial_dim, - input_embed=xs["input_embed"], - segment_starts=xs["segment_starts"], - segment_lens=xs["segment_lens"], - state=state.decoder, - ) - return loop_out_, new_state - - label_loop_out, _, _ = rf.scan( - spatial_dim=non_blank_targets_spatial_dim, - xs={ - "input_embed": non_blank_input_embeddings, - "segment_starts": segment_starts, - "segment_lens": segment_lens, - }, - ys=model.label_loop_step_output_templates(batch_dims=batch_dims), - initial=rf.State( - decoder=model.label_decoder_default_initial_state( - batch_dims=batch_dims, - # TODO: do we need these sparse dims? they are automatically added by rf.range_over_dim - segment_starts_sparse_dim=segment_starts.sparse_dim, - segment_lens_sparse_dim=segment_lens.sparse_dim, - ), - ), - body=_label_loop_body, - ) - - logits = model.decode_label_logits(input_embed=non_blank_input_embeddings, **label_loop_out) - logits_packed, pack_dim = rf.pack_padded(logits, dims=batch_dims + [non_blank_targets_spatial_dim], enforce_sorted=False) - non_blank_targets_packed, _ = rf.pack_padded( - non_blank_targets, dims=batch_dims + [non_blank_targets_spatial_dim], enforce_sorted=False, out_dim=pack_dim - ) - - log_prob = rf.log_softmax(logits_packed, axis=model.target_dim) - log_prob = rf.label_smoothed_log_prob_gradient(log_prob, 0.1, axis=model.target_dim) - loss = rf.cross_entropy( - target=non_blank_targets_packed, estimated=log_prob, estimated_type="log-probs", axis=model.target_dim + label_model_viterbi_training( + model=model.label_decoder, + enc_args=enc_args, + enc_spatial_dim=enc_spatial_dim, + non_blank_targets=non_blank_targets, + non_blank_targets_spatial_dim=non_blank_targets_spatial_dim, + segment_starts=segment_starts, + segment_lens=segment_lens, + batch_dims=batch_dims, ) - loss.mark_as_loss("non_blank_ce", scale=aed_loss_scale, use_normalized_loss=use_normalized_loss) - - best = rf.reduce_argmax(logits_packed, axis=model.target_dim) - frame_error = best != non_blank_targets_packed - frame_error.mark_as_loss(name="non_blank_fer", as_error=True) # ------------------- blank loop ------------------- - def _blank_loop_body(xs, state: rf.State): - new_state = rf.State() - loop_out_, new_state.decoder = model.time_sync_loop_step( - enc=enc_args["enc"], - enc_spatial_dim=enc_spatial_dim, - input_embed=xs["input_embed"], - state=state.decoder, - ) - return loop_out_, new_state - - label_loop_out, _, _ = rf.scan( - spatial_dim=align_targets_spatial_dim, - xs={ - "input_embed": align_input_embeddings, - }, - ys=model.blank_loop_step_output_templates(batch_dims=batch_dims), - initial=rf.State( - decoder=model.blank_decoder_default_initial_state( - batch_dims=batch_dims, - ), - ), - body=_blank_loop_body, - ) - - blank_logits = model.decode_blank_logits(**label_loop_out) - blank_logits_packed, pack_dim = rf.pack_padded(blank_logits, dims=batch_dims + [align_targets_spatial_dim], enforce_sorted=False) - emit_ground_truth, emit_blank_target_dim = _get_emit_ground_truth() - emit_ground_truth_packed, _ = rf.pack_padded( - emit_ground_truth, dims=batch_dims + [align_targets_spatial_dim], enforce_sorted=False, out_dim=pack_dim + emit_ground_truth, emit_blank_target_dim = get_emit_ground_truth(align_targets, model.blank_idx) + blank_model_viterbi_training( + model=model.blank_decoder, + enc_args=enc_args, + enc_spatial_dim=enc_spatial_dim, + align_targets=align_targets, + align_targets_spatial_dim=align_targets_spatial_dim, + emit_ground_truth=emit_ground_truth, + emit_blank_target_dim=emit_blank_target_dim, + batch_dims=batch_dims, ) - # rf.log_sigmoid not implemented for torch backend - emit_log_prob = rf.log(rf.sigmoid(blank_logits_packed)) - blank_log_prob = rf.log(rf.sigmoid(-blank_logits_packed)) - blank_logit_dim = blank_logits_packed.remaining_dims((pack_dim,))[0] - emit_blank_log_prob, _ = rf.concat( - (blank_log_prob, blank_logit_dim), (emit_log_prob, blank_logit_dim), out_dim=emit_blank_target_dim) - blank_loss = rf.cross_entropy( - target=emit_ground_truth_packed, - estimated=emit_blank_log_prob, - estimated_type="log-probs", - axis=emit_blank_target_dim - ) - blank_loss.mark_as_loss("emit_blank_ce", scale=aed_loss_scale, use_normalized_loss=use_normalized_loss) - - best = rf.reduce_argmax(emit_blank_log_prob, axis=emit_blank_target_dim) - frame_error = best != emit_ground_truth_packed - frame_error.mark_as_loss(name="emit_blank_fer", as_error=True) - -from_scratch_training: TrainDef[SegmentalAttentionModel] -from_scratch_training.learning_rate_control_error_measure = "dev_score_full_sum" +viterbi_training: TrainDef[SegmentalAttentionModel] +viterbi_training.learning_rate_control_error_measure = "dev_score_full_sum" diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/utils.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/utils.py index e4304d0f8..707be5236 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/utils.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/utils.py @@ -1,8 +1,10 @@ from typing import Optional, Sequence, Tuple +import torch from returnn.tensor import Tensor, Dim import returnn.frontend as rf +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model import SegmentalAttentionModel def get_non_blank_mask(x: Tensor, blank_idx: int): @@ -13,9 +15,6 @@ def get_non_blank_mask(x: Tensor, blank_idx: int): def get_masked( input: Tensor, mask: Tensor, mask_dim: Dim, batch_dims: Sequence[Dim], result_spatial_dim: Optional[Dim] = None ) -> Tuple[Tensor, Dim]: - - import torch - if not result_spatial_dim: new_lens = rf.reduce_sum(rf.cast(mask, "int32"), axis=mask_dim) result_spatial_dim = Dim(name=f"{mask_dim.name}_masked", dimension=rf.copy_to_device(new_lens, "cpu")) @@ -42,3 +41,41 @@ def get_masked( result = result.copy_transpose(batch_dims + [result_spatial_dim]) return result, result_spatial_dim + + +def get_segment_starts_and_lens( + align_targets: Tensor, + align_targets_spatial_dim: Dim, + model: SegmentalAttentionModel, + batch_dims: Sequence[Dim], + out_spatial_dim: Dim +): + non_blank_mask = get_non_blank_mask(align_targets, model.blank_idx) + targets_range = rf.range_over_dim(align_targets_spatial_dim, dtype="int32") + targets_range = rf.expand_dim(targets_range, batch_dims[0]) + non_blank_positions, _ = get_masked( + targets_range, non_blank_mask, align_targets_spatial_dim, batch_dims, out_spatial_dim + ) + starts = rf.maximum( + rf.convert_to_tensor(0, dtype="int32"), non_blank_positions - model.center_window_size // 2) + ends = rf.minimum( + rf.copy_to_device(align_targets_spatial_dim.get_size_tensor() - 1, non_blank_positions.device), + non_blank_positions + model.center_window_size // 2 + ) + lens = ends - starts + 1 + + return starts, lens + + +def get_emit_ground_truth( + align_targets: Tensor, + blank_idx: int +): + non_blank_mask = get_non_blank_mask(align_targets, blank_idx) + result = rf.where(non_blank_mask, rf.convert_to_tensor(1), rf.convert_to_tensor(0)) + sparse_dim = Dim(name="emit_ground_truth", dimension=2) + # result = rf.expand_dim(result, sparse_dim) + result.sparse_dim = sparse_dim + torch.set_printoptions(threshold=10000) + + return result, sparse_dim diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v1/__init__.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v1/__init__.py index 71065787f..f9266f4f2 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v1/__init__.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v1/__init__.py @@ -4,38 +4,17 @@ from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.pipelines.pipeline_ls_conf.center_window_att import ( train, recog ) - -from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model import MakeModel -from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model_import import map_param_func_v2 - -from i6_experiments.users.zeyer.returnn.convert_ckpt_rf import ConvertTfCheckpointToRfPtJob - -from i6_core.returnn.training import PtCheckpoint, Checkpoint - -from sisyphus import Path +from i6_experiments.users.schmitt.custom_load_params import load_missing_params def run_exps(): for model_alias, config_builder in baseline.center_window_att_baseline_rf( win_size_list=(5,), ): - # for train_alias, checkpoint in train.train_center_window_att_from_scratch( - # alias=model_alias, - # config_builder=config_builder, - # n_epochs_list=(1,), - # time_rqmt=4 - # ): - # recog.center_window_returnn_frame_wise_beam_search( - # alias=train_alias, - # config_builder=config_builder, - # checkpoint=checkpoint, - # checkpoint_aliases=("last",) - # ) - for train_alias, checkpoint in train.train_center_window_att_import_global_tf( alias=model_alias, config_builder=config_builder, - n_epochs_list=(1,), + n_epochs_list=(10,), time_rqmt=4, train_opts=dict( aux_loss_layers=None, @@ -57,33 +36,25 @@ def run_exps(): pure_torch=True, ) + for model_alias, config_builder in baseline.center_window_att_baseline_rf( + win_size_list=(5,), decoder_version=2 + ): for train_alias, checkpoint in train.train_center_window_att_import_global_tf( alias=model_alias, config_builder=config_builder, - n_epochs_list=(20,), - time_rqmt=12, + n_epochs_list=(10,), + time_rqmt=4, train_opts=dict( aux_loss_layers=None, accum_grad_multiple_step=2, optimizer={"class": "adam", "epsilon": 1e-8} - ) + ), + custom_missing_load_func=load_missing_params ): recog.center_window_returnn_frame_wise_beam_search( alias=train_alias, config_builder=config_builder, checkpoint=checkpoint, - checkpoint_aliases=("last",) + checkpoint_aliases=("last",), + pure_torch=True, ) - - # for train_alias, checkpoint in train.train_center_window_att_import_center_window_tf( - # alias=model_alias, - # config_builder=config_builder, - # n_epochs_list=(9,), - # time_rqmt=4 - # ): - # recog.center_window_returnn_frame_wise_beam_search( - # alias=train_alias, - # config_builder=config_builder, - # checkpoint=checkpoint, - # checkpoint_aliases=("last",) - # ) diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v1/baseline.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v1/baseline.py index 60dfefc64..b80ee17cc 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v1/baseline.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v1/baseline.py @@ -44,6 +44,7 @@ def get_center_window_att_config_builder_rf( config_builder = SegmentalAttConfigBuilderRF( variant_params=variant_params, center_window_size=win_size, + decoder_version=decoder_version, model_def=from_scratch_model_def, get_model_func=_returnn_v2_get_model, ) @@ -53,13 +54,13 @@ def get_center_window_att_config_builder_rf( def center_window_att_baseline_rf( win_size_list: Tuple[int, ...] = (5, 129), + decoder_version: Optional[int] = None, ): for win_size in win_size_list: - alias = f"{base_alias}/baseline_rf/win-size-%d" % ( - win_size - ) + alias = f"{base_alias}/baseline_rf/win-size-{win_size}/decoder-version-{decoder_version if decoder_version else 1}" yield alias, get_center_window_att_config_builder_rf( win_size=win_size, use_weight_feedback=True, - length_model_opts={"use_label_model_state": True, "use_alignment_ctx": False}, + length_model_opts={"use_label_model_state": False, "use_alignment_ctx": False}, + decoder_version=decoder_version, ) diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/train.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/train.py index d74888066..d82fdf89d 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/train.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/train.py @@ -1,8 +1,8 @@ -from typing import Tuple, Optional, List, Dict +from typing import Tuple, Optional, List, Dict, Union, Callable from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.config_builder_rf.base import SegmentalAttConfigBuilderRF from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23.train_new import SegmentalTrainExperiment -from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.train import _returnn_v2_train_step, from_scratch_training +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.train import _returnn_v2_train_step, viterbi_training from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.pipelines.pipeline_ls_conf.checkpoints import ( external_checkpoints, default_import_model_name, @@ -33,7 +33,7 @@ def train_center_window_att_from_scratch( }, "import_model_train_epoch1": None, "lr_opts": {"type": "dyn_lr_lin_warmup_invsqrt_decay"}, - "train_def": from_scratch_training, + "train_def": viterbi_training, "train_step_func": _returnn_v2_train_step, } ) @@ -55,6 +55,7 @@ def train_center_window_att_import_global_tf( n_epochs_list: Tuple[int, ...], time_rqmt: int = 168, train_opts: Optional[Dict] = None, + custom_missing_load_func: Optional[Callable] = None ): _train_opts = { "preload_from_files": { @@ -64,10 +65,12 @@ def train_center_window_att_import_global_tf( "ignore_missing": True, # because of length model params } }, - "train_def": from_scratch_training, + "train_def": viterbi_training, "train_step_func": _returnn_v2_train_step, "batching": "random", } + if custom_missing_load_func: + _train_opts["preload_from_files"]["pretrained_global_att_params"]["custom_missing_load_func"] = custom_missing_load_func if train_opts: _train_opts.update(train_opts) @@ -119,7 +122,7 @@ def train_center_window_att_import_center_window_tf( # } # }, "import_model_train_epoch1": get_center_window_baseline_v1_tf_checkpoint(), - "train_def": from_scratch_training, + "train_def": viterbi_training, "train_step_func": _returnn_v2_train_step, "batching": "random", "aux_loss_layers": None, diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/checkpoints.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/checkpoints.py index 732c9dfa6..2b3dc216b 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/checkpoints.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/checkpoints.py @@ -1,10 +1,10 @@ from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23.pipelines.pipeline_ls_conf.checkpoints import external_checkpoints as external_checkpoints_tf from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23.pipelines.pipeline_ls_conf.checkpoints import default_import_model_name from i6_experiments.users.schmitt.returnn_frontend.convert.checkpoint import ConvertTfCheckpointToRfPtJob -from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model_import import map_param_func_v2 as map_param_func_v2_global +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.global_.model_import import map_param_func_v2 as map_param_func_v2_global from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.global_.model import MakeModel as MakeModelGlobal from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model import MakeModel as MakeModelSegmental -from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model_import import map_param_func_v2 as map_param_func_v2_segmental +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model_old.model_import import map_param_func_v2 as map_param_func_v2_segmental from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23.pipelines.pipeline_ls_conf.center_window_att.baseline_v1 import ( baseline, ) diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/global_att/baseline_v1/__init__.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/global_att/baseline_v1/__init__.py index 1499832d9..b291006ca 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/global_att/baseline_v1/__init__.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/global_att/baseline_v1/__init__.py @@ -29,20 +29,7 @@ def run_exps(): for train_alias, checkpoint in train.train_import_global_tf( alias=model_alias, config_builder=config_builder, - n_epochs_list=(1,), - time_rqmt=4, - ): - recog.global_att_returnn_label_sync_beam_search( - alias=train_alias, - config_builder=config_builder, - checkpoint=checkpoint, - checkpoint_aliases=("last",), - ) - - for train_alias, checkpoint in train.train_import_global_tf( - alias=model_alias, - config_builder=config_builder, - n_epochs_list=(20,), + n_epochs_list=(10,), time_rqmt=4, ): recog.global_att_returnn_label_sync_beam_search( From f59d4a2dbc84bd87d0d7b9b982c47ee5965cf7d5 Mon Sep 17 00:00:00 2001 From: schmitt Date: Thu, 16 May 2024 10:28:31 +0200 Subject: [PATCH 016/227] add readme for RF --- .../dependencies/returnn/network_builder_rf/README | 10 ++++++++++ 1 file changed, 10 insertions(+) create mode 100644 users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/README diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/README b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/README new file mode 100644 index 000000000..1bb9d3c89 --- /dev/null +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/README @@ -0,0 +1,10 @@ +The contents in this package are all tested for commit: + +commit d94322fa3ea82a53426766afe845e62811433df2 (HEAD -> main) +Author: schmitt +Date: Thu May 16 10:19:52 2024 +0200 + + update + +and are consistent with baseline V1 of my old global and segmental model experiments regarding scores, WERs, losses +and speed. From 2d0a5dc827ebf939fe01980a8cd53a8d2fe80ced Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Thu, 16 May 2024 10:20:25 +0200 Subject: [PATCH 017/227] more --- users/zeyer/experiments/exp2024_04_23_baselines/ctc.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py index a56f931ec..04bed1fa8 100644 --- a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py +++ b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py @@ -30,7 +30,7 @@ def py(): - train_exp( + train_exp( # 8.23 "v6-bhv20-11gb-f32-bs15k-accgrad1-mgpu4-pavg100-wd1e_2-lrlin1e_5_295k-speedpertV2", config_11gb_v6_f32_accgrad1_mgpu4_pavg100_wd1e_4, config_updates={ @@ -41,7 +41,7 @@ def py(): }, ) - train_exp( + train_exp( # 8.12 "v6-bhv20-11gb-f32-bs15k-accgrad1-mgpu4-pavg100-wd1e_2-lrlin1e_5_295k-speedpertV2-spm10k", config_11gb_v6_f32_accgrad1_mgpu4_pavg100_wd1e_4, config_updates={ From 9998dbf742ced5094f097162a6a5bf6c3686293d Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Thu, 16 May 2024 10:20:34 +0200 Subject: [PATCH 018/227] cleanup, generalize, different spm vocab sizes --- users/zeyer/datasets/librispeech.py | 62 +++++++++++++++++------------ 1 file changed, 36 insertions(+), 26 deletions(-) diff --git a/users/zeyer/datasets/librispeech.py b/users/zeyer/datasets/librispeech.py index ac62016f8..c800e6893 100644 --- a/users/zeyer/datasets/librispeech.py +++ b/users/zeyer/datasets/librispeech.py @@ -5,6 +5,8 @@ from __future__ import annotations from typing import Optional, Any, Union, Tuple, Dict from copy import deepcopy +import re +from functools import cache from sisyphus import tk from i6_core.corpus.convert import CorpusToTextDictJob @@ -48,28 +50,37 @@ _train_corpus_text_dict = _corpus_text_dicts["train-other-960"] _train_corpus_text = TextDictToTextLinesJob(_train_corpus_text_dict, gzip=True).out_text_lines -# https://github.com/google/sentencepiece/blob/master/doc/options.md -_spm10k_train_job = TrainSentencePieceJob( - training_text=_train_corpus_text, - # Not sure if power-of-two or just multiple-of-64, but 10240 has more 2s in it (2048*5) than 10048. - vocab_size=10_240, - model_type=SentencePieceType.UNIGRAM, - additional_options={ - "split_digits": True, - "unk_id": 2, # default is 0 - "bos_id": 1, # default is 1 - "eos_id": 0, # default is 2 - }, -) -spm10k = SentencePieceModel( - dim=10_240, - model_file=_spm10k_train_job.out_model, - unknown_label="", - bos_idx=1, - eos_idx=0, -) -# common +@cache +def _get_spm_vocab(*, dim: Union[int, str]) -> SentencePieceModel: + if isinstance(dim, str): + # Not sure if power-of-two or just multiple-of-64, but 10240 has more 2s in it (2048*5) than 10048. + dim = {"10k": 10_240, "5k": 5_120, "4k": 4_096, "1k": 1_024}[dim] + assert isinstance(dim, int) and dim >= 10 + + # https://github.com/google/sentencepiece/blob/master/doc/options.md + _spm_train_job = TrainSentencePieceJob( + training_text=_train_corpus_text, + vocab_size=dim, + model_type=SentencePieceType.UNIGRAM, + additional_options={ + "split_digits": True, + "unk_id": 2, # default is 0 + "bos_id": 1, # default is 1 + "eos_id": 0, # default is 2 + }, + ) + spm = SentencePieceModel( + dim=dim, + model_file=_spm_train_job.out_model, + unknown_label="", + bos_idx=1, + eos_idx=0, + ) + return spm + + +# common, this is the BPE10k that many of us use bpe10k = Bpe( dim=10_025, eos_idx=0, @@ -537,7 +548,10 @@ def get_librispeech_task_raw_v2( so it is easier to copy this setup to a new environment. """ if isinstance(vocab, str): - vocab = {"bpe10k": bpe10k, "spm10k": spm10k}[vocab] + if re.match("^spm[0-9]+.*$", vocab): + vocab = _get_spm_vocab(dim=vocab[3:]) + else: + vocab = {"bpe10k": bpe10k}[vocab] cache_key = make_hashable((dataset_cls, vocab, train_vocab_opts, audio_opts, audio_dim, dataset_train_opts)) if cache_key in _librispeech_task_raw_v2_cache: @@ -581,10 +595,6 @@ def get_librispeech_task_raw_v2( return task -def get_librispeech_task_bpe10k_raw_v2(**dataset_train_opts) -> Task: - return get_librispeech_task_raw_v2(vocab=bpe10k, **dataset_train_opts) - - def _bpe_to_words_v1(bpe: RecogOutput) -> RecogOutput: """BPE to words""" from i6_core.returnn.search import SearchBPEtoWordsJob From d5e00decef3176d4fae364e54d9d0484349cb4f8 Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Thu, 16 May 2024 10:30:54 +0200 Subject: [PATCH 019/227] more --- users/zeyer/datasets/librispeech.py | 24 ++++++++--- .../exp2024_04_23_baselines/ctc.py | 41 +++++++++---------- 2 files changed, 37 insertions(+), 28 deletions(-) diff --git a/users/zeyer/datasets/librispeech.py b/users/zeyer/datasets/librispeech.py index c800e6893..5fdf35cb7 100644 --- a/users/zeyer/datasets/librispeech.py +++ b/users/zeyer/datasets/librispeech.py @@ -52,7 +52,9 @@ @cache -def _get_spm_vocab(*, dim: Union[int, str]) -> SentencePieceModel: +def _get_spm_vocab( + *, dim: Union[int, str], model_type: SentencePieceType = SentencePieceType.UNIGRAM +) -> SentencePieceModel: if isinstance(dim, str): # Not sure if power-of-two or just multiple-of-64, but 10240 has more 2s in it (2048*5) than 10048. dim = {"10k": 10_240, "5k": 5_120, "4k": 4_096, "1k": 1_024}[dim] @@ -62,7 +64,7 @@ def _get_spm_vocab(*, dim: Union[int, str]) -> SentencePieceModel: _spm_train_job = TrainSentencePieceJob( training_text=_train_corpus_text, vocab_size=dim, - model_type=SentencePieceType.UNIGRAM, + model_type=model_type, additional_options={ "split_digits": True, "unk_id": 2, # default is 0 @@ -91,6 +93,19 @@ def _get_spm_vocab(*, dim: Union[int, str]) -> SentencePieceModel: unknown_label=None, ) + +@cache +def _get_vocab_by_str(vocab: str) -> Union[SentencePieceModel, Bpe]: + if re.match("^spm[0-9]+.*$", vocab): + return _get_spm_vocab(dim=vocab[3:], model_type=SentencePieceType.UNIGRAM) + elif re.match("^spm_bpe[0-9]+.*$", vocab): + return _get_spm_vocab(dim=vocab[3:], model_type=SentencePieceType.BPE) + elif vocab == "bpe10k": # predefined + return bpe10k + else: + raise ValueError(f"invalid vocab {vocab!r}") + + # ESPnet uses this SPM. However, it does not use the vocab directly from it. # It has some custom code to generate its own vocab based from this: # https://github.com/espnet/espnet/blob/d0047402e830a3c53e8b590064af4bf70415fb3b/egs2/TEMPLATE/asr1/asr.sh#L878 @@ -548,10 +563,7 @@ def get_librispeech_task_raw_v2( so it is easier to copy this setup to a new environment. """ if isinstance(vocab, str): - if re.match("^spm[0-9]+.*$", vocab): - vocab = _get_spm_vocab(dim=vocab[3:]) - else: - vocab = {"bpe10k": bpe10k}[vocab] + vocab = _get_vocab_by_str(vocab) cache_key = make_hashable((dataset_cls, vocab, train_vocab_opts, audio_opts, audio_dim, dataset_train_opts)) if cache_key in _librispeech_task_raw_v2_cache: diff --git a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py index 04bed1fa8..828dc82ea 100644 --- a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py +++ b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py @@ -30,28 +30,25 @@ def py(): - train_exp( # 8.23 - "v6-bhv20-11gb-f32-bs15k-accgrad1-mgpu4-pavg100-wd1e_2-lrlin1e_5_295k-speedpertV2", - config_11gb_v6_f32_accgrad1_mgpu4_pavg100_wd1e_4, - config_updates={ - **_get_cfg_lrlin_oclr_by_bs_nep(15_000, 500), - "optimizer.weight_decay": 1e-2, - "__train_audio_preprocess": speed_pert_librosa_config, - "speed_pert_discrete_values": [0.7, 0.8, 0.9, 1.0, 1.1], - }, - ) - - train_exp( # 8.12 - "v6-bhv20-11gb-f32-bs15k-accgrad1-mgpu4-pavg100-wd1e_2-lrlin1e_5_295k-speedpertV2-spm10k", - config_11gb_v6_f32_accgrad1_mgpu4_pavg100_wd1e_4, - config_updates={ - **_get_cfg_lrlin_oclr_by_bs_nep(15_000, 500), - "optimizer.weight_decay": 1e-2, - "__train_audio_preprocess": speed_pert_librosa_config, - "speed_pert_discrete_values": [0.7, 0.8, 0.9, 1.0, 1.1], - }, - vocab="spm10k", - ) + for vocab in [ + "bpm10k", # 8.23 + "spm10k", # 8.12 + "spm_bpe10k", + "spm4k", + "spm1k", + "bpe1k", + ]: + train_exp( # 8.23 + f"v6-bhv20-11gb-f32-bs15k-accgrad1-mgpu4-pavg100-wd1e_2-lrlin1e_5_295k-speedpertV2-{vocab}", + config_11gb_v6_f32_accgrad1_mgpu4_pavg100_wd1e_4, + config_updates={ + **_get_cfg_lrlin_oclr_by_bs_nep(15_000, 500), + "optimizer.weight_decay": 1e-2, + "__train_audio_preprocess": speed_pert_librosa_config, + "speed_pert_discrete_values": [0.7, 0.8, 0.9, 1.0, 1.1], + }, + vocab=vocab, + ) train_exp( "v6-bhv20-11gb-f32-bs15k-accgrad1-mgpu4-pavg100-wd1e_2-lrlin1e_5_295k-speedpertV2-spm10k-spmSample03", From 9a8d172f03b7662800ca359af60784fd8e83d5a7 Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Thu, 16 May 2024 10:31:04 +0200 Subject: [PATCH 020/227] more --- users/zeyer/experiments/exp2024_04_23_baselines/ctc.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py index 828dc82ea..cfb5507f8 100644 --- a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py +++ b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py @@ -36,7 +36,7 @@ def py(): "spm_bpe10k", "spm4k", "spm1k", - "bpe1k", + "spm_bpe1k", ]: train_exp( # 8.23 f"v6-bhv20-11gb-f32-bs15k-accgrad1-mgpu4-pavg100-wd1e_2-lrlin1e_5_295k-speedpertV2-{vocab}", From c3d0391906dc26edda847395f9a7a39ec64f9f75 Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Thu, 16 May 2024 10:31:43 +0200 Subject: [PATCH 021/227] small fix --- users/zeyer/experiments/exp2024_04_23_baselines/ctc.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py index cfb5507f8..65265722d 100644 --- a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py +++ b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py @@ -31,7 +31,7 @@ def py(): for vocab in [ - "bpm10k", # 8.23 + "bpe10k", # 8.23 "spm10k", # 8.12 "spm_bpe10k", "spm4k", From 3220040eed0bf77129b8839200df32f9b73a3868 Mon Sep 17 00:00:00 2001 From: "luca.gaudino" Date: Thu, 16 May 2024 11:12:09 +0200 Subject: [PATCH 022/227] update ls att+ctc+lm --- .../librispeech_960/attention_asr_config.py | 14 +- .../configs/ctc_att_search_w_recombine.py | 208 +++++++++++++++++- 2 files changed, 213 insertions(+), 9 deletions(-) diff --git a/users/gaudino/experiments/conformer_att_2023/librispeech_960/attention_asr_config.py b/users/gaudino/experiments/conformer_att_2023/librispeech_960/attention_asr_config.py index c801f5546..3fbe78a96 100644 --- a/users/gaudino/experiments/conformer_att_2023/librispeech_960/attention_asr_config.py +++ b/users/gaudino/experiments/conformer_att_2023/librispeech_960/attention_asr_config.py @@ -505,8 +505,9 @@ class CTCDecoderArgs(DecoderArgs): add_att_dec: bool = False att_scale: float = 0.65 ts_reward: float = 0.0 - blank_prob_scale: float = 0.0 - repeat_prob_scale: float = 0.0 + blank_prob_scale: float = 1.0 + repeat_prob_scale: float = 1.0 + label_prob_scale: float = 1.0 ctc_prior_correction: bool = False prior_scale: float = 1.0 logits: bool = False @@ -520,10 +521,15 @@ class CTCDecoderArgs(DecoderArgs): one_minus_term_mul_scale: float = 1.0 one_minus_term_sub_scale: float = 0.0 length_normalization: bool = False - hash_override_version: Optional[int] = None + length_normalization_scale: float = 1.0 + target_dim: int = 10025 + target_embed_dim: int = 640 + # hash_override_version: Optional[int] = None blank_collapse: bool = False renorm_p_comb: bool = False - recombine:bool = False + renorm_after_remove_blank: bool = True + recombine: bool = False + max_approx: bool = False def create_config( diff --git a/users/gaudino/experiments/conformer_att_2023/librispeech_960/configs/ctc_att_search_w_recombine.py b/users/gaudino/experiments/conformer_att_2023/librispeech_960/configs/ctc_att_search_w_recombine.py index 3f405dcf0..3ed600a57 100644 --- a/users/gaudino/experiments/conformer_att_2023/librispeech_960/configs/ctc_att_search_w_recombine.py +++ b/users/gaudino/experiments/conformer_att_2023/librispeech_960/configs/ctc_att_search_w_recombine.py @@ -503,7 +503,7 @@ def run_exp( # --------------------------- Without LM --------------------------- # # att only - for beam_size in [12]: + for beam_size in []: search_args = copy.deepcopy(oclr_args) search_args["beam_size"] = beam_size run_decoding( @@ -525,7 +525,7 @@ def run_exp( ) # ctc ts - for beam_size, prior_scale in product([12, 32], [0, 0.1]): + for beam_size, prior_scale in product([12, 32], []): search_args = copy.deepcopy(oclr_args) search_args["beam_size"] = beam_size search_args["ctc_log_prior_file"] = new_prior_file @@ -550,12 +550,13 @@ def run_exp( use_sclite=True, ) - # optsr att + ctc w prior - for scales, prior_scale, beam_size in product([(0.65, 0.35), (0.7, 0.3)], [0, 0.1], [32]): + # optsr max att + ctc w prior + for scales, prior_scale, beam_size in product([(0.65, 0.35)], [0.0, 0.05, 0.1], [32]): search_args = copy.deepcopy(oclr_args) search_args["beam_size"] = beam_size att_scale, ctc_scale = scales search_args["ctc_log_prior_file"] = new_prior_file + label_scale = 1.0 search_args["decoder_args"] = CTCDecoderArgs( add_att_dec=True, @@ -564,11 +565,20 @@ def run_exp( ctc_prior_correction=prior_scale > 0, prior_scale=prior_scale, recombine=True, + max_approx=True, + # normalization settings + one_minus_term_mul_scale=0.0, + renorm_after_remove_blank=False, + blank_prob_scale=1.0, + repeat_prob_scale=1.0, + label_prob_scale=label_scale, ) + time_rqmt = 2 run_decoding( exp_name=f"bsf{bsf}/" - + f"optsr_att{att_scale}_ctc{ctc_scale}" + + f"optsr_max_att{att_scale}_ctc{ctc_scale}" + (f"_prior_{prior_scale}" if prior_scale > 0 else "") + + f"_vanilla" + f"_beam{beam_size}", train_data=train_data, checkpoint=train_job_avg_ckpt[ @@ -584,7 +594,195 @@ def run_exp( "", }, # blanks are removed in the network use_sclite=True, + time_rqmt=time_rqmt, ) # --------------------------- With Lstm LM --------------------------- # + + # optsr max ctc w prior + lstm lm + for lm_scale, beam_size in product([0.3, 0.4, 0.5, 0.6], [12]): + search_args = copy.deepcopy(oclr_args) + search_args["beam_size"] = beam_size + search_args["ctc_log_prior_file"] = new_prior_file + ctc_scale = 1.0 + label_scale = 1.0 + prior_scale = 0.0 + + ext_lm_opts = lstm_lm_opts_map[BPE_10K] + + if not bsf > 0: + search_args["batch_size"] = ( + 4000 * 160 if beam_size <= 32 else 2000 * 160 + ) + + time_rqmt = 2 + if beam_size > 30: + time_rqmt = 3 + + search_args["decoder_args"] = CTCDecoderArgs( + # add_att_dec=True, + # att_scale=att_scale, + add_ext_lm=True, + lm_type="lstm", + ext_lm_opts=ext_lm_opts, + lm_scale=lm_scale, + ctc_scale=ctc_scale, + ctc_prior_correction=prior_scale > 0, + prior_scale=prior_scale, + recombine=True, + max_approx=True, + # normalization settings + one_minus_term_mul_scale=0.0, + renorm_after_remove_blank=False, + blank_prob_scale=1.0, + repeat_prob_scale=1.0, + label_prob_scale=label_scale, + ) + run_decoding( + exp_name=f"bsf{bsf}/" + + f"optsr_max_ctc{ctc_scale}_lstmlm{lm_scale}" + + (f"_prior_{prior_scale}" if prior_scale > 0 else "") + + f"_vanilla" + + f"_beam{beam_size}", + train_data=train_data, + checkpoint=train_job_avg_ckpt[ + f"base_conf_12l_lstm_1l_conv6_OCLR_sqrdReLU_cyc915_ep2035_peak0.0009_retrain1_const20_linDecay580_{1e-4}" + ], + search_args=search_args, + feature_extraction_net=log10_net_10ms, + bpe_size=BPE_10K, + test_sets=["dev-other"], + # test_sets=["dev-other"], + remove_label={ + "", + "", + }, # blanks are removed in the network + use_sclite=True, + time_rqmt=time_rqmt, + ) + # --------------------------- With Trafo LM --------------------------- # + + # optsr max ctc w prior + trafo lm + for lm_scale, beam_size in product([0.5, 0.6, 0.65, 0.7], [12]): + search_args = copy.deepcopy(oclr_args) + search_args["beam_size"] = beam_size + search_args["ctc_log_prior_file"] = new_prior_file + ctc_scale = 1.0 + label_scale = 1.0 + prior_scale = 0.0 + + ext_lm_opts = trafo_lm_opts_map[BPE_10K] + + if not bsf > 0: + search_args["batch_size"] = ( + 4000 * 160 if beam_size <= 32 else 2000 * 160 + ) + + time_rqmt = 4 + if beam_size > 30: + time_rqmt = 5 + + search_args["decoder_args"] = CTCDecoderArgs( + # add_att_dec=True, + # att_scale=att_scale, + add_ext_lm=True, + lm_type="trafo", + ext_lm_opts=ext_lm_opts, + lm_scale=lm_scale, + ctc_scale=ctc_scale, + ctc_prior_correction=prior_scale > 0, + prior_scale=prior_scale, + recombine=True, + max_approx=True, + # normalization settings + one_minus_term_mul_scale=0.0, + renorm_after_remove_blank=False, + blank_prob_scale=1.0, + repeat_prob_scale=1.0, + label_prob_scale=label_scale, + ) + run_decoding( + exp_name=f"bsf{bsf}/" + + f"optsr_max_ctc{ctc_scale}_trafolm{lm_scale}" + + (f"_prior_{prior_scale}" if prior_scale > 0 else "") + + f"_vanilla" + + f"_beam{beam_size}", + train_data=train_data, + checkpoint=train_job_avg_ckpt[ + f"base_conf_12l_lstm_1l_conv6_OCLR_sqrdReLU_cyc915_ep2035_peak0.0009_retrain1_const20_linDecay580_{1e-4}" + ], + search_args=search_args, + feature_extraction_net=log10_net_10ms, + bpe_size=BPE_10K, + test_sets=["dev-other"], + # test_sets=["dev-other"], + remove_label={ + "", + "", + }, # blanks are removed in the network + use_sclite=True, + time_rqmt=time_rqmt, + ) + + # optsr max att + ctc w prior + trafo lm + for scales, lm_scale, beam_size in product([(0.65, 0.35, 0.0)], [0.45, 0.5, 0.55], [12]): + search_args = copy.deepcopy(oclr_args) + search_args["beam_size"] = beam_size + search_args["ctc_log_prior_file"] = new_prior_file + att_scale, ctc_scale, prior_scale = scales + label_scale = 1.0 + + ext_lm_opts = trafo_lm_opts_map[BPE_10K] + + if not bsf > 0: + search_args["batch_size"] = ( + 4000 * 160 if beam_size <= 32 else 2000 * 160 + ) + + time_rqmt = 4 + if beam_size > 30: + time_rqmt = 5 + + search_args["decoder_args"] = CTCDecoderArgs( + add_att_dec=True, + att_scale=att_scale, + add_ext_lm=True, + lm_type="trafo", + ext_lm_opts=ext_lm_opts, + lm_scale=lm_scale, + ctc_scale=ctc_scale, + ctc_prior_correction=prior_scale > 0, + prior_scale=prior_scale, + recombine=True, + max_approx=True, + # normalization settings + one_minus_term_mul_scale=0.0, + renorm_after_remove_blank=False, + blank_prob_scale=1.0, + repeat_prob_scale=1.0, + label_prob_scale=label_scale, + ) + run_decoding( + exp_name=f"bsf{bsf}/" + + f"optsr_max_att{att_scale}_ctc{ctc_scale}_trafolm{lm_scale}" + + (f"_prior_{prior_scale}" if prior_scale > 0 else "") + + f"_vanilla" + + f"_beam{beam_size}", + train_data=train_data, + checkpoint=train_job_avg_ckpt[ + f"base_conf_12l_lstm_1l_conv6_OCLR_sqrdReLU_cyc915_ep2035_peak0.0009_retrain1_const20_linDecay580_{1e-4}" + ], + search_args=search_args, + feature_extraction_net=log10_net_10ms, + bpe_size=BPE_10K, + test_sets=["dev-other"], + # test_sets=["dev-other"], + remove_label={ + "", + "", + }, # blanks are removed in the network + use_sclite=True, + time_rqmt=time_rqmt, + ) + From 7b294a2b081199da35c32dbeceb01422169816da Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Thu, 16 May 2024 09:58:36 +0000 Subject: [PATCH 023/227] add args --- .../librispeech_960/attention_asr_config.py | 31 ++++++++++++++----- 1 file changed, 24 insertions(+), 7 deletions(-) diff --git a/users/zeineldeen/experiments/conformer_att_2022/librispeech_960/attention_asr_config.py b/users/zeineldeen/experiments/conformer_att_2022/librispeech_960/attention_asr_config.py index ded12f9e8..3a6f500a1 100644 --- a/users/zeineldeen/experiments/conformer_att_2022/librispeech_960/attention_asr_config.py +++ b/users/zeineldeen/experiments/conformer_att_2022/librispeech_960/attention_asr_config.py @@ -6,6 +6,7 @@ from dataclasses import dataclass, asdict from i6_experiments.users.zeineldeen.models.asr.encoder.conformer_encoder import ConformerEncoder +from i6_experiments.users.zeineldeen.models.asr.encoder.conformer_encoder_v2 import ConformerEncoderV2 from i6_experiments.users.zeineldeen.models.asr.decoder.transformer_decoder import TransformerDecoder from i6_experiments.users.zeineldeen.models.asr.decoder.conformer_decoder import ConformerDecoder from i6_experiments.users.zeineldeen.models.asr.decoder.rnn_decoder import RNNDecoder @@ -349,11 +350,6 @@ def pretrain_layers_and_dims( net_dict = encoder_model.network.get_net() - # if decoder_args["ce_loss_scale"] == 0.0: - # assert encoder_args["with_ctc"], "CTC loss is not enabled." - # net_dict["output"] = {"class": "copy", "from": "ctc"} - # net_dict["decision"]["target"] = "bpe_labels_w_blank" - # else: net_dict.update(decoder_model.network.get_net()) net_dict.update(extra_net_dict) @@ -430,6 +426,17 @@ class ConformerEncoderArgs(EncoderArgs): convolution_first: bool = False +class ConformerEncoderV2Args(ConformerEncoderArgs): + # weight noise + ff_weight_noise: Optional[float] = None + mhsa_weight_noise: Optional[float] = None + conv_weight_noise: Optional[float] = None + frontend_conv_weight_noise: Optional[float] = None + + # weight dropout + frontend_conv_weight_dropout: Optional[float] = None + + class DecoderArgs: pass @@ -454,8 +461,14 @@ class TransformerDecoderArgs(DecoderArgs): embed_dropout: float = 0.1 softmax_dropout: float = 0.0 + ff_weight_noise: Optional[float] = None + mhsa_weight_noise: Optional[float] = None + ff_weight_dropout: Optional[float] = None + mhsa_weight_dropout: Optional[float] = None + # other regularization l2: float = 0.0 + self_att_l2: float = 0.0 rel_pos_clipping: int = 16 label_smoothing: float = 0.1 apply_embed_weight: bool = False @@ -732,9 +745,13 @@ def create_config( exp_config["newbob_learning_rate_decay"] = lr_decay # -------------------------- network -------------------------- # - encoder_type = None + if isinstance(encoder_args, ConformerEncoderArgs): encoder_type = ConformerEncoder + elif isinstance(encoder_args, ConformerEncoderV2Args): + encoder_type = ConformerEncoderV2 + else: + raise ValueError("invalid encoder_args type") if isinstance(decoder_args, TransformerDecoderArgs): decoder_type = TransformerDecoder @@ -746,7 +763,7 @@ def create_config( decoder_type = ConformerDecoder dec_type = "conformer" # TODO: check if same as transformer else: - assert False, "invalid decoder_args type" + raise ValueError("invalid decoder_args type") encoder_args = asdict(encoder_args) if feature_extraction_net: From 4a79ffad26f3ada7c86f5c16520e94e486ea05fd Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Thu, 16 May 2024 10:11:58 +0000 Subject: [PATCH 024/227] fix pretraining --- .../librispeech_960/attention_asr_config.py | 12 +++++++++--- 1 file changed, 9 insertions(+), 3 deletions(-) diff --git a/users/zeineldeen/experiments/conformer_att_2022/librispeech_960/attention_asr_config.py b/users/zeineldeen/experiments/conformer_att_2022/librispeech_960/attention_asr_config.py index 3a6f500a1..8e2d62658 100644 --- a/users/zeineldeen/experiments/conformer_att_2022/librispeech_960/attention_asr_config.py +++ b/users/zeineldeen/experiments/conformer_att_2022/librispeech_960/attention_asr_config.py @@ -315,14 +315,18 @@ def pretrain_layers_and_dims( dim_frac_enc = 1 dim_frac_dec = 1 - # TODO: use explicit param names otherwise multiple matches can lead to multiple reductions! - # TODO: WARNING: this does not include weight dropout and weight noise! # do not enable regulizations in the first pretraining step to make it more stable if initial_disabled_regularization_patterns is None: - regs_words = ["dropout", "noise", "l2"] # dropout, weight dropout, l2, weight noise + # dropout, weight dropout, l2, weight noise + regs_words = ["dropout", "weight_noise", "l2"] else: regs_words = initial_disabled_regularization_patterns + + excluded_keys = ["param_dropout_min_ndim", "weight_noise_layers"] + for k in encoder_args_copy.keys(): + if k in excluded_keys: + continue for regs_word in regs_words: if regs_word in k and encoder_args_copy[k] is not None: if not isinstance(encoder_args_copy[k], float): @@ -333,6 +337,8 @@ def pretrain_layers_and_dims( encoder_args_copy[k] *= dim_frac_enc for k in decoder_args_copy.keys(): + if k in excluded_keys: + continue for regs_word in regs_words: if regs_word in k and decoder_args_copy[k] is not None: if not isinstance(decoder_args_copy[k], float): From da315769f79e73c5689df0c08263236f227b01d7 Mon Sep 17 00:00:00 2001 From: Lukas Rilling Date: Tue, 16 Apr 2024 17:35:55 +0200 Subject: [PATCH 025/227] Glow-TTS-ASR: Update with fixed invertibility tests --- .../evaluation/forward_comparison.ipynb | 110 +- .../evaluation/phoneme_prediction_eval.ipynb | 618 +++--- users/rilling/evaluation/swer_eval.ipynb | 869 ++++---- users/rilling/evaluation/wer_eval.ipynb | 1782 +++++++++-------- .../common/eval_references/swer.py | 2 +- .../librispeech/common/tts_eval.py | 11 +- .../librispeech_glow_asr/experiments.py | 229 ++- ...former_no_freeze_spec_augment_weak_conf.py | 290 +++ ...2.py => glowASR_conformer_v2_weak_conf.py} | 33 +- ...former_x_vector_v2_bottleneck_weak_conf.py | 445 ++++ .../training_comparison.ipynb | 31 +- ..._test_maxlike_alignment_multi_layer_ffn.py | 1 + .../training_comparison.ipynb | 12 +- .../librispeech_joint_training/experiments.py | 69 + .../librispeech_joint_training/pipeline.py | 6 +- .../glowTTS_ASR_conformer_two_forward_pass.py | 4 +- .../glowTTS_ASR_conformer_x_vector.py | 7 +- .../pytorch_networks/glow_ASR_conformer.py | 8 +- .../glow_ASR_conformer_specaugment_before.py | 8 +- ...SR_conformer_specaugment_before_xvector.py | 7 +- .../shared/eval_invertibility.py | 76 +- .../config.py | 5 +- .../data.py | 2 +- .../exp_joint/experiments.py | 6 +- .../exp_joint_2step/experiments.py | 99 +- .../exp_joint_2step/training_comparison.ipynb | 152 +- .../experiments.py | 56 + .../training_comparison.ipynb | 42 +- .../exp_tts/experiments.py | 192 +- .../exp_tts/training_comparison.ipynb | 589 +++++- .../pipeline.py | 1 + .../frozen_glowtts/ga_glowTTS_ASR_ffn.py | 1 + .../frozen_glowtts/ga_glowTTS_ASR_ffn_mas.py | 658 ++++++ .../ga_glowTTS_ASR_ffn_mas_no_eval.py | 657 ++++++ .../ga_glowTTS_ASR_ffn_x_vector.py | 1 - .../ga_glowTTS_ASR_ffn_x_vector_mas.py | 8 +- ...ga_glowTTS_ASR_ffn_x_vector_mas_no_eval.py | 600 ++++++ .../glowASR_conformer_x_vector.py | 483 +++++ .../pytorch_networks/glowTTS.py | 1 + .../pytorch_networks/glowTTS_x_vector_v2.py | 1 + .../pytorch_networks/shared/configs.py | 41 +- .../shared/eval_invertibility.py | 90 + .../storage.py | 5 +- 43 files changed, 6465 insertions(+), 1843 deletions(-) create mode 100644 users/rilling/experiments/librispeech/librispeech_glow_asr/pytorch_networks/glowASR_conformer_no_freeze_spec_augment_weak_conf.py rename users/rilling/experiments/librispeech/librispeech_glow_asr/pytorch_networks/{glowASR_conformer_v2.py => glowASR_conformer_v2_weak_conf.py} (96%) create mode 100644 users/rilling/experiments/librispeech/librispeech_glow_asr/pytorch_networks/glowASR_conformer_x_vector_v2_bottleneck_weak_conf.py create mode 100644 users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/pytorch_networks/frozen_glowtts/ga_glowTTS_ASR_ffn_mas.py create mode 100644 users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/pytorch_networks/frozen_glowtts/ga_glowTTS_ASR_ffn_mas_no_eval.py create mode 100644 users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/pytorch_networks/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector_mas_no_eval.py create mode 100644 users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/pytorch_networks/frozen_glowtts/glowASR_conformer_x_vector.py create mode 100644 users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/pytorch_networks/shared/eval_invertibility.py diff --git a/users/rilling/evaluation/forward_comparison.ipynb b/users/rilling/evaluation/forward_comparison.ipynb index 604037054..c22bf1a9e 100644 --- a/users/rilling/evaluation/forward_comparison.ipynb +++ b/users/rilling/evaluation/forward_comparison.ipynb @@ -2,14 +2,14 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_3656952/2049839218.py:8: DeprecationWarning: Importing display from IPython.core.display is deprecated since IPython 7.14, please import from IPython display\n", + "/tmp/ipykernel_503671/2049839218.py:8: DeprecationWarning: Importing display from IPython.core.display is deprecated since IPython 7.14, please import from IPython display\n", " from IPython.core.display import display\n" ] } @@ -33,35 +33,38 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{'/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/tts_eval_gl/test-clean/forward/output/audio_files/': '/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/tts_eval_gl/test-clean/forward/output/audio_files/': '/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/tts_eval_gl/test-clean/forward/output/audio_files/': '/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/tts_eval_gl/test-clean/forward/output/audio_files/': '/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc192/200ep/dec_drop_0.05/tts_eval_gl/test-clean/forward/output/audio_files/': '/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc192/200ep/dec_drop_0.05/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/200ep/dec_drop_0.05/tts_eval_gl/test-clean/forward/output/audio_files/': '/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/200ep/dec_drop_0.05/'}" + "{'/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/400ep/dec_drop_0.05/tts_eval_gl/test-clean/forward/output/audio_files/': '/glowTTS_x_vector_v2/enc768/400ep/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/200ep/dec_drop_0.05/tts_eval_gl/test-clean/forward/output/audio_files/': '/glowTTS_x_vector_v2/enc768/200ep/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/100ep/dec_drop_0.05/tts_eval_gl/test-clean/forward/output/audio_files/': '/glowTTS_x_vector_v2/enc768/100ep/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/200ep_long_cooldown/dec_drop_0.05/tts_eval_gl/test-clean/forward/output/audio_files/': '/glowTTS_x_vector_v2/enc768/200ep_long_cooldown/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/100ep/dec_drop_0.05/tts_eval_gl/test-clean/forward/output/audio_files/': '/glowTTS/enc768/100ep/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/200ep/dec_drop_0.05/tts_eval_gl/test-clean/forward/output/audio_files/': '/glowTTS/enc768/200ep/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/400ep/grad_clip_10/dec_drop_0.05/tts_eval_gl/test-clean/forward/output/audio_files/': '/glowTTS/enc768/400ep/grad_clip_10/'}" ] }, - "execution_count": 15, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "globs = [\n", - " # \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector/enc768/100ep/dec_drop_0.05/tts_eval_gl/test-clean/forward/output/audio_files/\",\n", + " \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/*/dec_drop_0.05/tts_eval_gl/test-clean/forward/output/audio_files/\",\n", + " \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/*/dec_drop_0.05/tts_eval_gl/test-clean/forward/output/audio_files/\",\n", + " \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/*/*/dec_drop_0.05/tts_eval_gl/test-clean/forward/output/audio_files/\",\n", " # \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS/tts_eval_gl/test-clean/forward/output/audio_files/\",\n", " # \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_x_vector/tts_eval_gl/test-clean/forward/output/audio_files/\",\n", " # \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2_conformer_coupling/enc768/200ep/dec_drop_0.05/tts_eval_gl/test-clean/forward/output/audio_files/\",\n", " # \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_simple_encoder/*/200ep/dec_drop_*/tts_eval_gl/forward/output/audio_files/\",\n", - " \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment*/tts_eval_gl/test-clean/forward/output/audio_files/\",\n", - " \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass*/tts_eval_gl/test-clean/forward/output/audio_files/\",\n", - " \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc*/200ep/dec_drop_0.05/tts_eval_gl/test-clean/forward/output/audio_files/\",\n", + " # \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment*/tts_eval_gl/test-clean/forward/output/audio_files/\",\n", + " # \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass*/tts_eval_gl/test-clean/forward/output/audio_files/\",\n", + " # \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc*/200ep/dec_drop_0.05/tts_eval_gl/test-clean/forward/output/audio_files/\",\n", "]\n", "lr_files = []\n", "for g in globs:\n", @@ -83,16 +86,16 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/tts_eval_gl/test-clean/forward/output/audio_files/test-clean_8463-287645-0010_8463-287645-0010.ogg\n", - "/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/\n", - "AutoMOS: 3.196073057424081\n", + "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/400ep/dec_drop_0.05/tts_eval_gl/test-clean/forward/output/audio_files/test-clean_121-127105-0010_121-127105-0010.ogg\n", + "/glowTTS_x_vector_v2/enc768/400ep/\n", + "AutoMOS: 3.3250440482638384\n", "\n" ] }, @@ -101,7 +104,7 @@ "text/html": [ "\n", " \n", " " @@ -117,9 +120,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/tts_eval_gl/test-clean/forward/output/audio_files/test-clean_8463-287645-0010_8463-287645-0010.ogg\n", - "/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/\n", - "AutoMOS: 2.320053706043645\n", + "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/200ep/dec_drop_0.05/tts_eval_gl/test-clean/forward/output/audio_files/test-clean_121-127105-0010_121-127105-0010.ogg\n", + "/glowTTS_x_vector_v2/enc768/200ep/\n", + "AutoMOS: 3.2574123507855752\n", "\n" ] }, @@ -128,7 +131,7 @@ "text/html": [ "\n", " \n", " " @@ -144,9 +147,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/tts_eval_gl/test-clean/forward/output/audio_files/test-clean_8463-287645-0010_8463-287645-0010.ogg\n", - "/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/\n", - "AutoMOS: 3.1575978984566113\n", + "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/100ep/dec_drop_0.05/tts_eval_gl/test-clean/forward/output/audio_files/test-clean_121-127105-0010_121-127105-0010.ogg\n", + "/glowTTS_x_vector_v2/enc768/100ep/\n", + "AutoMOS: 3.181718836146358\n", "\n" ] }, @@ -155,7 +158,7 @@ "text/html": [ "\n", " \n", " " @@ -171,9 +174,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/tts_eval_gl/test-clean/forward/output/audio_files/test-clean_8463-287645-0010_8463-287645-0010.ogg\n", - "/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/\n", - "AutoMOS: 2.614637943229785\n", + "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/200ep_long_cooldown/dec_drop_0.05/tts_eval_gl/test-clean/forward/output/audio_files/test-clean_121-127105-0010_121-127105-0010.ogg\n", + "/glowTTS_x_vector_v2/enc768/200ep_long_cooldown/\n", + "AutoMOS: 3.212764627153152\n", "\n" ] }, @@ -182,7 +185,7 @@ "text/html": [ "\n", " \n", " " @@ -198,9 +201,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc192/200ep/dec_drop_0.05/tts_eval_gl/test-clean/forward/output/audio_files/test-clean_8463-287645-0010_8463-287645-0010.ogg\n", - "/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc192/200ep/dec_drop_0.05/\n", - "AutoMOS: 3.2963643568126777\n", + "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/100ep/dec_drop_0.05/tts_eval_gl/test-clean/forward/output/audio_files/test-clean_121-127105-0010_121-127105-0010.ogg\n", + "/glowTTS/enc768/100ep/\n", + "AutoMOS: 3.302589650658008\n", "\n" ] }, @@ -209,7 +212,7 @@ "text/html": [ "\n", " \n", " " @@ -225,9 +228,36 @@ "name": "stdout", "output_type": "stream", "text": [ - "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/200ep/dec_drop_0.05/tts_eval_gl/test-clean/forward/output/audio_files/test-clean_8463-287645-0010_8463-287645-0010.ogg\n", - "/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/200ep/dec_drop_0.05/\n", - "AutoMOS: 3.2574123507855752\n", + "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/200ep/dec_drop_0.05/tts_eval_gl/test-clean/forward/output/audio_files/test-clean_121-127105-0010_121-127105-0010.ogg\n", + "/glowTTS/enc768/200ep/\n", + "AutoMOS: 3.3596264232244146\n", + "\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/400ep/grad_clip_10/dec_drop_0.05/tts_eval_gl/test-clean/forward/output/audio_files/test-clean_121-127105-0010_121-127105-0010.ogg\n", + "/glowTTS/enc768/400ep/grad_clip_10/\n", + "AutoMOS: 3.2932603021495437\n", "\n" ] }, @@ -236,7 +266,7 @@ "text/html": [ "\n", " \n", " " @@ -250,7 +280,7 @@ } ], "source": [ - "sequence_index = 5\n", + "sequence_index = 10\n", "sequence_name = sequence_names[sequence_index]\n", "\n", "for folder, name in files.items():\n", diff --git a/users/rilling/evaluation/phoneme_prediction_eval.ipynb b/users/rilling/evaluation/phoneme_prediction_eval.ipynb index fd2438cd1..31e863a2d 100644 --- a/users/rilling/evaluation/phoneme_prediction_eval.ipynb +++ b/users/rilling/evaluation/phoneme_prediction_eval.ipynb @@ -44,57 +44,67 @@ { "data": { "text/plain": [ - "['/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/mean_only/200ep/basic_init/no_specaug/tts_target_size/ce_ls_0.1/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/200ep/tts_pretrained/no_specaug/tts_target_size/ce_ls_0.1/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/no_specaug/tts_target_size/ce_ls_0.1/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/no_specaug/tts_target_size/ce_ls_1.0/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_simple_encoder_x_vector/200ep/basic_init/no_specaug/tts_target_size/ce_ls_0.1/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_cnn_x_vector/tts_pretrained/no_specaug/tts_target_size/ce_ls_0.1/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_cnn_x_vector/basic_init/no_specaug/tts_target_size/ce_ls_0.1/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/200ep/basic_init/no_specaug/tts_target_size/ce_ls_0.1/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/200ep/tts_pretrained/no_specaug/tts_target_size/ce_ls_0.1/',\n", + "['/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_simple_encoder_x_vector/200ep/basic_init/no_specaug/tts_target_size/ce_ls_0.1/',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/specaug/ce_ls_0.1/',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/specaug/ce_ls_1/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/no_specaug/ce_ls_0.1/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/200ep/basic_init/no_specaug/tts_target_size/ce_ls_0.1/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/200ep/tts_pretrained/no_specaug/tts_target_size/ce_ls_0.1/',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/no_specaug/ce_ls_1/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_blstm_x_vector/specaug/ce_ls_0.1/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/no_specaug/ce_ls_0.1/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_cnn_x_vector/tts_pretrained/no_specaug/tts_target_size/ce_ls_0.1/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_cnn_x_vector/basic_init/no_specaug/tts_target_size/ce_ls_0.1/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/mean_only/200ep/basic_init/no_specaug/tts_target_size/ce_ls_0.1/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/200ep/tts_pretrained/no_specaug/tts_target_size/ce_ls_0.1/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/no_specaug/tts_target_size/ce_ls_1.0/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/no_specaug/tts_target_size/ce_ls_0.1/',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_blstm_x_vector/specaug/ce_ls_1/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_blstm_x_vector/no_specaug/ce_ls_0.1/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_blstm_x_vector/specaug/ce_ls_0.1/',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_blstm_x_vector/no_specaug/ce_ls_1/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step_tts/ga_glowTTS_ASR_ffn_x_vector_v2_2ndstep_tts/ce_ls_1.0/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector/basic_init/ce_ls_0.1/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector/tts_pretrained/ce_ls_0.1/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector/200ep/tts_pretrained/ce_ls_0.1/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector/200ep/basic_init/ce_ls_0.1/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector_v2/basic_init/ce_ls_0.1/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector_v2/basic_init/ce_ls_0.01/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector_v2/tts_pretrained/ce_ls_0.1/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector_v2/tts_pretrained/ce_ls_0.01/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step/ga_glowTTS_ASR_ffn_x_vector_v2_2ndstep/ce_ls_1.0/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn_x_vector/100ep/encoder/decoder_eval/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn_x_vector/100ep/encoder/encoder_eval/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn_x_vector/100ep/decoder/encoder_eval/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn_x_vector/100ep/decoder/decoder_eval/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector/100ep/decoder/decoder_eval/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector/100ep/decoder/encoder_eval/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_blstm_x_vector/no_specaug/ce_ls_0.1/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/first_step/ga_glowTTS_ASR_ffn_x_vector_v2/ce_ls_4.0/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/first_step/ga_glowTTS_ASR_ffn_x_vector_v2/ce_ls_3.0/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/first_step/ga_glowTTS_ASR_ffn_x_vector_v2/ce_ls_2.0/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/first_step/ga_glowTTS_ASR_ffn_x_vector_v2/ce_ls_1.0/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_mas/100ep/encoder/decoder_eval/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_mas/100ep/encoder/encoder_eval/',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector/100ep/encoder/decoder_eval/',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector/100ep/encoder/encoder_eval/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector/100ep/decoder/encoder_eval/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector/100ep/decoder/decoder_eval/',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn/100ep/encoder/encoder_eval/',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn/100ep/encoder/decoder_eval/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn/100ep/decoder/encoder_eval/',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn/100ep/decoder/decoder_eval/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn/100ep/decoder/encoder_eval/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn_x_vector/100ep/encoder/encoder_eval/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn_x_vector/100ep/encoder/decoder_eval/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn_x_vector/100ep/decoder/encoder_eval/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn_x_vector/100ep/decoder/decoder_eval/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector_mas/100ep/encoder/decoder_eval/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector_mas/100ep/encoder/encoder_eval/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector_mas/100ep/decoder/decoder_eval/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector_mas/100ep/decoder/encoder_eval/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn/100ep/decoder/decoder_eval/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn/100ep/decoder/encoder_eval/',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn/100ep/encoder/decoder_eval/',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn/100ep/encoder/encoder_eval/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn/100ep/decoder/encoder_eval/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn/100ep/decoder/decoder_eval/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/first_step/ga_glowTTS_ASR_ffn_x_vector_v2/ce_ls_1.0/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/first_step/ga_glowTTS_ASR_ffn_x_vector_v2/ce_ls_2.0/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/first_step/ga_glowTTS_ASR_ffn_x_vector_v2/ce_ls_3.0/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/first_step/ga_glowTTS_ASR_ffn_x_vector_v2/ce_ls_4.0/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector_v2/200ep/tts_pretrained/ce_ls_0.1/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_mas_no_eval/100ep/decoder/decoder_eval/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_mas_no_eval/100ep/decoder/encoder_eval/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_mas_no_eval/100ep/encoder/decoder_eval/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_mas_no_eval/100ep/encoder/encoder_eval/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector_v2/tts_pretrained/ce_ls_0.1/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector_v2/tts_pretrained/ce_ls_0.01/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector_v2/basic_init/ce_ls_0.1/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector_v2/basic_init/ce_ls_0.01/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step_tts/ga_glowTTS_ASR_ffn_x_vector_v2_2ndstep_tts/ce_ls_1.0/',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector_v2/200ep/tts_pretrained/ce_ls_1.0/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector_v2/200ep/tts_pretrained/ce_ls_0.1/',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/ce_ls_1.0/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/ce_ls_0.1/']" + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/ce_ls_0.1/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector/200ep/basic_init/ce_ls_0.1/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector/200ep/tts_pretrained/ce_ls_0.1/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector/tts_pretrained/ce_ls_0.1/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector/basic_init/ce_ls_0.1/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step/ga_glowTTS_ASR_ffn_x_vector_v2_2ndstep/ce_ls_1.0/']" ] }, "execution_count": 3, @@ -163,24 +173,24 @@ " \n", " \n", " joint_training/given_alignments\n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/mean_only/200ep/basic_init/no_specaug/tts_target_size/ce_ls_0.1/\n", - " 22.60\n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_simple_encoder_x_vector/200ep/basic_init/no_specaug/tts_target_size/ce_ls_0.1/\n", + " 21.30\n", " \n", " \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/200ep/tts_pretrained/no_specaug/tts_target_size/ce_ls_0.1/\n", - " 23.40\n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/specaug/ce_ls_0.1/\n", + " 26.49\n", " \n", " \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/no_specaug/tts_target_size/ce_ls_0.1/\n", - " 22.76\n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/specaug/ce_ls_1/\n", + " 27.30\n", " \n", " \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/no_specaug/tts_target_size/ce_ls_1.0/\n", - " 22.24\n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/200ep/basic_init/no_specaug/tts_target_size/ce_ls_0.1/\n", + " 30.09\n", " \n", " \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_simple_encoder_x_vector/200ep/basic_init/no_specaug/tts_target_size/ce_ls_0.1/\n", - " 21.30\n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/200ep/tts_pretrained/no_specaug/tts_target_size/ce_ls_0.1/\n", + " 28.56\n", " \n", " \n", "\n", @@ -189,11 +199,11 @@ "text/plain": [ " Accuracy [%]\n", "Group Experiment \n", - "joint_training/given_alignments /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 22.60\n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 23.40\n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 22.76\n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 22.24\n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 21.30" + "joint_training/given_alignments /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 21.30\n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 26.49\n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 27.30\n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 30.09\n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 28.56" ] }, "execution_count": 4, @@ -265,63 +275,63 @@ " \n", " \n", " joint_training/given_alignments\n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/mean_only/200ep/basic_init/no_specaug/tts_target_size/ce_ls_0.1/\n", - " 22.60\n", - " 2.922168\n", - " 2.922654\n", - " -0.803728\n", - " 0.932394\n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_simple_encoder_x_vector/200ep/basic_init/no_specaug/tts_target_size/ce_ls_0.1/\n", + " 21.30\n", + " 2.920585\n", + " 2.941674\n", + " -0.797284\n", + " 0.957548\n", " True\n", " False\n", - " 1.000166\n", + " 1.007221\n", " True\n", " \n", " \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/200ep/tts_pretrained/no_specaug/tts_target_size/ce_ls_0.1/\n", - " 23.40\n", - " 2.879141\n", - " 2.887437\n", - " -0.805783\n", - " 0.625962\n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/specaug/ce_ls_0.1/\n", + " 26.49\n", + " 2.868420\n", + " 2.858513\n", + " -0.802836\n", + " 0.434087\n", " True\n", " False\n", - " 1.002882\n", + " 0.996546\n", " True\n", " \n", " \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/no_specaug/tts_target_size/ce_ls_0.1/\n", - " 22.76\n", - " 2.923517\n", - " 2.933859\n", - " -0.799504\n", - " 0.818331\n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/specaug/ce_ls_1/\n", + " 27.30\n", + " 2.664396\n", + " 2.957262\n", + " -0.72108\n", + " 0.747725\n", " True\n", " False\n", - " 1.003538\n", + " 1.109919\n", " True\n", " \n", " \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/no_specaug/tts_target_size/ce_ls_1.0/\n", - " 22.24\n", - " 2.922999\n", - " 2.924061\n", - " -0.801181\n", - " 0.834689\n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/200ep/basic_init/no_specaug/tts_target_size/ce_ls_0.1/\n", + " 30.09\n", + " 2.782269\n", + " 2.795637\n", + " -0.785492\n", + " 0.890597\n", " True\n", " False\n", - " 1.000363\n", + " 1.004805\n", " True\n", " \n", " \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_simple_encoder_x_vector/200ep/basic_init/no_specaug/tts_target_size/ce_ls_0.1/\n", - " 21.30\n", - " 2.920585\n", - " 2.941674\n", - " -0.797284\n", - " 0.957548\n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/200ep/tts_pretrained/no_specaug/tts_target_size/ce_ls_0.1/\n", + " 28.56\n", + " 2.813527\n", + " 2.825326\n", + " -0.803716\n", + " 0.439343\n", " True\n", " False\n", - " 1.007221\n", + " 1.004194\n", " True\n", " \n", " \n", @@ -331,43 +341,43 @@ "text/plain": [ " Accuracy [%] \\\n", "Group Experiment \n", - "joint_training/given_alignments /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 22.60 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 23.40 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 22.76 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 22.24 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 21.30 \n", + "joint_training/given_alignments /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 21.30 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 26.49 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 27.30 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 30.09 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 28.56 \n", "\n", " CE \\\n", "Group Experiment \n", - "joint_training/given_alignments /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 2.922168 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 2.879141 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 2.923517 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 2.922999 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 2.920585 \n", + "joint_training/given_alignments /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 2.920585 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 2.868420 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 2.664396 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 2.782269 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 2.813527 \n", "\n", " dev CE \\\n", "Group Experiment \n", - "joint_training/given_alignments /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 2.922654 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 2.887437 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 2.933859 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 2.924061 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 2.941674 \n", + "joint_training/given_alignments /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 2.941674 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 2.858513 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 2.957262 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 2.795637 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 2.825326 \n", "\n", " MLE \\\n", "Group Experiment \n", - "joint_training/given_alignments /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.803728 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.805783 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.799504 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.801181 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.797284 \n", + "joint_training/given_alignments /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.797284 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.802836 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.72108 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.785492 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.803716 \n", "\n", " DP \\\n", "Group Experiment \n", - "joint_training/given_alignments /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.932394 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.625962 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.818331 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.834689 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.957548 \n", + "joint_training/given_alignments /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.957548 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.434087 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.747725 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.890597 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.439343 \n", "\n", " Joint \\\n", "Group Experiment \n", @@ -387,11 +397,11 @@ "\n", " overfitting \\\n", "Group Experiment \n", - "joint_training/given_alignments /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 1.000166 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 1.002882 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 1.003538 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 1.000363 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 1.007221 \n", + "joint_training/given_alignments /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 1.007221 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.996546 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 1.109919 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 1.004805 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 1.004194 \n", "\n", " Training data available \n", "Group Experiment \n", @@ -526,33 +536,16 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 13, "metadata": {}, - "outputs": [ - { - "ename": "IndexError", - "evalue": "list index out of range", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[8], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m df_indexed[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mCE loss scale\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[43mdf_indexed\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mapply\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43;01mlambda\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mx\u001b[49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mfloat\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mExperiment\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msplit\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43m/ce_ls_\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m]\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msplit\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43m/\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43maxis\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m/work/tools22/users/lukas.rilling/sis_env/lib/python3.10/site-packages/pandas/core/frame.py:10037\u001b[0m, in \u001b[0;36mDataFrame.apply\u001b[0;34m(self, func, axis, raw, result_type, args, by_row, **kwargs)\u001b[0m\n\u001b[1;32m 10025\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mpandas\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mcore\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mapply\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m frame_apply\n\u001b[1;32m 10027\u001b[0m op \u001b[38;5;241m=\u001b[39m frame_apply(\n\u001b[1;32m 10028\u001b[0m \u001b[38;5;28mself\u001b[39m,\n\u001b[1;32m 10029\u001b[0m func\u001b[38;5;241m=\u001b[39mfunc,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 10035\u001b[0m kwargs\u001b[38;5;241m=\u001b[39mkwargs,\n\u001b[1;32m 10036\u001b[0m )\n\u001b[0;32m> 10037\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mop\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mapply\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241m.\u001b[39m__finalize__(\u001b[38;5;28mself\u001b[39m, method\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mapply\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n", - "File \u001b[0;32m/work/tools22/users/lukas.rilling/sis_env/lib/python3.10/site-packages/pandas/core/apply.py:831\u001b[0m, in \u001b[0;36mFrameApply.apply\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 828\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mraw:\n\u001b[1;32m 829\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mapply_raw()\n\u001b[0;32m--> 831\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mapply_standard\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m/work/tools22/users/lukas.rilling/sis_env/lib/python3.10/site-packages/pandas/core/apply.py:957\u001b[0m, in \u001b[0;36mFrameApply.apply_standard\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 956\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mapply_standard\u001b[39m(\u001b[38;5;28mself\u001b[39m):\n\u001b[0;32m--> 957\u001b[0m results, res_index \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mapply_series_generator\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 959\u001b[0m \u001b[38;5;66;03m# wrap results\u001b[39;00m\n\u001b[1;32m 960\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mwrap_results(results, res_index)\n", - "File \u001b[0;32m/work/tools22/users/lukas.rilling/sis_env/lib/python3.10/site-packages/pandas/core/apply.py:973\u001b[0m, in \u001b[0;36mFrameApply.apply_series_generator\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 970\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m option_context(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mmode.chained_assignment\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;28;01mNone\u001b[39;00m):\n\u001b[1;32m 971\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i, v \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28menumerate\u001b[39m(series_gen):\n\u001b[1;32m 972\u001b[0m \u001b[38;5;66;03m# ignore SettingWithCopy here in case the user mutates\u001b[39;00m\n\u001b[0;32m--> 973\u001b[0m results[i] \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[43mv\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 974\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(results[i], ABCSeries):\n\u001b[1;32m 975\u001b[0m \u001b[38;5;66;03m# If we have a view on v, we need to make a copy because\u001b[39;00m\n\u001b[1;32m 976\u001b[0m \u001b[38;5;66;03m# series_generator will swap out the underlying data\u001b[39;00m\n\u001b[1;32m 977\u001b[0m results[i] \u001b[38;5;241m=\u001b[39m results[i]\u001b[38;5;241m.\u001b[39mcopy(deep\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m)\n", - "Cell \u001b[0;32mIn[8], line 1\u001b[0m, in \u001b[0;36m\u001b[0;34m(x)\u001b[0m\n\u001b[0;32m----> 1\u001b[0m df_indexed[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mCE loss scale\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m df_indexed\u001b[38;5;241m.\u001b[39mapply(\u001b[38;5;28;01mlambda\u001b[39;00m x: \u001b[38;5;28mfloat\u001b[39m(\u001b[43mx\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mExperiment\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msplit\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43m/ce_ls_\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m]\u001b[49m\u001b[38;5;241m.\u001b[39msplit(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m/\u001b[39m\u001b[38;5;124m\"\u001b[39m)[\u001b[38;5;241m0\u001b[39m]), axis\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1\u001b[39m)\n", - "\u001b[0;31mIndexError\u001b[0m: list index out of range" - ] - } - ], + "outputs": [], "source": [ - "df_indexed[\"CE loss scale\"] = df_indexed.apply(lambda x: float(x[\"Experiment\"].split(\"/ce_ls_\")[1].split(\"/\")[0]), axis=1)" + "df_indexed[\"CE loss scale\"] = df_indexed.apply(lambda x: float(x[\"Experiment\"].split(\"/ce_ls_\")[1].split(\"/\")[0] if \"/ce_ls_\" in x[\"Experiment\"] else np.nan), axis=1)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -607,7 +600,7 @@ " False\n", " 1.007\n", " True\n", - " 200\n", + " 200.0\n", " [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05]\n", " unknown\n", " 0.1\n", @@ -616,52 +609,52 @@ " 1\n", " joint_training/given_alignments\n", " /u/lukas.rilling/experiments/glow_tts_asr_v2/o...\n", - " 21.61\n", - " 2.939\n", - " 2.947\n", - " -\n", - " -\n", - " False\n", + " 26.49\n", + " 2.868\n", + " 2.859\n", + " -0.803\n", + " 0.434\n", + " True\n", " False\n", - " 1.003\n", + " 0.997\n", " True\n", - " 100\n", - " [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05]\n", + " 250.0\n", + " [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08]\n", " unknown\n", - " 1.0\n", + " 0.1\n", " \n", " \n", " 2\n", " joint_training/given_alignments\n", " /u/lukas.rilling/experiments/glow_tts_asr_v2/o...\n", - " 21.33\n", - " 2.925\n", - " 2.946\n", - " -0.792\n", - " 0.247\n", + " 27.30\n", + " 2.664\n", + " 2.957\n", + " -0.721\n", + " 0.748\n", " True\n", " False\n", - " 1.007\n", + " 1.11\n", " True\n", - " 200\n", - " [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05]\n", + " 250.0\n", + " [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08]\n", " unknown\n", - " 0.1\n", + " 1.0\n", " \n", " \n", " 3\n", " joint_training/given_alignments\n", " /u/lukas.rilling/experiments/glow_tts_asr_v2/o...\n", - " 21.39\n", - " 2.921\n", - " 2.947\n", - " -0.779\n", - " 0.256\n", + " 30.09\n", + " 2.782\n", + " 2.796\n", + " -0.785\n", + " 0.891\n", " True\n", " False\n", - " 1.009\n", + " 1.005\n", " True\n", - " 200\n", + " 200.0\n", " [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05]\n", " unknown\n", " 0.1\n", @@ -671,18 +664,18 @@ " joint_training/given_alignments\n", " /u/lukas.rilling/experiments/glow_tts_asr_v2/o...\n", " 28.56\n", - " 0.003\n", - " 0.003\n", - " -0.702\n", - " 0.075\n", + " 2.814\n", + " 2.825\n", + " -0.804\n", + " 0.439\n", " True\n", " False\n", - " 0.948\n", + " 1.004\n", " True\n", - " 100\n", - " [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05]\n", + " 200.0\n", + " [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05]\n", " unknown\n", - " 4.0\n", + " 0.1\n", " \n", " \n", "\n", @@ -698,41 +691,41 @@ "\n", " Experiment Accuracy [%] CE \\\n", "0 /u/lukas.rilling/experiments/glow_tts_asr_v2/o... 21.30 2.921 \n", - "1 /u/lukas.rilling/experiments/glow_tts_asr_v2/o... 21.61 2.939 \n", - "2 /u/lukas.rilling/experiments/glow_tts_asr_v2/o... 21.33 2.925 \n", - "3 /u/lukas.rilling/experiments/glow_tts_asr_v2/o... 21.39 2.921 \n", - "4 /u/lukas.rilling/experiments/glow_tts_asr_v2/o... 28.56 0.003 \n", + "1 /u/lukas.rilling/experiments/glow_tts_asr_v2/o... 26.49 2.868 \n", + "2 /u/lukas.rilling/experiments/glow_tts_asr_v2/o... 27.30 2.664 \n", + "3 /u/lukas.rilling/experiments/glow_tts_asr_v2/o... 30.09 2.782 \n", + "4 /u/lukas.rilling/experiments/glow_tts_asr_v2/o... 28.56 2.814 \n", "\n", " dev CE MLE DP Joint Still running overfitting \\\n", "0 2.942 -0.797 0.958 True False 1.007 \n", - "1 2.947 - - False False 1.003 \n", - "2 2.946 -0.792 0.247 True False 1.007 \n", - "3 2.947 -0.779 0.256 True False 1.009 \n", - "4 0.003 -0.702 0.075 True False 0.948 \n", + "1 2.859 -0.803 0.434 True False 0.997 \n", + "2 2.957 -0.721 0.748 True False 1.11 \n", + "3 2.796 -0.785 0.891 True False 1.005 \n", + "4 2.825 -0.804 0.439 True False 1.004 \n", "\n", - " Training data available Num Epochs \\\n", - "0 True 200 \n", - "1 True 100 \n", - "2 True 200 \n", - "3 True 200 \n", - "4 True 100 \n", + " Training data available Num Epochs \\\n", + "0 True 200.0 \n", + "1 True 250.0 \n", + "2 True 250.0 \n", + "3 True 200.0 \n", + "4 True 200.0 \n", "\n", - " LR ASR Model Type \\\n", - "0 [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] unknown \n", - "1 [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] unknown \n", - "2 [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] unknown \n", - "3 [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] unknown \n", - "4 [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] unknown \n", + " LR ASR Model Type \\\n", + "0 [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] unknown \n", + "1 [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] unknown \n", + "2 [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] unknown \n", + "3 [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] unknown \n", + "4 [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] unknown \n", "\n", - " CE loss scale \n", - "0 0.1 \n", - "1 1.0 \n", - "2 0.1 \n", - "3 0.1 \n", - "4 4.0 " + " CE loss scale \n", + "0 0.1 \n", + "1 0.1 \n", + "2 1.0 \n", + "3 0.1 \n", + "4 0.1 " ] }, - "execution_count": 49, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } @@ -744,177 +737,82 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "| | Group | Experiment | Accuracy [%] | CE | dev CE | MLE | DP | Joint | Still running | overfitting | Training data available | Num Epochs | LR | ASR Model Type | CE loss scale |\n", - "|---:|:--------------------------------|:----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------------:|:------|:---------|:-------|:------|:--------|:----------------|:--------------|:--------------------------|-------------:|:-------------------------------------------------|:-----------------|----------------:|\n", - "| 0 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_simple_encoder_x_vector/200ep/basic_init/no_specaug/tts_target_size/ce_ls_0.1/ | 21.3 | 2.921 | 2.942 | -0.797 | 0.958 | True | False | 1.007 | True | 200 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", - "| 1 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step/ga_glowTTS_ASR_ffn_x_vector_v2_2ndstep/ce_ls_1.0/ | 21.61 | 2.939 | 2.947 | - | - | False | False | 1.003 | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | unknown | 1 |\n", - "| 2 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector/200ep/tts_pretrained/ce_ls_0.1/ | 21.33 | 2.925 | 2.946 | -0.792 | 0.247 | True | False | 1.007 | True | 200 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", - "| 3 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector/200ep/basic_init/ce_ls_0.1/ | 21.39 | 2.921 | 2.947 | -0.779 | 0.256 | True | False | 1.009 | True | 200 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", - "| 4 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/first_step/ga_glowTTS_ASR_ffn_x_vector_v2/ce_ls_4.0/ | 28.56 | 0.003 | 0.003 | -0.702 | 0.075 | True | False | 0.948 | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | unknown | 4 |\n", - "| 5 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/first_step/ga_glowTTS_ASR_ffn_x_vector_v2/ce_ls_1.0/ | 20.45 | 0.012 | 0.012 | -0.716 | 0.075 | True | False | 0.98 | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | unknown | 1 |\n", - "| 6 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/first_step/ga_glowTTS_ASR_ffn_x_vector_v2/ce_ls_2.0/ | 20.38 | 0.006 | 0.006 | -0.708 | 0.075 | True | False | 1.018 | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | unknown | 2 |\n", - "| 7 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/first_step/ga_glowTTS_ASR_ffn_x_vector_v2/ce_ls_3.0/ | 20.47 | 0.004 | 0.004 | -0.703 | 0.075 | True | False | 0.954 | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | unknown | 3 |\n", - "| 8 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector/basic_init/ce_ls_0.1/ | 25.67 | 2.583 | 3.019 | -0.767 | 0.265 | True | False | 1.169 | True | 200 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", - "| 9 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector/tts_pretrained/ce_ls_0.1/ | 27.63 | 2.617 | 2.915 | -0.775 | 0.263 | True | False | 1.114 | True | 200 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", - "| 10 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/ce_ls_0.1/ | 20.71 | 0.124 | 0.122 | -0.757 | 0.071 | True | False | 0.983 | True | 200 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", - "| 11 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/ce_ls_1.0/ | 20.48 | 0.012 | 0.011 | -0.73 | 0.07 | True | False | 0.965 | True | 200 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 1 |\n", - "| 12 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector_v2/200ep/tts_pretrained/ce_ls_1.0/ | 20.42 | 0.014 | 0.014 | -0.729 | 0.076 | True | False | 1.049 | True | 200 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 1 |\n", - "| 13 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector_v2/200ep/tts_pretrained/ce_ls_0.1/ | 20.22 | 0.14 | 0.14 | -0.76 | 0.075 | True | False | 0.995 | True | 200 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", - "| 14 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step_tts/ga_glowTTS_ASR_ffn_x_vector_v2_2ndstep_tts/ce_ls_1.0/ | 20.18 | - | - | - | - | True | True | - | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | unknown | 1 |\n", - "| 15 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector_v2/tts_pretrained/ce_ls_0.01/ | 19.98 | 0.372 | 0.338 | -0.797 | 0.063 | True | False | 0.91 | True | 200 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.01 |\n", - "| 16 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector_v2/tts_pretrained/ce_ls_0.1/ | 20.29 | 0.052 | 0.047 | -0.791 | 0.052 | True | False | 0.9 | True | 200 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", - "| 17 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector_v2/basic_init/ce_ls_0.01/ | 19.97 | 0.341 | 0.308 | -0.787 | 0.064 | True | False | 0.903 | True | 200 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.01 |\n", - "| 18 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector_v2/basic_init/ce_ls_0.1/ | 20.32 | 0.052 | 0.048 | -0.783 | 0.052 | True | False | 0.916 | True | 200 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", - "| 19 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_cnn_x_vector/basic_init/no_specaug/tts_target_size/ce_ls_0.1/ | 27.3 | 2.573 | 2.942 | -0.776 | 0.432 | True | False | 1.143 | True | 200 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", - "| 20 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_cnn_x_vector/tts_pretrained/no_specaug/tts_target_size/ce_ls_0.1/ | 28.92 | 2.564 | 2.893 | -0.793 | 0.396 | True | False | 1.128 | True | 200 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", - "| 21 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/specaug/ce_ls_0.1/ | 26.49 | 2.868 | 2.859 | -0.803 | 0.434 | True | False | 0.997 | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | unknown | 0.1 |\n", - "| 22 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/specaug/ce_ls_1/ | 27.3 | 2.664 | 2.957 | -0.721 | 0.748 | True | False | 1.11 | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | unknown | 1 |\n", - "| 23 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/200ep/basic_init/no_specaug/tts_target_size/ce_ls_0.1/ | 30.09 | 2.782 | 2.796 | -0.785 | 0.891 | True | False | 1.005 | True | 200 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", - "| 24 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/200ep/tts_pretrained/no_specaug/tts_target_size/ce_ls_0.1/ | 28.56 | 2.814 | 2.825 | -0.804 | 0.439 | True | False | 1.004 | True | 200 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", - "| 25 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/no_specaug/ce_ls_0.1/ | 30.44 | 2.793 | 2.791 | -0.795 | 0.506 | True | False | 1.0 | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | unknown | 0.1 |\n", - "| 26 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/no_specaug/ce_ls_1/ | 27.72 | 2.532 | 2.992 | -0.691 | 0.76 | True | False | 1.182 | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | unknown | 1 |\n", - "| 27 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/no_specaug/tts_target_size/ce_ls_1.0/ | 22.24 | 2.923 | 2.924 | -0.801 | 0.835 | True | False | 1.0 | True | 200 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 1 |\n", - "| 28 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/no_specaug/tts_target_size/ce_ls_0.1/ | 22.76 | 2.924 | 2.934 | -0.8 | 0.818 | True | False | 1.004 | True | 200 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", - "| 29 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/200ep/tts_pretrained/no_specaug/tts_target_size/ce_ls_0.1/ | 23.4 | 2.879 | 2.887 | -0.806 | 0.626 | True | False | 1.003 | True | 200 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", - "| 30 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/mean_only/200ep/basic_init/no_specaug/tts_target_size/ce_ls_0.1/ | 22.6 | 2.922 | 2.923 | -0.804 | 0.932 | True | False | 1.0 | True | 200 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", - "| 31 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_blstm_x_vector/specaug/ce_ls_1/ | 35.97 | 1.395 | 2.544 | -0.66 | 0.303 | True | False | 1.824 | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | blstm | 1 |\n", - "| 32 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_blstm_x_vector/specaug/ce_ls_0.1/ | 36.7 | 1.672 | 2.312 | -0.774 | 1.02 | True | False | 1.383 | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | blstm | 0.1 |\n", - "| 33 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_blstm_x_vector/no_specaug/ce_ls_1/ | 34.25 | 1.042 | 3.15 | -0.69 | 0.352 | True | False | 3.023 | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | blstm | 1 |\n", - "| 34 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_blstm_x_vector/no_specaug/ce_ls_0.1/ | 33.05 | 1.031 | 3.339 | -0.786 | 0.368 | True | False | 3.239 | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | blstm | 0.1 |\n" + "| | Group | Experiment | Accuracy [%] | CE | dev CE | MLE | DP | Joint | Still running | overfitting | Training data available | Num Epochs | LR | ASR Model Type | CE loss scale |\n", + "|---:|:--------------------------------|:-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------------:|:------|:---------|:-------|:------|:--------|:----------------|:--------------|:--------------------------|:-------------|:-------------------------------------------------|:-----------------|:----------------|\n", + "| 0 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_simple_encoder_x_vector/200ep/basic_init/no_specaug/tts_target_size/ce_ls_0.1/ | 21.3 | 2.921 | 2.942 | -0.797 | 0.958 | True | False | 1.007 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", + "| 1 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/specaug/ce_ls_0.1/ | 26.49 | 2.868 | 2.859 | -0.803 | 0.434 | True | False | 0.997 | True | 250.0 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | unknown | 0.1 |\n", + "| 2 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/specaug/ce_ls_1/ | 27.3 | 2.664 | 2.957 | -0.721 | 0.748 | True | False | 1.11 | True | 250.0 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | unknown | 1.0 |\n", + "| 3 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/200ep/basic_init/no_specaug/tts_target_size/ce_ls_0.1/ | 30.09 | 2.782 | 2.796 | -0.785 | 0.891 | True | False | 1.005 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", + "| 4 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/200ep/tts_pretrained/no_specaug/tts_target_size/ce_ls_0.1/ | 28.56 | 2.814 | 2.825 | -0.804 | 0.439 | True | False | 1.004 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", + "| 5 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/no_specaug/ce_ls_1/ | 27.72 | 2.532 | 2.992 | -0.691 | 0.76 | True | False | 1.182 | True | 250.0 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | unknown | 1.0 |\n", + "| 6 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/no_specaug/ce_ls_0.1/ | 30.44 | 2.793 | 2.791 | -0.795 | 0.506 | True | False | 1.0 | True | 250.0 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | unknown | 0.1 |\n", + "| 7 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_cnn_x_vector/tts_pretrained/no_specaug/tts_target_size/ce_ls_0.1/ | 28.92 | 2.564 | 2.893 | -0.793 | 0.396 | True | False | 1.128 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", + "| 8 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_cnn_x_vector/basic_init/no_specaug/tts_target_size/ce_ls_0.1/ | 27.3 | 2.573 | 2.942 | -0.776 | 0.432 | True | False | 1.143 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", + "| 9 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/mean_only/200ep/basic_init/no_specaug/tts_target_size/ce_ls_0.1/ | 22.6 | 2.922 | 2.923 | -0.804 | 0.932 | True | False | 1.0 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", + "| 10 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/200ep/tts_pretrained/no_specaug/tts_target_size/ce_ls_0.1/ | 23.4 | 2.879 | 2.887 | -0.806 | 0.626 | True | False | 1.003 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", + "| 11 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/no_specaug/tts_target_size/ce_ls_1.0/ | 22.24 | 2.923 | 2.924 | -0.801 | 0.835 | True | False | 1.0 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 1.0 |\n", + "| 12 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/no_specaug/tts_target_size/ce_ls_0.1/ | 22.76 | 2.924 | 2.934 | -0.8 | 0.818 | True | False | 1.004 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", + "| 13 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_blstm_x_vector/specaug/ce_ls_1/ | 35.97 | 1.395 | 2.544 | -0.66 | 0.303 | True | False | 1.824 | True | 250.0 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | blstm | 1.0 |\n", + "| 14 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_blstm_x_vector/specaug/ce_ls_0.1/ | 36.7 | 1.672 | 2.312 | -0.774 | 1.02 | True | False | 1.383 | True | 250.0 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | blstm | 0.1 |\n", + "| 15 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_blstm_x_vector/no_specaug/ce_ls_1/ | 34.25 | 1.042 | 3.15 | -0.69 | 0.352 | True | False | 3.023 | True | 250.0 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | blstm | 1.0 |\n", + "| 16 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_blstm_x_vector/no_specaug/ce_ls_0.1/ | 33.05 | 1.031 | 3.339 | -0.786 | 0.368 | True | False | 3.239 | True | 250.0 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | blstm | 0.1 |\n", + "| 17 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/first_step/ga_glowTTS_ASR_ffn_x_vector_v2/ce_ls_4.0/ | 28.56 | 0.003 | 0.003 | -0.702 | 0.075 | True | False | 0.948 | True | 100.0 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | unknown | 4.0 |\n", + "| 18 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/first_step/ga_glowTTS_ASR_ffn_x_vector_v2/ce_ls_3.0/ | 20.47 | 0.004 | 0.004 | -0.703 | 0.075 | True | False | 0.954 | True | 100.0 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | unknown | 3.0 |\n", + "| 19 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/first_step/ga_glowTTS_ASR_ffn_x_vector_v2/ce_ls_2.0/ | 20.38 | 0.006 | 0.006 | -0.708 | 0.075 | True | False | 1.018 | True | 100.0 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | unknown | 2.0 |\n", + "| 20 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/first_step/ga_glowTTS_ASR_ffn_x_vector_v2/ce_ls_1.0/ | 20.45 | 0.012 | 0.012 | -0.716 | 0.075 | True | False | 0.98 | True | 100.0 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | unknown | 1.0 |\n", + "| 21 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_mas/100ep/encoder/decoder_eval/ | 37.48 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 22 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_mas/100ep/encoder/encoder_eval/ | 37.57 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 23 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector/100ep/encoder/decoder_eval/ | 12.68 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 24 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector/100ep/encoder/encoder_eval/ | 42.05 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 25 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector/100ep/decoder/encoder_eval/ | 19.16 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 26 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector/100ep/decoder/decoder_eval/ | 19.96 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 27 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn/100ep/encoder/encoder_eval/ | 44.63 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 28 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn/100ep/encoder/decoder_eval/ | 12.24 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 29 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn/100ep/decoder/decoder_eval/ | 19.94 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 30 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn/100ep/decoder/encoder_eval/ | 18.49 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 31 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn_x_vector/100ep/encoder/encoder_eval/ | 70.57 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 32 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn_x_vector/100ep/encoder/decoder_eval/ | 11.4 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 33 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn_x_vector/100ep/decoder/encoder_eval/ | 22.76 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 34 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn_x_vector/100ep/decoder/decoder_eval/ | 21.33 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 35 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector_mas/100ep/encoder/decoder_eval/ | 12.72 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 36 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector_mas/100ep/encoder/encoder_eval/ | 12.68 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 37 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector_mas/100ep/decoder/decoder_eval/ | 12.73 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 38 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector_mas/100ep/decoder/encoder_eval/ | 12.71 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 39 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn/100ep/decoder/decoder_eval/ | 21.3 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 40 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn/100ep/decoder/encoder_eval/ | 22.09 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 41 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn/100ep/encoder/decoder_eval/ | 11.33 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 42 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn/100ep/encoder/encoder_eval/ | 72.13 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 43 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_mas_no_eval/100ep/decoder/decoder_eval/ | 37.64 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 44 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_mas_no_eval/100ep/decoder/encoder_eval/ | 37.46 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 45 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_mas_no_eval/100ep/encoder/decoder_eval/ | 37.51 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 46 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_mas_no_eval/100ep/encoder/encoder_eval/ | 37.56 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 47 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector_v2/tts_pretrained/ce_ls_0.1/ | 20.29 | 0.052 | 0.047 | -0.791 | 0.052 | True | False | 0.9 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", + "| 48 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector_v2/tts_pretrained/ce_ls_0.01/ | 19.98 | 0.372 | 0.338 | -0.797 | 0.063 | True | False | 0.91 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.01 |\n", + "| 49 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector_v2/basic_init/ce_ls_0.1/ | 20.32 | 0.052 | 0.048 | -0.783 | 0.052 | True | False | 0.916 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", + "| 50 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector_v2/basic_init/ce_ls_0.01/ | 19.97 | 0.341 | 0.308 | -0.787 | 0.064 | True | False | 0.903 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.01 |\n", + "| 51 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step_tts/ga_glowTTS_ASR_ffn_x_vector_v2_2ndstep_tts/ce_ls_1.0/ | 20.18 | - | - | - | - | True | True | - | True | 100.0 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | unknown | 1.0 |\n", + "| 52 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector_v2/200ep/tts_pretrained/ce_ls_1.0/ | 20.42 | 0.014 | 0.014 | -0.729 | 0.076 | True | False | 1.049 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 1.0 |\n", + "| 53 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector_v2/200ep/tts_pretrained/ce_ls_0.1/ | 20.22 | 0.14 | 0.14 | -0.76 | 0.075 | True | False | 0.995 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", + "| 54 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/ce_ls_1.0/ | 20.48 | 0.012 | 0.011 | -0.73 | 0.07 | True | False | 0.965 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 1.0 |\n", + "| 55 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/ce_ls_0.1/ | 20.71 | 0.124 | 0.122 | -0.757 | 0.071 | True | False | 0.983 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", + "| 56 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector/200ep/basic_init/ce_ls_0.1/ | 21.39 | 2.921 | 2.947 | -0.779 | 0.256 | True | False | 1.009 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", + "| 57 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector/200ep/tts_pretrained/ce_ls_0.1/ | 21.33 | 2.925 | 2.946 | -0.792 | 0.247 | True | False | 1.007 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", + "| 58 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector/tts_pretrained/ce_ls_0.1/ | 27.63 | 2.617 | 2.915 | -0.775 | 0.263 | True | False | 1.114 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", + "| 59 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector/basic_init/ce_ls_0.1/ | 25.67 | 2.583 | 3.019 | -0.767 | 0.265 | True | False | 1.169 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", + "| 60 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step/ga_glowTTS_ASR_ffn_x_vector_v2_2ndstep/ce_ls_1.0/ | 21.61 | 2.939 | 2.947 | - | - | False | False | 1.003 | True | 100.0 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | unknown | 1.0 |\n" ] } ], "source": [ "print(df_rounded.to_markdown())" ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "ename": "KeyError", - "evalue": "False", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", - "File \u001b[0;32m/work/tools22/users/lukas.rilling/sis_env/lib/python3.10/site-packages/pandas/core/indexes/base.py:3790\u001b[0m, in \u001b[0;36mIndex.get_loc\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m 3789\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m-> 3790\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_engine\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget_loc\u001b[49m\u001b[43m(\u001b[49m\u001b[43mcasted_key\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 3791\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mKeyError\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m err:\n", - "File \u001b[0;32mindex.pyx:152\u001b[0m, in \u001b[0;36mpandas._libs.index.IndexEngine.get_loc\u001b[0;34m()\u001b[0m\n", - "File \u001b[0;32mindex.pyx:181\u001b[0m, in \u001b[0;36mpandas._libs.index.IndexEngine.get_loc\u001b[0;34m()\u001b[0m\n", - "File \u001b[0;32mpandas/_libs/hashtable_class_helper.pxi:7080\u001b[0m, in \u001b[0;36mpandas._libs.hashtable.PyObjectHashTable.get_item\u001b[0;34m()\u001b[0m\n", - "File \u001b[0;32mpandas/_libs/hashtable_class_helper.pxi:7088\u001b[0m, in \u001b[0;36mpandas._libs.hashtable.PyObjectHashTable.get_item\u001b[0;34m()\u001b[0m\n", - "\u001b[0;31mKeyError\u001b[0m: False", - "\nThe above exception was the direct cause of the following exception:\n", - "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[28], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[43mdf_tuned\u001b[49m\u001b[43m[\u001b[49m\u001b[43mdf_tuned\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mJoint\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01mis\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m]\u001b[49m\u001b[38;5;241m.\u001b[39mto_markdown())\n", - "File \u001b[0;32m/work/tools22/users/lukas.rilling/sis_env/lib/python3.10/site-packages/pandas/core/frame.py:3896\u001b[0m, in \u001b[0;36mDataFrame.__getitem__\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m 3894\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mcolumns\u001b[38;5;241m.\u001b[39mnlevels \u001b[38;5;241m>\u001b[39m \u001b[38;5;241m1\u001b[39m:\n\u001b[1;32m 3895\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_getitem_multilevel(key)\n\u001b[0;32m-> 3896\u001b[0m indexer \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcolumns\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget_loc\u001b[49m\u001b[43m(\u001b[49m\u001b[43mkey\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 3897\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m is_integer(indexer):\n\u001b[1;32m 3898\u001b[0m indexer \u001b[38;5;241m=\u001b[39m [indexer]\n", - "File \u001b[0;32m/work/tools22/users/lukas.rilling/sis_env/lib/python3.10/site-packages/pandas/core/indexes/base.py:3797\u001b[0m, in \u001b[0;36mIndex.get_loc\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m 3792\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(casted_key, \u001b[38;5;28mslice\u001b[39m) \u001b[38;5;129;01mor\u001b[39;00m (\n\u001b[1;32m 3793\u001b[0m \u001b[38;5;28misinstance\u001b[39m(casted_key, abc\u001b[38;5;241m.\u001b[39mIterable)\n\u001b[1;32m 3794\u001b[0m \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28many\u001b[39m(\u001b[38;5;28misinstance\u001b[39m(x, \u001b[38;5;28mslice\u001b[39m) \u001b[38;5;28;01mfor\u001b[39;00m x \u001b[38;5;129;01min\u001b[39;00m casted_key)\n\u001b[1;32m 3795\u001b[0m ):\n\u001b[1;32m 3796\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m InvalidIndexError(key)\n\u001b[0;32m-> 3797\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mKeyError\u001b[39;00m(key) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01merr\u001b[39;00m\n\u001b[1;32m 3798\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m:\n\u001b[1;32m 3799\u001b[0m \u001b[38;5;66;03m# If we have a listlike key, _check_indexing_error will raise\u001b[39;00m\n\u001b[1;32m 3800\u001b[0m \u001b[38;5;66;03m# InvalidIndexError. Otherwise we fall through and re-raise\u001b[39;00m\n\u001b[1;32m 3801\u001b[0m \u001b[38;5;66;03m# the TypeError.\u001b[39;00m\n\u001b[1;32m 3802\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_check_indexing_error(key)\n", - "\u001b[0;31mKeyError\u001b[0m: False" - ] - } - ], - "source": [ - "print(df_tuned[df_tuned[\"Joint\"]].to_markdown())" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 29, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "df_tuned.plot(kind=\"scatter\", x=\"WER (dev-other)\", y=\"CTC\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 30, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "df_tuned.plot(kind=\"scatter\", x=\"WER (dev-other)\", y=\"dev CTC\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 31, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "df_tuned[df_tuned[\"overfitting\"] < 100].plot(kind=\"scatter\", x=\"WER (dev-other)\", y=\"overfitting\")" - ] } ], "metadata": { @@ -933,7 +831,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.12" + "version": "3.10.13" } }, "nbformat": 4, diff --git a/users/rilling/evaluation/swer_eval.ipynb b/users/rilling/evaluation/swer_eval.ipynb index 24acd6f0c..9122f2655 100644 --- a/users/rilling/evaluation/swer_eval.ipynb +++ b/users/rilling/evaluation/swer_eval.ipynb @@ -2,18 +2,9 @@ "cells": [ { "cell_type": "code", - "execution_count": 35, + "execution_count": 1, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The autoreload extension is already loaded. To reload it, use:\n", - " %reload_ext autoreload\n" - ] - } - ], + "outputs": [], "source": [ "import glob\n", "import sys\n", @@ -29,104 +20,106 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 2, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "['/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_x_vector_v2/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + "['/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_100ep_pe1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_two_forward_pass/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_x_vector_v2/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_100ep_pe1_radam1e-9/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_100ep_pe1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_x_vector/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_ASR_conformer_two_forward_pass/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_100ep_pe1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_x_vector/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_ASR_conformer_x_vector/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_100ep_pe1_radam1e-9/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_ctc_scale_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_ctc_scale_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_ctc_scale_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2_multiscale/enc768/200ep/dec_drop_0.05/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector/enc768/100ep/dec_drop_0.05/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2_logdist_loss_grad_clip_10/ed_scale_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2_logdist_loss_grad_clip_10/ed_scale_1.0/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_simple_encoder/12cb/200ep/dec_drop_0.05/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_simple_encoder/20cb/200ep/dec_drop_0.05/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_batch_norm/enc768/200ep/dec_drop_0.05/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2_conformer_coupling/enc768/200ep/dec_drop_0.05/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc192/100ep/dec_drop_0.05/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/400ep/dec_drop_0.05/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/200ep/dec_drop_0.0/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/200ep/dec_drop_0.05/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/100ep/dec_drop_0.05/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/200ep_long_cooldown/dec_drop_0.0/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/200ep_long_cooldown/dec_drop_0.05/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc192/200ep/dec_drop_0.05/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc192/200ep/dec_drop_0.0/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc192/200ep/dec_drop_0.05_epsilon_1e-8/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc192/200ep/dec_drop_0.05/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc192/200ep/dec_drop_0.0/grad_clip_10/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc192/100ep/dec_drop_0.05/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/400ep/grad_clip_10/dec_drop_0.05/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/200ep/dec_drop_0.0/epsilon_1e-8/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/200ep/dec_drop_0.0/grad_clip_10/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/200ep/dec_drop_0.05_epsilon_1e-8/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/200ep/dec_drop_0.0_epsilon_1e-8/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/200ep/dec_drop_0.05/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/200ep/dec_drop_0.0/epsilon_1e-8/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/400ep/grad_clip_10/dec_drop_0.05/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/100ep/dec_drop_0.05/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/100ep/dec_drop_0.00/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/100ep/dec_drop_0.05/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2_logdist_loss/ed_scale_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc192/200ep/dec_drop_0.0/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc192/200ep/dec_drop_0.05/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/100ep/dec_drop_0.05/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/200ep/dec_drop_0.0/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/200ep/dec_drop_0.05/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/200ep_long_cooldown/dec_drop_0.0/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/200ep_long_cooldown/dec_drop_0.05/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/400ep/dec_drop_0.05/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/mean_only/200ep/basic_init/no_specaug/tts_target_size/ce_ls_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/200ep/tts_pretrained/no_specaug/tts_target_size/ce_ls_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/no_specaug/tts_target_size/ce_ls_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/no_specaug/tts_target_size/ce_ls_1.0/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_cnn_x_vector/tts_pretrained/no_specaug/tts_target_size/ce_ls_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_cnn_x_vector/basic_init/no_specaug/tts_target_size/ce_ls_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/200ep/basic_init/no_specaug/tts_target_size/ce_ls_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/200ep/tts_pretrained/no_specaug/tts_target_size/ce_ls_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2_logdist_loss_grad_clip_10/ed_scale_1.0/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2_logdist_loss_grad_clip_10/ed_scale_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_simple_encoder/12cb/200ep/dec_drop_0.05/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_simple_encoder/20cb/200ep/dec_drop_0.05/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2_conformer_coupling/enc768/200ep/dec_drop_0.05/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2_multiscale/enc768/200ep/dec_drop_0.05/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_batch_norm/enc768/200ep/dec_drop_0.05/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector/enc768/100ep/dec_drop_0.05/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/specaug/ce_ls_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/specaug/ce_ls_1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/no_specaug/ce_ls_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/200ep/basic_init/no_specaug/tts_target_size/ce_ls_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/200ep/tts_pretrained/no_specaug/tts_target_size/ce_ls_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/no_specaug/ce_ls_1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector/basic_init/ce_ls_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector/tts_pretrained/ce_ls_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector/200ep/tts_pretrained/ce_ls_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector/200ep/basic_init/ce_ls_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector_v2/basic_init/ce_ls_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector_v2/basic_init/ce_ls_0.01/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/no_specaug/ce_ls_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_cnn_x_vector/tts_pretrained/no_specaug/tts_target_size/ce_ls_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_cnn_x_vector/basic_init/no_specaug/tts_target_size/ce_ls_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/mean_only/200ep/basic_init/no_specaug/tts_target_size/ce_ls_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/200ep/tts_pretrained/no_specaug/tts_target_size/ce_ls_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/no_specaug/tts_target_size/ce_ls_1.0/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/no_specaug/tts_target_size/ce_ls_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector_v2/tts_pretrained/ce_ls_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector_v2/tts_pretrained/ce_ls_0.01/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector_v2/200ep/tts_pretrained/ce_ls_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector_v2/basic_init/ce_ls_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector_v2/basic_init/ce_ls_0.01/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector_v2/200ep/tts_pretrained/ce_ls_1.0/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector_v2/200ep/tts_pretrained/ce_ls_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/ce_ls_1.0/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/ce_ls_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS_x_vector/enc192/100ep/not_silence_preprocessed/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS_x_vector/enc768/100ep/not_silence_preprocessed/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS_nar_taco_encoder/not_silence_preprocessed/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS_nar_taco_encoder/silence_preprocessed/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS_nar_taco_encoder_no_blstm/silence_preprocessed/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS_ddi_actnorm/enc192/100ep/not_silence_preprocessed/LR_scheduled/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS/enc192/200ep/long_cooldown/not_silence_preprocessed/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS/enc192/200ep/long_cooldown/silence_preprocessed/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS/enc192/100ep/not_silence_preprocessed/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS/enc192/100ep/silence_preprocessed/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector/200ep/basic_init/ce_ls_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector/200ep/tts_pretrained/ce_ls_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector/tts_pretrained/ce_ls_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector/basic_init/ce_ls_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS/enc256/not_silence_preprocessed/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS/enc768/with_sigma/not_silence_preprocessed/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS/enc768/with_sigma/silence_preprocessed/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS/enc768/mean_only/not_silence_preprocessed/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS/enc768/mean_only/silence_preprocessed/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS/enc256/not_silence_preprocessed/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS_simple_encoder/silence_preprocessed/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer']" + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS/enc768/mean_only/not_silence_preprocessed/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS/enc192/100ep/not_silence_preprocessed/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS/enc192/100ep/silence_preprocessed/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS/enc192/200ep/long_cooldown/not_silence_preprocessed/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS/enc192/200ep/long_cooldown/silence_preprocessed/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS_simple_encoder/silence_preprocessed/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS_ddi_actnorm/enc192/100ep/not_silence_preprocessed/LR_scheduled/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS_x_vector/enc768/100ep/not_silence_preprocessed/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS_x_vector/enc192/100ep/not_silence_preprocessed/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS_nar_taco_encoder/not_silence_preprocessed/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS_nar_taco_encoder/silence_preprocessed/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS_nar_taco_encoder_no_blstm/silence_preprocessed/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer']" ] }, - "execution_count": 36, + "execution_count": 2, "metadata": {}, "output_type": "execute_result" } @@ -147,16 +140,23 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 3, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:root:Settings file 'settings.py' does not exist, ignoring it ([Errno 2] No such file or directory: 'settings.py').\n" + ] + }, { "data": { "text/plain": [ - "'250'" + "'100'" ] }, - "execution_count": 37, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } @@ -178,93 +178,16 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{'frontend_config': {'in_features': 80,\n", - " 'conv1_channels': 16,\n", - " 'conv2_channels': 16,\n", - " 'conv3_channels': 16,\n", - " 'conv4_channels': 16,\n", - " 'conv_kernel_size': (3, 3),\n", - " 'conv_padding': None,\n", - " 'pool1_kernel_size': (2, 1),\n", - " 'pool1_stride': (2, 1),\n", - " 'pool1_padding': None,\n", - " 'pool2_kernel_size': (2, 1),\n", - " 'pool2_stride': (2, 1),\n", - " 'pool2_padding': None,\n", - " 'activation': None,\n", - " 'out_features': 96,\n", - " 'activation_str': 'ReLU'},\n", - " 'specaug_config': {'repeat_per_n_frames': 100,\n", - " 'max_dim_time': 20,\n", - " 'num_repeat_feat': 5,\n", - " 'max_dim_feat': 8},\n", - " 'decoder_config': {'hidden_channels': 192,\n", - " 'kernel_size': 5,\n", - " 'dilation_rate': 1,\n", - " 'n_blocks': 12,\n", - " 'n_layers': 4,\n", - " 'p_dropout': 0.05,\n", - " 'n_split': 4,\n", - " 'n_sqz': 2,\n", - " 'sigmoid_scale': False,\n", - " 'ddi': True,\n", - " 'n_heads': 2},\n", - " 'text_encoder_config': {'n_vocab': 44,\n", - " 'hidden_channels': 192,\n", - " 'filter_channels': 768,\n", - " 'filter_channels_dp': 256,\n", - " 'n_heads': 2,\n", - " 'n_layers': 6,\n", - " 'kernel_size': 3,\n", - " 'p_dropout': 0.1,\n", - " 'window_size': 4,\n", - " 'block_length': None,\n", - " 'mean_only': False,\n", - " 'prenet': True},\n", - " 'conformer_asr_encoder_config': {'conformer_size': 96,\n", - " 'ff_dim': 384,\n", - " 'ff_dropout': 0.2,\n", - " 'num_heads': 2,\n", - " 'att_weights_dropout': 0.2,\n", - " 'mhsa_dropout': 0.2,\n", - " 'kernel_size': 9,\n", - " 'conv_dropout': 0.2,\n", - " 'num_layers': 8},\n", - " 'out_channels': 80,\n", - " 'gin_channels': 512,\n", - " 'final_dropout': 0.2,\n", - " 'label_target_size': 79,\n", - " 'specaug_start_epoch': 1,\n", - " 'n_speakers': 251}" + "(91, 91, 91, 91, 91, 91, 91, 91)" ] }, - "execution_count": 38, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "eval(returnn_configs[0].value(\"model_kwargs\", \"default\"))[\"model_config\"]" - ] - }, - { - "cell_type": "code", - "execution_count": 39, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(89, 89, 89, 89, 89, 89, 89, 89)" - ] - }, - "execution_count": 39, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -277,6 +200,7 @@ "experiment_group = []\n", "wers = []\n", "nisqas = []\n", + "nisqa_confidence =[]\n", "encoder_channels = []\n", "num_epochs = []\n", "dec_dropout = []\n", @@ -289,12 +213,19 @@ " wers.append(float(ff.readline().replace(\"\\n\", \"\")))\n", "\n", " mos_path = f.replace(wer_subdir, \"tts_eval_gl/test-clean/nisqa_mos/average\")\n", - " breakpoint()\n", " if os.path.exists(mos_path):\n", " with open(mos_path, \"r\") as fmos:\n", " nisqas.append(float(fmos.readline().replace(\"\\n\", \"\")))\n", " else:\n", " nisqas.append(None)\n", + "\n", + " mos_conf_path = f.replace(wer_subdir, \"tts_eval_gl/test-clean/nisqa_mos/confidence_max_interval\")\n", + " if os.path.exists(mos_conf_path):\n", + " with open(mos_conf_path, \"r\") as fmos:\n", + " nisqa_confidence.append(float(fmos.readline().replace(\"\\n\", \"\")))\n", + " else:\n", + " nisqa_confidence.append(None)\n", + "\n", " folders = [\"librispeech_glow_asr\", \"joint_training/default\", \"joint_training/conformer_coupling\", \"joint_training/given_alignments\", \"tts_architecture\"]\n", " found = False\n", " for folder in folders:\n", @@ -373,7 +304,7 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 16, "metadata": {}, "outputs": [ { @@ -400,6 +331,7 @@ " \n", " sWER\n", " autoMOS\n", + " autoMOS confidence\n", " num_epochs\n", " decoder dropout\n", " mean only\n", @@ -418,25 +350,28 @@ " \n", " \n", " \n", + " \n", " \n", " \n", " \n", " \n", " joint_training/conformer_coupling\n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_x_vector_v2/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer\n", - " 5.2\n", - " 2.136262\n", - " 250\n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_100ep_pe1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer\n", + " 12.4\n", + " 2.936271\n", + " NaN\n", + " 100\n", " 0.05\n", " False\n", " 768\n", - " [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08]\n", + " [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05]\n", " {'class': 'adam', 'epsilon': 1e-08}\n", " \n", " \n", " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_two_forward_pass/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer\n", " 20.9\n", " 2.449569\n", + " NaN\n", " 250\n", " 0.05\n", " False\n", @@ -445,9 +380,10 @@ " {'class': 'adam', 'epsilon': 1e-08}\n", " \n", " \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer\n", - " 97.7\n", - " 1.611414\n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_x_vector_v2/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer\n", + " 5.2\n", + " 2.136262\n", + " NaN\n", " 250\n", " 0.05\n", " False\n", @@ -456,25 +392,27 @@ " {'class': 'adam', 'epsilon': 1e-08}\n", " \n", " \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_x_vector/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer\n", - " 99.5\n", - " 1.933423\n", - " 250\n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_100ep_pe1_radam1e-9/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer\n", + " 14.7\n", + " 2.588368\n", + " NaN\n", + " 100\n", " 0.05\n", " False\n", " 768\n", - " [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08]\n", - " {'class': 'adam', 'epsilon': 1e-08}\n", + " [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05]\n", + " {'class': 'radam', 'epsilon': 1e-09}\n", " \n", " \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_ASR_conformer_two_forward_pass/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer\n", - " 95.7\n", - " 1.824994\n", - " 250\n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_100ep_pe1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer\n", + " 14.4\n", + " 2.718031\n", + " NaN\n", + " 100\n", " 0.05\n", " False\n", " 768\n", - " [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08]\n", + " [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05]\n", " {'class': 'adam', 'epsilon': 1e-08}\n", " \n", " \n", @@ -488,107 +426,127 @@ " ...\n", " ...\n", " ...\n", + " ...\n", " \n", " \n", " tts_architecture\n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS/enc768/with_sigma/silence_preprocessed/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer\n", - " 15.3\n", - " 3.404880\n", - " 200\n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS_x_vector/enc768/100ep/not_silence_preprocessed/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer\n", + " 20.9\n", + " 3.312732\n", + " NaN\n", + " 100\n", " 0.00\n", " False\n", " 768\n", - " [0: 5e-05, 49: 0.0005, 50: 0.0005, 200: 1e-06]\n", + " [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05]\n", " {'class': 'adam', 'epsilon': 1e-09}\n", " \n", " \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS/enc768/mean_only/not_silence_preprocessed/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer\n", - " 15.5\n", - " 3.469905\n", - " 200\n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS_x_vector/enc192/100ep/not_silence_preprocessed/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer\n", + " 95.4\n", + " 2.633865\n", + " NaN\n", + " 100\n", " 0.00\n", - " True\n", - " 768\n", - " [0: 5e-05, 49: 0.0005, 50: 0.0005, 200: 1e-06]\n", + " False\n", + " 192\n", + " [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05]\n", " {'class': 'adam', 'epsilon': 1e-09}\n", " \n", " \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS/enc768/mean_only/silence_preprocessed/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer\n", - " 16.9\n", - " 3.515657\n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS_nar_taco_encoder/not_silence_preprocessed/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer\n", + " 25.2\n", + " 3.463099\n", + " NaN\n", " 200\n", " 0.00\n", - " True\n", - " 768\n", - " [0: 5e-05, 49: 0.0005, 50: 0.0005, 200: 1e-06]\n", + " -\n", + " -\n", + " [0: 1e-05, 49: 0.0005, 50: 0.0005, 200: 1e-05]\n", " {'class': 'adam', 'epsilon': 1e-09}\n", " \n", " \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS/enc256/not_silence_preprocessed/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer\n", - " 97.9\n", - " 1.694847\n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS_nar_taco_encoder/silence_preprocessed/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer\n", + " 25.9\n", + " 3.391651\n", + " NaN\n", " 200\n", " 0.00\n", - " False\n", - " 256\n", - " [0: 5e-05, 49: 0.0005, 50: 0.0005, 200: 1e-06]\n", + " -\n", + " -\n", + " [0: 1e-05, 49: 0.0005, 50: 0.0005, 200: 1e-05]\n", " {'class': 'adam', 'epsilon': 1e-09}\n", " \n", " \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS_simple_encoder/silence_preprocessed/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer\n", - " 56.4\n", - " 3.333580\n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS_nar_taco_encoder_no_blstm/silence_preprocessed/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer\n", + " 105.6\n", + " 3.165388\n", + " NaN\n", " 100\n", " 0.00\n", " -\n", " -\n", - " [0: 0.0001, 49: 0.0005, 50: 0.0005, 100: 1e-06]\n", + " [0: 0.0001, 49: 0.0005, 50: 0.0001, 100: 1e-06]\n", " {'class': 'radam', 'epsilon': 1e-09}\n", " \n", " \n", "\n", - "

89 rows × 8 columns

\n", + "

91 rows × 9 columns

\n", "" ], "text/plain": [ - " sWER \\\n", - "Group Experiment \n", - "joint_training/conformer_coupling /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 5.2 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 20.9 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 97.7 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 99.5 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 95.7 \n", - "... ... \n", - "tts_architecture /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 15.3 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 15.5 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 16.9 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 97.9 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 56.4 \n", + " sWER \\\n", + "Group Experiment \n", + "joint_training/conformer_coupling /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 12.4 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 20.9 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 5.2 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 14.7 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 14.4 \n", + "... ... \n", + "tts_architecture /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 20.9 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 95.4 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 25.2 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 25.9 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 105.6 \n", "\n", " autoMOS \\\n", "Group Experiment \n", - "joint_training/conformer_coupling /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 2.136262 \n", + "joint_training/conformer_coupling /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 2.936271 \n", " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 2.449569 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 1.611414 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 1.933423 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 1.824994 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 2.136262 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 2.588368 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 2.718031 \n", "... ... \n", - "tts_architecture /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 3.404880 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 3.469905 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 3.515657 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 1.694847 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 3.333580 \n", + "tts_architecture /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 3.312732 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 2.633865 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 3.463099 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 3.391651 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 3.165388 \n", + "\n", + " autoMOS confidence \\\n", + "Group Experiment \n", + "joint_training/conformer_coupling /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... NaN \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... NaN \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... NaN \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... NaN \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... NaN \n", + "... ... \n", + "tts_architecture /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... NaN \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... NaN \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... NaN \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... NaN \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... NaN \n", "\n", " num_epochs \\\n", "Group Experiment \n", - "joint_training/conformer_coupling /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 250 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 250 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 250 \n", + "joint_training/conformer_coupling /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 100 \n", " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 250 \n", " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 250 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 100 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 100 \n", "... ... \n", - "tts_architecture /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 200 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 200 \n", + "tts_architecture /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 100 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 100 \n", " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 200 \n", " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 200 \n", " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 100 \n", @@ -616,10 +574,10 @@ " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False \n", "... ... \n", "tts_architecture /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... True \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... True \n", " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False \n", " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... - \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... - \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... - \n", "\n", " encoder channels \\\n", "Group Experiment \n", @@ -630,31 +588,31 @@ " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 768 \n", "... ... \n", "tts_architecture /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 768 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 768 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 768 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 256 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 192 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... - \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... - \n", " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... - \n", "\n", " LR \\\n", "Group Experiment \n", - "joint_training/conformer_coupling /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] \n", + "joint_training/conformer_coupling /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] \n", " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] \n", " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] \n", "... ... \n", - "tts_architecture /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... [0: 5e-05, 49: 0.0005, 50: 0.0005, 200: 1e-06] \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... [0: 5e-05, 49: 0.0005, 50: 0.0005, 200: 1e-06] \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... [0: 5e-05, 49: 0.0005, 50: 0.0005, 200: 1e-06] \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... [0: 5e-05, 49: 0.0005, 50: 0.0005, 200: 1e-06] \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... [0: 0.0001, 49: 0.0005, 50: 0.0005, 100: 1e-06] \n", + "tts_architecture /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... [0: 1e-05, 49: 0.0005, 50: 0.0005, 200: 1e-05] \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... [0: 1e-05, 49: 0.0005, 50: 0.0005, 200: 1e-05] \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... [0: 0.0001, 49: 0.0005, 50: 0.0001, 100: 1e-06] \n", "\n", " Optimizer \n", "Group Experiment \n", "joint_training/conformer_coupling /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... {'class': 'adam', 'epsilon': 1e-08} \n", " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... {'class': 'adam', 'epsilon': 1e-08} \n", " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... {'class': 'adam', 'epsilon': 1e-08} \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... {'class': 'adam', 'epsilon': 1e-08} \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... {'class': 'radam', 'epsilon': 1e-09} \n", " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... {'class': 'adam', 'epsilon': 1e-08} \n", "... ... \n", "tts_architecture /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... {'class': 'adam', 'epsilon': 1e-09} \n", @@ -663,10 +621,10 @@ " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... {'class': 'adam', 'epsilon': 1e-09} \n", " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... {'class': 'radam', 'epsilon': 1e-09} \n", "\n", - "[89 rows x 8 columns]" + "[91 rows x 9 columns]" ] }, - "execution_count": 40, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" } @@ -676,14 +634,14 @@ "\n", "index = pd.MultiIndex.from_arrays([experiment_group, wer_files], names=(\"Group\", \"Experiment\"))\n", "\n", - "df = pd.DataFrame({\"sWER\": wers, \"autoMOS\": nisqas, \"num_epochs\": num_epochs, \"decoder dropout\": dec_dropout, \"mean only\": mean_only, \"encoder channels\": encoder_channels, \"LR\": lr, \"Optimizer\": optimizer}, index=index)\n", + "df = pd.DataFrame({\"sWER\": wers, \"autoMOS\": nisqas, \"autoMOS confidence\": nisqa_confidence, \"num_epochs\": num_epochs, \"decoder dropout\": dec_dropout, \"mean only\": mean_only, \"encoder channels\": encoder_channels, \"LR\": lr, \"Optimizer\": optimizer}, index=index)\n", "\n", "df" ] }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 17, "metadata": {}, "outputs": [ { @@ -710,6 +668,7 @@ " \n", " sWER\n", " autoMOS\n", + " autoMOS confidence\n", " num_epochs\n", " decoder dropout\n", " mean only\n", @@ -742,32 +701,35 @@ " \n", " \n", " \n", + " \n", " \n", " \n", " \n", " \n", " joint_training/conformer_coupling\n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_x_vector_v2/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer\n", - " 5.2\n", - " 2.136262\n", - " 250\n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_100ep_pe1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer\n", + " 12.4\n", + " 2.936271\n", + " NaN\n", + " 100\n", " 0.05\n", " False\n", " 768\n", - " [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08]\n", + " [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05]\n", " {'class': 'adam', 'epsilon': 1e-08}\n", - " -0.453089\n", - " -0.401680\n", - " -0.465325\n", - " 0.246206\n", - " 0.344511\n", - " 0.229336\n", - " True\n", + " -0.826781\n", + " -0.846025\n", + " NaN\n", + " 0.382039\n", + " 0.353906\n", + " NaN\n", + " False\n", " \n", " \n", " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_two_forward_pass/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer\n", " 20.9\n", " 2.449569\n", + " NaN\n", " 250\n", " 0.05\n", " False\n", @@ -783,58 +745,61 @@ " True\n", " \n", " \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer\n", - " 97.7\n", - " 1.611414\n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_x_vector_v2/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer\n", + " 5.2\n", + " 2.136262\n", + " NaN\n", " 250\n", " 0.05\n", " False\n", " 768\n", " [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08]\n", " {'class': 'adam', 'epsilon': 1e-08}\n", - " -0.824271\n", - " -0.830326\n", - " NaN\n", - " 0.964433\n", - " 0.725438\n", - " NaN\n", - " False\n", + " -0.453089\n", + " -0.401680\n", + " -0.465325\n", + " 0.246206\n", + " 0.344511\n", + " 0.229336\n", + " True\n", " \n", " \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_x_vector/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer\n", - " 99.5\n", - " 1.933423\n", - " 250\n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_100ep_pe1_radam1e-9/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer\n", + " 14.7\n", + " 2.588368\n", + " NaN\n", + " 100\n", " 0.05\n", " False\n", " 768\n", - " [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08]\n", - " {'class': 'adam', 'epsilon': 1e-08}\n", - " -0.809305\n", - " -0.755239\n", - " -0.813211\n", - " 1.001979\n", - " 1.077792\n", - " 1.042415\n", + " [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05]\n", + " {'class': 'radam', 'epsilon': 1e-09}\n", + " -0.825730\n", + " -0.844433\n", + " NaN\n", + " 0.384814\n", + " 0.355806\n", + " NaN\n", " False\n", " \n", " \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_ASR_conformer_two_forward_pass/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer\n", - " 95.7\n", - " 1.824994\n", - " 250\n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_100ep_pe1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer\n", + " 14.4\n", + " 2.718031\n", + " NaN\n", + " 100\n", " 0.05\n", " False\n", " 768\n", - " [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08]\n", + " [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05]\n", " {'class': 'adam', 'epsilon': 1e-08}\n", - " -0.657168\n", + " -0.825686\n", + " -0.844577\n", " NaN\n", - " -0.670671\n", - " 1.004604\n", + " 0.389056\n", + " 0.360854\n", " NaN\n", - " 2.091343\n", - " True\n", + " False\n", " \n", " \n", "\n", @@ -843,27 +808,35 @@ "text/plain": [ " sWER \\\n", "Group Experiment \n", - "joint_training/conformer_coupling /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 5.2 \n", + "joint_training/conformer_coupling /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 12.4 \n", " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 20.9 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 97.7 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 99.5 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 95.7 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 5.2 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 14.7 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 14.4 \n", "\n", " autoMOS \\\n", "Group Experiment \n", - "joint_training/conformer_coupling /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 2.136262 \n", + "joint_training/conformer_coupling /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 2.936271 \n", " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 2.449569 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 1.611414 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 1.933423 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 1.824994 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 2.136262 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 2.588368 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 2.718031 \n", + "\n", + " autoMOS confidence \\\n", + "Group Experiment \n", + "joint_training/conformer_coupling /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... NaN \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... NaN \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... NaN \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... NaN \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... NaN \n", "\n", " num_epochs \\\n", "Group Experiment \n", - "joint_training/conformer_coupling /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 250 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 250 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 250 \n", + "joint_training/conformer_coupling /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 100 \n", " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 250 \n", " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 250 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 100 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 100 \n", "\n", " decoder dropout \\\n", "Group Experiment \n", @@ -891,78 +864,78 @@ "\n", " LR \\\n", "Group Experiment \n", - "joint_training/conformer_coupling /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] \n", + "joint_training/conformer_coupling /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] \n", " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] \n", " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] \n", "\n", - " Optimizer \\\n", - "Group Experiment \n", - "joint_training/conformer_coupling /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... {'class': 'adam', 'epsilon': 1e-08} \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... {'class': 'adam', 'epsilon': 1e-08} \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... {'class': 'adam', 'epsilon': 1e-08} \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... {'class': 'adam', 'epsilon': 1e-08} \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... {'class': 'adam', 'epsilon': 1e-08} \n", + " Optimizer \\\n", + "Group Experiment \n", + "joint_training/conformer_coupling /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... {'class': 'adam', 'epsilon': 1e-08} \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... {'class': 'adam', 'epsilon': 1e-08} \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... {'class': 'adam', 'epsilon': 1e-08} \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... {'class': 'radam', 'epsilon': 1e-09} \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... {'class': 'adam', 'epsilon': 1e-08} \n", "\n", " MLE \\\n", "Group Experiment \n", - "joint_training/conformer_coupling /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.453089 \n", + "joint_training/conformer_coupling /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.826781 \n", " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.672552 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.824271 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.809305 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.657168 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.453089 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.825730 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.825686 \n", "\n", " dev MLE \\\n", "Group Experiment \n", - "joint_training/conformer_coupling /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.401680 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... NaN \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.830326 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.755239 \n", + "joint_training/conformer_coupling /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.846025 \n", " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... NaN \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.401680 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.844433 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.844577 \n", "\n", " devtrain MLE \\\n", "Group Experiment \n", - "joint_training/conformer_coupling /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.465325 \n", + "joint_training/conformer_coupling /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... NaN \n", " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.692025 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.465325 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... NaN \n", " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... NaN \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.813211 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.670671 \n", "\n", " DP loss \\\n", "Group Experiment \n", - "joint_training/conformer_coupling /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.246206 \n", + "joint_training/conformer_coupling /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.382039 \n", " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.444391 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.964433 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 1.001979 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 1.004604 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.246206 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.384814 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.389056 \n", "\n", " DP dev loss \\\n", "Group Experiment \n", - "joint_training/conformer_coupling /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.344511 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... NaN \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.725438 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 1.077792 \n", + "joint_training/conformer_coupling /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.353906 \n", " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... NaN \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.344511 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.355806 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.360854 \n", "\n", " DP devtrain loss \\\n", "Group Experiment \n", - "joint_training/conformer_coupling /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.229336 \n", + "joint_training/conformer_coupling /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... NaN \n", " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.412498 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.229336 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... NaN \n", " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... NaN \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 1.042415 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 2.091343 \n", "\n", " Joint \n", "Group Experiment \n", - "joint_training/conformer_coupling /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... True \n", + "joint_training/conformer_coupling /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... True \n", " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... True \n", " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... True " + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False " ] }, - "execution_count": 41, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } @@ -1023,7 +996,7 @@ }, { "cell_type": "code", - "execution_count": 42, + "execution_count": 18, "metadata": {}, "outputs": [], "source": [ @@ -1035,62 +1008,64 @@ }, { "cell_type": "code", - "execution_count": 43, + "execution_count": 19, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "| | Group | Experiment | sWER | autoMOS | num_epochs | decoder dropout | mean only | encoder channels | LR | Optimizer | MLE | dev MLE | devtrain MLE | DP loss | DP dev loss | DP devtrain loss | Joint |\n", - "|---:|:----------------------------------|:------------------------------------------------------------------------------------------------------------------------|-------:|----------:|-------------:|------------------:|:------------|:-------------------|:-------------------------------------------------|:-------------------------------------|------:|----------:|---------------:|----------:|--------------:|-------------------:|:--------|\n", - "| 2 | joint_training/conformer_coupling | joint_training/conformer_coupling/raw_audio/ddi/glowTTS/ | 97.7 | 1.61 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.82 | -0.83 | nan | 0.96 | 0.73 | nan | False |\n", - "| 3 | joint_training/conformer_coupling | joint_training/conformer_coupling/raw_audio/ddi/glowTTS_x_vector/ | 99.5 | 1.93 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.81 | -0.76 | -0.81 | 1 | 1.08 | 1.04 | False |\n", - "| 5 | joint_training/conformer_coupling | joint_training/conformer_coupling/raw_audio/ddi/glowTTS_100ep_pe1/ | 14.4 | 2.72 | 100 | 0.05 | False | 768 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'adam', 'epsilon': 1e-08} | -0.83 | -0.84 | nan | 0.39 | 0.36 | nan | False |\n", - "| 7 | joint_training/conformer_coupling | joint_training/conformer_coupling/raw_audio/ddi/glowTTS_100ep_pe1_radam1e-9/ | 14.7 | 2.59 | 100 | 0.05 | False | 768 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.83 | -0.84 | nan | 0.38 | 0.36 | nan | False |\n", - "| 22 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2_multiscale/enc768/200ep/dec_drop_0.05/ | 100 | 1.25 | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.79 | -0.8 | -0.81 | 0.53 | 0.57 | 0.52 | False |\n", - "| 23 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector/enc768/100ep/dec_drop_0.05/ | 97.9 | 1.51 | 100 | 0.05 | False | 768 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.78 | -0.79 | -0.79 | 0.99 | 1.38 | 1.38 | False |\n", - "| 24 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2_logdist_loss_grad_clip_10/ed_scale_0.1/ | 95.7 | 3.21 | 200 | 0.05 | False | 192 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.8 | -0.79 | -0.79 | 1.08 | 1.81 | 1.83 | False |\n", - "| 25 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2_logdist_loss_grad_clip_10/ed_scale_1.0/ | 98.8 | 2.27 | 200 | 0.05 | False | 192 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.74 | -0.76 | -0.76 | 1.13 | 1.54 | 1.55 | False |\n", - "| 26 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_simple_encoder/12cb/200ep/dec_drop_0.05/ | 70.3 | 3.47 | 200 | 0.05 | False | - | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.8 | -0.82 | -0.83 | 0.43 | 0.5 | 0.4 | False |\n", - "| 27 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_simple_encoder/20cb/200ep/dec_drop_0.05/ | 57.3 | 3.46 | 200 | 0.05 | False | - | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.83 | -0.85 | -0.86 | 0.4 | 0.47 | 0.38 | False |\n", - "| 28 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_batch_norm/enc768/200ep/dec_drop_0.05/ | 15.1 | 3.4 | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.81 | -0.82 | -0.83 | 0.39 | 0.45 | 0.36 | False |\n", - "| 29 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2_conformer_coupling/enc768/200ep/dec_drop_0.05/ | 9.6 | 1.79 | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.84 | -0.85 | -0.86 | 0.37 | 0.42 | 0.34 | False |\n", - "| 30 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc192/100ep/dec_drop_0.05/ | 98.1 | 1.52 | 100 | 0.05 | False | 192 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.8 | -0.8 | -0.81 | 0.99 | 0.78 | 0.78 | False |\n", - "| 31 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc192/200ep/dec_drop_0.05_epsilon_1e-8/ | 96.7 | 2.27 | 200 | 0.05 | False | 192 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-08} | -0.81 | -0.82 | -0.82 | 0.98 | 0.81 | 0.83 | False |\n", - "| 32 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc192/200ep/dec_drop_0.05/ | 98.8 | 1.88 | 200 | 0.05 | False | 192 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.81 | -0.82 | -0.82 | 0.99 | 0.62 | 0.62 | False |\n", - "| 33 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/200ep/dec_drop_0.05_epsilon_1e-8/ | 15.7 | 3.35 | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-08} | -0.81 | -0.83 | -0.83 | 0.39 | 0.44 | 0.35 | False |\n", - "| 34 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/200ep/dec_drop_0.0_epsilon_1e-8/ | 95.9 | 3.06 | 200 | 0 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-08} | -0.83 | -0.75 | -0.81 | 0.98 | 0.45 | 0.46 | False |\n", - "| 35 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/200ep/dec_drop_0.05/ | 15.1 | 3.36 | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.81 | -0.83 | -0.83 | 0.39 | 0.44 | 0.35 | False |\n", - "| 36 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/200ep/dec_drop_0.0/epsilon_1e-8/ | 95.9 | 3.06 | 200 | 0 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-08} | -0.83 | -0.75 | -0.81 | 0.98 | 0.45 | 0.46 | False |\n", - "| 37 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/400ep/grad_clip_10/dec_drop_0.05/ | 14.4 | 3.29 | 400 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 400: 1e-06] | {'class': 'radam', 'epsilon': 1e-09} | -0.82 | -0.84 | -0.85 | 0.37 | 0.44 | 0.33 | False |\n", - "| 38 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/100ep/dec_drop_0.05/ | 17.2 | 3.3 | 100 | 0.05 | False | 768 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.8 | -0.81 | -0.82 | 0.4 | 0.43 | 0.37 | False |\n", - "| 39 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/100ep/dec_drop_0.00/ | 16.3 | 3.27 | 100 | 0 | False | 768 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.83 | -0.82 | -0.83 | 0.41 | 0.44 | 0.38 | False |\n", - "| 40 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2_logdist_loss/ed_scale_0.1/ | 95.8 | 3.09 | 200 | 0.05 | False | 192 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.78 | -0.78 | -0.78 | 1.08 | 2.07 | 2.08 | False |\n", - "| 41 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc192/200ep/dec_drop_0.0/ | 95.4 | 2.41 | 200 | 0 | False | 192 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.84 | -0.82 | -0.83 | 0.97 | 1.15 | 1.18 | False |\n", - "| 42 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc192/200ep/dec_drop_0.05/ | 13.3 | 3.3 | 200 | 0.05 | False | 192 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.81 | -0.82 | -0.83 | 0.38 | 0.41 | 0.34 | False |\n", - "| 43 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/100ep/dec_drop_0.05/ | 16.3 | 3.18 | 100 | 0.05 | False | 768 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.8 | -0.81 | -0.82 | 0.41 | 0.44 | 0.38 | False |\n", - "| 44 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/200ep/dec_drop_0.0/ | 96.2 | 2.29 | 200 | 0 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.81 | -0.8 | -0.8 | 0.98 | 0.87 | 0.88 | False |\n", - "| 45 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/200ep/dec_drop_0.05/ | 14.6 | 3.26 | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.81 | -0.82 | -0.83 | 0.39 | 0.44 | 0.36 | False |\n", - "| 46 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/200ep_long_cooldown/dec_drop_0.0/ | 16.7 | 3.32 | 200 | 0 | False | 768 | [0: 1e-06, 49: 0.0005, 50: 0.0005, 200: 1e-06] | {'class': 'radam', 'epsilon': 1e-09} | -0.85 | -0.76 | -0.85 | 0.41 | 0.47 | 0.38 | False |\n", - "| 47 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/200ep_long_cooldown/dec_drop_0.05/ | 15.6 | 3.21 | 200 | 0.05 | False | 768 | [0: 1e-06, 49: 0.0005, 50: 0.0005, 200: 1e-06] | {'class': 'radam', 'epsilon': 1e-09} | -0.81 | -0.82 | -0.83 | 0.39 | 0.45 | 0.36 | False |\n", - "| 48 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/400ep/dec_drop_0.05/ | 12.9 | 3.33 | 400 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 400: 1e-06] | {'class': 'radam', 'epsilon': 1e-09} | -0.82 | -0.83 | -0.84 | 0.38 | 0.46 | 0.34 | False |\n", - "| 73 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS_x_vector/enc192/100ep/not_silence_preprocessed/ | 95.4 | 2.63 | 100 | 0 | False | 192 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'adam', 'epsilon': 1e-09} | -0.81 | -0.79 | nan | 0.97 | 1.27 | nan | False |\n", - "| 74 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS_x_vector/enc768/100ep/not_silence_preprocessed/ | 20.9 | 3.31 | 100 | 0 | False | 768 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'adam', 'epsilon': 1e-09} | -0.81 | -0.8 | nan | 0.46 | 0.47 | nan | False |\n", - "| 75 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS_nar_taco_encoder/not_silence_preprocessed/ | 25.2 | 3.46 | 200 | 0 | - | - | [0: 1e-05, 49: 0.0005, 50: 0.0005, 200: 1e-05] | {'class': 'adam', 'epsilon': 1e-09} | -0.84 | -0.71 | nan | 0.41 | 0.46 | nan | False |\n", - "| 76 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS_nar_taco_encoder/silence_preprocessed/ | 25.9 | 3.39 | 200 | 0 | - | - | [0: 1e-05, 49: 0.0005, 50: 0.0005, 200: 1e-05] | {'class': 'adam', 'epsilon': 1e-09} | -0.83 | -0.81 | nan | 0.39 | 0.42 | nan | False |\n", - "| 77 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS_nar_taco_encoder_no_blstm/silence_preprocessed/ | 105.6 | 3.17 | 100 | 0 | - | - | [0: 0.0001, 49: 0.0005, 50: 0.0001, 100: 1e-06] | {'class': 'radam', 'epsilon': 1e-09} | -0.8 | -0.79 | nan | 0.88 | 0.87 | nan | False |\n", - "| 78 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS_ddi_actnorm/enc192/100ep/not_silence_preprocessed/LR_scheduled/ | 100 | 3.12 | 100 | 0 | False | 192 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'adam', 'epsilon': 1e-09} | -0.84 | -0.8 | nan | 0.42 | 0.44 | nan | False |\n", - "| 79 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS/enc192/200ep/long_cooldown/not_silence_preprocessed/ | 14.7 | 3.29 | 200 | 0 | False | 192 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 200: 1e-07] | {'class': 'adam', 'epsilon': 1e-08} | -0.84 | -0.69 | nan | 0.41 | 0.43 | nan | False |\n", - "| 80 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS/enc192/200ep/long_cooldown/silence_preprocessed/ | 13.5 | 3.28 | 200 | 0 | False | 192 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 200: 1e-07] | {'class': 'adam', 'epsilon': 1e-08} | -0.82 | -0.81 | nan | 0.38 | 0.39 | nan | False |\n", - "| 81 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS/enc192/100ep/not_silence_preprocessed/ | 14.3 | 3.31 | 100 | 0 | False | 192 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'adam', 'epsilon': 1e-09} | -0.84 | -0.77 | nan | 0.41 | 0.42 | nan | False |\n", - "| 82 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS/enc192/100ep/silence_preprocessed/ | 13.5 | 3.3 | 100 | 0 | False | 192 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'adam', 'epsilon': 1e-09} | -0.82 | -0.81 | nan | 0.37 | 0.39 | nan | False |\n", - "| 83 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS/enc768/with_sigma/not_silence_preprocessed/ | 15.7 | 3.35 | 200 | 0 | False | 768 | [0: 5e-05, 49: 0.0005, 50: 0.0005, 200: 1e-06] | {'class': 'adam', 'epsilon': 1e-09} | -0.85 | -0.83 | nan | 0.4 | 0.45 | nan | False |\n", - "| 84 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS/enc768/with_sigma/silence_preprocessed/ | 15.3 | 3.4 | 200 | 0 | False | 768 | [0: 5e-05, 49: 0.0005, 50: 0.0005, 200: 1e-06] | {'class': 'adam', 'epsilon': 1e-09} | -0.74 | -0.46 | nan | 0.37 | 0.41 | nan | False |\n", - "| 85 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS/enc768/mean_only/not_silence_preprocessed/ | 15.5 | 3.47 | 200 | 0 | True | 768 | [0: 5e-05, 49: 0.0005, 50: 0.0005, 200: 1e-06] | {'class': 'adam', 'epsilon': 1e-09} | -0.85 | -0.76 | nan | 0.4 | 0.45 | nan | False |\n", - "| 86 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS/enc768/mean_only/silence_preprocessed/ | 16.9 | 3.52 | 200 | 0 | True | 768 | [0: 5e-05, 49: 0.0005, 50: 0.0005, 200: 1e-06] | {'class': 'adam', 'epsilon': 1e-09} | -0.74 | -0.71 | nan | 0.37 | 0.41 | nan | False |\n", - "| 87 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS/enc256/not_silence_preprocessed/ | 97.9 | 1.69 | 200 | 0 | False | 256 | [0: 5e-05, 49: 0.0005, 50: 0.0005, 200: 1e-06] | {'class': 'adam', 'epsilon': 1e-09} | -0.85 | -0.54 | nan | 0.96 | 0.5 | nan | False |\n", - "| 88 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS_simple_encoder/silence_preprocessed/ | 56.4 | 3.33 | 100 | 0 | - | - | [0: 0.0001, 49: 0.0005, 50: 0.0005, 100: 1e-06] | {'class': 'radam', 'epsilon': 1e-09} | -0.84 | -0.82 | nan | 0.38 | 0.43 | nan | False |\n" + "| | Group | Experiment | sWER | autoMOS | autoMOS confidence | num_epochs | decoder dropout | mean only | encoder channels | LR | Optimizer | MLE | dev MLE | devtrain MLE | DP loss | DP dev loss | DP devtrain loss | Joint |\n", + "|---:|:----------------------------------|:------------------------------------------------------------------------------------------------------------------------|-------:|----------:|---------------------:|-------------:|------------------:|:------------|:-------------------|:-------------------------------------------------|:-------------------------------------|------:|----------:|---------------:|----------:|--------------:|-------------------:|:--------|\n", + "| 0 | joint_training/conformer_coupling | joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_100ep_pe1/ | 12.4 | 2.94 | nan | 100 | 0.05 | False | 768 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'adam', 'epsilon': 1e-08} | -0.83 | -0.85 | nan | 0.38 | 0.35 | nan | False |\n", + "| 3 | joint_training/conformer_coupling | joint_training/conformer_coupling/raw_audio/ddi/glowTTS_100ep_pe1_radam1e-9/ | 14.7 | 2.59 | nan | 100 | 0.05 | False | 768 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.83 | -0.84 | nan | 0.38 | 0.36 | nan | False |\n", + "| 4 | joint_training/conformer_coupling | joint_training/conformer_coupling/raw_audio/ddi/glowTTS_100ep_pe1/ | 14.4 | 2.72 | nan | 100 | 0.05 | False | 768 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'adam', 'epsilon': 1e-08} | -0.83 | -0.84 | nan | 0.39 | 0.36 | nan | False |\n", + "| 5 | joint_training/conformer_coupling | joint_training/conformer_coupling/raw_audio/ddi/glowTTS/ | 97.7 | 1.61 | nan | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.82 | -0.83 | nan | 0.96 | 0.73 | nan | False |\n", + "| 7 | joint_training/conformer_coupling | joint_training/conformer_coupling/raw_audio/ddi/glowTTS_x_vector/ | 99.5 | 1.93 | nan | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.81 | -0.76 | -0.81 | 1 | 1.08 | 1.04 | False |\n", + "| 23 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/400ep/dec_drop_0.05/ | 12.9 | 3.33 | 0.02 | 400 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 400: 1e-06] | {'class': 'radam', 'epsilon': 1e-09} | -0.82 | -0.83 | -0.84 | 0.38 | 0.46 | 0.34 | False |\n", + "| 24 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/200ep/dec_drop_0.0/ | 96.2 | 2.29 | nan | 200 | 0 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.81 | -0.8 | -0.8 | 0.98 | 0.87 | 0.88 | False |\n", + "| 25 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/200ep/dec_drop_0.05/ | 14.6 | 3.26 | 0.02 | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.81 | -0.82 | -0.83 | 0.39 | 0.44 | 0.36 | False |\n", + "| 26 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/100ep/dec_drop_0.05/ | 16.3 | 3.18 | 0.02 | 100 | 0.05 | False | 768 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.8 | -0.81 | -0.82 | 0.41 | 0.44 | 0.38 | False |\n", + "| 27 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/200ep_long_cooldown/dec_drop_0.0/ | 16.7 | 3.32 | nan | 200 | 0 | False | 768 | [0: 1e-06, 49: 0.0005, 50: 0.0005, 200: 1e-06] | {'class': 'radam', 'epsilon': 1e-09} | -0.85 | -0.76 | -0.85 | 0.41 | 0.47 | 0.38 | False |\n", + "| 28 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/200ep_long_cooldown/dec_drop_0.05/ | 15.6 | 3.21 | nan | 200 | 0.05 | False | 768 | [0: 1e-06, 49: 0.0005, 50: 0.0005, 200: 1e-06] | {'class': 'radam', 'epsilon': 1e-09} | -0.81 | -0.82 | -0.83 | 0.39 | 0.45 | 0.36 | False |\n", + "| 29 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc192/200ep/dec_drop_0.05/ | 13.3 | 3.3 | nan | 200 | 0.05 | False | 192 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.81 | -0.82 | -0.83 | 0.38 | 0.41 | 0.34 | False |\n", + "| 30 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc192/200ep/dec_drop_0.0/ | 95.4 | 2.41 | nan | 200 | 0 | False | 192 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.84 | -0.82 | -0.83 | 0.97 | 1.15 | 1.18 | False |\n", + "| 31 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc192/200ep/dec_drop_0.05_epsilon_1e-8/ | 96.7 | 2.27 | nan | 200 | 0.05 | False | 192 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-08} | -0.81 | -0.82 | -0.82 | 0.98 | 0.81 | 0.83 | False |\n", + "| 32 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc192/200ep/dec_drop_0.05/ | 98.8 | 1.88 | nan | 200 | 0.05 | False | 192 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.81 | -0.82 | -0.82 | 0.99 | 0.62 | 0.62 | False |\n", + "| 33 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc192/200ep/dec_drop_0.0/grad_clip_10/ | 12.8 | 3.34 | nan | 200 | 0 | False | 192 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.85 | -0.77 | -0.85 | 0.39 | 0.43 | 0.36 | False |\n", + "| 34 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc192/100ep/dec_drop_0.05/ | 98.1 | 1.52 | nan | 100 | 0.05 | False | 192 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.8 | -0.8 | -0.81 | 0.99 | 0.78 | 0.78 | False |\n", + "| 35 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/400ep/grad_clip_10/dec_drop_0.05/ | 14.4 | 3.29 | 0.02 | 400 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 400: 1e-06] | {'class': 'radam', 'epsilon': 1e-09} | -0.82 | -0.84 | -0.85 | 0.37 | 0.44 | 0.33 | False |\n", + "| 36 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/200ep/dec_drop_0.0/epsilon_1e-8/ | 95.9 | 3.06 | nan | 200 | 0 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-08} | -0.83 | -0.75 | -0.81 | 0.98 | 0.45 | 0.46 | False |\n", + "| 37 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/200ep/dec_drop_0.0/grad_clip_10/ | 14.5 | 3.31 | nan | 200 | 0 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.85 | -0.84 | -0.85 | 0.4 | 0.45 | 0.36 | False |\n", + "| 38 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/200ep/dec_drop_0.05_epsilon_1e-8/ | 15.7 | 3.35 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-08} | -0.81 | -0.83 | -0.83 | 0.39 | 0.44 | 0.35 | False |\n", + "| 39 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/200ep/dec_drop_0.05/ | 15.1 | 3.36 | 0.02 | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.81 | -0.83 | -0.83 | 0.39 | 0.44 | 0.35 | False |\n", + "| 40 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/100ep/dec_drop_0.00/ | 16.3 | 3.27 | nan | 100 | 0 | False | 768 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.83 | -0.82 | -0.83 | 0.41 | 0.44 | 0.38 | False |\n", + "| 41 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/100ep/dec_drop_0.05/ | 17.2 | 3.3 | nan | 100 | 0.05 | False | 768 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.8 | -0.81 | -0.82 | 0.4 | 0.43 | 0.37 | False |\n", + "| 42 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2_logdist_loss/ed_scale_0.1/ | 95.8 | 3.09 | nan | 200 | 0.05 | False | 192 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.78 | -0.78 | -0.78 | 1.08 | 2.07 | 2.08 | False |\n", + "| 43 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2_logdist_loss_grad_clip_10/ed_scale_1.0/ | 98.8 | 2.27 | nan | 200 | 0.05 | False | 192 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.74 | -0.76 | -0.76 | 1.13 | 1.54 | 1.55 | False |\n", + "| 44 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2_logdist_loss_grad_clip_10/ed_scale_0.1/ | 95.7 | 3.21 | nan | 200 | 0.05 | False | 192 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.8 | -0.79 | -0.79 | 1.08 | 1.81 | 1.83 | False |\n", + "| 45 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_simple_encoder/12cb/200ep/dec_drop_0.05/ | 70.3 | 3.47 | nan | 200 | 0.05 | False | - | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.8 | -0.82 | -0.83 | 0.43 | 0.5 | 0.4 | False |\n", + "| 46 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_simple_encoder/20cb/200ep/dec_drop_0.05/ | 57.3 | 3.46 | nan | 200 | 0.05 | False | - | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.83 | -0.85 | -0.86 | 0.4 | 0.47 | 0.38 | False |\n", + "| 47 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2_conformer_coupling/enc768/200ep/dec_drop_0.05/ | 9.6 | 1.79 | 0.03 | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.84 | -0.85 | -0.86 | 0.37 | 0.42 | 0.34 | False |\n", + "| 48 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2_multiscale/enc768/200ep/dec_drop_0.05/ | 100 | 1.25 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.79 | -0.8 | -0.81 | 0.53 | 0.57 | 0.52 | False |\n", + "| 49 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_batch_norm/enc768/200ep/dec_drop_0.05/ | 15.1 | 3.4 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.81 | -0.82 | -0.83 | 0.39 | 0.45 | 0.36 | False |\n", + "| 50 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector/enc768/100ep/dec_drop_0.05/ | 97.9 | 1.51 | nan | 100 | 0.05 | False | 768 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.78 | -0.79 | -0.79 | 0.99 | 1.38 | 1.38 | False |\n", + "| 75 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS/enc256/not_silence_preprocessed/ | 97.9 | 1.69 | nan | 200 | 0 | False | 256 | [0: 5e-05, 49: 0.0005, 50: 0.0005, 200: 1e-06] | {'class': 'adam', 'epsilon': 1e-09} | -0.85 | -0.54 | nan | 0.96 | 0.5 | nan | False |\n", + "| 76 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS/enc768/with_sigma/not_silence_preprocessed/ | 15.7 | 3.35 | nan | 200 | 0 | False | 768 | [0: 5e-05, 49: 0.0005, 50: 0.0005, 200: 1e-06] | {'class': 'adam', 'epsilon': 1e-09} | -0.85 | -0.83 | nan | 0.4 | 0.45 | nan | False |\n", + "| 77 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS/enc768/with_sigma/silence_preprocessed/ | 15.3 | 3.4 | nan | 200 | 0 | False | 768 | [0: 5e-05, 49: 0.0005, 50: 0.0005, 200: 1e-06] | {'class': 'adam', 'epsilon': 1e-09} | -0.74 | -0.46 | nan | 0.37 | 0.41 | nan | False |\n", + "| 78 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS/enc768/mean_only/silence_preprocessed/ | 16.9 | 3.52 | nan | 200 | 0 | True | 768 | [0: 5e-05, 49: 0.0005, 50: 0.0005, 200: 1e-06] | {'class': 'adam', 'epsilon': 1e-09} | -0.74 | -0.71 | nan | 0.37 | 0.41 | nan | False |\n", + "| 79 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS/enc768/mean_only/not_silence_preprocessed/ | 15.5 | 3.47 | nan | 200 | 0 | True | 768 | [0: 5e-05, 49: 0.0005, 50: 0.0005, 200: 1e-06] | {'class': 'adam', 'epsilon': 1e-09} | -0.85 | -0.76 | nan | 0.4 | 0.45 | nan | False |\n", + "| 80 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS/enc192/100ep/not_silence_preprocessed/ | 14.3 | 3.31 | nan | 100 | 0 | False | 192 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'adam', 'epsilon': 1e-09} | -0.84 | -0.77 | nan | 0.41 | 0.42 | nan | False |\n", + "| 81 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS/enc192/100ep/silence_preprocessed/ | 13.5 | 3.3 | nan | 100 | 0 | False | 192 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'adam', 'epsilon': 1e-09} | -0.82 | -0.81 | nan | 0.37 | 0.39 | nan | False |\n", + "| 82 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS/enc192/200ep/long_cooldown/not_silence_preprocessed/ | 14.7 | 3.29 | nan | 200 | 0 | False | 192 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 200: 1e-07] | {'class': 'adam', 'epsilon': 1e-08} | -0.84 | -0.69 | nan | 0.41 | 0.43 | nan | False |\n", + "| 83 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS/enc192/200ep/long_cooldown/silence_preprocessed/ | 13.5 | 3.28 | nan | 200 | 0 | False | 192 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 200: 1e-07] | {'class': 'adam', 'epsilon': 1e-08} | -0.82 | -0.81 | nan | 0.38 | 0.39 | nan | False |\n", + "| 84 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS_simple_encoder/silence_preprocessed/ | 56.4 | 3.33 | nan | 100 | 0 | - | - | [0: 0.0001, 49: 0.0005, 50: 0.0005, 100: 1e-06] | {'class': 'radam', 'epsilon': 1e-09} | -0.84 | -0.82 | nan | 0.38 | 0.43 | nan | False |\n", + "| 85 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS_ddi_actnorm/enc192/100ep/not_silence_preprocessed/LR_scheduled/ | 100 | 3.12 | nan | 100 | 0 | False | 192 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'adam', 'epsilon': 1e-09} | -0.84 | -0.8 | nan | 0.42 | 0.44 | nan | False |\n", + "| 86 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS_x_vector/enc768/100ep/not_silence_preprocessed/ | 20.9 | 3.31 | nan | 100 | 0 | False | 768 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'adam', 'epsilon': 1e-09} | -0.81 | -0.8 | nan | 0.46 | 0.47 | nan | False |\n", + "| 87 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS_x_vector/enc192/100ep/not_silence_preprocessed/ | 95.4 | 2.63 | nan | 100 | 0 | False | 192 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'adam', 'epsilon': 1e-09} | -0.81 | -0.79 | nan | 0.97 | 1.27 | nan | False |\n", + "| 88 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS_nar_taco_encoder/not_silence_preprocessed/ | 25.2 | 3.46 | nan | 200 | 0 | - | - | [0: 1e-05, 49: 0.0005, 50: 0.0005, 200: 1e-05] | {'class': 'adam', 'epsilon': 1e-09} | -0.84 | -0.71 | nan | 0.41 | 0.46 | nan | False |\n", + "| 89 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS_nar_taco_encoder/silence_preprocessed/ | 25.9 | 3.39 | nan | 200 | 0 | - | - | [0: 1e-05, 49: 0.0005, 50: 0.0005, 200: 1e-05] | {'class': 'adam', 'epsilon': 1e-09} | -0.83 | -0.81 | nan | 0.39 | 0.42 | nan | False |\n", + "| 90 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS_nar_taco_encoder_no_blstm/silence_preprocessed/ | 105.6 | 3.17 | nan | 100 | 0 | - | - | [0: 0.0001, 49: 0.0005, 50: 0.0001, 100: 1e-06] | {'class': 'radam', 'epsilon': 1e-09} | -0.8 | -0.79 | nan | 0.88 | 0.87 | nan | False |\n" ] } ], @@ -1100,7 +1075,67 @@ }, { "cell_type": "code", - "execution_count": 44, + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "| | Group | Experiment | sWER | autoMOS | autoMOS confidence | num_epochs | decoder dropout | mean only | encoder channels | LR | Optimizer | MLE | dev MLE | devtrain MLE | DP loss | DP dev loss | DP devtrain loss | Joint |\n", + "|---:|:----------------------------------|:----------------------------------------------------------------------------------------------------------------------------------------------------|-------:|----------:|---------------------:|-------------:|------------------:|:------------|-------------------:|:-------------------------------------------------|:-------------------------------------|------:|----------:|---------------:|----------:|--------------:|-------------------:|:--------|\n", + "| 1 | joint_training/conformer_coupling | joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_two_forward_pass/ | 20.9 | 2.45 | nan | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.67 | nan | -0.69 | 0.44 | nan | 0.41 | True |\n", + "| 2 | joint_training/conformer_coupling | joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_x_vector_v2/ | 5.2 | 2.14 | nan | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.45 | -0.4 | -0.47 | 0.25 | 0.34 | 0.23 | True |\n", + "| 6 | joint_training/conformer_coupling | joint_training/conformer_coupling/raw_audio/ddi/glowTTS_ASR_conformer_two_forward_pass/ | 95.7 | 1.82 | nan | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.66 | nan | -0.67 | 1 | nan | 2.09 | True |\n", + "| 8 | joint_training/conformer_coupling | joint_training/conformer_coupling/raw_audio/ddi/glowTTS_ASR_conformer_x_vector/ | 5.2 | 2.14 | nan | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.45 | -0.4 | -0.47 | 0.25 | 0.34 | 0.23 | True |\n", + "| 9 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1/ | 4.6 | 3.11 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.74 | -0.69 | -0.76 | 0.35 | 0.48 | 0.33 | True |\n", + "| 10 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass/ | 9.5 | 2.75 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.61 | -0.56 | -0.63 | 0.42 | 0.58 | 0.4 | True |\n", + "| 11 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/ | 11.2 | 3.18 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.76 | -0.69 | -0.78 | 0.4 | 0.56 | 0.38 | True |\n", + "| 12 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_ctc_scale_0.1/ | 13.3 | 3.12 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.75 | -0.69 | -0.77 | 0.42 | 0.57 | 0.4 | True |\n", + "| 13 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment/ | 5.2 | 2.3 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.51 | -0.46 | -0.52 | 0.25 | 0.35 | 0.23 | True |\n", + "| 14 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/ | 9.9 | 2.64 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.62 | -0.57 | -0.64 | 0.4 | 0.55 | 0.38 | True |\n", + "| 15 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/ | 7.9 | 3.19 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.75 | -0.7 | -0.77 | 0.37 | 0.51 | 0.35 | True |\n", + "| 16 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/ | 6.7 | 2.48 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.58 | -0.53 | -0.59 | 0.35 | 0.46 | 0.33 | True |\n", + "| 17 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_ctc_scale_0.1/ | 7.6 | 3.15 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.75 | -0.7 | -0.77 | 0.38 | 0.5 | 0.36 | True |\n", + "| 18 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/ | 4.4 | 3.2 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.75 | -0.69 | -0.76 | 0.33 | 0.46 | 0.31 | True |\n", + "| 19 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/ | 14.8 | 2.61 | 0.03 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.68 | nan | -0.7 | 0.4 | nan | 0.37 | True |\n", + "| 20 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/ | 6 | 2.32 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.52 | -0.47 | -0.54 | 0.23 | 0.35 | 0.2 | True |\n", + "| 21 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/ | 15.2 | 3.16 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.78 | nan | -0.81 | 0.38 | nan | 0.36 | True |\n", + "| 22 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector/ | 98 | 1.58 | 0.01 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.55 | -0.5 | -0.55 | 1.02 | 0.82 | 0.7 | True |\n", + "| 51 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/specaug/ce_ls_0.1/ | 25.2 | 3.11 | nan | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.8 | -0.82 | -0.82 | 0.43 | 0.46 | 0.41 | True |\n", + "| 52 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/specaug/ce_ls_1/ | 88.5 | 1.87 | nan | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.72 | -0.73 | -0.74 | 0.75 | 0.79 | 0.69 | True |\n", + "| 53 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/200ep/basic_init/no_specaug/tts_target_size/ce_ls_0.1/ | 98.1 | 1.82 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.79 | -0.79 | -0.8 | 0.89 | 0.57 | 0.58 | True |\n", + "| 54 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/200ep/tts_pretrained/no_specaug/tts_target_size/ce_ls_0.1/ | 32.9 | 2.77 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.8 | -0.82 | -0.83 | 0.44 | 0.49 | 0.41 | True |\n", + "| 55 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/no_specaug/ce_ls_1/ | 83.9 | 1.92 | nan | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.69 | -0.7 | -0.71 | 0.76 | 0.94 | 0.72 | True |\n", + "| 56 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/no_specaug/ce_ls_0.1/ | 41.9 | 2.75 | nan | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.79 | -0.81 | -0.82 | 0.51 | 0.54 | 0.49 | True |\n", + "| 57 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_cnn_x_vector/tts_pretrained/no_specaug/tts_target_size/ce_ls_0.1/ | 14.1 | 3.2 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.79 | -0.81 | -0.81 | 0.4 | 0.45 | 0.36 | True |\n", + "| 58 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_cnn_x_vector/basic_init/no_specaug/tts_target_size/ce_ls_0.1/ | 23.3 | 3.13 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.78 | -0.79 | -0.79 | 0.43 | 0.48 | 0.4 | True |\n", + "| 59 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/mean_only/200ep/basic_init/no_specaug/tts_target_size/ce_ls_0.1/ | 96.4 | 2.37 | nan | 200 | 0.05 | True | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.8 | -0.8 | -0.81 | 0.93 | 0.72 | 0.73 | True |\n", + "| 60 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/200ep/tts_pretrained/no_specaug/tts_target_size/ce_ls_0.1/ | 91.7 | 2.66 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.81 | -0.82 | -0.83 | 0.63 | 0.63 | 0.59 | True |\n", + "| 61 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/no_specaug/tts_target_size/ce_ls_1.0/ | 97.2 | 2.12 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.8 | -0.8 | -0.81 | 0.83 | 0.61 | 0.62 | True |\n", + "| 62 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/no_specaug/tts_target_size/ce_ls_0.1/ | 99.9 | 1.56 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.8 | -0.77 | -0.8 | 0.82 | 0.53 | 0.54 | True |\n", + "| 63 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector_v2/tts_pretrained/ce_ls_0.1/ | 99.7 | 1.83 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.79 | -0.81 | -0.81 | 0.05 | 0.05 | 0.04 | True |\n", + "| 64 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector_v2/tts_pretrained/ce_ls_0.01/ | 97.2 | 1.97 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.8 | -0.81 | -0.82 | 0.06 | 0.06 | 0.05 | True |\n", + "| 65 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector_v2/basic_init/ce_ls_0.1/ | 99.1 | 1.64 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.78 | -0.8 | -0.8 | 0.05 | 0.05 | 0.04 | True |\n", + "| 66 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector_v2/basic_init/ce_ls_0.01/ | 98.2 | 2.18 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.79 | -0.8 | -0.81 | 0.06 | 0.06 | 0.05 | True |\n", + "| 67 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector_v2/200ep/tts_pretrained/ce_ls_1.0/ | 100 | 1.97 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.73 | -0.75 | -0.75 | 0.08 | 0.08 | 0.07 | True |\n", + "| 68 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector_v2/200ep/tts_pretrained/ce_ls_0.1/ | 100 | 1.98 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.76 | -0.78 | -0.78 | 0.08 | 0.08 | 0.07 | True |\n", + "| 69 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/ce_ls_1.0/ | 100 | 1.98 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.73 | -0.74 | -0.75 | 0.07 | 0.08 | 0.06 | True |\n", + "| 70 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/ce_ls_0.1/ | 100 | 1.98 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.76 | -0.77 | -0.78 | 0.07 | 0.08 | 0.06 | True |\n", + "| 71 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector/200ep/basic_init/ce_ls_0.1/ | 97.9 | 1.78 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.78 | -0.79 | -0.8 | 0.26 | 0.24 | 0.25 | True |\n", + "| 72 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector/200ep/tts_pretrained/ce_ls_0.1/ | 95.4 | 2.53 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.79 | -0.81 | -0.81 | 0.25 | 0.22 | 0.23 | True |\n", + "| 73 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector/tts_pretrained/ce_ls_0.1/ | 95.2 | 2.18 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.78 | -0.79 | -0.79 | 0.26 | 0.24 | 0.25 | True |\n", + "| 74 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector/basic_init/ce_ls_0.1/ | 96.1 | 2.35 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.77 | -0.78 | -0.79 | 0.27 | 0.26 | 0.26 | True |\n" + ] + } + ], + "source": [ + "print(df_no_index[df_no_index[\"Joint\"]].to_markdown())\n" + ] + }, + { + "cell_type": "code", + "execution_count": 20, "metadata": {}, "outputs": [ { @@ -1109,13 +1144,13 @@ "" ] }, - "execution_count": 44, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1130,7 +1165,7 @@ }, { "cell_type": "code", - "execution_count": 45, + "execution_count": 21, "metadata": {}, "outputs": [ { @@ -1139,13 +1174,13 @@ "" ] }, - "execution_count": 45, + "execution_count": 21, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkIAAAGwCAYAAABFFQqPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA5TUlEQVR4nO3de3RU9b3//9fkQjBALuRCiIZLJAoI0nAVghEKRaSnVbSnizQWxQi1glTEtnCsbT0epVqt/ZFytLZUpcXY2ipF1hFNJYBGhBCg5RIjEMI9JiE3kgAmZP/+8JspQzKXkExm9uznY61Zy+zLzGd2y8xrPp/357NthmEYAgAAsKAgXzcAAADAVwhCAADAsghCAADAsghCAADAsghCAADAsghCAADAsghCAADAskJ83QB/19LSolOnTqlPnz6y2Wy+bg4AAPCAYRg6e/asEhMTFRTkvN+HIOTGqVOnlJSU5OtmAACAK3D8+HFdc801TvcThNzo06ePpC8vZEREhI9bAwAAPFFXV6ekpCT797gzBCE3WofDIiIiCEIAAJiMu7IWiqUBAIBlEYQAAIBlEYQAAIBlEYQAAIBlEYQAAIBlEYQAAIBlEYQAAIBlEYQAAIBlEYQAAIBlmSYIVVVVKTMzUxEREYqKilJWVpbq6+s9OtcwDN12222y2Wxat26ddxsKAABMwzRBKDMzU/v371dubq42bNigrVu3asGCBR6d++tf/9rv7xy/pbhc/98Hn+nDgxW+bgoAAJZhinuNFRUVaePGjSooKNDYsWMlSdnZ2Zo1a5aee+45JSYmOj13z549ev7557Vz507179+/u5rssaNnGnTHqnxVNzbZt0WHh2r9wslKign3YcsAAAh8pugR2rZtm6KiouwhSJKmT5+uoKAgbd++3el5jY2N+s53vqNVq1YpISHBo9e6cOGC6urqHB7edHkIkqTqxiZ9c9VHXn1dAABgkiBUVlam+Ph4h20hISHq27evysrKnJ63ZMkSTZo0SbfffrvHr7VixQpFRkbaH0lJSVfcbne2FJe3CUGtqhubGCYDAMDLfBqEli1bJpvN5vLx6aefXtFzr1+/Xps2bdKvf/3rDp23fPly1dbW2h/Hjx+/otf3xJ4TNS737zpW7bXXBgAAPq4RWrp0qe69916XxyQnJyshIUHl5eUO25ubm1VVVeV0yGvTpk06fPiwoqKiHLbfdddduvnmm7V58+Z2zwsLC1NYWJinb6FTvnJNlMv9owdEd0s7AACwKp8Gobi4OMXFxbk9buLEiaqpqVFhYaHGjBkj6cug09LSogkTJrR7zrJly3T//fc7bBs5cqReeOEFfeMb3+h847vALdfHKzo8tN3hsejwUN2c4v7aAACAK2eKGqFhw4Zp5syZmj9/vnbs2KH8/HwtWrRIc+bMsc8YO3nypIYOHaodO3ZIkhISEjRixAiHhyQNGDBAgwcP9tl7udz6hZMVHR7qsK111hgAAPAuU0yfl6S1a9dq0aJFmjZtmoKCgnTXXXdp5cqV9v1NTU0qLi5WY2OjD1vZcUkx4dr90xn68GCFdh2r1ugB0fQEAQDQTWyGYRi+boQ/q6urU2RkpGpraxUREeHr5gAAAA94+v1tiqExAAAAbyAIAQAAyyIIAQAAyyIIAQAAyyIIAQAAyyIIAQAAyyIIAQAAyyIIAQAAyyIIAQAAyyIIAQAAyyIIAQAAyyIIAQAAyyIIAQAAyyIIAQAAyyIIAQAAyyIIAQAAyyIIAQAAyyIIAQAAyyIIAQAAyyIIAQAAyyIIAQAAyyIIAQAAyyIIAQAAyyIIAQAAyyIIAQAAyyIIAQAAyyIIAQAAyyIIAQAAyyIIAQAAyyIIAQAAyyIIAQAAyyIIAQAAywrxdQPwpZKKeh2tatSgmF4aHNvL180BAMASCEI+VtP4hRbn7NHWgxX2bekpccrOSFVkeKgPWwYAQOBjaMzHFufsUf6hSodt+Ycq9VDObh+1CAAA6yAI+VBJRb22HqzQRcNw2H7RMLT1YIWOVDb4qGUAAFgDQciHjlY1utxfesa/g1BJRb3yissJbAAA06JGyIcG9g13uX9QjH8WTVPXBAAIFPQI+VByXG+lp8Qp2GZz2B5ssyk9Jc5vZ49R1wQACBQEIR/LzkhV2pBYh21pQ2KVnZHqoxa5Rl0TACCQMDTmY5HhoVqTNV5HKhtUeqbB79cR8qSuyZ/bDwDApQhCfmJwrGMA8tcFFs1a1wQAQHsIQn7G3wuRW+ua8g9VOgyPBdtsShsS61ehDQAAd6gR8jNmKEQ2W10TAADO0CPkR1oLkS93aSGyP/S4mK2uCQAAZwhCfsRshciX1zUBAGA2DI35EQqRAQDoXgQhP2LWBRYBADArgpCfoRAZAIDuQ42Qn6EQGQCA7kMQ8lMUIgMA4H0MjQEAAMsiCAEAAMsiCAEAAMsiCAEAAMsiCAEAAMsiCAEAAMsiCAEAAMsiCAEAAMsiCAEAAMsiCAEAAMviFhsAAFhMSUW9jlY1cj9LEYQAALCMmsYvtDhnj7YerLBvS0+JU3ZGqiLDQ33YMt9haAwAAItYnLNH+YcqHbblH6rUQzm7fdQi3zNNEKqqqlJmZqYiIiIUFRWlrKws1dfXuzxnypQpstlsDo8HHnigm1oMAID/KKmo19aDFbpoGA7bLxqGth6s0JHKBh+1zLdME4QyMzO1f/9+5ebmasOGDdq6dasWLFjg9rz58+fr9OnT9sezzz7bDa0FAMC/HK1qdLm/9Iw1g5ApaoSKioq0ceNGFRQUaOzYsZKk7OxszZo1S88995wSExOdnhseHq6EhASPX+vChQu6cOGC/e+6urorbzgAAH5iYN9wl/sHxVizaNoUPULbtm1TVFSUPQRJ0vTp0xUUFKTt27e7PHft2rWKjY3ViBEjtHz5cjU2uk7EK1asUGRkpP2RlJTUJe8BAABfSo7rrfSUOAXbbA7bg202pafEWXb2mCmCUFlZmeLj4x22hYSEqG/fviorK3N63ne+8x396U9/Ul5enpYvX64//vGPuvvuu12+1vLly1VbW2t/HD9+vEveAwAAvpadkaq0IbEO29KGxCo7I9VHLfI9nw6NLVu2TM8884zLY4qKiq74+S+tIRo5cqT69++vadOm6fDhw7r22mvbPScsLExhYWFX/JoAAPiryPBQrckaryOVDSo908A6QvJxEFq6dKnuvfdel8ckJycrISFB5eXlDtubm5tVVVXVofqfCRMmSJIOHTrkNAgBABDoBscSgFr5NAjFxcUpLi7O7XETJ05UTU2NCgsLNWbMGEnSpk2b1NLSYg83ntizZ48kqX///lfUXgAAEFhMUSM0bNgwzZw5U/Pnz9eOHTuUn5+vRYsWac6cOfYZYydPntTQoUO1Y8cOSdLhw4f15JNPqrCwUKWlpVq/fr3mzp2r9PR03Xjjjb58OwAAwE+YIghJX87+Gjp0qKZNm6ZZs2Zp8uTJevnll+37m5qaVFxcbJ8V1qNHD/3jH//QjBkzNHToUC1dulR33XWX3nnnHV+9BQAA4GdshnHZEpNwUFdXp8jISNXW1ioiIsLXzQEAAB7w9PvbND1CAAAAXY0gBAAALIsgBAAALIsgBAAALIsgBAAALIsgBAAALIsgBAAALIsgBAAALIsgBAAALIsgBAAALIsgBAAALIsgBAAALCvE1w2AeyUV9Tpa1ahBMb00OLaXr5sDAEDAIAj5sZrGL7Q4Z4+2Hqywb0tPiVN2Rqoiw0N92DIAAAIDQ2N+bHHOHuUfqnTYln+oUg/l7PZRiwAACCwEIT9VUlGvrQcrdNEwHLZfNAxtPVihI5UNPmoZAACBgyDkp45WNbrcX3qGIAQAQGcRhPzUwL7hLvcPiqFoGgCAziII+ankuN5KT4lTsM3msD3YZlN6ShyzxwAA6AIEIT+WnZGqtCGxDtvShsQqOyPVRy0CACCwMH3ej0WGh2pN1ngdqWxQ6ZkG1hECAKCLEYRMYHAsAQgA0HVYqPffCEIAAFgEC/W2RY0QAAAWwUK9bRGEAACwABbqbR9BCAAAC2Ch3vYRhAAAsAAW6m0fQQgAAAtgod72EYQAALAIFupti+nzAABYBAv1tkUQCkAslAUAcIWFev+NIBRAWCgLAICOoUYogLBQFgAAHUMQChAslAUAQMcRhAIEC2UBANBxBKEAwUJZAAB0HEEoQLBQFgAAHUcQCiDtLZQ1rH8fPTrjOh+1CAAA/2YzjMuqa+Ggrq5OkZGRqq2tVUREhK+b45F/Hq/RY+v2at/JOvs2ptEDAKzE0+9veoQC0PPvf6aiU2cdtjGNHgCAtghCAYZp9AAAeI4gFGCYRg8AgOcIQgGGafQAAHiOIBRgmEYPAIDnCEIBqL1p9GlDYpWdkeqjFgEA4J+4+3wAigwP1Zqs8TpS2aDSMw0aFNOLniAAANpBEApgg2MJQAAAuMLQGAAAsCyCEAAAsCyCEAAAsCyCEAAAsCyCEAAAsCyCEAAAsCyCEAAAsCyCEAAAsCyCEAAAsCyCEAAAsCyCEAAAsCyCEAAAsCyCEAAAsCyPg9Czzz6rc+fO2f/Oz8/XhQsX7H+fPXtWDz74YNe2DgAAwItshmEYnhwYHBys06dPKz4+XpIUERGhPXv2KDk5WZL0+eefKzExURcvXvRea32grq5OkZGRqq2tVUREhK+bAwAAPODp97fHPUKX5yUP8xMAAIDfMk2NUFVVlTIzMxUREaGoqChlZWWpvr7e7Xnbtm3TV7/6VfXq1UsRERFKT093GOIDAADWZZoglJmZqf379ys3N1cbNmzQ1q1btWDBApfnbNu2TTNnztSMGTO0Y8cOFRQUaNGiRQoKMs3bBgAAXhTSkYN///vfq3fv3pKk5uZmvfrqq4qNjZX0ZbG0txQVFWnjxo0qKCjQ2LFjJUnZ2dmaNWuWnnvuOSUmJrZ73pIlS7R48WItW7bMvu3666/3WjsBAIC5eByEBgwYoN/97nf2vxMSEvTHP/6xzTHesG3bNkVFRdlDkCRNnz5dQUFB2r59u2bPnt3mnPLycm3fvl2ZmZmaNGmSDh8+rKFDh+qpp57S5MmTnb7WhQsXHGbD1dXVde2bAQAAfsPjIFRaWurFZrhWVlZmn63WKiQkRH379lVZWVm755SUlEiSfv7zn+u5557TV77yFa1Zs0bTpk3Tvn37lJKS0u55K1as0BNPPNG1bwAAAPilLiuWOXHihNuancstW7ZMNpvN5ePTTz+9ova0tLRIkr73ve9p3rx5Sk1N1QsvvKDrr79ef/jDH5yet3z5ctXW1tofx48fv6LXBwAA/q9DNUKunDlzRqtXr9bLL7/s8TlLly7Vvffe6/KY5ORkJSQkqLy83GF7c3OzqqqqlJCQ0O55/fv3lyQNHz7cYfuwYcN07Ngxp68XFhamsLAwD1oPAADMrsuC0JWIi4tTXFyc2+MmTpyompoaFRYWasyYMZKkTZs2qaWlRRMmTGj3nEGDBikxMVHFxcUO2z/77DPddtttnW88AAAwPVPMIx82bJhmzpyp+fPna8eOHcrPz9eiRYs0Z84c+4yxkydPaujQodqxY4ckyWaz6Yc//KFWrlypv/71rzp06JAef/xxffrpp8rKyvLl2wEAAH7Cpz1CHbF27VotWrRI06ZNU1BQkO666y6tXLnSvr+pqUnFxcVqbGy0b3v44Yd1/vx5LVmyRFVVVRo1apRyc3N17bXX+uItAAAAP+PxvcbuvPNOl/tramq0ZcsW7jUGAAB8ztPvb497hCIjI93unzt3ructBAAA8DGPg9Arr7zizXYAAAB0O1MUSwMAAHiDxz1C9913n0fHuVqsEAAAwJ94HIReffVVDRw4UKmpqfKwvhoAAMCveRyEvv/97ysnJ0dHjhzRvHnzdPfdd6tv377ebBsAAIBXeVwjtGrVKp0+fVo/+tGP9M477ygpKUnf/va39d5779FDBAAATMnjdYQud/ToUb366qtas2aNmpubtX//fvXu3bur2+dzrCMEAID5ePr9fcWzxoKCgmSz2WQYRsAtoggAAKyhQ0HowoULysnJ0de+9jVdd9112rt3r37zm9/o2LFjAdkbBAAAApvHxdIPPvig3njjDSUlJem+++5TTk6OYmNjvdk2AAAAr/K4RigoKEgDBgxQamqqbDab0+PeeuutLmucP6BGCAAA8+nye43NnTvXZQACAAAwmw4tqAgAABBIuNcYAACwLIIQAACwLIIQAACwLIIQAACwrA4HofPnz3ujHQAAAN2uw0EoPj5e9957r3Jzc9XS0uKNNgEAAHSLDgeh1157TQ0NDbr99tt19dVX6+GHH9bOnTu90TYAAACv6nAQmj17tt588019/vnnevrpp3XgwAHddNNNuu666/Tf//3f3mgjAACAV3h8iw1XDhw4oMzMTP3rX/8KuDvRc4sNAADMx9Pv7yueNXb+/Hn95S9/0R133KHRo0erqqpKP/zhD6/06QAAALqdx7fYaPXee+/p9ddf17p16xQSEqJvfetbev/995Wenu6N9gEAAHhNh4PQ7Nmz9R//8R9as2aNZs2apdDQUG+0CwAAwOs6HIQ+//xz9enTxxttAQAA6FYdrhHq06ePDh8+rJ/85CfKyMhQeXm5JOndd9/V/v37u7yBAAAA3tLhILRlyxaNHDlS27dv11tvvaX6+npJ0j//+U/97Gc/6/IGAgAAeEuHg9CyZcv0P//zP8rNzVWPHj3s27/61a/qk08+6dLGAQAAeFOHg9DevXs1e/bsNtvj4+NVWVnZJY0CAADoDh0OQlFRUTp9+nSb7bt379bVV1/dJY0CAADoDh0OQnPmzNGPf/xjlZWVyWazqaWlRfn5+Xr00Uc1d+5cb7QRAADAKzochJ5++mkNHTpUSUlJqq+v1/Dhw5Wenq5JkybpJz/5iTfaCAAA4BVXfK+xY8eOad++faqvr1dqaqpSUlK6um1+gXuNAQBgPp5+f3d4QcVWAwYM0IABA670dAAAAJ/zKAg98sgjHj/hr371qytuDAAAQHfyKAjt3r3b4e9du3apublZ119/vSTps88+U3BwsMaMGdP1LQQAAPASj4JQXl6e/b9/9atfqU+fPnrttdcUHR0tSaqurta8efN08803e6eVAAAAXtDhYumrr75a77//vm644QaH7fv27dOMGTN06tSpLm2gr1EsDQCA+Xj6/d3h6fN1dXWqqKhos72iokJnz57t6NMBAAD4TIeD0OzZszVv3jy99dZbOnHihE6cOKG//e1vysrK0p133umNNgIAAHhFh6fPv/TSS3r00Uf1ne98R01NTV8+SUiIsrKy9Mtf/rLLGwgAAOAtV7ygYkNDgw4fPixJuvbaa9WrV68ubZi/oEYIAADz8fqCir169dKNN954pacDAAD4XIdrhAAAAAIFQQgAAFgWQQgAAFgWQQgAAFgWQQgAAFgWQQgAAFgWQQgAAFgWQQgAAFgWQQgAAFgWQQgAAFgWQQgAAFjWFd9rDJ1XUlGvo1WNGhTTS4NjA/OmtQAA+DOCkA/UNH6hxTl7tPVghX1bekqcsjNSFRke6sOWAQBgLQyN+cDinD3KP1TpsC3/UKUeytntoxYBAGBNBKFuVlJRr60HK3TRMBy2XzQMbT1YoSOVDd3Shrzicpev5ewYT84FAMAsGBrrZvtP17ncX3qmwWv1Qp4MyTk75n/uGKGfrNvHcB4AIKDQI9TN1nxc6nL/oBjvFU17MiTn7JjbV33EcB4AIODQI9SNSirqVVBa7XT/uIHRXusNah2Su9ylQ3LG//vv9o6pbmxyeS6z3gAAZkSPUDc6WtXocv+9kwb57LVLzzS4PcbVuQAAmJFpglBVVZUyMzMVERGhqKgoZWVlqb6+3unxpaWlstls7T7efPPNbmz5vw3sG+5y//CrIz16nispWHb32oNierk9xtW5AACYkWmGxjIzM3X69Gnl5uaqqalJ8+bN04IFC/T666+3e3xSUpJOnz7tsO3ll1/WL3/5S912223d0eQ2kuN6Kz0lTvmHKh1mjQXbbEobEut2eKkz6w95+trOjom4KkR155qvqN0A4K9Y2BY2w7hsHrcfKioq0vDhw1VQUKCxY8dKkjZu3KhZs2bpxIkTSkxM9Oh5UlNTNXr0aK1evdrpMRcuXNCFCxfsf9fV1SkpKUm1tbWKiIjo3BuRVNvYpIdydl9RmJm7ekebkBIkaXJKnNZkje+S13Z2zFN3jNBjzBoDECBY2Dbw1dXVKTIy0u33tymC0B/+8ActXbpU1dX/LjRubm5Wz5499eabb2r27Nlun6OwsFBjx45Vfn6+Jk2a5PS4n//853riiSfabO+qINTqSGWDSs80ePwrpKSiXl99fovT/esXpenGa6K67LWdHdPRdgOAP2rvh2VrL7cnPyzh/zwNQqaoESorK1N8fLzDtpCQEPXt21dlZWUePcfq1as1bNgwlyFIkpYvX67a2lr74/jx41fcblcGx/bS1OvjPQ4T7gqZ/+vtvV362s6O6Wi7AcDf+MPCtvAfPg1Cy5Ytc1rQ3Pr49NNPO/06586d0+uvv66srCy3x4aFhSkiIsLh4Q/cFTLvO1nHP143WBUbgOTZLFpYh0+LpZcuXap7773X5THJyclKSEhQeXm5w/bm5mZVVVUpISHB7ev89a9/VWNjo+bOnduZ5vpUclxvjUiM0L5Tzlem9uaq1GZGLQCAS3kyixbW4dMgFBcXp7i4OLfHTZw4UTU1NSosLNSYMWMkSZs2bVJLS4smTJjg9vzVq1frm9/8pkev5c+emj1St6/Kd7qff7ztc7WiNrUAgPV0dgYvAospaoSGDRummTNnav78+dqxY4fy8/O1aNEizZkzxz5j7OTJkxo6dKh27NjhcO6hQ4e0detW3X///b5oepcalRSl9JQ4BdkctwfbbEpPieMfbzuoBQDQnuyMVKUNiXXYljYkVtkZqT5qEXzFNOsIrV27VosWLdK0adMUFBSku+66SytXrrTvb2pqUnFxsRobHcd+//CHP+iaa67RjBkzurvJXpGdkdpmejv/eJ3zpBaAAAlYT2R4qNZkjWcmLMwxfd6XPJ1+1938/R+vvyxS5m7ZgbxHp/jl9QMAdI6n39+m6RGCo8Gx/hmA/K0wmVoAAIArpqgRgnm4Kkz2FWoBAADO0COELtNamHy5SwuTfdEDQy0AAMAZghC6jL8XJvvrcCIAwHcYGkOXYZEyAIDZEITQZVoLk4Ntjgsdsc4RAMBfEYTQpShMBgCYCTVC6FIUJgMAzIQgBK+gMBkAYAYMjQEAAMsiCAEAAMsiCAEAAMsiCAEAAMsiCAEAAMti1hgAAF2kpKJeR6saWTrERAhCAAB0Uk3jF1qcs8fhxtPpKXHKzkhVZHioD1sGdxgaAwCgkxbn7FH+oUqHbfmHKvVQzm4ftQieIggBANAJJRX12nqwQhcNw2H7RcPQ1oMVOlLZ4KOWwRMEIQAAOuFoVaPL/aVnCEL+jCAEAEAnDOwb7nL/oBiKpv0ZQQgAgE5Ijuut9JQ4BdtsDtuDbTalp8Qxe8zPEYQAAOik7IxUpQ2JddiWNiRW2RmpPmpR55VU1CuvuDzga5yYPg8AQCdFhodqTdZ4HalsUOmZBlOvI2S1pQDoEQIAoIsMju2lqdfHmzYESdKDa3c5hCBJ2nqwQt9fW+ijFnkXQQgAAEj6cjjs48Nn2t338eEzATlMRhACAACSpO1H2g9B9v0lrvebETVCAAAEkC3F5dpzokajB0Tr5pS4Dp5tc7nXcLnXnAhCAAAEgKNnGnTHqnxVNzbZt0WHh2r9wslKinG91lGrCYP7utx/U3JMp9rojxgaAwAgAFwegiSpurFJ31z1kcfPkRzXWxOdhJ2JyTGmLgJ3hiAEAIDJbSkubxOCWlU3NunDy2aBubLstus14uoIh23pKXF66e4xnWqjv2JoDAAAk9tzosbl/l3Hql3WC5VU1OvAqTq99nGpCo5W27ePSIzQ07NH6sakqC5qqf8hCAEAYHJfuSbK5f7RA6Lb3d7e4omXKjp9Vs+9/5nWZI3vbBP9FkNjAACY3C3XxyvayarP0eGhTnuDFufsUf6hSqfPe9EwtPVgRUCuH9SKIAQAQABYv3BymzDUOmusPSUV9dp6sEIXDfeT4kvPBG4QYmgMXa6kol5HqxpNfa8dADCbpJhw7f7pDH14sEK7jlW7XUfoaFWjx889KCZwP8sJQugyVrtRHwD4o5tT4jxaSHFgX/drCwXbbEobEhvQP2oZGkOnlFTUK6+4XEcqG9oda84/VKmHcnb7qHUAAGeS43orPSVOwTbnq0mnDYlVdkZqN7aq+9EjhCvibqZBq0sL7QL5FwUAmFF2Rqoeytnt8Fk+blC07pk0SDckRlric5sghCvibqbB5UrPEIQAwN9EhodqTdZ4HalsUOmZBkvWdhKE0GGtMw06IpAL7QDA7AbHWi8AtSIIocM6MtPACoV2AADzIgjBY63T4l0V1l3OCoV2AADzIgjBrfYKo6PDQ1V3rkkXL1mHq7X354nbb7DsWDMABIotxeXac6LG7XpEZkcQglvtFUbXNjYpMjzU4W7Hrb0/keGhBCAAMKmjZxp0x6p8h8/31hWqk2Lcrz1kNgQhuOSsMLpFUnVjk/6YNV7NLQa9PwAQIC4PQdKXn/ffXPWRdv90ho9a5T0sqAiX3BVGN7cYmnp9PCEIAALAluLyNiGoVXVjkz7s4IxhMyAIwSV3S7AzLR4AAseeEzUu9+86Vt09DelGBCG45GwJ9mCbTekpcfQEAUAA+co1US73jx4Q3T0N6UYEIbiVnZGqtCGxDtuYFg8A/unSe0B2VJKbUYBroimWhgWxBDsA+L/2ljoZNzBav79nnCLDQz16Dnd1oYF4uyR6hOCxwbG9KIwGAD+1OGePPrqsmLngaLWmPJenWicF0JezYl0oQQgAAJNrXeqkpZ191Y1Nun9NgUfPY8W6UIIQAkZnxsUBwMzcDWkVlFZ7/NlotbpQaoRgeu2Ni6enxNlXuQaAQOduSEtyrO9pvXdkezWfVqsLJQjB9Nq7BUj+oUo9lLNba7LG+6hVANB9zp5vUliITReaDafHDIrp1aEfjoNjvR+AXAWy7kIQgqk5uwXIRcPQ1oMVOlIZeDMcAKBVTeMX+v6fdmlbyRmnxwTbpLQhX9b3zF29wy9+OPpTTz41QjA1T6Z6AkCgWpyzx2UIkqTRA6OVnZFq/+F40XDsNbr0h2N3cdWT390IQjA1K071BADJeY/45R6cOkSR4aFufzjuP1XbVU1zyZ8CmUQQgslZcaonAEjue8Rbtf4gdPfD8bWPSzvbJI/4W08+QQimZ7WpngAgeTZTbNzAaPsPwuS43vrKNZFOj+3IFPvO8LeefIqlYXpWm+oJANK/e8SdDY9Fh4fq9/eMc9h2obm9JRf/rTtuodHa7vxDlQ7DY8E2m9KGxHb75zc9QggY3AIEgNVkZ6RqYnJMm+3D+0foyTtGqKrxC/u2kop6FZWddfl8n9ee75ZeIX/qybcZhuF80QGorq5OkZGRqq2tVUREhK+bAwBAG0cqG/RJyRmd+6JZ7+4tU8HRavu+1mnpu45Xa94rnt1qo7umsnuzJ9/T72/T9AhVVVUpMzNTERERioqKUlZWlurr612eU1ZWpu9+97tKSEhQr169NHr0aP3tb3/rphYDANA9Bsf2Usb4AdpcXKldx2oc9rVOS/ekpujSc+5fU+D12xb5Q0++aYJQZmam9u/fr9zcXG3YsEFbt27VggULXJ4zd+5cFRcXa/369dq7d6/uvPNOffvb39bu3d2/TgGuDPcPAwDPuJuWbvt/s2kvn2XbnouGoYLSL3uQpj63WXNX7/D4DvZmY4qhsaKiIg0fPlwFBQUaO3asJGnjxo2aNWuWTpw4ocTExHbP6927t1588UV997vftW+LiYnRM888o/vvv9+j12ZozDf8adVRADCDvOJyl0Nfj//HMPWL6KnXPi5VQWm10+OcmZgco5wFN3Wmid0qoIbGtm3bpqioKHsIkqTp06crKChI27dvd3repEmT9Oc//1lVVVVqaWnRG2+8ofPnz2vKlClOz7lw4YLq6uocHuh+/rTqKACYgbuhryc3FGnR67tVUFqtiJ4dnzS+reRMQPbOmyIIlZWVKT4+3mFbSEiI+vbtq7KyMqfn/eUvf1FTU5NiYmIUFham733ve3r77bc1ZMgQp+esWLFCkZGR9kdSUlKXvQ+zuXRYqjuHqPxt1VEAMIPkuN4aOzDao2Przjdf0Wt84uZ2Hmbk03WEli1bpmeeecblMUVFRVf8/I8//rhqamr0j3/8Q7GxsVq3bp2+/e1v68MPP9TIkSPbPWf58uV65JFH7H/X1dVZLgy1Nyx1KW8PUXmy6ihT5AHAUUlFvcYPitbOox0f9vKU++oi8/FpEFq6dKnuvfdel8ckJycrISFB5eXlDtubm5tVVVWlhISEds87fPiwfvOb32jfvn264YYbJEmjRo3Shx9+qFWrVumll15q97ywsDCFhYV1/M0EkAfX7tLHh52nfm/fqdjfVh0FAH/m7sdrR8T36aHys1843T+hnTWLzM6nQSguLk5xcXFuj5s4caJqampUWFioMWPGSJI2bdqklpYWTZgwod1zGhu/7FUICnIc/QsODlZLi+uVNa2spKLeZQiSHIeoLu2ZKamo19Gqxk6vB+Fvq45aUVf9bwnA+9qrqbxSrkJQalJUQH4emOIWG8OGDdPMmTM1f/58vfTSS2pqatKiRYs0Z84c+4yxkydPatq0aVqzZo3Gjx+voUOHasiQIfre976n5557TjExMVq3bp19+j3at/2I5+O/rUNU3pjhlZ2Rqodydjs8J/cP8z5m6wHm4ukd6LtC1s2Du+V1upspiqUlae3atRo6dKimTZumWbNmafLkyXr55Zft+5uamlRcXGzvCQoNDdX//d//KS4uTt/4xjd04403as2aNXrttdc0a9YsX70NE/B8BLh1iMobM7xa7x+W9+gUvTJvnPIenaI1WeP5MvYyZusB5uKupnLJ11K0flGa0lPcj7585Zool/tvSHR+w1YzM0WPkCT17dtXr7/+utP9gwYN0uVLIqWkpLCSdAdNGNzX7TGXDlE5+zXibPisowbHemdohqGftrz9vyWArueupvKbo65WdDs/IKPDQ1V9yQKJrT2/D+XstlxZgmmCELpHclxvTUyO0TYXUyQvHaJy92tk/T9P6pujrvabf0AM/TjHbD3AfDypqZy7ekebnt66c80aNyhaD04dokExvWQYhnYdr9ajt14nSZYqSyAIoY2X7h7Tpj5n3KBo3TNpkG5IjHT4MnT3a+SF3IN6IfegX4SNkop6LX5jtw6cclwk09uz4Nprhz/2RjFbDzAnVzWVrnp6C0qr1Tc8VD/7+/42Pw7XL0zTmcYv/O5zyhsIQmijtT7H1V2BL/0yb+/XyOW6O2xcyt3U0u4a+vH33ihm6wHm5Ooze9dx12sKPfb2PhWdPuuwrbX3yBef175gmmJpdL/27gpc0/iF5q7eoa8+v8V+M76miy2akOy6tsiXq0J7OrW09Ix322aGQuTsjFSlDYl12Bbo3eJAoLj8M7um8Qut2nTI5Tn7TtVZfhV/eoTQIe19mW8vOaMxA6OV9+gUrf/nSb2Qe9Dp+d1dZ9KRqaXeHPoxSyGyJ72BAPzT5cPui3P2aPexmnaPDbbZNCyxj/addH4/TavUBRKE4DFnX+YtkgqOVmtxzi7NTr3a5XN0d52JuwJgqXuGfsxWiOyt2Xpm4a91XN5m1fftDzpz7dsbdh83KNrlHeZHD4zST74+TLev+tjpMVapCyQIwSM1jV9o8Ruuh3D2nqzTXie/LnxVZ+KuAFjqnqEfCpHNwd/ruLzFqu/bH3TFtW+vp77Qzf3GHpw6RKOSoqkLFDVCcOLyu80vztnTZrZVR/iqzqS1ADjY5rhQZJCkEYkR3bZQo7N2BNtsSk+Js8wHjr8zQx2XN1j1ffuDzl771p76y+t8WpzPXZH07x9f1AXSI4TLtPfrZOzAK7+b8Yo7R+qm5BifftG3N7V0sg9+7XLbEP9mljqurmbV9+0PuuLauxt2D9KX5QutLu/toS6QIITLtPfrZNcVhiBJSojs6fN/VP7yD91f2oH2ma2Oq6tY9X37g6649u6G3ccMjFbBJZ/hzn58WbkukCAEO1fF0FfKn2pf/OUfur+0A46sWsdl1fftD7ri2rtb/4sfX+5RIwQ7t12snt+PldoXmI5V67is+r79QVdde3d1PpevL3R5DajV2YzL71QKB3V1dYqMjFRtba0iIiJ83RyvKqmo11ef3+J0/8irI5zOCrvcuEHR+v3cccw4ganUNja1qeOywuwpq75vf9CV195dz4/VZgd6+v1NEHLDSkFIkv3mfO11sc6bPEjzXinw6HlemTdOU6+P91YzAa+y6lCCVd+3P+iOa+/q8z0Qb6fh6fc3NUJwsHTGdapquKB9l0yVb+1iPdNwwePnoa4AZmbVOi6rvm9/4O1rz+xA5whCkNR+l+mIqyP09OyRuvGaKEnSmYYLGpEYoQOn6lwWUE/08XR5AIAjZgc6R7E0JLU/bb7o1Fk9995nDjda3ecmBEmSrQNF1QAA72N2oHMEIThdmbS1y3T+azvbhCRXWefjw2eYjQAAfoTZgc4RhOC2y7TgaHWbkOSuwr70DEEIAPwJt9NoHzVC8OjGpB1l5W5WAPBHrG7fPnqE4LLLdNygaJfnXr7IIt2sAODfLl9g0eoIQpDkvMv093PHOQ1JE5NjNHlIXJtzrN7NCgAwDxZUdMNqCyq212Xa3sqnl64cTTcrAMDfsKAirkh7i3oZMtR00XHSfEFptb6/tlAvZo5hETYAgGkxNAa3Fufs0baSM222f3z4jB7K2e2DFgHdi5tUAoGLHiG45GxZ9lZWX5odgc1qN6kErIgeIbjkbo0hiTWDELjaW3E9/1AlPaFAACEIwSVP1hhizSAEIncrrjNMBgQGglCA6qqahtY1hpxhzSAEKk9uUgnA/KgRCjDeqGnIzkjVA38qbFMwPenaGNYMQsDiJpWANRCEAoyrmoY1WeOv6Dkjw0OVs+AmHals0CclZ2STNCE5hp4gBLTW3tD8Q5UOw2PBNpvShsTy/38gQBCEAoizGV6X1jR05sOb9YJgNdkZqW0WE2X1dCCwEIQCiCc1DQQZwHPcpBIIfAShAEJNA+Ad9IYCgYtZYwHE1V3kmd0FAEBbBKEA4+wu8tQ0AADQFkNjAYaaBgAAPEcQClDUNAAA4B5DYwAAwLIIQgAAwLIIQgAAwLIIQgAAwLIIQgAAwLIIQgAAwLIIQgAAwLIIQgAAwLIIQgAAwLIIQgAAwLK4xYYbhmFIkurq6nzcEgAA4KnW7+3W73FnCEJunD17VpKUlJTk45YAAICOOnv2rCIjI53utxnuopLFtbS06NSpU+rTp4/Onj2rpKQkHT9+XBEREb5uWkCqq6vjGnsZ19j7uMbexzX2PrNfY8MwdPbsWSUmJiooyHklED1CbgQFBemaa66RJNlsNklSRESEKf9PYSZcY+/jGnsf19j7uMbeZ+Zr7KonqBXF0gAAwLIIQgAAwLIIQh0QFhamn/3sZwoLC/N1UwIW19j7uMbexzX2Pq6x91nlGlMsDQAALIseIQAAYFkEIQAAYFkEIQAAYFkEIQAAYFkEIQ+tWrVKgwYNUs+ePTVhwgTt2LHD100yrRUrVmjcuHHq06eP4uPjdccdd6i4uNjhmPPnz2vhwoWKiYlR7969ddddd+nzzz/3UYvN7xe/+IVsNpsefvhh+zauceedPHlSd999t2JiYnTVVVdp5MiR2rlzp32/YRj66U9/qv79++uqq67S9OnTdfDgQR+22FwuXryoxx9/XIMHD9ZVV12la6+9Vk8++aTDvaO4xh23detWfeMb31BiYqJsNpvWrVvnsN+Ta1pVVaXMzExFREQoKipKWVlZqq+v78Z30XUIQh7485//rEceeUQ/+9nPtGvXLo0aNUq33nqrysvLfd00U9qyZYsWLlyoTz75RLm5uWpqatKMGTPU0NBgP2bJkiV655139Oabb2rLli06deqU7rzzTh+22rwKCgr029/+VjfeeKPDdq5x51RXVystLU2hoaF69913deDAAT3//POKjo62H/Pss89q5cqVeumll7R9+3b16tVLt956q86fP+/DlpvHM888oxdffFG/+c1vVFRUpGeeeUbPPvussrOz7cdwjTuuoaFBo0aN0qpVq9rd78k1zczM1P79+5Wbm6sNGzZo69atWrBgQXe9ha5lwK3x48cbCxcutP998eJFIzEx0VixYoUPWxU4ysvLDUnGli1bDMMwjJqaGiM0NNR488037ccUFRUZkoxt27b5qpmmdPbsWSMlJcXIzc01brnlFuMHP/iBYRhc467w4x//2Jg8ebLT/S0tLUZCQoLxy1/+0r6tpqbGCAsLM3Jycrqjiab39a9/3bjvvvsctt15551GZmamYRhc464gyXj77bftf3tyTQ8cOGBIMgoKCuzHvPvuu4bNZjNOnjzZbW3vKvQIufHFF1+osLBQ06dPt28LCgrS9OnTtW3bNh+2LHDU1tZKkvr27StJKiwsVFNTk8M1Hzp0qAYMGMA176CFCxfq61//usO1lLjGXWH9+vUaO3as/vM//1Px8fFKTU3V7373O/v+I0eOqKyszOEaR0ZGasKECVxjD02aNEkffPCBPvvsM0nSP//5T3300Ue67bbbJHGNvcGTa7pt2zZFRUVp7Nix9mOmT5+uoKAgbd++vdvb3FncdNWNyspKXbx4Uf369XPY3q9fP3366ac+alXgaGlp0cMPP6y0tDSNGDFCklRWVqYePXooKirK4dh+/fqprKzMB600pzfeeEO7du1SQUFBm31c484rKSnRiy++qEceeUT/9V//pYKCAi1evFg9evTQPffcY7+O7X12cI09s2zZMtXV1Wno0KEKDg7WxYsX9dRTTykzM1OSuMZe4Mk1LSsrU3x8vMP+kJAQ9e3b15TXnSAEn1q4cKH27dunjz76yNdNCSjHjx/XD37wA+Xm5qpnz56+bk5Aamlp0dixY/X0009LklJTU7Vv3z699NJLuueee3zcusDwl7/8RWvXrtXrr7+uG264QXv27NHDDz+sxMRErjG6DENjbsTGxio4OLjNbJrPP/9cCQkJPmpVYFi0aJE2bNigvLw8XXPNNfbtCQkJ+uKLL1RTU+NwPNfcc4WFhSovL9fo0aMVEhKikJAQbdmyRStXrlRISIj69evHNe6k/v37a/jw4Q7bhg0bpmPHjkmS/Try2XHlfvjDH2rZsmWaM2eORo4cqe9+97tasmSJVqxYIYlr7A2eXNOEhIQ2k4Wam5tVVVVlyutOEHKjR48eGjNmjD744AP7tpaWFn3wwQeaOHGiD1tmXoZhaNGiRXr77be1adMmDR482GH/mDFjFBoa6nDNi4uLdezYMa65h6ZNm6a9e/dqz5499sfYsWOVmZlp/2+uceekpaW1Wfbhs88+08CBAyVJgwcPVkJCgsM1rqur0/bt27nGHmpsbFRQkOPXVHBwsFpaWiRxjb3Bk2s6ceJE1dTUqLCw0H7Mpk2b1NLSogkTJnR7mzvN19XaZvDGG28YYWFhxquvvmocOHDAWLBggREVFWWUlZX5ummm9P3vf9+IjIw0Nm/ebJw+fdr+aGxstB/zwAMPGAMGDDA2bdpk7Ny505g4caIxceJEH7ba/C6dNWYYXOPO2rFjhxESEmI89dRTxsGDB421a9ca4eHhxp/+9Cf7Mb/4xS+MqKgo4+9//7vxr3/9y7j99tuNwYMHG+fOnfNhy83jnnvuMa6++mpjw4YNxpEjR4y33nrLiI2NNX70ox/Zj+Ead9zZs2eN3bt3G7t37zYkGb/61a+M3bt3G0ePHjUMw7NrOnPmTCM1NdXYvn278dFHHxkpKSlGRkaGr95SpxCEPJSdnW0MGDDA6NGjhzF+/Hjjk08+8XWTTEtSu49XXnnFfsy5c+eMBx980IiOjjbCw8ON2bNnG6dPn/ZdowPA5UGIa9x577zzjjFixAgjLCzMGDp0qPHyyy877G9paTEef/xxo1+/fkZYWJgxbdo0o7i42EetNZ+6ujrjBz/4gTFgwACjZ8+eRnJysvHYY48ZFy5csB/DNe64vLy8dj+D77nnHsMwPLumZ86cMTIyMozevXsbERERxrx584yzZ8/64N10ns0wLlmiEwAAwEKoEQIAAJZFEAIAAJZFEAIAAJZFEAIAAJZFEAIAAJZFEAIAAJZFEAIAAJZFEAIAAJZFEAIAAJZFEAIQMDZu3CibzaaysjKH7f3799egQYMctpWWlspms9lvLjllyhTZbLY2jwceeMB+zqXbIyIiNG7cOP3973/3+vsC4D0EIQABY/LkyQoJCdHmzZvt24qKinTu3DlVV1ertLTUvj0vL09hYWFKS0uzb5s/f75Onz7t8Hj22WcdXuOVV17R6dOntXPnTqWlpelb3/qW9u7d6+23BsBLCEIATOmvf/2rRo4cqauuukoxMTGaPn26bDabxo0b5xCENm/erMmTJystLa3N9ptuukk9e/a0bwsPD1dCQoLDIyIiwuF1o6KilJCQoOuuu05PPvmkmpublZeX5+23C8BLCEIATOf06dPKyMjQfffdp6KiIm3evFl33nmnDMPQ1KlTHYJJXl6epkyZoltuucVh++bNmzV16tQrbkNzc7NWr14tSerRo8eVvxkAPsXd5wGYzq5duzRmzBiVlpZq4MCBDvv+8Y9/6Gtf+5pOnTql/v37q1+/ftqwYYOam5uVkZGh0tJSlZSU6Nprr9WWLVuUnp4u6csaoY8//rhNqPntb3+rzMxMSV/WCPXs2VPBwcE6d+6cWlpaNGjQIBUWFqpv377d8+YBdKkQXzcAADpq1KhRmjZtmkaOHKlbb71VM2bM0Le+9S1FR0dr0qRJ6tGjhzZv3qxRo0bp3LlzGj16tFpaWlRRUaEjR45o8+bNuuqqq3TTTTc5PG9mZqYee+wxh239+vVz+PuFF17Q9OnTVVJSoiVLlmjlypWEIMDECEIATCc4OFi5ubn6+OOP9f777ys7O1uPPfaYtm/frsGDB2v8+PHKy8tTVVWVJk+erODgYAUHB2vSpEnKy8tTXl6e0tLS2vT+REZGasiQIS5fOyEhQUOGDNGQIUP0yiuvaNasWTpw4IDi4+O9+ZYBeAk1QgBMyWazKS0tTU888YR2796tHj166O2335YkTZ06VZs3b9bmzZs1ZcoU+znp6enavHmztmzZ0qn6oFbjx4/XmDFj9NRTT3X6uQD4BkEIgOls375dTz/9tHbu3Kljx47prbfeUkVFhYYNGybpyyB08OBBvffee7rlllvs591yyy1at26djh8/3m4QamxsVFlZmcOjurraZVsefvhh/fa3v9XJkye79k0C6BYUSwMwnaKiIi1ZskS7du1SXV2dBg4cqIceekiLFi2SJJ0/f15RUVEKDQ1VdXW1QkK+rAK4cOGCoqKiFBIS4rBd+rJYesuWLW1e69Zbb9XGjRslfdkL9fbbb+uOO+6w7zcMQ8OHD9fUqVP1v//7v1581wC8gSAEAAAsi6ExAABgWQQhAABgWQQhAABgWQQhAABgWQQhAABgWQQhAABgWQQhAABgWQQhAABgWQQhAABgWQQhAABgWQQhAABgWf8/lwvRA1xNffsAAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "
" ] @@ -1160,7 +1195,7 @@ }, { "cell_type": "code", - "execution_count": 46, + "execution_count": 22, "metadata": {}, "outputs": [ { @@ -1169,13 +1204,13 @@ "" ] }, - "execution_count": 46, + "execution_count": 22, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1190,7 +1225,7 @@ }, { "cell_type": "code", - "execution_count": 47, + "execution_count": 23, "metadata": {}, "outputs": [ { @@ -1199,13 +1234,13 @@ "" ] }, - "execution_count": 47, + "execution_count": 23, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1220,7 +1255,7 @@ }, { "cell_type": "code", - "execution_count": 48, + "execution_count": 24, "metadata": {}, "outputs": [ { @@ -1229,13 +1264,13 @@ "" ] }, - "execution_count": 48, + "execution_count": 24, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1250,7 +1285,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 25, "metadata": {}, "outputs": [ { @@ -1268,7 +1303,7 @@ "\u001b[0;31mKeyError\u001b[0m: 'Experiment'", "\nThe above exception was the direct cause of the following exception:\n", "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[34], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m df_standard_flow_variations \u001b[38;5;241m=\u001b[39m df[\u001b[38;5;241m~\u001b[39mdf[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mJoint\u001b[39m\u001b[38;5;124m\"\u001b[39m]]\u001b[38;5;241m.\u001b[39mreplace(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m-\u001b[39m\u001b[38;5;124m\"\u001b[39m, np\u001b[38;5;241m.\u001b[39mnan)\n\u001b[0;32m----> 2\u001b[0m df_standard_flow_variations[\u001b[38;5;241m~\u001b[39m\u001b[43mdf_standard_flow_variations\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mExperiment\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[38;5;241m.\u001b[39mstr\u001b[38;5;241m.\u001b[39mcontains(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124msimple_encoder\u001b[39m\u001b[38;5;124m\"\u001b[39m) \u001b[38;5;241m&\u001b[39m \u001b[38;5;241m~\u001b[39mdf_standard_flow_variations[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mExperiment\u001b[39m\u001b[38;5;124m\"\u001b[39m]\u001b[38;5;241m.\u001b[39mstr\u001b[38;5;241m.\u001b[39mcontains(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mddi_actnorm\u001b[39m\u001b[38;5;124m\"\u001b[39m)]\n", + "Cell \u001b[0;32mIn[25], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m df_standard_flow_variations \u001b[38;5;241m=\u001b[39m df[\u001b[38;5;241m~\u001b[39mdf[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mJoint\u001b[39m\u001b[38;5;124m\"\u001b[39m]]\u001b[38;5;241m.\u001b[39mreplace(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m-\u001b[39m\u001b[38;5;124m\"\u001b[39m, np\u001b[38;5;241m.\u001b[39mnan)\n\u001b[0;32m----> 2\u001b[0m df_standard_flow_variations[\u001b[38;5;241m~\u001b[39m\u001b[43mdf_standard_flow_variations\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mExperiment\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[38;5;241m.\u001b[39mstr\u001b[38;5;241m.\u001b[39mcontains(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124msimple_encoder\u001b[39m\u001b[38;5;124m\"\u001b[39m) \u001b[38;5;241m&\u001b[39m \u001b[38;5;241m~\u001b[39mdf_standard_flow_variations[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mExperiment\u001b[39m\u001b[38;5;124m\"\u001b[39m]\u001b[38;5;241m.\u001b[39mstr\u001b[38;5;241m.\u001b[39mcontains(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mddi_actnorm\u001b[39m\u001b[38;5;124m\"\u001b[39m)]\n", "File \u001b[0;32m/work/tools22/users/lukas.rilling/sis_env/lib/python3.10/site-packages/pandas/core/frame.py:3896\u001b[0m, in \u001b[0;36mDataFrame.__getitem__\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m 3894\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mcolumns\u001b[38;5;241m.\u001b[39mnlevels \u001b[38;5;241m>\u001b[39m \u001b[38;5;241m1\u001b[39m:\n\u001b[1;32m 3895\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_getitem_multilevel(key)\n\u001b[0;32m-> 3896\u001b[0m indexer \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcolumns\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget_loc\u001b[49m\u001b[43m(\u001b[49m\u001b[43mkey\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 3897\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m is_integer(indexer):\n\u001b[1;32m 3898\u001b[0m indexer \u001b[38;5;241m=\u001b[39m [indexer]\n", "File \u001b[0;32m/work/tools22/users/lukas.rilling/sis_env/lib/python3.10/site-packages/pandas/core/indexes/base.py:3797\u001b[0m, in \u001b[0;36mIndex.get_loc\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m 3792\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(casted_key, \u001b[38;5;28mslice\u001b[39m) \u001b[38;5;129;01mor\u001b[39;00m (\n\u001b[1;32m 3793\u001b[0m \u001b[38;5;28misinstance\u001b[39m(casted_key, abc\u001b[38;5;241m.\u001b[39mIterable)\n\u001b[1;32m 3794\u001b[0m \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28many\u001b[39m(\u001b[38;5;28misinstance\u001b[39m(x, \u001b[38;5;28mslice\u001b[39m) \u001b[38;5;28;01mfor\u001b[39;00m x \u001b[38;5;129;01min\u001b[39;00m casted_key)\n\u001b[1;32m 3795\u001b[0m ):\n\u001b[1;32m 3796\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m InvalidIndexError(key)\n\u001b[0;32m-> 3797\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mKeyError\u001b[39;00m(key) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01merr\u001b[39;00m\n\u001b[1;32m 3798\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m:\n\u001b[1;32m 3799\u001b[0m \u001b[38;5;66;03m# If we have a listlike key, _check_indexing_error will raise\u001b[39;00m\n\u001b[1;32m 3800\u001b[0m \u001b[38;5;66;03m# InvalidIndexError. Otherwise we fall through and re-raise\u001b[39;00m\n\u001b[1;32m 3801\u001b[0m \u001b[38;5;66;03m# the TypeError.\u001b[39;00m\n\u001b[1;32m 3802\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_check_indexing_error(key)\n", "\u001b[0;31mKeyError\u001b[0m: 'Experiment'" @@ -1282,7 +1317,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": null, "metadata": {}, "outputs": [ { @@ -1573,7 +1608,7 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": null, "metadata": {}, "outputs": [ { @@ -1603,7 +1638,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": null, "metadata": {}, "outputs": [ { @@ -1633,7 +1668,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": {}, "outputs": [ { @@ -1663,7 +1698,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": null, "metadata": {}, "outputs": [ { diff --git a/users/rilling/evaluation/wer_eval.ipynb b/users/rilling/evaluation/wer_eval.ipynb index 81fcc25ad..2bf05746d 100644 --- a/users/rilling/evaluation/wer_eval.ipynb +++ b/users/rilling/evaluation/wer_eval.ipynb @@ -28,85 +28,85 @@ { "data": { "text/plain": [ - "['/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer_specaugment_before/tuning/lm_2.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer_specaugment_before/tuning/lm_3.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer_specaugment_before/tuning/lm_1.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer_specaugment_before/tuning/lm_4.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer_specaugment_before/tuning/lm_2.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer_specaugment_before/tuning/lm_3.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer_specaugment_before/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_x_vector_v2/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_3.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_2.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_4.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_1.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_3.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_2.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer/search/dev-other/sclite/wer',\n", + "['/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer/tuning/lm_1.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer/tuning/lm_4.0/search/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer/tuning/lm_2.5/search/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer/tuning/lm_3.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer/tuning/lm_4.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer/tuning/lm_1.5/search/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer/tuning/lm_2.0/search/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer/tuning/lm_3.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_two_forward_pass/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_3.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_2.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_3.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_2.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer_specaugment_before/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer_specaugment_before/tuning/lm_1.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer_specaugment_before/tuning/lm_4.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer_specaugment_before/tuning/lm_2.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer_specaugment_before/tuning/lm_3.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer_specaugment_before/tuning/lm_2.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer_specaugment_before/tuning/lm_3.0/search/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_4.0/search/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_1.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glow_ASR_conformer/tuning/lm_1.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_3.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_2.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_3.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_2.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_two_forward_pass/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_2.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_3.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_1.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_4.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_2.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_3.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_x_vector_v2/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_2.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_3.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_1.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_4.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_2.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_3.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_ASR_conformer_two_forward_pass/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glow_ASR_conformer/search/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glow_ASR_conformer/tuning/lm_4.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glow_ASR_conformer/tuning/lm_1.5/search/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glow_ASR_conformer/tuning/lm_3.5/search/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glow_ASR_conformer/tuning/lm_2.5/search/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glow_ASR_conformer/tuning/lm_3.0/search/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glow_ASR_conformer/tuning/lm_2.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glow_ASR_conformer/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_ASR_conformer_two_forward_pass/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_2.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_3.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_2.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_3.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_1.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_4.0/search/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_ASR_conformer_x_vector/search/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_ASR_conformer_x_vector/tuning/lm_3.0/search/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_ASR_conformer_x_vector/tuning/lm_2.0/search/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_ASR_conformer_x_vector/tuning/lm_3.5/search/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_ASR_conformer_x_vector/tuning/lm_2.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_ASR_conformer_x_vector/tuning/lm_1.5/search/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_ASR_conformer_x_vector/tuning/lm_4.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass/tuning/lm_2.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass/tuning/lm_3.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass/tuning/lm_4.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_ASR_conformer_x_vector/tuning/lm_1.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_control_radam/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer/tuning/lm_4.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer/tuning/lm_2.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer/tuning/lm_3.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer/tuning/lm_2.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer/tuning/lm_3.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer/tuning/lm_4.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1/tuning/lm_4.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1/tuning/lm_2.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1/tuning/lm_3.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1/tuning/lm_2.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1/tuning/lm_3.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1/tuning/lm_4.5/search/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass/tuning/lm_4.0/search/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass/tuning/lm_2.5/search/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass/tuning/lm_3.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment/tuning/lm_2.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment/tuning/lm_3.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment/tuning/lm_4.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment/tuning/lm_4.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment/tuning/lm_2.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment/tuning/lm_3.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_ddi_actnorm/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_control_spec_augment/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_ctc_scale_0.1/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_ctc_scale_0.1/tuning/lm_3.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_ctc_scale_0.1/tuning/lm_2.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_ctc_scale_0.1/tuning/lm_4.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_ctc_scale_0.1/tuning/lm_4.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_ctc_scale_0.1/tuning/lm_3.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_ctc_scale_0.1/tuning/lm_2.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/tuning/lm_4.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/tuning/lm_2.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/tuning/lm_3.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/tuning/lm_2.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/tuning/lm_3.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/tuning/lm_4.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass/tuning/lm_2.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass/tuning/lm_3.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass/tuning/lm_4.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment_tts_train_segments/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment_tts_train_segments/tuning/lm_4.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment_tts_train_segments/tuning/lm_3.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment_tts_train_segments/tuning/lm_2.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment_tts_train_segments/tuning/lm_3.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment_tts_train_segments/tuning/lm_2.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment_tts_train_segments/tuning/lm_4.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvector/search/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1_tts_segments/search/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1_tts_segments/tuning/lm_3.5/search/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1_tts_segments/tuning/lm_2.5/search/dev-other/sclite/wer',\n", @@ -114,597 +114,749 @@ " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1_tts_segments/tuning/lm_4.5/search/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1_tts_segments/tuning/lm_3.0/search/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1_tts_segments/tuning/lm_2.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_2.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_3.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_4.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_4.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_2.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_3.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_control/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/tuning/lm_2.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/tuning/lm_3.5/search/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/tuning/lm_4.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/tuning/lm_4.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/tuning/lm_2.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/tuning/lm_3.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/tuning/lm_2.5/search/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/tuning/lm_3.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/tuning/lm_2.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/tuning/lm_4.5/search/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_ctc_scale_0.1/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_ctc_scale_0.1/tuning/lm_4.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_ctc_scale_0.1/tuning/lm_3.5/search/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_ctc_scale_0.1/tuning/lm_2.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_ctc_scale_0.1/tuning/lm_3.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_ctc_scale_0.1/tuning/lm_2.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_ctc_scale_0.1/tuning/lm_3.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_ctc_scale_0.1/tuning/lm_4.0/search/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_ctc_scale_0.1/tuning/lm_4.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/tuning/lm_2.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/tuning/lm_3.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/tuning/lm_4.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/tuning/lm_4.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/tuning/lm_2.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/tuning/lm_3.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_ctc_scale_0.1/tuning/lm_2.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_ctc_scale_0.1/tuning/lm_3.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_ctc_scale_0.1/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment/tuning/lm_3.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment/tuning/lm_2.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment/tuning/lm_4.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment/tuning/lm_4.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment/tuning/lm_3.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment/tuning/lm_2.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment/search/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment_tts_train_segments/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment_tts_train_segments/tuning/lm_3.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment_tts_train_segments/tuning/lm_2.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment_tts_train_segments/tuning/lm_4.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment_tts_train_segments/tuning/lm_4.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment_tts_train_segments/tuning/lm_3.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment_tts_train_segments/tuning/lm_2.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_no_jit/tuning/lm_1.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_no_jit/tuning/lm_2.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_no_jit/tuning/lm_3.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_no_jit/tuning/lm_2.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_no_jit/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/tuning/lm_4.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/tuning/lm_3.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/tuning/lm_2.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/tuning/lm_3.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/tuning/lm_2.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/tuning/lm_4.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_control/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_coupling_epsilon/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector/tuning/lm_4.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector/tuning/lm_3.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector/tuning/lm_2.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector/tuning/lm_3.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector/tuning/lm_2.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector/tuning/lm_4.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_trainXvector/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/tuning/lm_4.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/tuning/lm_3.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/tuning/lm_2.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/tuning/lm_3.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/tuning/lm_2.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/tuning/lm_4.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector/tuning/lm_4.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector/tuning/lm_2.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector/tuning/lm_3.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector/tuning/lm_2.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector/tuning/lm_3.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector/tuning/lm_4.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_tts_train_segments/tuning/lm_2.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_tts_train_segments/tuning/lm_3.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_tts_train_segments/tuning/lm_4.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_tts_train_segments/tuning/lm_4.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_tts_train_segments/tuning/lm_2.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_tts_train_segments/tuning/lm_3.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_tts_train_segments/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_tts_train_segments/tuned/lm_2.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/tuning/lm_3.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/tuning/lm_2.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/tuning/lm_4.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/tuning/lm_4.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/tuning/lm_3.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/tuning/lm_2.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_ddi_actnorm/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/tuning/lm_4.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/tuning/lm_3.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/tuning/lm_2.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/tuning/lm_3.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/tuning/lm_2.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/tuning/lm_4.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/search/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/tuning/lm_4.0/search/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/tuning/lm_2.5/search/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/tuning/lm_3.5/search/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/tuning/lm_2.0/search/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/tuning/lm_3.0/search/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/tuning/lm_4.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/tuning/lm_3.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/tuning/lm_2.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/tuning/lm_4.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/tuning/lm_4.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/tuning/lm_3.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/tuning/lm_2.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ddi_actnorm/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1/tuning/lm_4.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1/tuning/lm_2.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1/tuning/lm_3.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1/tuning/lm_2.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1/tuning/lm_3.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1/tuning/lm_4.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer/tuning/lm_4.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer/tuning/lm_3.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer/tuning/lm_2.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/tuning/lm_4.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/tuning/lm_3.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/tuning/lm_2.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/tuning/lm_3.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/tuning/lm_2.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/tuning/lm_4.0/search/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer/tuning/lm_3.5/search/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer/tuning/lm_2.5/search/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer/tuning/lm_4.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_3.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_2.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_4.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_4.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_3.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_2.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_control_radam/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_encoder_sample_ctc_scale_0.1/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/tuning/lm_4.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/tuning/lm_3.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/tuning/lm_2.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/tuning/lm_3.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/tuning/lm_2.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/tuning/lm_4.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/tuning/lm_2.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/tuning/lm_3.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/tuning/lm_4.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/tuning/lm_4.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/tuning/lm_2.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/tuning/lm_3.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer/tuning/lm_4.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer/tuning/lm_3.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer/tuning/lm_2.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvector_eval/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvector_eval/tuning/lm_2.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvector_eval/tuning/lm_3.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvector_eval/tuning/lm_4.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvector_eval/tuning/lm_4.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvector_eval/tuning/lm_2.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvector_eval/tuning/lm_3.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector/tuning/lm_2.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector/tuning/lm_3.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector/tuning/lm_4.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector/tuning/lm_4.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector/tuning/lm_2.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector/tuning/lm_3.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_encoder_sample_ctc_scale_0.1/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/tuning/lm_3.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/tuning/lm_2.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/tuning/lm_4.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/tuning/lm_4.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/tuning/lm_3.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/tuning/lm_2.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/search/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v3/tuning/lm_4.5/search/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v3/tuning/lm_2.0/search/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v3/tuning/lm_3.0/search/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v3/tuning/lm_2.5/search/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v3/tuning/lm_3.5/search/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v3/tuning/lm_4.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/tuning/lm_4.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/tuning/lm_3.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/tuning/lm_2.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_4.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_3.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_2.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_3.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_2.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_4.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_tts_train_segments/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_tts_train_segments/tuned/lm_2.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_tts_train_segments/tuning/lm_2.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_tts_train_segments/tuning/lm_3.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_tts_train_segments/tuning/lm_4.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_tts_train_segments/tuning/lm_4.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_tts_train_segments/tuning/lm_2.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_tts_train_segments/tuning/lm_3.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_ctc_scale_0.1/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_ctc_scale_0.1/tuning/lm_2.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_ctc_scale_0.1/tuning/lm_3.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_ctc_scale_0.1/tuning/lm_4.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_ctc_scale_0.1/tuning/lm_4.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_ctc_scale_0.1/tuning/lm_2.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_ctc_scale_0.1/tuning/lm_3.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_coupling_epsilon/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/tuning/lm_4.5/search/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/tuning/lm_3.0/search/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/tuning/lm_2.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/tuning/lm_4.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/tuning/lm_3.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/tuning/lm_2.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/tuning/lm_4.0/search/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvector/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_trainXvector/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_control/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ddi_actnorm/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_control_spec_augment/search/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_radam/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer/tuning/lm_2.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer/tuning/lm_3.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer/tuning/lm_4.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer/tuning/lm_4.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer/tuning/lm_2.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer/tuning/lm_3.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step/ga_glowTTS_ASR_ffn_x_vector_v2_blstm_2ndstep_v2/no_specaug/ce_ls_1.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step/ga_glowTTS_ASR_ffn_x_vector_v2_blstm_2ndstep/no_specaug/ce_ls_1.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_control/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_3.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_2.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_4.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_4.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_3.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_2.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/tuning/lm_4.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/tuning/lm_2.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/tuning/lm_3.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/tuning/lm_2.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/tuning/lm_3.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/tuning/lm_4.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/tuning/lm_2.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/tuning/lm_3.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/tuning/lm_4.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/tuning/lm_4.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/tuning/lm_2.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/tuning/lm_3.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/tuning/lm_4.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/tuning/lm_3.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/tuning/lm_2.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/tuning/lm_3.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/tuning/lm_2.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/tuning/lm_4.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_no_jit/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_no_jit/tuning/lm_2.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_no_jit/tuning/lm_3.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_no_jit/tuning/lm_2.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_no_jit/tuning/lm_1.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector/tuning/lm_4.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector/tuning/lm_2.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector/tuning/lm_3.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector/tuning/lm_2.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector/tuning/lm_3.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector/tuning/lm_4.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector/search/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step/ga_glowTTS_ASR_ffn_x_vector_v2_blstm_2ndstep/specaug/ce_ls_1.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step/ga_glowTTS_ASR_ffn_x_vector_v2_blstm_2ndstep/no_specaug/ce_ls_1.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step/ga_glowTTS_ASR_ffn_x_vector_v2_blstm_2ndstep_v2/no_specaug/ce_ls_1.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_4x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/default/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval_spec_aug/not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/tuned/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/tuned/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/tuned/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/tuned/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/tuned/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/tuned/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/tuned/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/tuned/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/tuned/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/tuned/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/tuned/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/tuned/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/tuned/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/tuned/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/tuned/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/tuned/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/tuned/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/tuned/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/tuned/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/tuned/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/tuned/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/tuned/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/tuned/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/tuned/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm2.5_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm2.0_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm2.0_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm1.5_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm3.0_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm3.0_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm3.5_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm4.0_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm3.5_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm2.5_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm2.5_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm1.5_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm2.0_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm1.5_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm3.0_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm4.0_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm4.0_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm3.5_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm2.5_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm3.5_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm2.5_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm1.5_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm2.0_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm4.0_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm3.0_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm1.5_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm4.0_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm3.5_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm2.0_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm2.5_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm3.0_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm2.0_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm1.5_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm3.0_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm3.5_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm4.0_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc768_100ep_xvector/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_simple_encoder/silence_preprocessed/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment_before/glow_enc192_200ep_not_freezed/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment_before/glow_enc192_200ep/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/tuning/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/tuning/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/tuning/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/tuning/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/tuning/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/tuning/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/tuning/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/tuning/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/tuning/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/tuning/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/tuning/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/tuning/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/tuning/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/tuning/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/tuning/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/tuning/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/tuning/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/tuning/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/tuning/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/tuning/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/tuning/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/tuning/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/tuning/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/tuning/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/silence_preprocessing/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/tuning/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/tuning/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/tuning/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/tuning/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/tuning/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/tuning/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/tuning/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/tuning/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/tuning/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/tuning/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/tuning/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/tuning/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/silence_preprocessed/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm3.0_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm4.0_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm3.5_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm2.5_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm2.0_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm1.5_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm2.0_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm3.0_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm1.5_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm3.0_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm4.0_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm3.5_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm4.0_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm3.5_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm2.5_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm2.0_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm1.5_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm2.5_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm3.0_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm4.0_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm3.5_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm3.0_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm2.5_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm2.0_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm1.5_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm2.0_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm3.0_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm3.5_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm4.0_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm4.0_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm1.5_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm2.5_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm2.5_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm2.0_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm1.5_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm3.5_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/drop_around_blstm/lm5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/drop_around_blstm/spec_augment/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_nar_taco_encoder_16blocks/not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc768/with_sigma/not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc768/with_sigma/silence_preprocessing/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_nar_taco_encoder/not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_nar_taco_encoder/silence_preprocessed/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_with_small_enc/silence_preprocessed/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_simple_encoder/silence_preprocessed/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_simple_encoder_epoch84/silence_preprocessed/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc192/100epTTS/silence_preprocessed/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc192/200epsTTS_early_eval_ep100/silence_preprocessed/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc192/200epsTTS_early_eval_ep100/not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc192/not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc192/200epsTTS/silence_preprocessed/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc192/200epsTTS/not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/linear_1x512_d0.2_b300_fs4/glow_nar_taco_encoder_16blocks/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/linear_1x512_d0.2_b300_fs4/glow_enc768/tts_dataset/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x1024_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/tts_dataset/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/tuning/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/tuning/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/tuning/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/tuning/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/tuning/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/tuning/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/tuning/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/tuning/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/tuning/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/tuning/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/tuning/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/tuning/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/tuning/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/tuning/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/tuning/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/tuning/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/tuning/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/tuning/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/tuning/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/tuning/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/tuning/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/tuning/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/tuning/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/tuning/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/default_250/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/tts_dataset/spec_augment/no_glow/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/tuned/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/layer_norm/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/batch_norm/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/tuning/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/tuning/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/tuning/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/tuning/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/tuning/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/tuning/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/tuning/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/tuning/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/tuning/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/tuning/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/tuning/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/tuning/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.4/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/tuning/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/tuning/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/tuning/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/tuning/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/tuning/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/tuning/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/tuning/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/tuning/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/tuning/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/tuning/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/tuning/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/tuning/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.1/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.2/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment_before/glow_enc192_200ep_not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/lm_tuning/lm2.0_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/lm_tuning/lm1.5_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/lm_tuning/lm2.5_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/lm_tuning/lm3.5_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/lm_tuning/lm4.0_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/lm_tuning/lm3.0_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/lm_tuning/lm3.0_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/lm_tuning/lm2.0_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/lm_tuning/lm1.5_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/lm_tuning/lm2.0_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/lm_tuning/lm2.5_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/lm_tuning/lm1.5_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/lm_tuning/lm4.0_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/lm_tuning/lm4.0_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/lm_tuning/lm3.5_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/lm_tuning/lm2.5_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/lm_tuning/lm3.0_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/lm_tuning/lm3.5_ps0/default_250/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm3.0_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm3.5_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm4.0_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm2.0_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm2.5_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm3.0_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm2.5_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm2.0_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm2.0_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm1.5_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm3.0_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm3.5_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm4.0_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm2.5_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm2.5_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm1.5_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm3.5_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm2.0_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm3.0_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm4.0_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm4.0_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm1.5_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm3.5_ps0.3/default_250/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm3.0_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm2.5_ps0.5/default_250/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm2.0_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm2.0_ps0/default_250/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm1.5_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm4.0_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm3.0_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm1.5_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm4.0_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm3.5_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm3.0_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm3.5_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm4.0_ps0.5/default_250/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm2.5_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm3.5_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm2.5_ps0/default_250/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm1.5_ps0.5/default_250/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm2.0_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm2.5_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm1.5_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm2.0_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm3.5_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm2.5_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm2.5_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm1.5_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm4.0_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm3.5_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm4.0_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm3.0_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm2.0_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm1.5_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm2.0_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm2.5_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm3.0_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm3.5_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm4.0_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm3.0_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/tuned/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/batch_norm/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/layer_norm/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm4.0_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm3.5_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm3.0_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm4.0_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm4.0_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm3.5_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm1.5_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/weak_baseline/lm_tuning/lm3.0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/weak_baseline/lm_tuning/lm2.0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/weak_baseline/lm_tuning/lm3.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/weak_baseline/lm_tuning/lm2.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/weak_baseline/lm_tuning/lm1.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/weak_baseline/lm_tuning/lm4.0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/weak_baseline/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm2.5_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm2.0_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm1.5_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm3.0_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm3.0_ps0.3/default_250/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm2.0_ps0/default_250/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm3.5_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm3.0_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm3.0_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm1.5_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm2.0_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm2.5_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm3.5_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm3.5_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm4.0_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm2.5_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm3.0_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm1.5_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm2.0_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm4.0_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm2.5_ps0.3/default_250/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm4.0_ps0/default_250/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm1.5_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm2.5_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm2.0_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm1.5_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm3.0_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm2.5_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm4.0_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm3.5_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm3.5_ps0/default_250/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm2.0_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm2.5_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm3.0_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm1.5_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm2.0_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm3.0_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm4.0_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm3.5_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm3.5_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm2.5_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm2.0_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm2.5_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm1.5_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm4.0_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm1.5_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm3.0_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm3.5_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm4.0_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm1.5_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm1.5_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm4.0_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/default_250/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm2.0_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm4.0_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm1.5_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm1.5_ps0/default_250/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm2.5_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm3.5_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm4.0_ps0.3/default_250/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm3.5_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm2.5_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm4.0_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm3.5_ps0/default_250/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm3.0_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm2.0_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm2.5_ps0/default_250/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm1.5_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm2.0_ps0.3/default_250/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm2.5_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm2.0_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm3.5_ps0.5/default_250/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm4.0_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm3.0_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm3.5_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm2.0_ps0/default_250/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm3.0_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm3.0_ps0/default_250/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_v2/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/tuned/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/tuned_no_prior/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.4/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/tuning/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/tuning/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/tuning/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/tuning/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/tuning/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/tuning/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/tuning/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/tuning/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/tuning/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/tuning/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/tuning/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/tuning/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/tuning/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/tuning/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/tuning/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/tuning/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/tuning/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/tuning/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/tuning/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/tuning/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/tuning/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/tuning/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/tuning/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/tuning/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.1/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm1.5_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm2.0_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm2.5_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm2.5_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm3.5_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm4.0_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm3.5_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm3.0_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm1.5_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm4.0_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm2.0_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm1.5_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm3.0_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm2.5_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm2.0_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm3.5_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm4.0_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm3.0_ps0.5/default_250/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.2/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/default_250/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_v3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_200ep_not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/weak_baseline/lm_tuning/lm3.0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/weak_baseline/lm_tuning/lm2.0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/weak_baseline/lm_tuning/lm1.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/weak_baseline/lm_tuning/lm4.0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/weak_baseline/lm_tuning/lm3.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/weak_baseline/lm_tuning/lm2.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/weak_baseline/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/test/blstm512/warmup/d0.2_b100/default_250/extra/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_4x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x1024_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/tts_dataset/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/tuning/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/tuning/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/tuning/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/tuning/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/tuning/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/tuning/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/tuning/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/tuning/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/tuning/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/tuning/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/tuning/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/tuning/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/lm5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/tuning/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/tuning/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/tuning/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/tuning/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/tuning/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/tuning/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/tuning/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/tuning/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/tuning/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/tuning/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/tuning/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/tuning/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/silence_preprocessing/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/tuning/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/tuning/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/tuning/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/tuning/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/tuning/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/tuning/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/tuning/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/tuning/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/tuning/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/tuning/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/tuning/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/tuning/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/tuning/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/tuning/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/tuning/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/tuning/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/tuning/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/tuning/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/tuning/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/tuning/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/tuning/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/tuning/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/tuning/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/tuning/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/silence_preprocessed/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment_before/glow_enc192_200ep_not_freezed/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment_before/glow_enc192_200ep/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_simple_encoder/silence_preprocessed/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm2.5_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm2.0_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm1.5_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm2.0_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm3.0_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm3.0_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm3.5_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm4.0_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm4.0_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm2.5_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm1.5_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm1.5_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm2.0_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm3.0_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm3.5_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm4.0_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm3.5_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm2.5_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm2.0_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm1.5_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm2.0_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm3.0_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm2.5_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm4.0_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm3.5_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm3.0_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm2.0_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm1.5_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm3.5_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm2.5_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm2.5_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm3.5_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm4.0_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm4.0_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm1.5_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm3.0_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm4.0_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm3.5_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm3.0_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm1.5_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm2.0_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm3.0_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm2.5_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm2.0_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm3.5_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm4.0_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm3.0_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm1.5_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm4.0_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm2.0_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm2.5_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm1.5_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm3.5_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm2.5_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm3.0_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm4.0_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm3.5_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm3.0_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm2.5_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm2.0_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm1.5_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm2.0_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm3.0_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm3.5_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm4.0_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm4.0_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm1.5_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm2.5_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm2.5_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm2.0_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm1.5_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm3.5_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc768_100ep_xvector/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/drop_around_blstm/lm5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/drop_around_blstm/spec_augment/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/default/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/tuned/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/tuned/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/tuned/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/tuned/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/tuned/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/tuned/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/tuned/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/tuned/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/tuned/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/tuned/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/tuned/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/tuned/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/tuned/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/tuned/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/tuned/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/tuned/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/tuned/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/tuned/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/tuned/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/tuned/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/tuned/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/tuned/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/tuned/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/tuned/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval_spec_aug/not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_nar_taco_encoder_16blocks/not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc192/200epsTTS_early_eval_ep100/not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc192/200epsTTS_early_eval_ep100/silence_preprocessed/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc192/not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc192/200epsTTS/silence_preprocessed/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc192/200epsTTS/not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc192/100epTTS/silence_preprocessed/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_with_small_enc/silence_preprocessed/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_simple_encoder/silence_preprocessed/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc768/with_sigma/not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc768/with_sigma/not_silence_preprocessed/lm5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc768/with_sigma/silence_preprocessing/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_simple_encoder_epoch84/silence_preprocessed/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_nar_taco_encoder/not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_nar_taco_encoder/silence_preprocessed/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/linear_1x512_d0.2_b300_fs4/glow_enc768/tts_dataset/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/linear_1x512_d0.2_b300_fs4/glow_nar_taco_encoder_16blocks/default_250/dev-other/sclite/wer']" + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/tuned_no_prior/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/tuned/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_v2/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer']" ] }, "execution_count": 2, @@ -929,7 +1081,8 @@ "outputs": [], "source": [ "df_final = df_indexed.round(decimals=3)\n", - "df_final = df_final.fillna(\"-\")" + "df_final = df_final.fillna(\"-\")\n", + "df_final[\"Missing glow.eval\"] = df_final[\"Experiment\"].str.contains(\"glow_not_eval\")" ] }, { @@ -948,66 +1101,62 @@ "name": "stdout", "output_type": "stream", "text": [ - "| | Group | Experiment | WER (dev-other) | Count | Tuned | CTC | dev CTC | overfitting | dev MLE | dev DP | Joint | Still running | Training data available | Num Epochs | LR | ASR Model Type |\n", - "|----:|:--------------------------------|:------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|------------------:|--------:|:--------|:------|:----------|:--------------|:--------------------|:--------------------|:--------|:----------------|:--------------------------|:-------------|:-------------------------------------------------|:-----------------|\n", - "| 9 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ddi_actnorm/ | 66.7 | 1 | False | 0.282 | 0.583 | 2.068 | -0.696242607904203 | 0.4012426779125676 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 11 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_control/ | 38.5 | 1 | False | 0.216 | 0.735 | 3.408 | -0.7795215357433666 | 1.5493716010541627 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 12 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_control_radam/ | 38.3 | 1 | False | 0.214 | 0.731 | 3.414 | -0.7803357613809181 | 1.4600530691219098 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 13 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_control_spec_augment/ | 37.9 | 1 | False | 0.501 | 0.588 | 1.173 | -0.7782901200381193 | 1.4496996285337391 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 15 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_ddi_actnorm/ | 94.4 | 1 | False | 0.165 | 1.062 | 6.429 | -0.5203935901323954 | 0.21473516580281835 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 16 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_encoder_sample_ctc_scale_0.1/ | 100 | 1 | False | 3.481 | 6.325 | 1.817 | -0.7816050729968331 | 1.1355000418243986 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 17 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_radam/ | 43.8 | 1 | False | 0.098 | 1.135 | 11.599 | -0.5829270274350138 | 0.34816459318002063 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 21 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_trainXvector/ | 47 | 1 | False | 0.046 | 1.485 | 32.45 | -0.5923372669653459 | 0.586278223855929 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 32 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_coupling_epsilon/ | 30.4 | 1 | False | 0.243 | 0.576 | 2.37 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 36 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_control/ | 46.3 | 1 | False | 0.233 | 0.916 | 3.927 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 39 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvector/ | 43.5 | 1 | False | 0.251 | 0.762 | 3.03 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 44 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step/ga_glowTTS_ASR_ffn_x_vector_v2_blstm_2ndstep/no_specaug/ce_ls_1.0/ | 81 | 1 | False | 0.036 | 2.023 | 55.937 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 45 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step/ga_glowTTS_ASR_ffn_x_vector_v2_blstm_2ndstep/specaug/ce_ls_1.0/ | 79.5 | 1 | False | 1.182 | 0.749 | 0.634 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 46 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step/ga_glowTTS_ASR_ffn_x_vector_v2_blstm_2ndstep_v2/no_specaug/ce_ls_1.0/ | 86.9 | 1 | False | 0.006 | 3.047 | 476.04 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 47 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x1024_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/ | 66.4 | 1 | False | 0.582 | 1.039 | 1.786 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 48 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/default/ | 55.1 | 1 | False | 0.177 | 1.151 | 6.489 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 49 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/drop_around_blstm/lm5/ | 66.3 | 1 | False | 0.599 | 0.948 | 1.581 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 50 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/drop_around_blstm/spec_augment/ | 94.2 | 1 | False | 2.438 | 1.396 | 0.573 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 52 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval_spec_aug/not_silence_preprocessed/ | 67.7 | 1 | False | 0.725 | 1.04 | 1.434 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 56 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/silence_preprocessed/ | 78.1 | 1 | False | 0.779 | 1.163 | 1.493 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 57 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/ | 73.4 | 1 | False | 0.667 | 1.099 | 1.648 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 59 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/lm5/ | 73.4 | 1 | False | 0.667 | 1.099 | 1.648 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 60 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/silence_preprocessing/ | 76.2 | 1 | False | 0.71 | 1.15 | 1.62 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 61 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_simple_encoder/silence_preprocessed/ | 50.3 | 1 | False | 0.046 | 1.527 | 33.333 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 66 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc768_100ep_xvector/ | 62.4 | 1 | False | 0.326 | 1.049 | 3.219 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 67 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment_before/glow_enc192_200ep/ | 92.4 | 1 | False | 2.272 | 1.371 | 0.604 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 68 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment_before/glow_enc192_200ep_not_freezed/ | 30.9 | 1 | False | 0.172 | 0.56 | 3.248 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 69 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc192/100epTTS/silence_preprocessed/ | 59.7 | 1 | False | 0.356 | 1.057 | 2.966 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 70 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc192/200epsTTS/not_silence_preprocessed/ | 61.8 | 1 | False | 0.449 | 1.042 | 2.32 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 71 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc192/200epsTTS/silence_preprocessed/ | 61.8 | 1 | False | 0.408 | 1.04 | 2.552 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 72 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc192/200epsTTS_early_eval_ep100/not_silence_preprocessed/ | 60.6 | 1 | False | 0.385 | 1.046 | 2.718 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 73 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc192/200epsTTS_early_eval_ep100/silence_preprocessed/ | 60.8 | 1 | False | 0.35 | 1.066 | 3.045 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 74 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc192/not_silence_preprocessed/ | 61.1 | 1 | False | 0.402 | 1.038 | 2.579 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 75 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc768/with_sigma/not_silence_preprocessed/ | 70.4 | 1 | False | 0.737 | 1.107 | 1.503 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 76 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc768/with_sigma/not_silence_preprocessed/lm5/ | 70.4 | 1 | False | 0.737 | 1.107 | 1.503 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 77 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc768/with_sigma/silence_preprocessing/ | 71.9 | 1 | False | 0.767 | 1.135 | 1.479 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 78 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_nar_taco_encoder/not_silence_preprocessed/ | 66.2 | 1 | False | 0.668 | 1.026 | 1.535 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 79 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_nar_taco_encoder/silence_preprocessed/ | 67.7 | 1 | False | 0.622 | 1.081 | 1.738 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 80 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_nar_taco_encoder_16blocks/not_silence_preprocessed/ | 55.1 | 1 | False | 0.105 | 1.32 | 12.536 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 81 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_simple_encoder/silence_preprocessed/ | 56.9 | 1 | False | 0.096 | 1.431 | 14.855 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 82 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_simple_encoder_epoch84/silence_preprocessed/ | 57.4 | 1 | False | 0.079 | 1.519 | 19.301 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 83 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_with_small_enc/silence_preprocessed/ | 79.4 | 1 | False | 1.103 | 1.283 | 1.163 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 84 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_4x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/ | 52.4 | 1 | False | 0.378 | 0.812 | 2.15 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 90 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.1/ | 25.8 | 1 | False | 0.406 | 0.422 | 1.041 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 91 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.2/ | 25.5 | 1 | False | 0.413 | 0.417 | 1.01 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 92 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/ | 26.2 | 1 | False | 0.44 | 0.415 | 0.943 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 93 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.4/ | 25.2 | 1 | False | 0.416 | 0.413 | 0.993 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 97 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/batch_norm/ | 29.4 | 1 | False | 0.392 | 0.504 | 1.285 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 98 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/layer_norm/ | 28.5 | 1 | False | 0.407 | 0.488 | 1.197 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 100 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_v2/ | 26.6 | 1 | False | 0.216 | 0.589 | 2.724 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 101 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_v3/ | 26.3 | 1 | False | 0.211 | 0.591 | 2.799 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 106 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/ | 41.3 | 1 | False | 0.423 | 0.751 | 1.777 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 109 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_200ep_not_silence_preprocessed/ | 100 | 1 | False | 3.454 | 5.802 | 1.68 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 111 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/tts_dataset/spec_augment/no_glow/ | 20.9 | 1 | False | 0.091 | 0.419 | 4.591 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 112 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/linear_1x512_d0.2_b300_fs4/glow_enc768/tts_dataset/ | 99.7 | 1 | False | 2.628 | 2.609 | 0.993 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | unknown |\n", - "| 113 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/linear_1x512_d0.2_b300_fs4/glow_nar_taco_encoder_16blocks/ | 98.8 | 1 | False | 2.23 | 2.39 | 1.072 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | unknown |\n", - "| 115 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/tts_dataset/ | 59.8 | 1 | False | 0.071 | 1.537 | 21.521 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 116 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/test/blstm512/warmup/d0.2_b100/default_250/extra/dev-other/sclite/wer | 127.9 | 1 | False | - | - | - | - | - | False | False | True | - | - | blstm |\n" + "| | Group | Experiment | WER (dev-other) | Count | Tuned | CTC | dev CTC | overfitting | dev MLE | dev DP | Joint | Still running | Training data available | Num Epochs | LR | ASR Model Type | Missing glow.eval |\n", + "|----:|:--------------------------------|:------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|------------------:|--------:|:--------|------:|----------:|--------------:|:--------------------|:--------------------|:--------|:----------------|:--------------------------|-------------:|:-------------------------------------------------|:-----------------|:--------------------|\n", + "| 9 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ddi_actnorm/ | 66.7 | 1 | False | 0.282 | 0.583 | 2.068 | -0.696242607904203 | 0.4012426779125676 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 11 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_control/ | 38.5 | 1 | False | 0.216 | 0.735 | 3.408 | -0.7795215357433666 | 1.5493716010541627 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 12 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_control_radam/ | 38.3 | 1 | False | 0.214 | 0.731 | 3.414 | -0.7803357613809181 | 1.4600530691219098 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 13 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_control_spec_augment/ | 37.9 | 1 | False | 0.501 | 0.588 | 1.173 | -0.7782901200381193 | 1.4496996285337391 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 15 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_ddi_actnorm/ | 94.4 | 1 | False | 0.165 | 1.062 | 6.429 | -0.5203935901323954 | 0.21473516580281835 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 16 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_encoder_sample_ctc_scale_0.1/ | 100 | 1 | False | 3.481 | 6.325 | 1.817 | -0.7816050729968331 | 1.1355000418243986 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 17 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_radam/ | 43.8 | 1 | False | 0.098 | 1.135 | 11.599 | -0.5829270274350138 | 0.34816459318002063 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 21 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_trainXvector/ | 47 | 1 | False | 0.046 | 1.485 | 32.45 | -0.5923372669653459 | 0.586278223855929 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 32 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_coupling_epsilon/ | 30.4 | 1 | False | 0.243 | 0.576 | 2.37 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 36 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_control/ | 46.3 | 1 | False | 0.233 | 0.916 | 3.927 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 39 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvector/ | 43.5 | 1 | False | 0.251 | 0.762 | 3.03 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 45 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step/ga_glowTTS_ASR_ffn_x_vector_v2_blstm_2ndstep/no_specaug/ce_ls_1.0/ | 81 | 1 | False | 0.036 | 2.023 | 55.937 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 46 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step/ga_glowTTS_ASR_ffn_x_vector_v2_blstm_2ndstep/specaug/ce_ls_1.0/ | 79.5 | 1 | False | 1.182 | 0.749 | 0.634 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 47 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step/ga_glowTTS_ASR_ffn_x_vector_v2_blstm_2ndstep_v2/no_specaug/ce_ls_1.0/ | 86.9 | 1 | False | 0.006 | 3.047 | 476.04 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 48 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x1024_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/ | 66.4 | 1 | False | 0.582 | 1.039 | 1.786 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 49 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/default/ | 55.1 | 1 | False | 0.177 | 1.151 | 6.489 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 50 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/drop_around_blstm/lm5/ | 66.3 | 1 | False | 0.599 | 0.948 | 1.581 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 51 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/drop_around_blstm/spec_augment/ | 94.2 | 1 | False | 2.438 | 1.396 | 0.573 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 53 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval_spec_aug/not_silence_preprocessed/ | 67.7 | 1 | False | 0.725 | 1.04 | 1.434 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 57 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/silence_preprocessed/ | 78.1 | 1 | False | 0.779 | 1.163 | 1.493 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 58 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/ | 73.4 | 1 | False | 0.667 | 1.099 | 1.648 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 60 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/silence_preprocessing/ | 76.2 | 1 | False | 0.71 | 1.15 | 1.62 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 61 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_simple_encoder/silence_preprocessed/ | 50.3 | 1 | False | 0.046 | 1.527 | 33.333 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 66 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc768_100ep_xvector/ | 62.4 | 1 | False | 0.326 | 1.049 | 3.219 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 67 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment_before/glow_enc192_200ep/ | 92.4 | 1 | False | 2.272 | 1.371 | 0.604 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 68 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment_before/glow_enc192_200ep_not_freezed/ | 30.9 | 1 | False | 0.172 | 0.56 | 3.248 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 69 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc192/100epTTS/silence_preprocessed/ | 59.7 | 1 | False | 0.356 | 1.057 | 2.966 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 70 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc192/200epsTTS/not_silence_preprocessed/ | 61.8 | 1 | False | 0.449 | 1.042 | 2.32 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 71 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc192/200epsTTS/silence_preprocessed/ | 61.8 | 1 | False | 0.408 | 1.04 | 2.552 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 72 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc192/200epsTTS_early_eval_ep100/not_silence_preprocessed/ | 60.6 | 1 | False | 0.385 | 1.046 | 2.718 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 73 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc192/200epsTTS_early_eval_ep100/silence_preprocessed/ | 60.8 | 1 | False | 0.35 | 1.066 | 3.045 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 74 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc192/not_silence_preprocessed/ | 61.1 | 1 | False | 0.402 | 1.038 | 2.579 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 75 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc768/with_sigma/not_silence_preprocessed/ | 70.4 | 1 | False | 0.737 | 1.107 | 1.503 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 76 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc768/with_sigma/silence_preprocessing/ | 71.9 | 1 | False | 0.767 | 1.135 | 1.479 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 77 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_nar_taco_encoder/not_silence_preprocessed/ | 66.2 | 1 | False | 0.668 | 1.026 | 1.535 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 78 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_nar_taco_encoder/silence_preprocessed/ | 67.7 | 1 | False | 0.622 | 1.081 | 1.738 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 79 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_nar_taco_encoder_16blocks/not_silence_preprocessed/ | 55.1 | 1 | False | 0.105 | 1.32 | 12.536 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 80 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_simple_encoder/silence_preprocessed/ | 56.9 | 1 | False | 0.096 | 1.431 | 14.855 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 81 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_simple_encoder_epoch84/silence_preprocessed/ | 57.4 | 1 | False | 0.079 | 1.519 | 19.301 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 82 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_with_small_enc/silence_preprocessed/ | 79.4 | 1 | False | 1.103 | 1.283 | 1.163 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 83 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_4x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/ | 52.4 | 1 | False | 0.378 | 0.812 | 2.15 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 94 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_v2/ | 26.6 | 1 | False | 0.216 | 0.589 | 2.724 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 95 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_v3/ | 26.3 | 1 | False | 0.211 | 0.591 | 2.799 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 108 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.1/ | 25.8 | 1 | False | 0.406 | 0.422 | 1.041 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | True |\n", + "| 109 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.2/ | 25.5 | 1 | False | 0.413 | 0.417 | 1.01 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | True |\n", + "| 110 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/ | 26.2 | 1 | False | 0.44 | 0.415 | 0.943 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | True |\n", + "| 111 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.4/ | 25.2 | 1 | False | 0.416 | 0.413 | 0.993 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | True |\n", + "| 115 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/batch_norm/ | 29.4 | 1 | False | 0.392 | 0.504 | 1.285 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | True |\n", + "| 116 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/layer_norm/ | 28.5 | 1 | False | 0.407 | 0.488 | 1.197 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | True |\n", + "| 118 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment_before/glow_enc192_200ep_not_silence_preprocessed/ | 100 | 1 | False | 3.454 | 5.802 | 1.68 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | True |\n", + "| 119 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/tts_dataset/spec_augment/no_glow/ | 20.9 | 1 | False | 0.091 | 0.419 | 4.591 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 120 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/linear_1x512_d0.2_b300_fs4/glow_enc768/tts_dataset/ | 99.7 | 1 | False | 2.628 | 2.609 | 0.993 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | unknown | False |\n", + "| 121 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/linear_1x512_d0.2_b300_fs4/glow_nar_taco_encoder_16blocks/ | 98.8 | 1 | False | 2.23 | 2.39 | 1.072 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | unknown | False |\n", + "| 124 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/tts_dataset/ | 59.8 | 1 | False | 0.071 | 1.537 | 21.521 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n" ] } ], @@ -1033,18 +1182,19 @@ "name": "stdout", "output_type": "stream", "text": [ - "| | Group | Experiment | WER (dev-other) | Count | Tuned | CTC | dev CTC | overfitting | dev MLE | dev DP | Joint | Still running | Training data available | Num Epochs | LR | ASR Model Type |\n", - "|----:|:---------------------|:----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|------------------:|--------:|:--------|------:|----------:|--------------:|:----------|:---------|:--------|:----------------|:--------------------------|-------------:|:-----------------------------------------------|:-----------------|\n", - "| 51 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/ | 58 | 13 | True | 0.022 | 2.315 | 104.406 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 53 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/ | 44.6 | 13 | True | 0.326 | 1.042 | 3.202 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 54 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/ | 63.8 | 13 | True | 0.065 | 2.401 | 36.955 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 55 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/ | 55.4 | 13 | True | 0.882 | 1.139 | 1.292 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 58 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/ | 63.2 | 13 | True | 0.062 | 2.427 | 39.391 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 62 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/ | 34 | 19 | True | 0.058 | 0.913 | 15.782 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 63 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/ | 33.8 | 19 | True | 0.003 | 1.209 | 454.454 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 64 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/ | 31.4 | 19 | True | 0.024 | 0.926 | 39.211 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 65 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/ | 23.9 | 19 | True | 0.187 | 0.566 | 3.019 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 114 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/ | 49.4 | 13 | True | 0.028 | 1.672 | 58.743 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n" + "| | Group | Experiment | WER (dev-other) | Count | Tuned | CTC | dev CTC | overfitting | dev MLE | dev DP | Joint | Still running | Training data available | Num Epochs | LR | ASR Model Type | Missing glow.eval |\n", + "|----:|:---------------------|:----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|------------------:|--------:|:--------|------:|----------:|--------------:|:----------|:---------|:--------|:----------------|:--------------------------|-------------:|:-----------------------------------------------|:-----------------|:--------------------|\n", + "| 52 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/ | 58 | 13 | True | 0.022 | 2.315 | 104.406 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 54 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/ | 44.6 | 13 | True | 0.326 | 1.042 | 3.202 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | True |\n", + "| 55 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/ | 63.8 | 13 | True | 0.065 | 2.401 | 36.955 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 56 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/ | 55.4 | 13 | True | 0.882 | 1.139 | 1.292 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 59 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/ | 63.2 | 13 | True | 0.062 | 2.427 | 39.391 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 62 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/ | 34 | 19 | True | 0.058 | 0.913 | 15.782 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 63 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/ | 33.8 | 19 | True | 0.003 | 1.209 | 454.454 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 64 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/ | 31.4 | 19 | True | 0.024 | 0.926 | 39.211 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 65 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/ | 23.9 | 19 | True | 0.187 | 0.566 | 3.019 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 122 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/ | 49.4 | 13 | True | 0.028 | 1.672 | 58.743 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 123 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/ | 57 | 13 | True | 0.508 | 0.863 | 1.698 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n" ] } ], @@ -1068,52 +1218,50 @@ "name": "stdout", "output_type": "stream", "text": [ - "| | Group | Experiment | WER (dev-other) | Count | Tuned | CTC | dev CTC | overfitting | dev MLE | dev DP | Joint | Still running | Training data available | Num Epochs | LR | ASR Model Type |\n", - "|----:|:--------------------------------|:------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|------------------:|--------:|:--------|:------|:----------|:--------------|:----------|:---------|:--------|:----------------|:--------------------------|:-------------|:-----------------------------------------------|:-----------------|\n", - "| 44 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step/ga_glowTTS_ASR_ffn_x_vector_v2_blstm_2ndstep/no_specaug/ce_ls_1.0/ | 81 | 1 | False | 0.036 | 2.023 | 55.937 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 45 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step/ga_glowTTS_ASR_ffn_x_vector_v2_blstm_2ndstep/specaug/ce_ls_1.0/ | 79.5 | 1 | False | 1.182 | 0.749 | 0.634 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 46 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step/ga_glowTTS_ASR_ffn_x_vector_v2_blstm_2ndstep_v2/no_specaug/ce_ls_1.0/ | 86.9 | 1 | False | 0.006 | 3.047 | 476.04 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 47 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x1024_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/ | 66.4 | 1 | False | 0.582 | 1.039 | 1.786 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 48 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/default/ | 55.1 | 1 | False | 0.177 | 1.151 | 6.489 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 49 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/drop_around_blstm/lm5/ | 66.3 | 1 | False | 0.599 | 0.948 | 1.581 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 50 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/drop_around_blstm/spec_augment/ | 94.2 | 1 | False | 2.438 | 1.396 | 0.573 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 51 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/ | 58 | 13 | True | 0.022 | 2.315 | 104.406 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 52 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval_spec_aug/not_silence_preprocessed/ | 67.7 | 1 | False | 0.725 | 1.04 | 1.434 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 53 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/ | 44.6 | 13 | True | 0.326 | 1.042 | 3.202 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 54 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/ | 63.8 | 13 | True | 0.065 | 2.401 | 36.955 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 55 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/ | 55.4 | 13 | True | 0.882 | 1.139 | 1.292 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 56 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/silence_preprocessed/ | 78.1 | 1 | False | 0.779 | 1.163 | 1.493 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 57 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/ | 73.4 | 1 | False | 0.667 | 1.099 | 1.648 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 58 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/ | 63.2 | 13 | True | 0.062 | 2.427 | 39.391 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 59 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/lm5/ | 73.4 | 1 | False | 0.667 | 1.099 | 1.648 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 60 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/silence_preprocessing/ | 76.2 | 1 | False | 0.71 | 1.15 | 1.62 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 61 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_simple_encoder/silence_preprocessed/ | 50.3 | 1 | False | 0.046 | 1.527 | 33.333 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 62 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/ | 34 | 19 | True | 0.058 | 0.913 | 15.782 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 63 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/ | 33.8 | 19 | True | 0.003 | 1.209 | 454.454 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 64 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/ | 31.4 | 19 | True | 0.024 | 0.926 | 39.211 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 65 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/ | 23.9 | 19 | True | 0.187 | 0.566 | 3.019 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 66 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc768_100ep_xvector/ | 62.4 | 1 | False | 0.326 | 1.049 | 3.219 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 67 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment_before/glow_enc192_200ep/ | 92.4 | 1 | False | 2.272 | 1.371 | 0.604 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 68 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment_before/glow_enc192_200ep_not_freezed/ | 30.9 | 1 | False | 0.172 | 0.56 | 3.248 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 69 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc192/100epTTS/silence_preprocessed/ | 59.7 | 1 | False | 0.356 | 1.057 | 2.966 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 70 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc192/200epsTTS/not_silence_preprocessed/ | 61.8 | 1 | False | 0.449 | 1.042 | 2.32 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 71 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc192/200epsTTS/silence_preprocessed/ | 61.8 | 1 | False | 0.408 | 1.04 | 2.552 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 72 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc192/200epsTTS_early_eval_ep100/not_silence_preprocessed/ | 60.6 | 1 | False | 0.385 | 1.046 | 2.718 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 73 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc192/200epsTTS_early_eval_ep100/silence_preprocessed/ | 60.8 | 1 | False | 0.35 | 1.066 | 3.045 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 74 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc192/not_silence_preprocessed/ | 61.1 | 1 | False | 0.402 | 1.038 | 2.579 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 75 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc768/with_sigma/not_silence_preprocessed/ | 70.4 | 1 | False | 0.737 | 1.107 | 1.503 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 76 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc768/with_sigma/not_silence_preprocessed/lm5/ | 70.4 | 1 | False | 0.737 | 1.107 | 1.503 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 77 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc768/with_sigma/silence_preprocessing/ | 71.9 | 1 | False | 0.767 | 1.135 | 1.479 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 78 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_nar_taco_encoder/not_silence_preprocessed/ | 66.2 | 1 | False | 0.668 | 1.026 | 1.535 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 79 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_nar_taco_encoder/silence_preprocessed/ | 67.7 | 1 | False | 0.622 | 1.081 | 1.738 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 80 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_nar_taco_encoder_16blocks/not_silence_preprocessed/ | 55.1 | 1 | False | 0.105 | 1.32 | 12.536 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 81 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_simple_encoder/silence_preprocessed/ | 56.9 | 1 | False | 0.096 | 1.431 | 14.855 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 82 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_simple_encoder_epoch84/silence_preprocessed/ | 57.4 | 1 | False | 0.079 | 1.519 | 19.301 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 83 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_with_small_enc/silence_preprocessed/ | 79.4 | 1 | False | 1.103 | 1.283 | 1.163 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 84 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_4x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/ | 52.4 | 1 | False | 0.378 | 0.812 | 2.15 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 114 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/ | 49.4 | 13 | True | 0.028 | 1.672 | 58.743 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 115 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/tts_dataset/ | 59.8 | 1 | False | 0.071 | 1.537 | 21.521 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 116 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/test/blstm512/warmup/d0.2_b100/default_250/extra/dev-other/sclite/wer | 127.9 | 1 | False | - | - | - | - | - | False | False | True | - | - | blstm |\n" + "| | Group | Experiment | WER (dev-other) | Count | Tuned | CTC | dev CTC | overfitting | dev MLE | dev DP | Joint | Still running | Training data available | Num Epochs | LR | ASR Model Type | Missing glow.eval |\n", + "|----:|:--------------------------------|:------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|------------------:|--------:|:--------|------:|----------:|--------------:|:----------|:---------|:--------|:----------------|:--------------------------|-------------:|:-----------------------------------------------|:-----------------|:--------------------|\n", + "| 45 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step/ga_glowTTS_ASR_ffn_x_vector_v2_blstm_2ndstep/no_specaug/ce_ls_1.0/ | 81 | 1 | False | 0.036 | 2.023 | 55.937 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 46 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step/ga_glowTTS_ASR_ffn_x_vector_v2_blstm_2ndstep/specaug/ce_ls_1.0/ | 79.5 | 1 | False | 1.182 | 0.749 | 0.634 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 47 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step/ga_glowTTS_ASR_ffn_x_vector_v2_blstm_2ndstep_v2/no_specaug/ce_ls_1.0/ | 86.9 | 1 | False | 0.006 | 3.047 | 476.04 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 48 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x1024_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/ | 66.4 | 1 | False | 0.582 | 1.039 | 1.786 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 49 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/default/ | 55.1 | 1 | False | 0.177 | 1.151 | 6.489 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 50 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/drop_around_blstm/lm5/ | 66.3 | 1 | False | 0.599 | 0.948 | 1.581 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 51 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/drop_around_blstm/spec_augment/ | 94.2 | 1 | False | 2.438 | 1.396 | 0.573 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 52 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/ | 58 | 13 | True | 0.022 | 2.315 | 104.406 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 53 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval_spec_aug/not_silence_preprocessed/ | 67.7 | 1 | False | 0.725 | 1.04 | 1.434 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 54 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/ | 44.6 | 13 | True | 0.326 | 1.042 | 3.202 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | True |\n", + "| 55 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/ | 63.8 | 13 | True | 0.065 | 2.401 | 36.955 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 56 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/ | 55.4 | 13 | True | 0.882 | 1.139 | 1.292 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 57 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/silence_preprocessed/ | 78.1 | 1 | False | 0.779 | 1.163 | 1.493 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 58 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/ | 73.4 | 1 | False | 0.667 | 1.099 | 1.648 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 59 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/ | 63.2 | 13 | True | 0.062 | 2.427 | 39.391 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 60 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/silence_preprocessing/ | 76.2 | 1 | False | 0.71 | 1.15 | 1.62 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 61 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_simple_encoder/silence_preprocessed/ | 50.3 | 1 | False | 0.046 | 1.527 | 33.333 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 62 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/ | 34 | 19 | True | 0.058 | 0.913 | 15.782 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 63 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/ | 33.8 | 19 | True | 0.003 | 1.209 | 454.454 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 64 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/ | 31.4 | 19 | True | 0.024 | 0.926 | 39.211 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 65 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/ | 23.9 | 19 | True | 0.187 | 0.566 | 3.019 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 66 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc768_100ep_xvector/ | 62.4 | 1 | False | 0.326 | 1.049 | 3.219 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 67 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment_before/glow_enc192_200ep/ | 92.4 | 1 | False | 2.272 | 1.371 | 0.604 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 68 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment_before/glow_enc192_200ep_not_freezed/ | 30.9 | 1 | False | 0.172 | 0.56 | 3.248 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 69 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc192/100epTTS/silence_preprocessed/ | 59.7 | 1 | False | 0.356 | 1.057 | 2.966 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 70 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc192/200epsTTS/not_silence_preprocessed/ | 61.8 | 1 | False | 0.449 | 1.042 | 2.32 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 71 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc192/200epsTTS/silence_preprocessed/ | 61.8 | 1 | False | 0.408 | 1.04 | 2.552 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 72 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc192/200epsTTS_early_eval_ep100/not_silence_preprocessed/ | 60.6 | 1 | False | 0.385 | 1.046 | 2.718 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 73 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc192/200epsTTS_early_eval_ep100/silence_preprocessed/ | 60.8 | 1 | False | 0.35 | 1.066 | 3.045 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 74 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc192/not_silence_preprocessed/ | 61.1 | 1 | False | 0.402 | 1.038 | 2.579 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 75 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc768/with_sigma/not_silence_preprocessed/ | 70.4 | 1 | False | 0.737 | 1.107 | 1.503 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 76 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc768/with_sigma/silence_preprocessing/ | 71.9 | 1 | False | 0.767 | 1.135 | 1.479 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 77 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_nar_taco_encoder/not_silence_preprocessed/ | 66.2 | 1 | False | 0.668 | 1.026 | 1.535 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 78 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_nar_taco_encoder/silence_preprocessed/ | 67.7 | 1 | False | 0.622 | 1.081 | 1.738 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 79 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_nar_taco_encoder_16blocks/not_silence_preprocessed/ | 55.1 | 1 | False | 0.105 | 1.32 | 12.536 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 80 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_simple_encoder/silence_preprocessed/ | 56.9 | 1 | False | 0.096 | 1.431 | 14.855 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 81 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_simple_encoder_epoch84/silence_preprocessed/ | 57.4 | 1 | False | 0.079 | 1.519 | 19.301 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 82 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_with_small_enc/silence_preprocessed/ | 79.4 | 1 | False | 1.103 | 1.283 | 1.163 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 83 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_4x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/ | 52.4 | 1 | False | 0.378 | 0.812 | 2.15 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 122 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/ | 49.4 | 13 | True | 0.028 | 1.672 | 58.743 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 123 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/ | 57 | 13 | True | 0.508 | 0.863 | 1.698 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 124 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/tts_dataset/ | 59.8 | 1 | False | 0.071 | 1.537 | 21.521 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n" ] } ], @@ -1141,52 +1289,62 @@ "name": "stdout", "output_type": "stream", "text": [ - "| | Group | Experiment | WER (dev-other) | Count | Tuned | CTC | dev CTC | overfitting | dev MLE | dev DP | Joint | Still running | Training data available | Num Epochs | LR | ASR Model Type |\n", - "|----:|:----------------------------------|:---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|------------------:|--------:|:--------|:------|:----------|:--------------|:----------|:---------|:--------|:----------------|:--------------------------|:-------------|:-------------------------------------------------|:-----------------|\n", - "| 2 | joint_training/conformer_coupling | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glow_ASR_conformer/ | 29.6 | 7 | True | 0.024 | 0.863 | 36.326 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 5 | joint_training/conformer_coupling | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer/ | 29.8 | 7 | True | 0.023 | 0.866 | 37.161 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 6 | joint_training/conformer_coupling | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer_specaugment_before/ | 18.7 | 7 | True | 0.133 | 0.444 | 3.33 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 30 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer/ | 38.3 | 7 | True | 0.037 | 1.206 | 32.173 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 31 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/ | 24.1 | 7 | True | 0.244 | 0.575 | 2.358 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 32 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_coupling_epsilon/ | 30.4 | 1 | False | 0.243 | 0.576 | 2.37 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 33 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_no_jit/ | 23.8 | 5 | True | - | - | - | - | - | False | False | True | - | - | conformer |\n", - "| 34 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_tts_train_segments/ | 24.6 | 8 | True | 0.242 | 0.587 | 2.424 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 35 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector/ | 35.3 | 7 | True | 0.233 | 0.9 | 3.862 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 36 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_control/ | 46.3 | 1 | False | 0.233 | 0.916 | 3.927 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 37 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/ | 24.5 | 7 | True | 0.23 | 0.59 | 2.568 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 38 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v3/ | 24.6 | 7 | True | 0.239 | 0.594 | 2.488 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 39 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvector/ | 43.5 | 1 | False | 0.251 | 0.762 | 3.03 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 40 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/ | 32.4 | 7 | True | 0.244 | 0.761 | 3.119 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 41 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer/ | 29.5 | 7 | True | 0.216 | 0.73 | 3.38 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 42 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/ | 25.6 | 7 | True | 0.491 | 0.587 | 1.196 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 43 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment_tts_train_segments/ | 25.4 | 7 | True | 0.502 | 0.592 | 1.181 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 85 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/ | 25.5 | 13 | True | 0.03 | 0.732 | 24.376 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 86 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/ | 28.1 | 19 | True | 0.001 | 1.248 | 2248.206 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 87 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/ | 28.7 | 19 | True | 0.001 | 1.295 | 1861.864 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 88 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/ | 27.1 | 13 | True | 0.001 | 1.193 | 975.256 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 89 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/ | 21.2 | 13 | True | 0.345 | 0.462 | 1.339 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 90 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.1/ | 25.8 | 1 | False | 0.406 | 0.422 | 1.041 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 91 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.2/ | 25.5 | 1 | False | 0.413 | 0.417 | 1.01 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 92 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/ | 26.2 | 1 | False | 0.44 | 0.415 | 0.943 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 93 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.4/ | 25.2 | 1 | False | 0.416 | 0.413 | 0.993 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 94 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/ | 20 | 13 | True | 0.416 | 0.418 | 1.005 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 95 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/ | 19.4 | 13 | True | 0.364 | 0.417 | 1.144 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 96 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/ | 21.8 | 14 | True | 0.368 | 0.474 | 1.287 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 97 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/batch_norm/ | 29.4 | 1 | False | 0.392 | 0.504 | 1.285 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 98 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/layer_norm/ | 28.5 | 1 | False | 0.407 | 0.488 | 1.197 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 99 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/ | 26.1 | 19 | True | 0.003 | 1.046 | 335.647 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 100 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_v2/ | 26.6 | 1 | False | 0.216 | 0.589 | 2.724 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 101 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_v3/ | 26.3 | 1 | False | 0.211 | 0.591 | 2.799 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 102 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/ | 17.6 | 19 | True | 0.086 | 0.512 | 5.958 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 103 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/ | 18.3 | 19 | True | 0.08 | 0.548 | 6.834 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 104 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/ | 23.6 | 13 | True | 0.42 | 0.476 | 1.133 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 105 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/ | 19.7 | 13 | True | 0.281 | 0.458 | 1.63 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 106 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/ | 41.3 | 1 | False | 0.423 | 0.751 | 1.777 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 107 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/ | 100 | 13 | True | 3.463 | 5.332 | 1.54 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 108 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/ | 18 | 15 | True | 0.083 | 0.544 | 6.584 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 109 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_200ep_not_silence_preprocessed/ | 100 | 1 | False | 3.454 | 5.802 | 1.68 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 110 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/weak_baseline/ | 25.5 | 7 | True | 0.5 | 0.589 | 1.177 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 111 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/tts_dataset/spec_augment/no_glow/ | 20.9 | 1 | False | 0.091 | 0.419 | 4.591 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n" + "| | Group | Experiment | WER (dev-other) | Count | Tuned | CTC | dev CTC | overfitting | dev MLE | dev DP | Joint | Still running | Training data available | Num Epochs | LR | ASR Model Type | Missing glow.eval |\n", + "|----:|:----------------------------------|:-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|------------------:|--------:|:--------|:------|:----------|:--------------|:----------|:---------|:--------|:----------------|:--------------------------|:-------------|:-------------------------------------------------|:-----------------|:--------------------|\n", + "| 2 | joint_training/conformer_coupling | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glow_ASR_conformer/ | 29.6 | 7 | True | 0.024 | 0.863 | 36.326 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 5 | joint_training/conformer_coupling | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer/ | 29.8 | 7 | True | 0.023 | 0.866 | 37.161 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 6 | joint_training/conformer_coupling | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer_specaugment_before/ | 18.7 | 7 | True | 0.133 | 0.444 | 3.33 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 30 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer/ | 38.3 | 7 | True | 0.037 | 1.206 | 32.173 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 31 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/ | 24.1 | 7 | True | 0.244 | 0.575 | 2.358 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 32 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_coupling_epsilon/ | 30.4 | 1 | False | 0.243 | 0.576 | 2.37 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 33 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_no_jit/ | 23.8 | 5 | True | - | - | - | - | - | False | False | True | - | - | conformer | False |\n", + "| 34 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_tts_train_segments/ | 24.6 | 8 | True | 0.242 | 0.587 | 2.424 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 35 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector/ | 35.3 | 7 | True | 0.233 | 0.9 | 3.862 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 36 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_control/ | 46.3 | 1 | False | 0.233 | 0.916 | 3.927 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 37 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/ | 24.5 | 7 | True | 0.23 | 0.59 | 2.568 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 38 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v3/ | 24.6 | 7 | True | 0.239 | 0.594 | 2.488 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 39 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvector/ | 43.5 | 1 | False | 0.251 | 0.762 | 3.03 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 40 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvector_eval/ | 37 | 7 | True | 0.167 | 0.931 | 5.565 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 41 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/ | 32.4 | 7 | True | 0.244 | 0.761 | 3.119 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 42 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer/ | 29.5 | 7 | True | 0.216 | 0.73 | 3.38 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 43 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/ | 25.6 | 7 | True | 0.491 | 0.587 | 1.196 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 44 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment_tts_train_segments/ | 25.4 | 7 | True | 0.502 | 0.592 | 1.181 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 84 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/ | 28.1 | 19 | True | 0.001 | 1.248 | 2248.206 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 85 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/ | 28.7 | 19 | True | 0.001 | 1.295 | 1861.864 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 86 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/ | 49.1 | 13 | True | 0.006 | 2.364 | 381.61 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 87 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/ | 36.1 | 13 | True | 0.002 | 1.65 | 869.021 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 88 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/ | 27.1 | 13 | True | 0.001 | 1.193 | 975.256 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 89 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/ | 20 | 13 | True | 0.331 | 0.453 | 1.37 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 90 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/ | 19.7 | 13 | True | 0.335 | 0.448 | 1.338 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 91 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/ | 18.9 | 13 | True | 0.32 | 0.439 | 1.374 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 92 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/ | 38 | 13 | True | 0.321 | 0.894 | 2.788 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 93 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/ | 26.1 | 19 | True | 0.003 | 1.046 | 335.647 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 94 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_v2/ | 26.6 | 1 | False | 0.216 | 0.589 | 2.724 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 95 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_v3/ | 26.3 | 1 | False | 0.211 | 0.591 | 2.799 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 96 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/ | 26.6 | 19 | True | 0.003 | 1.081 | 368.105 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 97 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/ | 18.3 | 19 | True | 0.08 | 0.548 | 6.834 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 98 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/ | 23.6 | 13 | True | 0.42 | 0.476 | 1.133 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 99 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/ | 19.7 | 13 | True | 0.281 | 0.458 | 1.63 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 100 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/ | 38.2 | 13 | True | 0.285 | 0.975 | 3.417 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 101 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/ | 25.3 | 13 | True | 0.33 | 0.543 | 1.644 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 102 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/ | 22 | 13 | True | 0.279 | 0.488 | 1.75 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 103 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/ | 18 | 15 | True | 0.083 | 0.544 | 6.584 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 104 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/ | 17.6 | 19 | True | 0.086 | 0.512 | 5.958 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 105 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/weak_baseline/ | 25.5 | 7 | True | 0.5 | 0.589 | 1.177 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 106 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/ | 25.5 | 13 | True | 0.03 | 0.732 | 24.376 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | True |\n", + "| 107 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/ | 21.2 | 13 | True | 0.345 | 0.462 | 1.339 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | True |\n", + "| 108 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.1/ | 25.8 | 1 | False | 0.406 | 0.422 | 1.041 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | True |\n", + "| 109 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.2/ | 25.5 | 1 | False | 0.413 | 0.417 | 1.01 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | True |\n", + "| 110 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/ | 26.2 | 1 | False | 0.44 | 0.415 | 0.943 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | True |\n", + "| 111 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.4/ | 25.2 | 1 | False | 0.416 | 0.413 | 0.993 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | True |\n", + "| 112 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/ | 20 | 13 | True | 0.416 | 0.418 | 1.005 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | True |\n", + "| 113 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/ | 19.4 | 13 | True | 0.364 | 0.417 | 1.144 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | True |\n", + "| 114 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/ | 21.8 | 14 | True | 0.368 | 0.474 | 1.287 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | True |\n", + "| 115 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/batch_norm/ | 29.4 | 1 | False | 0.392 | 0.504 | 1.285 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | True |\n", + "| 116 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/layer_norm/ | 28.5 | 1 | False | 0.407 | 0.488 | 1.197 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | True |\n", + "| 117 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/ | 100 | 13 | True | 3.463 | 5.332 | 1.54 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | True |\n", + "| 118 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment_before/glow_enc192_200ep_not_silence_preprocessed/ | 100 | 1 | False | 3.454 | 5.802 | 1.68 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | True |\n", + "| 119 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/tts_dataset/spec_augment/no_glow/ | 20.9 | 1 | False | 0.091 | 0.419 | 4.591 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n" ] } ], @@ -1200,25 +1358,26 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "| | Group | Experiment | WER (dev-other) | Count | Tuned | CTC | dev CTC | overfitting | dev MLE | dev DP | Joint | Still running | Training data available | Num Epochs | LR | ASR Model Type |\n", - "|----:|:---------------------|:-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|------------------:|--------:|:--------|------:|----------:|--------------:|:----------|:---------|:--------|:----------------|:--------------------------|-------------:|:-------------------------------------------------|:-----------------|\n", - "| 62 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/ | 34 | 19 | True | 0.058 | 0.913 | 15.782 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 63 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/ | 33.8 | 19 | True | 0.003 | 1.209 | 454.454 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 64 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/ | 31.4 | 19 | True | 0.024 | 0.926 | 39.211 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 65 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/ | 23.9 | 19 | True | 0.187 | 0.566 | 3.019 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 68 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment_before/glow_enc192_200ep_not_freezed/ | 30.9 | 1 | False | 0.172 | 0.56 | 3.248 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 86 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/ | 28.1 | 19 | True | 0.001 | 1.248 | 2248.21 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 87 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/ | 28.7 | 19 | True | 0.001 | 1.295 | 1861.86 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 99 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/ | 26.1 | 19 | True | 0.003 | 1.046 | 335.647 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 102 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/ | 17.6 | 19 | True | 0.086 | 0.512 | 5.958 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 103 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/ | 18.3 | 19 | True | 0.08 | 0.548 | 6.834 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n" + "| | Group | Experiment | WER (dev-other) | Count | Tuned | CTC | dev CTC | overfitting | dev MLE | dev DP | Joint | Still running | Training data available | Num Epochs | LR | ASR Model Type | Missing glow.eval |\n", + "|----:|:---------------------|:-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|------------------:|--------:|:--------|------:|----------:|--------------:|:----------|:---------|:--------|:----------------|:--------------------------|-------------:|:-------------------------------------------------|:-----------------|:--------------------|\n", + "| 62 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/ | 34 | 19 | True | 0.058 | 0.913 | 15.782 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 63 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/ | 33.8 | 19 | True | 0.003 | 1.209 | 454.454 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 64 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/ | 31.4 | 19 | True | 0.024 | 0.926 | 39.211 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 65 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/ | 23.9 | 19 | True | 0.187 | 0.566 | 3.019 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 68 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment_before/glow_enc192_200ep_not_freezed/ | 30.9 | 1 | False | 0.172 | 0.56 | 3.248 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 84 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/ | 28.1 | 19 | True | 0.001 | 1.248 | 2248.21 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 85 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/ | 28.7 | 19 | True | 0.001 | 1.295 | 1861.86 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 93 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/ | 26.1 | 19 | True | 0.003 | 1.046 | 335.647 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 96 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/ | 26.6 | 19 | True | 0.003 | 1.081 | 368.105 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 97 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/ | 18.3 | 19 | True | 0.08 | 0.548 | 6.834 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 104 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/ | 17.6 | 19 | True | 0.086 | 0.512 | 5.958 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n" ] } ], @@ -1240,20 +1399,20 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_3659618/226959626.py:22: SettingWithCopyWarning: \n", + "/var/tmp/ipykernel_2362097/226959626.py:22: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame.\n", "Try using .loc[row_indexer,col_indexer] = value instead\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " df_joint[\"auto MOS\"] = mos\n", - "/tmp/ipykernel_3659618/226959626.py:23: SettingWithCopyWarning: \n", + "/var/tmp/ipykernel_2362097/226959626.py:23: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame.\n", "Try using .loc[row_indexer,col_indexer] = value instead\n", "\n", @@ -1291,42 +1450,42 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 18, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "| | Group | Experiment | WER (dev-other) | Count | Tuned | CTC | dev CTC | overfitting | dev MLE | dev DP | Joint | Still running | Training data available | Num Epochs | LR | ASR Model Type | auto MOS | sWER |\n", - "|---:|:----------------------------------|:-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|------------------:|--------:|:--------|------:|----------:|--------------:|----------:|---------:|:--------|:----------------|:--------------------------|-------------:|:-------------------------------------------------|:-----------------|-----------:|-------:|\n", - "| 0 | joint_training/conformer_coupling | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_ASR_conformer_two_forward_pass/ | 23.9 | 7 | True | 0.292 | 0.564 | 1.933 | -0.670671 | 2.09134 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | 1.82 | 95.7 |\n", - "| 1 | joint_training/conformer_coupling | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_ASR_conformer_x_vector/ | 34.6 | 7 | True | 0.204 | 0.881 | 4.312 | -0.465325 | 0.229336 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | 2.14 | 5.2 |\n", - "| 3 | joint_training/conformer_coupling | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_two_forward_pass/ | 24 | 7 | True | 0.289 | 0.569 | 1.967 | -0.692025 | 0.412498 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | 2.45 | 20.9 |\n", - "| 4 | joint_training/conformer_coupling | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_x_vector_v2/ | 34.6 | 7 | True | 0.204 | 0.881 | 4.312 | -0.465325 | 0.229336 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | 2.14 | 5.2 |\n", - "| 7 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/ | 23.8 | 7 | True | 0.3 | 0.582 | 1.94 | -0.699266 | 0.370426 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | 2.61 | 14.8 |\n", - "| 8 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/ | 24 | 7 | True | 0.431 | 0.558 | 1.294 | -0.805268 | 0.355401 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | 3.16 | 15.2 |\n", - "| 9 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ddi_actnorm/ | 66.7 | 1 | False | 0.282 | 0.583 | 2.068 | -0.696243 | 0.401243 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | nan | nan |\n", - "| 10 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector/ | 38.4 | 7 | True | 0.103 | 1.099 | 10.685 | -0.548408 | 0.701494 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | 1.58 | 98 |\n", - "| 11 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_control/ | 38.5 | 1 | False | 0.216 | 0.735 | 3.408 | -0.779522 | 1.54937 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | nan | nan |\n", - "| 12 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_control_radam/ | 38.3 | 1 | False | 0.214 | 0.731 | 3.414 | -0.780336 | 1.46005 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | nan | nan |\n", - "| 13 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_control_spec_augment/ | 37.9 | 1 | False | 0.501 | 0.588 | 1.173 | -0.77829 | 1.4497 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | nan | nan |\n", - "| 14 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_ctc_scale_0.1/ | 34.7 | 7 | True | 0.142 | 0.927 | 6.549 | -0.769183 | 0.36247 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | 3.15 | 7.6 |\n", - "| 15 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_ddi_actnorm/ | 94.4 | 1 | False | 0.165 | 1.062 | 6.429 | -0.520394 | 0.214735 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | nan | nan |\n", - "| 16 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_encoder_sample_ctc_scale_0.1/ | 100 | 1 | False | 3.481 | 6.325 | 1.817 | -0.781605 | 1.1355 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | nan | nan |\n", - "| 17 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_radam/ | 43.8 | 1 | False | 0.098 | 1.135 | 11.599 | -0.582927 | 0.348165 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | nan | nan |\n", - "| 18 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment/ | 37 | 7 | True | 0.197 | 0.946 | 4.803 | -0.521236 | 0.225934 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | 2.3 | 5.2 |\n", - "| 19 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1/ | 29.4 | 7 | True | 0.409 | 0.689 | 1.685 | -0.759844 | 0.329289 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | 3.11 | 4.6 |\n", - "| 20 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1_tts_segments/ | 29.6 | 7 | True | 0.409 | 0.696 | 1.703 | -0.75744 | 0.330754 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | nan | nan |\n", - "| 21 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_trainXvector/ | 47 | 1 | False | 0.046 | 1.485 | 32.45 | -0.592337 | 0.586278 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | nan | nan |\n", - "| 22 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass/ | 39.7 | 7 | True | 0.432 | 0.863 | 1.998 | -0.629746 | 0.403638 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | 2.75 | 9.5 |\n", - "| 23 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_ctc_scale_0.1/ | 52.4 | 7 | True | 0.455 | 1.104 | 2.429 | -0.771774 | 0.399888 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | 3.12 | 13.3 |\n", - "| 24 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/ | 47.7 | 7 | True | 0.386 | 1.015 | 2.63 | -0.641523 | 0.379653 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | 2.64 | 9.9 |\n", - "| 25 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/ | 50.7 | 7 | True | 0.441 | 1.084 | 2.461 | -0.778751 | 0.379635 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | 3.18 | 11.2 |\n", - "| 26 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/ | 44.1 | 7 | True | 0.058 | 1.44 | 25.027 | -0.591349 | 0.326762 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | 2.48 | 6.7 |\n", - "| 27 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/ | 36.1 | 7 | True | 0.128 | 1.01 | 7.915 | -0.772961 | 0.346386 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | 3.19 | 7.9 |\n", - "| 28 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/ | 42.6 | 7 | True | 0.136 | 1.228 | 9.014 | -0.535346 | 0.203592 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | 2.32 | 6 |\n", - "| 29 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/ | 31.9 | 7 | True | 0.378 | 0.76 | 2.009 | -0.764738 | 0.306534 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | 3.2 | 4.4 |\n" + "| | Group | Experiment | WER (dev-other) | Count | Tuned | CTC | dev CTC | overfitting | dev MLE | dev DP | Joint | Still running | Training data available | Num Epochs | LR | ASR Model Type | Missing glow.eval | auto MOS | sWER |\n", + "|---:|:----------------------------------|:-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|------------------:|--------:|:--------|------:|----------:|--------------:|----------:|---------:|:--------|:----------------|:--------------------------|-------------:|:-------------------------------------------------|:-----------------|:--------------------|-----------:|-------:|\n", + "| 0 | joint_training/conformer_coupling | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_ASR_conformer_two_forward_pass/ | 23.9 | 7 | True | 0.292 | 0.564 | 1.933 | -0.670671 | 2.09134 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | 1.82 | 95.7 |\n", + "| 1 | joint_training/conformer_coupling | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_ASR_conformer_x_vector/ | 34.6 | 7 | True | 0.204 | 0.881 | 4.312 | -0.465325 | 0.229336 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | 2.14 | 5.2 |\n", + "| 3 | joint_training/conformer_coupling | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_two_forward_pass/ | 24 | 7 | True | 0.289 | 0.569 | 1.967 | -0.692025 | 0.412498 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | 2.45 | 20.9 |\n", + "| 4 | joint_training/conformer_coupling | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_x_vector_v2/ | 34.6 | 7 | True | 0.204 | 0.881 | 4.312 | -0.465325 | 0.229336 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | 2.14 | 5.2 |\n", + "| 7 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/ | 23.8 | 7 | True | 0.3 | 0.582 | 1.94 | -0.699266 | 0.370426 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | 2.61 | 14.8 |\n", + "| 8 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/ | 24 | 7 | True | 0.431 | 0.558 | 1.294 | -0.805268 | 0.355401 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | 3.16 | 15.2 |\n", + "| 9 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ddi_actnorm/ | 66.7 | 1 | False | 0.282 | 0.583 | 2.068 | -0.696243 | 0.401243 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | nan | nan |\n", + "| 10 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector/ | 38.4 | 7 | True | 0.103 | 1.099 | 10.685 | -0.548408 | 0.701494 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | 1.58 | 98 |\n", + "| 11 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_control/ | 38.5 | 1 | False | 0.216 | 0.735 | 3.408 | -0.779522 | 1.54937 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | nan | nan |\n", + "| 12 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_control_radam/ | 38.3 | 1 | False | 0.214 | 0.731 | 3.414 | -0.780336 | 1.46005 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | nan | nan |\n", + "| 13 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_control_spec_augment/ | 37.9 | 1 | False | 0.501 | 0.588 | 1.173 | -0.77829 | 1.4497 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | nan | nan |\n", + "| 14 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_ctc_scale_0.1/ | 34.7 | 7 | True | 0.142 | 0.927 | 6.549 | -0.769183 | 0.36247 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | 3.15 | 7.6 |\n", + "| 15 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_ddi_actnorm/ | 94.4 | 1 | False | 0.165 | 1.062 | 6.429 | -0.520394 | 0.214735 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | nan | nan |\n", + "| 16 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_encoder_sample_ctc_scale_0.1/ | 100 | 1 | False | 3.481 | 6.325 | 1.817 | -0.781605 | 1.1355 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | nan | nan |\n", + "| 17 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_radam/ | 43.8 | 1 | False | 0.098 | 1.135 | 11.599 | -0.582927 | 0.348165 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | nan | nan |\n", + "| 18 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment/ | 37 | 7 | True | 0.197 | 0.946 | 4.803 | -0.521236 | 0.225934 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | 2.3 | 5.2 |\n", + "| 19 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1/ | 29.4 | 7 | True | 0.409 | 0.689 | 1.685 | -0.759844 | 0.329289 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | 3.11 | 4.6 |\n", + "| 20 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1_tts_segments/ | 29.6 | 7 | True | 0.409 | 0.696 | 1.703 | -0.75744 | 0.330754 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | nan | nan |\n", + "| 21 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_trainXvector/ | 47 | 1 | False | 0.046 | 1.485 | 32.45 | -0.592337 | 0.586278 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | nan | nan |\n", + "| 22 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass/ | 39.7 | 7 | True | 0.432 | 0.863 | 1.998 | -0.629746 | 0.403638 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | 2.75 | 9.5 |\n", + "| 23 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_ctc_scale_0.1/ | 52.4 | 7 | True | 0.455 | 1.104 | 2.429 | -0.771774 | 0.399888 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | 3.12 | 13.3 |\n", + "| 24 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/ | 47.7 | 7 | True | 0.386 | 1.015 | 2.63 | -0.641523 | 0.379653 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | 2.64 | 9.9 |\n", + "| 25 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/ | 50.7 | 7 | True | 0.441 | 1.084 | 2.461 | -0.778751 | 0.379635 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | 3.18 | 11.2 |\n", + "| 26 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/ | 44.1 | 7 | True | 0.058 | 1.44 | 25.027 | -0.591349 | 0.326762 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | 2.48 | 6.7 |\n", + "| 27 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/ | 36.1 | 7 | True | 0.128 | 1.01 | 7.915 | -0.772961 | 0.346386 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | 3.19 | 7.9 |\n", + "| 28 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/ | 42.6 | 7 | True | 0.136 | 1.228 | 9.014 | -0.535346 | 0.203592 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | 2.32 | 6 |\n", + "| 29 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/ | 31.9 | 7 | True | 0.378 | 0.76 | 2.009 | -0.764738 | 0.306534 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | 3.2 | 4.4 |\n" ] } ], @@ -1343,23 +1502,24 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 19, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "| | Group | Experiment | WER (dev-other) | Count | Tuned | CTC | dev CTC | overfitting | dev MLE | dev DP | Joint | Still running | Training data available | Num Epochs | LR | ASR Model Type |\n", - "|----:|:-----------------------|:-------------------------------------------------------------------------------------------------------------------------------------------------------------|------------------:|--------:|:--------|------:|----------:|--------------:|:----------|:---------|:--------|:----------------|:--------------------------|-------------:|:-------------------------------------------------|:-----------------|\n", - "| 41 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer/ | 29.5 | 7 | True | 0.216 | 0.73 | 3.38 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 42 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/ | 25.6 | 7 | True | 0.491 | 0.587 | 1.196 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 43 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment_tts_train_segments/ | 25.4 | 7 | True | 0.502 | 0.592 | 1.181 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 88 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/ | 27.1 | 13 | True | 0.001 | 1.193 | 975.256 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 108 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/ | 18 | 15 | True | 0.083 | 0.544 | 6.584 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 111 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/tts_dataset/spec_augment/no_glow/ | 20.9 | 1 | False | 0.091 | 0.419 | 4.591 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer |\n", - "| 114 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/ | 49.4 | 13 | True | 0.028 | 1.672 | 58.743 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n", - "| 115 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/tts_dataset/ | 59.8 | 1 | False | 0.071 | 1.537 | 21.521 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm |\n" + "| | Group | Experiment | WER (dev-other) | Count | Tuned | CTC | dev CTC | overfitting | dev MLE | dev DP | Joint | Still running | Training data available | Num Epochs | LR | ASR Model Type | Missing glow.eval |\n", + "|----:|:-----------------------|:------------------------------------------------------------------------------------------------------------------------------------------------------------------|------------------:|--------:|:--------|------:|----------:|--------------:|:----------|:---------|:--------|:----------------|:--------------------------|-------------:|:-------------------------------------------------|:-----------------|:--------------------|\n", + "| 42 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer/ | 29.5 | 7 | True | 0.216 | 0.73 | 3.38 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 43 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/ | 25.6 | 7 | True | 0.491 | 0.587 | 1.196 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 44 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment_tts_train_segments/ | 25.4 | 7 | True | 0.502 | 0.592 | 1.181 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 88 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/ | 27.1 | 13 | True | 0.001 | 1.193 | 975.256 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 103 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/ | 18 | 15 | True | 0.083 | 0.544 | 6.584 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 119 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/tts_dataset/spec_augment/no_glow/ | 20.9 | 1 | False | 0.091 | 0.419 | 4.591 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 122 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/ | 49.4 | 13 | True | 0.028 | 1.672 | 58.743 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 123 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/ | 57 | 13 | True | 0.508 | 0.863 | 1.698 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 124 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/tts_dataset/ | 59.8 | 1 | False | 0.071 | 1.537 | 21.521 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n" ] } ], @@ -1370,7 +1530,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 20, "metadata": {}, "outputs": [], "source": [ @@ -1379,7 +1539,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 21, "metadata": {}, "outputs": [ { @@ -1389,7 +1549,7 @@ "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[18], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mdf_training_avail\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mplot\u001b[49m\u001b[43m(\u001b[49m\u001b[43mkind\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mscatter\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mx\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mWER (dev-other)\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mCTC\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n", + "Cell \u001b[0;32mIn[21], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mdf_training_avail\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mplot\u001b[49m\u001b[43m(\u001b[49m\u001b[43mkind\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mscatter\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mx\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mWER (dev-other)\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mCTC\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n", "File \u001b[0;32m/work/tools22/users/lukas.rilling/sis_env/lib/python3.10/site-packages/pandas/plotting/_core.py:976\u001b[0m, in \u001b[0;36mPlotAccessor.__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 974\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m kind \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_dataframe_kinds:\n\u001b[1;32m 975\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(data, ABCDataFrame):\n\u001b[0;32m--> 976\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mplot_backend\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mplot\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdata\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mx\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43my\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mkind\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mkind\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 977\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 978\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mplot kind \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mkind\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m can only be used for data frames\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n", "File \u001b[0;32m/work/tools22/users/lukas.rilling/sis_env/lib/python3.10/site-packages/pandas/plotting/_matplotlib/__init__.py:71\u001b[0m, in \u001b[0;36mplot\u001b[0;34m(data, kind, **kwargs)\u001b[0m\n\u001b[1;32m 69\u001b[0m kwargs[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124max\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mgetattr\u001b[39m(ax, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mleft_ax\u001b[39m\u001b[38;5;124m\"\u001b[39m, ax)\n\u001b[1;32m 70\u001b[0m plot_obj \u001b[38;5;241m=\u001b[39m PLOT_CLASSES[kind](data, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m---> 71\u001b[0m \u001b[43mplot_obj\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mgenerate\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 72\u001b[0m plot_obj\u001b[38;5;241m.\u001b[39mdraw()\n\u001b[1;32m 73\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m plot_obj\u001b[38;5;241m.\u001b[39mresult\n", "File \u001b[0;32m/work/tools22/users/lukas.rilling/sis_env/lib/python3.10/site-packages/pandas/plotting/_matplotlib/core.py:453\u001b[0m, in \u001b[0;36mMPLPlot.generate\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 451\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compute_plot_data()\n\u001b[1;32m 452\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_setup_subplots()\n\u001b[0;32m--> 453\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_make_plot\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 454\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_add_table()\n\u001b[1;32m 455\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_make_legend()\n", @@ -1491,7 +1651,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.12" + "version": "3.10.13" } }, "nbformat": 4, diff --git a/users/rilling/experiments/librispeech/common/eval_references/swer.py b/users/rilling/experiments/librispeech/common/eval_references/swer.py index dc61a166c..8276ac479 100644 --- a/users/rilling/experiments/librispeech/common/eval_references/swer.py +++ b/users/rilling/experiments/librispeech/common/eval_references/swer.py @@ -12,7 +12,7 @@ def get_swer_evaluation_reference(): from i6_core.corpus.filter import FilterCorpusRemoveUnknownWordSegmentsJob bliss = FilterCorpusRemoveUnknownWordSegmentsJob( - bliss_corpus=get_bliss_corpus_dict()["test-clean"], bliss_lexicon=get_tts_lexicon(), all_unknown=False + bliss_corpus=get_bliss_corpus_dict(audio_format="ogg")["test-clean"], bliss_lexicon=get_tts_lexicon(), all_unknown=False ).out_corpus system = asr_recognizer_systems[asr_system] diff --git a/users/rilling/experiments/librispeech/common/tts_eval.py b/users/rilling/experiments/librispeech/common/tts_eval.py index a60a27157..b3ca0a1e1 100644 --- a/users/rilling/experiments/librispeech/common/tts_eval.py +++ b/users/rilling/experiments/librispeech/common/tts_eval.py @@ -79,6 +79,7 @@ def tts_eval( nisqa_eval=False, swer_eval=False, swer_eval_corpus_key="train-clean", + nisqa_confidence=False ): """ Run search for a specific test dataset @@ -106,13 +107,13 @@ def tts_eval( name = prefix_name + f"/tts_eval_{vocoder}/{swer_eval_corpus_key}" forward_job.add_alias(name + "/forward") if nisqa_eval: - evaluate_nisqa(name, forward_job.out_files["out_corpus.xml.gz"], vocoder=vocoder) + evaluate_nisqa(name, forward_job.out_files["out_corpus.xml.gz"], vocoder=vocoder, with_bootstrap=nisqa_confidence) if swer_eval: evaluate_swer(name, forward_job, returnn_exe=returnn_exe_asr, returnn_root=returnn_root, corpus_key=swer_eval_corpus_key) return forward_job -def evaluate_nisqa(prefix_name: str, bliss_corpus: tk.Path, vocoder: str = "univnet"): +def evaluate_nisqa(prefix_name: str, bliss_corpus: tk.Path, vocoder: str = "univnet", with_bootstrap=False): predict_mos_job = NISQAMosPredictionJob(bliss_corpus, nisqa_repo=NISQA_REPO) predict_mos_job.add_alias(prefix_name + f"/nisqa_mos") tk.register_output(os.path.join(prefix_name, "nisqa_mos/average"), predict_mos_job.out_mos_average) @@ -120,6 +121,12 @@ def evaluate_nisqa(prefix_name: str, bliss_corpus: tk.Path, vocoder: str = "univ tk.register_output(os.path.join(prefix_name, "nisqa_mos/max"), predict_mos_job.out_mos_max) tk.register_output(os.path.join(prefix_name, "nisqa_mos/std_dev"), predict_mos_job.out_mos_std_dev) + if with_bootstrap: + from i6_experiments.users.rossenbach.tts.evaluation.nisqa import NISQAConfidenceJob + nisqa_confidence_job = NISQAConfidenceJob(predict_mos_job.output_dir, bliss_corpus) + nisqa_confidence_job.add_alias(prefix_name + "/nisqa_mos_confidence") + tk.register_output(os.path.join(prefix_name, "nisqa_mos/confidence_max_interval"), nisqa_confidence_job.out_max_interval_bound) + def evaluate_swer( name: str, diff --git a/users/rilling/experiments/librispeech/librispeech_glow_asr/experiments.py b/users/rilling/experiments/librispeech/librispeech_glow_asr/experiments.py index 9e033c1fc..4bc50602a 100644 --- a/users/rilling/experiments/librispeech/librispeech_glow_asr/experiments.py +++ b/users/rilling/experiments/librispeech/librispeech_glow_asr/experiments.py @@ -908,7 +908,7 @@ def run_exp( ) train_args_conformer["net_args"]["n_vocab"] = vocab_size_without_blank run_exp( - prefix_name + "conformer/tts_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed", + prefix_name + "conformer/glow_not_eval/tts_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed", datasets=train_data, train_args=train_args_conformer, search_args=default_search_args_tts, @@ -919,7 +919,7 @@ def run_exp( train_args_conformer_asr_data = copy.deepcopy(train_args_conformer) train_args_conformer_asr_data["net_args"]["n_vocab"] = vocab_size_without_blank_normal_ctc run_exp( - prefix_name + "conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed", + prefix_name + "conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed", datasets=train_data_normal_ctc, train_args=train_args_conformer_asr_data, search_args=default_search_args_asr, @@ -927,6 +927,18 @@ def run_exp( num_epochs=250, ) + train_args_conformer_asr_data_spec_aug_before = copy.deepcopy(train_args_conformer_asr_data) + train_args_conformer_asr_data_spec_aug_before["network_module"] = "glowASR_conformer_specaug_before" + train_args_conformer_asr_data_spec_aug_before["net_args"]["spec_augment"] = True + run_exp( + prefix_name + "conformer/glow_not_eval/asr_dataset/spec_augment_before/glow_enc192_200ep_not_silence_preprocessed", + datasets=train_data_normal_ctc, + train_args=train_args_conformer_asr_data_spec_aug_before, + search_args=default_search_args_asr, + large_gpu_training=False, + num_epochs=250, + ) + train_args_glow100ep_conformer_asr_data = copy.deepcopy(train_args_conformer_asr_data) tts_exp_name = "glowTTS/enc192/100ep/not_silence_preprocessed" tts_train_job = TTS_experiments[tts_exp_name]["train_job"] @@ -935,7 +947,7 @@ def run_exp( ) run_exp( - prefix_name + "conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed", + prefix_name + "conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed", datasets=train_data_normal_ctc, train_args=train_args_glow100ep_conformer_asr_data, search_args=default_search_args_asr, @@ -950,7 +962,7 @@ def run_exp( tts_train_job.out_checkpoints[tts_train_job.returnn_config.get("num_epochs", 200)] ) run_exp( - prefix_name + "conformer/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed", + prefix_name + "conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed", datasets=train_data_normal_ctc, train_args=train_args_glow_enc768_200ep_conformer_asr_data, search_args=default_search_args_asr, @@ -978,7 +990,7 @@ def run_exp( train_args_conformer_asr_data_layer_norm = copy.deepcopy(train_args_conformer_asr_data) train_args_conformer_asr_data_layer_norm["net_args"]["layer_norm"] = True run_exp( - prefix_name + "conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/layer_norm", + prefix_name + "conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/layer_norm", datasets=train_data_normal_ctc, train_args=train_args_conformer_asr_data_layer_norm, search_args=default_search_args_asr, @@ -989,7 +1001,7 @@ def run_exp( train_args_conformer_asr_data_batch_norm = copy.deepcopy(train_args_conformer_asr_data) train_args_conformer_asr_data_batch_norm["net_args"]["batch_norm"] = True run_exp( - prefix_name + "conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/batch_norm", + prefix_name + "conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/batch_norm", datasets=train_data_normal_ctc, train_args=train_args_conformer_asr_data_batch_norm, search_args=default_search_args_asr, @@ -1000,7 +1012,7 @@ def run_exp( train_args_conformer_no_spec_augment = copy.deepcopy(train_args_conformer) train_args_conformer_no_spec_augment["net_args"]["spec_augment"] = False run_exp( - prefix_name + "conformer/tts_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed", + prefix_name + "conformer/glow_not_eval/tts_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed", datasets=train_data, train_args=train_args_conformer_no_spec_augment, search_args=default_search_args_tts, @@ -1012,7 +1024,7 @@ def run_exp( train_args_conformer_no_spec_augment_asr_data["net_args"]["n_vocab"] = vocab_size_without_blank_normal_ctc run_exp( - prefix_name + "conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed", + prefix_name + "conformer/glow_not_eval/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed", datasets=train_data_normal_ctc, train_args=train_args_conformer_no_spec_augment_asr_data, search_args=default_search_args_asr, @@ -1082,7 +1094,7 @@ def run_exp( additional_search_args = {"lm_weight": lm_w, "prior_scale": ps} run_exp( prefix_name - + f"conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_{lm_w}_ps_{ps}", + + f"conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_{lm_w}_ps_{ps}", datasets=train_data_normal_ctc, train_args=train_args_conformer_asr_data, search_args={**default_search_args_asr, **additional_search_args}, @@ -1094,7 +1106,7 @@ def run_exp( run_exp( prefix_name - + f"conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/tuning/lm_{lm_w}_ps_{ps}", + + f"conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/tuning/lm_{lm_w}_ps_{ps}", datasets=train_data_normal_ctc, train_args=train_args_glow100ep_conformer_asr_data, search_args={**default_search_args_asr, **additional_search_args}, @@ -1106,7 +1118,7 @@ def run_exp( run_exp( prefix_name - + f"conformer/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/tuning/lm_{lm_w}_ps_{ps}", + + f"conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/tuning/lm_{lm_w}_ps_{ps}", datasets=train_data_normal_ctc, train_args=train_args_glow_enc768_200ep_conformer_asr_data, search_args={**default_search_args_asr, **additional_search_args}, @@ -1159,7 +1171,7 @@ def run_exp( ) run_exp( prefix_name - + f"conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_{lm_w}_ps_{ps}", + + f"conformer/glow_not_eval/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_{lm_w}_ps_{ps}", datasets=train_data_normal_ctc, train_args=train_args_conformer_no_spec_augment_asr_data, search_args={**default_search_args_asr, **additional_search_args}, @@ -1200,7 +1212,7 @@ def run_exp( optimized_search_args = {"lm_weight": 3.0, "prior_scale": 0.5} run_exp( - prefix_name + f"conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/tuned", + prefix_name + f"conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/tuned", datasets=train_data_normal_ctc, train_args=train_args_conformer_asr_data, search_args={**default_search_args_asr, **optimized_search_args}, @@ -1210,7 +1222,7 @@ def run_exp( test_datasets=test_dataset_normal_ctc_tuples, ) run_exp( - prefix_name + f"conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/tuned", + prefix_name + f"conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/tuned", datasets=train_data_normal_ctc, train_args=train_args_conformer_asr_data, search_args={**default_search_args_asr, **optimized_search_args}, @@ -1233,7 +1245,7 @@ def run_exp( run_exp( prefix_name - + f"conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_{p}", + + f"conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_{p}", datasets=train_data_normal_ctc, train_args=train_args_conformer_speaker_drop_asr_data, search_args=default_search_args_asr, @@ -1254,7 +1266,7 @@ def run_exp( additional_search_args = {"lm_weight": lm_w, "prior_scale": ps} run_exp( prefix_name - + f"conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_{lm_w}_ps_{ps}", + + f"conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_{lm_w}_ps_{ps}", datasets=train_data_normal_ctc, train_args=train_args_conformer_speaker_drop_asr_data, search_args={**default_search_args_asr, **additional_search_args}, @@ -1275,7 +1287,7 @@ def run_exp( additional_search_args = {"lm_weight": lm_w, "prior_scale": ps} run_exp( prefix_name - + f"conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_{lm_w}_ps_{ps}", + + f"conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_{lm_w}_ps_{ps}", datasets=train_data_normal_ctc, train_args=train_args_conformer_speaker_drop_asr_data, search_args={**default_search_args_asr, **additional_search_args}, @@ -1283,6 +1295,49 @@ def run_exp( num_epochs=250, with_prior=True, ) + + # -------------------Speaker Drop Fix ----------------------- + train_args_conformer_speaker_drop_asr_data = copy.deepcopy(train_args_conformer_asr_data_v2) + + for p in [0.3, 0.5, 1]: + TTS_exp_name = f"glowTTS/enc192/100ep/speaker_drop/p_speaker_drop_{p}_not_silence_preprocessed" + assert TTS_exp_name in TTS_experiments, "Experiment reference not found!" + + TTS_exp_train_job = TTS_experiments[TTS_exp_name]["train_job"] + train_args_conformer_speaker_drop_asr_data["config"]["preload_from_files"]["existing-model"]["filename"] = ( + TTS_exp_train_job.out_checkpoints[TTS_exp_train_job.returnn_config.get("num_epochs", 100)] + ) + + run_exp( + prefix_name + + f"conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_{p}", + datasets=train_data_normal_ctc, + train_args=train_args_conformer_speaker_drop_asr_data, + search_args=default_search_args_asr, + large_gpu_training=True, + num_epochs=250, + ) + + for p in [0.3, 0.5, 1]: + TTS_exp_name = f"glowTTS/enc192/100ep/speaker_drop/p_speaker_drop_{p}_not_silence_preprocessed" + assert TTS_exp_name in TTS_experiments, "Experiment reference not found!" + TTS_exp_train_job = TTS_experiments[TTS_exp_name]["train_job"] + train_args_conformer_speaker_drop_asr_data["config"]["preload_from_files"]["existing-model"]["filename"] = ( + TTS_exp_train_job.out_checkpoints[TTS_exp_train_job.returnn_config.get("num_epochs", 100)] + ) + for lm_w in [2.5, 3.0, 3.5, 4.0]: + for ps in [0, 0.3, 0.5]: + additional_search_args = {"lm_weight": lm_w, "prior_scale": ps} + run_exp( + prefix_name + + f"conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_{p}/search_params/lm_{lm_w}_ps_{ps}", + datasets=train_data_normal_ctc, + train_args=train_args_conformer_speaker_drop_asr_data, + search_args={**default_search_args_asr, **additional_search_args}, + large_gpu_training=True, + num_epochs=250, + with_prior=True, + ) # ------------------------------ No Freezing Experiments ------------------------------ train_args_conformer_no_freeze_asr_data = copy.deepcopy(train_args_conformer_asr_data) @@ -1313,18 +1368,6 @@ def run_exp( num_epochs=250, ) - train_args_conformer_asr_data_spec_aug_before = copy.deepcopy(train_args_conformer_asr_data) - train_args_conformer_asr_data_spec_aug_before["network_module"] = "glowASR_conformer_specaug_before" - train_args_conformer_asr_data_spec_aug_before["net_args"]["spec_augment"] = True - run_exp( - prefix_name + "conformer/asr_dataset/spec_augment_before/glow_enc192_200ep_not_silence_preprocessed", - datasets=train_data_normal_ctc, - train_args=train_args_conformer_asr_data_spec_aug_before, - search_args=default_search_args_asr, - large_gpu_training=False, - num_epochs=250, - ) - train_args_conformer_no_freeze_asr_data_no_spec_augment = copy.deepcopy(train_args_conformer_no_freeze_asr_data) train_args_conformer_no_freeze_asr_data_no_spec_augment["net_args"]["spec_augment"] = False train_args_conformer_no_freeze_asr_data_no_spec_augment["network_module"] = "glowASR_conformer_no_freeze" @@ -1379,6 +1422,21 @@ def run_exp( num_epochs=250, ) + train_args_weak_conformer_no_pretrained_asr_data_spec_augment_after_fe = copy.deepcopy( + train_args_conformer_no_pretrained_asr_data_spec_augment_after_fe + ) + train_args_weak_conformer_no_pretrained_asr_data_spec_augment_after_fe["network_module"] = ( + "glowASR_conformer_no_freeze_spec_augment_weak_conf" + ) + run_exp( + prefix_name + "weak_conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained", + datasets=train_data_normal_ctc, + train_args=train_args_weak_conformer_no_pretrained_asr_data_spec_augment_after_fe, + search_args=default_search_args_asr, + large_gpu_training=False, + num_epochs=250, + ) + train_args_conformer_no_pretrained_control = copy.deepcopy(train_args_conformer_no_pretrained_asr_data) train_args_conformer_no_pretrained_control["network_module"] = "glowASR_conformer" run_exp( @@ -1612,7 +1670,7 @@ def run_exp( with_prior=True, ) - train_args_conformer_asr_data_v3_768 = copy.deepcopy(train_args_conformer_asr_data) + train_args_conformer_asr_data_v3_768 = copy.deepcopy(train_args_conformer_asr_data_v2) train_args_conformer_asr_data_v3_768["config"]["preload_from_files"]["existing-model"]["filename"] = tts_models[ "glowTTS/enc768/200ep/dec_drop_0.05" ].checkpoint @@ -1626,6 +1684,53 @@ def run_exp( num_epochs=250, ) + train_args_weak_conformer_asr_data_v3_768 = copy.deepcopy(train_args_conformer_asr_data_v3_768) + train_args_weak_conformer_asr_data_v3_768["network_module"] = "glowASR_conformer_x_vector_v2_weak_conf" + run_exp( + prefix_name + "weak_conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2", + datasets=train_data_normal_ctc, + train_args=train_args_weak_conformer_asr_data_v3_768, + search_args=default_search_args_asr, + large_gpu_training=True, + num_epochs=250, + ) + + train_args_conformer_asr_data_v3_768_no_specaug = copy.deepcopy(train_args_conformer_asr_data_v3_768) + train_args_conformer_asr_data_v3_768_no_specaug["net_args"]["spec_augment"] = False + run_exp( + prefix_name + "conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2", + datasets=train_data_normal_ctc, + train_args=train_args_conformer_asr_data_v3_768_no_specaug, + search_args=default_search_args_asr, + large_gpu_training=True, + num_epochs=250, + ) + + train_args_conformer_asr_data_v3_768_400 = copy.deepcopy(train_args_conformer_asr_data_v3_768) + train_args_conformer_asr_data_v3_768_400["config"]["preload_from_files"]["existing-model"]["filename"] = tts_models[ + "glowTTS/enc768/400ep/grad_clip_10/dec_drop_0.05" + ].checkpoint + + run_exp( + prefix_name + "conformer/asr_dataset/spec_augment/glow_enc768_400ep_dec_0.05_v2", + datasets=train_data_normal_ctc, + train_args=train_args_conformer_asr_data_v3_768_400, + search_args=default_search_args_asr, + large_gpu_training=True, + num_epochs=250, + ) + + train_args_conformer_asr_data_v3_768_400_no_specaug = copy.deepcopy(train_args_conformer_asr_data_v3_768_400) + train_args_conformer_asr_data_v3_768_400_no_specaug["net_args"]["spec_augment"] = False + run_exp( + prefix_name + "conformer/asr_dataset/no_spec_augment/glow_enc768_400ep_dec_0.05_v2", + datasets=train_data_normal_ctc, + train_args=train_args_conformer_asr_data_v3_768_400_no_specaug, + search_args=default_search_args_asr, + large_gpu_training=True, + num_epochs=250, + ) + train_args_conformer_asr_data_v3_192 = copy.deepcopy(train_args_conformer_asr_data_v3_768) train_args_conformer_asr_data_v3_192["config"]["preload_from_files"]["existing-model"]["filename"] = tts_models[ "glowTTS/enc192/200ep/dec_drop_0.05" @@ -1654,6 +1759,52 @@ def run_exp( num_epochs=250, ) + train_args_weak_conformer_asr_data_xvector_v3 = copy.deepcopy(train_args_conformer_asr_data_xvector_v3) + train_args_weak_conformer_asr_data_xvector_v3["network_module"] = "glowASR_conformer_x_vector_v2_bottleneck_weak_conf" + run_exp( + prefix_name + "weak_conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2", + datasets=train_data_normal_ctc, + train_args=train_args_weak_conformer_asr_data_xvector_v3, + search_args=default_search_args_asr, + large_gpu_training=False, + num_epochs=250, + ) + + train_args_conformer_asr_data_xvector_v3_no_specaug = copy.deepcopy(train_args_conformer_asr_data_xvector_v3) + train_args_conformer_asr_data_xvector_v3_no_specaug["net_args"]["spec_augment"] = False + run_exp( + prefix_name + "conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2", + datasets=train_data_normal_ctc, + train_args=train_args_conformer_asr_data_xvector_v3_no_specaug, + search_args=default_search_args_asr, + large_gpu_training=True, + num_epochs=250, + ) + + train_args_conformer_asr_data_xvector_v3_400 = copy.deepcopy(train_args_conformer_asr_data_xvector_v3) + train_args_conformer_asr_data_xvector_v3_400["config"]["preload_from_files"]["existing-model"]["filename"] = tts_models[ + "glowTTS_x_vector_v2/enc768/400ep/dec_drop_0.05" + ].checkpoint + run_exp( + prefix_name + "conformer/asr_dataset/spec_augment/glow_x_vector_enc768_400ep_dec_0.05_v2", + datasets=train_data_normal_ctc, + train_args=train_args_conformer_asr_data_xvector_v3_400, + search_args=default_search_args_asr, + large_gpu_training=False, + num_epochs=250, + ) + + train_args_conformer_asr_data_xvector_v3_400_no_specaug = copy.deepcopy(train_args_conformer_asr_data_xvector_v3_400) + train_args_conformer_asr_data_xvector_v3_400_no_specaug["net_args"]["spec_augment"] = False + run_exp( + prefix_name + "conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_400ep_dec_0.05_v2", + datasets=train_data_normal_ctc, + train_args=train_args_conformer_asr_data_xvector_v3_400_no_specaug, + search_args=default_search_args_asr, + large_gpu_training=True, + num_epochs=250, + ) + train_args_conformer_asr_data_xvector_v3_192 = copy.deepcopy(train_args_conformer_asr_data_xvector_v3) train_args_conformer_asr_data_xvector_v3_192["config"]["preload_from_files"]["existing-model"]["filename"] = ( tts_models["glowTTS_x_vector_v2/enc192/200ep/dec_drop_0.05"].checkpoint @@ -1680,6 +1831,15 @@ def run_exp( num_epochs=250, ) + run_exp( + prefix_name + f"conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_{lm_w}_ps_{ps}", + datasets=train_data_normal_ctc, + train_args=train_args_conformer_asr_data_v3_768_no_specaug, + search_args={**default_search_args_asr, **additional_search_args}, + large_gpu_training=True, + num_epochs=250, + ) + run_exp( prefix_name + f"conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/search_params/lm_{lm_w}_ps_{ps}", @@ -1700,6 +1860,15 @@ def run_exp( num_epochs=250, ) + run_exp( + prefix_name + f"conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_{lm_w}_ps_{ps}", + datasets=train_data_normal_ctc, + train_args=train_args_conformer_asr_data_xvector_v3_no_specaug, + search_args={**default_search_args_asr, **additional_search_args}, + large_gpu_training=True, + num_epochs=250, + ) + run_exp( prefix_name + f"conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/search_params/lm_{lm_w}_ps_{ps}", diff --git a/users/rilling/experiments/librispeech/librispeech_glow_asr/pytorch_networks/glowASR_conformer_no_freeze_spec_augment_weak_conf.py b/users/rilling/experiments/librispeech/librispeech_glow_asr/pytorch_networks/glowASR_conformer_no_freeze_spec_augment_weak_conf.py new file mode 100644 index 000000000..233ed37ad --- /dev/null +++ b/users/rilling/experiments/librispeech/librispeech_glow_asr/pytorch_networks/glowASR_conformer_no_freeze_spec_augment_weak_conf.py @@ -0,0 +1,290 @@ +""" +Trying to make the aligner more AppTek-Like + +Extended weight init code +""" + +from dataclasses import dataclass +import torch +import numpy as np +from torch import nn +import multiprocessing +from librosa import filters +import sys +import time +from typing import Any, Dict, Optional, Tuple, Union +import math + +from torchaudio.functional import mask_along_axis + +from i6_models.parts.blstm import BlstmEncoderV1, BlstmEncoderV1Config + + +from i6_models.parts.conformer.norm import LayerNormNC +from i6_models.assemblies.conformer.conformer_v1 import ConformerEncoderV1Config +from i6_models.assemblies.conformer.conformer_v1 import ConformerBlockV1Config, ConformerEncoderV1 +from i6_models.config import ModuleFactoryV1 +from i6_models.parts.frontend.vgg_act import VGG4LayerActFrontendV1, VGG4LayerActFrontendV1Config + +from i6_models.parts.conformer.convolution import ConformerConvolutionV1Config +from i6_models.parts.conformer.feedforward import ConformerPositionwiseFeedForwardV1Config +from i6_models.parts.conformer.mhsa import ConformerMHSAV1Config +from i6_models.primitives.specaugment import specaugment_v1_by_length +from i6_models.primitives.feature_extraction import LogMelFeatureExtractionV1, LogMelFeatureExtractionV1Config +from ..i6modelsV1_VGG4LayerActFrontendV1_v4_cfg import ModelConfig + +from ..i6modelsV1_VGG4LayerActFrontendV1_v4_cfg import \ + SpecaugConfig, VGG4LayerActFrontendV1Config_mod, ModelConfig + + +from returnn.torch.context import get_run_ctx + +from .shared.configs import DbMelFeatureExtractionConfig +from .shared.feature_extraction import DbMelFeatureExtraction +from .shared.spec_augment import apply_spec_aug +from .shared.mask import mask_tensor + +from .shared import modules +from .shared import commons +from .shared import attentions +from .monotonic_align import maximum_path + +from .shared.forward import forward_init_hook, forward_step, forward_finish_hook, prior_init_hook, prior_finish_hook, prior_step +from .shared.train import train_step + +from IPython import embed + +class Model(nn.Module): + """ + Flow-based ASR model based on GlowTTS Structure using a pre-trained flow-based decoder + trained to generate spectrograms from given statistics coming from an encoder + + Model was pretrained using the architecture in + users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS.py + """ + + def __init__( + self, + n_vocab: int, + hidden_channels: int = 192, + out_channels: int = 80, + n_blocks_dec: int = 12, + kernel_size_dec: int = 5, + dilation_rate: int = 1, + n_block_layers: int = 4, + p_dropout: float = 0.1, + p_dropout_flow: float = 0.05, + gin_channels: int = 0, + n_split: int = 4, + n_sqz: int = 2, + sigmoid_scale: bool = False, + window_size: int = 4, + block_length: int = None, + hidden_channels_dec: int = None, + label_target_size=None, + spec_augment = False, + layer_norm = False, + batch_norm = False, + **kwargs, + ): + """_summary_ + + Args: + n_vocab (int): vocabulary size + hidden_channels (int): Number of hidden channels in encoder + out_channels (int): Number of channels in the output + n_blocks_dec (int, optional): Number of coupling blocks in the decoder. Defaults to 12. + kernel_size_dec (int, optional): Kernel size in the decoder. Defaults to 5. + dilation_rate (int, optional): Dilation rate for CNNs of coupling blocks in decoder. Defaults to 5. + n_block_layers (int, optional): Number of layers in the CNN of the coupling blocks in decoder. Defaults to 4. + p_dropout_dec (_type_, optional): Dropout probability in the decoder. Defaults to 0.. + n_speakers (int, optional): Number of speakers. Defaults to 0. + gin_channels (int, optional): Number of speaker embedding channels. Defaults to 0. + n_split (int, optional): Number of splits for the 1x1 convolution for flows in the decoder. Defaults to 4. + n_sqz (int, optional): Squeeze. Defaults to 1. + sigmoid_scale (bool, optional): Boolean to define if log probs in coupling layers should be rescaled using sigmoid. Defaults to False. + window_size (int, optional): Window size in Multi-Head Self-Attention for encoder. Defaults to None. + block_length (_type_, optional): Block length for optional block masking in Multi-Head Attention for encoder. Defaults to None. + hidden_channels_dec (_type_, optional): Number of hidden channels in decodder. Defaults to hidden_channels. + final_hidden_channels: Number of hidden channels in the final network + final_n_layers: Number of layers in the final network + label_target_size: Target size of target vocabulary, target size for final network + """ + super().__init__() + self.n_vocab = n_vocab + self.hidden_channels = hidden_channels + self.out_channels = out_channels + self.n_blocks_dec = n_blocks_dec + self.kernel_size_dec = kernel_size_dec + self.dilation_rate = dilation_rate + self.n_block_layers = n_block_layers + self.p_dropout = p_dropout + self.p_dropout_flow = p_dropout_flow + self.n_split = n_split + self.n_sqz = n_sqz + self.sigmoid_scale = sigmoid_scale + self.window_size = window_size + self.block_length = block_length + self.hidden_channels_dec = hidden_channels_dec + self.spec_augment = spec_augment + self.layer_norm = layer_norm + self.batch_norm = batch_norm + + self.net_kwargs = { + "repeat_per_num_frames": 100, + "max_dim_feat": 8, + "num_repeat_feat": 5, + "max_dim_time": 20, + } + + fe_config = DbMelFeatureExtractionConfig.from_dict(kwargs["fe_config"]) + self.feature_extraction = DbMelFeatureExtraction(config=fe_config) + + if label_target_size is None: + if n_vocab is None: + run_ctx = get_run_ctx() + dataset = run_ctx.engine.train_dataset or run_ctx.engine.forward_dataset + self.label_target_size = len(dataset.datasets["zip_dataset"].targets.labels) + else: + self.label_target_size = n_vocab + else: + self.label_target_size = label_target_size + + self.decoder = modules.Flow( + out_channels, + hidden_channels_dec or hidden_channels, + kernel_size_dec, + dilation_rate, + n_blocks_dec, + n_block_layers, + p_dropout=p_dropout_flow, + n_split=n_split, + n_sqz=n_sqz, + sigmoid_scale=sigmoid_scale, + gin_channels=gin_channels, + ) + + frontend_config = VGG4LayerActFrontendV1Config( + in_features=80, + conv1_channels=16, + conv2_channels=16, + conv3_channels=16, + conv4_channels=16, + conv_kernel_size=(3, 3), + conv_padding=None, + pool1_kernel_size=(2, 1), + pool1_stride=(2, 1), + pool1_padding=None, + pool2_kernel_size=(2, 1), + pool2_stride=(2, 1), + pool2_padding=None, + out_features=96, + activation=nn.ReLU(), + ) + + model_config = ModelConfig( + frontend_config=frontend_config, + specaug_config=None, + label_target_size=self.n_vocab, + conformer_size=96, + num_layers=8, + num_heads=2, + ff_dim=384, + att_weights_dropout=0.2, + conv_dropout=0.2, + ff_dropout=0.2, + mhsa_dropout=0.2, + conv_kernel_size=9, + final_dropout=0.2, + specauc_start_epoch=1, + ) + self.cfg = model_config + frontend_config = self.cfg.frontend_config + conformer_size = self.cfg.conformer_size + conformer_config = ConformerEncoderV1Config( + num_layers=self.cfg.num_layers, + frontend=ModuleFactoryV1(module_class=VGG4LayerActFrontendV1, cfg=frontend_config), + block_cfg=ConformerBlockV1Config( + ff_cfg=ConformerPositionwiseFeedForwardV1Config( + input_dim=conformer_size, + hidden_dim=self.cfg.ff_dim, + dropout=self.cfg.ff_dropout, + activation=nn.functional.silu, + ), + mhsa_cfg=ConformerMHSAV1Config( + input_dim=conformer_size, + num_att_heads=self.cfg.num_heads, + att_weights_dropout=self.cfg.att_weights_dropout, + dropout=self.cfg.mhsa_dropout, + ), + conv_cfg=ConformerConvolutionV1Config( + channels=conformer_size, kernel_size=self.cfg.conv_kernel_size, dropout=self.cfg.conv_dropout, activation=nn.functional.silu, + norm=LayerNormNC(conformer_size) + ), + ), + ) + + if self.layer_norm: + print("Using Layer Norm after Flow...") + + if self.batch_norm: + print("Using Batch Norm after Flow...") + self.bn = nn.BatchNorm1d(self.out_channels) + else: + self.bn = None + + self.conformer = ConformerEncoderV1(cfg=conformer_config) + self.final_linear = nn.Linear(conformer_size, self.cfg.label_target_size + 1) # + CTC blank + self.final_dropout = nn.Dropout(p=self.cfg.final_dropout) + self.specaug_start_epoch = self.cfg.specauc_start_epoch + + def forward(self, raw_audio, raw_audio_len): + with torch.no_grad(): + squeezed_audio = torch.squeeze(raw_audio) + log_mel_features, log_mel_features_len = self.feature_extraction(squeezed_audio, raw_audio_len) # [B, T, F] + + audio_max_length = log_mel_features.size(1) + flow_in = log_mel_features.transpose(1,2) # [B, F, T] + flow_in, flow_in_length, flow_in_max_length = self.preprocess(flow_in, log_mel_features_len, audio_max_length) + mask = torch.unsqueeze(commons.sequence_mask(log_mel_features_len, flow_in.size(2)), 1).to(flow_in.dtype) + flow_out, _ = self.decoder(flow_in, mask, reverse=False) # [B, F, T] + + spec_augment_in = flow_out.transpose(1,2) # [B, T, F] + mask = mask_tensor(spec_augment_in, flow_in_length) + + if self.training and self.spec_augment: + audio_features_masked_2 = apply_spec_aug( + spec_augment_in, + num_repeat_time=torch.max(log_mel_features_len).detach().cpu().numpy() + // self.net_kwargs["repeat_per_num_frames"], + max_dim_time=self.net_kwargs["max_dim_time"], + num_repeat_feat=self.net_kwargs["num_repeat_feat"], + max_dim_feat=self.net_kwargs["max_dim_feat"], + ) + else: + audio_features_masked_2 = spec_augment_in + + conformer_in = audio_features_masked_2 + + if self.layer_norm: + conformer_in = torch.nn.functional.layer_norm(conformer_in, (conformer_in.size(-1),)) + elif self.bn is not None: + conformer_in = self.bn(conformer_in.transpose(1,2)).transpose(1,2) + + conformer_out, out_mask = self.conformer(conformer_in, mask) + conformer_out = self.final_dropout(conformer_out) + logits = self.final_linear(conformer_out) + + log_probs = torch.log_softmax(logits, dim=2) + + return log_probs, torch.sum(out_mask, dim=1) + + def preprocess(self, y, y_lengths, y_max_length): + if y_max_length is not None: + y_max_length = (y_max_length // self.n_sqz) * self.n_sqz + y = y[:, :, :y_max_length] + y_lengths = (y_lengths // self.n_sqz) * self.n_sqz + return y, y_lengths, y_max_length + + def store_inverse(self): + self.decoder.store_inverse() diff --git a/users/rilling/experiments/librispeech/librispeech_glow_asr/pytorch_networks/glowASR_conformer_v2.py b/users/rilling/experiments/librispeech/librispeech_glow_asr/pytorch_networks/glowASR_conformer_v2_weak_conf.py similarity index 96% rename from users/rilling/experiments/librispeech/librispeech_glow_asr/pytorch_networks/glowASR_conformer_v2.py rename to users/rilling/experiments/librispeech/librispeech_glow_asr/pytorch_networks/glowASR_conformer_v2_weak_conf.py index 9756a0827..de2448b48 100644 --- a/users/rilling/experiments/librispeech/librispeech_glow_asr/pytorch_networks/glowASR_conformer_v2.py +++ b/users/rilling/experiments/librispeech/librispeech_glow_asr/pytorch_networks/glowASR_conformer_v2_weak_conf.py @@ -172,10 +172,10 @@ def __init__( ) frontend_config = VGG4LayerActFrontendV1Config( in_features=80, - conv1_channels=32, - conv2_channels=64, - conv3_channels=64, - conv4_channels=32, + conv1_channels=16, + conv2_channels=16, + conv3_channels=16, + conv4_channels=16, conv_kernel_size=(3, 3), conv_padding=None, pool1_kernel_size=(2, 1), @@ -184,26 +184,27 @@ def __init__( pool2_kernel_size=(2, 1), pool2_stride=(2, 1), pool2_padding=None, - out_features=384, + out_features=96, activation=nn.ReLU(), ) + conformer_model_config = ModelConfig( frontend_config=frontend_config, - specaug_config=specaug_config, + specaug_config=None, label_target_size=self.n_vocab, - conformer_size=384, - num_layers=12, - num_heads=4, - ff_dim=1536, + conformer_size=96, + num_layers=8, + num_heads=2, + ff_dim=384, att_weights_dropout=0.2, conv_dropout=0.2, ff_dropout=0.2, mhsa_dropout=0.2, - conv_kernel_size=31, + conv_kernel_size=9, final_dropout=0.2, - specauc_start_epoch=1 + specauc_start_epoch=1, ) - + self.cfg = conformer_model_config frontend_config = self.cfg.frontend_config conformer_size = self.cfg.conformer_size @@ -244,7 +245,6 @@ def __init__( self.final_dropout = nn.Dropout(p=self.cfg.final_dropout) self.specaug_start_epoch = self.cfg.specauc_start_epoch - def forward(self, raw_audio, raw_audio_len): with torch.no_grad(): self.decoder.eval() @@ -274,12 +274,12 @@ def forward(self, raw_audio, raw_audio_len): audio_features_masked_2 = spec_augment_in conformer_in = audio_features_masked_2 - + if self.layer_norm: conformer_in = torch.nn.functional.layer_norm(conformer_in, (conformer_in.size(-1),)) elif self.bn is not None: conformer_in = self.bn(conformer_in.transpose(1,2)).transpose(1,2) - + conformer_out, out_mask = self.conformer(conformer_in, mask) conformer_out = self.final_dropout(conformer_out) logits = self.final_linear(conformer_out) @@ -297,4 +297,3 @@ def preprocess(self, y, y_lengths, y_max_length): def store_inverse(self): self.decoder.store_inverse() - diff --git a/users/rilling/experiments/librispeech/librispeech_glow_asr/pytorch_networks/glowASR_conformer_x_vector_v2_bottleneck_weak_conf.py b/users/rilling/experiments/librispeech/librispeech_glow_asr/pytorch_networks/glowASR_conformer_x_vector_v2_bottleneck_weak_conf.py new file mode 100644 index 000000000..84a33497a --- /dev/null +++ b/users/rilling/experiments/librispeech/librispeech_glow_asr/pytorch_networks/glowASR_conformer_x_vector_v2_bottleneck_weak_conf.py @@ -0,0 +1,445 @@ +""" +Trying to make the aligner more AppTek-Like + +Extended weight init code +""" + +from dataclasses import dataclass +import torch +import numpy as np +from torch import nn +import multiprocessing +from librosa import filters +import sys +import time +from typing import Any, Dict, Optional, Tuple, Union +import math + +from torchaudio.functional import mask_along_axis + +from i6_models.parts.blstm import BlstmEncoderV1, BlstmEncoderV1Config + + +from i6_models.parts.conformer.norm import LayerNormNC +from i6_models.assemblies.conformer.conformer_v1 import ConformerEncoderV1Config +from i6_models.assemblies.conformer.conformer_v1 import ConformerBlockV1Config, ConformerEncoderV1 +from i6_models.config import ModuleFactoryV1 +from i6_models.parts.frontend.vgg_act import VGG4LayerActFrontendV1, VGG4LayerActFrontendV1Config + +from i6_models.parts.conformer.convolution import ConformerConvolutionV1Config +from i6_models.parts.conformer.feedforward import ConformerPositionwiseFeedForwardV1Config +from i6_models.parts.conformer.mhsa import ConformerMHSAV1Config +from i6_models.primitives.specaugment import specaugment_v1_by_length +from i6_models.primitives.feature_extraction import LogMelFeatureExtractionV1, LogMelFeatureExtractionV1Config +from ..i6modelsV1_VGG4LayerActFrontendV1_v4_cfg import ModelConfig + +from ..i6modelsV1_VGG4LayerActFrontendV1_v4_cfg import \ + SpecaugConfig, VGG4LayerActFrontendV1Config_mod, ModelConfig + + +from returnn.torch.context import get_run_ctx + +from .shared.configs import DbMelFeatureExtractionConfig +from .shared.feature_extraction import DbMelFeatureExtraction +from .shared.spec_augment import apply_spec_aug +from .shared.mask import mask_tensor + +from .shared import modules +from .shared import commons +from .shared import attentions +from .monotonic_align import maximum_path + +from .shared.forward import forward_init_hook, forward_step, forward_finish_hook, prior_init_hook, prior_finish_hook, prior_step +from .shared.train import train_step + +from IPython import embed + +class XVector(nn.Module): + def __init__(self, input_dim=40, num_classes=8, **kwargs): + super(XVector, self).__init__() + self.tdnn1 = modules.TDNN( + input_dim=input_dim, + output_dim=512, + context_size=5, + dilation=1, + dropout_p=0.5, + batch_norm=True + ) + self.tdnn2 = modules.TDNN( + input_dim=512, output_dim=512, context_size=3, dilation=2, dropout_p=0.5, batch_norm=True + ) + self.tdnn3 = modules.TDNN( + input_dim=512, output_dim=512, context_size=2, dilation=3, dropout_p=0.5, batch_norm=True + ) + self.tdnn4 = modules.TDNN( + input_dim=512, output_dim=512, context_size=1, dilation=1, dropout_p=0.5, batch_norm=True + ) + self.tdnn5 = modules.TDNN( + input_dim=512, output_dim=512, context_size=1, dilation=1, dropout_p=0.5, batch_norm=True + ) + #### Frame levelPooling + self.segment6 = nn.Linear(1024, 512) + self.segment7 = nn.Linear(512, 512) + self.output = nn.Linear(512, num_classes) + self.softmax = nn.Softmax(dim=1) + + # fe_config = DbMelFeatureExtractionConfig.from_dict(kwargs["fe_config"]) + # self.feature_extraction = DbMelFeatureExtraction(config=fe_config) + + def forward(self, x, x_lengths): + # with torch.no_grad(): + # squeezed_audio = torch.squeeze(raw_audio) + # x, x_lengths = self.feature_extraction(squeezed_audio, raw_audio_lengths) # [B, T, F] + + # x = x.transpose(1, 2) + tdnn1_out = self.tdnn1(x) + # return tdnn1_out + tdnn2_out = self.tdnn2(tdnn1_out) + tdnn3_out = self.tdnn3(tdnn2_out) + tdnn4_out = self.tdnn4(tdnn3_out) + tdnn5_out = self.tdnn5(tdnn4_out) + ### Stat Pool + mean = torch.mean(tdnn5_out, 2) + std = torch.std(tdnn5_out, 2) + stat_pooling = torch.cat((mean, std), 1) + segment6_out = self.segment6(stat_pooling) + x_vec = self.segment7(segment6_out) + output = self.output(x_vec) + predictions = self.softmax(output) + return output, predictions, x_vec + +class Flow(nn.Module): + def __init__( + self, + in_channels, + hidden_channels, + kernel_size, + dilation_rate, + n_blocks, + n_layers, + p_dropout=0.0, + n_split=4, + n_sqz=2, + sigmoid_scale=False, + gin_channels=0, + ): + """Flow-based decoder model + + Args: + in_channels (int): Number of incoming channels + hidden_channels (int): Number of hidden channels + kernel_size (int): Kernel Size for convolutions in coupling blocks + dilation_rate (float): Dilation Rate to define dilation in convolutions of coupling block + n_blocks (int): Number of coupling blocks + n_layers (int): Number of layers in CNN of the coupling blocks + p_dropout (float, optional): Dropout probability for CNN in coupling blocks. Defaults to 0.. + n_split (int, optional): Number of splits for the 1x1 convolution for flows in the decoder. Defaults to 4. + n_sqz (int, optional): Squeeze. Defaults to 1. + sigmoid_scale (bool, optional): Boolean to define if log probs in coupling layers should be rescaled using sigmoid. Defaults to False. + gin_channels (int, optional): Number of speaker embedding channels. Defaults to 0. + """ + super().__init__() + + self.in_channels = in_channels + self.hidden_channels = hidden_channels + self.kernel_size = kernel_size + self.dilation_rate = dilation_rate + self.n_blocks = n_blocks + self.n_layers = n_layers + self.p_dropout = p_dropout + self.n_split = n_split + self.n_sqz = n_sqz + self.sigmoid_scale = sigmoid_scale + self.gin_channels = gin_channels + + self.flows = nn.ModuleList() + + for b in range(n_blocks): + self.flows.append(modules.ActNorm(channels=in_channels * n_sqz)) + self.flows.append(modules.InvConvNear(channels=in_channels * n_sqz, n_split=n_split)) + self.flows.append( + attentions.CouplingBlock( + in_channels * n_sqz, + hidden_channels, + kernel_size=kernel_size, + dilation_rate=dilation_rate, + n_layers=n_layers, + gin_channels=gin_channels, + p_dropout=p_dropout, + sigmoid_scale=sigmoid_scale, + ) + ) + + def forward(self, x, x_mask, g=None, reverse=False): + if not reverse: + flows = self.flows + logdet_tot = 0 + else: + flows = reversed(self.flows) + logdet_tot = None + if g is not None: + g = g.unsqueeze(-1) + + if self.n_sqz > 1: + x, x_mask = commons.channel_squeeze(x, x_mask, self.n_sqz) + for f in flows: + if not reverse: + x, logdet = f(x, x_mask, g=g, reverse=reverse) + logdet_tot += logdet + else: + x, logdet = f(x, x_mask, g=g, reverse=reverse) + if self.n_sqz > 1: + x, x_mask = commons.channel_unsqueeze(x, x_mask, self.n_sqz) + return x, logdet_tot + + def store_inverse(self): + for f in self.flows: + f.store_inverse() + +class Model(nn.Module): + """ + Flow-based ASR model based on GlowTTS Structure using a pre-trained flow-based decoder + trained to generate spectrograms from given statistics coming from an encoder + + Model was pretrained using the architecture in + users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS.py + """ + + def __init__( + self, + n_vocab: int, + hidden_channels: int = 192, + out_channels: int = 80, + n_blocks_dec: int = 12, + kernel_size_dec: int = 5, + dilation_rate: int = 1, + n_block_layers: int = 4, + p_dropout: float = 0.1, + p_dropout_flow: float = 0.05, + gin_channels: int = 0, + n_split: int = 4, + n_sqz: int = 2, + sigmoid_scale: bool = False, + window_size: int = 4, + block_length: int = None, + hidden_channels_dec: int = None, + label_target_size=None, + spec_augment = False, + layer_norm = False, + batch_norm = False, + n_speakers = 1, + **kwargs, + ): + """_summary_ + + Args: + n_vocab (int): vocabulary size + hidden_channels (int): Number of hidden channels in encoder + out_channels (int): Number of channels in the output + n_blocks_dec (int, optional): Number of coupling blocks in the decoder. Defaults to 12. + kernel_size_dec (int, optional): Kernel size in the decoder. Defaults to 5. + dilation_rate (int, optional): Dilation rate for CNNs of coupling blocks in decoder. Defaults to 5. + n_block_layers (int, optional): Number of layers in the CNN of the coupling blocks in decoder. Defaults to 4. + p_dropout_dec (_type_, optional): Dropout probability in the decoder. Defaults to 0.. + n_speakers (int, optional): Number of speakers. Defaults to 0. + gin_channels (int, optional): Number of speaker embedding channels. Defaults to 0. + n_split (int, optional): Number of splits for the 1x1 convolution for flows in the decoder. Defaults to 4. + n_sqz (int, optional): Squeeze. Defaults to 1. + sigmoid_scale (bool, optional): Boolean to define if log probs in coupling layers should be rescaled using sigmoid. Defaults to False. + window_size (int, optional): Window size in Multi-Head Self-Attention for encoder. Defaults to None. + block_length (_type_, optional): Block length for optional block masking in Multi-Head Attention for encoder. Defaults to None. + hidden_channels_dec (_type_, optional): Number of hidden channels in decodder. Defaults to hidden_channels. + final_hidden_channels: Number of hidden channels in the final network + final_n_layers: Number of layers in the final network + label_target_size: Target size of target vocabulary, target size for final network + """ + super().__init__() + self.n_vocab = n_vocab + self.hidden_channels = hidden_channels + self.out_channels = out_channels + self.n_blocks_dec = n_blocks_dec + self.kernel_size_dec = kernel_size_dec + self.dilation_rate = dilation_rate + self.n_block_layers = n_block_layers + self.p_dropout = p_dropout + self.p_dropout_flow = p_dropout_flow + self.n_split = n_split + self.n_sqz = n_sqz + self.sigmoid_scale = sigmoid_scale + self.window_size = window_size + self.block_length = block_length + self.hidden_channels_dec = hidden_channels_dec + self.spec_augment = spec_augment + self.layer_norm = layer_norm + self.batch_norm = batch_norm + + self.net_kwargs = { + "repeat_per_num_frames": 100, + "max_dim_feat": 8, + "num_repeat_feat": 5, + "max_dim_time": 20, + } + + fe_config = DbMelFeatureExtractionConfig.from_dict(kwargs["fe_config"]) + self.feature_extraction = DbMelFeatureExtraction(config=fe_config) + + if label_target_size is None: + if n_vocab is None: + run_ctx = get_run_ctx() + dataset = run_ctx.engine.train_dataset or run_ctx.engine.forward_dataset + self.label_target_size = len(dataset.datasets["zip_dataset"].targets.labels) + else: + self.label_target_size = n_vocab + else: + self.label_target_size = label_target_size + + if n_speakers > 1: + self.x_vector = XVector(out_channels, n_speakers) + self.x_vector_bottleneck = nn.Sequential(nn.Linear(512, gin_channels), nn.ReLU()) + + self.decoder = Flow( + out_channels, + hidden_channels_dec or hidden_channels, + kernel_size_dec, + dilation_rate, + n_blocks_dec, + n_block_layers, + p_dropout=p_dropout_flow, + n_split=n_split, + n_sqz=n_sqz, + sigmoid_scale=sigmoid_scale, + gin_channels=gin_channels, + ) + + frontend_config = VGG4LayerActFrontendV1Config( + in_features=80, + conv1_channels=16, + conv2_channels=16, + conv3_channels=16, + conv4_channels=16, + conv_kernel_size=(3, 3), + conv_padding=None, + pool1_kernel_size=(2, 1), + pool1_stride=(2, 1), + pool1_padding=None, + pool2_kernel_size=(2, 1), + pool2_stride=(2, 1), + pool2_padding=None, + out_features=96, + activation=nn.ReLU(), + ) + + model_config = ModelConfig( + frontend_config=frontend_config, + specaug_config=None, + label_target_size=self.n_vocab, + conformer_size=96, + num_layers=8, + num_heads=2, + ff_dim=384, + att_weights_dropout=0.2, + conv_dropout=0.2, + ff_dropout=0.2, + mhsa_dropout=0.2, + conv_kernel_size=9, + final_dropout=0.2, + specauc_start_epoch=1, + ) + self.cfg = model_config + frontend_config = self.cfg.frontend_config + conformer_size = self.cfg.conformer_size + conformer_config = ConformerEncoderV1Config( + num_layers=self.cfg.num_layers, + frontend=ModuleFactoryV1(module_class=VGG4LayerActFrontendV1, cfg=frontend_config), + block_cfg=ConformerBlockV1Config( + ff_cfg=ConformerPositionwiseFeedForwardV1Config( + input_dim=conformer_size, + hidden_dim=self.cfg.ff_dim, + dropout=self.cfg.ff_dropout, + activation=nn.functional.silu, + ), + mhsa_cfg=ConformerMHSAV1Config( + input_dim=conformer_size, + num_att_heads=self.cfg.num_heads, + att_weights_dropout=self.cfg.att_weights_dropout, + dropout=self.cfg.mhsa_dropout, + ), + conv_cfg=ConformerConvolutionV1Config( + channels=conformer_size, kernel_size=self.cfg.conv_kernel_size, dropout=self.cfg.conv_dropout, activation=nn.functional.silu, + norm=LayerNormNC(conformer_size) + ), + ), + ) + + if self.layer_norm: + print("Using Layer Norm after Flow...") + + if self.batch_norm: + print("Using Batch Norm after Flow...") + self.bn = nn.BatchNorm1d(self.out_channels) + else: + self.bn = None + + self.conformer = ConformerEncoderV1(cfg=conformer_config) + self.final_linear = nn.Linear(conformer_size, self.cfg.label_target_size + 1) # + CTC blank + self.final_dropout = nn.Dropout(p=self.cfg.final_dropout) + self.specaug_start_epoch = self.cfg.specauc_start_epoch + + def forward(self, raw_audio, raw_audio_len): + with torch.no_grad(): + self.x_vector.eval() + self.x_vector_bottleneck.eval() + self.decoder.eval() + squeezed_audio = torch.squeeze(raw_audio) + log_mel_features, log_mel_features_len = self.feature_extraction(squeezed_audio, raw_audio_len) # [B, T, F] + + audio_max_length = log_mel_features.size(1) + + flow_in = log_mel_features.transpose(1,2) # [B, F, T] + flow_in, flow_in_length, flow_in_max_length = self.preprocess(flow_in, log_mel_features_len, audio_max_length) + mask = torch.unsqueeze(commons.sequence_mask(log_mel_features_len, flow_in.size(2)), 1).to(flow_in.dtype) + + _, _, g = self.x_vector(log_mel_features.transpose(1,2), log_mel_features_len) + g = self.x_vector_bottleneck(g) + + flow_out, _ = self.decoder(flow_in, mask, g=g, reverse=False) # [B, F, T] + + spec_augment_in = flow_out.transpose(1,2) # [B, T, F] + mask = mask_tensor(spec_augment_in, flow_in_length) + + if self.training and self.spec_augment: + audio_features_masked_2 = apply_spec_aug( + spec_augment_in, + num_repeat_time=torch.max(log_mel_features_len).detach().cpu().numpy() + // self.net_kwargs["repeat_per_num_frames"], + max_dim_time=self.net_kwargs["max_dim_time"], + num_repeat_feat=self.net_kwargs["num_repeat_feat"], + max_dim_feat=self.net_kwargs["max_dim_feat"], + ) + else: + audio_features_masked_2 = spec_augment_in + + conformer_in = audio_features_masked_2 + + if self.layer_norm: + conformer_in = torch.nn.functional.layer_norm(conformer_in, (conformer_in.size(-1),)) + elif self.bn is not None: + conformer_in = self.bn(conformer_in.transpose(1,2)).transpose(1,2) + + conformer_out, out_mask = self.conformer(conformer_in, mask) + conformer_out = self.final_dropout(conformer_out) + logits = self.final_linear(conformer_out) + + log_probs = torch.log_softmax(logits, dim=2) + + return log_probs, torch.sum(out_mask, dim=1) + + def preprocess(self, y, y_lengths, y_max_length): + if y_max_length is not None: + y_max_length = (y_max_length // self.n_sqz) * self.n_sqz + y = y[:, :, :y_max_length] + y_lengths = (y_lengths // self.n_sqz) * self.n_sqz + return y, y_lengths, y_max_length + + def store_inverse(self): + self.decoder.store_inverse() diff --git a/users/rilling/experiments/librispeech/librispeech_glow_asr/training_comparison.ipynb b/users/rilling/experiments/librispeech/librispeech_glow_asr/training_comparison.ipynb index 8be3ac0cd..326039076 100644 --- a/users/rilling/experiments/librispeech/librispeech_glow_asr/training_comparison.ipynb +++ b/users/rilling/experiments/librispeech/librispeech_glow_asr/training_comparison.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 34, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -32,24 +32,25 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "['/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/training']\n" + "['/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/training', '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/training']\n" ] }, { "data": { "text/plain": [ - "({'/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/training': ''},\n", - " 1)" + "({'/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/training': '/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/training': '/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/'},\n", + " 2)" ] }, - "execution_count": 35, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } @@ -60,7 +61,8 @@ " # \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed*/training\",\n", " # \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_*eval/not_silence_preprocessed/training\"\n", " # \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed*/training\"\n", - " \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/training\"\n", + " \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/training\",\n", + " \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/training\",\n", " # \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/librispeech_glow_asr/pytorch/encoding_test/enc768/mean_only/*/training\",\n", " # \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/librispeech_glow_asr/pytorch/encoding_test/enc768/with_sigma/*/training\",\n", " # \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/librispeech_glow_asr/pytorch/encoding_test/enc192/*/training\",\n", @@ -90,7 +92,7 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 18, "metadata": {}, "outputs": [], "source": [ @@ -118,7 +120,7 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 19, "metadata": {}, "outputs": [], "source": [ @@ -127,14 +129,15 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 20, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/training: 3\n", + "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/training: 3\n", + "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/training: 3\n", "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/training: 3\n", "Large Font: False\n", "Setup Interactive Legend\n", @@ -144,18 +147,18 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "d0ff87fb45264d3db97bab3bb479940b", + "model_id": "d2310e7bf4524ee3b98f4cd89b041032", "version_major": 2, "version_minor": 0 }, - "image/png": "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", + "image/png": "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", "text/html": [ "\n", "
\n", "
\n", " Figure\n", "
\n", - " \n", + " \n", "
\n", " " ], diff --git a/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_encoder_sample_test_maxlike_alignment_multi_layer_ffn.py b/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_encoder_sample_test_maxlike_alignment_multi_layer_ffn.py index a693950ae..d46e6a0e9 100644 --- a/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_encoder_sample_test_maxlike_alignment_multi_layer_ffn.py +++ b/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_encoder_sample_test_maxlike_alignment_multi_layer_ffn.py @@ -524,6 +524,7 @@ def forward_step(*, model: Model, data, run_ctx, **kwargs): # print(f"audio_feature shape: {audio_features.shape}") # print(f"audio_feature length: {audio_features_len}") logits, attn, y_lengths = model(phonemes, phonemes_len, audio_features, audio_features_len, speaker_labels) + breakpoint() # embed() upsampled_phonemes = torch.matmul(attn.squeeze(1).transpose(1, 2), phonemes.float().unsqueeze(-1)).squeeze(-1) diff --git a/users/rilling/experiments/librispeech/librispeech_glowtts/training_comparison.ipynb b/users/rilling/experiments/librispeech/librispeech_glowtts/training_comparison.ipynb index 9b26a3326..6113ebc5e 100644 --- a/users/rilling/experiments/librispeech/librispeech_glowtts/training_comparison.ipynb +++ b/users/rilling/experiments/librispeech/librispeech_glowtts/training_comparison.ipynb @@ -29,8 +29,8 @@ { "data": { "text/plain": [ - "{'/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/tts_architecture/glow_tts/raw_audio/decoder_test/simple_enc/glowTTS_simple_encoder_test_maxlike_alignment_multi_layer_ffn_v2/training': '/simple_enc/glowTTS_simple_encoder_test_maxlike_alignment_multi_layer_ffn_v2/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/tts_architecture/glow_tts/raw_audio/decoder_test/simple_enc/glowTTS_simple_encoder_test_maxlike_alignment_multi_layer_ffn/training': '/simple_enc/glowTTS_simple_encoder_test_maxlike_alignment_multi_layer_ffn/',\n", + "{'/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/tts_architecture/glow_tts/raw_audio/decoder_test/simple_enc/glowTTS_simple_encoder_test_maxlike_alignment_multi_layer_ffn/training': '/simple_enc/glowTTS_simple_encoder_test_maxlike_alignment_multi_layer_ffn/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/tts_architecture/glow_tts/raw_audio/decoder_test/simple_enc/glowTTS_simple_encoder_test_maxlike_alignment_multi_layer_ffn_v2/training': '/simple_enc/glowTTS_simple_encoder_test_maxlike_alignment_multi_layer_ffn_v2/',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/tts_architecture/glow_tts/raw_audio/decoder_test/enc192/glowTTS_encoder_sample_test_maxlike_alignment_multi_layer_ffn/training': '/enc192/glowTTS_encoder_sample_test_maxlike_alignment_multi_layer_ffn/'}" ] }, @@ -49,7 +49,7 @@ " # \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/tts_architecture/glow_tts/raw_audio/encoding_test/glowTTS_encoding_test_simple_linear/training\",\n", " # \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS/enc768/*/not_silence_preprocessed/training/\",\n", " # \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/vocoder/simple_gl/vocoder.simple_gl.blstm_gl_predictor_v1/training\"\n", - " \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/tts_architecture/glow_tts/raw_audio/decoder_test/*/*_maxlike_alignment_multi_layer_ffn*/training\",\n", + " # \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/tts_architecture/glow_tts/raw_audio/decoder_test/*/*_maxlike_alignment_multi_layer_ffn*/training\",\n", "]\n", "lr_files = []\n", "for g in globs:\n", @@ -102,18 +102,18 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "c77a4179d2734831920e79543b557541", + "model_id": "c18ea0d7037b458783fc20c28536cdc4", "version_major": 2, "version_minor": 0 }, - "image/png": "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", + "image/png": "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", "text/html": [ "\n", "
\n", "
\n", " Figure\n", "
\n", - " \n", + " \n", "
\n", " " ], diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training/experiments.py b/users/rilling/experiments/librispeech/librispeech_joint_training/experiments.py index 9b9b7b572..a4d523046 100644 --- a/users/rilling/experiments/librispeech/librispeech_joint_training/experiments.py +++ b/users/rilling/experiments/librispeech/librispeech_joint_training/experiments.py @@ -3,6 +3,7 @@ import numpy as np from sisyphus import tk from dataclasses import asdict +import torch from .data import ( @@ -62,6 +63,7 @@ def run_exp( eval_tts=False, tts_eval_datasets=None, eval_invertibility=False, + large_gpu_training=False, ): exp = {} @@ -82,6 +84,7 @@ def run_exp( returnn_root=MINI_RETURNN_ROOT, prefix=prefix + name, num_epochs=num_epochs, + large_gpu=large_gpu_training ) else: train_job = given_train_job_for_forward @@ -168,6 +171,7 @@ def run_exp( nisqa_eval=True, swer_eval=True, swer_eval_corpus_key=ds_k, + nisqa_confidence=True, ) # forward_job_gl = tts_eval( @@ -383,6 +387,52 @@ def run_exp( n_speakers=speaker_datastream.vocab_size, ) + strong_specaug_config = SpecaugConfig( + repeat_per_n_frames=25, + max_dim_time=20, + max_dim_feat=16, + num_repeat_feat=5, + ) + strong_frontend_config = VGG4LayerActFrontendV1Config_mod( + in_features=80, + conv1_channels=32, + conv2_channels=64, + conv3_channels=64, + conv4_channels=32, + conv_kernel_size=(3, 3), + conv_padding=None, + pool1_kernel_size=(2, 1), + pool1_stride=(2, 1), + pool1_padding=None, + pool2_kernel_size=(2, 1), + pool2_stride=(2, 1), + pool2_padding=None, + out_features=384, + activation_str="ReLU", + activation=None + ) + model_config_strong_conformer = ModelConfig( + frontend_config=strong_frontend_config, + specaug_config=strong_specaug_config, + text_encoder_config=text_encoder_config, + decoder_config=flow_decoder_config, + label_target_size=vocab_size_without_blank_asr, + conformer_size=384, + num_layers=12, + num_heads=4, + ff_dim=1536, + att_weights_dropout=0.2, + conv_dropout=0.2, + ff_dropout=0.2, + mhsa_dropout=0.2, + conv_kernel_size=31, + final_dropout=0.2, + specauc_start_epoch=1, + out_channels=80, + gin_channels=256, + n_speakers=speaker_datastream.vocab_size, + ) + net_module = "glowTTS_ASR_conformer_x_vector" train_args = { @@ -972,6 +1022,7 @@ def run_exp( search_args=default_search_args, eval_tts=True, tts_eval_datasets=tts_forward_datasets, + eval_invertibility=True, ) exp_dict = run_exp( net_module + "_ctc_scale_0.1", @@ -984,6 +1035,7 @@ def run_exp( search_args=default_search_args, eval_tts=True, tts_eval_datasets=tts_forward_datasets, + eval_invertibility=True, ) for lm in [2.0, 2.5, 3.0, 3.5, 4.0, 4.5]: @@ -1007,6 +1059,23 @@ def run_exp( search_args={**default_search_args, **{"lm_weight": lm}}, ) + train_args_two_forward_no_xvector_strong_conformer = copy.deepcopy(train_args_two_forward_no_xvector) + train_args_two_forward_no_xvector_strong_conformer["net_args"]["model_config"] = asdict(model_config_strong_conformer) + + exp_dict = run_exp( + net_module + "_strong_conformer_ctc_scale_0.1", + train_args_two_forward_no_xvector_strong_conformer, + training_datasets, + asr_test_datasets, + 250, + training_args={"ctc_scale": 0.1}, + forward_args=forward_args, + search_args=default_search_args, + eval_tts=True, + tts_eval_datasets=tts_forward_datasets, + large_gpu_training=True + ) + train_args_conformer_only = copy.deepcopy(train_args) train_args_conformer_only["net_args"]["model_config"] = asdict(model_config) net_module = "only_conformer" diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training/pipeline.py b/users/rilling/experiments/librispeech/librispeech_joint_training/pipeline.py index 4c5d7c014..1f85c074e 100644 --- a/users/rilling/experiments/librispeech/librispeech_joint_training/pipeline.py +++ b/users/rilling/experiments/librispeech/librispeech_joint_training/pipeline.py @@ -13,7 +13,7 @@ from .default_tools import SCTK_BINARY_PATH, NISQA_REPO -def training(config, returnn_exe, returnn_root, prefix, num_epochs=65): +def training(config, returnn_exe, returnn_root, prefix, num_epochs=65, large_gpu=False): train_job = ReturnnTrainingJob( config, log_verbosity=5, @@ -24,6 +24,10 @@ def training(config, returnn_exe, returnn_root, prefix, num_epochs=65): returnn_python_exe=returnn_exe, returnn_root=returnn_root, ) + + if (large_gpu): + train_job.rqmt["gpu_mem"] = 24 + train_job.add_alias(prefix + "/training") tk.register_output(prefix + "/training.models", train_job.out_model_dir) diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/glowTTS_ASR_conformer_two_forward_pass.py b/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/glowTTS_ASR_conformer_two_forward_pass.py index ef03ac686..256267ce4 100644 --- a/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/glowTTS_ASR_conformer_two_forward_pass.py +++ b/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/glowTTS_ASR_conformer_two_forward_pass.py @@ -57,6 +57,7 @@ from .shared.forward import search_init_hook, search_finish_hook from .shared.eval_forward import * +from .shared.eval_invertibility import * from IPython import embed @@ -435,8 +436,7 @@ def forward( return log_probs, torch.sum(out_mask, dim=1) else: z, logdet = self.decoder(y, z_mask, g=g, reverse=False) # [B, F, T] - from IPython import embed - embed() + with torch.no_grad(): x_s_sq_r = torch.exp(-2 * x_logs) logp1 = torch.sum(-0.5 * math.log(2 * math.pi) - x_logs, [1]).unsqueeze(-1) # [b, t, 1] diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/glowTTS_ASR_conformer_x_vector.py b/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/glowTTS_ASR_conformer_x_vector.py index 9d2430fd2..ecb2211c3 100644 --- a/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/glowTTS_ASR_conformer_x_vector.py +++ b/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/glowTTS_ASR_conformer_x_vector.py @@ -414,7 +414,7 @@ def __init__( self.specaug_start_epoch = self.cfg.specauc_start_epoch def forward( - self, x=None, x_lengths=None, raw_audio=None, raw_audio_lengths=None, g=None, gen=False, recognition=False, noise_scale=1.0, length_scale=1.0, invertibility_check=False + self, x=None, x_lengths=None, raw_audio=None, raw_audio_lengths=None, g=None, gen=False, recognition=False, noise_scale=1.0, length_scale=1.0 ): if not gen: with torch.no_grad(): @@ -439,11 +439,6 @@ def forward( y, y_lengths, y_max_length = self.preprocess(y, y_lengths, y_max_length) z_mask = torch.unsqueeze(commons.sequence_mask(y_lengths, y_max_length), 1).to(torch.int32) - if invertibility_check: - z, _ = self.decoder(y, z_mask, g=g, reverse=False) - y_hat, _ = self.decoder(z, z_mask, g=g, reverse=True) - return y_hat, y - if not recognition: attn_mask = torch.unsqueeze(x_mask, -1) * torch.unsqueeze(z_mask, 2) diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/glow_ASR_conformer.py b/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/glow_ASR_conformer.py index b4ac61197..181e53bd6 100644 --- a/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/glow_ASR_conformer.py +++ b/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/glow_ASR_conformer.py @@ -384,7 +384,7 @@ def __init__( self.specaug_start_epoch = self.cfg.specauc_start_epoch def forward( - self, x=None, x_lengths=None, raw_audio=None, raw_audio_lengths=None, g=None, gen=False, recognition=False, noise_scale=1.0, length_scale=1.0, invertibility_check=False + self, x=None, x_lengths=None, raw_audio=None, raw_audio_lengths=None, g=None, gen=False, recognition=False, noise_scale=1.0, length_scale=1.0 ): if not gen: with torch.no_grad(): @@ -398,12 +398,6 @@ def forward( y, y_lengths, y_max_length = self.preprocess(y, y_lengths, y_max_length) z_mask = torch.unsqueeze(commons.sequence_mask(y_lengths, y_max_length), 1).to(torch.int32) - - if invertibility_check: - g = None # speaker is set in generic forward_invertibility_step, but should not be used, since it was not used during training - z, _ = self.decoder(y, z_mask, g=g, reverse=False) - y_hat, _ = self.decoder(z, z_mask, g=g, reverse=True) - return y_hat, y z, logdet = self.decoder(y, z_mask, g=g, reverse=False) diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/glow_ASR_conformer_specaugment_before.py b/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/glow_ASR_conformer_specaugment_before.py index 7ac8b696a..99c78cbfd 100644 --- a/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/glow_ASR_conformer_specaugment_before.py +++ b/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/glow_ASR_conformer_specaugment_before.py @@ -424,7 +424,7 @@ def __init__( self.specaug_start_epoch = self.cfg.specauc_start_epoch def forward( - self, x=None, x_lengths=None, raw_audio=None, raw_audio_lengths=None, g=None, gen=False, recognition=False, noise_scale=1.0, length_scale=1.0, invertibility_check=False + self, x=None, x_lengths=None, raw_audio=None, raw_audio_lengths=None, g=None, gen=False, recognition=False, noise_scale=1.0, length_scale=1.0 ): if not gen: with torch.no_grad(): @@ -452,12 +452,6 @@ def forward( y, y_lengths, y_max_length = self.preprocess(y, y_lengths, y_max_length) z_mask = torch.unsqueeze(commons.sequence_mask(y_lengths, y_max_length), 1).to(torch.int32) - if invertibility_check: - g = None # Remove speaker id, which is set in forward_invertibility_step - z, _ = self.decoder(y, z_mask, g=g, reverse=False) - y_hat, _ = self.decoder(z, z_mask, g=g, reverse=True) - return y_hat, y - z, logdet = self.decoder(y, z_mask, g=g, reverse=False) # from IPython import embed # embed() diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/glow_ASR_conformer_specaugment_before_xvector.py b/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/glow_ASR_conformer_specaugment_before_xvector.py index 74ba049af..3565e6b00 100644 --- a/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/glow_ASR_conformer_specaugment_before_xvector.py +++ b/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/glow_ASR_conformer_specaugment_before_xvector.py @@ -385,7 +385,7 @@ def __init__( self.specaug_start_epoch = self.cfg.specauc_start_epoch def forward( - self, x=None, x_lengths=None, raw_audio=None, raw_audio_lengths=None, g=None, gen=False, recognition=False, noise_scale=1.0, length_scale=1.0, invertibility_check=False + self, x=None, x_lengths=None, raw_audio=None, raw_audio_lengths=None, g=None, gen=False, recognition=False, noise_scale=1.0, length_scale=1.0 ): with torch.no_grad(): squeezed_audio = torch.squeeze(raw_audio) @@ -413,11 +413,6 @@ def forward( z, logdet = self.decoder(y, z_mask, g=g, reverse=False) - if invertibility_check: - z, _ = self.decoder(y, z_mask, g=g, reverse=False) - y_hat, _ = self.decoder(z, z_mask, g=g, reverse=True) - return y_hat, y - conformer_in = z.transpose(1,2) mask = mask_tensor(spec_augment_in, y_lengths) conformer_out, out_mask = self.conformer(conformer_in, mask) diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/shared/eval_invertibility.py b/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/shared/eval_invertibility.py index b6eb1eb57..3cdc198d0 100644 --- a/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/shared/eval_invertibility.py +++ b/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/shared/eval_invertibility.py @@ -2,15 +2,24 @@ import torch import numpy as np from returnn.datasets.hdf import SimpleHDFWriter +from . import commons + def forward_init_hook_invertibility(run_ctx, **kwargs): - run_ctx.batch_mae = [] + run_ctx.total_mae = 0 + run_ctx.total_ae_var = 0 + run_ctx.total_ae_max = torch.tensor(-np.inf) + run_ctx.total_ae_min = torch.tensor(np.inf) + run_ctx.num_of_obs = 0 def forward_finish_hook_invertibility(run_ctx, **kwargs): - all_batch_mse = torch.Tensor(run_ctx.batch_mae).mean() with open("output.hdf", "w+") as f: - f.write(str(all_batch_mse)) + f.write("total, mean, var, max, min \n") + f.write( + f"{run_ctx.num_of_obs}, {str(float(run_ctx.total_mae))}, {str(float(run_ctx.total_ae_var))}, {str(float(run_ctx.total_ae_max))}, {str(float(run_ctx.total_ae_min))}" + ) + def forward_step_invertibility(*, model, data, run_ctx, **kwargs): raw_audio = data["audio_features"] # [B, N] (sparse) @@ -25,16 +34,57 @@ def forward_step_invertibility(*, model, data, run_ctx, **kwargs): else: raise Exception("Missing speaker embedding!") - tags = data["seq_tag"] + squeezed_audio = torch.squeeze(raw_audio) + y, y_lengths = model.feature_extraction(squeezed_audio, raw_audio_len) # [B, T, F] + y = y.transpose(1, 2) # [B, F, T] + + if hasattr(model, "x_vector"): + _, _, g = model.x_vector(y, y_lengths) + + if hasattr(model, "x_vector_bottleneck"): + g = model.x_vector_bottleneck(g) + elif hasattr(model, "emb_g"): + g = torch.nn.functional.normalize(model.emb_g(g.squeeze(-1))).unsqueeze(-1) + else: + g = None + + y_max_length = y.size(2) + + y, y_lengths, y_max_length = model.preprocess(y, y_lengths, y_max_length) + z_mask = torch.unsqueeze(commons.sequence_mask(y_lengths, y_max_length), 1).to(torch.int32) + + z, _ = model.decoder(y, z_mask, g=g, reverse=False) + y_hat, _ = model.decoder(z, z_mask, g=g, reverse=True) + + mae = torch.nn.functional.l1_loss(y_hat * z_mask, y * z_mask, reduction="none") # [B, F, T] - y_hat, y = model( - x=phonemes, - x_lengths=phonemes_len, - raw_audio=raw_audio, - raw_audio_lengths=raw_audio_len, - g=g, - invertibility_check=True, + current_num_of_obs = y_hat.shape[1] * y_lengths.sum() # F * total_number_of_frames_in_batch + + old_mae = run_ctx.total_mae + + current_mae = ( + mae.sum() / current_num_of_obs + ) # This considers the masking by only using the mean over all unmasked elements + + current_var = (mae - current_mae).sum() / ( + current_num_of_obs - 1 + ) # Variance over unmasked elements with bias correction 1 + + run_ctx.total_mae = ((run_ctx.num_of_obs / (run_ctx.num_of_obs + current_num_of_obs)) * old_mae) + ( + (current_num_of_obs / (run_ctx.num_of_obs + current_num_of_obs)) * current_mae ) - mse = torch.nn.functional.l1_loss(y_hat, y) - run_ctx.batch_mae.append(mse) + run_ctx.total_ae_var = ( + (run_ctx.num_of_obs / (run_ctx.num_of_obs + current_num_of_obs)) * run_ctx.total_ae_var + + ((current_num_of_obs / (run_ctx.num_of_obs + current_num_of_obs)) * current_var) + + ((run_ctx.num_of_obs * current_num_of_obs) / (run_ctx.num_of_obs + current_num_of_obs) ** 2) + * (old_mae - current_mae) ** 2 + ) + + run_ctx.total_ae_max = torch.max(run_ctx.total_ae_max, mae.max()) + + run_ctx.total_ae_min = torch.min( + run_ctx.total_ae_min, (mae + (-1 * z_mask + 1) * torch.tensor(float("inf")).nan_to_num(0.0)).min() + ) # Masked Min operation + + run_ctx.num_of_obs += current_num_of_obs diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/config.py b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/config.py index 85f0139fc..669e1954b 100644 --- a/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/config.py +++ b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/config.py @@ -33,11 +33,14 @@ def get_training_config( # changing these does not change the hash post_config = { "cleanup_old_models": True if keep_epochs is None else {"keep": keep_epochs}, - "stop_on_nonfinite_train_score": True, # this might break now with True + # "stop_on_nonfinite_train_score": True, # this might break now with True "allow_missing_optimizer_checkpoint": True, "backend": "torch" } + if "stop_on_nonfinite_train_score" not in config: + post_config["stop_on_nonfinite_train_score"] = True + base_config = { ############# "train": training_datasets.train.as_returnn_opts(), diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/data.py b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/data.py index a127a39c5..8e1229403 100644 --- a/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/data.py +++ b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/data.py @@ -431,7 +431,7 @@ def build_training_dataset( if use_tts_train_segments: train_segments, cv_segments = get_librispeech_tts_segments(ls_corpus_key=librispeech_key) else: - train_segments = None + train_segments, cv_segments = (None, None) train_bliss, train_ogg = get_train_bliss_and_zip("train-clean-100", silence_preprocessed=silence_preprocessing) dev_clean_bliss_tts, dev_clean_ogg = get_train_bliss_and_zip( diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/exp_joint/experiments.py b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/exp_joint/experiments.py index 302e4d7ef..adf39a1bc 100644 --- a/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/exp_joint/experiments.py +++ b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/exp_joint/experiments.py @@ -33,7 +33,7 @@ PhonemePredictionConfigCNN ) -from ..storage import tts_models +from ..storage import tts_models, add_tts_model, TTSModel def get_glow_joint(x_vector_exp, joint_exps, tts_exps, gl_checkpoint): @@ -768,6 +768,8 @@ def run_exp( tts_eval_datasets=tts_forward_datasets_xvectors ) + add_tts_model(net_module + "/basic_init/no_specaug/tts_target_size/ce_ls_0.1", TTSModel(model_config_cnn, exp_dict["train_job"].out_checkpoints[200])) + train_args_cnn_pretrained = copy.deepcopy(train_args_cnn) train_args_cnn_pretrained["config"]["preload_from_files"] = { "glowTTS_xvector": { @@ -789,3 +791,5 @@ def run_exp( asr_search=False, tts_eval_datasets=tts_forward_datasets_xvectors ) + + add_tts_model(net_module + "/tts_pretrained/no_specaug/tts_target_size/ce_ls_0.1", TTSModel(model_config_cnn, exp_dict["train_job"].out_checkpoints[200])) diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/exp_joint_2step/experiments.py b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/exp_joint_2step/experiments.py index efb1349bd..277fae3fd 100644 --- a/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/exp_joint_2step/experiments.py +++ b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/exp_joint_2step/experiments.py @@ -21,6 +21,8 @@ from i6_experiments.users.rilling.experiments.librispeech.common.tts_eval import tts_eval from ..default_tools import RETURNN_COMMON, RETURNN_PYTORCH_EXE, RETURNN_PYTORCH_ASR_SEARCH_EXE, MINI_RETURNN_ROOT +from i6_models.parts.frontend.vgg_act import VGG4LayerActFrontendV1, VGG4LayerActFrontendV1Config + from ..pytorch_networks.shared.configs import ( SpecaugConfig, ModelConfigV1, @@ -31,7 +33,8 @@ FlowDecoderConfig, PhonemePredictionConfig, PhonemePredictionConfigCNN, - PhonemePredictionConfigBLSTM + PhonemePredictionConfigBLSTM, + ConformerASRConfig ) from ..storage import tts_models, add_tts_model, TTSModel @@ -69,6 +72,8 @@ def run_exp( ): exp = {} + assert num_epochs == len(args["config"]["learning_rates"]), "Number of Epochs and Number of LR steps differs!" + if given_train_job_for_forward is None: training_config = get_training_config( training_datasets=dataset, @@ -175,6 +180,14 @@ def run_exp( xvectors_file=x_vector_extractions["x_vector_cnn/1e-3_not_silence_preprocessed"]["hdf"], ) + train_settings = TrainingDatasetSettings( + custom_processing_function=None, partition_epoch=3, epoch_wise_filters=[], seq_ordering="laplace:.1000" + ) + + training_datasets_pe3 = build_training_dataset( + settings=train_settings, librispeech_key="train-clean-100", silence_preprocessing=False + ) + from typing import cast from i6_experiments.users.rossenbach.common_setups.returnn.datastreams.vocabulary import LabelDatastream @@ -491,3 +504,87 @@ def run_exp( search_args=default_search_args, asr_search=False, ) + + + # ==================== CNN pretrained 2nd step Conformer ====================== + net_module = "frozen_glowtts.glowASR_conformer_x_vector" + first_step_cnn = tts_models["glowTTS_ASR_cnn_x_vector/tts_pretrained/no_specaug/tts_target_size/ce_ls_0.1"] + model_config = first_step_cnn.config + + specaug_config_conf = SpecaugConfig( + repeat_per_n_frames=100, + max_dim_feat=8, + num_repeat_feat=5, + max_dim_time=20, + ) + + frontend_config = VGG4LayerActFrontendV1Config_mod( + in_features=80, + conv1_channels=32, + conv2_channels=64, + conv3_channels=64, + conv4_channels=32, + conv_kernel_size=(3, 3), + conv_padding=None, + pool1_kernel_size=(2, 1), + pool1_stride=(2, 1), + pool1_padding=None, + pool2_kernel_size=(2, 1), + pool2_stride=(2, 1), + pool2_padding=None, + out_features=384, + activation_str="ReLU", + ) + + model_config.phoneme_prediction_config = ConformerASRConfig( + frontend_config=frontend_config, + label_target_size=vocab_size_without_blank_asr, + conformer_size=384, + num_layers=12, + num_heads=4, + ff_dim=1536, + att_weights_dropout=0.2, + conv_dropout=0.2, + ff_dropout=0.2, + mhsa_dropout=0.2, + conv_kernel_size=31, + final_dropout=0.2, + ) + + model_config.specaug_config = specaug_config_conf + model_config.specauc_start_epoch = 1 + + train_args = { + "net_args": {"fe_config": asdict(fe_config), "model_config": asdict(model_config)}, + "network_module": net_module, + "debug": True, + "config": { + "optimizer": {"class": "adam", "epsilon": 1e-8}, + "learning_rates": list(np.linspace(7e-6, 7e-4, 110)) + list(np.linspace(7e-4, 7e-5, 110)) + list(np.linspace(7e-5, 1e-8, 30)), + "batch_size": 360 * 16000, + # "gradient_clip_norm": 1.0, + "stop_on_nonfinite_train_score": False, + # "max_seq_length": {"audio_features": 25 * 16000}, + # "max_seqs": 60, + "preload_from_files": { + "glowTTS": { + "filename": first_step_cnn.checkpoint, + "init_for_train": True, + "ignore_missing": True, + "ignore_params_prefixes": ["encoder", "phoneme_pred_cnn", "phoneme_pred_output"], + } + } + }, + } + + exp_dict = run_exp( + "second_step_asr/" + net_module.replace(".", "/"), + train_args, + training_datasets_pe3, + asr_test_datasets, + 250, + forward_args=forward_args, + search_args=default_search_args, + asr_search=True, + asr_cv_set=True, + ) \ No newline at end of file diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/exp_joint_2step/training_comparison.ipynb b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/exp_joint_2step/training_comparison.ipynb index fe4388e41..51ba86d4c 100644 --- a/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/exp_joint_2step/training_comparison.ipynb +++ b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/exp_joint_2step/training_comparison.ipynb @@ -23,16 +23,16 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 2, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{'/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step_tts/ga_glowTTS_ASR_ffn_x_vector_v2_2ndstep_tts/ce_ls_1.0/training': ''}" + "{'/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step_asr/frozen_glowtts/glowASR_conformer_x_vector/training/': '/'}" ] }, - "execution_count": 7, + "execution_count": 2, "metadata": {}, "output_type": "execute_result" } @@ -44,7 +44,8 @@ " # \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/first_step/ga_glowTTS_ASR_ffn_x_vector_v2/ce_ls_*/training\",\n", " # \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/first_step/ga_glowTTS_ASR_ffn_x_vector_v2*/ce_ls_*/training\",\n", " # \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step/ga_glowTTS_ASR_ffn_x_vector_v2*/*/ce_ls_*/training\",\n", - " \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step_tts/ga_glowTTS_ASR_ffn_x_vector_v2*/ce_ls_*/training\",\n", + " # \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step_tts/ga_glowTTS_ASR_ffn_x_vector_v2*/ce_ls_*/training\",\n", + " \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step_asr/frozen_glowtts/glowASR_conformer_x_vector/training/\",\n", " # \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_cnn_x_vector/*/no_specaug/*/ce_ls_0.1/training\",\n", "]\n", "lr_files = []\n", @@ -64,38 +65,54 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ + "# lr_files.append(\n", + "# \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc768/with_sigma/not_silence_preprocessed/lm5/training/\"\n", + "# )\n", + "# files[lr_files[-1]] = \"Baseline BLSTM on Glow Enc 768\"\n", + "\n", "lr_files.append(\n", - " \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc768/with_sigma/not_silence_preprocessed/lm5/training/\"\n", + " \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/training\"\n", ")\n", - "files[lr_files[-1]] = \"Baseline BLSTM on Glow Enc 768\"" + "files[lr_files[-1]] = \"Former Baseline\"\n", + "\n", + "lr_files.append(\n", + " \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/training/\"\n", + ")\n", + "files[lr_files[-1]] = \"Enc768 0.05 x-vector\"\n" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{'/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/specaug/ce_ls_0.1/training': 3,\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/specaug/ce_ls_1/training': 3,\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/no_specaug/ce_ls_1/training': 3,\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/no_specaug/ce_ls_0.1/training': 3}" + "{'/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/no_specaug/ce_ls_1/training/': 3,\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/no_specaug/ce_ls_0.1/training/': 3,\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/specaug/ce_ls_1/training/': 3,\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/specaug/ce_ls_0.1/training/': 3,\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step_asr/frozen_glowtts/glowASR_conformer_x_vector/training/': 3,\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/training': 3,\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/training/': 3}" ] }, - "execution_count": 9, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "partition_epochs = {\n", - " \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/*/ce_ls_*/training\": 3\n", + " \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/*/ce_ls_*/training/\": 3, \n", + " \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step_asr/frozen_glowtts/glowASR_conformer_x_vector/training/\": 3,\n", + " \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/training\": 3,\n", + " \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/training/\": 3,\n", "}\n", "\n", "partition_epochs_2 = {}\n", @@ -109,15 +126,16 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step_tts/ga_glowTTS_ASR_ffn_x_vector_v2_2ndstep_tts/ce_ls_1.0/training: 1\n", - "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc768/with_sigma/not_silence_preprocessed/lm5/training/: 1\n", + "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step_asr/frozen_glowtts/glowASR_conformer_x_vector/training/: 3\n", + "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/training: 3\n", + "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/training/: 3\n", "Large Font: False\n", "Setup Interactive Legend\n", "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous view', 'arrow-left', 'back'), ('Forward', 'Forward to next view', 'arrow-right', 'forward'), ('Pan', 'Left button pans, Right button zooms\\nx/y fixes axis, CTRL fixes aspect', 'arrows', 'pan'), ('Zoom', 'Zoom to rectangle\\nx/y fixes axis', 'square-o', 'zoom'), ('Download', 'Download plot', 'floppy-o', 'save_figure')]))\n" @@ -126,18 +144,18 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "3b8565f06a5947a091b20af742cbf857", + "model_id": "8879ad67b2a94651b6ff26731340937c", "version_major": 2, "version_minor": 0 }, - "image/png": "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", + "image/png": "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", "text/html": [ "\n", "
\n", "
\n", " Figure\n", "
\n", - " \n", + " \n", "
\n", " " ], @@ -153,7 +171,6 @@ "error_data = {}\n", "labels = list(files.values())\n", "for i, lr_file in enumerate(lr_files):\n", - " breakpoint()\n", " data = get_epoch_data(lr_file, epoch=None)\n", " if data is None:\n", " continue\n", @@ -170,6 +187,7 @@ " # error_data[(labels[i], int(ep//p_e))].update(ep_data_error)\n", " error_data_tmp = []\n", "df = pd.DataFrame.from_dict(error_data, orient=\"index\")\n", + "\n", "plot_df(\n", " df,\n", " plot_lr=False,\n", @@ -177,7 +195,7 @@ " shrink_axes=0.6,\n", " # ylim_max=4,\n", " # ylim_min=-0.9,\n", - " keys_exclude=\"ctc\",\n", + " # keys_exclude=\"ctc\",\n", " # color_map=\"Set1\",\n", " draggable=True\n", ")" @@ -185,7 +203,93 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ctcdev_loss_ctcdevtrain_loss_ctc
/13.8545573.8639753.834595
23.7420743.5673983.467777
32.4797512.1673831.838922
42.0517741.8115391.417094
51.8355451.5860351.171362
\n", + "
" + ], + "text/plain": [ + " ctc dev_loss_ctc devtrain_loss_ctc\n", + "/ 1 3.854557 3.863975 3.834595\n", + " 2 3.742074 3.567398 3.467777\n", + " 3 2.479751 2.167383 1.838922\n", + " 4 2.051774 1.811539 1.417094\n", + " 5 1.835545 1.586035 1.171362" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.head(5)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -229,7 +333,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.12" + "version": "3.10.13" } }, "nbformat": 4, diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/exp_joint_flow_ga_frozen_glowtts/experiments.py b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/exp_joint_flow_ga_frozen_glowtts/experiments.py index 7e6b8fd3d..a460aa1ed 100644 --- a/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/exp_joint_flow_ga_frozen_glowtts/experiments.py +++ b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/exp_joint_flow_ga_frozen_glowtts/experiments.py @@ -543,3 +543,59 @@ def run_exp( search_args=default_search_args, phoneme_pred=True, ) + + net_module = "frozen_glowtts.ga_glowTTS_ASR_ffn_mas" + train_args_no_xvectors_mas = copy.deepcopy(train_args_no_xvectors) + train_args_no_xvectors_mas["network_module"] = net_module + + exp_dict = run_exp( + net_module.replace(".", "/") + "/100ep/encoder", + train_args_no_xvectors_mas, + training_datasets_pe1_tts_segments, + dev_dataset_tuples_with_phon, + 100, + forward_args=forward_args, + training_args={"recognition_input": "encoder"}, + search_args=default_search_args, + phoneme_pred=True, + ) + + exp_dict = run_exp( + net_module.replace(".", "/") + "/100ep/decoder", + train_args_no_xvectors_mas, + training_datasets_pe1_tts_segments, + dev_dataset_tuples_with_phon, + 100, + forward_args=forward_args, + training_args={"recognition_input": "decoder"}, + search_args=default_search_args, + phoneme_pred=True, + ) + + net_module = "frozen_glowtts.ga_glowTTS_ASR_ffn_mas_no_eval" + train_args_no_xvectors_mas_no_eval = copy.deepcopy(train_args_no_xvectors_mas) + train_args_no_xvectors_mas_no_eval["network_module"] = net_module + + exp_dict = run_exp( + net_module.replace(".", "/") + "/100ep/encoder", + train_args_no_xvectors_mas_no_eval, + training_datasets_pe1_tts_segments, + dev_dataset_tuples_with_phon, + 100, + forward_args=forward_args, + training_args={"recognition_input": "encoder"}, + search_args=default_search_args, + phoneme_pred=True, + ) + + exp_dict = run_exp( + net_module.replace(".", "/") + "/100ep/decoder", + train_args_no_xvectors_mas_no_eval, + training_datasets_pe1_tts_segments, + dev_dataset_tuples_with_phon, + 100, + forward_args=forward_args, + training_args={"recognition_input": "decoder"}, + search_args=default_search_args, + phoneme_pred=True, + ) diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/exp_joint_flow_ga_frozen_glowtts/training_comparison.ipynb b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/exp_joint_flow_ga_frozen_glowtts/training_comparison.ipynb index 87b422387..d4a6b1d03 100644 --- a/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/exp_joint_flow_ga_frozen_glowtts/training_comparison.ipynb +++ b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/exp_joint_flow_ga_frozen_glowtts/training_comparison.ipynb @@ -29,14 +29,20 @@ { "data": { "text/plain": [ - "{'/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn/100ep/decoder/training': '/ga_glowTTS_ASR_ffn/100ep/decoder/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn/100ep/encoder/training': '/ga_glowTTS_ASR_ffn/100ep/encoder/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn_x_vector/100ep/decoder/training': '/ga_glowTTS_ASR_cnn_x_vector/100ep/decoder/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn_x_vector/100ep/encoder/training': '/ga_glowTTS_ASR_cnn_x_vector/100ep/encoder/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector/100ep/encoder/training': '/ga_glowTTS_ASR_ffn_x_vector/100ep/encoder/',\n", + "{'/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector/100ep/encoder/training': '/ga_glowTTS_ASR_ffn_x_vector/100ep/encoder/',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector/100ep/decoder/training': '/ga_glowTTS_ASR_ffn_x_vector/100ep/decoder/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn_x_vector/100ep/encoder/training': '/ga_glowTTS_ASR_cnn_x_vector/100ep/encoder/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn_x_vector/100ep/decoder/training': '/ga_glowTTS_ASR_cnn_x_vector/100ep/decoder/',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn/100ep/decoder/training': '/ga_glowTTS_ASR_cnn/100ep/decoder/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn/100ep/encoder/training': '/ga_glowTTS_ASR_cnn/100ep/encoder/'}" + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn/100ep/encoder/training': '/ga_glowTTS_ASR_cnn/100ep/encoder/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector_mas/100ep/decoder/training': '/ga_glowTTS_ASR_ffn_x_vector_mas/100ep/decoder/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector_mas/100ep/encoder/training': '/ga_glowTTS_ASR_ffn_x_vector_mas/100ep/encoder/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_mas/100ep/decoder/training': '/ga_glowTTS_ASR_ffn_mas/100ep/decoder/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_mas/100ep/encoder/training': '/ga_glowTTS_ASR_ffn_mas/100ep/encoder/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn/100ep/encoder/training': '/ga_glowTTS_ASR_ffn/100ep/encoder/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn/100ep/decoder/training': '/ga_glowTTS_ASR_ffn/100ep/decoder/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_mas_no_eval/100ep/encoder/training': '/ga_glowTTS_ASR_ffn_mas_no_eval/100ep/encoder/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_mas_no_eval/100ep/decoder/training': '/ga_glowTTS_ASR_ffn_mas_no_eval/100ep/decoder/'}" ] }, "execution_count": 2, @@ -88,8 +94,8 @@ { "data": { "text/plain": [ - "{'/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/no_specaug/ce_ls_0.1/training': 3,\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/no_specaug/ce_ls_1/training': 3,\n", + "{'/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/no_specaug/ce_ls_1/training': 3,\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/no_specaug/ce_ls_0.1/training': 3,\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/specaug/ce_ls_1/training': 3,\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/specaug/ce_ls_0.1/training': 3}" ] @@ -122,14 +128,20 @@ "name": "stdout", "output_type": "stream", "text": [ - "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn/100ep/decoder/training: 1\n", - "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn/100ep/encoder/training: 1\n", - "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn_x_vector/100ep/decoder/training: 1\n", - "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn_x_vector/100ep/encoder/training: 1\n", "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector/100ep/encoder/training: 1\n", "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector/100ep/decoder/training: 1\n", + "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn_x_vector/100ep/encoder/training: 1\n", + "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn_x_vector/100ep/decoder/training: 1\n", "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn/100ep/decoder/training: 1\n", "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn/100ep/encoder/training: 1\n", + "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector_mas/100ep/decoder/training: 1\n", + "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector_mas/100ep/encoder/training: 1\n", + "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_mas/100ep/decoder/training: 1\n", + "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_mas/100ep/encoder/training: 1\n", + "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn/100ep/encoder/training: 1\n", + "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn/100ep/decoder/training: 1\n", + "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_mas_no_eval/100ep/encoder/training: 1\n", + "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_mas_no_eval/100ep/decoder/training: 1\n", "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/tts_architecture/glow_tts/raw_audio/decoder_test/enc768/with_sigma/glowTTS_encoder_sample_test_multi_layer_ffn/training: 1\n", "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/tts_architecture/glow_tts/raw_audio/decoder_test/enc768/with_sigma/glowTTS_decoder_test_multi_layer_ffn/training: 1\n", "Large Font: False\n", @@ -140,18 +152,18 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "6453f1c5e2b6422d80da690ad730b709", + "model_id": "b72cb5e1fa034185b3d62f3b9035307a", "version_major": 2, "version_minor": 0 }, - "image/png": "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", + "image/png": "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", "text/html": [ "\n", "
\n", "
\n", " Figure\n", "
\n", - " \n", + " \n", "
\n", " " ], diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/exp_tts/experiments.py b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/exp_tts/experiments.py index 131f42a28..4e74cd979 100644 --- a/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/exp_tts/experiments.py +++ b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/exp_tts/experiments.py @@ -63,7 +63,9 @@ def run_exp( given_train_job_for_forward=None, nisqa_evaluation=True, swer_evaluation=True, - tts_eval_datasets=None + tts_eval_datasets=None, + eval_invertibility=False, + nisqa_confidence=False, ): exp = {} assert len(args["config"]["learning_rates"]) == num_epochs, "Length of LR schedule and number of epochs differ." @@ -111,7 +113,8 @@ def run_exp( vocoder="gl", nisqa_eval=nisqa_evaluation, swer_eval=swer_evaluation, - swer_eval_corpus_key=ds_k + swer_eval_corpus_key=ds_k, + nisqa_confidence=nisqa_confidence, ) if extract_x_vector: @@ -127,6 +130,21 @@ def run_exp( target="xvector", ) exp["forward_xvector_job"] = forward_xvector_job + + if eval_invertibility: + forward_x_vector_config = get_forward_config( + forward_dataset=dataset, **args, forward_args=forward_args, target="invertibility" + ) + forward_xvector_job = forward( + checkpoint=train_job.out_checkpoints[num_epochs], + config=forward_x_vector_config, + returnn_exe=RETURNN_PYTORCH_EXE, + returnn_root=MINI_RETURNN_ROOT, + prefix=prefix + name, + target="invertibility", + ) + exp["forward_invertibility_job"] = forward_xvector_job + return exp train_settings = TrainingDatasetSettings( @@ -395,6 +413,7 @@ def run_exp( 100, forward_args=forward_args, tts_eval_datasets=tts_forward_datasets_xvectors, + nisqa_confidence=True, ) add_tts_model( net_module, @@ -414,10 +433,16 @@ def run_exp( 200, forward_args=forward_args, tts_eval_datasets=tts_forward_datasets_xvectors, - swer_evaluation=True + swer_evaluation=True, + eval_invertibility=True, + nisqa_confidence=True, ) add_tts_model( - net_module + "/enc768/200ep/dec_drop_0.05", TTSModel(ModelConfigV1.from_dict(train_args_TTS_xvector_200ep["net_args"]["model_config"]), exp_dict["train_job"].out_checkpoints[200]) + net_module + "/enc768/200ep/dec_drop_0.05", + TTSModel( + ModelConfigV1.from_dict(train_args_TTS_xvector_200ep["net_args"]["model_config"]), + exp_dict["train_job"].out_checkpoints[200], + ), ) train_args_TTS_xvector_200ep["net_args"]["model_config"]["text_encoder_config"]["filter_channels"] = 192 @@ -429,7 +454,7 @@ def run_exp( 200, forward_args=forward_args, tts_eval_datasets=tts_forward_datasets_xvectors, - swer_evaluation=True + swer_evaluation=True, ) add_tts_model( @@ -455,7 +480,7 @@ def run_exp( 200, forward_args=forward_args, tts_eval_datasets=tts_forward_datasets_xvectors, - swer_evaluation=True + swer_evaluation=True, ) train_args_TTS_xvector_200ep_no_dec_dropout["net_args"]["model_config"]["text_encoder_config"][ @@ -469,7 +494,7 @@ def run_exp( 200, forward_args=forward_args, tts_eval_datasets=tts_forward_datasets_xvectors, - swer_evaluation=True + swer_evaluation=True, ) train_args_xvector_altLR = copy.deepcopy(train_args_TTS_xvector_200ep) @@ -486,11 +511,13 @@ def run_exp( 200, forward_args=forward_args, tts_eval_datasets=tts_forward_datasets_xvectors, - swer_evaluation=True + swer_evaluation=True, ) train_args_xvector_altLR_no_dec_drop = copy.deepcopy(train_args_xvector_altLR) - train_args_xvector_altLR_no_dec_drop["net_args"]["model_config"]["decoder_config"] = asdict(flow_decoder_config_no_dropout) + train_args_xvector_altLR_no_dec_drop["net_args"]["model_config"]["decoder_config"] = asdict( + flow_decoder_config_no_dropout + ) exp_dict = run_exp( net_module + "/enc768/200ep_long_cooldown/dec_drop_0.0", train_args_xvector_altLR_no_dec_drop, @@ -499,7 +526,7 @@ def run_exp( 200, forward_args=forward_args, tts_eval_datasets=tts_forward_datasets_xvectors, - swer_evaluation=True + swer_evaluation=True, ) net_module = "glowTTS" @@ -518,7 +545,9 @@ def run_exp( ) train_args_TTS_100ep_no_dec_dropout = copy.deepcopy(train_args_TTS) - train_args_TTS_100ep_no_dec_dropout["net_args"]["model_config"]["decoder_config"] = asdict(flow_decoder_config_no_dropout) + train_args_TTS_100ep_no_dec_dropout["net_args"]["model_config"]["decoder_config"] = asdict( + flow_decoder_config_no_dropout + ) train_args_TTS_100ep_no_dec_dropout["config"]["gradient_clip_norm"] = 10.0 exp_dict = run_exp( net_module + "/enc768/100ep/dec_drop_0.00", @@ -529,7 +558,13 @@ def run_exp( forward_args=forward_args, tts_eval_datasets=tts_forward_datasets, ) - add_tts_model(net_module + "/enc768/100ep/dec_drop_0.00", TTSModel(ModelConfigV1.from_dict(train_args_TTS_100ep_no_dec_dropout["net_args"]["model_config"]), exp_dict["train_job"].out_checkpoints[100])) + add_tts_model( + net_module + "/enc768/100ep/dec_drop_0.00", + TTSModel( + ModelConfigV1.from_dict(train_args_TTS_100ep_no_dec_dropout["net_args"]["model_config"]), + exp_dict["train_job"].out_checkpoints[100], + ), + ) train_args_TTS_200ep = copy.deepcopy(train_args_TTS) train_args_TTS_200ep["config"]["learning_rates"] = lr_schedule_200ep @@ -545,8 +580,16 @@ def run_exp( forward_args=forward_args, swer_evaluation=True, tts_eval_datasets=tts_forward_datasets, + eval_invertibility=True, + nisqa_confidence=True, + ) + add_tts_model( + net_module + "/enc768/200ep/dec_drop_0.05", + TTSModel( + ModelConfigV1.from_dict(train_args_TTS_200ep["net_args"]["model_config"]), + exp_dict["train_job"].out_checkpoints[200], + ), ) - add_tts_model(net_module + "/enc768/200ep/dec_drop_0.05", TTSModel(ModelConfigV1.from_dict(train_args_TTS_200ep["net_args"]["model_config"]), exp_dict["train_job"].out_checkpoints[200])) exp_dict = run_exp( net_module + "/enc768/200ep/dec_drop_0.05_epsilon_1e-8", @@ -732,10 +775,12 @@ def run_exp( p_dropout=model_config.decoder_config.p_dropout, n_split=model_config.decoder_config.n_split, n_sqz=model_config.decoder_config.n_sqz, - sigmoid_scale=model_config.decoder_config.sigmoid_scale + sigmoid_scale=model_config.decoder_config.sigmoid_scale, ) - train_args_TTS_xvector_200ep_conformer_coupling["net_args"]["model_config"] = asdict(model_config_conformer_coupling) + train_args_TTS_xvector_200ep_conformer_coupling["net_args"]["model_config"] = asdict( + model_config_conformer_coupling + ) train_args_TTS_xvector_200ep_conformer_coupling["config"]["batch_size"] = 75 * 16000 train_args_TTS_xvector_200ep_conformer_coupling["config"]["accum_grad_multiple_step"] = 4 @@ -747,7 +792,8 @@ def run_exp( 200, forward_args=forward_args, tts_eval_datasets=tts_forward_datasets_xvectors, - swer_evaluation=True + swer_evaluation=True, + nisqa_confidence=True, ) # ===================== Multi-Scale ======================= @@ -778,7 +824,7 @@ def run_exp( 200, forward_args=forward_args, tts_eval_datasets=tts_forward_datasets_xvectors, - swer_evaluation=True + swer_evaluation=True, ) # ============= Encoding Distance Loss ======================== @@ -854,12 +900,12 @@ def run_exp( ffn_channels=None, specauc_start_epoch=None, out_channels=80, - gin_channels=512, + gin_channels=256, n_speakers=speaker_datastream.vocab_size, ) net_module = "glowTTS" train_args_400 = { - "net_args": {"fe_config": asdict(fe_config), "model_config": asdict(model_config_tts_only)}, + "net_args": {"fe_config": asdict(fe_config), "model_config": asdict(model_config_400ep)}, "network_module": net_module, "debug": True, "config": { @@ -871,6 +917,44 @@ def run_exp( }, } + train_args_400_gin512 = copy.deepcopy(train_args_400) + train_args_400_gin512["net_args"]["model_config"] = asdict(model_config_tts_only) + exp_dict = run_exp( + net_module + "/enc768/400ep/gin512/dec_drop_0.05", + train_args_400_gin512, + training_datasets_pe1_tts_segments, + asr_test_datasets, + 400, + forward_args=forward_args, + swer_evaluation=True, + nisqa_evaluation=True, + tts_eval_datasets=tts_forward_datasets, + nisqa_confidence=True, + ) + + train_args_400_gin512_grad_norm = copy.deepcopy(train_args_400_gin512) + train_args_400_gin512_grad_norm["config"]["gradient_clip_norm"] = 10 + exp_dict = run_exp( + net_module + "/enc768/400ep/gin512/grad_clip_10/dec_drop_0.05", + train_args_400_gin512_grad_norm, + training_datasets_pe1_tts_segments, + asr_test_datasets, + 400, + forward_args=forward_args, + swer_evaluation=True, + nisqa_evaluation=True, + tts_eval_datasets=tts_forward_datasets, + nisqa_confidence=True, + ) + + add_tts_model( + net_module + "/enc768/400ep/gin512/grad_clip_10/dec_drop_0.05", + TTSModel( + ModelConfigV1.from_dict(train_args_400_gin512_grad_norm["net_args"]["model_config"]), + exp_dict["train_job"].out_checkpoints[400], + ), + ) + exp_dict = run_exp( net_module + "/enc768/400ep/dec_drop_0.05", train_args_400, @@ -881,6 +965,7 @@ def run_exp( swer_evaluation=True, nisqa_evaluation=True, tts_eval_datasets=tts_forward_datasets, + nisqa_confidence=True, ) train_args_400_grad_norm = copy.deepcopy(train_args_400) @@ -895,6 +980,28 @@ def run_exp( swer_evaluation=True, nisqa_evaluation=True, tts_eval_datasets=tts_forward_datasets, + nisqa_confidence=True, + ) + + add_tts_model( + net_module + "/enc768/400ep/grad_clip_10/dec_drop_0.05", + TTSModel( + ModelConfigV1.from_dict(train_args_400_grad_norm["net_args"]["model_config"]), + exp_dict["train_job"].out_checkpoints[400], + ), + ) + + train_args_400_grad_norm["net_args"]["model_config"]["text_encoder_config"]["filter_channels"] = 192 + exp_dict = run_exp( + net_module + "/enc192/400ep/grad_clip_10/dec_drop_0.05", + train_args_400_grad_norm, + training_datasets_pe1_tts_segments, + asr_test_datasets, + 400, + forward_args=forward_args, + swer_evaluation=True, + nisqa_evaluation=True, + tts_eval_datasets=tts_forward_datasets, ) net_module = "glowTTS_x_vector_v2" @@ -909,6 +1016,30 @@ def run_exp( } } + train_args_400_xvector_gin512 = copy.deepcopy(train_args_400_xvector) + train_args_400_xvector_gin512["net_args"]["model_config"] = asdict(model_config_tts_only) + + exp_dict = run_exp( + net_module + "/enc768/400ep/gin512/dec_drop_0.05", + train_args_400_xvector_gin512, + training_datasets_pe1_tts_segments, + asr_test_datasets, + 400, + forward_args=forward_args, + swer_evaluation=True, + nisqa_evaluation=True, + tts_eval_datasets=tts_forward_datasets_xvectors, + nisqa_confidence=True, + ) + + add_tts_model( + net_module + "/enc768/400ep/gin512/dec_drop_0.05", + TTSModel( + ModelConfigV1.from_dict(train_args_400_xvector_gin512["net_args"]["model_config"]), + exp_dict["train_job"].out_checkpoints[400], + ), + ) + exp_dict = run_exp( net_module + "/enc768/400ep/dec_drop_0.05", train_args_400_xvector, @@ -919,4 +1050,27 @@ def run_exp( swer_evaluation=True, nisqa_evaluation=True, tts_eval_datasets=tts_forward_datasets_xvectors, + nisqa_confidence=True, + ) + + add_tts_model( + net_module + "/enc768/400ep/dec_drop_0.05", + TTSModel( + ModelConfigV1.from_dict(train_args_400_xvector["net_args"]["model_config"]), + exp_dict["train_job"].out_checkpoints[400], + ), + ) + + train_args_400_xvector["net_args"]["model_config"]["text_encoder_config"]["filter_channels"] = 192 + + exp_dict = run_exp( + net_module + "/enc192/400ep/dec_drop_0.05", + train_args_400_xvector, + training_datasets_pe1_tts_segments, + asr_test_datasets, + 400, + forward_args=forward_args, + swer_evaluation=True, + nisqa_evaluation=True, + tts_eval_datasets=tts_forward_datasets_xvectors, ) diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/exp_tts/training_comparison.ipynb b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/exp_tts/training_comparison.ipynb index 7c75f0100..72d769622 100644 --- a/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/exp_tts/training_comparison.ipynb +++ b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/exp_tts/training_comparison.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 3, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -23,21 +23,21 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{'/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc192/200ep/dec_drop_0.0_epsilon_1e-8/training': '/enc192/200ep/dec_drop_0.0_epsilon_1e-8/',\n", + "{'/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc192/200ep/dec_drop_0.0/grad_clip_10/training': '/enc192/200ep/dec_drop_0.0/grad_clip_10/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/200ep/dec_drop_0.0/grad_clip_10/training': '/enc768/200ep/dec_drop_0.0/grad_clip_10/',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc192/200ep/dec_drop_0.05_epsilon_1e-8/training': '/enc192/200ep/dec_drop_0.05_epsilon_1e-8/',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc192/200ep/dec_drop_0.05/training': '/enc192/200ep/dec_drop_0.05/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/200ep/dec_drop_0.0_epsilon_1e-8/training': '/enc768/200ep/dec_drop_0.0_epsilon_1e-8/',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/200ep/dec_drop_0.05_epsilon_1e-8/training': '/enc768/200ep/dec_drop_0.05_epsilon_1e-8/',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/200ep/dec_drop_0.05/training': '/enc768/200ep/dec_drop_0.05/'}" ] }, - "execution_count": 5, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } @@ -46,7 +46,9 @@ "globs = [\n", " # \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS*/enc768/400ep/dec_drop_0.05/training\",\n", " # \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/400ep/grad_clip_10/dec_drop_0.05/training\",\n", - " \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc*/200ep/dec_drop_0.0*/training\"\n", + " # \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc192/200ep/dec_drop_0.0*/training\",\n", + " \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc*/200ep/dec_drop_0.0*/grad_clip_10/training\",\n", + " \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc*/200ep/dec_drop_0.0*/training\",\n", "]\n", "breakpoint()\n", "lr_files = []\n", @@ -66,7 +68,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -78,17 +80,17 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc192/200ep/dec_drop_0.0_epsilon_1e-8/training: 1\n", + "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc192/200ep/dec_drop_0.0/grad_clip_10/training: 1\n", + "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/200ep/dec_drop_0.0/grad_clip_10/training: 1\n", "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc192/200ep/dec_drop_0.05_epsilon_1e-8/training: 1\n", "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc192/200ep/dec_drop_0.05/training: 1\n", - "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/200ep/dec_drop_0.0_epsilon_1e-8/training: 1\n", "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/200ep/dec_drop_0.05_epsilon_1e-8/training: 1\n", "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/200ep/dec_drop_0.05/training: 1\n", "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/200ep/dec_drop_0.05/training/: 1\n", @@ -100,18 +102,18 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "08febe3432d0417d8d3a1c7840fe31d0", + "model_id": "2084e635587446d2aab96b81f3fa6006", "version_major": 2, "version_minor": 0 }, - "image/png": "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", + "image/png": "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", "text/html": [ "\n", "
\n", "
\n", " Figure\n", "
\n", - " \n", + " \n", "
\n", " " ], @@ -158,7 +160,564 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "df2 = df.reset_index()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
dev_loss_dpdev_loss_mle...dpmle
level_0/enc192/200ep/dec_drop_0.0/grad_clip_10//enc192/200ep/dec_drop_0.05//enc192/200ep/dec_drop_0.05_epsilon_1e-8//enc768/200ep/dec_drop_0.0/grad_clip_10//enc768/200ep/dec_drop_0.05//enc768/200ep/dec_drop_0.05_epsilon_1e-8/Baseline Glow-TTS 768/enc192/200ep/dec_drop_0.0/grad_clip_10//enc192/200ep/dec_drop_0.05//enc192/200ep/dec_drop_0.05_epsilon_1e-8/.../enc768/200ep/dec_drop_0.05//enc768/200ep/dec_drop_0.05_epsilon_1e-8/Baseline Glow-TTS 768/enc192/200ep/dec_drop_0.0/grad_clip_10//enc192/200ep/dec_drop_0.05//enc192/200ep/dec_drop_0.05_epsilon_1e-8//enc768/200ep/dec_drop_0.0/grad_clip_10//enc768/200ep/dec_drop_0.05//enc768/200ep/dec_drop_0.05_epsilon_1e-8/Baseline Glow-TTS 768
level_1
11.2388031.2300681.2299081.0768351.2381041.2352751.2381040.0464500.0733960.073425...1.1451111.1450461.1451110.5372520.5681190.5695990.5026200.5308900.5325450.530890
21.2048271.2410251.2441681.1124671.3533281.3581041.353328-0.219648-0.152898-0.153953...1.1662361.1662611.166236-0.101299-0.082530-0.082966-0.083080-0.066146-0.066379-0.066146
31.1806951.2466911.2458881.0896631.7226231.7481281.722623-0.341818-0.295465-0.295729...1.1489091.1495771.148909-0.294475-0.281159-0.281597-0.293310-0.281814-0.282104-0.281814
41.1653151.2490061.2577491.0540371.5680671.5431481.568067-0.392180-0.361857-0.362248...1.1260331.1261831.126033-0.371938-0.375815-0.375824-0.381286-0.383792-0.383782-0.383792
51.1595921.2477901.2482641.0558131.4635251.4849411.463525-0.419574-0.413436-0.414346...1.1043971.1045111.104397-0.410438-0.422834-0.422658-0.422354-0.433206-0.433054-0.433206
..................................................................
1960.4307960.6787800.8247170.4451260.4423680.4382850.442368-0.837367-0.813777-0.816068...0.3888700.3870810.388870-0.850404-0.808053-0.806879-0.848083-0.811209-0.810240-0.811209
1970.4298700.7454000.8247250.4442180.4407210.4373380.440721-0.837755-0.810379-0.815329...0.3882160.3865260.388216-0.850987-0.808369-0.807225-0.848792-0.811539-0.810735-0.811539
1980.4320650.6821560.8126070.4450280.4417050.4371700.441705-0.830906-0.814995-0.817098...0.3882450.3865450.388245-0.851446-0.808689-0.807542-0.849257-0.810812-0.811058-0.810812
1990.4303980.6005700.8086160.4462320.4422300.4377040.442230-0.835626-0.814634-0.816613...0.3879940.3862900.387994-0.852212-0.809059-0.807872-0.849940-0.811891-0.811443-0.811891
2000.4319750.6150260.8141730.4458010.4412180.4382480.441218-0.773976-0.815064-0.817505...0.3873770.3860670.387377-0.852834-0.809477-0.808277-0.850649-0.812429-0.811807-0.812429
\n", + "

200 rows × 28 columns

\n", + "
" + ], + "text/plain": [ + " dev_loss_dp \\\n", + "level_0 /enc192/200ep/dec_drop_0.0/grad_clip_10/ /enc192/200ep/dec_drop_0.05/ \n", + "level_1 \n", + "1 1.238803 1.230068 \n", + "2 1.204827 1.241025 \n", + "3 1.180695 1.246691 \n", + "4 1.165315 1.249006 \n", + "5 1.159592 1.247790 \n", + "... ... ... \n", + "196 0.430796 0.678780 \n", + "197 0.429870 0.745400 \n", + "198 0.432065 0.682156 \n", + "199 0.430398 0.600570 \n", + "200 0.431975 0.615026 \n", + "\n", + " \\\n", + "level_0 /enc192/200ep/dec_drop_0.05_epsilon_1e-8/ \n", + "level_1 \n", + "1 1.229908 \n", + "2 1.244168 \n", + "3 1.245888 \n", + "4 1.257749 \n", + "5 1.248264 \n", + "... ... \n", + "196 0.824717 \n", + "197 0.824725 \n", + "198 0.812607 \n", + "199 0.808616 \n", + "200 0.814173 \n", + "\n", + " \\\n", + "level_0 /enc768/200ep/dec_drop_0.0/grad_clip_10/ /enc768/200ep/dec_drop_0.05/ \n", + "level_1 \n", + "1 1.076835 1.238104 \n", + "2 1.112467 1.353328 \n", + "3 1.089663 1.722623 \n", + "4 1.054037 1.568067 \n", + "5 1.055813 1.463525 \n", + "... ... ... \n", + "196 0.445126 0.442368 \n", + "197 0.444218 0.440721 \n", + "198 0.445028 0.441705 \n", + "199 0.446232 0.442230 \n", + "200 0.445801 0.441218 \n", + "\n", + " \\\n", + "level_0 /enc768/200ep/dec_drop_0.05_epsilon_1e-8/ Baseline Glow-TTS 768 \n", + "level_1 \n", + "1 1.235275 1.238104 \n", + "2 1.358104 1.353328 \n", + "3 1.748128 1.722623 \n", + "4 1.543148 1.568067 \n", + "5 1.484941 1.463525 \n", + "... ... ... \n", + "196 0.438285 0.442368 \n", + "197 0.437338 0.440721 \n", + "198 0.437170 0.441705 \n", + "199 0.437704 0.442230 \n", + "200 0.438248 0.441218 \n", + "\n", + " dev_loss_mle \\\n", + "level_0 /enc192/200ep/dec_drop_0.0/grad_clip_10/ /enc192/200ep/dec_drop_0.05/ \n", + "level_1 \n", + "1 0.046450 0.073396 \n", + "2 -0.219648 -0.152898 \n", + "3 -0.341818 -0.295465 \n", + "4 -0.392180 -0.361857 \n", + "5 -0.419574 -0.413436 \n", + "... ... ... \n", + "196 -0.837367 -0.813777 \n", + "197 -0.837755 -0.810379 \n", + "198 -0.830906 -0.814995 \n", + "199 -0.835626 -0.814634 \n", + "200 -0.773976 -0.815064 \n", + "\n", + " ... \\\n", + "level_0 /enc192/200ep/dec_drop_0.05_epsilon_1e-8/ ... \n", + "level_1 ... \n", + "1 0.073425 ... \n", + "2 -0.153953 ... \n", + "3 -0.295729 ... \n", + "4 -0.362248 ... \n", + "5 -0.414346 ... \n", + "... ... ... \n", + "196 -0.816068 ... \n", + "197 -0.815329 ... \n", + "198 -0.817098 ... \n", + "199 -0.816613 ... \n", + "200 -0.817505 ... \n", + "\n", + " dp \\\n", + "level_0 /enc768/200ep/dec_drop_0.05/ \n", + "level_1 \n", + "1 1.145111 \n", + "2 1.166236 \n", + "3 1.148909 \n", + "4 1.126033 \n", + "5 1.104397 \n", + "... ... \n", + "196 0.388870 \n", + "197 0.388216 \n", + "198 0.388245 \n", + "199 0.387994 \n", + "200 0.387377 \n", + "\n", + " \\\n", + "level_0 /enc768/200ep/dec_drop_0.05_epsilon_1e-8/ Baseline Glow-TTS 768 \n", + "level_1 \n", + "1 1.145046 1.145111 \n", + "2 1.166261 1.166236 \n", + "3 1.149577 1.148909 \n", + "4 1.126183 1.126033 \n", + "5 1.104511 1.104397 \n", + "... ... ... \n", + "196 0.387081 0.388870 \n", + "197 0.386526 0.388216 \n", + "198 0.386545 0.388245 \n", + "199 0.386290 0.387994 \n", + "200 0.386067 0.387377 \n", + "\n", + " mle \\\n", + "level_0 /enc192/200ep/dec_drop_0.0/grad_clip_10/ /enc192/200ep/dec_drop_0.05/ \n", + "level_1 \n", + "1 0.537252 0.568119 \n", + "2 -0.101299 -0.082530 \n", + "3 -0.294475 -0.281159 \n", + "4 -0.371938 -0.375815 \n", + "5 -0.410438 -0.422834 \n", + "... ... ... \n", + "196 -0.850404 -0.808053 \n", + "197 -0.850987 -0.808369 \n", + "198 -0.851446 -0.808689 \n", + "199 -0.852212 -0.809059 \n", + "200 -0.852834 -0.809477 \n", + "\n", + " \\\n", + "level_0 /enc192/200ep/dec_drop_0.05_epsilon_1e-8/ \n", + "level_1 \n", + "1 0.569599 \n", + "2 -0.082966 \n", + "3 -0.281597 \n", + "4 -0.375824 \n", + "5 -0.422658 \n", + "... ... \n", + "196 -0.806879 \n", + "197 -0.807225 \n", + "198 -0.807542 \n", + "199 -0.807872 \n", + "200 -0.808277 \n", + "\n", + " \\\n", + "level_0 /enc768/200ep/dec_drop_0.0/grad_clip_10/ /enc768/200ep/dec_drop_0.05/ \n", + "level_1 \n", + "1 0.502620 0.530890 \n", + "2 -0.083080 -0.066146 \n", + "3 -0.293310 -0.281814 \n", + "4 -0.381286 -0.383792 \n", + "5 -0.422354 -0.433206 \n", + "... ... ... \n", + "196 -0.848083 -0.811209 \n", + "197 -0.848792 -0.811539 \n", + "198 -0.849257 -0.810812 \n", + "199 -0.849940 -0.811891 \n", + "200 -0.850649 -0.812429 \n", + "\n", + " \n", + "level_0 /enc768/200ep/dec_drop_0.05_epsilon_1e-8/ Baseline Glow-TTS 768 \n", + "level_1 \n", + "1 0.532545 0.530890 \n", + "2 -0.066379 -0.066146 \n", + "3 -0.282104 -0.281814 \n", + "4 -0.383782 -0.383792 \n", + "5 -0.433054 -0.433206 \n", + "... ... ... \n", + "196 -0.810240 -0.811209 \n", + "197 -0.810735 -0.811539 \n", + "198 -0.811058 -0.810812 \n", + "199 -0.811443 -0.811891 \n", + "200 -0.811807 -0.812429 \n", + "\n", + "[200 rows x 28 columns]" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df2.pivot_table(index=\"level_1\", columns=\"level_0\", values=list(df.columns))" + ] + }, + { + "cell_type": "code", + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -196,7 +755,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/pipeline.py b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/pipeline.py index 75e982e3f..ed5402169 100644 --- a/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/pipeline.py +++ b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/pipeline.py @@ -58,6 +58,7 @@ def forward( returnn_python_exe=returnn_exe, returnn_root=returnn_root, mem_rqmt=20, + device="cpu" ) # last_forward_job.rqmt["gpu_mem"] = 24 diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/pytorch_networks/frozen_glowtts/ga_glowTTS_ASR_ffn.py b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/pytorch_networks/frozen_glowtts/ga_glowTTS_ASR_ffn.py index df8895e3c..bd712e14b 100644 --- a/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/pytorch_networks/frozen_glowtts/ga_glowTTS_ASR_ffn.py +++ b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/pytorch_networks/frozen_glowtts/ga_glowTTS_ASR_ffn.py @@ -508,6 +508,7 @@ def phoneme_prediction_step(*, model: Model, data, run_ctx, **kwargs): given_attn=given_attn, recognition_input=run_ctx.recognition_input, ) + breakpoint() x_mask = torch.unsqueeze(commons.sequence_mask(phonemes_len, phonemes.size(1)), 1).to(phonemes.dtype) attn_mask = torch.unsqueeze(x_mask, -1) * torch.unsqueeze(z_mask, 2) diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/pytorch_networks/frozen_glowtts/ga_glowTTS_ASR_ffn_mas.py b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/pytorch_networks/frozen_glowtts/ga_glowTTS_ASR_ffn_mas.py new file mode 100644 index 000000000..a0cd90ee6 --- /dev/null +++ b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/pytorch_networks/frozen_glowtts/ga_glowTTS_ASR_ffn_mas.py @@ -0,0 +1,658 @@ +""" +Trying to make the aligner more AppTek-Like + +Extended weight init code +""" + +from dataclasses import dataclass +import torch +import numpy as np +from torch import nn +import multiprocessing +from librosa import filters +import sys +import time +from typing import Any, Dict, Optional, Tuple, Union +import math +import os +import soundfile + +from ..shared.configs import ( + SpecaugConfig, + VGG4LayerActFrontendV1Config_mod, + FlowDecoderConfig, + TextEncoderConfig, + DbMelFeatureExtractionConfig, + ModelConfigV2 +) + +from returnn.datasets.hdf import SimpleHDFWriter + +from ..shared.feature_extraction import DbMelFeatureExtraction +from ..shared.spec_augment import apply_spec_aug +from ..shared.mask import mask_tensor + +from ..shared import modules +from ..shared import commons +from ..shared import attentions +from ..monotonic_align import maximum_path + +from ..shared.forward import search_init_hook, search_finish_hook +from ..shared.eval_forward import * + +from IPython import embed + +class XVector(nn.Module): + def __init__(self, input_dim=40, num_classes=8, **kwargs): + super(XVector, self).__init__() + self.tdnn1 = modules.TDNN( + input_dim=input_dim, output_dim=512, context_size=5, dilation=1, dropout_p=0.5, batch_norm=True + ) + self.tdnn2 = modules.TDNN( + input_dim=512, output_dim=512, context_size=3, dilation=2, dropout_p=0.5, batch_norm=True + ) + self.tdnn3 = modules.TDNN( + input_dim=512, output_dim=512, context_size=2, dilation=3, dropout_p=0.5, batch_norm=True + ) + self.tdnn4 = modules.TDNN( + input_dim=512, output_dim=512, context_size=1, dilation=1, dropout_p=0.5, batch_norm=True + ) + self.tdnn5 = modules.TDNN( + input_dim=512, output_dim=512, context_size=1, dilation=1, dropout_p=0.5, batch_norm=True + ) + #### Frame levelPooling + self.segment6 = nn.Linear(1024, 512) + self.segment7 = nn.Linear(512, 512) + self.output = nn.Linear(512, num_classes) + self.softmax = nn.Softmax(dim=1) + + # fe_config = DbMelFeatureExtractionConfig.from_dict(kwargs["fe_config"]) + # self.feature_extraction = DbMelFeatureExtraction(config=fe_config) + + def forward(self, x, x_lengths): + # with torch.no_grad(): + # squeezed_audio = torch.squeeze(raw_audio) + # x, x_lengths = self.feature_extraction(squeezed_audio, raw_audio_lengths) # [B, T, F] + + # x = x.transpose(1, 2) + tdnn1_out = self.tdnn1(x) + # return tdnn1_out + tdnn2_out = self.tdnn2(tdnn1_out) + tdnn3_out = self.tdnn3(tdnn2_out) + tdnn4_out = self.tdnn4(tdnn3_out) + tdnn5_out = self.tdnn5(tdnn4_out) + ### Stat Pool + mean = torch.mean(tdnn5_out, 2) + std = torch.std(tdnn5_out, 2) + stat_pooling = torch.cat((mean, std), 1) + segment6_out = self.segment6(stat_pooling) + x_vec = self.segment7(segment6_out) + output = self.output(x_vec) + predictions = self.softmax(output) + return output, predictions, x_vec + + +class DurationPredictor(nn.Module): + """ + Duration Predictor module, trained using calculated durations coming from monotonic alignment search + """ + + def __init__(self, in_channels, filter_channels, filter_size, p_dropout): + super().__init__() + + self.in_channels = in_channels + self.filter_channels = filter_channels + self.filter_size = filter_size + self.p_dropout = p_dropout + + self.convs = nn.Sequential( + modules.Conv1DBlock( + in_size=self.in_channels, + out_size=self.filter_channels, + filter_size=self.filter_size, + p_dropout=p_dropout, + ), + modules.Conv1DBlock( + in_size=self.filter_channels, + out_size=self.filter_channels, + filter_size=self.filter_size, + p_dropout=p_dropout, + ), + ) + self.proj = nn.Conv1d(in_channels=self.filter_channels, out_channels=1, kernel_size=1) + + def forward(self, x, x_mask): + x_with_mask = (x, x_mask) + (x, x_mask) = self.convs(x_with_mask) + x = self.proj(x * x_mask) + return x + + +class FlowDecoder(nn.Module): + def __init__(self, cfg: FlowDecoderConfig, in_channels, gin_channels): + """Flow-based decoder model + + Args: + in_channels (int): Number of incoming channels + hidden_channels (int): Number of hidden channels + kernel_size (int): Kernel Size for convolutions in coupling blocks + dilation_rate (float): Dilation Rate to define dilation in convolutions of coupling block + n_blocks (int): Number of coupling blocks + n_layers (int): Number of layers in CNN of the coupling blocks + p_dropout (float, optional): Dropout probability for CNN in coupling blocks. Defaults to 0.. + n_split (int, optional): Number of splits for the 1x1 convolution for flows in the decoder. Defaults to 4. + n_sqz (int, optional): Squeeze. Defaults to 1. + sigmoid_scale (bool, optional): Boolean to define if log probs in coupling layers should be rescaled using sigmoid. Defaults to False. + gin_channels (int, optional): Number of speaker embedding channels. Defaults to 0. + """ + super().__init__() + self.cfg = cfg + + self.flows = nn.ModuleList() + + for _ in range(self.cfg.n_blocks): + self.flows.append(modules.ActNorm(channels=in_channels * self.cfg.n_sqz)) + self.flows.append(modules.InvConvNear(channels=in_channels * self.cfg.n_sqz, n_split=self.cfg.n_split)) + self.flows.append( + attentions.CouplingBlock( + in_channels * self.cfg.n_sqz, + self.cfg.hidden_channels, + kernel_size=self.cfg.kernel_size, + dilation_rate=self.cfg.dilation_rate, + n_layers=self.cfg.n_layers, + gin_channels=gin_channels, + p_dropout=self.cfg.p_dropout, + sigmoid_scale=self.cfg.sigmoid_scale, + ) + ) + + def forward(self, x, x_mask, g=None, reverse=False): + if not reverse: + flows = self.flows + logdet_tot = 0 + else: + flows = reversed(self.flows) + logdet_tot = None + + if self.cfg.n_sqz > 1: + x, x_mask = commons.channel_squeeze(x, x_mask, self.cfg.n_sqz) + for f in flows: + if not reverse: + x, logdet = f(x, x_mask, g=g, reverse=reverse) + logdet_tot += logdet + else: + x, logdet = f(x, x_mask, g=g, reverse=reverse) + if self.cfg.n_sqz > 1: + x, x_mask = commons.channel_unsqueeze(x, x_mask, self.cfg.n_sqz) + return x, logdet_tot + + def store_inverse(self): + for f in self.flows: + f.store_inverse() + +class TextEncoder(nn.Module): + """ + Text Encoder model + """ + + def __init__(self, cfg: TextEncoderConfig, out_channels, gin_channels): + """Text Encoder Model based on Multi-Head Self-Attention combined with FF-CCNs + + Args: + n_vocab (int): Size of vocabulary for embeddings + out_channels (int): Number of output channels + hidden_channels (int): Number of hidden channels + filter_channels (int): Number of filter channels + filter_channels_dp (int): Number of filter channels for duration predictor + n_heads (int): Number of heads in encoder's Multi-Head Attention + n_layers (int): Number of layers consisting of Multi-Head Attention and CNNs in encoder + kernel_size (int): Kernel Size for CNNs in encoder layers + p_dropout (float): Dropout probability for both encoder and duration predictor + window_size (int, optional): Window size in Multi-Head Self-Attention for encoder. Defaults to None. + block_length (_type_, optional): Block length for optional block masking in Multi-Head Attention for encoder. Defaults to None. + mean_only (bool, optional): Boolean to only project text encodings to mean values instead of mean and std. Defaults to False. + prenet (bool, optional): Boolean to add ConvReluNorm prenet before encoder . Defaults to False. + gin_channels (int, optional): Number of channels for speaker condition. Defaults to 0. + """ + super().__init__() + self.cfg = cfg + + self.emb = nn.Embedding(self.cfg.n_vocab, self.cfg.hidden_channels) + nn.init.normal_(self.emb.weight, 0.0, self.cfg.hidden_channels**-0.5) + + if self.cfg.prenet: + self.pre = modules.ConvReluNorm( + self.cfg.hidden_channels, + self.cfg.hidden_channels, + self.cfg.hidden_channels, + kernel_size=5, + n_layers=3, + p_dropout=0.5, + ) + self.encoder = attentions.Encoder( + self.cfg.hidden_channels, + self.cfg.filter_channels, + self.cfg.n_heads, + self.cfg.n_layers, + self.cfg.kernel_size, + self.cfg.p_dropout, + window_size=self.cfg.window_size, + block_length=self.cfg.block_length, + ) + + self.proj_m = nn.Conv1d(self.cfg.hidden_channels, out_channels, 1) + if not self.cfg.mean_only: + self.proj_s = nn.Conv1d(self.cfg.hidden_channels, out_channels, 1) + self.proj_w = DurationPredictor( + self.cfg.hidden_channels + gin_channels, + self.cfg.filter_channels_dp, + self.cfg.kernel_size, + self.cfg.p_dropout, + ) + + def forward(self, x, x_lengths, g=None): + x = self.emb(x) * math.sqrt(self.cfg.hidden_channels) # [b, t, h] + x = torch.transpose(x, 1, -1) # [b, h, t] + x_mask = torch.unsqueeze(commons.sequence_mask(x_lengths, x.size(2)), 1).to(x.dtype) + + if self.cfg.prenet: + x = self.pre(x, x_mask) + x = self.encoder(x, x_mask) + + if g is not None: + g_exp = g.expand(-1, -1, x.size(-1)) + # print(f"Dimension of input in Text Encoder: x.shape: {x.shape}; g: {g.shape}, g_exp: {g_exp.shape}") + x_dp = torch.cat([torch.detach(x), g_exp], 1) + else: + x_dp = torch.detach(x) + + x_m = self.proj_m(x) * x_mask + if not self.cfg.mean_only: + x_logs = self.proj_s(x) * x_mask + else: + x_logs = torch.zeros_like(x_m) + + # print(f"Dimension of input in Text Encoder before DP: {x_dp.shape}") + + logw = self.proj_w(x_dp, x_mask) + return x_m, x_logs, logw, x_mask + +class Model(nn.Module): + """ + Flow-based ASR model based on GlowTTS Structure using a pre-trained flow-based decoder + trained to generate spectrograms from given statistics coming from an encoder + + Model was pretrained using the architecture in + users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS.py + """ + + def __init__( + self, + model_config: dict, + **kwargs, + ): + """_summary_ + + Args: + n_vocab (int): vocabulary size + hidden_channels (int): Number of hidden channels in encoder + out_channels (int): Number of channels in the output + n_blocks_dec (int, optional): Number of coupling blocks in the decoder. Defaults to 12. + kernel_size_dec (int, optional): Kernel size in the decoder. Defaults to 5. + dilation_rate (int, optional): Dilation rate for CNNs of coupling blocks in decoder. Defaults to 5. + n_block_layers (int, optional): Number of layers in the CNN of the coupling blocks in decoder. Defaults to 4. + p_dropout_dec (_type_, optional): Dropout probability in the decoder. Defaults to 0.. + n_speakers (int, optional): Number of speakers. Defaults to 0. + gin_channels (int, optional): Number of speaker embedding channels. Defaults to 0. + n_split (int, optional): Number of splits for the 1x1 convolution for flows in the decoder. Defaults to 4. + n_sqz (int, optional): Squeeze. Defaults to 1. + sigmoid_scale (bool, optional): Boolean to define if log probs in coupling layers should be rescaled using sigmoid. Defaults to False. + window_size (int, optional): Window size in Multi-Head Self-Attention for encoder. Defaults to None. + block_length (_type_, optional): Block length for optional block masking in Multi-Head Attention for encoder. Defaults to None. + hidden_channels_dec (_type_, optional): Number of hidden channels in decodder. Defaults to hidden_channels. + final_hidden_channels: Number of hidden channels in the final network + final_n_layers: Number of layers in the final network + label_target_size: Target size of target vocabulary, target size for final network + """ + super().__init__() + + self.net_kwargs = { + "repeat_per_num_frames": 100, + "max_dim_feat": 8, + "num_repeat_feat": 5, + "max_dim_time": 20, + } + + fe_config = DbMelFeatureExtractionConfig.from_dict(kwargs["fe_config"]) + self.feature_extraction = DbMelFeatureExtraction(config=fe_config) + + # if label_target_size is None: + # if n_vocab is None: + # run_ctx = get_run_ctx() + # dataset = run_ctx.engine.train_dataset or run_ctx.engine.forward_dataset + # self.label_target_size = len(dataset.datasets["zip_dataset"].targets.labels) + # else: + # self.label_target_size = n_vocab + # else: + # self.label_target_size = label_target_size + + self.cfg = ModelConfigV2.from_dict(model_config) + text_encoder_config = self.cfg.text_encoder_config + decoder_config = self.cfg.decoder_config + + if self.cfg.n_speakers > 1: + self.emb_g = nn.Embedding(self.cfg.n_speakers, self.cfg.gin_channels) + nn.init.uniform_(self.emb_g.weight, -0.1, 0.1) + + self.encoder = TextEncoder( + text_encoder_config, out_channels=self.cfg.out_channels, gin_channels=self.cfg.gin_channels + ) + + self.decoder = FlowDecoder( + decoder_config, in_channels=self.cfg.out_channels, gin_channels=self.cfg.gin_channels + ) + + self.asr_output = nn.Sequential() + + for i in range(self.cfg.phoneme_prediction_config.n_layers): + if i == 0: + in_channels = self.cfg.out_channels + else: + in_channels = self.cfg.phoneme_prediction_config.n_channels + if i < self.cfg.phoneme_prediction_config.n_layers - 1: + out_channels = self.cfg.phoneme_prediction_config.n_channels + else: + out_channels = self.cfg.label_target_size + 1 + + self.asr_output.append(nn.Linear(in_channels, out_channels)) + if i < self.cfg.phoneme_prediction_config.n_layers - 1: + self.asr_output.append(nn.ReLU()) + self.asr_output.append(nn.Dropout(self.cfg.phoneme_prediction_config.p_dropout)) + + self.specaug_start_epoch = self.cfg.specauc_start_epoch + + def forward( + self, x=None, x_lengths=None, raw_audio=None, raw_audio_lengths=None, g=None, recognition_input=None, noise_scale=1.0, length_scale=1.0 + ): + assert recognition_input in ["encoder", "decoder"] + with torch.no_grad(): + squeezed_audio = torch.squeeze(raw_audio) + y, y_lengths = self.feature_extraction(squeezed_audio, raw_audio_lengths) # [B, T, F] + y = y.transpose(1, 2) # [B, F, T] + self.encoder.eval() + self.decoder.eval() + assert g is not None, "Missing speaker embeddings!" + g = nn.functional.normalize(self.emb_g(g.squeeze(-1))).unsqueeze(-1) + + y_max_length = y.size(2) + + y, y_lengths, y_max_length = self.preprocess(y, y_lengths, y_max_length) + z_mask = torch.unsqueeze(commons.sequence_mask(y_lengths, y_max_length), 1).to(torch.int32) + + x_m, x_logs, logw, x_mask = self.encoder(x, x_lengths, g=g) # mean, std logs, duration logs, mask + attn_mask = torch.unsqueeze(x_mask, -1) * torch.unsqueeze(z_mask, 2) + z, logdet = self.decoder(y, z_mask, g=g, reverse=False) + + x_s_sq_r = torch.exp(-2 * x_logs) + logp1 = torch.sum(-0.5 * math.log(2 * math.pi) - x_logs, [1]).unsqueeze(-1) # [b, t, 1] + logp2 = torch.matmul(x_s_sq_r.transpose(1, 2), -0.5 * (z**2)) # [b, t, d] x [b, d, t'] = [b, t, t'] + logp3 = torch.matmul((x_m * x_s_sq_r).transpose(1, 2), z) # [b, t, d] x [b, d, t'] = [b, t, t'] + logp4 = torch.sum(-0.5 * (x_m**2) * x_s_sq_r, [1]).unsqueeze(-1) # [b, t, 1] + logp = logp1 + logp2 + logp3 + logp4 # [b, t, t'] + + attn = maximum_path(logp, attn_mask.squeeze(1)).unsqueeze(1).detach() + # embed() + + z_m = torch.matmul(attn.squeeze(1).transpose(1, 2), x_m.transpose(1, 2)).transpose( + 1, 2 + ) # [b, t', t], [b, t, d] -> [b, d, t'] + z_logs = torch.matmul(attn.squeeze(1).transpose(1, 2), x_logs.transpose(1, 2)).transpose( + 1, 2 + ) # [b, t', t], [b, t, d] -> [b, d, t'] + + if recognition_input == "encoder": # TODO: This is wrong! + asr_in = z.transpose(1, 2) + else: + asr_in = ((z_m + torch.exp(z_logs) * torch.randn_like(z_m) * noise_scale) * z_mask).transpose(1,2) + + logits = self.asr_output(asr_in) + + return logits, y_lengths, z_mask, attn + + def preprocess(self, y, y_lengths, y_max_length): + if y_max_length is not None: + y_max_length = (y_max_length // self.cfg.decoder_config.n_sqz) * self.cfg.decoder_config.n_sqz + y = y[:, :, :y_max_length] + y_lengths = (y_lengths // self.cfg.decoder_config.n_sqz) * self.cfg.decoder_config.n_sqz + return y, y_lengths, y_max_length + + def store_inverse(self): + self.decoder.store_inverse() + + +def train_step(*, model: Model, data, run_ctx, **kwargs): + tags = data["seq_tag"] + audio_features = data["audio_features"] # [B, T, F] + # audio_features = audio_features.transpose(1, 2) # [B, F, T] necessary because glowTTS expects the channels to be in the 2nd dimension + audio_features_len = data["audio_features:size1"] # [B] + + # perform local length sorting for more efficient packing + audio_features_len, indices = torch.sort(audio_features_len, descending=True) + + audio_features = audio_features[indices, :, :] + phonemes = data["phonemes"][indices, :] # [B, T] (sparse) + phonemes_len = data["phonemes:size1"][indices] # [B, T] + phonemes_eow = data["phonemes_eow"][indices, :] # [B, T] + phonemes_eow_len = data["phonemes_eow:size1"][indices] + durations = data["durations"][indices] + speaker_labels = data["speaker_labels"][indices, :] # [B, 1] (sparse) + tags = list(np.array(tags)[indices.detach().cpu().numpy()]) + + recognition_input = kwargs["recognition_input"] + logits, y_lengths, z_mask, attn = model( + phonemes, + phonemes_len, + audio_features, + audio_features_len, + g=speaker_labels, + recognition_input=recognition_input, + ) + + upsampled_phonemes = torch.matmul(attn.squeeze(1).transpose(1, 2), phonemes.float().unsqueeze(-1)).squeeze(-1) + + mask = commons.sequence_mask(y_lengths) + ce_losses = nn.functional.cross_entropy(logits.transpose(1, 2), upsampled_phonemes.long(), reduction="none") + ce_loss = (ce_losses * mask.float()).sum() / mask.float().sum() + + run_ctx.mark_as_loss(name="ce", loss=ce_loss) + +def phoneme_prediction_init_hook(run_ctx, **kwargs): + run_ctx.hdf_writer = SimpleHDFWriter("output.hdf", dim=1, ndim=1) + run_ctx.pool = multiprocessing.Pool(8) + run_ctx.recognition_input = kwargs["recognition_input"] + + +def phoneme_prediction_finish_hook(run_ctx, **kwargs): + run_ctx.hdf_writer.close() + + +def phoneme_prediction_step(*, model: Model, data, run_ctx, **kwargs): + """ + :param Model model: _description_ + :param _type_ data: _description_ + :param _type_ run_ctx: _description_ + """ + tags = data["seq_tag"] + audio_features = data["audio_features"] # [B, T, F] + audio_features_len = data["audio_features:size1"] # [B] + + # perform local length sorting for more efficient packing + audio_features_len, indices = torch.sort(audio_features_len, descending=True) + audio_features = audio_features[indices, :, :] + phonemes = data["phonemes"][indices, :] # [B, T] (sparse) + phonemes_len = data["phonemes:size1"][indices] # [B, T] + durations = data["durations"][indices] + + speaker_labels = data["speaker_labels"][indices, :] # [B, 1] (sparse) + + tags = list(np.array(tags)[indices.detach().cpu().numpy()]) + + logits, y_lengths, z_mask, attn = model( + x=phonemes, + x_lengths=phonemes_len, + raw_audio=audio_features, + raw_audio_lengths=audio_features_len, + g=speaker_labels, + recognition_input=run_ctx.recognition_input, + ) + + upsampled_phonemes = torch.matmul(attn.int().squeeze(1).transpose(1, 2), phonemes.unsqueeze(-1)).squeeze(-1) + + mask = commons.sequence_mask(y_lengths) + pred = torch.softmax(logits, dim=2).argmax(dim=2) + + accuracies = ( + (((pred == upsampled_phonemes) * mask).sum(dim=1) / y_lengths).unsqueeze(-1).unsqueeze(-1).detach().cpu() + ) + + for tag, acc in zip(tags, accuracies): + run_ctx.hdf_writer.insert_batch(np.array(acc), [1], [tag]) + + +def encoder_phoneme_prediction_init_hook(run_ctx, **kwargs): + run_ctx.hdf_writer = SimpleHDFWriter("output.hdf", dim=1, ndim=1) + run_ctx.pool = multiprocessing.Pool(8) + + +def encoder_phoneme_prediction_finish_hook(run_ctx, **kwargs): + run_ctx.hdf_writer.close() + + +def encoder_phoneme_prediction_step(*, model: Model, data, run_ctx, **kwargs): + """ + :param Model model: _description_ + :param _type_ data: _description_ + :param _type_ run_ctx: _description_ + """ + tags = data["seq_tag"] + audio_features = data["audio_features"] # [B, T, F] + # audio_features = audio_features.transpose(1, 2) # [B, F, T] necessary because glowTTS expects the channels to be in the 2nd dimension + audio_features_len = data["audio_features:size1"] # [B] + + # perform local length sorting for more efficient packing + audio_features_len, indices = torch.sort(audio_features_len, descending=True) + + audio_features = audio_features[indices, :, :] + phonemes = data["phonemes"][indices, :] # [B, T] (sparse) + phonemes_len = data["phonemes:size1"][indices] # [B, T] + speaker_labels = data["speaker_labels"][indices, :] # [B, 1] (sparse) + durations = data["durations"][indices] + + tags = list(np.array(tags)[indices.detach().cpu().numpy()]) + + x_mask = torch.unsqueeze(commons.sequence_mask(phonemes_len, phonemes.size(1)), 1).to(phonemes.dtype) + y_lengths = torch.ceil(audio_features.size(1) / model.feature_extraction.hop_length).to(torch.int32) + y_lengths = (y_lengths // model.cfg.decoder_config.n_sqz) * model.cfg.decoder_config.n_sqz + z_mask = torch.unsqueeze(commons.sequence_mask(audio_features_len, y_lengths), 1) + attn_mask = torch.unsqueeze(x_mask, -1) * torch.unsqueeze(z_mask, 2) + given_attn = commons.generate_path(durations.squeeze(1), attn_mask.squeeze(1)).unsqueeze(1).to(torch.float32) + + (z, z_m, z_logs, logdet, z_mask), (x_m, x_logs, x_mask), y_lengths, (given_attn, logw, logw_), (logits, _) = model( + x=phonemes, + x_lengths=phonemes_len, + raw_audio=audio_features, + raw_audio_lengths=audio_features_len, + g=speaker_labels, + given_attn=given_attn, + recognition=False, + ) + x_mask = torch.unsqueeze(commons.sequence_mask(phonemes_len, phonemes.size(1)), 1).to(phonemes.dtype) + + attn_mask = torch.unsqueeze(x_mask, -1) * torch.unsqueeze(z_mask, 2) + given_attn = commons.generate_path(durations.squeeze(1), attn_mask.squeeze(1)).unsqueeze(1) + + upsampled_phonemes = torch.matmul(given_attn.squeeze(1).transpose(1, 2), phonemes.unsqueeze(-1)).squeeze(-1) + + mask = commons.sequence_mask(y_lengths) + pred = torch.softmax(logits, dim=2).argmax(dim=2) + + accuracies = ( + (((pred == upsampled_phonemes) * mask).sum(dim=1) / y_lengths).unsqueeze(-1).unsqueeze(-1).detach().cpu() + ) + + for tag, acc in zip(tags, accuracies): + run_ctx.hdf_writer.insert_batch(np.array(acc), [1], [tag]) + + +# def search_init_hook(run_ctx, **kwargs): +# # we are storing durations, but call it output.hdf to match +# # the default output of the ReturnnForwardJob +# from torchaudio.models.decoder import ctc_decoder +# run_ctx.recognition_file = open("search_out.py", "wt") +# run_ctx.recognition_file.write("{\n") +# import subprocess +# if kwargs["arpa_lm"] is not None: +# lm = subprocess.check_output(["cf", kwargs["arpa_lm"]]).decode().strip() +# else: +# lm = None +# from returnn.datasets.util.vocabulary import Vocabulary +# vocab = Vocabulary.create_vocab( +# vocab_file=kwargs["returnn_vocab"], unknown_label=None) +# labels = vocab.labels + +# run_ctx.ctc_decoder = ctc_decoder( +# lexicon=kwargs["lexicon"], +# lm=lm, +# lm_weight=kwargs["lm_weight"], +# tokens=labels + ["[blank]", "[SILENCE]", "[UNK]"], +# # "[SILENCE]" and "[UNK]" are not actually part of the vocab, +# # but the decoder is happy as long they are defined in the token list +# # even if they do not exist as label index in the softmax output, +# blank_token="[blank]", +# sil_token="[SILENCE]", +# unk_word="[unknown]", +# nbest=1, +# beam_size=kwargs["beam_size"], +# beam_size_token=kwargs.get("beam_size_token", None), +# beam_threshold=kwargs["beam_threshold"], +# sil_score=kwargs.get("sil_score", 0.0), +# word_score=kwargs.get("word_score", 0.0), +# ) +# run_ctx.labels = labels +# run_ctx.blank_log_penalty = kwargs.get("blank_log_penalty", None) + +# if kwargs.get("prior_file", None): +# run_ctx.prior = np.loadtxt(kwargs["prior_file"], dtype="float32") +# run_ctx.prior_scale = kwargs["prior_scale"] +# else: +# run_ctx.prior = None + +# def search_finish_hook(run_ctx, **kwargs): +# run_ctx.recognition_file.write("}\n") +# run_ctx.recognition_file.close() + +# def search_step(*, model, data, run_ctx, **kwargs): +# raw_audio = data["raw_audio"] # [B, T', F] +# raw_audio_len = data["raw_audio:size1"] # [B] + +# logprobs, audio_features_len = model( +# raw_audio=raw_audio, +# raw_audio_lengths=raw_audio_len, +# recognition=True +# ) + +# tags = data["seq_tag"] + +# logprobs_cpu = logprobs.cpu() +# if run_ctx.blank_log_penalty is not None: +# # assumes blank is last +# logprobs_cpu[:, :, -1] -= run_ctx.blank_log_penalty +# if run_ctx.prior is not None: +# logprobs_cpu -= run_ctx.prior_scale * run_ctx.prior +# hypothesis = run_ctx.ctc_decoder(logprobs_cpu, audio_features_len.cpu()) + +# for hyp, tag in zip(hypothesis, tags): +# words = hyp[0].words +# sequence = " ".join([word for word in words if not word.startswith("[")]) +# print(sequence) +# run_ctx.recognition_file.write("%s: %s,\n" % (repr(tag), repr(sequence))) diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/pytorch_networks/frozen_glowtts/ga_glowTTS_ASR_ffn_mas_no_eval.py b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/pytorch_networks/frozen_glowtts/ga_glowTTS_ASR_ffn_mas_no_eval.py new file mode 100644 index 000000000..564e5ba13 --- /dev/null +++ b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/pytorch_networks/frozen_glowtts/ga_glowTTS_ASR_ffn_mas_no_eval.py @@ -0,0 +1,657 @@ +""" +Trying to make the aligner more AppTek-Like + +Extended weight init code +""" + +from dataclasses import dataclass +import torch +import numpy as np +from torch import nn +import multiprocessing +from librosa import filters +import sys +import time +from typing import Any, Dict, Optional, Tuple, Union +import math +import os +import soundfile + +from ..shared.configs import ( + SpecaugConfig, + VGG4LayerActFrontendV1Config_mod, + FlowDecoderConfig, + TextEncoderConfig, + DbMelFeatureExtractionConfig, + ModelConfigV2 +) + +from returnn.datasets.hdf import SimpleHDFWriter + +from ..shared.feature_extraction import DbMelFeatureExtraction +from ..shared.spec_augment import apply_spec_aug +from ..shared.mask import mask_tensor + +from ..shared import modules +from ..shared import commons +from ..shared import attentions +from ..monotonic_align import maximum_path + +from ..shared.forward import search_init_hook, search_finish_hook +from ..shared.eval_forward import * + +from IPython import embed + +class XVector(nn.Module): + def __init__(self, input_dim=40, num_classes=8, **kwargs): + super(XVector, self).__init__() + self.tdnn1 = modules.TDNN( + input_dim=input_dim, output_dim=512, context_size=5, dilation=1, dropout_p=0.5, batch_norm=True + ) + self.tdnn2 = modules.TDNN( + input_dim=512, output_dim=512, context_size=3, dilation=2, dropout_p=0.5, batch_norm=True + ) + self.tdnn3 = modules.TDNN( + input_dim=512, output_dim=512, context_size=2, dilation=3, dropout_p=0.5, batch_norm=True + ) + self.tdnn4 = modules.TDNN( + input_dim=512, output_dim=512, context_size=1, dilation=1, dropout_p=0.5, batch_norm=True + ) + self.tdnn5 = modules.TDNN( + input_dim=512, output_dim=512, context_size=1, dilation=1, dropout_p=0.5, batch_norm=True + ) + #### Frame levelPooling + self.segment6 = nn.Linear(1024, 512) + self.segment7 = nn.Linear(512, 512) + self.output = nn.Linear(512, num_classes) + self.softmax = nn.Softmax(dim=1) + + # fe_config = DbMelFeatureExtractionConfig.from_dict(kwargs["fe_config"]) + # self.feature_extraction = DbMelFeatureExtraction(config=fe_config) + + def forward(self, x, x_lengths): + # with torch.no_grad(): + # squeezed_audio = torch.squeeze(raw_audio) + # x, x_lengths = self.feature_extraction(squeezed_audio, raw_audio_lengths) # [B, T, F] + + # x = x.transpose(1, 2) + tdnn1_out = self.tdnn1(x) + # return tdnn1_out + tdnn2_out = self.tdnn2(tdnn1_out) + tdnn3_out = self.tdnn3(tdnn2_out) + tdnn4_out = self.tdnn4(tdnn3_out) + tdnn5_out = self.tdnn5(tdnn4_out) + ### Stat Pool + mean = torch.mean(tdnn5_out, 2) + std = torch.std(tdnn5_out, 2) + stat_pooling = torch.cat((mean, std), 1) + segment6_out = self.segment6(stat_pooling) + x_vec = self.segment7(segment6_out) + output = self.output(x_vec) + predictions = self.softmax(output) + return output, predictions, x_vec + + +class DurationPredictor(nn.Module): + """ + Duration Predictor module, trained using calculated durations coming from monotonic alignment search + """ + + def __init__(self, in_channels, filter_channels, filter_size, p_dropout): + super().__init__() + + self.in_channels = in_channels + self.filter_channels = filter_channels + self.filter_size = filter_size + self.p_dropout = p_dropout + + self.convs = nn.Sequential( + modules.Conv1DBlock( + in_size=self.in_channels, + out_size=self.filter_channels, + filter_size=self.filter_size, + p_dropout=p_dropout, + ), + modules.Conv1DBlock( + in_size=self.filter_channels, + out_size=self.filter_channels, + filter_size=self.filter_size, + p_dropout=p_dropout, + ), + ) + self.proj = nn.Conv1d(in_channels=self.filter_channels, out_channels=1, kernel_size=1) + + def forward(self, x, x_mask): + x_with_mask = (x, x_mask) + (x, x_mask) = self.convs(x_with_mask) + x = self.proj(x * x_mask) + return x + + +class FlowDecoder(nn.Module): + def __init__(self, cfg: FlowDecoderConfig, in_channels, gin_channels): + """Flow-based decoder model + + Args: + in_channels (int): Number of incoming channels + hidden_channels (int): Number of hidden channels + kernel_size (int): Kernel Size for convolutions in coupling blocks + dilation_rate (float): Dilation Rate to define dilation in convolutions of coupling block + n_blocks (int): Number of coupling blocks + n_layers (int): Number of layers in CNN of the coupling blocks + p_dropout (float, optional): Dropout probability for CNN in coupling blocks. Defaults to 0.. + n_split (int, optional): Number of splits for the 1x1 convolution for flows in the decoder. Defaults to 4. + n_sqz (int, optional): Squeeze. Defaults to 1. + sigmoid_scale (bool, optional): Boolean to define if log probs in coupling layers should be rescaled using sigmoid. Defaults to False. + gin_channels (int, optional): Number of speaker embedding channels. Defaults to 0. + """ + super().__init__() + self.cfg = cfg + + self.flows = nn.ModuleList() + + for _ in range(self.cfg.n_blocks): + self.flows.append(modules.ActNorm(channels=in_channels * self.cfg.n_sqz)) + self.flows.append(modules.InvConvNear(channels=in_channels * self.cfg.n_sqz, n_split=self.cfg.n_split)) + self.flows.append( + attentions.CouplingBlock( + in_channels * self.cfg.n_sqz, + self.cfg.hidden_channels, + kernel_size=self.cfg.kernel_size, + dilation_rate=self.cfg.dilation_rate, + n_layers=self.cfg.n_layers, + gin_channels=gin_channels, + p_dropout=self.cfg.p_dropout, + sigmoid_scale=self.cfg.sigmoid_scale, + ) + ) + + def forward(self, x, x_mask, g=None, reverse=False): + if not reverse: + flows = self.flows + logdet_tot = 0 + else: + flows = reversed(self.flows) + logdet_tot = None + + if self.cfg.n_sqz > 1: + x, x_mask = commons.channel_squeeze(x, x_mask, self.cfg.n_sqz) + for f in flows: + if not reverse: + x, logdet = f(x, x_mask, g=g, reverse=reverse) + logdet_tot += logdet + else: + x, logdet = f(x, x_mask, g=g, reverse=reverse) + if self.cfg.n_sqz > 1: + x, x_mask = commons.channel_unsqueeze(x, x_mask, self.cfg.n_sqz) + return x, logdet_tot + + def store_inverse(self): + for f in self.flows: + f.store_inverse() + +class TextEncoder(nn.Module): + """ + Text Encoder model + """ + + def __init__(self, cfg: TextEncoderConfig, out_channels, gin_channels): + """Text Encoder Model based on Multi-Head Self-Attention combined with FF-CCNs + + Args: + n_vocab (int): Size of vocabulary for embeddings + out_channels (int): Number of output channels + hidden_channels (int): Number of hidden channels + filter_channels (int): Number of filter channels + filter_channels_dp (int): Number of filter channels for duration predictor + n_heads (int): Number of heads in encoder's Multi-Head Attention + n_layers (int): Number of layers consisting of Multi-Head Attention and CNNs in encoder + kernel_size (int): Kernel Size for CNNs in encoder layers + p_dropout (float): Dropout probability for both encoder and duration predictor + window_size (int, optional): Window size in Multi-Head Self-Attention for encoder. Defaults to None. + block_length (_type_, optional): Block length for optional block masking in Multi-Head Attention for encoder. Defaults to None. + mean_only (bool, optional): Boolean to only project text encodings to mean values instead of mean and std. Defaults to False. + prenet (bool, optional): Boolean to add ConvReluNorm prenet before encoder . Defaults to False. + gin_channels (int, optional): Number of channels for speaker condition. Defaults to 0. + """ + super().__init__() + self.cfg = cfg + + self.emb = nn.Embedding(self.cfg.n_vocab, self.cfg.hidden_channels) + nn.init.normal_(self.emb.weight, 0.0, self.cfg.hidden_channels**-0.5) + + if self.cfg.prenet: + self.pre = modules.ConvReluNorm( + self.cfg.hidden_channels, + self.cfg.hidden_channels, + self.cfg.hidden_channels, + kernel_size=5, + n_layers=3, + p_dropout=0.5, + ) + self.encoder = attentions.Encoder( + self.cfg.hidden_channels, + self.cfg.filter_channels, + self.cfg.n_heads, + self.cfg.n_layers, + self.cfg.kernel_size, + self.cfg.p_dropout, + window_size=self.cfg.window_size, + block_length=self.cfg.block_length, + ) + + self.proj_m = nn.Conv1d(self.cfg.hidden_channels, out_channels, 1) + if not self.cfg.mean_only: + self.proj_s = nn.Conv1d(self.cfg.hidden_channels, out_channels, 1) + self.proj_w = DurationPredictor( + self.cfg.hidden_channels + gin_channels, + self.cfg.filter_channels_dp, + self.cfg.kernel_size, + self.cfg.p_dropout, + ) + + def forward(self, x, x_lengths, g=None): + x = self.emb(x) * math.sqrt(self.cfg.hidden_channels) # [b, t, h] + x = torch.transpose(x, 1, -1) # [b, h, t] + x_mask = torch.unsqueeze(commons.sequence_mask(x_lengths, x.size(2)), 1).to(x.dtype) + + if self.cfg.prenet: + x = self.pre(x, x_mask) + x = self.encoder(x, x_mask) + + if g is not None: + g_exp = g.expand(-1, -1, x.size(-1)) + # print(f"Dimension of input in Text Encoder: x.shape: {x.shape}; g: {g.shape}, g_exp: {g_exp.shape}") + x_dp = torch.cat([torch.detach(x), g_exp], 1) + else: + x_dp = torch.detach(x) + + x_m = self.proj_m(x) * x_mask + if not self.cfg.mean_only: + x_logs = self.proj_s(x) * x_mask + else: + x_logs = torch.zeros_like(x_m) + + # print(f"Dimension of input in Text Encoder before DP: {x_dp.shape}") + + logw = self.proj_w(x_dp, x_mask) + return x_m, x_logs, logw, x_mask + +class Model(nn.Module): + """ + Flow-based ASR model based on GlowTTS Structure using a pre-trained flow-based decoder + trained to generate spectrograms from given statistics coming from an encoder + + Model was pretrained using the architecture in + users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS.py + """ + + def __init__( + self, + model_config: dict, + **kwargs, + ): + """_summary_ + + Args: + n_vocab (int): vocabulary size + hidden_channels (int): Number of hidden channels in encoder + out_channels (int): Number of channels in the output + n_blocks_dec (int, optional): Number of coupling blocks in the decoder. Defaults to 12. + kernel_size_dec (int, optional): Kernel size in the decoder. Defaults to 5. + dilation_rate (int, optional): Dilation rate for CNNs of coupling blocks in decoder. Defaults to 5. + n_block_layers (int, optional): Number of layers in the CNN of the coupling blocks in decoder. Defaults to 4. + p_dropout_dec (_type_, optional): Dropout probability in the decoder. Defaults to 0.. + n_speakers (int, optional): Number of speakers. Defaults to 0. + gin_channels (int, optional): Number of speaker embedding channels. Defaults to 0. + n_split (int, optional): Number of splits for the 1x1 convolution for flows in the decoder. Defaults to 4. + n_sqz (int, optional): Squeeze. Defaults to 1. + sigmoid_scale (bool, optional): Boolean to define if log probs in coupling layers should be rescaled using sigmoid. Defaults to False. + window_size (int, optional): Window size in Multi-Head Self-Attention for encoder. Defaults to None. + block_length (_type_, optional): Block length for optional block masking in Multi-Head Attention for encoder. Defaults to None. + hidden_channels_dec (_type_, optional): Number of hidden channels in decodder. Defaults to hidden_channels. + final_hidden_channels: Number of hidden channels in the final network + final_n_layers: Number of layers in the final network + label_target_size: Target size of target vocabulary, target size for final network + """ + super().__init__() + + self.net_kwargs = { + "repeat_per_num_frames": 100, + "max_dim_feat": 8, + "num_repeat_feat": 5, + "max_dim_time": 20, + } + + fe_config = DbMelFeatureExtractionConfig.from_dict(kwargs["fe_config"]) + self.feature_extraction = DbMelFeatureExtraction(config=fe_config) + + # if label_target_size is None: + # if n_vocab is None: + # run_ctx = get_run_ctx() + # dataset = run_ctx.engine.train_dataset or run_ctx.engine.forward_dataset + # self.label_target_size = len(dataset.datasets["zip_dataset"].targets.labels) + # else: + # self.label_target_size = n_vocab + # else: + # self.label_target_size = label_target_size + + self.cfg = ModelConfigV2.from_dict(model_config) + text_encoder_config = self.cfg.text_encoder_config + decoder_config = self.cfg.decoder_config + + if self.cfg.n_speakers > 1: + self.emb_g = nn.Embedding(self.cfg.n_speakers, self.cfg.gin_channels) + nn.init.uniform_(self.emb_g.weight, -0.1, 0.1) + + self.encoder = TextEncoder( + text_encoder_config, out_channels=self.cfg.out_channels, gin_channels=self.cfg.gin_channels + ) + + self.decoder = FlowDecoder( + decoder_config, in_channels=self.cfg.out_channels, gin_channels=self.cfg.gin_channels + ) + + self.asr_output = nn.Sequential() + + for i in range(self.cfg.phoneme_prediction_config.n_layers): + if i == 0: + in_channels = self.cfg.out_channels + else: + in_channels = self.cfg.phoneme_prediction_config.n_channels + if i < self.cfg.phoneme_prediction_config.n_layers - 1: + out_channels = self.cfg.phoneme_prediction_config.n_channels + else: + out_channels = self.cfg.label_target_size + 1 + + self.asr_output.append(nn.Linear(in_channels, out_channels)) + if i < self.cfg.phoneme_prediction_config.n_layers - 1: + self.asr_output.append(nn.ReLU()) + self.asr_output.append(nn.Dropout(self.cfg.phoneme_prediction_config.p_dropout)) + + self.specaug_start_epoch = self.cfg.specauc_start_epoch + + def forward( + self, x=None, x_lengths=None, raw_audio=None, raw_audio_lengths=None, g=None, recognition_input=None, noise_scale=1.0, length_scale=1.0 + ): + assert recognition_input in ["encoder", "decoder"] + with torch.no_grad(): + squeezed_audio = torch.squeeze(raw_audio) + y, y_lengths = self.feature_extraction(squeezed_audio, raw_audio_lengths) # [B, T, F] + y = y.transpose(1, 2) # [B, F, T] + + assert g is not None, "Missing speaker embeddings!" + g = nn.functional.normalize(self.emb_g(g.squeeze(-1))).unsqueeze(-1) + + y_max_length = y.size(2) + + y, y_lengths, y_max_length = self.preprocess(y, y_lengths, y_max_length) + z_mask = torch.unsqueeze(commons.sequence_mask(y_lengths, y_max_length), 1).to(torch.int32) + + x_m, x_logs, logw, x_mask = self.encoder(x, x_lengths, g=g) # mean, std logs, duration logs, mask + attn_mask = torch.unsqueeze(x_mask, -1) * torch.unsqueeze(z_mask, 2) + z, logdet = self.decoder(y, z_mask, g=g, reverse=False) + + x_s_sq_r = torch.exp(-2 * x_logs) + logp1 = torch.sum(-0.5 * math.log(2 * math.pi) - x_logs, [1]).unsqueeze(-1) # [b, t, 1] + logp2 = torch.matmul(x_s_sq_r.transpose(1, 2), -0.5 * (z**2)) # [b, t, d] x [b, d, t'] = [b, t, t'] + logp3 = torch.matmul((x_m * x_s_sq_r).transpose(1, 2), z) # [b, t, d] x [b, d, t'] = [b, t, t'] + logp4 = torch.sum(-0.5 * (x_m**2) * x_s_sq_r, [1]).unsqueeze(-1) # [b, t, 1] + logp = logp1 + logp2 + logp3 + logp4 # [b, t, t'] + + attn = maximum_path(logp, attn_mask.squeeze(1)).unsqueeze(1).detach() + # embed() + + z_m = torch.matmul(attn.squeeze(1).transpose(1, 2), x_m.transpose(1, 2)).transpose( + 1, 2 + ) # [b, t', t], [b, t, d] -> [b, d, t'] + z_logs = torch.matmul(attn.squeeze(1).transpose(1, 2), x_logs.transpose(1, 2)).transpose( + 1, 2 + ) # [b, t', t], [b, t, d] -> [b, d, t'] + + if recognition_input == "encoder": + asr_in = z.transpose(1,2) + else: + asr_in = ((z_m + torch.exp(z_logs) * torch.randn_like(z_m) * noise_scale) * z_mask).transpose(1,2) + + logits = self.asr_output(asr_in) + + return logits, y_lengths, z_mask, attn + + def preprocess(self, y, y_lengths, y_max_length): + if y_max_length is not None: + y_max_length = (y_max_length // self.cfg.decoder_config.n_sqz) * self.cfg.decoder_config.n_sqz + y = y[:, :, :y_max_length] + y_lengths = (y_lengths // self.cfg.decoder_config.n_sqz) * self.cfg.decoder_config.n_sqz + return y, y_lengths, y_max_length + + def store_inverse(self): + self.decoder.store_inverse() + + +def train_step(*, model: Model, data, run_ctx, **kwargs): + tags = data["seq_tag"] + audio_features = data["audio_features"] # [B, T, F] + # audio_features = audio_features.transpose(1, 2) # [B, F, T] necessary because glowTTS expects the channels to be in the 2nd dimension + audio_features_len = data["audio_features:size1"] # [B] + + # perform local length sorting for more efficient packing + audio_features_len, indices = torch.sort(audio_features_len, descending=True) + + audio_features = audio_features[indices, :, :] + phonemes = data["phonemes"][indices, :] # [B, T] (sparse) + phonemes_len = data["phonemes:size1"][indices] # [B, T] + phonemes_eow = data["phonemes_eow"][indices, :] # [B, T] + phonemes_eow_len = data["phonemes_eow:size1"][indices] + durations = data["durations"][indices] + speaker_labels = data["speaker_labels"][indices, :] # [B, 1] (sparse) + tags = list(np.array(tags)[indices.detach().cpu().numpy()]) + + recognition_input = kwargs["recognition_input"] + logits, y_lengths, z_mask, attn = model( + phonemes, + phonemes_len, + audio_features, + audio_features_len, + g=speaker_labels, + recognition_input=recognition_input, + ) + + upsampled_phonemes = torch.matmul(attn.squeeze(1).transpose(1, 2), phonemes.float().unsqueeze(-1)).squeeze(-1) + + mask = commons.sequence_mask(y_lengths) + ce_losses = nn.functional.cross_entropy(logits.transpose(1, 2), upsampled_phonemes.long(), reduction="none") + ce_loss = (ce_losses * mask.float()).sum() / mask.float().sum() + + run_ctx.mark_as_loss(name="ce", loss=ce_loss) + +def phoneme_prediction_init_hook(run_ctx, **kwargs): + run_ctx.hdf_writer = SimpleHDFWriter("output.hdf", dim=1, ndim=1) + run_ctx.pool = multiprocessing.Pool(8) + run_ctx.recognition_input = kwargs["recognition_input"] + + +def phoneme_prediction_finish_hook(run_ctx, **kwargs): + run_ctx.hdf_writer.close() + + +def phoneme_prediction_step(*, model: Model, data, run_ctx, **kwargs): + """ + :param Model model: _description_ + :param _type_ data: _description_ + :param _type_ run_ctx: _description_ + """ + tags = data["seq_tag"] + audio_features = data["audio_features"] # [B, T, F] + audio_features_len = data["audio_features:size1"] # [B] + + # perform local length sorting for more efficient packing + audio_features_len, indices = torch.sort(audio_features_len, descending=True) + audio_features = audio_features[indices, :, :] + phonemes = data["phonemes"][indices, :] # [B, T] (sparse) + phonemes_len = data["phonemes:size1"][indices] # [B, T] + durations = data["durations"][indices] + + speaker_labels = data["speaker_labels"][indices, :] # [B, 1] (sparse) + + tags = list(np.array(tags)[indices.detach().cpu().numpy()]) + + logits, y_lengths, z_mask, attn = model( + x=phonemes, + x_lengths=phonemes_len, + raw_audio=audio_features, + raw_audio_lengths=audio_features_len, + g=speaker_labels, + recognition_input=run_ctx.recognition_input, + ) + + upsampled_phonemes = torch.matmul(attn.int().squeeze(1).transpose(1, 2), phonemes.unsqueeze(-1)).squeeze(-1) + + mask = commons.sequence_mask(y_lengths) + pred = torch.softmax(logits, dim=2).argmax(dim=2) + + accuracies = ( + (((pred == upsampled_phonemes) * mask).sum(dim=1) / y_lengths).unsqueeze(-1).unsqueeze(-1).detach().cpu() + ) + + for tag, acc in zip(tags, accuracies): + run_ctx.hdf_writer.insert_batch(np.array(acc), [1], [tag]) + + +def encoder_phoneme_prediction_init_hook(run_ctx, **kwargs): + run_ctx.hdf_writer = SimpleHDFWriter("output.hdf", dim=1, ndim=1) + run_ctx.pool = multiprocessing.Pool(8) + + +def encoder_phoneme_prediction_finish_hook(run_ctx, **kwargs): + run_ctx.hdf_writer.close() + + +def encoder_phoneme_prediction_step(*, model: Model, data, run_ctx, **kwargs): + """ + :param Model model: _description_ + :param _type_ data: _description_ + :param _type_ run_ctx: _description_ + """ + tags = data["seq_tag"] + audio_features = data["audio_features"] # [B, T, F] + # audio_features = audio_features.transpose(1, 2) # [B, F, T] necessary because glowTTS expects the channels to be in the 2nd dimension + audio_features_len = data["audio_features:size1"] # [B] + + # perform local length sorting for more efficient packing + audio_features_len, indices = torch.sort(audio_features_len, descending=True) + + audio_features = audio_features[indices, :, :] + phonemes = data["phonemes"][indices, :] # [B, T] (sparse) + phonemes_len = data["phonemes:size1"][indices] # [B, T] + speaker_labels = data["speaker_labels"][indices, :] # [B, 1] (sparse) + durations = data["durations"][indices] + + tags = list(np.array(tags)[indices.detach().cpu().numpy()]) + + x_mask = torch.unsqueeze(commons.sequence_mask(phonemes_len, phonemes.size(1)), 1).to(phonemes.dtype) + y_lengths = torch.ceil(audio_features.size(1) / model.feature_extraction.hop_length).to(torch.int32) + y_lengths = (y_lengths // model.cfg.decoder_config.n_sqz) * model.cfg.decoder_config.n_sqz + z_mask = torch.unsqueeze(commons.sequence_mask(audio_features_len, y_lengths), 1) + attn_mask = torch.unsqueeze(x_mask, -1) * torch.unsqueeze(z_mask, 2) + given_attn = commons.generate_path(durations.squeeze(1), attn_mask.squeeze(1)).unsqueeze(1).to(torch.float32) + + (z, z_m, z_logs, logdet, z_mask), (x_m, x_logs, x_mask), y_lengths, (given_attn, logw, logw_), (logits, _) = model( + x=phonemes, + x_lengths=phonemes_len, + raw_audio=audio_features, + raw_audio_lengths=audio_features_len, + g=speaker_labels, + given_attn=given_attn, + recognition=False, + ) + x_mask = torch.unsqueeze(commons.sequence_mask(phonemes_len, phonemes.size(1)), 1).to(phonemes.dtype) + + attn_mask = torch.unsqueeze(x_mask, -1) * torch.unsqueeze(z_mask, 2) + given_attn = commons.generate_path(durations.squeeze(1), attn_mask.squeeze(1)).unsqueeze(1) + + upsampled_phonemes = torch.matmul(given_attn.squeeze(1).transpose(1, 2), phonemes.unsqueeze(-1)).squeeze(-1) + + mask = commons.sequence_mask(y_lengths) + pred = torch.softmax(logits, dim=2).argmax(dim=2) + + accuracies = ( + (((pred == upsampled_phonemes) * mask).sum(dim=1) / y_lengths).unsqueeze(-1).unsqueeze(-1).detach().cpu() + ) + + for tag, acc in zip(tags, accuracies): + run_ctx.hdf_writer.insert_batch(np.array(acc), [1], [tag]) + + +# def search_init_hook(run_ctx, **kwargs): +# # we are storing durations, but call it output.hdf to match +# # the default output of the ReturnnForwardJob +# from torchaudio.models.decoder import ctc_decoder +# run_ctx.recognition_file = open("search_out.py", "wt") +# run_ctx.recognition_file.write("{\n") +# import subprocess +# if kwargs["arpa_lm"] is not None: +# lm = subprocess.check_output(["cf", kwargs["arpa_lm"]]).decode().strip() +# else: +# lm = None +# from returnn.datasets.util.vocabulary import Vocabulary +# vocab = Vocabulary.create_vocab( +# vocab_file=kwargs["returnn_vocab"], unknown_label=None) +# labels = vocab.labels + +# run_ctx.ctc_decoder = ctc_decoder( +# lexicon=kwargs["lexicon"], +# lm=lm, +# lm_weight=kwargs["lm_weight"], +# tokens=labels + ["[blank]", "[SILENCE]", "[UNK]"], +# # "[SILENCE]" and "[UNK]" are not actually part of the vocab, +# # but the decoder is happy as long they are defined in the token list +# # even if they do not exist as label index in the softmax output, +# blank_token="[blank]", +# sil_token="[SILENCE]", +# unk_word="[unknown]", +# nbest=1, +# beam_size=kwargs["beam_size"], +# beam_size_token=kwargs.get("beam_size_token", None), +# beam_threshold=kwargs["beam_threshold"], +# sil_score=kwargs.get("sil_score", 0.0), +# word_score=kwargs.get("word_score", 0.0), +# ) +# run_ctx.labels = labels +# run_ctx.blank_log_penalty = kwargs.get("blank_log_penalty", None) + +# if kwargs.get("prior_file", None): +# run_ctx.prior = np.loadtxt(kwargs["prior_file"], dtype="float32") +# run_ctx.prior_scale = kwargs["prior_scale"] +# else: +# run_ctx.prior = None + +# def search_finish_hook(run_ctx, **kwargs): +# run_ctx.recognition_file.write("}\n") +# run_ctx.recognition_file.close() + +# def search_step(*, model, data, run_ctx, **kwargs): +# raw_audio = data["raw_audio"] # [B, T', F] +# raw_audio_len = data["raw_audio:size1"] # [B] + +# logprobs, audio_features_len = model( +# raw_audio=raw_audio, +# raw_audio_lengths=raw_audio_len, +# recognition=True +# ) + +# tags = data["seq_tag"] + +# logprobs_cpu = logprobs.cpu() +# if run_ctx.blank_log_penalty is not None: +# # assumes blank is last +# logprobs_cpu[:, :, -1] -= run_ctx.blank_log_penalty +# if run_ctx.prior is not None: +# logprobs_cpu -= run_ctx.prior_scale * run_ctx.prior +# hypothesis = run_ctx.ctc_decoder(logprobs_cpu, audio_features_len.cpu()) + +# for hyp, tag in zip(hypothesis, tags): +# words = hyp[0].words +# sequence = " ".join([word for word in words if not word.startswith("[")]) +# print(sequence) +# run_ctx.recognition_file.write("%s: %s,\n" % (repr(tag), repr(sequence))) diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/pytorch_networks/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector.py b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/pytorch_networks/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector.py index 096a27828..bca2eed86 100644 --- a/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/pytorch_networks/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector.py +++ b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/pytorch_networks/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector.py @@ -501,7 +501,6 @@ def phoneme_prediction_step(*, model: Model, data, run_ctx, **kwargs): z_mask = torch.unsqueeze(commons.sequence_mask(audio_features_len, y_lengths), 1) attn_mask = torch.unsqueeze(x_mask, -1) * torch.unsqueeze(z_mask, 2) given_attn = commons.generate_path(durations.squeeze(1), attn_mask.squeeze(1)).unsqueeze(1).to(torch.float32) - logits, y_lengths, z_mask = model( x=phonemes, x_lengths=phonemes_len, diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/pytorch_networks/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector_mas.py b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/pytorch_networks/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector_mas.py index 0ec257369..a23d9e795 100644 --- a/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/pytorch_networks/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector_mas.py +++ b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/pytorch_networks/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector_mas.py @@ -414,7 +414,7 @@ def forward( 1, 2 ) # [b, t', t], [b, t, d] -> [b, d, t'] - if recognition_input == "encoder": + if recognition_input == "encoder": #TODO: This is wrong! asr_in = z.transpose(1,2) else: asr_in = ((z_m + torch.exp(z_logs) * torch.randn_like(z_m) * noise_scale) * z_mask).transpose(1,2) @@ -508,12 +508,8 @@ def phoneme_prediction_step(*, model: Model, data, run_ctx, **kwargs): g=speaker_labels, recognition_input=run_ctx.recognition_input, ) - x_mask = torch.unsqueeze(commons.sequence_mask(phonemes_len, phonemes.size(1)), 1).to(phonemes.dtype) - attn_mask = torch.unsqueeze(x_mask, -1) * torch.unsqueeze(z_mask, 2) - given_attn = commons.generate_path(durations.squeeze(1), attn_mask.squeeze(1)).unsqueeze(1) - - upsampled_phonemes = torch.matmul(given_attn.squeeze(1).transpose(1, 2), phonemes.unsqueeze(-1)).squeeze(-1) + upsampled_phonemes = torch.matmul(attn.squeeze(1).transpose(1, 2), phonemes.unsqueeze(-1)).squeeze(-1) mask = commons.sequence_mask(y_lengths) pred = torch.softmax(logits, dim=2).argmax(dim=2) diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/pytorch_networks/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector_mas_no_eval.py b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/pytorch_networks/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector_mas_no_eval.py new file mode 100644 index 000000000..198ff888b --- /dev/null +++ b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/pytorch_networks/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector_mas_no_eval.py @@ -0,0 +1,600 @@ +""" +Trying to make the aligner more AppTek-Like + +Extended weight init code +""" + +from dataclasses import dataclass +import torch +import numpy as np +from torch import nn +import multiprocessing +from librosa import filters +import sys +import time +from typing import Any, Dict, Optional, Tuple, Union +import math +import os +import soundfile + +from ..shared.configs import ( + SpecaugConfig, + VGG4LayerActFrontendV1Config_mod, + FlowDecoderConfig, + TextEncoderConfig, + DbMelFeatureExtractionConfig, + ModelConfigV2 +) + +from returnn.datasets.hdf import SimpleHDFWriter + +from ..shared.feature_extraction import DbMelFeatureExtraction +from ..shared.spec_augment import apply_spec_aug +from ..shared.mask import mask_tensor + +from ..shared import modules +from ..shared import commons +from ..shared import attentions +from ..monotonic_align import maximum_path + +from ..shared.forward import search_init_hook, search_finish_hook +from ..shared.eval_forward import * + +from IPython import embed + +class XVector(nn.Module): + def __init__(self, input_dim=40, num_classes=8, **kwargs): + super(XVector, self).__init__() + self.tdnn1 = modules.TDNN( + input_dim=input_dim, output_dim=512, context_size=5, dilation=1, dropout_p=0.5, batch_norm=True + ) + self.tdnn2 = modules.TDNN( + input_dim=512, output_dim=512, context_size=3, dilation=2, dropout_p=0.5, batch_norm=True + ) + self.tdnn3 = modules.TDNN( + input_dim=512, output_dim=512, context_size=2, dilation=3, dropout_p=0.5, batch_norm=True + ) + self.tdnn4 = modules.TDNN( + input_dim=512, output_dim=512, context_size=1, dilation=1, dropout_p=0.5, batch_norm=True + ) + self.tdnn5 = modules.TDNN( + input_dim=512, output_dim=512, context_size=1, dilation=1, dropout_p=0.5, batch_norm=True + ) + #### Frame levelPooling + self.segment6 = nn.Linear(1024, 512) + self.segment7 = nn.Linear(512, 512) + self.output = nn.Linear(512, num_classes) + self.softmax = nn.Softmax(dim=1) + + # fe_config = DbMelFeatureExtractionConfig.from_dict(kwargs["fe_config"]) + # self.feature_extraction = DbMelFeatureExtraction(config=fe_config) + + def forward(self, x, x_lengths): + # with torch.no_grad(): + # squeezed_audio = torch.squeeze(raw_audio) + # x, x_lengths = self.feature_extraction(squeezed_audio, raw_audio_lengths) # [B, T, F] + + # x = x.transpose(1, 2) + tdnn1_out = self.tdnn1(x) + # return tdnn1_out + tdnn2_out = self.tdnn2(tdnn1_out) + tdnn3_out = self.tdnn3(tdnn2_out) + tdnn4_out = self.tdnn4(tdnn3_out) + tdnn5_out = self.tdnn5(tdnn4_out) + ### Stat Pool + mean = torch.mean(tdnn5_out, 2) + std = torch.std(tdnn5_out, 2) + stat_pooling = torch.cat((mean, std), 1) + segment6_out = self.segment6(stat_pooling) + x_vec = self.segment7(segment6_out) + output = self.output(x_vec) + predictions = self.softmax(output) + return output, predictions, x_vec + + +class DurationPredictor(nn.Module): + """ + Duration Predictor module, trained using calculated durations coming from monotonic alignment search + """ + + def __init__(self, in_channels, filter_channels, filter_size, p_dropout): + super().__init__() + + self.in_channels = in_channels + self.filter_channels = filter_channels + self.filter_size = filter_size + self.p_dropout = p_dropout + + self.convs = nn.Sequential( + modules.Conv1DBlock( + in_size=self.in_channels, + out_size=self.filter_channels, + filter_size=self.filter_size, + p_dropout=p_dropout, + ), + modules.Conv1DBlock( + in_size=self.filter_channels, + out_size=self.filter_channels, + filter_size=self.filter_size, + p_dropout=p_dropout, + ), + ) + self.proj = nn.Conv1d(in_channels=self.filter_channels, out_channels=1, kernel_size=1) + + def forward(self, x, x_mask): + x_with_mask = (x, x_mask) + (x, x_mask) = self.convs(x_with_mask) + x = self.proj(x * x_mask) + return x + + +class FlowDecoder(nn.Module): + def __init__(self, cfg: FlowDecoderConfig, in_channels, gin_channels): + """Flow-based decoder model + + Args: + in_channels (int): Number of incoming channels + hidden_channels (int): Number of hidden channels + kernel_size (int): Kernel Size for convolutions in coupling blocks + dilation_rate (float): Dilation Rate to define dilation in convolutions of coupling block + n_blocks (int): Number of coupling blocks + n_layers (int): Number of layers in CNN of the coupling blocks + p_dropout (float, optional): Dropout probability for CNN in coupling blocks. Defaults to 0.. + n_split (int, optional): Number of splits for the 1x1 convolution for flows in the decoder. Defaults to 4. + n_sqz (int, optional): Squeeze. Defaults to 1. + sigmoid_scale (bool, optional): Boolean to define if log probs in coupling layers should be rescaled using sigmoid. Defaults to False. + gin_channels (int, optional): Number of speaker embedding channels. Defaults to 0. + """ + super().__init__() + self.cfg = cfg + + self.flows = nn.ModuleList() + + for _ in range(self.cfg.n_blocks): + self.flows.append(modules.ActNorm(channels=in_channels * self.cfg.n_sqz)) + self.flows.append(modules.InvConvNear(channels=in_channels * self.cfg.n_sqz, n_split=self.cfg.n_split)) + self.flows.append( + attentions.CouplingBlock( + in_channels * self.cfg.n_sqz, + self.cfg.hidden_channels, + kernel_size=self.cfg.kernel_size, + dilation_rate=self.cfg.dilation_rate, + n_layers=self.cfg.n_layers, + gin_channels=gin_channels, + p_dropout=self.cfg.p_dropout, + sigmoid_scale=self.cfg.sigmoid_scale, + ) + ) + + def forward(self, x, x_mask, g=None, reverse=False): + if not reverse: + flows = self.flows + logdet_tot = 0 + else: + flows = reversed(self.flows) + logdet_tot = None + + if g is not None: + g = g.unsqueeze(-1) + + if self.cfg.n_sqz > 1: + x, x_mask = commons.channel_squeeze(x, x_mask, self.cfg.n_sqz) + for f in flows: + if not reverse: + x, logdet = f(x, x_mask, g=g, reverse=reverse) + logdet_tot += logdet + else: + x, logdet = f(x, x_mask, g=g, reverse=reverse) + if self.cfg.n_sqz > 1: + x, x_mask = commons.channel_unsqueeze(x, x_mask, self.cfg.n_sqz) + return x, logdet_tot + + def store_inverse(self): + for f in self.flows: + f.store_inverse() + +class TextEncoder(nn.Module): + """ + Text Encoder model + """ + + def __init__(self, cfg: TextEncoderConfig, out_channels, gin_channels): + """Text Encoder Model based on Multi-Head Self-Attention combined with FF-CCNs + + Args: + n_vocab (int): Size of vocabulary for embeddings + out_channels (int): Number of output channels + hidden_channels (int): Number of hidden channels + filter_channels (int): Number of filter channels + filter_channels_dp (int): Number of filter channels for duration predictor + n_heads (int): Number of heads in encoder's Multi-Head Attention + n_layers (int): Number of layers consisting of Multi-Head Attention and CNNs in encoder + kernel_size (int): Kernel Size for CNNs in encoder layers + p_dropout (float): Dropout probability for both encoder and duration predictor + window_size (int, optional): Window size in Multi-Head Self-Attention for encoder. Defaults to None. + block_length (_type_, optional): Block length for optional block masking in Multi-Head Attention for encoder. Defaults to None. + mean_only (bool, optional): Boolean to only project text encodings to mean values instead of mean and std. Defaults to False. + prenet (bool, optional): Boolean to add ConvReluNorm prenet before encoder . Defaults to False. + gin_channels (int, optional): Number of channels for speaker condition. Defaults to 0. + """ + super().__init__() + self.cfg = cfg + + self.emb = nn.Embedding(self.cfg.n_vocab, self.cfg.hidden_channels) + nn.init.normal_(self.emb.weight, 0.0, self.cfg.hidden_channels**-0.5) + + if self.cfg.prenet: + self.pre = modules.ConvReluNorm( + self.cfg.hidden_channels, + self.cfg.hidden_channels, + self.cfg.hidden_channels, + kernel_size=5, + n_layers=3, + p_dropout=0.5, + ) + self.encoder = attentions.Encoder( + self.cfg.hidden_channels, + self.cfg.filter_channels, + self.cfg.n_heads, + self.cfg.n_layers, + self.cfg.kernel_size, + self.cfg.p_dropout, + window_size=self.cfg.window_size, + block_length=self.cfg.block_length, + ) + + self.proj_m = nn.Conv1d(self.cfg.hidden_channels, out_channels, 1) + if not self.cfg.mean_only: + self.proj_s = nn.Conv1d(self.cfg.hidden_channels, out_channels, 1) + self.proj_w = DurationPredictor( + self.cfg.hidden_channels + gin_channels, + self.cfg.filter_channels_dp, + self.cfg.kernel_size, + self.cfg.p_dropout, + ) + + def forward(self, x, x_lengths, g=None): + x = self.emb(x) * math.sqrt(self.cfg.hidden_channels) # [b, t, h] + x = torch.transpose(x, 1, -1) # [b, h, t] + x_mask = torch.unsqueeze(commons.sequence_mask(x_lengths, x.size(2)), 1).to(x.dtype) + + if self.cfg.prenet: + x = self.pre(x, x_mask) + x = self.encoder(x, x_mask) + + if g is not None: + g_exp = g.unsqueeze(-1).expand(-1, -1, x.size(-1)) + # print(f"Dimension of input in Text Encoder: x.shape: {x.shape}; g: {g.shape}, g_exp: {g_exp.shape}") + x_dp = torch.cat([torch.detach(x), g_exp], 1) + else: + x_dp = torch.detach(x) + + x_m = self.proj_m(x) * x_mask + if not self.cfg.mean_only: + x_logs = self.proj_s(x) * x_mask + else: + x_logs = torch.zeros_like(x_m) + + # print(f"Dimension of input in Text Encoder before DP: {x_dp.shape}") + + logw = self.proj_w(x_dp, x_mask) + return x_m, x_logs, logw, x_mask + +class Model(nn.Module): + """ + Flow-based ASR model based on GlowTTS Structure using a pre-trained flow-based decoder + trained to generate spectrograms from given statistics coming from an encoder + + Model was pretrained using the architecture in + users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS.py + """ + + def __init__( + self, + model_config: dict, + **kwargs, + ): + """_summary_ + + Args: + n_vocab (int): vocabulary size + hidden_channels (int): Number of hidden channels in encoder + out_channels (int): Number of channels in the output + n_blocks_dec (int, optional): Number of coupling blocks in the decoder. Defaults to 12. + kernel_size_dec (int, optional): Kernel size in the decoder. Defaults to 5. + dilation_rate (int, optional): Dilation rate for CNNs of coupling blocks in decoder. Defaults to 5. + n_block_layers (int, optional): Number of layers in the CNN of the coupling blocks in decoder. Defaults to 4. + p_dropout_dec (_type_, optional): Dropout probability in the decoder. Defaults to 0.. + n_speakers (int, optional): Number of speakers. Defaults to 0. + gin_channels (int, optional): Number of speaker embedding channels. Defaults to 0. + n_split (int, optional): Number of splits for the 1x1 convolution for flows in the decoder. Defaults to 4. + n_sqz (int, optional): Squeeze. Defaults to 1. + sigmoid_scale (bool, optional): Boolean to define if log probs in coupling layers should be rescaled using sigmoid. Defaults to False. + window_size (int, optional): Window size in Multi-Head Self-Attention for encoder. Defaults to None. + block_length (_type_, optional): Block length for optional block masking in Multi-Head Attention for encoder. Defaults to None. + hidden_channels_dec (_type_, optional): Number of hidden channels in decodder. Defaults to hidden_channels. + final_hidden_channels: Number of hidden channels in the final network + final_n_layers: Number of layers in the final network + label_target_size: Target size of target vocabulary, target size for final network + """ + super().__init__() + + self.net_kwargs = { + "repeat_per_num_frames": 100, + "max_dim_feat": 8, + "num_repeat_feat": 5, + "max_dim_time": 20, + } + + fe_config = DbMelFeatureExtractionConfig.from_dict(kwargs["fe_config"]) + self.feature_extraction = DbMelFeatureExtraction(config=fe_config) + + # if label_target_size is None: + # if n_vocab is None: + # run_ctx = get_run_ctx() + # dataset = run_ctx.engine.train_dataset or run_ctx.engine.forward_dataset + # self.label_target_size = len(dataset.datasets["zip_dataset"].targets.labels) + # else: + # self.label_target_size = n_vocab + # else: + # self.label_target_size = label_target_size + + self.cfg = ModelConfigV2.from_dict(model_config) + text_encoder_config = self.cfg.text_encoder_config + decoder_config = self.cfg.decoder_config + + if self.cfg.n_speakers > 1: + self.x_vector = XVector(self.cfg.out_channels, self.cfg.n_speakers) + self.x_vector_bottleneck = nn.Sequential(nn.Linear(512, self.cfg.gin_channels), nn.ReLU()) + + self.encoder = TextEncoder( + text_encoder_config, out_channels=self.cfg.out_channels, gin_channels=self.cfg.gin_channels + ) + + self.decoder = FlowDecoder( + decoder_config, in_channels=self.cfg.out_channels, gin_channels=self.cfg.gin_channels + ) + + self.asr_output = nn.Sequential() + + for i in range(self.cfg.phoneme_prediction_config.n_layers): + if i == 0: + in_channels = self.cfg.out_channels + else: + in_channels = self.cfg.phoneme_prediction_config.n_channels + if i < self.cfg.phoneme_prediction_config.n_layers - 1: + out_channels = self.cfg.phoneme_prediction_config.n_channels + else: + out_channels = self.cfg.label_target_size + 1 + + self.asr_output.append(nn.Linear(in_channels, out_channels)) + if i < self.cfg.phoneme_prediction_config.n_layers - 1: + self.asr_output.append(nn.ReLU()) + self.asr_output.append(nn.Dropout(self.cfg.phoneme_prediction_config.p_dropout)) + + self.specaug_start_epoch = self.cfg.specauc_start_epoch + + def forward( + self, x=None, x_lengths=None, raw_audio=None, raw_audio_lengths=None, g=None, recognition_input=None, noise_scale=1.0, length_scale=1.0 + ): + with torch.no_grad(): + squeezed_audio = torch.squeeze(raw_audio) + y, y_lengths = self.feature_extraction(squeezed_audio, raw_audio_lengths) # [B, T, F] + y = y.transpose(1, 2) # [B, F, T] + self.encoder.eval() + self.decoder.eval() + self.x_vector_bottleneck.eval() + self.x_vector.eval() + _, _, g = self.x_vector(y, y_lengths) + g = self.x_vector_bottleneck(g) + + y_max_length = y.size(2) + + y, y_lengths, y_max_length = self.preprocess(y, y_lengths, y_max_length) + z_mask = torch.unsqueeze(commons.sequence_mask(y_lengths, y_max_length), 1).to(torch.int32) + + x_m, x_logs, logw, x_mask = self.encoder(x, x_lengths, g=g) # mean, std logs, duration logs, mask + attn_mask = torch.unsqueeze(x_mask, -1) * torch.unsqueeze(z_mask, 2) + z, logdet = self.decoder(y, z_mask, g=g, reverse=False) + + x_s_sq_r = torch.exp(-2 * x_logs) + logp1 = torch.sum(-0.5 * math.log(2 * math.pi) - x_logs, [1]).unsqueeze(-1) # [b, t, 1] + logp2 = torch.matmul(x_s_sq_r.transpose(1, 2), -0.5 * (z**2)) # [b, t, d] x [b, d, t'] = [b, t, t'] + logp3 = torch.matmul((x_m * x_s_sq_r).transpose(1, 2), z) # [b, t, d] x [b, d, t'] = [b, t, t'] + logp4 = torch.sum(-0.5 * (x_m**2) * x_s_sq_r, [1]).unsqueeze(-1) # [b, t, 1] + logp = logp1 + logp2 + logp3 + logp4 # [b, t, t'] + + attn = maximum_path(logp, attn_mask.squeeze(1)).unsqueeze(1).detach() + # embed() + + z_m = torch.matmul(attn.squeeze(1).transpose(1, 2), x_m.transpose(1, 2)).transpose( + 1, 2 + ) # [b, t', t], [b, t, d] -> [b, d, t'] + z_logs = torch.matmul(attn.squeeze(1).transpose(1, 2), x_logs.transpose(1, 2)).transpose( + 1, 2 + ) # [b, t', t], [b, t, d] -> [b, d, t'] + + if recognition_input == "encoder": # TODO: This is wrong! + asr_in = z.transpose(1, 2) + else: + asr_in = ((z_m + torch.exp(z_logs) * torch.randn_like(z_m) * noise_scale) * z_mask).transpose(1,2) + + logits = self.asr_output(asr_in) + + return logits, y_lengths, z_mask, attn + + def preprocess(self, y, y_lengths, y_max_length): + if y_max_length is not None: + y_max_length = (y_max_length // self.cfg.decoder_config.n_sqz) * self.cfg.decoder_config.n_sqz + y = y[:, :, :y_max_length] + y_lengths = (y_lengths // self.cfg.decoder_config.n_sqz) * self.cfg.decoder_config.n_sqz + return y, y_lengths, y_max_length + + def store_inverse(self): + self.decoder.store_inverse() + + +def train_step(*, model: Model, data, run_ctx, **kwargs): + tags = data["seq_tag"] + audio_features = data["audio_features"] # [B, T, F] + # audio_features = audio_features.transpose(1, 2) # [B, F, T] necessary because glowTTS expects the channels to be in the 2nd dimension + audio_features_len = data["audio_features:size1"] # [B] + + # perform local length sorting for more efficient packing + audio_features_len, indices = torch.sort(audio_features_len, descending=True) + + audio_features = audio_features[indices, :, :] + phonemes = data["phonemes"][indices, :] # [B, T] (sparse) + phonemes_len = data["phonemes:size1"][indices] # [B, T] + phonemes_eow = data["phonemes_eow"][indices, :] # [B, T] + phonemes_eow_len = data["phonemes_eow:size1"][indices] + durations = data["durations"][indices] + tags = list(np.array(tags)[indices.detach().cpu().numpy()]) + + recognition_input = kwargs["recognition_input"] + logits, y_lengths, z_mask, attn = model( + phonemes, + phonemes_len, + audio_features, + audio_features_len, + recognition_input=recognition_input, + ) + + upsampled_phonemes = torch.matmul(attn.squeeze(1).transpose(1, 2), phonemes.float().unsqueeze(-1)).squeeze(-1) + + mask = commons.sequence_mask(y_lengths) + ce_losses = nn.functional.cross_entropy(logits.transpose(1, 2), upsampled_phonemes.long(), reduction="none") + ce_loss = (ce_losses * mask.float()).sum() / mask.float().sum() + + run_ctx.mark_as_loss(name="ce", loss=ce_loss) + + +def phoneme_prediction_init_hook(run_ctx, **kwargs): + run_ctx.hdf_writer = SimpleHDFWriter("output.hdf", dim=1, ndim=1) + run_ctx.pool = multiprocessing.Pool(8) + run_ctx.recognition_input = kwargs["recognition_input"] + + +def phoneme_prediction_finish_hook(run_ctx, **kwargs): + run_ctx.hdf_writer.close() + + +def phoneme_prediction_step(*, model: Model, data, run_ctx, **kwargs): + """ + :param Model model: _description_ + :param _type_ data: _description_ + :param _type_ run_ctx: _description_ + """ + tags = data["seq_tag"] + audio_features = data["audio_features"] # [B, T, F] + audio_features_len = data["audio_features:size1"] # [B] + + # perform local length sorting for more efficient packing + audio_features_len, indices = torch.sort(audio_features_len, descending=True) + audio_features = audio_features[indices, :, :] + phonemes = data["phonemes"][indices, :] # [B, T] (sparse) + phonemes_len = data["phonemes:size1"][indices] # [B, T] + durations = data["durations"][indices] + + speaker_labels = None # it is x-vector and during prediction the audio is available therefore g will be predicted + + tags = list(np.array(tags)[indices.detach().cpu().numpy()]) + + logits, y_lengths, z_mask, attn = model( + x=phonemes, + x_lengths=phonemes_len, + raw_audio=audio_features, + raw_audio_lengths=audio_features_len, + g=speaker_labels, + recognition_input=run_ctx.recognition_input, + ) + x_mask = torch.unsqueeze(commons.sequence_mask(phonemes_len, phonemes.size(1)), 1).to(phonemes.dtype) + + attn_mask = torch.unsqueeze(x_mask, -1) * torch.unsqueeze(z_mask, 2) + given_attn = commons.generate_path(durations.squeeze(1), attn_mask.squeeze(1)).unsqueeze(1) + + upsampled_phonemes = torch.matmul(given_attn.squeeze(1).transpose(1, 2), phonemes.unsqueeze(-1)).squeeze(-1) + + mask = commons.sequence_mask(y_lengths) + pred = torch.softmax(logits, dim=2).argmax(dim=2) + + accuracies = ( + (((pred == upsampled_phonemes) * mask).sum(dim=1) / y_lengths).unsqueeze(-1).unsqueeze(-1).detach().cpu() + ) + + for tag, acc in zip(tags, accuracies): + run_ctx.hdf_writer.insert_batch(np.array(acc), [1], [tag]) + + +# def search_init_hook(run_ctx, **kwargs): +# # we are storing durations, but call it output.hdf to match +# # the default output of the ReturnnForwardJob +# from torchaudio.models.decoder import ctc_decoder +# run_ctx.recognition_file = open("search_out.py", "wt") +# run_ctx.recognition_file.write("{\n") +# import subprocess +# if kwargs["arpa_lm"] is not None: +# lm = subprocess.check_output(["cf", kwargs["arpa_lm"]]).decode().strip() +# else: +# lm = None +# from returnn.datasets.util.vocabulary import Vocabulary +# vocab = Vocabulary.create_vocab( +# vocab_file=kwargs["returnn_vocab"], unknown_label=None) +# labels = vocab.labels + +# run_ctx.ctc_decoder = ctc_decoder( +# lexicon=kwargs["lexicon"], +# lm=lm, +# lm_weight=kwargs["lm_weight"], +# tokens=labels + ["[blank]", "[SILENCE]", "[UNK]"], +# # "[SILENCE]" and "[UNK]" are not actually part of the vocab, +# # but the decoder is happy as long they are defined in the token list +# # even if they do not exist as label index in the softmax output, +# blank_token="[blank]", +# sil_token="[SILENCE]", +# unk_word="[unknown]", +# nbest=1, +# beam_size=kwargs["beam_size"], +# beam_size_token=kwargs.get("beam_size_token", None), +# beam_threshold=kwargs["beam_threshold"], +# sil_score=kwargs.get("sil_score", 0.0), +# word_score=kwargs.get("word_score", 0.0), +# ) +# run_ctx.labels = labels +# run_ctx.blank_log_penalty = kwargs.get("blank_log_penalty", None) + +# if kwargs.get("prior_file", None): +# run_ctx.prior = np.loadtxt(kwargs["prior_file"], dtype="float32") +# run_ctx.prior_scale = kwargs["prior_scale"] +# else: +# run_ctx.prior = None + +# def search_finish_hook(run_ctx, **kwargs): +# run_ctx.recognition_file.write("}\n") +# run_ctx.recognition_file.close() + +# def search_step(*, model, data, run_ctx, **kwargs): +# raw_audio = data["raw_audio"] # [B, T', F] +# raw_audio_len = data["raw_audio:size1"] # [B] + +# logprobs, audio_features_len = model( +# raw_audio=raw_audio, +# raw_audio_lengths=raw_audio_len, +# recognition=True +# ) + +# tags = data["seq_tag"] + +# logprobs_cpu = logprobs.cpu() +# if run_ctx.blank_log_penalty is not None: +# # assumes blank is last +# logprobs_cpu[:, :, -1] -= run_ctx.blank_log_penalty +# if run_ctx.prior is not None: +# logprobs_cpu -= run_ctx.prior_scale * run_ctx.prior +# hypothesis = run_ctx.ctc_decoder(logprobs_cpu, audio_features_len.cpu()) + +# for hyp, tag in zip(hypothesis, tags): +# words = hyp[0].words +# sequence = " ".join([word for word in words if not word.startswith("[")]) +# print(sequence) +# run_ctx.recognition_file.write("%s: %s,\n" % (repr(tag), repr(sequence))) diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/pytorch_networks/frozen_glowtts/glowASR_conformer_x_vector.py b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/pytorch_networks/frozen_glowtts/glowASR_conformer_x_vector.py new file mode 100644 index 000000000..0d34a2d53 --- /dev/null +++ b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/pytorch_networks/frozen_glowtts/glowASR_conformer_x_vector.py @@ -0,0 +1,483 @@ +""" +Trying to make the aligner more AppTek-Like + +Extended weight init code +""" + +from dataclasses import dataclass +import torch +import numpy as np +from torch import nn +import multiprocessing +from librosa import filters +import sys +import time +from typing import Any, Dict, Optional, Tuple, Union +import math + +from torchaudio.functional import mask_along_axis + +from i6_models.parts.blstm import BlstmEncoderV1, BlstmEncoderV1Config + + +from i6_models.parts.conformer.norm import LayerNormNC +from i6_models.assemblies.conformer.conformer_v1 import ConformerEncoderV1Config +from i6_models.assemblies.conformer.conformer_v1 import ConformerBlockV1Config, ConformerEncoderV1 +from i6_models.config import ModuleFactoryV1 +from i6_models.parts.frontend.vgg_act import VGG4LayerActFrontendV1, VGG4LayerActFrontendV1Config + +from i6_models.parts.conformer.convolution import ConformerConvolutionV1Config +from i6_models.parts.conformer.feedforward import ConformerPositionwiseFeedForwardV1Config +from i6_models.parts.conformer.mhsa import ConformerMHSAV1Config +from i6_models.primitives.specaugment import specaugment_v1_by_length +from i6_models.primitives.feature_extraction import LogMelFeatureExtractionV1, LogMelFeatureExtractionV1Config + +from ..shared.configs import SpecaugConfig, ModelConfigV2, FlowDecoderConfig, ConformerASRConfig + + +from returnn.torch.context import get_run_ctx + +from ..shared.configs import DbMelFeatureExtractionConfig +from ..shared.feature_extraction import DbMelFeatureExtraction +from ..shared.spec_augment import apply_spec_aug +from ..shared.mask import mask_tensor + +from ..shared import modules +from ..shared import commons +from ..shared import attentions +from ..monotonic_align import maximum_path + +class XVector(nn.Module): + def __init__(self, input_dim=40, num_classes=8, **kwargs): + super(XVector, self).__init__() + self.tdnn1 = modules.TDNN( + input_dim=input_dim, + output_dim=512, + context_size=5, + dilation=1, + dropout_p=0.5, + batch_norm=True + ) + self.tdnn2 = modules.TDNN( + input_dim=512, output_dim=512, context_size=3, dilation=2, dropout_p=0.5, batch_norm=True + ) + self.tdnn3 = modules.TDNN( + input_dim=512, output_dim=512, context_size=2, dilation=3, dropout_p=0.5, batch_norm=True + ) + self.tdnn4 = modules.TDNN( + input_dim=512, output_dim=512, context_size=1, dilation=1, dropout_p=0.5, batch_norm=True + ) + self.tdnn5 = modules.TDNN( + input_dim=512, output_dim=512, context_size=1, dilation=1, dropout_p=0.5, batch_norm=True + ) + #### Frame levelPooling + self.segment6 = nn.Linear(1024, 512) + self.segment7 = nn.Linear(512, 512) + self.output = nn.Linear(512, num_classes) + self.softmax = nn.Softmax(dim=1) + + # fe_config = DbMelFeatureExtractionConfig.from_dict(kwargs["fe_config"]) + # self.feature_extraction = DbMelFeatureExtraction(config=fe_config) + + def forward(self, x, x_lengths): + # with torch.no_grad(): + # squeezed_audio = torch.squeeze(raw_audio) + # x, x_lengths = self.feature_extraction(squeezed_audio, raw_audio_lengths) # [B, T, F] + + # x = x.transpose(1, 2) + tdnn1_out = self.tdnn1(x) + # return tdnn1_out + tdnn2_out = self.tdnn2(tdnn1_out) + tdnn3_out = self.tdnn3(tdnn2_out) + tdnn4_out = self.tdnn4(tdnn3_out) + tdnn5_out = self.tdnn5(tdnn4_out) + ### Stat Pool + mean = torch.mean(tdnn5_out, 2) + std = torch.std(tdnn5_out, 2) + stat_pooling = torch.cat((mean, std), 1) + segment6_out = self.segment6(stat_pooling) + x_vec = self.segment7(segment6_out) + output = self.output(x_vec) + predictions = self.softmax(output) + return output, predictions, x_vec + +class FlowDecoder(nn.Module): + def __init__(self, cfg: FlowDecoderConfig, in_channels, gin_channels): + """Flow-based decoder model + + Args: + in_channels (int): Number of incoming channels + hidden_channels (int): Number of hidden channels + kernel_size (int): Kernel Size for convolutions in coupling blocks + dilation_rate (float): Dilation Rate to define dilation in convolutions of coupling block + n_blocks (int): Number of coupling blocks + n_layers (int): Number of layers in CNN of the coupling blocks + p_dropout (float, optional): Dropout probability for CNN in coupling blocks. Defaults to 0.. + n_split (int, optional): Number of splits for the 1x1 convolution for flows in the decoder. Defaults to 4. + n_sqz (int, optional): Squeeze. Defaults to 1. + sigmoid_scale (bool, optional): Boolean to define if log probs in coupling layers should be rescaled using sigmoid. Defaults to False. + gin_channels (int, optional): Number of speaker embedding channels. Defaults to 0. + """ + super().__init__() + self.cfg = cfg + + self.flows = nn.ModuleList() + + for _ in range(self.cfg.n_blocks): + self.flows.append(modules.ActNorm(channels=in_channels * self.cfg.n_sqz)) + self.flows.append(modules.InvConvNear(channels=in_channels * self.cfg.n_sqz, n_split=self.cfg.n_split)) + self.flows.append( + attentions.CouplingBlock( + in_channels * self.cfg.n_sqz, + self.cfg.hidden_channels, + kernel_size=self.cfg.kernel_size, + dilation_rate=self.cfg.dilation_rate, + n_layers=self.cfg.n_layers, + gin_channels=gin_channels, + p_dropout=self.cfg.p_dropout, + sigmoid_scale=self.cfg.sigmoid_scale, + ) + ) + + def forward(self, x, x_mask, g=None, reverse=False): + if not reverse: + flows = self.flows + logdet_tot = 0 + else: + flows = reversed(self.flows) + logdet_tot = None + + if g is not None: + g = g.unsqueeze(-1) + + if self.cfg.n_sqz > 1: + x, x_mask = commons.channel_squeeze(x, x_mask, self.cfg.n_sqz) + for f in flows: + if not reverse: + x, logdet = f(x, x_mask, g=g, reverse=reverse) + logdet_tot += logdet + else: + x, logdet = f(x, x_mask, g=g, reverse=reverse) + if self.cfg.n_sqz > 1: + x, x_mask = commons.channel_unsqueeze(x, x_mask, self.cfg.n_sqz) + return x, logdet_tot + + def store_inverse(self): + for f in self.flows: + f.store_inverse() + +class Model(nn.Module): + """ + Flow-based ASR model based on GlowTTS Structure using a pre-trained flow-based decoder + trained to generate spectrograms from given statistics coming from an encoder + + Model was pretrained using the architecture in + users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS.py + """ + + def __init__( + self, + model_config: ModelConfigV2, + # n_vocab: int, + # hidden_channels: int = 192, + # out_channels: int = 80, + # n_blocks_dec: int = 12, + # kernel_size_dec: int = 5, + # dilation_rate: int = 1, + # n_block_layers: int = 4, + # p_dropout: float = 0.1, + # p_dropout_flow: float = 0.05, + # gin_channels: int = 0, + # n_split: int = 4, + # n_sqz: int = 2, + # sigmoid_scale: bool = False, + # window_size: int = 4, + # block_length: int = None, + # hidden_channels_dec: int = None, + # label_target_size=None, + # spec_augment = False, + # layer_norm = False, + # batch_norm = False, + # n_speakers = 1, + **kwargs, + ): + """_summary_ + + Args: + n_vocab (int): vocabulary size + hidden_channels (int): Number of hidden channels in encoder + out_channels (int): Number of channels in the output + n_blocks_dec (int, optional): Number of coupling blocks in the decoder. Defaults to 12. + kernel_size_dec (int, optional): Kernel size in the decoder. Defaults to 5. + dilation_rate (int, optional): Dilation rate for CNNs of coupling blocks in decoder. Defaults to 5. + n_block_layers (int, optional): Number of layers in the CNN of the coupling blocks in decoder. Defaults to 4. + p_dropout_dec (_type_, optional): Dropout probability in the decoder. Defaults to 0.. + n_speakers (int, optional): Number of speakers. Defaults to 0. + gin_channels (int, optional): Number of speaker embedding channels. Defaults to 0. + n_split (int, optional): Number of splits for the 1x1 convolution for flows in the decoder. Defaults to 4. + n_sqz (int, optional): Squeeze. Defaults to 1. + sigmoid_scale (bool, optional): Boolean to define if log probs in coupling layers should be rescaled using sigmoid. Defaults to False. + window_size (int, optional): Window size in Multi-Head Self-Attention for encoder. Defaults to None. + block_length (_type_, optional): Block length for optional block masking in Multi-Head Attention for encoder. Defaults to None. + hidden_channels_dec (_type_, optional): Number of hidden channels in decodder. Defaults to hidden_channels. + final_hidden_channels: Number of hidden channels in the final network + final_n_layers: Number of layers in the final network + label_target_size: Target size of target vocabulary, target size for final network + """ + super().__init__() + # self.n_vocab = n_vocab + # self.hidden_channels = hidden_channels + # self.out_channels = out_channels + # self.n_blocks_dec = n_blocks_dec + # self.kernel_size_dec = kernel_size_dec + # self.dilation_rate = dilation_rate + # self.n_block_layers = n_block_layers + # self.p_dropout = p_dropout + # self.p_dropout_flow = p_dropout_flow + # self.n_split = n_split + # self.n_sqz = n_sqz + # self.sigmoid_scale = sigmoid_scale + # self.window_size = window_size + # self.block_length = block_length + # self.hidden_channels_dec = hidden_channels_dec + # self.spec_augment = spec_augment + # self.layer_norm = layer_norm + # self.batch_norm = batch_norm + + fe_config = DbMelFeatureExtractionConfig.from_dict(kwargs["fe_config"]) + self.feature_extraction = DbMelFeatureExtraction(config=fe_config) + + self.cfg = ModelConfigV2.from_dict(model_config) + text_encoder_config = self.cfg.text_encoder_config + decoder_config = self.cfg.decoder_config + + if self.cfg.n_speakers > 1: + self.x_vector = XVector(self.cfg.out_channels, self.cfg.n_speakers) + self.x_vector_bottleneck = nn.Sequential(nn.Linear(512, self.cfg.gin_channels), nn.ReLU()) + + # self.encoder = TextEncoder( + # text_encoder_config, out_channels=self.cfg.out_channels, gin_channels=self.cfg.gin_channels + # ) + + self.decoder = FlowDecoder( + decoder_config, in_channels=self.cfg.out_channels, gin_channels=self.cfg.gin_channels + ) + + if self.cfg.n_speakers > 1: + self.x_vector = XVector(self.cfg.out_channels, self.cfg.n_speakers) + self.x_vector_bottleneck = nn.Sequential(nn.Linear(512, self.cfg.gin_channels), nn.ReLU()) + + + # specaug_config = SpecaugConfig( + # repeat_per_n_frames=25, + # max_dim_time=20, + # max_dim_feat=16, + # num_repeat_feat=5, + # ) + + self.conf_cfg = self.cfg.phoneme_prediction_config + frontend_config = self.conf_cfg.frontend_config + conformer_size = self.conf_cfg.conformer_size + conformer_config = ConformerEncoderV1Config( + num_layers=self.conf_cfg.num_layers, + frontend=ModuleFactoryV1(module_class=VGG4LayerActFrontendV1, cfg=frontend_config), + block_cfg=ConformerBlockV1Config( + ff_cfg=ConformerPositionwiseFeedForwardV1Config( + input_dim=conformer_size, + hidden_dim=self.conf_cfg.ff_dim, + dropout=self.conf_cfg.ff_dropout, + activation=nn.functional.silu, + ), + mhsa_cfg=ConformerMHSAV1Config( + input_dim=conformer_size, + num_att_heads=self.conf_cfg.num_heads, + att_weights_dropout=self.conf_cfg.att_weights_dropout, + dropout=self.conf_cfg.mhsa_dropout, + ), + conv_cfg=ConformerConvolutionV1Config( + channels=conformer_size, kernel_size=self.conf_cfg.conv_kernel_size, dropout=self.conf_cfg.conv_dropout, activation=nn.functional.silu, + norm=LayerNormNC(conformer_size) + ), + ), + ) + + self.conformer = ConformerEncoderV1(cfg=conformer_config) + self.final_linear = nn.Linear(conformer_size, self.conf_cfg.label_target_size + 1) # + CTC blank + self.final_dropout = nn.Dropout(p=self.conf_cfg.final_dropout) + self.specaug_start_epoch = self.cfg.specauc_start_epoch + self.specaug_cfg = self.cfg.specaug_config + + def forward(self, raw_audio, raw_audio_len): + with torch.no_grad(): + self.x_vector.eval() + self.x_vector_bottleneck.eval() + self.decoder.eval() + squeezed_audio = torch.squeeze(raw_audio) + log_mel_features, log_mel_features_len = self.feature_extraction(squeezed_audio, raw_audio_len) # [B, T, F] + + audio_max_length = log_mel_features.size(1) + + flow_in = log_mel_features.transpose(1,2) # [B, F, T] + flow_in, flow_in_length, flow_in_max_length = self.preprocess(flow_in, log_mel_features_len, audio_max_length) + mask = torch.unsqueeze(commons.sequence_mask(log_mel_features_len, flow_in.size(2)), 1).to(flow_in.dtype) + + _, _, g = self.x_vector(log_mel_features.transpose(1,2), log_mel_features_len) + g = self.x_vector_bottleneck(g) + + flow_out, _ = self.decoder(flow_in, mask, g=g, reverse=False) # [B, F, T] + + spec_augment_in = flow_out.transpose(1,2) # [B, T, F] + mask = mask_tensor(spec_augment_in, flow_in_length) + + run_ctx = get_run_ctx() + if self.training and self.specaug_start_epoch is not None and run_ctx.epoch > self.specaug_start_epoch: + audio_features_masked_2 = apply_spec_aug( + spec_augment_in, + num_repeat_time=torch.max(log_mel_features_len).detach().cpu().numpy() + // self.cfg.specaug_config.repeat_per_n_frames, + max_dim_time=self.cfg.specaug_config.max_dim_time, + num_repeat_feat=self.cfg.specaug_config.num_repeat_feat, + max_dim_feat=self.cfg.specaug_config.max_dim_feat, + ) + else: + audio_features_masked_2 = spec_augment_in + + conformer_in = audio_features_masked_2 + + conformer_out, out_mask = self.conformer(conformer_in, mask) + conformer_out = self.final_dropout(conformer_out) + logits = self.final_linear(conformer_out) + + log_probs = torch.log_softmax(logits, dim=2) + + return log_probs, torch.sum(out_mask, dim=1) + + def preprocess(self, y, y_lengths, y_max_length): + if y_max_length is not None: + y_max_length = (y_max_length // self.cfg.decoder_config.n_sqz) * self.cfg.decoder_config.n_sqz + y = y[:, :, :y_max_length] + y_lengths = (y_lengths // self.cfg.decoder_config.n_sqz) * self.cfg.decoder_config.n_sqz + return y, y_lengths, y_max_length + + def store_inverse(self): + self.decoder.store_inverse() + + +def train_step(*, model: nn.Module, data, run_ctx, **kwargs): + raw_audio = data["audio_features"] # [B, T', F] + raw_audio_len = data["audio_features:size1"] # [B] + + phon_labels = data["phonemes_eow"] # [B, N] (sparse) + phon_labels_len = data["phonemes_eow:size1"] # [B, N] + + logprobs, audio_features_len = model( + raw_audio=raw_audio, + raw_audio_len=raw_audio_len, + ) + transposed_logprobs = torch.permute(logprobs, (1, 0, 2)) + ctc_loss = nn.functional.ctc_loss( + transposed_logprobs, + phon_labels, + input_lengths=audio_features_len, + target_lengths=phon_labels_len, + blank=model.cfg.label_target_size, + reduction="sum", + zero_infinity=True + ) + num_phonemes = torch.sum(phon_labels_len) + run_ctx.mark_as_loss(name="ctc", loss=ctc_loss, inv_norm_factor=num_phonemes) + + +def forward_init_hook(run_ctx, **kwargs): + # we are storing durations, but call it output.hdf to match + # the default output of the ReturnnForwardJob + from torchaudio.models.decoder import ctc_decoder + run_ctx.recognition_file = open("search_out.py", "wt") + run_ctx.recognition_file.write("{\n") + import subprocess + if kwargs["arpa_lm"] is not None: + lm = subprocess.check_output(["cf", kwargs["arpa_lm"]]).decode().strip() + else: + lm = None + from returnn.datasets.util.vocabulary import Vocabulary + vocab = Vocabulary.create_vocab( + vocab_file=kwargs["returnn_vocab"], unknown_label=None) + labels = vocab.labels + print(f"labels from vocab:{labels}") + if "asr_data" in kwargs.keys() and kwargs["asr_data"]: + print(f"Using ctc_decoder for ASR data...") + run_ctx.ctc_decoder = ctc_decoder( + lexicon=kwargs["lexicon"], + lm=lm, + lm_weight=kwargs["lm_weight"], + tokens=labels + ["[blank]", "[SILENCE]", "[UNK]"], + # "[SILENCE]" and "[UNK]" are not actually part of the vocab, + # but the decoder is happy as long they are defined in the token list + # even if they do not exist as label index in the softmax output, + blank_token="[blank]", + sil_token="[SILENCE]", + unk_word="[unknown]", + nbest=1, + beam_size=kwargs["beam_size"], + beam_size_token=kwargs.get("beam_size_token", None), + beam_threshold=kwargs["beam_threshold"], + sil_score=kwargs.get("sil_score", 0.0), + word_score=kwargs.get("word_score", 0.0), + ) + else: + print(f"Using ctc_decoder for TTS data...") + + run_ctx.ctc_decoder = ctc_decoder( + lexicon=kwargs["lexicon"], + lm=lm, + lm_weight=kwargs["lm_weight"], + tokens=labels, + blank_token="[blank]", + sil_token="[space]", # [space] is our actual silence + unk_word="[UNKNOWN]", + nbest=1, + beam_size=kwargs["beam_size"], + beam_threshold=kwargs["beam_threshold"], + sil_score=kwargs.get("sil_score", 0.0), + word_score=kwargs.get("word_score", 0.0), + ) + run_ctx.labels = labels + run_ctx.blank_log_penalty = kwargs.get("blank_log_penalty", None) + + if kwargs.get("prior_file", None): + run_ctx.prior = np.loadtxt(kwargs["prior_file"], dtype="float32") + run_ctx.prior_scale = kwargs["prior_scale"] + else: + run_ctx.prior = None + + +def forward_finish_hook(run_ctx, **kwargs): + run_ctx.recognition_file.write("}\n") + run_ctx.recognition_file.close() + + +def forward_step(*, model, data, run_ctx, **kwargs): + raw_audio = data["raw_audio"] # [B, T', F] + raw_audio_len = data["raw_audio:size1"] # [B] + logprobs, audio_features_len = model( + raw_audio=raw_audio, + raw_audio_len=raw_audio_len, + ) + + tags = data["seq_tag"] + + logprobs_cpu = logprobs.cpu() + if run_ctx.blank_log_penalty is not None: + # assumes blank is last + logprobs_cpu[:, :, -1] -= run_ctx.blank_log_penalty + if run_ctx.prior is not None: + logprobs_cpu -= run_ctx.prior_scale * run_ctx.prior + hypothesis = run_ctx.ctc_decoder(logprobs_cpu, audio_features_len.cpu()) + + for hyp, tag in zip(hypothesis, tags): + words = hyp[0].words + sequence = " ".join([word for word in words if not word.startswith("[")]) + print(sequence) + run_ctx.recognition_file.write("%s: %s,\n" % (repr(tag), repr(sequence))) + + diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/pytorch_networks/glowTTS.py b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/pytorch_networks/glowTTS.py index 0d095d95e..4ebb7b991 100644 --- a/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/pytorch_networks/glowTTS.py +++ b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/pytorch_networks/glowTTS.py @@ -18,6 +18,7 @@ from .shared.eval_forward import * +from .shared.eval_invertibility import * class DurationPredictor(nn.Module): """ diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/pytorch_networks/glowTTS_x_vector_v2.py b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/pytorch_networks/glowTTS_x_vector_v2.py index 1b88aede8..19577801f 100644 --- a/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/pytorch_networks/glowTTS_x_vector_v2.py +++ b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/pytorch_networks/glowTTS_x_vector_v2.py @@ -19,6 +19,7 @@ from .shared.configs import DbMelFeatureExtractionConfig, ModelConfigV1 from .shared.eval_forward import * +from .shared.eval_invertibility import * class XVector(nn.Module): diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/pytorch_networks/shared/configs.py b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/pytorch_networks/shared/configs.py index 9d4a920c6..1a6a1b009 100644 --- a/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/pytorch_networks/shared/configs.py +++ b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/pytorch_networks/shared/configs.py @@ -58,21 +58,6 @@ def from_dict(cls, d): return VGG4LayerActFrontendV1Config(**d) -@dataclass -class ConformerEncoderV1Config(ModelConfiguration): - """ - Attributes: - num_layers: Number of conformer layers in the conformer encoder - frontend: A pair of ConformerFrontend and corresponding config - block_cfg: Configuration for ConformerBlockV1 - """ - - num_layers: int - - # nested configurations - frontend: ModuleFactoryV1 - block_cfg: ConformerBlockV1Config - @dataclass class SpecaugConfig(ModelConfiguration): @@ -215,7 +200,27 @@ class PhonemePredictionConfigBLSTM(ModelConfiguration): def from_dict(cls, d): d = d.copy() return PhonemePredictionConfigBLSTM(**d) - + +@dataclass +class ConformerASRConfig(): + frontend_config: VGG4LayerActFrontendV1Config + label_target_size: int + conformer_size: int + num_layers: int + num_heads: int + ff_dim: int + att_weights_dropout: float + conv_dropout: float + ff_dropout: float + mhsa_dropout: float + conv_kernel_size: int + final_dropout: float + + @classmethod + def from_dict(cls, d): + d = d.copy() + d["frontend_config"] = VGG4LayerActFrontendV1Config_mod.from_dict(d["frontend_config"]) + return ConformerASRConfig(**d) @dataclass class ModelConfigV1: @@ -250,7 +255,7 @@ class ModelConfigV2: gin_channels: int n_speakers: Union[tk.Variable, int] specauc_start_epoch: Optional[int] = None - phoneme_prediction_config: Optional[Union[PhonemePredictionConfig, PhonemePredictionConfigCNN, PhonemePredictionConfigBLSTM]] = None + phoneme_prediction_config: Optional[Union[PhonemePredictionConfig, PhonemePredictionConfigCNN, PhonemePredictionConfigBLSTM, ConformerASRConfig]] = None specaug_config: Optional[SpecaugConfig] = None @classmethod @@ -272,6 +277,8 @@ def from_dict(cls, d): d["phoneme_prediction_config"] = PhonemePredictionConfigCNN.from_dict(d["phoneme_prediction_config"]) elif "subsampling_factor" in d["phoneme_prediction_config"].keys(): d["phoneme_prediction_config"] = PhonemePredictionConfigBLSTM.from_dict(d["phoneme_prediction_config"]) + elif "conformer_size" in d["phoneme_prediction_config"].keys(): + d["phoneme_prediction_config"] = ConformerASRConfig.from_dict(d["phoneme_prediction_config"]) else: d["phoneme_prediction_config"] = PhonemePredictionConfig.from_dict(d["phoneme_prediction_config"]) return ModelConfigV2(**d) diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/pytorch_networks/shared/eval_invertibility.py b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/pytorch_networks/shared/eval_invertibility.py new file mode 100644 index 000000000..3cdc198d0 --- /dev/null +++ b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/pytorch_networks/shared/eval_invertibility.py @@ -0,0 +1,90 @@ +import multiprocessing +import torch +import numpy as np +from returnn.datasets.hdf import SimpleHDFWriter +from . import commons + + +def forward_init_hook_invertibility(run_ctx, **kwargs): + run_ctx.total_mae = 0 + run_ctx.total_ae_var = 0 + run_ctx.total_ae_max = torch.tensor(-np.inf) + run_ctx.total_ae_min = torch.tensor(np.inf) + run_ctx.num_of_obs = 0 + + +def forward_finish_hook_invertibility(run_ctx, **kwargs): + with open("output.hdf", "w+") as f: + f.write("total, mean, var, max, min \n") + f.write( + f"{run_ctx.num_of_obs}, {str(float(run_ctx.total_mae))}, {str(float(run_ctx.total_ae_var))}, {str(float(run_ctx.total_ae_max))}, {str(float(run_ctx.total_ae_min))}" + ) + + +def forward_step_invertibility(*, model, data, run_ctx, **kwargs): + raw_audio = data["audio_features"] # [B, N] (sparse) + raw_audio_len = data["audio_features:size1"] # [B] + phonemes = data["phonemes"] + phonemes_len = data["phonemes:size1"] + + if "xvectors" in data: + g = data["xvectors"] + elif "speaker_labels" in data: + g = data["speaker_labels"] + else: + raise Exception("Missing speaker embedding!") + + squeezed_audio = torch.squeeze(raw_audio) + y, y_lengths = model.feature_extraction(squeezed_audio, raw_audio_len) # [B, T, F] + y = y.transpose(1, 2) # [B, F, T] + + if hasattr(model, "x_vector"): + _, _, g = model.x_vector(y, y_lengths) + + if hasattr(model, "x_vector_bottleneck"): + g = model.x_vector_bottleneck(g) + elif hasattr(model, "emb_g"): + g = torch.nn.functional.normalize(model.emb_g(g.squeeze(-1))).unsqueeze(-1) + else: + g = None + + y_max_length = y.size(2) + + y, y_lengths, y_max_length = model.preprocess(y, y_lengths, y_max_length) + z_mask = torch.unsqueeze(commons.sequence_mask(y_lengths, y_max_length), 1).to(torch.int32) + + z, _ = model.decoder(y, z_mask, g=g, reverse=False) + y_hat, _ = model.decoder(z, z_mask, g=g, reverse=True) + + mae = torch.nn.functional.l1_loss(y_hat * z_mask, y * z_mask, reduction="none") # [B, F, T] + + current_num_of_obs = y_hat.shape[1] * y_lengths.sum() # F * total_number_of_frames_in_batch + + old_mae = run_ctx.total_mae + + current_mae = ( + mae.sum() / current_num_of_obs + ) # This considers the masking by only using the mean over all unmasked elements + + current_var = (mae - current_mae).sum() / ( + current_num_of_obs - 1 + ) # Variance over unmasked elements with bias correction 1 + + run_ctx.total_mae = ((run_ctx.num_of_obs / (run_ctx.num_of_obs + current_num_of_obs)) * old_mae) + ( + (current_num_of_obs / (run_ctx.num_of_obs + current_num_of_obs)) * current_mae + ) + + run_ctx.total_ae_var = ( + (run_ctx.num_of_obs / (run_ctx.num_of_obs + current_num_of_obs)) * run_ctx.total_ae_var + + ((current_num_of_obs / (run_ctx.num_of_obs + current_num_of_obs)) * current_var) + + ((run_ctx.num_of_obs * current_num_of_obs) / (run_ctx.num_of_obs + current_num_of_obs) ** 2) + * (old_mae - current_mae) ** 2 + ) + + run_ctx.total_ae_max = torch.max(run_ctx.total_ae_max, mae.max()) + + run_ctx.total_ae_min = torch.min( + run_ctx.total_ae_min, (mae + (-1 * z_mask + 1) * torch.tensor(float("inf")).nan_to_num(0.0)).min() + ) # Masked Min operation + + run_ctx.num_of_obs += current_num_of_obs diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/storage.py b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/storage.py index 98f41b9b9..4d1e613e2 100644 --- a/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/storage.py +++ b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/storage.py @@ -1,7 +1,8 @@ from typing import Dict from dataclasses import dataclass from sisyphus import tk -from .pytorch_networks.shared.configs import ModelConfigV1 +from typing import Union +from .pytorch_networks.shared.configs import ModelConfigV1, ModelConfigV2 synthetic_ogg_zip_data = {} @@ -17,7 +18,7 @@ def add_duration(name: str, duration_hdf: tk.Path): @dataclass class TTSModel: - config: ModelConfigV1 + config: Union[ModelConfigV1, ModelConfigV2] checkpoint: tk.Path tts_models: Dict[str, TTSModel] = {} From 0818c70e69db643d1dbcb0f2cb44f6996e2e50da Mon Sep 17 00:00:00 2001 From: Lukas Rilling Date: Thu, 16 May 2024 12:26:04 +0200 Subject: [PATCH 026/227] Glow-TTS-ASR update --- .../evaluation/invertibility_eval.ipynb | 865 +++++ .../evaluation/phoneme_prediction_eval.ipynb | 456 +-- users/rilling/evaluation/swer_eval.ipynb | 353 +- users/rilling/evaluation/wer_eval.ipynb | 3275 ++++++++++++----- .../experiments.py | 66 +- .../glowTTS_ASR_conformer_two_forward_pass.py | 25 +- .../glowTTS_ASR_conformer_x_vector_v2.py | 26 +- .../training_comparison.ipynb | 72 +- .../librispeech_glow_asr/config.py | 44 + .../librispeech_glow_asr/experiments.py | 210 +- .../librispeech_glow_asr/pipeline.py | 30 + .../glowASR_blstm_frame_stack.py | 2 +- .../glowASR_blstm_frame_stack_v2.py | 2 +- .../glowASR_blstm_frame_stack_x_vector.py | 2 +- .../glowASR_blstm_frame_stack_x_vector_v2.py | 2 +- .../pytorch_networks/glowASR_conformer.py | 8 +- .../glowASR_conformer_no_freeze.py | 1 + ...lowASR_conformer_no_freeze_spec_augment.py | 1 + ...no_freeze_spec_augment_before_weak_conf.py | 298 ++ .../glowASR_conformer_no_pretrained.py | 2 +- .../pytorch_networks/glowASR_conformer_v2.py | 298 ++ .../only_blstm_frame_stack.py | 2 +- .../shared/eval_invertibility.py | 83 + .../librispeech_glow_asr/serializer.py | 22 + .../training_comparison.ipynb | 30 +- .../librispeech_joint_training/config.py | 47 + .../librispeech_joint_training/data.py | 13 +- .../librispeech_joint_training/experiments.py | 617 +++- .../librispeech_joint_training/pipeline.py | 34 + .../glowTTS_ASR_blstm_two_forward_pass.py | 632 ++++ .../glowTTS_ASR_blstm_x_vector.py | 679 ++++ .../glowTTS_ASR_conformer_two_forward_pass.py | 3 +- ...ASR_conformer_x_vector_two_forward_pass.py | 2 +- ..._conformer_x_vector_two_forward_pass_v2.py | 2 +- .../glowTTS_ASR_conformer_x_vector_v2.py | 3 +- .../pytorch_networks/glow_ASR_conformer.py | 2 +- .../glow_ASR_conformer_specaugment_before.py | 2 +- ...SR_conformer_specaugment_before_xvector.py | 2 +- ...conformer_specaugment_before_xvector_v2.py | 2 +- .../glow_ASR_conformer_xvector.py | 2 +- .../glow_ASR_conformer_xvector_eval.py | 2 +- .../pytorch_networks/only_conformer.py | 38 +- .../shared/eval_invertibility.py | 86 +- .../pytorch_networks/shared/forward.py | 7 +- ...6modelsV1_VGG4LayerActFrontendV1_v4_cfg.py | 23 + .../librispeech_joint_training/serializer.py | 19 + .../training_comparison.ipynb | 81 +- .../config.py | 49 + .../data.py | 13 +- .../exp_joint_2step/experiments.py | 38 +- .../exp_joint_2step/training_comparison.ipynb | 48 +- .../exp_tts/experiments.py | 157 +- .../exp_tts/training_comparison.ipynb | 996 ++--- .../pipeline.py | 39 +- .../glowASR_conformer_x_vector.py | 100 +- .../pytorch_networks/glowTTS.py | 2 + .../shared/eval_invertibility.py | 2 +- .../shared/feature_statistics.py | 65 + .../text_hdf/text_hdf_from_bliss.py | 4 +- users/rilling/speakers/pooling.py | 26 +- 60 files changed, 7642 insertions(+), 2370 deletions(-) create mode 100644 users/rilling/evaluation/invertibility_eval.ipynb create mode 100644 users/rilling/experiments/librispeech/librispeech_glow_asr/pytorch_networks/glowASR_conformer_no_freeze_spec_augment_before_weak_conf.py create mode 100644 users/rilling/experiments/librispeech/librispeech_glow_asr/pytorch_networks/glowASR_conformer_v2.py create mode 100644 users/rilling/experiments/librispeech/librispeech_glow_asr/pytorch_networks/shared/eval_invertibility.py create mode 100644 users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/glowTTS_ASR_blstm_two_forward_pass.py create mode 100644 users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/glowTTS_ASR_blstm_x_vector.py create mode 100644 users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/pytorch_networks/shared/feature_statistics.py diff --git a/users/rilling/evaluation/invertibility_eval.ipynb b/users/rilling/evaluation/invertibility_eval.ipynb new file mode 100644 index 000000000..95ea667d4 --- /dev/null +++ b/users/rilling/evaluation/invertibility_eval.ipynb @@ -0,0 +1,865 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import glob\n", + "import sys\n", + "import subprocess\n", + "import numpy as np\n", + "import pandas as pd\n", + "import os\n", + "\n", + "sys.path.append(\"/u/lukas.rilling/dev/\")\n", + "\n", + "from returnn_training_progress import get_epoch_data\n", + "from returnn_training_plot_nb import plot_df\n", + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "base_dir = \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/\"\n", + "accuracy_files = str(\n", + " subprocess.check_output(\n", + " f\"find {base_dir} -type l -name 'forward_invertibility' -not -path '*/lm*'\",\n", + " shell=True,\n", + " ),\n", + " \"utf-8\",\n", + ").split(\"\\n\")[:-1]" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
totalmeanvarmaxminGroupPath
02443905600.6181952.617023e+052.852016e+060.0librispeech_glow_asr/u/lukas.rilling/experiments/glow_tts_asr_v2/a...
02443905600.0000012.096195e-122.357960e-040.0librispeech_glow_asr/u/lukas.rilling/experiments/glow_tts_asr_v2/a...
02443905600.0399575.573043e-021.344167e+030.0librispeech_glow_asr/u/lukas.rilling/experiments/glow_tts_asr_v2/a...
02443905600.0000232.390446e-093.259611e-020.0librispeech_glow_asr/u/lukas.rilling/experiments/glow_tts_asr_v2/a...
02443905600.0420551.417796e-025.968618e+020.0joint_training/default/u/lukas.rilling/experiments/glow_tts_asr_v2/a...
\n", + "
" + ], + "text/plain": [ + " total mean var max min \\\n", + "0 244390560 0.618195 2.617023e+05 2.852016e+06 0.0 \n", + "0 244390560 0.000001 2.096195e-12 2.357960e-04 0.0 \n", + "0 244390560 0.039957 5.573043e-02 1.344167e+03 0.0 \n", + "0 244390560 0.000023 2.390446e-09 3.259611e-02 0.0 \n", + "0 244390560 0.042055 1.417796e-02 5.968618e+02 0.0 \n", + "\n", + " Group Path \n", + "0 librispeech_glow_asr /u/lukas.rilling/experiments/glow_tts_asr_v2/a... \n", + "0 librispeech_glow_asr /u/lukas.rilling/experiments/glow_tts_asr_v2/a... \n", + "0 librispeech_glow_asr /u/lukas.rilling/experiments/glow_tts_asr_v2/a... \n", + "0 librispeech_glow_asr /u/lukas.rilling/experiments/glow_tts_asr_v2/a... \n", + "0 joint_training/default /u/lukas.rilling/experiments/glow_tts_asr_v2/a... " + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "experiment_group = []\n", + "paths = []\n", + "df = None\n", + "for i,f in enumerate(accuracy_files):\n", + " filename = f + \"/output/output.hdf\"\n", + " if os.path.exists(filename):\n", + " if df is None:\n", + " df = pd.read_csv(filename)\n", + " else:\n", + " df2 = pd.read_csv(filename)\n", + " df = pd.concat([df, df2])\n", + " \n", + " folders = [\"librispeech_glow_asr\", \"joint_training/default\", \"joint_training/conformer_coupling\", \"joint_training/given_alignments\"]\n", + " found = False\n", + " for folder in folders:\n", + " if folder in f:\n", + " experiment_group.append(folder)\n", + " found = True\n", + " break\n", + " paths.append(f.replace(\"forward_invertibility/invertibility\", \"\").replace(\"/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech\", \"\"))\n", + " assert len(paths) == len(experiment_group), f\"Can't find this experiment group: {f}\"\n", + "\n", + "assert len(paths) == len(experiment_group), f\"Well wer has length: {len(accuracies)} and experiment_group has length {len(experiment_group)}\"\n", + "df[\"Group\"] = experiment_group\n", + "df[\"Path\"] = paths\n", + "df.head(5)\n", + "\n", + "# accuracy_files" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "df[\"Name\"] = df[\"Path\"].str.removeprefix(\"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech\")\n", + "df.rename(columns=lambda x: x.strip(), inplace=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "| | Group | Name | mean | var | min | max |\n", + "|---:|:--------------------------------|:---------------------------------------------------------------------------------------------------------------------------|------------:|-----------------:|------:|---------------:|\n", + "| 0 | librispeech_glow_asr | /librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment_before/glow_not_pretrained/forward_invertibility | 0.618195 | 261702 | 0 | 2.85202e+06 |\n", + "| 0 | librispeech_glow_asr | /librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/forward_invertibility | 1.04137e-06 | 2.09619e-12 | 0 | 0.000235796 |\n", + "| 0 | librispeech_glow_asr | /librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/forward_invertibility | 0.0399574 | 0.0557304 | 0 | 1344.17 |\n", + "| 0 | librispeech_glow_asr | /librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/forward_invertibility | 2.25829e-05 | 2.39045e-09 | 0 | 0.0325961 |\n", + "| 0 | joint_training/default | /joint_training/default/raw_audio/glow_ASR_conformer/forward_invertibility | 0.0420548 | 0.014178 | 0 | 596.862 |\n", + "| 0 | joint_training/default | /joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/forward_invertibility | 1.92626e-07 | 3.00763e-14 | 0 | 9.05991e-06 |\n", + "| 0 | joint_training/default | /joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/forward_invertibility | 0.278556 | 5.73934 | 0 | 7504.17 |\n", + "| 0 | joint_training/default | /joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/forward_invertibility | 2.07554e-07 | 3.50488e-14 | 0 | 5.96046e-06 |\n", + "| 0 | joint_training/default | /joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/forward_invertibility | 2.37935e-07 | 4.92569e-14 | 0 | 5.48363e-06 |\n", + "| 0 | joint_training/default | /joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/forward_invertibility | 2.78031e-07 | 5.60585e-14 | 0 | 1.40667e-05 |\n", + "| 0 | joint_training/default | /joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_ctc_scale_0.1/forward_invertibility | 1.8688e-07 | 2.94753e-14 | 0 | 6.91414e-06 |\n", + "| 0 | joint_training/given_alignments | /joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/200ep/dec_drop_0.05/forward_invertibility | 2.50928e-07 | 5.20072e-14 | 0 | 8.10623e-06 |\n", + "| 0 | joint_training/given_alignments | /joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/200ep/dec_drop_0.05/forward_invertibility | 2.27961e-07 | 4.0735e-14 | 0 | 8.34465e-06 |\n" + ] + } + ], + "source": [ + "print(df[[\"Group\", \"Name\", \"mean\", \"var\", \"min\", \"max\"]].to_markdown())" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'accuracies' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[6], line 3\u001b[0m\n\u001b[1;32m 1\u001b[0m index \u001b[38;5;241m=\u001b[39m pd\u001b[38;5;241m.\u001b[39mMultiIndex\u001b[38;5;241m.\u001b[39mfrom_arrays([experiment_group, accuracy_files], names\u001b[38;5;241m=\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mGroup\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mExperiment\u001b[39m\u001b[38;5;124m\"\u001b[39m))\n\u001b[0;32m----> 3\u001b[0m df \u001b[38;5;241m=\u001b[39m pd\u001b[38;5;241m.\u001b[39mDataFrame({\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mAccuracy\u001b[39m\u001b[38;5;124m\"\u001b[39m: \u001b[43maccuracies\u001b[49m}, index\u001b[38;5;241m=\u001b[39mindex)\n\u001b[1;32m 4\u001b[0m df[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mAccuracy [\u001b[39m\u001b[38;5;124m%\u001b[39m\u001b[38;5;124m]\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m df[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mAccuracy\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m*\u001b[39m \u001b[38;5;241m100\u001b[39m\n\u001b[1;32m 5\u001b[0m df[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mAccuracy [\u001b[39m\u001b[38;5;124m%\u001b[39m\u001b[38;5;124m]\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m df[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mAccuracy [\u001b[39m\u001b[38;5;124m%\u001b[39m\u001b[38;5;124m]\u001b[39m\u001b[38;5;124m\"\u001b[39m]\u001b[38;5;241m.\u001b[39mround(decimals\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m2\u001b[39m)\n", + "\u001b[0;31mNameError\u001b[0m: name 'accuracies' is not defined" + ] + } + ], + "source": [ + "index = pd.MultiIndex.from_arrays([experiment_group, accuracy_files], names=(\"Group\", \"Experiment\"))\n", + "\n", + "df = pd.DataFrame({\"Accuracy\": accuracies}, index=index)\n", + "df[\"Accuracy [%]\"] = df[\"Accuracy\"] * 100\n", + "df[\"Accuracy [%]\"] = df[\"Accuracy [%]\"].round(decimals=2)\n", + "df = df.drop(\"Accuracy\", axis=1)\n", + "df.head(5)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Accuracy [%]CEdev CEMLEDPJointStill runningoverfittingTraining data available
GroupExperiment
joint_training/given_alignments/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_simple_encoder_x_vector/200ep/basic_init/no_specaug/tts_target_size/ce_ls_0.1/21.302.9205852.941674-0.7972840.957548TrueFalse1.007221True
/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/specaug/ce_ls_0.1/26.492.8684202.858513-0.8028360.434087TrueFalse0.996546True
/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/specaug/ce_ls_1/27.302.6643962.957262-0.721080.747725TrueFalse1.109919True
/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/200ep/basic_init/no_specaug/tts_target_size/ce_ls_0.1/30.092.7822692.795637-0.7854920.890597TrueFalse1.004805True
/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/200ep/tts_pretrained/no_specaug/tts_target_size/ce_ls_0.1/28.562.8135272.825326-0.8037160.439343TrueFalse1.004194True
\n", + "
" + ], + "text/plain": [ + " Accuracy [%] \\\n", + "Group Experiment \n", + "joint_training/given_alignments /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 21.30 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 26.49 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 27.30 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 30.09 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 28.56 \n", + "\n", + " CE \\\n", + "Group Experiment \n", + "joint_training/given_alignments /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 2.920585 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 2.868420 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 2.664396 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 2.782269 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 2.813527 \n", + "\n", + " dev CE \\\n", + "Group Experiment \n", + "joint_training/given_alignments /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 2.941674 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 2.858513 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 2.957262 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 2.795637 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 2.825326 \n", + "\n", + " MLE \\\n", + "Group Experiment \n", + "joint_training/given_alignments /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.797284 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.802836 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.72108 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.785492 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.803716 \n", + "\n", + " DP \\\n", + "Group Experiment \n", + "joint_training/given_alignments /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.957548 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.434087 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.747725 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.890597 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.439343 \n", + "\n", + " Joint \\\n", + "Group Experiment \n", + "joint_training/given_alignments /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... True \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... True \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... True \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... True \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... True \n", + "\n", + " Still running \\\n", + "Group Experiment \n", + "joint_training/given_alignments /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False \n", + "\n", + " overfitting \\\n", + "Group Experiment \n", + "joint_training/given_alignments /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 1.007221 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.996546 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 1.109919 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 1.004805 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 1.004194 \n", + "\n", + " Training data available \n", + "Group Experiment \n", + "joint_training/given_alignments /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... True \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... True \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... True \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... True \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... True " + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ce_scores = []\n", + "ce_dev_scores = []\n", + "overfitting = []\n", + "mle_scores = []\n", + "dp_scores = []\n", + "lr = []\n", + "finished = []\n", + "joint = []\n", + "for index, series in df.iterrows():\n", + " data = get_epoch_data((f\"{index[1]}training/work/learning_rates\").replace(\"output\", \"alias\"), None)\n", + " breakpoint()\n", + " if data is None or \"ce\" not in data[list(data.keys())[-1]][\"error\"]:\n", + " if data is None:\n", + " finished.append(True)\n", + " else:\n", + " finished.append(False)\n", + " ce_scores.append(np.nan)\n", + " ce_dev_scores.append(np.nan)\n", + " mle_scores.append(np.nan)\n", + " dp_scores.append(np.nan)\n", + " overfitting.append(np.nan)\n", + " else:\n", + " last_epoch_data = data[list(data.keys())[-1]]\n", + " finished.append(True)\n", + " ce_scores.append(last_epoch_data[\"error\"][\"ce\"])\n", + " ce_dev_scores.append(last_epoch_data[\"error\"][\"dev_loss_ce\"])\n", + " overfitting.append(ce_dev_scores[-1] / ce_scores[-1])\n", + "\n", + " if \"mle\" in last_epoch_data[\"error\"]:\n", + " mle_scores.append(last_epoch_data[\"error\"][\"mle\"])\n", + " dp_scores.append(last_epoch_data[\"error\"][\"dp\"])\n", + " else:\n", + " mle_scores.append(\"-\")\n", + " dp_scores.append(\"-\")\n", + "\n", + "df[\"CE\"] = ce_scores\n", + "df[\"dev CE\"] = ce_dev_scores\n", + "df[\"MLE\"] = mle_scores\n", + "df[\"DP\"] = dp_scores\n", + "df[\"Joint\"] = [True if x != \"-\" and x != False else False for x in mle_scores]\n", + "df[\"Still running\"] = [not x for x in finished]\n", + "df[\"overfitting\"] = overfitting\n", + "df[\"Training data available\"] = df[\"CE\"] != np.nan\n", + "\n", + "df.head(5)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:root:Settings file 'settings.py' does not exist, ignoring it ([Errno 2] No such file or directory: 'settings.py').\n" + ] + } + ], + "source": [ + "from returnn.config import Config as ReturnnConfig\n", + "\n", + "df_indexed = df.reset_index()\n", + "\n", + "returnn_configs = []\n", + "for i in df_indexed.itertuples():\n", + " experiment_path = i[2]\n", + " returnn_config_path = experiment_path.replace(\"output\", \"alias\") + \"training/output/returnn.config\"\n", + " returnn_configs.append(ReturnnConfig())\n", + " try:\n", + " returnn_configs[-1].load_file(returnn_config_path)\n", + " except AssertionError:\n", + " returnn_configs[-1] = False" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "lr = []\n", + "num_epochs = []\n", + "asr_model_type = []\n", + "\n", + "for i in df_indexed.itertuples():\n", + " if returnn_configs[i[0]]:\n", + " if returnn_configs[i[0]].has(\"learning_rates\"):\n", + " learning_rates = np.array(eval(returnn_configs[i[0]].value(\"learning_rates\", \"default\")))\n", + " lr_argmax = learning_rates.argmax()\n", + " lr.append(\n", + " f\"[0: {learning_rates[0]}, {lr_argmax}: {learning_rates[lr_argmax]}, {lr_argmax + 1}: {learning_rates[lr_argmax + 1]}, {returnn_configs[i[0]].value('num_epochs', '-')}: {learning_rates[-1]}]\"\n", + " )\n", + " elif returnn_configs[i[0]].has(\"learning_rate\"):\n", + " lr.append(returnn_configs[i[0]].value(\"learning_rate\", \"-\"))\n", + " else:\n", + " lr.append(\"-\")\n", + "\n", + " num_epochs.append(int(returnn_configs[i[0]].value(\"num_epochs\", \"-\")))\n", + " else:\n", + " lr.append(\"-\")\n", + " num_epochs.append(\"-\")\n", + "\n", + " if \"conformer\" in i[2]:\n", + " asr_model_type.append(\"conformer\")\n", + " elif \"blstm\" in i[2]:\n", + " asr_model_type.append(\"blstm\")\n", + " else:\n", + " asr_model_type.append(\"unknown\")\n", + "\n", + "df_indexed[\"Num Epochs\"] = num_epochs\n", + "df_indexed[\"LR\"] = lr\n", + "df_indexed[\"ASR Model Type\"] = asr_model_type" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "df_indexed[\"CE loss scale\"] = df_indexed.apply(lambda x: float(x[\"Experiment\"].split(\"/ce_ls_\")[1].split(\"/\")[0] if \"/ce_ls_\" in x[\"Experiment\"] else np.nan), axis=1)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
GroupExperimentAccuracy [%]CEdev CEMLEDPJointStill runningoverfittingTraining data availableNum EpochsLRASR Model TypeCE loss scale
0joint_training/given_alignments/u/lukas.rilling/experiments/glow_tts_asr_v2/o...21.302.9212.942-0.7970.958TrueFalse1.007True200.0[0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05]unknown0.1
1joint_training/given_alignments/u/lukas.rilling/experiments/glow_tts_asr_v2/o...26.492.8682.859-0.8030.434TrueFalse0.997True250.0[0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08]unknown0.1
2joint_training/given_alignments/u/lukas.rilling/experiments/glow_tts_asr_v2/o...27.302.6642.957-0.7210.748TrueFalse1.11True250.0[0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08]unknown1.0
3joint_training/given_alignments/u/lukas.rilling/experiments/glow_tts_asr_v2/o...30.092.7822.796-0.7850.891TrueFalse1.005True200.0[0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05]unknown0.1
4joint_training/given_alignments/u/lukas.rilling/experiments/glow_tts_asr_v2/o...28.562.8142.825-0.8040.439TrueFalse1.004True200.0[0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05]unknown0.1
\n", + "
" + ], + "text/plain": [ + " Group \\\n", + "0 joint_training/given_alignments \n", + "1 joint_training/given_alignments \n", + "2 joint_training/given_alignments \n", + "3 joint_training/given_alignments \n", + "4 joint_training/given_alignments \n", + "\n", + " Experiment Accuracy [%] CE \\\n", + "0 /u/lukas.rilling/experiments/glow_tts_asr_v2/o... 21.30 2.921 \n", + "1 /u/lukas.rilling/experiments/glow_tts_asr_v2/o... 26.49 2.868 \n", + "2 /u/lukas.rilling/experiments/glow_tts_asr_v2/o... 27.30 2.664 \n", + "3 /u/lukas.rilling/experiments/glow_tts_asr_v2/o... 30.09 2.782 \n", + "4 /u/lukas.rilling/experiments/glow_tts_asr_v2/o... 28.56 2.814 \n", + "\n", + " dev CE MLE DP Joint Still running overfitting \\\n", + "0 2.942 -0.797 0.958 True False 1.007 \n", + "1 2.859 -0.803 0.434 True False 0.997 \n", + "2 2.957 -0.721 0.748 True False 1.11 \n", + "3 2.796 -0.785 0.891 True False 1.005 \n", + "4 2.825 -0.804 0.439 True False 1.004 \n", + "\n", + " Training data available Num Epochs \\\n", + "0 True 200.0 \n", + "1 True 250.0 \n", + "2 True 250.0 \n", + "3 True 200.0 \n", + "4 True 200.0 \n", + "\n", + " LR ASR Model Type \\\n", + "0 [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] unknown \n", + "1 [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] unknown \n", + "2 [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] unknown \n", + "3 [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] unknown \n", + "4 [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] unknown \n", + "\n", + " CE loss scale \n", + "0 0.1 \n", + "1 0.1 \n", + "2 1.0 \n", + "3 0.1 \n", + "4 0.1 " + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df_rounded = df_indexed.replace(\"-\", np.nan).round(decimals=3).fillna(\"-\")\n", + "df_rounded.head(5)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "| | Group | Experiment | Accuracy [%] | CE | dev CE | MLE | DP | Joint | Still running | overfitting | Training data available | Num Epochs | LR | ASR Model Type | CE loss scale |\n", + "|---:|:--------------------------------|:-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------------:|:------|:---------|:-------|:------|:--------|:----------------|:--------------|:--------------------------|:-------------|:-------------------------------------------------|:-----------------|:----------------|\n", + "| 0 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_simple_encoder_x_vector/200ep/basic_init/no_specaug/tts_target_size/ce_ls_0.1/ | 21.3 | 2.921 | 2.942 | -0.797 | 0.958 | True | False | 1.007 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", + "| 1 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/specaug/ce_ls_0.1/ | 26.49 | 2.868 | 2.859 | -0.803 | 0.434 | True | False | 0.997 | True | 250.0 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | unknown | 0.1 |\n", + "| 2 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/specaug/ce_ls_1/ | 27.3 | 2.664 | 2.957 | -0.721 | 0.748 | True | False | 1.11 | True | 250.0 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | unknown | 1.0 |\n", + "| 3 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/200ep/basic_init/no_specaug/tts_target_size/ce_ls_0.1/ | 30.09 | 2.782 | 2.796 | -0.785 | 0.891 | True | False | 1.005 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", + "| 4 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/200ep/tts_pretrained/no_specaug/tts_target_size/ce_ls_0.1/ | 28.56 | 2.814 | 2.825 | -0.804 | 0.439 | True | False | 1.004 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", + "| 5 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/no_specaug/ce_ls_1/ | 27.72 | 2.532 | 2.992 | -0.691 | 0.76 | True | False | 1.182 | True | 250.0 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | unknown | 1.0 |\n", + "| 6 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/no_specaug/ce_ls_0.1/ | 30.44 | 2.793 | 2.791 | -0.795 | 0.506 | True | False | 1.0 | True | 250.0 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | unknown | 0.1 |\n", + "| 7 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_cnn_x_vector/tts_pretrained/no_specaug/tts_target_size/ce_ls_0.1/ | 28.92 | 2.564 | 2.893 | -0.793 | 0.396 | True | False | 1.128 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", + "| 8 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_cnn_x_vector/basic_init/no_specaug/tts_target_size/ce_ls_0.1/ | 27.3 | 2.573 | 2.942 | -0.776 | 0.432 | True | False | 1.143 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", + "| 9 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/mean_only/200ep/basic_init/no_specaug/tts_target_size/ce_ls_0.1/ | 22.6 | 2.922 | 2.923 | -0.804 | 0.932 | True | False | 1.0 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", + "| 10 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/200ep/tts_pretrained/no_specaug/tts_target_size/ce_ls_0.1/ | 23.4 | 2.879 | 2.887 | -0.806 | 0.626 | True | False | 1.003 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", + "| 11 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/no_specaug/tts_target_size/ce_ls_1.0/ | 22.24 | 2.923 | 2.924 | -0.801 | 0.835 | True | False | 1.0 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 1.0 |\n", + "| 12 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/no_specaug/tts_target_size/ce_ls_0.1/ | 22.76 | 2.924 | 2.934 | -0.8 | 0.818 | True | False | 1.004 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", + "| 13 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_blstm_x_vector/specaug/ce_ls_1/ | 35.97 | 1.395 | 2.544 | -0.66 | 0.303 | True | False | 1.824 | True | 250.0 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | blstm | 1.0 |\n", + "| 14 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_blstm_x_vector/specaug/ce_ls_0.1/ | 36.7 | 1.672 | 2.312 | -0.774 | 1.02 | True | False | 1.383 | True | 250.0 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | blstm | 0.1 |\n", + "| 15 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_blstm_x_vector/no_specaug/ce_ls_1/ | 34.25 | 1.042 | 3.15 | -0.69 | 0.352 | True | False | 3.023 | True | 250.0 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | blstm | 1.0 |\n", + "| 16 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_blstm_x_vector/no_specaug/ce_ls_0.1/ | 33.05 | 1.031 | 3.339 | -0.786 | 0.368 | True | False | 3.239 | True | 250.0 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | blstm | 0.1 |\n", + "| 17 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/first_step/ga_glowTTS_ASR_ffn_x_vector_v2/ce_ls_4.0/ | 28.56 | 0.003 | 0.003 | -0.702 | 0.075 | True | False | 0.948 | True | 100.0 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | unknown | 4.0 |\n", + "| 18 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/first_step/ga_glowTTS_ASR_ffn_x_vector_v2/ce_ls_3.0/ | 20.47 | 0.004 | 0.004 | -0.703 | 0.075 | True | False | 0.954 | True | 100.0 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | unknown | 3.0 |\n", + "| 19 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/first_step/ga_glowTTS_ASR_ffn_x_vector_v2/ce_ls_2.0/ | 20.38 | 0.006 | 0.006 | -0.708 | 0.075 | True | False | 1.018 | True | 100.0 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | unknown | 2.0 |\n", + "| 20 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/first_step/ga_glowTTS_ASR_ffn_x_vector_v2/ce_ls_1.0/ | 20.45 | 0.012 | 0.012 | -0.716 | 0.075 | True | False | 0.98 | True | 100.0 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | unknown | 1.0 |\n", + "| 21 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_mas/100ep/encoder/decoder_eval/ | 37.48 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 22 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_mas/100ep/encoder/encoder_eval/ | 37.57 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 23 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector/100ep/encoder/decoder_eval/ | 12.68 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 24 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector/100ep/encoder/encoder_eval/ | 42.05 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 25 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector/100ep/decoder/encoder_eval/ | 19.16 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 26 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector/100ep/decoder/decoder_eval/ | 19.96 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 27 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn/100ep/encoder/encoder_eval/ | 44.63 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 28 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn/100ep/encoder/decoder_eval/ | 12.24 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 29 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn/100ep/decoder/decoder_eval/ | 19.94 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 30 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn/100ep/decoder/encoder_eval/ | 18.49 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 31 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn_x_vector/100ep/encoder/encoder_eval/ | 70.57 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 32 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn_x_vector/100ep/encoder/decoder_eval/ | 11.4 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 33 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn_x_vector/100ep/decoder/encoder_eval/ | 22.76 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 34 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn_x_vector/100ep/decoder/decoder_eval/ | 21.33 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 35 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector_mas/100ep/encoder/decoder_eval/ | 12.72 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 36 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector_mas/100ep/encoder/encoder_eval/ | 12.68 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 37 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector_mas/100ep/decoder/decoder_eval/ | 12.73 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 38 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector_mas/100ep/decoder/encoder_eval/ | 12.71 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 39 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn/100ep/decoder/decoder_eval/ | 21.3 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 40 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn/100ep/decoder/encoder_eval/ | 22.09 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 41 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn/100ep/encoder/decoder_eval/ | 11.33 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 42 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn/100ep/encoder/encoder_eval/ | 72.13 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 43 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_mas_no_eval/100ep/decoder/decoder_eval/ | 37.64 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 44 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_mas_no_eval/100ep/decoder/encoder_eval/ | 37.46 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 45 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_mas_no_eval/100ep/encoder/decoder_eval/ | 37.51 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 46 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_mas_no_eval/100ep/encoder/encoder_eval/ | 37.56 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 47 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector_v2/tts_pretrained/ce_ls_0.1/ | 20.29 | 0.052 | 0.047 | -0.791 | 0.052 | True | False | 0.9 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", + "| 48 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector_v2/tts_pretrained/ce_ls_0.01/ | 19.98 | 0.372 | 0.338 | -0.797 | 0.063 | True | False | 0.91 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.01 |\n", + "| 49 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector_v2/basic_init/ce_ls_0.1/ | 20.32 | 0.052 | 0.048 | -0.783 | 0.052 | True | False | 0.916 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", + "| 50 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector_v2/basic_init/ce_ls_0.01/ | 19.97 | 0.341 | 0.308 | -0.787 | 0.064 | True | False | 0.903 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.01 |\n", + "| 51 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step_tts/ga_glowTTS_ASR_ffn_x_vector_v2_2ndstep_tts/ce_ls_1.0/ | 20.18 | - | - | - | - | True | True | - | True | 100.0 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | unknown | 1.0 |\n", + "| 52 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector_v2/200ep/tts_pretrained/ce_ls_1.0/ | 20.42 | 0.014 | 0.014 | -0.729 | 0.076 | True | False | 1.049 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 1.0 |\n", + "| 53 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector_v2/200ep/tts_pretrained/ce_ls_0.1/ | 20.22 | 0.14 | 0.14 | -0.76 | 0.075 | True | False | 0.995 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", + "| 54 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/ce_ls_1.0/ | 20.48 | 0.012 | 0.011 | -0.73 | 0.07 | True | False | 0.965 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 1.0 |\n", + "| 55 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/ce_ls_0.1/ | 20.71 | 0.124 | 0.122 | -0.757 | 0.071 | True | False | 0.983 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", + "| 56 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector/200ep/basic_init/ce_ls_0.1/ | 21.39 | 2.921 | 2.947 | -0.779 | 0.256 | True | False | 1.009 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", + "| 57 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector/200ep/tts_pretrained/ce_ls_0.1/ | 21.33 | 2.925 | 2.946 | -0.792 | 0.247 | True | False | 1.007 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", + "| 58 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector/tts_pretrained/ce_ls_0.1/ | 27.63 | 2.617 | 2.915 | -0.775 | 0.263 | True | False | 1.114 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", + "| 59 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector/basic_init/ce_ls_0.1/ | 25.67 | 2.583 | 3.019 | -0.767 | 0.265 | True | False | 1.169 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", + "| 60 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step/ga_glowTTS_ASR_ffn_x_vector_v2_2ndstep/ce_ls_1.0/ | 21.61 | 2.939 | 2.947 | - | - | False | False | 1.003 | True | 100.0 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | unknown | 1.0 |\n" + ] + } + ], + "source": [ + "print(df_rounded.to_markdown())" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "sis_env", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/users/rilling/evaluation/phoneme_prediction_eval.ipynb b/users/rilling/evaluation/phoneme_prediction_eval.ipynb index 31e863a2d..f6539769a 100644 --- a/users/rilling/evaluation/phoneme_prediction_eval.ipynb +++ b/users/rilling/evaluation/phoneme_prediction_eval.ipynb @@ -45,66 +45,68 @@ "data": { "text/plain": [ "['/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_simple_encoder_x_vector/200ep/basic_init/no_specaug/tts_target_size/ce_ls_0.1/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/specaug/ce_ls_0.1/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/specaug/ce_ls_1/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/200ep/basic_init/no_specaug/tts_target_size/ce_ls_0.1/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/200ep/tts_pretrained/no_specaug/tts_target_size/ce_ls_0.1/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/no_specaug/ce_ls_1/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/no_specaug/ce_ls_0.1/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector_v2/200ep/tts_pretrained/ce_ls_0.1/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector_v2/200ep/tts_pretrained/ce_ls_1.0/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/ce_ls_0.1/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/ce_ls_1.0/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector_v2/tts_pretrained/ce_ls_0.01/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector_v2/tts_pretrained/ce_ls_0.1/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector_v2/basic_init/ce_ls_0.01/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector_v2/basic_init/ce_ls_0.1/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector/200ep/tts_pretrained/ce_ls_0.1/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector/200ep/basic_init/ce_ls_0.1/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step_tts/ga_glowTTS_ASR_ffn_x_vector_v2_2ndstep_tts/ce_ls_1.0/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector/tts_pretrained/ce_ls_0.1/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector/basic_init/ce_ls_0.1/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step/ga_glowTTS_ASR_ffn_x_vector_v2_2ndstep/ce_ls_1.0/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/first_step/ga_glowTTS_ASR_ffn_x_vector_v2/ce_ls_1.0/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/first_step/ga_glowTTS_ASR_ffn_x_vector_v2/ce_ls_3.0/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/first_step/ga_glowTTS_ASR_ffn_x_vector_v2/ce_ls_2.0/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/first_step/ga_glowTTS_ASR_ffn_x_vector_v2/ce_ls_4.0/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn/100ep/encoder/decoder_eval/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn/100ep/encoder/encoder_eval/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn/100ep/decoder/decoder_eval/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn/100ep/decoder/encoder_eval/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector_mas/100ep/encoder/decoder_eval/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector_mas/100ep/encoder/encoder_eval/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector_mas/100ep/decoder/decoder_eval/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector_mas/100ep/decoder/encoder_eval/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_mas_no_eval/100ep/encoder/encoder_eval/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_mas_no_eval/100ep/encoder/decoder_eval/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_mas_no_eval/100ep/decoder/encoder_eval/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_mas_no_eval/100ep/decoder/decoder_eval/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn/100ep/decoder/decoder_eval/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn/100ep/decoder/encoder_eval/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn/100ep/encoder/decoder_eval/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn/100ep/encoder/encoder_eval/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_mas/100ep/encoder/decoder_eval/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_mas/100ep/encoder/encoder_eval/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_mas/100ep/decoder/decoder_eval/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_mas/100ep/decoder/encoder_eval/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn_x_vector/100ep/encoder/decoder_eval/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn_x_vector/100ep/encoder/encoder_eval/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn_x_vector/100ep/decoder/decoder_eval/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn_x_vector/100ep/decoder/encoder_eval/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector/100ep/decoder/decoder_eval/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector/100ep/decoder/encoder_eval/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector/100ep/encoder/decoder_eval/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector/100ep/encoder/encoder_eval/',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_cnn_x_vector/tts_pretrained/no_specaug/tts_target_size/ce_ls_0.1/',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_cnn_x_vector/basic_init/no_specaug/tts_target_size/ce_ls_0.1/',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/mean_only/200ep/basic_init/no_specaug/tts_target_size/ce_ls_0.1/',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/200ep/tts_pretrained/no_specaug/tts_target_size/ce_ls_0.1/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/no_specaug/tts_target_size/ce_ls_1.0/',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/no_specaug/tts_target_size/ce_ls_0.1/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/no_specaug/tts_target_size/ce_ls_1.0/',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_blstm_x_vector/specaug/ce_ls_1/',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_blstm_x_vector/specaug/ce_ls_0.1/',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_blstm_x_vector/no_specaug/ce_ls_1/',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_blstm_x_vector/no_specaug/ce_ls_0.1/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/first_step/ga_glowTTS_ASR_ffn_x_vector_v2/ce_ls_4.0/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/first_step/ga_glowTTS_ASR_ffn_x_vector_v2/ce_ls_3.0/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/first_step/ga_glowTTS_ASR_ffn_x_vector_v2/ce_ls_2.0/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/first_step/ga_glowTTS_ASR_ffn_x_vector_v2/ce_ls_1.0/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_mas/100ep/encoder/decoder_eval/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_mas/100ep/encoder/encoder_eval/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector/100ep/encoder/decoder_eval/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector/100ep/encoder/encoder_eval/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector/100ep/decoder/encoder_eval/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector/100ep/decoder/decoder_eval/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn/100ep/encoder/encoder_eval/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn/100ep/encoder/decoder_eval/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn/100ep/decoder/decoder_eval/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn/100ep/decoder/encoder_eval/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn_x_vector/100ep/encoder/encoder_eval/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn_x_vector/100ep/encoder/decoder_eval/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn_x_vector/100ep/decoder/encoder_eval/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn_x_vector/100ep/decoder/decoder_eval/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector_mas/100ep/encoder/decoder_eval/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector_mas/100ep/encoder/encoder_eval/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector_mas/100ep/decoder/decoder_eval/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector_mas/100ep/decoder/encoder_eval/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn/100ep/decoder/decoder_eval/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn/100ep/decoder/encoder_eval/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn/100ep/encoder/decoder_eval/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn/100ep/encoder/encoder_eval/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_mas_no_eval/100ep/decoder/decoder_eval/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_mas_no_eval/100ep/decoder/encoder_eval/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_mas_no_eval/100ep/encoder/decoder_eval/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_mas_no_eval/100ep/encoder/encoder_eval/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector_v2/tts_pretrained/ce_ls_0.1/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector_v2/tts_pretrained/ce_ls_0.01/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector_v2/basic_init/ce_ls_0.1/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector_v2/basic_init/ce_ls_0.01/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step_tts/ga_glowTTS_ASR_ffn_x_vector_v2_2ndstep_tts/ce_ls_1.0/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector_v2/200ep/tts_pretrained/ce_ls_1.0/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector_v2/200ep/tts_pretrained/ce_ls_0.1/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/ce_ls_1.0/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/ce_ls_0.1/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector/200ep/basic_init/ce_ls_0.1/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector/200ep/tts_pretrained/ce_ls_0.1/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector/tts_pretrained/ce_ls_0.1/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector/basic_init/ce_ls_0.1/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step/ga_glowTTS_ASR_ffn_x_vector_v2_2ndstep/ce_ls_1.0/']" + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/200ep/basic_init/no_specaug/tts_target_size/ce_ls_0.1/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/200ep/tts_pretrained/no_specaug/tts_target_size/ce_ls_0.1/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/no_specaug/ce_ls_1/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/no_specaug/ce_ls_0.1/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/specaug/ce_ls_1/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/specaug/ce_ls_0.1/']" ] }, "execution_count": 3, @@ -177,20 +179,20 @@ " 21.30\n", " \n", " \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/specaug/ce_ls_0.1/\n", - " 26.49\n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector_v2/200ep/tts_pretrained/ce_ls_0.1/\n", + " 20.22\n", " \n", " \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/specaug/ce_ls_1/\n", - " 27.30\n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector_v2/200ep/tts_pretrained/ce_ls_1.0/\n", + " 20.42\n", " \n", " \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/200ep/basic_init/no_specaug/tts_target_size/ce_ls_0.1/\n", - " 30.09\n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/ce_ls_0.1/\n", + " 20.71\n", " \n", " \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/200ep/tts_pretrained/no_specaug/tts_target_size/ce_ls_0.1/\n", - " 28.56\n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/ce_ls_1.0/\n", + " 20.48\n", " \n", " \n", "\n", @@ -200,10 +202,10 @@ " Accuracy [%]\n", "Group Experiment \n", "joint_training/given_alignments /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 21.30\n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 26.49\n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 27.30\n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 30.09\n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 28.56" + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 20.22\n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 20.42\n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 20.71\n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 20.48" ] }, "execution_count": 4, @@ -287,51 +289,51 @@ " True\n", " \n", " \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/specaug/ce_ls_0.1/\n", - " 26.49\n", - " 2.868420\n", - " 2.858513\n", - " -0.802836\n", - " 0.434087\n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector_v2/200ep/tts_pretrained/ce_ls_0.1/\n", + " 20.22\n", + " 0.140343\n", + " 0.139632\n", + " -0.760167\n", + " 0.075069\n", " True\n", " False\n", - " 0.996546\n", + " 0.994934\n", " True\n", " \n", " \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/specaug/ce_ls_1/\n", - " 27.30\n", - " 2.664396\n", - " 2.957262\n", - " -0.72108\n", - " 0.747725\n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector_v2/200ep/tts_pretrained/ce_ls_1.0/\n", + " 20.42\n", + " 0.013599\n", + " 0.014265\n", + " -0.72889\n", + " 0.075977\n", " True\n", " False\n", - " 1.109919\n", + " 1.048934\n", " True\n", " \n", " \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/200ep/basic_init/no_specaug/tts_target_size/ce_ls_0.1/\n", - " 30.09\n", - " 2.782269\n", - " 2.795637\n", - " -0.785492\n", - " 0.890597\n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/ce_ls_0.1/\n", + " 20.71\n", + " 0.124269\n", + " 0.122107\n", + " -0.757141\n", + " 0.071102\n", " True\n", " False\n", - " 1.004805\n", + " 0.982599\n", " True\n", " \n", " \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/200ep/tts_pretrained/no_specaug/tts_target_size/ce_ls_0.1/\n", - " 28.56\n", - " 2.813527\n", - " 2.825326\n", - " -0.803716\n", - " 0.439343\n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/ce_ls_1.0/\n", + " 20.48\n", + " 0.011644\n", + " 0.011235\n", + " -0.729906\n", + " 0.069833\n", " True\n", " False\n", - " 1.004194\n", + " 0.964920\n", " True\n", " \n", " \n", @@ -342,42 +344,42 @@ " Accuracy [%] \\\n", "Group Experiment \n", "joint_training/given_alignments /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 21.30 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 26.49 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 27.30 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 30.09 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 28.56 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 20.22 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 20.42 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 20.71 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 20.48 \n", "\n", " CE \\\n", "Group Experiment \n", "joint_training/given_alignments /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 2.920585 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 2.868420 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 2.664396 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 2.782269 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 2.813527 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.140343 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.013599 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.124269 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.011644 \n", "\n", " dev CE \\\n", "Group Experiment \n", "joint_training/given_alignments /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 2.941674 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 2.858513 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 2.957262 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 2.795637 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 2.825326 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.139632 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.014265 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.122107 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.011235 \n", "\n", " MLE \\\n", "Group Experiment \n", "joint_training/given_alignments /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.797284 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.802836 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.72108 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.785492 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.803716 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.760167 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.72889 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.757141 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.729906 \n", "\n", " DP \\\n", "Group Experiment \n", "joint_training/given_alignments /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.957548 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.434087 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.747725 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.890597 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.439343 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.075069 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.075977 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.071102 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.069833 \n", "\n", " Joint \\\n", "Group Experiment \n", @@ -398,10 +400,10 @@ " overfitting \\\n", "Group Experiment \n", "joint_training/given_alignments /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 1.007221 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.996546 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 1.109919 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 1.004805 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 1.004194 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.994934 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 1.048934 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.982599 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.964920 \n", "\n", " Training data available \n", "Group Experiment \n", @@ -536,7 +538,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -545,7 +547,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -609,17 +611,17 @@ " 1\n", " joint_training/given_alignments\n", " /u/lukas.rilling/experiments/glow_tts_asr_v2/o...\n", - " 26.49\n", - " 2.868\n", - " 2.859\n", - " -0.803\n", - " 0.434\n", + " 20.22\n", + " 0.14\n", + " 0.14\n", + " -0.76\n", + " 0.075\n", " True\n", " False\n", - " 0.997\n", + " 0.995\n", " True\n", - " 250.0\n", - " [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08]\n", + " 200.0\n", + " [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05]\n", " unknown\n", " 0.1\n", " \n", @@ -627,17 +629,17 @@ " 2\n", " joint_training/given_alignments\n", " /u/lukas.rilling/experiments/glow_tts_asr_v2/o...\n", - " 27.30\n", - " 2.664\n", - " 2.957\n", - " -0.721\n", - " 0.748\n", + " 20.42\n", + " 0.014\n", + " 0.014\n", + " -0.729\n", + " 0.076\n", " True\n", " False\n", - " 1.11\n", + " 1.049\n", " True\n", - " 250.0\n", - " [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08]\n", + " 200.0\n", + " [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05]\n", " unknown\n", " 1.0\n", " \n", @@ -645,14 +647,14 @@ " 3\n", " joint_training/given_alignments\n", " /u/lukas.rilling/experiments/glow_tts_asr_v2/o...\n", - " 30.09\n", - " 2.782\n", - " 2.796\n", - " -0.785\n", - " 0.891\n", + " 20.71\n", + " 0.124\n", + " 0.122\n", + " -0.757\n", + " 0.071\n", " True\n", " False\n", - " 1.005\n", + " 0.983\n", " True\n", " 200.0\n", " [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05]\n", @@ -663,19 +665,19 @@ " 4\n", " joint_training/given_alignments\n", " /u/lukas.rilling/experiments/glow_tts_asr_v2/o...\n", - " 28.56\n", - " 2.814\n", - " 2.825\n", - " -0.804\n", - " 0.439\n", + " 20.48\n", + " 0.012\n", + " 0.011\n", + " -0.73\n", + " 0.07\n", " True\n", " False\n", - " 1.004\n", + " 0.965\n", " True\n", " 200.0\n", " [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05]\n", " unknown\n", - " 0.1\n", + " 1.0\n", " \n", " \n", "\n", @@ -691,41 +693,41 @@ "\n", " Experiment Accuracy [%] CE \\\n", "0 /u/lukas.rilling/experiments/glow_tts_asr_v2/o... 21.30 2.921 \n", - "1 /u/lukas.rilling/experiments/glow_tts_asr_v2/o... 26.49 2.868 \n", - "2 /u/lukas.rilling/experiments/glow_tts_asr_v2/o... 27.30 2.664 \n", - "3 /u/lukas.rilling/experiments/glow_tts_asr_v2/o... 30.09 2.782 \n", - "4 /u/lukas.rilling/experiments/glow_tts_asr_v2/o... 28.56 2.814 \n", + "1 /u/lukas.rilling/experiments/glow_tts_asr_v2/o... 20.22 0.14 \n", + "2 /u/lukas.rilling/experiments/glow_tts_asr_v2/o... 20.42 0.014 \n", + "3 /u/lukas.rilling/experiments/glow_tts_asr_v2/o... 20.71 0.124 \n", + "4 /u/lukas.rilling/experiments/glow_tts_asr_v2/o... 20.48 0.012 \n", "\n", " dev CE MLE DP Joint Still running overfitting \\\n", "0 2.942 -0.797 0.958 True False 1.007 \n", - "1 2.859 -0.803 0.434 True False 0.997 \n", - "2 2.957 -0.721 0.748 True False 1.11 \n", - "3 2.796 -0.785 0.891 True False 1.005 \n", - "4 2.825 -0.804 0.439 True False 1.004 \n", + "1 0.14 -0.76 0.075 True False 0.995 \n", + "2 0.014 -0.729 0.076 True False 1.049 \n", + "3 0.122 -0.757 0.071 True False 0.983 \n", + "4 0.011 -0.73 0.07 True False 0.965 \n", "\n", " Training data available Num Epochs \\\n", "0 True 200.0 \n", - "1 True 250.0 \n", - "2 True 250.0 \n", + "1 True 200.0 \n", + "2 True 200.0 \n", "3 True 200.0 \n", "4 True 200.0 \n", "\n", - " LR ASR Model Type \\\n", - "0 [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] unknown \n", - "1 [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] unknown \n", - "2 [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] unknown \n", - "3 [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] unknown \n", - "4 [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] unknown \n", + " LR ASR Model Type \\\n", + "0 [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] unknown \n", + "1 [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] unknown \n", + "2 [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] unknown \n", + "3 [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] unknown \n", + "4 [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] unknown \n", "\n", " CE loss scale \n", "0 0.1 \n", "1 0.1 \n", "2 1.0 \n", "3 0.1 \n", - "4 0.1 " + "4 1.0 " ] }, - "execution_count": 15, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -737,7 +739,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -747,66 +749,68 @@ "| | Group | Experiment | Accuracy [%] | CE | dev CE | MLE | DP | Joint | Still running | overfitting | Training data available | Num Epochs | LR | ASR Model Type | CE loss scale |\n", "|---:|:--------------------------------|:-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------------:|:------|:---------|:-------|:------|:--------|:----------------|:--------------|:--------------------------|:-------------|:-------------------------------------------------|:-----------------|:----------------|\n", "| 0 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_simple_encoder_x_vector/200ep/basic_init/no_specaug/tts_target_size/ce_ls_0.1/ | 21.3 | 2.921 | 2.942 | -0.797 | 0.958 | True | False | 1.007 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", - "| 1 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/specaug/ce_ls_0.1/ | 26.49 | 2.868 | 2.859 | -0.803 | 0.434 | True | False | 0.997 | True | 250.0 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | unknown | 0.1 |\n", - "| 2 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/specaug/ce_ls_1/ | 27.3 | 2.664 | 2.957 | -0.721 | 0.748 | True | False | 1.11 | True | 250.0 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | unknown | 1.0 |\n", - "| 3 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/200ep/basic_init/no_specaug/tts_target_size/ce_ls_0.1/ | 30.09 | 2.782 | 2.796 | -0.785 | 0.891 | True | False | 1.005 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", - "| 4 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/200ep/tts_pretrained/no_specaug/tts_target_size/ce_ls_0.1/ | 28.56 | 2.814 | 2.825 | -0.804 | 0.439 | True | False | 1.004 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", - "| 5 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/no_specaug/ce_ls_1/ | 27.72 | 2.532 | 2.992 | -0.691 | 0.76 | True | False | 1.182 | True | 250.0 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | unknown | 1.0 |\n", - "| 6 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/no_specaug/ce_ls_0.1/ | 30.44 | 2.793 | 2.791 | -0.795 | 0.506 | True | False | 1.0 | True | 250.0 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | unknown | 0.1 |\n", - "| 7 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_cnn_x_vector/tts_pretrained/no_specaug/tts_target_size/ce_ls_0.1/ | 28.92 | 2.564 | 2.893 | -0.793 | 0.396 | True | False | 1.128 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", - "| 8 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_cnn_x_vector/basic_init/no_specaug/tts_target_size/ce_ls_0.1/ | 27.3 | 2.573 | 2.942 | -0.776 | 0.432 | True | False | 1.143 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", - "| 9 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/mean_only/200ep/basic_init/no_specaug/tts_target_size/ce_ls_0.1/ | 22.6 | 2.922 | 2.923 | -0.804 | 0.932 | True | False | 1.0 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", - "| 10 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/200ep/tts_pretrained/no_specaug/tts_target_size/ce_ls_0.1/ | 23.4 | 2.879 | 2.887 | -0.806 | 0.626 | True | False | 1.003 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", - "| 11 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/no_specaug/tts_target_size/ce_ls_1.0/ | 22.24 | 2.923 | 2.924 | -0.801 | 0.835 | True | False | 1.0 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 1.0 |\n", - "| 12 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/no_specaug/tts_target_size/ce_ls_0.1/ | 22.76 | 2.924 | 2.934 | -0.8 | 0.818 | True | False | 1.004 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", - "| 13 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_blstm_x_vector/specaug/ce_ls_1/ | 35.97 | 1.395 | 2.544 | -0.66 | 0.303 | True | False | 1.824 | True | 250.0 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | blstm | 1.0 |\n", - "| 14 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_blstm_x_vector/specaug/ce_ls_0.1/ | 36.7 | 1.672 | 2.312 | -0.774 | 1.02 | True | False | 1.383 | True | 250.0 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | blstm | 0.1 |\n", - "| 15 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_blstm_x_vector/no_specaug/ce_ls_1/ | 34.25 | 1.042 | 3.15 | -0.69 | 0.352 | True | False | 3.023 | True | 250.0 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | blstm | 1.0 |\n", - "| 16 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_blstm_x_vector/no_specaug/ce_ls_0.1/ | 33.05 | 1.031 | 3.339 | -0.786 | 0.368 | True | False | 3.239 | True | 250.0 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | blstm | 0.1 |\n", - "| 17 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/first_step/ga_glowTTS_ASR_ffn_x_vector_v2/ce_ls_4.0/ | 28.56 | 0.003 | 0.003 | -0.702 | 0.075 | True | False | 0.948 | True | 100.0 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | unknown | 4.0 |\n", - "| 18 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/first_step/ga_glowTTS_ASR_ffn_x_vector_v2/ce_ls_3.0/ | 20.47 | 0.004 | 0.004 | -0.703 | 0.075 | True | False | 0.954 | True | 100.0 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | unknown | 3.0 |\n", - "| 19 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/first_step/ga_glowTTS_ASR_ffn_x_vector_v2/ce_ls_2.0/ | 20.38 | 0.006 | 0.006 | -0.708 | 0.075 | True | False | 1.018 | True | 100.0 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | unknown | 2.0 |\n", - "| 20 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/first_step/ga_glowTTS_ASR_ffn_x_vector_v2/ce_ls_1.0/ | 20.45 | 0.012 | 0.012 | -0.716 | 0.075 | True | False | 0.98 | True | 100.0 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | unknown | 1.0 |\n", - "| 21 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_mas/100ep/encoder/decoder_eval/ | 37.48 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", - "| 22 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_mas/100ep/encoder/encoder_eval/ | 37.57 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", - "| 23 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector/100ep/encoder/decoder_eval/ | 12.68 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", - "| 24 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector/100ep/encoder/encoder_eval/ | 42.05 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", - "| 25 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector/100ep/decoder/encoder_eval/ | 19.16 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", - "| 26 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector/100ep/decoder/decoder_eval/ | 19.96 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", - "| 27 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn/100ep/encoder/encoder_eval/ | 44.63 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", - "| 28 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn/100ep/encoder/decoder_eval/ | 12.24 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", - "| 29 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn/100ep/decoder/decoder_eval/ | 19.94 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", - "| 30 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn/100ep/decoder/encoder_eval/ | 18.49 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", - "| 31 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn_x_vector/100ep/encoder/encoder_eval/ | 70.57 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", - "| 32 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn_x_vector/100ep/encoder/decoder_eval/ | 11.4 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", - "| 33 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn_x_vector/100ep/decoder/encoder_eval/ | 22.76 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", - "| 34 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn_x_vector/100ep/decoder/decoder_eval/ | 21.33 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", - "| 35 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector_mas/100ep/encoder/decoder_eval/ | 12.72 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", - "| 36 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector_mas/100ep/encoder/encoder_eval/ | 12.68 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", - "| 37 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector_mas/100ep/decoder/decoder_eval/ | 12.73 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", - "| 38 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector_mas/100ep/decoder/encoder_eval/ | 12.71 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", - "| 39 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn/100ep/decoder/decoder_eval/ | 21.3 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", - "| 40 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn/100ep/decoder/encoder_eval/ | 22.09 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", - "| 41 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn/100ep/encoder/decoder_eval/ | 11.33 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", - "| 42 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn/100ep/encoder/encoder_eval/ | 72.13 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", - "| 43 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_mas_no_eval/100ep/decoder/decoder_eval/ | 37.64 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", - "| 44 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_mas_no_eval/100ep/decoder/encoder_eval/ | 37.46 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", - "| 45 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_mas_no_eval/100ep/encoder/decoder_eval/ | 37.51 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", - "| 46 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_mas_no_eval/100ep/encoder/encoder_eval/ | 37.56 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", - "| 47 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector_v2/tts_pretrained/ce_ls_0.1/ | 20.29 | 0.052 | 0.047 | -0.791 | 0.052 | True | False | 0.9 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", - "| 48 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector_v2/tts_pretrained/ce_ls_0.01/ | 19.98 | 0.372 | 0.338 | -0.797 | 0.063 | True | False | 0.91 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.01 |\n", - "| 49 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector_v2/basic_init/ce_ls_0.1/ | 20.32 | 0.052 | 0.048 | -0.783 | 0.052 | True | False | 0.916 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", - "| 50 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector_v2/basic_init/ce_ls_0.01/ | 19.97 | 0.341 | 0.308 | -0.787 | 0.064 | True | False | 0.903 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.01 |\n", - "| 51 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step_tts/ga_glowTTS_ASR_ffn_x_vector_v2_2ndstep_tts/ce_ls_1.0/ | 20.18 | - | - | - | - | True | True | - | True | 100.0 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | unknown | 1.0 |\n", - "| 52 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector_v2/200ep/tts_pretrained/ce_ls_1.0/ | 20.42 | 0.014 | 0.014 | -0.729 | 0.076 | True | False | 1.049 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 1.0 |\n", - "| 53 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector_v2/200ep/tts_pretrained/ce_ls_0.1/ | 20.22 | 0.14 | 0.14 | -0.76 | 0.075 | True | False | 0.995 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", - "| 54 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/ce_ls_1.0/ | 20.48 | 0.012 | 0.011 | -0.73 | 0.07 | True | False | 0.965 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 1.0 |\n", - "| 55 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/ce_ls_0.1/ | 20.71 | 0.124 | 0.122 | -0.757 | 0.071 | True | False | 0.983 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", - "| 56 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector/200ep/basic_init/ce_ls_0.1/ | 21.39 | 2.921 | 2.947 | -0.779 | 0.256 | True | False | 1.009 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", - "| 57 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector/200ep/tts_pretrained/ce_ls_0.1/ | 21.33 | 2.925 | 2.946 | -0.792 | 0.247 | True | False | 1.007 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", - "| 58 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector/tts_pretrained/ce_ls_0.1/ | 27.63 | 2.617 | 2.915 | -0.775 | 0.263 | True | False | 1.114 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", - "| 59 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector/basic_init/ce_ls_0.1/ | 25.67 | 2.583 | 3.019 | -0.767 | 0.265 | True | False | 1.169 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", - "| 60 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step/ga_glowTTS_ASR_ffn_x_vector_v2_2ndstep/ce_ls_1.0/ | 21.61 | 2.939 | 2.947 | - | - | False | False | 1.003 | True | 100.0 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | unknown | 1.0 |\n" + "| 1 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector_v2/200ep/tts_pretrained/ce_ls_0.1/ | 20.22 | 0.14 | 0.14 | -0.76 | 0.075 | True | False | 0.995 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", + "| 2 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector_v2/200ep/tts_pretrained/ce_ls_1.0/ | 20.42 | 0.014 | 0.014 | -0.729 | 0.076 | True | False | 1.049 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 1.0 |\n", + "| 3 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/ce_ls_0.1/ | 20.71 | 0.124 | 0.122 | -0.757 | 0.071 | True | False | 0.983 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", + "| 4 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/ce_ls_1.0/ | 20.48 | 0.012 | 0.011 | -0.73 | 0.07 | True | False | 0.965 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 1.0 |\n", + "| 5 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector_v2/tts_pretrained/ce_ls_0.01/ | 19.98 | 0.372 | 0.338 | -0.797 | 0.063 | True | False | 0.91 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.01 |\n", + "| 6 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector_v2/tts_pretrained/ce_ls_0.1/ | 20.29 | 0.052 | 0.047 | -0.791 | 0.052 | True | False | 0.9 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", + "| 7 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector_v2/basic_init/ce_ls_0.01/ | 19.97 | 0.341 | 0.308 | -0.787 | 0.064 | True | False | 0.903 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.01 |\n", + "| 8 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector_v2/basic_init/ce_ls_0.1/ | 20.32 | 0.052 | 0.048 | -0.783 | 0.052 | True | False | 0.916 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", + "| 9 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector/200ep/tts_pretrained/ce_ls_0.1/ | 21.33 | 2.925 | 2.946 | -0.792 | 0.247 | True | False | 1.007 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", + "| 10 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector/200ep/basic_init/ce_ls_0.1/ | 21.39 | 2.921 | 2.947 | -0.779 | 0.256 | True | False | 1.009 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", + "| 11 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step_tts/ga_glowTTS_ASR_ffn_x_vector_v2_2ndstep_tts/ce_ls_1.0/ | 20.18 | - | - | - | - | True | True | - | True | 100.0 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | unknown | 1.0 |\n", + "| 12 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector/tts_pretrained/ce_ls_0.1/ | 27.63 | 2.617 | 2.915 | -0.775 | 0.263 | True | False | 1.114 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", + "| 13 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector/basic_init/ce_ls_0.1/ | 25.67 | 2.583 | 3.019 | -0.767 | 0.265 | True | False | 1.169 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", + "| 14 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step/ga_glowTTS_ASR_ffn_x_vector_v2_2ndstep/ce_ls_1.0/ | 21.61 | 2.939 | 2.947 | - | - | False | False | 1.003 | True | 100.0 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | unknown | 1.0 |\n", + "| 15 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/first_step/ga_glowTTS_ASR_ffn_x_vector_v2/ce_ls_1.0/ | 20.45 | 0.012 | 0.012 | -0.716 | 0.075 | True | False | 0.98 | True | 100.0 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | unknown | 1.0 |\n", + "| 16 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/first_step/ga_glowTTS_ASR_ffn_x_vector_v2/ce_ls_3.0/ | 20.47 | 0.004 | 0.004 | -0.703 | 0.075 | True | False | 0.954 | True | 100.0 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | unknown | 3.0 |\n", + "| 17 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/first_step/ga_glowTTS_ASR_ffn_x_vector_v2/ce_ls_2.0/ | 20.38 | 0.006 | 0.006 | -0.708 | 0.075 | True | False | 1.018 | True | 100.0 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | unknown | 2.0 |\n", + "| 18 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/first_step/ga_glowTTS_ASR_ffn_x_vector_v2/ce_ls_4.0/ | 28.56 | 0.003 | 0.003 | -0.702 | 0.075 | True | False | 0.948 | True | 100.0 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | unknown | 4.0 |\n", + "| 19 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn/100ep/encoder/decoder_eval/ | 11.33 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 20 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn/100ep/encoder/encoder_eval/ | 72.13 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 21 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn/100ep/decoder/decoder_eval/ | 21.3 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 22 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn/100ep/decoder/encoder_eval/ | 22.09 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 23 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector_mas/100ep/encoder/decoder_eval/ | 12.72 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 24 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector_mas/100ep/encoder/encoder_eval/ | 12.68 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 25 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector_mas/100ep/decoder/decoder_eval/ | 12.73 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 26 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector_mas/100ep/decoder/encoder_eval/ | 12.71 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 27 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_mas_no_eval/100ep/encoder/encoder_eval/ | 37.56 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 28 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_mas_no_eval/100ep/encoder/decoder_eval/ | 37.51 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 29 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_mas_no_eval/100ep/decoder/encoder_eval/ | 37.46 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 30 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_mas_no_eval/100ep/decoder/decoder_eval/ | 37.64 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 31 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn/100ep/decoder/decoder_eval/ | 19.94 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 32 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn/100ep/decoder/encoder_eval/ | 18.49 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 33 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn/100ep/encoder/decoder_eval/ | 12.24 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 34 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn/100ep/encoder/encoder_eval/ | 44.63 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 35 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_mas/100ep/encoder/decoder_eval/ | 37.48 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 36 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_mas/100ep/encoder/encoder_eval/ | 37.57 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 37 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_mas/100ep/decoder/decoder_eval/ | 37.68 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 38 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_mas/100ep/decoder/encoder_eval/ | 37.45 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 39 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn_x_vector/100ep/encoder/decoder_eval/ | 11.4 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 40 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn_x_vector/100ep/encoder/encoder_eval/ | 70.57 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 41 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn_x_vector/100ep/decoder/decoder_eval/ | 21.33 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 42 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_cnn_x_vector/100ep/decoder/encoder_eval/ | 22.76 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 43 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector/100ep/decoder/decoder_eval/ | 19.96 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 44 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector/100ep/decoder/encoder_eval/ | 19.16 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 45 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector/100ep/encoder/decoder_eval/ | 12.68 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 46 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/frozen_glowtts/ga_glowTTS_ASR_ffn_x_vector/100ep/encoder/encoder_eval/ | 42.05 | - | - | - | - | True | False | - | True | - | - | unknown | - |\n", + "| 47 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_cnn_x_vector/tts_pretrained/no_specaug/tts_target_size/ce_ls_0.1/ | 28.92 | 2.564 | 2.893 | -0.793 | 0.396 | True | False | 1.128 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", + "| 48 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_cnn_x_vector/basic_init/no_specaug/tts_target_size/ce_ls_0.1/ | 27.3 | 2.573 | 2.942 | -0.776 | 0.432 | True | False | 1.143 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", + "| 49 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/mean_only/200ep/basic_init/no_specaug/tts_target_size/ce_ls_0.1/ | 22.6 | 2.922 | 2.923 | -0.804 | 0.932 | True | False | 1.0 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", + "| 50 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/200ep/tts_pretrained/no_specaug/tts_target_size/ce_ls_0.1/ | 23.4 | 2.879 | 2.887 | -0.806 | 0.626 | True | False | 1.003 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", + "| 51 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/no_specaug/tts_target_size/ce_ls_0.1/ | 22.76 | 2.924 | 2.934 | -0.8 | 0.818 | True | False | 1.004 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", + "| 52 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/no_specaug/tts_target_size/ce_ls_1.0/ | 22.24 | 2.923 | 2.924 | -0.801 | 0.835 | True | False | 1.0 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 1.0 |\n", + "| 53 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_blstm_x_vector/specaug/ce_ls_1/ | 35.97 | 1.395 | 2.544 | -0.66 | 0.303 | True | False | 1.824 | True | 250.0 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | blstm | 1.0 |\n", + "| 54 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_blstm_x_vector/specaug/ce_ls_0.1/ | 36.7 | 1.672 | 2.312 | -0.774 | 1.02 | True | False | 1.383 | True | 250.0 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | blstm | 0.1 |\n", + "| 55 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_blstm_x_vector/no_specaug/ce_ls_1/ | 34.25 | 1.042 | 3.15 | -0.69 | 0.352 | True | False | 3.023 | True | 250.0 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | blstm | 1.0 |\n", + "| 56 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_blstm_x_vector/no_specaug/ce_ls_0.1/ | 33.05 | 1.031 | 3.339 | -0.786 | 0.368 | True | False | 3.239 | True | 250.0 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | blstm | 0.1 |\n", + "| 57 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/200ep/basic_init/no_specaug/tts_target_size/ce_ls_0.1/ | 30.09 | 2.782 | 2.796 | -0.785 | 0.891 | True | False | 1.005 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", + "| 58 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/200ep/tts_pretrained/no_specaug/tts_target_size/ce_ls_0.1/ | 28.56 | 2.814 | 2.825 | -0.804 | 0.439 | True | False | 1.004 | True | 200.0 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | unknown | 0.1 |\n", + "| 59 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/no_specaug/ce_ls_1/ | 27.72 | 2.532 | 2.992 | -0.691 | 0.76 | True | False | 1.182 | True | 250.0 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | unknown | 1.0 |\n", + "| 60 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/no_specaug/ce_ls_0.1/ | 30.44 | 2.793 | 2.791 | -0.795 | 0.506 | True | False | 1.0 | True | 250.0 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | unknown | 0.1 |\n", + "| 61 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/specaug/ce_ls_1/ | 27.3 | 2.664 | 2.957 | -0.721 | 0.748 | True | False | 1.11 | True | 250.0 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | unknown | 1.0 |\n", + "| 62 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/specaug/ce_ls_0.1/ | 26.49 | 2.868 | 2.859 | -0.803 | 0.434 | True | False | 0.997 | True | 250.0 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | unknown | 0.1 |\n" ] } ], @@ -831,7 +835,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.13" + "version": "3.10.12" } }, "nbformat": 4, diff --git a/users/rilling/evaluation/swer_eval.ipynb b/users/rilling/evaluation/swer_eval.ipynb index 9122f2655..1e207a807 100644 --- a/users/rilling/evaluation/swer_eval.ipynb +++ b/users/rilling/evaluation/swer_eval.ipynb @@ -49,6 +49,7 @@ " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/400ep/gin512/dec_drop_0.05/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/400ep/dec_drop_0.05/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/200ep/dec_drop_0.0/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/200ep/dec_drop_0.05/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", @@ -62,6 +63,7 @@ " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc192/200ep/dec_drop_0.0/grad_clip_10/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc192/100ep/dec_drop_0.05/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/400ep/grad_clip_10/dec_drop_0.05/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/400ep/gin512/grad_clip_10/dec_drop_0.05/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/200ep/dec_drop_0.0/epsilon_1e-8/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/200ep/dec_drop_0.0/grad_clip_10/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/200ep/dec_drop_0.05_epsilon_1e-8/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", @@ -184,7 +186,7 @@ { "data": { "text/plain": [ - "(91, 91, 91, 91, 91, 91, 91, 91)" + "(93, 93, 93, 93, 93, 93, 93, 93)" ] }, "execution_count": 4, @@ -304,7 +306,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -491,7 +493,7 @@ " \n", " \n", "\n", - "

91 rows × 9 columns

\n", + "

93 rows × 9 columns

\n", "" ], "text/plain": [ @@ -621,10 +623,10 @@ " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... {'class': 'adam', 'epsilon': 1e-09} \n", " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... {'class': 'radam', 'epsilon': 1e-09} \n", "\n", - "[91 rows x 9 columns]" + "[93 rows x 9 columns]" ] }, - "execution_count": 16, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -641,7 +643,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 13, "metadata": {}, "outputs": [ { @@ -719,10 +721,10 @@ " {'class': 'adam', 'epsilon': 1e-08}\n", " -0.826781\n", " -0.846025\n", - " NaN\n", + " None\n", " 0.382039\n", " 0.353906\n", - " NaN\n", + " None\n", " False\n", " \n", " \n", @@ -736,13 +738,13 @@ " 768\n", " [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08]\n", " {'class': 'adam', 'epsilon': 1e-08}\n", - " -0.672552\n", - " NaN\n", - " -0.692025\n", - " 0.444391\n", - " NaN\n", - " 0.412498\n", - " True\n", + " False\n", + " False\n", + " False\n", + " False\n", + " False\n", + " False\n", + " False\n", " \n", " \n", " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_x_vector_v2/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer\n", @@ -755,13 +757,13 @@ " 768\n", " [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08]\n", " {'class': 'adam', 'epsilon': 1e-08}\n", - " -0.453089\n", - " -0.401680\n", - " -0.465325\n", - " 0.246206\n", - " 0.344511\n", - " 0.229336\n", - " True\n", + " False\n", + " False\n", + " False\n", + " False\n", + " False\n", + " False\n", + " False\n", " \n", " \n", " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_100ep_pe1_radam1e-9/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer\n", @@ -774,12 +776,12 @@ " 768\n", " [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05]\n", " {'class': 'radam', 'epsilon': 1e-09}\n", - " -0.825730\n", + " -0.82573\n", " -0.844433\n", - " NaN\n", + " None\n", " 0.384814\n", " 0.355806\n", - " NaN\n", + " None\n", " False\n", " \n", " \n", @@ -795,10 +797,10 @@ " {'class': 'adam', 'epsilon': 1e-08}\n", " -0.825686\n", " -0.844577\n", - " NaN\n", + " None\n", " 0.389056\n", " 0.360854\n", - " NaN\n", + " None\n", " False\n", " \n", " \n", @@ -881,61 +883,61 @@ " MLE \\\n", "Group Experiment \n", "joint_training/conformer_coupling /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.826781 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.672552 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.453089 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.825730 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.82573 \n", " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.825686 \n", "\n", " dev MLE \\\n", "Group Experiment \n", "joint_training/conformer_coupling /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.846025 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... NaN \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.401680 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False \n", " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.844433 \n", " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.844577 \n", "\n", - " devtrain MLE \\\n", - "Group Experiment \n", - "joint_training/conformer_coupling /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... NaN \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.692025 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.465325 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... NaN \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... NaN \n", + " devtrain MLE \\\n", + "Group Experiment \n", + "joint_training/conformer_coupling /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... None \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... None \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... None \n", "\n", " DP loss \\\n", "Group Experiment \n", "joint_training/conformer_coupling /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.382039 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.444391 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.246206 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False \n", " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.384814 \n", " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.389056 \n", "\n", - " DP dev loss \\\n", - "Group Experiment \n", - "joint_training/conformer_coupling /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.353906 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... NaN \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.344511 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.355806 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.360854 \n", + " DP dev loss \\\n", + "Group Experiment \n", + "joint_training/conformer_coupling /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.353906 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.355806 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.360854 \n", "\n", - " DP devtrain loss \\\n", - "Group Experiment \n", - "joint_training/conformer_coupling /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... NaN \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.412498 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.229336 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... NaN \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... NaN \n", + " DP devtrain loss \\\n", + "Group Experiment \n", + "joint_training/conformer_coupling /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... None \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... None \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... None \n", "\n", " Joint \n", "Group Experiment \n", "joint_training/conformer_coupling /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... True \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... True \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False \n", " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False \n", " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False " ] }, - "execution_count": 17, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } @@ -961,6 +963,9 @@ " mle_dev_scores.append(False)\n", " dp_scores.append(False)\n", " dp_dev_scores.append(False)\n", + " mle_devtrain_scores.append(False)\n", + " dp_devtrain_scores.append(False)\n", + " joint.append(False)\n", " else:\n", " last_epoch_data = data[list(data.keys())[-1]]\n", " finished.append(True)\n", @@ -996,7 +1001,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -1008,64 +1013,69 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "| | Group | Experiment | sWER | autoMOS | autoMOS confidence | num_epochs | decoder dropout | mean only | encoder channels | LR | Optimizer | MLE | dev MLE | devtrain MLE | DP loss | DP dev loss | DP devtrain loss | Joint |\n", - "|---:|:----------------------------------|:------------------------------------------------------------------------------------------------------------------------|-------:|----------:|---------------------:|-------------:|------------------:|:------------|:-------------------|:-------------------------------------------------|:-------------------------------------|------:|----------:|---------------:|----------:|--------------:|-------------------:|:--------|\n", - "| 0 | joint_training/conformer_coupling | joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_100ep_pe1/ | 12.4 | 2.94 | nan | 100 | 0.05 | False | 768 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'adam', 'epsilon': 1e-08} | -0.83 | -0.85 | nan | 0.38 | 0.35 | nan | False |\n", - "| 3 | joint_training/conformer_coupling | joint_training/conformer_coupling/raw_audio/ddi/glowTTS_100ep_pe1_radam1e-9/ | 14.7 | 2.59 | nan | 100 | 0.05 | False | 768 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.83 | -0.84 | nan | 0.38 | 0.36 | nan | False |\n", - "| 4 | joint_training/conformer_coupling | joint_training/conformer_coupling/raw_audio/ddi/glowTTS_100ep_pe1/ | 14.4 | 2.72 | nan | 100 | 0.05 | False | 768 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'adam', 'epsilon': 1e-08} | -0.83 | -0.84 | nan | 0.39 | 0.36 | nan | False |\n", - "| 5 | joint_training/conformer_coupling | joint_training/conformer_coupling/raw_audio/ddi/glowTTS/ | 97.7 | 1.61 | nan | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.82 | -0.83 | nan | 0.96 | 0.73 | nan | False |\n", - "| 7 | joint_training/conformer_coupling | joint_training/conformer_coupling/raw_audio/ddi/glowTTS_x_vector/ | 99.5 | 1.93 | nan | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.81 | -0.76 | -0.81 | 1 | 1.08 | 1.04 | False |\n", - "| 23 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/400ep/dec_drop_0.05/ | 12.9 | 3.33 | 0.02 | 400 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 400: 1e-06] | {'class': 'radam', 'epsilon': 1e-09} | -0.82 | -0.83 | -0.84 | 0.38 | 0.46 | 0.34 | False |\n", - "| 24 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/200ep/dec_drop_0.0/ | 96.2 | 2.29 | nan | 200 | 0 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.81 | -0.8 | -0.8 | 0.98 | 0.87 | 0.88 | False |\n", - "| 25 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/200ep/dec_drop_0.05/ | 14.6 | 3.26 | 0.02 | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.81 | -0.82 | -0.83 | 0.39 | 0.44 | 0.36 | False |\n", - "| 26 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/100ep/dec_drop_0.05/ | 16.3 | 3.18 | 0.02 | 100 | 0.05 | False | 768 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.8 | -0.81 | -0.82 | 0.41 | 0.44 | 0.38 | False |\n", - "| 27 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/200ep_long_cooldown/dec_drop_0.0/ | 16.7 | 3.32 | nan | 200 | 0 | False | 768 | [0: 1e-06, 49: 0.0005, 50: 0.0005, 200: 1e-06] | {'class': 'radam', 'epsilon': 1e-09} | -0.85 | -0.76 | -0.85 | 0.41 | 0.47 | 0.38 | False |\n", - "| 28 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/200ep_long_cooldown/dec_drop_0.05/ | 15.6 | 3.21 | nan | 200 | 0.05 | False | 768 | [0: 1e-06, 49: 0.0005, 50: 0.0005, 200: 1e-06] | {'class': 'radam', 'epsilon': 1e-09} | -0.81 | -0.82 | -0.83 | 0.39 | 0.45 | 0.36 | False |\n", - "| 29 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc192/200ep/dec_drop_0.05/ | 13.3 | 3.3 | nan | 200 | 0.05 | False | 192 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.81 | -0.82 | -0.83 | 0.38 | 0.41 | 0.34 | False |\n", - "| 30 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc192/200ep/dec_drop_0.0/ | 95.4 | 2.41 | nan | 200 | 0 | False | 192 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.84 | -0.82 | -0.83 | 0.97 | 1.15 | 1.18 | False |\n", - "| 31 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc192/200ep/dec_drop_0.05_epsilon_1e-8/ | 96.7 | 2.27 | nan | 200 | 0.05 | False | 192 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-08} | -0.81 | -0.82 | -0.82 | 0.98 | 0.81 | 0.83 | False |\n", - "| 32 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc192/200ep/dec_drop_0.05/ | 98.8 | 1.88 | nan | 200 | 0.05 | False | 192 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.81 | -0.82 | -0.82 | 0.99 | 0.62 | 0.62 | False |\n", - "| 33 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc192/200ep/dec_drop_0.0/grad_clip_10/ | 12.8 | 3.34 | nan | 200 | 0 | False | 192 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.85 | -0.77 | -0.85 | 0.39 | 0.43 | 0.36 | False |\n", - "| 34 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc192/100ep/dec_drop_0.05/ | 98.1 | 1.52 | nan | 100 | 0.05 | False | 192 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.8 | -0.8 | -0.81 | 0.99 | 0.78 | 0.78 | False |\n", - "| 35 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/400ep/grad_clip_10/dec_drop_0.05/ | 14.4 | 3.29 | 0.02 | 400 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 400: 1e-06] | {'class': 'radam', 'epsilon': 1e-09} | -0.82 | -0.84 | -0.85 | 0.37 | 0.44 | 0.33 | False |\n", - "| 36 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/200ep/dec_drop_0.0/epsilon_1e-8/ | 95.9 | 3.06 | nan | 200 | 0 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-08} | -0.83 | -0.75 | -0.81 | 0.98 | 0.45 | 0.46 | False |\n", - "| 37 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/200ep/dec_drop_0.0/grad_clip_10/ | 14.5 | 3.31 | nan | 200 | 0 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.85 | -0.84 | -0.85 | 0.4 | 0.45 | 0.36 | False |\n", - "| 38 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/200ep/dec_drop_0.05_epsilon_1e-8/ | 15.7 | 3.35 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-08} | -0.81 | -0.83 | -0.83 | 0.39 | 0.44 | 0.35 | False |\n", - "| 39 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/200ep/dec_drop_0.05/ | 15.1 | 3.36 | 0.02 | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.81 | -0.83 | -0.83 | 0.39 | 0.44 | 0.35 | False |\n", - "| 40 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/100ep/dec_drop_0.00/ | 16.3 | 3.27 | nan | 100 | 0 | False | 768 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.83 | -0.82 | -0.83 | 0.41 | 0.44 | 0.38 | False |\n", - "| 41 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/100ep/dec_drop_0.05/ | 17.2 | 3.3 | nan | 100 | 0.05 | False | 768 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.8 | -0.81 | -0.82 | 0.4 | 0.43 | 0.37 | False |\n", - "| 42 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2_logdist_loss/ed_scale_0.1/ | 95.8 | 3.09 | nan | 200 | 0.05 | False | 192 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.78 | -0.78 | -0.78 | 1.08 | 2.07 | 2.08 | False |\n", - "| 43 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2_logdist_loss_grad_clip_10/ed_scale_1.0/ | 98.8 | 2.27 | nan | 200 | 0.05 | False | 192 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.74 | -0.76 | -0.76 | 1.13 | 1.54 | 1.55 | False |\n", - "| 44 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2_logdist_loss_grad_clip_10/ed_scale_0.1/ | 95.7 | 3.21 | nan | 200 | 0.05 | False | 192 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.8 | -0.79 | -0.79 | 1.08 | 1.81 | 1.83 | False |\n", - "| 45 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_simple_encoder/12cb/200ep/dec_drop_0.05/ | 70.3 | 3.47 | nan | 200 | 0.05 | False | - | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.8 | -0.82 | -0.83 | 0.43 | 0.5 | 0.4 | False |\n", - "| 46 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_simple_encoder/20cb/200ep/dec_drop_0.05/ | 57.3 | 3.46 | nan | 200 | 0.05 | False | - | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.83 | -0.85 | -0.86 | 0.4 | 0.47 | 0.38 | False |\n", - "| 47 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2_conformer_coupling/enc768/200ep/dec_drop_0.05/ | 9.6 | 1.79 | 0.03 | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.84 | -0.85 | -0.86 | 0.37 | 0.42 | 0.34 | False |\n", - "| 48 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2_multiscale/enc768/200ep/dec_drop_0.05/ | 100 | 1.25 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.79 | -0.8 | -0.81 | 0.53 | 0.57 | 0.52 | False |\n", - "| 49 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_batch_norm/enc768/200ep/dec_drop_0.05/ | 15.1 | 3.4 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.81 | -0.82 | -0.83 | 0.39 | 0.45 | 0.36 | False |\n", - "| 50 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector/enc768/100ep/dec_drop_0.05/ | 97.9 | 1.51 | nan | 100 | 0.05 | False | 768 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.78 | -0.79 | -0.79 | 0.99 | 1.38 | 1.38 | False |\n", - "| 75 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS/enc256/not_silence_preprocessed/ | 97.9 | 1.69 | nan | 200 | 0 | False | 256 | [0: 5e-05, 49: 0.0005, 50: 0.0005, 200: 1e-06] | {'class': 'adam', 'epsilon': 1e-09} | -0.85 | -0.54 | nan | 0.96 | 0.5 | nan | False |\n", - "| 76 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS/enc768/with_sigma/not_silence_preprocessed/ | 15.7 | 3.35 | nan | 200 | 0 | False | 768 | [0: 5e-05, 49: 0.0005, 50: 0.0005, 200: 1e-06] | {'class': 'adam', 'epsilon': 1e-09} | -0.85 | -0.83 | nan | 0.4 | 0.45 | nan | False |\n", - "| 77 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS/enc768/with_sigma/silence_preprocessed/ | 15.3 | 3.4 | nan | 200 | 0 | False | 768 | [0: 5e-05, 49: 0.0005, 50: 0.0005, 200: 1e-06] | {'class': 'adam', 'epsilon': 1e-09} | -0.74 | -0.46 | nan | 0.37 | 0.41 | nan | False |\n", - "| 78 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS/enc768/mean_only/silence_preprocessed/ | 16.9 | 3.52 | nan | 200 | 0 | True | 768 | [0: 5e-05, 49: 0.0005, 50: 0.0005, 200: 1e-06] | {'class': 'adam', 'epsilon': 1e-09} | -0.74 | -0.71 | nan | 0.37 | 0.41 | nan | False |\n", - "| 79 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS/enc768/mean_only/not_silence_preprocessed/ | 15.5 | 3.47 | nan | 200 | 0 | True | 768 | [0: 5e-05, 49: 0.0005, 50: 0.0005, 200: 1e-06] | {'class': 'adam', 'epsilon': 1e-09} | -0.85 | -0.76 | nan | 0.4 | 0.45 | nan | False |\n", - "| 80 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS/enc192/100ep/not_silence_preprocessed/ | 14.3 | 3.31 | nan | 100 | 0 | False | 192 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'adam', 'epsilon': 1e-09} | -0.84 | -0.77 | nan | 0.41 | 0.42 | nan | False |\n", - "| 81 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS/enc192/100ep/silence_preprocessed/ | 13.5 | 3.3 | nan | 100 | 0 | False | 192 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'adam', 'epsilon': 1e-09} | -0.82 | -0.81 | nan | 0.37 | 0.39 | nan | False |\n", - "| 82 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS/enc192/200ep/long_cooldown/not_silence_preprocessed/ | 14.7 | 3.29 | nan | 200 | 0 | False | 192 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 200: 1e-07] | {'class': 'adam', 'epsilon': 1e-08} | -0.84 | -0.69 | nan | 0.41 | 0.43 | nan | False |\n", - "| 83 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS/enc192/200ep/long_cooldown/silence_preprocessed/ | 13.5 | 3.28 | nan | 200 | 0 | False | 192 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 200: 1e-07] | {'class': 'adam', 'epsilon': 1e-08} | -0.82 | -0.81 | nan | 0.38 | 0.39 | nan | False |\n", - "| 84 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS_simple_encoder/silence_preprocessed/ | 56.4 | 3.33 | nan | 100 | 0 | - | - | [0: 0.0001, 49: 0.0005, 50: 0.0005, 100: 1e-06] | {'class': 'radam', 'epsilon': 1e-09} | -0.84 | -0.82 | nan | 0.38 | 0.43 | nan | False |\n", - "| 85 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS_ddi_actnorm/enc192/100ep/not_silence_preprocessed/LR_scheduled/ | 100 | 3.12 | nan | 100 | 0 | False | 192 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'adam', 'epsilon': 1e-09} | -0.84 | -0.8 | nan | 0.42 | 0.44 | nan | False |\n", - "| 86 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS_x_vector/enc768/100ep/not_silence_preprocessed/ | 20.9 | 3.31 | nan | 100 | 0 | False | 768 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'adam', 'epsilon': 1e-09} | -0.81 | -0.8 | nan | 0.46 | 0.47 | nan | False |\n", - "| 87 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS_x_vector/enc192/100ep/not_silence_preprocessed/ | 95.4 | 2.63 | nan | 100 | 0 | False | 192 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'adam', 'epsilon': 1e-09} | -0.81 | -0.79 | nan | 0.97 | 1.27 | nan | False |\n", - "| 88 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS_nar_taco_encoder/not_silence_preprocessed/ | 25.2 | 3.46 | nan | 200 | 0 | - | - | [0: 1e-05, 49: 0.0005, 50: 0.0005, 200: 1e-05] | {'class': 'adam', 'epsilon': 1e-09} | -0.84 | -0.71 | nan | 0.41 | 0.46 | nan | False |\n", - "| 89 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS_nar_taco_encoder/silence_preprocessed/ | 25.9 | 3.39 | nan | 200 | 0 | - | - | [0: 1e-05, 49: 0.0005, 50: 0.0005, 200: 1e-05] | {'class': 'adam', 'epsilon': 1e-09} | -0.83 | -0.81 | nan | 0.39 | 0.42 | nan | False |\n", - "| 90 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS_nar_taco_encoder_no_blstm/silence_preprocessed/ | 105.6 | 3.17 | nan | 100 | 0 | - | - | [0: 0.0001, 49: 0.0005, 50: 0.0001, 100: 1e-06] | {'class': 'radam', 'epsilon': 1e-09} | -0.8 | -0.79 | nan | 0.88 | 0.87 | nan | False |\n" + "| | Group | Experiment | sWER | autoMOS | autoMOS confidence | num_epochs | decoder dropout | mean only | encoder channels | LR | Optimizer | MLE | dev MLE | devtrain MLE | DP loss | DP dev loss | DP devtrain loss | Joint |\n", + "|---:|:----------------------------------|:------------------------------------------------------------------------------------------------------------------------|-------:|----------:|---------------------:|-------------:|------------------:|:------------|:-------------------|:-------------------------------------------------|:-------------------------------------|----------:|----------:|---------------:|----------:|--------------:|-------------------:|:--------|\n", + "| 0 | joint_training/conformer_coupling | joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_100ep_pe1/ | 12.4 | 2.94 | nan | 100 | 0.05 | False | 768 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'adam', 'epsilon': 1e-08} | -0.826781 | -0.846025 | | 0.382039 | 0.353906 | | False |\n", + "| 1 | joint_training/conformer_coupling | joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_two_forward_pass/ | 20.9 | 2.45 | nan | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | 0 | 0 | 0 | 0 | 0 | 0 | False |\n", + "| 2 | joint_training/conformer_coupling | joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_x_vector_v2/ | 5.2 | 2.14 | nan | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | 0 | 0 | 0 | 0 | 0 | 0 | False |\n", + "| 3 | joint_training/conformer_coupling | joint_training/conformer_coupling/raw_audio/ddi/glowTTS_100ep_pe1_radam1e-9/ | 14.7 | 2.59 | nan | 100 | 0.05 | False | 768 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.82573 | -0.844433 | | 0.384814 | 0.355806 | | False |\n", + "| 4 | joint_training/conformer_coupling | joint_training/conformer_coupling/raw_audio/ddi/glowTTS_100ep_pe1/ | 14.4 | 2.72 | nan | 100 | 0.05 | False | 768 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'adam', 'epsilon': 1e-08} | -0.825686 | -0.844577 | | 0.389056 | 0.360854 | | False |\n", + "| 5 | joint_training/conformer_coupling | joint_training/conformer_coupling/raw_audio/ddi/glowTTS/ | 97.7 | 1.61 | nan | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.824271 | -0.830326 | | 0.964433 | 0.725438 | | False |\n", + "| 7 | joint_training/conformer_coupling | joint_training/conformer_coupling/raw_audio/ddi/glowTTS_x_vector/ | 99.5 | 1.93 | nan | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.809305 | -0.755239 | -0.813211 | 1.00198 | 1.07779 | 1.04241 | False |\n", + "| 8 | joint_training/conformer_coupling | joint_training/conformer_coupling/raw_audio/ddi/glowTTS_ASR_conformer_x_vector/ | 5.2 | 2.14 | nan | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | 0 | 0 | 0 | 0 | 0 | 0 | False |\n", + "| 23 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/400ep/gin512/dec_drop_0.05/ | 12.9 | 3.33 | 0.02 | 400 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 400: 1e-06] | {'class': 'radam', 'epsilon': 1e-09} | -0.822881 | -0.834023 | -0.844881 | 0.376549 | 0.455059 | 0.340289 | False |\n", + "| 24 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/400ep/dec_drop_0.05/ | 12.9 | 3.33 | 0.02 | 400 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 400: 1e-06] | {'class': 'radam', 'epsilon': 1e-09} | 0 | 0 | 0 | 0 | 0 | 0 | False |\n", + "| 25 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/200ep/dec_drop_0.0/ | 96.2 | 2.29 | nan | 200 | 0 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.813627 | -0.797961 | -0.803228 | 0.975631 | 0.866819 | 0.882062 | False |\n", + "| 26 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/200ep/dec_drop_0.05/ | 14.6 | 3.26 | 0.02 | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.809709 | -0.82178 | -0.830623 | 0.390625 | 0.4432 | 0.357604 | False |\n", + "| 27 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/100ep/dec_drop_0.05/ | 16.3 | 3.18 | 0.02 | 100 | 0.05 | False | 768 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.795013 | -0.809868 | -0.816514 | 0.408781 | 0.440684 | 0.381301 | False |\n", + "| 28 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/200ep_long_cooldown/dec_drop_0.0/ | 16.7 | 3.32 | nan | 200 | 0 | False | 768 | [0: 1e-06, 49: 0.0005, 50: 0.0005, 200: 1e-06] | {'class': 'radam', 'epsilon': 1e-09} | -0.846667 | -0.76151 | -0.845555 | 0.409992 | 0.468342 | 0.378645 | False |\n", + "| 29 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/200ep_long_cooldown/dec_drop_0.05/ | 15.6 | 3.21 | nan | 200 | 0.05 | False | 768 | [0: 1e-06, 49: 0.0005, 50: 0.0005, 200: 1e-06] | {'class': 'radam', 'epsilon': 1e-09} | -0.80793 | -0.820998 | -0.829611 | 0.394024 | 0.448099 | 0.360531 | False |\n", + "| 30 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc192/200ep/dec_drop_0.05/ | 13.3 | 3.3 | nan | 200 | 0.05 | False | 192 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.811426 | -0.824218 | -0.832125 | 0.375146 | 0.412309 | 0.342878 | False |\n", + "| 31 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc192/200ep/dec_drop_0.0/ | 95.4 | 2.41 | nan | 200 | 0 | False | 192 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.841694 | -0.819818 | -0.83016 | 0.965626 | 1.15174 | 1.18063 | False |\n", + "| 32 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc192/200ep/dec_drop_0.05_epsilon_1e-8/ | 96.7 | 2.27 | nan | 200 | 0.05 | False | 192 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-08} | -0.808277 | -0.817505 | -0.821914 | 0.982278 | 0.814173 | 0.826286 | False |\n", + "| 33 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc192/200ep/dec_drop_0.05/ | 98.8 | 1.88 | nan | 200 | 0.05 | False | 192 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.809477 | -0.815064 | -0.819234 | 0.989373 | 0.615026 | 0.622701 | False |\n", + "| 34 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc192/200ep/dec_drop_0.0/grad_clip_10/ | 12.8 | 3.34 | nan | 200 | 0 | False | 192 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.852834 | -0.773976 | -0.851532 | 0.392373 | 0.431975 | 0.362269 | False |\n", + "| 35 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc192/100ep/dec_drop_0.05/ | 98.1 | 1.52 | nan | 100 | 0.05 | False | 192 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.797353 | -0.804897 | -0.808365 | 0.989832 | 0.777391 | 0.784409 | False |\n", + "| 36 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/400ep/grad_clip_10/dec_drop_0.05/ | 14.4 | 3.29 | 0.02 | 400 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 400: 1e-06] | {'class': 'radam', 'epsilon': 1e-09} | 0 | 0 | 0 | 0 | 0 | 0 | False |\n", + "| 37 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/400ep/gin512/grad_clip_10/dec_drop_0.05/ | 14.4 | 3.29 | 0.02 | 400 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 400: 1e-06] | {'class': 'radam', 'epsilon': 1e-09} | -0.824197 | -0.835761 | -0.846551 | 0.372315 | 0.440626 | 0.33371 | False |\n", + "| 38 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/200ep/dec_drop_0.0/epsilon_1e-8/ | 95.9 | 3.06 | nan | 200 | 0 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-08} | -0.82712 | -0.750288 | -0.813842 | 0.979225 | 0.454561 | 0.462357 | False |\n", + "| 39 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/200ep/dec_drop_0.0/grad_clip_10/ | 14.5 | 3.31 | nan | 200 | 0 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.850649 | -0.838267 | -0.849902 | 0.396277 | 0.445801 | 0.364157 | False |\n", + "| 40 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/200ep/dec_drop_0.05_epsilon_1e-8/ | 15.7 | 3.35 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-08} | -0.811807 | -0.826657 | -0.834532 | 0.386067 | 0.438248 | 0.351594 | False |\n", + "| 41 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/200ep/dec_drop_0.05/ | 15.1 | 3.36 | 0.02 | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.812429 | -0.827038 | -0.834987 | 0.387377 | 0.441218 | 0.352695 | False |\n", + "| 42 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/100ep/dec_drop_0.00/ | 16.3 | 3.27 | nan | 100 | 0 | False | 768 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.831177 | -0.821651 | -0.830556 | 0.409946 | 0.437995 | 0.384226 | False |\n", + "| 43 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/100ep/dec_drop_0.05/ | 17.2 | 3.3 | nan | 100 | 0.05 | False | 768 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.798251 | -0.814911 | -0.821276 | 0.397457 | 0.432689 | 0.367326 | False |\n", + "| 44 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2_logdist_loss/ed_scale_0.1/ | 95.8 | 3.09 | nan | 200 | 0.05 | False | 192 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.782615 | -0.779794 | -0.782747 | 1.08489 | 2.0684 | 2.07562 | False |\n", + "| 45 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2_logdist_loss_grad_clip_10/ed_scale_1.0/ | 98.8 | 2.27 | nan | 200 | 0.05 | False | 192 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.743438 | -0.756143 | -0.757724 | 1.13249 | 1.54302 | 1.5535 | False |\n", + "| 46 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2_logdist_loss_grad_clip_10/ed_scale_0.1/ | 95.7 | 3.21 | nan | 200 | 0.05 | False | 192 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.798058 | -0.786642 | -0.791474 | 1.07707 | 1.81449 | 1.83075 | False |\n", + "| 47 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_simple_encoder/12cb/200ep/dec_drop_0.05/ | 70.3 | 3.47 | nan | 200 | 0.05 | False | - | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.80368 | -0.821293 | -0.825658 | 0.428016 | 0.498157 | 0.402439 | False |\n", + "| 48 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_simple_encoder/20cb/200ep/dec_drop_0.05/ | 57.3 | 3.46 | nan | 200 | 0.05 | False | - | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.834191 | -0.847676 | -0.856235 | 0.402502 | 0.472223 | 0.376431 | False |\n", + "| 49 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2_conformer_coupling/enc768/200ep/dec_drop_0.05/ | 9.6 | 1.79 | 0.03 | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.842848 | -0.852489 | -0.860671 | 0.370438 | 0.41724 | 0.344025 | False |\n", + "| 50 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2_multiscale/enc768/200ep/dec_drop_0.05/ | 100 | 1.25 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.785697 | -0.800581 | -0.807986 | 0.533892 | 0.569833 | 0.522571 | False |\n", + "| 51 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_batch_norm/enc768/200ep/dec_drop_0.05/ | 15.1 | 3.4 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.80533 | -0.817184 | -0.826384 | 0.389733 | 0.44642 | 0.357169 | False |\n", + "| 52 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector/enc768/100ep/dec_drop_0.05/ | 97.9 | 1.51 | nan | 100 | 0.05 | False | 768 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.781911 | -0.787168 | -0.790923 | 0.991812 | 1.38362 | 1.38305 | False |\n", + "| 77 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS/enc256/not_silence_preprocessed/ | 97.9 | 1.69 | nan | 200 | 0 | False | 256 | [0: 5e-05, 49: 0.0005, 50: 0.0005, 200: 1e-06] | {'class': 'adam', 'epsilon': 1e-09} | -0.851128 | -0.54391 | | 0.962189 | 0.501158 | | False |\n", + "| 78 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS/enc768/with_sigma/not_silence_preprocessed/ | 15.7 | 3.35 | nan | 200 | 0 | False | 768 | [0: 5e-05, 49: 0.0005, 50: 0.0005, 200: 1e-06] | {'class': 'adam', 'epsilon': 1e-09} | -0.851343 | -0.833649 | | 0.401905 | 0.450686 | | False |\n", + "| 79 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS/enc768/with_sigma/silence_preprocessed/ | 15.3 | 3.4 | nan | 200 | 0 | False | 768 | [0: 5e-05, 49: 0.0005, 50: 0.0005, 200: 1e-06] | {'class': 'adam', 'epsilon': 1e-09} | -0.736796 | -0.463881 | | 0.371603 | 0.409141 | | False |\n", + "| 80 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS/enc768/mean_only/silence_preprocessed/ | 16.9 | 3.52 | nan | 200 | 0 | True | 768 | [0: 5e-05, 49: 0.0005, 50: 0.0005, 200: 1e-06] | {'class': 'adam', 'epsilon': 1e-09} | -0.735579 | -0.714157 | | 0.366752 | 0.410529 | | False |\n", + "| 81 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS/enc768/mean_only/not_silence_preprocessed/ | 15.5 | 3.47 | nan | 200 | 0 | True | 768 | [0: 5e-05, 49: 0.0005, 50: 0.0005, 200: 1e-06] | {'class': 'adam', 'epsilon': 1e-09} | -0.85035 | -0.763903 | | 0.395024 | 0.448581 | | False |\n", + "| 82 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS/enc192/100ep/not_silence_preprocessed/ | 14.3 | 3.31 | nan | 100 | 0 | False | 192 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'adam', 'epsilon': 1e-09} | -0.8365 | -0.770533 | | 0.406652 | 0.423657 | | False |\n", + "| 83 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS/enc192/100ep/silence_preprocessed/ | 13.5 | 3.3 | nan | 100 | 0 | False | 192 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'adam', 'epsilon': 1e-09} | -0.819508 | -0.80574 | | 0.373986 | 0.385518 | | False |\n", + "| 84 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS/enc192/200ep/long_cooldown/not_silence_preprocessed/ | 14.7 | 3.29 | nan | 200 | 0 | False | 192 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 200: 1e-07] | {'class': 'adam', 'epsilon': 1e-08} | -0.839926 | -0.694879 | | 0.411271 | 0.432932 | | False |\n", + "| 85 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS/enc192/200ep/long_cooldown/silence_preprocessed/ | 13.5 | 3.28 | nan | 200 | 0 | False | 192 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 200: 1e-07] | {'class': 'adam', 'epsilon': 1e-08} | -0.82215 | -0.807288 | | 0.377117 | 0.390598 | | False |\n", + "| 86 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS_simple_encoder/silence_preprocessed/ | 56.4 | 3.33 | nan | 100 | 0 | - | - | [0: 0.0001, 49: 0.0005, 50: 0.0005, 100: 1e-06] | {'class': 'radam', 'epsilon': 1e-09} | -0.842638 | -0.822322 | | 0.384891 | 0.428803 | | False |\n", + "| 87 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS_ddi_actnorm/enc192/100ep/not_silence_preprocessed/LR_scheduled/ | 100 | 3.12 | nan | 100 | 0 | False | 192 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'adam', 'epsilon': 1e-09} | -0.837399 | -0.801737 | | 0.42113 | 0.441682 | | False |\n", + "| 88 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS_x_vector/enc768/100ep/not_silence_preprocessed/ | 20.9 | 3.31 | nan | 100 | 0 | False | 768 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'adam', 'epsilon': 1e-09} | -0.810979 | -0.801251 | | 0.459904 | 0.467786 | | False |\n", + "| 89 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS_x_vector/enc192/100ep/not_silence_preprocessed/ | 95.4 | 2.63 | nan | 100 | 0 | False | 192 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'adam', 'epsilon': 1e-09} | -0.805523 | -0.788462 | | 0.972006 | 1.27149 | | False |\n", + "| 90 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS_nar_taco_encoder/not_silence_preprocessed/ | 25.2 | 3.46 | nan | 200 | 0 | - | - | [0: 1e-05, 49: 0.0005, 50: 0.0005, 200: 1e-05] | {'class': 'adam', 'epsilon': 1e-09} | -0.844504 | -0.70768 | | 0.411171 | 0.455673 | | False |\n", + "| 91 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS_nar_taco_encoder/silence_preprocessed/ | 25.9 | 3.39 | nan | 200 | 0 | - | - | [0: 1e-05, 49: 0.0005, 50: 0.0005, 200: 1e-05] | {'class': 'adam', 'epsilon': 1e-09} | -0.829622 | -0.813688 | | 0.386848 | 0.423963 | | False |\n", + "| 92 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS_nar_taco_encoder_no_blstm/silence_preprocessed/ | 105.6 | 3.17 | nan | 100 | 0 | - | - | [0: 0.0001, 49: 0.0005, 50: 0.0001, 100: 1e-06] | {'class': 'radam', 'epsilon': 1e-09} | -0.799977 | -0.788486 | | 0.8847 | 0.873624 | | False |\n" ] } ], @@ -1075,57 +1085,54 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "| | Group | Experiment | sWER | autoMOS | autoMOS confidence | num_epochs | decoder dropout | mean only | encoder channels | LR | Optimizer | MLE | dev MLE | devtrain MLE | DP loss | DP dev loss | DP devtrain loss | Joint |\n", - "|---:|:----------------------------------|:----------------------------------------------------------------------------------------------------------------------------------------------------|-------:|----------:|---------------------:|-------------:|------------------:|:------------|-------------------:|:-------------------------------------------------|:-------------------------------------|------:|----------:|---------------:|----------:|--------------:|-------------------:|:--------|\n", - "| 1 | joint_training/conformer_coupling | joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_two_forward_pass/ | 20.9 | 2.45 | nan | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.67 | nan | -0.69 | 0.44 | nan | 0.41 | True |\n", - "| 2 | joint_training/conformer_coupling | joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_x_vector_v2/ | 5.2 | 2.14 | nan | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.45 | -0.4 | -0.47 | 0.25 | 0.34 | 0.23 | True |\n", - "| 6 | joint_training/conformer_coupling | joint_training/conformer_coupling/raw_audio/ddi/glowTTS_ASR_conformer_two_forward_pass/ | 95.7 | 1.82 | nan | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.66 | nan | -0.67 | 1 | nan | 2.09 | True |\n", - "| 8 | joint_training/conformer_coupling | joint_training/conformer_coupling/raw_audio/ddi/glowTTS_ASR_conformer_x_vector/ | 5.2 | 2.14 | nan | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.45 | -0.4 | -0.47 | 0.25 | 0.34 | 0.23 | True |\n", - "| 9 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1/ | 4.6 | 3.11 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.74 | -0.69 | -0.76 | 0.35 | 0.48 | 0.33 | True |\n", - "| 10 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass/ | 9.5 | 2.75 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.61 | -0.56 | -0.63 | 0.42 | 0.58 | 0.4 | True |\n", - "| 11 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/ | 11.2 | 3.18 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.76 | -0.69 | -0.78 | 0.4 | 0.56 | 0.38 | True |\n", - "| 12 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_ctc_scale_0.1/ | 13.3 | 3.12 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.75 | -0.69 | -0.77 | 0.42 | 0.57 | 0.4 | True |\n", - "| 13 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment/ | 5.2 | 2.3 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.51 | -0.46 | -0.52 | 0.25 | 0.35 | 0.23 | True |\n", - "| 14 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/ | 9.9 | 2.64 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.62 | -0.57 | -0.64 | 0.4 | 0.55 | 0.38 | True |\n", - "| 15 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/ | 7.9 | 3.19 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.75 | -0.7 | -0.77 | 0.37 | 0.51 | 0.35 | True |\n", - "| 16 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/ | 6.7 | 2.48 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.58 | -0.53 | -0.59 | 0.35 | 0.46 | 0.33 | True |\n", - "| 17 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_ctc_scale_0.1/ | 7.6 | 3.15 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.75 | -0.7 | -0.77 | 0.38 | 0.5 | 0.36 | True |\n", - "| 18 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/ | 4.4 | 3.2 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.75 | -0.69 | -0.76 | 0.33 | 0.46 | 0.31 | True |\n", - "| 19 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/ | 14.8 | 2.61 | 0.03 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.68 | nan | -0.7 | 0.4 | nan | 0.37 | True |\n", - "| 20 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/ | 6 | 2.32 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.52 | -0.47 | -0.54 | 0.23 | 0.35 | 0.2 | True |\n", - "| 21 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/ | 15.2 | 3.16 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.78 | nan | -0.81 | 0.38 | nan | 0.36 | True |\n", - "| 22 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector/ | 98 | 1.58 | 0.01 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.55 | -0.5 | -0.55 | 1.02 | 0.82 | 0.7 | True |\n", - "| 51 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/specaug/ce_ls_0.1/ | 25.2 | 3.11 | nan | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.8 | -0.82 | -0.82 | 0.43 | 0.46 | 0.41 | True |\n", - "| 52 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/specaug/ce_ls_1/ | 88.5 | 1.87 | nan | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.72 | -0.73 | -0.74 | 0.75 | 0.79 | 0.69 | True |\n", - "| 53 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/200ep/basic_init/no_specaug/tts_target_size/ce_ls_0.1/ | 98.1 | 1.82 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.79 | -0.79 | -0.8 | 0.89 | 0.57 | 0.58 | True |\n", - "| 54 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/200ep/tts_pretrained/no_specaug/tts_target_size/ce_ls_0.1/ | 32.9 | 2.77 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.8 | -0.82 | -0.83 | 0.44 | 0.49 | 0.41 | True |\n", - "| 55 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/no_specaug/ce_ls_1/ | 83.9 | 1.92 | nan | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.69 | -0.7 | -0.71 | 0.76 | 0.94 | 0.72 | True |\n", - "| 56 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/no_specaug/ce_ls_0.1/ | 41.9 | 2.75 | nan | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.79 | -0.81 | -0.82 | 0.51 | 0.54 | 0.49 | True |\n", - "| 57 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_cnn_x_vector/tts_pretrained/no_specaug/tts_target_size/ce_ls_0.1/ | 14.1 | 3.2 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.79 | -0.81 | -0.81 | 0.4 | 0.45 | 0.36 | True |\n", - "| 58 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_cnn_x_vector/basic_init/no_specaug/tts_target_size/ce_ls_0.1/ | 23.3 | 3.13 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.78 | -0.79 | -0.79 | 0.43 | 0.48 | 0.4 | True |\n", - "| 59 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/mean_only/200ep/basic_init/no_specaug/tts_target_size/ce_ls_0.1/ | 96.4 | 2.37 | nan | 200 | 0.05 | True | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.8 | -0.8 | -0.81 | 0.93 | 0.72 | 0.73 | True |\n", - "| 60 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/200ep/tts_pretrained/no_specaug/tts_target_size/ce_ls_0.1/ | 91.7 | 2.66 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.81 | -0.82 | -0.83 | 0.63 | 0.63 | 0.59 | True |\n", - "| 61 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/no_specaug/tts_target_size/ce_ls_1.0/ | 97.2 | 2.12 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.8 | -0.8 | -0.81 | 0.83 | 0.61 | 0.62 | True |\n", - "| 62 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/no_specaug/tts_target_size/ce_ls_0.1/ | 99.9 | 1.56 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.8 | -0.77 | -0.8 | 0.82 | 0.53 | 0.54 | True |\n", - "| 63 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector_v2/tts_pretrained/ce_ls_0.1/ | 99.7 | 1.83 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.79 | -0.81 | -0.81 | 0.05 | 0.05 | 0.04 | True |\n", - "| 64 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector_v2/tts_pretrained/ce_ls_0.01/ | 97.2 | 1.97 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.8 | -0.81 | -0.82 | 0.06 | 0.06 | 0.05 | True |\n", - "| 65 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector_v2/basic_init/ce_ls_0.1/ | 99.1 | 1.64 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.78 | -0.8 | -0.8 | 0.05 | 0.05 | 0.04 | True |\n", - "| 66 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector_v2/basic_init/ce_ls_0.01/ | 98.2 | 2.18 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.79 | -0.8 | -0.81 | 0.06 | 0.06 | 0.05 | True |\n", - "| 67 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector_v2/200ep/tts_pretrained/ce_ls_1.0/ | 100 | 1.97 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.73 | -0.75 | -0.75 | 0.08 | 0.08 | 0.07 | True |\n", - "| 68 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector_v2/200ep/tts_pretrained/ce_ls_0.1/ | 100 | 1.98 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.76 | -0.78 | -0.78 | 0.08 | 0.08 | 0.07 | True |\n", - "| 69 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/ce_ls_1.0/ | 100 | 1.98 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.73 | -0.74 | -0.75 | 0.07 | 0.08 | 0.06 | True |\n", - "| 70 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/ce_ls_0.1/ | 100 | 1.98 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.76 | -0.77 | -0.78 | 0.07 | 0.08 | 0.06 | True |\n", - "| 71 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector/200ep/basic_init/ce_ls_0.1/ | 97.9 | 1.78 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.78 | -0.79 | -0.8 | 0.26 | 0.24 | 0.25 | True |\n", - "| 72 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector/200ep/tts_pretrained/ce_ls_0.1/ | 95.4 | 2.53 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.79 | -0.81 | -0.81 | 0.25 | 0.22 | 0.23 | True |\n", - "| 73 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector/tts_pretrained/ce_ls_0.1/ | 95.2 | 2.18 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.78 | -0.79 | -0.79 | 0.26 | 0.24 | 0.25 | True |\n", - "| 74 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector/basic_init/ce_ls_0.1/ | 96.1 | 2.35 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.77 | -0.78 | -0.79 | 0.27 | 0.26 | 0.26 | True |\n" + "| | Group | Experiment | sWER | autoMOS | autoMOS confidence | num_epochs | decoder dropout | mean only | encoder channels | LR | Optimizer | MLE | dev MLE | devtrain MLE | DP loss | DP dev loss | DP devtrain loss | Joint |\n", + "|---:|:----------------------------------|:----------------------------------------------------------------------------------------------------------------------------------------------------|-------:|----------:|---------------------:|-------------:|------------------:|:------------|-------------------:|:-------------------------------------------------|:-------------------------------------|----------:|----------:|---------------:|----------:|--------------:|-------------------:|:--------|\n", + "| 6 | joint_training/conformer_coupling | joint_training/conformer_coupling/raw_audio/ddi/glowTTS_ASR_conformer_two_forward_pass/ | 95.7 | 1.82 | nan | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.657168 | | -0.670671 | 1.0046 | | 2.09134 | True |\n", + "| 9 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1/ | 4.6 | 3.11 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.74139 | -0.690156 | -0.759844 | 0.346902 | 0.481245 | 0.329289 | True |\n", + "| 10 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass/ | 9.5 | 2.75 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.610471 | -0.555647 | -0.629746 | 0.416831 | 0.583815 | 0.403638 | True |\n", + "| 11 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/ | 11.2 | 3.18 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.758909 | -0.69436 | -0.778751 | 0.400894 | 0.55533 | 0.379635 | True |\n", + "| 12 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_ctc_scale_0.1/ | 13.3 | 3.12 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.753013 | -0.694853 | -0.771774 | 0.417359 | 0.565613 | 0.399888 | True |\n", + "| 13 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment/ | 5.2 | 2.3 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.506816 | -0.458788 | -0.521236 | 0.245737 | 0.346906 | 0.225934 | True |\n", + "| 14 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/ | 9.9 | 2.64 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.621646 | -0.565345 | -0.641523 | 0.402243 | 0.552866 | 0.379653 | True |\n", + "| 15 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/ | 7.9 | 3.19 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.754171 | -0.704233 | -0.772961 | 0.369618 | 0.50542 | 0.346386 | True |\n", + "| 16 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/ | 6.7 | 2.48 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.577228 | -0.531676 | -0.591349 | 0.349734 | 0.46387 | 0.326762 | True |\n", + "| 17 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_ctc_scale_0.1/ | 7.6 | 3.15 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.750811 | -0.700515 | -0.769183 | 0.380467 | 0.502884 | 0.36247 | True |\n", + "| 18 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/ | 4.4 | 3.2 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.745622 | -0.693835 | -0.764738 | 0.330255 | 0.457476 | 0.306534 | True |\n", + "| 19 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/ | 14.8 | 2.61 | 0.03 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.679734 | | -0.699266 | 0.399065 | | 0.370426 | True |\n", + "| 20 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/ | 6 | 2.32 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.520932 | -0.470559 | -0.535346 | 0.229065 | 0.345538 | 0.203592 | True |\n", + "| 21 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/ | 15.2 | 3.16 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.784652 | | -0.805268 | 0.383526 | | 0.355401 | True |\n", + "| 22 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector/ | 98 | 1.58 | 0.01 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.552728 | -0.497187 | -0.548408 | 1.01904 | 0.823625 | 0.701494 | True |\n", + "| 53 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/specaug/ce_ls_0.1/ | 25.2 | 3.11 | nan | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.802836 | -0.81678 | -0.823897 | 0.434087 | 0.464465 | 0.407059 | True |\n", + "| 54 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/specaug/ce_ls_1/ | 88.5 | 1.87 | nan | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.72108 | -0.734634 | -0.74084 | 0.747725 | 0.789389 | 0.691204 | True |\n", + "| 55 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/200ep/basic_init/no_specaug/tts_target_size/ce_ls_0.1/ | 98.1 | 1.82 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.785492 | -0.790627 | -0.79625 | 0.890597 | 0.574966 | 0.575373 | True |\n", + "| 56 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/200ep/tts_pretrained/no_specaug/tts_target_size/ce_ls_0.1/ | 32.9 | 2.77 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.803716 | -0.816318 | -0.825113 | 0.439343 | 0.490279 | 0.409061 | True |\n", + "| 57 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/no_specaug/ce_ls_1/ | 83.9 | 1.92 | nan | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.690569 | -0.702706 | -0.708801 | 0.760198 | 0.943391 | 0.716967 | True |\n", + "| 58 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/no_specaug/ce_ls_0.1/ | 41.9 | 2.75 | nan | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.794999 | -0.80951 | -0.816001 | 0.505974 | 0.538897 | 0.493393 | True |\n", + "| 59 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_cnn_x_vector/tts_pretrained/no_specaug/tts_target_size/ce_ls_0.1/ | 14.1 | 3.2 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.793062 | -0.805013 | -0.81407 | 0.39621 | 0.451179 | 0.36325 | True |\n", + "| 60 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_cnn_x_vector/basic_init/no_specaug/tts_target_size/ce_ls_0.1/ | 23.3 | 3.13 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.77557 | -0.785888 | -0.794856 | 0.432057 | 0.483314 | 0.399083 | True |\n", + "| 61 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/mean_only/200ep/basic_init/no_specaug/tts_target_size/ce_ls_0.1/ | 96.4 | 2.37 | nan | 200 | 0.05 | True | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.803728 | -0.802102 | -0.808006 | 0.932394 | 0.721534 | 0.725609 | True |\n", + "| 62 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/200ep/tts_pretrained/no_specaug/tts_target_size/ce_ls_0.1/ | 91.7 | 2.66 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.805783 | -0.821988 | -0.827055 | 0.625962 | 0.62989 | 0.592278 | True |\n", + "| 63 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/no_specaug/tts_target_size/ce_ls_1.0/ | 97.2 | 2.12 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.801181 | -0.803144 | -0.808404 | 0.834689 | 0.611662 | 0.619833 | True |\n", + "| 64 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/no_specaug/tts_target_size/ce_ls_0.1/ | 99.9 | 1.56 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.799504 | -0.772613 | -0.798104 | 0.818331 | 0.531823 | 0.536853 | True |\n", + "| 65 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector_v2/tts_pretrained/ce_ls_0.1/ | 99.7 | 1.83 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.790621 | -0.805995 | -0.811551 | 0.0523576 | 0.0489216 | 0.0415039 | True |\n", + "| 66 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector_v2/tts_pretrained/ce_ls_0.01/ | 97.2 | 1.97 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.797074 | -0.812303 | -0.818065 | 0.0631472 | 0.0577708 | 0.0508676 | True |\n", + "| 67 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector_v2/basic_init/ce_ls_0.1/ | 99.1 | 1.64 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.782616 | -0.797878 | -0.803697 | 0.0519058 | 0.0493118 | 0.0413708 | True |\n", + "| 68 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector_v2/basic_init/ce_ls_0.01/ | 98.2 | 2.18 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.787278 | -0.802672 | -0.808277 | 0.0638544 | 0.0582362 | 0.0520775 | True |\n", + "| 69 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector_v2/200ep/tts_pretrained/ce_ls_1.0/ | 100 | 1.97 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.72889 | -0.745734 | -0.75171 | 0.075977 | 0.0820037 | 0.0666421 | True |\n", + "| 70 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector_v2/200ep/tts_pretrained/ce_ls_0.1/ | 100 | 1.98 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.760167 | -0.775606 | -0.781364 | 0.075069 | 0.0806164 | 0.0651269 | True |\n", + "| 71 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/ce_ls_1.0/ | 100 | 1.98 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.729906 | -0.74441 | -0.750384 | 0.0698329 | 0.0841703 | 0.0607633 | True |\n", + "| 72 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/ce_ls_0.1/ | 100 | 1.98 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.757141 | -0.771994 | -0.778037 | 0.071102 | 0.0818373 | 0.0614895 | True |\n", + "| 73 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector/200ep/basic_init/ce_ls_0.1/ | 97.9 | 1.78 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.779347 | -0.79411 | -0.800602 | 0.255822 | 0.238816 | 0.246318 | True |\n", + "| 74 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector/200ep/tts_pretrained/ce_ls_0.1/ | 95.4 | 2.53 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.792338 | -0.806682 | -0.812767 | 0.247139 | 0.215995 | 0.232498 | True |\n", + "| 75 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector/tts_pretrained/ce_ls_0.1/ | 95.2 | 2.18 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.775121 | -0.788423 | -0.794789 | 0.263264 | 0.235715 | 0.253516 | True |\n", + "| 76 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector/basic_init/ce_ls_0.1/ | 96.1 | 2.35 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.76667 | -0.781423 | -0.785757 | 0.265068 | 0.264766 | 0.261945 | True |\n" ] } ], @@ -1135,7 +1142,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 17, "metadata": {}, "outputs": [ { @@ -1144,13 +1151,13 @@ "" ] }, - "execution_count": 20, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1165,7 +1172,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 18, "metadata": {}, "outputs": [ { @@ -1174,13 +1181,13 @@ "" ] }, - "execution_count": 21, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1195,7 +1202,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 19, "metadata": {}, "outputs": [ { @@ -1204,13 +1211,13 @@ "" ] }, - "execution_count": 22, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1225,7 +1232,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 20, "metadata": {}, "outputs": [ { @@ -1234,13 +1241,13 @@ "" ] }, - "execution_count": 23, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjcAAAGwCAYAAABVdURTAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA5U0lEQVR4nO3de3hU9YH/8c/kQkiATIDcQAMJJtVyESMQCKEBKpUiVal26+bHLqjoPm65iJbtSl3ddavEbuulRlu0KjRtQbyitValkJACkXusrhZDc4EqgQm5kQRBkvP7w82UIclkJpnJnDnzfj3PPI/5njMz3znBnM98rzbDMAwBAABYRFigKwAAAOBLhBsAAGAphBsAAGAphBsAAGAphBsAAGAphBsAAGAphBsAAGApEYGuQH9rb2/XZ599piFDhshmswW6OgAAwAOGYejUqVMaOXKkwsLct82EXLj57LPPlJKSEuhqAACAXjh69Kguvvhit+eEXLgZMmSIpC8vTmxsbIBrAwAAPNHU1KSUlBTnfdydkAs3HV1RsbGxhBsAAIKMJ0NKGFAMAAAshXADAAAshXADAAAshXADAAAshXADAAAshXADAAAshXADAAAshXADAAAshXADAAAshXADAAAsJeS2XwAAIJhUOJpVXdeq1OGDlBY/KNDVCQqEGwAATKih9axWbCxTSbnDWZabkaCCvEzZYyIDWDPzo1sKAAATWrGxTDsP17qU7Txcq+UbDwaoRsGDcAMAgMlUOJpVUu5Qm2G4lLcZhkrKHaqsbQlQzYID4QYAAJOprmt1e7zqJOHGHcINAAAmM3pYjNvjqcMZWOwO4QYAAJMZkzBYuRkJCrfZXMrDbTblZiQwa6oHhBsAAEyoIC9TOenxLmU56fEqyMsMUI2CB1PBAQAwIXtMpAqXZKmytkVVJ1tY58YLhBsAAEwsLZ5Q4y26pQAAgKUENNzk5+drypQpGjJkiBITE7VgwQIdOnSox+e99NJLuuyyyzRw4EBNmDBBb731Vj/UFgAABIOAhpvt27dr6dKleu+997RlyxZ98cUXuvrqq9XS0v38/V27dikvL09LlizRwYMHtWDBAi1YsEAffvhhP9YcAACYlc0wLlj+MIAcDocSExO1fft25ebmdnnOTTfdpJaWFr355pvOsmnTpumKK67Q2rVre3yPpqYm2e12NTY2KjY21md1BwAA/uPN/dtUY24aGxslScOGDev2nNLSUs2ZM8elbO7cuSotLe3y/DNnzqipqcnlAQAArMs04aa9vV0rV65UTk6Oxo8f3+15NTU1SkpKcilLSkpSTU1Nl+fn5+fLbrc7HykpKT6tNwAAMBfThJulS5fqww8/1AsvvODT1129erUaGxudj6NHj/r09QEAgLmYYp2bZcuW6c0331RJSYkuvvhit+cmJyfr+PHjLmXHjx9XcnJyl+dHRUUpKirKZ3UFAADmFtCWG8MwtGzZMr322mvatm2b0tLSenxOdna2tm7d6lK2ZcsWZWdn+6uaAAAgiAS05Wbp0qXasGGDXn/9dQ0ZMsQ5bsZutys6OlqStGjRIl100UXKz8+XJN15552aOXOmHnnkEc2fP18vvPCC9u3bp2eeeSZgnwMAAJhHQFtufvGLX6ixsVGzZs3SiBEjnI9NmzY5zzly5IiOHTvm/Hn69OnasGGDnnnmGU2cOFEvv/yyNm/e7HYQMgAACB2mWuemP7DODQAAwSdo17kBAADoK8INAACwFMINAACwFMINAACwFMINAACwFMINAACwFMINAACwFMINAACwFMINAACwFMINAACwFMINAACwFMINAACwFMINAACwFMINAACwFMINAACwFMINAACwFMINAACwFMINAACwFMINAACwlIhAVwAAAHSvwtGs6rpWpQ4fpLT4QYGuTlAg3AAAYEINrWe1YmOZSsodzrLcjAQV5GXKHhMZwJqZH91SAACY0IqNZdp5uNalbOfhWi3feDBANQoehBsAAEymwtGsknKH2gzDpbzNMFRS7lBlbUuAahYcCDcAAJhMdV2r2+NVJwk37hBuAAAwmdHDYtweTx3OwGJ3CDcAAJjMmITBys1IULjN5lIebrMpNyOBWVM9INwAAGBCBXmZykmPdynLSY9XQV5mgGoUPJgKDgCACdljIlW4JEuVtS2qOtnCOjdeINwAAGBiafGEGm/RLQUAACyFcAMAACyFcAMAACyFcAMAACyFcAMAACyFcAMAACyFcAMAACyFcAMAACyFcAMAACyFcAMAACyFcAMAACyFcAMAACyFcAMAACyFcAMAACyFcAMAACyFcAMAACyFcAMAACyFcAMAACyFcAMAACyFcAMAACyFcAMAACyFcAMAACyFcAMAACyFcAMAACyFcAMAACyFcAMAACyFcAMAACyFcAMAACyFcAMAACyFcAMAACyFcAMAACyFcAMAACyFcAMAACyFcAMAACwlItAVAAAAvlXhaFZ1XatShw9SWvygQFen3xFuAACwiIbWs1qxsUwl5Q5nWW5GggryMmWPiQxgzfoX3VIAAFjEio1l2nm41qVs5+FaLd94MEA1CgzCDQAAFlDhaFZJuUNthuFS3mYYKil3qLK2JUA163+EGwAALKC6rtXt8aqThBsAABBERg+LcXs8dXjoDCwm3AAAYAFjEgYrNyNB4TabS3m4zabcjISQmjVFuAEAwCIK8jKVkx7vUpaTHq+CvMwA1SgwAhpuSkpKdO2112rkyJGy2WzavHmz2/OLi4tls9k6PWpqavqnwgAAmJg9JlKFS7JUtGqW1t0yRUWrZqlwSVZITQOXArzOTUtLiyZOnKhbb71VN9xwg8fPO3TokGJjY50/JyYm+qN6AAAEpbT40Fy8r0NAw828efM0b948r5+XmJiouLg4j849c+aMzpw54/y5qanJ6/cDAADBIyjH3FxxxRUaMWKEvvGNb2jnzp1uz83Pz5fdbnc+UlJS+qmWAAAgEIIq3IwYMUJr167VK6+8oldeeUUpKSmaNWuWDhw40O1zVq9ercbGRufj6NGj/VhjAADQ34Jqb6lLL71Ul156qfPn6dOn669//asee+wx/frXv+7yOVFRUYqKiuqvKgIAgAALqpabrmRlZenw4cOBrgYAADCJoA83ZWVlGjFiRKCrAQAATCKg3VLNzc0urS6VlZUqKyvTsGHDNGrUKK1evVqffvqpCgsLJUmPP/640tLSNG7cOH3++ed69tlntW3bNr377ruB+ggAAMBkAhpu9u3bp9mzZzt/vvvuuyVJixcv1vr163Xs2DEdOXLEefzs2bP6/ve/r08//VQxMTG6/PLL9cc//tHlNQAAQGizGcYFe6NbXFNTk+x2uxobG10WAgQAAOblzf076MfcAAAAnI9wAwAALIVwAwAALIVwAwAALIVwAwAALIVwAwAALIVwAwAALCWoNs4EAACdVTiaVV3XqtThg5QWPyjQ1Qk4wg0AAEGqofWsVmwsU0m5w1mWm5GggrxM2WMiA1izwKJbCgCAILViY5l2Hq51Kdt5uFbLNx4MUI3MgXADAEAQqnA0q6TcobYLdlFqMwyVlDtUWdsSoJoFHuEGAIAgVF3X6vZ41UnCDQAACCKjh8W4PZ46PHQHFhNuAAAIQmMSBis3I0HhNptLebjNptyMhJCeNUW4AQAgSBXkZSonPd6lLCc9XgV5mQGqkTkwFRwAgCBlj4lU4ZIsVda2qOpkC+vc/B/CDQAAQS4tnlBzPrqlAACApRBuAACApRBuAACApRBuAACApRBuAACApRBuAACApRBuAACApRBuAACApbCIHwAAJlThaFZ1XSurDvcC4QYAABNpaD2rFRvLVFLucJblZiSoIC9T9pjIANYseNAtBQCAiazYWKadh2tdynYertXyjQcDVKPgQ7gBAMAkKhzNKil3qM0wXMrbDEMl5Q5V1rYEqGbBhXADAIBJVNe1uj1edZJw4wmvw83p06fV2vr3i19dXa3HH39c7777rk8rBgBAqBk9LMbt8dThDCz2hNfh5vrrr1dhYaEkqaGhQVOnTtUjjzyi66+/Xr/4xS98XkEAAELFmITBys1IULjN5lIebrMpNyOBWVMe8jrcHDhwQF/72tckSS+//LKSkpJUXV2twsJCPfHEEz6vIAAAoaQgL1M56fEuZTnp8SrIywxQjYKP11PBW1tbNWTIEEnSu+++qxtuuEFhYWGaNm2aqqurfV5BAABCiT0mUoVLslRZ26Kqky2sc9MLXrfcpKena/PmzTp69KjeeecdXX311ZKkEydOKDY21ucVBAAgFKXFD9LsSxMJNr3gdbi5//77tWrVKqWmpmrq1KnKzs6W9GUrTmYmTWYAACCwbIZxwWR6D9TU1OjYsWOaOHGiwsK+zEd79uxRbGysLrvsMp9X0peamppkt9vV2NhISxMAAEHCm/t3r7ZfSE5OVnJysvPNtm3bpksvvdT0wQYAAFif191S3/3ud/Xkk09K+nLNm8mTJ+u73/2uLr/8cr3yyis+ryAAAIA3vA43JSUlzqngr732mgzDUENDg5544gk9+OCDPq8gAACAN7wON42NjRo2bJgk6e2339aNN96omJgYzZ8/X+Xl5T6vIAAAgDe8DjcpKSkqLS1VS0uL3n77bedU8Pr6eg0cONDnFQQAAPCG1wOKV65cqYULF2rw4MEaPXq0Zs2aJenL7qoJEyb4un4AAABe8TrcfO9731NWVpaOHj2qb3zjG86p4GPGjGHMDQAACLherXPToeOptgs2+DIz1rkBACD4eHP/9nrMjSQVFhZqwoQJio6OVnR0tC6//HL9+te/7lVlAQBAZxWOZhUdOqHK2pZAVyXoeN0t9eijj+q+++7TsmXLlJOTI0nasWOH7rjjDtXW1uquu+7yeSUBAAgVDa1ntWJjmUrKHc6y3IwEFeRlyh4TGcCaBQ+vu6XS0tL0wAMPaNGiRS7lv/rVr/Rf//Vfqqys9GkFfY1uKQCAmS16bo92Hq5V23m353CbTTnp8SpckhXAmgWWX7uljh07punTp3cqnz59uo4dO+btywEAgP9T4WhWSbnDJdhIUpthqKTcQReVh7wON+np6XrxxRc7lW/atEkZGRk+qRQAAKGouq7V7fGqk4QbT3g95uaBBx7QTTfdpJKSEueYm507d2rr1q1dhh4AAOCZ0cNi3B5PHT6on2oS3Lxuubnxxhu1e/duxcfHa/Pmzdq8ebPi4+O1Z88effvb3/ZHHQEACAljEgYrNyNB4RcssRJusyk3I0Fp8YQbT/RpnZtgxIBiAICZNbZ+oeUbDzJb6gLe3L896pZqamry+M0JDAAA9J49JlKFS7JUWduiqpMtSh0+iBYbL3kUbuLi4npchdgwDNlsNrW1tfmkYgAAhLK0eEJNb3kUboqKivxdDwAAAJ/wKNzMnDnT3/UAAADwCa+nggMAgOBS4WhWdV1ryIzfIdwAAGBRobpPVa92BQcAAOa3YmOZdh6udSnbebhWyzceDFCN+gfhBgAACwrlfaq8DjcPPvig6Xf+BgAg1IXyPlVeh5uXXnpJ6enpmj59un7+85+rtra25ycBAIB+Fcr7VHkdbt5//339+c9/1qxZs/TTn/5UI0eO1Pz587Vhwwa1trpPiQAAoH+E8j5Vfd5baufOndqwYYNeeuklff75515t1RAI7C0FAAgVVtqnyud7S7kzaNAgRUdHa8CAATp16lRfXw4AAPhIqO5T1avZUpWVlXrooYc0btw4TZ48WQcPHtQDDzygmpoaX9cPAAD0UVr8IM2+NDEkgo3Ui5abadOmae/evbr88st1yy23KC8vTxdddJE/6gYAAOA1r8PNVVddpeeff15jx471R30AAAD6pNcDis+ePavKykpdcskliogInl0cGFAMAEDw8eb+7fWYm9OnT2vJkiWKiYnRuHHjdOTIEUnS8uXL9fDDD3v1WiUlJbr22ms1cuRI2Ww2bd68ucfnFBcX68orr1RUVJTS09O1fv16bz8CAACwMK/DzT333KP3339fxcXFGjhwoLN8zpw52rRpk1ev1dLSookTJ+qpp57y6PzKykrNnz9fs2fPVllZmVauXKnbbrtN77zzjlfvCwAArMvr/qTNmzdr06ZNmjZtmmznLQw0btw4/fWvf/XqtebNm6d58+Z5fP7atWuVlpamRx55RJL01a9+VTt27NBjjz2muXPndvmcM2fO6MyZM86fzb4ODwAA6BuvW24cDocSExM7lbe0tLiEHX8oLS3VnDlzXMrmzp2r0tLSbp+Tn58vu93ufKSkpPi1jgAAILC8DjeTJ0/W73//e+fPHYHm2WefVXZ2tu9q1oWamholJSW5lCUlJampqUmnT5/u8jmrV69WY2Oj83H06FG/1hEAAASW191Sa9as0bx58/TRRx/p3Llz+tnPfqaPPvpIu3bt0vbt2/1Rxz6JiopSVFRUoKsBAAD6idctNzNmzFBZWZnOnTunCRMm6N1331ViYqJKS0s1adIkf9TRKTk5WcePH3cpO378uGJjYxUdHe3X9wYAAMGhVwvUXHLJJfrlL3/p67r0KDs7W2+99ZZL2ZYtW/zeHQYAAIKHR+HGmxlG3iyM19zcrMOHDzt/rqysVFlZmYYNG6ZRo0Zp9erV+vTTT1VYWChJuuOOO/Tkk0/qBz/4gW699VZt27ZNL774ossYIAAAENo8CjdxcXEez4Rqa2vz+M337dun2bNnO3++++67JUmLFy/W+vXrdezYMecigZKUlpam3//+97rrrrv0s5/9TBdffLGeffbZbqeBAwBCS4WjWdV1rSGz+zW65tH2C+cPFK6qqtI999yjm2++2dkdVFpaql/96lfKz8/X4sWL/VdbH2D7BQCwnobWs1qxsUwl5Q5nWW5GggryMmWPiQxgzeAr3ty/vd5b6qqrrtJtt92mvLw8l/INGzbomWeeUXFxsdcV7k+EGwCwnkXP7dHOw7VqO++WFm6zKSc9XoVLsgJYM/iKX/eWKi0t1eTJkzuVT548WXv27PH25QAA6JMKR7NKyh0uwUaS2gxDJeUOVda2BKhmCBSvw01KSkqXM6WeffZZVv8FAPS76rpWt8erThJuQo3XU8Efe+wx3XjjjfrDH/6gqVOnSpL27Nmj8vJyvfLKKz6vIAAA7oweFuP2eOpwBhaHGq9bbq655hqVl5fruuuuU11dnerq6nTttdfqk08+0TXXXOOPOgIA0K0xCYOVm5Gg8Atm9YbbbMrNSGDWVAjyekBxsGNAMQBYT2PrF1q+8SCzpSzMm/t3r1YoBgDATOwxkSpckqXK2hZVnWxhnZsQR7gBAFhGWjyhBr0YcwMAAGBmtNwAAACfMcMWGF6Fm/fee0+/+93vdPbsWV111VX65je/6a96AQCA85ghNLhjpi0wPJ4t9fLLL+umm25SdHS0IiMj1dTUpB//+MdatWqVv+voU8yWAgAEEzOFBnf8vQWGX7ZfyM/P1+23367GxkbV19frwQcf1Jo1a/pcWQAA0L0VG8u083CtS9nOw7VavvFggGrUmdm2wPA43Bw6dEirVq1SeHi4JOn73/++Tp06pRMnTvitcgAAhDKzhYbumG0LDI/DTWtrq0sz0IABAzRw4EA1Nzf7pWIAAIQ6s4WG7phtCwyvBhQ/++yzGjx4sPPnc+fOaf369YqPj3eWrVixwne1AwAghJktNHSnYwuM7sbc9PcAaI8HFKempsp2wb4dnV7MZlNFRYVPKuYvDCgGAAQTfw/U9RV/b4Hhzf2bvaUAADAxT0ODWaaK+2sLDMKNG4QbAEAw6i40BMtU8b7yy1RwSWpvb9fzzz+vb33rWxo/frwmTJig6667ToWFhQqxjAQAQL9Kix+k2ZcmyjAMFR064ZwpFQxTxfubxwOKDcPQddddp7feeksTJ07UhAkTZBiGPv74Y91888169dVXtXnzZj9WFQCA0NVVC82U1KHaW1Xf6dzzp4qbcTVjf/M43Kxfv14lJSXaunWrZs+e7XJs27ZtWrBggQoLC7Vo0SKfVxIAgFDXVQvN/urOweZ8VSdDM9x43C21ceNG/fCHP+wUbCTp61//uu655x799re/9WnlAABA94v5tfcwIsQsU8X7m8fh5s9//rPbjTLnzZun999/3yeVAgDALCoczS5jXAKhp8X8LryZh9tsys1ICMlWG8mLbqm6ujolJSV1ezwpKUn19e6bxwAACBZmmoXU02J+k0YP1d7zuqhy0uNVkJfp72qZlsfhpq2tTRER3Z8eHh6uc+fO+aRSAAAEmrtZSP29eF5PKwAXLslSyScOHTxarytHDdXXMhL6tX5m49VsqZtvvllRUVFdHj9z5ozPKgUAQCB1jHG5UCBnIRXkZXZazC8nPV4PLhivRc/tMUULk1l4HG4WL17c4znMlAIAWIEnG1b2d7ixx0SqcElWp8X8OrZnOF+gWpjMwuNws27dOn/WAwAA0zDzhpVp8X9fodiMLUxm4NUKxQAAhIKOMS7hF2wYbbZZSJ60MIUiwg0AAF0oyMtUTnq8S5nZZiGZuYUpkDzulgIAIJR0N8bFTHqaRWW2+vYXWm4AAHCjY8NKswaFYGhh6m+03AAAEMTsMZH6r+vGandlnWySpo4Zbtog1l8INwAABIkKR7Oq61qdXWRmWkXZTAg3AACYXHch5ou2du2prHM5N9TXuJEINwAAmF5XW0HsOOzoclfwUF/jRmJAMQAAptaxUN/5s6EkdRlszheqa9xIhBsAAEytp4X6uhOqa9xIdEsBAGBqPS3UFyap/byfQ32NG4mWGwAATM3dVhDTLxmuGRkJLuWhvsaNRMsNAACmV5CXqeUbD7rMluoIMfaYSFOvohwINsMwehiSZC1NTU2y2+1qbGxUbGxsoKsDAIDHQjnEeHP/puUGAIAgkRYfeqGmNxhzAwAALIVwAwAALIVwAwAALIVwAwAALIVwAwAALIXZUgAA+EGFo1nVda0hOW070Ag3AAD4UEPrWa3YWOay4F5uRoJzwT34H91SAAD40IqNZdp5uNalbOfhWi3feLDf6lDhaFbRoROqrA3NncFpuQEAwEcqHM0uLTYd2gxDJeUOVda2+KyLqqtuL1qNvkS4AQDAR6rrWt0erzrZ93DjLsC4azUqXJLVp/cNJnRLAQDgI6OHxbg9njq876023QWY2wr3qqTcobYLtow8v9UoVBBuAADwkTEJg5WbkaBwm82lPNxmU25GQp9bbTq6vboKMHur6t0+t+ok4QYmE+qDwwAgWBTkZSonPd6lLCc9XgV5mX1+7Z66vdzxRatRsGDMjckxOAwAgos9JlKFS7JUWduiqpMtPl3npqdurymjh+rAkQaXlp1wm0056fEhtdYOLTcmZ4YphQAA76XFD9LsSxN9GircdXtNSR2qm6en6spRcS7Hzm81CpVeAFpuTMyXUwpZKRMArKEgL1PLNx50uT/ERkdob1W9c9zNlNShWjw9VeNG2pUWP0gNrWe16Lk9IdMLQLgxMV9MKaRbCwCs5cJur59vO6wDRxpczjlQ3aDoyL+pcMlISe57Aaw4RZxuKRPzdEqhu2ZGurUAwJrS4gdp9LAY7a2udzv9290MK6tOEaflxsQ6+lZ3lDvUfsGxoTGRCrfJbTNjf66UCQDof5608PfEFwsLmg0tNybXXfdR0+kvdP1TO922yvjiHz2sIVQGEQKhxpMW/v5YWNBsaLkxuZMtZ1Tf+kWn8jZD3ZT/vVUmFP9BwxVjrgBr62jh33m41u30b0/OsRJabkyutws2VZ1s8ftKmTA/xlwB1ufJooEFeZnKdDNF3GpouTG5nlpfutPRKtPVlEEr/4PG3zHmCggNPS0a2NGCu6/679szTEkdaukWXMKNyblrcoyNjlDT6XNumxn9uVImzK0/dicGYB5p8V3/fe+qBfdAdYNlp4FLdEsFhe6aHN9YOsPj/Uv8sVImzI0xVwBCcRq4RMuNKVQ4mrW78qQkm6aNGd4pgLhrfaFVBt3xdKAhAOsK1RZcU7TcPPXUU0pNTdXAgQM1depU7dmzp9tz169fL5vN5vIYOHBgP9bWdxpaz+r//fI9ff2R7Vr96oda/eoHmv3TYuU9854au5gJ1V3rC60y6I4/dyeG+bEEQOjo7ncdqi24AW+52bRpk+6++26tXbtWU6dO1eOPP665c+fq0KFDSkxM7PI5sbGxOnTokPNn2wWzgYLFio1l2vXXk53KSytOWrov1IrMuncXY65CE0sAhI6efteh2oIb8JabRx99VLfffrtuueUWjR07VmvXrlVMTIyef/75bp9js9mUnJzsfCQlJfVjjX2ju5ksHazcF+qpYPjW2bEZ3dcf2a5b1u3V7J8Wa9Fze7pseQskWvdCC0sAhA5Pfteh2IIb0Jabs2fPav/+/Vq9erWzLCwsTHPmzFFpaWm3z2tubtbo0aPV3t6uK6+8UmvWrNG4ceO6PPfMmTM6c+aM8+empibffYAuePoN3pP1a6zaF9qTYPrWGWqb0cH8WAIgdHj6uw7FFtyAttzU1taqra2tU8tLUlKSampqunzOpZdequeff16vv/66fvOb36i9vV3Tp0/X3/72ty7Pz8/Pl91udz5SUlJ8/jkk77/Be7J+jVX7QnsSLN86Q3UWglUEQ8tgb7DtSujw9ncdSi24Ae+W8lZ2drYWLVqkK664QjNnztSrr76qhIQEPf30012ev3r1ajU2NjofR48e9Uu9vL0hd/SDdsdsKwj76kbQ0+t4GxgCeYPiJhKcgqUrsbdCdQBpKOJ33b2AdkvFx8crPDxcx48fdyk/fvy4kpOTPXqNyMhIZWZm6vDhw10ej4qKUlRUVJ/r6o63zcAdXVer5n5F59rbOw0qzh4z3DR9ob7qIvL0dTydtmiGriv+sAQnq3clhuoA0lDE77p7AW25GTBggCZNmqStW7c6y9rb27V161ZlZ2d79BptbW364IMPNGLECH9Vs0eefoO/8BvjdU/uVERYmN5YmqOHb5ig/BsmqGjVLG38l2k+vUH3pXXDV11Enr6Op4HBDF1X7N0VfEKlKzEUB5BaXXd/x/lddy3gU8HvvvtuLV68WJMnT1ZWVpYef/xxtbS06JZbbpEkLVq0SBdddJHy8/MlSf/93/+tadOmKT09XQ0NDfrJT36i6upq3XbbbQH7DEOj3QeRnm7IkvzyjdFd68bJljMuA587WpPCbTaVHa1XXctZjR0R65OBid60bHnyTcRMAybZuyu4hMqCZqE4gNSqemql5nfdtYCHm5tuukkOh0P333+/ampqdMUVV+jtt992DjI+cuSIwsL+3sBUX1+v22+/XTU1NRo6dKgmTZqkXbt2aezYsYH6CHp0S3m3xzq+wQfihtxVmNpR7tCsnxap/rzxBVERYTpzrt3r1/f0RuDtDaWnwGCmGxR/WIJLqHUldrfXEIKHp92onv6uzboml68FPNxI0rJly7Rs2bIujxUXF7v8/Nhjj+mxxx7rh1p5pqf1alZd/RVJ/X9D7q5e7ZJLsJHUq2AjeX4j8PaG0lNg6KkvNSKs/xd15CYSHBijgGDiyy/FZhin2J+CbraU2fQUWk62npXU/98YPVlHp7fCJE0ZPdTj/6l6Ozalu2mLPUWxc+1GD2cgFHWMWVh19VcYo4Cg4MsZmWYYp9ifTNFyE8w8DS39/Y2xp3FAfdEuaW91vRY9t8fj1O/LsSk9XfNAtNzAvLr7xvrGshydbDlr+eZ5BC9ffSk20zjF/kLLTR950yrRl1Ht3s54cjcOyFe8Sf0dXU1Fq2Zp3S1TVLRqlgqXZPWqObS7a97hn5/bY6l1S9A33X1j/ek7n4TMgmYITr6akRmKa3LZDMMIqTb8pqYm2e12NTY2KjY21iev2dj6RadWCXd9md4MPu1NP2mFo1lff2R7Lz+N94pWzer3G0RX1/x8HS1iVli3BL3X0/8Lgfi3C3jD2/tLV6zy/4E392+6pXzA2xkz3gw+7c2CY/4cb9OVQEyf7bjmJZ84tOj5PZ2OW7m5FZ4z08w6oDd8MSMzFAfS0y3lQ77et6O3C455sm+VLwVy+uyF1+ZCVmxuhedCbeo3rKuv95dQW+yPlhsT6+23zo6UvuOwQ/6eOOTNrCl/4OYFd0LxGyvQlVBbk4uWGxPry427IC9TY0f2fUzRLdNT3R6/uYfj/sYWCOhJqH1jBdwJlZ3BCTcm1pcbtz0mUk/8Y9//eM++LNHt8bEX2fv8Hn3FzQvu+HKmHoDgQLeUyfVlfZgxCYM1efRQ7auu7/ac/Bsm6NX9f9OBIw1dNtvnfiXB9M36odbcit5hFWkgdBBuTK6vN+5rJoxwG25skp5dPMVtgAqWzSG5eQEAJMJN0OjtjTt6QLjb43+padLUMcPdBihaRgAAwYRwY1EdO79eFBft9rz1u6q1fle1xl8UqzXfnqDZl3Y/xoaWEQBAMCDcWExXKxrboyPUePqc2+d9+GmTrntyp6V3iQUAhAZmS/nJhXtBebs3VG91taLxqdPnNNTDsLKj3GHZXWIBAKGBlhsf66rlZGhMpOrP28TRX60j3e382i6pvvUL/XpJlg4cqddjbjbVbJfYtgAAENRoufGxrlpO6i/Yndqb3bS90dOKxufaDV17+UiPXottCwAAwYpw40Pd7QV1oZ72huotT1Y07lgYMMzm9lS2LQAABC3CjQ95uxu3r1tHPF3RuCAvUzPSE7p8DbYtAAAEO8KND3m7G7c/Wkc82YqgY92aN5bmaPwF+0+ZcXE+AAC8YTOMHvpQLKapqUl2u12NjY2Kje37xpIXWvTcnk5bFVyoY+uCwiVZPn//Dt4suMfifAAAs/Pm/k248bHG1i86bVXQX7OlAACwKm/u30wF97HutiqgdQQAgP5BuPGTC7cqYOsCAAD6BwOKAQCApRBuAACApRBuAACApTDmBgAAk6twNKu6rpVJKR4i3AAAYFJdbcbMciI9o1sKAACT6mozZn9tvmwlhBsAAEyou82Y/bX5spUQbgAAMKGeNmM+f/PlCkezig6dIPD8H8bcAABgMhWOZtU0fu72nNThgxiT0w3CDQAAJtFVWLlQx+bLafGDnJs1n69jTI4/N2c2O7qlAAAwia4GEF8oJz1eBXmZjMlxg5YbAABMoCOsdOfhGyZo6pjhznVuDhytd/t6VSdbQnZNHFpuAAAwgZ4GEA+JinAJK6OHxbg9P3V4aAYbiXADAIAp9BRW1u+qcvl5TMJg5WYkKNxmcykPt9mUm5EQsq02EuEGAABTGJMwWFNSh3Z7fG91fadxNAV5mcpJj3cp6xiTE8oYcwMAgEksnp6qvVXdj6W5cByNPSZShUuyVFnboqqTLew99X8INwAAmMTYEbFuj3c3jiYtnlBzPrqlAAAwCcbR+AbhBgAAE2EcTd/RLQUAgIkwjqbvCDcAAJgQ42h6j24pAABgKYQbAABgKYQbAABgKYQbAABgKYQbAABgKYQbAABgKYQbAABgKYQbAABgKYQbAABgKYQbAABgKYQbAABgKewtBQBAiKhwNKu6rtXym3ESbgAAsLiG1rNasbFMJeUOZ1luRoIK8jJlj4kMYM38g24pAAAs7tZ1e1yCjSSVlDt0y7o9AaqRfxFuAACwsApHsw4cbezy2IGjDaqsbennGvkf4QYAAIuocDSr6NAJl8Dy69Iqt8/5TQ/HgxFjbgAACELnDw4eGhPZ7Ziao/Wn3b5OdV2rv6va7wg3AAAEka4GBw+NiVTT6S9cztt5uFa3Fe7V+JF2t683d1yyX+oZSIQbAACCyIqNZdp5uNalrL71i07ntRmG9lbVa29VfbevFREm/cPkFJ/XMdAINwAABIkKR3OnWU+9FRFm0xtLc3zyWmZDuAEAIEj4cnzMlrtnWnYhP2ZLAQAQJEYPi/HZa1WdtN4U8A6EGwAAgsSYhMHKzUhQuM3mUh6mLwcVeyN1uDVbbSTCDQAAQaUgL1M56fEuZTMyElS8araKVs3SulumaMrooZ0CUIdwm025GQmW7ZKSJJthGEagK9GfmpqaZLfb1djYqNjY2EBXBwCAXqmsbVHVyZYuN8FsbP1Cyzce7HLwcbDuKeXN/dsU4eapp57ST37yE9XU1GjixIkqKChQVlZWt+e/9NJLuu+++1RVVaWMjAz9+Mc/1jXXXOPRe/VXuNl+6ITK/tagK0cN1dcyEvz2Pp7obhfYQOwOGyo70gKAGXQEoIgwm861G0H9t9eb+3fAZ0tt2rRJd999t9auXaupU6fq8ccf19y5c3Xo0CElJiZ2On/Xrl3Ky8tTfn6+vvWtb2nDhg1asGCBDhw4oPHjxwfgE7iqPtmiBU/tdFlzYGhMpN5YOkMpw303EMwT3e0C++CC8fqPzR/26+6wobYjLQCYQVp88IaZvgh4y83UqVM1ZcoUPfnkk5Kk9vZ2paSkaPny5brnnns6nX/TTTeppaVFb775prNs2rRpuuKKK7R27doe38/fLTeZ//1ul4spDY2J1MH7r/b5+7mz6Lk92nm4Vm3n/YrDbTbFRkeo6fS5TuU56fEqXNJ9i5k/6uLP9wQAWIc39++ADig+e/as9u/frzlz5jjLwsLCNGfOHJWWlnb5nNLSUpfzJWnu3Lndnn/mzBk1NTW5PPxl+6ETXQYb6cvVI//ko4WXPNGx0FPbBdm1zTBU3/pFl+Ul5Q6/7A7rri7+ek8AQOgKaLipra1VW1ubkpKSXMqTkpJUU1PT5XNqamq8Oj8/P192u935SEnx3zLTZX9rcHv8wJHul8D2td4u9OSPdQ96qouV11oAAPQ/y08FX716tRobG52Po0eP+u29rrg4zu3xK0cN9dt7X6i3Cz35Y92Dnupi5bUWAAD9L6DhJj4+XuHh4Tp+/LhL+fHjx5Wc3PUupcnJyV6dHxUVpdjYWJeHv8y8NLHbRZSGxkT266yp7hZ6CrfZNDQmsstyf6174K4uVl9rAQDQ/wIabgYMGKBJkyZp69atzrL29nZt3bpV2dnZXT4nOzvb5XxJ2rJlS7fn97c3ls7oFHA6Zkv1t64WespJj9cbS2d0WV6Ql9nvdfHnewIAQlPAZ0tt2rRJixcv1tNPP62srCw9/vjjevHFF/WXv/xFSUlJWrRokS666CLl5+dL+nIq+MyZM/Xwww9r/vz5euGFF7RmzRqPp4L31zo3fyp36MCRelOsc9PdQk/uFoDq77oAAOBOUK1zc9NNN8nhcOj+++9XTU2NrrjiCr399tvOQcNHjhxRWNjfG5imT5+uDRs26D/+4z/0wx/+UBkZGdq8ebMp1rg539cyEgIeajp0t85BINY/CNU1FwAA/SfgLTf9je0XAAAIPkGzzg0AAICvEW4AAIClEG4AAIClEG4AAIClEG4AAIClEG4AAIClEG4AAIClEG4AAIClEG4AAIClBHz7hf7WsSBzU1NTgGsCAAA81XHf9mRjhZALN6dOnZIkpaSkBLgmAADAW6dOnZLdbnd7TsjtLdXe3q7PPvtMQ4YM0alTp5SSkqKjR4+yz5SfNDU1cY39jGvcP7jO/sc19r9gvsaGYejUqVMaOXKky4baXQm5lpuwsDBdfPHFkiSbzSZJio2NDbpfcrDhGvsf17h/cJ39j2vsf8F6jXtqsenAgGIAAGAphBsAAGApIR1uoqKi9J//+Z+KiooKdFUsi2vsf1zj/sF19j+usf+FyjUOuQHFAADA2kK65QYAAFgP4QYAAFgK4QYAAFgK4QYAAFhKSIebp556SqmpqRo4cKCmTp2qPXv2BLpKQSs/P19TpkzRkCFDlJiYqAULFujQoUMu53z++edaunSphg8frsGDB+vGG2/U8ePHA1Tj4Pbwww/LZrNp5cqVzjKur298+umn+qd/+icNHz5c0dHRmjBhgvbt2+c8bhiG7r//fo0YMULR0dGaM2eOysvLA1jj4NLW1qb77rtPaWlpio6O1iWXXKIf/ehHLvsFcY29U1JSomuvvVYjR46UzWbT5s2bXY57cj3r6uq0cOFCxcbGKi4uTkuWLFFzc3M/fgofM0LUCy+8YAwYMMB4/vnnjf/93/81br/9diMuLs44fvx4oKsWlObOnWusW7fO+PDDD42ysjLjmmuuMUaNGmU0Nzc7z7njjjuMlJQUY+vWrca+ffuMadOmGdOnTw9grYPTnj17jNTUVOPyyy837rzzTmc517fv6urqjNGjRxs333yzsXv3bqOiosJ45513jMOHDzvPefjhhw273W5s3rzZeP/9943rrrvOSEtLM06fPh3AmgePhx56yBg+fLjx5ptvGpWVlcZLL71kDB482PjZz37mPIdr7J233nrLuPfee41XX33VkGS89tprLsc9uZ7f/OY3jYkTJxrvvfee8ac//clIT0838vLy+vmT+E7IhpusrCxj6dKlzp/b2tqMkSNHGvn5+QGslXWcOHHCkGRs377dMAzDaGhoMCIjI42XXnrJec7HH39sSDJKS0sDVc2gc+rUKSMjI8PYsmWLMXPmTGe44fr6xr//+78bM2bM6PZ4e3u7kZycbPzkJz9xljU0NBhRUVHGxo0b+6OKQW/+/PnGrbfe6lJ2ww03GAsXLjQMg2vcVxeGG0+u50cffWRIMvbu3es85w9/+INhs9mMTz/9tN/q7ksh2S119uxZ7d+/X3PmzHGWhYWFac6cOSotLQ1gzayjsbFRkjRs2DBJ0v79+/XFF1+4XPPLLrtMo0aN4pp7YenSpZo/f77LdZS4vr7yxhtvaPLkyfqHf/gHJSYmKjMzU7/85S+dxysrK1VTU+Nyne12u6ZOncp19tD06dO1detWffLJJ5Kk999/Xzt27NC8efMkcY19zZPrWVpaqri4OE2ePNl5zpw5cxQWFqbdu3f3e519IeQ2zpSk2tpatbW1KSkpyaU8KSlJf/nLXwJUK+tob2/XypUrlZOTo/Hjx0uSampqNGDAAMXFxbmcm5SUpJqamgDUMvi88MILOnDggPbu3dvpGNfXNyoqKvSLX/xCd999t374wx9q7969WrFihQYMGKDFixc7r2VXfzu4zp6555571NTUpMsuu0zh4eFqa2vTQw89pIULF0oS19jHPLmeNTU1SkxMdDkeERGhYcOGBe01D8lwA/9aunSpPvzwQ+3YsSPQVbGMo0eP6s4779SWLVs0cODAQFfHstrb2zV58mStWbNGkpSZmakPP/xQa9eu1eLFiwNcO2t48cUX9dvf/lYbNmzQuHHjVFZWppUrV2rkyJFcY/hMSHZLxcfHKzw8vNNMkuPHjys5OTlAtbKGZcuW6c0331RRUZEuvvhiZ3lycrLOnj2rhoYGl/O55p7Zv3+/Tpw4oSuvvFIRERGKiIjQ9u3b9cQTTygiIkJJSUlcXx8YMWKExo4d61L21a9+VUeOHJEk57Xkb0fv/du//Zvuuece/eM//qMmTJigf/7nf9Zdd92l/Px8SVxjX/PkeiYnJ+vEiRMux8+dO6e6urqgveYhGW4GDBigSZMmaevWrc6y9vZ2bd26VdnZ2QGsWfAyDEPLli3Ta6+9pm3btiktLc3l+KRJkxQZGelyzQ8dOqQjR45wzT1w1VVX6YMPPlBZWZnzMXnyZC1cuND531zfvsvJyem0hMEnn3yi0aNHS5LS0tKUnJzscp2bmpq0e/durrOHWltbFRbmeusJDw9Xe3u7JK6xr3lyPbOzs9XQ0KD9+/c7z9m2bZva29s1derUfq+zTwR6RHOgvPDCC0ZUVJSxfv1646OPPjL+5V/+xYiLizNqamoCXbWg9K//+q+G3W43iouLjWPHjjkfra2tznPuuOMOY9SoUca2bduMffv2GdnZ2UZ2dnYAax3czp8tZRhcX1/Ys2ePERERYTz00ENGeXm58dvf/taIiYkxfvOb3zjPefjhh424uDjj9ddfN/785z8b119/PdOUvbB48WLjoosuck4Ff/XVV434+HjjBz/4gfMcrrF3Tp06ZRw8eNA4ePCgIcl49NFHjYMHDxrV1dWGYXh2Pb/5zW8amZmZxu7du40dO3YYGRkZTAUPVgUFBcaoUaOMAQMGGFlZWcZ7770X6CoFLUldPtatW+c85/Tp08b3vvc9Y+jQoUZMTIzx7W9/2zh27FjgKh3kLgw3XF/f+N3vfmeMHz/eiIqKMi677DLjmWeecTne3t5u3HfffUZSUpIRFRVlXHXVVcahQ4cCVNvg09TUZNx5553GqFGjjIEDBxpjxowx7r33XuPMmTPOc7jG3ikqKury7+/ixYsNw/Dsep48edLIy8szBg8ebMTGxhq33HKLcerUqQB8Gt+wGcZ5y0ICAAAEuZAccwMAAKyLcAMAACyFcAMAACyFcAMAACyFcAMAACyFcAMAACyFcAMAACyFcAMAACyFcAMAACyFcAPAtN5++23ZbDbV1NS4lI8YMUKpqakuZVVVVbLZbM4NAmfNmiWbzdbpcccddzifc355bGyspkyZotdff93vnwuAfxFuAJjWjBkzFBERoeLiYmfZxx9/rNOnT6u+vl5VVVXO8qKiIkVFRSknJ8dZdvvtt+vYsWMuj//5n/9xeY9169bp2LFj2rdvn3JycvSd73xHH3zwgb8/GgA/ItwAMIWXX35ZEyZMUHR0tIYPH645c+bIZrNpypQpLuGmuLhYM2bMUE5OTqfyadOmaeDAgc6ymJgYJScnuzxiY2Nd3jcuLk7Jycn6yle+oh/96Ec6d+6cioqK/P1xAfgR4QZAwB07dkx5eXm69dZb9fHHH6u4uFg33HCDDMPQ7NmzXcJGUVGRZs2apZkzZ7qUFxcXa/bs2b2uw7lz5/Tcc89JkgYMGND7DwMg4NgVHEDAHThwQJMmTVJVVZVGjx7tcuyPf/yjvvGNb+izzz7TiBEjlJSUpDfffFPnzp1TXl6eqqqqVFFRoUsuuUTbt29Xbm6upC/H3OzatatTUHn66ae1cOFCSV+OuRk4cKDCw8N1+vRptbe3KzU1Vfv379ewYcP658MD8LmIQFcAACZOnKirrrpKEyZM0Ny5c3X11VfrO9/5joYOHarp06drwIABKi4u1sSJE3X69GldeeWVam9vl8PhUGVlpYqLixUdHa1p06a5vO7ChQt17733upQlJSW5/PzYY49pzpw5qqio0F133aUnnniCYAMEOcINgIALDw/Xli1btGvXLr377rsqKCjQvffeq927dystLU1ZWVkqKipSXV2dZsyYofDwcIWHh2v69OkqKipSUVGRcnJyOrXS2O12paenu33v5ORkpaenKz09XevWrdM111yjjz76SImJif78yAD8iDE3AEzBZrMpJydHDzzwgA4ePKgBAwbotddekyTNnj1bxcXFKi4u1qxZs5zPyc3NVXFxsbZv396n8TYdsrKyNGnSJD300EN9fi0AgUO4ARBwu3fv1po1a7Rv3z4dOXJEr776qhwOh7761a9K+jLclJeX65133tHMmTOdz5s5c6Y2b96so0ePdhluWltbVVNT4/Kor693W5eVK1fq6aef1qeffurbDwmg3zCgGEDAffzxx7rrrrt04MABNTU1afTo0Vq+fLmWLVsmSfr8888VFxenyMhI1dfXKyLiyx71M2fOKC4uThERES7l0pcDirdv397pvebOnau3335b0petRa+99poWLFjgPG4YhsaOHavZs2fr5z//uR8/NQB/IdwAAABLoVsKAABYCuEGAABYCuEGAABYCuEGAABYCuEGAABYCuEGAABYCuEGAABYCuEGAABYCuEGAABYCuEGAABYCuEGAABYyv8Hvl5sOEFaNGQAAAAASUVORK5CYII=", "text/plain": [ "
" ] @@ -1255,7 +1262,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 21, "metadata": {}, "outputs": [ { @@ -1264,13 +1271,13 @@ "" ] }, - "execution_count": 24, + "execution_count": 21, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1285,7 +1292,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 22, "metadata": {}, "outputs": [ { @@ -1303,7 +1310,7 @@ "\u001b[0;31mKeyError\u001b[0m: 'Experiment'", "\nThe above exception was the direct cause of the following exception:\n", "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[25], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m df_standard_flow_variations \u001b[38;5;241m=\u001b[39m df[\u001b[38;5;241m~\u001b[39mdf[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mJoint\u001b[39m\u001b[38;5;124m\"\u001b[39m]]\u001b[38;5;241m.\u001b[39mreplace(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m-\u001b[39m\u001b[38;5;124m\"\u001b[39m, np\u001b[38;5;241m.\u001b[39mnan)\n\u001b[0;32m----> 2\u001b[0m df_standard_flow_variations[\u001b[38;5;241m~\u001b[39m\u001b[43mdf_standard_flow_variations\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mExperiment\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[38;5;241m.\u001b[39mstr\u001b[38;5;241m.\u001b[39mcontains(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124msimple_encoder\u001b[39m\u001b[38;5;124m\"\u001b[39m) \u001b[38;5;241m&\u001b[39m \u001b[38;5;241m~\u001b[39mdf_standard_flow_variations[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mExperiment\u001b[39m\u001b[38;5;124m\"\u001b[39m]\u001b[38;5;241m.\u001b[39mstr\u001b[38;5;241m.\u001b[39mcontains(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mddi_actnorm\u001b[39m\u001b[38;5;124m\"\u001b[39m)]\n", + "Cell \u001b[0;32mIn[22], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m df_standard_flow_variations \u001b[38;5;241m=\u001b[39m df[\u001b[38;5;241m~\u001b[39mdf[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mJoint\u001b[39m\u001b[38;5;124m\"\u001b[39m]]\u001b[38;5;241m.\u001b[39mreplace(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m-\u001b[39m\u001b[38;5;124m\"\u001b[39m, np\u001b[38;5;241m.\u001b[39mnan)\n\u001b[0;32m----> 2\u001b[0m df_standard_flow_variations[\u001b[38;5;241m~\u001b[39m\u001b[43mdf_standard_flow_variations\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mExperiment\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[38;5;241m.\u001b[39mstr\u001b[38;5;241m.\u001b[39mcontains(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124msimple_encoder\u001b[39m\u001b[38;5;124m\"\u001b[39m) \u001b[38;5;241m&\u001b[39m \u001b[38;5;241m~\u001b[39mdf_standard_flow_variations[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mExperiment\u001b[39m\u001b[38;5;124m\"\u001b[39m]\u001b[38;5;241m.\u001b[39mstr\u001b[38;5;241m.\u001b[39mcontains(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mddi_actnorm\u001b[39m\u001b[38;5;124m\"\u001b[39m)]\n", "File \u001b[0;32m/work/tools22/users/lukas.rilling/sis_env/lib/python3.10/site-packages/pandas/core/frame.py:3896\u001b[0m, in \u001b[0;36mDataFrame.__getitem__\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m 3894\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mcolumns\u001b[38;5;241m.\u001b[39mnlevels \u001b[38;5;241m>\u001b[39m \u001b[38;5;241m1\u001b[39m:\n\u001b[1;32m 3895\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_getitem_multilevel(key)\n\u001b[0;32m-> 3896\u001b[0m indexer \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcolumns\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget_loc\u001b[49m\u001b[43m(\u001b[49m\u001b[43mkey\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 3897\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m is_integer(indexer):\n\u001b[1;32m 3898\u001b[0m indexer \u001b[38;5;241m=\u001b[39m [indexer]\n", "File \u001b[0;32m/work/tools22/users/lukas.rilling/sis_env/lib/python3.10/site-packages/pandas/core/indexes/base.py:3797\u001b[0m, in \u001b[0;36mIndex.get_loc\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m 3792\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(casted_key, \u001b[38;5;28mslice\u001b[39m) \u001b[38;5;129;01mor\u001b[39;00m (\n\u001b[1;32m 3793\u001b[0m \u001b[38;5;28misinstance\u001b[39m(casted_key, abc\u001b[38;5;241m.\u001b[39mIterable)\n\u001b[1;32m 3794\u001b[0m \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28many\u001b[39m(\u001b[38;5;28misinstance\u001b[39m(x, \u001b[38;5;28mslice\u001b[39m) \u001b[38;5;28;01mfor\u001b[39;00m x \u001b[38;5;129;01min\u001b[39;00m casted_key)\n\u001b[1;32m 3795\u001b[0m ):\n\u001b[1;32m 3796\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m InvalidIndexError(key)\n\u001b[0;32m-> 3797\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mKeyError\u001b[39;00m(key) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01merr\u001b[39;00m\n\u001b[1;32m 3798\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m:\n\u001b[1;32m 3799\u001b[0m \u001b[38;5;66;03m# If we have a listlike key, _check_indexing_error will raise\u001b[39;00m\n\u001b[1;32m 3800\u001b[0m \u001b[38;5;66;03m# InvalidIndexError. Otherwise we fall through and re-raise\u001b[39;00m\n\u001b[1;32m 3801\u001b[0m \u001b[38;5;66;03m# the TypeError.\u001b[39;00m\n\u001b[1;32m 3802\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_check_indexing_error(key)\n", "\u001b[0;31mKeyError\u001b[0m: 'Experiment'" diff --git a/users/rilling/evaluation/wer_eval.ipynb b/users/rilling/evaluation/wer_eval.ipynb index 2bf05746d..ebc9639f8 100644 --- a/users/rilling/evaluation/wer_eval.ipynb +++ b/users/rilling/evaluation/wer_eval.ipynb @@ -28,835 +28,1007 @@ { "data": { "text/plain": [ - "['/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer/tuning/lm_1.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer/tuning/lm_4.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer/tuning/lm_2.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer/tuning/lm_3.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer/tuning/lm_2.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer/tuning/lm_3.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer_specaugment_before/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer_specaugment_before/tuning/lm_1.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer_specaugment_before/tuning/lm_4.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer_specaugment_before/tuning/lm_2.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer_specaugment_before/tuning/lm_3.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer_specaugment_before/tuning/lm_2.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer_specaugment_before/tuning/lm_3.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_4.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_1.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_3.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_2.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_3.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_2.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_two_forward_pass/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_2.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_3.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_1.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_4.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_2.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_3.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_x_vector_v2/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_2.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_3.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_1.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_4.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_2.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_3.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_ASR_conformer_two_forward_pass/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glow_ASR_conformer/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glow_ASR_conformer/tuning/lm_4.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glow_ASR_conformer/tuning/lm_1.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glow_ASR_conformer/tuning/lm_3.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glow_ASR_conformer/tuning/lm_2.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glow_ASR_conformer/tuning/lm_3.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glow_ASR_conformer/tuning/lm_2.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_ASR_conformer_x_vector/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_ASR_conformer_x_vector/tuning/lm_3.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_ASR_conformer_x_vector/tuning/lm_2.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_ASR_conformer_x_vector/tuning/lm_3.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_ASR_conformer_x_vector/tuning/lm_2.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_ASR_conformer_x_vector/tuning/lm_4.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_ASR_conformer_x_vector/tuning/lm_1.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_control_radam/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer/tuning/lm_4.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer/tuning/lm_2.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer/tuning/lm_3.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer/tuning/lm_2.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer/tuning/lm_3.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer/tuning/lm_4.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1/tuning/lm_4.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1/tuning/lm_2.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1/tuning/lm_3.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1/tuning/lm_2.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1/tuning/lm_3.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1/tuning/lm_4.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass/tuning/lm_4.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass/tuning/lm_2.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass/tuning/lm_3.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass/tuning/lm_2.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass/tuning/lm_3.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass/tuning/lm_4.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment_tts_train_segments/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment_tts_train_segments/tuning/lm_4.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment_tts_train_segments/tuning/lm_3.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment_tts_train_segments/tuning/lm_2.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment_tts_train_segments/tuning/lm_3.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment_tts_train_segments/tuning/lm_2.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment_tts_train_segments/tuning/lm_4.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvector/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1_tts_segments/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1_tts_segments/tuning/lm_3.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1_tts_segments/tuning/lm_2.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1_tts_segments/tuning/lm_4.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1_tts_segments/tuning/lm_4.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1_tts_segments/tuning/lm_3.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1_tts_segments/tuning/lm_2.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/tuning/lm_4.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/tuning/lm_3.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/tuning/lm_2.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/tuning/lm_3.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/tuning/lm_2.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/tuning/lm_4.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_ctc_scale_0.1/tuning/lm_2.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_ctc_scale_0.1/tuning/lm_3.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_ctc_scale_0.1/tuning/lm_4.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_ctc_scale_0.1/tuning/lm_4.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_ctc_scale_0.1/tuning/lm_2.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_ctc_scale_0.1/tuning/lm_3.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_ctc_scale_0.1/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment/tuning/lm_3.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment/tuning/lm_2.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment/tuning/lm_4.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment/tuning/lm_4.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment/tuning/lm_3.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment/tuning/lm_2.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/tuning/lm_3.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/tuning/lm_2.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/tuning/lm_4.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/tuning/lm_4.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/tuning/lm_3.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/tuning/lm_2.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_ddi_actnorm/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/tuning/lm_4.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/tuning/lm_3.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/tuning/lm_2.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/tuning/lm_3.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/tuning/lm_2.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/tuning/lm_4.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/tuning/lm_4.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/tuning/lm_2.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/tuning/lm_3.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/tuning/lm_2.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/tuning/lm_3.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/tuning/lm_4.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/tuning/lm_4.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/tuning/lm_3.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/tuning/lm_2.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/tuning/lm_3.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/tuning/lm_2.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/tuning/lm_4.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer/tuning/lm_3.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer/tuning/lm_2.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer/tuning/lm_4.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer/tuning/lm_4.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer/tuning/lm_3.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer/tuning/lm_2.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvector_eval/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvector_eval/tuning/lm_2.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvector_eval/tuning/lm_3.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvector_eval/tuning/lm_4.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvector_eval/tuning/lm_4.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvector_eval/tuning/lm_2.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvector_eval/tuning/lm_3.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector/tuning/lm_2.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector/tuning/lm_3.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector/tuning/lm_4.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector/tuning/lm_4.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector/tuning/lm_2.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector/tuning/lm_3.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_encoder_sample_ctc_scale_0.1/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/tuning/lm_3.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/tuning/lm_2.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/tuning/lm_4.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/tuning/lm_4.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/tuning/lm_3.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/tuning/lm_2.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v3/tuning/lm_4.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v3/tuning/lm_2.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v3/tuning/lm_3.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v3/tuning/lm_2.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v3/tuning/lm_3.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v3/tuning/lm_4.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v3/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_4.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_3.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_2.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_3.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_2.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_4.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_tts_train_segments/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_tts_train_segments/tuned/lm_2.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_tts_train_segments/tuning/lm_2.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_tts_train_segments/tuning/lm_3.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_tts_train_segments/tuning/lm_4.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_tts_train_segments/tuning/lm_4.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_tts_train_segments/tuning/lm_2.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_tts_train_segments/tuning/lm_3.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_ctc_scale_0.1/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_ctc_scale_0.1/tuning/lm_2.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_ctc_scale_0.1/tuning/lm_3.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_ctc_scale_0.1/tuning/lm_4.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_ctc_scale_0.1/tuning/lm_4.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_ctc_scale_0.1/tuning/lm_2.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_ctc_scale_0.1/tuning/lm_3.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_coupling_epsilon/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/tuning/lm_4.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/tuning/lm_3.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/tuning/lm_2.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/tuning/lm_3.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/tuning/lm_2.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/tuning/lm_4.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_trainXvector/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_control/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ddi_actnorm/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_control_spec_augment/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_radam/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_control/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_3.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_2.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_4.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_4.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_3.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_2.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/tuning/lm_4.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/tuning/lm_2.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/tuning/lm_3.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/tuning/lm_2.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/tuning/lm_3.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/tuning/lm_4.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/tuning/lm_2.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/tuning/lm_3.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/tuning/lm_4.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/tuning/lm_4.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/tuning/lm_2.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/tuning/lm_3.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/tuning/lm_4.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/tuning/lm_3.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/tuning/lm_2.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/tuning/lm_3.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/tuning/lm_2.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/tuning/lm_4.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_no_jit/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_no_jit/tuning/lm_2.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_no_jit/tuning/lm_3.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_no_jit/tuning/lm_2.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_no_jit/tuning/lm_1.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector/tuning/lm_4.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector/tuning/lm_2.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector/tuning/lm_3.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector/tuning/lm_2.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector/tuning/lm_3.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector/tuning/lm_4.5/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step/ga_glowTTS_ASR_ffn_x_vector_v2_blstm_2ndstep/specaug/ce_ls_1.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step/ga_glowTTS_ASR_ffn_x_vector_v2_blstm_2ndstep/no_specaug/ce_ls_1.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step/ga_glowTTS_ASR_ffn_x_vector_v2_blstm_2ndstep_v2/no_specaug/ce_ls_1.0/search/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_4x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/default/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval_spec_aug/not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/tuned/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/tuned/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/tuned/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/tuned/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/tuned/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/tuned/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/tuned/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/tuned/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/tuned/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/tuned/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/tuned/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/tuned/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/tuned/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/tuned/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/tuned/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/tuned/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/tuned/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/tuned/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/tuned/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/tuned/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/tuned/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/tuned/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/tuned/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/tuned/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm2.5_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm2.0_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm2.0_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm1.5_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm3.0_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm3.0_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm3.5_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm4.0_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm3.5_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm2.5_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm2.5_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm1.5_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm2.0_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm1.5_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm3.0_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm4.0_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm4.0_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm3.5_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm2.5_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm3.5_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm2.5_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm1.5_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm2.0_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm4.0_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm3.0_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm1.5_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm4.0_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm3.5_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm2.0_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm2.5_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm3.0_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm2.0_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm1.5_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm3.0_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm3.5_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm4.0_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc768_100ep_xvector/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_simple_encoder/silence_preprocessed/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment_before/glow_enc192_200ep_not_freezed/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment_before/glow_enc192_200ep/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/tuning/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/tuning/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/tuning/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/tuning/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/tuning/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/tuning/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/tuning/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/tuning/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/tuning/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/tuning/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/tuning/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/tuning/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/tuning/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/tuning/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/tuning/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/tuning/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/tuning/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/tuning/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/tuning/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/tuning/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/tuning/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/tuning/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/tuning/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/tuning/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/silence_preprocessing/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/tuning/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/tuning/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/tuning/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/tuning/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/tuning/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/tuning/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/tuning/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/tuning/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/tuning/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/tuning/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/tuning/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/tuning/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/silence_preprocessed/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm3.0_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm4.0_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm3.5_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm2.5_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm2.0_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm1.5_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm2.0_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm3.0_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm1.5_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm3.0_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm4.0_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm3.5_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm4.0_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm3.5_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm2.5_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm2.0_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm1.5_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm2.5_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm3.0_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm4.0_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm3.5_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm3.0_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm2.5_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm2.0_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm1.5_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm2.0_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm3.0_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm3.5_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm4.0_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm4.0_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm1.5_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm2.5_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm2.5_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm2.0_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm1.5_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm3.5_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/drop_around_blstm/lm5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/drop_around_blstm/spec_augment/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_nar_taco_encoder_16blocks/not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc768/with_sigma/not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc768/with_sigma/silence_preprocessing/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_nar_taco_encoder/not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_nar_taco_encoder/silence_preprocessed/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_with_small_enc/silence_preprocessed/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_simple_encoder/silence_preprocessed/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_simple_encoder_epoch84/silence_preprocessed/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc192/100epTTS/silence_preprocessed/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc192/200epsTTS_early_eval_ep100/silence_preprocessed/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc192/200epsTTS_early_eval_ep100/not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc192/not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc192/200epsTTS/silence_preprocessed/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc192/200epsTTS/not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/linear_1x512_d0.2_b300_fs4/glow_nar_taco_encoder_16blocks/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/linear_1x512_d0.2_b300_fs4/glow_enc768/tts_dataset/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x1024_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/tts_dataset/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/tuning/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/tuning/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/tuning/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/tuning/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/tuning/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/tuning/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/tuning/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/tuning/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/tuning/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/tuning/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/tuning/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/tuning/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/tuning/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/tuning/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/tuning/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/tuning/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/tuning/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/tuning/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/tuning/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/tuning/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/tuning/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/tuning/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/tuning/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/tuning/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/tts_dataset/spec_augment/no_glow/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/tuned/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/layer_norm/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/batch_norm/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/tuning/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/tuning/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/tuning/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/tuning/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/tuning/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/tuning/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/tuning/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/tuning/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/tuning/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/tuning/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/tuning/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/tuning/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.4/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/tuning/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/tuning/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/tuning/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/tuning/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/tuning/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/tuning/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/tuning/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/tuning/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/tuning/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/tuning/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/tuning/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/tuning/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.1/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.2/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment_before/glow_enc192_200ep_not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/lm_tuning/lm2.0_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/lm_tuning/lm1.5_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/lm_tuning/lm2.5_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/lm_tuning/lm3.5_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/lm_tuning/lm4.0_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/lm_tuning/lm3.0_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/lm_tuning/lm3.0_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/lm_tuning/lm2.0_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/lm_tuning/lm1.5_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/lm_tuning/lm2.0_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/lm_tuning/lm2.5_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/lm_tuning/lm1.5_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/lm_tuning/lm4.0_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/lm_tuning/lm4.0_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/lm_tuning/lm3.5_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/lm_tuning/lm2.5_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/lm_tuning/lm3.0_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/lm_tuning/lm3.5_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm3.0_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm2.5_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm2.0_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm2.0_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm1.5_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm3.0_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm3.5_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm4.0_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm2.5_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm2.5_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm1.5_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm3.5_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm2.0_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm3.0_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm4.0_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm4.0_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm1.5_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm3.5_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm3.0_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm2.5_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm2.0_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm2.0_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm1.5_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm3.0_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm3.5_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm4.0_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm2.5_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm2.5_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm1.5_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm2.0_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm3.5_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm3.0_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm4.0_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm4.0_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm3.5_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm1.5_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/weak_baseline/lm_tuning/lm3.0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/weak_baseline/lm_tuning/lm2.0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/weak_baseline/lm_tuning/lm3.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/weak_baseline/lm_tuning/lm2.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/weak_baseline/lm_tuning/lm1.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/weak_baseline/lm_tuning/lm4.0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/weak_baseline/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm2.5_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm2.0_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm1.5_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm3.0_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm3.0_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm2.0_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm3.5_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm4.0_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm2.5_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm4.0_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm1.5_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm2.0_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm1.5_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm3.0_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm2.5_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm4.0_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm3.5_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm3.5_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm2.0_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm4.0_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm1.5_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm1.5_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm2.5_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm3.5_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm4.0_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm3.5_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm3.0_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm2.5_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm1.5_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm2.0_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm2.5_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm4.0_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm3.5_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm2.0_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm3.0_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm3.0_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm1.5_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm2.0_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm2.5_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm2.5_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm3.5_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm4.0_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm3.5_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm3.0_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm1.5_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm4.0_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm2.0_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm1.5_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm3.0_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm2.5_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm2.0_ps0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm3.5_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm4.0_ps0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm3.0_ps0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_v3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/tuned_no_prior/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/tuned/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + "['/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/lm_tuning/lm1.5_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/lm_tuning/lm2.0_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/lm_tuning/lm2.5_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/lm_tuning/lm2.0_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/lm_tuning/lm4.0_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/lm_tuning/lm3.5_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/lm_tuning/lm3.0_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/lm_tuning/lm3.0_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/lm_tuning/lm2.0_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/lm_tuning/lm1.5_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/lm_tuning/lm4.0_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/lm_tuning/lm1.5_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/lm_tuning/lm2.5_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/lm_tuning/lm3.5_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/lm_tuning/lm4.0_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/lm_tuning/lm3.5_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/lm_tuning/lm3.0_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/lm_tuning/lm2.5_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_1.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_1.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_2.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_1.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_2.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_2.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_2.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_1.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_1.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_2.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_1.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_2.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm2.5_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm1.5_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm2.0_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm3.5_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm2.5_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm4.0_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm3.5_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm1.5_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm3.0_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm4.0_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm3.0_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm2.0_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm1.5_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm2.0_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm2.5_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm3.5_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm4.0_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm3.0_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm3.0_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm4.0_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm3.5_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm4.0_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm1.5_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm2.5_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm2.5_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm2.0_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm1.5_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm3.5_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm3.0_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm4.0_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm3.5_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm3.0_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm2.5_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm2.0_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm1.5_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm2.0_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/weak_baseline/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/weak_baseline/lm_tuning/lm3.0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/weak_baseline/lm_tuning/lm2.0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/weak_baseline/lm_tuning/lm3.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/weak_baseline/lm_tuning/lm2.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/weak_baseline/lm_tuning/lm1.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/weak_baseline/lm_tuning/lm4.0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/default_250/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_1.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_2.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_2.0_ps_0.3/default_250/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_1.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_1.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_2.0_ps_0.5/default_250/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/default_250/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_1.5_ps_0.5/default_250/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_1.5_ps_0/default_250/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_2.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_1.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_2.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_2.0_ps_0.3/default_250/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_v2/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/tuned_no_prior/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/tuned/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/default_250/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/search_params/lm_1.5_ps_0.3/default_250/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/search_params/lm_2.0_ps_0/default_250/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/search_params/lm_2.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/search_params/lm_1.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/search_params/lm_1.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/search_params/lm_2.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/search_params/lm_2.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/search_params/lm_1.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/search_params/lm_1.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/search_params/lm_2.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/search_params/lm_1.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/search_params/lm_2.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0/search_params/lm_2.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0/search_params/lm_2.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0/search_params/lm_2.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm1.5_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm4.0_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm3.5_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm4.0_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm3.0_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm3.5_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm2.0_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm1.5_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm2.5_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm2.5_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm4.0_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm3.5_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm3.0_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm1.5_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm2.0_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm2.0_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm2.5_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm3.0_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/search_params/lm_2.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/search_params/lm_2.0_ps_0.5/default_250/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/search_params/lm_2.0_ps_0.3/default_250/dev-other/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer']" + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_100ep_dec_0.05_v2/search_params/lm_1.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_100ep_dec_0.05_v2/search_params/lm_2.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_100ep_dec_0.05_v2/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_100ep_dec_0.05_v2/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_100ep_dec_0.05_v2/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_100ep_dec_0.05_v2/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_100ep_dec_0.05_v2/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_100ep_dec_0.05_v2/search_params/lm_1.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_100ep_dec_0.05_v2/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_100ep_dec_0.05_v2/search_params/lm_2.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_100ep_dec_0.05_v2/search_params/lm_2.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_100ep_dec_0.05_v2/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_100ep_dec_0.05_v2/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_100ep_dec_0.05_v2/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_100ep_dec_0.05_v2/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_100ep_dec_0.05_v2/search_params/lm_1.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_100ep_dec_0.05_v2/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_100ep_dec_0.05_v2/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_100ep_dec_0.05_v2/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm2.5_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm1.5_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm2.0_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm3.0_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm3.0_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm2.0_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm4.0_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm3.5_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm2.5_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm4.0_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm2.0_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm1.5_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm1.5_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm3.0_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm2.5_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm3.5_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm4.0_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm3.5_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm2.5_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm1.5_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm2.0_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm2.0_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm3.0_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm3.0_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm4.0_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm3.5_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm1.5_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm2.5_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm4.0_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm2.0_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm1.5_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm3.5_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm3.0_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm2.5_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm3.5_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm4.0_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_v3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_2.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_2.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_2.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_2.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_2.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_2.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment_before/glow_enc192_200ep_not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/tuned/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/batch_norm/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/layer_norm/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.2/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.1/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/tuning/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/tuning/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/tuning/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/tuning/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/tuning/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/tuning/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/tuning/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/tuning/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/tuning/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/tuning/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/tuning/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/tuning/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.4/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/tuning/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/tuning/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/tuning/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/tuning/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/tuning/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/tuning/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/tuning/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/tuning/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/tuning/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/tuning/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/tuning/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/tuning/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/tts_dataset/spec_augment/no_glow/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/tts_dataset/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/tuning/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/tuning/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/tuning/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/tuning/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/tuning/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/tuning/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/tuning/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/tuning/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/tuning/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/tuning/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/tuning/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/tuning/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/linear_1x512_d0.2_b300_fs4/glow_nar_taco_encoder_16blocks/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/linear_1x512_d0.2_b300_fs4/glow_enc768/tts_dataset/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x1024_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc768/with_sigma/not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc768/with_sigma/silence_preprocessing/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_simple_encoder_epoch84/silence_preprocessed/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_nar_taco_encoder_16blocks/not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_nar_taco_encoder/not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_nar_taco_encoder/silence_preprocessed/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc192/200epsTTS/silence_preprocessed/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc192/200epsTTS/not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc192/200epsTTS_early_eval_ep100/not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc192/200epsTTS_early_eval_ep100/silence_preprocessed/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc192/not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc192/100epTTS/silence_preprocessed/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_with_small_enc/silence_preprocessed/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_simple_encoder/silence_preprocessed/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm4.0_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm3.5_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm3.5_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm3.0_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm2.5_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm1.5_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm4.0_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm2.0_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm1.5_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm2.5_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm3.5_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm2.0_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm4.0_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm3.0_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm3.0_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm2.0_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm1.5_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm2.5_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm3.0_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm4.0_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm3.5_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm2.5_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm3.0_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm1.5_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm2.0_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm2.0_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm3.0_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm3.5_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm4.0_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm4.0_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm1.5_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm2.5_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm2.5_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm2.0_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm1.5_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm3.5_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/default/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_simple_encoder/silence_preprocessed/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment_before/glow_enc192_200ep/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment_before/glow_enc192_200ep_not_freezed/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/drop_around_blstm/spec_augment/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/drop_around_blstm/lm5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/silence_preprocessing/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/tuning/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/tuning/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/tuning/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/tuning/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/tuning/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/tuning/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/tuning/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/tuning/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/tuning/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/tuning/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/tuning/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/tuning/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/silence_preprocessed/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/tuning/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/tuning/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/tuning/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/tuning/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/tuning/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/tuning/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/tuning/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/tuning/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/tuning/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/tuning/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/tuning/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/tuning/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/tuning/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/tuning/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/tuning/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/tuning/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm1.5_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm2.0_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm3.0_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm2.5_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm2.0_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm4.0_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm3.5_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm3.0_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm2.5_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm2.0_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm1.5_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm3.5_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm2.5_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm3.5_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm4.0_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm1.5_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm4.0_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm3.0_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc768_100ep_xvector/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm2.5_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm2.0_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm1.5_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm2.0_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm3.0_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm3.0_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm4.0_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm3.5_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm2.5_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm3.5_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm2.0_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm2.5_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm1.5_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm1.5_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm3.0_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm4.0_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm3.5_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm4.0_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/tuned/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/tuned/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/tuned/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/tuned/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/tuned/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/tuned/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/tuned/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/tuned/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/tuned/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/tuned/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/tuned/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/tuned/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/tuned/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/tuned/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/tuned/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/tuned/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/tuned/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/tuned/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/tuned/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/tuned/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/tuned/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/tuned/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/tuned/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/tuned/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval_spec_aug/not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment_before/glow_not_pretrained/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment_before/glow_not_pretrainedlm_tuning/lm3.0_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment_before/glow_not_pretrainedlm_tuning/lm3.0_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment_before/glow_not_pretrainedlm_tuning/lm2.0_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment_before/glow_not_pretrainedlm_tuning/lm3.5_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment_before/glow_not_pretrainedlm_tuning/lm4.0_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment_before/glow_not_pretrainedlm_tuning/lm2.5_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment_before/glow_not_pretrainedlm_tuning/lm2.0_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment_before/glow_not_pretrainedlm_tuning/lm1.5_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment_before/glow_not_pretrainedlm_tuning/lm2.5_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment_before/glow_not_pretrainedlm_tuning/lm3.0_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment_before/glow_not_pretrainedlm_tuning/lm3.5_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment_before/glow_not_pretrainedlm_tuning/lm4.0_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment_before/glow_not_pretrainedlm_tuning/lm3.5_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment_before/glow_not_pretrainedlm_tuning/lm2.5_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment_before/glow_not_pretrainedlm_tuning/lm1.5_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment_before/glow_not_pretrainedlm_tuning/lm1.5_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment_before/glow_not_pretrainedlm_tuning/lm4.0_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment_before/glow_not_pretrainedlm_tuning/lm2.0_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm1.5_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm2.0_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm2.5_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm2.5_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm3.5_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm4.0_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm3.5_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm4.0_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm3.0_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm1.5_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm2.0_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm1.5_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm3.0_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm2.5_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm2.0_ps0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm3.5_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm4.0_ps0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm3.0_ps0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_1.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_1.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_2.0_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_2.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_1.5_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_2.0_ps_0.5/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_4x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/default_250/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_ctc_scale_0.1/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_ctc_scale_0.1/tuning/lm_4.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_ctc_scale_0.1/tuning/lm_3.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_ctc_scale_0.1/tuning/lm_2.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_ctc_scale_0.1/tuning/lm_3.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_ctc_scale_0.1/tuning/lm_2.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_ctc_scale_0.1/tuning/lm_4.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/tuning/lm_2.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/tuning/lm_2.5_ps_0.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/tuning/lm_3.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/tuning/lm_2.0_ps_0.3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/tuning/lm_4.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/tuning/lm_4.0_ps_0.3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/tuning/lm_4.5_ps_0.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/tuning/lm_3.0_ps_0.3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/tuning/lm_3.5_ps_0.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/tuning/lm_4.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/tuning/lm_2.5_ps_0.3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/tuning/lm_2.0_ps_0.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/tuning/lm_4.0_ps_0.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/tuning/lm_2.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/tuning/lm_4.5_ps_0.3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/tuning/lm_3.0_ps_0.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/tuning/lm_3.5_ps_0.3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/tuning/lm_3.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_tts_train_segments/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_tts_train_segments/tuning/lm_4.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_tts_train_segments/tuning/lm_3.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_tts_train_segments/tuning/lm_2.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_tts_train_segments/tuning/lm_3.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_tts_train_segments/tuning/lm_2.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_tts_train_segments/tuning/lm_4.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_tts_train_segments/tuned/lm_2.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass/tuning/lm_4.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass/tuning/lm_2.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass/tuning/lm_3.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass/tuning/lm_2.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass/tuning/lm_3.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass/tuning/lm_4.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/tuning/lm_4.0_ps_0.3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/tuning/lm_3.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/tuning/lm_4.5_ps_0.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/tuning/lm_3.0_ps_0.3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/tuning/lm_3.5_ps_0.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/tuning/lm_2.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/tuning/lm_2.5_ps_0.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/tuning/lm_2.0_ps_0.3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/tuning/lm_4.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/tuning/lm_4.0_ps_0.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/tuning/lm_4.5_ps_0.3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/tuning/lm_3.0_ps_0.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/tuning/lm_4.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/tuning/lm_3.5_ps_0.3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/tuning/lm_3.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/tuning/lm_2.5_ps_0.3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/tuning/lm_2.0_ps_0.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/tuning/lm_2.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_blstm_x_vector/tuning/lm_4.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_blstm_x_vector/tuning/lm_3.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_blstm_x_vector/tuning/lm_2.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_blstm_x_vector/tuning/lm_3.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_blstm_x_vector/tuning/lm_2.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_blstm_x_vector/tuning/lm_4.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_blstm_x_vector/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_radam/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1/tuning/lm_4.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1/tuning/lm_2.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1/tuning/lm_3.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1/tuning/lm_2.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1/tuning/lm_3.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1/tuning/lm_4.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_control_spec_augment/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/tuning/lm_2.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/tuning/lm_2.0_ps_0.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/tuning/lm_3.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/tuning/lm_2.5_ps_0.3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/tuning/lm_4.5_ps_0.3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/tuning/lm_4.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/tuning/lm_4.0_ps_0.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/tuning/lm_3.5_ps_0.3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/tuning/lm_3.0_ps_0.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/tuning/lm_4.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/tuning/lm_2.0_ps_0.3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/tuning/lm_2.5_ps_0.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/tuning/lm_4.5_ps_0.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/tuning/lm_4.0_ps_0.3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/tuning/lm_2.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/tuning/lm_3.5_ps_0.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/tuning/lm_3.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/tuning/lm_3.0_ps_0.3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_3.5_ps_0.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_3.0_ps_0.3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_4.5_ps_0.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_3.5_ps_0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_4.0_ps_0.3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_2.0_ps_0.3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_3.0_ps_0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_2.5_ps_0.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_3.5_ps_0.3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_4.5_ps_0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_2.0_ps_0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_3.0_ps_0.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_4.5_ps_0.3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_4.0_ps_0.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_2.0_ps_0.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_2.5_ps_0.3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_2.5_ps_0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_4.0_ps_0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_control/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/tuning/lm_4.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/tuning/lm_3.0_ps_0.3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/tuning/lm_3.5_ps_0.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/tuning/lm_4.0_ps_0.3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/tuning/lm_4.5_ps_0.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/tuning/lm_2.5_ps_0.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/tuning/lm_2.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/tuning/lm_2.0_ps_0.3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/tuning/lm_3.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/tuning/lm_3.0_ps_0.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/tuning/lm_2.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/tuning/lm_3.5_ps_0.3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/tuning/lm_4.0_ps_0.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/tuning/lm_4.5_ps_0.3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/tuning/lm_3.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/tuning/lm_4.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/tuning/lm_2.5_ps_0.3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/tuning/lm_2.0_ps_0.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/tuning/lm_4.0_ps_0.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/tuning/lm_4.5_ps_0.3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/tuning/lm_4.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/tuning/lm_3.0_ps_0.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/tuning/lm_3.5_ps_0.3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/tuning/lm_3.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/tuning/lm_2.5_ps_0.3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/tuning/lm_2.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/tuning/lm_2.0_ps_0.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/tuning/lm_4.0_ps_0.3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/tuning/lm_4.5_ps_0.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/tuning/lm_3.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/tuning/lm_3.0_ps_0.3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/tuning/lm_2.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/tuning/lm_3.5_ps_0.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/tuning/lm_4.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/tuning/lm_2.5_ps_0.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/tuning/lm_2.0_ps_0.3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/tuning/lm_4.5_ps_0.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/tuning/lm_4.0_ps_0.3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/tuning/lm_3.5_ps_0.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/tuning/lm_4.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/tuning/lm_3.0_ps_0.3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/tuning/lm_3.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/tuning/lm_2.0_ps_0.3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/tuning/lm_2.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/tuning/lm_2.5_ps_0.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/tuning/lm_4.5_ps_0.3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/tuning/lm_3.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/tuning/lm_4.0_ps_0.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/tuning/lm_3.5_ps_0.3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/tuning/lm_2.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/tuning/lm_3.0_ps_0.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/tuning/lm_2.0_ps_0.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/tuning/lm_2.5_ps_0.3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/tuning/lm_4.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_ctc_scale_0.1/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_ctc_scale_0.1/tuning/lm_4.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_ctc_scale_0.1/tuning/lm_3.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_ctc_scale_0.1/tuning/lm_2.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_ctc_scale_0.1/tuning/lm_3.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_ctc_scale_0.1/tuning/lm_2.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_ctc_scale_0.1/tuning/lm_4.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_4.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_2.0_ps_0.3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_2.5_ps_0.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_4.5_ps_0.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_4.0_ps_0.3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_3.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_2.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_3.5_ps_0.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_3.0_ps_0.3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_3.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_2.0_ps_0.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_2.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_2.5_ps_0.3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_4.5_ps_0.3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_4.0_ps_0.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_4.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_3.5_ps_0.3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_3.0_ps_0.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_blstm_x_vector_specaug/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_trainXvector/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_no_jit/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_no_jit/tuning/lm_3.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_no_jit/tuning/lm_2.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_no_jit/tuning/lm_2.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_no_jit/tuning/lm_1.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector/tuning/lm_3.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector/tuning/lm_2.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector/tuning/lm_4.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector/tuning/lm_4.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector/tuning/lm_3.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector/tuning/lm_2.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/tuning/lm_2.5_ps_0.3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/tuning/lm_2.0_ps_0.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/tuning/lm_4.5_ps_0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/tuning/lm_2.0_ps_0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/tuning/lm_3.0_ps_0.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/tuning/lm_2.5_ps_0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/tuning/lm_3.5_ps_0.3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/tuning/lm_4.0_ps_0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/tuning/lm_4.0_ps_0.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/tuning/lm_4.5_ps_0.3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/tuning/lm_2.5_ps_0.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/tuning/lm_3.5_ps_0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/tuning/lm_2.0_ps_0.3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/tuning/lm_3.0_ps_0.3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/tuning/lm_3.5_ps_0.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/tuning/lm_3.0_ps_0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/tuning/lm_4.0_ps_0.3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/tuning/lm_4.5_ps_0.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/tuning/lm_2.0_ps_0.3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/tuning/lm_2.5_ps_0.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/tuning/lm_4.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/tuning/lm_3.5_ps_0.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/tuning/lm_3.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/tuning/lm_3.0_ps_0.3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/tuning/lm_4.5_ps_0.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/tuning/lm_4.0_ps_0.3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/tuning/lm_2.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/tuning/lm_3.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/tuning/lm_2.0_ps_0.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/tuning/lm_2.5_ps_0.3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/tuning/lm_2.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/tuning/lm_3.5_ps_0.3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/tuning/lm_3.0_ps_0.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/tuning/lm_4.5_ps_0.3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/tuning/lm_4.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/tuning/lm_4.0_ps_0.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector/tuning/lm_2.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector/tuning/lm_3.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector/tuning/lm_4.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector/tuning/lm_4.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector/tuning/lm_2.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector/tuning/lm_3.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvector/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/tuning/lm_2.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/tuning/lm_2.0_ps_0.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/tuning/lm_2.5_ps_0.3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/tuning/lm_3.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/tuning/lm_4.5_ps_0.3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/tuning/lm_4.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/tuning/lm_4.0_ps_0.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/tuning/lm_3.5_ps_0.3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/tuning/lm_3.0_ps_0.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/tuning/lm_4.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/tuning/lm_2.0_ps_0.3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/tuning/lm_2.5_ps_0.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/tuning/lm_4.5_ps_0.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/tuning/lm_2.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/tuning/lm_4.0_ps_0.3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/tuning/lm_3.5_ps_0.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/tuning/lm_3.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/tuning/lm_3.0_ps_0.3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment_tts_train_segments/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment_tts_train_segments/tuning/lm_4.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment_tts_train_segments/tuning/lm_3.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment_tts_train_segments/tuning/lm_2.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment_tts_train_segments/tuning/lm_3.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment_tts_train_segments/tuning/lm_2.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment_tts_train_segments/tuning/lm_4.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/tuning/lm_2.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/tuning/lm_2.0_ps_0.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/tuning/lm_2.5_ps_0.3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/tuning/lm_3.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/tuning/lm_4.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/tuning/lm_4.5_ps_0.3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/tuning/lm_4.0_ps_0.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/tuning/lm_3.5_ps_0.3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/tuning/lm_3.0_ps_0.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/tuning/lm_4.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/tuning/lm_2.0_ps_0.3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/tuning/lm_2.5_ps_0.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/tuning/lm_2.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/tuning/lm_4.5_ps_0.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/tuning/lm_4.0_ps_0.3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/tuning/lm_3.5_ps_0.5/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/tuning/lm_3.0_ps_0.3/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/tuning/lm_3.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v3/tuning/lm_4.0/search/dev-other/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v3/tuning/lm_2.5/search/dev-other/sclite/wer',\n", + " ...]" ] }, "execution_count": 2, @@ -936,6 +1108,1156 @@ "cell_type": "code", "execution_count": 5, "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "| | WER (dev-other) |\n", + "|:---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|------------------:|\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/default_250/dev-other/sclite/wer') | 19 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/lm_tuning/lm1.5_ps0.5/default_250/dev-other/sclite/wer') | 20 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/lm_tuning/lm2.0_ps0.5/default_250/dev-other/sclite/wer') | 18.9 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/lm_tuning/lm2.5_ps0.3/default_250/dev-other/sclite/wer') | 18.2 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/lm_tuning/lm2.0_ps0/default_250/dev-other/sclite/wer') | 18.9 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/lm_tuning/lm4.0_ps0.3/default_250/dev-other/sclite/wer') | 17.8 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/lm_tuning/lm3.5_ps0.3/default_250/dev-other/sclite/wer') | 17.6 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/lm_tuning/lm3.0_ps0/default_250/dev-other/sclite/wer') | 18 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/lm_tuning/lm3.0_ps0.5/default_250/dev-other/sclite/wer') | 17.8 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/lm_tuning/lm2.0_ps0.3/default_250/dev-other/sclite/wer') | 18.9 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/lm_tuning/lm1.5_ps0.3/default_250/dev-other/sclite/wer') | 19.9 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/lm_tuning/lm4.0_ps0/default_250/dev-other/sclite/wer') | 18.1 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/lm_tuning/lm1.5_ps0/default_250/dev-other/sclite/wer') | 19.9 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/lm_tuning/lm2.5_ps0.5/default_250/dev-other/sclite/wer') | 18.2 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/lm_tuning/lm3.5_ps0.5/default_250/dev-other/sclite/wer') | 17.6 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/lm_tuning/lm4.0_ps0.5/default_250/dev-other/sclite/wer') | 17.8 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/lm_tuning/lm3.5_ps0/default_250/dev-other/sclite/wer') | 17.9 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/lm_tuning/lm3.0_ps0.3/default_250/dev-other/sclite/wer') | 17.7 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/lm_tuning/lm2.5_ps0/default_250/dev-other/sclite/wer') | 18.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/default_250/dev-other/sclite/wer') | 36.2 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer') | 36 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer') | 36.8 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_1.5_ps_0.3/default_250/dev-other/sclite/wer') | 40.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer') | 36.9 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer') | 36.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_1.5_ps_0/default_250/dev-other/sclite/wer') | 40.2 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer') | 38 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer') | 36.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_2.0_ps_0.3/default_250/dev-other/sclite/wer') | 39 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer') | 36 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_1.5_ps_0.5/default_250/dev-other/sclite/wer') | 40.7 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer') | 36.1 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer') | 36.9 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer') | 36.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer') | 37.7 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_2.0_ps_0/default_250/dev-other/sclite/wer') | 38.8 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer') | 37.8 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_2.0_ps_0.5/default_250/dev-other/sclite/wer') | 39.2 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/default_250/dev-other/sclite/wer') | 49.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_2.0_ps_0.5/default_250/dev-other/sclite/wer') | 52.1 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer') | 50.7 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer') | 49.8 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer') | 49.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer') | 50 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer') | 49.2 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_1.5_ps_0.5/default_250/dev-other/sclite/wer') | 53.7 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer') | 49.1 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_1.5_ps_0/default_250/dev-other/sclite/wer') | 53.2 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer') | 50.5 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_2.0_ps_0.3/default_250/dev-other/sclite/wer') | 51.9 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer') | 50.9 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer') | 49.1 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer') | 49.5 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer') | 49.9 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_1.5_ps_0.3/default_250/dev-other/sclite/wer') | 53.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_2.0_ps_0/default_250/dev-other/sclite/wer') | 51.7 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer') | 49.1 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm2.5_ps0/default_250/dev-other/sclite/wer') | 30 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm1.5_ps0.5/default_250/dev-other/sclite/wer') | 32.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm2.0_ps0.5/default_250/dev-other/sclite/wer') | 31.1 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm3.5_ps0/default_250/dev-other/sclite/wer') | 28.9 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm2.5_ps0.3/default_250/dev-other/sclite/wer') | 30 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm4.0_ps0.3/default_250/dev-other/sclite/wer') | 28.7 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm3.5_ps0.3/default_250/dev-other/sclite/wer') | 28.9 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm1.5_ps0/default_250/dev-other/sclite/wer') | 32.1 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm3.0_ps0.5/default_250/dev-other/sclite/wer') | 29.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm4.0_ps0/default_250/dev-other/sclite/wer') | 28.7 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm3.0_ps0/default_250/dev-other/sclite/wer') | 29.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm2.0_ps0.3/default_250/dev-other/sclite/wer') | 31.1 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm1.5_ps0.3/default_250/dev-other/sclite/wer') | 32.2 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm2.0_ps0/default_250/dev-other/sclite/wer') | 30.9 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm2.5_ps0.5/default_250/dev-other/sclite/wer') | 30.1 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm3.5_ps0.5/default_250/dev-other/sclite/wer') | 29 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm4.0_ps0.5/default_250/dev-other/sclite/wer') | 28.7 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm3.0_ps0.3/default_250/dev-other/sclite/wer') | 29.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/default_250/dev-other/sclite/wer') | 28.9 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/default_250/dev-other/sclite/wer') | 28.1 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm3.0_ps0.5/default_250/dev-other/sclite/wer') | 29.1 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm4.0_ps0/default_250/dev-other/sclite/wer') | 28.2 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm3.5_ps0.3/default_250/dev-other/sclite/wer') | 28.5 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm4.0_ps0.3/default_250/dev-other/sclite/wer') | 28.2 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm1.5_ps0/default_250/dev-other/sclite/wer') | 31.6 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm2.5_ps0.3/default_250/dev-other/sclite/wer') | 29.6 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm2.5_ps0/default_250/dev-other/sclite/wer') | 29.5 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm2.0_ps0.5/default_250/dev-other/sclite/wer') | 30.6 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm1.5_ps0.5/default_250/dev-other/sclite/wer') | 31.9 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm3.5_ps0/default_250/dev-other/sclite/wer') | 28.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm3.0_ps0.3/default_250/dev-other/sclite/wer') | 28.9 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm4.0_ps0.5/default_250/dev-other/sclite/wer') | 28.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm3.5_ps0.5/default_250/dev-other/sclite/wer') | 28.6 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm3.0_ps0/default_250/dev-other/sclite/wer') | 28.9 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm2.5_ps0.5/default_250/dev-other/sclite/wer') | 29.7 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm2.0_ps0/default_250/dev-other/sclite/wer') | 30.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm1.5_ps0.3/default_250/dev-other/sclite/wer') | 31.8 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm2.0_ps0.3/default_250/dev-other/sclite/wer') | 30.5 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer') | 27.1 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer') | 27.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer') | 27.8 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer') | 27.7 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer') | 27.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer') | 28.5 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer') | 27.1 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer') | 27.1 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer') | 28.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer') | 27.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer') | 27.8 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer') | 28.5 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/default_250/dev-other/sclite/wer') | 27.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/weak_baseline/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/weak_baseline/default_250/dev-other/sclite/wer') | 37.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/weak_baseline/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/weak_baseline/lm_tuning/lm3.0/default_250/dev-other/sclite/wer') | 26.2 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/weak_baseline/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/weak_baseline/lm_tuning/lm2.0/default_250/dev-other/sclite/wer') | 25.7 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/weak_baseline/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/weak_baseline/lm_tuning/lm3.5/default_250/dev-other/sclite/wer') | 28 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/weak_baseline/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/weak_baseline/lm_tuning/lm2.5/default_250/dev-other/sclite/wer') | 25.5 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/weak_baseline/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/weak_baseline/lm_tuning/lm1.5/default_250/dev-other/sclite/wer') | 27.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/weak_baseline/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/weak_baseline/lm_tuning/lm4.0/default_250/dev-other/sclite/wer') | 30.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/default_250/dev-other/sclite/wer') | 42.1 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer') | 37.7 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer') | 37.7 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_1.5_ps_0.3/default_250/dev-other/sclite/wer') | 39.9 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer') | 38.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_2.0_ps_0/default_250/dev-other/sclite/wer') | 38.7 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_2.0_ps_0.3/default_250/dev-other/sclite/wer') | 38.7 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer') | 38.2 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer') | 39.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer') | 37.9 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer') | 37.9 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer') | 38.5 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer') | 37.5 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_1.5_ps_0.5/default_250/dev-other/sclite/wer') | 40 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_1.5_ps_0/default_250/dev-other/sclite/wer') | 39.9 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer') | 38.1 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_2.0_ps_0.5/default_250/dev-other/sclite/wer') | 38.7 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer') | 37.9 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer') | 38.2 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/default_250/dev-other/sclite/wer') | 26.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer') | 22.6 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer') | 22.2 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_1.5_ps_0.5/default_250/dev-other/sclite/wer') | 23.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer') | 21.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_1.5_ps_0/default_250/dev-other/sclite/wer') | 23.2 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer') | 21.9 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer') | 21.7 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer') | 22.1 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_2.0_ps_0.5/default_250/dev-other/sclite/wer') | 22.2 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer') | 22.6 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_1.5_ps_0.3/default_250/dev-other/sclite/wer') | 23.2 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer') | 21.6 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_2.0_ps_0/default_250/dev-other/sclite/wer') | 22.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer') | 21.7 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer') | 23.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer') | 22 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer') | 21.6 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_2.0_ps_0.3/default_250/dev-other/sclite/wer') | 22.2 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_v2/default_250/dev-other/sclite/wer') | 26.6 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer') | 18.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer') | 18.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer') | 18.1 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer') | 18.1 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer') | 18.7 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer') | 18.2 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer') | 18.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer') | 18 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer') | 18.7 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer') | 18.1 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer') | 18.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer') | 18.7 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/tuned_no_prior/default_250/dev-other/sclite/wer') | 18.2 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/tuned/default_250/dev-other/sclite/wer') | 18 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/default_250/dev-other/sclite/wer') | 19.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/default_250/dev-other/sclite/wer') | 43.1 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer') | 38.7 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/search_params/lm_1.5_ps_0.3/default_250/dev-other/sclite/wer') | 39.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer') | 37.6 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer') | 39.8 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer') | 38 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer') | 37.7 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/search_params/lm_2.0_ps_0/default_250/dev-other/sclite/wer') | 38.5 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer') | 37.7 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/search_params/lm_2.0_ps_0.3/default_250/dev-other/sclite/wer') | 38.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer') | 38.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer') | 38.2 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/search_params/lm_1.5_ps_0.5/default_250/dev-other/sclite/wer') | 39.7 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer') | 37.5 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer') | 37.9 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/search_params/lm_1.5_ps_0/default_250/dev-other/sclite/wer') | 39.6 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer') | 37.7 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer') | 38.6 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/search_params/lm_2.0_ps_0.5/default_250/dev-other/sclite/wer') | 38.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer') | 25.5 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/search_params/lm_2.0_ps_0.3/default_250/dev-other/sclite/wer') | 25.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer') | 24.9 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/search_params/lm_1.5_ps_0/default_250/dev-other/sclite/wer') | 26.5 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/search_params/lm_1.5_ps_0.3/default_250/dev-other/sclite/wer') | 26.5 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer') | 26.1 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer') | 26.2 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer') | 25.1 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer') | 25 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/search_params/lm_2.0_ps_0.5/default_250/dev-other/sclite/wer') | 25.5 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer') | 27.1 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer') | 25.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer') | 25 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/search_params/lm_1.5_ps_0.5/default_250/dev-other/sclite/wer') | 26.6 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/search_params/lm_2.0_ps_0/default_250/dev-other/sclite/wer') | 25.6 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer') | 25.7 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer') | 25.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer') | 24.8 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/default_250/dev-other/sclite/wer') | 29.8 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer') | 23.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer') | 23 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer') | 23.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer') | 22.9 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer') | 23.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer') | 23.1 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0/search_params/lm_2.0_ps_0.3/default_250/dev-other/sclite/wer') | 23.9 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0/search_params/lm_2.0_ps_0/default_250/dev-other/sclite/wer') | 24 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer') | 23.2 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer') | 22.9 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer') | 23 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer') | 23.9 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer') | 23.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0/search_params/lm_2.0_ps_0.5/default_250/dev-other/sclite/wer') | 23.9 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer') | 23.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0/default_250/dev-other/sclite/wer') | 25.9 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm1.5_ps0/default_250/dev-other/sclite/wer') | 29.8 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm4.0_ps0/default_250/dev-other/sclite/wer') | 26.6 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm3.5_ps0.5/default_250/dev-other/sclite/wer') | 26.9 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm4.0_ps0.5/default_250/dev-other/sclite/wer') | 26.6 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm3.0_ps0.3/default_250/dev-other/sclite/wer') | 27.2 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm3.5_ps0/default_250/dev-other/sclite/wer') | 26.8 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm2.0_ps0.3/default_250/dev-other/sclite/wer') | 28.7 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm1.5_ps0.3/default_250/dev-other/sclite/wer') | 30 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm2.5_ps0/default_250/dev-other/sclite/wer') | 27.8 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm2.5_ps0.5/default_250/dev-other/sclite/wer') | 28 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm4.0_ps0.3/default_250/dev-other/sclite/wer') | 26.5 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm3.5_ps0.3/default_250/dev-other/sclite/wer') | 26.8 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm3.0_ps0.5/default_250/dev-other/sclite/wer') | 27.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm1.5_ps0.5/default_250/dev-other/sclite/wer') | 30.1 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm2.0_ps0.5/default_250/dev-other/sclite/wer') | 28.8 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm2.0_ps0/default_250/dev-other/sclite/wer') | 28.6 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm2.5_ps0.3/default_250/dev-other/sclite/wer') | 27.9 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm3.0_ps0/default_250/dev-other/sclite/wer') | 27.2 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/default_250/dev-other/sclite/wer') | 26.9 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/default_250/dev-other/sclite/wer') | 24.1 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer') | 21.9 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer') | 20.6 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer') | 20.7 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer') | 20.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer') | 20 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/search_params/lm_2.0_ps_0/default_250/dev-other/sclite/wer') | 21 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/search_params/lm_2.0_ps_0.5/default_250/dev-other/sclite/wer') | 20.8 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer') | 20.2 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer') | 21.1 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer') | 20.2 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer') | 20.1 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer') | 20.6 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer') | 21 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/search_params/lm_2.0_ps_0.3/default_250/dev-other/sclite/wer') | 20.7 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer') | 20.2 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_100ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_100ep_dec_0.05_v2/search_params/lm_1.5_ps_0/default_250/dev-other/sclite/wer') | 22.9 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_100ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_100ep_dec_0.05_v2/search_params/lm_2.0_ps_0.3/default_250/dev-other/sclite/wer') | 21.8 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_100ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_100ep_dec_0.05_v2/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer') | 21.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_100ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_100ep_dec_0.05_v2/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer') | 22.1 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_100ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_100ep_dec_0.05_v2/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer') | 21.5 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_100ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_100ep_dec_0.05_v2/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer') | 21.7 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_100ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_100ep_dec_0.05_v2/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer') | 21.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_100ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_100ep_dec_0.05_v2/search_params/lm_1.5_ps_0.3/default_250/dev-other/sclite/wer') | 22.7 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_100ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_100ep_dec_0.05_v2/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer') | 22.1 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_100ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_100ep_dec_0.05_v2/search_params/lm_2.0_ps_0.5/default_250/dev-other/sclite/wer') | 21.8 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_100ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_100ep_dec_0.05_v2/search_params/lm_2.0_ps_0/default_250/dev-other/sclite/wer') | 22 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_100ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_100ep_dec_0.05_v2/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer') | 21.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_100ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_100ep_dec_0.05_v2/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer') | 21.6 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_100ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_100ep_dec_0.05_v2/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer') | 21.2 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_100ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_100ep_dec_0.05_v2/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer') | 22.8 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_100ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_100ep_dec_0.05_v2/search_params/lm_1.5_ps_0.5/default_250/dev-other/sclite/wer') | 22.8 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_100ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_100ep_dec_0.05_v2/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer') | 21.7 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_100ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_100ep_dec_0.05_v2/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer') | 22 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_100ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_100ep_dec_0.05_v2/default_250/dev-other/sclite/wer') | 25.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer') | 20 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer') | 20.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer') | 20.5 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer') | 21.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer') | 19.9 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer') | 19.9 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer') | 20.6 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer') | 20 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer') | 20.2 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer') | 20 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer') | 20.2 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer') | 19.7 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/default_250/dev-other/sclite/wer') | 23.6 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm2.5_ps0.5/default_250/dev-other/sclite/wer') | 27.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm1.5_ps0.3/default_250/dev-other/sclite/wer') | 29.6 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm2.0_ps0.3/default_250/dev-other/sclite/wer') | 28.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm3.0_ps0/default_250/dev-other/sclite/wer') | 26.8 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm3.0_ps0.3/default_250/dev-other/sclite/wer') | 26.8 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm2.0_ps0/default_250/dev-other/sclite/wer') | 28.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm4.0_ps0.5/default_250/dev-other/sclite/wer') | 26.1 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm3.5_ps0.5/default_250/dev-other/sclite/wer') | 26.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm2.5_ps0.3/default_250/dev-other/sclite/wer') | 27.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm4.0_ps0/default_250/dev-other/sclite/wer') | 26.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm2.0_ps0.5/default_250/dev-other/sclite/wer') | 28.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm1.5_ps0.5/default_250/dev-other/sclite/wer') | 29.7 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm1.5_ps0/default_250/dev-other/sclite/wer') | 29.5 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm3.0_ps0.5/default_250/dev-other/sclite/wer') | 26.8 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm2.5_ps0/default_250/dev-other/sclite/wer') | 27.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm3.5_ps0.3/default_250/dev-other/sclite/wer') | 26.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm4.0_ps0.3/default_250/dev-other/sclite/wer') | 26.1 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/lm_tuning/lm3.5_ps0/default_250/dev-other/sclite/wer') | 26.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/default_250/dev-other/sclite/wer') | 26.6 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/default_250/dev-other/sclite/wer') | 19.7 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm2.5_ps0.5/default_250/dev-other/sclite/wer') | 18.9 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm1.5_ps0.3/default_250/dev-other/sclite/wer') | 20.8 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm2.0_ps0.3/default_250/dev-other/sclite/wer') | 19.8 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm2.0_ps0/default_250/dev-other/sclite/wer') | 19.8 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm3.0_ps0.3/default_250/dev-other/sclite/wer') | 18.6 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm3.0_ps0/default_250/dev-other/sclite/wer') | 18.7 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm4.0_ps0.5/default_250/dev-other/sclite/wer') | 18.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm3.5_ps0.5/default_250/dev-other/sclite/wer') | 18.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm1.5_ps0/default_250/dev-other/sclite/wer') | 20.9 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm2.5_ps0.3/default_250/dev-other/sclite/wer') | 19 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm4.0_ps0/default_250/dev-other/sclite/wer') | 18.8 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm2.0_ps0.5/default_250/dev-other/sclite/wer') | 19.8 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm1.5_ps0.5/default_250/dev-other/sclite/wer') | 20.9 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm3.5_ps0/default_250/dev-other/sclite/wer') | 18.6 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm3.0_ps0.5/default_250/dev-other/sclite/wer') | 18.5 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm2.5_ps0/default_250/dev-other/sclite/wer') | 19 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm3.5_ps0.3/default_250/dev-other/sclite/wer') | 18.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm4.0_ps0.3/default_250/dev-other/sclite/wer') | 18.5 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_v3/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_v3/default_250/dev-other/sclite/wer') | 26.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer') | 19.2 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer') | 19.6 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_2.0_ps_0.5/default_250/dev-other/sclite/wer') | 19.7 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer') | 18.9 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer') | 19.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer') | 19.6 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer') | 19.9 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer') | 19.1 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_2.0_ps_0.3/default_250/dev-other/sclite/wer') | 19.7 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer') | 20.6 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer') | 19.5 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer') | 19 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_2.0_ps_0/default_250/dev-other/sclite/wer') | 20 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer') | 19.1 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer') | 19.9 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/default_250/dev-other/sclite/wer') | 23 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer') | 24.7 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer') | 23.6 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer') | 25.8 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer') | 23.8 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer') | 25.8 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer') | 24.1 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer') | 23.7 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer') | 27.1 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer') | 24.2 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer') | 25.2 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer') | 23.6 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer') | 24.6 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/default_250/dev-other/sclite/wer') | 30.8 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/default_250/dev-other/sclite/wer') | 24 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_2.0_ps_0.3/default_250/dev-other/sclite/wer') | 20.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer') | 19.9 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_2.0_ps_0/default_250/dev-other/sclite/wer') | 20.6 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer') | 19.8 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer') | 19.8 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer') | 20.1 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer') | 20.6 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer') | 21.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_2.0_ps_0.5/default_250/dev-other/sclite/wer') | 20.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer') | 19.8 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer') | 20.5 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer') | 19.9 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer') | 20.1 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer') | 19.7 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer') | 20.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment_before/glow_enc192_200ep_not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment_before/glow_enc192_200ep_not_silence_preprocessed/default_250/dev-other/sclite/wer') | 100 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/default_250/dev-other/sclite/wer') | 27.6 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer') | 25.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer') | 25.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer') | 25.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer') | 25.8 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer') | 25.7 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer') | 26 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer') | 25.2 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer') | 25.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer') | 25.6 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer') | 25.6 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer') | 25.7 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer') | 25.5 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/tuned/default_250/dev-other/sclite/wer') | 21.8 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer') | 21.9 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer') | 22.5 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer') | 24.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer') | 22.1 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer') | 23.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer') | 21.9 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer') | 21.8 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer') | 22.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer') | 22.8 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer') | 22.6 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer') | 22 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer') | 23.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/default_250/dev-other/sclite/wer') | 27.5 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/batch_norm/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/batch_norm/default_250/dev-other/sclite/wer') | 29.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/layer_norm/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/layer_norm/default_250/dev-other/sclite/wer') | 28.5 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.2/default_250/dev-other/sclite/wer') | 25.5 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/default_250/dev-other/sclite/wer') | 25.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer') | 20.6 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer') | 20 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer') | 21.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer') | 20.1 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer') | 21.2 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer') | 20.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer') | 20 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer') | 22.2 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer') | 20.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer') | 20.9 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer') | 20 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer') | 20.5 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.1/default_250/dev-other/sclite/wer') | 25.8 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/tuning/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer') | 21.6 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/tuning/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer') | 21.2 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/tuning/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer') | 22 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/tuning/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer') | 21.2 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/tuning/lm_2.5_ps_0/default_250/dev-other/sclite/wer') | 21.7 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/tuning/lm_4.0_ps_0/default_250/dev-other/sclite/wer') | 23.2 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/tuning/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer') | 21.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/tuning/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer') | 21.2 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/tuning/lm_3.5_ps_0/default_250/dev-other/sclite/wer') | 22.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/tuning/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer') | 22.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/tuning/lm_3.0_ps_0/default_250/dev-other/sclite/wer') | 21.8 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/tuning/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer') | 21.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/default_250/dev-other/sclite/wer') | 26.5 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.4/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.4/default_250/dev-other/sclite/wer') | 25.2 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/default_250/dev-other/sclite/wer') | 100 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/tuning/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer') | 100 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/tuning/lm_2.5_ps_0/default_250/dev-other/sclite/wer') | 100 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/tuning/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer') | 100 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/tuning/lm_4.0_ps_0/default_250/dev-other/sclite/wer') | 100 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/tuning/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer') | 100 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/tuning/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer') | 100 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/tuning/lm_3.0_ps_0/default_250/dev-other/sclite/wer') | 100 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/tuning/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer') | 100 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/tuning/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer') | 100 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/tuning/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer') | 100 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/tuning/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer') | 100 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/tuning/lm_3.5_ps_0/default_250/dev-other/sclite/wer') | 100 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/default_250/dev-other/sclite/wer') | 26.2 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer') | 19.5 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer') | 19.9 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer') | 21.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer') | 19.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer') | 19.9 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer') | 20.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer') | 19.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer') | 20.1 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer') | 19.6 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer') | 20.5 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer') | 19.8 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer') | 20.5 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/default_250/dev-other/sclite/wer') | 24.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/tts_dataset/spec_augment/no_glow/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/tts_dataset/spec_augment/no_glow/default_250/dev-other/sclite/wer') | 20.9 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/tts_dataset/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/tts_dataset/default_250/dev-other/sclite/wer') | 59.8 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/tuning/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer') | 49.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/tuning/lm_3.5_ps_0/default_250/dev-other/sclite/wer') | 49.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/tuning/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer') | 47.9 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/tuning/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer') | 48.2 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/tuning/lm_3.0_ps_0/default_250/dev-other/sclite/wer') | 49.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/tuning/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer') | 48.1 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/tuning/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer') | 49.2 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/tuning/lm_2.5_ps_0/default_250/dev-other/sclite/wer') | 50 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/tuning/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer') | 48.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/tuning/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer') | 47.7 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/tuning/lm_4.0_ps_0/default_250/dev-other/sclite/wer') | 50 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/tuning/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer') | 48.5 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/default_250/dev-other/sclite/wer') | 53 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/default_250/dev-other/sclite/wer') | 57 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/linear_1x512_d0.2_b300_fs4/glow_nar_taco_encoder_16blocks/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/linear_1x512_d0.2_b300_fs4/glow_nar_taco_encoder_16blocks/default_250/dev-other/sclite/wer') | 98.8 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/linear_1x512_d0.2_b300_fs4/glow_enc768/tts_dataset/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/linear_1x512_d0.2_b300_fs4/glow_enc768/tts_dataset/default_250/dev-other/sclite/wer') | 99.7 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x1024_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x1024_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/default_250/dev-other/sclite/wer') | 66.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc768/with_sigma/not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc768/with_sigma/not_silence_preprocessed/default_250/dev-other/sclite/wer') | 70.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc768/with_sigma/silence_preprocessing/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc768/with_sigma/silence_preprocessing/default_250/dev-other/sclite/wer') | 71.9 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_simple_encoder_epoch84/silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_simple_encoder_epoch84/silence_preprocessed/default_250/dev-other/sclite/wer') | 57.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_nar_taco_encoder_16blocks/not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_nar_taco_encoder_16blocks/not_silence_preprocessed/default_250/dev-other/sclite/wer') | 55.1 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_nar_taco_encoder/not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_nar_taco_encoder/not_silence_preprocessed/default_250/dev-other/sclite/wer') | 66.2 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_nar_taco_encoder/silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_nar_taco_encoder/silence_preprocessed/default_250/dev-other/sclite/wer') | 67.7 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc192/200epsTTS/silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc192/200epsTTS/silence_preprocessed/default_250/dev-other/sclite/wer') | 61.8 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc192/200epsTTS/not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc192/200epsTTS/not_silence_preprocessed/default_250/dev-other/sclite/wer') | 61.8 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc192/200epsTTS_early_eval_ep100/not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc192/200epsTTS_early_eval_ep100/not_silence_preprocessed/default_250/dev-other/sclite/wer') | 60.6 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc192/200epsTTS_early_eval_ep100/silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc192/200epsTTS_early_eval_ep100/silence_preprocessed/default_250/dev-other/sclite/wer') | 60.8 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc192/not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc192/not_silence_preprocessed/default_250/dev-other/sclite/wer') | 61.1 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc192/100epTTS/silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_enc192/100epTTS/silence_preprocessed/default_250/dev-other/sclite/wer') | 59.7 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_with_small_enc/silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_with_small_enc/silence_preprocessed/default_250/dev-other/sclite/wer') | 79.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_simple_encoder/silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_simple_encoder/silence_preprocessed/default_250/dev-other/sclite/wer') | 56.9 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm4.0_ps0.5/default_250/dev-other/sclite/wer') | 35 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm3.5_ps0.5/default_250/dev-other/sclite/wer') | 34.2 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm3.5_ps0/default_250/dev-other/sclite/wer') | 35.6 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm3.0_ps0.3/default_250/dev-other/sclite/wer') | 34.2 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm2.5_ps0/default_250/dev-other/sclite/wer') | 35.2 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm1.5_ps0.3/default_250/dev-other/sclite/wer') | 37.6 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm4.0_ps0/default_250/dev-other/sclite/wer') | 36.7 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm2.0_ps0.3/default_250/dev-other/sclite/wer') | 35.9 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm1.5_ps0/default_250/dev-other/sclite/wer') | 37.9 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm2.5_ps0.5/default_250/dev-other/sclite/wer') | 34.6 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm3.5_ps0.3/default_250/dev-other/sclite/wer') | 34.5 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm2.0_ps0/default_250/dev-other/sclite/wer') | 36.2 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm4.0_ps0.3/default_250/dev-other/sclite/wer') | 35.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm3.0_ps0/default_250/dev-other/sclite/wer') | 35.1 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm3.0_ps0.5/default_250/dev-other/sclite/wer') | 34 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm2.0_ps0.5/default_250/dev-other/sclite/wer') | 35.9 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm1.5_ps0.5/default_250/dev-other/sclite/wer') | 37.9 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm2.5_ps0.3/default_250/dev-other/sclite/wer') | 34.6 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/default_250/dev-other/sclite/wer') | 40.7 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/default_250/dev-other/sclite/wer') | 36.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm3.0_ps0.3/default_250/dev-other/sclite/wer') | 34.5 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm4.0_ps0.5/default_250/dev-other/sclite/wer') | 33.8 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm3.5_ps0.5/default_250/dev-other/sclite/wer') | 33.9 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm2.5_ps0.5/default_250/dev-other/sclite/wer') | 35.5 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm3.0_ps0/default_250/dev-other/sclite/wer') | 34.7 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm1.5_ps0.3/default_250/dev-other/sclite/wer') | 39.5 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm2.0_ps0/default_250/dev-other/sclite/wer') | 37.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm2.0_ps0.3/default_250/dev-other/sclite/wer') | 37.2 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm3.0_ps0.5/default_250/dev-other/sclite/wer') | 34.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm3.5_ps0.3/default_250/dev-other/sclite/wer') | 34 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm4.0_ps0/default_250/dev-other/sclite/wer') | 34.7 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm4.0_ps0.3/default_250/dev-other/sclite/wer') | 34.1 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm1.5_ps0/default_250/dev-other/sclite/wer') | 39.5 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm2.5_ps0.3/default_250/dev-other/sclite/wer') | 35.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm2.5_ps0/default_250/dev-other/sclite/wer') | 35.8 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm2.0_ps0.5/default_250/dev-other/sclite/wer') | 37.2 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm1.5_ps0.5/default_250/dev-other/sclite/wer') | 39.6 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm3.5_ps0/default_250/dev-other/sclite/wer') | 34.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/default/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/default/default_250/dev-other/sclite/wer') | 55.1 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_simple_encoder/silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_simple_encoder/silence_preprocessed/default_250/dev-other/sclite/wer') | 50.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment_before/glow_enc192_200ep/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment_before/glow_enc192_200ep/default_250/dev-other/sclite/wer') | 92.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment_before/glow_enc192_200ep_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment_before/glow_enc192_200ep_not_freezed/default_250/dev-other/sclite/wer') | 30.9 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/drop_around_blstm/spec_augment/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/drop_around_blstm/spec_augment/default_250/dev-other/sclite/wer') | 94.2 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/drop_around_blstm/lm5/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/drop_around_blstm/lm5/default_250/dev-other/sclite/wer') | 66.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/silence_preprocessing/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/silence_preprocessing/default_250/dev-other/sclite/wer') | 76.2 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/default_250/dev-other/sclite/wer') | 73.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/default_250/dev-other/sclite/wer') | 67.1 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/tuning/lm_4.0_ps_0/default_250/dev-other/sclite/wer') | 64 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/tuning/lm_2.5_ps_0/default_250/dev-other/sclite/wer') | 63.8 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/tuning/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer') | 63.5 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/tuning/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer') | 61.8 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/tuning/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer') | 62.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/tuning/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer') | 62.7 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/tuning/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer') | 63.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/tuning/lm_3.0_ps_0/default_250/dev-other/sclite/wer') | 63.2 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/tuning/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer') | 62.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/tuning/lm_3.5_ps_0/default_250/dev-other/sclite/wer') | 63.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/tuning/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer') | 62.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/tuning/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer') | 62.1 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/silence_preprocessed/default_250/dev-other/sclite/wer') | 78.1 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/default_250/dev-other/sclite/wer') | 79.1 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/tuning/lm_4.0_ps_0/default_250/dev-other/sclite/wer') | 69.5 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/tuning/lm_2.5_ps_0/default_250/dev-other/sclite/wer') | 55.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/tuning/lm_3.5_ps_0/default_250/dev-other/sclite/wer') | 64.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/tuning/lm_3.0_ps_0/default_250/dev-other/sclite/wer') | 59.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/tuning/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer') | 62.6 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/tuning/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer') | 62.8 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/tuning/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer') | 62.9 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/tuning/lm_2.5_ps_0/default_250/dev-other/sclite/wer') | 64.6 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/tuning/lm_4.0_ps_0/default_250/dev-other/sclite/wer') | 64.6 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/tuning/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer') | 63.9 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/tuning/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer') | 63.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/tuning/lm_3.5_ps_0/default_250/dev-other/sclite/wer') | 64 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/tuning/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer') | 63.1 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/tuning/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer') | 62.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/tuning/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer') | 63.8 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/tuning/lm_3.0_ps_0/default_250/dev-other/sclite/wer') | 63.8 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/default_250/dev-other/sclite/wer') | 67.8 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm1.5_ps0.3/default_250/dev-other/sclite/wer') | 26.1 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm2.0_ps0.3/default_250/dev-other/sclite/wer') | 24.7 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm3.0_ps0/default_250/dev-other/sclite/wer') | 25 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm2.5_ps0.5/default_250/dev-other/sclite/wer') | 24.1 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm2.0_ps0/default_250/dev-other/sclite/wer') | 25.1 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm4.0_ps0.5/default_250/dev-other/sclite/wer') | 25.1 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm3.5_ps0.5/default_250/dev-other/sclite/wer') | 24.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm3.0_ps0.3/default_250/dev-other/sclite/wer') | 24 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm2.5_ps0/default_250/dev-other/sclite/wer') | 24.7 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm2.0_ps0.5/default_250/dev-other/sclite/wer') | 24.6 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm1.5_ps0.5/default_250/dev-other/sclite/wer') | 26.1 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm3.5_ps0/default_250/dev-other/sclite/wer') | 26 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm2.5_ps0.3/default_250/dev-other/sclite/wer') | 24.2 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm3.5_ps0.3/default_250/dev-other/sclite/wer') | 24.6 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm4.0_ps0.3/default_250/dev-other/sclite/wer') | 25.7 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm1.5_ps0/default_250/dev-other/sclite/wer') | 26.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm4.0_ps0/default_250/dev-other/sclite/wer') | 27.5 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/lm_tuning/lm3.0_ps0.5/default_250/dev-other/sclite/wer') | 23.9 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/default_250/dev-other/sclite/wer') | 32.2 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc768_100ep_xvector/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc768_100ep_xvector/default_250/dev-other/sclite/wer') | 62.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/default_250/dev-other/sclite/wer') | 35.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm2.5_ps0.5/default_250/dev-other/sclite/wer') | 32.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm2.0_ps0/default_250/dev-other/sclite/wer') | 33.9 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm1.5_ps0.3/default_250/dev-other/sclite/wer') | 35.7 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm2.0_ps0.3/default_250/dev-other/sclite/wer') | 33.6 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm3.0_ps0/default_250/dev-other/sclite/wer') | 32.1 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm3.0_ps0.3/default_250/dev-other/sclite/wer') | 31.7 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm4.0_ps0.5/default_250/dev-other/sclite/wer') | 31.6 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm3.5_ps0.5/default_250/dev-other/sclite/wer') | 31.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm2.5_ps0.3/default_250/dev-other/sclite/wer') | 32.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm3.5_ps0/default_250/dev-other/sclite/wer') | 32.1 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm2.0_ps0.5/default_250/dev-other/sclite/wer') | 33.8 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm2.5_ps0/default_250/dev-other/sclite/wer') | 32.6 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm1.5_ps0.5/default_250/dev-other/sclite/wer') | 36 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm1.5_ps0/default_250/dev-other/sclite/wer') | 35.6 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm3.0_ps0.5/default_250/dev-other/sclite/wer') | 31.6 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm4.0_ps0/default_250/dev-other/sclite/wer') | 32.6 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm3.5_ps0.3/default_250/dev-other/sclite/wer') | 31.5 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/lm_tuning/lm4.0_ps0.3/default_250/dev-other/sclite/wer') | 31.9 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/tuned/lm_2.5_ps_0/default_250/dev-other/sclite/wer') | 44.6 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/tuned/lm_4.0_ps_0/default_250/dev-other/sclite/wer') | 52.2 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/tuned/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer') | 42.2 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/tuned/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer') | 45.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/tuned/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer') | 41.8 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/tuned/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer') | 46.1 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/tuned/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer') | 41.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/tuned/lm_3.0_ps_0/default_250/dev-other/sclite/wer') | 46.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/tuned/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer') | 43.5 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/tuned/lm_3.5_ps_0/default_250/dev-other/sclite/wer') | 48.9 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/tuned/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer') | 43.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/tuned/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer') | 48.1 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/default_250/dev-other/sclite/wer') | 60.7 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/tuned/lm_2.5_ps_0/default_250/dev-other/sclite/wer') | 59.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/tuned/lm_4.0_ps_0/default_250/dev-other/sclite/wer') | 58.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/tuned/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer') | 58.5 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/tuned/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer') | 57.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/tuned/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer') | 56.6 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/tuned/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer') | 57.6 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/tuned/lm_3.0_ps_0/default_250/dev-other/sclite/wer') | 58.2 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/tuned/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer') | 58.7 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/tuned/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer') | 56.8 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/tuned/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer') | 57.1 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/tuned/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer') | 57.2 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/tuned/lm_3.5_ps_0/default_250/dev-other/sclite/wer') | 58 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/default_250/dev-other/sclite/wer') | 60.5 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval_spec_aug/not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval_spec_aug/not_silence_preprocessed/default_250/dev-other/sclite/wer') | 67.7 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment_before/glow_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment_before/glow_not_pretrained/default_250/dev-other/sclite/wer') | 30.5 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment_before/glow_not_pretrained', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment_before/glow_not_pretrainedlm_tuning/lm3.0_ps0/default_250/dev-other/sclite/wer') | 24.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment_before/glow_not_pretrained', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment_before/glow_not_pretrainedlm_tuning/lm3.0_ps0.3/default_250/dev-other/sclite/wer') | 23.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment_before/glow_not_pretrained', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment_before/glow_not_pretrainedlm_tuning/lm2.0_ps0/default_250/dev-other/sclite/wer') | 24.7 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment_before/glow_not_pretrained', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment_before/glow_not_pretrainedlm_tuning/lm3.5_ps0.5/default_250/dev-other/sclite/wer') | 23.5 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment_before/glow_not_pretrained', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment_before/glow_not_pretrainedlm_tuning/lm4.0_ps0.5/default_250/dev-other/sclite/wer') | 24.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment_before/glow_not_pretrained', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment_before/glow_not_pretrainedlm_tuning/lm2.5_ps0.5/default_250/dev-other/sclite/wer') | 23.5 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment_before/glow_not_pretrained', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment_before/glow_not_pretrainedlm_tuning/lm2.0_ps0.3/default_250/dev-other/sclite/wer') | 24.6 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment_before/glow_not_pretrained', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment_before/glow_not_pretrainedlm_tuning/lm1.5_ps0.3/default_250/dev-other/sclite/wer') | 26.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment_before/glow_not_pretrained', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment_before/glow_not_pretrainedlm_tuning/lm2.5_ps0/default_250/dev-other/sclite/wer') | 24.1 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment_before/glow_not_pretrained', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment_before/glow_not_pretrainedlm_tuning/lm3.0_ps0.5/default_250/dev-other/sclite/wer') | 23.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment_before/glow_not_pretrained', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment_before/glow_not_pretrainedlm_tuning/lm3.5_ps0/default_250/dev-other/sclite/wer') | 25 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment_before/glow_not_pretrained', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment_before/glow_not_pretrainedlm_tuning/lm4.0_ps0.3/default_250/dev-other/sclite/wer') | 24.9 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment_before/glow_not_pretrained', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment_before/glow_not_pretrainedlm_tuning/lm3.5_ps0.3/default_250/dev-other/sclite/wer') | 23.9 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment_before/glow_not_pretrained', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment_before/glow_not_pretrainedlm_tuning/lm2.5_ps0.3/default_250/dev-other/sclite/wer') | 23.6 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment_before/glow_not_pretrained', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment_before/glow_not_pretrainedlm_tuning/lm1.5_ps0/default_250/dev-other/sclite/wer') | 26.2 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment_before/glow_not_pretrained', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment_before/glow_not_pretrainedlm_tuning/lm1.5_ps0.5/default_250/dev-other/sclite/wer') | 26.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment_before/glow_not_pretrained', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment_before/glow_not_pretrainedlm_tuning/lm4.0_ps0/default_250/dev-other/sclite/wer') | 26.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment_before/glow_not_pretrained', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment_before/glow_not_pretrainedlm_tuning/lm2.0_ps0.5/default_250/dev-other/sclite/wer') | 24.6 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/default_250/dev-other/sclite/wer') | 40.9 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm1.5_ps0.5/default_250/dev-other/sclite/wer') | 42 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm2.0_ps0.5/default_250/dev-other/sclite/wer') | 40 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm2.5_ps0/default_250/dev-other/sclite/wer') | 38.5 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm2.5_ps0.3/default_250/dev-other/sclite/wer') | 38.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm3.5_ps0/default_250/dev-other/sclite/wer') | 38.1 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm4.0_ps0.3/default_250/dev-other/sclite/wer') | 37.8 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm3.5_ps0.3/default_250/dev-other/sclite/wer') | 37.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm4.0_ps0/default_250/dev-other/sclite/wer') | 38.7 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm3.0_ps0.5/default_250/dev-other/sclite/wer') | 37.7 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm1.5_ps0/default_250/dev-other/sclite/wer') | 41.3 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm2.0_ps0.3/default_250/dev-other/sclite/wer') | 39.8 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm1.5_ps0.3/default_250/dev-other/sclite/wer') | 41.7 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm3.0_ps0/default_250/dev-other/sclite/wer') | 38 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm2.5_ps0.5/default_250/dev-other/sclite/wer') | 38.7 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm2.0_ps0/default_250/dev-other/sclite/wer') | 39.6 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm3.5_ps0.5/default_250/dev-other/sclite/wer') | 37.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm4.0_ps0.5/default_250/dev-other/sclite/wer') | 37.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm3.0_ps0.3/default_250/dev-other/sclite/wer') | 37.7 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/default_250/dev-other/sclite/wer') | 54.6 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0.3/default_250/dev-other/sclite/wer') | 35.5 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_1.5_ps_0/default_250/dev-other/sclite/wer') | 36.2 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0.5/default_250/dev-other/sclite/wer') | 36.6 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0.3/default_250/dev-other/sclite/wer') | 41.1 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_1.5_ps_0.3/default_250/dev-other/sclite/wer') | 35.5 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0/default_250/dev-other/sclite/wer') | 41.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0/default_250/dev-other/sclite/wer') | 38.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0.5/default_250/dev-other/sclite/wer') | 33.8 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_2.0_ps_0.3/default_250/dev-other/sclite/wer') | 34 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_3.0_ps_0.5/default_250/dev-other/sclite/wer') | 34.6 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_3.5_ps_0.3/default_250/dev-other/sclite/wer') | 38 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_2.0_ps_0/default_250/dev-other/sclite/wer') | 35.5 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0.5/default_250/dev-other/sclite/wer') | 39.5 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_1.5_ps_0.5/default_250/dev-other/sclite/wer') | 35.7 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0.3/default_250/dev-other/sclite/wer') | 34.2 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_2.0_ps_0.5/default_250/dev-other/sclite/wer') | 34 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_2.5_ps_0/default_250/dev-other/sclite/wer') | 36.2 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_4.0_ps_0/default_250/dev-other/sclite/wer') | 45.4 |\n", + "| ('librispeech_glow_asr', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_4x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_4x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/default_250/dev-other/sclite/wer') | 52.4 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_ctc_scale_0.1/search/dev-other/sclite/wer') | 74.9 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_ctc_scale_0.1/tuning/lm_4.0/search/dev-other/sclite/wer') | 66.3 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_ctc_scale_0.1/tuning/lm_3.5/search/dev-other/sclite/wer') | 61.9 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_ctc_scale_0.1/tuning/lm_2.5/search/dev-other/sclite/wer') | 54.4 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_ctc_scale_0.1/tuning/lm_3.0/search/dev-other/sclite/wer') | 57.9 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_ctc_scale_0.1/tuning/lm_2.0/search/dev-other/sclite/wer') | 52.4 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_ctc_scale_0.1/tuning/lm_4.5/search/dev-other/sclite/wer') | 70.6 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/tuning/lm_2.0/search/dev-other/sclite/wer') | 24.7 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/tuning/lm_2.5_ps_0.5/search/dev-other/sclite/wer') | 23.7 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/tuning/lm_3.0/search/dev-other/sclite/wer') | 24.2 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/tuning/lm_2.0_ps_0.3/search/dev-other/sclite/wer') | 24.5 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/tuning/lm_4.5/search/dev-other/sclite/wer') | 28.2 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/tuning/lm_4.0_ps_0.3/search/dev-other/sclite/wer') | 24.8 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/tuning/lm_4.5_ps_0.5/search/dev-other/sclite/wer') | 25.7 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/tuning/lm_3.0_ps_0.3/search/dev-other/sclite/wer') | 23.5 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/tuning/lm_3.5_ps_0.5/search/dev-other/sclite/wer') | 23.6 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/tuning/lm_4.0/search/dev-other/sclite/wer') | 26.4 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/tuning/lm_2.5_ps_0.3/search/dev-other/sclite/wer') | 23.7 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/tuning/lm_2.0_ps_0.5/search/dev-other/sclite/wer') | 24.6 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/tuning/lm_4.0_ps_0.5/search/dev-other/sclite/wer') | 24.4 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/tuning/lm_2.5/search/dev-other/sclite/wer') | 24.1 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/tuning/lm_4.5_ps_0.3/search/dev-other/sclite/wer') | 26.5 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/tuning/lm_3.0_ps_0.5/search/dev-other/sclite/wer') | 23.3 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/tuning/lm_3.5_ps_0.3/search/dev-other/sclite/wer') | 23.9 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/tuning/lm_3.5/search/dev-other/sclite/wer') | 25.1 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/search/dev-other/sclite/wer') | 30.7 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_tts_train_segments/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_tts_train_segments/search/dev-other/sclite/wer') | 30.7 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_tts_train_segments/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_tts_train_segments/tuning/lm_4.5/search/dev-other/sclite/wer') | 28.4 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_tts_train_segments/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_tts_train_segments/tuning/lm_3.0/search/dev-other/sclite/wer') | 24.6 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_tts_train_segments/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_tts_train_segments/tuning/lm_2.0/search/dev-other/sclite/wer') | 25.3 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_tts_train_segments/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_tts_train_segments/tuning/lm_3.5/search/dev-other/sclite/wer') | 25.3 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_tts_train_segments/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_tts_train_segments/tuning/lm_2.5/search/dev-other/sclite/wer') | 24.6 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_tts_train_segments/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_tts_train_segments/tuning/lm_4.0/search/dev-other/sclite/wer') | 26.6 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_tts_train_segments/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_tts_train_segments/tuned/lm_2.5/search/dev-other/sclite/wer') | 24.6 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass/search/dev-other/sclite/wer') | 56.7 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass/tuning/lm_4.5/search/dev-other/sclite/wer') | 52.5 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass/tuning/lm_2.0/search/dev-other/sclite/wer') | 39.7 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass/tuning/lm_3.0/search/dev-other/sclite/wer') | 42.3 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass/tuning/lm_2.5/search/dev-other/sclite/wer') | 40.4 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass/tuning/lm_3.5/search/dev-other/sclite/wer') | 45 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass/tuning/lm_4.0/search/dev-other/sclite/wer') | 48.4 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/tuning/lm_4.0_ps_0.3/search/dev-other/sclite/wer') | 58.2 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/tuning/lm_3.5/search/dev-other/sclite/wer') | 59.2 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/tuning/lm_4.5_ps_0.5/search/dev-other/sclite/wer') | 59.8 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/tuning/lm_3.0_ps_0.3/search/dev-other/sclite/wer') | 50.8 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/tuning/lm_3.5_ps_0.5/search/dev-other/sclite/wer') | 52.3 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/tuning/lm_2.5/search/dev-other/sclite/wer') | 52.2 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/tuning/lm_2.5_ps_0.5/search/dev-other/sclite/wer') | 48.1 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/tuning/lm_2.0_ps_0.3/search/dev-other/sclite/wer') | 48.5 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/tuning/lm_4.0/search/dev-other/sclite/wer') | 63.3 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/tuning/lm_4.0_ps_0.5/search/dev-other/sclite/wer') | 55.9 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/tuning/lm_4.5_ps_0.3/search/dev-other/sclite/wer') | 62.4 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/tuning/lm_3.0_ps_0.5/search/dev-other/sclite/wer') | 49.6 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/tuning/lm_4.5/search/dev-other/sclite/wer') | 67.8 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/tuning/lm_3.5_ps_0.3/search/dev-other/sclite/wer') | 54.3 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/tuning/lm_3.0/search/dev-other/sclite/wer') | 55.3 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/tuning/lm_2.5_ps_0.3/search/dev-other/sclite/wer') | 48.8 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/tuning/lm_2.0_ps_0.5/search/dev-other/sclite/wer') | 48.2 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/tuning/lm_2.0/search/dev-other/sclite/wer') | 50.7 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/search/dev-other/sclite/wer') | 72 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_blstm_x_vector/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_blstm_x_vector/tuning/lm_4.5/search/dev-other/sclite/wer') | 48.1 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_blstm_x_vector/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_blstm_x_vector/tuning/lm_3.0/search/dev-other/sclite/wer') | 48.4 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_blstm_x_vector/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_blstm_x_vector/tuning/lm_2.0/search/dev-other/sclite/wer') | 50.9 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_blstm_x_vector/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_blstm_x_vector/tuning/lm_3.5/search/dev-other/sclite/wer') | 47.8 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_blstm_x_vector/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_blstm_x_vector/tuning/lm_2.5/search/dev-other/sclite/wer') | 49.4 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_blstm_x_vector/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_blstm_x_vector/tuning/lm_4.0/search/dev-other/sclite/wer') | 47.7 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_blstm_x_vector/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_blstm_x_vector/search/dev-other/sclite/wer') | 48.8 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_radam/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_radam/search/dev-other/sclite/wer') | 43.8 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1/search/dev-other/sclite/wer') | 40.1 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1/tuning/lm_4.0/search/dev-other/sclite/wer') | 33.8 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1/tuning/lm_2.5/search/dev-other/sclite/wer') | 29.4 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1/tuning/lm_3.5/search/dev-other/sclite/wer') | 31.6 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1/tuning/lm_2.0/search/dev-other/sclite/wer') | 30 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1/tuning/lm_3.0/search/dev-other/sclite/wer') | 30 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1/tuning/lm_4.5/search/dev-other/sclite/wer') | 36.6 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_control_spec_augment/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_control_spec_augment/search/dev-other/sclite/wer') | 37.9 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/search/dev-other/sclite/wer') | 42.3 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/tuning/lm_2.5/search/dev-other/sclite/wer') | 31.9 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/tuning/lm_2.0_ps_0.5/search/dev-other/sclite/wer') | 31.8 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/tuning/lm_3.5/search/dev-other/sclite/wer') | 33.8 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/tuning/lm_2.5_ps_0.3/search/dev-other/sclite/wer') | 30.8 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/tuning/lm_4.5_ps_0.3/search/dev-other/sclite/wer') | 35.8 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/tuning/lm_4.0/search/dev-other/sclite/wer') | 36.3 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/tuning/lm_4.0_ps_0.5/search/dev-other/sclite/wer') | 32.6 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/tuning/lm_3.5_ps_0.3/search/dev-other/sclite/wer') | 31.9 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/tuning/lm_3.0_ps_0.5/search/dev-other/sclite/wer') | 30.5 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/tuning/lm_4.5/search/dev-other/sclite/wer') | 38.9 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/tuning/lm_2.0_ps_0.3/search/dev-other/sclite/wer') | 31.9 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/tuning/lm_2.5_ps_0.5/search/dev-other/sclite/wer') | 30.6 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/tuning/lm_4.5_ps_0.5/search/dev-other/sclite/wer') | 34.5 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/tuning/lm_4.0_ps_0.3/search/dev-other/sclite/wer') | 33.6 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/tuning/lm_2.0/search/dev-other/sclite/wer') | 32.4 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/tuning/lm_3.5_ps_0.5/search/dev-other/sclite/wer') | 31.1 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/tuning/lm_3.0/search/dev-other/sclite/wer') | 32.4 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/tuning/lm_3.0_ps_0.3/search/dev-other/sclite/wer') | 31 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_3.5_ps_0.5/search/dev-other/sclite/wer') | 23.4 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_3.0_ps_0.3/search/dev-other/sclite/wer') | 23.2 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_4.5_ps_0.5/search/dev-other/sclite/wer') | 25.7 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_3.5_ps_0/search/dev-other/sclite/wer') | 24.9 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_4.0_ps_0.3/search/dev-other/sclite/wer') | 24.8 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_2.0_ps_0.3/search/dev-other/sclite/wer') | 24.3 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_3.0_ps_0/search/dev-other/sclite/wer') | 24.1 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_2.5_ps_0.5/search/dev-other/sclite/wer') | 23.2 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_3.5_ps_0.3/search/dev-other/sclite/wer') | 23.6 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_4.5_ps_0/search/dev-other/sclite/wer') | 28.6 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_2.0_ps_0/search/dev-other/sclite/wer') | 24.4 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_3.0_ps_0.5/search/dev-other/sclite/wer') | 23 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_4.5_ps_0.3/search/dev-other/sclite/wer') | 26.5 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_4.0_ps_0.5/search/dev-other/sclite/wer') | 24.4 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_2.0_ps_0.5/search/dev-other/sclite/wer') | 24.4 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_2.5_ps_0.3/search/dev-other/sclite/wer') | 23.3 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_2.5_ps_0/search/dev-other/sclite/wer') | 23.8 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/tuning/lm_4.0_ps_0/search/dev-other/sclite/wer') | 26.5 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/search/dev-other/sclite/wer') | 31.2 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_control/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_control/search/dev-other/sclite/wer') | 38.5 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/tuning/lm_4.5/search/dev-other/sclite/wer') | 63.8 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/tuning/lm_3.0_ps_0.3/search/dev-other/sclite/wer') | 47.7 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/tuning/lm_3.5_ps_0.5/search/dev-other/sclite/wer') | 48.9 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/tuning/lm_4.0_ps_0.3/search/dev-other/sclite/wer') | 54.2 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/tuning/lm_4.5_ps_0.5/search/dev-other/sclite/wer') | 55.9 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/tuning/lm_2.5_ps_0.5/search/dev-other/sclite/wer') | 45 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/tuning/lm_2.0/search/dev-other/sclite/wer') | 47.7 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/tuning/lm_2.0_ps_0.3/search/dev-other/sclite/wer') | 45.6 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/tuning/lm_3.0/search/dev-other/sclite/wer') | 51.7 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/tuning/lm_3.0_ps_0.5/search/dev-other/sclite/wer') | 46.3 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/tuning/lm_2.5/search/dev-other/sclite/wer') | 49 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/tuning/lm_3.5_ps_0.3/search/dev-other/sclite/wer') | 50.6 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/tuning/lm_4.0_ps_0.5/search/dev-other/sclite/wer') | 52 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/tuning/lm_4.5_ps_0.3/search/dev-other/sclite/wer') | 58.3 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/tuning/lm_3.5/search/dev-other/sclite/wer') | 55.2 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/tuning/lm_4.0/search/dev-other/sclite/wer') | 59.5 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/tuning/lm_2.5_ps_0.3/search/dev-other/sclite/wer') | 45.9 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/tuning/lm_2.0_ps_0.5/search/dev-other/sclite/wer') | 45.2 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/search/dev-other/sclite/wer') | 68.2 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/tuning/lm_4.0_ps_0.5/search/dev-other/sclite/wer') | 27 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/tuning/lm_4.5_ps_0.3/search/dev-other/sclite/wer') | 30.5 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/tuning/lm_4.5/search/dev-other/sclite/wer') | 33.7 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/tuning/lm_3.0_ps_0.5/search/dev-other/sclite/wer') | 24.3 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/tuning/lm_3.5_ps_0.3/search/dev-other/sclite/wer') | 25.9 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/tuning/lm_3.0/search/dev-other/sclite/wer') | 26.4 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/tuning/lm_2.5_ps_0.3/search/dev-other/sclite/wer') | 24.4 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/tuning/lm_2.0/search/dev-other/sclite/wer') | 25.7 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/tuning/lm_2.0_ps_0.5/search/dev-other/sclite/wer') | 25.1 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/tuning/lm_4.0_ps_0.3/search/dev-other/sclite/wer') | 27.9 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/tuning/lm_4.5_ps_0.5/search/dev-other/sclite/wer') | 29.3 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/tuning/lm_3.5/search/dev-other/sclite/wer') | 28 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/tuning/lm_3.0_ps_0.3/search/dev-other/sclite/wer') | 24.8 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/tuning/lm_2.5/search/dev-other/sclite/wer') | 25.6 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/tuning/lm_3.5_ps_0.5/search/dev-other/sclite/wer') | 25.3 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/tuning/lm_4.0/search/dev-other/sclite/wer') | 30.4 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/tuning/lm_2.5_ps_0.5/search/dev-other/sclite/wer') | 24.2 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/tuning/lm_2.0_ps_0.3/search/dev-other/sclite/wer') | 25 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/search/dev-other/sclite/wer') | 37.3 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/search/dev-other/sclite/wer') | 30.5 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/tuning/lm_4.5_ps_0.5/search/dev-other/sclite/wer') | 26 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/tuning/lm_4.0_ps_0.3/search/dev-other/sclite/wer') | 25.2 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/tuning/lm_3.5_ps_0.5/search/dev-other/sclite/wer') | 23.9 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/tuning/lm_4.5/search/dev-other/sclite/wer') | 28.3 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/tuning/lm_3.0_ps_0.3/search/dev-other/sclite/wer') | 23.8 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/tuning/lm_3.0/search/dev-other/sclite/wer') | 24.5 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/tuning/lm_2.0_ps_0.3/search/dev-other/sclite/wer') | 24.6 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/tuning/lm_2.0/search/dev-other/sclite/wer') | 25.1 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/tuning/lm_2.5_ps_0.5/search/dev-other/sclite/wer') | 23.9 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/tuning/lm_4.5_ps_0.3/search/dev-other/sclite/wer') | 26.6 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/tuning/lm_3.5/search/dev-other/sclite/wer') | 25.4 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/tuning/lm_4.0_ps_0.5/search/dev-other/sclite/wer') | 24.7 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/tuning/lm_3.5_ps_0.3/search/dev-other/sclite/wer') | 24.2 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/tuning/lm_2.5/search/dev-other/sclite/wer') | 24.5 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/tuning/lm_3.0_ps_0.5/search/dev-other/sclite/wer') | 23.6 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/tuning/lm_2.0_ps_0.5/search/dev-other/sclite/wer') | 24.7 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/tuning/lm_2.5_ps_0.3/search/dev-other/sclite/wer') | 23.9 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/tuning/lm_4.0/search/dev-other/sclite/wer') | 26.5 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_ctc_scale_0.1/search/dev-other/sclite/wer') | 40.8 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_ctc_scale_0.1/tuning/lm_4.5/search/dev-other/sclite/wer') | 38.4 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_ctc_scale_0.1/tuning/lm_3.0/search/dev-other/sclite/wer') | 34.7 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_ctc_scale_0.1/tuning/lm_2.0/search/dev-other/sclite/wer') | 35.7 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_ctc_scale_0.1/tuning/lm_3.5/search/dev-other/sclite/wer') | 35.2 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_ctc_scale_0.1/tuning/lm_2.5/search/dev-other/sclite/wer') | 34.7 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_ctc_scale_0.1/tuning/lm_4.0/search/dev-other/sclite/wer') | 36.4 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_4.0/search/dev-other/sclite/wer') | 45.1 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_2.0_ps_0.3/search/dev-other/sclite/wer') | 45.4 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_2.5_ps_0.5/search/dev-other/sclite/wer') | 43.9 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_4.5_ps_0.5/search/dev-other/sclite/wer') | 44.1 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_4.0_ps_0.3/search/dev-other/sclite/wer') | 43.8 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_3.5/search/dev-other/sclite/wer') | 44.4 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_2.5/search/dev-other/sclite/wer') | 44.6 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_3.5_ps_0.5/search/dev-other/sclite/wer') | 43 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_3.0_ps_0.3/search/dev-other/sclite/wer') | 43.3 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_3.0/search/dev-other/sclite/wer') | 44.1 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_2.0_ps_0.5/search/dev-other/sclite/wer') | 45.6 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_2.0/search/dev-other/sclite/wer') | 45.7 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_2.5_ps_0.3/search/dev-other/sclite/wer') | 44 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_4.5_ps_0.3/search/dev-other/sclite/wer') | 44.9 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_4.0_ps_0.5/search/dev-other/sclite/wer') | 43.4 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_4.5/search/dev-other/sclite/wer') | 46.5 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_3.5_ps_0.3/search/dev-other/sclite/wer') | 43.4 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_3.0_ps_0.5/search/dev-other/sclite/wer') | 43.2 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/search/dev-other/sclite/wer') | 48.1 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_blstm_x_vector_specaug/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_blstm_x_vector_specaug/search/dev-other/sclite/wer') | 44 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_trainXvector/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_trainXvector/search/dev-other/sclite/wer') | 47 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_no_jit/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_no_jit/search/dev-other/sclite/wer') | 30.4 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_no_jit/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_no_jit/tuning/lm_3.0/search/dev-other/sclite/wer') | 24.1 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_no_jit/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_no_jit/tuning/lm_2.0/search/dev-other/sclite/wer') | 24.4 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_no_jit/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_no_jit/tuning/lm_2.5/search/dev-other/sclite/wer') | 23.8 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_no_jit/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_no_jit/tuning/lm_1.5/search/dev-other/sclite/wer') | 26 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector/tuning/lm_3.0/search/dev-other/sclite/wer') | 35.7 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector/tuning/lm_2.0/search/dev-other/sclite/wer') | 36.1 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector/tuning/lm_4.5/search/dev-other/sclite/wer') | 41.6 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector/tuning/lm_4.0/search/dev-other/sclite/wer') | 39.1 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector/tuning/lm_3.5/search/dev-other/sclite/wer') | 37.1 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector/tuning/lm_2.5/search/dev-other/sclite/wer') | 35.3 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector/search/dev-other/sclite/wer') | 44.9 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/search/dev-other/sclite/wer') | 35.1 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/tuning/lm_2.5_ps_0.3/search/dev-other/sclite/wer') | 23.1 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/tuning/lm_2.0_ps_0.5/search/dev-other/sclite/wer') | 23.8 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/tuning/lm_4.5_ps_0/search/dev-other/sclite/wer') | 31.2 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/tuning/lm_2.0_ps_0/search/dev-other/sclite/wer') | 24.4 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/tuning/lm_3.0_ps_0.5/search/dev-other/sclite/wer') | 22.9 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/tuning/lm_2.5_ps_0/search/dev-other/sclite/wer') | 24 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/tuning/lm_3.5_ps_0.3/search/dev-other/sclite/wer') | 24.4 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/tuning/lm_4.0_ps_0/search/dev-other/sclite/wer') | 28.3 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/tuning/lm_4.0_ps_0.5/search/dev-other/sclite/wer') | 25.1 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/tuning/lm_4.5_ps_0.3/search/dev-other/sclite/wer') | 28.4 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/tuning/lm_2.5_ps_0.5/search/dev-other/sclite/wer') | 22.9 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/tuning/lm_3.5_ps_0/search/dev-other/sclite/wer') | 26.2 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/tuning/lm_2.0_ps_0.3/search/dev-other/sclite/wer') | 23.7 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/tuning/lm_3.0_ps_0.3/search/dev-other/sclite/wer') | 23.3 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/tuning/lm_3.5_ps_0.5/search/dev-other/sclite/wer') | 23.8 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/tuning/lm_3.0_ps_0/search/dev-other/sclite/wer') | 24.7 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/tuning/lm_4.0_ps_0.3/search/dev-other/sclite/wer') | 26 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/tuning/lm_4.5_ps_0.5/search/dev-other/sclite/wer') | 27.3 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/tuning/lm_2.0_ps_0.3/search/dev-other/sclite/wer') | 36.9 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/tuning/lm_2.5_ps_0.5/search/dev-other/sclite/wer') | 35.5 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/tuning/lm_4.0/search/dev-other/sclite/wer') | 37.8 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/tuning/lm_3.5_ps_0.5/search/dev-other/sclite/wer') | 34.9 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/tuning/lm_3.5/search/dev-other/sclite/wer') | 36.6 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/tuning/lm_3.0_ps_0.3/search/dev-other/sclite/wer') | 35.2 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/tuning/lm_4.5_ps_0.5/search/dev-other/sclite/wer') | 37.1 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/tuning/lm_4.0_ps_0.3/search/dev-other/sclite/wer') | 36.3 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/tuning/lm_2.5/search/dev-other/sclite/wer') | 36.4 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/tuning/lm_3.0/search/dev-other/sclite/wer') | 36.1 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/tuning/lm_2.0_ps_0.5/search/dev-other/sclite/wer') | 37 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/tuning/lm_2.5_ps_0.3/search/dev-other/sclite/wer') | 35.7 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/tuning/lm_2.0/search/dev-other/sclite/wer') | 37.4 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/tuning/lm_3.5_ps_0.3/search/dev-other/sclite/wer') | 35.4 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/tuning/lm_3.0_ps_0.5/search/dev-other/sclite/wer') | 34.8 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/tuning/lm_4.5_ps_0.3/search/dev-other/sclite/wer') | 37.8 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/tuning/lm_4.5/search/dev-other/sclite/wer') | 39.8 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/tuning/lm_4.0_ps_0.5/search/dev-other/sclite/wer') | 35.7 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/search/dev-other/sclite/wer') | 42.3 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector/search/dev-other/sclite/wer') | 44.2 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector/tuning/lm_2.5/search/dev-other/sclite/wer') | 38.6 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector/tuning/lm_3.5/search/dev-other/sclite/wer') | 39 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector/tuning/lm_4.0/search/dev-other/sclite/wer') | 40.1 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector/tuning/lm_4.5/search/dev-other/sclite/wer') | 41.8 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector/tuning/lm_2.0/search/dev-other/sclite/wer') | 39.7 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector/tuning/lm_3.0/search/dev-other/sclite/wer') | 38.4 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvector/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvector/search/dev-other/sclite/wer') | 43.5 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/tuning/lm_2.0/search/dev-other/sclite/wer') | 44.1 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/tuning/lm_2.0_ps_0.5/search/dev-other/sclite/wer') | 44.2 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/tuning/lm_2.5_ps_0.3/search/dev-other/sclite/wer') | 42.5 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/tuning/lm_3.0/search/dev-other/sclite/wer') | 42.6 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/tuning/lm_4.5_ps_0.3/search/dev-other/sclite/wer') | 44.3 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/tuning/lm_4.5/search/dev-other/sclite/wer') | 46.1 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/tuning/lm_4.0_ps_0.5/search/dev-other/sclite/wer') | 42.3 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/tuning/lm_3.5_ps_0.3/search/dev-other/sclite/wer') | 41.9 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/tuning/lm_3.0_ps_0.5/search/dev-other/sclite/wer') | 41.8 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/tuning/lm_4.0/search/dev-other/sclite/wer') | 44.3 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/tuning/lm_2.0_ps_0.3/search/dev-other/sclite/wer') | 44 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/tuning/lm_2.5_ps_0.5/search/dev-other/sclite/wer') | 42.6 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/tuning/lm_4.5_ps_0.5/search/dev-other/sclite/wer') | 43.4 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/tuning/lm_2.5/search/dev-other/sclite/wer') | 42.9 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/tuning/lm_4.0_ps_0.3/search/dev-other/sclite/wer') | 42.8 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/tuning/lm_3.5_ps_0.5/search/dev-other/sclite/wer') | 41.6 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/tuning/lm_3.5/search/dev-other/sclite/wer') | 43.1 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/tuning/lm_3.0_ps_0.3/search/dev-other/sclite/wer') | 41.7 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/search/dev-other/sclite/wer') | 48.4 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment_tts_train_segments/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment_tts_train_segments/search/dev-other/sclite/wer') | 37.3 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment_tts_train_segments/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment_tts_train_segments/tuning/lm_4.0/search/dev-other/sclite/wer') | 30.5 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment_tts_train_segments/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment_tts_train_segments/tuning/lm_3.5/search/dev-other/sclite/wer') | 27.9 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment_tts_train_segments/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment_tts_train_segments/tuning/lm_2.5/search/dev-other/sclite/wer') | 25.4 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment_tts_train_segments/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment_tts_train_segments/tuning/lm_3.0/search/dev-other/sclite/wer') | 26.3 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment_tts_train_segments/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment_tts_train_segments/tuning/lm_2.0/search/dev-other/sclite/wer') | 25.8 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment_tts_train_segments/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment_tts_train_segments/tuning/lm_4.5/search/dev-other/sclite/wer') | 33.5 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/search/dev-other/sclite/wer') | 43.2 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/tuning/lm_2.5/search/dev-other/sclite/wer') | 32.4 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/tuning/lm_2.0_ps_0.5/search/dev-other/sclite/wer') | 32.6 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/tuning/lm_2.5_ps_0.3/search/dev-other/sclite/wer') | 31.7 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/tuning/lm_3.5/search/dev-other/sclite/wer') | 34.7 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/tuning/lm_4.0/search/dev-other/sclite/wer') | 37.1 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/tuning/lm_4.5_ps_0.3/search/dev-other/sclite/wer') | 37.1 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/tuning/lm_4.0_ps_0.5/search/dev-other/sclite/wer') | 33.9 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/tuning/lm_3.5_ps_0.3/search/dev-other/sclite/wer') | 32.9 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/tuning/lm_3.0_ps_0.5/search/dev-other/sclite/wer') | 31.6 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/tuning/lm_4.5/search/dev-other/sclite/wer') | 39.9 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/tuning/lm_2.0_ps_0.3/search/dev-other/sclite/wer') | 32.4 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/tuning/lm_2.5_ps_0.5/search/dev-other/sclite/wer') | 31.6 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/tuning/lm_2.0/search/dev-other/sclite/wer') | 32.8 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/tuning/lm_4.5_ps_0.5/search/dev-other/sclite/wer') | 36.1 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/tuning/lm_4.0_ps_0.3/search/dev-other/sclite/wer') | 34.9 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/tuning/lm_3.5_ps_0.5/search/dev-other/sclite/wer') | 32.2 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/tuning/lm_3.0_ps_0.3/search/dev-other/sclite/wer') | 31.9 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/tuning/lm_3.0/search/dev-other/sclite/wer') | 33 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v3/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v3/tuning/lm_4.0/search/dev-other/sclite/wer') | 26.8 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v3/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v3/tuning/lm_2.5/search/dev-other/sclite/wer') | 24.6 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v3/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v3/tuning/lm_3.5/search/dev-other/sclite/wer') | 25.4 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v3/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v3/tuning/lm_2.0/search/dev-other/sclite/wer') | 25.4 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v3/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v3/tuning/lm_3.0/search/dev-other/sclite/wer') | 24.7 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v3/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v3/tuning/lm_4.5/search/dev-other/sclite/wer') | 28.7 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v3/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v3/search/dev-other/sclite/wer') | 31 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_ddi_actnorm/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_ddi_actnorm/search/dev-other/sclite/wer') | 94.4 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_control_radam/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_control_radam/search/dev-other/sclite/wer') | 38.3 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ddi_actnorm/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ddi_actnorm/search/dev-other/sclite/wer') | 66.7 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1_tts_segments/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1_tts_segments/search/dev-other/sclite/wer') | 39.9 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1_tts_segments/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1_tts_segments/tuning/lm_4.5/search/dev-other/sclite/wer') | 36.5 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1_tts_segments/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1_tts_segments/tuning/lm_3.0/search/dev-other/sclite/wer') | 30.3 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1_tts_segments/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1_tts_segments/tuning/lm_2.0/search/dev-other/sclite/wer') | 30 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1_tts_segments/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1_tts_segments/tuning/lm_3.5/search/dev-other/sclite/wer') | 31.5 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1_tts_segments/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1_tts_segments/tuning/lm_2.5/search/dev-other/sclite/wer') | 29.6 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1_tts_segments/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1_tts_segments/tuning/lm_4.0/search/dev-other/sclite/wer') | 33.6 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvector_eval/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvector_eval/tuning/lm_2.5_ps_0.5/search/dev-other/sclite/wer') | 36.3 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvector_eval/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvector_eval/tuning/lm_4.0/search/dev-other/sclite/wer') | 39.8 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvector_eval/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvector_eval/tuning/lm_2.0_ps_0.3/search/dev-other/sclite/wer') | 37.4 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvector_eval/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvector_eval/tuning/lm_3.5/search/dev-other/sclite/wer') | 38.3 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvector_eval/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvector_eval/tuning/lm_4.0_ps_0.3/search/dev-other/sclite/wer') | 37.9 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvector_eval/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvector_eval/tuning/lm_4.5_ps_0.5/search/dev-other/sclite/wer') | 39 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvector_eval/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvector_eval/tuning/lm_3.0_ps_0.3/search/dev-other/sclite/wer') | 36.2 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvector_eval/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvector_eval/tuning/lm_3.5_ps_0.5/search/dev-other/sclite/wer') | 36.5 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvector_eval/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvector_eval/tuning/lm_2.5/search/dev-other/sclite/wer') | 37 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvector_eval/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvector_eval/tuning/lm_3.0/search/dev-other/sclite/wer') | 37.4 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvector_eval/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvector_eval/tuning/lm_2.5_ps_0.3/search/dev-other/sclite/wer') | 36.3 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvector_eval/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvector_eval/tuning/lm_2.0_ps_0.5/search/dev-other/sclite/wer') | 37.6 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvector_eval/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvector_eval/tuning/lm_2.0/search/dev-other/sclite/wer') | 37.7 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvector_eval/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvector_eval/tuning/lm_4.0_ps_0.5/search/dev-other/sclite/wer') | 37.3 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvector_eval/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvector_eval/tuning/lm_4.5_ps_0.3/search/dev-other/sclite/wer') | 39.8 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvector_eval/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvector_eval/tuning/lm_3.0_ps_0.5/search/dev-other/sclite/wer') | 36 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvector_eval/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvector_eval/tuning/lm_3.5_ps_0.3/search/dev-other/sclite/wer') | 36.9 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvector_eval/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvector_eval/tuning/lm_4.5/search/dev-other/sclite/wer') | 42.1 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvector_eval/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvector_eval/search/dev-other/sclite/wer') | 44.7 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer/tuning/lm_3.0/search/dev-other/sclite/wer') | 38.3 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer/tuning/lm_2.0_ps_0.3/search/dev-other/sclite/wer') | 39.8 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer/tuning/lm_2.0/search/dev-other/sclite/wer') | 39.9 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer/tuning/lm_2.5_ps_0.5/search/dev-other/sclite/wer') | 38.7 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer/tuning/lm_4.5_ps_0.5/search/dev-other/sclite/wer') | 38.5 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer/tuning/lm_4.0_ps_0.3/search/dev-other/sclite/wer') | 38.2 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer/tuning/lm_3.5_ps_0.5/search/dev-other/sclite/wer') | 37.7 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer/tuning/lm_4.5/search/dev-other/sclite/wer') | 39.9 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer/tuning/lm_3.0_ps_0.3/search/dev-other/sclite/wer') | 37.9 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer/tuning/lm_4.0/search/dev-other/sclite/wer') | 39 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer/tuning/lm_2.0_ps_0.5/search/dev-other/sclite/wer') | 40.2 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer/tuning/lm_2.5_ps_0.3/search/dev-other/sclite/wer') | 38.7 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer/tuning/lm_4.5_ps_0.3/search/dev-other/sclite/wer') | 38.9 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer/tuning/lm_3.5/search/dev-other/sclite/wer') | 38.4 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer/tuning/lm_4.0_ps_0.5/search/dev-other/sclite/wer') | 38 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer/tuning/lm_3.5_ps_0.3/search/dev-other/sclite/wer') | 37.7 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer/tuning/lm_2.5/search/dev-other/sclite/wer') | 38.7 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer/tuning/lm_3.0_ps_0.5/search/dev-other/sclite/wer') | 37.9 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer/search/dev-other/sclite/wer') | 41.4 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_control/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_control/search/dev-other/sclite/wer') | 46.3 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment/tuning/lm_3.0/search/dev-other/sclite/wer') | 37 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment/tuning/lm_2.0/search/dev-other/sclite/wer') | 37.9 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment/tuning/lm_4.5/search/dev-other/sclite/wer') | 41.9 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment/tuning/lm_4.0/search/dev-other/sclite/wer') | 39.4 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment/tuning/lm_3.5/search/dev-other/sclite/wer') | 37.9 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment/tuning/lm_2.5/search/dev-other/sclite/wer') | 37 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment/search/dev-other/sclite/wer') | 44.7 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_encoder_sample_ctc_scale_0.1/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_encoder_sample_ctc_scale_0.1/search/dev-other/sclite/wer') | 100 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_coupling_epsilon/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_coupling_epsilon/search/dev-other/sclite/wer') | 30.4 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer/tuning/lm_3.5_ps_0.3/search/dev-other/sclite/wer') | 29.1 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer/tuning/lm_3.0_ps_0.5/search/dev-other/sclite/wer') | 28.3 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer/tuning/lm_4.5_ps_0.3/search/dev-other/sclite/wer') | 32.8 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer/tuning/lm_4.0_ps_0.5/search/dev-other/sclite/wer') | 29.9 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer/tuning/lm_3.0_ps_0/search/dev-other/sclite/wer') | 29.7 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer/tuning/lm_3.5_ps_0/search/dev-other/sclite/wer') | 30.8 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer/tuning/lm_2.0_ps_0.5/search/dev-other/sclite/wer') | 29.5 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer/tuning/lm_2.5_ps_0.3/search/dev-other/sclite/wer') | 28.5 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer/tuning/lm_3.5_ps_0.5/search/dev-other/sclite/wer') | 28.7 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer/tuning/lm_4.0_ps_0/search/dev-other/sclite/wer') | 32.9 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer/tuning/lm_3.0_ps_0.3/search/dev-other/sclite/wer') | 28.5 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer/tuning/lm_2.5_ps_0/search/dev-other/sclite/wer') | 29.5 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer/tuning/lm_4.5_ps_0.5/search/dev-other/sclite/wer') | 31.7 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer/tuning/lm_4.0_ps_0.3/search/dev-other/sclite/wer') | 30.6 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer/tuning/lm_2.0_ps_0.3/search/dev-other/sclite/wer') | 29.6 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer/tuning/lm_2.5_ps_0.5/search/dev-other/sclite/wer') | 28.4 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer/tuning/lm_2.0_ps_0/search/dev-other/sclite/wer') | 30.1 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer/tuning/lm_4.5_ps_0/search/dev-other/sclite/wer') | 35.4 |\n", + "| ('joint_training/default', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer/search/dev-other/sclite/wer') | 38.4 |\n", + "| ('joint_training/conformer_coupling', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glow_ASR_conformer/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glow_ASR_conformer/search/dev-other/sclite/wer') | 32.4 |\n", + "| ('joint_training/conformer_coupling', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glow_ASR_conformer/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glow_ASR_conformer/tuning/lm_2.0/search/dev-other/sclite/wer') | 30.6 |\n", + "| ('joint_training/conformer_coupling', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glow_ASR_conformer/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glow_ASR_conformer/tuning/lm_3.0/search/dev-other/sclite/wer') | 29.6 |\n", + "| ('joint_training/conformer_coupling', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glow_ASR_conformer/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glow_ASR_conformer/tuning/lm_2.5/search/dev-other/sclite/wer') | 29.8 |\n", + "| ('joint_training/conformer_coupling', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glow_ASR_conformer/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glow_ASR_conformer/tuning/lm_3.5/search/dev-other/sclite/wer') | 29.6 |\n", + "| ('joint_training/conformer_coupling', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glow_ASR_conformer/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glow_ASR_conformer/tuning/lm_4.0/search/dev-other/sclite/wer') | 30.2 |\n", + "| ('joint_training/conformer_coupling', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glow_ASR_conformer/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glow_ASR_conformer/tuning/lm_1.5/search/dev-other/sclite/wer') | 32 |\n", + "| ('joint_training/conformer_coupling', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer/search/dev-other/sclite/wer') | 32.9 |\n", + "| ('joint_training/conformer_coupling', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer/tuning/lm_2.5/search/dev-other/sclite/wer') | 30.1 |\n", + "| ('joint_training/conformer_coupling', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer/tuning/lm_3.5/search/dev-other/sclite/wer') | 29.9 |\n", + "| ('joint_training/conformer_coupling', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer/tuning/lm_4.0/search/dev-other/sclite/wer') | 30.7 |\n", + "| ('joint_training/conformer_coupling', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer/tuning/lm_1.5/search/dev-other/sclite/wer') | 32.3 |\n", + "| ('joint_training/conformer_coupling', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer/tuning/lm_2.0/search/dev-other/sclite/wer') | 31 |\n", + "| ('joint_training/conformer_coupling', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer/tuning/lm_3.0/search/dev-other/sclite/wer') | 29.8 |\n", + "| ('joint_training/conformer_coupling', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer_specaugment_before/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer_specaugment_before/tuning/lm_2.0/search/dev-other/sclite/wer') | 19.3 |\n", + "| ('joint_training/conformer_coupling', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer_specaugment_before/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer_specaugment_before/tuning/lm_3.0/search/dev-other/sclite/wer') | 18.8 |\n", + "| ('joint_training/conformer_coupling', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer_specaugment_before/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer_specaugment_before/tuning/lm_1.5/search/dev-other/sclite/wer') | 20.2 |\n", + "| ('joint_training/conformer_coupling', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer_specaugment_before/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer_specaugment_before/tuning/lm_4.0/search/dev-other/sclite/wer') | 20.2 |\n", + "| ('joint_training/conformer_coupling', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer_specaugment_before/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer_specaugment_before/tuning/lm_2.5/search/dev-other/sclite/wer') | 18.7 |\n", + "| ('joint_training/conformer_coupling', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer_specaugment_before/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer_specaugment_before/tuning/lm_3.5/search/dev-other/sclite/wer') | 19.3 |\n", + "| ('joint_training/conformer_coupling', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer_specaugment_before/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer_specaugment_before/search/dev-other/sclite/wer') | 23.1 |\n", + "| ('joint_training/conformer_coupling', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_x_vector_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_x_vector_v2/search/dev-other/sclite/wer') | 40.1 |\n", + "| ('joint_training/conformer_coupling', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_x_vector_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_4.0/search/dev-other/sclite/wer') | 35.3 |\n", + "| ('joint_training/conformer_coupling', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_x_vector_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_1.5/search/dev-other/sclite/wer') | 36.2 |\n", + "| ('joint_training/conformer_coupling', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_x_vector_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_2.5/search/dev-other/sclite/wer') | 33.3 |\n", + "| ('joint_training/conformer_coupling', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_x_vector_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_3.5/search/dev-other/sclite/wer') | 33.9 |\n", + "| ('joint_training/conformer_coupling', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_x_vector_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_2.0/search/dev-other/sclite/wer') | 34.2 |\n", + "| ('joint_training/conformer_coupling', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_x_vector_v2/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_x_vector_v2/tuning/lm_3.0/search/dev-other/sclite/wer') | 33.1 |\n", + "| ('joint_training/given_alignments', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step_asr/frozen_glowtts/glowASR_conformer_x_vector/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step_asr/frozen_glowtts/glowASR_conformer_x_vector/tuning/lm_2.5_ps_0.5/search/dev-other/sclite/wer') | 21.2 |\n", + "| ('joint_training/given_alignments', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step_asr/frozen_glowtts/glowASR_conformer_x_vector/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step_asr/frozen_glowtts/glowASR_conformer_x_vector/tuning/lm_3.0/search/dev-other/sclite/wer') | 21.3 |\n", + "| ('joint_training/given_alignments', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step_asr/frozen_glowtts/glowASR_conformer_x_vector/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step_asr/frozen_glowtts/glowASR_conformer_x_vector/tuning/lm_3.5_ps_0.5/search/dev-other/sclite/wer') | 21.1 |\n", + "| ('joint_training/given_alignments', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step_asr/frozen_glowtts/glowASR_conformer_x_vector/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step_asr/frozen_glowtts/glowASR_conformer_x_vector/tuning/lm_2_ps_0.5/search/dev-other/sclite/wer') | 21.7 |\n", + "| ('joint_training/given_alignments', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step_asr/frozen_glowtts/glowASR_conformer_x_vector/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step_asr/frozen_glowtts/glowASR_conformer_x_vector/tuning/lm_4.5/search/dev-other/sclite/wer') | 23.3 |\n", + "| ('joint_training/given_alignments', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step_asr/frozen_glowtts/glowASR_conformer_x_vector/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step_asr/frozen_glowtts/glowASR_conformer_x_vector/tuning/lm_3.0_ps_0.3/search/dev-other/sclite/wer') | 21 |\n", + "| ('joint_training/given_alignments', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step_asr/frozen_glowtts/glowASR_conformer_x_vector/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step_asr/frozen_glowtts/glowASR_conformer_x_vector/tuning/lm_4.5_ps_0.5/search/dev-other/sclite/wer') | 22.2 |\n", + "| ('joint_training/given_alignments', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step_asr/frozen_glowtts/glowASR_conformer_x_vector/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step_asr/frozen_glowtts/glowASR_conformer_x_vector/tuning/lm_4.0_ps_0.3/search/dev-other/sclite/wer') | 21.6 |\n", + "| ('joint_training/given_alignments', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step_asr/frozen_glowtts/glowASR_conformer_x_vector/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step_asr/frozen_glowtts/glowASR_conformer_x_vector/tuning/lm_2/search/dev-other/sclite/wer') | 21.9 |\n", + "| ('joint_training/given_alignments', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step_asr/frozen_glowtts/glowASR_conformer_x_vector/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step_asr/frozen_glowtts/glowASR_conformer_x_vector/tuning/lm_4.0/search/dev-other/sclite/wer') | 22.3 |\n", + "| ('joint_training/given_alignments', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step_asr/frozen_glowtts/glowASR_conformer_x_vector/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step_asr/frozen_glowtts/glowASR_conformer_x_vector/tuning/lm_2.5_ps_0.3/search/dev-other/sclite/wer') | 21.2 |\n", + "| ('joint_training/given_alignments', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step_asr/frozen_glowtts/glowASR_conformer_x_vector/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step_asr/frozen_glowtts/glowASR_conformer_x_vector/tuning/lm_3.5_ps_0.3/search/dev-other/sclite/wer') | 21.2 |\n", + "| ('joint_training/given_alignments', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step_asr/frozen_glowtts/glowASR_conformer_x_vector/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step_asr/frozen_glowtts/glowASR_conformer_x_vector/tuning/lm_3.0_ps_0.5/search/dev-other/sclite/wer') | 21 |\n", + "| ('joint_training/given_alignments', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step_asr/frozen_glowtts/glowASR_conformer_x_vector/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step_asr/frozen_glowtts/glowASR_conformer_x_vector/tuning/lm_2.5/search/dev-other/sclite/wer') | 21.3 |\n", + "| ('joint_training/given_alignments', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step_asr/frozen_glowtts/glowASR_conformer_x_vector/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step_asr/frozen_glowtts/glowASR_conformer_x_vector/tuning/lm_2_ps_0.3/search/dev-other/sclite/wer') | 21.7 |\n", + "| ('joint_training/given_alignments', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step_asr/frozen_glowtts/glowASR_conformer_x_vector/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step_asr/frozen_glowtts/glowASR_conformer_x_vector/tuning/lm_4.5_ps_0.3/search/dev-other/sclite/wer') | 22.4 |\n", + "| ('joint_training/given_alignments', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step_asr/frozen_glowtts/glowASR_conformer_x_vector/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step_asr/frozen_glowtts/glowASR_conformer_x_vector/tuning/lm_3.5/search/dev-other/sclite/wer') | 21.7 |\n", + "| ('joint_training/given_alignments', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step_asr/frozen_glowtts/glowASR_conformer_x_vector/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step_asr/frozen_glowtts/glowASR_conformer_x_vector/tuning/lm_4.0_ps_0.5/search/dev-other/sclite/wer') | 21.6 |\n", + "| ('joint_training/given_alignments', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step_asr/frozen_glowtts/glowASR_conformer_x_vector/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step_asr/frozen_glowtts/glowASR_conformer_x_vector/search/dev-other/sclite/wer') | 24.7 |\n", + "| ('joint_training/given_alignments', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step/ga_glowTTS_ASR_ffn_x_vector_v2_blstm_2ndstep/specaug/ce_ls_1.0/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step/ga_glowTTS_ASR_ffn_x_vector_v2_blstm_2ndstep/specaug/ce_ls_1.0/search/dev-other/sclite/wer') | 79.5 |\n", + "| ('joint_training/given_alignments', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step/ga_glowTTS_ASR_ffn_x_vector_v2_blstm_2ndstep/no_specaug/ce_ls_1.0/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step/ga_glowTTS_ASR_ffn_x_vector_v2_blstm_2ndstep/no_specaug/ce_ls_1.0/search/dev-other/sclite/wer') | 81 |\n", + "| ('joint_training/given_alignments', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step/ga_glowTTS_ASR_ffn_x_vector_v2_blstm_2ndstep_v2/no_specaug/ce_ls_1.0/', '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step/ga_glowTTS_ASR_ffn_x_vector_v2_blstm_2ndstep_v2/no_specaug/ce_ls_1.0/search/dev-other/sclite/wer') | 86.9 |\n" + ] + } + ], + "source": [ + "print(df.to_markdown())" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, "outputs": [], "source": [ "count_series = df.index.get_level_values(\"Experiment\").value_counts()\n", @@ -946,7 +2268,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -955,7 +2277,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -1007,7 +2329,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -1036,7 +2358,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -1076,7 +2398,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -1094,7 +2416,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 12, "metadata": {}, "outputs": [ { @@ -1103,20 +2425,21 @@ "text": [ "| | Group | Experiment | WER (dev-other) | Count | Tuned | CTC | dev CTC | overfitting | dev MLE | dev DP | Joint | Still running | Training data available | Num Epochs | LR | ASR Model Type | Missing glow.eval |\n", "|----:|:--------------------------------|:------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|------------------:|--------:|:--------|------:|----------:|--------------:|:--------------------|:--------------------|:--------|:----------------|:--------------------------|-------------:|:-------------------------------------------------|:-----------------|:--------------------|\n", - "| 9 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ddi_actnorm/ | 66.7 | 1 | False | 0.282 | 0.583 | 2.068 | -0.696242607904203 | 0.4012426779125676 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", - "| 11 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_control/ | 38.5 | 1 | False | 0.216 | 0.735 | 3.408 | -0.7795215357433666 | 1.5493716010541627 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", - "| 12 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_control_radam/ | 38.3 | 1 | False | 0.214 | 0.731 | 3.414 | -0.7803357613809181 | 1.4600530691219098 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", - "| 13 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_control_spec_augment/ | 37.9 | 1 | False | 0.501 | 0.588 | 1.173 | -0.7782901200381193 | 1.4496996285337391 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", - "| 15 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_ddi_actnorm/ | 94.4 | 1 | False | 0.165 | 1.062 | 6.429 | -0.5203935901323954 | 0.21473516580281835 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", - "| 16 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_encoder_sample_ctc_scale_0.1/ | 100 | 1 | False | 3.481 | 6.325 | 1.817 | -0.7816050729968331 | 1.1355000418243986 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", - "| 17 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_radam/ | 43.8 | 1 | False | 0.098 | 1.135 | 11.599 | -0.5829270274350138 | 0.34816459318002063 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", - "| 21 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_trainXvector/ | 47 | 1 | False | 0.046 | 1.485 | 32.45 | -0.5923372669653459 | 0.586278223855929 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", - "| 32 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_coupling_epsilon/ | 30.4 | 1 | False | 0.243 | 0.576 | 2.37 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", - "| 36 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_control/ | 46.3 | 1 | False | 0.233 | 0.916 | 3.927 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", - "| 39 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvector/ | 43.5 | 1 | False | 0.251 | 0.762 | 3.03 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", - "| 45 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step/ga_glowTTS_ASR_ffn_x_vector_v2_blstm_2ndstep/no_specaug/ce_ls_1.0/ | 81 | 1 | False | 0.036 | 2.023 | 55.937 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", - "| 46 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step/ga_glowTTS_ASR_ffn_x_vector_v2_blstm_2ndstep/specaug/ce_ls_1.0/ | 79.5 | 1 | False | 1.182 | 0.749 | 0.634 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", - "| 47 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step/ga_glowTTS_ASR_ffn_x_vector_v2_blstm_2ndstep_v2/no_specaug/ce_ls_1.0/ | 86.9 | 1 | False | 0.006 | 3.047 | 476.04 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 5 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_blstm_x_vector_specaug/ | 44 | 1 | False | 0.027 | 1.443 | 53.493 | -0.6382890479131178 | 0.19790865955027667 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | blstm | False |\n", + "| 8 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ddi_actnorm/ | 66.7 | 1 | False | 0.282 | 0.583 | 2.068 | -0.696242607904203 | 0.4012426779125676 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 10 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_control/ | 38.5 | 1 | False | 0.216 | 0.735 | 3.408 | -0.7795215357433666 | 1.5493716010541627 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 11 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_control_radam/ | 38.3 | 1 | False | 0.214 | 0.731 | 3.414 | -0.7803357613809181 | 1.4600530691219098 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 12 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_control_spec_augment/ | 37.9 | 1 | False | 0.501 | 0.588 | 1.173 | -0.7782901200381193 | 1.4496996285337391 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 14 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_ddi_actnorm/ | 94.4 | 1 | False | 0.165 | 1.062 | 6.429 | -0.5203935901323954 | 0.21473516580281835 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 15 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_encoder_sample_ctc_scale_0.1/ | 100 | 1 | False | 3.481 | 6.325 | 1.817 | -0.7816050729968331 | 1.1355000418243986 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 16 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_radam/ | 43.8 | 1 | False | 0.098 | 1.135 | 11.599 | -0.5829270274350138 | 0.34816459318002063 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 20 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_trainXvector/ | 47 | 1 | False | 0.046 | 1.485 | 32.45 | -0.5923372669653459 | 0.586278223855929 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 31 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_coupling_epsilon/ | 30.4 | 1 | False | 0.243 | 0.576 | 2.37 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 35 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_control/ | 46.3 | 1 | False | 0.233 | 0.916 | 3.927 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 38 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvector/ | 43.5 | 1 | False | 0.251 | 0.762 | 3.03 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 44 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step/ga_glowTTS_ASR_ffn_x_vector_v2_blstm_2ndstep/no_specaug/ce_ls_1.0/ | 81 | 1 | False | 0.036 | 2.023 | 55.937 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 45 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step/ga_glowTTS_ASR_ffn_x_vector_v2_blstm_2ndstep/specaug/ce_ls_1.0/ | 79.5 | 1 | False | 1.182 | 0.749 | 0.634 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 46 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step/ga_glowTTS_ASR_ffn_x_vector_v2_blstm_2ndstep_v2/no_specaug/ce_ls_1.0/ | 86.9 | 1 | False | 0.006 | 3.047 | 476.04 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", "| 48 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x1024_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/ | 66.4 | 1 | False | 0.582 | 1.039 | 1.786 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", "| 49 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/default/ | 55.1 | 1 | False | 0.177 | 1.151 | 6.489 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", "| 50 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/drop_around_blstm/lm5/ | 66.3 | 1 | False | 0.599 | 0.948 | 1.581 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", @@ -1144,19 +2467,21 @@ "| 81 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_simple_encoder_epoch84/silence_preprocessed/ | 57.4 | 1 | False | 0.079 | 1.519 | 19.301 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", "| 82 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_with_small_enc/silence_preprocessed/ | 79.4 | 1 | False | 1.103 | 1.283 | 1.163 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", "| 83 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_4x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/ | 52.4 | 1 | False | 0.378 | 0.812 | 2.15 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", - "| 94 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_v2/ | 26.6 | 1 | False | 0.216 | 0.589 | 2.724 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", - "| 95 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_v3/ | 26.3 | 1 | False | 0.211 | 0.591 | 2.799 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", - "| 108 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.1/ | 25.8 | 1 | False | 0.406 | 0.422 | 1.041 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | True |\n", - "| 109 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.2/ | 25.5 | 1 | False | 0.413 | 0.417 | 1.01 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | True |\n", - "| 110 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/ | 26.2 | 1 | False | 0.44 | 0.415 | 0.943 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | True |\n", - "| 111 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.4/ | 25.2 | 1 | False | 0.416 | 0.413 | 0.993 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | True |\n", - "| 115 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/batch_norm/ | 29.4 | 1 | False | 0.392 | 0.504 | 1.285 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | True |\n", - "| 116 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/layer_norm/ | 28.5 | 1 | False | 0.407 | 0.488 | 1.197 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | True |\n", - "| 118 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment_before/glow_enc192_200ep_not_silence_preprocessed/ | 100 | 1 | False | 3.454 | 5.802 | 1.68 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | True |\n", - "| 119 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/tts_dataset/spec_augment/no_glow/ | 20.9 | 1 | False | 0.091 | 0.419 | 4.591 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", - "| 120 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/linear_1x512_d0.2_b300_fs4/glow_enc768/tts_dataset/ | 99.7 | 1 | False | 2.628 | 2.609 | 0.993 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | unknown | False |\n", - "| 121 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/linear_1x512_d0.2_b300_fs4/glow_nar_taco_encoder_16blocks/ | 98.8 | 1 | False | 2.23 | 2.39 | 1.072 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | unknown | False |\n", - "| 124 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/tts_dataset/ | 59.8 | 1 | False | 0.071 | 1.537 | 21.521 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n" + "| 95 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_v2/ | 26.6 | 1 | False | 0.216 | 0.589 | 2.724 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 96 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_v3/ | 26.3 | 1 | False | 0.211 | 0.591 | 2.799 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 110 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.1/ | 25.8 | 1 | False | 0.406 | 0.422 | 1.041 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | True |\n", + "| 111 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.2/ | 25.5 | 1 | False | 0.413 | 0.417 | 1.01 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | True |\n", + "| 112 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/ | 26.2 | 1 | False | 0.44 | 0.415 | 0.943 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | True |\n", + "| 113 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.4/ | 25.2 | 1 | False | 0.416 | 0.413 | 0.993 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | True |\n", + "| 117 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/batch_norm/ | 29.4 | 1 | False | 0.392 | 0.504 | 1.285 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | True |\n", + "| 118 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/layer_norm/ | 28.5 | 1 | False | 0.407 | 0.488 | 1.197 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | True |\n", + "| 120 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment_before/glow_enc192_200ep_not_silence_preprocessed/ | 100 | 1 | False | 3.454 | 5.802 | 1.68 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | True |\n", + "| 121 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/tts_dataset/spec_augment/no_glow/ | 20.9 | 1 | False | 0.091 | 0.419 | 4.591 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 122 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/linear_1x512_d0.2_b300_fs4/glow_enc768/tts_dataset/ | 99.7 | 1 | False | 2.628 | 2.609 | 0.993 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | unknown | False |\n", + "| 123 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/linear_1x512_d0.2_b300_fs4/glow_nar_taco_encoder_16blocks/ | 98.8 | 1 | False | 2.23 | 2.39 | 1.072 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | unknown | False |\n", + "| 125 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/ | 57 | 1 | False | 0.508 | 0.863 | 1.698 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 126 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/tts_dataset/ | 59.8 | 1 | False | 0.071 | 1.537 | 21.521 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 130 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment_before/glow_not_pretrained/ | 30.5 | 1 | False | 0.245 | 0.58 | 2.37 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n" ] } ], @@ -1166,7 +2491,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -1175,7 +2500,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 14, "metadata": {}, "outputs": [ { @@ -1184,17 +2509,16 @@ "text": [ "| | Group | Experiment | WER (dev-other) | Count | Tuned | CTC | dev CTC | overfitting | dev MLE | dev DP | Joint | Still running | Training data available | Num Epochs | LR | ASR Model Type | Missing glow.eval |\n", "|----:|:---------------------|:----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|------------------:|--------:|:--------|------:|----------:|--------------:|:----------|:---------|:--------|:----------------|:--------------------------|-------------:|:-----------------------------------------------|:-----------------|:--------------------|\n", - "| 52 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/ | 58 | 13 | True | 0.022 | 2.315 | 104.406 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", - "| 54 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/ | 44.6 | 13 | True | 0.326 | 1.042 | 3.202 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | True |\n", - "| 55 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/ | 63.8 | 13 | True | 0.065 | 2.401 | 36.955 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", - "| 56 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/ | 55.4 | 13 | True | 0.882 | 1.139 | 1.292 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", - "| 59 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/ | 63.2 | 13 | True | 0.062 | 2.427 | 39.391 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 52 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/ | 56.6 | 13 | True | 0.022 | 2.315 | 104.406 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 54 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/ | 41.3 | 13 | True | 0.326 | 1.042 | 3.202 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | True |\n", + "| 55 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/ | 62.4 | 13 | True | 0.065 | 2.401 | 36.955 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 56 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/ | 55.4 | 5 | True | 0.882 | 1.139 | 1.292 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 59 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/ | 61.8 | 13 | True | 0.062 | 2.427 | 39.391 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", "| 62 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/ | 34 | 19 | True | 0.058 | 0.913 | 15.782 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", "| 63 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/ | 33.8 | 19 | True | 0.003 | 1.209 | 454.454 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", "| 64 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/ | 31.4 | 19 | True | 0.024 | 0.926 | 39.211 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", "| 65 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/ | 23.9 | 19 | True | 0.187 | 0.566 | 3.019 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", - "| 122 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/ | 49.4 | 13 | True | 0.028 | 1.672 | 58.743 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", - "| 123 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/ | 57 | 13 | True | 0.508 | 0.863 | 1.698 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n" + "| 124 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/ | 47.7 | 13 | True | 0.028 | 1.672 | 58.743 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n" ] } ], @@ -1211,7 +2535,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -1220,21 +2544,21 @@ "text": [ "| | Group | Experiment | WER (dev-other) | Count | Tuned | CTC | dev CTC | overfitting | dev MLE | dev DP | Joint | Still running | Training data available | Num Epochs | LR | ASR Model Type | Missing glow.eval |\n", "|----:|:--------------------------------|:------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|------------------:|--------:|:--------|------:|----------:|--------------:|:----------|:---------|:--------|:----------------|:--------------------------|-------------:|:-----------------------------------------------|:-----------------|:--------------------|\n", - "| 45 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step/ga_glowTTS_ASR_ffn_x_vector_v2_blstm_2ndstep/no_specaug/ce_ls_1.0/ | 81 | 1 | False | 0.036 | 2.023 | 55.937 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", - "| 46 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step/ga_glowTTS_ASR_ffn_x_vector_v2_blstm_2ndstep/specaug/ce_ls_1.0/ | 79.5 | 1 | False | 1.182 | 0.749 | 0.634 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", - "| 47 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step/ga_glowTTS_ASR_ffn_x_vector_v2_blstm_2ndstep_v2/no_specaug/ce_ls_1.0/ | 86.9 | 1 | False | 0.006 | 3.047 | 476.04 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 44 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step/ga_glowTTS_ASR_ffn_x_vector_v2_blstm_2ndstep/no_specaug/ce_ls_1.0/ | 81 | 1 | False | 0.036 | 2.023 | 55.937 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 45 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step/ga_glowTTS_ASR_ffn_x_vector_v2_blstm_2ndstep/specaug/ce_ls_1.0/ | 79.5 | 1 | False | 1.182 | 0.749 | 0.634 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 46 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step/ga_glowTTS_ASR_ffn_x_vector_v2_blstm_2ndstep_v2/no_specaug/ce_ls_1.0/ | 86.9 | 1 | False | 0.006 | 3.047 | 476.04 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", "| 48 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x1024_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/ | 66.4 | 1 | False | 0.582 | 1.039 | 1.786 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", "| 49 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/default/ | 55.1 | 1 | False | 0.177 | 1.151 | 6.489 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", "| 50 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/drop_around_blstm/lm5/ | 66.3 | 1 | False | 0.599 | 0.948 | 1.581 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", "| 51 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/drop_around_blstm/spec_augment/ | 94.2 | 1 | False | 2.438 | 1.396 | 0.573 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", - "| 52 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/ | 58 | 13 | True | 0.022 | 2.315 | 104.406 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 52 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval/not_silence_preprocessed/ | 56.6 | 13 | True | 0.022 | 2.315 | 104.406 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", "| 53 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_eval_spec_aug/not_silence_preprocessed/ | 67.7 | 1 | False | 0.725 | 1.04 | 1.434 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", - "| 54 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/ | 44.6 | 13 | True | 0.326 | 1.042 | 3.202 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | True |\n", - "| 55 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/ | 63.8 | 13 | True | 0.065 | 2.401 | 36.955 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", - "| 56 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/ | 55.4 | 13 | True | 0.882 | 1.139 | 1.292 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 54 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_not_eval/not_silence_preprocessed/ | 41.3 | 13 | True | 0.326 | 1.042 | 3.202 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | True |\n", + "| 55 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/glow_eval/not_silence_preprocessed/ | 62.4 | 13 | True | 0.065 | 2.401 | 36.955 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 56 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/ | 55.4 | 5 | True | 0.882 | 1.139 | 1.292 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", "| 57 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/silence_preprocessed/ | 78.1 | 1 | False | 0.779 | 1.163 | 1.493 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", "| 58 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/ | 73.4 | 1 | False | 0.667 | 1.099 | 1.648 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", - "| 59 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/ | 63.2 | 13 | True | 0.062 | 2.427 | 39.391 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 59 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/glow_eval/ | 61.8 | 13 | True | 0.062 | 2.427 | 39.391 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", "| 60 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/silence_preprocessing/ | 76.2 | 1 | False | 0.71 | 1.15 | 1.62 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", "| 61 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_simple_encoder/silence_preprocessed/ | 50.3 | 1 | False | 0.046 | 1.527 | 33.333 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", "| 62 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/ | 34 | 19 | True | 0.058 | 0.913 | 15.782 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", @@ -1259,9 +2583,9 @@ "| 81 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_simple_encoder_epoch84/silence_preprocessed/ | 57.4 | 1 | False | 0.079 | 1.519 | 19.301 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", "| 82 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/tts_dataset/glow_with_small_enc/silence_preprocessed/ | 79.4 | 1 | False | 1.103 | 1.283 | 1.163 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", "| 83 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_4x512_d0.2_b300_fs4/asr_dataset/glow_enc768/not_silence_preprocessed/ | 52.4 | 1 | False | 0.378 | 0.812 | 2.15 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", - "| 122 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/ | 49.4 | 13 | True | 0.028 | 1.672 | 58.743 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", - "| 123 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/ | 57 | 13 | True | 0.508 | 0.863 | 1.698 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", - "| 124 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/tts_dataset/ | 59.8 | 1 | False | 0.071 | 1.537 | 21.521 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n" + "| 124 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/ | 47.7 | 13 | True | 0.028 | 1.672 | 58.743 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 125 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/ | 57 | 1 | False | 0.508 | 0.863 | 1.698 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 126 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/tts_dataset/ | 59.8 | 1 | False | 0.071 | 1.537 | 21.521 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n" ] } ], @@ -1282,7 +2606,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 16, "metadata": {}, "outputs": [ { @@ -1291,60 +2615,67 @@ "text": [ "| | Group | Experiment | WER (dev-other) | Count | Tuned | CTC | dev CTC | overfitting | dev MLE | dev DP | Joint | Still running | Training data available | Num Epochs | LR | ASR Model Type | Missing glow.eval |\n", "|----:|:----------------------------------|:-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|------------------:|--------:|:--------|:------|:----------|:--------------|:----------|:---------|:--------|:----------------|:--------------------------|:-------------|:-------------------------------------------------|:-----------------|:--------------------|\n", - "| 2 | joint_training/conformer_coupling | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glow_ASR_conformer/ | 29.6 | 7 | True | 0.024 | 0.863 | 36.326 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", - "| 5 | joint_training/conformer_coupling | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer/ | 29.8 | 7 | True | 0.023 | 0.866 | 37.161 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", - "| 6 | joint_training/conformer_coupling | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer_specaugment_before/ | 18.7 | 7 | True | 0.133 | 0.444 | 3.33 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", - "| 30 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer/ | 38.3 | 7 | True | 0.037 | 1.206 | 32.173 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", - "| 31 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/ | 24.1 | 7 | True | 0.244 | 0.575 | 2.358 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", - "| 32 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_coupling_epsilon/ | 30.4 | 1 | False | 0.243 | 0.576 | 2.37 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", - "| 33 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_no_jit/ | 23.8 | 5 | True | - | - | - | - | - | False | False | True | - | - | conformer | False |\n", - "| 34 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_tts_train_segments/ | 24.6 | 8 | True | 0.242 | 0.587 | 2.424 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", - "| 35 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector/ | 35.3 | 7 | True | 0.233 | 0.9 | 3.862 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", - "| 36 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_control/ | 46.3 | 1 | False | 0.233 | 0.916 | 3.927 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", - "| 37 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/ | 24.5 | 7 | True | 0.23 | 0.59 | 2.568 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", - "| 38 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v3/ | 24.6 | 7 | True | 0.239 | 0.594 | 2.488 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", - "| 39 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvector/ | 43.5 | 1 | False | 0.251 | 0.762 | 3.03 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", - "| 40 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvector_eval/ | 37 | 7 | True | 0.167 | 0.931 | 5.565 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", - "| 41 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/ | 32.4 | 7 | True | 0.244 | 0.761 | 3.119 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", - "| 42 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer/ | 29.5 | 7 | True | 0.216 | 0.73 | 3.38 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", - "| 43 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/ | 25.6 | 7 | True | 0.491 | 0.587 | 1.196 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", - "| 44 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment_tts_train_segments/ | 25.4 | 7 | True | 0.502 | 0.592 | 1.181 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 0 | joint_training/conformer_coupling | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glow_ASR_conformer/ | 29.6 | 7 | True | 0.024 | 0.863 | 36.326 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 2 | joint_training/conformer_coupling | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer/ | 29.8 | 7 | True | 0.023 | 0.866 | 37.161 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 3 | joint_training/conformer_coupling | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glow_ASR_conformer_specaugment_before/ | 18.7 | 7 | True | 0.133 | 0.444 | 3.33 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 29 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer/ | 37.7 | 19 | True | 0.037 | 1.206 | 32.173 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 30 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before/ | 23.3 | 19 | True | 0.244 | 0.575 | 2.358 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 31 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_coupling_epsilon/ | 30.4 | 1 | False | 0.243 | 0.576 | 2.37 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 32 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_no_jit/ | 23.8 | 5 | True | - | - | - | - | - | False | False | True | - | - | conformer | False |\n", + "| 33 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_tts_train_segments/ | 24.6 | 8 | True | 0.242 | 0.587 | 2.424 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 34 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector/ | 35.3 | 7 | True | 0.233 | 0.9 | 3.862 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 35 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_control/ | 46.3 | 1 | False | 0.233 | 0.916 | 3.927 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 36 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v2/ | 23.6 | 19 | True | 0.23 | 0.59 | 2.568 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 37 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_specaugment_before_xvector_v3/ | 24.6 | 7 | True | 0.239 | 0.594 | 2.488 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 38 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvector/ | 43.5 | 1 | False | 0.251 | 0.762 | 3.03 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 39 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvector_eval/ | 36 | 19 | True | 0.167 | 0.931 | 5.565 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 40 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glow_ASR_conformer_xvectorgrad_clip_10/ | 31.6 | 19 | True | 0.244 | 0.761 | 3.119 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 41 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer/ | 28.3 | 19 | True | 0.216 | 0.73 | 3.38 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 42 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/ | 24.2 | 19 | True | 0.491 | 0.587 | 1.196 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 43 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment_tts_train_segments/ | 25.4 | 7 | True | 0.502 | 0.592 | 1.181 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 47 | joint_training/given_alignments | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/second_step_asr/frozen_glowtts/glowASR_conformer_x_vector/ | 21 | 19 | True | 0.27 | 0.492 | 1.826 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", "| 84 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/ | 28.1 | 19 | True | 0.001 | 1.248 | 2248.206 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", "| 85 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/ | 28.7 | 19 | True | 0.001 | 1.295 | 1861.864 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", - "| 86 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/ | 49.1 | 13 | True | 0.006 | 2.364 | 381.61 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", - "| 87 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/ | 36.1 | 13 | True | 0.002 | 1.65 | 869.021 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 86 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/ | 49.1 | 19 | True | 0.006 | 2.364 | 381.61 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 87 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/ | 36 | 19 | True | 0.002 | 1.65 | 869.021 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", "| 88 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/ | 27.1 | 13 | True | 0.001 | 1.193 | 975.256 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", - "| 89 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/ | 20 | 13 | True | 0.331 | 0.453 | 1.37 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", - "| 90 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/ | 19.7 | 13 | True | 0.335 | 0.448 | 1.338 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", - "| 91 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/ | 18.9 | 13 | True | 0.32 | 0.439 | 1.374 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", - "| 92 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/ | 38 | 13 | True | 0.321 | 0.894 | 2.788 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", - "| 93 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/ | 26.1 | 19 | True | 0.003 | 1.046 | 335.647 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", - "| 94 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_v2/ | 26.6 | 1 | False | 0.216 | 0.589 | 2.724 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", - "| 95 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_v3/ | 26.3 | 1 | False | 0.211 | 0.591 | 2.799 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", - "| 96 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/ | 26.6 | 19 | True | 0.003 | 1.081 | 368.105 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", - "| 97 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/ | 18.3 | 19 | True | 0.08 | 0.548 | 6.834 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", - "| 98 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/ | 23.6 | 13 | True | 0.42 | 0.476 | 1.133 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", - "| 99 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/ | 19.7 | 13 | True | 0.281 | 0.458 | 1.63 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", - "| 100 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/ | 38.2 | 13 | True | 0.285 | 0.975 | 3.417 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", - "| 101 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/ | 25.3 | 13 | True | 0.33 | 0.543 | 1.644 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", - "| 102 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/ | 22 | 13 | True | 0.279 | 0.488 | 1.75 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", - "| 103 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/ | 18 | 15 | True | 0.083 | 0.544 | 6.584 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", - "| 104 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/ | 17.6 | 19 | True | 0.086 | 0.512 | 5.958 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", - "| 105 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/weak_baseline/ | 25.5 | 7 | True | 0.5 | 0.589 | 1.177 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", - "| 106 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/ | 25.5 | 13 | True | 0.03 | 0.732 | 24.376 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | True |\n", - "| 107 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/ | 21.2 | 13 | True | 0.345 | 0.462 | 1.339 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | True |\n", - "| 108 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.1/ | 25.8 | 1 | False | 0.406 | 0.422 | 1.041 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | True |\n", - "| 109 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.2/ | 25.5 | 1 | False | 0.413 | 0.417 | 1.01 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | True |\n", - "| 110 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/ | 26.2 | 1 | False | 0.44 | 0.415 | 0.943 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | True |\n", - "| 111 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.4/ | 25.2 | 1 | False | 0.416 | 0.413 | 0.993 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | True |\n", - "| 112 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/ | 20 | 13 | True | 0.416 | 0.418 | 1.005 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | True |\n", - "| 113 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/ | 19.4 | 13 | True | 0.364 | 0.417 | 1.144 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | True |\n", - "| 114 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/ | 21.8 | 14 | True | 0.368 | 0.474 | 1.287 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | True |\n", - "| 115 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/batch_norm/ | 29.4 | 1 | False | 0.392 | 0.504 | 1.285 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | True |\n", - "| 116 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/layer_norm/ | 28.5 | 1 | False | 0.407 | 0.488 | 1.197 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | True |\n", - "| 117 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/ | 100 | 13 | True | 3.463 | 5.332 | 1.54 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | True |\n", - "| 118 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment_before/glow_enc192_200ep_not_silence_preprocessed/ | 100 | 1 | False | 3.454 | 5.802 | 1.68 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | True |\n", - "| 119 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/tts_dataset/spec_augment/no_glow/ | 20.9 | 1 | False | 0.091 | 0.419 | 4.591 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n" + "| 89 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/ | 20 | 16 | True | 0.331 | 0.453 | 1.37 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 90 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/ | 19.7 | 16 | True | 0.335 | 0.448 | 1.338 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 91 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0/ | 22.9 | 16 | True | 0.214 | 0.575 | 2.69 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 92 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/ | 18.9 | 16 | True | 0.32 | 0.439 | 1.374 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 93 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/ | 37.5 | 19 | True | 0.321 | 0.894 | 2.788 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 94 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/ | 26.1 | 19 | True | 0.003 | 1.046 | 335.647 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 95 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_v2/ | 26.6 | 1 | False | 0.216 | 0.589 | 2.724 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 96 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_v3/ | 26.3 | 1 | False | 0.211 | 0.591 | 2.799 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 97 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/ | 26.5 | 19 | True | 0.003 | 1.081 | 368.105 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 98 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/ | 18.3 | 19 | True | 0.08 | 0.548 | 6.834 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 99 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector/ | 23.6 | 13 | True | 0.42 | 0.476 | 1.133 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 100 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_100ep_xvector_v2/ | 19.7 | 13 | True | 0.281 | 0.458 | 1.63 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 101 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2/ | 37.5 | 19 | True | 0.285 | 0.975 | 3.417 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 102 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc192_200ep_dec_0.05_v2/ | 24.8 | 19 | True | 0.33 | 0.543 | 1.644 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 103 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_100ep_dec_0.05_v2/ | 21.2 | 19 | True | 0.27 | 0.479 | 1.772 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 104 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/ | 21.4 | 19 | True | 0.279 | 0.488 | 1.75 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 105 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/ | 18 | 15 | True | 0.083 | 0.544 | 6.584 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 106 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/ | 17.6 | 19 | True | 0.086 | 0.512 | 5.958 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 107 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/weak_baseline/ | 25.5 | 7 | True | 0.5 | 0.589 | 1.177 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 108 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed/ | 25.2 | 13 | True | 0.03 | 0.732 | 24.376 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | True |\n", + "| 109 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed/ | 21.2 | 13 | True | 0.345 | 0.462 | 1.339 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | True |\n", + "| 110 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.1/ | 25.8 | 1 | False | 0.406 | 0.422 | 1.041 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | True |\n", + "| 111 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.2/ | 25.5 | 1 | False | 0.413 | 0.417 | 1.01 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | True |\n", + "| 112 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.3/ | 26.2 | 1 | False | 0.44 | 0.415 | 0.943 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | True |\n", + "| 113 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.4/ | 25.2 | 1 | False | 0.416 | 0.413 | 0.993 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | True |\n", + "| 114 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0.5/ | 20 | 13 | True | 0.416 | 0.418 | 1.005 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | True |\n", + "| 115 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_1/ | 19.4 | 13 | True | 0.364 | 0.417 | 1.144 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | True |\n", + "| 116 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/ | 21.8 | 14 | True | 0.368 | 0.474 | 1.287 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | True |\n", + "| 117 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/batch_norm/ | 29.4 | 1 | False | 0.392 | 0.504 | 1.285 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | True |\n", + "| 118 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/layer_norm/ | 28.5 | 1 | False | 0.407 | 0.488 | 1.197 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | True |\n", + "| 119 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc768_200ep_not_silence_preprocessed/ | 100 | 13 | True | 3.463 | 5.332 | 1.54 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | True |\n", + "| 120 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment_before/glow_enc192_200ep_not_silence_preprocessed/ | 100 | 1 | False | 3.454 | 5.802 | 1.68 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | True |\n", + "| 121 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/tts_dataset/spec_augment/no_glow/ | 20.9 | 1 | False | 0.091 | 0.419 | 4.591 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 127 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/ | 37.4 | 19 | True | 0.039 | 1.198 | 30.666 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 128 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/ | 33.8 | 19 | True | 0.917 | 0.753 | 0.821 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 129 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment_before/glow_not_pretrained | 23.3 | 18 | True | - | - | - | - | - | False | False | True | - | - | conformer | False |\n", + "| 130 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment_before/glow_not_pretrained/ | 30.5 | 1 | False | 0.245 | 0.58 | 2.37 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n" ] } ], @@ -1358,26 +2689,29 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "| | Group | Experiment | WER (dev-other) | Count | Tuned | CTC | dev CTC | overfitting | dev MLE | dev DP | Joint | Still running | Training data available | Num Epochs | LR | ASR Model Type | Missing glow.eval |\n", - "|----:|:---------------------|:-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|------------------:|--------:|:--------|------:|----------:|--------------:|:----------|:---------|:--------|:----------------|:--------------------------|-------------:|:-------------------------------------------------|:-----------------|:--------------------|\n", - "| 62 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/ | 34 | 19 | True | 0.058 | 0.913 | 15.782 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", - "| 63 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/ | 33.8 | 19 | True | 0.003 | 1.209 | 454.454 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", - "| 64 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/ | 31.4 | 19 | True | 0.024 | 0.926 | 39.211 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", - "| 65 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/ | 23.9 | 19 | True | 0.187 | 0.566 | 3.019 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", - "| 68 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment_before/glow_enc192_200ep_not_freezed/ | 30.9 | 1 | False | 0.172 | 0.56 | 3.248 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", - "| 84 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/ | 28.1 | 19 | True | 0.001 | 1.248 | 2248.21 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", - "| 85 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/ | 28.7 | 19 | True | 0.001 | 1.295 | 1861.86 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", - "| 93 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/ | 26.1 | 19 | True | 0.003 | 1.046 | 335.647 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", - "| 96 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/ | 26.6 | 19 | True | 0.003 | 1.081 | 368.105 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", - "| 97 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/ | 18.3 | 19 | True | 0.08 | 0.548 | 6.834 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", - "| 104 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/ | 17.6 | 19 | True | 0.086 | 0.512 | 5.958 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n" + "| | Group | Experiment | WER (dev-other) | Count | Tuned | CTC | dev CTC | overfitting | dev MLE | dev DP | Joint | Still running | Training data available | Num Epochs | LR | ASR Model Type | Missing glow.eval |\n", + "|----:|:---------------------|:-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|------------------:|--------:|:--------|:------|:----------|:--------------|:----------|:---------|:--------|:----------------|:--------------------------|:-------------|:-------------------------------------------------|:-----------------|:--------------------|\n", + "| 62 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_freezed/ | 34 | 19 | True | 0.058 | 0.913 | 15.782 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 63 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/no_spec_augment/glow_enc192_200ep_not_pretrained/ | 33.8 | 19 | True | 0.003 | 1.209 | 454.454 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 64 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_freezed/ | 31.4 | 19 | True | 0.024 | 0.926 | 39.211 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 65 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/glow_enc192_200ep_not_pretrained/ | 23.9 | 19 | True | 0.187 | 0.566 | 3.019 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 68 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment_before/glow_enc192_200ep_not_freezed/ | 30.9 | 1 | False | 0.172 | 0.56 | 3.248 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 84 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/ | 28.1 | 19 | True | 0.001 | 1.248 | 2248.206 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 85 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/ | 28.7 | 19 | True | 0.001 | 1.295 | 1861.864 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 94 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed_not_freezed/ | 26.1 | 19 | True | 0.003 | 1.046 | 335.647 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 97 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/ | 26.5 | 19 | True | 0.003 | 1.081 | 368.105 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 98 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/ | 18.3 | 19 | True | 0.08 | 0.548 | 6.834 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 106 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_not_pretrained/ | 17.6 | 19 | True | 0.086 | 0.512 | 5.958 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 127 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/ | 37.4 | 19 | True | 0.039 | 1.198 | 30.666 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 129 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment_before/glow_not_pretrained | 23.3 | 18 | True | - | - | - | - | - | False | False | True | - | - | conformer | False |\n", + "| 130 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/weak_conformer/asr_dataset/spec_augment_before/glow_not_pretrained/ | 30.5 | 1 | False | 0.245 | 0.58 | 2.37 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n" ] } ], @@ -1399,20 +2733,20 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 18, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/var/tmp/ipykernel_2362097/226959626.py:22: SettingWithCopyWarning: \n", + "/u/lukas.rilling/experiments/glow_tts_asr_v2/recipe/i6_experiments/users/rilling/evaluation/ipykernel_2908543/226959626.py:22: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame.\n", "Try using .loc[row_indexer,col_indexer] = value instead\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " df_joint[\"auto MOS\"] = mos\n", - "/var/tmp/ipykernel_2362097/226959626.py:23: SettingWithCopyWarning: \n", + "/u/lukas.rilling/experiments/glow_tts_asr_v2/recipe/i6_experiments/users/rilling/evaluation/ipykernel_2908543/226959626.py:23: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame.\n", "Try using .loc[row_indexer,col_indexer] = value instead\n", "\n", @@ -1450,7 +2784,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 19, "metadata": {}, "outputs": [ { @@ -1459,33 +2793,32 @@ "text": [ "| | Group | Experiment | WER (dev-other) | Count | Tuned | CTC | dev CTC | overfitting | dev MLE | dev DP | Joint | Still running | Training data available | Num Epochs | LR | ASR Model Type | Missing glow.eval | auto MOS | sWER |\n", "|---:|:----------------------------------|:-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|------------------:|--------:|:--------|------:|----------:|--------------:|----------:|---------:|:--------|:----------------|:--------------------------|-------------:|:-------------------------------------------------|:-----------------|:--------------------|-----------:|-------:|\n", - "| 0 | joint_training/conformer_coupling | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_ASR_conformer_two_forward_pass/ | 23.9 | 7 | True | 0.292 | 0.564 | 1.933 | -0.670671 | 2.09134 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | 1.82 | 95.7 |\n", - "| 1 | joint_training/conformer_coupling | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_ASR_conformer_x_vector/ | 34.6 | 7 | True | 0.204 | 0.881 | 4.312 | -0.465325 | 0.229336 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | 2.14 | 5.2 |\n", - "| 3 | joint_training/conformer_coupling | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_two_forward_pass/ | 24 | 7 | True | 0.289 | 0.569 | 1.967 | -0.692025 | 0.412498 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | 2.45 | 20.9 |\n", - "| 4 | joint_training/conformer_coupling | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_x_vector_v2/ | 34.6 | 7 | True | 0.204 | 0.881 | 4.312 | -0.465325 | 0.229336 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | 2.14 | 5.2 |\n", - "| 7 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/ | 23.8 | 7 | True | 0.3 | 0.582 | 1.94 | -0.699266 | 0.370426 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | 2.61 | 14.8 |\n", - "| 8 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/ | 24 | 7 | True | 0.431 | 0.558 | 1.294 | -0.805268 | 0.355401 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | 3.16 | 15.2 |\n", - "| 9 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ddi_actnorm/ | 66.7 | 1 | False | 0.282 | 0.583 | 2.068 | -0.696243 | 0.401243 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | nan | nan |\n", - "| 10 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector/ | 38.4 | 7 | True | 0.103 | 1.099 | 10.685 | -0.548408 | 0.701494 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | 1.58 | 98 |\n", - "| 11 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_control/ | 38.5 | 1 | False | 0.216 | 0.735 | 3.408 | -0.779522 | 1.54937 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | nan | nan |\n", - "| 12 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_control_radam/ | 38.3 | 1 | False | 0.214 | 0.731 | 3.414 | -0.780336 | 1.46005 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | nan | nan |\n", - "| 13 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_control_spec_augment/ | 37.9 | 1 | False | 0.501 | 0.588 | 1.173 | -0.77829 | 1.4497 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | nan | nan |\n", - "| 14 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_ctc_scale_0.1/ | 34.7 | 7 | True | 0.142 | 0.927 | 6.549 | -0.769183 | 0.36247 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | 3.15 | 7.6 |\n", - "| 15 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_ddi_actnorm/ | 94.4 | 1 | False | 0.165 | 1.062 | 6.429 | -0.520394 | 0.214735 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | nan | nan |\n", - "| 16 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_encoder_sample_ctc_scale_0.1/ | 100 | 1 | False | 3.481 | 6.325 | 1.817 | -0.781605 | 1.1355 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | nan | nan |\n", - "| 17 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_radam/ | 43.8 | 1 | False | 0.098 | 1.135 | 11.599 | -0.582927 | 0.348165 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | nan | nan |\n", - "| 18 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment/ | 37 | 7 | True | 0.197 | 0.946 | 4.803 | -0.521236 | 0.225934 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | 2.3 | 5.2 |\n", - "| 19 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1/ | 29.4 | 7 | True | 0.409 | 0.689 | 1.685 | -0.759844 | 0.329289 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | 3.11 | 4.6 |\n", - "| 20 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1_tts_segments/ | 29.6 | 7 | True | 0.409 | 0.696 | 1.703 | -0.75744 | 0.330754 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | nan | nan |\n", - "| 21 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_trainXvector/ | 47 | 1 | False | 0.046 | 1.485 | 32.45 | -0.592337 | 0.586278 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | nan | nan |\n", - "| 22 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass/ | 39.7 | 7 | True | 0.432 | 0.863 | 1.998 | -0.629746 | 0.403638 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | 2.75 | 9.5 |\n", - "| 23 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_ctc_scale_0.1/ | 52.4 | 7 | True | 0.455 | 1.104 | 2.429 | -0.771774 | 0.399888 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | 3.12 | 13.3 |\n", - "| 24 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/ | 47.7 | 7 | True | 0.386 | 1.015 | 2.63 | -0.641523 | 0.379653 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | 2.64 | 9.9 |\n", - "| 25 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/ | 50.7 | 7 | True | 0.441 | 1.084 | 2.461 | -0.778751 | 0.379635 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | 3.18 | 11.2 |\n", - "| 26 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/ | 44.1 | 7 | True | 0.058 | 1.44 | 25.027 | -0.591349 | 0.326762 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | 2.48 | 6.7 |\n", - "| 27 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/ | 36.1 | 7 | True | 0.128 | 1.01 | 7.915 | -0.772961 | 0.346386 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | 3.19 | 7.9 |\n", - "| 28 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/ | 42.6 | 7 | True | 0.136 | 1.228 | 9.014 | -0.535346 | 0.203592 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | 2.32 | 6 |\n", - "| 29 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/ | 31.9 | 7 | True | 0.378 | 0.76 | 2.009 | -0.764738 | 0.306534 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | 3.2 | 4.4 |\n" + "| 1 | joint_training/conformer_coupling | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_x_vector_v2/ | 33.1 | 7 | True | 0.271 | 0.863 | 3.185 | -0.803254 | 0.310085 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | 2.05 | 4.2 |\n", + "| 4 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_blstm_x_vector/ | 47.7 | 7 | True | 0.002 | 2.18 | 1163.98 | -0.692515 | 0.302857 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | blstm | False | 3.11 | 16 |\n", + "| 5 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_blstm_x_vector_specaug/ | 44 | 1 | False | 0.027 | 1.443 | 53.493 | -0.638289 | 0.197909 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | blstm | False | 3.01 | 6.3 |\n", + "| 6 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/ | 23 | 19 | True | 0.3 | 0.582 | 1.94 | -0.699266 | 0.370426 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | 2.61 | 14.8 |\n", + "| 7 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/ | 22.9 | 19 | True | 0.431 | 0.558 | 1.294 | -0.805268 | 0.355401 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | 3.16 | 15.2 |\n", + "| 8 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ddi_actnorm/ | 66.7 | 1 | False | 0.282 | 0.583 | 2.068 | -0.696243 | 0.401243 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | nan | nan |\n", + "| 9 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector/ | 38.4 | 7 | True | 0.103 | 1.099 | 10.685 | -0.548408 | 0.701494 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | 1.58 | 98 |\n", + "| 10 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_control/ | 38.5 | 1 | False | 0.216 | 0.735 | 3.408 | -0.779522 | 1.54937 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | nan | nan |\n", + "| 11 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_control_radam/ | 38.3 | 1 | False | 0.214 | 0.731 | 3.414 | -0.780336 | 1.46005 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | nan | nan |\n", + "| 12 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_control_spec_augment/ | 37.9 | 1 | False | 0.501 | 0.588 | 1.173 | -0.77829 | 1.4497 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | nan | nan |\n", + "| 13 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_ctc_scale_0.1/ | 34.7 | 7 | True | 0.142 | 0.927 | 6.549 | -0.769183 | 0.36247 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | 3.15 | 7.6 |\n", + "| 14 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_ddi_actnorm/ | 94.4 | 1 | False | 0.165 | 1.062 | 6.429 | -0.520394 | 0.214735 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | nan | nan |\n", + "| 15 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_encoder_sample_ctc_scale_0.1/ | 100 | 1 | False | 3.481 | 6.325 | 1.817 | -0.781605 | 1.1355 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | nan | nan |\n", + "| 16 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_radam/ | 43.8 | 1 | False | 0.098 | 1.135 | 11.599 | -0.582927 | 0.348165 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | nan | nan |\n", + "| 17 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment/ | 37 | 7 | True | 0.197 | 0.946 | 4.803 | -0.521236 | 0.225934 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | 2.3 | 5.2 |\n", + "| 18 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1/ | 29.4 | 7 | True | 0.409 | 0.689 | 1.685 | -0.759844 | 0.329289 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | 3.11 | 4.6 |\n", + "| 19 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1_tts_segments/ | 29.6 | 7 | True | 0.409 | 0.696 | 1.703 | -0.75744 | 0.330754 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | nan | nan |\n", + "| 20 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_trainXvector/ | 47 | 1 | False | 0.046 | 1.485 | 32.45 | -0.592337 | 0.586278 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | nan | nan |\n", + "| 21 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass/ | 39.7 | 7 | True | 0.432 | 0.863 | 1.998 | -0.629746 | 0.403638 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | 2.75 | 9.5 |\n", + "| 22 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_ctc_scale_0.1/ | 52.4 | 7 | True | 0.455 | 1.104 | 2.429 | -0.771774 | 0.399888 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | 3.12 | 13.3 |\n", + "| 23 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/ | 45 | 19 | True | 0.386 | 1.015 | 2.63 | -0.641523 | 0.379653 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | 2.64 | 9.9 |\n", + "| 24 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/ | 48.1 | 19 | True | 0.441 | 1.084 | 2.461 | -0.778751 | 0.379635 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | 3.18 | 11.2 |\n", + "| 25 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/ | 43 | 19 | True | 0.058 | 1.44 | 25.027 | -0.591349 | 0.326762 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | 2.48 | 6.7 |\n", + "| 26 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/ | 34.8 | 19 | True | 0.128 | 1.01 | 7.915 | -0.772961 | 0.346386 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | 3.19 | 7.9 |\n", + "| 27 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/ | 41.6 | 19 | True | 0.136 | 1.228 | 9.014 | -0.535346 | 0.203592 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | 2.32 | 6 |\n", + "| 28 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/ | 30.5 | 19 | True | 0.378 | 0.76 | 2.009 | -0.764738 | 0.306534 | True | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False | 3.2 | 4.4 |\n" ] } ], @@ -1502,7 +2835,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 20, "metadata": {}, "outputs": [ { @@ -1511,15 +2844,15 @@ "text": [ "| | Group | Experiment | WER (dev-other) | Count | Tuned | CTC | dev CTC | overfitting | dev MLE | dev DP | Joint | Still running | Training data available | Num Epochs | LR | ASR Model Type | Missing glow.eval |\n", "|----:|:-----------------------|:------------------------------------------------------------------------------------------------------------------------------------------------------------------|------------------:|--------:|:--------|------:|----------:|--------------:|:----------|:---------|:--------|:----------------|:--------------------------|-------------:|:-------------------------------------------------|:-----------------|:--------------------|\n", - "| 42 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer/ | 29.5 | 7 | True | 0.216 | 0.73 | 3.38 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", - "| 43 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/ | 25.6 | 7 | True | 0.491 | 0.587 | 1.196 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", - "| 44 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment_tts_train_segments/ | 25.4 | 7 | True | 0.502 | 0.592 | 1.181 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 41 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer/ | 28.3 | 19 | True | 0.216 | 0.73 | 3.38 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 42 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment/ | 24.2 | 19 | True | 0.491 | 0.587 | 1.196 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 43 | joint_training/default | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/only_conformer_spec_augment_tts_train_segments/ | 25.4 | 7 | True | 0.502 | 0.592 | 1.181 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", "| 88 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/no_spec_augment/no_glow/ | 27.1 | 13 | True | 0.001 | 1.193 | 975.256 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", - "| 103 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/ | 18 | 15 | True | 0.083 | 0.544 | 6.584 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", - "| 119 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/tts_dataset/spec_augment/no_glow/ | 20.9 | 1 | False | 0.091 | 0.419 | 4.591 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", - "| 122 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/ | 49.4 | 13 | True | 0.028 | 1.672 | 58.743 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", - "| 123 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/ | 57 | 13 | True | 0.508 | 0.863 | 1.698 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", - "| 124 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/tts_dataset/ | 59.8 | 1 | False | 0.071 | 1.537 | 21.521 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n" + "| 105 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/ | 18 | 15 | True | 0.083 | 0.544 | 6.584 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 121 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/tts_dataset/spec_augment/no_glow/ | 20.9 | 1 | False | 0.091 | 0.419 | 4.591 | - | - | False | False | True | 250 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | conformer | False |\n", + "| 124 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/ | 47.7 | 13 | True | 0.028 | 1.672 | 58.743 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 125 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/asr_dataset/spec_augment/ | 57 | 1 | False | 0.508 | 0.863 | 1.698 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n", + "| 126 | librispeech_glow_asr | /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/librispeech_glow_asr/pytorch/only_blstm_2x512_d0.2_b300_fs4/tts_dataset/ | 59.8 | 1 | False | 0.071 | 1.537 | 21.521 | - | - | False | False | True | 100 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | blstm | False |\n" ] } ], @@ -1530,7 +2863,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 21, "metadata": {}, "outputs": [], "source": [ @@ -1539,7 +2872,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 22, "metadata": {}, "outputs": [ { @@ -1549,7 +2882,7 @@ "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[21], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mdf_training_avail\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mplot\u001b[49m\u001b[43m(\u001b[49m\u001b[43mkind\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mscatter\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mx\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mWER (dev-other)\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mCTC\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n", + "Cell \u001b[0;32mIn[22], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mdf_training_avail\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mplot\u001b[49m\u001b[43m(\u001b[49m\u001b[43mkind\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mscatter\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mx\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mWER (dev-other)\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mCTC\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n", "File \u001b[0;32m/work/tools22/users/lukas.rilling/sis_env/lib/python3.10/site-packages/pandas/plotting/_core.py:976\u001b[0m, in \u001b[0;36mPlotAccessor.__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 974\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m kind \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_dataframe_kinds:\n\u001b[1;32m 975\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(data, ABCDataFrame):\n\u001b[0;32m--> 976\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mplot_backend\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mplot\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdata\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mx\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43my\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mkind\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mkind\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 977\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 978\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mplot kind \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mkind\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m can only be used for data frames\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n", "File \u001b[0;32m/work/tools22/users/lukas.rilling/sis_env/lib/python3.10/site-packages/pandas/plotting/_matplotlib/__init__.py:71\u001b[0m, in \u001b[0;36mplot\u001b[0;34m(data, kind, **kwargs)\u001b[0m\n\u001b[1;32m 69\u001b[0m kwargs[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124max\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mgetattr\u001b[39m(ax, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mleft_ax\u001b[39m\u001b[38;5;124m\"\u001b[39m, ax)\n\u001b[1;32m 70\u001b[0m plot_obj \u001b[38;5;241m=\u001b[39m PLOT_CLASSES[kind](data, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m---> 71\u001b[0m \u001b[43mplot_obj\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mgenerate\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 72\u001b[0m plot_obj\u001b[38;5;241m.\u001b[39mdraw()\n\u001b[1;32m 73\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m plot_obj\u001b[38;5;241m.\u001b[39mresult\n", "File \u001b[0;32m/work/tools22/users/lukas.rilling/sis_env/lib/python3.10/site-packages/pandas/plotting/_matplotlib/core.py:453\u001b[0m, in \u001b[0;36mMPLPlot.generate\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 451\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compute_plot_data()\n\u001b[1;32m 452\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_setup_subplots()\n\u001b[0;32m--> 453\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_make_plot\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 454\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_add_table()\n\u001b[1;32m 455\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_make_legend()\n", @@ -1651,7 +2984,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.13" + "version": "3.10.12" } }, "nbformat": 4, diff --git a/users/rilling/experiments/librispeech/librispeech_conformer_cb_joint/experiments.py b/users/rilling/experiments/librispeech/librispeech_conformer_cb_joint/experiments.py index 2cda50a90..3504f73c8 100644 --- a/users/rilling/experiments/librispeech/librispeech_conformer_cb_joint/experiments.py +++ b/users/rilling/experiments/librispeech/librispeech_conformer_cb_joint/experiments.py @@ -170,6 +170,7 @@ def tune_lm( asr_test_datasets, num_epochs, search_args, + additional_training_args={}, lm_weights=[1.5, 2.0, 2.5, 3.0, 3.5, 4.0], ): for lm in lm_weights: @@ -179,6 +180,7 @@ def tune_lm( training_datasets, asr_test_datasets, num_epochs, + training_args=additional_training_args, search_args={**search_args, **{"lm_weight": lm}}, tts_forward=False, ) @@ -501,23 +503,23 @@ def tune_lm( experiments[alias] = exp_dict net_module = "glowTTS_ASR_conformer_two_forward_pass" - train_args["network_module"] = net_module - alias = "ddi/" + net_module - exp_dict = run_exp( - alias, - train_args, - training_datasets, - asr_test_datasets, - 250, - forward_args=forward_args, - search_args=default_search_args, - tts_forward=True, - tts_eval_datasets=tts_forward_datasets, - ) + # train_args["network_module"] = net_module + # alias = "ddi/" + net_module + # exp_dict = run_exp( + # alias, + # train_args, + # training_datasets, + # asr_test_datasets, + # 250, + # forward_args=forward_args, + # search_args=default_search_args, + # tts_forward=True, + # tts_eval_datasets=tts_forward_datasets, + # ) - experiments[alias] = exp_dict + # experiments[alias] = exp_dict - tune_lm(alias, train_args, training_datasets, asr_test_datasets, 250, search_args=default_search_args) + # tune_lm(alias, train_args, training_datasets, asr_test_datasets, 250, search_args=default_search_args) train_args_no_ddi["network_module"] = net_module alias = "no_ddi/" + net_module @@ -527,6 +529,7 @@ def tune_lm( training_datasets, asr_test_datasets, 250, + training_args={"ctc_scale": 0.1}, forward_args=forward_args, search_args=default_search_args, tts_forward=True, @@ -535,7 +538,7 @@ def tune_lm( experiments[alias] = exp_dict - tune_lm(alias, train_args_no_ddi, training_datasets, asr_test_datasets, 250, search_args=default_search_args) + tune_lm(alias, train_args_no_ddi, training_datasets, asr_test_datasets, 250, search_args=default_search_args, additional_training_args={"ctc_scale": 0.1}) net_module = "glow_ASR_conformer" train_args["network_module"] = net_module @@ -621,34 +624,35 @@ def tune_lm( net_module = "glowTTS_ASR_conformer_x_vector" train_args_with_x_vector["network_module"] = net_module - alias = "ddi/" + net_module - exp_dict = run_exp( - alias, - train_args_with_x_vector, - training_datasets, - asr_test_datasets, - 250, - forward_args=forward_args, - search_args=default_search_args, - tts_forward=True, - tts_eval_datasets=tts_forward_datasets_xvectors, - ) - tune_lm(alias, train_args_with_x_vector, training_datasets, asr_test_datasets, 250, search_args=default_search_args) + # alias = "ddi/" + net_module + # exp_dict = run_exp( + # alias, + # train_args_with_x_vector, + # training_datasets, + # asr_test_datasets, + # 250, + # forward_args=forward_args, + # search_args=default_search_args, + # tts_forward=True, + # tts_eval_datasets=tts_forward_datasets_xvectors, + # ) + # tune_lm(alias, train_args_with_x_vector, training_datasets, asr_test_datasets, 250, search_args=default_search_args) net_module = "glowTTS_ASR_conformer_x_vector_v2" train_args_with_x_vector_no_ddi["network_module"] = net_module alias = "no_ddi/" + net_module exp_dict = run_exp( alias, - train_args_with_x_vector, + train_args_with_x_vector_no_ddi, training_datasets, asr_test_datasets, 250, + training_args={"ctc_scale": 0.1}, forward_args=forward_args, search_args=default_search_args, tts_forward=True, tts_eval_datasets=tts_forward_datasets_xvectors, ) - tune_lm(alias, train_args_with_x_vector, training_datasets, asr_test_datasets, 250, search_args=default_search_args) + tune_lm(alias, train_args_with_x_vector_no_ddi, training_datasets, asr_test_datasets, 250, search_args=default_search_args, additional_training_args={"ctc_scale": 0.1}) return experiments diff --git a/users/rilling/experiments/librispeech/librispeech_conformer_cb_joint/pytorch_networks/glowTTS_ASR_conformer_two_forward_pass.py b/users/rilling/experiments/librispeech/librispeech_conformer_cb_joint/pytorch_networks/glowTTS_ASR_conformer_two_forward_pass.py index d1559f461..45d76f495 100644 --- a/users/rilling/experiments/librispeech/librispeech_conformer_cb_joint/pytorch_networks/glowTTS_ASR_conformer_two_forward_pass.py +++ b/users/rilling/experiments/librispeech/librispeech_conformer_cb_joint/pytorch_networks/glowTTS_ASR_conformer_two_forward_pass.py @@ -40,7 +40,6 @@ SpecaugConfig, VGG4LayerActFrontendV1Config_mod, ModelConfig, - FlowDecoderConfig, ConformerCouplingFlowDecoderConfig, TextEncoderConfig, ) @@ -99,24 +98,22 @@ def forward(self, x, x_mask): class FlowDecoder(nn.Module): - def __init__(self, cfg: ConformerCouplingFlowDecoderConfig, in_channels, gin_channels): + def __init__( + self, + cfg: ConformerCouplingFlowDecoderConfig, + in_channels, + gin_channels=0, + ): """Flow-based decoder model Args: + cfg (FlowDecoderConfig): Decoder specific parameters wrapped in FlowDecoderConfig in_channels (int): Number of incoming channels - hidden_channels (int): Number of hidden channels - kernel_size (int): Kernel Size for convolutions in coupling blocks - dilation_rate (float): Dilation Rate to define dilation in convolutions of coupling block - n_blocks (int): Number of coupling blocks - n_layers (int): Number of layers in CNN of the coupling blocks - p_dropout (float, optional): Dropout probability for CNN in coupling blocks. Defaults to 0.. - n_split (int, optional): Number of splits for the 1x1 convolution for flows in the decoder. Defaults to 4. - n_sqz (int, optional): Squeeze. Defaults to 1. - sigmoid_scale (bool, optional): Boolean to define if log probs in coupling layers should be rescaled using sigmoid. Defaults to False. - gin_channels (int, optional): Number of speaker embedding channels. Defaults to 0. """ super().__init__() + self.cfg = cfg + self.in_channels = in_channels self.flows = nn.ModuleList() @@ -124,12 +121,13 @@ def __init__(self, cfg: ConformerCouplingFlowDecoderConfig, in_channels, gin_cha self.flows.append(modules.ActNorm(channels=in_channels * self.cfg.n_sqz, ddi=self.cfg.ddi)) self.flows.append(modules.InvConvNear(channels=in_channels * self.cfg.n_sqz, n_split=self.cfg.n_split)) self.flows.append( - attentions.CouplingBlock( + attentions.ConformerCouplingBlock( in_channels * self.cfg.n_sqz, self.cfg.hidden_channels, kernel_size=self.cfg.kernel_size, dilation_rate=self.cfg.dilation_rate, n_layers=self.cfg.n_layers, + n_heads=self.cfg.n_heads, gin_channels=gin_channels, p_dropout=self.cfg.p_dropout, sigmoid_scale=self.cfg.sigmoid_scale, @@ -146,6 +144,7 @@ def forward(self, x, x_mask, g=None, reverse=False): if self.cfg.n_sqz > 1: x, x_mask = commons.channel_squeeze(x, x_mask, self.cfg.n_sqz) + for f in flows: if not reverse: x, logdet = f(x, x_mask, g=g, reverse=reverse) diff --git a/users/rilling/experiments/librispeech/librispeech_conformer_cb_joint/pytorch_networks/glowTTS_ASR_conformer_x_vector_v2.py b/users/rilling/experiments/librispeech/librispeech_conformer_cb_joint/pytorch_networks/glowTTS_ASR_conformer_x_vector_v2.py index 037f63ded..8c6850152 100644 --- a/users/rilling/experiments/librispeech/librispeech_conformer_cb_joint/pytorch_networks/glowTTS_ASR_conformer_x_vector_v2.py +++ b/users/rilling/experiments/librispeech/librispeech_conformer_cb_joint/pytorch_networks/glowTTS_ASR_conformer_x_vector_v2.py @@ -40,8 +40,8 @@ SpecaugConfig, VGG4LayerActFrontendV1Config_mod, ModelConfig, - FlowDecoderConfig, TextEncoderConfig, + ConformerCouplingFlowDecoderConfig ) from .shared.configs import DbMelFeatureExtractionConfig @@ -148,24 +148,22 @@ def forward(self, x, x_mask): class FlowDecoder(nn.Module): - def __init__(self, cfg: FlowDecoderConfig, in_channels, gin_channels): + def __init__( + self, + cfg: ConformerCouplingFlowDecoderConfig, + in_channels, + gin_channels=0, + ): """Flow-based decoder model Args: + cfg (FlowDecoderConfig): Decoder specific parameters wrapped in FlowDecoderConfig in_channels (int): Number of incoming channels - hidden_channels (int): Number of hidden channels - kernel_size (int): Kernel Size for convolutions in coupling blocks - dilation_rate (float): Dilation Rate to define dilation in convolutions of coupling block - n_blocks (int): Number of coupling blocks - n_layers (int): Number of layers in CNN of the coupling blocks - p_dropout (float, optional): Dropout probability for CNN in coupling blocks. Defaults to 0.. - n_split (int, optional): Number of splits for the 1x1 convolution for flows in the decoder. Defaults to 4. - n_sqz (int, optional): Squeeze. Defaults to 1. - sigmoid_scale (bool, optional): Boolean to define if log probs in coupling layers should be rescaled using sigmoid. Defaults to False. - gin_channels (int, optional): Number of speaker embedding channels. Defaults to 0. """ super().__init__() + self.cfg = cfg + self.in_channels = in_channels self.flows = nn.ModuleList() @@ -173,12 +171,13 @@ def __init__(self, cfg: FlowDecoderConfig, in_channels, gin_channels): self.flows.append(modules.ActNorm(channels=in_channels * self.cfg.n_sqz, ddi=self.cfg.ddi)) self.flows.append(modules.InvConvNear(channels=in_channels * self.cfg.n_sqz, n_split=self.cfg.n_split)) self.flows.append( - attentions.CouplingBlock( + attentions.ConformerCouplingBlock( in_channels * self.cfg.n_sqz, self.cfg.hidden_channels, kernel_size=self.cfg.kernel_size, dilation_rate=self.cfg.dilation_rate, n_layers=self.cfg.n_layers, + n_heads=self.cfg.n_heads, gin_channels=gin_channels, p_dropout=self.cfg.p_dropout, sigmoid_scale=self.cfg.sigmoid_scale, @@ -198,6 +197,7 @@ def forward(self, x, x_mask, g=None, reverse=False): if self.cfg.n_sqz > 1: x, x_mask = commons.channel_squeeze(x, x_mask, self.cfg.n_sqz) + for f in flows: if not reverse: x, logdet = f(x, x_mask, g=g, reverse=reverse) diff --git a/users/rilling/experiments/librispeech/librispeech_conformer_cb_joint/training_comparison.ipynb b/users/rilling/experiments/librispeech/librispeech_conformer_cb_joint/training_comparison.ipynb index a3dd2e9b2..dd25ac8a0 100644 --- a/users/rilling/experiments/librispeech/librispeech_conformer_cb_joint/training_comparison.ipynb +++ b/users/rilling/experiments/librispeech/librispeech_conformer_cb_joint/training_comparison.ipynb @@ -23,21 +23,17 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{'/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS/training': '/glowTTS/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_x_vector/training': '/glowTTS_x_vector/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_ASR_conformer_x_vector/training': '/glowTTS_ASR_conformer_x_vector/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_ASR_conformer_two_forward_pass/training': '/glowTTS_ASR_conformer_two_forward_pass/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_100ep_pe1/training': '/glowTTS_100ep_pe1/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_100ep_pe1_radam1e-9/training': '/glowTTS_100ep_pe1_radam1e-9/'}" + "{'/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_two_forward_pass/training': '/glowTTS_ASR_conformer_two_forward_pass/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_x_vector_v2/training': '/glowTTS_ASR_conformer_x_vector_v2/'}" ] }, - "execution_count": 3, + "execution_count": 2, "metadata": {}, "output_type": "execute_result" } @@ -55,8 +51,8 @@ " # \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/raw_audio/conformer_coupling/ddi/glowTTS_x*/training\",\n", " # \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/raw_audio/conformer_coupling/ddi/glow_ASR_conformer*/training\",\n", " # \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/raw_audio/conformer_coupling/no_ddi/glow_ASR_conformer*/training\",\n", - " \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/conformer_coupling/raw_audio/conformer_coupling/no_ddi/glowTTS*/training\",\n", - " \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS*/training\",\n", + " \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR*/training\",\n", + " # \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS*/training\",\n", " # \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/raw_audio/glow_ASR_conformer/training\",\n", "]\n", "# globs = [\"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/raw_audio/glowTTS_ASR*pass*/training\"]\n", @@ -79,26 +75,20 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "['/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS/training',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_x_vector/training',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_ASR_conformer_x_vector/training',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_ASR_conformer_two_forward_pass/training',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_100ep_pe1/training',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_100ep_pe1_radam1e-9/training',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS/enc192/100ep/not_silence_preprocessed/training',\n", + "['/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_two_forward_pass/training',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_x_vector_v2/training',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS_x_vector/enc768/100ep/not_silence_preprocessed/training',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS_ddi_actnorm/enc192/100ep/not_silence_preprocessed/LR_scheduled/training/',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/weak_baseline/training',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/training/']" + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/training']" ] }, - "execution_count": 4, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } @@ -115,27 +105,19 @@ "# files[lr_files[-1]] = \"Baseline\"\n", "\n", "lr_files.append(\n", - " \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS/enc192/100ep/not_silence_preprocessed/training\"\n", - ")\n", - "files[lr_files[-1]] = \"Baseline GlowTTS\"\n", - "\n", - "lr_files.append(\n", " \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS_x_vector/enc768/100ep/not_silence_preprocessed/training\"\n", ")\n", "files[lr_files[-1]] = \"Baseline GlowTTS x-vector\"\n", - "lr_files.append(\n", - " \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS_ddi_actnorm/enc192/100ep/not_silence_preprocessed/LR_scheduled/training/\"\n", - ")\n", - "files[lr_files[-1]] = \"Baseline GlowTTS ddi\"\n", "\n", "lr_files.append(\n", " \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/weak_baseline/training\"\n", ")\n", "files[lr_files[-1]] = \"Baseline Weak Conformer\"\n", + "\n", "lr_files.append(\n", - " \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/training/\"\n", + " \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/training\"\n", ")\n", - "files[lr_files[-1]] = \"Baseline Conformer\"\n", + "files[lr_files[-1]] = \"Joint Training WN coupling\"\n", "\n", "\n", "lr_files" @@ -143,7 +125,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -153,12 +135,13 @@ " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS_x_vector/enc768/100ep/not_silence_preprocessed/training': 1,\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS_x_vector_v3/enc768/100ep/not_silence_preprocessed/training': 1,\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS_x_vector_v3_norm_xvector/enc768/100ep/not_silence_preprocessed/training': 1,\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_100ep_pe1/training': 1,\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_100ep_pe1_radam1e-9/training': 1,\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_100ep_pe1/training': 1,\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_100ep_pe1/training': 1,\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS_ddi_actnorm/enc192/100ep/not_silence_preprocessed/LR_scheduled/training/': 1}" ] }, - "execution_count": 8, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -185,24 +168,17 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS/training: 3\n", - "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_x_vector/training: 3\n", - "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_ASR_conformer_x_vector/training: 3\n", - "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_ASR_conformer_two_forward_pass/training: 3\n", - "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_100ep_pe1/training: 1\n", - "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_100ep_pe1_radam1e-9/training: 1\n", - "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS/enc192/100ep/not_silence_preprocessed/training: 1\n", + "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_x_vector_v2/training: 3\n", "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS_x_vector/enc768/100ep/not_silence_preprocessed/training: 1\n", - "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS_ddi_actnorm/enc192/100ep/not_silence_preprocessed/LR_scheduled/training/: 1\n", "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/weak_baseline/training: 3\n", - "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/training/: 3\n", + "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/training: 3\n", "Large Font: False\n", "Setup Interactive Legend\n", "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous view', 'arrow-left', 'back'), ('Forward', 'Forward to next view', 'arrow-right', 'forward'), ('Pan', 'Left button pans, Right button zooms\\nx/y fixes axis, CTRL fixes aspect', 'arrows', 'pan'), ('Zoom', 'Zoom to rectangle\\nx/y fixes axis', 'square-o', 'zoom'), ('Download', 'Download plot', 'floppy-o', 'save_figure')]))\n" @@ -211,18 +187,18 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "ce7c336b10804e61adf7a71ab7821c74", + "model_id": "3c478dd060334d60b8990ebf5cc8ca96", "version_major": 2, "version_minor": 0 }, - "image/png": "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", + "image/png": "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", "text/html": [ "\n", "
\n", "
\n", " Figure\n", "
\n", - " \n", + " \n", "
\n", " " ], diff --git a/users/rilling/experiments/librispeech/librispeech_glow_asr/config.py b/users/rilling/experiments/librispeech/librispeech_glow_asr/config.py index e35213679..16421c75f 100644 --- a/users/rilling/experiments/librispeech/librispeech_glow_asr/config.py +++ b/users/rilling/experiments/librispeech/librispeech_glow_asr/config.py @@ -103,6 +103,50 @@ def get_prior_config( ) return returnn_config +def get_inv_config( + training_datasets: TrainingDatasets, + network_module: str, + net_args: Dict[str, Any], + config: Dict[str, Any], + debug: bool = False, + use_custom_engine=False, + **kwargs, +): + """ + Returns the RETURNN config serialized by :class:`ReturnnCommonSerializer` in returnn_common for the ctc_aligner + :param returnn_common_root: returnn_common version to be used, usually output of CloneGitRepositoryJob + :param training_datasets: datasets for training + :param kwargs: arguments to be passed to the network construction + :return: RETURNN training config + """ + + # changing these does not change the hash + post_config = { + } + + base_config = { + ############# + "batch_size": 50000 * 160, + "max_seqs": 60, + ############# + "forward": training_datasets.devtrain.as_returnn_opts() + + } + config = {**base_config, **copy.deepcopy(config)} + post_config["backend"] = "torch" + + serializer = get_pytorch_serializer_v3( + network_module=network_module, + net_args=net_args, + debug=debug, + use_custom_engine=use_custom_engine, + invertibility=True + ) + returnn_config = ReturnnConfig( + config=config, post_config=post_config, python_epilog=[serializer] + ) + return returnn_config + def get_search_config( network_module: str, net_args: Dict[str, Any], diff --git a/users/rilling/experiments/librispeech/librispeech_glow_asr/experiments.py b/users/rilling/experiments/librispeech/librispeech_glow_asr/experiments.py index 4bc50602a..de7fb6b1b 100644 --- a/users/rilling/experiments/librispeech/librispeech_glow_asr/experiments.py +++ b/users/rilling/experiments/librispeech/librispeech_glow_asr/experiments.py @@ -23,9 +23,9 @@ from .data_ctc import get_text_lexicon as get_text_lexicon_asr from .default_tools import RETURNN_EXE, MINI_RETURNN_ROOT -from .pipeline import training, search, compute_prior, compute_phoneme_pred_accuracy +from .pipeline import training, search, compute_prior, compute_phoneme_pred_accuracy, evaluate_invertibility -from .config import get_training_config, get_search_config, get_prior_config +from .config import get_training_config, get_search_config, get_prior_config, get_inv_config from i6_experiments.users.rilling.experiments.librispeech.librispeech_joint_training_given_alignments.storage import ( tts_models, @@ -75,7 +75,7 @@ def glowASR(TTS_experiments: dict): test_dataset_tuples = {} test_dataset_normal_ctc_tuples = {} - for testset in ["test-clean"]: + for testset in ["test-clean", "test-other"]: test_dataset_tuples[testset] = build_test_dataset( librispeech_key="train-clean-100", dataset_key=testset, @@ -135,8 +135,11 @@ def run_exp( test_datasets=dev_dataset_tuples, large_gpu_training=False, only_forward_no_search=False, + eval_invertibility=False, ): - search_args = search_args if search_args is not None else {} + search_args = copy.deepcopy(search_args) if search_args is not None else {} + + with_prior = with_prior or ("prior_scale" in search_args and search_args["prior_scale"] != 0) returnn_config = get_training_config(training_datasets=datasets, **train_args) returnn_search_config = get_search_config(**train_args, search_args=search_args) @@ -190,6 +193,16 @@ def run_exp( # search(ft_name + "/default_best", returnn_search_config, best_checkpoint, test_dataset_tuples, RETURNN_EXE, RETURNN_ROOT) # search(ft_name + "/average_4", returnn_search_config, averaged_checkpoint, test_dataset_tuples, RETURNN_EXE, RETURNN_ROOT) + if eval_invertibility: + inv_config = get_inv_config(training_datasets=datasets, **train_args) + evaluate_invertibility( + ft_name, + inv_config, + checkpoint=train_job.out_checkpoints[num_epochs], + returnn_exe=RETURNN_EXE, + returnn_root=MINI_RETURNN_ROOT, + ) + return train_job train_args = { @@ -581,6 +594,7 @@ def run_exp( train_args=train_args_blstm_frame_stack_v2, search_args={**default_search_args_asr, **additional_search_args}, test_datasets=dev_dataset_normal_ctc_tuples, + with_prior=True, ) # run_exp( # prefix_name + "blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc768/with_sigma/not_silence_preprocessed/lm4", @@ -652,6 +666,7 @@ def run_exp( train_args=train_args_blstm_only, search_args={**default_search_args_asr, **additional_search_args}, test_datasets=dev_dataset_normal_ctc_tuples, + with_prior=True, ) run_exp( @@ -660,6 +675,7 @@ def run_exp( train_args=train_args_blstm_only_spec_aug, search_args=default_search_args_asr, test_datasets=dev_dataset_normal_ctc_tuples, + with_prior=True, ) run_exp( @@ -1325,7 +1341,7 @@ def run_exp( train_args_conformer_speaker_drop_asr_data["config"]["preload_from_files"]["existing-model"]["filename"] = ( TTS_exp_train_job.out_checkpoints[TTS_exp_train_job.returnn_config.get("num_epochs", 100)] ) - for lm_w in [2.5, 3.0, 3.5, 4.0]: + for lm_w in [2.0, 2.5, 3.0, 3.5, 4.0]: for ps in [0, 0.3, 0.5]: additional_search_args = {"lm_weight": lm_w, "prior_scale": ps} run_exp( @@ -1338,6 +1354,39 @@ def run_exp( num_epochs=250, with_prior=True, ) + + train_args_conformer_speaker_drop_asr_data_p0 = copy.deepcopy(train_args_conformer_speaker_drop_asr_data) + tts_exp_name = "glowTTS/enc192/100ep/not_silence_preprocessed" + tts_train_job = TTS_experiments[tts_exp_name]["train_job"] + train_args_conformer_speaker_drop_asr_data_p0["config"]["preload_from_files"]["existing-model"]["filename"] = ( + tts_train_job.out_checkpoints[tts_train_job.returnn_config.get("num_epochs", 100)] + ) + + run_exp( + prefix_name + + f"conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0", + datasets=train_data_normal_ctc, + train_args=train_args_conformer_speaker_drop_asr_data_p0, + search_args=default_search_args_asr, + large_gpu_training=True, + num_epochs=250, + ) + + for lm_w in [2.0, 2.5, 3.0, 3.5, 4.0]: + for ps in [0, 0.3, 0.5]: + additional_search_args = {"lm_weight": lm_w, "prior_scale": ps} + run_exp( + prefix_name + + f"conformer/asr_dataset/spec_augment/glow_enc192_100ep_not_silence_preprocessed_speaker_drop_0/search_params/lm_{lm_w}_ps_{ps}", + datasets=train_data_normal_ctc, + train_args=train_args_conformer_speaker_drop_asr_data_p0, + search_args={**default_search_args_asr, **additional_search_args}, + large_gpu_training=True, + num_epochs=250, + with_prior=True, + ) + + # ------------------------------ No Freezing Experiments ------------------------------ train_args_conformer_no_freeze_asr_data = copy.deepcopy(train_args_conformer_asr_data) @@ -1364,6 +1413,21 @@ def run_exp( datasets=train_data_normal_ctc, train_args=train_args_conformer_no_freeze_asr_data_spec_aug_before, search_args=default_search_args_asr, + large_gpu_training=True, + num_epochs=250, + ) + + + train_args_weak_conformer_no_freeze_asr_data_spec_aug_before = copy.deepcopy(train_args_conformer_no_freeze_asr_data_spec_aug_before) + train_args_weak_conformer_no_freeze_asr_data_spec_aug_before["network_module"] = ( + "glowASR_conformer_no_freeze_spec_augment_before_weak_conf" + ) + run_exp( + prefix_name + + "weak_conformer/asr_dataset/spec_augment_before/glow_enc192_200ep_not_silence_preprocessed_not_freezed", + datasets=train_data_normal_ctc, + train_args=train_args_weak_conformer_no_freeze_asr_data_spec_aug_before, + search_args=default_search_args_asr, large_gpu_training=False, num_epochs=250, ) @@ -1390,7 +1454,21 @@ def run_exp( search_args=default_search_args_asr, large_gpu_training=False, num_epochs=250, + eval_invertibility=True ) + + train_args_weak_conformer_no_pretrained_asr_data = copy.deepcopy(train_args_conformer_no_pretrained_asr_data) + train_args_weak_conformer_no_pretrained_asr_data["network_module"] = "glowASR_conformer_no_freeze_spec_augment_before_weak_conf" + run_exp( + prefix_name + "weak_conformer/asr_dataset/spec_augment_before/glow_not_pretrained", + datasets=train_data_normal_ctc, + train_args=train_args_weak_conformer_no_pretrained_asr_data, + search_args=default_search_args_asr, + large_gpu_training=False, + num_epochs=250, + eval_invertibility=True + ) + train_args_conformer_no_pretrained_asr_data_no_spec_augment = copy.deepcopy( train_args_conformer_no_pretrained_asr_data ) @@ -1405,6 +1483,7 @@ def run_exp( search_args=default_search_args_asr, large_gpu_training=False, num_epochs=250, + eval_invertibility=True, ) train_args_conformer_no_pretrained_asr_data_spec_augment_after_fe = copy.deepcopy( @@ -1420,6 +1499,7 @@ def run_exp( search_args=default_search_args_asr, large_gpu_training=False, num_epochs=250, + eval_invertibility=True ) train_args_weak_conformer_no_pretrained_asr_data_spec_augment_after_fe = copy.deepcopy( @@ -1553,6 +1633,17 @@ def run_exp( num_epochs=250, with_prior=True, ) + + run_exp( + prefix_name + f"weak_conformer/asr_dataset/spec_augment_before/glow_not_pretrained/lm_tuning/lm{lm_w}_ps{ps}", + datasets=train_data_normal_ctc, + train_args=train_args_weak_conformer_no_pretrained_asr_data, + search_args={**default_search_args_asr, **additional_search_args}, + large_gpu_training=False, + num_epochs=250, + eval_invertibility=True + ) + run_exp( prefix_name + f"conformer/asr_dataset/no_spec_augment/glow_enc192_not_pretrained/lm_tuning/lm{lm_w}_ps{ps}", @@ -1573,6 +1664,16 @@ def run_exp( large_gpu_training=False, num_epochs=250, ) + + run_exp( + prefix_name + f"weak_conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained/lm_tuning/lm{lm_w}_ps{ps}", + datasets=train_data_normal_ctc, + train_args=train_args_weak_conformer_no_pretrained_asr_data_spec_augment_after_fe, + search_args={**default_search_args_asr, **additional_search_args}, + large_gpu_training=False, + num_epochs=250, + ) + run_exp( prefix_name + f"conformer/asr_dataset/spec_augment/glow_enc192_not_pretrained_control/lm_tuning/lm{lm_w}_ps{ps}", @@ -1684,16 +1785,16 @@ def run_exp( num_epochs=250, ) - train_args_weak_conformer_asr_data_v3_768 = copy.deepcopy(train_args_conformer_asr_data_v3_768) - train_args_weak_conformer_asr_data_v3_768["network_module"] = "glowASR_conformer_x_vector_v2_weak_conf" - run_exp( - prefix_name + "weak_conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2", - datasets=train_data_normal_ctc, - train_args=train_args_weak_conformer_asr_data_v3_768, - search_args=default_search_args_asr, - large_gpu_training=True, - num_epochs=250, - ) + # train_args_weak_conformer_asr_data_v3_768 = copy.deepcopy(train_args_conformer_asr_data_v3_768) + # train_args_weak_conformer_asr_data_v3_768["network_module"] = "glowASR_conformer_v2_weak_conf" + # run_exp( + # prefix_name + "weak_conformer/asr_dataset/spec_augment/glow_enc768_200ep_dec_0.05_v2", + # datasets=train_data_normal_ctc, + # train_args=train_args_weak_conformer_asr_data_v3_768, + # search_args=default_search_args_asr, + # large_gpu_training=True, + # num_epochs=250, + # ) train_args_conformer_asr_data_v3_768_no_specaug = copy.deepcopy(train_args_conformer_asr_data_v3_768) train_args_conformer_asr_data_v3_768_no_specaug["net_args"]["spec_augment"] = False @@ -1706,30 +1807,30 @@ def run_exp( num_epochs=250, ) - train_args_conformer_asr_data_v3_768_400 = copy.deepcopy(train_args_conformer_asr_data_v3_768) - train_args_conformer_asr_data_v3_768_400["config"]["preload_from_files"]["existing-model"]["filename"] = tts_models[ - "glowTTS/enc768/400ep/grad_clip_10/dec_drop_0.05" - ].checkpoint + # train_args_conformer_asr_data_v3_768_400 = copy.deepcopy(train_args_conformer_asr_data_v3_768) + # train_args_conformer_asr_data_v3_768_400["config"]["preload_from_files"]["existing-model"]["filename"] = tts_models[ + # "glowTTS/enc768/400ep/grad_clip_10/dec_drop_0.05" + # ].checkpoint - run_exp( - prefix_name + "conformer/asr_dataset/spec_augment/glow_enc768_400ep_dec_0.05_v2", - datasets=train_data_normal_ctc, - train_args=train_args_conformer_asr_data_v3_768_400, - search_args=default_search_args_asr, - large_gpu_training=True, - num_epochs=250, - ) + # run_exp( + # prefix_name + "conformer/asr_dataset/spec_augment/glow_enc768_400ep_dec_0.05_v2", + # datasets=train_data_normal_ctc, + # train_args=train_args_conformer_asr_data_v3_768_400, + # search_args=default_search_args_asr, + # large_gpu_training=True, + # num_epochs=250, + # ) - train_args_conformer_asr_data_v3_768_400_no_specaug = copy.deepcopy(train_args_conformer_asr_data_v3_768_400) - train_args_conformer_asr_data_v3_768_400_no_specaug["net_args"]["spec_augment"] = False - run_exp( - prefix_name + "conformer/asr_dataset/no_spec_augment/glow_enc768_400ep_dec_0.05_v2", - datasets=train_data_normal_ctc, - train_args=train_args_conformer_asr_data_v3_768_400_no_specaug, - search_args=default_search_args_asr, - large_gpu_training=True, - num_epochs=250, - ) + # train_args_conformer_asr_data_v3_768_400_no_specaug = copy.deepcopy(train_args_conformer_asr_data_v3_768_400) + # train_args_conformer_asr_data_v3_768_400_no_specaug["net_args"]["spec_augment"] = False + # run_exp( + # prefix_name + "conformer/asr_dataset/no_spec_augment/glow_enc768_400ep_dec_0.05_v2", + # datasets=train_data_normal_ctc, + # train_args=train_args_conformer_asr_data_v3_768_400_no_specaug, + # search_args=default_search_args_asr, + # large_gpu_training=True, + # num_epochs=250, + # ) train_args_conformer_asr_data_v3_192 = copy.deepcopy(train_args_conformer_asr_data_v3_768) train_args_conformer_asr_data_v3_192["config"]["preload_from_files"]["existing-model"]["filename"] = tts_models[ @@ -1759,6 +1860,19 @@ def run_exp( num_epochs=250, ) + train_args_conformer_asr_data_xvector_v3_100epTTS = copy.deepcopy(train_args_conformer_asr_data_xvector_v3) + train_args_conformer_asr_data_xvector_v3_100epTTS["config"]["preload_from_files"]["existing-model"]["filename"] = tts_models[ + "glowTTS_x_vector_v2/enc768/100ep/dec_drop_0.05" + ].checkpoint + run_exp( + prefix_name + "conformer/asr_dataset/spec_augment/glow_x_vector_enc768_100ep_dec_0.05_v2", + datasets=train_data_normal_ctc, + train_args=train_args_conformer_asr_data_xvector_v3_100epTTS, + search_args=default_search_args_asr, + large_gpu_training=False, + num_epochs=250, + ) + train_args_weak_conformer_asr_data_xvector_v3 = copy.deepcopy(train_args_conformer_asr_data_xvector_v3) train_args_weak_conformer_asr_data_xvector_v3["network_module"] = "glowASR_conformer_x_vector_v2_bottleneck_weak_conf" run_exp( @@ -1790,7 +1904,7 @@ def run_exp( datasets=train_data_normal_ctc, train_args=train_args_conformer_asr_data_xvector_v3_400, search_args=default_search_args_asr, - large_gpu_training=False, + large_gpu_training=True, num_epochs=250, ) @@ -1818,7 +1932,7 @@ def run_exp( num_epochs=250, ) - for lm_w in [2.5, 3.0, 3.5, 4.0]: + for lm_w in [1.5, 2.0, 2.5, 3.0, 3.5, 4.0]: for ps in [0, 0.3, 0.5]: additional_search_args = {"lm_weight": lm_w, "prior_scale": ps} run_exp( @@ -1830,7 +1944,6 @@ def run_exp( large_gpu_training=True, num_epochs=250, ) - run_exp( prefix_name + f"conformer/asr_dataset/no_spec_augment/glow_enc768_200ep_dec_0.05_v2/search_params/lm_{lm_w}_ps_{ps}", datasets=train_data_normal_ctc, @@ -1860,6 +1973,15 @@ def run_exp( num_epochs=250, ) + run_exp( + prefix_name + f"weak_conformer/asr_dataset/spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_{lm_w}_ps_{ps}", + datasets=train_data_normal_ctc, + train_args=train_args_weak_conformer_asr_data_xvector_v3, + search_args={**default_search_args_asr, **additional_search_args}, + large_gpu_training=False, + num_epochs=250, + ) + run_exp( prefix_name + f"conformer/asr_dataset/no_spec_augment/glow_x_vector_enc768_200ep_dec_0.05_v2/search_params/lm_{lm_w}_ps_{ps}", datasets=train_data_normal_ctc, @@ -1868,6 +1990,14 @@ def run_exp( large_gpu_training=True, num_epochs=250, ) + run_exp( + prefix_name + f"conformer/asr_dataset/spec_augment/glow_x_vector_enc768_100ep_dec_0.05_v2/search_params/lm_{lm_w}_ps_{ps}", + datasets=train_data_normal_ctc, + train_args=train_args_conformer_asr_data_xvector_v3_100epTTS, + search_args={**default_search_args_asr, **additional_search_args}, + large_gpu_training=False, + num_epochs=250, + ) run_exp( prefix_name diff --git a/users/rilling/experiments/librispeech/librispeech_glow_asr/pipeline.py b/users/rilling/experiments/librispeech/librispeech_glow_asr/pipeline.py index 4cd076b54..fbf095bc9 100644 --- a/users/rilling/experiments/librispeech/librispeech_glow_asr/pipeline.py +++ b/users/rilling/experiments/librispeech/librispeech_glow_asr/pipeline.py @@ -209,3 +209,33 @@ def compute_prior( ) search_job.add_alias(prefix_name + "/prior_job") return search_job.out_files["prior.txt"] + +def evaluate_invertibility( + prefix, + config, + checkpoint, + returnn_exe, + returnn_root, +): + hdf_outputs = [] + + last_forward_job = ReturnnForwardJob( + model_checkpoint=checkpoint, + returnn_config=config, + hdf_outputs=hdf_outputs, + returnn_python_exe=returnn_exe, + returnn_root=returnn_root, + mem_rqmt=20, + device="cpu" + ) + + forward_prefix = prefix + "/forward_invertibility" + + last_forward_job.add_alias(forward_prefix) + + tts_hdf = None + + tts_hdf = last_forward_job.out_hdf_files["output.hdf"] + tk.register_output(forward_prefix, tts_hdf) + + return last_forward_job diff --git a/users/rilling/experiments/librispeech/librispeech_glow_asr/pytorch_networks/glowASR_blstm_frame_stack.py b/users/rilling/experiments/librispeech/librispeech_glow_asr/pytorch_networks/glowASR_blstm_frame_stack.py index 8cee7af0d..5c964055f 100644 --- a/users/rilling/experiments/librispeech/librispeech_glow_asr/pytorch_networks/glowASR_blstm_frame_stack.py +++ b/users/rilling/experiments/librispeech/librispeech_glow_asr/pytorch_networks/glowASR_blstm_frame_stack.py @@ -31,7 +31,7 @@ from .shared import attentions from .monotonic_align import maximum_path -from .shared.forward import forward_init_hook, forward_step, forward_finish_hook +from .shared.forward import forward_init_hook, forward_step, forward_finish_hook, prior_step, prior_finish_hook, prior_init_hook from .shared.train import train_step from IPython import embed diff --git a/users/rilling/experiments/librispeech/librispeech_glow_asr/pytorch_networks/glowASR_blstm_frame_stack_v2.py b/users/rilling/experiments/librispeech/librispeech_glow_asr/pytorch_networks/glowASR_blstm_frame_stack_v2.py index d971b6b16..f3c3ef110 100644 --- a/users/rilling/experiments/librispeech/librispeech_glow_asr/pytorch_networks/glowASR_blstm_frame_stack_v2.py +++ b/users/rilling/experiments/librispeech/librispeech_glow_asr/pytorch_networks/glowASR_blstm_frame_stack_v2.py @@ -31,7 +31,7 @@ from .shared import attentions from .monotonic_align import maximum_path -from .shared.forward import forward_init_hook, forward_step, forward_finish_hook +from .shared.forward import forward_init_hook, forward_step, forward_finish_hook, prior_step, prior_finish_hook, prior_init_hook from .shared.train import train_step from IPython import embed diff --git a/users/rilling/experiments/librispeech/librispeech_glow_asr/pytorch_networks/glowASR_blstm_frame_stack_x_vector.py b/users/rilling/experiments/librispeech/librispeech_glow_asr/pytorch_networks/glowASR_blstm_frame_stack_x_vector.py index 4f415af64..90c7aea2b 100644 --- a/users/rilling/experiments/librispeech/librispeech_glow_asr/pytorch_networks/glowASR_blstm_frame_stack_x_vector.py +++ b/users/rilling/experiments/librispeech/librispeech_glow_asr/pytorch_networks/glowASR_blstm_frame_stack_x_vector.py @@ -31,7 +31,7 @@ from .shared import attentions from .monotonic_align import maximum_path -from .shared.forward import forward_init_hook, forward_step, forward_finish_hook +from .shared.forward import forward_init_hook, forward_step, forward_finish_hook, prior_step, prior_finish_hook, prior_init_hook from .shared.train import train_step from IPython import embed diff --git a/users/rilling/experiments/librispeech/librispeech_glow_asr/pytorch_networks/glowASR_blstm_frame_stack_x_vector_v2.py b/users/rilling/experiments/librispeech/librispeech_glow_asr/pytorch_networks/glowASR_blstm_frame_stack_x_vector_v2.py index 86a9400cb..842862bca 100644 --- a/users/rilling/experiments/librispeech/librispeech_glow_asr/pytorch_networks/glowASR_blstm_frame_stack_x_vector_v2.py +++ b/users/rilling/experiments/librispeech/librispeech_glow_asr/pytorch_networks/glowASR_blstm_frame_stack_x_vector_v2.py @@ -31,7 +31,7 @@ from .shared import attentions from .monotonic_align import maximum_path -from .shared.forward import forward_init_hook, forward_step, forward_finish_hook +from .shared.forward import forward_init_hook, forward_step, forward_finish_hook, prior_step, prior_finish_hook, prior_init_hook from .shared.train import train_step from IPython import embed diff --git a/users/rilling/experiments/librispeech/librispeech_glow_asr/pytorch_networks/glowASR_conformer.py b/users/rilling/experiments/librispeech/librispeech_glow_asr/pytorch_networks/glowASR_conformer.py index d85c91898..6c8e5a5ee 100644 --- a/users/rilling/experiments/librispeech/librispeech_glow_asr/pytorch_networks/glowASR_conformer.py +++ b/users/rilling/experiments/librispeech/librispeech_glow_asr/pytorch_networks/glowASR_conformer.py @@ -203,7 +203,7 @@ def __init__( final_dropout=0.2, specauc_start_epoch=1 ) - + self.cfg = conformer_model_config frontend_config = self.cfg.frontend_config conformer_size = self.cfg.conformer_size @@ -244,7 +244,6 @@ def __init__( self.final_dropout = nn.Dropout(p=self.cfg.final_dropout) self.specaug_start_epoch = self.cfg.specauc_start_epoch - def forward(self, raw_audio, raw_audio_len): with torch.no_grad(): squeezed_audio = torch.squeeze(raw_audio) @@ -273,12 +272,12 @@ def forward(self, raw_audio, raw_audio_len): audio_features_masked_2 = spec_augment_in conformer_in = audio_features_masked_2 - + if self.layer_norm: conformer_in = torch.nn.functional.layer_norm(conformer_in, (conformer_in.size(-1),)) elif self.bn is not None: conformer_in = self.bn(conformer_in.transpose(1,2)).transpose(1,2) - + conformer_out, out_mask = self.conformer(conformer_in, mask) conformer_out = self.final_dropout(conformer_out) logits = self.final_linear(conformer_out) @@ -296,4 +295,3 @@ def preprocess(self, y, y_lengths, y_max_length): def store_inverse(self): self.decoder.store_inverse() - diff --git a/users/rilling/experiments/librispeech/librispeech_glow_asr/pytorch_networks/glowASR_conformer_no_freeze.py b/users/rilling/experiments/librispeech/librispeech_glow_asr/pytorch_networks/glowASR_conformer_no_freeze.py index 01b444d2f..7eb66c389 100644 --- a/users/rilling/experiments/librispeech/librispeech_glow_asr/pytorch_networks/glowASR_conformer_no_freeze.py +++ b/users/rilling/experiments/librispeech/librispeech_glow_asr/pytorch_networks/glowASR_conformer_no_freeze.py @@ -50,6 +50,7 @@ from .monotonic_align import maximum_path from .shared.forward import forward_init_hook, forward_step, forward_finish_hook, prior_init_hook, prior_finish_hook, prior_step +from .shared.eval_invertibility import * from .shared.train import train_step from IPython import embed diff --git a/users/rilling/experiments/librispeech/librispeech_glow_asr/pytorch_networks/glowASR_conformer_no_freeze_spec_augment.py b/users/rilling/experiments/librispeech/librispeech_glow_asr/pytorch_networks/glowASR_conformer_no_freeze_spec_augment.py index d7e6bd6b0..70dca4b54 100644 --- a/users/rilling/experiments/librispeech/librispeech_glow_asr/pytorch_networks/glowASR_conformer_no_freeze_spec_augment.py +++ b/users/rilling/experiments/librispeech/librispeech_glow_asr/pytorch_networks/glowASR_conformer_no_freeze_spec_augment.py @@ -51,6 +51,7 @@ from .shared.forward import forward_init_hook, forward_step, forward_finish_hook, prior_init_hook, prior_finish_hook, prior_step from .shared.train import train_step +from .shared.eval_invertibility import * from IPython import embed diff --git a/users/rilling/experiments/librispeech/librispeech_glow_asr/pytorch_networks/glowASR_conformer_no_freeze_spec_augment_before_weak_conf.py b/users/rilling/experiments/librispeech/librispeech_glow_asr/pytorch_networks/glowASR_conformer_no_freeze_spec_augment_before_weak_conf.py new file mode 100644 index 000000000..4676f411e --- /dev/null +++ b/users/rilling/experiments/librispeech/librispeech_glow_asr/pytorch_networks/glowASR_conformer_no_freeze_spec_augment_before_weak_conf.py @@ -0,0 +1,298 @@ +""" +Trying to make the aligner more AppTek-Like + +Extended weight init code +""" + +from dataclasses import dataclass +import torch +import numpy as np +from torch import nn +import multiprocessing +from librosa import filters +import sys +import time +from typing import Any, Dict, Optional, Tuple, Union +import math + +from torchaudio.functional import mask_along_axis + +from i6_models.parts.blstm import BlstmEncoderV1, BlstmEncoderV1Config + + +from i6_models.parts.conformer.norm import LayerNormNC +from i6_models.assemblies.conformer.conformer_v1 import ConformerEncoderV1Config +from i6_models.assemblies.conformer.conformer_v1 import ConformerBlockV1Config, ConformerEncoderV1 +from i6_models.config import ModuleFactoryV1 +from i6_models.parts.frontend.vgg_act import VGG4LayerActFrontendV1, VGG4LayerActFrontendV1Config + +from i6_models.parts.conformer.convolution import ConformerConvolutionV1Config +from i6_models.parts.conformer.feedforward import ConformerPositionwiseFeedForwardV1Config +from i6_models.parts.conformer.mhsa import ConformerMHSAV1Config +from i6_models.primitives.specaugment import specaugment_v1_by_length +from i6_models.primitives.feature_extraction import LogMelFeatureExtractionV1, LogMelFeatureExtractionV1Config +from ..i6modelsV1_VGG4LayerActFrontendV1_v4_cfg import ModelConfig + +from ..i6modelsV1_VGG4LayerActFrontendV1_v4_cfg import \ + SpecaugConfig, VGG4LayerActFrontendV1Config_mod, ModelConfig + + +from returnn.torch.context import get_run_ctx + +from .shared.configs import DbMelFeatureExtractionConfig +from .shared.feature_extraction import DbMelFeatureExtraction +from .shared.spec_augment import apply_spec_aug +from .shared.mask import mask_tensor + +from .shared import modules +from .shared import commons +from .shared import attentions +from .monotonic_align import maximum_path + +from .shared.forward import forward_init_hook, forward_step, forward_finish_hook, prior_init_hook, prior_finish_hook, prior_step +from .shared.train import train_step +from .shared.eval_invertibility import * + +from IPython import embed + +class Model(nn.Module): + """ + Flow-based ASR model based on GlowTTS Structure using a pre-trained flow-based decoder + trained to generate spectrograms from given statistics coming from an encoder + + Model was pretrained using the architecture in + users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS.py + """ + + def __init__( + self, + n_vocab: int, + hidden_channels: int = 192, + out_channels: int = 80, + n_blocks_dec: int = 12, + kernel_size_dec: int = 5, + dilation_rate: int = 1, + n_block_layers: int = 4, + p_dropout: float = 0.1, + p_dropout_flow: float = 0.05, + gin_channels: int = 0, + n_split: int = 4, + n_sqz: int = 2, + sigmoid_scale: bool = False, + window_size: int = 4, + block_length: int = None, + hidden_channels_dec: int = None, + label_target_size=None, + spec_augment = False, + layer_norm = False, + batch_norm = False, + **kwargs, + ): + """_summary_ + + Args: + n_vocab (int): vocabulary size + hidden_channels (int): Number of hidden channels in encoder + out_channels (int): Number of channels in the output + n_blocks_dec (int, optional): Number of coupling blocks in the decoder. Defaults to 12. + kernel_size_dec (int, optional): Kernel size in the decoder. Defaults to 5. + dilation_rate (int, optional): Dilation rate for CNNs of coupling blocks in decoder. Defaults to 5. + n_block_layers (int, optional): Number of layers in the CNN of the coupling blocks in decoder. Defaults to 4. + p_dropout_dec (_type_, optional): Dropout probability in the decoder. Defaults to 0.. + n_speakers (int, optional): Number of speakers. Defaults to 0. + gin_channels (int, optional): Number of speaker embedding channels. Defaults to 0. + n_split (int, optional): Number of splits for the 1x1 convolution for flows in the decoder. Defaults to 4. + n_sqz (int, optional): Squeeze. Defaults to 1. + sigmoid_scale (bool, optional): Boolean to define if log probs in coupling layers should be rescaled using sigmoid. Defaults to False. + window_size (int, optional): Window size in Multi-Head Self-Attention for encoder. Defaults to None. + block_length (_type_, optional): Block length for optional block masking in Multi-Head Attention for encoder. Defaults to None. + hidden_channels_dec (_type_, optional): Number of hidden channels in decodder. Defaults to hidden_channels. + final_hidden_channels: Number of hidden channels in the final network + final_n_layers: Number of layers in the final network + label_target_size: Target size of target vocabulary, target size for final network + """ + super().__init__() + self.n_vocab = n_vocab + self.hidden_channels = hidden_channels + self.out_channels = out_channels + self.n_blocks_dec = n_blocks_dec + self.kernel_size_dec = kernel_size_dec + self.dilation_rate = dilation_rate + self.n_block_layers = n_block_layers + self.p_dropout = p_dropout + self.p_dropout_flow = p_dropout_flow + self.n_split = n_split + self.n_sqz = n_sqz + self.sigmoid_scale = sigmoid_scale + self.window_size = window_size + self.block_length = block_length + self.hidden_channels_dec = hidden_channels_dec + self.spec_augment = spec_augment + self.layer_norm = layer_norm + self.batch_norm = batch_norm + + self.net_kwargs = { + "repeat_per_num_frames": 100, + "max_dim_feat": 8, + "num_repeat_feat": 5, + "max_dim_time": 20, + } + + fe_config = DbMelFeatureExtractionConfig.from_dict(kwargs["fe_config"]) + self.feature_extraction = DbMelFeatureExtraction(config=fe_config) + + if label_target_size is None: + if n_vocab is None: + run_ctx = get_run_ctx() + dataset = run_ctx.engine.train_dataset or run_ctx.engine.forward_dataset + self.label_target_size = len(dataset.datasets["zip_dataset"].targets.labels) + else: + self.label_target_size = n_vocab + else: + self.label_target_size = label_target_size + + self.decoder = modules.Flow( + out_channels, + hidden_channels_dec or hidden_channels, + kernel_size_dec, + dilation_rate, + n_blocks_dec, + n_block_layers, + p_dropout=p_dropout_flow, + n_split=n_split, + n_sqz=n_sqz, + sigmoid_scale=sigmoid_scale, + gin_channels=gin_channels, + ) + + specaug_config = SpecaugConfig( + repeat_per_n_frames=25, + max_dim_time=20, + max_dim_feat=16, + num_repeat_feat=5, + ) + frontend_config = VGG4LayerActFrontendV1Config( + in_features=80, + conv1_channels=16, + conv2_channels=16, + conv3_channels=16, + conv4_channels=16, + conv_kernel_size=(3, 3), + conv_padding=None, + pool1_kernel_size=(2, 1), + pool1_stride=(2, 1), + pool1_padding=None, + pool2_kernel_size=(2, 1), + pool2_stride=(2, 1), + pool2_padding=None, + out_features=96, + activation=nn.ReLU(), + ) + + model_config = ModelConfig( + frontend_config=frontend_config, + specaug_config=None, + label_target_size=self.n_vocab, + conformer_size=96, + num_layers=8, + num_heads=2, + ff_dim=384, + att_weights_dropout=0.2, + conv_dropout=0.2, + ff_dropout=0.2, + mhsa_dropout=0.2, + conv_kernel_size=9, + final_dropout=0.2, + specauc_start_epoch=1, + ) + self.cfg = model_config + frontend_config = self.cfg.frontend_config + conformer_size = self.cfg.conformer_size + conformer_config = ConformerEncoderV1Config( + num_layers=self.cfg.num_layers, + frontend=ModuleFactoryV1(module_class=VGG4LayerActFrontendV1, cfg=frontend_config), + block_cfg=ConformerBlockV1Config( + ff_cfg=ConformerPositionwiseFeedForwardV1Config( + input_dim=conformer_size, + hidden_dim=self.cfg.ff_dim, + dropout=self.cfg.ff_dropout, + activation=nn.functional.silu, + ), + mhsa_cfg=ConformerMHSAV1Config( + input_dim=conformer_size, + num_att_heads=self.cfg.num_heads, + att_weights_dropout=self.cfg.att_weights_dropout, + dropout=self.cfg.mhsa_dropout, + ), + conv_cfg=ConformerConvolutionV1Config( + channels=conformer_size, kernel_size=self.cfg.conv_kernel_size, dropout=self.cfg.conv_dropout, activation=nn.functional.silu, + norm=LayerNormNC(conformer_size) + ), + ), + ) + + if self.layer_norm: + print("Using Layer Norm after Flow...") + + if self.batch_norm: + print("Using Batch Norm after Flow...") + self.bn = nn.BatchNorm1d(self.out_channels) + else: + self.bn = None + + self.conformer = ConformerEncoderV1(cfg=conformer_config) + self.final_linear = nn.Linear(conformer_size, self.cfg.label_target_size + 1) # + CTC blank + self.final_dropout = nn.Dropout(p=self.cfg.final_dropout) + self.specaug_start_epoch = self.cfg.specauc_start_epoch + + + def forward(self, raw_audio, raw_audio_len): + with torch.no_grad(): + squeezed_audio = torch.squeeze(raw_audio) + log_mel_features, log_mel_features_len = self.feature_extraction(squeezed_audio, raw_audio_len) # [B, T, F] + + audio_max_length = log_mel_features.size(1) + spec_augment_in = log_mel_features + if self.training and self.spec_augment: + audio_features_masked_2 = apply_spec_aug( + spec_augment_in, + num_repeat_time=torch.max(log_mel_features_len).detach().cpu().numpy() + // self.net_kwargs["repeat_per_num_frames"], + max_dim_time=self.net_kwargs["max_dim_time"], + num_repeat_feat=self.net_kwargs["num_repeat_feat"], + max_dim_feat=self.net_kwargs["max_dim_feat"], + ) + else: + audio_features_masked_2 = spec_augment_in + + flow_in = audio_features_masked_2.transpose(1,2) # [B, F, T] + flow_in, flow_in_length, flow_in_max_length = self.preprocess(flow_in, log_mel_features_len, audio_max_length) + mask = torch.unsqueeze(commons.sequence_mask(log_mel_features_len, flow_in.size(2)), 1).to(flow_in.dtype) + flow_out, _ = self.decoder(flow_in, mask, reverse=False) # [B, F, T] + + conformer_in = flow_out.transpose(1,2) + mask = mask_tensor(conformer_in, flow_in_length) + + if self.layer_norm: + conformer_in = torch.nn.functional.layer_norm(conformer_in, (conformer_in.size(-1),)) + elif self.bn is not None: + conformer_in = self.bn(conformer_in.transpose(1,2)).transpose(1,2) + + conformer_out, out_mask = self.conformer(conformer_in, mask) + conformer_out = self.final_dropout(conformer_out) + logits = self.final_linear(conformer_out) + + log_probs = torch.log_softmax(logits, dim=2) + + return log_probs, torch.sum(out_mask, dim=1) + + def preprocess(self, y, y_lengths, y_max_length): + if y_max_length is not None: + y_max_length = (y_max_length // self.n_sqz) * self.n_sqz + y = y[:, :, :y_max_length] + y_lengths = (y_lengths // self.n_sqz) * self.n_sqz + return y, y_lengths, y_max_length + + def store_inverse(self): + self.decoder.store_inverse() + diff --git a/users/rilling/experiments/librispeech/librispeech_glow_asr/pytorch_networks/glowASR_conformer_no_pretrained.py b/users/rilling/experiments/librispeech/librispeech_glow_asr/pytorch_networks/glowASR_conformer_no_pretrained.py index 4bd7877ea..4e6da3392 100644 --- a/users/rilling/experiments/librispeech/librispeech_glow_asr/pytorch_networks/glowASR_conformer_no_pretrained.py +++ b/users/rilling/experiments/librispeech/librispeech_glow_asr/pytorch_networks/glowASR_conformer_no_pretrained.py @@ -51,7 +51,7 @@ from .shared.forward import forward_init_hook, forward_step, forward_finish_hook, prior_init_hook, prior_finish_hook, prior_step from .shared.train import train_step - +from .shared.eval_invertibility import * from IPython import embed class Model(nn.Module): diff --git a/users/rilling/experiments/librispeech/librispeech_glow_asr/pytorch_networks/glowASR_conformer_v2.py b/users/rilling/experiments/librispeech/librispeech_glow_asr/pytorch_networks/glowASR_conformer_v2.py new file mode 100644 index 000000000..0c1fd6c21 --- /dev/null +++ b/users/rilling/experiments/librispeech/librispeech_glow_asr/pytorch_networks/glowASR_conformer_v2.py @@ -0,0 +1,298 @@ +""" +Trying to make the aligner more AppTek-Like + +Extended weight init code +""" + +from dataclasses import dataclass +import torch +import numpy as np +from torch import nn +import multiprocessing +from librosa import filters +import sys +import time +from typing import Any, Dict, Optional, Tuple, Union +import math + +from torchaudio.functional import mask_along_axis + +from i6_models.parts.blstm import BlstmEncoderV1, BlstmEncoderV1Config + + +from i6_models.parts.conformer.norm import LayerNormNC +from i6_models.assemblies.conformer.conformer_v1 import ConformerEncoderV1Config +from i6_models.assemblies.conformer.conformer_v1 import ConformerBlockV1Config, ConformerEncoderV1 +from i6_models.config import ModuleFactoryV1 +from i6_models.parts.frontend.vgg_act import VGG4LayerActFrontendV1, VGG4LayerActFrontendV1Config + +from i6_models.parts.conformer.convolution import ConformerConvolutionV1Config +from i6_models.parts.conformer.feedforward import ConformerPositionwiseFeedForwardV1Config +from i6_models.parts.conformer.mhsa import ConformerMHSAV1Config +from i6_models.primitives.specaugment import specaugment_v1_by_length +from i6_models.primitives.feature_extraction import LogMelFeatureExtractionV1, LogMelFeatureExtractionV1Config + +from ..i6modelsV1_VGG4LayerActFrontendV1_v4_cfg import \ + SpecaugConfig, VGG4LayerActFrontendV1Config_mod, ModelConfig + + +from returnn.torch.context import get_run_ctx + +from .shared.configs import DbMelFeatureExtractionConfig +from .shared.feature_extraction import DbMelFeatureExtraction +from .shared.spec_augment import apply_spec_aug +from .shared.mask import mask_tensor + +from .shared import modules +from .shared import commons +from .shared import attentions +from .monotonic_align import maximum_path + +from .shared.forward import forward_init_hook, forward_step, forward_finish_hook, prior_init_hook, prior_finish_hook, prior_step +from .shared.train import train_step + +from IPython import embed + +class Model(nn.Module): + """ + Flow-based ASR model based on GlowTTS Structure using a pre-trained flow-based decoder + trained to generate spectrograms from given statistics coming from an encoder + + Model was pretrained using the architecture in + users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS.py + """ + + def __init__( + self, + n_vocab: int, + hidden_channels: int = 192, + out_channels: int = 80, + n_blocks_dec: int = 12, + kernel_size_dec: int = 5, + dilation_rate: int = 1, + n_block_layers: int = 4, + p_dropout: float = 0.1, + p_dropout_flow: float = 0.05, + gin_channels: int = 0, + n_split: int = 4, + n_sqz: int = 2, + sigmoid_scale: bool = False, + window_size: int = 4, + block_length: int = None, + hidden_channels_dec: int = None, + label_target_size: int = None, + spec_augment: bool = False, + layer_norm: bool = False, + batch_norm: bool = False, + conformer_model_config: ModelConfig = None, + **kwargs, + ): + """_summary_ + + Args: + n_vocab (int): vocabulary size + hidden_channels (int): Number of hidden channels in encoder + out_channels (int): Number of channels in the output + n_blocks_dec (int, optional): Number of coupling blocks in the decoder. Defaults to 12. + kernel_size_dec (int, optional): Kernel size in the decoder. Defaults to 5. + dilation_rate (int, optional): Dilation rate for CNNs of coupling blocks in decoder. Defaults to 5. + n_block_layers (int, optional): Number of layers in the CNN of the coupling blocks in decoder. Defaults to 4. + p_dropout_dec (_type_, optional): Dropout probability in the decoder. Defaults to 0.. + n_speakers (int, optional): Number of speakers. Defaults to 0. + gin_channels (int, optional): Number of speaker embedding channels. Defaults to 0. + n_split (int, optional): Number of splits for the 1x1 convolution for flows in the decoder. Defaults to 4. + n_sqz (int, optional): Squeeze. Defaults to 1. + sigmoid_scale (bool, optional): Boolean to define if log probs in coupling layers should be rescaled using sigmoid. Defaults to False. + window_size (int, optional): Window size in Multi-Head Self-Attention for encoder. Defaults to None. + block_length (_type_, optional): Block length for optional block masking in Multi-Head Attention for encoder. Defaults to None. + hidden_channels_dec (_type_, optional): Number of hidden channels in decodder. Defaults to hidden_channels. + final_hidden_channels: Number of hidden channels in the final network + final_n_layers: Number of layers in the final network + label_target_size: Target size of target vocabulary, target size for final network + """ + super().__init__() + self.n_vocab = n_vocab + self.hidden_channels = hidden_channels + self.out_channels = out_channels + self.n_blocks_dec = n_blocks_dec + self.kernel_size_dec = kernel_size_dec + self.dilation_rate = dilation_rate + self.n_block_layers = n_block_layers + self.p_dropout = p_dropout + self.p_dropout_flow = p_dropout_flow + self.n_split = n_split + self.n_sqz = n_sqz + self.sigmoid_scale = sigmoid_scale + self.window_size = window_size + self.block_length = block_length + self.hidden_channels_dec = hidden_channels_dec + self.spec_augment = spec_augment + self.layer_norm = layer_norm + self.batch_norm = batch_norm + + self.net_kwargs = { + "repeat_per_num_frames": 100, + "max_dim_feat": 8, + "num_repeat_feat": 5, + "max_dim_time": 20, + } + + fe_config = DbMelFeatureExtractionConfig.from_dict(kwargs["fe_config"]) + self.feature_extraction = DbMelFeatureExtraction(config=fe_config) + + if label_target_size is None: + if n_vocab is None: + run_ctx = get_run_ctx() + dataset = run_ctx.engine.train_dataset or run_ctx.engine.forward_dataset + self.label_target_size = len(dataset.datasets["zip_dataset"].targets.labels) + else: + self.label_target_size = n_vocab + else: + self.label_target_size = label_target_size + + self.decoder = modules.Flow( + out_channels, + hidden_channels_dec or hidden_channels, + kernel_size_dec, + dilation_rate, + n_blocks_dec, + n_block_layers, + p_dropout=p_dropout_flow, + n_split=n_split, + n_sqz=n_sqz, + sigmoid_scale=sigmoid_scale, + gin_channels=gin_channels, + ) + if conformer_model_config is None: + specaug_config = SpecaugConfig( + repeat_per_n_frames=25, + max_dim_time=20, + max_dim_feat=16, + num_repeat_feat=5, + ) + frontend_config = VGG4LayerActFrontendV1Config( + in_features=80, + conv1_channels=32, + conv2_channels=64, + conv3_channels=64, + conv4_channels=32, + conv_kernel_size=(3, 3), + conv_padding=None, + pool1_kernel_size=(2, 1), + pool1_stride=(2, 1), + pool1_padding=None, + pool2_kernel_size=(2, 1), + pool2_stride=(2, 1), + pool2_padding=None, + out_features=384, + activation=nn.ReLU(), + ) + conformer_model_config = ModelConfig( + frontend_config=frontend_config, + specaug_config=specaug_config, + label_target_size=self.n_vocab, + conformer_size=384, + num_layers=12, + num_heads=4, + ff_dim=1536, + att_weights_dropout=0.2, + conv_dropout=0.2, + ff_dropout=0.2, + mhsa_dropout=0.2, + conv_kernel_size=31, + final_dropout=0.2, + specauc_start_epoch=1 + ) + + self.cfg = conformer_model_config + frontend_config = self.cfg.frontend_config + conformer_size = self.cfg.conformer_size + conformer_config = ConformerEncoderV1Config( + num_layers=self.cfg.num_layers, + frontend=ModuleFactoryV1(module_class=VGG4LayerActFrontendV1, cfg=frontend_config), + block_cfg=ConformerBlockV1Config( + ff_cfg=ConformerPositionwiseFeedForwardV1Config( + input_dim=conformer_size, + hidden_dim=self.cfg.ff_dim, + dropout=self.cfg.ff_dropout, + activation=nn.functional.silu, + ), + mhsa_cfg=ConformerMHSAV1Config( + input_dim=conformer_size, + num_att_heads=self.cfg.num_heads, + att_weights_dropout=self.cfg.att_weights_dropout, + dropout=self.cfg.mhsa_dropout, + ), + conv_cfg=ConformerConvolutionV1Config( + channels=conformer_size, kernel_size=self.cfg.conv_kernel_size, dropout=self.cfg.conv_dropout, activation=nn.functional.silu, + norm=LayerNormNC(conformer_size) + ), + ), + ) + + if self.layer_norm: + print("Using Layer Norm after Flow...") + + if self.batch_norm: + print("Using Batch Norm after Flow...") + self.bn = nn.BatchNorm1d(self.out_channels) + else: + self.bn = None + + self.conformer = ConformerEncoderV1(cfg=conformer_config) + self.final_linear = nn.Linear(conformer_size, self.cfg.label_target_size + 1) # + CTC blank + self.final_dropout = nn.Dropout(p=self.cfg.final_dropout) + self.specaug_start_epoch = self.cfg.specauc_start_epoch + + def forward(self, raw_audio, raw_audio_len): + with torch.no_grad(): + self.decoder.eval() + squeezed_audio = torch.squeeze(raw_audio) + log_mel_features, log_mel_features_len = self.feature_extraction(squeezed_audio, raw_audio_len) # [B, T, F] + + audio_max_length = log_mel_features.size(1) + + flow_in = log_mel_features.transpose(1,2) # [B, F, T] + flow_in, flow_in_length, flow_in_max_length = self.preprocess(flow_in, log_mel_features_len, audio_max_length) + mask = torch.unsqueeze(commons.sequence_mask(log_mel_features_len, flow_in.size(2)), 1).to(flow_in.dtype) + flow_out, _ = self.decoder(flow_in, mask, reverse=False) # [B, F, T] + + spec_augment_in = flow_out.transpose(1,2) # [B, T, F] + mask = mask_tensor(spec_augment_in, flow_in_length) + + if self.training and self.spec_augment: + audio_features_masked_2 = apply_spec_aug( + spec_augment_in, + num_repeat_time=torch.max(log_mel_features_len).detach().cpu().numpy() + // self.net_kwargs["repeat_per_num_frames"], + max_dim_time=self.net_kwargs["max_dim_time"], + num_repeat_feat=self.net_kwargs["num_repeat_feat"], + max_dim_feat=self.net_kwargs["max_dim_feat"], + ) + else: + audio_features_masked_2 = spec_augment_in + + conformer_in = audio_features_masked_2 + + if self.layer_norm: + conformer_in = torch.nn.functional.layer_norm(conformer_in, (conformer_in.size(-1),)) + elif self.bn is not None: + conformer_in = self.bn(conformer_in.transpose(1,2)).transpose(1,2) + + conformer_out, out_mask = self.conformer(conformer_in, mask) + conformer_out = self.final_dropout(conformer_out) + logits = self.final_linear(conformer_out) + + log_probs = torch.log_softmax(logits, dim=2) + + return log_probs, torch.sum(out_mask, dim=1) + + def preprocess(self, y, y_lengths, y_max_length): + if y_max_length is not None: + y_max_length = (y_max_length // self.n_sqz) * self.n_sqz + y = y[:, :, :y_max_length] + y_lengths = (y_lengths // self.n_sqz) * self.n_sqz + return y, y_lengths, y_max_length + + def store_inverse(self): + self.decoder.store_inverse() diff --git a/users/rilling/experiments/librispeech/librispeech_glow_asr/pytorch_networks/only_blstm_frame_stack.py b/users/rilling/experiments/librispeech/librispeech_glow_asr/pytorch_networks/only_blstm_frame_stack.py index 32be20e41..08866c2cc 100644 --- a/users/rilling/experiments/librispeech/librispeech_glow_asr/pytorch_networks/only_blstm_frame_stack.py +++ b/users/rilling/experiments/librispeech/librispeech_glow_asr/pytorch_networks/only_blstm_frame_stack.py @@ -31,7 +31,7 @@ from .shared import attentions from .monotonic_align import maximum_path -from .shared.forward import forward_init_hook, forward_step, forward_finish_hook +from .shared.forward import forward_init_hook, forward_step, forward_finish_hook, prior_init_hook, prior_finish_hook, prior_step from .shared.train import train_step from IPython import embed diff --git a/users/rilling/experiments/librispeech/librispeech_glow_asr/pytorch_networks/shared/eval_invertibility.py b/users/rilling/experiments/librispeech/librispeech_glow_asr/pytorch_networks/shared/eval_invertibility.py new file mode 100644 index 000000000..127bf3375 --- /dev/null +++ b/users/rilling/experiments/librispeech/librispeech_glow_asr/pytorch_networks/shared/eval_invertibility.py @@ -0,0 +1,83 @@ +import multiprocessing +import torch +import numpy as np +from returnn.datasets.hdf import SimpleHDFWriter +from . import commons + + +def forward_init_hook_invertibility(run_ctx, **kwargs): + run_ctx.total_mae = 0 + run_ctx.total_ae_var = 0 + run_ctx.total_ae_max = torch.tensor(-np.inf) + run_ctx.total_ae_min = torch.tensor(np.inf) + run_ctx.num_of_obs = 0 + + +def forward_finish_hook_invertibility(run_ctx, **kwargs): + with open("output.hdf", "w+") as f: + f.write("total, mean, var, max, min \n") + f.write( + f"{run_ctx.num_of_obs}, {str(float(run_ctx.total_mae))}, {str(float(run_ctx.total_ae_var))}, {str(float(run_ctx.total_ae_max))}, {str(float(run_ctx.total_ae_min))}" + ) + + +def forward_step_invertibility(*, model, data, run_ctx, **kwargs): + raw_audio = data["raw_audio"] # [B, N] (sparse) + raw_audio_len = data["raw_audio:size1"] # [B] + phonemes = data["phon_labels"] + phonemes_len = data["phon_labels:size1"] + + squeezed_audio = torch.squeeze(raw_audio) + y, y_lengths = model.feature_extraction(squeezed_audio, raw_audio_len) # [B, T, F] + y = y.transpose(1, 2) # [B, F, T] + + if hasattr(model, "x_vector"): + _, _, g = model.x_vector(y, y_lengths) + + if hasattr(model, "x_vector_bottleneck"): + g = model.x_vector_bottleneck(g) + elif hasattr(model, "emb_g"): + g = torch.nn.functional.normalize(model.emb_g(g.squeeze(-1))).unsqueeze(-1) + else: + g = None + + y_max_length = y.size(2) + + y, y_lengths, y_max_length = model.preprocess(y, y_lengths, y_max_length) + z_mask = torch.unsqueeze(commons.sequence_mask(y_lengths, y_max_length), 1).to(torch.int32) + + z, _ = model.decoder(y, z_mask, g=g, reverse=False) + y_hat, _ = model.decoder(z, z_mask, g=g, reverse=True) + + mae = torch.nn.functional.l1_loss(y_hat * z_mask, y * z_mask, reduction="none") # [B, F, T] + + current_num_of_obs = y_hat.shape[1] * y_lengths.sum() # F * total_number_of_frames_in_batch + + old_mae = run_ctx.total_mae + + current_mae = ( + mae.sum() / current_num_of_obs + ) # This considers the masking by only using the mean over all unmasked elements + + current_var = (mae - current_mae).pow(2).sum() / ( + current_num_of_obs - 1 + ) # Variance over unmasked elements with bias correction 1 + + run_ctx.total_mae = ((run_ctx.num_of_obs / (run_ctx.num_of_obs + current_num_of_obs)) * old_mae) + ( + (current_num_of_obs / (run_ctx.num_of_obs + current_num_of_obs)) * current_mae + ) + + run_ctx.total_ae_var = ( + (run_ctx.num_of_obs / (run_ctx.num_of_obs + current_num_of_obs)) * run_ctx.total_ae_var + + ((current_num_of_obs / (run_ctx.num_of_obs + current_num_of_obs)) * current_var) + + ((run_ctx.num_of_obs * current_num_of_obs) / (run_ctx.num_of_obs + current_num_of_obs) ** 2) + * (old_mae - current_mae) ** 2 + ) + + run_ctx.total_ae_max = torch.max(run_ctx.total_ae_max, mae.max()) + + run_ctx.total_ae_min = torch.min( + run_ctx.total_ae_min, (mae + (-1 * z_mask + 1) * torch.tensor(float("inf")).nan_to_num(0.0)).min() + ) # Masked Min operation + + run_ctx.num_of_obs += current_num_of_obs diff --git a/users/rilling/experiments/librispeech/librispeech_glow_asr/serializer.py b/users/rilling/experiments/librispeech/librispeech_glow_asr/serializer.py index 6c60d9de5..1a926dbee 100644 --- a/users/rilling/experiments/librispeech/librispeech_glow_asr/serializer.py +++ b/users/rilling/experiments/librispeech/librispeech_glow_asr/serializer.py @@ -20,6 +20,7 @@ def get_pytorch_serializer_v3( use_custom_engine=False, search=False, prior=False, + invertibility=False, debug=False, search_args: Dict[str, Any]={}, **kwargs @@ -91,6 +92,27 @@ def get_pytorch_serializer_v3( serializer_objects.extend( [forward_step, init_hook, finish_hook] ) + + if invertibility: + forward_step = Import( + code_object_path=package + ".%s.forward_step_invertibility" % network_module, + unhashed_package_root=PACKAGE, + import_as="forward_step", + ) + init_hook = Import( + code_object_path=package + ".%s.forward_init_hook_invertibility" % network_module, + unhashed_package_root=PACKAGE, + import_as="forward_init_hook", + ) + finish_hook = Import( + code_object_path=package + ".%s.forward_finish_hook_invertibility" % network_module, + import_as="forward_finish_hook", + unhashed_package_root=PACKAGE, + ) + serializer_objects.extend( + [forward_step, init_hook, finish_hook] + ) + serializer = TorchCollection( serializer_objects=serializer_objects, make_local_package_copy=not debug, diff --git a/users/rilling/experiments/librispeech/librispeech_glow_asr/training_comparison.ipynb b/users/rilling/experiments/librispeech/librispeech_glow_asr/training_comparison.ipynb index 326039076..efbe738bc 100644 --- a/users/rilling/experiments/librispeech/librispeech_glow_asr/training_comparison.ipynb +++ b/users/rilling/experiments/librispeech/librispeech_glow_asr/training_comparison.ipynb @@ -32,25 +32,24 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "['/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/training', '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/training']\n" + "['/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_200ep_not_silence_preprocessed_not_freezed/training']\n" ] }, { "data": { "text/plain": [ - "({'/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/training': '/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/training': '/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/'},\n", - " 2)" + "({'/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_200ep_not_silence_preprocessed_not_freezed/training': ''},\n", + " 1)" ] }, - "execution_count": 17, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } @@ -61,8 +60,8 @@ " # \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed*/training\",\n", " # \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/librispeech_glow_asr/pytorch/blstm_2x512_d0.2_b300_fs4/asr_dataset/glow_enc192/glow_*eval/not_silence_preprocessed/training\"\n", " # \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed*/training\"\n", - " \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/training\",\n", - " \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/training\",\n", + " # \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/training\",\n", + " # \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/training\",\n", " # \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/librispeech_glow_asr/pytorch/encoding_test/enc768/mean_only/*/training\",\n", " # \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/librispeech_glow_asr/pytorch/encoding_test/enc768/with_sigma/*/training\",\n", " # \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/librispeech_glow_asr/pytorch/encoding_test/enc192/*/training\",\n", @@ -70,6 +69,7 @@ " # \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/tts_architecture/glow_tts/raw_audio/decoder_test/enc768/mean_only/*/training\",\n", " # \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/tts_architecture/glow_tts/raw_audio/decoder_test/enc192/*/training\",\n", " # \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/tts_architecture/glow_tts/raw_audio/decoder_test/enc768/with_sigma/*/training\",\n", + " \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment_before/glow_enc192_200ep_not_silence_preprocessed_not_freezed/training\"\n", "]\n", "lr_files = []\n", "for g in globs:\n", @@ -92,7 +92,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -120,7 +120,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -129,15 +129,13 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/glow_enc192_200ep_dec_0.05_v2/training: 3\n", - "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/glow_not_eval/asr_dataset/spec_augment/glow_enc192_200ep_not_silence_preprocessed/training: 3\n", "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/training: 3\n", "Large Font: False\n", "Setup Interactive Legend\n", @@ -147,18 +145,18 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "d2310e7bf4524ee3b98f4cd89b041032", + "model_id": "9711d7e04e59419f918b17db11cf953f", "version_major": 2, "version_minor": 0 }, - "image/png": "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", + "image/png": "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", "text/html": [ "\n", "
\n", "
\n", " Figure\n", "
\n", - " \n", + " \n", "
\n", " " ], diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training/config.py b/users/rilling/experiments/librispeech/librispeech_joint_training/config.py index 48e1c0dcb..c407b624e 100644 --- a/users/rilling/experiments/librispeech/librispeech_joint_training/config.py +++ b/users/rilling/experiments/librispeech/librispeech_joint_training/config.py @@ -194,3 +194,50 @@ def get_search_config( ) returnn_config = ReturnnConfig(config=config, post_config=post_config, python_epilog=[serializer]) return returnn_config + + +def get_prior_config( + training_datasets: TrainingDataset, + network_module: str, + net_args: Dict[str, Any], + config: Dict[str, Any], + debug: bool = False, + use_custom_engine=False, + target="prior", + **kwargs, +): + """ + Returns the RETURNN config serialized by :class:`ReturnnCommonSerializer` in returnn_common for the ctc_aligner + :param returnn_common_root: returnn_common version to be used, usually output of CloneGitRepositoryJob + :param training_datasets: datasets for training + :param kwargs: arguments to be passed to the network construction + :return: RETURNN training config + """ + + # changing these does not change the hash + post_config = { + } + + base_config = { + ############# + "batch_size": 50000 * 160, + "max_seqs": 60, + ############# + "forward": training_datasets.prior.as_returnn_opts() if target == "prior" else training_datasets.devtrain.as_returnn_opts() + + } + config = {**base_config, **copy.deepcopy(config)} + post_config["backend"] = "torch" + + serializer = get_serializer( + network_module=network_module, + net_args=net_args, + debug=debug, + use_custom_engine=use_custom_engine, + forward=True, + target=target, + ) + returnn_config = ReturnnConfig( + config=config, post_config=post_config, python_epilog=[serializer] + ) + return returnn_config diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training/data.py b/users/rilling/experiments/librispeech/librispeech_joint_training/data.py index 457b6ce9d..7910752e9 100644 --- a/users/rilling/experiments/librispeech/librispeech_joint_training/data.py +++ b/users/rilling/experiments/librispeech/librispeech_joint_training/data.py @@ -72,6 +72,7 @@ class TrainingDataset: train: Dataset cv: Dataset devtrain: Dataset + prior: Dataset datastreams: Dict[str, Datastream] @@ -516,7 +517,17 @@ def build_training_dataset( ) devtrain_dataset = make_meta_dataset(devtrain_zip_dataset, joint_speaker_dataset, train_eow_phonemes_dataset) - return TrainingDataset(train=train_dataset, cv=cv_dataset, devtrain=devtrain_dataset, datastreams=datastreams) + prior_zip_dataset = OggZipDataset( + files=train_ogg, + audio_options=training_audio_opts, + target_options=train_phoneme_datastream_tts.as_returnn_targets_opts(), + partition_epoch=1, + seq_ordering="sorted_reverse", + additional_options=additional_opts, + ) + prior_dataset = make_meta_dataset(prior_zip_dataset, joint_speaker_dataset, train_eow_phonemes_dataset) + + return TrainingDataset(train=train_dataset, cv=cv_dataset, devtrain=devtrain_dataset, datastreams=datastreams, prior=prior_dataset) @lru_cache() diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training/experiments.py b/users/rilling/experiments/librispeech/librispeech_joint_training/experiments.py index a4d523046..3b116ab20 100644 --- a/users/rilling/experiments/librispeech/librispeech_joint_training/experiments.py +++ b/users/rilling/experiments/librispeech/librispeech_joint_training/experiments.py @@ -15,8 +15,8 @@ get_arpa_lm, get_text_lexicon, ) -from .config import get_training_config, get_extract_durations_forward__config, get_forward_config, get_search_config -from .pipeline import training, forward, search +from .config import get_training_config, get_extract_durations_forward__config, get_forward_config, get_search_config, get_prior_config +from .pipeline import training, forward, search, compute_prior from i6_experiments.users.rilling.experiments.librispeech.common.tts_eval import tts_eval @@ -24,6 +24,7 @@ from .pytorch_networks.shared.i6modelsV1_VGG4LayerActFrontendV1_v4_cfg import ( SpecaugConfig, ModelConfig, + ModelConfigV2, VGG4LayerActFrontendV1Config_mod, TextEncoderConfig, FlowDecoderConfig, @@ -63,10 +64,14 @@ def run_exp( eval_tts=False, tts_eval_datasets=None, eval_invertibility=False, + eval_asr_invertibility=False, large_gpu_training=False, + with_prior=False, ): exp = {} + with_prior = with_prior or ("prior_scale" in search_args and search_args["prior_scale"] != 0) + if given_train_job_for_forward is None: training_config = get_training_config( training_datasets=dataset, @@ -90,6 +95,18 @@ def run_exp( train_job = given_train_job_for_forward exp["train_job"] = train_job + if with_prior: + returnn_config = get_prior_config(training_datasets=dataset, **args) + prior_file = compute_prior( + prefix + name, + returnn_config, + checkpoint=train_job.out_checkpoints[num_epochs], + returnn_exe=RETURNN_PYTORCH_ASR_SEARCH_EXE, + returnn_root=MINI_RETURNN_ROOT, + ) + tk.register_output(prefix + name + "/prior.txt", prior_file) + search_args["prior_file"] = prior_file + if extract_x_vector: forward_x_vector_config = get_forward_config( forward_dataset=dataset, **args, forward_args=forward_args, target="xvector", train_data=True @@ -115,22 +132,12 @@ def run_exp( ), ) - # forward_config_gl2 = get_forward_config( - # forward_dataset=dataset, - # **{**args, **{"config": {"batch_size": 50 * 16000}}}, - # forward_args={ - # **forward_args, - # "gl_net_checkpoint": gl_checkpoint["checkpoint"], - # "gl_net_config": gl_checkpoint["config"], - # }, - # target="corpus_gl", - # cv_data=True, - # ) - if eval_invertibility: - forward_config_invert = get_forward_config( - forward_dataset=dataset, **{**args, **{"config": {"batch_size": 50 * 16000}}}, target="invertibility" - ) + forward_config_invert = get_prior_config(dataset, target="invertibility", **args) + + if eval_asr_invertibility: + # Only used to check invertibility for models using two forward passes + forward_config_invert = get_prior_config(dataset, target="asr_invertibility", **args) if asr_search: search_config = get_search_config( @@ -174,18 +181,6 @@ def run_exp( nisqa_confidence=True, ) - # forward_job_gl = tts_eval( - # checkpoint=train_job.out_checkpoints[num_epochs], - # prefix_name=prefix + name, - # returnn_config=forward_config_gl2, - # returnn_exe=RETURNN_PYTORCH_EXE, - # returnn_root=MINI_RETURNN_ROOT, - # vocoder="gl", - # nisqa_eval=True, - # swer_eval=True, - # swer_eval_corpus_key="train-clean-100", - # ) - if eval_invertibility: forward_job = forward( checkpoint=train_job.out_checkpoints[num_epochs], @@ -198,6 +193,18 @@ def run_exp( exp["invertibility_job"] = forward_job + if eval_asr_invertibility: + forward_job = forward( + checkpoint=train_job.out_checkpoints[num_epochs], + config=forward_config_invert, + returnn_exe=RETURNN_PYTORCH_EXE, + returnn_root=MINI_RETURNN_ROOT, + prefix=prefix + name, + target="asr_invertibility", + ) + + exp["asr_invertibility_job"] = forward_job + if asr_search: search( prefix + name + "/search", @@ -302,6 +309,11 @@ def run_exp( ) asr_test_datasets2["dev-clean"] = build_test_dataset(librispeech_key="train-clean-100", dataset_key="dev-clean") + asr_test_datasets3 = copy.deepcopy(asr_test_datasets) + asr_test_datasets3["dev-clean"] = build_test_dataset(librispeech_key="train-clean-100", dataset_key="dev-clean") + asr_test_datasets3["test-clean"] = build_test_dataset(librispeech_key="train-clean-100", dataset_key="test-clean") + asr_test_datasets3["test-other"] = build_test_dataset(librispeech_key="train-clean-100", dataset_key="test-other") + tts_forward_datasets = {} tts_forward_datasets_xvectors = {} @@ -433,6 +445,9 @@ def run_exp( n_speakers=speaker_datastream.vocab_size, ) + model_config_strong_conformer_weak_specaug = copy.deepcopy(model_config_strong_conformer) + model_config_strong_conformer_weak_specaug.specaug_config = specaug_config + net_module = "glowTTS_ASR_conformer_x_vector" train_args = { @@ -650,18 +665,23 @@ def run_exp( search_args=default_search_args, eval_tts=True, tts_eval_datasets=tts_forward_datasets_xvectors, + eval_invertibility=True, ) for lm in [2.0, 2.5, 3.0, 3.5, 4.0, 4.5]: - exp_dict = run_exp( - net_module + f"/tuning/lm_{lm}", - train_args_v2, - training_datasets, - asr_test_datasets, - 250, - forward_args=forward_args, - search_args={**default_search_args, **{"lm_weight": lm}}, - ) + for ps in [0, 0.3, 0.5]: + additional_search_args = {"lm_weight": lm} if ps == 0 else {"lm_weight": lm, "prior_scale": ps} + suffix = f"/tuning/lm_{lm}" if ps == 0 else f"/tuning/lm_{lm}_ps_{ps}" + + exp_dict = run_exp( + net_module + suffix, + train_args_v2, + training_datasets, + asr_test_datasets, + 250, + forward_args=forward_args, + search_args={**default_search_args, **additional_search_args}, + ) exp_dict = run_exp( net_module + "_ctc_scale_0.1", train_args_v2, @@ -673,18 +693,23 @@ def run_exp( search_args=default_search_args, eval_tts=True, tts_eval_datasets=tts_forward_datasets_xvectors, + eval_invertibility=True ) for lm in [2.0, 2.5, 3.0, 3.5, 4.0, 4.5]: - exp_dict = run_exp( - net_module + f"_ctc_scale_0.1/tuning/lm_{lm}", - train_args_v2, - training_datasets, - asr_test_datasets, - 250, - training_args={"ctc_scale": 0.1}, - forward_args=forward_args, - search_args={**default_search_args, **{"lm_weight": lm}}, - ) + for ps in [0, 0.3, 0.5]: + additional_search_args = {"lm_weight": lm} if ps == 0 else {"lm_weight": lm, "prior_scale": ps} + suffix = f"_ctc_scale_0.1/tuning/lm_{lm}" if ps == 0 else f"_ctc_scale_0.1/tuning/lm_{lm}_ps_{ps}" + + exp_dict = run_exp( + net_module + suffix, + train_args_v2, + training_datasets, + asr_test_datasets, + 250, + training_args={"ctc_scale": 0.1}, + forward_args=forward_args, + search_args={**default_search_args, **additional_search_args}, + ) train_args_spec_augment_v2 = copy.deepcopy(train_args_v2) train_args_spec_augment_v2["net_args"]["model_config"]["specaug_config"] = asdict(specaug_config) @@ -701,15 +726,18 @@ def run_exp( ) for lm in [2.0, 2.5, 3.0, 3.5, 4.0, 4.5]: - exp_dict = run_exp( - net_module + f"_spec_augment/tuning/lm_{lm}", - train_args_spec_augment_v2, - training_datasets, - asr_test_datasets, - 250, - forward_args=forward_args, - search_args={**default_search_args, **{"lm_weight": lm}}, - ) + for ps in [0, 0.3, 0.5]: + additional_search_args = {"lm_weight": lm} if ps == 0 else {"lm_weight": lm, "prior_scale": ps} + suffix = f"_spec_augment/tuning/lm_{lm}" if ps == 0 else f"_spec_augment/tuning/lm_{lm}_ps_{ps}" + exp_dict = run_exp( + net_module + suffix, + train_args_spec_augment_v2, + training_datasets, + asr_test_datasets, + 250, + forward_args=forward_args, + search_args={**default_search_args, **additional_search_args}, + ) exp_dict = run_exp( net_module + "_spec_augment_ctc_scale_0.1", @@ -725,16 +753,19 @@ def run_exp( ) for lm in [2.0, 2.5, 3.0, 3.5, 4.0, 4.5]: - exp_dict = run_exp( - net_module + f"_spec_augment_ctc_scale_0.1/tuning/lm_{lm}", - train_args_spec_augment_v2, - training_datasets, - asr_test_datasets, - 250, - training_args={"ctc_scale": 0.1}, - forward_args=forward_args, - search_args={**default_search_args, **{"lm_weight": lm}}, - ) + for ps in [0, 0.3, 0.5]: + additional_search_args = {"lm_weight": lm} if ps == 0 else {"lm_weight": lm, "prior_scale": ps} + suffix = f"_spec_augment_ctc_scale_0.1/tuning/lm_{lm}" if ps == 0 else f"_spec_augment_ctc_scale_0.1/tuning/lm_{lm}_ps_{ps}" + exp_dict = run_exp( + net_module + suffix, + train_args_spec_augment_v2, + training_datasets, + asr_test_datasets, + 250, + training_args={"ctc_scale": 0.1}, + forward_args=forward_args, + search_args={**default_search_args, **additional_search_args}, + ) train_args_control = copy.deepcopy(train_args) net_module = "glowTTS_ASR_conformer_x_vector_control" @@ -985,26 +1016,31 @@ def run_exp( ) for lm in [2.0, 2.5, 3.0, 3.5, 4.0, 4.5]: - exp_dict = run_exp( - net_module + f"/tuning/lm_{lm}", - train_args_two_forward_v2, - training_datasets, - asr_test_datasets, - 250, - forward_args=forward_args, - search_args={**default_search_args, **{"lm_weight": lm}}, - ) + for ps in [0, 0.3, 0.5]: + additional_search_args = {"lm_weight": lm} if ps == 0 else {"lm_weight": lm, "prior_scale": ps} + suffix = f"/tuning/lm_{lm}" if ps == 0 else f"/tuning/lm_{lm}_ps_{ps}" + exp_dict = run_exp( + net_module + suffix, + train_args_two_forward_v2, + training_datasets, + asr_test_datasets, + 250, + forward_args=forward_args, + search_args={**default_search_args, **additional_search_args}, + ) - exp_dict = run_exp( - net_module + f"_ctc_scale_0.1/tuning/lm_{lm}", - train_args_two_forward_v2, - training_datasets, - asr_test_datasets, - 250, - training_args={"ctc_scale": 0.1}, - forward_args=forward_args, - search_args={**default_search_args, **{"lm_weight": lm}}, - ) + suffix = f"_ctc_scale_0.1/tuning/lm_{lm}" if ps == 0 else f"_ctc_scale_0.1/tuning/lm_{lm}_ps_{ps}" + + exp_dict = run_exp( + net_module + suffix, + train_args_two_forward_v2, + training_datasets, + asr_test_datasets, + 250, + training_args={"ctc_scale": 0.1}, + forward_args=forward_args, + search_args={**default_search_args, **additional_search_args}, + ) net_module = "glowTTS_ASR_conformer_two_forward_pass" train_args_two_forward_no_xvector = copy.deepcopy(train_args_spec_augment) @@ -1023,6 +1059,7 @@ def run_exp( eval_tts=True, tts_eval_datasets=tts_forward_datasets, eval_invertibility=True, + eval_asr_invertibility=True, ) exp_dict = run_exp( net_module + "_ctc_scale_0.1", @@ -1036,28 +1073,57 @@ def run_exp( eval_tts=True, tts_eval_datasets=tts_forward_datasets, eval_invertibility=True, + eval_asr_invertibility=True, ) for lm in [2.0, 2.5, 3.0, 3.5, 4.0, 4.5]: - exp_dict = run_exp( - net_module + f"/tuning/lm_{lm}", - train_args_two_forward_no_xvector, - training_datasets, - asr_test_datasets, - 250, - forward_args=forward_args, - search_args={**default_search_args, **{"lm_weight": lm}}, - ) - exp_dict = run_exp( - net_module + f"_ctc_scale_0.1/tuning/lm_{lm}", - train_args_two_forward_no_xvector, - training_datasets, - asr_test_datasets, - 250, - training_args={"ctc_scale": 0.1}, - forward_args=forward_args, - search_args={**default_search_args, **{"lm_weight": lm}}, - ) + for ps in [0, 0.3, 0.5]: + additional_search_args = {"lm_weight": lm, "prior_scale": ps} if ps != 0 else {"lm_weight": lm} + exp_dict = run_exp( + net_module + f"/tuning/lm_{lm}_ps_{ps}", + train_args_two_forward_no_xvector, + training_datasets, + asr_test_datasets, + 250, + forward_args=forward_args, + search_args={**default_search_args, **additional_search_args}, + with_prior=(ps!=0) + ) + exp_dict = run_exp( + net_module + f"_ctc_scale_0.1/tuning/lm_{lm}_ps_{ps}", + train_args_two_forward_no_xvector, + training_datasets, + asr_test_datasets, + 250, + training_args={"ctc_scale": 0.1}, + forward_args=forward_args, + search_args={**default_search_args, **additional_search_args}, + with_prior=(ps!=0) + ) + + tuned_search_args = {"lm_weight": 3.0, "prior_scale": 0.5} + exp_dict = run_exp( + net_module + f"/tuned", + train_args_two_forward_no_xvector, + training_datasets, + asr_test_datasets3, + 250, + forward_args=forward_args, + search_args={**default_search_args, **tuned_search_args}, + with_prior=(ps!=0) + ) + tuned_search_args = {"lm_weight": 2.5, "prior_scale": 0.5} + exp_dict = run_exp( + net_module + f"_ctc_scale_0.1/tuned", + train_args_two_forward_no_xvector, + training_datasets, + asr_test_datasets3, + 250, + training_args={"ctc_scale": 0.1}, + forward_args=forward_args, + search_args={**default_search_args, **tuned_search_args}, + with_prior=(ps!=0) + ) train_args_two_forward_no_xvector_strong_conformer = copy.deepcopy(train_args_two_forward_no_xvector) train_args_two_forward_no_xvector_strong_conformer["net_args"]["model_config"] = asdict(model_config_strong_conformer) @@ -1076,6 +1142,111 @@ def run_exp( large_gpu_training=True ) + exp_dict = run_exp( + net_module + "_strong_conformer_ctc_scale_1.0", + train_args_two_forward_no_xvector_strong_conformer, + training_datasets, + asr_test_datasets, + 250, + training_args={"ctc_scale": 1.0}, + forward_args=forward_args, + search_args=default_search_args, + eval_tts=True, + tts_eval_datasets=tts_forward_datasets, + large_gpu_training=True + ) + + train_args_two_forward_no_xvector_strong_conformer_weak_specaug = copy.deepcopy(train_args_two_forward_no_xvector_strong_conformer) + train_args_two_forward_no_xvector_strong_conformer_weak_specaug["net_args"]["model_config"] = asdict(model_config_strong_conformer_weak_specaug) + exp_dict = run_exp( + net_module + "_strong_conformer_weak_specaug_ctc_scale_0.1", + train_args_two_forward_no_xvector_strong_conformer_weak_specaug, + training_datasets, + asr_test_datasets, + 250, + training_args={"ctc_scale": 0.1}, + forward_args=forward_args, + search_args=default_search_args, + eval_tts=True, + tts_eval_datasets=tts_forward_datasets, + large_gpu_training=True + ) + + exp_dict = run_exp( + net_module + "_strong_conformer_weak_specaug_ctc_scale_1.0", + train_args_two_forward_no_xvector_strong_conformer_weak_specaug, + training_datasets, + asr_test_datasets, + 250, + training_args={"ctc_scale": 1.0}, + forward_args=forward_args, + search_args=default_search_args, + eval_tts=True, + tts_eval_datasets=tts_forward_datasets, + large_gpu_training=True + ) + + for lm in [2.0, 2.5, 3.0, 3.5, 4.0, 4.5]: + for ps in [0, 0.3, 0.5]: + additional_search_args = {"lm_weight": lm, "prior_scale": ps} if ps != 0 else {"lm_weight": lm} + exp_dict = run_exp( + net_module + f"_strong_conformer_weak_specaug_ctc_scale_0.1/tuning/lm_{lm}_ps_{ps}", + train_args_two_forward_no_xvector_strong_conformer_weak_specaug, + training_datasets, + asr_test_datasets, + 250, + training_args={"ctc_scale": 0.1}, + forward_args=forward_args, + search_args={**default_search_args, **additional_search_args}, + eval_tts=True, + tts_eval_datasets=tts_forward_datasets, + large_gpu_training=True, + ) + + exp_dict = run_exp( + net_module + f"_strong_conformer_weak_specaug_ctc_scale_1.0/tuning/lm_{lm}_ps_{ps}", + train_args_two_forward_no_xvector_strong_conformer_weak_specaug, + training_datasets, + asr_test_datasets, + 250, + training_args={"ctc_scale": 1.0}, + forward_args=forward_args, + search_args={**default_search_args, **additional_search_args}, + eval_tts=True, + tts_eval_datasets=tts_forward_datasets, + large_gpu_training=True, + ) + + tuned_search_args = {"lm_weight": 3.5, "prior_scale": 0.3} + exp_dict = run_exp( + net_module + f"_strong_conformer_weak_specaug_ctc_scale_0.1/tuned", + train_args_two_forward_no_xvector_strong_conformer_weak_specaug, + training_datasets, + asr_test_datasets3, + 250, + training_args={"ctc_scale": 0.1}, + forward_args=forward_args, + search_args={**default_search_args, **tuned_search_args}, + eval_tts=True, + tts_eval_datasets=tts_forward_datasets, + large_gpu_training=True, + ) + + tuned_search_args = {"lm_weight": 4.0, "prior_scale": 0.5} + exp_dict = run_exp( + net_module + f"_strong_conformer_weak_specaug_ctc_scale_1.0/tuned", + train_args_two_forward_no_xvector_strong_conformer_weak_specaug, + training_datasets, + asr_test_datasets3, + 250, + training_args={"ctc_scale": 1.0}, + forward_args=forward_args, + search_args={**default_search_args, **tuned_search_args}, + eval_tts=True, + tts_eval_datasets=tts_forward_datasets, + large_gpu_training=True, + ) + train_args_conformer_only = copy.deepcopy(train_args) train_args_conformer_only["net_args"]["model_config"] = asdict(model_config) net_module = "only_conformer" @@ -1093,16 +1264,19 @@ def run_exp( ) for lm in [2.0, 2.5, 3.0, 3.5, 4.0, 4.5]: - exp_dict = run_exp( - net_module + f"/tuning/lm_{lm}", - train_args_conformer_only, - training_datasets, - asr_test_datasets, - 250, - forward_args=forward_args, - search_args={**default_search_args, **{"lm_weight": lm}}, - tts_forward=False, - ) + for ps in [0, 0.3, 0.5]: + additional_search_args = {"lm_weight": lm, "prior_scale": ps} if ps != 0 else {"lm_weight": lm} + exp_dict = run_exp( + net_module + f"/tuning/lm_{lm}_ps_{ps}", + train_args_conformer_only, + training_datasets, + asr_test_datasets, + 250, + forward_args=forward_args, + search_args={**default_search_args, **additional_search_args}, + tts_forward=False, + with_prior=(ps!=0) + ) train_args_conformer_only_spec_augment = copy.deepcopy(train_args_spec_augment) train_args_conformer_only_spec_augment["network_module"] = net_module @@ -1119,16 +1293,31 @@ def run_exp( ) for lm in [2.0, 2.5, 3.0, 3.5, 4.0, 4.5]: - exp_dict = run_exp( - net_module + f"_spec_augment/tuning/lm_{lm}", - train_args_conformer_only_spec_augment, - training_datasets, - asr_test_datasets, - 250, - forward_args=forward_args, - search_args={**default_search_args, **{"lm_weight": lm}}, - tts_forward=False, - ) + for ps in [0, 0.3, 0.5]: + additional_search_args = {"lm_weight": lm, "prior_scale": ps} if ps != 0 else {"lm_weight": lm} + suffix = f"_spec_augment/tuning/lm_{lm}_ps_{ps}" if ps != 0 else f"_spec_augment/tuning/lm_{lm}" + exp_dict = run_exp( + net_module + suffix, + train_args_conformer_only_spec_augment, + training_datasets, + asr_test_datasets, + 250, + forward_args=forward_args, + search_args={**default_search_args, **additional_search_args}, + tts_forward=False, + ) + + tuned_search_args = {"lm_weight": 2.5, "prior_scale": 0.5} + exp_dict = run_exp( + net_module + "_spec_augment/tuned", + train_args_conformer_only_spec_augment, + training_datasets, + asr_test_datasets3, + 250, + forward_args=forward_args, + search_args={**default_search_args, **tuned_search_args}, + tts_forward=False, + ) exp_dict = run_exp( net_module + "_spec_augment_tts_train_segments", @@ -1181,16 +1370,19 @@ def run_exp( ) for lm in [2.0, 2.5, 3.0, 3.5, 4.0, 4.5]: - exp_dict = run_exp( - net_module + f"/tuning/lm_{lm}", - train_args_glow_conformer, - training_datasets, - asr_test_datasets, - 250, - forward_args=forward_args, - search_args={**default_search_args, **{"lm_weight": lm}}, - tts_forward=False, - ) + for ps in [0, 0.3, 0.5]: + additional_search_args = {"lm_weight": lm} if ps == 0 else {"lm_weight": lm, "prior_scale": ps} + suffix = f"/tuning/lm_{lm}" if ps == 0 else f"/tuning/lm_{lm}_ps_{ps}" + exp_dict = run_exp( + net_module + suffix, + train_args_glow_conformer, + training_datasets, + asr_test_datasets, + 250, + forward_args=forward_args, + search_args={**default_search_args, **additional_search_args}, + tts_forward=False, + ) net_module = "glow_ASR_conformer_specaugment_before" train_args_glow_conformer_specaugment_before = copy.deepcopy(train_args_glow_conformer) @@ -1208,16 +1400,19 @@ def run_exp( ) for lm in [2.0, 2.5, 3.0, 3.5, 4.0, 4.5]: - exp_dict = run_exp( - net_module + f"/tuning/lm_{lm}", - train_args_glow_conformer_specaugment_before, - training_datasets, - asr_test_datasets, - 250, - forward_args=forward_args, - search_args={**default_search_args, **{"lm_weight": lm}}, - tts_forward=False, - ) + for ps in [0, 0.3, 0.5]: + additional_search_args = {"lm_weight": lm} if ps == 0 else {"lm_weight": lm, "prior_scale": ps} + suffix = f"/tuning/lm_{lm}" if ps == 0 else f"/tuning/lm_{lm}_ps_{ps}" + exp_dict = run_exp( + net_module + suffix, + train_args_glow_conformer_specaugment_before, + training_datasets, + asr_test_datasets, + 250, + forward_args=forward_args, + search_args={**default_search_args, **additional_search_args}, + tts_forward=False, + ) exp_dict = run_exp( net_module + "_tts_train_segments", @@ -1310,16 +1505,19 @@ def run_exp( ) for lm in [2.0, 2.5, 3.0, 3.5, 4.0, 4.5]: - exp_dict = run_exp( - net_module + f"/tuning/lm_{lm}", - train_args_glow_conformer_specaugment_before_x_vector_v2, - training_datasets, - asr_test_datasets, - 250, - forward_args=forward_args, - search_args={**default_search_args, **{"lm_weight": lm}}, - tts_forward=False, - ) + for ps in [0, 0.3, 0.5]: + additional_search_args = {"lm_weight": lm} if ps == 0 else {"lm_weight": lm, "prior_scale": ps} + suffix = f"/tuning/lm_{lm}" if ps == 0 else f"/tuning/lm_{lm}_ps_{ps}" + exp_dict = run_exp( + net_module + suffix, + train_args_glow_conformer_specaugment_before_x_vector_v2, + training_datasets, + asr_test_datasets, + 250, + forward_args=forward_args, + search_args={**default_search_args, **additional_search_args}, + tts_forward=False, + ) net_module = "glow_ASR_conformer_specaugment_before_xvector_v3" train_args_glow_conformer_specaugment_before_x_vector_v3 = copy.deepcopy( @@ -1391,27 +1589,32 @@ def run_exp( ) for lm in [2.0, 2.5, 3.0, 3.5, 4.0, 4.5]: - exp_dict = run_exp( - train_args_glow_conformer_xvector["network_module"] + f"grad_clip_10/tuning/lm_{lm}", - train_args_glow_conformer_xvector, - training_datasets, - asr_test_datasets, - 250, - forward_args=forward_args, - search_args={**default_search_args, **{"lm_weight": lm}}, - tts_forward=False, - ) + for ps in [0, 0.3, 0.5]: + additional_search_args = {"lm_weight": lm} if ps == 0 else {"lm_weight": lm, "prior_scale": ps} + suffix = f"grad_clip_10/tuning/lm_{lm}" if ps == 0 else f"grad_clip_10/tuning/lm_{lm}_ps_{ps}" + exp_dict = run_exp( + train_args_glow_conformer_xvector["network_module"] + suffix, + train_args_glow_conformer_xvector, + training_datasets, + asr_test_datasets, + 250, + forward_args=forward_args, + search_args={**default_search_args, **additional_search_args}, + tts_forward=False, + ) - exp_dict = run_exp( - train_args_glow_conformer_xvector_eval["network_module"] + f"/tuning/lm_{lm}", - train_args_glow_conformer_xvector_eval, - training_datasets, - asr_test_datasets, - 250, - forward_args=forward_args, - search_args={**default_search_args, **{"lm_weight": lm}}, - tts_forward=False, - ) + suffix = f"/tuning/lm_{lm}" if ps == 0 else f"/tuning/lm_{lm}_ps_{ps}" + + exp_dict = run_exp( + train_args_glow_conformer_xvector_eval["network_module"] + suffix, + train_args_glow_conformer_xvector_eval, + training_datasets, + asr_test_datasets, + 250, + forward_args=forward_args, + search_args={**default_search_args, **additional_search_args}, + tts_forward=False, + ) train_args_glow_conformer_specaug_before_ddi_actnorm = copy.deepcopy(train_args_glow_conformer_specaugment_before) net_module = "glow_ASR_conformer_specaugment_before_ddi_actnorm" @@ -1500,4 +1703,68 @@ def run_exp( search_args=default_search_args, tts_forward=False, ) + # ================== BLSTM ================= + model_config_blstm = ModelConfigV2( + specaug_config=None, + decoder_config=flow_decoder_config, + text_encoder_config=text_encoder_config, + specauc_start_epoch=1, + label_target_size=vocab_size_without_blank_asr, + subsampling_factor=4, + blstm_layers=2, + blstm_hidden_dim=512, + blstm_dropout=0.2, + out_channels=80, + gin_channels=256, + n_speakers=speaker_datastream.vocab_size, + ) + + net_module="glowTTS_ASR_blstm_x_vector" + train_args_blstm = copy.deepcopy(train_args) + train_args_blstm["net_args"]["model_config"] = asdict(model_config_blstm) + train_args_blstm["network_module"] = net_module + exp_dict = run_exp( + net_module, + train_args_blstm, + training_datasets, + asr_test_datasets, + 250, + forward_args=forward_args, + search_args=default_search_args, + eval_tts=True, + tts_forward=False, + tts_eval_datasets=tts_forward_datasets_xvectors, + ) + + for lm_w in [2.0, 2.5, 3.0, 3.5, 4.0, 4.5]: + additional_search_args = {"lm_weight": lm_w} + exp_dict = run_exp( + net_module + f"/tuning/lm_{lm_w}", + train_args_blstm, + training_datasets, + asr_test_datasets, + 250, + forward_args=forward_args, + search_args={**default_search_args, **additional_search_args}, + eval_tts=True, + tts_forward=False, + tts_eval_datasets=tts_forward_datasets_xvectors, + ) + + model_config_blstm_specaug = copy.deepcopy(model_config_blstm) + model_config_blstm_specaug.specaug_config = specaug_config + train_args_blstm["net_args"]["model_config"] = asdict(model_config_blstm_specaug) + exp_dict = run_exp( + net_module + "_specaug", + train_args_blstm, + training_datasets, + asr_test_datasets, + 250, + forward_args=forward_args, + search_args=default_search_args, + eval_tts=True, + tts_forward=False, + tts_eval_datasets=tts_forward_datasets_xvectors, + ) + return experiments diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training/pipeline.py b/users/rilling/experiments/librispeech/librispeech_joint_training/pipeline.py index 1f85c074e..0ba7a3b33 100644 --- a/users/rilling/experiments/librispeech/librispeech_joint_training/pipeline.py +++ b/users/rilling/experiments/librispeech/librispeech_joint_training/pipeline.py @@ -199,6 +199,40 @@ def search(prefix_name, returnn_config, checkpoint, test_dataset_tuples, returnn return format_string_report, values_report +@tk.block() +def compute_prior( + prefix_name, + returnn_config, + checkpoint, + returnn_exe, + returnn_root, + mem_rqmt=8, +): + """ + Run search for a specific test dataset + + :param str prefix_name: + :param ReturnnConfig returnn_config: + :param Checkpoint checkpoint: + :param Path returnn_exe: + :param Path returnn_root: + """ + search_job = ReturnnForwardJobV2( + model_checkpoint=checkpoint, + returnn_config=returnn_config, + log_verbosity=5, + mem_rqmt=mem_rqmt, + time_rqmt=1, + device="gpu", + cpu_rqmt=4, + returnn_python_exe=returnn_exe, + returnn_root=returnn_root, + output_files=["prior.txt"], + ) + search_job.add_alias(prefix_name + "/prior_job") + return search_job.out_files["prior.txt"] + + # def evaluate_invertibility(name, checkpoint, forward_config, returnn_root, returnn_exe): # forward_job = forward( diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/glowTTS_ASR_blstm_two_forward_pass.py b/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/glowTTS_ASR_blstm_two_forward_pass.py new file mode 100644 index 000000000..5e3a588e3 --- /dev/null +++ b/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/glowTTS_ASR_blstm_two_forward_pass.py @@ -0,0 +1,632 @@ +""" +Trying to make the aligner more AppTek-Like + +Extended weight init code +""" + +from dataclasses import dataclass +import torch +import numpy as np +from torch import nn +import multiprocessing +from librosa import filters +import sys +import time +from typing import Any, Dict, Optional, Tuple, Union +import math +import os +import soundfile + +from torchaudio.functional import mask_along_axis + +from i6_models.parts.blstm import BlstmEncoderV1, BlstmEncoderV1Config + + +from i6_models.parts.conformer.norm import LayerNormNC +from i6_models.assemblies.conformer.conformer_v1 import ConformerEncoderV1Config +from i6_models.assemblies.conformer.conformer_v1 import ConformerBlockV1Config, ConformerEncoderV1 +from i6_models.config import ModuleFactoryV1 +from i6_models.parts.frontend.vgg_act import VGG4LayerActFrontendV1, VGG4LayerActFrontendV1Config + +from i6_models.parts.conformer.convolution import ConformerConvolutionV1Config +from i6_models.parts.conformer.feedforward import ConformerPositionwiseFeedForwardV1Config +from i6_models.parts.conformer.mhsa import ConformerMHSAV1Config +from i6_models.primitives.specaugment import specaugment_v1_by_length +from i6_models.primitives.feature_extraction import LogMelFeatureExtractionV1, LogMelFeatureExtractionV1Config + +from returnn.torch.context import get_run_ctx + +from .shared.i6modelsV1_VGG4LayerActFrontendV1_v4_cfg import ( + SpecaugConfig, + VGG4LayerActFrontendV1Config_mod, + ModelConfigV2, + FlowDecoderConfig, + TextEncoderConfig, +) + +from .shared.configs import DbMelFeatureExtractionConfig +from .shared.feature_extraction import DbMelFeatureExtraction +from .shared.spec_augment import apply_spec_aug +from .shared.mask import mask_tensor + +from .shared import modules +from .shared import commons +from .shared import attentions +from .monotonic_align import maximum_path + +from .shared.forward import prior_init_hook, prior_step, prior_finish_hook + +from .shared.eval_forward import * +from .shared.eval_invertibility import * + +from IPython import embed + +class DurationPredictor(nn.Module): + """ + Duration Predictor module, trained using calculated durations coming from monotonic alignment search + """ + + def __init__(self, in_channels, filter_channels, filter_size, p_dropout): + super().__init__() + + self.in_channels = in_channels + self.filter_channels = filter_channels + self.filter_size = filter_size + self.p_dropout = p_dropout + + self.convs = nn.Sequential( + modules.Conv1DBlock( + in_size=self.in_channels, + out_size=self.filter_channels, + filter_size=self.filter_size, + p_dropout=p_dropout, + ), + modules.Conv1DBlock( + in_size=self.filter_channels, + out_size=self.filter_channels, + filter_size=self.filter_size, + p_dropout=p_dropout, + ), + ) + self.proj = nn.Conv1d(in_channels=self.filter_channels, out_channels=1, kernel_size=1) + + def forward(self, x, x_mask): + x_with_mask = (x, x_mask) + (x, x_mask) = self.convs(x_with_mask) + x = self.proj(x * x_mask) + return x + + +class FlowDecoder(nn.Module): + def __init__(self, cfg: FlowDecoderConfig, in_channels, gin_channels): + """Flow-based decoder model + + Args: + in_channels (int): Number of incoming channels + hidden_channels (int): Number of hidden channels + kernel_size (int): Kernel Size for convolutions in coupling blocks + dilation_rate (float): Dilation Rate to define dilation in convolutions of coupling block + n_blocks (int): Number of coupling blocks + n_layers (int): Number of layers in CNN of the coupling blocks + p_dropout (float, optional): Dropout probability for CNN in coupling blocks. Defaults to 0.. + n_split (int, optional): Number of splits for the 1x1 convolution for flows in the decoder. Defaults to 4. + n_sqz (int, optional): Squeeze. Defaults to 1. + sigmoid_scale (bool, optional): Boolean to define if log probs in coupling layers should be rescaled using sigmoid. Defaults to False. + gin_channels (int, optional): Number of speaker embedding channels. Defaults to 0. + """ + super().__init__() + self.cfg = cfg + + self.flows = nn.ModuleList() + + for _ in range(self.cfg.n_blocks): + self.flows.append(modules.ActNorm(channels=in_channels * self.cfg.n_sqz)) + self.flows.append(modules.InvConvNear(channels=in_channels * self.cfg.n_sqz, n_split=self.cfg.n_split)) + self.flows.append( + attentions.CouplingBlock( + in_channels * self.cfg.n_sqz, + self.cfg.hidden_channels, + kernel_size=self.cfg.kernel_size, + dilation_rate=self.cfg.dilation_rate, + n_layers=self.cfg.n_layers, + gin_channels=gin_channels, + p_dropout=self.cfg.p_dropout, + sigmoid_scale=self.cfg.sigmoid_scale, + ) + ) + + def forward(self, x, x_mask, g=None, reverse=False): + if not reverse: + flows = self.flows + logdet_tot = 0 + else: + flows = reversed(self.flows) + logdet_tot = None + + if self.cfg.n_sqz > 1: + x, x_mask = commons.channel_squeeze(x, x_mask, self.cfg.n_sqz) + for f in flows: + if not reverse: + x, logdet = f(x, x_mask, g=g, reverse=reverse) + logdet_tot += logdet + else: + x, logdet = f(x, x_mask, g=g, reverse=reverse) + if self.cfg.n_sqz > 1: + x, x_mask = commons.channel_unsqueeze(x, x_mask, self.cfg.n_sqz) + return x, logdet_tot + + def store_inverse(self): + for f in self.flows: + f.store_inverse() + +class TextEncoder(nn.Module): + """ + Text Encoder model + """ + + def __init__(self, cfg: TextEncoderConfig, out_channels, gin_channels): + """Text Encoder Model based on Multi-Head Self-Attention combined with FF-CCNs + + Args: + n_vocab (int): Size of vocabulary for embeddings + out_channels (int): Number of output channels + hidden_channels (int): Number of hidden channels + filter_channels (int): Number of filter channels + filter_channels_dp (int): Number of filter channels for duration predictor + n_heads (int): Number of heads in encoder's Multi-Head Attention + n_layers (int): Number of layers consisting of Multi-Head Attention and CNNs in encoder + kernel_size (int): Kernel Size for CNNs in encoder layers + p_dropout (float): Dropout probability for both encoder and duration predictor + window_size (int, optional): Window size in Multi-Head Self-Attention for encoder. Defaults to None. + block_length (_type_, optional): Block length for optional block masking in Multi-Head Attention for encoder. Defaults to None. + mean_only (bool, optional): Boolean to only project text encodings to mean values instead of mean and std. Defaults to False. + prenet (bool, optional): Boolean to add ConvReluNorm prenet before encoder . Defaults to False. + gin_channels (int, optional): Number of channels for speaker condition. Defaults to 0. + """ + super().__init__() + self.cfg = cfg + + self.emb = nn.Embedding(self.cfg.n_vocab, self.cfg.hidden_channels) + nn.init.normal_(self.emb.weight, 0.0, self.cfg.hidden_channels**-0.5) + + if self.cfg.prenet: + self.pre = modules.ConvReluNorm( + self.cfg.hidden_channels, + self.cfg.hidden_channels, + self.cfg.hidden_channels, + kernel_size=5, + n_layers=3, + p_dropout=0.5, + ) + self.encoder = attentions.Encoder( + self.cfg.hidden_channels, + self.cfg.filter_channels, + self.cfg.n_heads, + self.cfg.n_layers, + self.cfg.kernel_size, + self.cfg.p_dropout, + window_size=self.cfg.window_size, + block_length=self.cfg.block_length, + ) + + self.proj_m = nn.Conv1d(self.cfg.hidden_channels, out_channels, 1) + if not self.cfg.mean_only: + self.proj_s = nn.Conv1d(self.cfg.hidden_channels, out_channels, 1) + self.proj_w = DurationPredictor( + self.cfg.hidden_channels + gin_channels, + self.cfg.filter_channels_dp, + self.cfg.kernel_size, + self.cfg.p_dropout, + ) + + def forward(self, x, x_lengths, g=None): + x = self.emb(x) * math.sqrt(self.cfg.hidden_channels) # [b, t, h] + x = torch.transpose(x, 1, -1) # [b, h, t] + x_mask = torch.unsqueeze(commons.sequence_mask(x_lengths, x.size(2)), 1).to(x.dtype) + + if self.cfg.prenet: + x = self.pre(x, x_mask) + x = self.encoder(x, x_mask) + + if g is not None: + g_exp = g.expand(-1, -1, x.size(-1)) + # print(f"Dimension of input in Text Encoder: x.shape: {x.shape}; g: {g.shape}, g_exp: {g_exp.shape}") + x_dp = torch.cat([torch.detach(x), g_exp], 1) + else: + x_dp = torch.detach(x) + + x_m = self.proj_m(x) * x_mask + if not self.cfg.mean_only: + x_logs = self.proj_s(x) * x_mask + else: + x_logs = torch.zeros_like(x_m) + + # print(f"Dimension of input in Text Encoder before DP: {x_dp.shape}") + + logw = self.proj_w(x_dp, x_mask) + return x_m, x_logs, logw, x_mask + +class Model(nn.Module): + """ + Flow-based ASR model based on GlowTTS Structure using a pre-trained flow-based decoder + trained to generate spectrograms from given statistics coming from an encoder + + Model was pretrained using the architecture in + users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS.py + """ + + def __init__( + self, + model_config: dict, + **kwargs, + ): + """_summary_ + + Args: + n_vocab (int): vocabulary size + hidden_channels (int): Number of hidden channels in encoder + out_channels (int): Number of channels in the output + n_blocks_dec (int, optional): Number of coupling blocks in the decoder. Defaults to 12. + kernel_size_dec (int, optional): Kernel size in the decoder. Defaults to 5. + dilation_rate (int, optional): Dilation rate for CNNs of coupling blocks in decoder. Defaults to 5. + n_block_layers (int, optional): Number of layers in the CNN of the coupling blocks in decoder. Defaults to 4. + p_dropout_dec (_type_, optional): Dropout probability in the decoder. Defaults to 0.. + n_speakers (int, optional): Number of speakers. Defaults to 0. + gin_channels (int, optional): Number of speaker embedding channels. Defaults to 0. + n_split (int, optional): Number of splits for the 1x1 convolution for flows in the decoder. Defaults to 4. + n_sqz (int, optional): Squeeze. Defaults to 1. + sigmoid_scale (bool, optional): Boolean to define if log probs in coupling layers should be rescaled using sigmoid. Defaults to False. + window_size (int, optional): Window size in Multi-Head Self-Attention for encoder. Defaults to None. + block_length (_type_, optional): Block length for optional block masking in Multi-Head Attention for encoder. Defaults to None. + hidden_channels_dec (_type_, optional): Number of hidden channels in decodder. Defaults to hidden_channels. + final_hidden_channels: Number of hidden channels in the final network + final_n_layers: Number of layers in the final network + label_target_size: Target size of target vocabulary, target size for final network + """ + super().__init__() + + self.net_kwargs = { + "repeat_per_num_frames": 100, + "max_dim_feat": 8, + "num_repeat_feat": 5, + "max_dim_time": 20, + } + + fe_config = DbMelFeatureExtractionConfig.from_dict(kwargs["fe_config"]) + self.feature_extraction = DbMelFeatureExtraction(config=fe_config) + + # if label_target_size is None: + # if n_vocab is None: + # run_ctx = get_run_ctx() + # dataset = run_ctx.engine.train_dataset or run_ctx.engine.forward_dataset + # self.label_target_size = len(dataset.datasets["zip_dataset"].targets.labels) + # else: + # self.label_target_size = n_vocab + # else: + # self.label_target_size = label_target_size + + self.cfg = ModelConfigV2.from_dict(model_config) + text_encoder_config = self.cfg.text_encoder_config + decoder_config = self.cfg.decoder_config + + if self.cfg.n_speakers > 1: + self.emb_g = nn.Embedding(self.cfg.n_speakers, self.cfg.gin_channels) + nn.init.uniform_(self.emb_g.weight, -0.1, 0.1) + + self.encoder = TextEncoder( + text_encoder_config, out_channels=self.cfg.out_channels, gin_channels=self.cfg.gin_channels + ) + + self.decoder = FlowDecoder( + decoder_config, in_channels=self.cfg.out_channels, gin_channels=self.cfg.gin_channels + ) + + blstm_config = BlstmEncoderV1Config(num_layers=self.cfg.blstm_layers, input_dim=self.cfg.out_channels*self.cfg.subsampling_factor, hidden_dim=self.cfg.blstm_hidden_dim, dropout=self.cfg.blstm_dropout, enforce_sorted=False) + + self.final = BlstmEncoderV1(blstm_config) + self.final_linear = nn.Linear(2*self.cfg.blstm_hidden_dim, self.cfg.label_target_size + 1) # + CTC blank + + self.specaug_start_epoch = self.cfg.specauc_start_epoch + + def forward( + self, x=None, x_lengths=None, raw_audio=None, raw_audio_lengths=None, g=None, gen=False, recognition=False, noise_scale=1.0, length_scale=1.0 + ): + if not gen: + with torch.no_grad(): + squeezed_audio = torch.squeeze(raw_audio) + y, y_lengths = self.feature_extraction(squeezed_audio, raw_audio_lengths) # [B, T, F] + y = y.transpose(1, 2) # [B, F, T] + else: + y, y_lengths = (None, None) + + if not recognition: + if g is not None: + g = nn.functional.normalize(self.emb_g(g.squeeze(-1))).unsqueeze(-1) + x_m, x_logs, logw, x_mask = self.encoder(x, x_lengths, g=g) # mean, std logs, duration logs, mask + else: + assert g is None, "Using model for recognition with given speaker identity." + + if gen: # durations from dp only used during generation + w = torch.exp(logw) * x_mask * length_scale # durations + w_ceil = torch.ceil(w) # durations ceiled + y_lengths = torch.clamp_min(torch.sum(w_ceil, [1, 2]), 1).long() + y_max_length = None + else: + y_max_length = y.size(2) + + y, y_lengths, y_max_length = self.preprocess(y, y_lengths, y_max_length) + z_mask = torch.unsqueeze(commons.sequence_mask(y_lengths, y_max_length), 1).to(torch.int32) + + if not recognition: + attn_mask = torch.unsqueeze(x_mask, -1) * torch.unsqueeze(z_mask, 2) + + if gen: + attn = commons.generate_path(w_ceil.squeeze(1), attn_mask.squeeze(1)).unsqueeze(1) + z_m = torch.matmul(attn.squeeze(1).transpose(1, 2), x_m.transpose(1, 2)).transpose(1, 2) + z_logs = torch.matmul(attn.squeeze(1).transpose(1, 2), x_logs.transpose(1, 2)).transpose(1, 2) + logw_ = torch.log(1e-8 + torch.sum(attn, -1)) * x_mask + + z = (z_m + torch.exp(z_logs) * torch.randn_like(z_m) * noise_scale) * z_mask + y, logdet = self.decoder(z, z_mask, g=g, reverse=True) + + return (y, z_m, z_logs, logdet, z_mask, y_lengths), (x_m, x_logs, x_mask), (attn, logw, logw_) + else: + if recognition: + mask = mask_tensor(y.transpose(1, 2), y_lengths) + + if self.training and self.cfg.specaug_config: + spec_augment_in = y.transpose(1, 2) # [B, T, F] + + if self.training and self.cfg.specaug_config is not None: + audio_features_masked_2 = apply_spec_aug( + spec_augment_in, + num_repeat_time=torch.max(y_lengths).detach().cpu().numpy() + // self.cfg.specaug_config.repeat_per_n_frames, + max_dim_time=self.cfg.specaug_config.max_dim_time, + num_repeat_feat=self.cfg.specaug_config.num_repeat_feat, + max_dim_feat=self.cfg.specaug_config.max_dim_feat, + ) + else: + audio_features_masked_2 = y.transpose(1, 2) + + z, logdet = self.decoder(audio_features_masked_2.transpose(1, 2), z_mask, g=g, reverse=False) # [B, F, T] + + blstm_in, mask = commons.channel_squeeze(audio_features_masked_2.transpose(1,2), mask, self.cfg.subsampling_factor) # frame stacking for subsampling is equivalent to the channel squeezing operation in glowTTS + blstm_in_length = y_lengths // 4 + + blstm_out = self.final(blstm_in.transpose(1,2), blstm_in_length) # [B, T, F] + logits = self.final_linear(blstm_out) + log_probs = torch.log_softmax(logits, dim=2) + + return log_probs, blstm_in_length + else: + z, logdet = self.decoder(y, z_mask, g=g, reverse=False) # [B, F, T] + + with torch.no_grad(): + x_s_sq_r = torch.exp(-2 * x_logs) + logp1 = torch.sum(-0.5 * math.log(2 * math.pi) - x_logs, [1]).unsqueeze(-1) # [b, t, 1] + logp2 = torch.matmul(x_s_sq_r.transpose(1, 2), -0.5 * (z**2)) # [b, t, d] x [b, d, t'] = [b, t, t'] + logp3 = torch.matmul((x_m * x_s_sq_r).transpose(1, 2), z) # [b, t, d] x [b, d, t'] = [b, t, t'] + logp4 = torch.sum(-0.5 * (x_m**2) * x_s_sq_r, [1]).unsqueeze(-1) # [b, t, 1] + logp = logp1 + logp2 + logp3 + logp4 # [b, t, t'] + + attn = maximum_path(logp, attn_mask.squeeze(1)).unsqueeze(1).detach() + # embed() + + z_m = torch.matmul(attn.squeeze(1).transpose(1, 2), x_m.transpose(1, 2)).transpose( + 1, 2 + ) # [b, t', t], [b, t, d] -> [b, d, t'] + z_logs = torch.matmul(attn.squeeze(1).transpose(1, 2), x_logs.transpose(1, 2)).transpose( + 1, 2 + ) # [b, t', t], [b, t, d] -> [b, d, t'] + + logw_ = torch.log(1e-8 + torch.sum(attn, -1)) * x_mask + return ( + (z, z_m, z_logs, logdet, z_mask), + (x_m, x_logs, x_mask), + y_lengths, + (attn, logw, logw_) + ) + + def preprocess(self, y, y_lengths, y_max_length): + if y_max_length is not None: + y_max_length = (y_max_length // self.cfg.decoder_config.n_sqz) * self.cfg.decoder_config.n_sqz + y = y[:, :, :y_max_length] + y_lengths = (y_lengths // self.cfg.decoder_config.n_sqz) * self.cfg.decoder_config.n_sqz + return y, y_lengths, y_max_length + + def store_inverse(self): + self.decoder.store_inverse() + + +def train_step(*, model: Model, data, run_ctx, **kwargs): + tags = data["seq_tag"] + audio_features = data["audio_features"] # [B, T, F] + # audio_features = audio_features.transpose(1, 2) # [B, F, T] necessary because glowTTS expects the channels to be in the 2nd dimension + audio_features_len = data["audio_features:size1"] # [B] + + # perform local length sorting for more efficient packing + audio_features_len, indices = torch.sort(audio_features_len, descending=True) + + audio_features = audio_features[indices, :, :] + phonemes = data["phonemes"][indices, :] # [B, T] (sparse) + phonemes_len = data["phonemes:size1"][indices] # [B, T] + phonemes_eow = data["phonemes_eow"][indices, :] # [B, T] + phonemes_eow_len = data["phonemes_eow:size1"][indices] + if "speaker_labels" in data: + speaker_labels = data["speaker_labels"][indices, :] # [B, 1] (sparse) + else: + speaker_labels = None + tags = list(np.array(tags)[indices.detach().cpu().numpy()]) + + if speaker_labels is not None: + ( + (z, z_m, z_logs, logdet, z_mask), + (x_m, x_logs, x_mask), + y_lengths, + (attn, logw, logw_) + ) = model(phonemes, phonemes_len, audio_features, audio_features_len, g=speaker_labels) + l_mle = commons.mle_loss(z, z_m, z_logs, logdet, z_mask) + l_dp = commons.duration_loss(logw, logw_, phonemes_len) + run_ctx.mark_as_loss(name="mle", loss=l_mle) + run_ctx.mark_as_loss(name="dp", loss=l_dp) + + logprobs, ctc_input_length = model(raw_audio=audio_features, raw_audio_lengths=audio_features_len, recognition=True) + + transposed_logprobs = torch.permute(logprobs, (1, 0, 2)) + l_ctc = nn.functional.ctc_loss( + transposed_logprobs, + phonemes_eow, + input_lengths=ctc_input_length, + target_lengths=phonemes_eow_len, + blank=model.cfg.label_target_size, + reduction="sum", + zero_infinity=True, + ) + + num_phonemes = torch.sum(phonemes_eow_len) + if "ctc_scale" in kwargs: + ctc_scale = kwargs["ctc_scale"] + else: + ctc_scale = 1 + run_ctx.mark_as_loss(name="ctc", loss=l_ctc, inv_norm_factor=num_phonemes, scale=ctc_scale) + + +def forward_init_hook(run_ctx, **kwargs): + import json + import utils + from utils import AttrDict + from inference import load_checkpoint + from generator import UnivNet as Generator + import numpy as np + + with open("/u/lukas.rilling/experiments/glow_tts_asr_v2/config_univ.json") as f: + data = f.read() + + json_config = json.loads(data) + h = AttrDict(json_config) + + generator = Generator(h).to(run_ctx.device) + + state_dict_g = load_checkpoint( + "/work/asr3/rossenbach/rilling/vocoder/univnet/glow_finetuning/g_01080000", run_ctx.device + ) + generator.load_state_dict(state_dict_g["generator"]) + + run_ctx.generator = generator + run_ctx.speaker_x_vectors = torch.load( + "/work/asr3/rossenbach/rilling/sisyphus_work_dirs/glow_tts_asr_v2/i6_core/returnn/forward/ReturnnForwardJob.U6UwGhE7ENbp/output/output_pooled.hdf" + ) + + +def forward_finish_hook(run_ctx, **kwargs): + pass + + +MAX_WAV_VALUE = 32768.0 + + +def forward_step(*, model: Model, data, run_ctx, **kwargs): + phonemes = data["phonemes"] # [B, N] (sparse) + phonemes_len = data["phonemes:size1"] # [B] + speaker_labels = data["speaker_labels"] # [B, 1] (sparse) + audio_features = data["audio_features"] + + tags = data["seq_tag"] + + (log_mels, z_m, z_logs, logdet, z_mask, y_lengths), (x_m, x_logs, x_mask), (attn, logw, logw_) = model( + phonemes, + phonemes_len, + g=speaker_labels, + gen=True, + noise_scale=kwargs["noise_scale"], + length_scale=kwargs["length_scale"], + ) + + noise = torch.randn([1, 64, log_mels.shape[-1]]).to(device=log_mels.device) + audios = run_ctx.generator.forward(noise, log_mels) + audios = audios * MAX_WAV_VALUE + audios = audios.cpu().numpy().astype("int16") + + if not os.path.exists("/var/tmp/lukas.rilling/"): + os.makedirs("/var/tmp/lukas.rilling/") + if not os.path.exists("/var/tmp/lukas.rilling/out"): + os.makedirs("/var/tmp/lukas.rilling/out/", exist_ok=True) + for audio, tag in zip(audios, tags): + soundfile.write(f"/var/tmp/lukas.rilling/out/" + tag.replace("/", "_") + ".wav", audio[0], 16000) + +def search_init_hook(run_ctx, **kwargs): + # we are storing durations, but call it output.hdf to match + # the default output of the ReturnnForwardJob + from torchaudio.models.decoder import ctc_decoder + with open("output.hdf", "w+"): + print("Created unnecessary output.hdf...") + + run_ctx.recognition_file = open("search_out.py", "wt") + run_ctx.recognition_file.write("{\n") + import subprocess + if kwargs["arpa_lm"] is not None: + lm = subprocess.check_output(["cf", kwargs["arpa_lm"]]).decode().strip() + else: + lm = None + from returnn.datasets.util.vocabulary import Vocabulary + vocab = Vocabulary.create_vocab( + vocab_file=kwargs["returnn_vocab"], unknown_label=None) + labels = vocab.labels + + run_ctx.ctc_decoder = ctc_decoder( + lexicon=kwargs["lexicon"], + lm=lm, + lm_weight=kwargs["lm_weight"], + tokens=labels + ["[blank]", "[SILENCE]", "[UNK]"], + # "[SILENCE]" and "[UNK]" are not actually part of the vocab, + # but the decoder is happy as long they are defined in the token list + # even if they do not exist as label index in the softmax output, + blank_token="[blank]", + sil_token="[SILENCE]", + unk_word="[unknown]", + nbest=1, + beam_size=kwargs["beam_size"], + beam_size_token=kwargs.get("beam_size_token", None), + beam_threshold=kwargs["beam_threshold"], + sil_score=kwargs.get("sil_score", 0.0), + word_score=kwargs.get("word_score", 0.0), + ) + run_ctx.labels = labels + run_ctx.blank_log_penalty = kwargs.get("blank_log_penalty", None) + + if kwargs.get("prior_file", None): + run_ctx.prior = np.loadtxt(kwargs["prior_file"], dtype="float32") + run_ctx.prior_scale = kwargs["prior_scale"] + else: + run_ctx.prior = None + +def search_finish_hook(run_ctx, **kwargs): + run_ctx.recognition_file.write("}\n") + run_ctx.recognition_file.close() + +def search_step(*, model, data, run_ctx, **kwargs): + raw_audio = data["raw_audio"] # [B, T', F] + raw_audio_len = data["raw_audio:size1"] # [B] + + logprobs, audio_features_len = model( + raw_audio=raw_audio, + raw_audio_lengths=raw_audio_len, + recognition=True + ) + + tags = data["seq_tag"] + + logprobs_cpu = logprobs.cpu() + if run_ctx.blank_log_penalty is not None: + # assumes blank is last + logprobs_cpu[:, :, -1] -= run_ctx.blank_log_penalty + if run_ctx.prior is not None: + logprobs_cpu -= run_ctx.prior_scale * run_ctx.prior + hypothesis = run_ctx.ctc_decoder(logprobs_cpu, audio_features_len.cpu()) + + for hyp, tag in zip(hypothesis, tags): + words = hyp[0].words + sequence = " ".join([word for word in words if not word.startswith("[")]) + print(sequence) + run_ctx.recognition_file.write("%s: %s,\n" % (repr(tag), repr(sequence))) diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/glowTTS_ASR_blstm_x_vector.py b/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/glowTTS_ASR_blstm_x_vector.py new file mode 100644 index 000000000..f128c1c75 --- /dev/null +++ b/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/glowTTS_ASR_blstm_x_vector.py @@ -0,0 +1,679 @@ +""" +Trying to make the aligner more AppTek-Like + +Extended weight init code +""" + +from dataclasses import dataclass +import torch +import numpy as np +from torch import nn +import multiprocessing +from librosa import filters +import sys +import time +from typing import Any, Dict, Optional, Tuple, Union +import math +import os +import soundfile + +from torchaudio.functional import mask_along_axis + +from i6_models.parts.blstm import BlstmEncoderV1, BlstmEncoderV1Config + + +from i6_models.parts.conformer.norm import LayerNormNC +from i6_models.assemblies.conformer.conformer_v1 import ConformerEncoderV1Config +from i6_models.assemblies.conformer.conformer_v1 import ConformerBlockV1Config, ConformerEncoderV1 +from i6_models.config import ModuleFactoryV1 +from i6_models.parts.frontend.vgg_act import VGG4LayerActFrontendV1, VGG4LayerActFrontendV1Config + +from i6_models.parts.conformer.convolution import ConformerConvolutionV1Config +from i6_models.parts.conformer.feedforward import ConformerPositionwiseFeedForwardV1Config +from i6_models.parts.conformer.mhsa import ConformerMHSAV1Config +from i6_models.primitives.specaugment import specaugment_v1_by_length +from i6_models.primitives.feature_extraction import LogMelFeatureExtractionV1, LogMelFeatureExtractionV1Config + +from returnn.torch.context import get_run_ctx + +from .shared.i6modelsV1_VGG4LayerActFrontendV1_v4_cfg import ( + SpecaugConfig, + VGG4LayerActFrontendV1Config_mod, + ModelConfigV2, + FlowDecoderConfig, + TextEncoderConfig, +) + +from .shared.configs import DbMelFeatureExtractionConfig +from .shared.feature_extraction import DbMelFeatureExtraction +from .shared.spec_augment import apply_spec_aug +from .shared.mask import mask_tensor + +from .shared import modules +from .shared import commons +from .shared import attentions +from .monotonic_align import maximum_path + +from .shared.forward import search_init_hook, search_finish_hook +from .shared.eval_forward import * + +from IPython import embed + + +class XVector(nn.Module): + def __init__(self, input_dim=40, num_classes=8, **kwargs): + super(XVector, self).__init__() + self.tdnn1 = modules.TDNN( + input_dim=input_dim, output_dim=512, context_size=5, dilation=1, dropout_p=0.5, batch_norm=True + ) + self.tdnn2 = modules.TDNN( + input_dim=512, output_dim=512, context_size=3, dilation=2, dropout_p=0.5, batch_norm=True + ) + self.tdnn3 = modules.TDNN( + input_dim=512, output_dim=512, context_size=2, dilation=3, dropout_p=0.5, batch_norm=True + ) + self.tdnn4 = modules.TDNN( + input_dim=512, output_dim=512, context_size=1, dilation=1, dropout_p=0.5, batch_norm=True + ) + self.tdnn5 = modules.TDNN( + input_dim=512, output_dim=512, context_size=1, dilation=1, dropout_p=0.5, batch_norm=True + ) + #### Frame levelPooling + self.segment6 = nn.Linear(1024, 512) + self.segment7 = nn.Linear(512, 512) + self.output = nn.Linear(512, num_classes) + self.softmax = nn.Softmax(dim=1) + + # fe_config = DbMelFeatureExtractionConfig.from_dict(kwargs["fe_config"]) + # self.feature_extraction = DbMelFeatureExtraction(config=fe_config) + + def forward(self, x, x_lengths): + # with torch.no_grad(): + # squeezed_audio = torch.squeeze(raw_audio) + # x, x_lengths = self.feature_extraction(squeezed_audio, raw_audio_lengths) # [B, T, F] + + # x = x.transpose(1, 2) + tdnn1_out = self.tdnn1(x) + # return tdnn1_out + tdnn2_out = self.tdnn2(tdnn1_out) + tdnn3_out = self.tdnn3(tdnn2_out) + tdnn4_out = self.tdnn4(tdnn3_out) + tdnn5_out = self.tdnn5(tdnn4_out) + ### Stat Pool + mean = torch.mean(tdnn5_out, 2) + std = torch.std(tdnn5_out, 2) + stat_pooling = torch.cat((mean, std), 1) + segment6_out = self.segment6(stat_pooling) + x_vec = self.segment7(segment6_out) + output = self.output(x_vec) + predictions = self.softmax(output) + return output, predictions, x_vec + + +class DurationPredictor(nn.Module): + """ + Duration Predictor module, trained using calculated durations coming from monotonic alignment search + """ + + def __init__(self, in_channels, filter_channels, filter_size, p_dropout): + super().__init__() + + self.in_channels = in_channels + self.filter_channels = filter_channels + self.filter_size = filter_size + self.p_dropout = p_dropout + + self.convs = nn.Sequential( + modules.Conv1DBlock( + in_size=self.in_channels, + out_size=self.filter_channels, + filter_size=self.filter_size, + p_dropout=p_dropout, + ), + modules.Conv1DBlock( + in_size=self.filter_channels, + out_size=self.filter_channels, + filter_size=self.filter_size, + p_dropout=p_dropout, + ), + ) + self.proj = nn.Conv1d(in_channels=self.filter_channels, out_channels=1, kernel_size=1) + + def forward(self, x, x_mask): + x_with_mask = (x, x_mask) + (x, x_mask) = self.convs(x_with_mask) + x = self.proj(x * x_mask) + return x + + +class FlowDecoder(nn.Module): + def __init__(self, cfg: FlowDecoderConfig, in_channels, gin_channels): + """Flow-based decoder model + + Args: + in_channels (int): Number of incoming channels + hidden_channels (int): Number of hidden channels + kernel_size (int): Kernel Size for convolutions in coupling blocks + dilation_rate (float): Dilation Rate to define dilation in convolutions of coupling block + n_blocks (int): Number of coupling blocks + n_layers (int): Number of layers in CNN of the coupling blocks + p_dropout (float, optional): Dropout probability for CNN in coupling blocks. Defaults to 0.. + n_split (int, optional): Number of splits for the 1x1 convolution for flows in the decoder. Defaults to 4. + n_sqz (int, optional): Squeeze. Defaults to 1. + sigmoid_scale (bool, optional): Boolean to define if log probs in coupling layers should be rescaled using sigmoid. Defaults to False. + gin_channels (int, optional): Number of speaker embedding channels. Defaults to 0. + """ + super().__init__() + self.cfg = cfg + + self.flows = nn.ModuleList() + + for _ in range(self.cfg.n_blocks): + self.flows.append(modules.ActNorm(channels=in_channels * self.cfg.n_sqz)) + self.flows.append(modules.InvConvNear(channels=in_channels * self.cfg.n_sqz, n_split=self.cfg.n_split)) + self.flows.append( + attentions.CouplingBlock( + in_channels * self.cfg.n_sqz, + self.cfg.hidden_channels, + kernel_size=self.cfg.kernel_size, + dilation_rate=self.cfg.dilation_rate, + n_layers=self.cfg.n_layers, + gin_channels=gin_channels, + p_dropout=self.cfg.p_dropout, + sigmoid_scale=self.cfg.sigmoid_scale, + ) + ) + + def forward(self, x, x_mask, g=None, reverse=False): + if not reverse: + flows = self.flows + logdet_tot = 0 + else: + flows = reversed(self.flows) + logdet_tot = None + + if g is not None: + g = g.unsqueeze(-1) + + if self.cfg.n_sqz > 1: + x, x_mask = commons.channel_squeeze(x, x_mask, self.cfg.n_sqz) + for f in flows: + if not reverse: + x, logdet = f(x, x_mask, g=g, reverse=reverse) + logdet_tot += logdet + else: + x, logdet = f(x, x_mask, g=g, reverse=reverse) + if self.cfg.n_sqz > 1: + x, x_mask = commons.channel_unsqueeze(x, x_mask, self.cfg.n_sqz) + return x, logdet_tot + + def store_inverse(self): + for f in self.flows: + f.store_inverse() + +class TextEncoder(nn.Module): + """ + Text Encoder model + """ + + def __init__(self, cfg: TextEncoderConfig, out_channels, gin_channels): + """Text Encoder Model based on Multi-Head Self-Attention combined with FF-CCNs + + Args: + n_vocab (int): Size of vocabulary for embeddings + out_channels (int): Number of output channels + hidden_channels (int): Number of hidden channels + filter_channels (int): Number of filter channels + filter_channels_dp (int): Number of filter channels for duration predictor + n_heads (int): Number of heads in encoder's Multi-Head Attention + n_layers (int): Number of layers consisting of Multi-Head Attention and CNNs in encoder + kernel_size (int): Kernel Size for CNNs in encoder layers + p_dropout (float): Dropout probability for both encoder and duration predictor + window_size (int, optional): Window size in Multi-Head Self-Attention for encoder. Defaults to None. + block_length (_type_, optional): Block length for optional block masking in Multi-Head Attention for encoder. Defaults to None. + mean_only (bool, optional): Boolean to only project text encodings to mean values instead of mean and std. Defaults to False. + prenet (bool, optional): Boolean to add ConvReluNorm prenet before encoder . Defaults to False. + gin_channels (int, optional): Number of channels for speaker condition. Defaults to 0. + """ + super().__init__() + self.cfg = cfg + + self.emb = nn.Embedding(self.cfg.n_vocab, self.cfg.hidden_channels) + nn.init.normal_(self.emb.weight, 0.0, self.cfg.hidden_channels**-0.5) + + if self.cfg.prenet: + self.pre = modules.ConvReluNorm( + self.cfg.hidden_channels, + self.cfg.hidden_channels, + self.cfg.hidden_channels, + kernel_size=5, + n_layers=3, + p_dropout=0.5, + ) + self.encoder = attentions.Encoder( + self.cfg.hidden_channels, + self.cfg.filter_channels, + self.cfg.n_heads, + self.cfg.n_layers, + self.cfg.kernel_size, + self.cfg.p_dropout, + window_size=self.cfg.window_size, + block_length=self.cfg.block_length, + ) + + self.proj_m = nn.Conv1d(self.cfg.hidden_channels, out_channels, 1) + if not self.cfg.mean_only: + self.proj_s = nn.Conv1d(self.cfg.hidden_channels, out_channels, 1) + self.proj_w = DurationPredictor( + self.cfg.hidden_channels + gin_channels, + self.cfg.filter_channels_dp, + self.cfg.kernel_size, + self.cfg.p_dropout, + ) + + def forward(self, x, x_lengths, g=None): + x = self.emb(x) * math.sqrt(self.cfg.hidden_channels) # [b, t, h] + x = torch.transpose(x, 1, -1) # [b, h, t] + x_mask = torch.unsqueeze(commons.sequence_mask(x_lengths, x.size(2)), 1).to(x.dtype) + + if self.cfg.prenet: + x = self.pre(x, x_mask) + x = self.encoder(x, x_mask) + + if g is not None: + g_exp = g.unsqueeze(-1).expand(-1, -1, x.size(-1)) + # print(f"Dimension of input in Text Encoder: x.shape: {x.shape}; g: {g.shape}, g_exp: {g_exp.shape}") + x_dp = torch.cat([torch.detach(x), g_exp], 1) + else: + x_dp = torch.detach(x) + + x_m = self.proj_m(x) * x_mask + if not self.cfg.mean_only: + x_logs = self.proj_s(x) * x_mask + else: + x_logs = torch.zeros_like(x_m) + + # print(f"Dimension of input in Text Encoder before DP: {x_dp.shape}") + + logw = self.proj_w(x_dp, x_mask) + return x_m, x_logs, logw, x_mask + +class Model(nn.Module): + """ + Flow-based ASR model based on GlowTTS Structure using a pre-trained flow-based decoder + trained to generate spectrograms from given statistics coming from an encoder + + Model was pretrained using the architecture in + users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS.py + """ + + def __init__( + self, + model_config: dict, + **kwargs, + ): + """_summary_ + + Args: + n_vocab (int): vocabulary size + hidden_channels (int): Number of hidden channels in encoder + out_channels (int): Number of channels in the output + n_blocks_dec (int, optional): Number of coupling blocks in the decoder. Defaults to 12. + kernel_size_dec (int, optional): Kernel size in the decoder. Defaults to 5. + dilation_rate (int, optional): Dilation rate for CNNs of coupling blocks in decoder. Defaults to 5. + n_block_layers (int, optional): Number of layers in the CNN of the coupling blocks in decoder. Defaults to 4. + p_dropout_dec (_type_, optional): Dropout probability in the decoder. Defaults to 0.. + n_speakers (int, optional): Number of speakers. Defaults to 0. + gin_channels (int, optional): Number of speaker embedding channels. Defaults to 0. + n_split (int, optional): Number of splits for the 1x1 convolution for flows in the decoder. Defaults to 4. + n_sqz (int, optional): Squeeze. Defaults to 1. + sigmoid_scale (bool, optional): Boolean to define if log probs in coupling layers should be rescaled using sigmoid. Defaults to False. + window_size (int, optional): Window size in Multi-Head Self-Attention for encoder. Defaults to None. + block_length (_type_, optional): Block length for optional block masking in Multi-Head Attention for encoder. Defaults to None. + hidden_channels_dec (_type_, optional): Number of hidden channels in decodder. Defaults to hidden_channels. + final_hidden_channels: Number of hidden channels in the final network + final_n_layers: Number of layers in the final network + label_target_size: Target size of target vocabulary, target size for final network + """ + super().__init__() + + self.net_kwargs = { + "repeat_per_num_frames": 100, + "max_dim_feat": 8, + "num_repeat_feat": 5, + "max_dim_time": 20, + } + + fe_config = DbMelFeatureExtractionConfig.from_dict(kwargs["fe_config"]) + self.feature_extraction = DbMelFeatureExtraction(config=fe_config) + + # if label_target_size is None: + # if n_vocab is None: + # run_ctx = get_run_ctx() + # dataset = run_ctx.engine.train_dataset or run_ctx.engine.forward_dataset + # self.label_target_size = len(dataset.datasets["zip_dataset"].targets.labels) + # else: + # self.label_target_size = n_vocab + # else: + # self.label_target_size = label_target_size + + self.cfg = ModelConfigV2.from_dict(model_config) + + text_encoder_config = self.cfg.text_encoder_config + decoder_config = self.cfg.decoder_config + + if self.cfg.n_speakers > 1: + self.x_vector = XVector(self.cfg.out_channels, self.cfg.n_speakers) + self.x_vector_bottleneck = nn.Sequential( + nn.Linear(512, self.cfg.gin_channels), + nn.ReLU() + ) + + self.encoder = TextEncoder( + text_encoder_config, out_channels=self.cfg.out_channels, gin_channels=self.cfg.gin_channels + ) + + self.decoder = FlowDecoder( + decoder_config, in_channels=self.cfg.out_channels, gin_channels=self.cfg.gin_channels + ) + + blstm_config = BlstmEncoderV1Config(num_layers=self.cfg.blstm_layers, input_dim=self.cfg.out_channels*self.cfg.subsampling_factor, hidden_dim=self.cfg.blstm_hidden_dim, dropout=self.cfg.blstm_dropout, enforce_sorted=False) + + self.final = BlstmEncoderV1(blstm_config) + self.final_linear = nn.Linear(2*self.cfg.blstm_hidden_dim, self.cfg.label_target_size + 1) # + CTC blank + + self.specaug_start_epoch = self.cfg.specauc_start_epoch + + def forward( + self, x=None, x_lengths=None, raw_audio=None, raw_audio_lengths=None, g=None, gen=False, recognition=False, noise_scale=1.0, length_scale=1.0 + ): + if not gen: + with torch.no_grad(): + squeezed_audio = torch.squeeze(raw_audio) + y, y_lengths = self.feature_extraction(squeezed_audio, raw_audio_lengths) # [B, T, F] + y = y.transpose(1, 2) # [B, F, T] + self.x_vector.eval() + _, _, g = self.x_vector(y, y_lengths) + else: + y, y_lengths = (None, None) + + g = self.x_vector_bottleneck(g) + if not recognition: + x_m, x_logs, logw, x_mask = self.encoder(x, x_lengths, g=g) # mean, std logs, duration logs, mask + + if gen: # durations from dp only used during generation + w = torch.exp(logw) * x_mask * length_scale # durations + w_ceil = torch.ceil(w) # durations ceiled + y_lengths = torch.clamp_min(torch.sum(w_ceil, [1, 2]), 1).long() + y_max_length = None + else: + y_max_length = y.size(2) + + y, y_lengths, y_max_length = self.preprocess(y, y_lengths, y_max_length) + z_mask = torch.unsqueeze(commons.sequence_mask(y_lengths, y_max_length), 1).to(torch.int32) + + if not recognition: + attn_mask = torch.unsqueeze(x_mask, -1) * torch.unsqueeze(z_mask, 2) + + if gen: + attn = commons.generate_path(w_ceil.squeeze(1), attn_mask.squeeze(1)).unsqueeze(1) + z_m = torch.matmul(attn.squeeze(1).transpose(1, 2), x_m.transpose(1, 2)).transpose(1, 2) + z_logs = torch.matmul(attn.squeeze(1).transpose(1, 2), x_logs.transpose(1, 2)).transpose(1, 2) + logw_ = torch.log(1e-8 + torch.sum(attn, -1)) * x_mask + + z = (z_m + torch.exp(z_logs) * torch.randn_like(z_m) * noise_scale) * z_mask + y, logdet = self.decoder(z, z_mask, g=g, reverse=True) + + return (y, z_m, z_logs, logdet, z_mask, y_lengths), (x_m, x_logs, x_mask), (attn, logw, logw_) + else: + z, logdet = self.decoder(y, z_mask, g=g, reverse=False) + + spec_augment_in = z.transpose(1, 2) # [B, T, F] + mask = torch.unsqueeze(commons.sequence_mask(y_lengths, y.size(2)), 1).to(y.dtype) + + if self.training and self.cfg.specaug_config is not None: + audio_features_masked_2 = apply_spec_aug( + spec_augment_in, + num_repeat_time=torch.max(y_lengths).detach().cpu().numpy() + // self.cfg.specaug_config.repeat_per_n_frames, + max_dim_time=self.cfg.specaug_config.max_dim_time, + num_repeat_feat=self.cfg.specaug_config.num_repeat_feat, + max_dim_feat=self.cfg.specaug_config.max_dim_feat, + ) + else: + audio_features_masked_2 = spec_augment_in + + blstm_in, mask = commons.channel_squeeze(audio_features_masked_2.transpose(1,2), mask, self.cfg.subsampling_factor) # frame stacking for subsampling is equivalent to the channel squeezing operation in glowTTS + blstm_in_length = y_lengths // 4 + + blstm_out = self.final(blstm_in.transpose(1,2), blstm_in_length) # [B, T, F] + logits = self.final_linear(blstm_out) + log_probs = torch.log_softmax(logits, dim=2) + + if recognition: + return log_probs, blstm_in_length + else: + with torch.no_grad(): + x_s_sq_r = torch.exp(-2 * x_logs) + logp1 = torch.sum(-0.5 * math.log(2 * math.pi) - x_logs, [1]).unsqueeze(-1) # [b, t, 1] + logp2 = torch.matmul(x_s_sq_r.transpose(1, 2), -0.5 * (z**2)) # [b, t, d] x [b, d, t'] = [b, t, t'] + logp3 = torch.matmul((x_m * x_s_sq_r).transpose(1, 2), z) # [b, t, d] x [b, d, t'] = [b, t, t'] + logp4 = torch.sum(-0.5 * (x_m**2) * x_s_sq_r, [1]).unsqueeze(-1) # [b, t, 1] + logp = logp1 + logp2 + logp3 + logp4 # [b, t, t'] + + attn = maximum_path(logp, attn_mask.squeeze(1)).unsqueeze(1).detach() + # embed() + + z_m = torch.matmul(attn.squeeze(1).transpose(1, 2), x_m.transpose(1, 2)).transpose( + 1, 2 + ) # [b, t', t], [b, t, d] -> [b, d, t'] + z_logs = torch.matmul(attn.squeeze(1).transpose(1, 2), x_logs.transpose(1, 2)).transpose( + 1, 2 + ) # [b, t', t], [b, t, d] -> [b, d, t'] + + logw_ = torch.log(1e-8 + torch.sum(attn, -1)) * x_mask + return ( + (z, z_m, z_logs, logdet, z_mask), + (x_m, x_logs, x_mask), + y_lengths, + (attn, logw, logw_), + (log_probs, blstm_in_length), + ) + + def preprocess(self, y, y_lengths, y_max_length): + if y_max_length is not None: + y_max_length = (y_max_length // self.cfg.decoder_config.n_sqz) * self.cfg.decoder_config.n_sqz + y = y[:, :, :y_max_length] + y_lengths = (y_lengths // self.cfg.decoder_config.n_sqz) * self.cfg.decoder_config.n_sqz + return y, y_lengths, y_max_length + + def store_inverse(self): + self.decoder.store_inverse() + + +def train_step(*, model: Model, data, run_ctx, **kwargs): + tags = data["seq_tag"] + audio_features = data["audio_features"] # [B, T, F] + # audio_features = audio_features.transpose(1, 2) # [B, F, T] necessary because glowTTS expects the channels to be in the 2nd dimension + audio_features_len = data["audio_features:size1"] # [B] + + # perform local length sorting for more efficient packing + audio_features_len, indices = torch.sort(audio_features_len, descending=True) + + audio_features = audio_features[indices, :, :] + phonemes = data["phonemes"][indices, :] # [B, T] (sparse) + phonemes_len = data["phonemes:size1"][indices] # [B, T] + phonemes_eow = data["phonemes_eow"][indices, :] # [B, T] + phonemes_eow_len = data["phonemes_eow:size1"][indices] + # speaker_labels = data["speaker_labels"][indices, :] # [B, 1] (sparse) + tags = list(np.array(tags)[indices.detach().cpu().numpy()]) + + ( + (z, z_m, z_logs, logdet, z_mask), + (x_m, x_logs, x_mask), + y_lengths, + (attn, logw, logw_), + (logprobs, ctc_input_length), + ) = model(phonemes, phonemes_len, audio_features, audio_features_len) + l_mle = commons.mle_loss(z, z_m, z_logs, logdet, z_mask) + l_dp = commons.duration_loss(logw, logw_, phonemes_len) + + transposed_logprobs = torch.permute(logprobs, (1, 0, 2)) + l_ctc = nn.functional.ctc_loss( + transposed_logprobs, + phonemes_eow, + input_lengths=ctc_input_length, + target_lengths=phonemes_eow_len, + blank=model.cfg.label_target_size, + reduction="sum", + zero_infinity=True, + ) + + run_ctx.mark_as_loss(name="mle", loss=l_mle) + run_ctx.mark_as_loss(name="dp", loss=l_dp) + + num_phonemes = torch.sum(phonemes_eow_len) + if "ctc_scale" in kwargs: + ctc_scale = kwargs["ctc_scale"] + else: + ctc_scale = 1 + run_ctx.mark_as_loss(name="ctc", loss=l_ctc, inv_norm_factor=num_phonemes, scale=ctc_scale) + + +def forward_init_hook(run_ctx, **kwargs): + import json + import utils + from utils import AttrDict + from inference import load_checkpoint + from generator import UnivNet as Generator + import numpy as np + + with open("/u/lukas.rilling/experiments/glow_tts_asr_v2/config_univ.json") as f: + data = f.read() + + json_config = json.loads(data) + h = AttrDict(json_config) + + generator = Generator(h).to(run_ctx.device) + + state_dict_g = load_checkpoint( + "/work/asr3/rossenbach/rilling/vocoder/univnet/glow_finetuning/g_01080000", run_ctx.device + ) + generator.load_state_dict(state_dict_g["generator"]) + + run_ctx.generator = generator + run_ctx.speaker_x_vectors = torch.load( + "/work/asr3/rossenbach/rilling/sisyphus_work_dirs/glow_tts_asr_v2/i6_core/returnn/forward/ReturnnForwardJob.U6UwGhE7ENbp/output/output_pooled.hdf" + ) + + +def forward_finish_hook(run_ctx, **kwargs): + pass + + +MAX_WAV_VALUE = 32768.0 + + +def forward_step(*, model: Model, data, run_ctx, **kwargs): + phonemes = data["phonemes"] # [B, N] (sparse) + phonemes_len = data["phonemes:size1"] # [B] + speaker_labels = data["speaker_labels"] # [B, 1] (sparse) + audio_features = data["audio_features"] + + tags = data["seq_tag"] + + speaker_x_vector = run_ctx.speaker_x_vectors[speaker_labels.detach().cpu().numpy(), :].squeeze(1) + + (log_mels, z_m, z_logs, logdet, z_mask, y_lengths), (x_m, x_logs, x_mask), (attn, logw, logw_) = model( + phonemes, + phonemes_len, + g=speaker_x_vector.to(run_ctx.device), + gen=True, + noise_scale=kwargs["noise_scale"], + length_scale=kwargs["length_scale"], + ) + + noise = torch.randn([1, 64, log_mels.shape[-1]]).to(device=log_mels.device) + audios = run_ctx.generator.forward(noise, log_mels) + audios = audios * MAX_WAV_VALUE + audios = audios.cpu().numpy().astype("int16") + + if not os.path.exists("/var/tmp/lukas.rilling/"): + os.makedirs("/var/tmp/lukas.rilling/") + if not os.path.exists("/var/tmp/lukas.rilling/out"): + os.makedirs("/var/tmp/lukas.rilling/out/", exist_ok=True) + for audio, tag in zip(audios, tags): + soundfile.write(f"/var/tmp/lukas.rilling/out/" + tag.replace("/", "_") + ".wav", audio[0], 16000) + +def search_init_hook(run_ctx, **kwargs): + # we are storing durations, but call it output.hdf to match + # the default output of the ReturnnForwardJob + from torchaudio.models.decoder import ctc_decoder + run_ctx.recognition_file = open("search_out.py", "wt") + run_ctx.recognition_file.write("{\n") + import subprocess + if kwargs["arpa_lm"] is not None: + lm = subprocess.check_output(["cf", kwargs["arpa_lm"]]).decode().strip() + else: + lm = None + from returnn.datasets.util.vocabulary import Vocabulary + vocab = Vocabulary.create_vocab( + vocab_file=kwargs["returnn_vocab"], unknown_label=None) + labels = vocab.labels + + run_ctx.ctc_decoder = ctc_decoder( + lexicon=kwargs["lexicon"], + lm=lm, + lm_weight=kwargs["lm_weight"], + tokens=labels + ["[blank]", "[SILENCE]", "[UNK]"], + # "[SILENCE]" and "[UNK]" are not actually part of the vocab, + # but the decoder is happy as long they are defined in the token list + # even if they do not exist as label index in the softmax output, + blank_token="[blank]", + sil_token="[SILENCE]", + unk_word="[unknown]", + nbest=1, + beam_size=kwargs["beam_size"], + beam_size_token=kwargs.get("beam_size_token", None), + beam_threshold=kwargs["beam_threshold"], + sil_score=kwargs.get("sil_score", 0.0), + word_score=kwargs.get("word_score", 0.0), + ) + run_ctx.labels = labels + run_ctx.blank_log_penalty = kwargs.get("blank_log_penalty", None) + + if kwargs.get("prior_file", None): + run_ctx.prior = np.loadtxt(kwargs["prior_file"], dtype="float32") + run_ctx.prior_scale = kwargs["prior_scale"] + else: + run_ctx.prior = None + +def search_finish_hook(run_ctx, **kwargs): + run_ctx.recognition_file.write("}\n") + run_ctx.recognition_file.close() + +def search_step(*, model, data, run_ctx, **kwargs): + raw_audio = data["raw_audio"] # [B, T', F] + raw_audio_len = data["raw_audio:size1"] # [B] + + logprobs, audio_features_len = model( + raw_audio=raw_audio, + raw_audio_lengths=raw_audio_len, + recognition=True + ) + + tags = data["seq_tag"] + + logprobs_cpu = logprobs.cpu() + if run_ctx.blank_log_penalty is not None: + # assumes blank is last + logprobs_cpu[:, :, -1] -= run_ctx.blank_log_penalty + if run_ctx.prior is not None: + logprobs_cpu -= run_ctx.prior_scale * run_ctx.prior + hypothesis = run_ctx.ctc_decoder(logprobs_cpu, audio_features_len.cpu()) + + for hyp, tag in zip(hypothesis, tags): + words = hyp[0].words + sequence = " ".join([word for word in words if not word.startswith("[")]) + print(sequence) + run_ctx.recognition_file.write("%s: %s,\n" % (repr(tag), repr(sequence))) diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/glowTTS_ASR_conformer_two_forward_pass.py b/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/glowTTS_ASR_conformer_two_forward_pass.py index 256267ce4..c9b6ec80b 100644 --- a/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/glowTTS_ASR_conformer_two_forward_pass.py +++ b/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/glowTTS_ASR_conformer_two_forward_pass.py @@ -54,7 +54,7 @@ from .shared import attentions from .monotonic_align import maximum_path -from .shared.forward import search_init_hook, search_finish_hook +from .shared.forward import prior_init_hook, prior_step, prior_finish_hook from .shared.eval_forward import * from .shared.eval_invertibility import * @@ -520,6 +520,7 @@ def train_step(*, model: Model, data, run_ctx, **kwargs): ) num_phonemes = torch.sum(phonemes_eow_len) + breakpoint() if "ctc_scale" in kwargs: ctc_scale = kwargs["ctc_scale"] else: diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/glowTTS_ASR_conformer_x_vector_two_forward_pass.py b/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/glowTTS_ASR_conformer_x_vector_two_forward_pass.py index 05dbaf9d9..6def36536 100644 --- a/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/glowTTS_ASR_conformer_x_vector_two_forward_pass.py +++ b/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/glowTTS_ASR_conformer_x_vector_two_forward_pass.py @@ -54,7 +54,7 @@ from .shared import attentions from .monotonic_align import maximum_path -from .shared.forward import search_init_hook, search_finish_hook +from .shared.forward import search_init_hook, search_finish_hook, prior_init_hook, prior_finish_hook, prior_step from .shared.eval_forward import * diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2.py b/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2.py index 7de3a79cf..56c1b4fb9 100644 --- a/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2.py +++ b/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2.py @@ -54,7 +54,7 @@ from .shared import attentions from .monotonic_align import maximum_path -from .shared.forward import search_init_hook, search_finish_hook +from .shared.forward import search_init_hook, search_finish_hook, prior_init_hook, prior_finish_hook, prior_step from .shared.eval_forward import * diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/glowTTS_ASR_conformer_x_vector_v2.py b/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/glowTTS_ASR_conformer_x_vector_v2.py index 370350966..65a206701 100644 --- a/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/glowTTS_ASR_conformer_x_vector_v2.py +++ b/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/glowTTS_ASR_conformer_x_vector_v2.py @@ -54,8 +54,9 @@ from .shared import attentions from .monotonic_align import maximum_path -from .shared.forward import search_init_hook, search_finish_hook +from .shared.forward import search_init_hook, search_finish_hook, prior_init_hook, prior_finish_hook, prior_step from .shared.eval_forward import * +from .shared.eval_invertibility import * from IPython import embed diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/glow_ASR_conformer.py b/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/glow_ASR_conformer.py index 181e53bd6..a60cf462d 100644 --- a/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/glow_ASR_conformer.py +++ b/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/glow_ASR_conformer.py @@ -54,7 +54,7 @@ from .shared import attentions from .monotonic_align import maximum_path -from .shared.forward import search_init_hook, search_finish_hook +from .shared.forward import search_init_hook, search_finish_hook, prior_finish_hook, prior_init_hook, prior_step from .shared.eval_invertibility import forward_init_hook_invertibility, forward_finish_hook_invertibility, forward_step_invertibility from IPython import embed diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/glow_ASR_conformer_specaugment_before.py b/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/glow_ASR_conformer_specaugment_before.py index 99c78cbfd..84a7f5656 100644 --- a/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/glow_ASR_conformer_specaugment_before.py +++ b/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/glow_ASR_conformer_specaugment_before.py @@ -54,7 +54,7 @@ from .shared import attentions from .monotonic_align import maximum_path -from .shared.forward import search_init_hook, search_finish_hook +from .shared.forward import search_init_hook, search_finish_hook, prior_finish_hook, prior_init_hook, prior_step from .shared.eval_invertibility import forward_init_hook_invertibility, forward_finish_hook_invertibility, forward_step_invertibility from IPython import embed diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/glow_ASR_conformer_specaugment_before_xvector.py b/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/glow_ASR_conformer_specaugment_before_xvector.py index 3565e6b00..54e8d707f 100644 --- a/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/glow_ASR_conformer_specaugment_before_xvector.py +++ b/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/glow_ASR_conformer_specaugment_before_xvector.py @@ -54,7 +54,7 @@ from .shared import attentions from .monotonic_align import maximum_path -from .shared.forward import search_init_hook, search_finish_hook +from .shared.forward import search_init_hook, search_finish_hook, prior_finish_hook, prior_init_hook, prior_step from .shared.eval_invertibility import forward_init_hook_invertibility, forward_finish_hook_invertibility, forward_step_invertibility from IPython import embed diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/glow_ASR_conformer_specaugment_before_xvector_v2.py b/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/glow_ASR_conformer_specaugment_before_xvector_v2.py index 476060b0c..61468f88d 100644 --- a/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/glow_ASR_conformer_specaugment_before_xvector_v2.py +++ b/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/glow_ASR_conformer_specaugment_before_xvector_v2.py @@ -54,7 +54,7 @@ from .shared import attentions from .monotonic_align import maximum_path -from .shared.forward import search_init_hook, search_finish_hook +from .shared.forward import search_init_hook, search_finish_hook, prior_finish_hook, prior_init_hook, prior_step from IPython import embed diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/glow_ASR_conformer_xvector.py b/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/glow_ASR_conformer_xvector.py index a60d5bad9..bbce70703 100644 --- a/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/glow_ASR_conformer_xvector.py +++ b/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/glow_ASR_conformer_xvector.py @@ -54,7 +54,7 @@ from .shared import attentions from .monotonic_align import maximum_path -from .shared.forward import search_init_hook, search_finish_hook +from .shared.forward import search_init_hook, search_finish_hook, prior_finish_hook, prior_init_hook, prior_step from IPython import embed diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/glow_ASR_conformer_xvector_eval.py b/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/glow_ASR_conformer_xvector_eval.py index 4eaf3b251..f6178e1f9 100644 --- a/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/glow_ASR_conformer_xvector_eval.py +++ b/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/glow_ASR_conformer_xvector_eval.py @@ -54,7 +54,7 @@ from .shared import attentions from .monotonic_align import maximum_path -from .shared.forward import search_init_hook, search_finish_hook +from .shared.forward import search_init_hook, search_finish_hook, prior_finish_hook, prior_init_hook, prior_step from IPython import embed diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/only_conformer.py b/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/only_conformer.py index 9b5d9d215..3f236c30f 100644 --- a/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/only_conformer.py +++ b/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/only_conformer.py @@ -56,9 +56,6 @@ # search_init_hook, search_step, search_finish_hook, - prior_init_hook, - prior_finish_hook, - prior_step, ) from IPython import embed @@ -278,3 +275,38 @@ def search_init_hook(run_ctx, **kwargs): else: run_ctx.prior = None + +def prior_init_hook(run_ctx, **kwargs): + # we are storing durations, but call it output.hdf to match + # the default output of the ReturnnForwardJob + run_ctx.sum_probs = None + run_ctx.sum_frames = 0 + + +def prior_finish_hook(run_ctx, **kwargs): + all_frames = run_ctx.sum_frames.detach().cpu().numpy() + all_probs = run_ctx.sum_probs.detach().cpu().numpy() + average_probs = all_probs / all_frames + log_average_probs = np.log(average_probs) + print("Prior sum in std-space (should be close to 1.0):", np.sum(average_probs)) + with open("prior.txt", 'w') as f: + np.savetxt(f, log_average_probs, delimiter=' ') + print("Saved prior in prior.txt in +log space.") + + +def prior_step(*, model, data, run_ctx, **kwargs): + raw_audio = data["audio_features"] # [B, T', F] + raw_audio_len = data["audio_features:size1"] # [B] + + logprobs, audio_features_len = model( + raw_audio=raw_audio, + raw_audio_len=raw_audio_len, + ) + + probs = torch.exp(logprobs) + run_ctx.sum_frames = run_ctx.sum_frames + torch.sum(audio_features_len) + if run_ctx.sum_probs is None: + run_ctx.sum_probs = torch.sum(probs, dim=(0, 1)) + else: + run_ctx.sum_probs += torch.sum(probs, dim=(0, 1)) + diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/shared/eval_invertibility.py b/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/shared/eval_invertibility.py index 3cdc198d0..7dcde6680 100644 --- a/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/shared/eval_invertibility.py +++ b/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/shared/eval_invertibility.py @@ -66,7 +66,91 @@ def forward_step_invertibility(*, model, data, run_ctx, **kwargs): mae.sum() / current_num_of_obs ) # This considers the masking by only using the mean over all unmasked elements - current_var = (mae - current_mae).sum() / ( + current_var = (mae - current_mae).pow(2).sum() / ( + current_num_of_obs - 1 + ) # Variance over unmasked elements with bias correction 1 + + run_ctx.total_mae = ((run_ctx.num_of_obs / (run_ctx.num_of_obs + current_num_of_obs)) * old_mae) + ( + (current_num_of_obs / (run_ctx.num_of_obs + current_num_of_obs)) * current_mae + ) + + run_ctx.total_ae_var = ( + (run_ctx.num_of_obs / (run_ctx.num_of_obs + current_num_of_obs)) * run_ctx.total_ae_var + + ((current_num_of_obs / (run_ctx.num_of_obs + current_num_of_obs)) * current_var) + + ((run_ctx.num_of_obs * current_num_of_obs) / (run_ctx.num_of_obs + current_num_of_obs) ** 2) + * (old_mae - current_mae) ** 2 + ) + + run_ctx.total_ae_max = torch.max(run_ctx.total_ae_max, mae.max()) + + run_ctx.total_ae_min = torch.min( + run_ctx.total_ae_min, (mae + (-1 * z_mask + 1) * torch.tensor(float("inf")).nan_to_num(0.0)).min() + ) # Masked Min operation + + run_ctx.num_of_obs += current_num_of_obs + +def forward_init_hook_asr_invertibility(run_ctx, **kwargs): + run_ctx.total_mae = 0 + run_ctx.total_ae_var = 0 + run_ctx.total_ae_max = torch.tensor(-np.inf) + run_ctx.total_ae_min = torch.tensor(np.inf) + run_ctx.num_of_obs = 0 + + +def forward_finish_hook_asr_invertibility(run_ctx, **kwargs): + with open("output.hdf", "w+") as f: + f.write("total, mean, var, max, min \n") + f.write( + f"{run_ctx.num_of_obs}, {str(float(run_ctx.total_mae))}, {str(float(run_ctx.total_ae_var))}, {str(float(run_ctx.total_ae_max))}, {str(float(run_ctx.total_ae_min))}" + ) + + +def forward_step_asr_invertibility(*, model, data, run_ctx, **kwargs): + raw_audio = data["audio_features"] # [B, N] (sparse) + raw_audio_len = data["audio_features:size1"] # [B] + phonemes = data["phonemes"] + phonemes_len = data["phonemes:size1"] + + if "xvectors" in data: + g = data["xvectors"] + elif "speaker_labels" in data: + g = data["speaker_labels"] + else: + raise Exception("Missing speaker embedding!") + + squeezed_audio = torch.squeeze(raw_audio) + y, y_lengths = model.feature_extraction(squeezed_audio, raw_audio_len) # [B, T, F] + y = y.transpose(1, 2) # [B, F, T] + + if hasattr(model, "x_vector"): + _, _, g = model.x_vector(y, y_lengths) + + if hasattr(model, "x_vector_bottleneck"): + g = model.x_vector_bottleneck(g) + elif hasattr(model, "emb_g"): + g = torch.nn.functional.normalize(model.emb_g(g.squeeze(-1))).unsqueeze(-1) + else: + g = None + + y_max_length = y.size(2) + + y, y_lengths, y_max_length = model.preprocess(y, y_lengths, y_max_length) + z_mask = torch.unsqueeze(commons.sequence_mask(y_lengths, y_max_length), 1).to(torch.int32) + + z, _ = model.decoder(y, z_mask, g=g, reverse=False) + y_hat, _ = model.decoder(z, z_mask, g=g, reverse=True) + + mae = torch.nn.functional.l1_loss(y_hat * z_mask, y * z_mask, reduction="none") # [B, F, T] + + current_num_of_obs = y_hat.shape[1] * y_lengths.sum() # F * total_number_of_frames_in_batch + + old_mae = run_ctx.total_mae + + current_mae = ( + mae.sum() / current_num_of_obs + ) # This considers the masking by only using the mean over all unmasked elements + + current_var = (mae - current_mae).pow(2).sum() / ( current_num_of_obs - 1 ) # Variance over unmasked elements with bias correction 1 diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/shared/forward.py b/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/shared/forward.py index 972b8500f..5d0d956d6 100644 --- a/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/shared/forward.py +++ b/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/shared/forward.py @@ -93,12 +93,13 @@ def prior_finish_hook(run_ctx, **kwargs): def prior_step(*, model, data, run_ctx, **kwargs): - raw_audio = data["raw_audio"] # [B, T', F] - raw_audio_len = data["raw_audio:size1"] # [B] + raw_audio = data["audio_features"] # [B, T', F] + raw_audio_len = data["audio_features:size1"] # [B] logprobs, audio_features_len = model( raw_audio=raw_audio, - raw_audio_len=raw_audio_len, + raw_audio_lengths=raw_audio_len, + recognition=True ) probs = torch.exp(logprobs) diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/shared/i6modelsV1_VGG4LayerActFrontendV1_v4_cfg.py b/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/shared/i6modelsV1_VGG4LayerActFrontendV1_v4_cfg.py index 48df0d70d..eafc1faa9 100644 --- a/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/shared/i6modelsV1_VGG4LayerActFrontendV1_v4_cfg.py +++ b/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/shared/i6modelsV1_VGG4LayerActFrontendV1_v4_cfg.py @@ -130,5 +130,28 @@ def from_dict(cls, d): d["decoder_config"] = FlowDecoderConfig.from_dict(d["decoder_config"]) d["text_encoder_config"] = TextEncoderConfig.from_dict(d["text_encoder_config"]) return ModelConfig(**d) + +@dataclass +class ModelConfigV2(): + specaug_config: Union[SpecaugConfig, None] + decoder_config: FlowDecoderConfig + text_encoder_config: TextEncoderConfig + specauc_start_epoch: int + label_target_size: int + subsampling_factor: int + blstm_layers: int + blstm_hidden_dim: int + blstm_dropout: float + out_channels: int + gin_channels: int + n_speakers: Union[tk.Variable, int] + + @classmethod + def from_dict(cls, d): + d = d.copy() + d["specaug_config"] = SpecaugConfig.from_dict(d["specaug_config"]) + d["decoder_config"] = FlowDecoderConfig.from_dict(d["decoder_config"]) + d["text_encoder_config"] = TextEncoderConfig.from_dict(d["text_encoder_config"]) + return ModelConfigV2(**d) diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training/serializer.py b/users/rilling/experiments/librispeech/librispeech_joint_training/serializer.py index 03d4e2079..82160af4a 100644 --- a/users/rilling/experiments/librispeech/librispeech_joint_training/serializer.py +++ b/users/rilling/experiments/librispeech/librispeech_joint_training/serializer.py @@ -188,6 +188,25 @@ def get_serializer( import_as="forward_finish_hook", ) serializer_objects.extend([vocoder_dependencies, forward_step, init_hook, finish_hook]) + elif target == "prior": + forward_step = Import( + code_object_path=package + ".%s.prior_step" % network_module, + unhashed_package_root=PACKAGE, + import_as="forward_step", + ) + init_hook = Import( + code_object_path=package + ".%s.prior_init_hook" % network_module, + unhashed_package_root=PACKAGE, + import_as="forward_init_hook", + ) + finish_hook = Import( + code_object_path=package + ".%s.prior_finish_hook" % network_module, + import_as="forward_finish_hook", + unhashed_package_root=PACKAGE, + ) + serializer_objects.extend( + [forward_step, init_hook, finish_hook] + ) else: forward_step = Import( code_object_path=package + f".{network_module}.forward_step_{target}", diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training/training_comparison.ipynb b/users/rilling/experiments/librispeech/librispeech_joint_training/training_comparison.ipynb index 8219973d6..56937615a 100644 --- a/users/rilling/experiments/librispeech/librispeech_joint_training/training_comparison.ipynb +++ b/users/rilling/experiments/librispeech/librispeech_joint_training/training_comparison.ipynb @@ -2,9 +2,18 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 15, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The autoreload extension is already loaded. To reload it, use:\n", + " %reload_ext autoreload\n" + ] + } + ], "source": [ "import sys\n", "sys.path.append(\"/u/lukas.rilling/dev/\")\n", @@ -23,24 +32,33 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{'/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_encoder_sample_ctc_scale_0.1/training': ''}" + "{'/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/training': '/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_ctc_scale_1.0/training': '/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_ctc_scale_1.0/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_1.0/training': '/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_1.0/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ddi_actnorm/training': '/glowTTS_ASR_conformer_two_forward_pass_ddi_actnorm/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_ctc_scale_0.1/training': '/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_ctc_scale_0.1/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_0.1/training': '/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_0.1/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/training': '/glowTTS_ASR_conformer_two_forward_pass/'}" ] }, - "execution_count": 2, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ "globs = [\n", - " # \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector/training\",\n", - " \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_encoder*/training\"\n", + " \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass*/training\",\n", + " # \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_ctc_scale_1.0/training\",\n", + " # \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/training\",\n", + " # \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_blstm_x_vector*/training\",\n", + " # \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_encoder*/training\"\n", " # \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1/training\",\n", " # \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/raw_audio/glowTTS_ASR_conformer_x_vector_control_spec_augment/training\",\n", " # \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1/training\"\n", @@ -70,19 +88,26 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 17, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "['/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_encoder_sample_ctc_scale_0.1/training',\n", + "['/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/training',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_ctc_scale_1.0/training',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_1.0/training',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ddi_actnorm/training',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_ctc_scale_0.1/training',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_0.1/training',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/training',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS/enc192/100ep/not_silence_preprocessed/training',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS_x_vector/enc768/100ep/not_silence_preprocessed/training',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/weak_baseline/training']" + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/weak_baseline/training',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/training']" ] }, - "execution_count": 3, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } @@ -112,12 +137,17 @@ ")\n", "files[lr_files[-1]] = \"Baseline Weak Conformer\"\n", "\n", + "lr_files.append(\n", + " \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/training\"\n", + ")\n", + "files[lr_files[-1]] = \"Baseline Strong Conformer\"\n", + "\n", "lr_files" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 18, "metadata": {}, "outputs": [ { @@ -125,15 +155,15 @@ "text/plain": [ "{'/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS/enc192/100ep/not_silence_preprocessed/training': 1,\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS_x_vector_v3_norm_xvector/enc768/100ep/not_silence_preprocessed/training': 1,\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS_x_vector_v3/enc768/100ep/not_silence_preprocessed/training': 1,\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS_x_vector/enc768/100ep/not_silence_preprocessed/training': 1,\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS_x_vector_v3/enc768/100ep/not_silence_preprocessed/training': 1,\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_x_vector_pe1_radam/training': 1,\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_x_vector_pe1_radam_no_dec_dropout/training': 1,\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_x_vector_pe1/training': 1,\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_x_vector_pe1_radam_no_dec_dropout/training': 1,\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS/training': 1}" ] }, - "execution_count": 4, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" } @@ -158,17 +188,24 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 19, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_encoder_sample_ctc_scale_0.1/training: 3\n", + "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/training: 3\n", + "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_ctc_scale_1.0/training: 3\n", + "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_1.0/training: 3\n", + "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ddi_actnorm/training: 3\n", + "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_ctc_scale_0.1/training: 3\n", + "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_0.1/training: 3\n", + "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/training: 3\n", "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS/enc192/100ep/not_silence_preprocessed/training: 1\n", "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS_x_vector/enc768/100ep/not_silence_preprocessed/training: 1\n", "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/weak_baseline/training: 3\n", + "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/training: 3\n", "Large Font: False\n", "Setup Interactive Legend\n", "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous view', 'arrow-left', 'back'), ('Forward', 'Forward to next view', 'arrow-right', 'forward'), ('Pan', 'Left button pans, Right button zooms\\nx/y fixes axis, CTRL fixes aspect', 'arrows', 'pan'), ('Zoom', 'Zoom to rectangle\\nx/y fixes axis', 'square-o', 'zoom'), ('Download', 'Download plot', 'floppy-o', 'save_figure')]))\n" @@ -177,18 +214,18 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "ee80df0cc455421888693e1de3ae055b", + "model_id": "79c0076f856b4e01889533746fe74923", "version_major": 2, "version_minor": 0 }, - "image/png": "iVBORw0KGgoAAAANSUhEUgAABdwAAAOECAYAAAC7OPPEAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd5hU5fnG8ftM3d6X3jtIBwUVFbuJGns3irEbjVETW2KJP0s0mqjR2HtXxN4biKJYAAFReodd2N6nnfP7Y2UVdxdmds/M2fL9XBdXsnPecrOUkGfeeV7DsixLAAAAAAAAAACgVVxOBwAAAAAAAAAAoCOg4A4AAAAAAAAAgA0ouAMAAAAAAAAAYAMK7gAAAAAAAAAA2ICCOwAAAAAAAAAANqDgDgAAAAAAAACADSi4AwAAAAAAAABgAwruAAAAAAAAAADYgII7AAAAAAAAAAA2oOAOAAAAAAAAAIANKLgDAAAAAAAAAGADCu4AAAAAAAAAANiAgjsAAAAAAAAAADag4A4AAAAAAAAAgA0ouAMAAAAAAAAAYAMK7gAAAAAAAAAA2ICCOwAAAAAAAAAANqDgDgAAAAAAAACADSi4AwAAAAAAAABgAwruAAAAAAAAAADYgII7AAAAAAAAAAA2oOAOAAAAAAAAAIANKLgDAAAAAAAAAGADCu4AAAAAAAAAANiAgjsAAAAAAAAAADag4A4AAAAAAAAAgA0ouAMAAAAAAAAAYAMK7gAAAAAAAAAA2ICCOwAAAAAAAAAANqDgDgAAAAAAAACADSi4AwAAAAAAAABgAwruAAAAAAAAAADYgII7AAAAAAAAAAA2oOAOAAAAAAAAAIANKLgDAAAAAAAAAGADCu4AAAAAAAAAANiAgjsAAAAAAAAAADag4A4AAAAAAAAAgA0ouAMAAAAAAAAAYAMK7gAAAAAAAAAA2ICCOwAAAAAAAAAANqDgDgAAAAAAAACADSi4AwAAAAAAAABgAwruAAAAAAAAAADYgII7AAAAAAAAAAA2oOAOAAAAAAAAAIANKLgDAAAAAAAAAGADCu4AAAAAAAAAANiAgjsAAAAAAAAAADag4A4AAAAAAAAAgA0ouAMAAAAAAAAAYAMK7gAAAAAAAAAA2ICCOwAAAAAAAAAANqDgDgAAAAAAAACADSi4AwAAAAAAAABgAwruAAAAAAAAAADYgII7AAAAAAAAAAA2oOAOAAAAAAAAAIANKLgDAAAAAAAAAGADCu4AAAAAAAAAANiAgjsAAAAAAAAAADag4A4AAAAAAAAAgA0ouAMAAAAAAAAAYAMK7gAAAAAAAAAA2ICCOwAAAAAAAAAANqDgDgAAAAAAAACADSi4AwAAAAAAAABgAwruAAAAAAAAAADYgII7AAAAAAAAAAA2oOAOAAAAAAAAAIANKLgDAAAAAAAAAGADCu4AAAAAAAAAANiAgjsAAAAAAAAAADag4A4AAAAAAAAAgA0ouAMAAAAAAAAAYAMK7gAAAAAAAAAA2ICCOwAAAAAAAAAANqDgDgAAAAAAAACADSi4AwAAAAAAAABgAwruAAAAAAAAAADYgII7AAAAAAAAAAA2oOAOAAAAAAAAAIANKLgDAAAAAAAAAGADCu4AALSQYRgx/ejXr5/tGfr16yfDMNrcWvHwySef6JhjjlHPnj3l8/mUnZ2toUOH6rjjjtM999yj8vJypyMCAAAAADo5j9MBAABor04//fRGr3322WdauXKlxowZo7Fjx273LC8vL0HJOp4bbrhB1113nSRp+PDhmjRpkrxer5YuXaoZM2Zo+vTpmjhxoiZPnuxwUgAAAABAZ0bBHQCAFnr88ccbvTZt2jStXLlSRx55pK6//vq4Z/joo48UCoXa3Fp2+vbbb3X99dfL6/XqxRdf1JFHHrnd84KCAj399NPKyspyJB8AAAAAANtQcAcAoB0bOHBgm1zLTjNmzJBlWTr++OMbFdslqVu3bvrLX/6S+GAAAAAAAPwKPdwBAEiAxx9/XIZh6Prrr9eyZct04oknqmvXrnK5XHr11VclSStWrND111+v3XffXd26dZPP51OvXr102mmnadmyZU2u21Tf9TVr1sgwDE2dOlW1tbW68sor1bdvX/n9fg0aNEi33nqrLMuK61qSNGvWLO23335KT09Xdna2fvvb3+qbb77Z7nsRja1bt0qS8vPzoxr/S9XV1br11ls1ceJEZWRkKDU1VcOGDdMf//jHJr+nTz31lKZMmaKMjAylpKRo9OjRuuWWW1RXV9do7LRp02QYhmbOnKn33ntP++67r7KysmQYhsrKyhrGvfvuuzr00EOVn58vv9+vAQMG6NJLL1VxcXGjNYPBoP73v/9p1113VW5urlJSUtSvXz8ddthhev7552P++QMAAAAAEosT7gAAJNDSpUsbiqn77ruvSktL5fV6JUkPP/ywbrvtNo0cOVK77rqr/H6/lixZoqeeekqvvfaaZs+erdGjR0e9VzAY1EEHHaQlS5Zo6tSpqq6u1qxZs3TllVeqsrJSN954Y9zWmjFjho4//nhFIhFNnjxZ/fr106JFizRlyhSdccYZUe8rSb1795Ykvfzyy7rqqqvUpUuXqOZt3rxZBx54oL7//ntlZ2dr6tSp8vv9WrVqle6//34NHjxYQ4YMaRh/7rnn6sEHH1RSUpL2228/paSkaObMmbr66qv1xhtv6MMPP1RKSkqjfZ599lk9/PDDmjhxon7zm99o5cqVDW9cXHnllbr11lvl8/m06667qnv37vruu+/0n//8R6+//ro+//xzde3atWGtU045RdOnT1d6err22msvZWRkaOPGjfrss89UVVWlE088MabvHQAAAAAgwSwAAGCb008/3ZJkXXfdddu9/thjj1mSLEnWhRdeaIXD4UZzv/jiC2vVqlWNXn/00UctSda+++7b6Fnfvn2tX//P+erVqxv22meffazy8vKGZ19//bXldrutlJQUq7KyMi5rlZeXWzk5OZYk65lnntluvWuuuaZhvV9/j5qzcuVKKzk52ZJkpaenW6effrr10EMPWfPmzWvy+7jN/vvvb0myjj/++EY/19WrV1vfffddw9fTp0+3JFk9evSwli1b1vB6WVmZNWXKFEuSddlll223xrZfa0nW888/32j/F1980ZJkjRw50lq+fHnD66ZpWtdee60lyTrhhBMaXl+1apUlyerbt69VVFS03Vq1tbXWnDlzdvKdAgAAAAA4jZYyAAAkUH5+vm699Va53e5GzyZPnqz+/fs3ev2MM87QnnvuqZkzZ6q8vDzqvVwulx544AFlZGQ0vLbtFHZNTY2++eabuKz14osvqqSkRPvvv79OPvnk7da59tpr1bdv36j3laQBAwbojTfeUO/evVVZWaknnnhCZ599tsaPH6+8vDxdcMEF2rx583ZzvvrqK3300Ufq0qWLHn74YaWlpW33vF+/ftt9WuDuu++WJF133XUaPHhww+uZmZm69957ZRiGHnjggSZbyxx66KE64YQTGr1+0003SZKee+45DRo0qOH1be10xo4dq+nTp6uoqEjSz61zxo0bp9zc3O3WSkpK0u67777zbxYAAAAAwFEU3AEASKADDjigybYk21RVVem5557TFVdcobPPPlvTpk3TtGnTtHnzZlmWpZUrV0a9V9++fTV06NBGr29ro/LrIrVda33++eeSpOOOO67ReI/Ho2OOOSbqfbfZf//9tWLFCs2YMUPnnXeexo8fL4/Ho7KyMt13330aO3asli5d2jD+ww8/lCSddNJJSk9P3+HaoVBIX375paT6li6/Nnr0aI0ePVpVVVVasGBBo+e/+93vGr22ZcsWfffddxo8eLBGjhzZ6LlhGNpzzz0ViUT07bffSpKGDRum1NRUvfXWW/rXv/6lTZs27TA3AAAAAKDtoYc7AAAJ1KdPn2afffzxxzrxxBMbTjo3pbKyMuq9evXq1eTr2wrQgUAgLmttK75v673+azv6HuyIz+fTUUcdpaOOOkqSVFZWpueff15XX321tmzZogsvvFAffPCBJGn9+vWSpIEDB+503eLiYgWDQeXl5Sk1NbXJMf369dN3332njRs3RvXzWbNmjSRp+fLljS6i/bVtJ9wzMjL00EMP6ZxzztHll1+uyy+/XEOGDNG+++6r3//+99pzzz13+nMBAAAAADiLgjsAAAmUlJTU5OtVVVU6/vjjVVJSomuvvVYnnnii+vbtq+TkZBmGoZNPPlnPPfecLMuKei+Xy74Pstm5ll2ysrJ03nnnqUePHjriiCP0ySefqKamZoefIGipHRXNm/o1NU1TktStWzcdfPDBO1z7ly12TjrpJB1wwAF67bXX9P7772vWrFl64IEH9MADD+jSSy/VHXfc0cKfAQAAAAAgESi4AwDQBsyePVvFxcU69thj9Y9//KPR81WrVjmQqmW6d+8u6edT5r/W3Osttd9++0mSIpGIysrKlJKS0nC6PpoWPLm5ufL5fCoqKlJ1dXWTp9y3nVjv2bNnVJm2fSIgLy9Pjz/+eFRztsnPz9dZZ52ls846S5Zl6b333tMJJ5ygf//73/rDH/6gXXbZJab1AAAAAACJ0/aOqwEA0AmVlpZKarp1y4oVKzRv3rxER2qxba1PXn755UbPIpGIZsyYEdN6OzvVv2LFCkn1LWfy8vIk1ffKl+ovLK2qqtrhfK/Xq8mTJ0uSnn/++UbPFy9erO+++05paWkaO3ZsVJl79eqlYcOGacmSJVq2bFlUc5piGIYOOeQQHXrooZKk77//vsVrAQAAAADij4I7AABtwLbLR2fMmLFdD/eysjKdeeaZCoVCTkWL2XHHHaecnBx98MEHjQrYN954o1avXh3Tetdcc43++te/NnlafePGjTr33HMl1V9e6vP5JEm77bab9t13X23ZskXnnHOOqqurt5u3Zs0aLVq0qOHriy66SJJ0/fXXb/dpgsrKSl144YWyLEvnnntusy2BmsttmqaOOeaYJi9bLS4u1kMPPdTw9fz58zVjxgwFg8HtxpWUlGju3LmSmu+LDwAAAABoG2gpAwBAGzBx4kQdeOCB+uCDDzRkyBBNnTpVkjRz5kzl5eXpiCOO0GuvveZsyChlZmbqoYce0vHHH6+TTjpJd999t/r166dFixZp2bJlOuecc/Tggw82FMd3pqqqSnfddZduv/12DRkyRCNGjFBSUpI2bNiguXPnKhQKadCgQbrzzju3m/fUU09p//3313PPPaf33ntPU6ZMkd/v18qVK7VgwQLdcccdGjVqlCTp2GOPbcg1cuRI7bfffkpJSdHMmTO1detWTZ48WTfccENM34eTTz5Z33//vW6++WZNmDBBY8eO1cCBA2VZllauXKmFCxcqLS1NZ599tiRp7dq1OuaYY5SZmamJEyeqW7duKisr06effqrKykodfvjh2n333WPKAAAAAABILE64AwDQRrz22mv629/+pvz8fL3zzjv69ttvdeKJJ+rLL79UVlaW0/FicvTRR+vDDz/U1KlTtXDhQr311lvq0aOHZs+erT59+kiq750ejb///e966qmndOqpp8rv92v27NmaPn26lixZot1220233XabFixY0Ki/es+ePfX111/rhhtuUK9evfTBBx/onXfeUU1NjS644AIddthh241/4IEH9OSTT2rcuHGaNWuW3njjDXXp0kU33XSTPv744xZdxnrTTTdp1qxZOuaYY1RQUKBXX31Vn3zyiSKRiM4//3y9/vrrDWMnT56sG2+8URMmTNDSpUv10ksv6ZtvvtHo0aP16KOPNtmiBwAAAADQthjWzhqjAgAA2OiQQw7Re++9py+//FKTJk1yOg4AAAAAALbhhDsAALDdxo0bVVhYuN1rpmnqP//5j9577z0NGTJEu+22m0PpAAAAAACID3q4AwAA282ePVunnnqqxo0bp759+yoQCGjx4sVas2aNUlJS9PDDD8swDKdjAgAAAABgK1rKAAAA2y1fvly33HKLZs+ercLCQtXV1albt26aOnWqrrzySo0YMcLpiAAAAAAA2I6COwAAAAAAAAAANqCHOwAAAAAAAAAANqDgDgAAAAAAAACADbg0FZ2GaZratGmT0tPTuagPAAAAnZ5lWaqsrFSPHj3kcnEWCwAAwA4U3NFpbNq0Sb1793Y6BgAAANCmrF+/Xr169XI6BgAAQIdAwR2dRnp6uqT6/0ORkZHhcBoAAADAWRUVFerdu3fDv5MBAADQehTc0WlsayOTkZFBwR0AAAD4Ce0WAQAA7EOjPgAAAAAAAAAAbEDBHQAAAAAAAAAAG1BwBwAAAAAAAADABhTcAQAAAAAAAACwAQV3AAAAAAAAAABsQMEdAAAAAAAAAAAbUHAHAAAAAAAAAMAGFNwBAAAAAAAAALABBXcAAAAAAAAAAGxAwR0AAAAAAAAAABtQcAcAAAAAAAAAwAYU3AEAAAAAAAAAsAEFdwAAAAAAAAAAbEDBHQAAAAAAAAAAG1BwBwAAAAAAAADABhTcAQAAAAAAAACwAQV3AAAAAAAAAABsQMEdAAAAAAAAAAAbUHAHAAAAAAAAAMAGFNwBAAAAAAAAALABBXcAAAAAAAAAAGxAwR0AAAAAAAAAABtQcAcAAAAAAAAAwAYU3AEAAAAAAAAAsAEFdwAAAAAAAAAAbEDBHQAAAAAAAAAAG1BwBwAAAAAAAADABhTcAQAAAAAAAACwAQV3AAAAAAAAAABsQMEdANBmWJalTSNGqvb9952OAgAAAAAAEDMK7gCANiOyabOs8nJVP/KY01EAAAAAAABiRsEdANBmhFcslyT5p+7jcBIAAAAAAIDYUXAHALQZZnGJjKxMpZ1zttNRAAAAAAAAYkbBHQDQZqQcfZS6fTZbZnmF01EAAAAAAABiRsEdANCmFJ91tsqvu87pGAAAAAAAADGj4A4AaDMK99pHwS/nyqqqcjoKAAAAAABAzCi4AwDaBLOsTOFVqyTDkFlV7XQcAAAAAACAmFFwBwC0CaEVKyVJ3rFjZFVzwh0AAAAAALQ/FNwBAG1CeMVyyTDkGzVKFifcAQAAAABAO+RxOgAAAJIUXrFS7t69lXndtZLb7XQcAAAAAACAmFFwBwC0CWnnn6fkI4+UkZTkdBQAAAAAAIAWoaUMAKBNcOfmyjdyF9V9/Im2HnOsLMtyOhIAAAAAAEBMKLijXSkuLtbYsWMbfgwZMkQej0clJSVORwPQClYgoJI/Xqjg4sUyy8sU/HKurLo6p2MBAAAAAADEhJYyaFdyc3O1YMGChq9vv/12zZo1Szk5Oc6FAtBq4dWrVfvqa0o9/TQZqamSJKuqSkpOdjgZAAAAAABA9DjhjnbtkUce0Zlnnul0DACtFF6+QpLkGTRYrtQ0SZJVXe1kJAAAAAAAgJhxwh3t1pw5c1RaWqrDDjusyeeBQECBQKDh64qKikRFAxCj0IoVcuXkyJ2TrUhqiiTJrKLgDgAAAAAA2hdOuKPdeuSRR3TaaafJ42n6faNbbrlFmZmZDT969+6d4IQAohVesUKewYMkSZ6+fZV1+7/k7t7N4VQAAAAAAACxMSzLspwOAcSqqqpK3bt319dff61hw4Y1OaapE+69e/dWeXm5MjIyEhUVQBRq331XVjCklN8d7nQUAAA6jYqKCmVmZvLvYwAAABvRUgbt0gsvvKAxY8Y0W2yXJL/fL7/fn8BUAFoq+ZBDGv67FQ6r5sWX5NttN3kHDXQwFQAAAAAAQGxoKYN2ictSgY4jUlKqmhmvyNx2z4LLpbK/Xq7gV185GwwAAAAAACBGnHBHuzRnzhynIwCwSei7BSq96E/q+uUcuTIyZLhcMlJSZFVzaSoAAAAAAGhfOOEOAHBUePkKGUlJcvfs2fCakZoqs6rKwVQAAAAAAACxo+AOAHBUaMUKeQYOlOH6+X+SjNRUTrgDAAAAAIB2h4I7AMBR4RUr5Bk8aLvX/LtPlrtXz2ZmAAAAAAAAtE30cAcAOMrTt6+8Y8du91r27f9yJgwAAAAAAEArUHAHADgq+z//bvSaFQrJCoXkSklxIBEAAAAAAEDL0FIGAOAYs6pKZnl5o9dL/3SxSqb9wYFEAAAAAAAALUfBHQDgmNrXXtfmkaNlBQLbvW6kpsqsrnIoFQAAAAAAQMtQcAcAOCa8YoXcffrI8Pu3e91ITZVVXeNQKgAAAAAAgJah4A4AcExoxQp5Bw1q9LorLU1WFSfcAQAAAABA+0LBHQDgmPCKlfIMblxwN9LSZFZXO5AIAAAAAACg5Si4AwAcYQUCimwplGfQwEbPUn9/qrp+PtuBVAAAAAAAAC3ncToAAKBzMvx+9Vj6oxSJNHrmSktzIBEAAAAAAEDrcMIdAOAYw+NpdGGqJAUXLlTx6WfILCtLfCgAAAAAAIAWouAOAHBE5f0PqPjMs5p8ZlVUqu7DDym4AwAAAACAdoWCOwDAEaEFC2SWVzT5zEhLlSSZVVycCgAAAAAA2g8K7gAAR4RWrJC3iQtTJcn4qYe7VUPBHQAAAAAAtB8U3AEACWdFIgqvWi3P4MFNPnel1p9wtzjhDgAAAAAA2hEK7gCAhIusXy8FAvI0c8LdlZWljGv+Ls+A/glOBgAAAAAA0HIepwMAADofV5cuyn36SfnGjm3yuZGcrPTzzk1sKAAAAAAAgFbihDsAIOFcKSlK2ndfuTIzmx1T+957Ci1blsBUAAAAAAAArUPBHQCQcDXTX1b188/vcEzZ5Veq9u13EpQIAAAAAACg9Si4AwASrubll1X30cc7HGOkpcqq5tJUAAAAAADQflBwBwAkXHjdenl6997hGFdqmqyqqgQlAgAAAAAAaD0K7gCAhLIiEUU2bpS7z44L7kZqiswqTri3J2Ztraxg0OkYAAAAAAA4hoI7ACChIgUFUigkT5++OxznHT5c7u7dEpQKdtg8aIiKTj7V6RgAAAAAADjG43QAAEDnYrhcSv3DGfIMHbLDcVk335SgRLCDZZqSpOAXXzicBAAAAAAA53DCHQCQUO7u3ZX1fzfI07PnTsdalpWARLCD4XIp7dxz5BkwwOkoAAAAAAA4hoI7ACChQsuXK7R06U7Hld94k7bsf0ACEsEOgW++lZGSosjmzbxRAgAAAADotCi4AwASqvLue1R2xVU7HWf4/bIqqxKQCK1lRSIqPn2aQosXK/0vl0qRiNORAAAAAABwBD3cAQAJFVm/Xu7evXc6zkhNlVldnYBEaK3gvPmyysqUftFF8k0Y73QcAAAAAAAcwwl3AEBChdevk6dPdAV3q7qa9iTtQODjj+XKzpZ35C6qffddhdevdzoSAAAAAACOoOAOAEgYq7ZWZkGh3H367HSsKy1NCoelQCABydAadR9/Iv++UyW3WyVnn6vArE+djgQAAAAAgCMouAMAEiZSUip33z7y9O+307FJBx6grp99Kvl88Q+GFrOCQbnycpV80EEyPB65u3ZVZPNmp2MBAAAAAOAIergDABLG07OHus35PKqxrowMuTIy4pwIrWX4fMp75umGr13du1NwBwAAAAB0WpxwBwAkTCz92MMbNqjkoosVXrcujonQWqEff5QVDDZ87abgDgAAAADoxCi4AwASpuKmm7X1iKOiGmvV1qp2xgxFCgrinAotZYVC2nrEUaq6/4GG13yjRsrVpauDqQAAAAAAcA4tZQAACRNeu1ZGSnJUY12paZIkq7o6npHQCsGvv5FVVSX/fvs2vJZ+0YUOJgIAAAAAwFmccAcAJExk3Xq5e/eJaqyRmiJJsqoouLdVdR99JFfXLvLusst2r1vBoKxIxKFUAAAAAAA4h4I7ACBhwuvXy9Ond1RjjdRUSZJZXRXPSGiFuo8/UdK++8owjIbXgvPma1P/gQovX+5gMrRVVl2dAnPnOh0DAAAAAOKGgjsAICHMsjJZ5eVy946y4O7xKP2yS+UdMSLOyZwTyyWybY1ZXS3D51PS/vtv97qraxdJ4uJUNKnqoYdVdPSxfAICAAAAQIdFD3cAQEIY6enqMusTufPzo56TceklcUzkrEhBgbYc8ltl3fZPJR90kNNxYuZKTVWX995p9KaBu0sXyTAU2cxlt2gsUlAgz9AhMtxup6MAAAAAQFxwwh0AkBCG2y3voEFyZWZGPSfw9dcKLV0ax1TOqXl5hsytW+WbuKvTUVokvHGjLMvarp2MJBler1xd8hXZtMmhZGjLQkuXyqquUXjtWqejAAAAAEBcUHAHACRE7Rtvquy662OaU37131X95FPxCeQgy7JU8+JLSj76KLlzshX4+hsF5893OlbUrLo6bdl7qqofe7zJ5+7u3Wkpg0Ysy1L4x6WKbNigmukvOx0HAAAAAOKCljIAgIQIzJmjwNffxDTHSEuVWVUdp0TOCc1foPCKFcr8v3/IsixV3n6HQkuWKP/1V+Xp39/peDsV+PJLWXV18u+5R5PPcx95WEZGRoJToa0zt26VWVoqSQqvWuVwGgAAAACID064AwASIrx+vTx9orswdRsjNVVWdVWcEjkntGyp3P37y7/nnjIMQ9n3/U+urCwVnfp7RYqKnI63U3UffyJ3r17yDBnS5HN3t25ypaQkOBXaOldenrp+OUfJhx+m8OrVUc8LLVumwr32Ue37H8QxHQAAAADYg4I7ACAhIuvWy907toK7KzVNVgc84Z564onqOuuThosj3TnZyn3mKVnVNSo+fZrMmhqHEzbPsizVffSRkvbbt1H/9m3qPvlExX84M8HJ0NYZLpc8vXvLO3KkwqtWN7pwtzmBOXMUXrVKJX84U5V33R31PAAAAABwAi1lAABxZ5mmwuvXK7VPn5jmufv0ljZ2rPeGwxs2yJWbK1dy8nave/r0Ue5TT6j0ggsV2bRZrkEDHUq4Y2Zpqay6gPz77df8mPJy1b33vszKSrnS0xOYDm1Z5d3/lRWJyLvLLnL36C6rulpGWtpO5yXtt5/cD3VV6IcfVHHbv+Tu20cpRx4Z/8AAAAAA0AKGxTEhdBIVFRXKzMxUeXm5MugtDCSUFQio6rHHlbT33vKOGO50HEcVnfp7KRJR3nPPNvncCodleNr2++GWZUmm2XBC/9cCc+eq6Ohj1WXmx/IOHpzgdGirthx2uDwDBynnrv+0eI3A3Lny7bqrDJdLZm1tozeuAMSGfx8DAADYr2MdGwQAtEmG36/0887t9MX2yObNCsz6VMmHH97sGMPjUfDbeSq5+JI22TrDCgRkGEazxXZJcnfvLkmKbNqUqFho4yzTVHjpMnmHDf35tXA4qrkVt96m4OLvJUn+SZNkuFwKzPlChXtMUeCLL+KSFwAAAABaioI7ACDuQsuWqfa992IuIFc9/rgKdpscp1SJVzPjFRk+n5IPO3SH48yKctVOn67ImjWJCRaDLYf8VhW337HDMe6uXSXVv8EASFJkwwZZNTXyDq0vuG858GBV/Ov2nc8rKlLl3f9VZO3a7V73DBsm7+DBKjrxZNW89lpcMgMAAABAS1BwBwDEXe2bb6ns8iubvWSzeYYihYVt8qR3rCzLUs2LLynpt7+Raycf2/eOHi1JCi5clIhoUTPLyxVetkyevn13OM7w+5V50//JN3ZsYoKhzQv9uFSS5Pmp4O7KyVF49ZqdzgsvW14/b8j2rYncOdnKffZp+ffeW5V33W1v2HYmsok3tgAAAIC2hII7ACDuIuvWyd27d8zzXGlpUjgsBQJxSJVYVnm5XHm5SjnuuJ2Odefmyt2zp0ILFyYgWfSCCxZIkrzjx+90bNq0afIOGxbnRGgvvMOHKfOmG+XuUd9uyNO/n8KrVu10XmjZUsnrladfv0bPDI9HqSedqPDSZQq3wU+DxJtlWap++hkVTNlLdR9+5HQcAAAAAD9p27eyAQA6hPD69fL07RPzPCMtVZJk1tTInZRkd6yEcmVlKf/l6VGP944e1eZOuAfnzZeRlSnPgP47H/vtPEWKtir54IMTkAxtnad3b6VNO/3nrwcMUM1L02WZpgxX8+c/wsuWyzNwgAyvt8nn/n32VsY1f5fRyS57NGtrVX7V1ap5abpSf3+q/HtNcToSAAAAgJ9QcAcAxF1k7Tr5dt015nlGapokyaqqknJy7I6VMFZdnYLz5ss3edIOi4u/lHrqKTLLyuIbLEahhQvlGz8+qtZANa+8osCXX1JwhySp6okn5Rs/Tr5RoyRJ7v79ZdXVySwobDj13hTv2LFNnm7fxpWaqvTzzrU7bpsW2bxZRb8/XZHVq5V9151KOfYYpyMBAAAA+AUK7gCAuLJMU56BA+UdMSLmub6xY5T/9psNl3C2V7Xvva/SC/6orrM/jep0uCQlTZ0a31AtkPPA/VG/CeDu3p3e0pAkWeGwyq//hzKvvaah4O7fcw91nfuFXN12/Gc79fidt2CKFBaq6qGHlXbBBXLnZNuSuS1zZWXJO3Cgcv57l7zDhzsdBwAAAMCv0MMdABBXhsulvBeeU8rvDo95ris9Xb4xY2T4/XFIljg106fLN3Fi1MV26adLVl95RcHFi+OYLDaGzyd3ly5RjXV37y6rvFxmdXWcU6GtC69eLQWD8v50YaokuVJS5OnVa4ef+DCrqxWY84XM2tqd7lF13/0KfNRx+5hb4bDK/3mrQj/+KCM5WTkP3EexHQAAAGijKLgDAOLKqq2V1cJLT82KCpX97e8K/fCDzakSJ1JQoMDMWUqJ4qTuLxmGoYpbblXtK6/GJ1iMat94U0XHnygrFIpqvLt7N0lSZHNBPGOhHQj/uFSS5Bk6ZLvXy2+6WVWPPtbsvNB3C1V03PGKrF+/w/XdXbvKO26sat//oPVh26BIYaGKTjhRVf+7T8Hv2tZFygAAAAAao+AOAIirmpema9PQ4bLC4dgnm6aqH39C4ZWr7A+WIDUzXpF8XiUffljMc71jRreZi1MDX3yhSGFhs5dX/pq7Tx/5dt9dirTg1x0dSmjpUrny8+XOzd3+9R9/VODTT5uft2yp5PXK03/nnwxJPuggBWbOlFVX1+q8TbFCIZkVFXFZe0cCn8/RloN/o/Dq1cqb/qJSTzg+4RkAAAAAxIaCOwAgrsLr18vdrZsMT+zXhhhp9ZemmtVVdsdKGCM5WennnCNXRkbMc32jRim0eLEs04xDstgE582Xb/y4qMd7evZU/vQXt2sjgs7J3adPk5/w8PTvr/DqNc3OCy9bLs+A/lG9yZN08EGyamoU+HxOa6I2q+al6SqYvIfqdvAGgd3MmhqVnH+BvEOGqMt778q/224J2xsAAABAy1FwBwDEVWTdenn69GnRXMPjkZL8sqprbE6VOGlnTFPGFZe3aK539ChZFRWKrFlrc6rYmLW1Ci1ZIt/48THNswIBmZWVcUqF9iL1+OOUefVVjV73DOiv8Nq1zX76JbRsmbyDhzT5rNFaQ4Yo48or5O7XrzVRm5V85BHy9O2j4lNPU9Ujj8qyrLjsI0lmaanM8nK5UlKU9/JLyn3uGbnz8+O2HwAAAAB7UXAHAMRVeP06ufv0bvF8V0qqrKr2e8I9vG5diy8O9Y4eXX9yNxS0OVVsQosWSZFIzAX3rb87UhU33RynVGgPrGBQwUWLmrzHwTNggBQKKbJhQ5NzDb9f3jGjo9rHMAylX3ShvAMHtCrvr1Xe+z9VP/ucXCkpyn/zDaWddabKr71OZX/5a4vvpmiOFYmo9u13tOU3h6r8uuslSd7Bg2W43bbuAwAAACC+KLgDAOIqsn6DPL1bXnBPPWNa1EW3tmjLbw5V9WOPt2iuOydHuY8+4nhbFu/w4cp57JFGl17ujLt7N4U3bY5TKrQHoWXLtPWQ3yq0+PtGz7y77KLMm26U0Uy7pbxnnlb6BedHvZdZW6vK++9X6McfW5z3l2pee10VN9+iyOb638OG263Ma69R1n/+rcjGTZJh2LKPWVWlygceVOGee6nk7HPk7t1b6X+5zJa1AQAAACRe7A11AQCIQde5X0iRSIvnZ1x6iY1pEssKh2WVlcn1q8siY2FWVSm8Zq18I3exMVlsXOnpSj7ooJjnubt3V/Cbb+OQCO1F+MelkiTPkMGNnrlzc5U27fQm51nBoOT1yoihqG14var8772yyivkHTasZYF/Evj6G5VecqmSjz5a6b/6Oyj1+OOUctyxMgxDwYULJZdLvpEjY97DrKmRKyVFZnm5Km/7l5J++1ulPXCffGPGtCo7AAAAAGdxwh0AEFeulBS50tNbPD+0fLlCy5fbmChxzNJSSZIrN6fFa1Q/+piKjj3O0YtTy666WoGvv455nrtHj4bTweicQkuXyt2rV7N/B9R98onqPvmk0evVzz6nzSNHy4rhzTrD41HSAQeo9v33W5xXksJr16rkD2fKN3aMsm+/rcmi/7bXKu+8S0VHHq3at96Oen2zvFwl552vLfvsKysUkqdnT3Wb/61y/nsXxXYAAACgA6DgDgCIm7pPZ6vopJNb3MNcksr/cYMqbvuXjakSxywqkiS5clp+wt07epSsykrHLk6NbNqs6iefkllcHPNcd/fuMktLZdXWxiFZY1YopK3HHKvgokUJ2Q87F/pxqTw7aIlU/dTTqnr4kUavh5cvl7trl5j7lycfdKDCPy5VeG3L/7wYqany77O3ch5+WIbfv8OxOffeo6QDD1DJOeeq8r/37PQy1fDq1dp6+BGqmz1b6X++WPppvKuZtjoAAAAA2h8K7gCAuAn98IOCX38jIyWlxWu4UtPa7aWpZnm5pPpe7C3lHV3fvz64aKEtmWIVnDdPkuQbNy7mucmH/lbdly+VkZxsd6wmhdeuVfDLuap5eUZC9sPOWXV18o4Y3uxzT//+Cq9e3ej10NJl8g6J7c4ASfJP3Ufy+1X3/gcxz7WCQUW2bpU7L0859/xX7pzsnc4xkpOVfe89Sr/kz6r4560q/8cNzY4NfPGFthx2uGRZ6vLGG0o95WQZPl/MOQEAAAC0bfRwBwDETWT9ern79I6pD/OvGakpMjdtsjFV4vgnT1aPtaslV8vf33bn5Mjdq5dC3y2UjjjCxnTRCc6bJ3evXnJ37RrzXCM5WfZcKxmd8Kr6wm36ueckcFfsSP5LL+zw1LdnwABF1m+QFQxuV3wOL1sm/x5N93ffEVdqqjKvvCLmi5Yty1LZ5Vco8PU36vrJRzEVwg2XSxl/uUyeAQPk3tEF0R6PfBMmKufuO+XKyoopHwAAAID2gxPuAIC4Ca9bL0/vPq1aw0hLk1XT8pY0TjM8HhmtKLhLkm/iBJnVNTYlik1w3nz5xsd+ul2qvzS26ORTVNuC08YtEV69WkZSktSKN3hgn22F9h294ebp318yTYXXrWt4LVJSIrO4uEUn3CUp7Zyz5d9tt5jmVN55l2pemq6Mv1za4lPnKUcfJf+uE2WFQiq9/AqFVqyQFYmo6oknZYVC8u+6q/KefJxiOwAAANDBUXAHAMTNthPureHOzZWR3PKWNE6qevxxFZ95VqvXyb7nv8q+9RYbEsUu5aQTlXLiCS2aa3g8Cn63UOEff7Q5VdMimzbJqqtTwa6TZNXVJWRPNK/m2efqfy3C4WbHeAYNlH+//aRfXI7qys5Wt/nfyr/v1Jbv/fIMBb74IrqxL01X5e13KOOKy5Vy1FEt3nMbs6xMwW++0dbDj1DRCSeq/JprFfzmm1avCwAAAKB9oOAOAIibjCsvV8qxx7RqjfSL/6Qub75uU6LECi9brsi69a1exzAMWZa1w8JlvKSecLyS9tmnxfPd3bsrsnmzjYmal/WP65X34guSaSq0fHlC9kTzQkuXykhJkeFpvoOhu0sX5T31hLy/uFjVMAy5u3SRKzW1xXtXPfaYqh59fKfjIiUlKrv6b0o56USlXXRhi/f7JXd+vvJfe1W+iRMU+n6Jcp96Qv7dd7dlbQAAAABtHwV3AEDcJB98sHxjxjgdwzFmcYlcubmtX6e6Wpt3GaXat96yIVX0Al9/rdp3323VGu4ePRJWcJck79gxkmEotOSHhO2JpoV/XCrPLwrpzTGrqhTe+PM9DZX33KvyG29q1d7JBx2kwMyZihQV7XCcOydHeS+/pKxbbm7VXRO/5kpPV+6TT6jbvG9a9YYVAAAAgPaHgjsAIC6qHn9CNa+1/mR67bvv1relCARsSJVYkeJiuXJzWr2OKzVVrvR0hRYusiFV9KqffFqV99zbqjXqT7gX2JSoeVZtrQr33V/BefPl7ttXoR8ouDsttHSpvMN2XnAvu+yvKr34zw1f182cpcj6Da3aO/nwwyTLUsGEXVX292saPY9s3aqKf/9HViQi3+jRMrzeVu3XFMMw5EpOtn1dAAAAAG0bBXcAgO2sYFCVd/xbwfnzW7+YaSmyaZPM6vZ3capZXGzLCXdJ8o4epeB3C21ZK1rBefPkGz++VWukHn+c0i+71KZEzQuvWaPwsmUykvzyjhihyNq1cd8TzYsUFcksKtquVUxzPAP6K7x6dcPX4WXL5BnasgtTG9bs319d536hzOuvk3fkLvXrrl6t0suvVODzOSqedoaqn35a5k5OwAMAAABArJpvqgm0UYFAQJdddpnee+89JSUlacyYMXr66aedjgXgF+re/0BmSYlSTzqx1WsZafV9nK3qaimn9afFEynzumvkysuzZS3f6NGqvPd/skxThiv+75dHSkoUWbNGvvHjWrWOb0LrCvbRCq+qL9h6BgxQ9l3/kcHJYke5cnLUdfancuXv/Pe/u39/mQUFMmtqZNXWyiwulnfw4FZncOfmKu2MaQ1fhzdsVGDmTNU884yMlBTlzZgud9eurd4HAAAAAH6JgjvanSuvvFKGYWjZsmUyDEMFBfFvVQAgNtXPPy/v+PFRnW7dGVdqmiTJqqpq9VqJljR1qm1reUePklVZqcjatfL072/bus0Jzav/dEJrT7hHiotV++prSj7yCLltOu3flPDq1TIyMuTKybG1FzdaxnC55BkQ3e/Tbb+fI6vXyKwor3+tlSfcm5K01xR1/XKOgl99JSMtTb6RI23fAwAAAABoKYN2pbq6Wo888ohuuummhoJKt27dHE4F4JfCGzcqMHOWLafbpZ9PuJtV7auljFldrcp7/6fwhtb1ot7Gv9tu6vbNV3L362fLejtjJCcr+fDD5O7du1XrmKWlKr/2OoWXLbMpWdPCq1bJM6C/DMNQpKRUWw48WHWfzo7rnmhe5f/uU+Vdd0c11jNwgOR2K1JQIM+AAcq6/V/yxOn3ueFyyT95MsV2AAAAAHHDCXe0KytXrlROTo5uvvlmffjhh0pOTtb111+v/fffv9HYQCCgwC8uWayoqEhkVKDTcufmKvu/dynpwAPtWa9PH+U+/5y8cTjxGk+RzZtVcfMt8k2cIE+vXq1ez0hOljuBbVL8e+4h/557tHodd/fukhT3i1PTzj1HZnn96WhXVqbCa9cq9P33Stp7r7jui+1ZkYjCa9aq9pVX5Rk2LKo5ruxs9Vi5vOHiUrverAMAAAAAJ3DCHe1KOBzW2rVrNWLECH3zzTe6++67dcIJJ6iwsLDR2FtuuUWZmZkNP3q38pQmgOgYSUlKOeooudLSbFnPlZyspL2myJWRYct6iWIWF0uSbZemSlLVY4+r9LK/2LbejgQXf99QwG4NV2qqjMxMRTZvtiFV87xDh8q/226S6k8xe4cNU2jJD3Hds7OzQiHVffiRgosXS5LqZs7UpiFDtWXvfRRaskT+SbtFtY5hGA3F9upnnlXgyy/jlhkAAAAA4o2CO9qVPn36yOVy6ZRTTpEkjRs3Tv3799eiRYsajb3qqqtUXl7e8GP9+vWJjgt0OoHP56jk/Atk2thv3bIsVdx6m4Lz59u2ZiKYxSWSJFeOfQV3q6pKtW+9Lcs0bVuzyX0iEW397aGqfe11W9Zzd+8W14K7WVWl8htvUnjNmobXPMOHK/TDkrjtCan0sr+q+PRpqnlxuiTJO2SoMq+6SrnPP6du879V6qmnRL1WxZ13qfjMs1Rx278U+HxOvCIDAAAAQNxRcEe7kpeXp/3331/vvfeeJGn16tVavXq1hg8f3mis3+9XRkbGdj8AxFf1M88otOQHGamptq1pGIYqH3hQwQXf2bZmIpjFxZLbLVdWpm1rNlycumatbWs2xSwuliIRubp1tWW9pAMOiFtPbkkKr1ypqvvu3+5EvnfEcIWXr5AVDMZt386s5rXXVfvyy8r69+3K/Md1kiR3j+5KO+tMJe01Re4uXWJb0LJU9/4HMouK5Bk8OA6JAQAAACAx6OGOduf+++/XmWeeqSuuuEIul0sPPPCAevbs6XQsoNMzS0tV++57yrj8Lw2XGtvFlZoqy8ZT84ng6tpVyUccIcNl33vb3lGjJUl1s2crbUB/29b9tchPbbrcNl1KnXnVlbas05zw6tWSJE//n78nyQcfJO+I4ZKN33/Ui2zarLKrrlby7w5XyvHH2/Ln3dO/n/TTJzfa230NAAAAAPBLFNzR7gwYMECffPKJ0zEA/ErNK69KkYhSjj3W9rWN1FRb29QkQvJBByr5IHsujt3GnZOt5COPUOXd/1XqSSfK8PlsXX+bbRecurvac8LdCgYVKSyUJ053aYRXrZYrL2+7Pv/ubt1se8MA2zNLS+UdMVxZt9xs25trngEDfv7v/eP3ZhIAAAAAxBvHvgAAtqh56SUlHXiA3Hl5tq9tpKXKqq62fd14ihQU2HLp6K9l/uN65b3wfNyK7VJ9r3gjJUUum34ta2bMUOHkPeLW3iW8enWTRdqqhx5W9QsvxmXPzsy7ywjlT39Jrqws29bc9utnZGXG9fc2AAAAAMQbBXcAgC1yH3tUmVdfHZe1kw89VL6xY+OydryUXnyJyi63v5WKOy9P3kEDZdXVNbRSsVvK0Uep+7IfZbjdtqzn7t5d0s+tauzmnzRJKUcf1ej1wJw5qn3ttbjs2RmFlvygrcedoMiWLbav7UpPV+4zT6nrrJm2rw0AAAAAiURLGQBAq1mWFdf2HRmX/Dlua8dLpLhYnoEDdj6whUovv1Kh+fPV5YP3ZCQl2b6+nX34t51eDi9fEZe2MqmnntLk694RI1T97HO279cZWXV1KrnoIskwtmvdY6ekqVPjsi4AAAAAJBIn3AEArWLW1mrLPvuqbubMuO0RKSiI22nueDFLiuXKzY3b+ukXXqDw+vWqvOde29cuuehilV13vW3ruXv3lpGZqdCiRbatuY1ZU6PAF1/IrKlp9Mw7fLjMLVsUKSqyfd/Opvyftyq8arVy/nt3XN7gAQAAAICOgoI7AKBV6t58S+GVK+Xp1y9ue1TceptKL74kbuvbzbIsmSWlcuXmxG0P75AhSr/gfFXec69CK1bYunb4xx8lG/utG4Yh7y67KLxxo21rbhP6fomKjj1ekTVrGz3zDB9eP2bJD7bv25nUffqpqh96WJlXXSnvT99TAAAAAEDTKLgDAFosMOcLlf39Gvn33z+uBXcjLU1mdVVMcyzLkiRFSkoV2bw5HrGa37uqSopE5MqJ3wl3SUr/00Vy9+ypsiuubPj52iFSWChX1662rSdJeU8/qezbbrV1TUkNn3xw9+/X6JmnX1+lXfhHubvHr91RZ2CWlCjp4IOUetaZTkcBAAAAgDaPHu4AgBYJfD5HRaf+Xv7Jk5Rzn/1tTX7JSE2VVVUd05yKW/4pqy6gwMyZ8u06Udl33B6ndI250tPVY80qycYieFOMpCRl3/EvmRUVtvVct4JBmcXFcnezt+Bu+P22rrdNeNUqubt3lys5ufGebrcyr7L/4trOJuXII5V8xBG29vUHAAAAgI6KE+4AgBbxjhqptHPPUe7jj8mVmhrXvVypqTKroj/hXvv++6q6939y9+imlGOOVu2rr8ksK4tfwCYYbrcMT/zf1/ZPnqzkgw6SZVmyAoFWrxfZulWSbL8EN1JQoII9pygw5wt71129Rp4BzV9OG16zRrVvvmXrnp1JeONGBefPj/ubRwAAAADQUVBwBwBEzbIsVT34kMJr1siVkaHMK6+I28nlXzLS0yRFV/ALr1mj0osvUdIhByvt3HOVctKJssJh1Ux/Ob4hf6Fu9mfacvgRMisrE7Zn6Z8vVelfr2j1Oq6cHOW98Lx8Y8bYkOoX6+bnyywoVNDui1M9bnl3GdHs47qPP1HJRX+SFQrZu28nUTvjFRWddIrE6XYAAAAAiAoFdwBAVCzTVPl116v8HzeobubMhO6dNm2aeny/eKfjrNpalZxznlw52cr+9x0yDEPuLl2U/JtDVP3U07b2Od+RyPr1Cs2fL6OJNifx4h00ULVvvdnqn6MrOVn+KXvKlZ1tU7J6htstz4gRCi3+3tZ1c+69R5nXXdvsc+/wYVIwqPCqVbbu21mEli6Vd+hQ2skAAAAAQJQouAMAdsoyTZX+6WJVP/qYsm65WWnTpjkdqWmGId+uE5XzwANyZWY2vJx6+mny9O8nq6IiITHM4mIZmZkJaSmzjWfgQKkuILO0tFXr1M3+TBV33mVTqu35Ru6i0OKdv3ESLcs0d/oGg3f4cElS6IcfbNu3MwkvXSbP0KFOxwAAAACAdoOCOwBgp4LffKPaV15V9p3/Ueppv0/8/vPnq3D/AxTZtLnZMWZ1tYykJGXddKN8I3fZ7pl/993re83/oggfT5HiYrlzcxOy1zbunj3q9964sVXrBD77TDXPv2BHpEa8I0cqvGKFzNpaW9YLfjlXm4cOV3jdumbHuLKy5O7RQ6EffrRlz7Yu8NVXqrj9DtW89nqr17LCYYVWrJB3GAV3AAAAAIgWBXcAwM4ZhpIOPkjJRx3pyPZWxFT4x6UyK8qbfB76fokKdpuswNdfN79GOKzad99VZMuWeMVsYBaXyJWbE/d9fsndw56Ce2Rzge0Xpm6TdMjB6vLuOzJ8PlvWC69aJau2dqd5kw4+SK6sLFv2bI3gokUK2thSx4pEFFy4UJUPPCgrEpEkVdz8T1XeeZcqbfiUgllcLE/fvvVteQAAAAAAUUncZ90BoJ2yAgFZNTW297RuT/y77ir/rrs6tr8rLVWSZFZVN3pmRSIqueCP8vTsKd/Ikc2uYVVXq/TCPyntwj8q488Xxy2rJKVNO11mTU1c9/g1V16eunzwvtz9+7VqHbOwUO6uXe0J9Svu3FxbT/6HV6+Wu3evnRbws278P9v2bI3Siy5WeMUKpZ56ijKuvKJVbwJEiou19beHKbJhg4zkZCUfeKA8A/or5+EHVTP9ZVX+63ZZltWq3uvurl3VdebHLZ4PAAAAAJ0RJ9wBYCdKL/6zCvc/QGZZmdNRHGGFwwp89ZWsQMCxDEZaWn2WmsYF97p331N4xQpl3fbPHV5S6srMVPKRR6jmmWcbTgPHi2/CeCXtNSWue/yaYRjyjhguVysvao0UFsoVp4K7JFU9+JAqH3jQlrXCq1fLM2DATsdZlqVIYaGsujpb9m0Jq65O4ZUr5d93X9W8+ppqXpreqvUCn89RZMMG5T7zlLovWSzPgP6SJHdeXv19BXV1MrdubV1mB//MAwAAAEB7RcEdAHYgtHKVat98S2bhFpX/4wan4zgi9P33KjrqGAUX2XfZZayMlPoT7tavTrhblqXK++6Xb/fd5Rs7dqfrpJ72e0U2bVLdRx/FI2aDqsceV3Dhwrju0eS+jzyqynv/16o1kn9ziPxT9rApUWOhH35Q7auv2rJWeFV0BffwypUqGD9RwXnzbdm3JaxAQGnnnavMa/6mrrM+Ueq00yVJ1U8+pdCS2C90Dc2fL3fv3kqaOrXRCX/fxInKfepJGenprcpcctHFKj7zrFatAQAAAACdDQV3ANiBurfekisvT1m3/0u+3Xd3Oo4jAl98KSMpSb7RoxzL4MpIV86DD8g3bux2r1u1tXJ3yVf6+edFtY5v9Gh5x45R9ZNPxSHlT5ksS+U33qjg19/EbY/mhBYvVu2777VqjYwrLlfyQQfZlKgx78iRCv24VFYo1Oq18l58Xul/vGCn4zz9+kl+v0I/xF7YtosrM1OZf7ta3iFD5O7aVYbXKysYVNWTT2rLIb9R+f/dKMs0o14v7YLzlXN/02+uuHNzlbTfvq3+tEN46dKGuwEAAAAAANGhhzsA7EDaRRcq5fjjtruU0TJNGa7O835lcO5c+SZMsO2iy5YwPB4lH/rbRq+7UlKU++gjMa2VfvGfFNm0udX9rZtj1dRIdQG5chLf89/ds6fqPv20xfPNqiqFV6yQd9gwGUlJNib7mXfUSCkYVHj5CnlHDG/VWu4uXaIaZ3g88g4ZotCSJa3arzWC330nuT3yjdzl51w+n7q8/ZYq77lXlXf8W0mHHBz1XQnu/Hy58/ObfV716GNy9+6t5AMPaFFeKxBQePVqpZ3NCXcAAAAAiEXnqRgBQIzCGzdJ0nbF9rKrrlb5Ndc6FSnhLNNU4Kuv5Js8yekoqnriSQXmzm34Orx6tWrffCvmfuzJBx2ktGmnx6XYLklmcbEkyWXj5aDRcvfoIbNwS4tPj4cWLdLWQw9XeMNGm5P9zDtihGQYCi5a1Kp1At98q5LzzpdZURHdvsOHKfjdQlmW1ap9W6rijv+o4tZbG71u+HxK/9NFMlJTFfxybhMzGwstXaqSP/1ZkR30aK+ZMUN1b7/d4rzhlaukSESeoUNavAYAAAAAdEYU3AGgCWZlpbYccKCqH3l0u9c9gwap+vEntiv8dmRmcbE8PXrKP3my01FUdd/9qvtkZsPXlf+7T2XXXiuFwzGvFd6wQWXXXR+XSzQbCu45DhTce/aQLEuRgoIWzY8UFtav0y1+l6a60tKUecM/5BszulXrhBYtUu1778tITY1qfNJvfiOzpFjmTz/HRAsvXSrv0KFNPjM8HqUcd6yMjIyo1gp88aVqX3tNrp8uE26Kp08fhdevb1FWSQot/VGS5B1CwR0AAAAAYkFLGQBoQvUzz8iqrW3UxiT1jGmqff0NlV72V3X94D0ZreyR3Na58/PV5YPW9QS3i5GWKqu6/tLUyJYtqpn+sjIuu1SG3x/zWlZdQNUPPyKzqKi+R7VlKfXUU+Tp1091H32s0NKlSjv7LBleb+w5k5KUdPBBcS1aN8c7dKgyrryixb8vIwWFMlJTd1jItUPaH85o9Rrh1avl6dNHhtsd1fjkgw6Uf4/d5UpLi1s7oeaYlZWKbNjQbMFdkrJuujHq9YLzF8g7YvgOf53dvXu36h6B5COOkG/iRLkyM1u8BgAAAAB0RpxwB4BfsQIBVT30sFKOPkru7t23e2a4XMq641+KbNqkijv+7VDCxIls3epYC45fc6WkyqqqklTfn9rwepX6+1NbtJZ30EClnHySggsWqPbtt1X7zrsyS0olSaEVK1Txz1tVdd/9LVt7+HDlPvqI3Hl5LZrfGu5u3ZR+0YUt3jtSULBdC6V4CW/YoKqHH4npktBGa6xaJc+A/jHNcaWlyayqUtHxJ6r23XdbvHeswsuWS5I8w5ovuFuWpfCaNYoUFe10vdD8+fKNH7/DMZ6+fRXZvFlWMBhb2J8YLpc8vXu3aC4AAAAAdGYU3AHgV2pefVVmQaHSzj+vyefeQYOU8ZfLJMNoM8XoeLAsS1sOPFiVd97ldBRJ9SfczeoamdXVqn7qKaWcfFKrTt9m/+s2dfv8s59+zJZv/DhJUvq55yjtvHNVceddCq1YGfO6kZJSRX5qK+OEutmftbw/umnK3bevvYGaEF61SuXXXa/w6jUtX2P1ann6x1ZwlyQjOVmu7GyV/PFCBVpxAjwWZk2NPEOHyDtoUPODQiEV7n+Aal6eseO1ysoUXrlSvnHjdjjOO3q0Uk8/rcVtk4rPOls1r7/RorkAAAAA0JlRcAeAXwuGlHLC8fIOHtzskPQLzlfm3662tS1F4Kuv6k/efvBhmyjkh1etlrl1q3xjxzgdRZLk32MP+caMluF2K+Pyy5V29llx2yvjkj/L3aOHyv7615hPYVf973/a+rsj4xMsChU33qTqp59t0dysG/6hvKeesDlRY96RIyVJocWLW7xG+p/+pOTDDot5nuF2K+fuO+UbO1bF085QaMWKFmeIVtJeU9T144922ALG8PnkGz9BwZ3dD+F2K/OmG+Xfc48dDvON3EVZN90oV5R94X/JrKlR3TvvxuWOAwAAAADo6Ci4A8CvpP7+VGX/+46djrMsS5X3P6Dat962ZV+zpESBzz9XybQzVHT0MQp8/fVO54SWL1fJBX+UFQrZkuGXgnPnSi6XfBMn2r52S6Rf+Eel//ECGUlJSjv9NHl69ozbXkZysrL/dauscERmWVlMc83iYrlzE39h6jbuHt0V2bTJsf2j4c7JkbtHD4W+/77Fa6SecHzDpxJiZSQlKfeRh+Xu2kXFJ58qs7KyxTmiYVZURDXOP3mSAnO/2uGbPK70dKVNO71Ru6umhH74oUUXp4aXLZMkeYdyYSoAAAAAxIqCOwD8QtUTT0bVQ1mSDMNQzXPPKzBnji17Jx9yiHpsWKfcZ56SVV2joiOPVvBXJ4DN8nJVP/2MKm7/6Q2BYEi1r72u4HcLbcnwS4Ev58o7che50tNtX7slzMpKVT38iEr/enlc3mD4Nf/uuyv/9VflzsmJaV6kuESu3Njm2Mnds6cimzbGPM+yLBVM2n2nLU3s4h25i0ItbH0TWrFCNS9NlxUOt3h/V1aW8p5+WukX/ynuv8cL99lXlXfdvdNx/kmTZJWVNRS8m1L9wgtRt8Ip/sNZqn7yqahzbhNaulQyDHl28CkfAAAAAEDTKLgDwE8CX32l8qv/puD8BVHP8Y4dq+CC6Mc3xywtre+7bVlKmjpV+e++rdznnpFv5EhZlqWKO+9SyXnna/O4CSq76mqFliyRZVnyDB0iIyVl520oWiC8aqV8kybZvm5LVd5zr8qvu16RdetleL0J2dMwDAXnzVfZdddH3ebHLCmWy8kT7j17KrIx9hPuVnm5Ihs2yPD54pCqsaSDDmpoLROruo8+VtlVV0tud6syuHt0V+opJ0uSrNraVq3VnEhJicwtW+SOot+8d8J4ubt3V2Tz5iafW5aliv+7SYFZs6La29OnjyLrWnDC/celcvftI1dKSsxzAQAAAKCz8zgdAADaiqp775NnyBAl7b9f1HN848ao9rXXZAUCMvz+Fu9d+8GHKrvkUnVbtFDunGwZLpeS9t5bkmQWFKjmmWdlZGYo4/K/KOWoo+Tu2rV+oscj364TFfhyrtL/eEGL929K/huvS4GArWu2RmTDBklS2vnnJnbfLYWqfvgR+caPU8oRR+x0vFla5mjB3TNokLzDhsmqq5ORlBT1vEhhoSTJ1a1rvKJtJ/WkE1s8N7RggTwDB9p2h0LZVVcrtHy58qe/ZMt6vxReulSS5B02dKdjXcnJ6vr13GZ/XpG1a2WWlu70wtRt3H16t6hPfvIxR8u3++4xzwMAAAAAUHAHAIVWrFDFTTer7sMPlX3nf2S4ov/wj2/sWCkUUmjJkqiLYE0Jzpkj74gRcudkN3rm7t5d3b5u/gS7f9IkVd53v6xIREYrT/xuY5lm/fchhoJtvKWdfZZcmZny77NPQvdNPuQQJR16qMqvuU7+vfZu8tfol7rOniUloOVNc5IPPEDJBx4Q87xtBfeGN3PizLIsRdaulZGUJHe3blHPixQUqPbtd5T5t6tty+IZMkTVzz0vs7partRU29aVfmrP4vXKE8UJd6n+UxVmRYWM9PRGhffg/PmSJO+4sVGt5enTR7VvvxNTXknyjRwptfDTBwAAAADQ2dFSBkCnZJmmwht/7nMdXrtWWf++Q8nHHhPTOt7hw5V24R/lyt5xEXaHWSxLgTlfyLdHy06UJv3mEGVefZWtRd6yq/6m4nPOs209O/jGjlXWzTfZdqo5Flk33iArElb5P27Y6VjD5WrVpx3sYIXDsmL8dEKk4KeCe5cu8YjUpK2HH6HqZ5+LaU71E0/KSEpSSitOyP+af6+9pFBIwblf2bbmNuEVK+UZNDDqNkiBuXO1ecRIRVavafQsOH+B3P36Rn2vgKd/f7nS02XG0C7HrKhQxX/uVGRT021tAAAAAAA7RsEdQKdiBYOqfuEFbdnvABUdf4KsSETeQYPU5aMPlXrC8TEXcw2/X5lXXSlPv34tzhRZt06RjRvl33OPFs33Dhmi1NN+H1P7kJ0Jzpkjt4MXf7Y17i5dlHntNQp8+qkiJSXNjosUFGjLYb9TcKH9l9hGyzJNbRoyTDUvvBjTvKT991Pe9Bdt/X20I4ZhtOjiVN+ECcq46gpbLzr1DBwgd/fuqvv0U9vW3Cbzhn8o78Xofy28I0ZIhqFAE/cyeIcOVerJJ0e9VvJhh6rbl3PkSk6Oek7oxx9VefsdMsvLop4DAAAAAPgZBXcAnUr5dder7NK/yNO/X337mJ9asLTm1HR43TrVTH+5xfMjhYXyDBggfysuKA189ZWqYyywNptnyxaFV62Sb3LbuTC1LUg5/nh1nfXJDk8XR7ZsUeinth9OMVwuufPzt/sERzTcubnyJ7hvt3fkSIUWfx/TnKQD9lfatGm25jAMQ/6991IohguTo17b5dppG6JfcqWnyztyFwW++LLRs9RTTm7RXQ3RXvgr1V+YKo9HnoEDY94HAAAAAEDBHUAnE/jqK6WceqpyH3tU/l13tWXN4NyvVHrxn2WWl7dovn+33dR19iy5MjNbnCHwyUxV3HhTTIW15mxrq+HfbbdWr9WRGIYhV0aGIlu2NNuuxSwuliRHL02VJHfPHops2hTTnKrHH1fNS9PjlKhp3pEjFdm0aYefGtjGMk2VXf03hb5fEpcsmddeo7wZ9v78IwUF2nLoYQrG+KaCb9IkBX91wj1SWKjgvPmyIpGY1ircZ19VPfhQ1ONDS5fK07+/DJ8vpn0AAAAAAPUouAPoVHxjxrS4dUtztl1gGPwu9jYilmUpsrn1vZJ9u0+WWVKi8IoVrV4r8NVX9X2iu3dv9VodTXjVahWMm9Bkuw9JMktKJSnqHtvx4u7ZU5EYT7jXTJ+hwBdfxClR07wjR8qVnx9V1sCsWap+4kmZlRVxyeLKypLhdtvyptU2oR9/VGjBd3Klp8U0zz95kiJbtypSVNTwWu2bb2nrMcdK4XBsIbxeRdaujXp4aOkyeYcOjW0PAAAAAEADCu4AOpXsf9+hlN8dbuuangEDZKSnK7RgQcxzwytXqWDibgp8PqdVGXwTJkhuty2XPmb+/W/Ke/qpVq/TEbn795OrSxcFPp3d5HOzuFhGSoqMGHpmx4O7R4+YL700Cwvl7tYtToma5hnQX90XzJNv1Kidjq166GF5R42SrxWtl3am9K+Xq+zyK2xbL/TjUhnJyXL37h3TvKR991WPJYvlzstreC04f768u+wS84W8nj69FV63Lurx/j12V9LBB8W0BwAAAADgZxTcAXQakaIiRTZvtvUEq1Tfo9k3ZoyCLSi4B+fMkTweeceOaVUGV2qqvKNHNXvyOhaG3y9P//6tXqcjMgxD/ilTFJj9WZPP/fvtq6w7bk9wqsbSzz9PXd57J+rxlmkqsmWLXF27xjFVY9vuTgh8/Y0s02x2XGjpUgVmfaq0s89q1X0LO+NKT1fdxx/b9ndEeOlSeYYOkeGK7Z9bht8vIylpuxzB+fPlGz8u5gzuPn0UWbc+6vEZl16ilKOPinkfAAAAAEA9Cu4AOo3qp59R4QHxObmZdPBB8vTtG/O8wOdz5BszRq7U1FZnSD3xRPnGxV6Q+6W6mTNVdNLJMquqWp2no0raey+FFi9usu+4d9Ag2z9B0RKurKyY7gQwi4ulcFjuboktuEtSeMMGFR13vMr+8tdmi+5Vjz4uV9cuSj78sLhm8e+9l8yCQltaM0n1bxS0tD1L1WOPa+uh9T/fSEmJImvWyvdT+6pYePr0UXj9+h2+obFNpLBQwcWLoxoLAAAAAGgaBXcAnUZ4+XJ5hwyOywnZtD+coczrro1pjmVZCnzxhW095VNPPUVpfzijVWsEPp2t8PIVMmx4A6Cj8k/ZU0ZamsLLljV6VvvmW6qbOTPxoX4lUliootOmRX/BqMultHPOlnfIkPgGa4KnVy9l33G7al6arrLL/tLkpaAZf71MOfffF/eLPH2TJkk+X7Mtg2KVef11Sm3hn0lXTo5C3y1UZMsWmYWF8gwdIt/48TGvk3z4YVF/2qH2jTe19XdHShTcAQAAAKDFPE4HAIBECS9bLm8rT4DvSKSgQJKi7oMd2bRZVigk3x72XeIanD9fRnKyvMOGxTw3MHeuqp54QqknnhjXth3tnbt7d3X/fpEMT+P/Ca168CG5+/dX0tSpiQ/2C0ZysgIffaTQMUfLu8uInY535+bG/IaRnVKOOVpyGSr9058ly1LWHbfLcLsl1b8x5c7L266feby4kpPlmzhRgc8+U9qZf2j1ev7ddmv53En1c4Nzv1Ly4Yep68cftWgdd36+3Pn5UY0NLV0q76BBTf7eBgAAAABEhxPuADoFKxJRaOVKeYcMjtseWw49XFWPPhb1eE/PHuq+eKH8e+xuW4bSv16uqocfiXlecPH3Kj79DPnGT1DmNX+3LU9HZXg8MmtrG/X6jpSUyJ2X61Cqn7kyMmSkpyuyaVNU48Pr17foDgI7pRx1lLLvvlPBRYtkVVRIkqxgUFsOOFC1776bsBzZ/7pV2f+9u9XrBBcsUMV/7pQVDLZovrtbN7n79VNg7lxFSkpa3FfeMk2VXnGV6j79dKdjw0uXydPCFjgAAAAAgHoU3AF0CmbhFhk+nzxxLLj7xo1VcP6CqMdboZAMt7vhJK8d/JMmKfBlCy5ODQTkGzdWuY8+LCMpybY8HVXg62+0ecRIRdas2e51s6RErlznC+6S5O7RPeqCe82LL6n4D2fGOdHOpRx1lLq8+45c2dmKlJSq5pVXFf5xqTwDByYsg6dfP7nS0lq9TmDWp6p6+GHJ623xGv7JkxT44gsVTtlbVfc/0KI1DJdLde+/r+DX3+xwnGVZ9Sfch1FwBwAAAIDWoOAOoFNw9+iu7j98L/+UKXHbwzd2rEILF0Z14aAViahg10mqfvY5ezNMmqTI6tWKFBZGNT5SXFzf1mbCeOU996xc6em25umovMOHSaapul/0+rZCIVnl5XLl5jiY7Gfunj0V2bgxqrGRwkK5uyb+wtSmGF6vrFBIRccdp7IrrpR/36nyDo7fG2VNKf3r5apsYYF7m20XpramPVP6JX9W1k03yiovj6o1UHM8vXsrvHbdDseYpWVy5ee3qB0VAAAAAOBnFNwBdBqGYchwxe+vPd/YsbKqqhReuXKnY0NLlsjculWe/v1szbCt73Ng7lc7HWuWlqrouONV9jdayMTKlZYm3/hxCnz2WcNrVl2dkg45WJ4BiTuNvSNpfzhDqaeeGtXYSEHbKbhL9UX39Isvrv/PCy5I+P5mWbnq3n2vVWtsK7i3hqdXL0XWb5Ak+caMafE67r59FFm/44K7Oydb3T77VEn779fifQAAAAAAFNwBdBKll1+pkosviese3jGjZWRlRnWqOPD5HCnJL9/48bZmcHftKv/++0s76fdsVler6Peny9xapLRzzrE1Q2fh32svBT6fIysSkSS50tOV+8jD8u860eFk9ZL23VdJ++0b1VizsFCurtFd9psoKb87vP5TKTbecRCtpL33UnDePJmVlS2ab4VCCq9cZUs/9NI/1/+95crMbPEant69FV63kxPuFRUt7hMPAAAAAPiZx+kAAJAIoUUL5R3R8pYM0XClp6v74kVRtZAIzPlC/om7yvD7bc+R9+TjO3xuBQIqOetshZcvV95LL8g7qG2cyG5v/HtNUeV/7lR4+XJ5hw2TWVMjq7partzcuH6SIlqRzZtV98GHSjnuWBnJyTscayQlydOvb4KSRc/wOPPPFP9eU6RIRIEvvlTyQQfGPN+qq1PaGdPk3223VmfJ+PvfWv198O+3n4yMDFmW1ezfT8XTzpBn0GBl3/bPVu0FAAAAAJ2d8xUBAIgzyzQVXr5CngT0gTYMQ1Y4vNM8wW+/jdvJXcuyFF63TmZtbZPPa155RYG5Xyn3sUflGz06Lhk6A9+4ceq+eGFDz+u6999XwdjxsmpqHE5WL7xmjcquulrhjTu/ODX/tVeUfv55CUjVPnj69ZO7Tx8FZs/e+eAmuNLTlXndtfKOGN7qLOnnn6e0s89q1Rr+iROUft65zRbbw+vWKTj3q4aWVAAAAACAlqPgDqDDi2zcKKu2Vt4hQ+K+V83rb2jz8F1k1dU1O8ZwudRt7hdKPf20uGSIbNyowt33bLZYmHLCCery/ruOtOroSAyPR67MzIY2HGZxieT3y0hNdThZPXfPnpKkyKboLk7F9rLvvlPp55/fornBxd8r9MMPNidqOSscVu377zfbVqbm5RkyUlKU9JtDEpwMAAAAADoeCu4AOrzwsuWSJM+Q+J9w9/TtI6umRqHvl+xwnCstTa6srLhkcPfsKXePHgp+ObfhNSsUUskFf1TtG2/KMAx5Bw2Ky96dTd3Hn6hg4m4ya2pkFhfLnZMTVUuhRHB36yYZhiI7OeEenD9fm0eNUWjFzi/77Uz8u+4qd4/uLZpb+Z//qPyG/7M5USsYhkrOOU91H3/c6JFlWap5eYaSfvMbuVJSHAgHAAAAAB0LBXcAHZ5v8iTlzZgud48ecd/LO3y45PMpuGBBs2NK/nihKu+6O24ZDMOQb/IkBebWF9ytcFilf7pYtW+9Lfm8cdu3M3L37iWzoEDBr75SpLhErtxcpyM1MHw+ubp22eklvpHNBTJLSuTKyU5QsvbBMk2V/e3vqn333Zjnhn5casuFqXYx3G65e/ZUZG3jE+7m5gJZVVVKOfZoB5IBAAAAQMdDwR1Ah+dKTZV/0qSEXGRp+Hzy7rKLggu+a/J57bvv1he+k5LimsM/aZJCixbLrKhQ6Z8vUe1bbyvnvv8p+eCD47pvZ+MZNEiubl0V+HS2zNJSuXJznI60naT9D5C7S5cdjokUFko+n1zZFNx/yXC5FPx2Xv2f1xiYtbWKrF0r77C2U3CX6j99E16/vtHr7h7d1e2br+SfMsWBVAAAAADQ8XicDgAA8VZ+8y3yjRmj5EN/m5D9fOPGKjDr00avVz/3vMouv0LJv/2t0qadHt8MkyfJlZmpkj9eqMCsT5Vz7z1K/u1v4rpnZ2QYhpL22kuB2Z8p//13d9i73wnZt/1zp2MiBQVyd+3aZlrhtCX+vfdSzQsvyopEZLjdUc0Jr1ghWZa8beiEuyS5e/dRaN687V6zQiGZJSVyd+3qUCoAAAAA6Hg44Q6gQ7MsS9VPPKnw2rUJ2zP94j8p/603tnutbuZMlf3lr0o95WRl/+8eGX5/XDN4Bg5Ut4ULlH3brcp58H4lH35YXPfrzPx77aXQkiX1bVmSk52Osx0rHK4/wb4DZmEhBddmJB92qMyiItV9/EnUc6y6gNy9e8uTgEuaY+EbNbJRW626T+rvIGjuMlUAAAAAQOwMy7Isp0MAiVBRUaHMzEyVl5crIyPD6ThIkMimzSrYdTflPP6Ykg88wLEcViSi2jffUvLvDuckcQdjVlbKLClR2ZVXKeXEE5VyxO+cjtSg6uFHVH7zLeqxcnmzv+/CGzfJqqpscyey24oth/xW7q5dlfvEY1HPsSyrXfw5Lz7nPEVWr1aXD95zOgoAh/DvYwAAAPvRUgZAhxZavkyS5B0yOKH7lv75EnlHjlRo2TKl/O538k/Zs00VYmEfV3q6jJQUBWZ/puTD2tYnCdw9e0iBgMziYrnz8poc4+kZ/8uE27PMG/8v6v72oRUrZSQnt9nvqRUMSqq/a8IsL1fdhx8q4/K/OJwKAAAAADoWWsoA6NDCy5bLSEqSu1evhO4bKSxU+Q3/p5oXXlSkuDiheyPxap59TrKsNndpqrtnT0lSZOPGZseUXXW1Al9+mahI7Y5/4gR5Bw6IamzFTTep5Myz4pyoZcyKCm0aOFh1770vSap98y0pFFLKkUc6GwwAAAAAOhgK7gA6NO+4ccq48oqoLzy0i3+PPWT4fMp94jFOtncihi++vflj9XPBfVOTz83aWlU/+VSzz1GvbuZMbT32eFmRSLNjwhs3qu7Dj5R66ikJTBY9V0aGjLS0hn7tkS1blHTA/nJ36+ZwMgAAAADoWGgpA6BD80+cIP/ECQnfN+3885R62u/lysxM+N5IvJSTT5KRlCT/Pns7HWU7rpwcKcmvSEFBk8/Nny5U5dLUHXNlZyv4xReq+/iTZu+CqHn6GRkpKUo+6sjEhouBp08fhdetlyRlXPJncY0PAAAAANiPE+4AOizLslT94ksKO3B61/B4KLZ3IobbrZTjjk34Jyl2xjAMdf9ugdL+cEaTz7cV4l3dKLjviG/MGHlHjVLNM880+dwKBlX97HNKOe5YuVJTE5wueu4+vRVZt1ah5ctl1da2i4tdAQAAAKC9oeAOoMMyt2xR2SWXKrRoodNRAMe40tKafRZesVISJ9yjkXrKyar76GNFNm1u9MysrJR/772VetrvHUgWvfoT7utUcubZKvv7NU7HAQAAAIAOiYI7gA4rvHyFJMkzeIjDSQDnVD38iEouvKjJZ0kHHqDUaafL2EFRHvWSjzxCRlKSal5/rdEzd26ucv57l7xD2vbfNekXXajs225TeOVKJf/ucKfjAAAAAECHRA93AB1WaPlyyeeTp28fp6MAjjHLyxX4fM52r9XN/kzeYUPl7tpVWTfd6FCy9sWVnq78t9+UZ+DA7V4PrVip4Lx5SjnyCBk+n0PpouPKylLtO+/I1bWL/FOmOB0HAAAAADokTrgD6LDCy5bJM3CADA/vLaLzcvfsIXPLFlmBgCSp9t13Vfz701R13/0OJ2t/vIMHy3C5ZIVCDa9VP/KIKm75p4OpohcpKlL1Y4/LO2Rom7tvAAAAAAA6CqpQADosV36+kvbd1+kYgKPcPXpKqr8gNfjdQpVe9CclH3KIMq660uFk7VPZ369RZONG5T72qMyqKtW8PENpZ5/V5k+3S/Un3FOnna60C853OgoAAAAAdFgU3AF0WBmXXuJ0BMBx7p71BffK/96jmhdeVPKRRyr7P3fwyY8W8g4dquonnlR44ybVffihrLo6pZ5yitOxomJ4PLQQAgAAAIA4o6UMgA7JCgQUKSqSZVlORwEc5enVU9n/vVuegQOVcuIJyr7z3xTbW6Hh8tTnn1f1k08q6aAD5e7R3elYAAAAAIA2gv/HDaBDCs6bp6Jjj1eXTz6Sd8gQp+MAjjH8fqUcfZTTMToMV3q6ko86UtXPPquMyy+Xd/BgpyMBAAAAANoQTrgD6JBCy5ZLHo88/fo5HQVAB5N6ysmyKirlGz1KvvHjnI4DAAAAAGhDOOEOoEMKL18uT//+7eIiQwDti3f0aHVbME+u1FSnowAAAAAA2hgK7gA6pPCy5fLQ6gFAHBiGIYNiOwAAAACgCbSUAdAhhTesl3covdsBAAAAAACQOJxwB9Ahdf1sthQMOh0DAAAAAAAAnQgn3AF0OFYkIsPlkpGU5HQUAAAAAAAAdCIU3NHu9OvXT0OHDtXYsWM1duxYvfDCC05HQhtTdtlfVHrpZU7HAAAAAAAAQCdDSxm0Sy+88ILGjh3rdAy0QWZtrWrffkdp55/ndBQAAAAAAAB0MpxwB9Ch1H3woazqaqUceYTTUQAAAAAAANDJcMId7dJpp50my7K022676Z///Kfy8/MbjQkEAgoEAg1fV1RUJDIiHFL7yivyjhsrT//+TkcBAAAAAABAJ8MJd7Q7n376qRYuXKh58+YpLy9Pp59+epPjbrnlFmVmZjb86N27d4KTItGsujoFvvpKKUcd5XQUAAAAAAAAdEKGZVmW0yGAltq8ebOGDBmiysrKRs+aOuHeu3dvlZeXKyMjI5ExkUBmTY1kWXKlpjodBQAAoE2rqKhQZmYm/z4GAACwES1l0K5UV1crFAopKytLkvTcc89p3LhxTY71+/3y+/0JTAenWXV1cqWkOB0DAAAAAAAAnRQFd7QrhYWFOuaYYxSJRGRZlgYMGKAnn3zS6VhoA8IbN2rL1P2U+9QT8k+e7HQcAAAAAAAAdEIU3NGuDBgwQPPnz3c6BuLAsixV3Xe/ko/4nTw9e8Y8v/bV1yTTlHfkyDikAwAAAAAAAHaOS1MBtAlWWZmqn3xKWw/7nYLffRfz/JpXXlXSQQfKlZYWh3QAAAAAAADAzlFwB+A4KxRS8VlnK+OqK+Xu2VNFRx+r2nffjXp+6McfFf7hByUfdVQcUwIAAAAAAAA7RsEdgOPM4mIFv5wrV2qq8l96QUkHHKCSs85R3SefRDU/+M23cuXkKGnqPnFOCgAAAAAAADSPHu4AHBcpKpIkufJyZSQnK/u+e+V/bi/599wzqvmpp56i5KOOlOHzxTMmAAAAAAAAsEOccAfgOHNbwT0/X5JkuFxKPeVkGT6fggsWqPiMPyi8cVPTcysrZUUicqWmJiwvAAAAAAAA0BQK7gAcZxYVS5LcOTmNnlk1tQrOX6Ate++jiv/cKau2drvnFTfdrKKjjklITgAAAAAAAGBHKLgDcJxv/Hhl3XarjOTkRs/8e+yurrNnKfWMaaq8624VTt1PwYULJUlWMKiaN96Ub/KkREcGAAAAAAAAGqHgDsBxngH9lXrKyc0+d6WnK/Pvf1OXjz6Ub8J4uXv1liTVvvWWrLIypRx1ZIKSAgAAAAAAAM0zLMuynA4BJEJFRYUyMzNVXl6ujIwMp+PgF+o+/kQypKR99416TqSkRAWjxsjdt4+6zfk8jukAAAA6Jv59DAAAYD+P0wEAoOqxx2R4vTEV3F1pacq86UZ5hwyJYzIAAAAAAAAgehTcATjOLCqSd9SomOYYPp/Spp0ep0QAAAAAAABA7OjhDsBxZlGx3Hl5TscAAAAAAAAAWoWCOwBHWZalSHGxXBTcAQAAAAAA0M5RcAfgrGBQ/j33lGfQQKeTAAAAAAAAAK1CD3cAjjL8fuU99YTTMQAAAAAAAIBW44Q7AEdZtbUyy8pkWZbTUQAAAAAAAIBWoeAOwFF1s2Zp8y6jZJaWOh0FAAAAAAAAaBUK7gAcZRYVSy6XXFlZTkcBAAAAAAAAWoWCOwBHRbZulSs3V4aLv44AAAAAAADQvlHhAuAos7hYrrxcp2MAAAAAAAAArUbBHYCjzKIiuXPznI4BAAAAAAAAtJrH6QAAOrfse/4rq6bG6RgAAAAAAABAq1FwB+Aow+ORkZHhdAwAAAAAAACg1WgpA8BRRadNU+1bbzsdAwAAAAAAAGg1Cu4AHGOFwwp8/LHM8nKnowAAAAAAAACtRsEdgGPMkhLJsuTKy3U6CgAAAAAAANBqFNwBOMYsKpYkufPyHU4CAAAAAAAAtB4FdwCOiRQVSRIn3AEAAAAAANAhUHAH4BjvoEHKuu1Wubt0cToKAAAAAAAA0GoepwMA6LzcPbor9ZSTnY4BAAAAAAAA2IIT7gAcE/jyS9W+/Y7TMQAAAAAAAABbUHAH4Jial6ar8n//czoGAAAAAAAAYAsK7gAcYxYVy52b53QMAAAAAAAAwBYU3AE4JlJcJFc+BXcAAAAAAAB0DBTcATjGLCqWKzfX6RgAAAAAAACALSi4A3CMb8wYeUcMdzoGAAAAAAAAYAuP0wEAdF45D9zndAQAAAAAAADANpxwB+AIKxiUWVoqy7KcjgIAAAAAAADYgoI7AEeEFn+vzSNHK/zjj05HAQAAAAAAAGxBwR2AIyJFRZIkV16ew0kAAAAAAAAAe1BwB+AIs6hIMgy5srOdjgIAAAAAAADYgoI7AEeYRUVyZWfL8HB3MwAAAAAAADoGCu4AHBEpKqadDAAAAAAAADoUjpYCcETmddfIqqpyOgYAAAAAAABgGwruABxhuN0yMjOdjgEAAAAAAADYhpYyABxR8qc/q/qZZ52OAQAAAAAAANiGgjsARwQ+/VSRLVucjgEAAAAAAADYhoI7gISzIhGZxcVyc2kqAAAAAAAAOhAK7gASziwrk0xTrnwK7gAAAAAAAOg4KLgDSDizqEiS5Mql4A4AAAAAAICOg4I7gIRz5ecr61+3yTNwoNNRAAAAAAAAANt4nA4AoPNx5+Qo9eSTnI4BAAAAAAAA2IoT7gASLrhwoWpenuF0DAAAAAAAAMBWFNwBJFzdO++q4p+3Oh0DAAAAAAAAsBUFdwAJFykulisv1+kYAAAAAAAAgK0ouANIOLOoSK68fKdjAAAAAAAAALai4A4g4cyiYrk54Q4AAAAAAIAOxuN0AACdj3fEcHmGDXM6BgAAAAAAAGArCu5AgpSVlUmSsrKyHM3RFmT98xanIwAAAAAAAAC2o6UMkCAffvihFi5c6HQMx1mRiCIlJbJM0+koAAAAAAAAgK0ouAMJ0qVLF23ZssXpGI6LFBSoYNQYBWbPdjoKAAAAAAAAYCsK7kCCdOnSRSUlJQoGg05HcZRZVCRJcuXmOZwEAAAAAAAAsBcFdyBBunTpIknaunWrw0mcZRYVS5LcebkOJwEAAAAAAADsRcEdSJDs7Gx5vd5O31YmUlT/hoMrJ8fhJAAAAAAAAIC9KLgDCWIYBn3cVX/C3cjKlOHzOR0FAAAAAAAAsBUFdyBBgvPnK9fl0pYtW2RZltNxHJN23rnq9vlnTscAAAAAAAAAbEfBHUiQsiuuUtpnn6u2tlaVlZVOx3GM4XbLlZXldAwAAAAAAADAdhTcgQTxT91HaR9+JEmduq1M2bXXq/Le/zkdAwAAAAAAALAdBXcgQZKmTpV3wwalJyV16oJ78MsvFdmwwekYAAAAAAAAgO0ouAMJ4ps4QUZqqnKqqzt1wT1StFWuvDynYwAAAAAAAAC28zgdAOgsDJ9P/il7KnPZMq33ehWJROR2u52OlVCWacosLpErN9fpKAAAAAAAAIDtOOEOJJB/n32U/sVcmaapoqIip+MknFVeLoXDcufnOx0FAAAAAAAAsB0FdyCB/PvsrYyNG+VSJ7041e9X1h3/knfsGKeTAAAAAAAAALaj4I526bHHHpNhGHr11VedjhK1xYsX652FC+Xt10/ZtXWdsuDuSklR6oknytOzp9NRAAAAAAAAANtRcEe7s2bNGj300EOaPHmy01FikpWVpYKCApUffJAyV65QYWGh05ESLjB3rqqfe15WOOx0FAAAAAAAAMB2FNzRrpimqbPOOkv//e9/5ff7nY4Tk549eyovJ0dL+/RR5g9LVVVVpZqaGqdjJYQViajyvvtVdOLJqn76aamTXRYLAAAAAACAzoGCO9qVf//739pzzz01YcKEnY4NBAKqqKjY7oeTqh96WP1mvKKCulq5XIakztHHPbxmjYqOPU4VN92stDOmKf/l6TIMw+lYAAAAAAAAgO0ouKPdWLx4sV5++WX9/e9/j2r8LbfcoszMzIYfvXv3jnPCHfPvs7e6zP5MmZLqxoxRUiDQKQrulffcq0hBofKmv6jMa6+RkZTkdCQAAAAAAAAgLgzLsiynQwDRuO+++3TDDTc0tJIpKChQRkaG/vGPf+j8889vND4QCCgQCDR8XVFRod69e6u8vFwZGRkJy/1LZVdepcq331bmGWdo5oYNMvbeS4cfcYQjWeIpsmmzQitXKmmvKTIrKiSXS660NKdjAQAA4BcqKiqUmZnp6L+PAQAAOhoK7mi3pk6dqj//+c868sgjoxrfFv4PRaSoSIV77iXfQQfpm7pabdptV00780y5XB3nwyaWZalwzykykpLU5cMPZHSgnxsAAEBH0hb+fQwAANDReJwOAHQm7rw8pV9ysVaUV2hdVqZkWSorK1NOTo7T0WwTWbNGkbXrlPvkExTbAQAAAAAA0KlQcEe7NXPmTKcjtEj6eedpVDishQ8+qIDbrcLCwg5VcA9+O0+S5Bs/zuEkAAAAAAAAQGJx/BRwgFvS0OJiSdL65cudDWOz4LffyjNokFzZ2U5HAQAAAAAAABKKgjvgBLdbvb/+Rq5IRJsKCpxOYyvfhAlKPeN0p2MAAAAAAAAACUfBHXCAYRjKu+YadV/8vYKWpWAw6HQk26Qce4zSpk1zOgYAAAAAAACQcBTcAYf4d52ooRs3SoahgtWrnY5ji/C6dar7dLasSMTpKAAAAAAAAEDCUXAHHNTjvHPlrq3V3A8/7BCn3GtffU0l55wrGYbTUQAAAAAAAICEo+AOOCj5oIOUWVysUq9X635cqppXX1WkpMTpWC0W/HaefOPGynDxVwsAAAAAAAA6H4/TAYDOzHC71dXjValpas2ihUq+/ErJMOQdO0ZJ++yjpAP2l2/cOKdjRsWyLAXnzVPq6ac5HQUAAAAAAABwBAV3wGHdBw3SD1WVWl9Rocn/vEWyLAW/+EJVjz+u4KLFynvycacjRiWyeo3MkhL5Jox3OgoAAAAAAADgCArugMMGHHO0vnn0UVW43Vp9z73K2bJF/t0nK/2yS+XfbTdJkmWabb5Ni1lZIe/48e3mRD4AAAAAAABgN8OyLMvpEEAiVFRUKDMzU+Xl5crIyHA6zna2bt2qV155RaP699eo9RtU9/4HCnzxhRQOy7fbbrKqq5X/+qsykpKcjgoAAIAOoi3/+xgAAKC9attHZoFOIj8/X6NGjdKSdetkHXes8p5/Vt0XfaesW/+p4Lx5Ci1Zosp7/+d0zB0Kr14tyzSdjgEAAAAAAAA4hoI70EbssssucrlcmjVrlizLkisjQ6mnnqKcB++XJFXeeZdCq9c4G7IZZlWVCveeqpoXX3Q6CgAAAAAAAOAYCu5AG+H3+xUOh7Vp0yatXbu24fXkgw9W9t13SaapouOOlxWJOJiyacH5CyTTpH87AAAAAAAAOjUK7kAb4ff71a1bNyUlJenzzz9XKBRqeJZy9FFKPetMmZs3q+TCP7W5onvw229lZGTIM3iw01EAAAAAAAAAx1BwB9qQvn37KhQKqba2Vt9+++12zzKvv05Z996jujffVNllf2lT/dKD386Tb9xYGS7+SgEAAAAAAEDnRXUMaEP69OmjSCSiAQMGaNGiRSopKWl4ZhiGUo88QmkXXqCa6S+r7K+Xt5miu7l1q3wTJjgdAwAAAAAAAHAUBXegDcnMzNT48eM1atQoZWRk6LPPPpNlWduNsWpqJa9XNc+/oLp33nUo6fa6vPu20v98sdMxAAAAAAAAAEdRcAfaEMMwNHHiROXn52vKlCkqKCjQsmXLthuTcdmlcmVmypWTo6qHHnYo6c+29ZM33G6HkwAAAAAAAADOouAOtDHhcFhLlixRWlqaevToodWrV2/33JWRocy//01mSYmCX3+t4Pz5DiWtV3b131V8+hmOZgAAAAAAAADaAgruQBtjGIbmzp2rlStXKj09XbW1tY3GJB99lDwjhkspyY6fcg9++41cXfIdzQAAAAAAAAC0BRTcgTbG7XarV69eWrdunZKTk5ssuBsul3Luv18Zl1yi2jffUnjjJgeSSmZlpcI/LpVvwnhH9gcAAAAAAADaEgruQBvUt29fbdmyRW63W7W1tY0uTpUk78ABSj3t91JSkqoee8yBlFJw/gLJsuSbMMGR/QEAAAAAAIC2hII70Ab17t1bklRTU6NIJKJQKNTkuEhBoVRXp+onnpRZXZ3IiJKk0Pz5MjIz5Rk4MOF7AwAAAAAAAG0NBXegDUpOTta4ceOUmZkpSU22lZEkz8AB8g4fLtXUqPqFFxMZUZKU9scL1OXtN2W4+KsEAAAAAAAAoEoGtFG77rqrevXqJan5grthGMr429WSpKr/3iPLNBOWT5IMj0eefv0SuicAAAAAAADQVlFwB9oo0zS1detWSc0X3CXJv9cUeUeMkLlli2o/+CBR8RRasVJbjz5G4dWrE7YnAAAAAAAA0JZRcAfaKMMw9M0330jaccHdMAxl3nC9jMxMVd33QILSSYFPP1Xwq6/lystL2J4AAAAAAABAW0bBHWijDMNQXl6eXC7XDgvukuTffXdl3/pPhb7+WsHFi+OeLTB3rspvuknJR/xOrvT0uO8HAAAAAAAAtAcU3IE2LCkpKaqCuyQl/eYQuXJyVH7DjXHNFFz8vYpPP0P+CROVfcftcd0LAAAAAAAAaE8ouANtmN/vl2VZURXcDY9HRna2gp9/rvCmTXHLZCT55d9zD+U8+rCMpKS47QMAAAAAAAC0NxTcgTYsNzdXycnJURXcJSnrlpskSaUXXSyrrs7WLJEtW2RWV8s7aJByH3lYrrQ0W9cHAAAAAAAA2jsK7kAbNnjwYA0YMCDqgnvSnnvKM3SIgl9+qU1Dhqn8tn8pUlzc6hxmaamKTjpZpZdc1uq1AAAAAAAAgI7K43QAAM2zLEsej0c1NTVRz+nyztuqfvY51bz4oqofeFBV998vV06ukg8+SKknnywjPU1Wba08Q4bIMAwF581XpLBAcnvk7t5N7u7d5crJkeGqfz/OrKlR8elnyCzcoowH7o/XTxUAAAAAAABo9wzLsiynQwCJUFFRoczMTJWXlysjI8PpOFHZtGmT3nzzTUnSH/7wB3k8sb1HFikpVfUjj6jyvvulQOD/2bvv+Cjq/I/jr9mSTdn0BBI6AqFJCQiIiIB0BClW5OSwnPrz0FMBy8lZTsV2nvUsp4h6CmKhKYggSkd67yDdAAFSSN8yvz82rESKCYRsQt7Px2Mf2Z35znw/M5tN+cx3Pt8i6+KmTcXeqCFHh91OweLFRdZFvfgCYX8aQt7cuWQ8OwbP3r3EffE5QS1bntfxiIiIiEj5URH/PhYREREp7zTCXaQcczgc/ud5eXk4S1g33RoTTcSokYTffx85kyaT9cEHuPfth+xsjlzbHwAjPg57q2Rs1apBaCiG3YZpeilYtRp3ykGsVasQ9czTpZJsN00TvF4Mq/W89yUiIiIiIiIiIlLeKOEuUo4FBwf7n+fm5pY44X6C4XAQNvhmwgbfjGmaeNPS8ezahfvEY/du3Hv34T18GM+hQ/DZhCLb5//8M4YjGMPhKPIgKAjDEYQRFIQR5IAge+HzIMzcXLyZmb5HegZm4XNcLoyICCwx0Viio7FEx2CJicESHYUlLAwjKMi336AgDLvdt097EBjGSQd0UnBWmy8Gh6MwhiCMYIdv+5AQjNBQ39fgYH+ZnBNMrxczPx8zN7fwkQemF07c+HPyDUAWy6nH73D492l6veByYbrdv311uzE9XvC4wePB9HjA4wG3B292FubxLLzHMzEzj+M9fhxvZiZmTg5mgQvcLt9XVwGm2+17np+PmZd3ygOPB0tsLJb4eKxV4rFUqYK1ShWs8fEYwcG+2EwveH0XPPyvTdO/DNP0Lzestt/OW2iI72vhOcTj+e3Y3G5wuTHdLt8+LBbA8J0Ti8X3PlksGDY72G0nfbX53ierFQofhmH4n2Ox+M5hQQFmfoHvuAvyfa8LXOD1+PrzH4/vtVlQgJmX72t/4lyd4Zz5HvkYQXYs4eEYEZFYIiOwRERgRIRjcYaD5eTvuZOeuz2FseSfFF8BpsvlOyZb4THabL5js9t93yMuV+H3hqvwvPnOI4XHfmJb/3PTLOynADM/H048Lygo+r15UmyGxVL0+97/CPadf4sFrCfeH4vvvbJZfZ8xuw3DXvh5C7L74v79xbETfRkW3+fM4fB9tkp4983pmC7XSZ/FXP/7Z9jsEBzs6ye4sL/g4HJz4c40zcLPkve3rxaL/30v8b48Ht/3SuH3FAUuTNPEsBV+b538fWKznVM/IiIiIiIicuEo4S5lYt++fRiGQY0aNQBYtmwZ48ePp0mTJtx1110Bjq78OnmEe3EnTv0jhmFgjYnGGhNNUOtWp6w3vV68aWl4Dx7Cc+gQnsOHMHNyiyQwKUwA+h4FhYlAX+Lam54BBQW+hFhkJPbq1bFEFCYyIyMwghx4MzLwHjvmf3j27MG1apUvyeZy+ZJM+fm+rx5PqRw3AMEOjOAQDMPwJ/TOm81WmPz1nvs+LBZfkjc8AiMstPBiw4kEaBDY7Rh2G0ZY9G/JxpMeWCx4jh71XTA5nIpr4yY8qamYGRnF698wfAlYi8X33OUqmtCtiAzDd24cjqJJ2uDg3y7AOByYBS7cu/fgzczAm5GJWXjRo9is1t8uPtntvsS//2KL74KE/3v4RCLebv/tq9Xqv/MDt9t38cDt+W0bh+9i1okLWTgcGEGFifPTcbl9n9MTSeucnNL5Pi/OeSg8p9htvyXz/d9bhYl6T+H58XgKz1Hh14IC38WHkrDbMcJCsYSEYoSF+S4OhYVhhIRiWE/q2zAKLxQYvuU2m+9Cnc160lcrZk4O3szjmMeP+74fCp+b2dmYphdMiibVTyTazxpfmO9CojMMI8yJJSzMdyGl8P3x+i8uFF7w+/3FlGKfhzAsTqfv50eYE4szzHcB0mL8dvwnnQcMA+PEupPPkdd7xotTmGf4GWcYv11Ms9qKfC3yfVB4Ae63OE6jyMULTr1AePJ76f/+OunYCi/6nf74LEWXnzher1l4QdL72/taeFynfP+cdCGxSH8nfx7P9P79vu/TnYcznZc/2nehyCefwHKOF+ZFRERERKT0KOEuZeKWW27hrrvu4tZbb+XgwYN0796dpk2b8tlnn3Hw4EGeeOKJQIdYLtlsNqxWKx6Pp0QTp54Pw2LBGhuLNTYWe9MmZdLn2Zgejy8B7F/wW8LBBH+yzszLhxOjoE9cDMjN8yWycnJ8zwuTW3i9J40ADv5tFLDDcdKI3hMjeQu/ej2/jWb+3cOwWE5KotqKjui2WcFyYvTyiecWX4IsPBwjIsIXyx8lWs7l3OXl+RKZhcl04+TE+snLfr+dafqOMzcXb86JEce+xK1hsZ46Wt1u9yWzMH9LWp2cyHK7C0d3u08a3V341estHLFeOLK3cLS6YbP7ks0Ox293UDgcGHbfyF5fIq/weKxWXzIrKOikpK/9nM+p6XJhZmf7EqP+b7ff7nowrNbCxHdQsUZZn5gq5UK8x8Vx4k4OXK7f3pcTdwmcuPPixF0ZBS5M10kjq09cSPKfiMKvnsJR/oXJWP/dFnl5vv2dlJQ2T0piFrmrwWbzja63Fl58CA3FUmRUfggEBfnu9jiR+D35joXcXN/FwOxsX7I8Owczx/ccT2Gi1u35LVlrmpgeb+GdJm5Mt+8rbg+mx40REoolIhxLZCTWmjV8FwnDw31J8pPv2jAKPzdFLlThT+oahuE757k5mFnZmNnZeLOzMbOy8GZlY1gMjGqJvx3nyXfhBBVeYAv63Z0GhuGP87eLFr47X07pJzvb9zo/D7xm4cUCE//n88S5MPnd+2MW3rkQjBEahiUm9reLVUV+Nv5O4Z07Re58OfG1yAWKE3cDeDlr4vjkxLj//BYmuE9zHL5jLHxuFr0gYnp+9z3g9fp24fX67hqwWn0J+5P6OPE59X//YP52zk5cCDj5vJ1I1p/t822a/u185/7kizVm0XYnvp5pf6csP/numxJetBIRERERkQtCCXcpExs2bKBt27YAfPHFF1x66aUsWrSIWbNmcc899yjhfhZDhgzh888/J68sRqmWQ/4E3enWlXEsFY1/BHxJtzMMfwkPS3T0BYisfDPsdoyoqNLbX4AS7f7+C8vMEBIS0DhEREREREREKoMz3JMuUrpcLpe/PMoPP/zAtddeC0CjRo1ISUkJZGjlXnBwMKGhoWU2wl1ERERERERERETOjRLuUiaaNm3Ku+++y4IFC5g9eza9evUC4NdffyU2NjbA0ZVvK1aswO12l1oNdxEREREREREREbkwlHCXMvHiiy/y3nvv0blzZwYPHkyLFi0AmDZtmr/UjJxeWloaHo+n0paUERERERERERERqShUw13KROfOnTly5AiZmZlEn1QT+q677iI0NDSAkZV/DocD0zRVUkZERERERERERKSc0wh3KRO5ubnk5+f7k+179uzhtddeY+vWrVSpUiXA0ZVvwcHBeL1elZQREREREREREREp55RwlzLRv39/PvnkEwDS09Np164dr7zyCgMGDOCdd94JcHTlm8Ph8JeU8Xq9gQ5HREREREREREREzkAJdykTq1atomPHjgB89dVXVK1alT179vDJJ5/wxhtvBDi68q1mzZo0bNgQQHXcRUREREREREREyjEl3KVM5OTkEB4eDsCsWbMYNGgQFouFyy+/nD179gQ4uvItJiaGBg0aAKisjIiIiIiIiIiISDmmhLuUifr16zNlyhT27dvH999/T48ePQA4fPgwERERAY6ufMvLyyMlJQVQwl1ERERERERERKQ8U8JdysQTTzzByJEjqVOnDm3btqV9+/aAb7R7cnJygKMr33Jzc1m2bJn/uYiIiIiIiIiIiJRPtkAHIJXD9ddfz5VXXklKSgotWrTwL+/atSsDBw4MYGTln8PhAMBisSjhLiIiIiIiIiIiUo4p4S5lJiEhgYSEBPbv3w9AjRo1aNu2bYCjKv+Cg4MBCAoKUsJdRERERERERESkHFNJGSkTXq+Xf/7zn0RGRlK7dm1q165NVFQUzzzzDF6vN9DhlWsWiwW73Y7NZlPCXUREREREREREpBzTCHcpE48//jhjx47lhRdeoEOHDgAsXLiQp556iry8PJ577rkAR1i+Va9enePHjyvhLiIiIiIiIiIiUo4ZpmmagQ5CLn7VqlXj3Xff5dprry2yfOrUqdx7770cOHDggseQmZlJZGQkGRkZREREXPD+Stv8+fM5cuQIgwYNCnQoIiIiUgF5PB5cLlegw5ByJCsri8suu4wVK1bgdDoDHU6lZbfbsVqtgQ5DRERESolGuEuZOHbsGI0aNTpleaNGjTh27FgAIqpYvF6variLiIjIOTFNk4MHD5Kenh7oUKSc8Xq9vPvuuxw6dIjU1NRAh1OpRUVFkZCQgGEYgQ5FREREzpMS7lImWrRowVtvvcUbb7xRZPlbb71F8+bNAxRVxfHTTz+RmppKbm4upmnqD3EREREpthPJ9ipVqhAaGqq/I8TP4/GQm5tLnTp1NMI6QEzTJCcnh8OHDwOQmJgY4IhERETkfCnhLmXipZde4pprruGHH36gffv2ACxZsoR9+/YxY8aMAEdX/jkcDrxeL16vl4KCAhwOR6BDEhERkQrA4/H4k+2xsbGBDkfKGY/HA0BwcLAS7gEUEhICwOHDh6lSpYreCxERkQrOEugApHLo1KkT27ZtY+DAgaSnp5Oens6gQYPYuHEj//vf/wIdXrkXHByM2+0GUFkZERERKbYTNdtDQ0MDHImInM2Jz6jmWRAREan4NMJdyky1atV47rnniixbu3YtY8eO5b///W+AoqoYHA6H/4/v3NxcoqKiAhuQiIiIVCgqIyNSvukzKiIicvHQCHeRCsDhcPhv+dUIdxERERERERERkfJJCXeRCqBu3br86U9/wjAMJdxFRERERERERETKKSXcRSoAu91OaGgooaGhSriLiIhIpbd7924Mw2DNmjWBDkVEREREpAjVcJcLatCgQWddn56eXjaBVHC5ubnMnz8fm82mhLuIiIiIiIiIiEg5pRHuckFFRkae9VG7dm2GDh0a6DDLPcMw2LNnjxLuIiIiUql4vV5eeukl6tevj8PhoFatWjz33HPUrVsXgOTkZAzDoHPnzv5tPvzwQ5o2bYrD4SAxMZHhw4cHKHoRERERqYw0wl0uqHHjxgU6hItCUFAQAFarVQl3ERERqTQee+wx3n//fV599VWuvPJKUlJS2LJlC8uWLaNt27b88MMPNG3a1P+30jvvvMNDDz3ECy+8QO/evcnIyGDRokUBPgoRERERqUyUcBepACwWCw6HA4vFQk5OTqDDERERkQouJyeHLVu2lHm/jRo1IjQ0tFhtjx8/zuuvv85bb73Fn//8ZwDq1avHlVdeye7duwGIjY0lISHBv82zzz7LiBEj+Nvf/uZf1qZNm9I7ABERERGRP6CEu0gF4XA4MAxDI9xFRETkvG3ZsoXWrVuXeb8rV66kVatWxWq7efNm8vPz6dq1a7HaHz58mF9//bXY7UVERERELgQl3EUqiFatWpGRkUFKSgputxubTR9fEREROTeNGjVi5cqVAem3uEJCQkq075K2FxERERG5EJSxE6kgkpKS2L9/P6tXryY3N5fw8PBAhyQiIiIVVGhoaLFHmgdKgwYNCAkJYc6cOdx5551F1p2o2e7xePzLwsPDqVOnDnPmzKFLly5lGquIiIiIyAlKuItUEKmpqaSnpwMo4S4iIiIXveDgYB555BEefvhhgoKC6NChA6mpqWzcuJE///nPhISEMHPmTGrUqEFwcDCRkZE89dRT3HPPPVSpUoXevXtz/PhxFi1axH333RfowxERERGRSsIS6ABEpHi2b9/Oxo0bAVTHXURERCqFf/zjH4wYMYInnniCxo0bc9NNN3H48GFsNhtvvPEG7733HtWqVaN///4A/PnPf+a1117j7bffpmnTpvTt25ft27cH+ChEREREpDIxTNM0Ax2ESFnIzMwkMjKSjIwMIiIiAh1Oia1atYqNGzeSm5vLVVddVaIaqCIiIlI55eXlsWvXLurWrUtwcHCgw5FyxuPxsHr1apKTk7FarYEOp1LTZ1VEROTioZIyUuH06NGDgwcPYrFYCA8P54033iA5OTnQYV1wDoeD/Px8HA4HOTk5gQ5HREREREREREREfkcJd6lwvvjiC6KiogCYPHkyw4YNY+3atYENqgw4HA68Xi8hISHk5eUFOhwRERERERERERH5HSXcpcI5kWwHyMjIwDCMwAVThpxOJ1WrVgXQCHcREREREREREZFySAl3qZCGDh3KTz/9BMCMGTNO2yY/P5/8/Hz/68zMzDKJ7UJJSEigf//+zJkzRwl3ERERERERERGRcsgS6ABEzsUnn3zCvn37ePbZZ3nkkUdO2+b5558nMjLS/6hZs2YZR1n6vF4vwcHBKikjIiIiIiIiIiJSDinhLhXan//8Z3766SeOHj16yrrHHnuMjIwM/2Pfvn0BiLD0FBQU8MEHH5Cbm6sR7iIiIiIiIiIiIuWQSspIhZKenk5OTg7VqlUDYMqUKcTGxhITE3NKW4fDgcPhKOsQLxi73Y5hGFgsFvLz8/F6vVgsumYmIiIiIiIiIiJSXijhLhVKRkYGN9xwA7m5uVgsFuLj4/n2228rxcSphmEQHBzsf52Xl0doaGgAIxIREREREREREZGTKeEuFUrt2rVZtmxZoMMIGIfDgWmaAOTk5CjhLiIiIiIiIiIiUo6oHoVIBeJwOPB4PADk5uYGOBoRERGRste5c2ceeOCBC97P7t27MQyDNWvWXPC+REREROTioYS7SAXSrVs3OnToACjhLiIiIiJQp04dXnvttUCHISIiIiKFVFJGpAIJCwsDfBOoKuEuIiIiIiIiIiJSvmiEu0gFsnPnThYsWEBISIgS7iIiInLRy87OZujQoTidThITE3nllVeKrM/Pz2fkyJFUr16dsLAw2rVrx9y5cwHIzMwkJCSE7777rsg2kydPJjw8nJycnBLHM2/ePNq2bYvD4SAxMZFHH30Ut9vtX//VV1/RrFkzQkJCiI2NpVu3bmRnZwMwd+5c2rZtS1hYGFFRUXTo0IE9e/YUq99vvvmGNm3aEBwcTFxcHAMHDgR85XX27NnDgw8+iGEYGIbh32bRokV07tyZ0NBQoqOj6dmzJ2lpaSU+ZhEREREpGSXcRSqQzMxMfvnlFyXcRUREpFIYNWoU8+bNY+rUqcyaNYu5c+eyatUq//rhw4ezZMkSPv/8c9atW8cNN9xAr1692L59OxEREfTt25fx48cX2ednn33GgAEDSjz5/IEDB+jTpw9t2rRh7dq1vPPOO4wdO5Znn30WgJSUFAYPHsztt9/O5s2bmTt3LoMGDcI0TdxuNwMGDKBTp06sW7eOJUuWcNdddxVJkJ/J9OnTGThwIH369GH16tXMmTOHtm3bAjBp0iRq1KjBP//5T1JSUkhJSQFgzZo1dO3alSZNmrBkyRIWLlxIv379/HMBiYiIiMiFo5IyIhWIw+GgoKCA4OBgJdxFRETkvJycoD0hOjqaunXrkpeXx6ZNm07ZplWrVgBs3brVP3L7hDp16hATE0Nqair79u0rsi48PJwGDRqUKL6srCzGjh3Lp59+SteuXQH4+OOPqVGjBgB79+5l3Lhx7N27l2rVqgEwcuRIZs6cybhx4xgzZgxDhgzh1ltvJScnh9DQUDIzM5k+fTqTJ08uUSwAb7/9NjVr1uStt97CMAwaNWrEr7/+yiOPPMITTzxBSkoKbrebQYMGUbt2bQCaNWsGwLFjx8jIyKBv377Uq1cPgMaNGxer3+eee46bb76Zp59+2r+sRYsWAMTExGC1WgkPDychIcG//qWXXuKyyy7j7bff9i9r2rRpiY9ZREREREpOCXeRCiQ4OBjTNHE4HBw9ejTQ4YiIiEgF9t577xVJ4gIMGTKETz/9lP3799O6detTtjFNE4Bhw4bx888/F1n3v//9jz/96U988cUXDB8+vMi6Hj168P3335covp07d1JQUEC7du38y2JiYmjYsCEA69evx+PxkJSUVGS7/Px8YmNjAejTpw92u51p06Zx88038/XXXxMREUG3bt1KFAvA5s2bad++fZFR6R06dCArK4v9+/fTokULunbtSrNmzejZsyc9evTg+uuvJzo6mpiYGIYNG0bPnj3p3r073bp148YbbyQxMfEP+12zZg1/+ctfShTrmjVruOGGG0p8jCIiIiJy/pRwF6lAgoODAbDZbBrhLiIiIufl7rvv5tprry2yLDo6GoAaNWqwcuXKM2770UcfnXaEO8CNN95I+/bti6wLDw8vhYiLysrKwmq1snLlSqxWa5F1TqcTgKCgIK6//nrGjx/PzTffzPjx47npppuw2Ur/3yCr1crs2bNZvHgxs2bN4s033+Txxx9n6dKl1K1bl3HjxnH//fczc+ZMJk6cyOjRo5k9ezaXX375WfcbEhJS4ljOZRsRERERKR1KuItUIJGRkf5RXrm5uZimWazanyIiIiK/l5iYeMYR1sHBwf7yMadzYpT56cTHxxMfH3/e8dWrVw+73c7SpUupVasWAGlpaWzbto1OnTqRnJyMx+Ph8OHDdOzY8Yz7GTJkCN27d2fjxo38+OOP/prrJdW4cWO+/vrrIn9/LVq0iPDwcH+ZG8Mw6NChAx06dOCJJ56gdu3aTJ48mYceegiA5ORkkpOTeeyxx2jfvj3jx4//w4R78+bNmTNnDrfddttp1wcFBZ1Sm/3ENr+/g0FERERELjxNmipSgYSFhdGiRQvCw8MxTZP8/PxAhyQiIiJyQTidTu644w5GjRrFjz/+yIYNGxg2bBgWi+9fmKSkJIYMGcLQoUOZNGkSu3btYtmyZTz//PNMnz7dv5+rrrqKhIQEhgwZQt26dYuUqCmJe++9l3379nHfffexZcsWpk6dypNPPslDDz2ExWJh6dKljBkzhhUrVrB3714mTZpEamoqjRs3ZteuXTz22GMsWbKEPXv2MGvWLLZv316sOu5PPvkkEyZM4Mknn2Tz5s2sX7+eF1980b++Tp06zJ8/nwMHDnDkyBEAHnvsMZYvX869997LunXr2LJlC++8845/vYiIiIhcOEq4i1Qgpmmya9cuvF4vgMrKiIiIyEXt5ZdfpmPHjvTr149u3bpx5ZVXFqktP27cOIYOHcqIESNo2LAhAwYMYPny5f4R8eAbdT548GDWrl3LkCFDzjmW6tWrM2PGDJYtW0aLFi245557uOOOOxg9ejQAERERzJ8/nz59+pCUlMTo0aN55ZVX6N27N6GhoWzZsoXrrruOpKQk7rrrLv76179y9913/2G/nTt35ssvv2TatGm0bNmSq6++mmXLlvnX//Of/2T37t3Uq1fPf2dBUlISs2bNYu3atbRt25b27dszderUC1JKR0RERESKMswTMx+JXOQyMzOJjIwkIyODiIiIQIdzzsaOHUuLFi1YtWoVvXr1KvIPpYiIiMjJ8vLy2LVrF3Xr1vXPBSNygsfjYfXq1SQnJ59SB1/Klj6rIiIiFw+NcBepYBwOB+CbmCsjIyPA0YiIiIiIiIiIiMgJSriLVDDBwcHk5+f7R+uLiIiISMmNGTMGp9N52kfv3r3LLI6mTZueMY7PPvuszOIQERERkdKhIn4iFYzD4SAvL08JdxEREZHzcM8993DjjTeedl1ISEiZxTFjxgxcLtdp11WtWrXM4hARERGR0qGEu0gFExsbi2EYWK1Wtm/fHuhwRERERCqkmJgYYmJiAh0GtWvXDnQIIiIiIlKKlHAXqWCuuOIKALZt20Z2djYulwu73R7gqEREREREREREREQ13EUqIK/XS2RkJIDKyoiIiIiIiIiIiJQTSriLVDDr16/nk08+UcJdRERERERERESknFHCXaSCsdvtFBQUEBQURHBwsBLuIiIiIiIiIiIi5YQS7iIVTHBwMAD5+flERkaSnp4e2IBEREREREREREQEUMJdpMJxOBzAbwl3jXAXERGRyqRz58488MADF7yf3bt3YxgGa9asueB9ldRTTz1Fy5YtAx2GiIiIiJyGEu4iFcyJhHteXh5RUVGkp6djmmaAoxIRERERERERERFboAMQkZKJjIzkpptuwul0kpubi8vlIjc3l9DQ0ECHJiIiIiIiIiIiUqlphLtIBWO1WomMjMRqtRIVFQWgsjIiIiJyUcrOzmbo0KE4nU4SExN55ZVXiqzPz89n5MiRVK9enbCwMNq1a8fcuXMByMzMJCQkhO+++67INpMnTyY8PJycnJwSxzNv3jzatm2Lw+EgMTGRRx99FLfb7V//1Vdf0axZM0JCQoiNjaVbt25kZ2cDMHfuXNq2bUtYWBhRUVF06NCBPXv2FKvfF154gapVqxIeHs4dd9xBXl5ekfXDhg1jwIABPP3008THxxMREcE999xDQUFBiY9RRERERM6PEu4iFdDChQvZvXs3ERERGIahiVNFRETkojRq1CjmzZvH1KlTmTVrFnPnzmXVqlX+9cOHD2fJkiV8/vnnrFu3jhtuuIFevXqxfft2IiIi6Nu3L+PHjy+yz88++4wBAwaU+O7AAwcO0KdPH9q0acPatWt55513GDt2LM8++ywAKSkpDB48mNtvv53Nmzczd+5cBg0ahGmauN1uBgwYQKdOnVi3bh1LlizhrrvuwjCMP+z3iy++4KmnnmLMmDGsWLGCxMRE3n777VPazZkzx9/vhAkTmDRpEk8//XSJjlFEREREzp9KyohUQHv37iUoKIg6dergdDo1wl1ERERKLCUlhSNHjtCsWTMANm3aRHh4ODVr1iQvL49NmzbRoEEDwsPDOXToEAcPHqRFixYAbN26leDgYGrXro3L5WL9+vXUq1ePyMhIUlNT2b9/P8nJyQBs374dm81G3bp1SxRfVlYWY8eO5dNPP6Vr164AfPzxx9SoUQPw/T00btw49u7dS7Vq1QAYOXIkM2fOZNy4cYwZM4YhQ4Zw6623kpOTQ2hoKJmZmUyfPp3JkyeX+Hy9/fbb1KxZk7feegvDMGjUqBG//vorjzzyCE888QQpKSm43W4GDRpE7dq1Afzn9tixY2RkZNC3b1/q1asHQOPGjYvV72uvvcYdd9zBHXfcAcCzzz7LDz/8cMoo96CgID788ENCQ0Np2rQp//znPxk1ahTPPPMMFovGWYmIiIiUFf3lJVIBORwO8vPzAfwTp4qIiIiUxHvvvUfv3r39r2+++WZefvllAPbv30/r1q1ZuXIlAJ988gldunTxtx02bBjPPPMMAEeOHKF169YsXLgQ8I3Ivvzyy/1t/+///o+///3vJY5v586dFBQU0K5dO/+ymJgYGjZsCMD69evxeDwkJSXhdDr9j3nz5rFz504A+vTpg91uZ9q0aQB8/fXXRERE0K1btxLHs3nzZtq3b19kVHqHDh3Iyspi//79tGjRgq5du9KsWTNuuOEG3n//fdLS0vxxDxs2jJ49e9KvXz9ef/11UlJSit3vyecAoH379qe0a9GiRZFR++3btycrK4t9+/aV+FhFRERE5NxphLtIBRQcHOxPuEdGRuofKRERESmxu+++m+uuu87/+vPPPyc8PByAGjVqsHLlSho0aADA0KFD6dGjh7/tRx99RHBwMABxcXGsXLnSP3L7xhtv5IorrvC3feedd7DZSv/fjqysLKxWKytXrsRqtRZZ53Q6Ad+o7+uvv57x48dz8803M378eG666aYLEo/VamX27NksXryYWbNm8eabb/L444+zdOlS6taty7hx47j//vuZOXMmEydOZPTo0cyePbvIxQkRERERqfg0wl2kAvr9CPfMzEy8Xm+AoxIREZGKJDEx0V/yBKBJkybUrFkT8F3cb9WqlT8BX7VqVX85GYCGDRv6y6bY7XZatWpFZGQkAPHx8f5yMgANGjQocTkZgHr16mG321m6dKl/WVpaGtu2bQMgOTkZj8fD4cOHqV+/fpFHQkKCf5shQ4Ywc+ZMNm7cyI8//siQIUNKHAv4SsAsWbIE0zT9yxYtWkR4eLi/zI1hGHTo0IGnn36a1atXExQUVKR8TXJyMo899hiLFy/m0ksvPaW+/Jn6PfkcAPz888+ntFu7di25ublF2jidTv97KiIiIiJlQwl3kQqofv36/hFnkZGRmKZJZmZmgKMSERERKT1Op5M77riDUaNG8eOPP7JhwwaGDRvmr0eelJTEkCFDGDp0KJMmTWLXrl0sW7aM559/nunTp/v3c9VVV5GQkMCQIUOoW7fuKeVZiuvee+9l37593HfffWzZsoWpU6fy5JNP8tBDD2GxWFi6dKl/YtO9e/cyadIkUlNTady4Mbt27eKxxx5jyZIl7Nmzh1mzZrF9+/Zi1XH/29/+xocffsi4cePYtm0bTz75JBs3bjylXUFBAXfccQebNm1ixowZPPnkkwwfPlz120VERETKmErKiFRAderU8T8/MZosIyODqKiowAQkIiIicgG8/PLLZGVl0a9fP8LDwxkxYkSRyeLHjRvHs88+y4gRIzhw4ABxcXFcfvnl9O3b19/GMAwGDx7MSy+9xBNPPHHOsVSvXp0ZM2YwatQoWrRoQUxMDHfccQejR48GICIigvnz5/Paa6+RmZlJ7dq1eeWVV+jduzeHDh1iy5YtfPzxxxw9epTExET++te/cvfdd/9hvzfddBM7d+7k4YcfJi8vj+uuu47/+7//4/vvvy/SrmvXrjRo0ICrrrqK/Px8Bg8ezFNPPXXOxysiIiIi58YwT74nUuQilpmZSWRkJBkZGURERAQ6nPOSlZXFkSNHqFOnDqZpMm7cOC677DKaN28e6NBERESkHMnLy2PXrl3UrVvXX3NdLj7Dhg0jPT2dKVOmlGg7j8fD6tWrSU5OPqUOvpQtfVZFREQuHrq/UKQC+vXXX5k1axYejwfDMIiMjCQ9PT3QYYmIiIiIiIiIiFRqSriLVEAnRr2cmDj1xMh9ERERESmeMWPG4HQ6T/vo3bt3mcXRtGnTM8bx2WeflVkcIiIiIlI6VMNdpAJyOByA79bT0NBQoqKiSElJCXBUIiIiIhXHPffcw4033njadSEhIWUWx4wZM3C5XKddV7Vq1WLt46OPPirFiERERETkfCjhLlIBOZ1OwFeXPiYmhsjISHJzcykoKCAoKCjA0YmIiIiUfzExMcTExAQ6DGrXrh3oEERERESkFKmkjEgFFBoaSlxcHF6vF4CoqCgAlZUREREREREREREJII1wF6mADMNg0KBB/teRkZGAL+EeHx8fqLBEREREREREREQqNY1wF6nACgoKAAgKCiIkJIT09PTABiQiIiIiIiIiIlKJKeEuUkFt3bqVjz/+GI/HA/jKyijhLiIiIiIiIiIiEjhKuItUUJGRkZim6U+yR0ZGqoa7iIiIiIiIiIhIACnhLlJBRUdHA3Ds2DHAN8I9IyMD0zQDGZaIiIjIBdW5c2ceeOCBC97P7t27MQyDNWvWXPC+LgTDMJgyZUqgwxARERGpdJRwF6mgHA4HYWFh/oR7ZGQkbrebnJycAEcmIiIiIiIiIiJSOSnhLlKBxcTEkJaWBvgS7oDquIuIiIiIiIiIiASIEu4iFViXLl3o0aMHABERERiGoTruIiIictHIzs5m6NChOJ1OEhMTeeWVV4qsz8/PZ+TIkVSvXp2wsDDatWvH3LlzAcjMzCQkJITvvvuuyDaTJ08mPDz8nO4KnDdvHm3btsXhcJCYmMijjz6K2+32r//qq69o1qwZISEhxMbG0q1bN7KzswGYO3cubdu2JSwsjKioKDp06MCePXv+sM+nnnqKli1b8uGHH1KrVi2cTif33nsvHo+Hl156iYSEBKpUqcJzzz131v3s27ePG2+8kaioKGJiYujfvz+7d+8u8TkQERERkbNTwl2kAgsODsZi8X2MLRYLERERGuEuIiIiF41Ro0Yxb948pk6dyqxZs5g7dy6rVq3yrx8+fDhLlizh888/Z926ddxwww306tWL7du3ExERQd++fRk/fnyRfX722WcMGDCA0NDQEsVy4MAB+vTpQ5s2bVi7di3vvPMOY8eO5dlnnwUgJSWFwYMHc/vtt7N582bmzp3LoEGDME0Tt9vNgAED6NSpE+vWrWPJkiXcddddGIZRrL537tzJd999x8yZM5kwYQJjx47lmmuuYf/+/cybN48XX3yR0aNHs3Tp0tNu73K56NmzJ+Hh4SxYsIBFixbhdDq55pprcLlcJToPIiIiInJ2tkAHICLnLjs7mx9++IH27dtTpUoVIiMjNcJdREREiiUlJYWUlJSztqlVqxZxcXEcOXKEvXv30qpVKwC2bt3qH7l9JpdeeilBQUH88ssveDweGjRoUKL4srKyGDt2LJ9++ildu3YF4OOPP6ZGjRoA7N27l3HjxrF3716qVasGwMiRI5k5cybjxo1jzJgxDBkyhFtvvZWcnBxCQ0PJzMxk+vTpTJ48uUSxALz99tvUrFmTt956C8MwaNSoEb/++iuPPPIITzzxBCkpKbjdbgYNGkTt2rUBaNasGeCb5D4jI4O+fftSr149ABo3blzsvr1eLx9++CHh4eE0adKELl26sHXrVmbMmIHFYqFhw4a8+OKL/PTTT7Rr1+6U7SdOnIjX6+WDDz7wJ/nHjRtHVFQUK1eupG3btiU+HyIiIiJyekq4i1RgwcHBHD58mCNHjlClShWioqJ0a7CIiIgUy3vvvcfTTz991jbvv/8+d955J1OmTOEvf/kLpmkCMGzYMH7++eezbrtv3z5q1KjBI488QmZmJt9//32J4tu5cycFBQVFEsgxMTE0bNgQgPXr1+PxeEhKSiqyXX5+PrGxsQD06dMHu93OtGnTuPnmm/n666+JiIigW7duJYoFYPPmzbRv377IqPQOHTqQlZXF/v37adGiBV27dqVZs2b07NmTHj16cP311xMdHU1MTAzDhg2jZ8+edO/enW7dunHjjTeSmJhYrL7r1KlDeHi4/3XVqlWxWq3+Ox1PLDt8+PBpt1+7di07duwosg+AvLw89u/fX5LTICIiIiJ/QAl3kQrMarUSFRXFsWPHAN/EqcePH8fj8WC1WgMcnYiIiJRnd999N9dee+1Z29SqVQuAAQMG+Ee3A3z00Ud/OMK9SpUqALz44ot4PJ7zjPZUWVlZWK1WVq5cecrfPU6nE4CgoCCuv/56xo8fz80338z48eO56aabsNlK/98gq9XK7NmzWbx4MbNmzeLNN9/k8ccfZ+nSpdStW5dx48Zx//33M3PmTCZOnMjo0aOZPXs2l19++R/u2263F3ltGMZpl3m93tNun5WVRevWrfnss8+KLPd4PH94l4OIiIiIlIwS7iIVXHR0NGlpaYAv4W6aJpmZmURHRwc4MhERESnPEhMTiz3COi4ujri4OP/rE6PMi+OSSy4pcWwA9erVw263s3TpUn/iPy0tjW3bttGpUyeSk5PxeDwcPnyYjh07nnE/Q4YMoXv37mzcuJEff/zRX3O9pBo3bszXX3+NaZr+Ue6LFi0iPDzcX+bGMAw6dOhAhw4deOKJJ6hduzaTJ0/moYceAiA5OZnk5GQee+wx2rdvz/jx44uVcD9frVq1YuLEiVSpUoWIiAj/co/Hw/Hjxy94/yIiIiKViSZNFangYmJiOHbsGKZpEhUVBaA67iIiIlLhOZ1O7rjjDkaNGsWPP/7Ihg0bGDZsmL+MSlJSEkOGDGHo0KFMmjSJXbt2sWzZMp5//nmmT5/u389VV11FQkICQ4YMoW7duqetcV4c9957L/v27eO+++5jy5YtTJ06lSeffJKHHnoIi8XC0qVLGTNmDCtWrGDv3r1MmjSJ1NRUGjduzK5du3jsscdYsmQJe/bsYdasWWzfvr1EddzPx5AhQ4iLi6N///4sWLCAXbt2MXfuXB544AEOHTpUJjGIiIiIVBYa4S5SwdWrV4/4+HgAQkJCsNvtpKenBzYoERERkVLw8ssvk5WVRb9+/QgPD2fEiBFFBhaMGzeOZ599lhEjRnDgwAHi4uK4/PLL6du3r7+NYRgMHjyYl156iSeeeOKcY6levTozZsxg1KhRtGjRgpiYGO644w5Gjx4NQEREBPPnz+e1114jMzOT2rVr88orr9C7d28OHTrEli1b+Pjjjzl69CiJiYn89a9/5e677z73k1MCoaGhzJ8/n0ceeYRBgwZx/PhxqlevztVXX01YWFiZxCAiIiJSWRjmiZmPRC5ymZmZREZGkpGRUeRW2ovN5MmTiYmJoVOnToEORURERAIsLy+PXbt2UbduXYKDgwMdjpQzHo+H1atXk5ycrPl/AkyfVRERkYuHSsqIXAQ2bNjA3r17AYiKiuLo0aMBjkhERERERERERKTyUcJd5CKwY8cOdu7cCfhudz5y5Ag5OTkBjkpERESk/BozZgxOp/O0j969e5dZHE2bNj1jHJ999lmZxSEiIiIipUM13EUuAjExMaSmpgJQs2ZNAPbv309SUlIgwxIREREpt+655x5uvPHG064LCQkpszhmzJiBy+U67bqqVauWWRwiIiIiUjqUcBe5CMTExLB9+3a8Xi8hISHEx8ezd+9eJdxFREREziAmJoaYmJhAh0Ht2rUDHYKIiIiIlCKVlBG5CERHR+PxeMjIyAB8o9z379+P1+sNcGQiIiIiIiIiIiKVhxLuIheB2NhYmjRpgtVqBaBWrVoUFBRw+PDhAEcmIiIiIiIiIiJSeSjhLnIRCA4O5sorryQiIgKA+Ph4goOD2bt3b4AjExERERERERERqTyUcBe5SGRmZnLw4EEADMOgZs2a7Nu3L8BRiYiIiIiIiIiIVB5KuItcJDZu3MjcuXP9r2vWrMnRo0fJzs4OXFAiIiIiIiIiIiKViBLuIheJmJgYMjMzcblcANSoUQPDMDTKXURERC4qnTt35oEHHgh0GCIiIiIip6WEu8hFIiYmBoC0tDTAV9e9SpUqquMuIiIiIiIiIiJSRpRwF7lIREdHA3Ds2DH/slq1anHgwAE8Hk+gwhIREREREREREak0lHAXuUjYbDaqVauGaZr+ZTVr1sTlcnHo0KEARiYiIiJybrKzsxk6dChOp5PExEReeeWVIuvr1KnDM888w+DBgwkLC6N69er85z//CVC0IiIiIiJKuItcVPr27Uvjxo39r2NjYwkNDVVZGREREamQRo0axbx585g6dSqzZs1i7ty5rFq1qkibl19+mRYtWrB69WoeffRR/va3vzF79uwARSwiIiIilZ0S7iIXmROTpgIYhkHNmjU1caqIiIicIiUlhfXr15/TtllZWaxatYrc3NxSjqpoH2PHjuVf//oXXbt2pVmzZnz88ce43e4i7Tp06MCjjz5KUlIS9913H9dffz2vvvrqBYtLRERERORslHAXuYjs3buXcePGFfnnt1atWqSlpXH8+PEARiYiIiLlzXvvvUfv3r3Padv169fTunVrfvnll1KO6jc7d+6koKCAdu3a+ZfFxMTQsGHDIu3at29/yuvNmzdfsLhERERERM5GCXeRi0hERARQdOLU6tWrYxiGRrmLiIhIEXfffTfffffdOW3brFkzVq5cySWXXFLKUYmIiIiIVGxKuItcRCIiIrBarUUS7kFBQSQmJqqOu4iIiBSRmJhIs2bNzmlbp9NJq1atCAkJKeWoflOvXj3sdjtLly71L0tLS2Pbtm1F2v3888+nvD55ThsRERERkbJkC3QAIlJ6LBYL0dHRRRLuADVr1mTFihW43W5sNn3sRUREpPxzOp3ccccdjBo1itjYWKpUqcLjjz+OxVJ0zNCiRYt46aWXGDBgALNnz+bLL79k+vTpAYpaRERERCo7Zd6kQsnLy+Pmm29m06ZNhISEUKVKFd555x3q168f6NDKjbi4uFMS7rVq1WLp0qWkpKRQs2bNAEUmIiIiUjIvv/wyWVlZ9OvXj/DwcEaMGEFGRkaRNiNGjGDFihU8/fTTRERE8O9//5uePXsGKGIRERERqeyUcJcK56677qJ3794YhsFbb73FnXfeydy5cwMdVrnRpk0bgoKCiiyLiorC6XSyb98+JdxFRESkwnA6nfzvf//jf//7n3/ZqFGjirSJiIjgiy++KOvQREREREROSzXcpUIJDg6mT58+GIYBwOWXX87u3bsDG1Q5ExISgtVqxev1+pcZhkGtWrVUx11EREREREREROQCUsJdKrTXX3+d/v37n3Zdfn4+mZmZRR6VxcaNG/nyyy8xTdO/rGbNmmRmZpKenh64wERERERERERERC5iKikjFdaYMWPYsWMHc+bMOe36559/nqeffrqMoyofoqOjycjI4PDhw1StWhWA6tWrY7fb2b59O23atAlwhCIiIiLnT3c6ioiIiEh5oxHuUiH961//YtKkSXz33XeEhoaets1jjz1GRkaG/7Fv374yjjJwEhISCA0NZceOHf5lNpuNhg0bsnnzZjweTwCjE6lczPx8vLm5gQ5DRERERERERMqAEu5S4fz73/9mwoQJzJ49m6ioqDO2czgcREREFHlUFhaLhXr16vHLL78UqeXepEkT8vLy2LlzZwCjE6k8zLw8jt52O7mTpwQ6FBEREREREREpA0q4S4Wyf/9+RowYQXp6Ol26dKFly5a0a9cu0GGVS/Xq1SMvL49jx475l0VFRVGjRg02btwYwMhEKg9vVhZmQQH2pk0CHYqIiIiIiIiIlAEl3KVCqVGjBqZpsnPnTtasWcOaNWtYunRpoMMql+Lj47n11luJi4srsrxp06akpqZy+PDhAEUmUjmYXi/WuDjivpiIERqK9yKesDh/xUpyZ80CwJuZyeFr+lKwajXgG+V/8gTOIiIiIiIiIhczJdxFLlKGYRAcHIzX6y1SVqZmzZqEh4drlHspUjJRfi9vwUJS+/TFc+QI5vHjHO58NXlzfiz29pkvvUzOpMmYJ312y5rp9Z71e9uTkoJZUABAzoQJZL0/1rdddja2evWxxEQDcPyt/3C489X+7fKXLMFz6NAFjFxEREREREQkcJRwF7mI5eTk8L///a/IhLEWi4UmTZqwc+dOcjWR4zkx3W4yX32NvHnzME2TtPvu5/i77wU6LClHrPFx2Js3wxIdjSUykrgpkwju2aPY27v37adg+XIOd++Ba0fZzLlgmiauHTvw/JoCQM7EL/i1dl28mZmA7yJA+lNP++Lbv5+DbS8nb84cACKfepK4iRMAsCYmEvPGa9jq1AEguFtXwv92v68Pr5ejw24n56uvAXDt2EnGs8/hzcry7ffAATwpKWVyvCIiIiIiIiIXghLuIhex0NBQQkNDT5kktWHDhhiGwZYtWwIUWQVntVKwciXu7TvANLHVrYu1WrVARyXlgDc3F9Ptxt6oEdEvvYhhtQLgaNMGi9NZ7P3EvPk6EU/8A3vTSzGC7BcqXLzHj5O/eEnhCy+p/QeQPX48AME9uhP17DMYhXFb4uOxJlQFwFajBjFv/wdHhw6+deHhGJbT/0kR1LIloYMGAmBYLFSdP5fQm28CwHNgP7nTvgHDACDz2edI+9uDgO8CwOG+/XBt3XoBjlxELkZz587FMAzSL+ISXiIiIiJS/tkCHYCIXFj16tVjzZo1uN1ubDbfRz44OJj69euzadMmWrRogeUMiTL5jff4cdIf/wfOO28nqHlzYj/52J9gjBjxkL/d8dffIKhNGxxXtD9lH56jR7HGxgKQO2sWlogIHJdfXqpxml4vGAaGYZD28KN409OJ/e+7pdpHeZTz1dfYW7bAXr9+QONIf2gEpttN7Pv/LbLctXETWR9/TNSY5zBsZ//V6z1+HCM0FEtICDFvvAb4ks9GYVK6NJzYX9Z/3yfr/Q9I3Lgew2olbuLn2C65BABrbCxhQ2/1b+O8bViRfYT063tOfVurVvU/D+7UiYRlP/tfRzw8CjM3z/fC48FwODCzss+pHxEREREREZFAUJZN5CJXv3593G43e/bsKbK8adOmZGdnn7K8svPm5GAWltpxbd7M8f+8DYARHIz34EE8h3yTzZ5uNK/pcpG3cBGuTZt8r71evDk5AOTO/oGDLZL95TKyP/yInC++9Pd5/N338KSmnlfsrh07OdjqMlwbNgAQck1vgjtd5e8j6+NP/PFcTEzTJO1vD5D53JhAh0LYkCGE3njjKcu9Odm41qzFW4z3OOPZMaT2H+B/7Tl8mNR+15K/YuV5x2d6vRy98y9kf/SxL97bbqPKnB/8I/GDLr0US2joefdzrmx162Jv0hgAw2Yj/uuvCGrdKmDxiIiIiIiIiJSUEu4iF7mIiAji4+M5fPhwkeVxcXFUrVpVk6eexHv8OCkNGpI7axYArq1byfrv+5i5uRh2O7ETJxDSvdsZtzfsduI+H0/YHbcDkNrvWjJfehkAR5vLiH7zdYyICABiJ3xG5LPPAODeupXMl1/GW3gLfPYn/yPj2ef8+3Vt3oz3+HEAPL+mkP355/7JNNOffIq0hx8BwFa7FqE33oClsI/gTp0IG3ILAAVLl5Lx1NN4jx4FfBcHLhaGYVBt9y/Ejvsw0KHguLLDab9HHG3aUGXWTKyJiX+4j7BbbibiwQf9ry0xMdguqYcR7DinmDyHDpH96WeYXi+GxYI9Kck/ytwaE42tevkuh+Q5eNB3t0ZhnXcRqTw6d+7MfffdxwMPPEB0dDRVq1bl/fffJzs7m9tuu43w8HDq16/Pd999d8Z9LFy4kI4dOxISEkLNmjW5//77yc7WnTMiIiIicuEo4S5SCfTt25f27U8tcXLppZfy66+/cuzYsQBEVf5YwsOJ/s+bBF12GQChAwaQuHY1RkgIQLFKehhWq79d+P/9H6HXXuvbd1QUoQMHYgkL8+/rxEjioORkqm1Yj62wHIrpcmEWFPiemyap/fqTM+FzAFybNpE+8mG8hRdQglq0+G1EsN1O5N8fw1a79ilxBXfpQsLKFdhq1vTts++1ZP/v0xKdH9M0S9S+rHiOHAF88XmOpQUkhtxvvuVwv/5/eCHjxPt6NkEtWhDc9Wr/a8NmI+aN1wi69NJivwcZz79AzrRvAPDsP0D646P9dz5EPDyKkD69i7Wf8sB0u8lfuAD3L78EOhQRCYCPP/6YuLg4li1bxn333cf//d//ccMNN3DFFVewatUqevTowa233krOae7g2rlzJ7169eK6665j3bp1TJw4kYULFzJ8+PAAHImIiIiIVBaGWV4zKCKlLDMzk8jISDIyMogoHAFcmZimicvlIigoyL/M4/EwYcIE6tSpw5VXXhnA6AIr74c5ZE+YQPSbbwS0nMbpmF4vrk2bsMbFYU1I8CVsTRPDcW6jncGX0D/+1n8IvroLQS1a4M3MxAgPP+sFBdPr5XCnLjiH30vYTTedc98XwtE/34bp9WKNj8O9axfxkyeVeQz5S5aQ+933RP3zqTO2yXjmWfKXLqXKt9+csY1r61YKli4j9KYbT3mPvdnZHPvLXYQNG0ZIj+6+5LvHg2GzkfPV12SNG0f8t99gGAbH7v0rQW3a4LxtGKbbDW43RnBwKR1t2TM9Hn/ZGxEpmby8PHbt2kXdunUJ/t3PgZSUFI4cOUKzZs3Yvn07VquVSy65hDVr1pCYmEhERASbN28mKSmJvLw89u7dS6tWrdizZw95eXk0bNiQTZs2ERERQWJiImvXrqVu3bpYrVZ27NjBpZdeytGjR/19ZGVl4SzBBNKdO3fG4/GwYMECwPd3S2RkJIMGDeKTTz4B4ODBgyQmJrJkyRLy8vLo0qULaWlpREVFceedd2K1Wnnvvff8+1y4cCGdOnUiOzv7lPNRGXk8HlavXk1ycjJW/ZwNqLN9VkVERKRi0Qh3kUrip59+4ocffiiyzGq10rhxY7Zt20ZBMUbeXrQMA0t4uH8ke3liWCwEXXop1oQE3+ugoPNKtoNvJHzEgw8Q1KIFpmly7C93kz5i5CntXFu3cmTIn/BmZGBYLIT0vQZbvcBOSno64SMeJPxv9xM6eDARI0YEJAZH+/ZnTbYDBPfojvMvfzlrm4JVq31liOz2U9YZoaFYa9TACAnBm5XFweTW5E6fAYC1Vk0cV14JhSPsY97+j3+SU8Nmq9DJdvDdOeLNyCDro4/L7Z0WIhXRe++9R+/evjtehg8fziOP+EqUXXXVVXz22Wf88ssvtG7dmvXr1zNlyhRat24NwDPPPMOwYcMAuOGGG/j3v/9NdnY2rVu35ocffmDJkiW0bt2aw4cPF+lj/fr1JY6xefPm/udWq5XY2FiaNWvmX1a1sETW70vnAaxdu5aPPvoIp9Ppf/Ts2ROv18uuXbtKHIuIiIiISHHYAh2AiJSNhIQEFi1aRG5uLiEnJZYbN27MqlWr2Lp1a5F/YCuT4K5XFynhUZkYhoHz3nsw7L47HzwHD+LefwDHZa2xREdjFrjwpB7BEhlJxCMPA767JXI+n0jo9ddhnCYxXNaCTkrGBIJpmrhWr8HWuBGWs1y0cbRr94f7Cht8s++8nmZSXsMwiH7pRf9r5z13YW/U0Lfvtm1xtG17DtFXHPlLl5I55nmCu3Q+bdkkESm5u+++m+uuuw6At956yz/Cef78+f4R7itXriQpKYkGDRrQqpVvEuN//OMf5OXlAfDll18SERFBWFgYK1eu9I9wX7lyJVWqVCnSx7n8nWH/3e8ZwzCKLDtxd5a3cG6Tk2VlZXH33Xdz//33n7KuVq1aJY5FRERERKQ4lHAXqSQuueQSFi9ezNatW2nZsqV/eWhoKJdccgkbNmygSZMmlep2Yvfu3WS9/wERjz6CJTw80OEETHCnTv7nmS+9TMGKlVSZ9xPWKlWI/3LiKe1dGzaQ/vfHsdWsiePKDmUZ6inyFy7CtWM7zsKRlgXr15Pz+UQin32mWDX3S4M3NZXUftcS8/5//7A2et6cH7HExhB00mfw94p7ESP8nntKEmaFF9y9O1V/Xow1JibQoYhcNBITE0ksnMy5QYMG/uUn/51wIsnudDqJi4sDoPZJF72aNGlyStuTn5/cR0nKyZSGVq1asWnTJurXL393Z4mIiIjIxUslZUQqieDgYJKSkli/fj1ut7vIuuTkZI4fP87WrVsDFF1guLZtJ3/pUqhEFxn+SMTo0cRN+uqsyeqgZs1IWLTQn2w3c3PLKrxT5K9YQc5Xv9Vs96ZnULB8Bd6jR8ssBkt0NPHff4ejwxV/2DbzhRfJ+err065z797NwQ5X4tq4qbRDvCgYhoE1JgYzL8/3uRUR+QOPPPIIixcvZvjw4axZs4bt27czdepUTZoqIiIiIheUEu4ilUjz5s2xWCxkZGQUWR4TE0ODBg1YuXIlrsIa0JVBSI/uVJn1fbmbKDWQrDHRWAtHMJ61XTXfaMWcr77mULceeI6lXejQTivigb8RP22K/7Xjyg5UmTWzWMdQWgy7naBLL8USGfmHbeO++oLIZ/55+pVWK8Fdu2IpHAkqp5f1wViO/vk2vMePBzoUESnnmjdvzrx589i2bRsdO3YkOTmZJ554gmrVqgU6NBERERG5iBmmZh+TSiIzM5PIyEgyMjKIiIgIdDgB4/V6sZymPnRmZiZffPEFrVu3Jjk5OQCRlR1vbi7ZH3+M889/LpcTpVYk7r17yfl6EuEP/A0Az68p2KqXTSLDNM0zjsR379+PtUoVjKCgCx5H1riPsISHE3r9dRe8LwFvdjaeX3/FflL5CxE5s7y8PHbt2kXdunUJruATKEvp83g8rF69muTk5EpVVrA80mdVRETk4qER7iKVjMVi4fjx4xw5cqTI8oiICBo3bszatWv9E6FdrAqWr+D4q6/jOXgw0KFUeLZatYh48AEMwyB/4SIOtb8C1+bNZdJ33vffc7BNO7zp6UWWu/fu5VC79uT9+GOZxOHauBFXMcsxeQ4eJPX6GyhYu/aUdfmLFgfsToGKxBIWhr1BA0yvF9eOnYEOR0RERERERKQIJdxFKqH58+czf/58fn+DS3JyMl6vl7WnSQZeTIKv6kjCsp+x1a0b6FAuKkGXtSb61X9ja9QIgOPvvEvBunUXrD9b7dqE3nwTlqioostr1SJm7Ps4Ona8YH2fLPpfLxP5+N+L1dYSE4M1Ng5+NzLfzM3lyC1DyPv22wsR4kXp+Guvc2TgILw5OYEORURERERERMTPFugARKTstWjRghkzZnDgwAFq1KjhXx4aGkqzZs1Yt24dl156KWFhYQGM8sJw7fwFa0LVYtXblpKxhIQQet0gwJdAzvnySywREQQ1b35B+rM3boy9cePTrgvp1euC9Pl7pscDFstZJ5k9mREURMx775y6IjiYqosXYQlViaPiChv2ZxztL9ccDCIiIiIiIlKuaIS7SCVUvXp1YmNjTzuSvUWLFthsNlauXBmAyC68o0P/TOaLLwc6jIueERJClR9mE3rTjQDkTJqMJzW11PZv5uWRM3Ua3t9NAOxfb5pkPP1PciZPLrU+Tyfnq6852CIZMz+/2NuYBQW4tmwpsswwDGzVq2GJji7tEC9a1pgYHO3bY5om7gO/BjocEREREREREUAJd5FKyTAMWrZsyYEDB0j9XRI0KCiI5ORktm7dSvrvamNfDGL/+x7O2/4c6DAqBcNiwbDZ8GZlkfHcGHK++rrU9u3atJm0e/+Ke9++0/dtGHjT0vBmZJZan6cT1LwZ4fffh+FwFHubnEmTONytB96sLP+yzJf/Rfann12IEC962R+M5XCPHqfU8hcREREREREJBJWUEamk6taty6WXXkpQUNAp65o0acL69etZsWIF3bp1C0B0F469aZNAh1DpWJxOqsya6R+97d6zB1vt2qdta7rdGLY//tUU1CqZhNUrscTGnrFN9GuvnlvAJXC2sjZnEtytG3FTJhdJ0nvT0zHCnaUdXqUQct0grNWrn1LLX0RERERERCQQNMJdpJKyWCxcccUVRJ6mlrnNZqN169b88ssvHDlyJADRXRh5P/7E8XfeDXQYlZI1NhbDYsG9bx+Hru5KzpQpALh37cK9fz8A+UuWkNKoCZ6UlOLts0oVDKv1rG28WVm4Nm46r9jPxDRNciZPxnPwYIm2s8bF4bisNYbd7l8W9dyzhN9zT2mHWClYY2II6dMbAM+xtABHIyIiIiIiIpWdEu4ildwvv/zC6tWrT1melJREZGQky5YtC0BUF4Zr82by584LdBiVmq1mTWJee80/qemRW/5E9tgPfesaNCB85AhwOPAcS8Nz7Nhp92F6vRy5+RbyfvrpD/vLePqfHPu/ezFNs/QOopA3NZW04fdTsGZNibfN/eZbsj76yLefjAzMgoLSDa4Syp74BYev6oTnIrpIKCIiIiIiIhWPEu4ilVxGRgarVq0iJyenyHKLxUKbNm3Yv38/Bw4cCFB0pSv8r/cSN3FCoMOo9EL69cUIDgYg9oP3cd53H+Ab+R1+z91YIiNJ7duX46/8+7Tbmzk5WOLjMJx/XIIl/N7/I3bCeAzDKL0DKGStUoXELZsI7tSpxNsWrF9PwbLlAGS++hqHu/cs7fAqneDu3Yl49BEsMTGBDkVEREREREQqMcO8EMP+RMqhzMxMIiMjycjIICIiItDhlBv5+fmMHz+epk2b0rZt2yLrTNNk2rRp5OXlcf3112P9g/Id5dmJH3UXIvEqpS9/0WJsDZOwxsWVyv5M0yy3771r61Y8B34l+OougQ7louHatBlb40bl9j0XKUt5eXns2rWLunXrElx4sfME94EDeM9wN9GFYImJwVa9epn1J3/M4/GwevVqkpOTK/TfeReDs31WRUREpGLRpKkilZzD4aBJkyZs2LCBxo0bEx4e7l9nGAYdO3bk66+/Zs2aNbRu3TqAkZ4f14YNHB08hLjJX2Nv0CDQ4cgfcHS4AgDT5SpS6xzA/csurIkJGCEhxdqXa8cOjt11N7EfjsVWp06pxZj54ksYYWGED//rOe/D9HiwN2yIvWHDUoursnPt/IXDvXoT8/Z/COl7TaDDESm33AcOcKhjJ8jPL7tOHQ6qLpinpLuIiIiIXNRUUkZESE5OxuFwsH79+lPWxcTE0KJFC1avXk16enrZB1dKLDExhN1xO1b9k19huPft41CHjuT/bh6BI0P/TMazzxV7P7bq1bFf2gzT7SndAG023+McmKbJoS5dSR/1MFn/fR/v70o6ybmz17uE2HEfEty7V6BDESnXvMeOlW2yHSA/v0xH1IuIiIiIBIIS7iJCUFAQ11xzDZdffvlp17dq1YqwsDAWLFhwQSafLAu26tWJePABLKGhgQ5FislavToh1/bDWqVKkeWx771L2O23F3s/RkgIMW+8hr1+vVKNL2LEQ4Tfc/c5bWsYBs7bb8MIDyfz9dcxzjFxL6cX3PVqDKuVgg0bOHbvX/Hm5gY6JBEREREREakklHAXEQCioqKwWCwcOXKEgoKCIutsNhsdO3YkJSWF7du3ByjC85P3wxzc+/YFOgwpAcNiIXL046eUgbE3bYK93iUl3l/+wkXkzfmxVGLzZmXhPc87PsJu/RNRTz9F4rq1GEFBpRKXFOVNS8eTegQ8pXx3g4iIiIiIiMgZKOEuIn4ul4tvv/2WZb8r4QFQo0YN6tevz5IlS8jLywtAdOfO9Ho5du9fyZ0+PdChyDkoWLuWo3fdg+lykf3Fl2R/Nv6c9pP1yf/I/nxiqcSU+823pDRrcV4jp73Hj5Mz7RvMrKxSiUlOFdzxSuK++ByL04nn4EE8KSmBDklEREREREQuckq4i4if3W6ndevWbNq0iUOHDp2y/vLLL8c0TX7++ecARHfuDIuFhJXLCRs8ONChyDkwbHa8qYfxHjmCa+NGCtasOaf9RP/7X8T8991SiSm4cydiPvgvlmJO3Ho63iNHSPu/e8mvYJ+nisYwDADSRj1C2gMPBTgaERERERERudipaKyIFNG0aVO2b9/OggULGDRoEBbLb9flQkNDadeuHQsWLCApKYlq1aoFMNKSsYSHBzoEOUf2pk2InzwJgKinnzrn/VicTgA8R45gjYs7r5isiYmEJCae1z5sdetSZc5sbA0bntd+pHiiX3oBz9GjAHh+TcGbk429fv0ARyUiIiIiIiIXG41wF5EiLBYLHTt2JC0tjQ0bNpyyvlGjRlStWpUFCxbgqSB1kbPGfkjGc2MCHYacp4J168iZPPm89pE3fwEHW12G+5dd57wP0zTJfO11XKUwn4G9USP/CGy5sKyJiQRdeikAx996i6N/Gorpdgc4KhEREREREbnYKOEuIqeIj4+nS5cuNGjQ4JR1hmHQsWNHMjMzWXOOpT3KnNcLphnoKOQ8Zb3/AWnD78c8j/fS0bYNUS++gCUx4Zz34U1LI3vcR7h37znnfUhgRT7xD2LHjcWw2fCmpZE7c+Z5fV+JiIiIiIiInKCSMiJyWvULSy0UFBRgt9uLjMKNiYmhZcuWrFq1isTExHJfWsb5lzsDHYKUgujXXyPyqSfPa0S4ERxM2OCbzysOa0wMiWtXY3q957UfCRwjOBh748YA5EydSubzL5KwcjlGYdkhERERERERkXOlEe4ickbZ2dlMmDCBHTt2nLKudevWVKtWjdmzZ5Oenl72wRWTmZuLtxzHJ8VnWCxYY2PPez+maZLxwotkT5x43vFIxRf25z9T5bsZWJxOzLw8UvsPJH/xkkCHJXLBWWJiwOEo204dDl+/IiIiIiIXMY1wF5EzCgsLo0aNGixatIjExEScJ43+tFgsdOvWjalTp/L999/Tv39/goODAxjt6eXNn8+x2+8kYeVyrAnnXkZELh6GYeBNS8eMyTyn7dNGjsIICSHqmX+WcmQSCIZhYLukLgDerCys1athqVoVANfGTVhiorEmJmK63bi3b8davTqWiAg8hw5hOJ1YwsICGb7IObNVr07VBfPwHjtWZn1aYmKwVa9eZv2JiIiIiASCYapoqVQSmZmZREZGkpGRQURERKDDqTDy8/P56quviIiI4JprrsHyu1G9mZmZTJ48mdjYWHr37o3Vag1QpKfnSU0lf/ESQq7tp8kp5RSm11vikerZEz7HsNkIveH6CxSVlBep112PtVo1Yt58A296OilNmxHz/n8J6dOb7Amfc/yt/1D1h1kYISGBDlXkjPLy8ti1axd169YtlxfGJbA8Hg+rV68mOTm53P0NV9nosyoiInLx0P3wInJWDoeDLl26kJKSwrp1605ZHxERQY8ePTh48CALFy4sdxMPWuPjCe1/rZLtclppD44g4/kXSrRN2OCblWyvJGLHfoDz7rsBMJxO4qdNxdH+cgAcHa4gfPhfMUJCME2z3P3sExERERERkcBQwl1E/lC1atW44oorqFGjxmnXJyYmctVVV7F169bTJuUD6fh/3sa1eXOgw5ByKqhlC+wNGwLgzcjAk5p61vaeI0coWLsW0+0ui/AkwCxRUQRd2hQAw2YjqHUrLNHRANhq1fJPwJszcSJHbx2KmZ8fsFhFRERERESkfFDCXUSK5dJLLyUuLg6Px4P7NMnGpKQkWrZsydKlS9m9e3fZB3ga3pwcst7/ANe2bYEORcop523DCB00EIDj77zL4e49z5o0zft+Fql9rwWXq6xClArAmpiIvXFjjLKegFJERERERETKHSXcRaTYTNPk22+/5eeffz7t+jZt2lCnTh1+/PFHjhw5UsbRncoSGkrimlWE9OsX6FCkAgi/526i33gNw+HAm57Ooas6k79kCQAFa9eS9d/3CRk0kCrfz1TNbikiuFMnIh//OwB5c34k88WXML3eAEclIiIiIiIigaCEu4gUm2EY1K9fn02bNrF3797Trr/66quJjo7mu+++IyMjIwBRnqqkk2JK5WSJiiL4qqt8L0wTx9VdsMTHA+Bau46s9z/AEhKCvUnjAEYp5Z17zx7fXTUeT6BDERERERERkQBQFkpESqRJkybUrFmTefPmkZube8p6m81G7969cTgcTJ8+naysrABE6ZP28COk//3xgPUvFZclOpqop57EXr8+AGFDbyVh+dIARyUVgfP224j54H0Mux33/v2YKj8kIiIiIiJSqSjhLiIlYhgGnTp1wjRN5s2bh2map7QJDg6mT58+AMyYMYO8vLyyDhOAoFbJ2Fu0CEjfIlJ5GYaBmZ/PketuIPOFFwMdjoiIiIiIiJQhW6ADEKlMzLw8jODgQIdx3kJDQ+ncuTP5+fkYhnHaNk6nkz59+jBt2jS+++47rrnmGoKCgso0zrCbby7T/kRETjAcDqJefgl740aBDkXkjI6nZpOXWXYXxYMjggmPDyuz/kpLnTp1eOCBB3jggQcA30W1yZMnM2DAgIDGdULnzp1p2bIlr732WqBDERERERGUcBcpMxlvvM7+j96m0XfzsVatGuhwzlutWrUA30SqqampVKlS5ZQ2UVFR9OnTh2+++YZZs2bRq1cvbLay+bHjOXQIT0oK9mbNMKzWMulTRORkwVd1BMCbmUnmy/8i4tFHsIRVvGSjXJyOp2Yz8f+m4nGV3QS/VruFm97pX+yk+7Bhw/j444/9r2NiYmjTpg0vvfQSzZs3v1Bh/qGUlBSio6MveD8FBQW8/vrrTJgwga1bt2Kz2ahTpw79+vXj3nvvpVq1ahe0/7lz59KlS5fz2seTTz7JU089xeTJk3nxxRfZvHkzXq+XWrVq0b17d10kEBERkYuSSsqIlJFfzTTW17eQnXY40KGUqn379jFlyhS2bdt22vVxcXH06tWLQ4cO8eOPP+L1ls0/9rkzviN1wCBNXCgiAefevZu8WbPxHDgQ6FBE/PIy88o02Q7gcXlLPKK+V69epKSkkJKSwpw5c7DZbPTt2/cCRVg8CQkJOByOC9pHfn4+3bt3Z8yYMQwbNoz58+ezfv163njjDY4cOcKbb755QfsHuOKKK/znPiUlhRtvvLHI+5GSksKePXv8z1977TUiIiKKrB85ciRz5szhpptu4rrrrmPZsmWsXLmS5557DpfmuBAREZGLlBLuImWk0X1P0OPFr4lo1AxvTs5pa59XRDVr1qRhw4bMmzeP/fv3n7ZNYmIi3bt3Z8+ePcyfP79Mku5hN99Ele+mY5RxGRsRkd8Lat6cqgvmYU9KwpuWxsE27cj/+WcAPL+m4Nqx86L5nSBS2hwOBwkJCSQkJNCyZUseffRR9u3bR2pqqr/NI488QlJSEqGhoVxyySX84x//KJLMXbt2LV26dCE8PJyIiAhat27NihUr/OsXLlxIx44dCQkJoWbNmtx///1kZ2efMSbDMJgyZQoAu3fvxjAMJk2aRJcuXQgNDaVFixYsWbKkyDYl7ePVV19l4cKF/Pjjj9x///20bt2aWrVq0alTJ959913GjBlzxm3T0tIYOnQo0dHRhIaG0rt3b7Zv3w747kyMj4/nq6++8re/5ZZbqFGjRpFYHQ4Hbrfbf+4TEhIICQkp8n4kJCRQq1Yt//PIyEgMwyiy3ul08s0339ChQwdGjRpFw4YNSUpKYsCAAfznP/854zGIiIiIVGRKuIuUEcNiIaZuE8yCAo4MvI7j/3410CGVCsMw6NixIzVq1GD27NkcOXLktO1q1apFly5d2L59Oz/88ANut/vCxhUSgr1x4wvah4hIcZ24+Gd6PIQMHIC1enUAsj/9lCM33OifDyP/55/xZmYGLE6R8iwrK4tPP/2U+vXrExsb618eHh7ORx99xKZNm3j99dd5//33efXV3/7OGjJkCDVq1GD58uWsXLmSRx99FLvdDsDOnTvp1asX1113HevWrWPixIksXLiQ4cOHlyi2xx9/nJEjR7JmzRqSkpIYPHiw/2+dc+ljwoQJdO/eneTk5NOuP9McOuArxbNixQqmTZvGkiVLME2TPn364HK5MAyDq666irlz5wK+5Pzu3bvJzc1ly5YtAMybN482bdoQGhpaonNwJgkJCWzcuJENGzaUyv5EREREyjsl3EXKmBEURNitfyKkT+9Ah1JqLBYL3bp1IyoqinXr1p2xXf369enZsyf79+/n22+/JTc394LEYxYUcGz4fRSsX39B9i8icq6scXFE/v0xbDVrAuD8y53E/s9Xo9rMy+Pon4aS/elnAHjT0vCcNIpXpDL69ttvcTqdOJ1OwsPDmTZtGhMnTsRi+e3fmNGjR3PFFVf465uPHDmSL774wr9+7969dOvWjUaNGtGgQQNuuOEGWrRoAcDzzz/PkCFDeOCBB2jQoAFXXHEFb7zxBp988gl5ecUvfzNy5EiuueYakpKSePrpp9mzZw87duw45z62bdtGw4YNiywbOHCg/1xcccUVp91u+/btTJs2jQ8++ICOHTvSokULPvvsMw4cOOAfld+5c2d/wn3BggU0bNiQTp06+ZfNnTuXTp06FfvY/8h9991HmzZtaNasGXXq1OHmm2/mww8/JD8/v9T6EBERESlPlHAXKSO56ansmD0RgLA/DcHeuDGm203+8uUBjqx02O12evfu7f8H7UzlEWrVqkW/fv04fvw4U6dOJSMjo9Rj8WZl4dm3H7ME/yiLiASCJTqaoEsvBcAIDqbKvJ8IvfkmALI/n8ihK67EVFJKKrEuXbqwZs0a1qxZw7Jly+jZsye9e/dmz549/jYTJ06kQ4cO/hImo0ePZu/evf71Dz30EHfeeSfdunXjhRdeYOfOnf51a9eu5aOPPvInsp1OJz179sTr9bJr165ix3nyJK6JiYkAHD58uFT7ePvtt1mzZg233347OTk5p22zefNmbDYb7dq18y+LjY2lYcOGbN68GYBOnTqxadMmUlNTmTdvHq1atfIn3F0uF4sXL6Zz587FjuuPhIWFMX36dHbs2MHo0aNxOp2MGDGCtm3bnvE4RERERCoyJdxFysiBFT+x/su3yM9K9y/L/vQzjt58C57DF8dEqsHBwVitVo4ePcq0adPIyso6bbv4+Hj69++PYRhMnTrV/w9pabHGxBA/dTJBl11WqvsVEbnQbNWrY42JASD0phuJGfsBhsOB6XJx9M6/ULB69R/uw7V58wW/w8c0Tbzp6Re0DxHwJWvr169P/fr1adOmDR988AHZ2dm8//77ACxZsoQhQ4bQp08fvv32W1avXs3jjz9OQUGBfx9PPfUUGzdu5JprruHHH3+kSZMmTJ48GfCVqbn77rv9Sf01a9awdu1atm/fTr169Yod54kSNfBbuZcTc9acSx8NGjRg69atRZYlJiZSv359Ygp/RpyrZs2aERMTw7x581iwYAGtW7emU6dOzJs3j+XLl+Nyuc44gv581KtXjzvvvJMPPviAVatWsWnTJiZOnFjq/YiIiIgEmhLuImWkXtcb6PPvb3A4o/zLwv40hLivvsBapQqelBSy/vv+RVG712q1kp2dzbRp00g/Q0ImIiKC/v37ExkZyTfffMPu3btLpW/T5cJVODHY2eqbioiUd9aYGIKv6giA9+hRvOnpGI5gANwHfsUsTCi6D/xKxgsv+n9/ZI37iPS/j/bvp7i/V9z79+PatNn/2szL89+t5M3MJPf77/2j7dMfGsHR2273tTNNsid8rgS8lAnDMLBYLP6ydIsXL6Z27do8/vjjXHbZZTRo0KDI6PcTkpKSePDBB5k1axaDBg1i3LhxALRq1YpNmzb5k/onP4JKaeL1c+lj8ODBzJ49m9XFuMh2ssaNG+N2u1m6dKl/2dGjR9m6dStNmjQBfpt/Z+rUqWzcuJGWLVvSvHlz8vPzee+997jssssICws79wMuhjp16hAaGnrWiWNFREREKiol3EXKiGEYOJxRuHKz2TL9I0zTxLDZCCqcDKtgw0Yy//WKv33OlCnkzV8QqHDPS1RUFNdeey12u51p06adcSLV4OBgrrnmGmrVqsXs2bPZsGHDGUvRFFfeTz9xuPPVuHb+cl77EREpT6wJCcR/9SX2Jr7JoNOGD/f/zjDz8sj5fCLuwhIaEY8+Qux77wLg2rGDlBbJpy1f5t63j6N33Im78IJn9sefcPQvd/nXH+7ek8xnn/O13bmTY7ffiatwUsXQIUMIf+gh37rt20l/9DFcheUqvJmZ5/2z/Hx5UlPJ/XZ6QGOQ0pGfn8/Bgwc5ePAgmzdv5r777iMrK4t+/foBvpHge/fu5fPPP2fnzp288cYb/tHrALm5uQwfPpy5c+eyZ88eFi1axPLly2lcOLH6I488wuLFixk+fDhr1qxh+/btTJ06tcSTpp7NufTx4IMP0r59e7p27crrr7/OqlWr2LVrF99//z3fffcdVqv1tNs1aNCA/v3785e//IWFCxeydu1a/vSnP1G9enX69+/vb9e5c2cmTJhAixYtCA0NxWKxcNVVV/HZZ5+Vav128N1h8PDDDzN37lx27drF6tWruf3223G5XHTv3r1U+xIREREpD5RwFyljR7avYf2Xb5F5oGhCOKR7NxI3rMMSEQFAzpdfkTdzJuAbte1NSyvzWM+H0+mkX79+hIeHM2vWLDwez2nb2Ww2unXrRrNmzVi8eDGLFi3y34J9LoI7dSL200+w17vknPchIlLeRb34AvamTQGwXVKXhNUr/bXgrTExWKv5akhb4+KIHP04QYX1pTOeeZb00f8AwBIRgTfzON7C8l/Ou/5C7Mfj/H1E/P1RQvpfC4D90ktJWL4Me+F+HJe1Jrjjlb51SUkkrFxO0OWXA5D24EMcu+ueUjtWMzeX7IkT8R4/Xuxtjv3fX/1lddy7d5P5r1cuijvIKqOZM2eSmJhIYmIi7dq1Y/ny5Xz55Zf+GuPXXnstDz74IMOHD6dly5YsXryYf/zjH/7tT5S6Gzp0KElJSdx444307t2bp59+GvDVXp83bx7btm2jY8eOJCcn88QTT1CtWrVSO4Zz6SM4OJg5c+bwyCOPMG7cOK688koaN27MAw88QIcOHfwToJ7OuHHjaN26NX379qV9+/aYpsmMGTOKlL3p1KkTHo+nSHK9c+fOeDyeUq3ffqKvX375haFDh9KoUSN69+7NwYMHmTVr1ikTw4qIiIhcDAwz0EOQRMpIZmYmkZGRZGRkEFGY1A6U/Kz0IqVlfs80TbxuFxYTjKAgsid+QcaTT1F18UJ/bd+KwuVykZmZSWxsrG9U/1nKvGzZsoUFCxZQrVo1unXrhsPhKMNIRUQufpmvvY6tbl1CCxPpF0L+4iWYrgKCO3XCvWcPGU88ReSY57BVL1kC033gALbq1TFNk8NXdSb0husJv/++M7Y3PR7M7GwsERG4duzAEhGBtUoVcmfOJOMfT1J1/lyMkBDyl6/A3rgRFqfzfA+1QsjLy2PXrl3UrVuX4OBg//LjqdlM/L+peFznfpG7pKx2Cze905/w+AtbrkSKz+PxsHr1apKTk884al7Kxpk+qyIiIlLx2AIdgEhl5HBG4XEXsH3meBr0GIw16LfEsnv3bvb87R7WV82m8+ixRNVKIrjr1WAYWGNiME2TrPf+S+i11/pHMJZndrud2NhYvF4vs2fPpk6dOmcczdSoUSMiIiKYPXs2U6ZMoWfPnkRFRRW7r+zxE3Bt3Ejks8+ofruIyGlEPPC3C96H44r2/ufeY8fwZmdjiYkGIHfGd9iSGmCvX/+s+8j76SeODh1GlR9/wN6gAbGfT/htH99Ox1qtGkGtkotsk/bAg3iPHCF2/GdF9h/SqxfB3btjWK2YbjfHbr+DkOsGEfXUk6V1yBVSeHwYN73Tn7zMvDLrMzgiWMl2EREREbnoKeEuUkYKclws+u9yWg9uTkRVJ1kH97L+yzeJqt2QhGa/JSdMl4vQmCrUbNeA8MQ6gK8kQNiNNwDg+TWF42++ib1BgwqRcD9ZSEgI8+bNIzU1lcsvvxyb7dQfQdWqVWPgwIHMnDmTKVOm0L17d6pXr168DkwTLBYl20VEyomg5GTiv/oC8N29lfnyvwju0Z3Ixx7FtWMHafcOJ/o/vt9p+ctX4N6yhbBb/4TjiiuIfuM1bHXqAPhHx5umSdbHn2CrW8efcD9x91TYLYPB4z3t7wCjcOSuYbMR/910LJGRABRs2ICtbl0sF3iCyPIqPD5MCXARERERkVKmkjJSaQS6pMy+1b8y89m5dB15JZe0r4XH5cGdf/yspWXOxJudjREaimEYmPn5GBWk9IppmmzevJklS5YQGRlJt27dzjiCvaCggB9++IEDBw7QoUMHGjdurES6iEgFZ7pceDMzscbG4t69m+PvvEfEyIewxseT/o8ncG/bTuzn48/68970eDDz87GEhpI94XPy584j+t23S/w7wvR4OHRVJxwdriT6pRfO99DKLZWpkLNRSZnyQ59VERGRi4cmTRUpI1UbxtGsXyNiakXh9Xj5+sEZbJ93CNPrZfO0seyc8yUAXo+bgqyMs+7LEhaGYRgcf/ddUq+7AbOgoCwO4bwZhkGTJk0YMGAAHo+HvXv3nrFtUFAQvXr1omnTpixcuJCZM2dy/CwT5uUvXYrnWMWaWFZEpLIx7HassbEA2OrUIfrF57HGxwMQ+c+niZs44Q8T54bViiU0FABvRjr2S5v67nAqaSxWK3Gf/o+IkQ8B4N6zBzM/v8T78WZmYp5hYvCS8Bw6RP7Spf7Xud98S/7y5b4+cnLI/XY6nqNHAXBt3UrOtG9+iyE9/bz7FxERERGR0qGEu0gZCQoN4vJhrYiqHoHpNWnUvT4JjeMpyM4gdetmMlKyAEjfu42v77icozvWA5B/PI3MlAyWjFtJTnpukX06Lr+ckH59wW4v8+M5H7GxsVx33XU0a9YMgF9++QWXy3VKO4vFwhVXXEHPnj05duwYX375JevWrcPrLTrBm+n1cuzev5L15ptlEr+IiJS+c7mLKfyeewi/bziG5dz+pLXVrYu1ShVMr5ejt91O+qOPAWDm5eHNzj7tNqbbTf6yZZhuNwBpI0Zx5Pob/Otzv/kWz8GDp93Wm52NN8N3Ud1zLI2M58bg/mUXADmfT+TobXdw4ubT42/9h9xvpvu2O3SIY3ffg3vLVgDyfvzJHyv4kvUiIiIiIlI+qKSMVBqBLilzNrNemE9OWi4DXuxJflY6a7+cSuO+1xIeH82Pz9yG1wzl8P7uDHy5FyGRp7/F1JuWhiU6miVvPUydq/qT2LxDGR/FucnNzeXzzz8nNDSUrl27EhcXd9p2BQUFLF++nI0bNxIfH89VV11FbOEoSQDPkSPg9WKtUqWsQhcRkYuIa+MmjJAQbJfUJfe77zh21z0krF6JNS6OgpWrMCLCsTdoQMGq1aT2u5a4KZNwtGmDa9s2PCkpBHfqhDc9nZSmzYh++y1C+/cnZ9JkMv/9KgkL5wOQesNNWOPjiHn7P3izszl8dTeiXn6J4Ks6+n6PeTxYq1Y9JTbT68U8ftxXTs5ux3S5wOstVkk5lamQs1FJmfJDn1UREZGLhyZNFSkHuj/ckdzMPADc+UGsnmolvnEW4fHRJLQeQtqeNG55YgD5x9M4uDkVZ1wMzpMmOctbsJCjt99B+PPP4srNxus+dbR4eRUSEsLAgQOZM2cOkydPplWrViQnJ2P53WjFoKAgOnToQP369Zk/fz6TJk2iefPmtG7dGqvVivUMiXoREZHisDdt4n8e1LIl0f9+xf+7JePZZ7FERRE77kPsLZoT/+007M2b+7ZLSsKelASAJSqKxE0b/Hee2erWIfTafpheL4bFQsSoEf4kuSUsjISlS/x9nu33mGGxYBRO9Aq+0jwiIiIiIlI+aYS7VBrleYT77+Vm5GEPsWMLsrLh2y3smL+bAS/1Ysl/HmX34hXU7DSGK+9qS25GHisnrqdFn3rk3f8XPCkHqbp4YZHb8r0eLxZr+a8e5fF4WLVqFWvWrCE5OZnLLrvsjG29Xi9r165l1apVhDocNP12Bo0efZigli3LLmAREak0vNnZ4HJhOcNE3+WZRs3K2WiEe/mhz6qIiMjFQwl3qTQqUsL9TLIOH+Dwlq1UadKOYKdByoY9LPjvVvo/34PQyCA2frECt8ukxZ/aYhT+0/TT64uxB9u48u62Z933iR8F51JDtzSlpqYSGRlJUFAQR44cISYm5pTR7idkZGSwYM4cfj1yhDrVq3NFp044nc4yjlhERKT8UhJPzkYJ9/JDn1UREZGLh0rKiFQgzirVcVapDsDaCa+ya94UbnprFtYg3+3p2dkm6f+bSH5dN8FXdSRn8mSiNm3BecvNAKQ/+hiOzp0I6dXrlH1nHdzDzEevo8voD4lr0KLsDup34uPjAXC5XEyfPh2n00nnzp2L1Gs/ITIykmsGDmTnzp0sWbKEL774gssuu4xLL730jEn68mz7vF0c2XmMy29rFfALHyIicvHLPvIr+ZlpZdafIyKasLhqZdZfaalTpw4PPPAADzzwAOAbnDB58mQGDBgQ0LhO6Ny5My1btuS1114LdCgiIiIighLuIhVW4363U6VpW6xBDrxuF/nH02j3l/Zkh+/BWq0au5ftJyrXQ53QVKI71QXAm52DN/WI73luLkZQkH8kvC3EyaXX/xVn1ZoBO6aT2e12+vTpw9y5c5k0aRKNGzemVatWhIaG+tu4f9mFa9tW6nXrRq1atVi+fDlLly5l27ZtXHnllSQkJATwCEpu+7xd1GpV8RIRcmF5jx/HvW079ubNzqlus5mbC8HBuogjIkVkH/mVbx/ojddVUGZ9WuxB9H3tu2In3YcNG8bHH3/sfx0TE0ObNm146aWXaF5YQz8QUlJSiI6OvuD9FBQU8PrrrzNhwgS2bt2KzWajTp069OvXj3vvvZdq1S7s3wxz586lS5cu57WPJ598kqeeeorJkyfz4osvsnnzZrxeL7Vq1aJ79+4V7iJBebvYIiIiIuVTxRsCKiIABDkjSWzeAYCtMz7hu4cH4srJIuzmm/FUqcFPry1ir7Mp0a/+279NzJuvE/qnIQAc//erpF7bH9PrBSAkKo7G/W4nOCKmxLF43S5+fvvvHPtl4zkdS87UaaSP/of/9fHX3yBv/gLi4+MZ2KcPl9Wvz44dO5g/fz4Fa9eSO2s2ALnff0/6o38H0/RPqjpw4ECsVivTpk1j5syZHD58+JxiKgtej5eVE9exf00KAD0f68SlfRspMSpFFKxaReq1/fEcOlTibU23m1/rJ5HzxRcXIDIRqcjyM9PKNNkO4HUVlHhEfa9evUhJSSElJYU5c+Zgs9no27fvBYqweBISEnAUTn57oeTn59O9e3fGjBnDsGHDmD9/PuvXr+eNN97gyJEjvPnmmxe0f4ArrrjCf+5TUlK48cYbi7wfKSkp7Nmzx//8tddeIyIiosj6kSNHMmfOHG666Sauu+46li1bxsqVK3nuuedwuVwX/BjKq8p87CIiIpWBEu4iF4FLrr6Oy+54AnuoE9M0Sd+zikGv9KFZv0Zs+Ppt1n/5FgAedwHf3NeNAyt/IqTvNdhvuYnsIyl4c3PJ/vxzvJmZ59R/flYGmQd24inIK1Z7b1YWma/8G9e2bQCYeXl409P9yf+8H3/CvXOnL+aNG6nyp6Hc0P4KrrjiCnImTeaXsWPZtGkTYXffRZU5s4uM+o2Li6N///507tyZjIwMpkyZwowZM0hJSTmnY7uQDIvBwU2ppO3LAMBqt5J9NIfv/vkj6fszAhydFIdpmuR8+RWeo0eL1z4vD/euXSXqI6h1a6rMnoW1SpVzCZHoN9/A0a7dOW0rIhJoDoeDhIQEEhISaNmyJY8++ij79u0jNTXV3+aRRx4hKSmJ0NBQLrnkEv7xj38USWiuXbuWLl26EB4eTkREBK1bt2bFihX+9QsXLqRjx46EhIRQs2ZN7r//frKzs88Yk2EYTJkyBYDdu3djGAaTJk2iS5cuhIaG0qJFC5YsWVJkm5L28eqrr7Jw4UJ+/PFH7r//flq3bk2tWrXo1KkT7777LmPGjDnjtmlpaQwdOpTo6GhCQ0Pp3bs327dvB3y/t+Lj4/nqq6/87W+55RZq1KhRJFaHw4Hb7faf+4SEBEJCQoq8HwkJCdSqVcv/PDIyEsMwiqx3Op188803dOjQgVGjRtGwYUOSkpIYMGAA//nPf854DJ988glOp9MfN8C9995Lo0aNyMnJOaV9ZmYmISEhfPfdd0WWT548mfDwcP82+/bt48YbbyQqKoqYmBj69+/P7t27i2zz4Ycf0rRpUxwOB4mJiQwfPhzwlRYCGDhwIIZh+F8DvPPOO9SrV4+goCAaNmzI//73vyL7NAyDd955h2uvvZawsDCee+65Mx67iIiIVHxKuItcBBzOKGpd3hOAX+ZO4qdnbyck3IthGGQdzSfjV98/dN6CAupc2Q9n1ZoEtWjBoSgP0+/vSebYsaSPfJjDa5eQl3mMrI8+4vibbxW7/5CoOHo8N5H4Rq39yzyHD/uS+IX/TGZPnEjGs75/LoygIHK+/Ar3Nt8/UbtsR/AMvw2jsO56/NTJOG8bBoA9KYnYzycQUqM6ERERRD72KHmjRrJw4UK+/PJL9mRk8Pu5ny0WC0lJSdxwww107dqVnJwcvvnmG7755hv2799/SvuyVJDjYu4bS0jdeRTDMOjz5NU069fIv94R7sDj9pKXVbajDuXcmOnpZDzzLLnffFus9pmv/JvU62/AzCvexSkAi9OJvUljjKCgEsdn2GyEDhqI7aSkgIhIRZWVlcWnn35K/fr1i8ztEh4ezkcffcSmTZt4/fXXef/993n11Vf964cMGUKNGjVYvnw5K1eu5NFHH8VeeLF+586d9OrVi+uuu45169YxceJEFi5c6E+yFtfjjz/OyJEjWbNmDUlJSQwePBi3233OfUyYMIHu3buTnJx82vVnuxtu2LBhrFixgmnTprFkyRJM06RPnz64XC4Mw+Cqq65i7ty5gC85v3v3bnJzc9myZQsA8+bNo02bNkXK+J2PhIQENm7cyIYNG4q9zdChQ+nTpw9DhgzB7XYzffp0PvjgAz777LPTxhUREUHfvn0ZP358keWfffYZAwYMIDQ0FJfLRc+ePQkPD2fBggUsWrQIp9NJr169KCjw/d31zjvv8Ne//pW77rqL9evXM23aNOrXrw/A8uXLARg3bhwpKSn+15MnT+Zvf/sbI0aMYMOGDdx9993cdttt/PTTT0Vieeqppxg4cCDr16/n9ttvL/4JFBERkQpHNdxFLjK12vUkrkFLbKFOAHJz25GXkYdpmthDnTS/+QF/29ptemB56yOCqlcnfNMGpo3sQ919A7kkzUrB0VSsxw4TEhJO6g03ETn67zguv/ysfWePn4AlLpaQHj1w795N+ohRBF12GZb69TFzcv0j6I2gIKouXohhsWCaJnsXf0dIVDzxjVr592WaJusmvk507UbU6tiLtN1bSFuxhTpX9qX1ZZdRp25dli1bxg8//EComce1g4cRERFRJB6LxUK9evW45JJL2LNnD6tWrWLGjBlUrVqVyy+/nLjoKLAYWG0lT2SeK2uQlcxDx8k+kkN8vVgMS9F/mG1BVvr+s1uZxXOxyV+yhLyf5hIx4iGMC3y7P4AlOpoqc2ZjLZzs94+ED/8rwVd3wQgOvsCRnT/P4cOkPfAgEX//O0GXNi3x9qbbjWHTnxkicn6+/fZbnE7f3zTZ2dkkJiby7bffFpkcffTo0f7nderUYeTIkXz++ec8/PDDAOzdu5dRo0bRqJHvAneDBg387Z9//nmGDBninxC1QYMGvPHGG3Tq1Il33nmH4GL+vB45ciTXXHMNAE8//TRNmzZlx44dNGrU6Jz62LZtG507dy6ybODAgcye7Sur17x5cxYvXnzKdtu3b2fatGksWrSIK664AvAlnWvWrMmUKVO44YYb6Ny5M++99x4ACxYsoGHDhlxyySXMnTuXRo0aMXfuXDp16lSs4y6O++67jwULFtCsWTNq167N5ZdfTo8ePRgyZMhZS/O89957NG/enPvvv59Jkybx1FNP0bp16zO2HzJkCLfeeis5OTmEhoaSmZnJ9OnTmTx5MgATJ07E6/XywQcf+C9YjBs3jqioKObOnUuPHj149tlnGTFiBH/729/8+23Tpg0A8YW/66OioorME/Svf/2LYcOGce+99wLw0EMP8fPPP/Ovf/2rSA38W265hdtuu62kp09EREQqII1wF7nI2EOdRNaoh8Ximwy14/+1o8ffO592JFRIlWokfTeXkP79sUZE0OulKTTsM5S8vn9iW/UaTPvr1eQd+hVbndrs3buWAyt/Inf2D2RNmcKR7WspyMmiYP16XPm5FOQcJ2/WLAqW+27RDmrdmmq7f8FeOCrIedswol960d/3idHshmHQ55VvqNf1BgAy9u/ENE3f6PxD+8hN990y/uvq+Wya/B4UHkdMdDS9e/emde1YQp2RhISEAL6ap7934rbfgQMH0qtXL9xuN1OnTmXqxE/54p5ueAtL2bhys8k5Vvo137NSs5n+5BwyD2VhtVno92x36rQ7++S0GSnHObDuYKnHcrFz795Dweo1cA6jwc9VcZPtAJbISBzt21/AaEqRaWI4wzHs55Y0P3TlVWS88OIfNxQROYsuXbqwZs0a1qxZw7Jly+jZsye9e/dmz549/jYTJ06kQ4cO/hImo0ePZu/evf71Dz30EHfeeSfdunXjhRdeYGdh2TrwlZv56KOPcDqd/kfPnj3xer3sKkEJsJMncU1MTATwzyNTWn28/fbbrFmzhttvv/20ZVUANm/ejM1mo91JpcRiY2Np2LAhmzdvBqBTp05s2rSJ1NRU5s2bR6tWrejUqRNz587F5XKxePHiU5L95yMsLIzp06ezY8cORo8ejdPpZMSIEbRt2/aMxwEQHR3N2LFj/eVaHn30Uf+6MWPGFDmfe/fupU+fPtjtdqZNmwbA119/TUREBN26+QYyrF27lh07dhAeHu7fLiYmhry8PHbu3Mnhw4f59ddf6dq1a4mOb/PmzXTo0KHIsg4dOvjP9wmXXXZZifYrIiIiFZcS7lKh3H///dSpUwfDMFizZk2gw6kQbEFWrDYLafsz+On1xbgLPKe0OZH8DomKIyQqnn2rfmXvumg6jnqLkDr1iHnrTVL2rOPQxqXkz5lDxuQvmT36ZlKmTSC1Vx+2f/waU+7qSMzYD4h8/O/Mff4ulr3/JIbdjisvm9n/GMzhTcsASN2ykuUfPOWv1753yUz2L58DwOHNK5kxoi+pW1YD0OFvr9Cw960ANB14Fz2f/wqLxUrOsUN8c38Pju5YT+ue19GzZw/y0w6RnZ3N+PHj+WHGNI4dOgBAQVYGqVtX43EXYBgGkRYXHZvWpXPnzmSbNo5fdgvff/UZeXl57PjhC6Y/2BtX7plrqpbEidI1Dqcv+Zt/3HcxoDiToq6auJ6fP1pVKnFUJmGDbybui8818WwpsFatSux/38XesOE5bR/x98cI6dP7nLbNfPEl0h997Jy2FZGLS1hYGPXr16d+/fq0adOGDz74gOzsbN5//30AlixZwpAhQ+jTpw/ffvstq1ev5vHHH/eXCAFfKY+NGzdyzTXX8OOPP9KkSRP/qOesrCzuvvtuf1J/zZo1rF27lu3bt1OvXr1ix2k/aT6ZE7+DTlzQP5c+GjRowNatW4ssS0xMpH79+sTElHyC+5M1a9aMmJgY5s2bx4IFC2jdujWdOnVi3rx5LF++HJfL5R8dX5rq1avHnXfeyQcffMCqVavYtGkTEydOPOs28+fPx2q1kpKSUqTm/T333FPkfFarVo2goCCuv/56f1mZ8ePHc9NNN2ErvNsqKyuL1q1bF9luzZo1bNu2jVtuucU/eONCCQsLu6D7FxERkfJD93pLhXL99dfz8MMPc+WVVwY6lAonP6uAw9uO4nV7IMh61ratb2pO8wFNsDt++xFx1ajfJrZy5mTT6/A+QmMTMKs1JLxeTcJbXoZhtbJ1zk5+WVmFnn/v7mvsNQlPrIst2PdPRl7mMY79ssmf5N+7ZCa24BBqtOlKSGwSOQU3kJsVd9q47CG//aOS2LIjEdXqArB2/Cvkph8hsuGD1I2rx/Zda9h94CCNmzSliiWHFa/dT/935hESGcvm8a+Tdng3vf81jUsuuYQfvxjH/uMFfPbpeKrY4knsMIL576ymywPtWfXRGFL3NaR225Y06Z1E2sx5bFmXQ7PbrsIZH0Zuuq9UT1bq/7N333FO1OkDxz+TnmyyvbOVsiy9N5FebKBiQ0URz/bz9CxnP/XUs52e7byzF8COHbCDAtJ77317r9n0ZH5/hB1ZKQKHuyDP+/XKayfJd2a+M0kgeb7PPN8Glr+/lvYjWxOTHk1cVgy1xfXM/td8zn54ONZIC6OvzCJYsB7aDj2i16v/pJ4YreHzH6qvx7dmLaaePdAdw481z7x5GDIzj6mOt3f5CvD5MA88+h/e/i1b8K1cRcSEy4963VBtLe7vvscyfNhRZZDDkQ1oHIzn5/noU1O0qzLE/8Z27thjXlefkYESHX1M63p+mkPDe+8R+9abR/1eUP1+giUl6BMSToqyP0KcihRFQafT4Xa7AVi0aBGZmZncf//9Wpv9s98b5eTkkJOTw+23385ll13G5MmTGTduHD179mTTpk1ane7fw7Hs47LLLuOBBx5g9erVh6zjfjAdOnQgEAiwdOlSLWheWVnJ1q1b6dixIxA+h4MGDWL69Ols3LiR7t2707VrV7xeL6+99hq9e/f+3YPDWVlZ2Gy2w04cu2jRIp566ilmzpzJPffcw80338zUqVMBiI2NPejAw4QJExg1ahQbN27kp59+4rHHHtOe69mzJ9OmTSMxMfGAMoT79+vHH39sUgpmf0ajkWCwafJKhw4dWLhwIVdddZX22MKFC7XzLYQQQohTj2S4i5PK4MGDSUtLa+lunJSScxO46N/nYLKZcNd62DJ7x2EnD90/2P5rBlsE0SnZmB3RWAYPJrJVNq16jSDgC5KYE0+XCy6mIi8eb4MPo81OxqBbqMwPT3CV3ncU6UMep3RruFRMj6uewBR/Oe5aD5ZIK+3PHMvuxYXavqbdNJPFk1cC4K7xsOb1OdQ99gK9JtyNcV+d+i4X30yPK+5j98J8LBURjB01lMz4DDav38LOaj9nPzsTsyMa1esl6aUvOK3PZeHjMBgYeMYEDIsdOHxRFHuL2aK4qIosI2/bZorXLcQWpWCODNcXrXx1MjuWFOH3hCdBWzt9EzP+9gM6gw5ThJFl76xh+9xfLg13JNoJesM/ytxffUX17XcccC5DwRAL31hO1d6aJo9boy0YzAYC3gCBHTuovPQygnsODCAciao/34T7m2+Pad2GyZOp//eLx7Sud+kyah96+JjWDVVVUfPXO7SJdZtDzb334vr4k2bbnzi0iMsuxXHD9ce2sqqCTndMAy/B/AJK+5+Gb/XqY9p1xRVX4nx78jGt612wENf0Gce0rurzEaqra9EJoYX4vXi9XkpKSigpKWHz5s385S9/wel0MnZseFCvXbt25OXl8dFHH7Fz505efPFFLXsdwO12c/PNNzN37lz27t3LwoULWb58OR06dADgnnvuYdGiRdx8882sWbOG7du3M3369KOeNPVwjmUft99+OwMGDGDEiBH8+9//ZtWqVezevZvvv/+eb7/9Fr3+4MkT7dq147zzzuO6665jwYIFrF27liuuuIJWrVpx3nnnae2GDh3Khx9+SLdu3bDZbOh0OgYPHsz7779/XOu3Q/gKg7vvvpu5c+eye/duVq9ezZ/+9Cf8fj+jRo066Dr19fVceeWV3HLLLZx11lm8//77TJs2jU8//fSw+xo8eDDJyclMmDCB7OzsJqV1JkyYQHx8POeddx7z589n9+7dzJ07l1tuuYWCggKtr88++ywvvvgi27dvZ9WqVfznP//RttEYkC8pKaG6uhqAu+66iylTpvDKK6+wfft2nnvuOT7//HPuvPPO//XUCSGEEOIkJQF38Yfl9Xqpq6trcjvV6Q3hj/zuJfksnboaT/2B9c6P1LaJf2XlXa9q99+9+jM2fLWFmPQoMnq1YuVHG/A5w5dz71lWwIavf7kses3bC9h+97MAuGrcbPh6K556L0aLgbjsaPaPk3Ub14H2w8OXW1fn17D8uyK8W3egulys/nQD815agiMli+jMdjgrXMRmx5Cc05X2mV3JbGjH4KFDiUpry/eT5/Lp518TeHMynvYDWPvlJgBssVY6j+7AGeNGM+GKCfTs1RO/zcMPPy/Ce/q1xI/qSGKulUX/uZukFx/gig+vICY9CoCOZ+Yw6MZ+xLeOZdTdg7nw+XPoe2V3AKJSHIy+N5wJD2C/4XoSf5x9wHl013ooWFN80Neiam8N7179GTWWFJIWLcDQ9sgvbd9f0pyfiLhq4jGtG/Pcs8RNPbYAov2qiaRs3/rbDQ9Cn5lJ6u6dx5RZf6wSv/sWx803Ndv+xO/DMmI4cW++cUzr6pKTiPvwfYz7AnFHy9SzJ/r0w8/PcCjub7+lYV/m5tHyzJpNcYdOqMfw/1yooYGyc8bgmb/gmPbtfOtt3F99fUzr+tauxbVfYPRoBMvKaHj/A0K1tce27zVrCJYd25wdajCI6vcf07rBkhK8ixcf234DAYKlpagHmavkj+y7774jJSWFlJQU+vXrx/Lly/nkk0+0GuPnnnsut99+OzfffDPdu3dn0aJFPPjgg9r6er2eyspKJk6cSE5ODpdccglnnXUWjzzyCBCuvT5v3jy2bdvGoEGD6NGjB3//+99JTU09bsdwLPuwWCz8+OOP3HPPPUyePJnTTz+dDh06cNtttzFw4EC+/PLLQ647efJkevXqxZgxYxgwYACqqvLNN980KXszZMgQgsFgk+D60KFDCQaDx7V+e+O+du3axcSJE8nNzeWss86ipKSEH374gfaHKFt26623EhERwRNPPAGEy+A88cQT3HDDDRQWFh50HQhn71922WWsXbuWCRMmNHnOZrPx888/k5GRwQUXXECHDh245ppr8Hg8Wsb7VVddxQsvvMDLL79Mp06dGDNmDNu3/zL4/+yzzzJr1izS09O1Kw/OP/98/v3vf/PMM8/QqVMnXnvtNSZPnnzcz6MQQgghTh6KKulQ4iSUlZXFl19+Sffu3Q/Z5uGHH9Z+TO2vtrb2kJeRnkrctR6sURb8ngDlOytJ7ZT0m+sEfEFQVfQmPUsf/pjCwiAXvhkuF7Lj5z3EZEQRlxXzm9vx/DyfYGEhEZddetT9DgZC6PQKiqKw6dtt+Nx+ul/QCQA1pKLoDsxqDQVDzHzuOzxJTmo9NZgNFtQCHWNuOIv4pLgD24dCFBYWsnnzZvbu3Ytep8NcW0Buz/506j+E8rU/k9RlACab46j7fzRCwRBrPttI+5FtiIi1/a77EkKcvIJFxfhWrsRy5hko+wXUjoTq8VDz4N+JuGICpm7djnrfVTfciKF1NpH33H3U69Y98yyuTz4leenRB6C9y5dTcf4FJM75EWNOzlGvX9Q2h8h778F+7TVHvW7lNdei+vzEv3v0AyQN775Hzf0P0Cpvz1GvG8jLo3TAQOI++hDLoCMvrefxeNi9ezfZ2dlY9iuV1FBRxFe3nUXI7zvM2seXzmhizAvfEhF//ILZ4n8TDAa1sjWHypoXzeNQn1UhhBBCnHwk4C5OSkcScPd6vXj3ywKrq6sjPT1dAu6/sm76ZlZ8sJbL3xyHxWGmeGMZUa0c2KKbThwV9Af58IbpdD0vl67ndSToD6IzHFvZhpZUVlbGls1b2L1nN/369SM3N5fa2lpUVSX6IDWjXS4XW7ZsYffu3VRWVgJgcJaTmpJEj+FjSUhIQKeTi4WEEKI5NX59Pdb/g/xbt6KLj0cfd+Cg62/xLlyEGgodVdC7UaiujlBV1THNqRFyu/EtXISxZw/0RzFp5uGCeA0VRXjrqo+6L8fKHBkjwfYTjATcTxwScBdCCCH+OCTgLk5KRxJw/7W6ujqioqIk4P4rakilam8NcdkxqCGVt8d/RJ8rutP1vA6Ub69kzRcbGXHH6ej0Orb9tIuk3HiiUk/+8xcKhVBVFb1ez/z589m8eTNxcXF06NCBdu3aNbnsulFtVQVLvphCICaD8joXPp8Ps9lMVlYWbdu2JSUl5XcJvm/9aSdBb5COZx19FqcQQohTmwTxxOFIwP3EIZ9VIYQQ4o/j0LMiCnECuuGGG/j6668pKSnhjDPOwOFwsGPHjpbu1klN0SnEZe8rA6PAJS+NxWAJ/9MQDIQIeIM4yxuITHaQM7x1C/b0+No/MD5gwADS0tLYtm0bCxcuZOnSpYwYMYKMjIwm69hsVoKbf6bbpbeR2nMoZWVl5OXlsXPnTrZu3YrNZqNNmza0bduW+Pj445b9X7GrmqAveFy2XHVk4QAAoYtJREFUJYQQQgghhBBCCCF+P5LhLk4ZkuEujoTT6WTTpk107NgRu93Ojh07MBqNpKeno9PpCIWC6HThDLBQKASESxqUlZWxY8cOdu3ahdvtJioqijZt2tC6dWtiYmL+p+C7qqoHrH+wx4QQQohfk6xZcTiS4X7ikM+qEEII8cchGe5CCLEfu91O3759tfs7d+5k7969WnBbVVVGjRxBw6rvcCZ0YN3WHbRr147+/fszcOBABgwYQFFREdu3b2f9+vWsWrWKyMhIsrOzyc7OJiEh4agD5Y3tdy/JJz47BpPdxPePz6XHRZ1J7ym1cIUQQgghhBBCCCFOFBJwF0KIwxg9ejTl5eVUVFQA4eB3TKSDjQu/Jv3MJPr168eaNWvYu3cvffv2JTc3l7S0NNLS0ggGgxQWFrJ79262bNnC2rVriYiIIDs7m4yMDJKTkzEYjuyf4YAvyKK3VtB+eGt6XNwFR6IdS6T59zx0IYQQQgghhBBCCHGUpKSMOGVISRlxPAX9PvRGEwBut5tly5axdetWzj//fBITEw9oHwqFKCkpYdeuXezZsweXy4Veryc1NVUL0EdHRx82+91V7cYabZFSMkIIIY6YlKkQhyMlZU4c8lkVQggh/jgkw10IIY6B3mhCDYXYMXsaSZ36MWTIELp3705UVBSqqrJ+/Xpyc3MxmcJBeZ1OR2pqKqmpqQwcOJCqqioKCgooKChg6dKlLF68mIiICNLS0mjVqhWpqanYbLYm+7TFWAEo3lSGTq8jqX18sx+3EEIIIYQQQgghhDg0CbgLIcQxCgZ8bPv2PQJeD5GtWhMVFQVAdXU1K1asYMmSJRgMBkwmEw6Hg/POOw+AhQsX4nA4aN26Nd26dSMQCFBUVERBQQGFhYVs3boVgJiYGFq1akWrVq1ISUnBZDKhqirL3l2DPcFGUvvTW+zYhRBCCCGEEEIIIcSBJOAuhBDHyGCyMPrJjzFaIpo8Hhsby/jx4ykoKMDn8+H3+5uUgXG73WzdupWlS5eSkJBA69at6dChAxkZGQC4XC6KioooLCxkz549bNiwAUVRiI2NJSEhgexLkklplUIoFEKn0zXrMQshhPjjcDqdeDyeZtufxWLBbrc32/6Ol6ysLG677TZuu+02IDyfyxdffMH555/fov36PUyZMoXbbruNmpqalu7KQblcLq688kpmzZpFfX091dXVREdHt3S3hBBCCCGakIC7EEL8DxqD7flLfyDo95F1+hgAIiIiaN++/UHXGTVqFD6fj7y8PHbt2sWaNWvo2LEjALt27cJgMJCUlESbNm0AqK+vp7CwkLKyMsrKyti6dSvqchWdTo/D6iAtqxUJCQnEx8cTHR0tQXghhBC/yel0Mm3aNILBYLPtU6/XM378+CMOuk+aNImpU6dq92NjY+nTpw9PP/00Xbt2/b26+ZuKi4uJiYn53ba/ZcsWOnTowOLFi+nfv7/2eP/+/VmzZg01NTVajW+Px0N0dDQvvfQS11xzze/Wp9+yY8cOHn/8cWbNmkV5eTmpqan079+fO+64g969ex+3/UydOpX58+ezaNEi4uPjtasLhRBCCCFOJBJwF0KI46Bw1TxQQ1rA3V1dxvI3HqbLJX8hJqvDAe1NJhNt27albdu2BINB9Ho9oVCIRYsW4XK5ADAajcTExDB48GA6dOhAZmamVhO+oqKCxZ8tp662lgJDARs3bgTCwYy4uDji4+NJSEggNjaW6OhojEZjM50JIYQQJwOPx9OswXYIT9Dp8XiOKsv9zDPPZPLkyQCUlJTwwAMPMGbMGPLy8n6vbv6m5OTk33X7ubm5JCcnM3fuXC3gXl9fz6pVq0hKSmLJkiUMHToUgMWLF+P1ehk+fPjv2qfDWbFiBSNGjKBz58689tpr5ObmUl9fz/Tp07njjjuYN2/ecdvXzp076dChA507dz7mbQSDQRRFabYEBZ/Pp31/E0IIIcSpQdIghRDiOOhz3UP0u/EJ7b7OYCQUDKDT//a4pl6vD6+j0zFhwgQuv/xyzjzzTHr27ElUVJSWxbZkyRImT57MjBkzwj84h+Yw7ppzGT9+PJMmTWLMmDH06dOHyMhIioqKmDdvHl988QWTJ0/mgw8+4JtvvmHRokVs2rSJ4uJifD7f73MyhBBCiOPEbDaTnJxMcnIy3bt359577yU/P5/y8nKtzT333ENOTg42m43WrVvz4IMP4vf7tefXrl3LsGHDcDgcREZG0qtXL1asWKE9v2DBAgYNGoTVaiU9PZ1bbrmFhoaGQ/ZJURS+/PJLAPbs2YOiKHz++ecMGzYMm81Gt27dWLx4cZN1jnYfw4YNY+7cuU3Wz8nJYezYsU0enzt3LpmZmWRnZwMwffp0evbsicVioXXr1jzyyCMEAgGt/XPPPUeXLl2IiIggPT2dm2++WRvoP5jy8nJ69+7NuHHj8Hq9BzyvqiqTJk2iXbt2zJ8/n3POOYc2bdrQvXt3HnroIaZPn661Xb9+PcOHD8dqtRIXF8f111+P0+nUnp80aRLnn38+zzzzDCkpKcTFxXHTTTdpr+XQoUN59tln+fnnn1EURRt0qK6uZuLEicTExGCz2TjrrLPYvn27tt0pU6YQHR3NjBkz6NixI2azmby8PLKysnjssceYOHEidrudzMxMZsyYQXl5Oeeddx52u52uXbs2ea8cyWuZlZXFo48+ysSJE4mMjOT6668/5PkVQgghxB+TBNyFEOI40BtMKIpC+ZaVrHrnKUz2aIbe9zpR6e2OajuKomC328nIyKBbt27aj3eAHj16MHDgQGJiYsjPz+fnhfMoLC7EU+dlxr++Y8PqDQSDQTIzMxk+fDiXX345559/PkOHDqVNmzbo9Xry8/NZuHAhM2fOZMqUKUybNo0ff/yRtWvXUlRUJEF4IYQQJyyn08l7771H27ZtiYuL0x53OBxMmTKFTZs28e9//5s33niD559/Xnt+woQJpKWlsXz5clauXMm9996rXfm1c+dOzjzzTC688ELWrVvHtGnTWLBgATfffPNR9e3+++/nzjvvZM2aNeTk5HDZZZdpge5j2cewYcNYsGCBto05c+YwdOhQhgwZwpw5c7R2c+bMYdiwYQDMnz+fiRMncuutt7Jp0yZee+01pkyZwuOPP6611+l0vPjii2zcuJGpU6cyZ84cXnzxxYP2IT8/n0GDBtG5c2c+/fRTzGbzAW3WrFnDxo0bueOOOw6aMd5YX72hoYEzzjiDmJgYli9fzieffMLs2bMPOAdz5sxh586dzJkzh6lTpzJlyhSmTJkCwOeff851113HgAEDKC4u5vPPPwfCgfoVK1YwY8YMFi9ejKqqnH322U0GXVwuF0899RRvvvkmGzduJDExEYDnn3+egQMHsnr1as455xyuvPJKJk6cyBVXXMGqVato06YNEydORFXVo3otn3nmGbp168bq1at58MEHD3p+hRBCCPHHpaiN3x6E+IOrq6sjKiqK2tpaIiMjW7o74g9qz4Kv2DHrI4be9zoGi+133Zfb7Uav1+Ot9vHtW7PRtwvidDm1DLSsrCxGjx6Nx+Nh7ty52O127HY7NpsNRVEIBoNUVlZSUVFBZWWl9qPebrcTHR1NdHQ0UVFR2nLjekIIIU4eHo+H3bt3k52drV0xBeHSZI0By+Z0wQUXEB8ff0RtJ02axHvvvaf1u6GhgZSUFL766it69ux5yPWeeeYZPvroIy0zOTIykv/85z9cddVVB7S99tpr0ev1vPbaa9pjCxYsYMiQITQ0NGCxWA47aeqePXvIzs7mzTff1Gqob9q0iU6dOrF582Zyc3OPaB+/tmPHDtq1a8eiRYsYMGAAffv25a677uL0008nOzubmpoaVFUlJiaG119/nYkTJzJy5EhGjBjBfffdp23nvffe4+6776aoqOig5+rjjz/m+uuvp7KyEr1er02aunTpUkaNGsW4ceN44YUXDvn//8cff8z48eNZtWoVPXr0OORr8sYbb3DPPfeQn59PRER4/ptvvvmGsWPHUlRURFJSEpMmTWLu3Lns3LlTu/rvkksuQafT8dFHHwFw2223sWbNGi3Lf/v27eTk5LBw4UJOO+00ACorK0lPT2fq1KlcfPHFTJkyhauvvpo1a9bQrVs3rU9ZWVkMGjSId999FwiXLEpJSeHBBx/kH//4BxC+urAxwJ+cnHzE75cePXrwxRdfHPJ8HMyhPqtCCCGEOPlIDXchhDiOsk4fQ+ZpZ6M0Q11Qq9UKgCnJxCV/Ox8AvzfAqs/XkTEkFaPJQNHGUiJaWVFVlZKSEpxOJz6fD71ez9VXX41Op2PdunXk5uZitVpxu93U1NRQU1NDQUG4NnzjuKzBYCAyMhKHw6Fdlt+47HA4pE68EEKI427YsGG88sorQLh0yMsvv8xZZ53FsmXLyMzMBGDatGm8+OKL7Ny5E6fTSSAQaJJc8de//pVrr72Wd999l5EjR3LxxRdrE5OvXbuWdevW8f7772vtVVUlFAqxe/duOnQ4cB6Wg9l/EteUlBQAysrKyM3NPaZ9tG3blrS0NObOnUunTp1YvXo1Q4YMITExkYyMDC2T2+v1ahnua9euZeHChU0y2hvr5rtcLmw2G7Nnz+bJJ59ky5Yt1NXVEQgEtOcdDgcQHtAfNGgQl19+OS+88MJhj/tIc7c2b95Mt27dtGA7wMCBAwmFQmzdupWkpCQAOnXqpAXbG8/l+vXrD7tdg8FAv379tMfi4uJo3749mzdv1h4zmUwHnWh3/8ca+9ClS5cDHisrKyM5OfmIX8vjOVGsEEIIIU4+EnAXQojjTNHpqCvazfxn/kL3K+6kVc+hlG1eQcHyH+lxxV3a80ZrBNaYxOO67/IdlWz+egc5A1tjsVmY/vAX9JvUk7POOUtr4/P5cLlc6HQ6VFVl586dWi1cs9lMfHw8AwcOJDo6mtraWlwuF16vl9raWurr66mvryc/Px+n09lkwj2j0YjdbiciIgKbzaYtR0ZGEhUVRUREhGTICyGEOCoRERG0bdtWu//mm28SFRXFG2+8wWOPPcbixYuZMGECjzzyCGeccQZRUVF89NFHPPvss9o6Dz/8MJdffjlff/013377LQ899BAfffQR48aNw+l0csMNN3DLLbccsO+MjIwj7uf+g86N/9eFQiGAY97H0KFDmTNnDl27dqVdu3ZaGZTGsjKqqtK2bVvS09O1/TzyyCNccMEFB2zLYrGwZ88exowZw4033sjjjz9ObGwsP//8M9ddd12TknJms5mRI0fy1Vdfcdddd9GqVatD9jEnJweALVu2HDbD/Uj9evBeURTtPP4vrFbrQb+DHOx1Ox6v5f4DC0IIIYQ49UjAXQghfgdGm4M2Iy4mKi0cJHBVllC+ZaWW+b701QewJ6Yx4Oan8DXUMffJ6+lx5T0ktP/ffqymdkri8tfHYbIZCQVDDLy+DznDWzdpYzKZMJlMQPiHZONEaGVlZZSVlVFZWak9v2LFCnbu3InJZCIqKgqdTkfHjh1p164dhYWFLF68mGAwiKIoGI1GjEYjBoNBy5B3u91NMuSjoqK0MjV2u13ri9FobPK3cf9CCCHE/hRFQafT4Xa7AVi0aBGZmZncf//9Wpu9e/cesF5OTg45OTncfvvtXHbZZUyePJlx48bRs2dPNm3a1CSof7wd6z6GDRvGLbfcQseOHbUJQgEGDx7MG2+8gaqqWnZ74362bt16yP2sXLmSUCjEs88+q9VbbyzVsj+dTse7777L5Zdfrk3empqaetBtdu/enY4dO/Lss88yfvz4A+q419TUEB0dTYcOHZgyZQoNDQ1aMHrhwoXodDrat29/VOdlfx06dCAQCLB06dImJWW2bt1Kx44dj3m7h9Ic7xchhBBCnPwk4C6EEL8Da3Q8uef8Uis26/QxZJ0+Rrvf/89PaMuhgJ/I1GxMNjsADRXFRMSnHPO+TbZwZtaOeXuY/+oy0rqnYE84fKaV2WwmPT1dy5Jr1KdPH9q0aUN1dTV1dXWoqqpNmmY2m7VsO5/PR11dHXq9ntGjRxMKhXj77bexWq1YLBb0ej2KohAZGUlDQwOFhYVarfmDsVgsJCQkkJCQQHx8PAkJCVJDXgghTkFer5eSkhIgXFLmv//9L06nk7FjxwLQrl078vLy+Oijj+jTpw9ff/11k9rZbrebu+66i4suuojs7GwKCgpYvnw5F154IQD33HMP/fv35+abb+baa68lIiKCTZs2MWvWLP773/8el2M41n0MGzaMhoYG3n77bd544w3t8SFDhnDttdcC8Oc//1l7/O9//ztjxowhIyODiy66CJ1Ox9q1a9mwYQOPPfYYbdu2xe/385///IexY8eycOFCXn/99YPuW6/X8/7773PZZZcxfPhw5s6dS3Jy8gHtFEVh8uTJjBw5kkGDBnH//feTm5uL0+lk5syZ/PDDD8ybN48JEybw0EMPcdVVV/Hwww9TXl7OX/7yF6688kqtbMuxaNeuHeeddx7XXXcdr732Gg6Hg3vvvZdWrVpx3nnnHfN2D6U53i9CCCGEOPlJwF0IIVqAIzlTW7ZExdH/z08CUL1nCz/cfwmD73mFlK4D/6d9tB2ShSPJrgXbVVU96oB1ZGQkkZGRZGVlHfBcfHw8gwcPPuh6qqoyaNAg6urqcLlcuN1uXC4XAwcOxGw2891335GXl9dknY4dO5KZmUl+fj4bNmygsLCQwsJC7TJuq9WqZdk3Hkfj39jYWEwmE16vF71ej9VqJSIiQitvExERcUDWnRBCiBPfd999p9VEdzgc5Obm8sknn2gZ3+eeey633347N998M16vl3POOYcHH3yQhx9+GAgHjisrK5k4cSKlpaXEx8dzwQUX8MgjjwDhGt7z5s3j/vvvZ9CgQaiqSps2bRg/fvxxO4Zj3Ud2djaZmZns3buXIUOGaI9nZGSQmprKnj17mmS+n3HGGXz11Vf84x//4KmnnsJoNGqTtgJ069aN5557jqeeeor77ruPwYMH8/jjjzNp0qSD7t9gMPDhhx8yfvx4LejeONC+v759+7JixQoef/xxrrvuOioqKkhJSeG0007TasDbbDa+//57br31Vvr06YPNZuPCCy/kueeeO7qTeRCTJ0/m1ltvZcyYMfh8PgYPHsw333zzu8wt0xzvFyGEEEKc/BT1SGe6EeIkV1dXR1RUFLW1tU0m0hLiRKCqKuun/ZvMQedRuWMtWQPPQWc4fj8UN3y9lfIdlQz9ywAUXctniXu9Xrxer1ZuRlVVLBYLFosFr9dLUVERlZWVVFZWUlFRgdVqJT09ncrKygMC9RAOwgQCAa3EwMGYzWatznxMTAyRkZFYrVZMJhNms7nJrTEjXwghTnYej4fdu3eTnZ2NxWLRHnc6nUybNq3JXBy/N71ez/jx47Hb7c22T3F4wWCQ1atX06NHjyaTlYrmd6jPqhBCCCFOPpLhLoQQJwBvXRV7F31LXE53Wg85H4Dagp0YLFYi4g9eN/VomCNM2KKtJ0SwHdAC24d6Ljs7m+zsbO2xUCiETqcjFApRUFCgBckb/zYGyD0eDw0NDTidThoaGnC5XDgcDlRVZffu3dpkr43lCQ6lsSZ9bGwsDocDv9+PwWDAZrNhtVqxWq2kpKTgcDjweDy4XC4MBgMRERESsBBCnBTsdjvjx4/H4/E02z4tFosE24UQQgghxB+eBNyFEOIEYImK4+xnZ2qTqqqqyqL/3EVkajYDb332f95+u6G/BK+L1pcQnRaFLcb6P2+3uTSWg9HpdGRkZByyXWOWfFxc3AHP5ebmEgwGqampobKykqqqKq1cTm1tLUuWLCEQCBAIBAgGgwQCAWw2G3V1dZSXl2ulbX69P0VRmmTWWywWsrKyGDx4MKFQiD179mileWQyWCHEicRut0sAXAghhBBCiONMAu5CCHGC0Bt/CcYqisLptz2HJSr+uO4jFAzx88tLadUthUH/1/e4bvtkoNfriYuLOyAgb7PZGDdu3GHXDQaD1NfX43Q6cblc+P1+fD4f9fX1Wq36+vp6PB4PW7ZsIT8/n6ioKIqKirRtmEwm7HY7Z599NlarlcLCQlRV1bLmGyeYFUIIIYQQQgghxMlJAu5CCHGCcqRkAeCuqaBg+Wzajbr0f96mTq9jzKMjMTvC5Vzqyxuwx9u0euWhYAidXiYXPRi9Xk90dDTR0dGHbKOqKnV1dVRUVFBRUUF5eTkmkwmfzweAz+ejqqqK9957DwgPrPx6KpURI0bQpk0btm3bxubNm7VJYnU6HSkpKfTo0QOPx8OCBQvQ6XRNnh84cCA6nQ6Xy4XFYpGJYoUQQgghhBBCiGYmAXchhDjBFS7/kY2fvUxG/zMw2aMp3biUuNadMdrCZQAqd6wDIK5t1yPanj0+AgC/J8CXd31HxzPb0evSrvi9AWbc+z09L+lC9oBDl20Rh6YoClFRUURFRdGmTRsgHIRvzIb3eDzahLFer5eGhgZtclin0wnAjz/+yKpVqzAYDHg8HhRF0W6lpaVs2rQJvV6P0+nUBkpUVW0SuP/uu++oqakhNjaW+Ph44uLiyMzMxGaz0dDQgNfrxWAwNLlJcF4IIYQQQgghhPjfScBdCCFOcG1GXkL6gDMw26NxVZUy59GrGXTnf0jrM5KyTctZ/ubD2OKSGXb/W0e1XaPFwOCb+hHfJhaAkD9IcodEotOifo/DOGUpioLJZNLKyRxKIBCgqqpKC8DX19djMBjw+/3araSkhPz8/CbBdZ1OR0REBHa7nXnz5uFwOEhLSyMxMRGXy0VRURGbN28mMjISm83Gxo0bWbNmTZN95+TkMHToUGpra/nqq6+0ILzRaMRisTBq1CgURWHr1q34/X7teAwGA3FxcVitVnw+H8FgEKPRiMEgXy+EONEcbB4KIcSJQz6jQgghxB+H/CIWQogTnKIomO3RAFijEzjn+W+wxiQCUFu4E73ZRv+bngJg+6yPSOzQm6i0tke07cw+aQD43X6m3/cDXc/rSEy6BNxbgsFgIDExkcTExMO2U1UVt9tNQ0MDDQ0NOJ1OnE4nDQ0N1NXVUVhYiMvl0trrdDocDgfLly9n3bp1KIpCZmamVo5Gr9cTGRlJaWkpiqKQk5OjTRrbGERvzKTfunUrZWVlTYICo0ePJisri02bNrFs2TJtnyaTiezsbAYNGoTH42HevHkYjUZMJhNGoxGj0Uj37t3R6XQUFxdrwfrGNhaLRQL3QhwHJpMJnU5HUVERCQkJmEwm7TMtRDAYBMDj8cgcIi1EVVV8Ph/l5eXa/59CCCGEOLkp6q+LxwrxB1VXV0dUVBS1tbVERka2dHeEOG5UVUVRFAI+DzNvHkXX8bfQZsTFOMsKqN69ibQ+I1EOUS6krmg3RpsDsyOWVZ9soO3pmUSnRVG5pxprtAVbtLWZj0YcD4FAgPr6em1C1/r6erxeLz6fTytv07js9Xq1gEsjq9WKzWbDarVq2ez73xoz4PV6PXa7Hbvdjtfrpbq6Wtu+3+8nMjKSNm3a4HK5mDdvXpNsfb/fz4QJE9DpdEyfPp3S0tImfRgyZAjt27dn8+bNLFq0SBsg0Ol0pKamMmLECILBILNnz8ZisWA2m7W/7du3R6fTsXbtWkpLS/F4PHg8HgKBAH369KFdu3YUFBSwdu1a9Ho9BoMBi8VCXFwcHTp0AKCqqgqbzYbZbCYUCmkDAoqi4HK58Hq92pUGiqJok976fD5cLpdWV19RFPR6PVZr+LMUCoWkfI9odj6fj+Li4iaDcUJA+N+k/Px80tPT5d+mFmaz2UhJSZGAuxBCCPEHIKljQghxkmvMVDSYLJz3yhzUfdnHe+bPYOvX75DebzQAC567jeiMdnS+6CaCAR+l6xezafqbmB0xDLrjRXpf+ksN+EVvrEBv1nP234ejqipBfwiDSTLfThYGg4GYmBhiYmJ+s62qqni9Xlwul5Y137jcWHO+vr4en8+nBe0Pddm70WjEarUSERGBzWbTthsREUGPHj0wm83abf9MyrPOOqvJIIDP59P6npSURL9+/QiFQtqtsTRPMBgkFApRXV2tBdV9Ph9ZWVlYrVbcbjfBYBC73U58fDwGg4GoqPAVHDqdDrPZTCAQwOv1UlNTg9vtpkOHDgQCAT799NMDju+KK67AZrMxf/589u7d2+S5fv360a1bNwoKCpg9e3aT52JjY7nooosAmDp1KjqdThvQsFqt9OvXD7vdTmVlJcFgEIfDgcVikSxkcdyYTCYyMjIIBAIHDLCJU5vT6eScc85hxYoVhy17Jn5fjYO/8u++EEII8ccgGe7ilCEZ7uJUo6oqflc9pojw+33L11OwxaWQ0f8MqnZv4vt7L+T0v/6bqPR21BbsoDZvG50vugkAT70Xb72XqNRIyrZV8PXDP3L+U2c2KTcTDPjQ6Y3y4/AUo6oqwWCwyeSv+99cLleT4H1DQ8NBA3x6vV4LvjfWfT/Ybf8SNPuXnDGbzdhstgPKYzRe8fG/CIVClJeXaxPM6vV69Ho9mZmZGAwGqqqq8Pl8TSatdTgcRERE4PF4qK6u1iayDYVCGAwGUlJSUFWVrVu34na7cbvduFwu3G43w4cPJyIigtmzZ7Nr1y7t/DgcDrp160b79u0pKipi2bJl2tUBPp+PqKgoxo0bB8CUKVO08j+N2fXnnnsuMTExrFmzhvz8/CbnOTMzk+zsbJxOJ7t27dKuWIDwwEnr1q0B2LVrl3YMja9FdHQ0RqPxuJxrIUTLku/HQgghhBDHn2S4CyHEH5SiKFqwHSD3nEnackxWB8b+ZzbWmAT0RhNFq+ZRvWez9vzcxy6j3ZkTiEq9EJNdofPZGUSlOgBY9NYKolIcuAo/pCZvG6Me/aDZjkm0PEVRtKBtRETEb7ZvrE3b0NCgZck3Zso3Lvv9fgKBgJZt3tDQQCAQaFJ+JhAIHHT7er0em82GzWbTMut/HbRvzBxszMBvvB2qXrFOpyMpKemQxxQbG3vI5ywWCykpKQd9TlEUcnNzD7nu4MGD6d69O06nUysJ1HiOjUYjMTExTQYeHA6Htm6fPn20IH9joL+xjI3FYiEiIkIrIeR0OklISADCwbaVK1cSCAS0Ejl2u10LuC9atOiAMiRjx44lJSWFZcuWsX79evR6vTYfQE5ODn379qWmpoaffvqpyXoGg4Fzzz0XgJ9++on6+vomAwS9evUiOTmZvLw89u7dqw0QGI1GYmNjSU9PJxAIsGfPHm1/jX+Tk5PR6XQ4nU5UVdWeC4VC2vlyu93U1tYSDAZRVVUrJRQdHa3NjdBYUiMUCqGqKlarVduuz+cD0M5x4/uu8Zw2vs/2vzW2byxL1HiVhsViQafT4fF48Pv92vuj8bXev5RRYyklGdwQQgghhBDi5CABdyGEOAUpioI9sZV2P3fMJHLHTAIgFAzQqvdwIlOyAKjbu4wdM/9K13MXYY6MoT5/LsEGG7mjx1JTWML3j36E12NnzD/ORqc/svqv9cV7qMnbRlrfURJE+oNTFEXLZP9fhEIhbSLXxsBxYyZ9Y1a9y+WiurpaC9433g51MZ/JZNLq1f86i74x2NuYTb9/nfjfa0JXk8lEfHw88fHxBzyXkJDAkCFDDrlup06dDvlcbm7uIQP9qampXH311VoQ+dcuvfRSgCaZ9Y1ZsFlZWdjtdi2QHAwGtb43TgIMaNvdf4AjMjISnU7XZICgMdjt8XgoLy/XBlr8fj/p6emkp6fj8XgOCOQDXHPNNQDMmTOH4uLiJs81zgewZ88e5s+ff8DxjxkzhmAwyHvvvXfAdhvLCC1atIg9e/Y0ea6xjFBRURGzZs1q8lxMTAwXX3wxAG+//fYBV3lcdNFFxMbGsmzZMrZs2dLkua5du9K/f39KS0uZOXOm9riiKNjtdi677DIApk2bRkNDA4qiMHDgQHJycg7ovxBCCCGEEKL5SUkZccqQS2aFODbumnLKt6wio/8ZACx/8xEUnZ7ef3qAHfO2svzl84ntcANnPHwb+Uvnk7fkS/r/+Un0RhP1xXswWO1Yo5sGELd8NYV1H7/IJe+s0h5TQyGCAR8Gk+Ww/fG7Gyjfuor4nO6YbI7DthUCmgbrG8u5/Prm8/kOmlXv8/kOGojW6/UYjUYtq7mx7ExjZnPjJKr7Z9RbrdYmNXr3/9tY110GoA5PVVWtDvn+df0dDgeKolBRUYHH4yEYDBIMBtHr9cTFxWG32/F4PLjdbi3w3/h8ZGQkoVCIgoICAoGAlk2u0+lISUnBYDBQU1ODx+PRBgUURWkyV0Ftba02wNO43YyMDAC2bt2qTZ67f0a+yWSiurqahoaGJsfncDiIjo7G7XZTWFjY5DgNBoMWWN+yZYuWdZ+WlnbYKy+EOBT5fiyEEEIIcfxJwF2cMuQHhRDHXyjgp3zbOqLTWmOwRvLB1f8kKn4jY59/H0VRmP3wldhikzjtlmcIeFwsevFOOl34Z2KzO1KyfhE1edvoMPZPAHx71/kkdelPz4n34izNZ/6zt3DaLf8iKq1tk3021p8/48lPiW3difItK8lfNoueE+8FoHDlHMyOaOJzehAKBfE31GF2/DJ56IbPXiGxQ28SO/ZpvhMlTlqqquL3+7VJWb1er7bcGFxt/Nu43Ni+MZjfWDLkt+h0OiIjIw+4mc3mJuVi9s9Gb8y6bwzmCyHE0ZDvx0IIIYQQx5/8MhNCCHHMdAYjSR17ARAKhjjt/64gvnUMiqKQt7KQ+M7X0vq0cJan39OAGgqi6HQoOh3Okjx2zP6Y3DFXoygKnS++CVts0r5tBYjObI8tNhmAVe88RdDnps+1D2OOjMUSnYi7uhyA+uK9VO3coPVpw2evEJvdkficHniqy5n+52EMvucVWvUcSk3eNnbP/QJzZOwBAXc1FMLvacBgtqLTGw46Kezaj14g4HHRa9LfjvpceZ01eGoqiUprc9TripajKAomkwmTyXTMwahAIKAF4Btr0TcGzBuD58FgkPr6eurq6qirq6OgoIC6ujpCodAR72f/zHqLxdJkktn9/zZmWjdmcTcu/zpL/9c18CX7XgghhBBCCCF+m2S4i1OGZPAI0byWvbeGsm0VjPnHSFRVZcUH62g7KJOYjGitzayn5xMKhDjjb4euTQ2wc85nhHxe2p1xOWooxLqPXyTr9DEHZL/DvgkKA370RhMBj4vCVXNJ7jwAc2QMaz54jrzF33Luf8L1ln98ZCJpfUbS/uyJVGxbw6wHL+Osf00nOiOHtR8+T/7S7xnzwncALH/jYYJ+H9GZOWQPOZ+CZbNJ6z0Cc2QMPmctqhrSMulr8rZhtNmJiE/F66yhaPXPeKrLWfvh8wy7/y2q92zWaubv+PFj7InpJHcZQCjgx11dhjUmEZ3BqB2Tu6aCJS/fR/fL7yAm69CTbh5K3uLvsCelE9v60HW+xYknFArhcrnw+Xza5KL73wAt474xm75xuXEy2saa941/jzTb/td0Ol2TGvb7LzfWud//1hjcbwzo6/X6Jv0WQpwY5PuxEEIIIcTxJxnuQgghfhd9r+hO0B+eKNBd62HrjztJ6pBATEY0BWuKKd5YSofRbQkGgtSXN2BxmDFaDv7fUpthF2rLik5Ht0tvA6CmsI7yHZW0G5INQOWeamLSo9AbTQAYLDYyTztbW7fbZbdrgW6A5K4DiWwVzjiPTM1m4G3Pa1n26f1GE5PdUWsb9PtI6tSX7CHnU7ljHctee5C4tl0xR8awacabFCybzZgXvgVg/jN/Ib3fKLpPuBN3VRlL/nsPg+95lZGPvEvFtrXsXfSN1o89P88gsUNvkrsMoL5kL9/cMZaRj7xHQm4vds75jKKVc+j1pwcxWmwUr5lPwNNAQm4v/C4nRavnkdRlAJbIWGoLdtJQXkhK90EHBDXXvP8vsgade0wB95VTnqBm71ZGPDQV2Deg4fehN/32JKgV21azafpbDPjLUwS9HgpX/ETGgLMw2uxs/OI1KrauYsi9rwEw68HLyBp8Hu1GXYqntpLidQvx1FSS1nsYEUnp6HT639jbH49Op8Nutx+2jcNxdPMYNE5Q2vi38daYZb9/mZz9l/cvpdO4XFlZqd1vrCV+JMek1+u1IH3j1QON9xsz6hvbNf5tXN4/gN+43Di5bWMWv2TjCyGEEEIIIVqSBNyFEEL8bvTGcJDUFm1lwlvjYN81VTWFdZRsKqfPhO4ATLtpBmk9Uhl4bW8aKl0semslfa/oRlRqJJ46LzqDgslmQg2plO+oJCLOxrY5u9gxfw/uag+tB2YS8Ab44q7v6DexB13G5qKq6gFBN0VRsET+MrFgp3E3aMsmexQZA87U7se27tQkQN3/z09oy3FtuzL+g/UoSngCxdZDLyCpc3/t+cF3v4TJHgVAZFobLn53NXqjGUVRiM/p0SToP/KR97RlW1wKQ+97g6iM8KSIpohIIhLTsMUmcfpf/813916Iz1VHQm4vXFWlLHrxTkY+8j6WyFgKls1i+w8fcP6rPwOw+L93E9+uO+3OuJwznviU0k1L8bnqMdkclG9dTX3xHloPHQfA9lkf4UjKILnraXjrq9k19wsyB56DLTYJo9UO+53Hb+88l8RO/ej9pwdwVZaw5OX76HnVfURn5FCTt43qvVvIHnQuAMtef4hQMFxCxVVZwrI3HiKmdSdiszsSld4OncGkbTe560AcKVkAVO3ayJL/3oOiNxARn8KWr6dQs3cbox79AICFL/yVjAFnkt5vNO7qMorXLiS97yiMNjt+dwOKTseiF+8islU23S+/g6NVuGoulTvW0fWSW4563YDPg7uyBFtCKvr9ju9E0Vg65ngLhUL4/X68Xq92a6xr3xjUb1xurHPfGKj3er00NDRQVVXVZELU/f8ezQWZiqJo5XR+Hajfv4TO/hOgHiz7/tdlfwBt3V/f9n98/+03Di78emDBZDIdciAB0AY8Gs9V43JjP/bvb+Pf5OTk3+W1FUIIIYQQQhwdCbgLIYRoFoqiwL54Vudz2tP5nPbac0NvGYApIhyc9Ln9eGo9KPpwMGz1ZxvYsySfy147n6A/yMwHZ9NrfBciUxxk98+gx0Wd0Bt06PRGzn18FI6kcEbwms82UrShlLMfGo6iKFTl1RARZ8McYaJ8eyVbftxJ/0k9D5lV/1t0+l/Wi0zNJjI1W7u/f6kbnU6PznRkQTCjNYKU7qdr99P7jiK97yjt/pn//EwLuEWmZnPR1BXoTRYAcsdcTZuRl2htLdEJGPcF/Rsqilj4/O2c8c/PwhPWrl1A3pLvtYD7nvkzSe5y2r6Aew0bP3+VhNxe2GKTiEzNpr54j7bdLuNvwZGcCUAoGMRkj9b6sHfh1+xd+LUWcG8z4mKi0tpitEQQnZXLJe+u0a4+SOs9vMmxd7n4Zm05tcdgLnxrCcaIyPAgSVQcyV1O+6WxoqDsy3iv2buNpa/8jeSup2G02Vnz3r+o2rWR1sMvxBodz3f3XkjbEZfQdtR4qvdsYc37z9DvxiewxSayY9Y0avK30/tPDwCw7PW/k9S5P976aso2LmPRi3fR7bLbiEhoRf7SH6javUm7umLjF68RnZFDq17DCHhclG9bTVzbrtTs3cqPD1+pTeoL4cEGvdGMOTKGoN9HXeEu7MnpGC0RuGsq8NRWEpMZ/jzMvPVM2o68hA5j/0TA56F0wxJiW3fCGp1A0OcFRdHO4a/lLf4WUJoMHB0pT10V7qoyYrJycVWWEPT7cCRn4HPWsnLqk7QdcQkJuT1RQyGUfYHq/TWWnDGbf/vKh2Oxfzb+/rf9J6r1+XxNbn6//5DrNWb1AwedjPbXAflG+7dr3Mahlhv719ifYDD4u5ybRldeeSVWq/V33YcQQgghhBDit0kNd3HKkBqVQpycagrraKh00apreALV6rwaolpFotMfGPTbX96KQqryauh+QSdUVeWtiz+k/6SedB6Ty+rPN7Lyg7VMeHMc1mgrqz/dgLPCxaD/6wvA90/OI2doNtkDMvDUeanaW01i+wQMJj1ep4+fX15Kj4s6Ed869rB9+DVVVfG5AxjNeqr21rD1p130uKgTtujfN0gWCvjxu50YbY4mAwXHmxoKhYPhzVzOI+j3odMbUHQ6qnZtxNdQR3KXAQBs+PQlEjv2JbFjH2rytrHh05fp9af7sUYnsPPHT6jJ365Ngrv4v3eT3O10sgedS23BTla89Q/63vAojuQMtn//ASUbljDojhcBmPvk9SR17k+HsX+ies9mvrvnAkY//jGO1CxWvv0opZuWc/7LcwD4+o4xpHQdSM+r7qOuaDdf3342Ix5+l8QOvdn05Rts/uptLnxzMQBf3DCYuDadGXz3y7iqSpl+41CG/u1NUroNZOu377L2/We5+N3VKIrC8jcfxhKVQJeLb8JbX83MW0YT26YLwx94m7zF37F5xpuMfuITFEVh4+evYrDYaH/2RAIeF0tfvZ/2Z08kPqcHhSvnsOKtR/HUVjD+/XXMefwaDJYIBt3xIsGAjx8fnkivSX8jrm1Xtn33Ptu+e5dznvsGRaejcucGfA11/Pz0jQy+8yX0JhMxWR0x2uw0VBThri4nvl03ACq2r8VkcxDZqjVBv4+avVuITG3NyqlPEte2C+l9R2GJivvN19tVVYazZA+JHftStHoe+ctmkzHgTFK6DkQNhQj6PBgstt/cjrumnOrdm0jqMuCor0ZQVRVXRRFmR8wR7QvCWev7Dwj8OpN//4GAxglrjUZjkwlsGz9bB8u+t9vt2iBBKBigZN0iIlu1wZ7YCm99NQ3lRURn5DSZH0II+X4shBBCCHH8HT5aIYQQQrSw6FaRWrAdICYj+jeD7QAZvVvR/YJfSsKc++RosgdkhJ/rmUr7kW3Rm8LBZ0ukmYjYX4LeRotBy7Av2VzGzAdm42sI16heMnUVRRtKCQVCAMx66mf2LM0HwoMB819dhtfpBWDnwr2sm7EZgFAwxNQrP2Han6ezZMoqvE4fRetKMO/L7F/z2UZ2zN9z2GPavSRf297R0BmMoNgo31Gt1dX/PSj7Smk0N73RpGVdx7bupAXbATpfdBOJHfsAEJ2Rw+l/fQFrdAIQzsBvDLYDDLj5aS07PyqtDSMemoojOfyeaXfG5VqwHWDofa/TYeyf9rVty9j/zCY6sz0mm4MO515Ln2v+rrXtd8NjtBt9GQAR8amMfvxjYrI6AJA99HyGP/C21nbUox/S5/pHALBEx3PeK/O0/qd0O53+Nz2pnWNbbDIRCakA6IwmWg+9gJ4T7w2vGxVHfE4Pra3f7cTvbgBA0enx1tcQ3DeBqskeTWLHPox4+F0Ael51Hz2uvCd8bg0mRj/2EXFtu4bPb5vOtB11mXa+Fz5/G4Urf6LHFXej6PX8+MhV1BbsAGD33C9Y8OxftGNb/sbDbPv+fQDcVaX8cP94KndtQG80UrZ5BV/d+ktm/o+PXMXyNx4GwFtfzVe3nUXZ5hUA5C3+hrlP3oCqqpRtWk7BslkUrggPbriqSvnkql4Ur1kAwM6fPuWH+8dr25375PWsnBIuD1W8ZiHz/vl/lOxrW7hqLgueu1Vru/6Tl9j6zTsABLxuFv77Diq2rwWgZN0iZtw8kvxlswHY+MXrbJr+Rritz8NXt51FwfLwc0Wr5/HNneeiBrzYbDZKFn7J8qeuoXjWVFJTU9n94ROYawpo3bo1dk8Fu97+G6kJMaSnp+Pc+DNlC74gOjoau93Onh/eZ8+s99n43pOozkr2/vAuVoOOyMhItsx8ixVvPxruvKIw/9m/ULjyp3B/1y/m+/suoq5kL2s/fJ7lbz/K6vf+pR3rgudupWTdIgCqdm9i+ZuPaO+XknWLKFgR3k7+slns/OkzGiqKAPA5aynfupqgP/zvo7u6jIaKYm27fk+DVlaqobyI6r1bCYX2ze1RU4GzNF9rW5O3DVdVmbZexbY1BDwu7XWtLdipDS7UFuzEVVkSbutuoGjNfHwNdQA4S/O19wpAXeEurW0o4Ke+ZC8Brzv8WnlcuGsqtLY+Z6123KFQEHd1WfjKEsDrrKE2f7vW1l1TjtdZw5FQQyHtPKiqirumQuuDEEIIIYT445GSMkIIIf7wFEUhsV28dj8uK0bLZgfoMLpdk/bDbx+oLaf3TGX8y+dijbJo95Pax5OY88v2Gmucexv8lG0tJ7gvGF+1t4aaglo4twM6vY5+E3sQ8AZJzk0goV0cF784RttExe4qQsHweg1VLlZ+tJ6+V3THEmlm+7zd1Jc6ASjdWoG33ktyx0TSe6TSUOVi96I82g7OxhJpJn9VEbXF9VrJnu+fnEdm71ZYoy1899hc0ronM+jGfkQmOyhYU0x1fi1dxuYCsG76ZmLSo0jvmYqr2s3Gb7bRYXRbbLFWPvnLV2T1T6ffxB4A1BbXY7absDgOLCGihlQ8Ti/WyPA5++7xucRlxdBnQjeq8mqY88IiRt55OlGpkaz9chOFa0s4+6Hh2rHboq0oun3n1OnF7wlgj484gle6ZegMRuyJrbT70Rk5RO+rww8Qn9NdW9abzMS17aLdt0YnaAMAQJPt6HR6bLGJ2v1fly7qdMH/actGSwQ9r7pPu5/YsY8WqAfoPuHOJn0Y/uBk7X5C+x4ktO+h3d+/JNKvxbfrpmWsQ3gOAoPFhikikqDfx5gXvsUaFx4gazf6cjJPH6u1HXLvq1o5HGtsEmc+/SX2xDSSO/fHWZpP68Hna23bjb4UY0Q421bR6UntORTzvhJJ2UPOJ73fGdpxdZ9wpxaINdkcDLj5aaKzwu9p+765CRplnHY2lsgYAFK6D6TNyPHYkzK05/e/8DPocxPc119VDeGtqyK0L7AcCniJSm9HUqd+4ft+rzYIoTeaadVrGLa4FAAsUfEkde6P3hj+rATcDUTEp5CQ2ytcukZv0P4NMdujicnuoLX17Cs51GjnT5+Q3Lk/QZ8PV0UJO2Z9ROthF2G02TFFRBHcN3mtTqdn7IuzsEaH/51K7TGEM578FDUQYO+ib8gadC7GfZn5aihEwOvWAuH+hnoqt6/VSoDtnj8Dd1Upab2Hs/TVBwi4G+h51X3knDmBiu1rmffPGzjvlbnYYpNYN+1FavO3M/rxaQDMuGkEHcZeQ8fzr2PJK3+jbONSxvz7OxzJmWz64jVKNy7l7GdmADDvnzfQeugFdLnkL9QV7GLWg5dx5lNfEJOVy7LX/k7xmp8Z/+EGFEXP/GduplXv4fS44i5cFUXMe/J6Rj36AfE5PdgzfwbbZ33EuNfmAzD/uVtxV5Yw6K6XiEhI5atbz2TYA2+T3GUA22dNY+NnL3PRlOXhPjz9ZxzJmfT/8xN466r58v+GkNJ9EGm9R6CqIVZOeYJLP1gPwJKX7sVodXD6X18g4HHx+XUD6X/TP8nofwZ75s9k2et/p9+Nj1NXsJPqPeGB0sF3v4waCvLlDYPod+MTWlkvIYQQQgjxxyIlZcQpQy6ZFUKcLArWFLNkyirOenAYEXE2Vn+6ger8Wm0gYMb9P9B2cDYdz2hHyeZyvvr7bC564RyiW0Wy4qN1FK8vZezj4drvi95aQXLHRNK6pVC0oYRN329n0A19cSTaWf3pBvJWFnLek+Hg5cz7Z5HWI4UeF3WmpqCWr/7+I2c+MJToVpHM+NsP1Jc3cNU7FwPwyS1fkdI5idOv70N9eQPf/uMnht16Gglt41gydRW7F+Vx2WvnAzD1yk+ITo/ivCdGU1/mZM1nG+lxUWfsCRHkrSykfEclvcZ3RVVV3pn4KZ3HtKfX+K5U5dXw80tLqCtxMnHqRaybvglXtYf+k3oC8OltX9Pl3FzaD29Dwdpivn9iHuNfGos9PoIdP++hprCW6vw6+l/dE3u87aiz7/NXFxGV4kBv1GOLtaIoCtt+2oXf46fT2eEBjXUzNpPRM5XotKgm6zZeSdA4cfDJxu8JsPXHnaT3TCUqxUH59koqdlfRfkSbI7rCRPyxNE5C7Xc34K6pwBodj9Eagd/TgKuiGEdyJjqDkfriPfjdDdr8BflLfyCyVWui0tpSvmUVlTvX02bERRgtEdSX5OF31Wtta/K2YXZEY41JJOB14yzNx5Gcid5kpnTjMso2LaPzRTehKAo1edsw2aOwxSYRCvjx1FZijopFbzDhc9Xjd9UTER+++qNi+1p2z/uC9mdfhS0+hcrt64jJbI/JHoWzNJ+64j2kdh8EQPmWlejNVmKzOxIM+MLZ/ct/Ir5dV1J7DqGhrFAbQKvatRFFpyMmqwNBn5cdP35MSrfTiUzNprZgByXrFxMKBqnctpq2oy4FVSW562moqkrRqrlEZ+YSEZ/S/C/mr8j3YyGEEEKI408C7uKUIT8ohBDi2KkhlWAghGHfBLAVu6owWgxEpUbSUOlizecb6XpuBxxJdir3VNNQ5SajZzjgFQyEQFV/M/ishlQK1hbjSLQT3SqSwnUlzPvPYk67tjdZ/dJZP3ML7hoPfa/sDsCy99aQ3iOVlE6J1Jc52b04n/Yj22COMLF06mqq9lYTDIQYdGNfZtw3i0E39iWrXzoFa4pZ9u5qxj42CqPVyPL31+J1ejn9hvBVDx/dOJ2el3RhwavLyB6QwbY5u7jq3YuxRJpZPHklPqePIX8ZgLfBxwfXfcGQm/rTemAmeSsL2fz9DkbedTo/PruQqr01dL+wE7kj2+B1evnhqfn0urQLqZ2SKNpYyva5uxn8534oisLOBXvRGXRk909n1+I8lkxeyZkPDiM2PZrKPdXkrSik+wWdUHQKW2bvQA2p2pUZy99fS1b/NBLaxFG1t4blH6yl7xXdiEmPpmBNMQFvgKx+6do5y+jdiuTcBGqL69m5YC+dz2mPyWZk07fbKNteQdfzOxKZ7OCdKz9hyF8G0Ob0TNZ+uYnN329n/MvnoigKW2bvJCk3npj9Bhp8Lh+hoNrkqgc1pFKVV4Mt2oo12kJ1Xg27l+TTZWwuRquR6vxaVFUlNiMaCJdeUnRHNg9ATUEtZocZa5RFuzrkWAYD/J4APpePiNhwxnfp1nLsCRHa/WPlc/kI+IK/+xwN+1NVFW+9D6PVgN6op3BdCbXF9XQ8I/xeCQVDR3yOgoEQOn3zz8kgmpd8PxZCCCGEOP4kRUmIZtLwzrs433yrpbshhBDHRNEpWrAdIL51LFGp4eBMRJyNgdf1wZFkB8IlexqD7QB6g+6IMr0VnUJ6j1SiW4W326prMpe/MU4LFncZm6sF2wH6XtGdlE7hkiuORDtdz+ug1cTvd1UPzvr7cMb8YyQRsTY6j2mPdV/g0xxhIr5NrFanPyLWqvUdoM2gLKJSIxn/yrn0HN+ZMx8YisEc7v+Aq3sx5C8DtO1Meu8SsvqH+4cKun3H2mVsLpEpdurLwqWAdHod1kgzJmt4wkpvnZfqvFotmLlzwR7ylhcAYDDpaahwUZMfrkldnV/LuumbtVJFlbuqqdhVDYQDqNvm7KKuOLyfoo2l7FmST315uPb11h93svGbbdqx7V6cR11JPQD1pU7Wz9xM0BfOxvfUe9m9pICtP+7EYNJz1fuX0Ob0TAC6nd+Ri18cg6IoBP1Blr6ziqL1pdo23x7/EUumrmbm/bOY++JivntsjrbPz27/ht2L8wBwVrhY/9UWrXTLymnrWPj6cgrWFPPupE9565IPtf4WrClm6hWf4KoO17r++eWlzLj/B227n9/5Hdvm7CIUDDHjvh9444IPqNtXemnTt9tY/sFare3cFxdrcy1U7qlm5v2zcNd4APj64R/58p7vtbbfPDKH7XN2A+Hg+0c3Ttdexw1fbWHh68u1tl/e/R3zX1kKQMnmciZfNo3a4vD5Xf7+Wr56YLbW9tPbvmbN5xu11/SLe75n54K9+N1+Nny9le+fmKe1/eGf81g/cwsAdaVOpt/7PVV7awDYNncXs56ej9fpJeANsOjNFWz9cae23alXfkL5jkrtWNdP/2Xeh8/++g3L3l0DhMtCff/EXK1c1cpp6/jk1q9+6e8tX7FkyiogPHn1u1d/Rvn28HY3fb+drx785djmvbRE66+7zsOcFxZRlVez77yUsfz9NVrbpVNXs+HrrQB4nT6+fuhHSreG66gXbShlwX7nd8vsHexcsBcIXzWy6uP11BSGPxfFm8qY++Ji7b20ePJKlk5dHW4bCPH5Hd+wd0X4M1Wwppgv7vwWvydcR33Vx+tZ+s5qbT/fPzGPvJWFAJRtq+Dbx+bgdYbL86ybsZnFk1dqbWc99TO79r2fK/dU8/0Tc7X36JbZO1gydZXWdvHklexZFu5DfamTBa8vp6Ey/NncszSfVR+vRwghhBBC/PFIDXchmkmgoADV42npbgghxCnHYDbQ46LO2v2EdnEktIvT7nc8K6dJ+z6Xd2tyPyrl0Fmfik5B2VfsOqN3KzJ6h2uwp3RKJKXTcK2d0Wpk5F2DtPvZAzK0SXwBRt87RFvO6NWK6z6foN1vOyiLtoOytPsDr/+lNrtOr2PCm7/Uge50Zg45Q1tjtIa/4g3/68AmGcrjXzpXW07rnqKVCALoeUkXOp6Vg96wrxa5oWleRuOgid6o54q3L0Tdl1UekxFN78u7kdI5kTYDMwn6ggS8Ae38jPvXmdqARnrP1Cb7PO3a3gS9QULBEB3PysEaZf1lECXJTtfzO2DcN0jR+rQMbfJigHMeGYE9IZyFbrAa6HJuLraY8KBKwBfEU+fV2vpcPoL+kNYna8wvWfEWh7nJHAEXPHuWNjBijjCR2TcNsz2cta8z6NCbfxk8UnQK2+ftZtCN/XAkRtBzfBdt0KfjmTm0Hpiptc0d1ZbYrOh951CHOcLI7H/N54JnziIi1kpMxi9XC8RmRhMRb9Neh8gUB/p9A14GkwGz3cS0P8+k85j24az2feclMsnOqLsHEbVv0KrruR20ORoAuo3riCPRzoLXl1NbWIdOr2gDOaldkptk9fe5sjv2fX0wRRjpeEY7rDEW8lYVsW76ZrL6pmltLZFmTLbwOQv5Q9SV1msDOVV5teSvKqLPhO74XH52L80no1d4QE5VVUw2IzpD+D3qqnZrQX2AwrUlWBxm2pyeSdAfZM3nG/G5A/S/qge+Bh81hXWEgip6g4I9PqKxFD6KAnGtY7XXzRRhxBJjYcf83XQY1Q6D+TA/gRTQ6X75zOh0CqFAiF0L95LWIxWdUffL8yqEgr9cLBzwBPA1+LX7Nfm1xKRHUba9Ar87QPHGUu31qC2up3RL+aH7IYQQQgghTlpSUkacMk6US2Yb66AKIYQQ4uT261JLRyPgC1JXUk9kkv3wAeBDyFtRiCPZ3qSsz5HaszQfb4OP9sPbHPW6pVvL2fLDDk6/sd8BgzK/xdvgY9Y/f6b35V1J7pD42yv8yv4TMB+t5R+sZfeiPC7579jfbvwrRetLmPnAbC595Vztyp6j8caFHzDgT720yaxPJCfK92MhhBBCiD8SCbiLU0ZL/6AI5OVRceHFxLzyMubevZp9/0IIIYQQ4uiFgiH8bj9Gq/GY5gmo2luDNcaCNdLyO/Tuf9PS34+FEEIIIf6IpKSMEM1En5yM9fzz0MfGtnRXhBBCCCHEEdLpdVp5mmMRmxl9/DojhBBCCCFOeDJpqhDNZNPXU9ge70UNBVu6K0IIIYQQQgghhBBCiN+BBNyFaCYmeySsWkfV9Te0dFeEEEIIIYQQQgghhBC/AykpI0QzaTfqUjzp3Qh5PS3dFSGEEEIIIYQQQgghxO9AMtyFaCahYICvnrqK7Z+9jn/HzpbujhBCCCGEEEIIIYQQ4jiTgLsQzUSnN9Dv+kexfzkP/9q1Ld0dIYQQQgghhBBCCCHEcSYBdyGaScjpJMYQRehfD2A+d0xLd0cIIYQQQgghhBBCCHGcSQ13IZpJ7SP/oGLZPFamODF+/A1Zb73X0l0SQgghhBBCCCGEEEIcR5LhLkQzsV0wDuuOIkb1u4ZIewJqKNTSXRJCCCGEEEIIIYQQQhxHEnAXopmY+vXDkJ5OybYVbO8QAT5fS3dJCCGEEEIIIYQQQghxHEnAXYhmouh02C66EN+qVTR8+SX1kye3dJeEEEIIIYQQQgghhBDHkQTchWhGtosuJLGgge7dxmAc0K+luyOEEEIIIYQQQgghhDiOJOAuRDMyZGVh6tuHRbu/Z/3MN1u6O0IIIYQQQgghhBBCiONIAu5CNDPbxReTvqUax3tfE6qtbenuCCGEEEIIIYQQQgghjhMJuAvRzKxjziGmwYBu3Dn4lVBLd0cIIYQQQgghhBBCCHGcSMBdiGYUCobQRUYS9cbLrNo9h/z3X2vpLgkhhBBCCCGEEEIIIY4TCbgL0Ux+fHYBs/+1AICo4aMZbOtNosfSwr0SQgghhBBCCCGEEEIcLxJwF6KZtBmURc7w1tp9b1I0a7b8gKqqLdgrIYQQQgghhBBCCCHE8SIBdyGaSVr3FCwOE35PAIBgwE9D4R68RQUt3DMhhBBCCCGEEEIIIcTxIAF3IZpJ+dbdfHP/05TvrAQg+/YHGdDzEvSKfAyFEEIIIYQQQgghhPgjkEifEM2krmAJVuPXKMHdABhatWKjuYQFT9zYwj0TQgghhBBCCCGEEEIcDxJwF6KZ5JxxOY5WnVn0n/sIeFwARM1dQ+y8dQTLy1u4d0IIIYQQQgghhBBCiP+VBNyFaCaKToet1RX46itZ+9ELALS+70lMIR1VH77bsp0TQgghhBBCCCGEEEL8zyTgLkQzGvbXc+lx5R1s+/ZdyjYtx9i1M+s7Wdj9/bSW7poQQgghhBBCCCGEEOJ/JAF3IZqRs6yBLT8nEp3VlaWvPkCwtoYeqxtIXVOEd+nSlu6eEEIIIYQQQgghhBDifyABdyGakSXSjD3BTqeL/oa7qpSN8z8l/quZ7OydRNXT/0RV1ZbuohBCCCGEEEIIIYQQ4hgZWroDQpxKjFYjI+44HV+Dn66X3sbq954mtjpArU3FuXwl3p9/xjJkSEt3UwghhBBCCCGEEEIIcQwk4C5EM5v74mLqSpyMffxKotLb4Vi+hdOzzqC+YQ17nnmE9oN/RFGUlu6mEEIIIYQQQgghhBDiKElJGXHS2b59O6eddho5OTn06dOHjRs3tnSXjkqHM9rRa3wXdDo9Kd0GEnHNn+BPl5LfOY4dpgqCZWUt3UUhhBBCCCGEEEIIIcQxkIC7OOnccMMNXH/99Wzbto177rmHSZMmtXSXjkpcdgwBXxB3rQeAwhU/8v3940kp9jNq6nw8ip9QMNDCvRRCCCGEEEIIIYQQQhwtCbiLk0pZWRkrVqzgiiuuAODCCy8kPz+fHTt2tHDPjpzf7ef7x+dSvCmcyZ7aaxinnX87GX97FAX47q7z2fTKYy3bSSGEEEIIIYQQQgghxFGTgLs4qeTn55OSkoLBEJ5+QFEUMjIyyMvLO6Ct1+ulrq6uye1EYIu2MuHNcWT3TwdAp9OTefn1hGpqyLvnVjqGWhG/ZLtkuQshhBBCCCGEEEIIcZKRgLv4w3ryySeJiorSbunp6S3dJU3ptgrWfNa09nx1/naWVyxFf/Zogrddwzd3nou3vrqFeiiEEEIIIYQQQgghhDhaEnAXJ5X09HSKi4sJBMLZ36qqkpeXR0ZGxgFt77vvPmpra7Vbfn5+c3f3kOqK66nYVdXkseQLLqfNyEtY+9Xr6PRGkjI6oQu1UAeFEEIIIYQQQgghhBBHzdDSHRDiaCQmJtKzZ0/ee+89Jk2axGeffUZaWhpt27Y9oK3ZbMZsNrdAL39bj4s6H/TxbqMnUTzjI1b+9290+6mQbTVezINPp+2IS5q5h0IIIYQQQgghhBBCiKMlGe7ipPPaa6/x2muvkZOTwz//+U8mT57c0l06au5aDx/fPJOCNcVNHjdnZjPg/x6nwVtH/vD2VCz6kdrdW1qol0IIIYQQQgghhBBCiKMhGe7ipNO+fXsWL17c0t34n1gcZlp1T8EaZTngucRzLiJ31nQ2Fa+gY7mf7IZods/7kvQBZ2IwHdheCCGEEEIIIYQQQghxYpCAuxAtQNEp9JvYA3e1+6DPZ7cfSEWgiu26Aszvv8m65Tr0ZisZ/c9o5p4KIYQQQgghhBBCCCGOlJSUEaKZbP5hO4vfXqndXzplFd888tNB20be+H8M+Nsr6AxGCuwuhg+/kfS+o3CWnjgTvwohhBBCCCGEEEIIIZqSgLsQzcTr9LHp2234XH4AOp6dw9BbTztke3XuQjquraNDUk+C733Mxi9e44cHL8PvaWiuLgshhBBCCCGEEEIIIY6CBNyFaCZtBmYS8AXZu7wAAEdCBDWFtdSV1B+0ve2Si2n33TzibroV985tJBkTGHDTUxhMVtRQqDm7LoQQQgghhBBCCCGEOAIScBeimTiS7CS2j2fngr1AuI77zy8tpWRT+UHbKwYDqt9H9d13saZ3FNu+nkpS537MffJ6tnw9tTm7LoQQQgghhBBCCCGEOAIyaaoQzajN6Zksnboar9OH2W5i0geXYDQf+mOoT0vDOnwEvXq2I27Ymej0BhI79iUms30z9loIIYQQQgghhBBCCHEkJMNdiGbUZmAmoWCIPUvDk5/mLS9kwWvLDtle0euJevQfJMRmYKppwLVtE7nnXEVkWhuWvno/AY+rubouhBBCCCGEEEIIIYT4DRJwF6IZRcTZSOmYqJWVCfgCeJ2+w6/k91N9x11UPvww395zAes/eJ6Ax0X51tU4ywqaoddCCCGEEEIIIYQQQogjIQF3IZpZm9MzKVxbjLvOQ/vhbRhxx+moIfWQ7RWTicSvZxL33PNk9z2DLT+8Tyjg55xnv8Joc1BXtLsZey+EEEIIIYQQQgghhDgUCbgL0cxan5ZJZIqD+lInAW+Adyd9yvafDx801ycnU//UU2TW27AnpbP8jYdQVZWFz9/G2g+ebaaeCyGEEEIIIYQQQgghDkcmTRWimVmjLYx/6VztfpdzOxCXFfOb65m6dwe9nvYzt7KiaA07f/yY/n9+EktMAqGAH53B+Dv2WgghhBBCCCGEEEII8Vskw12IFlJbXI/X6SV3VFtCgdBvto+4/DIsgwYRWekl1RPB2g+ew2C1U71rEzNvPQN3dVkz9FoIIYQQQgghhBBCCHEoEnAXogV4G3x8fPNMts/bw8avt/L1wz+iqoeu497IOXUqoaIiMleXolN0rJr6JNFZ7UnvOwq90dwMPRdCCCGEEEIIIYQQQhyKoh5JlE+IP4C6ujqioqKora0lMjKypbtD8cYy4tvG4nP68HsCRKU6UBTlsOuE6upQgfJxF1CRYmW9fwdD7n2NlO6D2DXnMyLiU0nuelrzHIAQQgghhDipnWjfj4UQQggh/ggkw12IFpLSKRGj2UBEnI36Mic/PrMANXT48S9dZCT+1atRq6qJnrOGtE6nEfC6Adi78GtKNy5tjq4LIYQQQgghhBBCCCEOQiZNFaKFqKrKnBcWkdQ+nui0KALeAH6PH5PNdNj1DG3bYhk1Es/8BeSuqyf+wdEoisKQe19DZzBSvWczMVkdmukohBBCCCGEEEIIIYQQjSTDXYgWoigKfrefbT/tolXXZM58YBglWyrwNvgOu56hVSuin3gc27lj8C1eTN0n01j66v04S/PYPe9Lvv/bJTRUFDfTUQghhBBCCCGEEEIIIRpJwF2IFtTm9CzKtldSV+rEXedh1lM/s33u7t9cL7A3D+err2Ps1ZP6p5+hNm87zrICMgeew9C/vYEtNolg4PCBeyGEEEIIIYQQQgghxPElJWWEaEGZfVphMOnZOX8PPS7qzIXPnU1UqoOAL4jBpD/kesY2rUla8DOqohDcs5dRA0/TJlxN6tSPBc/diiUqlj7XPtxMRyKEEEIIIYQQQgghhJAMdyFakNFqJKNPGjsX7AUgulUky95dwzeP/IiqHn4CVUN6OvVP/hPXu++BquLK38vKyY/jc9aQ1mcErXqPaI5DEEIIIYQQQgghhBBC7CMZ7kK0sLaDs/jhyXlsmbWD3FFtSeueQnRa5BGtaz3vPBSTkepbbsVVWshuewFBn4e+NzyK11nDvKf+jy4X/4XY1p1+56MQQgghhBBCCCGEEEJIhrsQLSyrbxodz8ph3ktL2DJ7B626JpPRuxWL316Jz+U/7LrW0aMwtG6N6nYTf9sddLvsdnb+9CnlW1ZhMFlBVQl43c10JEIIIYQQQgghhBBCnNok4C5EC1N0Cqdf34eOZ+aw6I0VuGs9BDwBdi7YS9Xemt9cX3U24N+8GX1SMq2HX0Rs684sevFOGsoLGXLva9iTMljzwbOEQsHf/2CEEEIIIYQQQgghhDiFKepvFYoW4g+irq6OqKgoamtriYw8spItzUkNqdQW1RGdFoWqqoQCIQLeIH63H3tCxOHXDQYJlpRQffMtBDvnsNK1Hm9tFUPuex1/Qx1LX3uAkQ+/S0RCq2Y6GiGEEEIIcaI70b8fCyGEEEKcjCTDXYgThKJTiE6LIhQM8dNzC9k+bzffPjqHhW8sP6L1Ky6+BNXnIzj1Q4Zc8RD2pHR++sdVoNMx5vlvASjduOz3PAQhhBBCCCGEEEIIIU5pEnAX4gSjKAoWhxmTzcSw206jzxXdqdhVxaI3VxDwBg6+jl5P7Ev/JW7qZHTp6TTcdT+Dr32S+JwezHvyeqr3bGb9J/9l1Tv/RA2FmvmIhBBCCCGEEEIIIYQ4NRhaugNCiKYUncLA6/sAoKoqu5fk43P6KN1agaJTaKh0ERFnO2A9U48euL/5Fn1EBMGqKqovvJgBr7/K7q6nEdO6Iz0n/Q01GKBq10Zq87fTetgFzX1oQgghhBBCCCGEEEL8oUmGuxAnsII1xfz4zAIWvbWSpNx4ijeV8eENX5K3ovCg7fUZGRh79CD+s08wpKVTecllZAZi0BtM1BXsZNeczylY8RM7Zk8jFAwgUzgIIYQQQgghhBBCCHH8yKSp4pRxsk4K1VDpYsM3W9n83Xa8DT4S2sRy2rW9qdpbg8lmou3grAPWcb71NqrbjX/7Dtyffor9LzdT2CGOolVzGfHQOwR9Hqr3bGH1e08z+K6XsETFNf+BCSGEEEKIFnWyfj8WQgghhDiRSUkZIU5wEXE2+l3Zg54Xd2HrjztZP2Mz0+/9AbPDTGrnJNJ7pbJq2nq6ntdBKzUTqqhA9fuJfv5ZDO1zCGzeTId77ibnjMtRdDqq92ymeP0i7EkZmCIiaagoIiI+tYWPVAghhBBCCCGEEEKIk5uUlBHiJGG0GOh8TnvGv3wuo+8dTEx6FLuX5FGyqYwdP+8m4AuQt7KQXYvyiLznbiLv/xvOf7+If/Uaol94HkVRCCxfhX/zZorXLmDjpy/jqa2gaM18vrrlTEo3LG3pQxRCCCGEEEIIIYQQ4qQmGe5CnGR0eh3ZAzLIHpBBfakTR5KdS189j09v/Rp7YgQGk4HWp2Wwatp6UlPaY7daUBSFYFUVdU8+ibF9e7o+/xzx7Xuy/I2HWPjvO0gfcAZxuT1Y88GzWKMTaH/2xJY+TCGEEEIIIYQQQgghTjoScBfiJOZIsocXFIX2I9qQ3T8dR7KDdTM2s+aLTQTOaU9Kn66s/svrtNn4OSkzP4N90zZE7yxncIdx7DRXsn32NGoLdmKJjMXUKRKfq56tX79D+7OvxBQh9TyFEEIIIYQQQgghhDgSEnAX4g/AaDbQ85Iu2v2gL4jFYWLNZxtZ89lGdHoHnu6TWPvsUpKsTnrefR7+nbtw/ec/pGVkkHzDLewsWkvxmvlUbF1NwOti+w8f0mbExdSX5GGNScAWm9SCRyiEEEIIIYQQQgghxIlPUdV96a5C/MHV1dURFRVFbW0tkZGnRtZ2Q6WLks3lFG8spXRrBRU7q0ANkZwTg7Pax+CLMjC+8x9883/G2rsnugvGUGRykjXkXKxxyeQt+pZ10/5NYse+DLjpn+Qt+Y7UnkMwWiJa+tCEEEIIIcT/6FT8fiyEEEII8XuTgLs4ZcgPCvDUe9kxfRUFezzoF8yi21lZLC3LpmJ7GWeHZlK+Lh+rKUDsOcOJuPIKNqz6Cm9dJV0vvR1XZTGz/z6B4Q+9g9Eagbe+muQup6EoSksflhBCCCGEOAby/VgIIYQQ4viTkjJCnEIsDjOdrxhAp0AA1wcF6Lr0wPXfjWTGNZD473f44dovUd1uElduxl28lJxLzyetqwlzQEdVTQUAi/9zF9aYBPwuJ+c8/w1bvp5CfE4P4tt1a+GjE0IIIYQQQgghhBCiZUmGuzhlSAbPwTW88y4Nn31BwhefsulfH7GnJgpnXYCagnqtjT7ko9fE3sS0clK65hvyln5HwNNAXE4PnCV7aT3sQtqMuJg17z5Nz0n3YYtLkcx3IYQQQogTnHw/FkIIIYQ4/iTgLk4Z8oPi0NRgENXtpqTfAKL+dh+WYcPwrF8PvU5jyzeb2fbTLpz1QULBEIl12xmQuI1taVkEHOVU7FhF0OfG7IjGFpfCiIffZdOXr1NbsJPBd/2XuqLd2BPT0BmMLX2YQgghhBBiP/L9WAghhBDi+JOSMkIIFL0exW4necUyFEWh4YMPqXvqaZJXraBzTpBuIwbhi4hh5XurSPOreBfsZvO2DrQvzKdDYmd2x6WRmF5NxyvuwWC2Ub51VTiIHwox68HLaTP8Qjqefz17Fswkc+A5mO3RLX3IQgghhBBCCCGEEEIcd5LhLk4ZksFzdIJFxehSkik97XQso0YS9bf7aHj3PawXXgCR0Xx137ek2WuwFm5jQ74DvbsWjykaU3wM3f8UQ/nmMnJ6D6Tet5MlL9+LPSkDZ1kBva/9O0Gvh5q9W+j/5ydxVZVhiY5Dp9O39CELIYQQQpxS5PuxEEIIIcTxJwF3ccqQHxTHJlRXh+r1EswvoPzCi0j84TuC+QUEdu3C9qer0el0FKwtZu1HqyjZWk0g+Mu6Dlcx8YNyqNi1nITIndTX7sHrqQHAHBlL9uDzyFv8LSndB9Pr6vvZ8tUUsgaNISI+tWUOVgghhBDiFCLfj4UQQgghjj8pKSOEOCzdvh9f+oQEUtavRWe34/7qa3zLlmG/9hoqr/4TMaNHc/ZjFxMoKqFBsVO2rZKKbaVUb7VSnhfEWZ1L+zo3weJY6mLSiAqsBncFO2Z+QEDx4l27iYr33mbTnNdxV5cRHZ/OtrmfMvKxD6gv3ovRYiOyVesWPhNCCCGEEEIIIYQQQhyeZLiLU4Zk8Bxfjf901D78COaBA9GnJFN+5tnET/8SxaDHv3ETtssvA1UlFFRRVXAXlLH589XU5FcTrHcREyihoNZHFa3okDeXiDvOYPv3r9GtPobqGAM1CQZq87ejCwSJ18dQbwyQmtWN9NPORElJJr5zH/QGUwufCSGEEEKIk5N8PxZCCCGEOP4k4C5OGfKD4vcVcjrxzp+PZfhw6l95FfcXX5I0bw4VE67AkJ1N9GOP4nzrbSzDh6HPyABFwe8JMOeFRRSsLibgC9eiUXQK0QkmvK4QirKd5DYuGnauB185brUWVflln1afjixdEvWtomg96Va8pcVYflpK4o23YmidjWf2j3gXLUL1+cI3rw98XhSbDX16OoaMDMwD+qNPSWmhsyaEEEII0XLk+7EQQgghxPEnAXdxypAfFM1LDQZR9HpcX36JzhGJqVdPSvr0I+aF51Ecdqr+dC1JP8/Dt3Ejvu07cA29gKp1u3F7dbgaQlTtrcZd6yW+dQy1RfXkjmrDwteXo9BA/7N17F25hNrqEJF6G9hqCOhLUINu4iv9tLvhXuZ/8ChRtngcBTWEDDpahaKxGW3oTVZUp5NgXj6hqipi33oD65ln4pwyBffnX5Iw40sAah/5B6rbjRIZic7hQHHYUaxWFIsVxWZDZ7ViOm0Aik5HoKAAxWRCn5iI6vMRLC9H0enAbEEXFYmilwlhhRBCCHHike/HQgghhBDHn9RwF0L8LhqDzLbzz9ceS9m6GYJBgsXFOO66E11SIoHPPsO/ZAkpf/4/9LdfhbFbN6Iff5Sys84h6v77MLTNxv3111hPG4jD0gNneQM55/XEbe1D9U878UVbqdxTDWoQhTqq9UaKZ5ShNyXgDBmojQsR8rkowInOaEJRdGSPOw+/uyNJOT0xDhhA3uLviGqVhHnYUK2vgYKCcFC+vg61rp6Q0wl+f5NjTC3IA6Dq//6MMbc9Mc/8i8CuXZSNGNX0XERFoYuJRhcdjS4mBnPfvjhu+Quq34/rs88wDxqMoVUqIZcL/H7UYBB8PtRAAHx+1IAf1edH0evQp6Sgi45GdbsJuT3oYqJRFAUhhBBCCCGEEEII0fIkw12cMiSD58Tn27ARxWJGn5xM3T+fwjb+EkIVFVTdcCNJSxbjfPVV3DO/InnxQiqvux5DWhpRD/2dgtvvx9d3BIHoRNZ/tg59dDTOCheeeh8XPH82i1//npKNG+lylkLBylX4XW7MDhtGR3eis7LIm/svcs/7K0mdOrHgmZtI6zsKNejH66yl/dkTcVWWYk9sRWKHPvgqyzHqjODxYMjMBMC/cROK1YqhdTYhpxPfihUQDKF6PIRqawlVVxOqqdH+GnNzibzzDoIlJZT06kPc1CmYRwyn6tmnqfvvS5j8h/5nOfqfTxJx5RU0fPQRNXfcRWreHhS9nspJV+PfsRN9XBy6+Dh0cXHoYmNRdDpCDQ2oDQ1EPfwQOrud2sceR/V4iH7sUVSPh/p/v4guKRF9QiK6xER0MTHo7BEodjuKzRbO1j/OGv/rOdkGC9RQCOB3OSdCCCFEc5Pvx0IIIYQQx59kuAshThimzp205ejHHtWWU7dtQVVV7FdPwnrO2QBYhg1DFxWF6vNh3rWJuLOGorPXE/HtPSTN/xn3t99S9/LLxKRfRlbZJmyOKPpefwfq1U+yNZhBfZlCsDBE4ZZ6DLozWDYNFGUlNnMiuxcsw2RtIOB2Urp+8S8dVHSghuh00U1k9j+Dn28ZTfaQcSR27EPZmnkkuHvhra/BkhxHQvuehAJ+UFU8dZX4aqtAVYlr24VQwM+qqU+S3v9MUnbvZMs3n7BuQjfUoB/6RRAZk0pKdjdS2vQgJrUNismMYjRAMIQ+PQ0A8+mnE/vm69qVBJYzz8CwfQehykqClZX4N2wgVFkFoVA4cB5hQ/V4wG5H36oVitEIQKi2FtennxEsLz8ggz98zAqm/v1I+PQT1FCIsqHDibznbqznnI1rxkzqnno63EyvRzGbwWxGsZhRLBYUsxnb+edjHTsG79Kl1D74EPHTPkQXE0PVNdfimf1jeGAgLm6/gYJ4dLExoKpEXHkF+vh4Gj76iGBBIZF33gFAzYN/RxcTgz45GX1SEvrkZHTJSShWq9Zn3b7lkNuNYjCgGI2oXi+hujoIBMJXEQQCYDShi7ChRERo56RRyOnUBhzqX34F9zffENi8BSxmzH37YurfH/OA/hg7dTrqskGh2lr8mzYR2LUbY5fOmLp2Par1hRBCCCGEEEIIcWKSgLsQ4qSgKAr6lBRtgtOIyy/TnkuY/gUQzppO2bIJxWbDes7ZGDt1RFEUss/qTva+tu1MeXS9qBuG9u0pvvgybM/+l+rVDvZOm0Pi/XdQ9LFKdb2Oi6fdzA9jH6TAmEzrgdHkLVhFdKqBmtLtLHnfw7afFxCs9rL+k9lknB6kZOXnrJ/24i/91elRQ8Emx2CJSaPVgJsp3zQHZ8lGtv9cgqs+joDPjkHXm24XDiImM4FV73/MtrXz2LrqW6yxSbTqNZTcMVfjSM7E66zBX1uJJS0NQ1oafk8DeoOJiEsvPeJzab96krasT0oieflSVFVFrakhWFZGqKYG1dlAyFmP6mxA15jxpihYRo1Enxp+DQzpaVjPPiv8XCCwb2Jab/jm8aB6vKiBcBBfFx2NqXcvbb8Rk67CPHgwoaoqQpWVhCoqCZaW4d+0mVBlJej1WM8+C318PKGaGoJl5eHX2OfDt2IFwZJSQuXlcJCLtPSZGSQvWghAab8B2K+/DsfNN+GZO5eqP1176BNjNmO/aiJRD/0d79KlVFxwEYk/z8PYpjUEAhjatMU6diyq04l38RLqnn4aPF4UhwNTnz7E/vdFdFFReH6aEz7enj0IuVz4160jVF2Nf+Mm/Js24d+4iWBBwS/n4k9XY+ralcDevTjfehvHX25Gn5BwxK+nEEIIIYQQQgghThxSUkacMuSSWXEoqsdDsLIKQ6tU/Js3E3I6MffpQ8P7H2DIzMTQpTNF9z6O/txxFG6pYe9PmzB16kjNzjLcXh0oChBCp1ST2dtCxZLlRCTaqW8oxO+PJbdfWwrWL6LG2R+9rh6zYT5qaCKO1MX4y3eR1en/KCx6nRh/JF2vvYdvn5tERquxxA5qy4bPXyMQMNKq7zh0rgIMVhOlO9fQ9exryBw+jmmTegEq1rgkrFHxRGfmYk/KICKxFTGZuVhjEzHZHC19in8Xqt9PqLyCYEkJwZISVJ8XAMUWgXV0uI6++5tvMbRpjbF9e4JlZfjWrEUxGMCgDw+KBPyoDS5CTieqy4WxXTvMpw8kVFuL+/sfsI4aiS4m5uD793rxrV2Lb/ESfBs2Evv6qyiKQtlZZ2Ps0pWYp/+Jf+MmykafAYAuPh5jp44YO3bU/hqyslD9fnR2O94lS6i+824Sv/0ancNB5TXX4lu+AsVkArMpfKWDybTflQQWov/5JIZWqbg+/YxQVRX2669D9fmouefefYMe+25eL4rBGJ7412pBn5pK1N8fBKD+lVcx9eiOuX9//Nu24fr0MwiFwoMZigK68Htc0elAp8PYvTvWUSMJVlXhnjET69gx6OPi8G/fTqhxYMTrRfV69huA8UIggGXUSAwZGQQKCgiVl2Pq0QOAYEVFeL6CYACCQdRgCEJBCP4yaGVo3x5FUQjk5YUnKU5ORvX5COQXoOiUJn0Nd2Jf2SKzGX1SEmooRLCwEH18/C9XQxzu/RUIgKqGr47weAg5nb+UaaqrQw0E9k2kbDkpSiOpqorqdIav8vD5mpxjNRjCkJmBzuEIXwljMIQ/J4fbVm0twfJyVK9PG9w8kamqilpfT6i6Gn1GBoqi4N+xA8Vg0D6Hgb17UYxG9MnJ4c/Z8dp3IACAYjAQrKoiWFSEqXNnAFzTZxDMywsPPlZXE6yqRnW70UVFoouKQhcdjeOvt6OLiMC7fDmKwYCpRw9C9fW4Pvsc1esFnw/L8OEYO3U8bn0Wpw75fiyEEEIIcfxJwF2cMuQHhfg9qCEVb4MPV3EVnjoP1qQYgju247VEUbipCrUwn5xLB1KzfhebvtvByOcvZ93TH5OfF2Tc5Il8Nv4lIlNi6fWnNnzx96X0HJ6F6lrJuoWRDP1rPzZN+Q8l1UNRjLvQK4X4gr2JsP0IDRHYk8bSUPsE9poIogf1pmD9PEx+A36LEi5PAxitdmIDFvqfdytfTX+cBCLpfctTLProSfzlpeiSEvFUlmIx2AhFWAjU1WKxR6NazCQ6WtFt0j0U715L/tyZdLn6bnSBEOVrF+MMucHrRW80YXBEolMVLLGJWGITMUfGYo1NQG8wHfl5VFV8zhp8zlocKVm/06vVPFS/P1zKx2xG9XoJFBSic9jRJyYe1XZc02cQ3Ls3fOXAvqsH8HrDy/sC6dFPPoE+KYm6p/9FsKSEmOeeRQ0GqRh3IYrFAhaLVt6HYADV7UbdN9lu7CsvA1A6chQRV0zAPmkSnp/nU3PffYCyX+A6BCFVC8LbLryAyHvuxrduHeVjziXx228wdupI9T334XrvvYMfzL5Bjrg33sAyfBh1z79AwzvvkrJ6JQAlffoRLCo67PlIzd+LotNRft44DK2ziXn+Ofzbt1M2dPhh1zMPGkT8Rx8QamigOCeXmJf+g+3883FOfYf6fz0TLicUYYNAENXlIuR2obrc4PMR9cjD2K+9Btf0GVT/+SZStm5GZ7dTcdnleH+eH96ByYQuMhwcVSIj0UVHoYuwE/XIQ+iTk3G+PZlQRQWRd9+FGghQdeOftfOrKAoohM+1Xo9isaBPTtbKJzV88CHGTh0xdeuGf8dO3DNmoLpcqA0NhBpcqG5X+HXZxzJsGBFXTCCwZw819z9A9JNPYMjIoObBv9Mw9Z0mAxi/FvfuO7+8Nu++S8qq8GtTdcttsG9gKlhRTqisfN8AiQ8AxWolZftWFEWh6qabMfXti/2qiQSrqvB8/0N44KNxAEdVw/MghEKoPi/Gtu2wjBxBsLSU+n+/iP2G6zFkZuKaMRPv/Pmg6MKDKfvmTFCDIQgGIBAgYuJETD174P5hFu7p04l96b8AVN99b/hzs69s1P7zZ7Av8J2yfSs6m42K8Zehi40h9pWXCeTnU9r/tPDJ0OnQp6VhaJ2NoXVrDNnZvyxnZBCsrKT+mWeJuOZPGNu2pfbJf9Lw5lvhdfcfeFCUcD+8XmJe/De2Cy/AOWUKtY88SqvdOwEoGzOW4N688NwZMTHoYmNQrFZCdXWEamoJ1dSQOOt7dFYr5RePRx8bS+xrrxAoLKJ04OnaIFzUIw9ju2DcYT8LQhyMfD8WQgghhDj+pKSMEEL8DxSdgsVhxuJI+eXB9D4AtBoA0B+AmJxUsi88HYA+/7iCPvuanv/u/xEMhDDZjJz1aCaRKQ50upHoc3aT3LsNOus/sS7YS++JV7LwxZ9xOwO06jmU9dM3EfKbUc0PUWTx0nlgL/zePmxfp+fc+/ux8fXJFJdEEvAWkeeNpHi6F4O+FSX1KSz4bBeuKi/BhgiiLVEEvXsJOh0EjQoBZx02JZKSmgJ8G3aSGD+ABXMfw+QNkdxlAEs/eorEaqhMshD0edChI6SoB5R26XPm/1G4ZTG61Rtx9WpPlFtHmzo7q1PdeHfvICIyAW+kFe+enYRsFryeegiFMFgiGHL+HRjXbmV5YCuJpjjatR2I4dyzqX3tVSL7D4LWmVS98xZqn+64K0twrllBsE0G8fYUEqPSCPXsTN5nU8nqfyaWbj2o+PYLlJQUzLEJ6KtqsXToFA5cN7jQp6bgr65Cpzegj4ykeOVc/F43GaeFS+VU7txAVKvWGCy2I39P7FcLXjGbwyVp9qOqajiruKEB34qVmHr2QImKOmAiVtt55x7xPiPvvuuXfer1JMz48ojXTZo9S1u2DB5E8sIFR7SeqWtXWuXt0SbAjbrvHhz/d304kGw2g9kSrudvMh2QLW2/ehK2887T7sc8/xyq3xcOOusNoNeB3hA+J40BzH1/o//5BIrZAoA+LY34zz7ZF9TdL6C7r62iKCjRUeFli4W4D97DmJsb7n/3bthvuF6bVFgxGMI1+7WbVcvAN/ftQ+zkt8KDGIDjr38l4qqJqC53eGLk2lrUurrwcl0dobracHAYtBJLjVS3+5fgs6qCSng5GAxfbVNaprWtf/4FIq6ehKlbN4KFBTS8/z46W4Q2SKBYreG5JRq33RhQD6nh5/YF4y2jR2Ns1w4lKgpdVCSKyRw+xzp9eP4Bgx5DVhYA1jPPwJiTo21T0SkEysrRRURg7NgR/eB4dImJ6OPj0SUmoHNEatnt+pQU7YoQ/6rV1Nz5y/uyyRUIOh2KxYLtwguwjByxr1TUyv9v777jo6oS/o9/ppdk0nuBkECAEHrvXUFFQAQLKLoqdnef1VWxuyqWdS27trWhLq5dEZEioNI7QugQ0hsJkF4mmfL7IxIffvq4PvuMsivf9+s1r9fl3ju5Z2YOZ+79zrnn4Lu0trX4FRW07D/w7Y89vrbPFrOptcxmM776+m9fqxd/83fzTxiDnPjDw8BkApMZS4/u34XZ3z5O1sewJx5r3Q8wRUcTtfBj/I1NeIuK8OTk4MnJwb1uPfUL3m7tRT5+HJFvzMdgMuHeug3H1Cmt79m552CKjT21HTy5bDRiCArC2rdP677nnYe1X3/8fj8Gg4Hozxb95LsDIt94va1umxMTSMzL+UnPExERERGRX5Z6uMsZQz145NfE0+xtDWyA8kPHiEgJp7a8juw1eQy8vDc56wvI21JIRPtwstfmYraacYbbKdxRijPCgbfZS2NVE+fPG0/p3nJ2fLCHxJ5xABhNRvI2HaE1CbRiNBzF7w/BZDVh8OXT4kkhJLaZjhkNhMb2Z+OiFURF+ulx7igObfmY6iMeYnqPpTr3fSIIw5sSStWBHQzvdSEbclfQUFJAeHQ7TlQVY3X7SOw9kkPblxLvi8Ux8lxy1r5ON08/KnqaObF/O+PancsmDlKVtx+j0YTv/xsb3+TxY42KxVDXwICKCIqmDyZ7xXuMSTmHsp4J5P/jb9QH/7dJTQ0GTAYTlkYPvqgwmmurGGrtifPeO9jxu5kYkhLpPvP3VM+5nh29WocesbshcvBorMXHsB2vwXzB+dR++AGupFQy/vhXSkeN4sDgeLqMuRjry/+g4caZHFq2AF9lFaaU9vjLjmIyW7F37krz4qU4+vQlecQkmHMrQe8v4OjqJQR9tILErds4Mf9VDEDYFb+h6fOlWDqnY2rXjuaNm7D27oXfD96iQiyZmfgqK6G5GVN8PL7a2taw/9uhMP7dh/iQXzf/tz8qtPXk/w/m93rxFheDx4s5tcM/f4L8bBqrmsjZkE9Lkwdvixdvsw9vixdPs5dBV/bBYlNfov8tnR+LiIiIBJ4Cdzlj6IJC5Ds+rw93fTO2ICsNJxqpO9ZAXNdoCrYVgwFiO0exZcEuwpNDMVlN7FtyiKTecTRVuynYUcLQOf0p3llKZWE1/Wf24uu/bCBlUDIxnaNY+fhaTBYj3hbf945rD7ERmhhCQrdY4rvFsPzRrxl1y2DCE40sm7eJuoo6TIYKvP44jMZanKENuBJ644rKo6W2iOhOiTRV5lFfHUVYchdo+Yboruez4vHFWMzf0OyfgsOxE7OpCmfCBXiqP8BqCyO2+yCKtzxPUqcBNPgslH6zmHZdh1DvqacyZx/DL36c3Vvehspauk2ay7q35pCSNJCoYcPY/NZDxEWmUWf1UleaBxgwms34vV6S0vpS01RJWLOV5vAgynOy6B6SiX/UEPYuepkIXxC+tPbU5R4iNCiKOosHb20NVlcY1vAouoyYTpO3kW3zH2LEkCuxnzuRtfdfSaOnHgxGzC0+QiLiMYSHY9qyi/iLrqS+JI/wt5eTtG0b++++CXtBOe3fepeSWZdQnxaHedRw6h77E2EzL2+9e+CNvxN+3/00bN+Cd8s2Mhetpuruezh4Yi8dbp6L8dHn8I4dynFLE97PlhI2czZWnxHvomWEPvowtYs+obG4gKhrb4RPltIU4aSMKuJzagidPI3ahhM0fLmKsBmXYDpejffwYWyTz6f+q1V4fV7Mvbpj2robW7duNNkM1K9fS/SEqdDs5sTmNVh698JTXIy76ji+yFCaCnJp8TTTghdvVSW9Z98BZjMnDu7CmZSCPTgMoK2Xst/vp6Whlua6aty1VbQ01BIcm0xQTNJ/fNArIt+pKq5hyQOrqD/egNluwWw1YrKYMFlNmK0mzv3jOOwuG18+vZ6UgcmkDml3uov8H0HnxyIiIiKBp8Bdzhi6oBD5+TTWNGE0GjDbLVRkHyc0Ppja8npyNxYS0T6ME/lV1JTWEpkaQUNlI5EpYcRnxLDska/pd0kPIlPCWfrwVwy+qh/VxTVsf283Q67qy65P9tFY1YTBZMBd20zmeV3oMyOTty7/kPYDk+gyNo3l81Yz8saBFHxTSvmhY3QZ35Hs1bkABEU4KT98jJjOUYy4YRBrXthESdZR+l3Sg5qyOlyxQWx/dydgAty09uq3YzCcAL8dPxZ6To4kOr0L4ObQyo30vngKVmsFexbvwmjvSHPVTjCGYAtvT2PZ14SnDsRiN3Pi8BcMnHMbFQc2U7hlHRlTbqVo09/x+UzU1Q2gbMvjGIMG4IxOoz73ZdIm3o6RY2R/8Tz9fnMPh5YuoL6imKhOvSjatqp1wtBmN/h99Jp4DSE9+rLm8euITOpM3MAxHFn2Lu7GGvy+/3mcbrstmB6zb2frK/cTEhKLPTkFb04uqUMnsXXl6/j93/+R5KSEPqPwZ+2lQ9dhbD60jKRSL71ve4IvPnyYhppjP1o/2h810P2iW9hSuJqa3ds5e+58ctcsZPe2z/Cbvh+KmwxmLK4QLEXljLn2T9QbWlg9/x46njuL5Cob5R+/Tc6gJBpLCvDg4YdOZNL6nk33zLM59sQ8/I/MJXjTPigoJuLZpzlxw41YevQgaPblHJs+g5Db/4AxLIzqPz5ExAvP4964EfdXXxP+zNPUPv8CBquV4Guu5tjcO2FQX7yxkVS983ds48dhbGrGs3U7IVddjW/HLoJaTARdNouaN97A2qEDtsGDqXv1NexnjcfgcNC0bDnOGdPx5ObiyT6C84KpNK1Zi8FixjZ4cOtEv+npmOJica9bh3XAQPyNjXgOHsQ2ehSeI0fw19dj7dmT5j17MIaEYEpMpGXvXszJyWCx4C0qwpya2jrWe0MD5sTE1rshjEaMoaH4qqpah8exWFqH03E6W4e1aWlpHYrmv/VM9/m8NFSUYA+Lwmz755PNypmnpame2pI8IlK74W12Y7L+tAlnPc1evC1ebEH/fL6P43mVLL5nJfZQO+c+MIbg6KAf3M/b4uXrv24kdUh7OgxKpra8DmuQ9Scd48fK2VjdRFNVE43VrQ+/H0ITXMRnxOD3+WmoasQRasdoMv7zP/hvRufHIiIiIoGnwF3OGLqgEPnP423x4vP4MNvNlB8+TkhsMFanhaOHjhGeHIq32UvJnqOkDW3P0UPHqCmppcv4juxbeghrkJWOI1JY/deNdBzZgeDoIDa+vp3Mc9JprGni8Nd5DP5NXza/9Q0et4c+M7rz9V82ktwngQ6Dk/n8vlVknteZkLhgNry6nZE3D2LLWzuxBlm4+MXJvDHzfbweH45QO7VH67C5rPi9fpobvhtPOrxdKDP+Ool3rl0IBgOXvDSZVU+to3T3UVxxLuoq6rEGWairqKe5/r89LzmUGc9NYs/nBzmyPp8hV/WldG85zggbVUW51B01tT7/aDHuRgdWm4/6Y8fAHE/aECshscF4POEc+mIpPSYPxhYSzL7PV+KI6gXeBuor9hHX6zxqCrfha6knrudZFG/9kKhOaYQmp5H1zrMEJ3TDFRNC6c7VtB9+JbWl2VQX7qfLpFvJXvE3bK4QMiZfw7o/X01C7xHYQsLY+9GLpI2dQVP1MQo3r2DQDY+SvfJ9PI11jLz9RZbcPoWwxAw6jJ3Dmscnk9hzBs74KA4ve4Ghsx8jd99WKg+u5ry7/87Xb9yHtdnH0Fue5KPbJpDWeSjxEy5k9ZM30HvwDEpqCyjft5UeQ6dTXlNEU34ufS64iV2r38Fe46bjjGvZ9fHzRHmcHK7YTVR0Kn3SxrD92GaqcvZhtbvwmQzQ0IgzOoHG+irMDW4sicmEOyJpV2WluHcix9Z+wZCM86kbN4DVj8750fpqMzsYbu2J80+PsOSG8XRM6kP6f/2RIxeey9FBaZgdQfi2fkPQeZPw5ebhO3CI0KuvoemThYTZo+g0/z1yu3el8twhpF90PdXnTcX9xF1UH96N57OlRD/7V5rf+QBjYQmxL79G9aWzsQ8ZQtgf/sDRjO6Ev/A8xtAQjs+8jNgtm2l47z3q3l5A3JbNVFx2OTgdhD/zFGUDBhFy4004xozh2LiziFr4CZ7sbCpv+wOJhfkU/deN5BbuoCmjA5WHsvAZ/BhMJoJrvMQMGElUSiamp18h6fNlNC5eTMOnnxLz+WIqf38rBqeTsIcfonzSZIIum4Vt4ABOzLmO8Kf+jKe4iNq//JXozxZR98KLeAoKCX/8USpvvQ1Ljx44Z0znxJzrcN10A4agYGqfeYawxx+jedNm3OvXEzbvEWpffAmD3U7wlVdQde992MePw9Qxjbq/PIfr+uvwVhyjcdEiQh98gMbPFuOrqCD4qt9Q9/IrmDp0wD5iOLXPPItj8vkYbDYaPvqY4DnX0LJ3Ly179hJ8zdU0fPopBosVxzkTqXvlVaz9+mJqn0LD++/hnDIFX1UV7jVrCbrmatzr1uOrrMR5/iQaPv0UU0IC1p49aXj/A2zDWyc1bVq9GsekSXjz8vHk5uI471zc6zeAxYxtwIDvfmSJjcG9eg3WIUPwN9TTsmcP9rPPxrNvP776OmwDBuDevBljRATmDh1wr1uHJSMDzBZwN2GKj//R+hloJy8htr32IKW71jNq7susvH8Ww2/9K9Fd+vzgc3xeH0aTkfytRaz801r8Pj/dJ3Wl14XdfjQUd9c3s2n+DgbO7o3d9dMCfYDl81ZTsruMzmPTCE0MwRFmxxlmxxHmwBlmx+L4bs6Nkt1lGExG4jNiqCysZtkjX9NY1URLY8sP/u2UgUmcfdcoGquaeGv2h5x910hSBiazb/lhDnxxGHuoHUeIHXuoDbvLhi3IitFixGQ2EdslipA4F/XHG2huaCE8OfQnv6ZA0/mxiIiISOApcJczhi4oROSn8vv9eJu9GM1G/D4/7vpmHCF23HXNtDS24IoN5kR+FUazkdAEF/lbiohICcdsNXFkfT4dBidTcfg4FdknGDCrF9veycLv89F/Zi++enYDST3jSewVx4rH1jDoyj60NHrYNH8HQ67py75lh6kpreOCP0/k8wdWcSK/inF/GM6SB78ksWcc+ZuLADBZjBhMRjxuD1GpEdRV1OP3w5jfD2X1XzcS2yWaY0eOU3u0nnPuH8OG17dRVVjzT1/7yJsHcejLHEr3ljP9r+eRv6WILX/f+aPPsYfamPzo2XibvSx56EsGXt4bZ5iDvE2FHFmXT3NTCz6Pj+93RfeTOakLmeemUrD9KBte2cTEe4cR3j6RDS+vomBbMVZXFDZHKbaQWOwhLgzebEKT++D3VhEafZxuU2ez+dW3qTl6jPF3/5Z9C18hb3sLwXHdqC/6kMT+UzBZm6jYs5TBN85j1zt/5nj2LhL7jKJo+1cYzRYiOmRQsHEZoe3SsQWFcCw7i9F3v8aBz16ncMsXzHjrGzY+dzsncvbS98p72PTCXST1H0vqmItZfsck+l19Pz5PCzvemMfUV9ZzYPEb5Hz9MWPueZ3t8x/GaLFhCw4lf8MSgqKTMFks1BTn4IiMw9NUT0t9LV0nXUVzfTXVBYepLS8kKCqepJ6jaKw7Qfaq978dE/2H70BoN+QcwoJj8Jjg0JfvM3jKbwkbOIIld0zB2+L+nz84g4GhY64hdtIMlj5wCdER7cm88QH2vfkkxwsO4Ehsj6GyivCUcVTVHsRdsA+3oYWGqgrax2XSZ+4z7H/7WY4f3sXAB1/l+Lt/p6TsAJXuE3jKj2IOCQOLGU5UYU1Mxt/sxnCsisFPLsD9+TKK9m+C3t2J31eOM7Mnu4o34tn2DUG9+4LJjG/rdoKnTsOfk4/34AGCLruMqLX7wG5nTfFKkkv9pF96A6X+Sra9+ySuuHYE2UOx7M8h9vd3Yli1Fn/ZUUJuuw33Hx8ndOAwzDMuIP+iqSTf/TDmkBDyb7sJx4N307hxI+7NWwiZezsNr7+Bye4k7KabqZ5zPTFXXItz5ChKJ59P5GuvQkEx1XffQ8Lhg1TNvYuWw4eJ/vADSsaNwzS4P5ZLLqR0+jSCf3sLsZ16c3zW5Rj+8TeM67fg/+hzotevpvTKy7EEhxLzt5cp65qJ6/f/hX3USMrHjCPq04V4Dh2i6g+3k1hcSOWtt9Fy8BAxixdxdPRYbCNHEHLr7yntkkHESy9icAXjLS3DefFFNFVV4PXYqCpu4PAX71BdeAhXyiwcYXZaqreS3L8H7Qb0we8z4/X4sAVbf3ToJZ/XR2VBNdWltW1DtOz5/CBRqU72vDuXzufOJrJjT3yeFqzOYPYvnk+3qddSsGk5wdEJRKb3w2Ru7fW99KGvCI13MeTqftRV1JO9No+WRg9Zn+7DbDPT96LudJ2Q3rY/wOGvc9vC6X9F/fEGshbt58jafBqrGvF5T22EzHYzl791IRabmc/vX4XVaWH8HSNw17nZ8f4enOEOHKF2HGHfPkLt2ENsYDDgbfZidVrwuD0UZ5UR3SkSZ5iDgu3F5G4spKnGTVNNa4/4pho3zQ0t+H2txx9582C6jEtj3/LDlB86xqibB/9Lry8QdH4sIiIiEngK3OWMoQsKEflP5/f7aWny4PeD1W6mpcmDu86NKyaY6tJafF4f4UmhFGeVERzlxBnuIG9LEQndY/E2eynOKiN9VCpl+8upLa+nXf9EcjcVYnVYiEqLoOLQMWK7xtBU08SxIydIH5vGibxKcjYU0HFYCtnr8sAPnUZ1YN3fthLdMZKgKCd7Pz/A+NtHUH+8ga+e3cD4O0ZQvKuM4qwyUoe0Y9+yQ7hig+kyvhNfPb2efpf2ICTOxZdPreeiF84nd2MBWZ/uZ+qTE1n/8lYMBugxuSvLHv6amM5ROCMcHP4ql6iOEbhr3dSW1+MItZEyIJnGajeJPePYs/gAXcZ3pNs56fzj6oVYHGYaq9143J5T3kNrkBW7y0qfGd3pPDaNT25fRsrAZDImdGLXJ/uoKqrG5/XTVNOEM9xBU6277e6Dxsp6Ogxpz4CZGRxek8e6v33DhLv64oqN5tDXOeRvPoDZGY3N2YLR6MYRkYzBX4LJYsWVkIbdfpCYLt1pqDJQuPlL+sycTlPVMXZ+sIyghJHUH/0GfE2Eth/GiUOLsId3ICgmnfKst+l7+TV43PXs+eh1Oo6fReWRzVTlHyB5yHkcP7SDoJgkYrr2ZfNL99Dz4t/iik/h68euJXX0NBqPl1G6cx09L/k9eesW0dJQS6ezLmX3h8+RNuZCUkddwOLfTaTLpN/giEzjm7ceIrzrPYRFH6K6YDtB7W8hd9WjdBrdiz6z5/L+rN5kTL2RhF4D+eLui4jp2p+EfqPZ/d5f6D79JrJXvo/X00zygPHkfPURQTHJuOLaUbRlBZEde5A27iK2vHQ3GVOupTRrHZ7GeiY+sZCPrxmC0WTBHhpJTUkOZruzdcLSb380cEYl4GtpZurLa1l+9wws9iDG3DufZXdOwxERizU4hMKNyzDbg3HXHD/lcw9tl845f/qU1Y9dR8k3q5n22iY2vXg3DcfLqMzd+6P/7yb+6VMKN3/BsUM7aa6rIjZzEB1GTmXZndMAMDuC8DTU4vOc2hPaGRlHt2k3Ep3ei5UPXEZMRn8G/OY+CrauYNtrf2zbz2R1YAsJx2A0YnOGYAuNxBWbTNfxs2hw17Dt1QcZOPtebHEJHPjoZSqLDuH1eaDFg99gw+9vwWj0U1WUh9ddS33zxXh9ydjsWThdbuzR51JfWY2/8hEM+AED1tBE6iuDSBvWEYPRSMXh42AMI7r7JQRFOilc+ywt/u5UFkfhcx/BZt1Kuz7xeFvclO3LJbx9Or7mYmxhCVidMaSOGkdSv1FUFeaz77MPObpnPR5PLHWVSfS9KJaQ2FhK9x3H7nIQ0zkGg8mM0WTGaDJhdbVn18IcDq7agSvayKDfnEvKoGSOH9nPise/pl2fRDImdj5lAl6DwQAGA6FJHQGoO1qIyWbHERaN19OMu6YSo9nS+vj2WH4/uOuaaahqpKnaTWN1Mw2VjXQem4bdZcNd34zVYcFg/PnmfvB5ffg8PgwmIyazkeaGFrwtXhyh9p/tmP+Mzo9FREREAk+Bu5wxdEEhInJ6+f1+PM1ejN8GWg1VraF2c30zTdVNhLcLo7KoGvytw+qU7DlKcJQTm8tG/uYiknrH01TjJn9rEb2mdSNvUyF1xxroPqkL29/NIiTORerQdnz59Hoyz+2CxWFm4+vb6TMjk7wtxZRkldFpVAdyNxUSlRrB8OsG8NqMd+kwJJk+F2by3o2fEdE+FK/HR3VxLYk946gurqGlyUPa8BRyNuQTmx7F2NuG8/pF75IxoRNJvRP44tHVDJ3Tn8Nf53I8r5LkPgmU7i3H7/PhDHNQVVKD0WRk+A0DWP2XTXQanUrhtiJa3F6u/McMFlz1MS0NLdiCrTTVNmMwGjAYDXjcnm8DRj+JPeIZ/bshLLxjOSaLkYueP5+N87eTtXD/999oA62hod9PaHwIM56bRM7GfFY+sY6z5o7E2+Ll6IEKstfkgd+P1WXDYjNTf6KRpuomAELighl50yBswTZ8fj/2YCuNVU34PD4+nfsFBiPEpEcS0d5Bc5MRg8GDu6oKr89FTJqFjiPaYQmKYdUT79Fz6gCS+3Vi76fLqCoLwmQ10FyThz08k5aGcjzuamyhnXFXHSFlcAc6jhzEzvfe5Vieg2HXDaNwy0rK8+I4kZtHc/UhDPahNFfvxNvcRIs3E0PzWjzeGKY/fz05X71J8b4E/L4mopOzaT/iIpbc+ypGYy0+09lYjV9iNFvxmUfhr19Ac0sGoUlJhEdvoffld7Lw9/OJbp/HmLufYeMLT3Isu5iw9N/QWPIqzqhUgmI6c3TnW7QbcTPVeeuozF5D+sSZVBzMoqYkn/7X3Mvej57D7IgleegN7HhlOu1H3YzFGUH2kgfJmPE8VbmbKN3xHv2veYTsL96kqaaa2O6jKdz4IUFRCViCIjh2cAs9Zz1B7dFCclb8lS7T/sKxfSs5cWQ19vCueBoOYLY5qakIxWzYT0RqJrbwFEq3L6brtCfBW8ThpX9j+ls7WP/Mf+Guq2bE7S/w2U3jiEjLxGBxUbx5MaHJnfD7fNQUH8Hk6oe3JQhf0wEwBmGxNuFKzKTdkAns/sfthCZ1xGAyU5W3n4i0HhgMUFNWSWNVPX5LXxwx46guyMJhfp8W63XEdk2jsegZmk4c+dF2ISI1k/7XPMCud/9GWdZqahp/R0J6OQ2l7+D7kTs0DEYTU15aTW1pHuue/i+SB44nJmMAtWX5ZL3z9I8eM6HPaDKnXU9NSQ6bnr+T7jNuIaH3CMp2b2TPh89jtFgxmEz4PR4MZgv4vPh9PoxmC53PvYLkAeOozNvP1tf+yDlPLMQeGslXj86huvAwRnNrwG+yOjCZLRjMFix2JwADr38EZ2Q8ez9+iZbGOnrP+sOPlvOXoPNjERERkcBT4C5nDF1QiIjIjzl5SuTz+PC4PViDrLjrmvG2eAmKcFJ7tA6TzYTdZaOyoJrg6NYQ7XheFTHpUdRV1FNztI523wbuBiPEdY0hb3MhYYkhOCOcFGwrJrFnHE01bop2lpJ5XmfytxTRUNlIxoR0dn68l5B4F+36JrL+b1voenYnDEYDOz/ay7DrBnDwyxzK9h5lwj2jWfPCZuqPN5A2tD3b3ssiPiOGkLhgdn92kM7j0nDXuMndVMAVC2aw7uWtlOwu45z7x7B83mrCEkMITXCx4/09JPeJBwwU7ihh+A0DqSmr5fDXuVw2fxpLHvwSs83MWXeOYP6l79FnenciU8P5/L5VxHaJoqq4BndtM9GdIqk/3oDH7aXvxd05sCKbuC7RuOuaydlQwNjbhlG2v5y9nx/CFRNES5OH5vpmwpJCqauox2A04IoNpqnGTe/pmfi9fjbO387kR8+itqKeNc9tIi4jmtryerzNXtr3T6JoZymumGDiM6M5sPIIg6/qhzPUzvpXttJrWje8bi+FO0uJz2j9DPBDVFoEeVuKCEtw4Yp3UbyzlIyJ6ThC7OxZfIBRvxvCwZVHaKhsJHVIO9a+tAX84Gn2UFdeDwZD6/BI3+oyPg1nuJOIlDBWPrGWUbcMpvPYNN676TOqCqs5dRwlH2D8dp2XUbeMIG1oPMsf/YrGKj/n3D+AiiO1LHt4PQZDNX5/MODDaKjB54/EbGnAEQpRnboycGYC7gYfBmMkzXXZOCMTsYeFcOLIbiI69MDTVEV1UQ6JfUZyPHsXPk8LMRn9KdyyguBv7zjI37CE+J7D8HlaKMvaQIdRUzlxZA/1x0pIGXYe+RuWYA0OJb7HUPZ/9jpx3YcQ1r4zzXVV2Fzhbf9nKrKPk7OhgKZqN7FdoojPiCE0MQSDwYC7toqcrz+m01mXkL3qA3yeZjqMmEzWu88Q2bEnocmdOLB4Pt2n30RtWT4Hl/ydTuf+keKti/DUH6TbBdez58PnCYqKp93Q89j84l2kjbkQW0g4ez54nrEPvEXprnUcWDyf0Xe9yp6PXsDjbiR11FS2vHw/MRkDiEzNZOc/niT9nMtpaajjyMr3GHHnS5R+s5byfVvofM7lHFq6gKj0XrQffj6r7p9J8qCzsThc5Hz1IennXE5NcQ4V+7fS7YLrKcvagNlmp8clv2flfZfSZdJVdBhxPp/dPJ4OIybT3FBL8bYv6TjuYsoPbKOxspz4nsMo3bWOxD6jGHj9I7x3aXeSBoyny7lXkLduEf2vfuDnb+D+Bzo/FhEREQk8Be5yxtAFhYiIyHf8fj8+r5+TQ3i3NHraxqRuafLgDHdQf6IBgKAIJ5VF1dhDbFjsFqqKqgmNd+Fxe6kurSGuawyVBVU0N3qI7RxFcVYZ9hAbYUmh5G4oILZrNEajgaKdpaQObU9lYRWVBdV0HptG9to8TGYjHQa3Y8f7u0noHktIvIusT/fTbUI6DVWNZK/JY8jV/Tj8VS71JxrofWEmm9/8hoj2YaQMTubrZzbQ/fyumKxGtv0ji1G3DKZwewkF24sZ94fhbHhtG2abmQGzevHp3C/oOr4j8ZkxfPXsBobNGUBDZSN7lxzirDtHsG/ZIeqONTDw8t6seWETUWmRdBqRwtKHvqLfJT0wmo2sf2Ub428fTt7WYgq2FDHh3tGs+vM67CE2Rt44iDdnfUDPC7qSkBnLJ39YznkPj6OyoJr1L2/lqg8uYe0Lm6kuqWHKExN457pPic+MYfCVfXnj0vfpPT0TW7CVTfN3MOXxs8nZWMCRtfnMev2C1nHGg6yMv731Lot+l/YkqVc8H9yymClPnM2J/CrWPL+Zaz+dxdd/2UhlUTVTn5jAB7csJrlPAn1mZLLgN58w+ndDsDjMrPrzOi58+lyy1+RxZH0+Fzw5kS+fXo81yMqwOf356PdLyDyvM3FdY1jx+BpG/24INWV17PxwD1OfnMiO93dTW1HPyBsH8eXT64lJj6LzmFSWP7qavhf1wGwzse3d1s+jeGcZJXvKGHHDIL75cA9mm5nuk7qw9qUtdBiUTHhyKDs+2EPPqRk0VjWSs6GAwVf2bQ3za5rImJDOns8PEprgIr5bLLsX7SdlUDImi4m8TYV0Gd+RqqJqqoprSB+dSsH2YkwWE4k94shek0dkh3CcEQ6Kd5URnxlDc4ObyoJKUgakUHG4BG+zn9iMBEp2HcEZEUpwjIuSrCNEd2qPz9NEZUEZCT0zqC4soKWxmdiMdEp378IeFkFIbAylWTuISOuC39vMidwDJPQeSk1RNu7aSuK6D6Zk51pswaGEp3Yj96uPie7aD7PNQU1xDnE9hpy2dkDnxyIiIiKBZz7dBRARERGRX57BYMBk/m68aluwFQCLw4LFYQFag/aTwpNC25ajUiPa9nWEtY4/Hd4urG17Yo+4tuWOI1LaljuPTQMgplMUMZ2iWrcP/257nxnd25YHze4DgCs2mNjO0QCkj0lt2z5wdu+25fF3jGhbnnjv6LZ9T+4/5Kp+bdsnP3pW2/L5j7QuR7QPI6lXPADdzunctn3EDYO+23fed8+b9tQ5APSY1IUek7oAcPbckW3bZy+YDrT+qHH1R5diNBqIz4ih85hUzFYTw64bgM/b2lN+8mNnYTKbsNjNXPzS5G/H8/aT2COO8HZhOCOdpA1rD8CAy3thNBnbXnNoggt7iI2z5o4kNCEEe4idsbcObX2vx6XR3NAMQO8LuxEcHYTRbKLfJd0JTw7FYDTQfVJXLN/O4WD4dq7ShO6xmK0mAJJ6xeOKCcZsNRHbJRqLw4LdZSMytbWHuzPCwclfbIIinNhdVjAYsAVbMX5btwyAAcO3d454AWiqdWP99k6B6uIammpb51s4eqACT5OHuooGCraVMPjKvpQfPkZtWR0ZE9LJ2ZBPYo84YjpFkbVwP+HJoZisJrb9Yxdpw9tTsKOEw1/lkD46laxP92N32UjsEcfq5zcxYFYvErrHsuLxNUx5YgLHc0+w9qUtXLswhT1L8qguqWXK44mse3kf7fon0md6Jsse+Ybxd7gwW00sfWgns15P5ciGKg59lcvMV9PZ/n4FNlcN429PZvkTefSfFUZijziWPFzIlCeqOJ5nYu2LR7h24WAOr7dQU3qUSQ/3IGu5i6SjNfSYnEjejhLieiAiIiIivyLq4S5nDPXgERERETlz+P1+DAYD3hZv22SoLY0tWBwWvB4fzXXNBEU6aaxpwtfiIyiydegos82MzWWlsrCa4Ogg8ENVcQ1RqeE0nGikvrKRuC7RlB8+htFkJCq1daii8ORQ7C4bhTuKSeqVQGNNE0cPVNBlXEeKdpbSXN9M6tD27Ft+mJC4YGK7RFP0TSkdBiWftvdI58ciIiIigafAXc4YuqAQEREREfmOzo9FREREAs94ugsgIiIiIiIiIiIiIvJroMBdRERERERERERERCQANGmqnDFOjp5UU1NzmksiIiIiInL6nTwv1iijIiIiIoGjwF3OGLW1tQAkJ5++ialERERERP7d1NbWEhoaerqLISIiIvKroElT5Yzh8/koKSnB5XJhMBh+lmPU1NSQnJxMYWGhJp46w6kuyEmqC3KS6oKcpLogJ53uuuD3+6mtrSUhIQGjUaONioiIiASCerjLGcNoNJKUlPSLHCskJEQX0AKoLsh3VBfkJNUFOUl1QU46nXVBPdtFREREAkvdGEREREREREREREREAkCBu4iIiIiIiIiIiIhIAChwFwkgm83G/fffj81mO91FkdNMdUFOUl2Qk1QX5CTVBTlJdUFERETk10eTpoqIiIiIiIiIiIiIBIB6uIuIiIiIiIiIiIiIBIACdxERERERERERERGRAFDgLiIiIiIiIiIiIiISAArcRQLo8OHDDBkyhPT0dPr378/evXtPd5HkF9DU1MSUKVNIT0+nZ8+ejB8/nuzsbADKy8uZMGECnTp1IjMzkzVr1pzm0sovZf78+RgMBhYuXAioLpyJ3G43N910E506daJ79+7MmjUL0HfFmWbJkiX06dOHXr16kZmZyZtvvgmoTTgT3HLLLaSkpGAwGNi5c2fb+h9rA9Q+iIiIiPznU+AuEkDXXnstc+bM4dChQ9xxxx1cccUVp7tI8guZM2cOBw8eZNeuXUyePJmrr74agDvvvJNBgwZx+PBh5s+fz6WXXkpLS8tpLq383PLy8njllVcYNGhQ2zrVhTPPnXfeicFg4NChQ+zevZsnn3wS0HfFmcTv9zNr1izeeOMNdu7cyeLFi7n22mupra1Vm3AGuPDCC1m3bh3t27c/Zf2PtQFqH0RERET+8xn8fr//dBdC5NegvLycjh07cuLECcxmM36/n/j4eNatW0fHjh1Pd/HkF7Rt2zYuvPBC8vLyCA4OJjs7m7i4OAAGDBjAvHnzGDdu3GkupfxcfD4fZ511Fo8//ji33norv/vd75gyZYrqwhmmvr6e+Ph4ioqKCAkJaVuv74ozi9/vJyoqik8++YQRI0aQlZXFxIkTyc3NJSIiQm3CGSIlJYWFCxfSq1evH20DQkJC1D6IiIiI/Aqoh7tIgBQWFhIfH4/ZbAbAYDDQrl07CgoKTnPJ5Jf27LPPMnnyZI4fP05LS0tbmAKtF92qE79uTz31FEOHDqVv375t61QXzjxHjhwhIiKCefPm0a9fP4YPH86qVav0XXGGMRgMvPfee1xwwQW0b9+eYcOG8eabb1JbW6s24Qz1Y22A2gcRERGRXwfz6S6AiMivybx588jOzmbVqlU0Njae7uLIL2zPnj189NFHGotZ8Hg85Ofnk5GRwWOPPcY333zD+PHj+fzzz0930eQX5PF4ePjhh/n4448ZMWIEW7du5fzzzz9lPG8REREREfl1UQ93kQBJTk6mtLQUj8cDtN5GXlBQQLt27U5zyeSX8uSTT/Lxxx+zdOlSnE4nkZGRmM1mysrK2vbJy8tTnfgVW7t2LXl5eXTq1ImUlBQ2bdrEnDlzeP/991UXzjDt2rXDaDQyc+ZMAHr37k2HDh3Iz8/Xd8UZZOfOnZSUlDBixAgA+vfvT1JSEllZWWoTzlA/dr6oc0kRERGRXwcF7iIBEhMTQ58+fViwYAEAH330EUlJSRpz8wzx1FNP8c4777BixQrCwsLa1k+fPp2XXnoJgK1bt1JcXMzIkSNPUynl53b99ddTWlpKXl4eeXl5DBo0iJdffpnrr79edeEMExUVxdixY1m+fDkAubm55ObmMnToUH1XnEFOBqj79+8HIDs7myNHjtC5c2e1CWeoHztf1LmkiIiIyK+DJk0VCaCDBw9yxRVXcPz4cUJCQpg/fz7du3c/3cWSn1lRURHJycmkpqbicrkAsNlsbN68maNHj3LZZZeRm5uL1WrlueeeY/To0ae5xPJLGTVqVNukqaoLZ56cnByuuuoqjh07htFo5L777mPatGn6rjjDvPPOO8ybNw+j0YjP52Pu3LlceumlahPOANdeey2ff/45ZWVlREZG4nK5yM7O/tE2QO2DiIiIyH8+Be4iIiIiIiIiIiIiIgGgIWVERERERERERERERAJAgbuIiIiIiIiIiIiISAAocBcRERERERERERERCQAF7iIiIiIiIiIiIiIiAaDAXUREREREREREREQkABS4i4iIiIiIiIiIiIgEgAJ3ERER+bdkMBhYuHDh6S6GiIiIiIiIyE+mwF1ERES+54orrsBgMHzvMWHChNNdNBEREREREZF/W+bTXQARERH59zRhwgTmz59/yjqbzXaaSiMiIiIiIiLy70893EVEROQH2Ww24uLiTnmEh4cDrcO9vPjii0ycOBGHw0FqaioffvjhKc/fvXs3Y8aMweFwEBkZyZw5c6irqztln9dff51u3bphs9mIj4/npptuOmX7sWPHmDp1Kk6nk06dOrFo0aK2bZWVlcycOZPo6GgcDgedOnX63g8EIiIiIiIiIr8kBe4iIiLyL7n33nuZNm0au3btYubMmVx88cXs378fgPr6es4++2zCw8PZunUrH3zwAStXrjwlUH/xxRe58cYbmTNnDrt372bRokV07NjxlGM8+OCDzJgxg6ysLM455xxmzpzJiRMn2o6/b98+li5dyv79+3nxxReJior65d4AERERERERkf+Pwe/3+093IUREROTfyxVXXMGCBQuw2+2nrL/rrru46667MBgMXHfddbz44ott2wYNGkSfPn144YUXeOWVV7jjjjsoLCwkKCgIgCVLljBp0iRKSkqIjY0lMTGRK6+8kocffvgHy2AwGLjnnnt46KGHgNYQPzg4mKVLlzJhwgTOP/98oqKieP3113+md0FERERERETkf0djuIuIiMgPGj169CmBOkBERETb8uDBg0/ZNnjwYHbu3AnA/v376dmzZ1vYDjB06FB8Ph8HDx7EYDBQUlLC2LFjf7QMPXr0aFsOCgoiJCSE8vJyAK6//nqmTZvGjh07OOuss5gyZQpDhgz5l16riIiIiIiISCAocBcREZEfFBQU9L0hXgLF4XD8pP0sFssp/zYYDPh8PgAmTpxIfn4+S5YsYcWKFYwdO5Ybb7yRJ598MuDlFREREREREfkpNIa7iIiI/Es2bdr0vX937doVgK5du7Jr1y7q6+vbtq9fvx6j0Ujnzp1xuVykpKSwatWq/1MZoqOjmT17NgsWLOCZZ57h5Zdf/j/9PREREREREZH/C/VwFxERkR/kdrspKys7ZZ3ZbG6bmPSDDz6gX79+DBs2jLfffpstW7bw2muvATBz5kzuv/9+Zs+ezQMPPEBFRQU333wzl112GbGxsQA88MADXHfddcTExDBx4kRqa2tZv349N998808q33333Uffvn3p1q0bbrebxYsXtwX+IiIiIiIiIqeDAncRERH5QcuWLSM+Pv6UdZ07d+bAgQMAPPjgg7z77rvccMMNxMfH884775CRkQGA0+lk+fLl/Pa3v6V///44nU6mTZvGU0891fa3Zs+eTVNTE08//TS33XYbUVFRXHjhhT+5fFarlblz55KXl4fD4WD48OG8++67AXjlIiIiIiIiIv8ag9/v95/uQoiIiMh/FoPBwCeffMKUKVNOd1FERERERERE/m1oDHcRERERERERERERkQBQ4C4iIiIiIiIiIiIiEgAaw11ERET+1zQinYiIiIiIiMj3qYe7iIiIiIiIiIiIiEgAKHAXEREREREREREREQkABe4iIiIiIiIiIiIiIgGgwF1EREREREREREREJAAUuIuIiIiIiIiIiIiIBIACdxERERERERERERGRAFDgLiIiIiIiIiIiIiISAArcRUREREREREREREQCQIG7iIiIiIiIiIiIiEgAKHAXEREREREREREREQkABe4iIiIiIiIiIiIiIgGgwF1EREREREREREREJAAUuIuIiIiIiIiIiIiIBIACdxERERERERERERGRAFDgLiIiIiIiIiIiIiISAArcRUREREREREREREQCQIG7iIiIiIiIiIiIiEgAKHAXEREREREREREREQkABe4iIiIiIiIiIiIiIgGgwF1EREREREREREREJAAUuIuIiIiIiIiIiIiIBIACdxERERERERERERGRAFDgLiIiIiIiIiIiIiISAArcRUREREREREREREQCQIG7iIiIiIiIiIiIiEgAKHAXEREREREREREREQkABe4iIiIiIiIiIiIiIgGgwF1EREREREREREREJAAUuIuIiIiIiIiIiIiIBIACdxERERERERERERGRAFDgLiIiIiIiIiIiIiISAArcRUREREREREREREQCQIG7iIiIiIiIiIiIiEgAKHAXEREREREREREREQkABe4iIiIiIiIiIiIiIgGgwF1EREREREREREREJAAUuIuIiIiIiIiIiIiIBIACdxERERERERERERGRAFDgLiIiIiIiIiIiIiISAArcRUREREREREREREQCQIG7iIiIiIiIiIiIiEgAKHAXEREREREREREREQkABe4iIiIiIiIiIiIiIgGgwF1EREREREREREREJAAUuIuIiIiIiIiIiIiIBIACdxERERERERERERGRAFDgLiIiIiIiIiIiIiISAArcRUREREREREREREQCQIG7iIiIiIiIiIiIiEgAKHAXEREREREREREREQkABe4iIiIiIiIiIiIiIgGgwF1EREREREREREREJAAUuIuIiIiIiIiIiIiIBIACdxERERERERERERGRAFDgLiIiIiIiIiIiIiISAArcRUREREREREREREQCQIG7iIiIiIiIiIiIiEgAKHAXEREREREREREREQkABe4iIiIiIiIiIiIiIgHw/wCL2jksBaCh9AAAAABJRU5ErkJggg==", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABdwAAAOECAYAAAC7OPPEAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd3hU1dbH8e+Zlp5AEiChhQAJTQihIwooKIKgKIIiV0ARsaCvV8CKiL1y7QURARXEQrXQNYigqEDoXSCU0Ekv0877R8zoSDFoSEB+n+fJk8w+++y99pAJyZp91jFM0zQREREREREREREREZF/xFLeAYiIiIiIiIiIiIiI/Bso4S4iIiIiIiIiIiIiUgqUcBcRERERERERERERKQVKuIuIiIiIiIiIiIiIlAIl3EVERERERERERERESoES7iIiIiIiIiIiIiIipUAJdxERERERERERERGRUqCEu4iIiIiIiIiIiIhIKVDCXURERERERERERESkFCjhLiIiIiIiIiIiIiJSCpRwFxEREREREREREREpBUq4i4iIiIiIiIiIiIiUAiXcRURERERERERERERKgRLuIiIiIiIiIiIiIiKlQAl3EREREREREREREZFSoIS7iIiIiIiIiIiIiEgpUMJdRERERERERERERKQUKOEuIiIiIiIiIiIiIlIKlHAXERERERERERERESkFSriLiIiIiIiIiIiIiJQCJdxFREREREREREREREqBEu4iIiIiIiIiIiIiIqVACXcRERERERERERERkVKghLuIiIiIiIiIiIiISClQwl1EREREREREREREpBQo4S4iIiIiIiIiIiIiUgqUcBcRERERERERERERKQVKuIuIiIiIiIiIiIiIlAIl3EVERERERERERERESoES7iIiIiIiIiIiIiIipUAJdxERERERERERERGRUqCEu4iIiIiIiIiIiIhIKVDCXURERERERERERESkFCjhLiIiIiIiIiIiIiJSCpRwFxEREREREREREREpBUq4i4iIiIiIiIiIiIiUAiXcRURERERERERERERKgRLuIiIiIiIiIiIiIiKlQAl3EREREREREREREZFSoIS7iIiIiIiIiIiIiEgpUMJdRERERERERERERKQUKOEuIiIiIiIiIiIiIlIKlHAXERERERERERERESkFSriLiIiIiIiIiIiIiJQCJdxFREREREREREREREqBEu4iIiIiIiIiIiIiIqVACXcRERERERERERERkVKghLuIiIiIiIiIiIiISClQwl1EREREREREREREpBQo4S4iIiIiIiIiIiIiUgqUcBcRERERERERERERKQVKuIuIiIiIiIiIiIiIlAIl3EVERERERERERERESoES7iIiIiIiIiIiIiIipUAJdxERERERERERERGRUqCEu4iIiIiIiIiIiIhIKVDCXURERERERERERESkFCjhLiIiIiIiIiIiIiJSCpRwFxEREREREREREREpBUq4i4iIiIiIiIiIiIiUAiXcRURERERERERERERKgRLuIiIiIiIiIiIiIiKlQAl3EREREREREREREZFSYCvvAERERERE5MzzeDy4XK7yDkNEREREpFQ5HA4slrNnX7kS7iIiIiIi/2KmabJ//34yMjLKOxQRERERkVJnsViIj4/H4XCUdygAGKZpmuUdhIiIiIiInBnp6elkZGRQuXJlgoODMQyjvEMSERERESkVXq+Xffv2YbfbqVmz5lnxu652uIuIiIiI/Et5PB5fsj0qKqq8wxERERERKXWVKlVi3759uN1u7HZ7eYejm6aKiIiIiPxbFddsDw4OLudIRERERETOjOJSMh6Pp5wjKaKEu4iIiIjIv9zZcGmtiIiIiMiZcLb9rquEu4iIiIiIiIiIiIhIKVDCXUREREREzik7d+7EMAxSU1PLOxQRERERET9KuIuIiIiIiIiIiIiIlAIl3EVERERE5Kzk9Xp54YUXqFu3LgEBAdSsWZOnn36a+Ph4AJKTkzEMg44dO/rOef/992nUqBEBAQHExsYydOjQcopeRERERM5HtvIOQERERERE5EQeeughxo0bx8svv8xFF11Eeno6mzZt4qeffqJVq1YsXLiQRo0a4XA4AHj77be57777eO655+jatSuZmZksXbq0nFchIiIiIucTwzRNs7yDEBERERGR0ldQUMCOHTuIj48nMDCwvMM5LdnZ2VSqVIk33niDW2+91e/Yzp07iY+PZ9WqVTRt2tTXXq1aNW6++WaeeuqpMo5WRERERMrL2fY7r3a4i4iIiIicZ/Ly8ti0aVOZz1u/fn2Cg4NL1Hfjxo0UFhbSqVOnEvU/ePAg+/btK3F/EREREZEzQQl3EREREZHzzKZNm2jevHmZz7tixQqaNWtWor5BQUGnNfbp9hcREREROROUcBcREREROc/Ur1+fFStWlMu8JZWQkEBQUBCLFi06rqRMcc12j8fjawsLC6NWrVosWrSISy65pHQCFhERERE5TUq4i4iIiIicZ4KDg0u807y8BAYG8sADD3D//ffjcDho164dhw4dYv369QwYMICgoCDmzp1L9erVCQwMJCIigtGjR3P77bdTuXJlunbtSnZ2NkuXLuXuu+8u7+WIiIiIyHnCUt4BiIiIiIiInMijjz7KsGHDGDVqFA0aNOD666/n4MGD2Gw2XnvtNcaOHUvVqlW5+uqrARgwYACvvPIKb731Fo0aNaJ79+5s3bq1nFchIiIiIucTwzRNs7yDEBERERGR0ldQUMCOHTuIj48nMDCwvMMRERERESl1Z9vvvNrhLiIiIiIiIiIiIiJSCpRwFxEREREREREREREpBUq4i4iI/E2GYZzWR61atUo9hlq1amEYxlk31pnw7bff0qtXL6pVq4bD4aBixYrUq1eP3r1788Ybb5CZmVneIYqIiIiIiMh5zlbeAYiIiJyrBgwYcFzb999/z/bt20lKSqJp06Z+x6Kjo8sosn+fJ554gsceewyABg0a0Lp1a+x2O5s3b2b69Ol8/vnntGjRgjZt2pRzpCIiIiIiInI+U8JdRETkb5o4ceJxbQMHDmT79u307NmT0aNHn/EYFi1ahMvlOuvGKk0rVqxg9OjR2O12Pv30U3r27Ol3fP/+/Xz00UdUqFChXOITERERERERKaaEu4iIyDmsTp06Z+VYpWn69OmYpkmfPn2OS7YDxMTEMHz48LIPTERERERERORPVMNdRESkDEycOBHDMBg9ejRbtmzhhhtuoEqVKlgsFmbOnAnAtm3bGD16NG3btiUmJgaHw0H16tXp378/W7ZsOeG4J6q7vnPnTgzDoGPHjuTn5/Pggw8SFxdHQEAAdevW5fnnn8c0zTM6FsDixYu59NJLCQsLo2LFinTr1o1ffvnF77koiUOHDgFQqVKlEvX/o9zcXJ5//nlatGhBeHg4ISEh1K9fn7vuuuuEz+mHH37IRRddRHh4OMHBwTRp0oRnn32WgoKC4/oOHDgQwzBISUlh3rx5XHLJJVSoUAHDMMjIyPD1mzt3LldeeSWVKlUiICCA2rVrc99993HkyJHjxnQ6nbz11lu0bNmSqKgogoODqVWrFt27d2fq1KmnvX4REREREREpW9rhLiIiUoY2b97sS6ZecsklHDt2DLvdDsB7773HCy+8wAUXXEDLli0JCAhgw4YNfPjhh8yaNYslS5bQpEmTEs/ldDq5/PLL2bBhAx07diQ3N5fFixfz4IMPkp2dzVNPPXXGxpo+fTp9+vTB4/HQpk0batWqxdq1a7nooou4+eabSzwvQI0aNQCYNm0aDz30EJUrVy7Reenp6Vx22WWsX7+eihUr0rFjRwICAvj111955513SEhIIDEx0dd/yJAhvPvuuwQGBnLppZcSHBxMSkoKDz/8MF988QULFy4kODj4uHmmTJnCe++9R4sWLejatSvbt2/3vXHx4IMP8vzzz+NwOGjZsiWxsbGsXr2al19+mdmzZ7N06VKqVKniG6tfv358/vnnhIWFcfHFFxMeHs7evXv5/vvvycnJ4YYbbjit505ERERERETKmCkiIiKlZsCAASZgPvbYY37tEyZMMAETMIcOHWq63e7jzv3hhx/MX3/99bj2999/3wTMSy655LhjcXFx5p//O9+xY4dvrg4dOpiZmZm+Yz///LNptVrN4OBgMzs7+4yMlZmZaUZGRpqAOXnyZL/xHn30Ud94f36OTmb79u1mUFCQCZhhYWHmgAEDzHHjxpkrV6484fNYrFOnTiZg9unT57i17tixw1y9erXv8eeff24CZtWqVc0tW7b42jMyMsyLLrrIBMxhw4b5jVH8bw2YU6dOPW7+Tz/91ATMCy64wNy6dauv3ev1mqNGjTIB8/rrr/e1//rrryZgxsXFmYcPH/YbKz8/31y2bNlfPFMix8vPzzc3bNhg5ufnl3coIiIiIiJnxNn2O69KyoiIiJShSpUq8fzzz2O1Wo871qZNG+Lj449rv/nmm2nXrh0pKSlkZmaWeC6LxcLYsWMJDw/3tRXvws7Ly+OXX345I2N9+umnHD16lE6dOnHjjTf6jTNq1Cji4uJKPC9A7dq1+eKLL6hRowbZ2dlMmjSJwYMH06xZM6Kjo7nzzjtJT0/3O+enn35i0aJFVK5cmffee4/Q0FC/47Vq1fK7WuC1114D4LHHHiMhIcHXHhERwZtvvolhGIwdO/aEpWWuvPJKrr/++uPan376aQA+/vhj6tat62svLqfTtGlTPv/8cw4fPgz8XjonOTmZqKgov7ECAwNp27btXz9ZIueBjh07cu+9957xeYpLaqWmpp7xuURERETk30MJdxERkTLUuXPnE5YlKZaTk8PHH3/MAw88wODBgxk4cCADBw4kPT0d0zTZvn17ieeKi4ujXr16x7UXl1H5c5K6tMZaunQpAL179z6uv81mo1evXiWet1inTp3Ytm0b06dP5/bbb6dZs2bYbDYyMjJ4++23adq0KZs3b/b1X7hwIQB9+/YlLCzslGO7XC5+/PFHoKiky581adKEJk2akJOTc8LE21VXXXVc28GDB1m9ejUJCQlccMEFxx03DIN27drh8XhYsWIFAPXr1yckJISvvvqKF198kX379p0ybhERKHoD8ZVXXinvMERERETkN6rhLiIiUoZq1qx50mPffPMNN9xwg2+n84lkZ2eXeK7q1aufsL04AV1YWHhGxipOvhfXXv+zUz0Hp+JwOLjmmmu45pprAMjIyGDq1Kk8/PDDHDx4kKFDh7JgwQIAdu/eDUCdOnX+ctwjR47gdDqJjo4mJCTkhH1q1arF6tWr2bt3b4nWs3PnTgC2bt163I1o/6x4h3t4eDjjxo3jtttu4/777+f+++8nMTGRSy65hJtuuol27dr95VpERERERESkfGmHu4iISBkKDAw8YXtOTg59+vTh8OHDjBo1ig0bNpCbm4vX68U0Tfr27QuAaZolnstiKb3/5ktzrNJSoUIFbr/9diZOnAjAt99+S15e3hmZ61RJ8xP9m3q9XgBiYmIYMGDAKT/+WGKnb9++/Prrr4wbN47evXuTkZHB2LFjueiiixg2bFjpL0zkLJebm0v//v0JDQ0lNjaWMWPG+B0vLCxk+PDhVKtWjZCQEFq3bk1KSgoAWVlZBAUFMWfOHL9zZsyYQVhY2N/6ebF48WJatWpFQEAAsbGxPPjgg7jdbt/xzz//nMaNGxMUFERUVBSdO3cmNzcXgJSUFFq1akVISAgVKlSgXbt27Nq1q0TzfvHFF7Rs2ZLAwECio6N9bzx27NiRXbt28d///hfDMPx+Vi1dupSOHTsSHBxMxYoV6dKlC8eOHTvtNYuIiIjI6dEOdxERkbPAkiVLOHLkCNdddx2PP/74ccd//fXXcojq74mNjQV+32X+Zydr/7suvfRSADweDxkZGQQHB/t215ekBE9UVBQOh4PDhw+Tm5t7wl3uxTvWq1WrVqKYiq8IiI6O9r0hUFKVKlXi1ltv5dZbb8U0TebNm8f111/P//73P2655RYaNWp0WuOJnMtGjBjB4sWLmTVrFpUrV+bhhx9m5cqVNG3aFIChQ4eyYcMGpk6dStWqVZkxYwZXXHEFa9euJSEhge7duzNlyhS6du3qG3Py5Mn07NnzlOW9TmTv3r1069aNgQMH8sEHH7Bp0yYGDx5MYGAgo0ePJj09nb59+/LCCy9wzTXXkJ2dzZIlSzBNE7fbTc+ePRk8eDAff/wxTqeTn3766S+vgAH46quvuOaaa3jkkUf44IMPcDqdfP311wBMnz6dpKQkbrvtNgYPHuw7JzU1lU6dOnHLLbfw6quvYrPZ+Pbbb/F4PKe1ZhERERE5fUq4i4iInAWKdx2eqHTLtm3bWLlyZVmH9Le1a9eOiRMnMm3aNIYMGeJ3zOPxMH369NMazzTNUyaltm3bBhSVnImOjgaKauU/8sgjfPzxxzz11FPH3TT1j+x2O23atOG7775j6tSpDBo0yO/4unXrWL16NaGhob4k31+pXr069evXZ8OGDWzZssVX6/50GYbBFVdcwZVXXsnHH3/M+vXrlXCXUpOenn7cvRwqVqxIfHw8BQUFbNiw4bhzmjVrBsDmzZt9O7eL1apVi8jISA4dOnTcG2thYWF+NyQuiZycHMaPH89HH31Ep06dAJg0aZLv52RaWhoTJkwgLS2NqlWrAjB8+HDmzp3LhAkTeOaZZ+jXrx833XQTeXl5BAcHk5WVxVdffcWMGTNOKxaAt956ixo1avDGG29gGAb169dn3759PPDAA4waNYr09HTcbjfXXnut78qVxo0bA3D06FEyMzPp3r27r9RVgwYNSjTv008/zQ033OD3ZmxSUhIAkZGRWK1WwsLCiImJ8R1/4YUXaNGiBW+99ZavTT87RERERMrG2Xd9uIiIyHmoOCE7ffp0vxruGRkZDBo0CJfLVV6hnbbevXsTGRnJggULmDp1qt+xp556ih07dpzWeI8++igjRow44W71vXv3+pL6V111FQ6HA4BWrVpxySWXcPDgQW677bbjEoM7d+5k7dq1vsd33303AKNHj/a7miA7O5uhQ4dimiZDhgw5aUmgk8Xt9Xrp1avXCW+2euTIEcaNG+d7vGrVKqZPn47T6fTrd/ToUZYvXw6cvC6+yN8xduxYmjdv7vfx6KOPArBnz57jjjVv3tx37sCBA487Vrzr+tNPPz3u2NChQ087vu3bt+N0OmndurWvLTIy0ncD57Vr1+LxeEhMTCQ0NNT3sXjxYt/Pi27dumG325k9ezYA06ZNIzw8nM6dO592PBs3bqRt27Z+bwC2a9eOnJwc9uzZQ1JSEp06daJx48b07t2bcePG+d5MjYyMZODAgXTp0oUePXrw6quvlvjG1cW71U/H3zlHREREREqHdriLiIicBVq0aMFll13GggULSExMpGPHjkBRzd/o6GiuvvpqZs2aVb5BllBERATjxo2jT58+9O3bl9dee41atWqxdu1atmzZwm233ca7777rS47/lZycHF599VVeeuklEhMTadiwIYGBgezZs4fly5fjcrmoW7cur7zyit95H374IZ06deLjjz9m3rx5XHTRRQQEBLB9+3ZSU1MZM2aMb/fpdddd54vrggsu4NJLLyU4OJiUlBQOHTpEmzZteOKJJ07rebjxxhtZv349zzzzDM2bN6dp06bUqVMH0zTZvn07a9asITQ01FcGYteuXfTq1YuIiAhatGhBTEwMGRkZfPfdd2RnZ9OjRw/atm17WjGInMqQIUO46qqr/NoqVqwIFF2lsWLFipOeO3HixBPucAfo06fPcd+rxTdYLk05OTlYrVZWrFiB1Wr1O1Z8VYvD4eC6665jypQp3HDDDUyZMoXrr78em630/wyyWq0sWLCAZcuWMX/+fF5//XUeeeQRli9fTnx8PBMmTOCee+5h7ty5fPLJJ4wcOZIFCxbQpk2bU44bFBR02rH8nXNEREREpHQo4S4iInKWmDVrFk8//TSffvopc+bMoXLlytxwww089dRT59wNM6+99loWLlzI448/zs8//8z69etp06YN48ePZ8GCBUBR7fSSGDlyJC1atGDevHmsXr2aJUuWkJmZSXh4OK1ateLqq6/mzjvvPK72erVq1fj555955ZVX+Pzzz1mwYAFWq5Xq1atz55130r17d7/+xTcnfeedd1i8eDFut5s6depw77338t///vdvJbCefvppunTpwhtvvMHSpUtZu3Yt4eHhVKtWjTvuuIPevXv7+rZp04annnqKb775hs2bN7NkyRIqVqxIkyZNGDRoEP/5z39Oe36RU4mNjfXdc+HPAgMDfeVjTqR4l/mJVKpUiUqVKv3j+OrUqYPdbmf58uXUrFkTKCq/tWXLFjp06EBycjIej4eDBw9y8cUXn3Scfv36cdlll7F+/Xq++eYbnnrqqb8VT4MGDZg2bZpfmaulS5cSFhbmK3NjGAbt2rWjXbt2jBo1iri4OGbMmMF9990HQHJyMsnJyTz00EO0bduWKVOm/GXCvUmTJixatIibb775hMcdDsdxtdmLzznRPUFERERE5MwyTNM0yzsIEREROX9cccUVzJs3jx9//NGvVISIlL6CggJ27NhBfHz8aZVEOlvccccdzJkzh/fff5/KlSvzyCOP8M033zBo0CBeeeUV/vOf/7B06VLGjBlDcnIyhw4dYtGiRTRp0oQrr7wSKLoPRFxcHJGRkeTk5Pju+/BXdu7cSXx8PKtWraJp06bs3buXxMREbr75ZoYOHcrmzZu59dZbueuuuxg9ejTLly9n0aJFXH755VSuXJnly5fzn//8h5kzZ1K/fn3effddrrrqKqpWrcrmzZu58cYbefLJJ7njjjtOGUdKSgqdOnVi5MiR3HDDDbjdbr7++mseeOABAC6//HKCgoJ46623CAgIIDo6mi1bttC4cWMGDRrE7bffjsPh4Ntvv6V3796+e12IiIiI/Fucbb/zqoa7iIiIlLq9e/dy4MABvzav18vLL7/MvHnzSExMpFWrVuUUnYicK1588UUuvvhievToQefOnbnooov8aslPmDCB/v37M2zYMOrVq0fPnj35+eeffTvioWjXed++fVm9ejX9+vX727FUq1aNr7/+mp9++omkpCRuv/12Bg0axMiRIwEIDw/nu+++o1u3biQmJjJy5EjGjBlD165dCQ4OZtOmTfTq1YvExERuu+027rrrruNuLH0iHTt25LPPPmP27Nk0bdqUSy+9lJ9++sl3/IknnmDnzp3UqVPHd2VBYmIi8+fPZ/Xq1bRq1Yq2bdsya9asM1JKR0RERET8aYe7iIiIlLqpU6fyn//8h+TkZOLi4igsLGTdunXs3LmT4OBg5s6de8oSECJSOs623T4iIiIiIqXtbPudVzvcRUREpNQ1b96c/v37k5GRwfz585k3bx4ej4ebbrqJn3/+Wcl2ERERERER+VdSwl3OSRMmTMAwDGbOnFneoYiIyAkkJCTw/vvvs3XrVrKysnA6naSlpfHBBx/QsGHD8g5PRIRnnnmG0NDQE3507dq1zOJo1KjRSeOYPHlymcUhIiIiIqVDRfzknLNz507GjRtHmzZtyjsUERERETlH3X777fTp0+eEx4KCgsosjq+//hqXy3XCY1WqVCmzOERERESkdCjhLucUr9fLrbfeyuuvv86wYcPKOxwREREROUdFRkYSGRlZ3mEQFxdX3iGIiIiISClSwl3OKf/73/9o164dzZs3/8u+hYWFFBYW+h57vV6OHj1KVFQUhmGcyTBFREREzgpOpxOv14vH48Hj8ZR3OHKWMU0Tr9eL3W7X78ciIiIipUQJdzlnrFu3jmnTpvHdd9+VqP+zzz7L448/foajEhERETl7xcXF8c4775Cfn1/eochZrEmTJjgcjvIOQ0RERORfQQl3OWcsWbKEnTt3kpCQAMD+/fu57bbbSE9P54477jiu/0MPPcR9993ne5yZmUnNmjXZvXs34eHhZRZ3sS2rXyExaQZfzboJp+cwTlcwdepcSIsWLUptjsM33EjgFV0IHTgAANPt5kC7iwm6vg8R9/2X/KwCfrz7TepWdVLj2YdKbV4RERE5OzmdTg4cOECtWrUIDAws73DkLOPxeFizZg0Wi6W8QxERERH51zBM0zTLOwiRv6Njx47ce++99OzZs0T9s7KyiIiIIDMzs1wS7m53AVmF7Vm+pA379jSgUuX92O3N6dr1qjM679H/+y/u7dup/OVsX5tpmuftZcPL3vsFZ76Ljne3Le9QREREzriCggJ27NhBfHy8Eu5yHI/Hw6pVq0hOTsZqtZZ3OCIiIiJ/y9n2O692uIuUEZstkF0bIql/wVZ2p12AzeYh49j+Mz5vxKOPYAkLAyA/s4Ccg7lE1a6IYT0/E+7RdSJxO1XDVkRERERERERESp+uHZRzVkpKSol3t58twiy9OJpdgMNuwe22kV/gKrWxC5cvZ1/DC3Dv3OnXbo2OxggIwDRNdkxbxvThc3D+uvOEY5wPEi+pTcMuCeUdhoiIiIiIiIiI/Asp4S5ShupeMJjmDb6lRs148gsCcLvtuN3uUhnbs38/ZmYmlsjI445ljfkfRwbcTP7eQ1g8ThzVYkplThEREZGyVlxW8GyUkpKCYRhkZGSUyngDBw48azeYGIbBzJkzyzsMERERkbOOEu4iZawgey9VwmZSt/6PAOTk5JTKuJ79BzCCgzF+Kx/zR5aoKAoXLyZ/9wEcphNLcHCpzHkuKvxlBYU//FDeYYiIiMhZYOfOnRiGQWpqaqmMd+GFF5Kenk5ERESpjCciIiIi5x4l3EXK2P49KVzQ6gccjjyg6GaupcG7fz+WKlVOeDPUwMs6g9tN7tpNOGznd/3y3PfeI/vV18s7DBERETmHOJ3OEvVzOBzExMSctzenFxEREREl3EXKXFz9G9l71MrOX5sBJpmZx0plXM+BA1hjTlwqxlatGvZGjcA0CQ4+v/8ArPDy/4h8/73yDkNERERKIDc3l/79+xMaGkpsbCxjxozxO15YWMjw4cOpVq0aISEhtG7dmpSUFKBoU0NQUBBz5szxO2fGjBmEhYWRl5dHfHw8AMnJyRiGQceOHYHfS7k8/fTTVK1alXr16gHw4Ycf0qJFC8LCwoiJieHGG2/k4MGDvrH/XFJm4sSJVKhQgXnz5tGgQQNCQ0O54oorSE9P/1vPR2FhIffccw+VK1cmMDCQiy66iJ9//tl3/NixY/Tr149KlSoRFBREQkICEyZMAIreNBg6dCixsbEEBgYSFxfHc889V6J5t27dSvv27QkMDKRhw4YsWLDA73jxlQJTp07lwgsvJDAwkAsuuIDFixf/rXWKiIiInMuUcBcpY4ZhcGBHNSIr5GIYJvv3bSyVcSNGjqTCc8+e9Hjg5Zdxwe4v6fbUFaUy37nKEhR0XpfUEREROZeMGDGCxYsXM2vWLObPn09KSgorV670HR86dCg//PADU6dOZc2aNfTu3ZsrrriCrVu3Eh4eTvfu3ZkyZYrfmJMnT6Znz54EBwfz008/AbBw4ULS09OZPn26r9+iRYvYvHkzCxYs4MsvvwTA5XLx5JNPsnr1ambOnMnOnTsZOHDgKdeQl5fHSy+9xIcffsh3331HWloaw4cP/1vPx/3338+0adOYNGkSK1eupG7dunTp0oWjR48C8Oijj7JhwwbmzJnDxo0befvtt4mOjgbgtddeY/bs2Xz66ads3ryZyZMnU6tWrb+c0+v1cu211+JwOFi+fDnvvPMODzzwwAn7jhgxgmHDhrFq1Sratm1Ljx49OHLkyN9aq4iIiMi5ylbeAYicL3bu3InD4aBq1arEVLgZj2M869c14eixg399cglYq8ZiPcXxkJsHEnLLzVhPcFNVEREROf+kp6dz+PBhGjduDMCGDRsICwujRo0aFBQUsGHDBhISEggLC+PAgQPs37+fpKQkADZv3uzbJe1yuVi7di116tQhIiKCQ4cOsWfPHpKTk4Gi3dE2m823m7ykcnJyGD9+PB999BGdOnUCYNKkSVSvXh2AtLQ0JkyYQFpaGlWrVgVg+PDhzJ07lwkTJvDMM8/Qr18/brrpJvLy8ggODiYrK4uvvvqKGTNmAFCpUiUAoqKiiPnTlYIhISG89957OBwOX9stt9zi+7p27dq89tprtGzZkpycHEJDQ0+4DpfLxTvvvEOdOnWAojcJnnjiidN6LqBot//bb7/NxIkT6dq1KwDjxo1jwYIFjB8/nhEjRpCWlkZycjItWrQA8Euop6WlkZCQwEUXXYRhGMTFxdG2bVtWrVp1ynkXLlzIpk2bmDdvnu95fuaZZ3wx/NHQoUPp1asXAG+//TZz585l/Pjx3H///ae9XhEREZFzlXa4i5SR1NRUtmzZAkDVOj1IP5KPYXjJy//nY5umybH7hlH4h0uK/8waFcXXY1aQOn39P59QREREznljx471S5recMMNvPjiiwDs2bOH5s2bs2LFCgA++OADLrnkEl/fgQMH8uSTTwJw+PBhmjdvzvfffw/Ap59+Sps2bXx977jjDh5++OHTjm/79u04nU5at27ta4uMjPSVd1m7di0ej4fExERCQ0N9H4sXL2b79u0AdOvWDbvdzuzZswGYNm0a4eHhdO7c+S/nb9y4sV+yHWDFihX06NGDmjVrEhYWRocOHYCiZPbJBAcH+5LtALGxsX5laEpq+/btuFwu2rVr52uz2+20atWKjRuLrpi84447mDp1Kk2bNuX+++9n2bJlvr4DBw4kNTWVevXqcc899zB//vwSzbtx40Zq1KjhS7YDtG3b9oR9/9hus9lo0aKFLzYRERGR84V2uIuUEbvdjtvt9j1u1XQeW9a/RH5eyD8e28zIIO+TTwm89NJT9ju2J5NqSSeu8y4iIiLnlyFDhvh2IwNMnTqVsLAwAKpXr86KFStISEgAoH///lx++eW+vhMnTiQwMBCA6OhoVqxY4Usq9+nThwsvvNDX9+2338ZmK/0/O3JycrBaraxYsQKr1f86v+Ld5g6Hg+uuu44pU6Zwww03MGXKFK6//voSxRMS4v87Wm5uLl26dKFLly5MnjyZSpUqkZaWRpcuXU55U1W73e732DAMTNMs6TJPS9euXdm1axdff/01CxYsoFOnTtx111289NJLNGvWjB07djBnzhwWLlxInz596NSpEw899NAZiUVERETkfKUd7iJlxGq1+iXcAarHbcQ0j28/XZ79+wGwVKly0j6maVKY48QR4jhpHxERETl/xMbG+srJADRs2JAaNWoAEBgYSLNmzXwJ+CpVqvjKyQDUq1ePuLg4oCih3KxZMyIiIoCiMi3F5WQAEhISTrucDECdOnWw2+0sX77c13bs2DHfFYPJycl4PB4OHjxI3bp1/T7+WB6mX79+zJ07l/Xr1/PNN9/Qr18/37HiHewej+cv49m0aRNHjhzhueee4+KLL6Z+/fp/a6f631WnTh0cDgdLly71tblcLn7++WcaNmzoa6tUqRIDBgzgo48+4pVXXuHdd9/1HQsPD+f6669n3LhxfPLJJ0yfPp3MzMxTztugQQN2797td6PXH3/88YR9/9judrtZsWIFDRo0OO21ioiIiJzLtMNdpIzYbDYKCwv92mKrHmTLBsjOzqZixYp/e2zPgQMAWGNPvnvdXejB6/YSEKqEu4iIiJz9QkNDGTRoECNGjCAqKorKlSvzyCOPYLEU7RlKTEykX79+9O/fnzFjxpCcnMyhQ4dYtGgRTZo04corrwSgffv2xMTE0K9fP+Lj4/1K1FSuXJmgoCDmzp1L9erVCQwM9L1x8Gc1a9bE4XDw+uuvc/vtt7Nu3TpfWZ2yEBISwh133MGIESOIjIykZs2avPDCC+Tl5TFo0CAARo0aRfPmzWnUqBGFhYV8+eWXvoT3//73P2JjY0lOTsZisfDZZ58RExPje1PlZDp37kxiYiIDBgzgxRdfJCsri0ceeeSEfd98800SEhJo0KABL7/8MseOHfOrey8iIiJyPtAOd5EyEh0dfVxSPSfLC8D33331j8Yu3uFurVz5pH3yjhUViw+KCPxHc4mIiIiUlRdffJGLL76YHj160LlzZy666CKaN2/uOz5hwgT69+/PsGHDqFevHj179uTnn3+mZs2avj6GYdC3b19Wr17tt7sdijZEvPbaa4wdO5aqVaty9dVXnzSWSpUqMXHiRD777DMaNmzIc889x0svvVT6iz6F5557jl69enHTTTfRrFkztm3bxrx583y/YzocDh566CGaNGlC+/btsVqtTJ06FYCwsDBeeOEFWrRoQcuWLdm5cydffPGF7w2Mk7FYLMyYMYP8/HxatWrFrbfeytNPP33S+J577jmSkpL4/vvvmT17NtHR0aX7JIiIiIic5QzzTBUQFDnLZGVlERERQWZmJuHh4WU+vzcri/yvvsazbx+e9HQ8+/axp3EaP0X9B7u9gJtv/r+/PbZz1SoKvvmW8GH3nbSPq9DNgU2HqFQ3igCVlRERETkvFBQUsGPHDuLj430110WKeTweVq1aRXJy8nF18E/Hzp07iY+PZ9WqVTRt2rT0AhQREREpgbPtd16VlBEpI/kHjzJvXCqRniwiwrxUrBRNFWcsgYH5FBQEk/nTT0S0avW3xnYkJ+P4Q63UE7EH2KieFPu3xv832bxoO26nh0ZdE8s7FBERERERERER+ZdRwl2kjLy58Bcq9apKwY8N2JxlhaNgz7MR0XgLBQXBHFi5AmvTmgTbK2ExTm+HUeFPP2GJiMBer95J+6z7chOOUAeJHWv/06Wc047uysBV4CrvMEREREQIDQ096bE5c+Zw8cUXn/EY5syZQ8eOHU94LC4ujvXr15/xGERERET+TZRwFykDpmlSO/tnssOq0rfZYxR2HssRM4ncw3lsyv8FqMKWtAKsB/rgCHNxIKcttSLvJjo4vkTjZ44ajb1JYyq+8PxJ+2ycv42YhpXP+4R721ua/3UnERERkTKQmpp60mPVqlUrkxjat29Pnz59TlhSxm63l2iMWrVqoUqlIiIiIkWUcBcpA97CQnKCK+M2AnAW2gmcdgXV2vwXOj3NtkVObDYne7dEUf3bJIKaLye5wXe4vN+xcn81IgL/S50KHU85vufAAQJjLjv5cZeHjD2ZNFQZFREREZGzRt26dcs7BEJCQqhbt+4/quEuIiIiIr879S3pRaRUWAMDcQZGYxoWzNy9ZFXuA7+8DXt+JMCw4XYHUDFvNxuXdiIudAaHX7yYrdO82A4eJNQ4esqxTZcL76FDWKtUOWmfzPRsvB6TyJoVSnll5x5vfj7evLzyDkNERERERERERP6FlHAXKSPhYSEA7HPWIWDfF6TXfRniL6FSeC0AzEFODMcufpqTRpUHXqZBmxnU3X4/VSKuPeUlut5Dh8E0scbEnLTP0V0ZAFSsGVFq6zlXZfz3Po7ecmt5hyEiIiIiIiIiIv9CSriLlJHoqIpYg8O5zfEY2QXRVFw3gt3Tp9E4ojrBRiaZR6rR9akZRNZ+mynThpEZ4SD4mkQO5s3m3m/vZn/u/hOO683LxZaYiLVa1ZPOHRETRnLvCwgMCzhTyztnhNx6K2H/d3d5hyEiIiIiIiIiIv9CSriLlJGgwEDCA6xUiK7Mm/XfpbAglKgVgziwait1spYDsOOndtS5eDPXXr2YRenXs2bjXQTveZJMZyYT179/wnHtdetS5dtF2OvXP+nclRKiaPWfpmdiWeecgBbNCWjbtrzDEBERERERERGRfyEl3EXKiGmaHMvIpEa4hbl7DI5c8zkep53wDU/TIO87ANJXhhMUtBDP0SvoVbeAegk55FczuCiqNcv2LWXd4bXHj+v1/uXcO35II+dwbqmvSURERERERERERH6nhLtIGbFarWB6yczOJSo0gCmHInD0+RzcUMFzCKvHzaGAACCMnSv6M/X2gVjzHUTYvczeO4fooEqMW/suHtPjN27W8y9woPNlJ53XVeBm/vPfsXf1iUvSiIiIiJxLOnbsyL333lveYYiIiIiInJAS7iJlJDAwEICMnHz6tK7JnNX7yEhshdFkKADR2UcpCAwkPzeXBpfXJbRSHbKORmA3TLpn1eZw/iEOZBxg26/bObT9CAe3HsY0TTzp+7GEhJ503ozdmWBCZM0KZbFMERERERERERGR85YS7iJlpDjhHmB4aVE7ipAAK1OW7SSw/VUABG0pBGD7L79gsVroeE9b8jKCcLvtNP8qiP9r9l+it8aSct9PTL9vDjOGz2X/xkN4DxzAGhNz0nmPpmWAARVqRJzxNYqIiIiIiIiIiJzPlHAXKSPFCXeHxcvh7EJ6t4pj5oo9ZHmL2vPyDcKzc9i6dy8AEVXDiYhpgyfbTmjuATrV7Mygawey+sofWHXt99hDbexZtQ/P/v1YqlQ56bxH0zIIrxKKPdB25hcpIiIiUopyc3Pp378/oaGhxMbGMmbMGL/jtWrV4sknn6Rv376EhIRQrVo13nzzzXKKVkRERERECXeRMhMUFARAt2ZxJMSE0adNTQwM5qemAVApYhtZEeEcyskhJycHgLAqMQRUcBO69ju8ubkk102medtk9kXsZnPiWqyRFjwHDmCNPfkOd0eQnerJVc/8AkVERERK2YgRI1i8eDGzZs1i/vz5pKSksHLlSr8+L774IklJSaxatYoHH3yQ//u//2PBggXlFLGIiIiInO+05VWkjBTvcG9/QXViKxQl33u2qM6sFb/QG6jo2ofFY2DaYPv27SQlJQHpYHdhCfPg/OFHAjt34j8Nb2LJ3sVsTEoloGVfKs+fixESctJ5m9/QpAxWJyIiIuea9PR00tPTT9mnZs2aREdHc/jwYdLS0mjWrBkAmzdvJjc395TnXnDBBTgcDn799Vc8Hg8JCQmnFV9OTg7jx4/no48+olOnTgBMmjSJ6tWr+/Vr164dDz74IACJiYksXbqUl19+mcsuO/lN5UVEREREzhQl3EXKiMPhAGDNtj38vM/DVc2rc2PbWsz9cR0AYeYRzGMmAUG5bNu27beEexiGAUZlGwVLlhDYuRMB1gCuS+zDu6vfYdv6HVRP6EBEVPgJ5/S4PLgLPQSEOspqmWe9w78exevxUjkhurxDERERKVdjx47l8ccfP2WfcePGceuttzJz5kwGDx6MaZoADBw4kB9//PGU5+7evZvq1avzwAMPkJWVxbx5804rvu3bt+N0OmndurWvLTIyknr16vn1a9u27XGPX3nlldOaS0RERESktCjhLlJGihPuu9L2MGNvDlc1r07liEA6NK0DqRAa4cWbbcPrgCNHjnD06FEiI4tudGqNgoLvvvONlVAhEYAD446ygnfp+PogLBUrHjfnwS1HmP3wfPq83p2KNSuc8TWeC1Z9vg5nrosrH+9U3qGIiIiUqyFDhnDVVVedsk/NmjUB6Nmzp293O8DEiRP/cod75cqVAXj++efxeDz/MFoRERERkXODEu4iZcRqtQIQaDM5luskO99FWJCdSxvXwFwFlqhgrDvd2KxOzIrhbNu2jVatihLulmgLzmVbi+q1V6lCbEgsGOCoksv+NUBAwAnnPJqWgcVqEB4bVlbLPOtdfEdr3+48ERGR81lsbCyxsbEl6hsdHU109O9Xh/15l/mp1K5d+7RjA6hTpw52u53ly5f7Ev/Hjh1jy5YtdOjQwdfvzzvtf/zxRxo0aPC35hQRERER+ad001SRMmIYBoZhYDeKkr27j+YBEGS3kkcgrmrNqLJxK7YfTeLsdrZv345pVgDAEln0Ui38fikA4QHh2AwbjgoZZAfHUFBonHDOo7syiKgajtVuPcOrO3cEhgUQFB5Y3mGIiIjIXwgNDWXQoEGMGDGCb775hnXr1jFw4EAsFv8/YZYuXcoLL7zAli1bePPNN/nss8/4v//7v3KKWkRERETOd0q4i5Qhi8WCFS8Auw4XXYbtsFnIJwgzMpoqzjQyw6oRfSiL7OxsDhyIAsDeuCO2OnUo+G4JAG6vG6vFSlb4LgD2rtl/wvmOpWWolIyIiIics1588UUuvvhievToQefOnbnoooto3ry5X59hw4bxyy+/kJyczFNPPcX//vc/unTpUk4Ri4iIiMj5TiVlRMqQzWbDarXQNakqFUOKarrbrRbsuDAPr6V6g6qsalrA3tgEQtyH2bbtEDExEHrDVXi2ppI3cyamaWKaJoWeQtIdh2lu2X/SEimZ6dlUS4opyyWe9bKefwFvTg4VnnyivEMRERGRvxAaGsqHH37Ihx9+6GsbMWKEX5/w8HA+/fTTsg5NREREROSElHAXKUNRUVEEBQXxWKfGvjaHzUIQBbiydxHe7irs+wo4bD1MQss6bNmyhQsvtGJm/Yi1eh28+w/g3roVW0ICAO7YaC67pT5BHU9cG7Xfe9fgcXnLZG3nCmvVqhh5eeUdhoiIiIiIiIiI/AuppIxIGXI4HDidTnIL3Ww/kF3UZrPgxYrhKSTgwgsJO3iAfHcu8TGxFBQUsGdPVdxpP5I/6wtwOChc8n1RPXgMXJFhBPXoTvaBHApzCo+bz2K1YA/U+2p/FHLTfwgbclt5hyEiIiIiIiIiIv9CSriLlKFjx46xf/9+Zv6yh1vfW45pmjhsVjxYwFOIrUF9Kh1KgxDI+mkHFSpUYMeOeKwRNjzp6ThatKBwSVEdd4thoeDoQfJ37uHj22ex/ftdfnNtmLeVrx5bVB7LFBERESkTO3fu5N577y3vMEREREREfJRwFylDVqsVr9dLzehg8p0eDmUX4rBa8GDF8DgxLBaqRoeBafLr6t1UqFCBvLwQjBADT3o6ARe1o/CHHzFdLkJtIXh37YZN66icEHXcjVMPbjlMQfbxu95FRERERERERETkzFDCXaQM2Wy2ooR7VAgAaYdzcdgs7KcSLlsYADHJTanx4ToObXFjs9lwuRwYQYDHg71hA8ycHJypqTQMiCMkz4M1JoZqSTHsW3MA0/v7zVOP7cogMq5COaxSRERERERERETk/KSEu0gZstvtmKZJtYpBWC0GaUfysFkNtlEbp70CAEEXXkiVoxvJddoxneByBYM1GGutWlirVcOoEEHhd0uw5bspcFiwVqlCtaRYCrILObLzGACm1+To7kwia1Yov8WKiIiIiIiIiIicZ3Q3RZEy5HA4ALAYEBcdQla+C8MwsBtebIVFyXJbg/oca1MLo0YBeYfycdmDsQQGEbO0qHZ7wIXtKFzyPavjwVMlAEulSlSJNgiNDibnUC7RtSPJPpiDu8BNRe1wFxERERERERERKTPa4S5ShmrUqAGAy+Vi8p0XMrB9bQDqGdsIyd8NgGGxYKtRHUukm+x9ubhcAEcBME2TwPYX41y5EisWPAE2DJsNq93Kje9dQ63WReMHVQii62OXUiUxuszXKCIiIiIiIiIicr5Swl2kDIWGhgLgdDoxDMPX7saOxfT4HkdWrow3yELOgRycToCjHL6+L5kPPUzAxRcV1XO3OvAE2H3nGIaBM8+J1+PFHmijZrOqBIQ6ymppIiIiIuUqJSUFwzDIyMgo71BERERE5DymhLtIGcrNzfV9Ttl4gCtf/BaX24vbcGD8IeFeKTkZANMGHo8Vr9eDERKEe+9ebLVqYa1ZE1tuAZ4/nJOxJ5OJ/T5j/6ZDrJ+zha2Ld5Tt4s4Rptf0u7msiIiIiIiIiIhIaVHCXaQMud1uAPLz8wkLtHEkx8m+jHzclgDA6+sX3bIFhteLw14IgMtlxxofg2fPXgACLr4I65EMvF4vplmUPI6oGo4jxM7e1fvZMHcL+zccLNvFnSMWvrSErx//przDEBERERERERGRfyEl3EXKUGBgIFCUcK8ZFQLArsO5FBpBGJjwW/LcZrfTas4cInfuAooS7rZa0Xj27Cmq437xxVz0/REwwOl1AmBYDKo1jmHPyn1k7MmiYs0KZb/Ac0DDKxJpcnWD8g5DRERE/kLHjh25++67uffee6lYsSJVqlRh3Lhx5ObmcvPNNxMWFkbdunWZM2fOScf4/vvvufjiiwkKCqJGjRrcc889visORURERETOBCXcRcpQUFAQAIWFhUSHBRDksLL7SC4/B1+GAeBx+fpWCwsnZvdaAJxOB7YaFTHz8jAzMrDG1yIiq2i3fKG74PdzmsRwcOsRvG4vkXEVympZ55RqTWKo0axqeYchIiIiJTBp0iSio6P56aefuPvuu7njjjvo3bs3F154IStXruTyyy/npptuIi8v77hzt2/fzhVXXEGvXr1Ys2YNn3zyCd9//z1Dhw4th5WIiIiIyPlCCXeRMhQQEABAQUEBhmFQIyqYXYdz8dqKEvG4fv9jMa97dw42qV3U7LLjaFmPyt8txggPx7VxI9tqBwOQ/8eEe1KM7+uKNSPO9HJEREREzqikpCRGjhxJQkICDz30EIGBgURHRzN48GASEhIYNWoUR44cYc2aNced++yzz9KvXz/uvfdeEhISuPDCC3nttdf44IMPKCgoOMFsIiIiIiL/nK28AxA5nwQHB2O1Wn2PH+15ARHBDta+V7STHVceBFUAwN2yBelZmUXNLjumNR9rdBSG1YonbTeZFewAFHp+/4MxPDaMHk9fRtqKvQSFB5bNos4x+V98iVlYSPB1vco7FBERkXKVnp7O4cOHady48Wmfm5OTw5YtW2jQoIHvCr4zoUmTJr6vrVYrUVFRfvFWqVIFgIMHDxIeHu537urVq1mzZg2TJ0/2tZmmidfrZceOHTRooBJzIiIiIlL6tMNdpAwFBQURGhqKYRgAJMSEUzk8ELvx2w1T/7DDPTIqyve1y2Vnz7PPc6hXb/LnziXk1kEEFBadk+/O9/UzDIOqF1ShzYBmZbCac1PhsmUUpKSUdxgiIiLlbuzYsXTt2vVvnbt27VqaN2/Or7/+WspR+bPb7X6PDcPwayv+ncrr9fJnOTk5DBkyhNTUVN/H6tWr2bp1K3Xq1DmjcYuIiIjI+Us73EXKUPEfg8V1Rn89mMNHS3dwoeX4kjLh4eFYPB68Visulx1P7To45qzCufwnAi+/nICCorEKPIVlu4hzXIVnnynvEERERM4KQ4YMoVevv3fFV+PGjVmxYgW1a9cu5ahKT7NmzdiwYQN169Yt71BERERE5DyiHe4iZcg0TTIzM8nMLCoVU+Dy8HXqPgr4LeFemOXra7FYiAgMBNOL0+mgMMyBNb4O7j17MSwWAj1FO7r+eNNUERERkZKKjY39W+VkAEJDQ2nWrNkZLSfzTz3wwAMsW7aMoUOHkpqaytatW5k1a5ZumioiIiIiZ5QS7iJlyGIpesm5XC4AakYV3fg0x5dwz/Tr37htW2yWopIyVkc2x6IS8OzbC0D9XW4A8j35iIiIiIi/Jk2asHjxYrZs2cLFF19McnIyo0aNomrVquUdmoiIiIj8i6mkjEgZMgwDi8WC212ULA8NtBMZ6mC98dsNwbxuv/7169dn1YpluFx2KlTIYIdZjfA9swBIOFh089VCt0rKiIiIyL9PygnuubJz587j2kzTPOHXAC1btmT+/PmlHZqIiIiIyElph7tIGftjwh2gZlQIad7KRQ88Tr++GRkZGNZACo8GE+TNYE9WGKF33YVpmmRHB2PzGuS58xAREREREREREZHyp4S7SBkLCAjA4/H4Hl/Tojr1K/yWaM895Nd33bp15OUV4DaiCDGOkJ/jJvfiqzAMg19rBeK2mGQ7sxAREREREREREZHyp4S7SBlr0qSJ3+XOXZpUpVHEbzc+zTng19dutwMmLsNLYFWDQKOQLZO/w71nDw5rAAB5Lu1wFxERERERERERORso4S5SxhwOB263G6/XC0B2vou92b/teHdm+/W12WyYponL5cQaE0SVA6vY8ct+ChZ/50u457t101QREREREREREZGzgRLuImVs48aNADidRWVktuzP5vvtv5WFceb49f094W7HCDKpmr+VgoAKHNp8CIfNAWiHu4iIiIiIiIiIyNlCCXeRMlZcTqY44e6wWXBSlDzHmevXNygoCJvNXpRwtxRQ/YrmOFw57PzVSbA1iAAXuLyuMo3/XLfikzUsn7SqvMMQEREREREREZF/ISXcRcqYw1GUXC9OuNutFrIJIdsMxjQMv76JiYk0atQIp9MBeAgbcD0xGevZkxlCNU8EDfYZWAy9jE+HPdCOPchW3mGIiIiIiIiIiMi/kLJOImWs6EaovyfcA2wWMqhAGtWpZws+7kVpt9txuYKKvm5QjWrW/aRZWpNpVMBR4CHfoxrup6PJ1Q3KOwQREREREREREfmX0tZYkTL25x3uQQ4rMeEOTAzM/Ay/vvv27WPVqlU4nVaKKtHkUPvu67G789iWEcgvdQ2O5B8p2wWIiIiIiIiIiIjICSnhLlLGkpKSgN8T7jEVghhxRW0uMDbDse1+fQ3DwOUqqtHu8ViBHEKu6k5M3jb2Hw7GazEo9DjLNP5znWv7r7i2bCnvMERERERERERE5F9ICXeRMlaxYkWsVqsv4Q5gcxSVjMHlXx7GZvu9wIzLZQeycaelEXNgJXmEk7z4QoJ3hWF6zbII/V8h+8UXyXxsdHmHISIiIn9Tx44duffee8/4PDt37sQwDFJTU8/4XKdr9OjRNG3atLzDEBEREZETUA13kTK2b98+DMPwJdxzC92MmLqaFNMAT6Ff3z8n3IOCsrHGXkDlzM003DeHnIgLqfp1HB99PY7acV7qX9GAipe0whIUVKZrOpdEjBqF6fWUdxgiIiIiIiIiIvIvpIS7SBk7evQobrfbl3C3Wy043V48WMDtn3AvvsEqgNPpALKxhIVhiYigQVIw/+vyFRFHK9F3USM27ohm3Tu7iH7pW6oHHKZClJ0K1cMJrhWLrVp1rNWrYa1RA2t0dFku96xjrRpb3iGIiIiIiIiIiMi/lErKiJSx4l3rhYVFyXW71QDAixX+VI89KCiISy65BACXKxDIAcBatSrk5NJ17gGOVjlM50+G0X9qPy7qXRsjrg6rHa1JyW7OzI0JTPsCvvrfCr658z1+7HwH69v34uCwh8ibNRvPEd1wVURERM5eubm59O/fn9DQUGJjYxkzZozf8cLCQoYPH061atUICQmhdevWpKSkAJCVlUVQUBBz5szxO2fGjBmEhYWRl5d32vEsXryYVq1aERAQQGxsLA8++CBut9t3/PPPP6dx48YEBQURFRVF586dyc3NBSAlJYVWrVoREhJChQoVaNeuHbt27SrRvM899xxVqlQhLCyMQYMGUVBQ4Hd84MCB9OzZk8cff5xKlSoRHh7O7bff7lfCUERERETKhna4i5SxPyfcDcPAZjGY6r2aG6zL/fparVaqVq0K+CfcbdWr4TlwkJjcojEK3YUEhwTT6KaLaHTTRXhcHjL2ZnFsd2bRx/ZDHEvLYPfhArxeYBsEr99J2JgfqBDiJrpeFSpcUAtbaBDWkCCswYHYQoOxhgRhCw3BajUxnS5wFmK6XJiFTnC5wGJgia6EtUpljNBQDMM4br1mQQHu3btx79iJZ9cuPEeOYKkQgaVixeM+8HjwZmbizcjEzMoq+jozE7OwEFtcTWy1a2OLi8MIDDzhc2uaJt7Dh/Gk7cZz8ABGSCiWihWwVCj6OFmM8jszPx9vVhbWKlXKOxQRERFGjBjB4sWLmTVrFpUrV+bhhx9m5cqVvvrlQ4cOZcOGDUydOpWqVasyY8YMrrjiCtauXUtCQgLdu3dnypQpdO3a1Tfm5MmT6dmzJ8HBwacVy969e+nWrRsDBw7kgw8+YNOmTQwePJjAwEBGjx5Neno6ffv25YUXXuCaa64hOzubJUuWYJombrebnj17MnjwYD7++GOcTic//fRTiX4v+fTTTxk9ejRvvvkmF110ER9++CGvvfYatWvX9uu3aNEiAgMDSUlJYefOndx8881ERUXx9NNPn9Y6RUREROSfUcJdpIwVJ9z/uDPJbrNQ4AzC8BQc13/16tUAuFwxQDYAFca8hGv1GlZ980jRWJ4Cgu2//9FotVuJqlWRqFoV/cYqTsQf2XGMw+v3cGhdNDsPFLJ5hx12FAAFwLHjYrB6nAS4c3C4cghw5RDgLvps9+Rh8XqwmG4sNgu28BCs4WHYwkNx5B0hYPcWrPt2Ypi/3dQ1MABrVDTerCzM7OwSPV+m3Y7XEYQ1N6uowTCwVq+OrXY8ttq1wTRxp+3Gs2cPnt27MfPzTz6Y1YolIgIjLBQjKKgocR8QSFZAZQ4ZVTjqrYDVYmK3eAiwebBbvDhsXhxWDw6rB5vXhdV0YzOd2LxOLF4Xhuf3XW388Y/mU/0BbZqYTidmQQFmfn7R59++xgRLVBTW6GgslaJ/+1wJS3T0Sd9owDTB7cZ0OcHlLnpTxOkEtxsjOBhrpUpYqlQu+ly5MpaQEAA8R4/hWr/e78O9bTuBl3Umavx7Jfr3ERGRc1d6ejqHDx+mcePGbN26FavVSu3atUlNTSU2Npbw8HA2btxIYmIiBQUFpKWl0axZM3bt2kVBQQH16tVjw4YNhIeHExsby+rVq4mPj8dqtbJt2zYuuOACjhw54psjJyeH0NDQEseXk5PD+PHj+eijj+jUqRMAkyZNonr16gCkpaUxYcIE0tLSfBsUhg8fzty5c5kwYQLPPPMM/fr146abbiIvL4/g4GCysrL46quvmDFjxmk/X2+99RY1atTgjTfewDAM6tevz759+3jggQcYNWoU6enpuN1urr32WuLi4gBo3LgxUFRSMDMzk+7du1OnTh0AGjRoUKJ5X3nlFQYNGsSgQYMAeOqpp1i4cOFxu9wdDgfvv/8+wcHBNGrUiCeeeIIRI0bw5JNPYrHowmYRERGRsqKEu0gZCw8Pp0KFCrhcLl/bi32TCZl0B1ZnxnH9N2/eDIDLFUJxwt0aFYUnIoId8UWJ0wL3KZLMf/DHRHziJUW7okzTJPdoHjl7j+HJzceTW4A7rwBPfgGevAI8eU4KnVBQWJmCfMjP85KX5+FIjpvCPBdet7do1/wf/ZYbJ7Yj1uoQEmEnLCaMsKoVCY4MxmIzipLwzgIoLICCfCjIx+UyyHfbyC+A/Fwvedku8jML8bq92INshIRaCLa5CPZkEZhziIDlaQRQSEDlSAJbJBDYswoBtaoSGB+HrWpM0W7tjAy8xzLwZmRgZmTgOXqMzCOF7D9i5WBmAAfzgnHm2bHgoaKRASa4CMSJA6fpwGtYT/GMmtjwYDW8WPFgMbxY8GLFi/W3rw3DxIIXC799NkwMvNQIPkJMbCFGYGDRR/EbAID3yBE8hw7j2bsXV+pqPEeOYGZmlujfGMOAAAeGzQ42G2ZeHvzpcnIjOBgjJATvoUNFj4OCsDdsSEDr1oQOGoQjOblkc4mIyDlt7NixvPfee+zZs4ehQ4cSHh7OZ599Rvv27Rk9ejRdunShefPmLFu2jPXr1zN48GBM0+TJJ59k/fr1/PDDD/Tu3ZsuXbowevRomjdvzqeffkp4eDhXXHEFu3fv5r333vPNsXbtWtq2bVvi+LZv347T6aR169a+tsjISOrVqwfA2rVr8Xg8JCYm+p1XWFhIVFQUAN26dcNutzN79mxuuOEGpk2bRnh4OJ07dz7t52vjxo20bdvWb1d6u3btyMnJYc+ePSQlJdGpUycaN25Mly5duPzyy7nuuuuoWLEikZGRDBw4kC5dunDZZZfRuXNn+vTpQ2zsX99bZuPGjdx+++1+bW3btuXbb7/1a0tKSvLbtd+2bVtycnLYvXu37w0AERERETnzlHAXKWORkZHUqFGDtLQ0X1tCTBgFZGDxuo7rb7PZ8HhcOJ0ZFL9knatXk/HYaGw9ijLdBe7jd8aXlGEYhEaFEBoV8rfHML0mXo8Xj8uLx+3B4/SQn1FA9qFccg7lknMwl5zDuRzZeYzdq9IxvV68XhPTYxad6zUxPV4cwQ6CI+0EVwwiMjaI6hWDCIkMwh5sJ+9oPjmH88g5lMuxQxXIyY+iMPi3S6lzgC2/fXAMOIYtwOqLzTR/++w1gEgALFaDyonRXNA4hmpNqlC5XiVsjuOT6+5CN4U5Tpy5TlyFblz5blwFblz5LlwFbtwFLtxOLx6nB4+raO3u3z57XB687qLnxuv24nF7cf32teOqBkS2r1Xy57iwqJzP7w2m33HDbge7HcPqvwbTNDEzM/EcOoT34CE8hw7iPXgIb3Y2trp1sDdqhC0+/rjzRETk32/IkCH06tULgDfeeAPrb/8XfPfdd74d7itWrCAxMZGEhASaNWsGwKOPPurbXf3ZZ58RHh5OSEgIK1as8O1wX7FiBZUrV/abo3i3d2nJycnxzWX90/9jxTvpHQ4H1113HVOmTOGGG25gypQpXH/99b4rDkuT1WplwYIFLFu2jPnz5/P666/zyCOPsHz5cuLj45kwYQL33HMPc+fO5ZNPPmHkyJEsWLCANm3alHosIiIiIlJ+lHAXKWNutxu32+2r4Q4weelOrsKOgQkeF1jtvmM2mw2Xy6Qo15rz2yAeXKtW4eiSAECBp5DyZFgMrBYrVrsVKIo9NDqESnWjzui8rnwXBdmFOPNcuPJdv31248xz4ipwYxgGhlEUn2EYGNaiz8FRwcQ2qIQ9yP6Xc9gCbNgCbIREnV6d19JmBARgBASc/nmGgfFbDXsSEko/MBEROWfFxsb6dlgn/OH/iOL66IAvyR4aGkp0dDSA327phg0bHtf3j1//cY7TKScDUKdOHex2O8uXL6dmzZoAHDt2jC1bttChQweSk5PxeDwcPHiQiy+++KTj9OvXj8suu4z169fzzTff8NRTT51WHMUaNGjAtGnTME3Tt8t96dKlhIWF+crcGIZBu3btaNeuHaNGjSIuLo4ZM2Zw3333AZCcnExycjIPPfQQbdu2ZcqUKX+ZcG/QoAHLly+nf//+vrYff/zxuH6rV68mPz+foKAgX5/Q0FBq1Kjxt9YrIiIiIn+PEu4iZSwnJ4eNGzf61dL8bvNBrvgtUY0rD6wRvmM2mw2LxcDlslGccDciwgFwOIt3uJespMy/jT3IXqKkuYiIiJx7QkNDGTRoECNGjCAqKorKlSvzyCOP+H6HSkxMpF+/fvTv358xY8aQnJzMoUOHWLRoEU2aNOHKK68EoH379sTExNCvXz/i4+P9StScjjvvvJNXXnmFu+++m6FDh7J582Yee+wx7rvvPiwWC8uXL2fRokVcfvnlVK5cmeXLl3Po0CEaNGjAjh07ePfdd7nqqquoWrUqmzdvZuvWrX5J9JP5v//7PwYOHEiLFi1o164dkydPZv369cfdNNXpdDJo0CBGjhzJzp07eeyxxxg6dKjqt4uIiIiUMSXcRcpY8SXMXq8Xr9eLxWLBYbPg+mPCPfD3hHvdunXZtOkXXC4rxTXci2t9N1uZya91Qig4wc1W5cR2Lt+N1+2ldjvVMhURETnbvfjii+Tk5NCjRw/CwsIYNmwYmX+4r8mECRN46qmnGDZsGHv37iU6Opo2bdrQvXt3Xx/DMOjbty8vvPACo0aN+tuxVKtWja+//poRI0aQlJREZGSkL8ENRffp+e6773jllVfIysoiLi6OMWPG0LVrVw4cOMCmTZuYNGkSR44cITY2lrvuuoshQ4b85bzXX38927dv5/7776egoIBevXpxxx13MG/ePL9+nTp1IiEhgfbt21NYWEjfvn0ZPXr0316viIiIiPw9hmn+qRCwyL9UVlYWERERZGZmEh4eXm5xFBQU8MEHHwDQv39/AgMDuXXcjzTdO56hvAf3bIPIOn7nfPHFBEJCNnDppcuApXgOH2Z/UjJuq8HdrzXm3mb3cWnNTuWwmnPPt68uw5nnostDHco7FBERkTOuoKCAHTt2EB8fT+Bvb9jLv8/AgQPJyMhg5syZp3Wex+Nh1apVJCcnH1cHX0RERORccbb9zqvrC0XKmN3+ewmU4jrudpuFtcZvNxJz+ZeHyc7OBiJwOmsDhYAbS1gYEU8+wZHoACwm2uF+Gi75vwuVbBcRERERERERkTNCCXeRMmaxWHxJd6fTCUCXxrEkWHYVdXDl+fVfvnw5GRm5uFzFNxrLwQgIIPSWm5nfNQaAQrcS7iIiIiKn45lnniE0NPSEH127di2zOBo1anTSOCZPnlxmcYiIiIhI6VANd5EyZhgGvXr1YurUqb6Ee88WNVg6byV4OC7hXpSc9+By5fzWkg1UIG/WLOweAwODfCXcRURERE7L7bffTp8+fU54LCgoqMzi+Prrr3G5XCc8VqVKlRKNMXHixFKMSERERET+CSXcRcqBw+EAft/hvvNQDoUEFB38U8LdZrNhml5cvvaiG6dmPPgw9m6RYEKhSsqU2LF7/4s3K4uo98eXdygiIiJSjiIjI4mMjCzvMIiL043cRURERP5NlHAXKQfffPMN8HvC/f3Fv9LMXZSEP1HC3esFp/O34xTtdDcCA7F7i1pUw73kAq+8En573kVEREREREREREqTEu4i5SA3NxfDMHwJ9wCbhQJ+u4uy2/+mqQEBAVgsFlyu4putFu1wNwIDCS0AmwkFKilTYkGXdS7vEERERERERERE5F9KN00VKQc2mw2LxeJLuNttFnYacXgxjtvh3rRpU1q1aoTbbcc04Y8J984/FZB4LEgJdxERERERERERkbOAEu4i5eDPCXeH1cI8SxecluDjEu4AdnsoAC5XGMUlZRxJTTBCQwhweVVSRkRERERERERE5CyghLtIOfhzwj0i2E6g1YML+3EJ9127dvHDDysAcLkiKd7hXvGVl1nVoQZrKhWQ7/IvQyMiIiIiIiIiIiJlTwl3kXLQvHlzIiIifAn3mzvU4Y6KKYR6M45LuHs8HvLyitpcrlCKd7ibponHYcNpg3yPEu4iIiJyfujYsSP33nvvGZ9n586dGIZBamrqGZ/rTDAMg5kzZ5Z3GCIiIiLnHSXcRcpB5cqVCQ0N9SXcAbAGYAA4/RPudrvd97XT6aV4h/vRwbdhbNoGQKFquIuIiIiIiIiIiJQ7JdxFysGePXvIzc31JdxnrdjDhv2/Jc2d2X59bTab72uXKwDfTVMDArC7TQDVcBcRERERERERETkLKOEuUg52795NRkaGL+HudHvI9liLDjpz/Poen3AvOm4EBmJzeQEo0A53ERER+RfKzc2lf//+hIaGEhsby5gxY/yOFxYWMnz4cKpVq0ZISAitW7cmJSUFgKysLIKCgpgzZ47fOTNmzCAsLMxXsu90LF68mFatWhEQEEBsbCwPPvggbrfbd/zzzz+ncePGBAUFERUVRefOncnNzQUgJSWFVq1aERISQoUKFWjXrh27du36yzlHjx5N06ZNef/996lZsyahoaHceeedeDweXnjhBWJiYqhcuTJPP/30KcfZvXs3ffr0oUKFCkRGRnL11Vezc+fO034OREREROTUlHAXKQc2mw3TNH0Jd7vVgtP8rXTMnxLuERERdO7cGQCXy8YfE+419znptDSbQk8hpmmWWfznsuxDuWQdyPnrjiIiIlLuRowYweLFi5k1axbz588nJSWFlStX+o4PHTqUH374galTp7JmzRp69+7NFVdcwdatWwkPD6d79+5MmTLFb8zJkyfTs2dPgoODTyuWvXv30q1bN1q2bMnq1at5++23GT9+PE899RQA6enp9O3bl1tuuYWNGzeSkpLCtddei2mauN1uevbsSYcOHVizZg0//PADt912G4ZhlGju7du3M2fOHObOncvHH3/M+PHjufLKK9mzZw+LFy/m+eefZ+TIkSxfvvyE57tcLrp06UJYWBhLlixh6dKlhIaGcuWVV+JyuU7reRARERGRU7P9dRcRKW02mw2v14vH4wHAYbOwnOb8bG1NS6/Hr6/D4SA+Ph7D8OJy2fGVlAkMJCTXTc20XMx2Ybi8LhxWR1kv5Zzz44QVOHNdXPl4p/IORUREpFylp6dz+PBhGjduzNatW7FardSuXZvU1FRiY2MJDw9n48aNJCYmUlBQQFpaGs2aNWPXrl0UFBRQr149NmzYQHh4OLGxsaxevZr4+HisVivbtm3jggsu4MiRI745cnJyCA0NLXF8OTk5jB8/no8++ohOnYr+3540aRLVq1cHIC0tjQkTJpCWlkbVqlUBGD58OHPnzmXChAk888wz9OvXj5tuuom8vDyCg4PJysriq6++YsaMGaf9fL311lvUqFGDN954A8MwqF+/Pvv27eOBBx5g1KhRpKen43a7ufbaa4mLiwOgcePGABw9epTMzEy6d+9OnTp1AGjQoEGJ5/Z6vbz//vuEhYXRsGFDLrnkEjZv3szXX3+NxWKhXr16PP/883z77be0bt36uPM/+eQTvF4v7733ni/JP2HCBCpUqMCKFSto1arVaT8fIiIiInJi2uEuUg7sdrsv4e7xeLDbLDhxkE0o/Kkeu8fjYdWqVdhsATidDSlOuIfedRfmHQNZVT8IUB33kmr1n6ZcOLhFeYchIiJS7saOHUvXrl2Bop3iDzzwAADt27dn8uTJ/PrrrzRv3py1a9cyc+ZMmjdvDsCTTz7JwIEDAejduzf/+9//yM3NpXnz5ixcuJAffviB5s2bc/DgQb851q5de1rxbd++HafT6ZdAjoyMpF69er7xPB4PiYmJhIaG+j4WL17M9u3bAejWrRt2u53Zs2cDMG3aNMLDw31XD56OjRs30rZtW79d6e3atSMnJ4c9e/aQlJREp06daNy4Mb1792bcuHEcO3bMF/fAgQPp0qULPXr04NVXXyU9Pb3Ec9eqVYuwsDDf4ypVqtCwYUMsFotf28GDB094/urVq9m2bRthYWG+5ykyMpKCggL27Nlzuk+FiIiIiJyCdriLlIMKFSpQpUoV0tPTcTqdNK8Vyc2N3DTasBbyY/36mqbJL7/8QkBAAC6XFcgFPFgjK+KsXJHU2AgACt0F4Agv+8WcYyKq6jkSEREBGDJkCL169QLgjTfewGotup/Md99959vhvmLFChITE0lISKBZs2YAPProoxQUFL3R/9lnnxEeHk5ISAgrVqzw7XBfsWIFlStX9pujeLd3acnJyfHNVRx7seKd9A6Hg+uuu44pU6Zwww03MGXKFK6//nq/e+SUFqvVyoIFC1i2bBnz58/n9ddf55FHHmH58uXEx8czYcIE7rnnHubOncsnn3zCyJEjWbBgAW3atPnLse12u99jwzBO2Ob1ek94fk5ODs2bN2fy5Ml+7R6P57QS/yIiIiLy15RwFykH1atXx2Kx8OWXX+J0OomMiKBWBFThIDjD/PparVYMw8BqLcDlOvxbay4F36Ximj4behe15OvGqSIiInIaYmNjiY0teqM/ISHB1960aVPf18VJ9tDQUKKjowF85VIAGjZseFzfP379xzlOp5wMQJ06dbDb7SxfvpyaNWsCcOzYMbZs2UKHDh1ITk7G4/Fw8OBBLr744pOO069fPy677DLWr1/PN99846u5froaNGjAtGnTME3Tt8t96dKlhIWF+crcGIZBu3btaNeuHaNGjSIuLo4ZM2Zw3333AZCcnExycjIPPfQQbdu2ZcqUKSVKuP9TzZo145NPPqFy5cqEh/+++cDj8ZCdnX3G5xcRERE5n6ikjEg5cLvdvhumOp1O9h3LY8XuXABMd75fX8MwsNlsWCwe3zmQgydtN+byFb5+hSopUyI5744j6+VXyjsMERER+QuhoaEMGjSIESNG8M0337Bu3ToGDhzoK6OSmJhIv3796N+/P9OnT2fHjh389NNPPPvss3z11Ve+cdq3b09MTAz9+vUjPj7+hDXOS+LOO+9k9+7d3H333WzatIlZs2bx2GOPcd9992GxWFi+fDnPPPMMv/zyC2lpaUyfPp1Dhw7RoEEDduzYwUMPPcQPP/zArl27mD9/Plu3bj2tOu7/RL9+/YiOjubqq69myZIl7Nixg5SUFO69914OHDhQJjGIiIiInC+0w12kHOzfv5/58+cDUFhYyJF8W1HC3QBc+cf1t9lsGIaBy1X8Hlk2RlAQdvfvlw0XaId7iZj5+ZgFeq5ERETOBS+++CI5OTn06NGDsLAwhg0bRmZmpu/4hAkTeOqppxg2bBh79+4lOjqaNm3a0L17d18fwzDo27cvL7zwAqNGjfrbsVSrVo2vv/6aESNGkJSURGRkJIMGDWLkyJEAhIeH89133/HKK6+QlZVFXFwcY8aMoWvXrhw4cIBNmzYxadIkjhw5QmxsLHfddRdDhgz5+0/OaQgODua7777jgQce4NprryU7O5tq1apx6aWXEhISUiYxiIiIiJwvDNM0zfIOQqQsZGVlERERQWZmpt+ltOVh//79vpt3de7cmcKAKO5/9wu+MG7CtAdjPJLr13/p0qUcPLiGgIAjdOs2E3iH/K8OcnjIEN4fWIMVLSryaJvHaBnTquwXIyIiImetgoICduzYQXx8PIGBgeUdjpxlPB4Pq1atIjk5+bg6+CIiIiLnirPtd16VlBEpB3+8UZfT6cRus5BNGN+Y7cDtPK5/u3btqFjR+ocd7jkYgYFYTPjPlL2AdriLiIiIiIiIiIiUNyXcRcpBccLdarXidDpxWC0UEMj3tMEw3eBx+fXPy8sDYnG5qv7WkoOtbh1ChtzGsQp2APLdx5eiEREREZETe+aZZwgNDT3hR9euXcssjkaNGp00jsmTJ5dZHCIiIiJSOlTDXaQcFCfcbTYbTqeT8CA7betEkbB9e1EHVz5Y7b7+3377Lbm5+Xg8AUAgkI0tLo6wu+7klVpLsGKh0FNY9gsREREROUfdfvvt9OnT54THgoKCyiyOr7/+GpfLdcJjVapUKbM4RERERKR0KOEuUg5CQkK49dZb+fzzz3E6nVQIcTCwQ22Sfp1Z1MGVB4G/15m3Wq2YphOnMw8IAbLx5uZS+MOP2FwmVgwKPCopIyIiIlJSkZGRREZGlncYxMXFlXcIIiIiIlKKVFJGpBwYhoHFYsHhcOB0OvF6TQ5lFeIyf3sPzJXn199utwNOXC4PEApk4z1wkGNDbsfu8mI1DQpUUkZERERERERERKRcKeEuUk5mz56Nx+PB6XTi9HgZ+fkaXMUXnfwpeW6z2fB6DbxeKx5PCMU3TQWwe8BiGhS4VVJGRERERERERESkPCnhLlJODh8+DOC7aSrwe8L9TzvcbTYbpmkUHXIVJdz5LeEe4DSxmgaFKikjIiIiIiIiIiJSrpRwFyknNpsNwzBwOp1YLAZWi8EOahUd/FPCvW3btlx8cZ2iQ65gIBtLUFHCfcR7h6juDCFfJWVERERERERERETKlRLuIuXEZrNhsVhwOp0A2K0Gj/Jg0cE/JdwtFgsBARWLDrmKargTGIitdm2MgAACXGiHewl999aPLBrzfXmHISIiIiIiIiIi/0K28g5A5Hz1xx3uAMEOGwWugKKDf0q4//rrr6xevRUAp7MykIphGFRZspg3RndlnyOXKqrhXiLVk2JxuzzlHYaIiEi5c+/di/fo0TKbzxIZia1atTM6R0pKCpdccgnHjh2jQoUKZ3QuKRtLly7l9ttvZ9OmTVx55ZXMnDmzvEP6V9i0aRMDBw4kNTWV+vXrk5qaWt4hnbaJEydy7733kpGRUd6hyG8GDhxIRkaGXqcict5Twl2knLRu3Zr09HQOHTqEaZrMvK8DW55sWHTQ5V8epqCggEOHDhUdcjmAHN+xjHAbhYaHAo9KypRE7XZx5R2CiIhIuXPv3cuBiztAYRm+YR8QQJUli0876X7zzTdTrVo1nnrqqTMUWMl07NiRxYsXn/R4hw4dTnkcwDRNDh06xKhRo/jqq684cOAAFStWJCkpiVGjRtGuXbsSx/Pss88ycuRInnvuOUaMGOF3zOPx8OKLLzJx4kR27dpFUFAQCQkJDB48mFtvvRUoSoxNmjQJKNoIUr16dXr37s0TTzxB4G/3Cjob3HfffTRt2pQ5c+YQGhpa3uGUitGjRzNz5sxyTXI/9thjhISEsHnz5n/N8/pvtHPnTuLj41m1ahVNmzYt73DKXFpaGnfccQfffvstoaGhDBgwgGeffRab7eSprKeffpqvvvqK1NRUHA7HSd+Q2bVrF/Xr1+fQoUN6DYhIqVPCXaScxMXF4XQ68Xq9eDwe7FYrXiyYgPGnHe52u933tct1DMgGTA5c2hnbJRZMM5AC7XAXERGREvIePVq2yXaAwsKieU8j4e7xePjyyy/56quvzmBgJTN9+nTflYm7d++mVatWLFy4kEaNGgHgdDpxOBy+/i1btuS2225j8ODBfuP06tULp9PJpEmTqF27NgcOHGDRokUcOXLktOJ5//33uf/++3n//fePS7g//vjjjB07ljfeeIMWLVqQlZXFL7/8wrFjx/z6denShXvvvde3w3nAgAEYhsHzzz9/WrGcSdu3b+f222+nevXqf3uMP//bnEmmaeLxeE6ZEDwbbN++nSuvvJK4uL+/GaWsntey/PeTs4fH4+HKK68kJiaGZcuWkZ6eTv/+/bHb7TzzzDMnPc/pdNK7d2/atm3L+PHjT9pv1qxZXHLJJUq2i8gZoRruIuUkLS3N92670+nkoU9ScRt2TMN6XEmZP/7C7nRaAS+Qh1noxO4GE5MC1XAvkYIl31PwzbflHYaIiIiUwLJly7Db7bRs2dL3uGnTpgQGBtKiRQtmzpyJYRin3Ck8bdo0GjVqREBAALVq1WLMmDG+Y2+88QYXXHCB73HxeO+8846vrXPnzowcOZLIyEhiYmKIiYmhUqVKAERFRfnaatas6fs6JiYGq9VKWFiYX1tGRgZLlizh+eef55JLLiEuLo5WrVrx0EMPcdVVV5X4eVm8eDH5+fk88cQTZGVlsWzZMr/js2fP5s4776R3797Ex8eTlJTEoEGDGD58uF+/gIAAoqOjqVGjBj179qRz584sWLCgxHHs2bOHvn37EhkZSUhICC1atGD58uW+42+//TZ16tTB4XBQr149PvzwQ7/zDcPgvffe45prriE4OJiEhARmz54NFO3sNQyDI0eOcMstt2AYBhMnTvStv1WrVgQEBBAbG8uDDz6I2+32jduxY0eGDh3KvffeS3R0NF26dCElJQXDMJg3bx7JyckEBQVx6aWXcvDgQebMmUODBg0IDw/nxhtvJC/v99/FvV4vzz77LPHx8QQFBZGUlMTnn3/uO1487pw5c2jevDkBAQF8//3J7xc0ceJEHn/8cVavXo1hGL51DR8+nO7du/v6vfLKKxiGwdy5c31tdevW5b333vPF9cQTT1C9enUCAgJo2rSpX99TMQyDFStW8MQTT2AYBqNHjwZg7dq1XHrppQQFBREVFcVtt91GTs7vV9YOHDiQnj178vTTT1O1alXq1at3Wq8hKEr0X3311VSpUoXQ0FBatmzJwoUL/eKrVasWTz75JP379yc8PJzbbrvN99zVrFmT4OBgrrnmmtN6k2r06NE0bdqUsWPHUqNGDYKDg+nTpw+ZmZm+Pj///DOXXXYZ0dHRRERE0KFDB1auXOk7bpomo0ePpmbNmgQEBFC1alXuuece3/G33nqLhIQEAgMDqVKlCtddd12JYvN6vbzwwgvUrVuXgIAAatasydNPPw1AfHw8AMnJyRiGQceOHX3nvf/++76fbbGxsQwdOvQv5/qrNRQWFvLAAw9Qo0YNAgICqFu3ri9p7fF4GDRokO+1UK9ePV599dW/XNupXj+nMn/+fDZs2MBHH31E06ZN6dq1K08++SRvvvmm783PE3n88cf573//S+PGjU85/qxZs07r566IyOlQwl2knGzatIk9e/YARQn3PUfzcGHH5PiEe/EOd4vFjctV/LLNxggKxO75LeHuVkmZksibPJmccePKOwwREREpgdmzZ9OjRw8MwyArK4sePXrQuHFjVq5cyZNPPskDDzxwyvNXrFhBnz59uOGGG1i7di2jR4/m0Ucf9SVuO3TowIYNG3yl+xYvXkx0dDQpKSkAuFwufvjhB78k1z8RGhpKaGgoM2fOpPAfXGEwfvx4+vbti91up2/fvsft4oyJieGbb77xrask1q1bx7Jly0q8kzgnJ4cOHTqwd+9eZs+ezerVq7n//vvxer0AzJgxg//7v/9j2LBhrFu3jiFDhnDzzTfz7bf+Gx8ef/xx+vTpw5o1a+jWrRv9+vXj6NGj1KhRg/T0dMLDw3nllVdIT0/n+uuvZ+/evXTr1o2WLVuyevVq3n77bcaPH39cyaFJkybhcDhYunSpX/J39OjRvPHGGyxbtozdu3fTp08fXnnlFaZMmcJXX33F/Pnzef311339n332WT744APeeecd1q9fz3//+1/+85//HFc+6MEHH+S5555j48aNNGnS5KTP2/XXX8+wYcNo1KgR6enpvnV16NCB77//Ho+n6F5Df/5e3Lt3L9u3b/d9L7766quMGTOGl156iTVr1tClSxeuuuoqtm7d+pf/dunp6TRq1Ihhw4aRnp7O8OHDyc3NpUuXLlSsWJGff/6Zzz77jIULFx6XxF20aBGbN29mwYIFfPnll6f9GsrJyaFbt24sWrSIVatWccUVV9CjRw/S0tL85nnppZdISkpi1apVPProoyxfvpxBgwYxdOhQUlNTueSSS067zNS2bdv49NNP+eKLL5g7dy6rVq3izjvv9B3Pzs5mwIABfP/99/z4448kJCTQrVs3srOzgaI3715++WXGjh3L1q1bmTlzpi+p+8svv3DPPffwxBNPsHnzZubOnUv79u1LFNdDDz3Ec889x6OPPsqGDRuYMmUKVapUAeCnn34CYOHChaSnpzN9+nSg6M2su+66i9tuu421a9cye/Zs6tat+5dznWoNAP379+fjjz/mtddeY+PGjYwdO9a3A9zr9VK9enU+++wzNmzYwKhRo3j44Yf59NNPTzpfSV8/J/LDDz/QuHFj33MBRVflZGVlsX79+r88/1QyMjL4/vvvlXAXkTPHFDlPZGZmmoCZmZlZ3qGYpmma33zzjTlt2jRz7Nix5oEDB8ybxy4zlzzW1nQ9HmCaCx/x65ubm2tu2bLFnDTpVXPFildM02xumuZW88CV3c2fe3YwX3r6SrPX7GvKZR0iIiJy9srPzzc3bNhg5ufn+7UXrllj7qlavcw/CtesOa34ExISzC+//NI0TdN8++23zaioKL+1jBs3zgTMVatWmaZpmt9++60JmMeOHTNN0zRvvPFG87LLLvMbc8SIEWbDhg1N0zRNr9drRkVFmZ999plpmqbZtGlT89lnnzVjYmJM0zTN77//3rTb7WZubq7fGDt27PCb90Ti4uLMl19++bj2zz//3KxYsaIZGBhoXnjhheZDDz1krl69usTPSWZmphkUFGSmpqaapmmaq1atMkNDQ83s7Gxfn/Xr15sNGjQwLRaL2bhxY3PIkCHm119/7TfOgAEDTKvVagYFBZkBAQEmYFosFvPzzz8vURxjx441w8LCzCNHjpzw+IUXXmgOHjzYr613795mt27dfI8Bc+TIkb7HOTk5JmDOmTPH1xYREWFOmDDB9/jhhx8269WrZ3q9Xl/bm2++aYaGhpoej8c0TdPs0KGDmZyc7Dd38ffGwoULfW3PPvusCZjbt2/3tQ0ZMsTs0qWLaZqmWVBQYAYHB5vLli3zG2vQoEFm3759/cadOXPmCZ+HE3nsscfMpKQkv7Zjx46ZFovF/Pnnn02v12tGRkaazz77rNm6dWvTNE3zo48+MqtVq+brX7VqVfPpp5/2G6Nly5bmnXfeWaIYkpKSzMcee8z3+N133zUrVqxo5uTk+Nq++uor02KxmPv37zdNs+h7pkqVKmZhYaGvz999Df1Ro0aNzNdff933OC4uzuzZs6dfn759+/p975imaV5//fVmREREidb72GOPmVar1dyzZ4+vbc6cOabFYjHT09NPeI7H4zHDwsLML774wjRN0xwzZoyZmJhoOp3O4/pOmzbNDA8PN7OyskoUT7GsrCwzICDAHDdu3AmPn+xnTdWqVc1HHnnkhOecyqnWsHnzZhMwFyxYUOLx7rrrLrNXr16+xwMGDDCvvvpq0zRL9vo5lcGDB5uXX365X1tubq4JHPfz7EQmTJhw0u+PyZMnmy1atPjLMUTk3HGy33nLi3a4i5QTm83m2wHkdDqxWy28Zr2LHEcM/Gm3evEltg6HG5fL+K01ByMwkOqHTeLSXTg9hXhMTxmvQkREROTM2LhxI/v27aNTp04AbN68mSZNmvjd0LNVq1Z/Ocafb0Tarl07tm7disfjwTAM2rdvT0pKChkZGWzYsIE777yTwsJCNm3axOLFi2nZsiXBwcGltq5evXqxb98+Zs+ezRVXXEFKSgrNmjXz7br/Kx9//DF16tQhKSkJgKZNmxIXF8cnn3zi69OwYUPWrVvHjz/+yC233MLBgwfp0aOH74apxTp27MjkyZNZtmwZAwYM4Oabb6ZXr14liiM1NZXk5GQiIyNPePxkz/3GjRv92v64GzwkJITw8HAOHjx40nk3btxI27ZtMQzD19auXTtycnJ8V48CNG/e/ITn/3G+KlWqEBwcTO3atf3aiufftm0beXl5XHbZZb6rE0JDQ/nggw/Yvn2737gtWrQ4acwlUaFCBZKSkkhJSWHt2rU4HA5uu+02Vq1aRU5ODosXL6ZDhw4AZGVlsW/fvhI9vyW1ceNGkpKSCAkJ8RvP6/WyefNmX1vjxo39roI43ddQTk4Ow4cPp0GDBlSoUIHQ0FA2btx43A73Pz+fGzdupHXr1n5tbdu2Pa011qxZk2p/uIdE27Zt/dZ34MABBg8eTEJCAhEREYSHh5OTk+OLrXfv3uTn51O7dm0GDx7MjBkzfKWMLrvsMuLi4qhduzY33XQTkydP9itNdDIbN26ksLDQ93OuJA4ePOj3s/F0nGoNqampWK1W3/fZibz55ps0b96cSpUqERoayrvvvnvcv12x03n9lDWVkxGRM00Jd5FyYrPZfJeMOp1O7DYLhyxVKLSGHldSxul0sm7dOiyWarhc9X9rzabCc8+x77KmbK1clLgv1I1TRURE5F9i9uzZXHbZZX4J9jOhY8eOpKSksGTJEpKTkwkPD/clEP+Y5CxNgYGBXHbZZTz66KMsW7aMgQMH8thjj5Xo3PHjx7N+/XpsNpvvY8OGDbz//vt+/SwWCy1btuTee+9l+vTpTJw4kfHjx7Njxw5fn5CQEGrUqEFSUhLvv/8+y5cvP+VNBv8oKCio5As+heLSicUMw/BtSvkn/pg4Ptl8hmGccv7i+uVfffUVqampvo8NGzYcV4f6ZPOdjuLvxeLvu8jISBo0aMD3339/xr4XT9eJ1nk6r6Hhw4czY8YMnnnmGZYsWUJqaiqNGzc+riZ3aTyfp2vAgAGkpqby6quvsmzZMlJTU4mKivLFVqNGDTZv3sxbb71FUFAQd955J+3bt8flchEWFsbKlSv5+OOPiY2NZdSoUSQlJfnu2XUyf+d19E9ee6daw1+NO3XqVIYPH86gQYOYP38+qamp3HzzzSetp346r58TiYmJ4cCBA35txY9jYmJKstwTcjqdzJ07Vwl3ETmjlHAXKScVK1b01aNzOp0M6lCHa+zfEug6elzC3eVysWzZMgzDgtP5ew13e906/FrVwk8Niv5QKNSNU0VERORfYtasWVx99dW+x/Xq1WPt2rV+tc9//vnnU47RoEEDli5d6te2dOlSEhMTsVqtwO913D/77DNfnemOHTuycOFCli5dWmr120+lYcOG5Obm/mW/tWvX8ssvv5CSkuKXwEpJSeGHH35g06ZNp5wDOOk8FouFhx9+mJEjR5Kf/9f3BmrSpAmpqakcPXr0hMdP9twXx/F3NWjQgB9++AHTNP3GDQsLo3r16v9o7D9r2LAhAQEBpKWlUbduXb+PGjVq/O1xHQ6Hb+PNHxXXcV+0aJHf9+LHH3/Mli1bfG3h4eFUrVq1VJ/fBg0asHr1ar/vj6VLl2KxWKhXr94pzz2d19DSpUsZOHAg11xzDY0bNyYmJoadO3eWKL4/3pAX4Mcffyzx+gDS0tLYt2+f3/l/XN/SpUu555576Natm+9mpIcPH/YbIygoiB49evDaa6/5Xndr164FijZUde7cmRdeeIE1a9awc+dOvvnmm1PGlJCQQFBQEIsWLTrh8eKrCf74/RIWFkatWrVOes5fOdkaGjdujNfrPWl99aVLl3LhhRdy5513kpycTN26dU+5U/2fvn7atm3L2rVr/a54WbBgAeHh4f/o50hKSgoVK1b0XSUkInImKOEuUk7q169Px44dsdvtOJ1OkmtF0pDNBLozj0u422w2ACyWw7hcOwA7kEPe9BkYafvw2IouqS3waIe7iIiInPsOHjzIL7/8Qvfu3X1tN954I16vl9tuu42NGzcyb948XnrpJQC/8iJ/NGzYMBYtWsSTTz7Jli1bmDRpEm+88QbDhw/39WnSpAkVK1ZkypQpfsnC4hub/rlsxz9x5MgRLr30Uj766CPWrFnDjh07+Oyzz3jhhRf83lw4mfHjx9OqVSvat2/PBRdc4Pto3749LVu29O1Ov+6663j55ZdZvnw5u3btIiUlhbvuuovExETq169/0vF79+6N1WrlzTff/MtY+vbtS0xMDD179mTp0qX8+uuvTJs2jR9++AGAESNGMHHiRN5++222bt3K//73P6ZPn+733P8dd955J7t37+buu+9m06ZNzJo1i8cee4z77rsPi6V0/7wNCwtj+PDh/Pe//2XSpEls376dlStX8vrrrzNp0qS/PW6tWrXYsWMHqampHD582PcmUvv27cnOzubLL7/0+16cPHkysbGxJCYm+sYYMWIEzz//PJ988gmbN2/mwQcfJDU1lf/7v//7WzH169ePwMBABgwYwLp16/j222+5++67uemmm/xuWnkip/MaSkhIYPr06aSmprJ69Wrf6/qv3HPPPcydO5eXXnqJrVu38sYbbzB37tzTWmPx+lavXs2SJUu455576NOnj2+3dEJCAh9++CEbN25k+fLl9OvXz2/Xd/FVIuvWrePXX3/lo48+IigoiLi4OL788ktee+01UlNT2bVrFx988AFer/cv36wIDAzkgQce4P777/eVWvnxxx99r+XKlSsTFBTE3LlzOXDgAJmZmUDRzX/HjBnDa6+9xtatW33fl3/lVGuoVasWAwYM4JZbbmHmzJns2LGDlJQU301RExIS+OWXX5g3bx5btmzh0UcfPeWbnv/09XP55ZfTsGFDbrrpJlavXs28efMYOXIkd911FwEBAUDRTWXr16/P3r17feelpaWRmppKWloaHo/H98Zk8Y772bNna3e7iJxxSriLlBOv10tBQQEOhwOn08myrYfI9xbttDp5wr0AlysPCAOyKfzxRyx70n39Ctx/vRtJRERE5Gz3xRdf0KpVK6Kjo31t4eHhfPHFF//P3p3H13Stjx//nMwnkySGhCCoICISQ6gxxkZTKWpqqoRq8HM1tGJoa4i4BDXTkqtmqqWIhMZYURI15sSQiKFmqZkIGU5y1u+PNPvryKwI7Xq/Xnnde/baw7PX2Xs7ffbaz0aj0eDh4cHXX3/NhAkTAAosO9OwYUPWr1/Pjz/+SL169ZgwYQIhISH0799fmUelUtGqVStUKhUtW7YEchKI1tbWNG7c+IWWtrC0tKRp06bMmTNHSZqPHz+egIAAFi5cWOiymZmZrFmzpsAa6927d2fVqlVotVq8vb2JjIzE19eXWrVq4e/vT506ddi5c6fyuzI/RkZGDBs2jBkzZhQ54t7ExISdO3dSoUIFfHx8cHNzY9q0acqTA127dmXevHnMnDkTV1dXwsLCWL58+d9+YsDR0ZFffvmFw4cP4+7uzpAhQxg4cCDjxo37W+styOTJkxk/fjyhoaG4uLjQqVMntm3bRvXq1Z97nd27d6dTp060bduW8uXLs27dOiDnCVg3NzfKly+v3Bhp3bo1Op0uTzmZwMBAvvjiC0aOHImbmxvbt28nIiICZ2fn54rJ3NycHTt2cO/ePTw9PenRowft27cv8riEkp1Ds2fPxtbWlubNm+Pr64u3tzcNGzYschtvv/02S5YsYd68ebi7u7Nz584Sf+c1a9bkgw8+wMfHh3feeYf69evz3XffKe1Lly7l/v37NGzYkL59+xIYGEiFChWUdhsbG5YsWUKLFi2oX78+u3fvJjIykrJly2JjY8OmTZto164dLi4uLF68mHXr1uHq6lpkXOPHj2fkyJFMmDABFxcXevfurYzqNjIyYv78+YSFhVGpUiXlxpy/vz9z587lu+++w9XVlc6dO3Pu3Lkit1XYPgAsWrSIHj16MHToUOrUqUNAQIByLRg8eDAffPABvXv3pmnTpty9e5ehQ4cWur2/c/4YGhqydetWDA0NadasGR9//DH9+vUjJCREmefJkyckJSWh1WqVaRMmTKBBgwZMnDiR1NRUGjRoQIMGDTh69CggE+6SJL0aKvH0s3iS9A+WkpJCmTJlePjwIdbW1qUdDomJiezfvx8bGxsqV67M7ptW1DwZSncRjqlTU+i/V2/+JUuWUKHCY3Q6Fd267QO8eDDhHgf+2MP/epQBYHqrb3Ap+/ce05UkSZIk6Z8jPT2dixcvUr16db2kdNb169xs5QUZr/DpOFNT7Pfvw+iplxYW5P3336dly5aMHj260PnWrl3LgAEDePjw4QurKf5vkp2dTVxcHA0aNFAS5ZL0TxQcHEx4eDgajaa0Q5FK0fHjx2nXrh23b9/O8/4GSZLebAX95i0tBQ9vkCTppcodXZQ7wt3E0IBMlQkqIUCbd6S6k5MTQiTw8KEKsAQeoTIzw+5+JnVPp5Dgai1LykiSJEmSVCxGjo7Y79+HroD62y+DgZ1dsZLtAC1btsTPzy/P9FWrVlGjRg0cHR2Jj49nzJgx9OrVSybbJUmSpCJlZWWxYMECmWyXJOmlkwl3SSoluQl3IyMjMjMzMTYy4ITKDS+TOKo/U1IGcmrYHT16mjt3VOSWlFGZOVDt0hMGnLvFqBmusqSMJEmSJEnFZuToCMVMgL9qBY1s//PPP5kwYQJ//vknFStWpGfPnkyZMuUVR/fyrF27lsGDB+fb5uTkxOnTp19ZLFOnTmXq1Kn5trVq1YqoqKhXFsubxtXVlcuXL+fbFhYWRp8+fV7q9v+N311RfV5arly5UugLPhMSEqhateoL297rdA0pypAhQ1izZk2+bR9//DGLFy9+4dts0qQJTZo0eeHrlSRJepYsKSP9a7xuJWWuXr1KVFQUTk5OaLVaLho7s/noVcaqV/OOYQwMP683v1ar5eTJ7cTH32TAgPPAI9J/+5CUjRtI/nUr4ye78HmjkbSt0q50dugNcTrqLFkZWbh3laV3JEmSpH++1+3xWqlwjx494ubNm/m2GRsb4+Tk9EK3V1hJmXv37nGvgCcg1Go1jq/pzZrXweXLl/VqSj/N3t4eKyurl7r9f+N3V9p9XpCsrCwuXbpUYHu1atUKfa9CSb3qa8jfcevWLVJSUvJts7a21qufL0mSVJTX7TevHOEuSaUk94eVoaEhjx8/pmYVK5wtHmGZeQd0eUe4b9myBVNTU7KyBEJYoVLdwKx1K/4wus/4thdQARlZsqRMUZ7ce4I2Lau0w5AkSZIkScrDysqq1BKDz7Kzs8POzq60w3gjlXZS89/43ZV2nxfEyMiImjVrvrLtvU7XkKJUqFBBJtUlSfrHkgl3SSolFSpUwN/fn7i4OG7fvs0H7pUQx0/R/PIvYJJ3BL6xsTFCpCGEICvLEmPjVLLv3cPgWjKYgAnGpMmSMkXy7ONR2iFIkiRJkiRJkiRJkiRJ/1AGpR2AJP1bGRoaYmpqiqmpKZmZmaRnZpOJSU5jPolzIyMjhMh55E6rtQAekbFvH2lTZwBgrDIkIzv9VYUvSZIkSZIkSZIkSZIkSdIzZMJdkkpJeno6UVFRZGRkkJmZSfjRqxy5nJrTqNNCtn7Zk5yEuwqAzExzIBWV2gyTTB0AxhiSliUT7kXJvneP7Dt3SjsMSZIkSZIkSZIkSZIk6R9IJtwlqRRdvXoVnU6HEAJjQ8gQxv/X+MwodyMjI3S6nFNWqzUDtKjMjTDKynnvsZEwkCPci+HhV19z/7PA0g5DkiRJkiRJkiRJkiRJ+geSCXdJKiW5L01VqXJGrRuRTSrm3McmZwat/otTW7VqhZdXzktltFrDnGUtdFg8zmbu5yexFWakyxHuRbL67DOsx44p7TAkSZIkSZIkSZIkSZKkfyD50lRJKiWGhn8lzf9KuBuSjQY3/mv4JbOyx+RJuJuYmKBWlweuo9XmjIRXWaswLFcO03v3MMs2JF2OcC+SsWvd0g5BkiRJkl4LWdevo7t375Vtz8DODiNHx5e6jejoaNq2bcv9+/exsbF5qduSXo2YmBiGDBnCmTNneO+99wgPDy/tkP4Rzpw5Q//+/dFoNNSpUweNRlPaIZXYihUrGDFiBA8ePCjtUKRXLDg4mEWLFnHr1i02b95M165dSzsk6Slt2rTBw8ODuXPnlnYoklRqZMJdkkqJSqXC0NAQIXJKwhiqcv43NfuvsjJa/ZIy586d48qVRzlNWmsATJwrUjE+ji+ntyVDl4GRHOEuSZIkSVIxZF2/zs1WXpCR8eo2amqK/f59JU66DxgwAEdHR/773/++pMCKp02bNuzbt6/Adi8vr0LbAYQQ3L59mwkTJrBt2zZu3ryJra0t7u7uTJgwgRYtWhQ7ntDQUMaNG8e0adMYNWqUXlt2djbffPMNK1as4PLly6jVapydnQkICODTTz8FoH///qxcuRLIefKycuXK9OzZk5CQEMzMzIodx8v2xRdf4OHhQVRUFJaWlqUdzgsRHBxMeHh4qSa5J06ciIWFBUlJSf+Yfv0n6t+/Pw8ePJA3mp6SmJjIpEmT2Lx5M2+//Ta2tralHdJL92++mZyens6QIUM4duwYiYmJdO7cuVjnw7179/jss8+IjIzEwMCA7t27M2/evDzXu3379vHxxx9z9erVl7QH0r+VTLhLUilq1qwZarWakydPUr+yNcGtDHl7fzCoyDPC/dGjR1y/fh2VSkVmpuqvqTlJ+QvVzKgosuUId0mSJEmSikV3796rTbYDZGTkbLcECffs7Gy2bt3Ktm3bXmJgxbNp0yYyMzOBnPfwNGnShN27d+Pq6gpAZmYmJiYmyvyenp4MGjSIgIAAvfV0796dzMxMVq5cSY0aNbh58yZ79uzh7t27JYpn2bJljB49mmXLluVJuE+aNImwsDAWLlxI48aNSUlJ4ejRo9y/f19vPm9vb0aMGKGMcPb390elUjF9+vQSxfIyXbhwgSFDhlC5cuXnXsez383LJIQgOztbKR/5urpw4QLvvfceTk5Oz72OV9Wvr/L7e1NptVqMjY2LnvEf4MKFCwB06dJFeVr8ebzKPpPH8PPLzs5GrVYTGBjIxo0bi71cnz59SE5OZteuXWi1WgYMGMCgQYP44Ycf9ObbsmULvr6+LzpsSZI13CWpNNWtW5dy5coBIHTZmJsaY6NKyWl8JuFubGxMVlYmRkYZaLW3Ach+dIs/m7XAWCtQ6YSs4S5JkiRJ0j9KbGwsxsbGeHp6Kp89PDwwMzOjcePGhIeHo1KpCh0pvHHjRlxdXTE1NaVatWrMmjVLaVu4cCH16tVTPueub/Hixcq0Dh06MG7cOOzs7HBwcMDBwYHy5csDULZsWWVa1apVlf/v4OCAoaEhVlZWetMePHjA/v37mT59Om3btsXJyYkmTZrw5Zdf8v777xe7X/bt20daWhohISGkpKQQGxur1x4REcHQoUPp2bMn1atXx93dnYEDBxIUFKQ3n6mpKeXKlaNKlSp07dqVDh06sGvXrmLHce3aNfz8/LCzs8PCwoLGjRtz6NAhpX3RokW89dZbmJiYULt2bVavXq23vEql4vvvv6dbt26Ym5vj7OxMREQEAJcuXUKlUnH37l0++eQTVCoVK1asUPa/SZMmmJqaUrFiRcaOHUtWVpay3jZt2jBs2DBGjBhBuXLl8Pb2Jjo6GpVKxY4dO2jQoAFqtZp27dpx69YtoqKicHFxwdramo8++ognT/7vd7hOpyM0NJTq1aujVqtxd3fn559/Vtpz1xsVFUWjRo0wNTXlwIEDBfbZihUrmDRpEvHx8ahUKmW/goKC6Ny5szLf3LlzUalUbN++XZlWs2ZNvv/+eyWukJAQKleujKmpKR4eHnrzFkalUnHs2DFCQkJQqVQEBwcDcPLkSdq1a4daraZs2bIMGjSI1NRUZbn+/fvTtWtXpkyZQqVKlahdu3aJziHISZZ26dIFe3t7LC0t8fT0ZPfu3XrxVatWjcmTJ9OvXz+sra0ZNGiQ0ndVq1bF3Nycbt26legmVXBwMB4eHoSFhVGlShXMzc3p1asXDx8+VOY5cuQIHTt2pFy5cpQpUwYvLy+OHz+utAshCA4OpmrVqpiamlKpUiUCAwOV9u+++w5nZ2fMzMywt7enR48exYrt559/xs3NTen3Dh068PjxY4KDg1m5ciVbtmxRjpXo6Gjl3Pjpp5/w8vLCzMyMtWvXFnlM5C63adMm2rZti7m5Oe7u7hw8eFAvniVLlih91K1bN2bPnl2iUdWRkZF4enpiZmZGuXLl6Natm9J2//59+vXrh62tLebm5rz77rucO3dOaV+xYgU2Njbs2LEDFxcXLC0t6dSpE8nJyUDO95ibHDUwMFAS7sXd92f7LPeYnjp1Kvb29tjY2BASEkJWVhajRo3Czs6OypUrs3z5cr19vHr1Kr169cLGxgY7Ozu6dOnCpUuXlPb8zpWiZGRkMGbMGKpUqYKpqSk1a9Zk6dKlXLp0ibZt2wJga2uLSqWif//+yn7PmDGDmjVrYmpqStWqVZkyZUqR28rMzGTYsGFUrFgRMzMznJycCA0NVdofPHjA4MGDsbe3x8zMjHr16rF161YA7t69i5+fH46Ojpibm+Pm5sa6deuK3LegoCAcHR2xsLCgadOmREdHFxkngIWFBYsWLSIgIAAHB4diLZOYmMj27dv5/vvvadq0KS1btmTBggX8+OOP3LhxQ2/eiIiIEv37K0nFJRPuklSKrly5otQcvH43lU1xN/+v8ZmEu5GREVlZOoyNM9FqdQCoDDPIvnIF42xQZevIkCPcJUmSJEn6B4mIiMDX1xeVSkVKSgq+vr64ublx/PhxJk+ezJgxhb8I/dixY/Tq1YsPP/yQkydPEhwczPjx45XErZeXFwkJCdy+nTOYYd++fZQrV05JBGi1Wg4ePEibNm1eyP5YWlpiaWlJeHg4GX/jCYOlS5fi5+eHsbExfn5+LF26VK/dwcGBX3/9Vdmv4jh16hSxsbHFHoWZmpqKl5cX169fJyIigvj4eEaPHo1Ol/M7dfPmzQwfPpyRI0dy6tQpBg8ezIABA9i7d6/eeiZNmkSvXr04ceIEPj4+9OnTh3v37lGlShWSk5OxtrZm7ty5JCcn07t3b65fv46Pjw+enp7Ex8ezaNEili5dmqfk0MqVKzExMSEmJkYv+RscHMzChQuJjY1VkmZz587lhx9+YNu2bezcuZMFCxYo84eGhrJq1SoWL17M6dOn+fzzz/n444/zlA8aO3Ys06ZNIzExkfr16xfYb71792bkyJG4urqSnJys7JeXlxcHDhwgOzsbyHssXr9+nQsXLijH4rx585g1axYzZ87kxIkTeHt78/777+slLwuSnJyMq6srI0eOJDk5maCgIB4/foy3tze2trYcOXKEDRs2sHv3boYNG6a37J49e0hKSmLXrl1s3bq1xOdQamoqPj4+7Nmzh7i4ODp16oSvry9XrlzR287MmTNxd3cnLi6O8ePHc+jQIQYOHMiwYcPQaDS0bdu2xGWmzp8/z/r164mMjGT79u3ExcUxdOhQpf3Ro0f4+/tz4MABfv/9d5ydnfHx8eHRo5yynhs3bmTOnDmEhYVx7tw5wsPDcXNzA+Do0aMEBgYSEhJCUlIS27dvp3Xr1sX6Lvz8/Pjkk09ITEwkOjqaDz74ACEEQUFB9OrVS0k4Jycn07x5c2XZsWPHMnz4cBITE/H29i72MfH1118TFBSERqOhVq1a+Pn5KTesct+ZMHz4cDQaDR07dixWAjfXtm3b6NatGz4+PsTFxbFnzx6aNGmitPfv35+jR48SERHBwYMHEULg4+ODVqtV5nny5AkzZ85k9erV/Pbbb1y5ckW5WRgUFKQkv3P7BIp/PjzbZwC//vorN27c4LfffmP27NlMnDiRzp07Y2try6FDhxgyZAiDBw/m2rVrQM4x7e3tjZWVFfv37ycmJka5MZD7FBTkPVeK0q9fP9atW8f8+fNJTEwkLCwMS0tLqlSpoozsTkpKIjk5mXnz5gHw5ZdfMm3aNMaPH09CQgI//PAD9vb2RW5r/vz5REREsH79epKSkli7di3VqlUDcpL47777LjExMaxZs4aEhASmTZumvIMuPT2dRo0asW3bNk6dOsWgQYPo27cvhw8fLnB7w4YN4+DBg/z444+cOHGCnj170qlTp2Jdr57HwYMHsbGxoXHjxsq0Dh06YGBgoHdT+PTp09y6dYt27dq9lDikfzkhSf8SDx8+FIB4+PBhaYei2Lhxo4iOjhZhYWFi76F40XnCGiEmkvN3eqPevGfPnhVhYWHixx+nidjYn4QQjYVO+5O4Vqmy+PR7b/H5yu6if1Tf0tkRSZIkSZJeS2lpaSIhIUGkpaXpTc84cUJcq1T5lf9lnDhRovidnZ3F1q1bhRBCLFq0SJQtW1ZvX5YsWSIAERcXJ4QQYu/evQIQ9+/fF0II8dFHH4mOHTvqrXPUqFGibt26QgghdDqdKFu2rNiwYYMQQggPDw8RGhoqHBwchBBCHDhwQBgbG4vHjx/rrePixYt6282Pk5OTmDNnTp7pP//8s7C1tRVmZmaiefPm4ssvvxTx8fHF7pOHDx8KtVotNBqNEEKIuLg4YWlpKR49eqTMc/r0aeHi4iIMDAyEm5ubGDx4sPjll1/01uPv7y8MDQ2FWq0WpqamAhAGBgbi559/LlYcYWFhwsrKSty9ezff9ubNm4uAgAC9aT179hQ+Pj7KZ0CMGzdO+ZyamioAERUVpUwrU6aMWL58ufL5q6++ErVr1xY6nU6Z9u233wpLS0uRnZ0thBDCy8tLNGjQQG/bucfG7t27lWmhoaECEBcuXFCmDR48WHh7ewshhEhPTxfm5uYiNjZWb10DBw4Ufn5+eusNDw/Ptx/yM3HiROHu7q437f79+8LAwEAcOXJE6HQ6YWdnJ0JDQ0XTpk2FEEKsWbNGODo6KvNXqlRJTJkyRW8dnp6eYujQocWKwd3dXUycOFH5/L///U/Y2tqK1NRUZdq2bduEgYGB+PPPP4UQOceMvb29yMjIUOZ53nPoaa6urmLBggXKZycnJ9G1a1e9efz8/PSOHSGE6N27tyhTpkyx9nfixInC0NBQXLt2TZkWFRUlDAwMRHJycr7LZGdnCysrKxEZGSmEEGLWrFmiVq1aIjMzM8+8GzduFNbW1iIlJaVY8eQ6duyYAMSlS5fybff39xddunTRm5Z7/Zk7d67e9KKOidzlvv/+e6X99OnTAhCJiYlCiJw+fe+99/TW0adPn2L3c7NmzUSfPn3ybTt79qwARExMjDLtzp07Qq1Wi/Xr1wshhFi+fLkAxPnz55V5vv32W2Fvb6983rx5s3g2lVXcfX+2z/z9/YWTk5Ny7RBCiNq1a4tWrVopn7OysoSFhYVYt26dEEKI1atX57kGZWRkCLVaLXbs2KGs99lzpTBJSUkCELt27cq3/dl/24QQIiUlRZiamoolS5YUaxtP++yzz0S7du309iHXjh07hIGBgUhKSir2+t577z0xcuRI5bOXl5cYPny4EEKIy5cvC0NDQ3H9+nW9Zdq3by++/PLLEsWd3/mQnylTpohatWrlmV6+fHnx3Xff6c3Xo0ePEsUgvb4K+s1bWuQId+mN884771C/fn08PDxo1aoVcXFxpR3SczMyMlJGsahENhk8NaIoS/+lqRUqVKBFC0+MjbV/jQAwB8NMMDCgS2wmTg+NZUkZSZIkSZL+MRITE7lx4wbt27cHckb21a9fX++Fnk+PnCxoHc++iLRFixacO3eO7OxsVCoVrVu3Jjo6mgcPHpCQkMDQoUPJyMjgzJkz7Nu3D09PT8zNzV/YfnXv3p0bN24QERFBp06diI6OpmHDhsqo+6KsW7eOt956C3d3dwA8PDxwcnLip59+UuapW7cup06d4vfff+eTTz7h1q1b+Pr6Ki9MzdWmTRvWrl1LbGws/v7+DBgwgO7duxcrDo1GQ4MGDbCzs8u3vaC+T0xM1Jv29GhwCwsLrK2tuXXrVoHbTUxMpFmzZnq1m1u0aEFqaqoyAhWgUaNG+S7/9Pbs7e0xNzenRo0aetNyt3/+/HmePHlCx44dlacTLC0tWbVqlVJHOtfTIymfh42NDe7u7kRHR3Py5ElMTEwYNGgQcXFxpKamsm/fPry8vABISUnhxo0bxerf4kpMTMTd3R0LCwu99el0OpKSkpRpbm5uek9BlPQcSk1NJSgoCBcXF2xsbLC0tCQxMTHPCPdn+zMxMZGmTZvqTWvWrFmJ9rFq1ao4PvUOiWbNmunt382bNwkICMDZ2ZkyZcpgbW1NamqqElvPnj1JS0ujRo0aBAQEsHnzZmVkeMeOHXFycqJGjRr07duXtWvX6pUmKoi7uzvt27fHzc2Nnj17smTJkjzvWijI031UkmPi6XOgYsWKAMoxn5SUlOe6WtR19mkajUa5Zj8rMTERIyMjve+xbNmy1K5dWy9Gc3Nz3nrrLb0YC7smlGTf8ztPXV1dMTD4v9SYvb298uQCgKGhIWXLllViiI+P5/z581hZWSnXBDs7O9LT0/WuC8+eK4XRaDQYGhoq53hxJCYmkpGRUWB/F6Z///5oNBpq165NYGAgO3fu1IulcuXK1KpVK99ls7OzmTx5Mm5ubtjZ2WFpacmOHTvynMO5Tp48SXZ2NrVq1dK7ju7bty/PdfRV27JliywnI700MuEuvXHWr1/PiRMn0Gg0fPHFF0r9sjdRbsLd0NAQldDxGAsGi28QkKekTJkyZXB1dcfEREtmZhagRqVKQ2VmRuMLgkoPVPKlqZIkSZIk/WNERETQsWNHvQT7y9CmTRuio6PZv38/DRo0wNraWkkgPp3kfJHMzMzo2LEj48ePJzY2lv79+zNx4sRiLbt06VJOnz6NkZGR8peQkMCyZcv05jMwMMDT05MRI0awadMmVqxYwdKlS7l48aIyj4WFBVWqVMHd3Z1ly5Zx6NChPOVpCqJWq4u/w4V49qWFKpVKKUvzdzydOC5oeyqVqtDt59Yv37ZtGxqNRvlLSEjQq+Ne2PZKIvdYzD3u7OzscHFx4cCBAy/tWCyp/PazJOdQUFAQmzdvZurUqezfvx+NRoObm5teKY6CtvOy+fv7o9FomDdvHrGxsWg0GsqWLavEVqVKFZKSkvjuu+9Qq9UMHTqU1q1bo9VqsbKy4vjx46xbt46KFSsyYcIE3N3dlfKhBTE0NGTXrl1ERUVRt25dFixYQO3atfXO04I8bx89ew4AL+ScgxdzXcjvnBRC/O31Qv59lt/2irouNGrUSO+aoNFoOHv2LB999FGh2yrI8/Tb3+nrhg0bcvHiRSZPnkxaWhq9evVS3jlQ1Hq/+eYb5s2bx5gxY9i7dy8ajQZvb+8853Cu1NRUDA0NOXbsmF5/JSYmKqVxXjQHB4c8N2mysrK4d++eUgc+OTmZuLg43nvvvZcSgyTJhLv0xnn6hS0PHz78W28mL205ddmzMDIyApFNNobE44YwMs+TcE9PT+fs2fMYGHig1ZYDzIEnlF2+jDON7LljlE62yEar0+a7LSnHn4m3uXHqZtEzSpIkSZJUqrZs2UKXLl2Uz7Vr1+bkyZN6tc+PHDlS6DpcXFyIiYnRmxYTE0OtWrWUerS5Nag3bNig1Jlu06YNu3fvJiYm5oXVby9M3bp1efz4cZHznTx5kqNHjxIdHa2XuIiOjubgwYOcOXOm0G0ABW7HwMCAr776inHjxpGWlpbvPE+rX78+Go2Ge/fu5dteUN/nxvG8XFxclNrPT6/XysqKypUr/611P6tu3bqYmppy5coVatasqfdXpUqV516viYmJ8pTr03LruO/Zs0fvWFy3bh1nz55VpllbW1OpUqUX2r8uLi7Ex8frHR8xMTEYGBgU+cLHkpxDMTEx9O/fn27duuHm5oaDg4PeyyYLi+/p2ssAv//+e7H3D3Len/X0CxN///13vf2LiYkhMDAQHx8f5UXLd+7c0VuHWq3G19eX+fPnK+fdyZMngZz/tuvQoQMzZszgxIkTXLp0iV9//bXIuFQqFS1atGDSpEnExcVhYmLC5s2bgYKPlWe9qGOidu3aea6rRV1nn1a/fn327NmTb5uLiwtZWVl63+Pdu3dJSkr6W9eFl3E+FKZhw4acO3eOChUq5LkulClT5rnW6ebmhk6ny/NuiFy5I+WfPhacnZ1Rq9UF9ndRrK2t6d27N0uWLOGnn35i48aN3Lt3j/r163Pt2jXOnj2b73IxMTF06dKFjz/+GHd3d2rUqFHgvAANGjQgOzubW7du5emv4r4EtaSaNWvGgwcPOHbsmDLt119/RafTKU9YREZG0rx58wKf0pKkv0sm3KU3Ur9+/ahSpQrjx49n9erV+c6TkZFBSkqK3t/rxtbWFmtra4yMjDBWQf9W1RnKMnQGRnkS7qmpqX+9fMgUrTYbMAPSMW3Zgp11s0kqm3NHWZaVKdzJyETiNpwq7TAkSZIkSSrErVu3OHr0KJ07d1amffTRR+h0OgYNGkRiYiI7duxg5syZAAUOwBg5ciR79uxh8uTJnD17lpUrV7Jw4ULlBXyQkyCytbXlhx9+0EsW5r7Y9NkyBX/H3bt3adeuHWvWrOHEiRNcvHiRDRs2MGPGDL2bCwVZunQpTZo0oXXr1tSrV0/5a926NZ6ensro9B49ejBnzhwOHTrE5cuXiY6O5j//+Q+1atWiTp06Ba6/Z8+eGBoa8u233xYZi5+fHw4ODnTt2pWYmBj++OMPNm7cyMGDBwEYNWoUK1asYNGiRZw7d47Zs2ezadMmvb5/HkOHDuXq1at89tlnnDlzhi1btjBx4kS++OILvbIQL4KVlRVBQUF8/vnnrFy5kgsXLnD8+HEWLFjAypUrn3u91apV4+LFi2g0Gu7cuaPcRGrdujWPHj1i69atesfi2rVrqVixol6Jh1GjRjF9+nR++uknkpKSGDt2LBqNhuHDhz9XTH369MHMzAx/f39OnTrF3r17+eyzz+jbt2+RL2EsyTnk7OzMpk2b0Gg0xMfHK+d1UQIDA9m+fTszZ87k3LlzLFy4kO3bt5doH3P3Lz4+nv379xMYGEivXr2UpJ+zszOrV68mMTGRQ4cO0adPH73RvrlPiZw6dYo//viDNWvWoFarcXJyYuvWrcyfPx+NRsPly5dZtWoVOp2uyJsVhw4dYurUqRw9epQrV66wadMmbt++jYuLC5BzrJw4cYKkpCTu3Lmj93LRZ72IY+Kzzz7jl19+Yfbs2Zw7d46wsDCioqKKPcht4sSJrFu3jokTJ5KYmMjJkyeZPn06kNO/Xbp0ISAggAMHDhAfH8/HH3+Mo6Njsa5/hXnR50Nh+vTpQ7ly5ejSpQv79+/n4sWLREdHExgYqFfWqiSqVauGv78/n3zyCeHh4co6169fD4CTkxMqlYqtW7dy+/ZtUlNTMTMzY8yYMYwePVopc/X7778X6yml2bNns27dOs6cOcPZs2fZsGEDDg4O2NjY4OXlRevWrenevTu7du3i4sWLREVFKeebs7Mzu3btIjY2lsTERAYPHszNmwUPaKtVqxZ9+vShX79+bNq0iYsXL3L48GFCQ0PZtm1bsfonISFBucH78OFD5WZzrsOHD1OnTh2uX78O5Nzc6dSpEwEBARw+fJiYmBiGDRvGhx9+SKVKlYCcp+hkORnpZZIJd+mNtGrVKq5evcp///tfxowZk+88oaGhlClTRvn7O6NQXhZPT09atGiBkZERKnR4u1eiF+GAKk/CPfexNkPDi2i1d8kd4Z66fAXG6VqEyPmhKhPuhWs7ogXeX5X+47iSJEmSJBUsMjKSJk2aUK5cOWWatbU1kZGRaDQaPDw8+Prrr5kwYQJAgWVnGjZsyPr16/nxxx+pV68eEyZMICQkRK8koUqlolWrVqhUKlq2bAnkJBCtra1p3LjxCy1tYWlpSdOmTZkzZ46SNB8/fjwBAQEsXLiw0GUzMzNZs2ZNgTXWu3fvzqpVq9BqtXh7exMZGYmvry+1atXC39+fOnXqsHPnzpwnKwtgZGTEsGHDmDFjRpEj7k1MTNi5cycVKlTAx8cHNzc3pk2bpjw50LVrV+bNm8fMmTNxdXUlLCyM5cuX/+0nBhwdHfnll184fPgw7u7uDBkyhIEDBzJu3Li/td6CTJ48mfHjxxMaGqokcbZt20b16tWfe53du3enU6dOtG3blvLly7Nu3TogZzCOm5sb5cuXV26MtG7dGp1Ol6ecTGBgIF988QUjR47Ezc2N7du3ExERgbOz83PFZG5uzo4dO7h37x6enp706NGD9u3bF3lcQsnOodmzZ2Nra0vz5s3x9fXF29ubhg0bFrmNt99+myVLljBv3jzc3d3ZuXNnib/zmjVr8sEHH+Dj46O8F+y7775T2pcuXcr9+/dp2LAhffv2JTAwkAoVKijtNjY2LFmyhBYtWlC/fn12795NZGQkZcuWxcbGhk2bNtGuXTtcXFxYvHgx69atw9XVtdCYrK2t+e233/Dx8aFWrVqMGzeOWbNm8e677wIQEBBA7dq1ady4MeXLl88zivtpL+KYaNGiBYsXL2b27Nm4u7uzfft2Pv/882KX9mrTpg0bNmwgIiICDw8P2rVrx+HDh5X25cuX06hRIzp37kyzZs0QQvDLL7/kKeFSUi/6fCiMubk5v/32G1WrVuWDDz7AxcWFgQMHkp6ejrW19XOvd9GiRfTo0YOhQ4dSp04dAgIClOuwo6MjkyZNYuzYsdjb2zNs2DAAxo8fz8iRI5kwYQIuLi707t270Hr3uaysrJgxYwaNGzfG09OTS5cu8csvvyg3LTdu3Iinpyd+fn7UrVuX0aNHK6Prx40bR8OGDfH29qZNmzbKjdfCLF++nH79+jFy5Ehq165N165dOXLkCFWrVi1W3/j4+NCgQQMiIyOJjo6mQYMGNGjQQGl/8uQJSUlJejek1q5dS506dWjfvj0+Pj60bNmS//3vf0DOk1579uyRCXfppVKJF1UMS5JKiVqt5tq1a5QtW1ZvekZGht4jxykpKVSpUoWHDx/+rX8IXzSdTsfmzZspX74CVwwq8/6u+qjVZhg36Afes5T5Hj9+zNq1a6le/U/u3q3Ahx8mAKbceuckYR1V3LKGy/YGfNd+MZWtXr+bC5IkSZIkvXrp6elcvHiR6tWr6yVMsq5f52YrL3jqt9JLZ2qK/f59GD310sKCvP/++7Rs2ZLRo0cXOt/atWsZMGAADx8+fGE1xf9NsrOziYuLo0GDBkqiXJL+iYKDgwkPD9cbFSsVT0BAAGfOnGH//v2lHYokvRCbNm1i3LhxJCQklHYo0gtU0G/e0lLw8AZJeg09ePCAJ0+eKI8BhYeHU7Zs2XzrbpmammJqavqqQyyRI0eOcP78eSwsLMjKymLhvrO8izGmGIJWv3Zm7mgklUpFzo1bNfAYlZkZRlkZZKMDDEiTI9wlSZIkSSqCkaMj9vv3oSug/vbLYGBnV6xkO0DLli3x8/PLM33VqlXUqFEDR0dH4uPjGTNmDL169ZLJdkmSpBdk5syZdOzYEQsLC6Kioli5cqXekwCS9KaztLRUSh1J0ssiE+7SG+Xhw4f07NmTtLQ0DAwMKF++PFu3bn1jX5xqaGiovDQ1OzsLFZCJMUJlmG9JmfLly2NqepPMTBU5Cfc7qMzMqHQvDa02k2v2RmRky4R7YR4ET0KkpmI785vSDkWSJEmSSpWRoyMUMwH+qhU0sv3PP/9kwoQJ/Pnnn1SsWJGePXsyZcqUVxzdy7N27VoGDx6cb5uTkxOnT59+ZbFMnTqVqVOn5tvWqlUroqKiXlksbxpXV1cuX76cb1tYWBh9+vR5qdv/N353RfV5ably5UqhL+5MSEgodlmNV+Xw4cPMmDGDR48eUaNGDebPn8+nn34KlP6x/abav3+/UiYoP6mpqS90e2/SNeDdd98t8OmJr776iq+++uqFb/Odd9554euUpGfJkjLSv0ZKSgplypR5rUrKnDhxgmPHjuHo6Eh2djahR40YkLWM7jYnsHZ0hV7r8yyTlDSeffuq8Omn9zEwiOeuvylZV69y9+ENxo6vzoS3g2ns4FkKe/NmeLLhZ0RaGhb9+pZ2KJIkSZL00r1uj9dKhXv06FGBL58zNjbGycnphW6vsJIy9+7d414BT0Co1WocX9ObNa+Dy5cvF/hyS3t7e6ysrF7q9v+N311p93lBsrKyuHTpUoHt1apVK/S9Cq+b17WfX3dpaWnKCz3zU7NmzRe6vTfpGnD9+nXS0tLybbOzs8u3moEk5ed1+8375lzZJekfyMjIiKysLAwNDcnIyMDE0ISwrP68q56D9TMj3AGEEBgZNQDuoNWaY2r6BFOvjugO/Y5q3wUA0uUI90KZ9+xR2iFIkiRJkiTly8rK6rVJWMlEx/N70TdGSurf+N2Vdp8XxMjI6IUnU0vT69rPrzu1Wv1Kj4M36RrwOiX/JelFkgl3SSpFRkZGCCGU0jLuTrZcORePTqfLU1IG4IcffqBixYrkJNzNMDVNw/KTAWyyucCuZjlvYE+XNdwlSZIkSZIkSZIkSZIkqVQYlHYAkvRvVq1aNT788EOMjY3JyspiVp+GTGAWlqnnICvvY1U5CfpHAGRmmgFpZN+9i1FGFllGKoxVxnKEuyRJkiRJkiRJkiRJkiSVEplwl6RSZGJigrW1tZJwz9YJslQmCEG+I9xz6vtdA0CrNQXSeLRwAWL/QbTGBpgZmpKeT6JekiRJkiRJkiRJkiRJkqSXTybcJakUPXjwgD179qDT6cjKyqLfolgyMEJAgQl3nS7nhVZarTEgUFkaY5SRhdZYhQlGpGdlvNJ9kCRJkiRJkiRJkiRJkiQph0y4S1Ip0mq1XLhwASEEWVlZGBsZoMUEhCgk4W7w17ImABhYGWKckY0wUGGGMRmypIwkSZIkSZIkSZIkSZIklQqZcJekUpRTIgZUKhVarRZjAxVPVBZkq4zyTbi3adOGFi3UAGi1OSPdVRaGeMQ9IPSrBEwxJk2WlJEkSZIkqRj+fJDGmRspr+zvzwcv/zdKdHQ0KpWKBw8evPRtSa9GTEwMbm5uGBsb07Vr19IO5x/jzJkzvP3225iZmeHh4VHa4TyXFStWYGNjU9phSKUgODgYe3t7VCoV4eHhpR3OG0meP9LT2rRpw4gRI0o7jH8Uo9IOQJL+zZ5OuAOYGqn4xng0Y8vvpcP1mXnmt7CwACpgYHCRzMyc+2UGlgaYZegwTctCjREZ2bKkjCRJkiRJhfvzQRq9FhwgM0v3yrZpYmTA+s9a4mCjLtFyAwYMwNHRkf/+978vKbLiadOmDfv27Suw3cvLq9B2ACEEt2/fZsKECWzbto2bN29ia2uLu7s7EyZMoEWLFsWOJzQ0lHHjxjFt2jRGjRql15adnc0333zDihUruHz5Mmq1GmdnZwICAvj0008B6N+/PytXrgRyfpNWrlyZnj17EhISgpmZWbHjeNm++OILPDw8iIqKwtLSsrTDeSGCg4MJDw9Ho9GUWgwTJ07EwsKCpKSkf0y//hP179+fBw8eyKTyUxITE5k0aRKbN2/m7bffxtbWtrRDkqQ8oqOjadu2Lffv3//X3dhIT09nyJAhHDt2jMTERDp37lysa9i9e/f47LPPiIyMxMDAgO7duzNv3rw8/0bt27ePjz/+mKtXr76kPXgxZMJdkkpRbsI9l4khqFSQhilkZ4AuGwwMlfakpCQePLDB2FitjHBXv9+ePxt0YOXSoRhkCznCvQja9CwQAmO1cWmHIkmSJEml5sET7StNtgNkZul48ERbooR7dnY2W7duZdu2bS8xsuLZtGkTmZmZAFy9epUmTZqwe/duXF1dAcjMzMTExESZ39PTk0GDBhEQEKC3nu7du5OZmcnKlSupUaMGN2/eZM+ePdy9e7dE8SxbtozRo0ezbNmyPAn3SZMmERYWxsKFC2ncuDEpKSkcPXqU+/fv683n7e3NiBEjqFOnDhqNBn9/f1QqFdOnTy9RLC/ThQsXGDJkCJUrV37udTz73bxMQgiys7Pz/M5/3Vy4cIH33nsPJyen517Hq+rXV/n9vam0Wi3Gxv+O/765cOECAF26dFEGrj2PV9ln8hiW/k2ys7NRq9UEBgaycePGYi/Xp08fkpOT2bVrF1qtlgEDBjBo0CB++OEHvfm2bNmCr6/viw77hZMlZSSpFJmYmNCoUSOsra0B+NzbmSEmm2h4a13ODFr95Pndu3e5cuUKJiYmaLU5Py5UqnQeG2YR18AGQyFkDfciRM+PZee030o7DEmSJEmSiiE2NhZjY2M8PT2Vzx4eHpiZmdG4cWPCw8NRqVSFjhTeuHEjrq6umJqaUq1aNWbNmqW0LVy4kHr16imfc9e3ePFiZVqHDh0YN24cdnZ2ODg44ODgQPny5QEoW7asMq1q1arK/3dwcMDQ0BArKyu9aQ8ePGD//v1Mnz6dtm3b4uTkRJMmTfjyyy95//33i90v+/btIy0tjZCQEFJSUoiNjdVrj4iIYOjQofTs2ZPq1avj7u7OwIEDCQoK0pvP1NSUcuXKUaVKFbp27UqHDh3YtWtXseO4du0afn5+2NnZYWFhQePGjTl06JDSvmjRIt566y1MTEyoXbs2q1ev1ltepVLx/fff061bN8zNzXF2diYiIgKAS5cuoVKpuHv3Lp988gkqlYoVK1Yo+9+kSRNMTU2pWLEiY8eOJSsrS1lvmzZtGDZsGCNGjKBcuXJ4e3sr5YZ27NhBgwYNUKvVtGvXjlu3bhEVFYWLiwvW1tZ89NFHPHnyf6UddTodoaGhVK9eHbVajbu7Oz///LPSnrveqKgoGjVqhKmpKQcOHCiwz1asWMGkSZOIj49HpVIp+xUUFETnzp2V+ebOnYtKpWL79u3KtJo1a/L9998rcYWEhFC5cmVMTU3x8PDQm7cwKpWKY8eOERISgkqlIjg4GICTJ0/Srl071Go1ZcuWZdCgQaSmpirL9e/fn65duzJlyhQqVapE7dq1S3QOQU6ytEuXLtjb22NpaYmnpye7d+/Wi69atWpMnjyZfv36YW1tzaBBg5S+q1q1Kubm5nTr1q1EN6mCg4Px8PAgLCyMKlWqYG5uTq9evXj48KEyz5EjR+jYsSPlypWjTJkyeHl5cfz4caVdCEFwcDBVq1bF1NSUSpUqERgYqLR/9913ODs7Y2Zmhr29PT169ChWbD///DNubm5Kv3fo0IHHjx8THBzMypUr2bJli3KsREdHK+fGTz/9hJeXF2ZmZqxdu7bIYyJ3uU2bNtG2bVvMzc1xd3fn4MGDevEsWbJE6aNu3boxe/bsEo3QjYyMxNPTEzMzM8qVK0e3bt2Utvv379OvXz9sbW0xNzfn3Xff5dy5c0p7bpmTHTt24OLigqWlJZ06dSI5ORnI+R5zE20GBgZKwr24+/5sn+Ue01OnTsXe3h4bGxtCQkLIyspi1KhR2NnZUblyZZYvX663j1evXqVXr17Y2NhgZ2dHly5duHTpktKe37lSmJKeR5CTdGzYsCFmZmbUqFGDSZMm6V0HZ8+ejZubGxYWFlSpUoWhQ4fqnc/Pun37No0bN6Zbt25kZBT+1Pz9+/fp06cP5cuXV56gyu2j3L7+8ccfad68OWZmZtSrVy/PE2CnTp3i3XffxdLSEnt7e/r27cudO3eUdp1Ox4wZM6hZsyampqZUrVqVKVOmKO1jxoyhVq1amJubU6NGDcaPH49Wq1Xac7+Dp40YMYI2bdoonx89ekSfPn2wsLCgYsWKzJkzp0SlVTIyMhgzZgxVqlTB1NSUmjVrsnTpUi5dukTbtm0BsLW1RaVS0b9//2LtV0EyMzMZNmwYFStWxMzMDCcnJ0JDQ5X2Bw8eMHjwYOzt7ZU+37p1K5CTR/Lz88PR0RFzc3Pc3NxYt25dkfsWFBSEo6MjFhYWNG3alOjo6GL1i4WFBYsWLSIgIAAHB4diLZOYmMj27dv5/vvvadq0KS1btmTBggX8+OOP3LhxQ2/eiIiIEv1mKi0y4S5JpcjQ0JBGjRopP2CsTA2wUaVglfXXPzTP1HE3NjZGq32MsfEVtH8l47XnTvJkzNcAGGVBepYsKVOY+l1caNjbrbTDkCRJkiSpGCIiIvD19UWlUpGSkoKvry9ubm4cP36cyZMnM2bMmEKXP3bsGL169eLDDz/k5MmTBAcHM378eCVx6+XlRUJCArdv3wZyErnlypVT/qNSq9Vy8OBBvf9A/zssLS2xtLQkPDy8yIRGYZYuXYqfnx/Gxsb4+fmxdOlSvXYHBwd+/fVXZb+K49SpU8TGxhZ7FGZqaipeXl5cv36diIgI4uPjGT16NDpdzpMTmzdvZvjw4YwcOZJTp04xePBgBgwYwN69e/XWM2nSJHr16sWJEyfw8fGhT58+3Lt3jypVqpCcnIy1tTVz584lOTmZ3r17c/36dXx8fPD09CQ+Pp5FixaxdOnSPCWHVq5ciYmJCTExMXpJq+DgYBYuXEhsbKySNJs7dy4//PAD27ZtY+fOnSxYsECZPzQ0lFWrVrF48WJOnz7N559/zscff5wneTR27FimTZtGYmIi9evXL7DfevfuzciRI3F1dSU5OVnZLy8vLw4cOEB2djaQ91i8fv06Fy5cUI7FefPmMWvWLGbOnMmJEyfw9vbm/fff10teFiQ5ORlXV1dGjhxJcnIyQUFBPH78GG9vb2xtbTly5AgbNmxg9+7dDBs2TG/ZPXv2kJSUxK5du9i6dWuJz6HU1FR8fHzYs2cPcXFxdOrUCV9fX65cuaK3nZkzZ+Lu7k5cXBzjx4/n0KFDDBw4kGHDhqHRaGjbtm2Jy0ydP3+e9evXExkZyfbt24mLi2Po0KFK+6NHj/D39+fAgQP8/vvvODs74+Pjw6NHj4Ccm3dz5swhLCyMc+fOER4ejptbzn9XHD16lMDAQEJCQkhKSmL79u20bt26WN+Fn58fn3zyCYmJiURHR/PBBx8ghCAoKIhevXopCefk5GSaN2+uLDt27FiGDx9OYmIi3t7exT4mvv76a4KCgtBoNNSqVQs/Pz8lURsTE8OQIUMYPnw4Go2Gjh07FisZmGvbtm1069YNHx8f4uLi2LNnD02aNFHa+/fvz9GjR4mIiODgwYMIIfDx8dFLlD558oSZM2eyevVqfvvtN65cuaLcLAwKClISu7l9AsU/H57tM4Bff/2VGzdu8NtvvzF79mwmTpxI586dsbW15dChQwwZMoTBgwdz7do1IOeY9vb2xsrKiv379xMTE6PcGMh9CgryniuFKel5tH//fvr168fw4cNJSEggLCyMFStW6H1XBgYGzJ8/n9OnT7Ny5Up+/fVXRo8ene/2r169SqtWrahXrx4///wzpqamhcY7fvx4EhISiIqKIjExkUWLFlGuXDm9eUaNGsXIkSOJi4ujWbNm+Pr6KjfJHjx4QLt27WjQoAFHjx5l+/bt3Lx5k169einLf/nll0ybNk3Z1g8//IC9vb3SbmVlxYoVK0hISGDevHksWbKEOXPmFBr3s7744gtiYmKIiIhg165d7N+/X+8mW1H69evHunXrmD9/PomJiYSFhWFpaUmVKlWUkd1JSUkkJyczb968Yu1XQebPn09ERATr168nKSmJtWvXUq1aNSAnif/uu+8SExPDmjVrSEhIYNq0aRga5lRFSE9Pp1GjRmzbto1Tp04xaNAg+vbty+HDhwvc3rBhwzh48CA//vgjJ06coGfPnnTq1KlY/8Y8j4MHD2JjY0Pjxo2VaR06dMDAwEDvRv7p06e5desW7dq1eylxvFBCkv4lHj58KADx8OHD0g5Fz9WrV8Uff/whwsLCxI97T4qfQ/uKlBA7ISYixL2LevMeP35crFy5VISHTxJ7924RQjQSGYmzxKHGNYXvZh/x3x8HiWF7/l+p7IckSZIkSa+ftLQ0kZCQINLS0vSmJ15/KJpO2P7K/xKvl+x3mLOzs9i6dasQQohFixaJsmXL6u3LkiVLBCDi4uKEEELs3btXAOL+/ftCCCE++ugj0bFjR711jho1StStW1cIIYROpxNly5YVGzZsEEII4eHhIUJDQ4WDg4MQQogDBw4IY2Nj8fjxY711XLx4UW+7+XFychJz5szJM/3nn38Wtra2wszMTDRv3lx8+eWXIj4+vth98vDhQ6FWq4VGoxFCCBEXFycsLS3Fo0ePlHlOnz4tXFxchIGBgXBzcxODBw8Wv/zyi956/P39haGhoVCr1cLU1FQAwsDAQPz888/FiiMsLExYWVmJu3fv5tvevHlzERAQoDetZ8+ewsfHR/kMiHHjximfU1NTBSCioqKUaWXKlBHLly9XPn/11Veidu3aQqfTKdO+/fZbYWlpKbKzs4UQQnh5eYkGDRrobTv32Ni9e7cyLTQ0VADiwoULyrTBgwcLb29vIYQQ6enpwtzcXMTGxuqta+DAgcLPz09vveHh4fn2Q34mTpwo3N3d9abdv39fGBgYiCNHjgidTifs7OxEaGioaNq0qRBCiDVr1ghHR0dl/kqVKokpU6borcPT01MMHTq0WDG4u7uLiRMnKp//97//CVtbW5GamqpM27ZtmzAwMBB//vmnECLnmLG3txcZGRnKPM97Dj3N1dVVLFiwQPns5OQkunbtqjePn5+f3rEjhBC9e/cWZcqUKdb+Tpw4URgaGopr164p06KiooSBgYFITk7Od5ns7GxhZWUlIiMjhRBCzJo1S9SqVUtkZmbmmXfjxo3C2tpapKSkFCueXMeOHROAuHTpUr7t/v7+okuXLnrTcq8/c+fO1Zte1DGRu9z333+vtJ8+fVoAIjExUQiR06fvvfee3jr69OlT7H5u1qyZ6NOnT75tZ8+eFYCIiYlRpt25c0eo1Wqxfv16IYQQy5cvF4A4f/68Ms+3334r7O3tlc+bN28Wz6ayirvvz/aZv7+/cHJyUq4dQghRu3Zt0apVK+VzVlaWsLCwEOvWrRNCCLF69eo816CMjAyhVqvFjh07lPU+e64UpqTnUfv27cXUqVP11rF69WpRsWLFArexYcMGUbZsWeXz8uXLRZkyZcSZM2dElSpVRGBgoN4+FcbX11cMGDAg37bcvp42bZoyTavVisqVK4vp06cLIYSYPHmyeOedd/SWu3r1qgBEUlKSSElJEaampmLJkiXFikcIIb755hvRqFEj5XN+587w4cOFl5eXEEKIlJQUYWxsrPS5EEI8ePBAmJubi+HDhxe5vaSkJAGIXbt25dv+7O+R3G2WdL9yffbZZ6Jdu3b5fkc7duwQBgYGIikpqdjre++998TIkSOVz15eXsp+X758WRgaGorr16/rLdO+fXvx5Zdfliju/L6H/EyZMkXUqlUrz/Ty5cuL7777Tm++Hj165LuOgn7zlhY5wl2SStmePXv4888/Abh0O4VUrSEG4q9HwZ6px25kZIRWq8PYWEtmZhZgiMpMh7E2ZySRYbYgPUuWlJEkSZIk6c2XmJjIjRs3aN++PZAzSqx+/fp6L/R8euRkQet49kWkLVq04Ny5c2RnZ6NSqWjdujXR0dE8ePCAhIQEhg4dSkZGBmfOnGHfvn14enpibm7+wvare/fu3Lhxg4iICDp16kR0dDQNGzZURt0XZd26dbz11lu4u7sD4OHhgZOTEz/99JMyT926dTl16hS///47n3zyCbdu3cLX11d5YWquNm3asHbtWmJjY/H392fAgAF07969WHFoNBoaNGiAnZ1dvu0F9X1iYqLetKdHg1tYWGBtbc2tW7cK3G5iYiLNmjXTq93cokULUlNTlRGoAI0aNcp3+ae3Z29vr5QjeHpa7vbPnz/PkydP6Nixo/J0gqWlJatWrVLqSOd6elTe87CxscHd3Z3o6GhOnjyJiYkJgwYNIi4ujtTUVPbt24eXlxcAKSkp3Lhxo1j9W1yJiYm4u7tjYWGhtz6dTkdSUpIyzc3NTe8piJKeQ6mpqQQFBeHi4oKNjQ2WlpYkJibmGeH+bH8mJibStGlTvWnNmjUr0T5WrVoVR0dHveWf3r+bN28SEBCAs7MzZcqUwdramtTUVCW2nj17kpaWRo0aNQgICGDz5s3KyPCOHTvi5OREjRo16Nu3L2vXrtUrTVQQd3d32rdvj5ubGz179mTJkiV53rVQkKf7qCTHxNPnQMWKFQGUYz4pKSnPdbWo6+zTNBqNcs1+VmJiIkZGRnrfY9myZaldu7ZejObm5rz11lt6MRZ2TSjJvud3nrq6umJg8H+pMXt7e+XJBch5Kr1s2bJKDPHx8Zw/fx4rKyvlmmBnZ0d6erredeHZc6UwJT2P4uPjCQkJ0bsuBQQEkJycrBx3u3fvpn379jg6OmJlZUXfvn25e/eu3nGZlpZGq1at+OCDD5g3b16xa+L/v//3//jxxx/x8PBg9OjRecqagf75aWRkROPGjZXvIz4+nr179+rFX6dOHSCn7FRiYiIZGRkFHksAP/30Ey1atMDBwQFLS0vGjRuX5zpSmD/++AOtVqt3fJcpU6bI8j+5NBoNhoaGynW5OIqzXwXp378/Go2G2rVrExgYyM6dO/ViqVy5MrVq1cp32ezsbCZPnoybmxt2dnZYWlqyY8eOAvvr5MmTZGdnU6tWLb3vaN++fXn+7XvVtmzZ8kaUkwFZUkaSSp2RkRFCCABMDASZGP9fwv2ZkjIODg40bFgDY2MtWm0moEZlqsPqURZdd6dgk2FAerYsKVOYJxt+5vGq1UXPKEmSJElSqYqIiKBjx456CfaXoU2bNkRHR7N//34aNGiAtbW1kvh4Osn5IpmZmdGxY0fGjx9PbGws/fv3Z+LEicVadunSpZw+fRojIyPlLyEhgWXLlunNZ2BggKenJyNGjGDTpk2sWLGCpUuXcvHiRWWe3Nq+7u7uLFu2jEOHDuUpT1MQtbr4L78tzLMvLVSpVEpZmr/j6cRxQdtTqVSFbj+33vG2bdvQaDTKX0JCgl4d98K2VxK5x2LucWdnZ4eLiwsHDhx4acdiSeW3nyU5h4KCgti8eTNTp05l//79aDQa3Nzc9EpxFLSdl83f3x+NRsO8efOIjY1Fo9FQtmxZJbYqVaqQlJTEd999h1qtZujQobRu3RqtVouVlRXHjx9n3bp1VKxYkQkTJuDu7s6DBw8K3aahoSG7du0iKiqKunXrsmDBAmrXrq13nhbkefvo2XMAeCHnHLyY60J+52Tufy//Xfn1WX7bK+q60KhRI71rgkaj4ezZs3z00UeFbqswJTmPUlNTmTRpkt72T548yblz5zAzM+PSpUt07tyZ+vXrs3HjRo4dO8a3334LoHeumZqa0qFDB7Zu3cr169eLHeu7777L5cuX+fzzz5Ub48++I6Qwqamp+Pr65unDc+fO0bp16yKPo4MHD9KnTx98fHzYunUrcXFxfP3113r7ZmBgkOe4ebp00d/1PMf63zk/GjZsyMWLF5k8eTJpaWn06tVLeU9EUev95ptvmDdvHmPGjGHv3r1oNBq8vb3zXHdzpaamYmhoyLFjx/S+n8TERKU0zovm4OCQ58ZaVlYW9+7dU+rAJycnExcXx3vvvfdSYnjRZMJdkkqZkZGR8o+3kUpwwKAFP1l/ltP4TMK9fPnyNGhQ96+EexZgjsokG3W6Dp9DmdimG5L+zKh4SZ82IYHMkydLOwxJkiRJkoqwZcsWunTponyuXbs2J0+e1Kt9fuTIkULX4eLiQkxMjN60mJgYatWqpdQ2za2du2HDBqU+bps2bdi9ezcxMTEvrH57YerWrcvjx4+LnO/kyZMcPXqU6Ohovf8Ijo6O5uDBg5w5c6bQbQAFbsfAwICvvvqKcePGkZZW9O/J+vXro9FouHfvXr7tBfV9bhzPy8XFRan9/PR6raysqFy58t9a97Pq1q2LqakpV65coWbNmnp/VapUee71mpiYKLXan5Zbx33Pnj16x+K6des4e/asMs3a2ppKlSq90P51cXEhPj5e7/iIiYnBwMCgyBGfJTmHYmJi6N+/P926dcPNzQ0HBwe9l00WFt/TdXwBfv/992LvH8CVK1f0Xr73+++/6+1fTEwMgYGB+Pj4KC9afvoljpCT2PL19WX+/PnKeXfyr/+2MDIyokOHDsyYMYMTJ05w6dIlfv311yLjUqlUtGjRgkmTJhEXF4eJiQmbN28GCj5WnvWijonatWvnua4WdZ19Wv369dmzZ0++bS4uLmRlZel9j3fv3iUpKelvXRdexvlQmIYNG3Lu3DkqVKiQ57pQpkyZ515vSc6jhg0bkpSUlGf7NWvWxMDAgGPHjqHT6Zg1axZvv/02tWrVyvPiSci57q9evZpGjRrRtm3bfOcpSPny5fH392fNmjXMnTuX//3vf3rtT5+fWVlZHDt2DBcXFyX+06dPU61atTzxW1hY4OzsjFqtLvBYio2NxcnJia+//prGjRvj7OzM5cuX88SXW+M/19MvWK9RowbGxsZ6x/fDhw85e/Zssfbfzc0NnU6X530euXKfbnj6/C1qv4pibW1N7969WbJkCT/99BMbN27k3r171K9fn2vXrhUYe0xMDF26dOHjjz/G3d2dGjVqFLqfDRo0IDs7m1u3buX5for7EtSSatasGQ8ePODYsWPKtF9//RWdTqc8FRMZGUnz5s0LfLLudSMT7pJUyp5OuBsbCK6pHIkz/usxu2cS7mlpaVy+/AQjo7ZotcaAGgMrQ8p8t5B49zJotRlkZGegEy9mhMI/UZmJE7D9ZkZphyFJkiRJUiFu3brF0aNH6dy5szLto48+QqfTMWjQIBITE9mxYwczZ84EKPAx+JEjR7Jnzx4mT57M2bNnWblyJQsXLtQbiVe/fn1sbW354Ycf9JIcuS82fbZMwd9x9+5d2rVrx5o1azhx4gQXL15kw4YNzJgxQ+/mQkGWLl1KkyZNaN26NfXq1VP+WrdujaenpzI6vUePHsyZM4dDhw5x+fJloqOj+c9//kOtWrWUx/bz07NnTwwNDZWRkIXx8/PDwcGBrl27EhMTwx9//MHGjRs5ePAgkPPCvBUrVrBo0SLOnTvH7Nmz2bRpU4lGQeZn6NChXL16lc8++4wzZ86wZcsWJk6cyBdffKFXFuJFsLKyIigoiM8//5yVK1dy4cIFjh8/zoIFC1i5cuVzr7datWpcvHgRjUbDnTt3lJtIrVu35tGjR2zdulXvWFy7di0VK1bUKxcwatQopk+fzk8//URSUhJjx45Fo9EwfPjw54qpT58+mJmZ4e/vz6lTp9i7dy+fffYZffv2LfKFfiU5h5ydndm0aRMajYb4+HjlvC5KYGAg27dvZ+bMmZw7d46FCxeyffv2Eu1j7v7Fx8ezf/9+AgMD6dWrl5JAcnZ2ZvXq1SQmJnLo0CH69OmjN3I09ymRU6dO8ccff7BmzRrUajVOTk5s3bqV+fPno9FouHz5MqtWrUKn0xV5s+LQoUNMnTqVo0ePcuXKFTZt2sTt27eVxGS1atU4ceIESUlJ3Llzp9ARui/imPjss8/45ZdfmD17NufOnSMsLIyoqKhilxqZOHEi69atY+LEiSQmJnLy5EmmT58O5PRvly5dCAgI4MCBA8THx/Pxxx/j6OhYrOtfYV70+VCYPn36UK5cObp06cL+/fu5ePEi0dHRBAYG6pW1KqmSnEcTJkxg1apVTJo0idOnT5OYmMiPP/7IuHHjAKhZsyZarZYFCxbwxx9/sHr1ar2XRz/N0NCQtWvX4u7uTrt27ZRyt4WZMGECW7Zs4fz585w+fZqtW7cqx2yub7/9ls2bN3PmzBn+85//cP/+fT755BMA/vOf/3Dv3j38/Pw4cuQIFy5cYMeOHQwYMIDs7GzMzMwYM2YMo0ePVkp4/f7778q/cc7Ozly5coUff/yRCxcuMH/+fOUmVa527dpx9OhRVq1axblz55g4cSKnTp1S2q2srPD392fUqFHs3buX06dPM3DgQAwMDIp1vFerVg1/f38++eQTwsPDleNg/fr1ADg5OaFSqdi6dSu3b98mNTW1yP0qzOzZs1m3bh1nzpzh7NmzbNiwAQcHB2xsbPDy8qJ169Z0796dXbt2cfHiRaKiopRrpLOzM7t27SI2NpbExEQGDx7MzZs3C9xWrVq16NOnD/369WPTpk1cvHiRw4cPExoayrZt24qMFSAhIUG5Kf/w4UNlgECuw4cPU6dOHeXJChcXFzp16kRAQACHDx8mJiaGYcOG8eGHH1KpUiUg58nHN6WcDMiEuySVujJlyiiPSlcvp6ZtuTu0Tg3PaXwm4X737l127NgN2PxVw90clUkWat/OfNvZmFuGOfNnZuf/aJAkSZIkSdKbIDIykiZNmlCuXDllmrW1NZGRkWg0Gjw8PPj666+ZMGECQIFlZxo2bMj69ev58ccfqVevHhMmTCAkJIT+/fsr86hUKlq1aoVKpaJly5ZATuLD2tqaxo0bv9DSFpaWljRt2pQ5c+YoSfPx48cTEBDAwoULC102MzOTNWvWFFhjvXv37qxatQqtVou3tzeRkZH4+vpSq1Yt/P39qVOnDjt37sTIyKjAbRgZGTFs2DBmzJhR5Ih7ExMTdu7cSYUKFfDx8cHNzY1p06YpTw507dqVefPmMXPmTFxdXQkLC2P58uV/+4kBR0dHfvnlFw4fPoy7uztDhgxh4MCBSqLpRZs8eTLjx48nNDRUSQhs27aN6tWrP/c6u3fvTqdOnWjbti3ly5dn3bp1ANja2uLm5kb58uWVGyOtW7dGp9PlKScTGBjIF198wciRI3Fzc2P79u1ERETg7Oz8XDGZm5uzY8cO7t27h6enJz169KB9+/ZFHpdQsnNo9uzZ2Nra0rx5c3x9ffH29qZhw4ZFbuPtt99myZIlzJs3D3d3d3bu3Fni77xmzZp88MEH+Pj48M4771C/fn2+++47pX3p0qXcv3+fhg0b0rdvXwIDA6lQoYLSbmNjw5IlS2jRogX169dn9+7dREZGUrZsWWxsbNi0aRPt2rXDxcWFxYsXs27dOlxdXQuNydramt9++w0fHx9q1arFuHHjmDVrFu+++y4AAQEB1K5dm8aNG1O+fPk8o7if9iKOiRYtWrB48WJmz56Nu7s727dv5/PPPy92aa82bdqwYcMGIiIi8PDwoF27dhw+fFhpX758OY0aNaJz5840a9YMIQS//PJLnhIuJfWiz4fCmJub89tvv1G1alU++OADXFxcGDhwIOnp6VhbWz/3ektyHnl7e7N161Z27tyJp6cnb7/9NnPmzMHJyQnIeTfA7NmzmT59OvXq1WPt2rWEhoYWuG0jIyPleG3Xrl2hNfMh5/r/5ZdfUr9+fVq3bo2hoSE//vij3jzTpk1j2rRpuLu7c+DAASIiIpR/03OfSMjOzuadd97Bzc2NESNGYGNjo9w4HT9+PCNHjmTChAm4uLjQu3dvJa7333+fzz//nGHDhuHh4UFsbCzjx4/X2763tzfjx49n9OjReHp68ujRI/r166c3z+zZs2nWrBmdO3emQ4cOtGjRAhcXl2If74sWLaJHjx4MHTqUOnXqEBAQoPzb6ejoyKRJkxg7diz29vYMGzasyP0qjJWVFTNmzKBx48Z4enpy6dIlfvnlF6W/Nm7ciKenJ35+ftStW5fRo0cro+vHjRtHw4YN8fb2pk2bNsrN8sIsX76cfv36MXLkSGrXrk3Xrl05cuQIVatWLVbf+Pj40KBBAyIjI4mOjqZBgwY0aNBAaX/y5AlJSUl6NxHXrl1LnTp1aN++PT4+PrRs2VJ5cuLx48fs2bPnjUq4q8SLKoYlSa+5lJQUypQpw8OHD//WP4Qvy7Jly/D09OTPU7vomDQyZ+IHa6B+H2WeP//8k4iICOrVS+PsWUv69z+E0JXn8ffV+LhcOF5XLdjr9JiVndZga2ZbSnsiSZIkSdLrIj09nYsXL1K9enW9/4D880EavRYcIDPr1T0VZ2JkwPrPWuJgU3QN0/fff5+WLVsyevToQudbu3YtAwYM4OHDhy+spvi/SXZ2NnFxcTRo0EBJlEvSP1FwcDDh4eF6Iyyl4gkICODMmTPs37+/tEOR3gCXLl2ievXqxMXF4eHhUdrhlMjjx49xdHRk1qxZDBw4sLTDkZ6yadMmxo0bR0JCQoHzFPSbt7QUPLxBkqRXysjIiPuP0rjz9KB2rX79zNw7/4aG59Fq3RBCDaTzcFIIxnPdICvnDmZGdvorilqSJEmSpDeRg42a9Z+15MGTF/cCsaLYmBsXK9kO0LJlS/z8/PJMX7VqFTVq1MDR0ZH4+HjGjBlDr169ZLJdkiTpBZk5cyYdO3bEwsKCqKgoVq5cqfckgCT9U8TFxXHmzBmaNGnCw4cPCQkJAfjbJY6kF8/S0lIpT/WmkAl3SSpl+/fvJzU1FSMjIy7desSJq6n4ARia5Skpk/sIsEplhBCQnW2BkdEDMDbGOAvEX48MpWdlIEmSJEmSVBgHG3WxE+CvWkEj2//8808mTJjAn3/+ScWKFenZsydTpkx5xdG9PGvXrmXw4MH5tjk5OXH69OlXFsvUqVOZOnVqvm2tWrUiKirqlcXypnF1dc3zAr9cYWFh9OnTJ9+2F+Xf+N0V1eel5cqVK4W+uDMhIaHYJRpelcOHDzNjxgwePXpEjRo1mD9/Pp9++ilQ+sf2m2r//v1KmaD8pKamvsJoijZkyBDWrFmTb9vHH39cYD34N9HMmTNJSkrCxMSERo0asX//fsqVK/fKv7M36br97rvvFvjEy1dffcVXX331wrf5zjvvvPB1vmyypIz0r/G6lpT57bffuHv3LlqtlkwTG36PO85C1ZdgagMtx0Crscq8T548ITIyklq1DnLkSF369r2FWn2BG3UOMTewOm/dVLGtgWBG65nUsXMpeKOSJEmSJP0rvG6P10qFe/ToUYEvMjM2Nlbq874ohZWUuXfvHvfu3ct3ObVajaOj4wuN5Z/k8uXLBb7c0t7eHisrq5e6/X/jd1fafV6QrKwsLl26VGB7tWrVCn2vwuvmde3n111aWprycsj81KxZ8xVGU7Rbt26RkpKSb5u1tbXeuw3+qV71d/YmXbevX79OWlpavm12dnbY2dm94ohyvG6/ed+cK7sk/UMZGRmRlZWFkZERWnTcwY5faUk74z/yjHA3Nzend+/eXL++BwCtVo1a/QSVmRlBvxhy2zidbQ2MSc+SJWUkSZIkSZLeNFZWVq9Nwqo0/6P5Tfeib4yU1L/xuyvtPi+IkZHRa5dM/Tte135+3anV6jfqOKhQocK/IqlemFf9nb1J1+3XKfn/OjMo7QAk6d/u6YS7Sui4hBNfiXEIU6s8CfdcxsYtAMjMNAPSMWvfDoNyZTF5lJNoT5c13CVJkiRJkiRJkiRJkiTplZMJd0kqZbkJd2NjYwzR4WBlSAVuIwxNISvvYzqrV6/m2jU3ADIyTIEn2M6ayTfeWsKb5TwKLEe4S5IkSZIkSZIkSZIkSdKrJxPuklTKateujY+PD4aGhlibGTK2pZoIVV90uux8R7hnZ2cjxH0A0tJyEu66hw/RIchU6VChkiPcC3FodRwx/ztS2mFIkiRJkiRJkiRJkiRJ/0Ay4S5JpczCwoKyZcv+30h3UzUAQmWcb8Ld2NgYIY5gaKgjLc0QyODuJ/0xvPsArYEOMyMzMuQI9wJZlbfAyt6ytMOQJEmSJEmSJEmSJEmS/oHkS1MlqZTdvn2bpKQkDA0NefQknSlbz7EJ0BkY5Ztwz0nMG6NWa/9KuIOBtSnG2ZloDcDU0JQ0mXAvUN1OtUo7BEmSJEmSJEmSJEmSJOkfSo5wl6RS9ujRIxISEjA0NESXnc2jrJwkuk5VcMJdqzVCrc4kPV0FgMrGBGOtIMtYhZmBKRmypIwkSZIkSUW4/eQWFx6cf2V/t5/ceun7FB0djUql4sGDBy99W9KrERMTg5ubG8bGxnTt2rW0w/nHOHPmDG+//TZmZmZ4eHiUdjjPZcWKFdjY2JR2GC9FmzZtGDFiRKHzVKtWjblz5yqfVSoV4eHhLzUuSZIkqXjkCHdJKmVGRjmnoUqlQpedTSa5JWUMQZv3pant2rXD2HglBw6k8+SJAMDA2pgPYrLIvnCNpY3qypemFkJ7OgGRpcXE3b20Q5EkSZKkUnP7yS2G7B6EVqd9Zds0NjBmcYf/Ud68QomWGzBgAI6Ojvz3v/99SZEVT5s2bdi3b1+B7V5eXoW2AwghuH37NhMmTGDbtm3cvHkTW1tb3N3dmTBhAi1atCh2PKGhoYwbN45p06YxatQovbbs7Gy++eYbVqxYweXLl1Gr1Tg7OxMQEMCnn34KQP/+/Vm5ciWQ83u0cuXK9OzZk5CQEMzMzIodx8v2xRdf4OHhQVRUFJaW/4yygMHBwYSHh6PRaEothokTJ2JhYUFSUtI/pl//7ZKTk7G1tX0l26pWrRojRowo8qbA6yAtLY1y5coRHx9PzZo1SzscSZL+JWTCXZJKWW7C3cDAgOzsLDIwpbWIYLNNBOb38r7cM+dHVBnU6kfcv6/LWdbakPL3s8i6q8VUZSxfmlqIRwsWoHv4kHLrfijtUCRJkiSp1KRkprzSZDuAVqclJTOlRAn37Oxstm7dyrZt215iZMWzadMmMjMzAbh69SpNmjRh9+7duLq6ApCZmYmJiYkyv6enJ4MGDSIgIEBvPd27dyczM5OVK1dSo0YNbt68yZ49e7h7926J4lm2bBmjR49m2bJleRLukyZNIiwsjIULF9K4cWNSUlI4evQo9+/f15vP29ubESNGUKdOHTQaDf7+/qhUKqZPn16iWF6mCxcuMGTIECpXrvzc63j2u3mZhBBkZ2crv/FfVxcuXOC9997Dycnpudfxqvr1VX5/bzIHB4fSDuGl0Gq1GBsbP/fyu3btwsnJSSbbJUl6pWRJGUkqZU//eNRlZwEqMjEhy1Cdb0mZM2fOcPJkY9Rqb9LSsgCwHDaQxAkfE/mePWYYyRHuhSgzdSq2CxeUdhiSJEmSJBVDbGwsxsbGeHp6Kp89PDwwMzOjcePGhIeHo1KpCh0pvHHjRlxdXTE1NaVatWrMmjVLaVu4cCH16tVTPueub/Hixcq0Dh06MG7cOOzs7HBwcMDBwYHy5csDULZsWWVa1apVlf/v4OCAoaEhVlZWetMePHjA/v37mT59Om3btsXJyYkmTZrw5Zdf8v777xe7X/bt20daWhohISGkpKQQGxur1x4REcHQoUPp2bMn1atXx93dnYEDBxIUFKQ3n6mpKeXKlaNKlSp07dqVDh06sGvXrmLHce3aNfz8/LCzs8PCwoLGjRtz6NAhpX3RokW89dZbmJiYULt2bVavXq23vEql4vvvv6dbt26Ym5vj7OxMREQEAJcuXUKlUnH37l0++eQTVCoVK1asUPa/SZMmmJqaUrFiRcaOHUtWVpay3jZt2jBs2DBGjBhBuXLl8Pb2VsoN7dixgwYNGqBWq2nXrh23bt0iKioKFxcXrK2t+eijj3jy5P9+g+t0OkJDQ6levTpqtRp3d3d+/vlnpT13vVFRUTRq1AhTU1MOHDhQYJ+tWLGCSZMmER8fj0qlUvYrKCiIzp07K/PNnTsXlUrF9u3blWk1a9bk+++/V+IKCQmhcuXKmJqa4uHhoTdvYVQqFceOHSMkJASVSkVwcDAAJ0+epF27dqjVasqWLcugQYNITU1Vluvfvz9du3ZlypQpVKpUidq1a5foHIKcRH+XLl2wt7fH0tIST09Pdu/erRdftWrVmDx5Mv369cPa2ppBgwYpfVe1alXMzc3p1q1biW5SBQcH4+HhQVhYGFWqVMHc3JxevXrx8OFDZZ4jR47QsWNHypUrR5kyZfDy8uL48eNKuxCC4OBgqlatiqmpKZUqVSIwMFBp/+6773B2dsbMzAx7e3t69OhRrNgeP35Mv379sLS0pGLFinrXqFy3bt3C19cXtVpN9erVWbt2bZ55SlJSZsyYMdSqVQtzc3Nq1KjB+PHj0Wr1b8JGRkbi6emJmZkZ5cqVo1u3bkDO+XX58mU+//xz5RiG/yvxs2PHDlxcXLC0tKRTp04kJycr6yzquM0973/66Se8vLwwMzNj7dq1yrE3depU7O3tsbGxISQkhKysLEaNGoWdnR2VK1dm+fLlefZ1y5YtJbq+SpIkvQgy4S5Jpczc3Jx69ephZmaW8/ivnwezGY/Rw0v5Jtxv3LjBpUuXMDMzIy0tZ5SVgWk2fxje5UhjG0yFoazhXghDO1sMy5Yt7TAkSZIkSSqGiIgIfH19UalUpKSk4Ovri5ubG8ePH2fy5MmMGTOm0OWPHTtGr169+PDDDzl58iTBwcGMHz9eSdx6eXmRkJDA7du3gZxEbrly5YiOjgZyRlYePHiQNm3avJD9sbS0xNLSkvDwcDIyMp57PUuXLsXPzw9jY2P8/PxYunSpXruDgwO//vqrsl/FcerUKWJjY4s9kjg1NRUvLy+uX79OREQE8fHxjB49Gp0u5wnMzZs3M3z4cEaOHMmpU6cYPHgwAwYMYO/evXrrmTRpEr169eLEiRP4+PjQp08f7t27R5UqVUhOTsba2pq5c+eSnJxM7969uX79Oj4+Pnh6ehIfH8+iRYtYunRpnpJDK1euxMTEhJiYGL3kb3BwMAsXLiQ2NparV6/Sq1cv5s6dyw8//MC2bdvYuXMnCxb83+CM0NBQVq1axeLFizl9+jSff/45H3/8cZ7yQWPHjmXatGkkJiZSv379Avutd+/ejBw5EldXV5KTk5X98vLy4sCBA2RnZwN5j8Xr169z4cIF5VicN28es2bNYubMmZw4cQJvb2/ef/99zp07V+R3l5ycjKurKyNHjiQ5OZmgoCAeP36Mt7c3tra2HDlyhA0bNrB7926GDRumt+yePXtISkpi165dbN26tcTnUGpqKj4+PuzZs4e4uDg6deqEr68vV65c0dvOzJkzcXd3Jy4ujvHjx3Po0CEGDhzIsGHD0Gg0tG3btsRlps6fP8/69euJjIxk+/btxMXFMXToUKX90aNH+Pv7c+DAAX7//XecnZ3x8fHh0aNHQM7Nuzlz5hAWFsa5c+cIDw/Hzc0NgKNHjxIYGEhISAhJSUls376d1q1bFyuuUaNGsW/fPrZs2cLOnTuJjo7WS/RDzs2Oq1evsnfvXn7++We+++47bt16/vdiWFlZsWLFChISEpg3bx5Llixhzpw5Svu2bdvo1q0bPj4+xMXFsWfPHpo0aQLkPO1TuXJlQkJClGM415MnT5g5cyarV6/mt99+48qVK3o3+op73I4dO5bhw4eTmJiIt7c3AL/++is3btzgt99+Y/bs2UycOJHOnTtja2vLoUOHGDJkCIMHD+batWvKenQ6HVu3bqVLly7P3VeSJEnPRUjSv8TDhw8FIB4+fFjaoeTr7NmzIiwsTNy8nyoeTLASdxa3EyLUNs98+/btE5s2LRdnzwaIsLAwkZnZVKQf/K9YMqW76Lesg5gRNVqM+W1UKeyBJEmSJEmvm7S0NJGQkCDS0tL0pp+/f074bvZ55X/n758rUfzOzs5i69atQgghFi1aJMqWLau3L0uWLBGAiIuLE0IIsXfvXgGI+/fvCyGE+Oijj0THjh311jlq1ChRt25dIYQQOp1OlC1bVmzYsEEIIYSHh4cIDQ0VDg4OQgghDhw4IIyNjcXjx4/11nHx4kW97ebHyclJzJkzJ8/0n3/+Wdja2gozMzPRvHlz8eWXX4r4+Phi98nDhw+FWq0WGo1GCCFEXFycsLS0FI8ePVLmOX36tHBxcREGBgbCzc1NDB48WPzyyy966/H39xeGhoZCrVYLU1NTAQgDAwPx888/FyuOsLAwYWVlJe7evZtve/PmzUVAQIDetJ49ewofHx/lMyDGjRunfE5NTRWAiIqKUqaVKVNGLF++XPn81Vdfidq1awudTqdM+/bbb4WlpaXIzs4WQgjh5eUlGjRooLft3GNj9+7dyrTQ0FABiAsXLijTBg8eLLy9vYUQQqSnpwtzc3MRGxurt66BAwcKPz8/vfWGh4fn2w/5mThxonB3d9ebdv/+fWFgYCCOHDkidDqdsLOzE6GhoaJp06ZCCCHWrFkjHB0dlfkrVaokpkyZorcOT09PMXTo0GLF4O7uLiZOnKh8/t///idsbW1FamqqMm3btm3CwMBA/Pnnn0KInGPG3t5eZGRkKPM87zn0NFdXV7FgwQLls5OTk+jatavePH5+fnrHjhBC9O7dW5QpU6ZY+ztx4kRhaGgorl27pkyLiooSBgYGIjk5Od9lsrOzhZWVlYiMjBRCCDFr1ixRq1YtkZmZmWfejRs3Cmtra5GSklKseHI9evRImJiYiPXr1yvT7t69K9RqtRg+fLgQQoikpCQBiMOHDyvzJCYmCkDvGgOIzZs3l2j7ub755hvRqFEj5XOzZs1Enz59Cpw/v+vb8uXLBSDOnz+vTPv222+Fvb298rmo4zb32jp37ly9efz9/YWTk5NyjgshRO3atUWrVq2Uz1lZWcLCwkKsW7dOmRYTEyMqVKigt5wkSf9MBf3mLS1yhLsklTIhBDdv3lRGAy3de5ZMjBFCBVl5X5pqbGyMVqtDrb4JQFqaGt2jWxhcTSbT2ACzbENZUkaSJEmSpDdeYmIiN27coH379gAkJSVRv359vRd65o64LGwdz76ItEWLFpw7d47s7GxUKhWtW7cmOjqaBw8ekJCQwNChQ8nIyODMmTPs27cPT09PzM3NX9h+de/enRs3bhAREUGnTp2Ijo6mYcOGyqj7oqxbt4633noL979eAO/h4YGTkxM//fSTMk/dunU5deoUv//+O5988olSjiL3ham52rRpw9q1a4mNjcXf358BAwbQvXv3YsWh0Who0KABdnZ2+bYX1PeJiYl6054eDW5hYYG1tXWhI3cTExNp1qyZUsYid72pqal6I1sbNWqU7/JPb8/e3l4pqfH0tNztnz9/nidPntCxY0fl6QRLS0tWrVrFhQsX9NbbuHHjAmMuDhsbG9zd3YmOjubkyZOYmJgwaNAg4uLiSE1NZd++fXh5eQGQkpLCjRs3itW/xZWYmIi7uzsWFhZ669PpdCQlJSnT3Nzc9J6CKOk5lJqaSlBQEC4uLtjY2GBpaUliYmKeEe7P9mdiYiJNmzbVm9asWbMS7WPVqlVxdHTUW/7p/bt58yYBAQE4OztTpkwZrK2tSU1NVWLr2bMnaWlp1KhRg4CAADZv3qyUMurYsSNOTk7UqFGDvn37snbtWr3SRAW5cOECmZmZevtmZ2dH7dq19fbdyMhI75iuU6cONjY2Jdr/p/3000+0aNECBwcHLC0tGTdunN53oNFolGtvSZibm/PWW28pnytWrKicTyU5bvM7n1xdXTEw+L8Ulr29vfKEAYChoSFly5bVu35s2bKFzp076y0nSZL0KsirjiSVMiEEW7Zs4d69ewDsPnkDLcboBJCVDn8l4nMZGRmRlQVqdU4yPj3dEgNzFcbpWrKMVZhlG5CWT6JekiRJkiTpTRIREUHHjh31EuwvQ5s2bYiOjmb//v00aNAAa2trJYH4dJLzRTIzM6Njx46MHz+e2NhY+vfvz8SJE4u17NKlSzl9+jRGRkbKX0JCAsuWLdObz8DAAE9PT0aMGMGmTZtYsWIFS5cu5eLFi8o8FhYWVKlSBXd3d5YtW8ahQ4fylKcpiFqtLv4OF+LZlyGqVCplIMrf8XTiuKDtqVSqQrefW79827ZtaDQa5S8hIUGvjnth2yuJ3GMx97izs7PDxcWFAwcOvLRjsaTy28+SnENBQUFs3ryZqVOnsn//fjQaDW5ubsoLiQvbzsvm7++PRqNh3rx5xMbGotFoKFu2rBJblSpVSEpK4rvvvkOtVjN06FBat26NVqvFysqK48ePs27dOipWrMiECRNwd3fnwYMHr3w/inLw4EH69OmDj48PW7duJS4ujq+//lrvO3je8zu/80kIUeL15Pf957fuoq4fERERsn67JEmlQibcJamUGRgYYGRkpPwQMTUQZGKMTvz1Q+GZ5HnFihWpXbusknBPS7NBpRY4XUihTfRdzLQq0rKKHk0hSZIkSZL0OtuyZYte3d3atWtz8uRJvdrnR44cKXQdLi4uxMTE6E2LiYmhVq1aGBoaAv9Xx33Dhg1Knek2bdqwe/duYmJiXlj99sLUrVuXx48fFznfyZMnOXr0KNHR0XoJ4OjoaA4ePMiZM2cK3QZQ4HYMDAz46quvGDduHGlpRQ/eqF+/PhqNRhk08qyC+j43jufl4uLCwYMH9ZJ4MTExWFlZUbly5b+17mfVrVsXU1NTrly5Qs2aNfX+qlSp8tzrNTExUWq1Py23jvuePXv0jsV169Zx9uxZZZq1tTWVKlV6of3r4uJCfHy83vERExODgYGB3mjr/JTkHIqJiaF///5069YNNzc3HBwcuHTpUrHie/qFvAC///57sfcP4MqVK9y4cUNv+af3LyYmhsDAQHx8fJQXLd+5c0dvHWq1Gl9fX+bPn6+cdydPngRyBkZ16NCBGTNmcOLECS5dusSvv/5aaExvvfUWxsbGevt2//59zp49q3yuU6cOWVlZHDt2TJmWlJT03Mn82NhYnJyc+Prrr2ncuDHOzs5cvnxZb5769euzZ8+eAtdR0DFcmJdx3Bbm3LlzXL58mY4dO77wdUuSJBVFJtwl6TVgbGys3IlXG6v4n6o/N23/eqzwmRenVq5cmUaNnDAzyykbk5ZmhUoteOvCY7puvYWZVsgR7pIkSZIkvdFu3brF0aNH6dy5szLto48+QqfTMWjQIBITE9mxYwczZ84E0Csv8rSRI0eyZ88eJk+ezNmzZ1m5ciULFy7Ue4lf/fr1sbW15YcfftBLFua+2PTZ8gd/x927d2nXrh1r1qzhxIkTXLx4kQ0bNjBjxoxivdRv6dKlNGnShNatW1OvXj3lr3Xr1nh6eiqj03v06MGcOXM4dOgQly9fJjo6mv/85z/UqlWLOnXqFLj+nj17YmhoyLfffltkLH5+fjg4ONC1a1diYmL4448/2LhxIwcPHgRyXgS5YsUKFi1axLlz55g9ezabNm3S6/vnMXToUK5evcpnn33GmTNn2LJlCxMnTuSLL7544WUjrKysCAoK4vPPP2flypVcuHCB48ePs2DBAlauXPnc661WrRoXL15Eo9Fw584d5SZS69atefToEVu3btU7FteuXUvFihWpVauWso5Ro0Yxffp0fvrpJ5KSkhg7diwajYbhw4c/V0x9+vTBzMwMf39/Tp06xd69e/nss8/o27cv9vb2hS5bknPI2dmZTZs2odFoiI+PV87rogQGBrJ9+3ZmzpzJuXPnWLhwIdu3by/RPubuX3x8PPv37ycwMJBevXrh4OCgxLZ69WoSExM5dOgQffr00RvpnfuUyKlTp/jjjz9Ys2YNarUaJycntm7dyvz589FoNFy+fJlVq1ah0+mKvFlhaWnJwIEDGTVqFL/++iunTp2if//+esdy7dq16dSpE4MHD+bQoUMcO3aMTz/99LlHoTs7O3PlyhV+/PFHLly4wPz589m8ebPePBMnTmTdunVMnDiRxMRETp48yfTp05X2atWq8dtvv3H9+vU8NyUK86KP28Js2bKFDh06vNCSYJIkScUlE+6S9BowMjJSfmiaGcF+g9bcsfjrLv8zCff09HSSk61Rqb7D1NSUtDQLDCvZYjh9Eufq2mKSqSMjO4NsUbIRB5IkSZIkSa+LyMhImjRpQrly5ZRp1tbWREZGotFo8PDw4Ouvv2bChAkABZadadiwIevXr+fHH3+kXr16TJgwgZCQEPr376/Mo1KpaNWqFSqVipYtWwI5CURra2saN278QktbWFpa0rRpU+bMmaMkzcePH09AQAALFy4sdNnMzEzWrFlTYI317t27s2rVKrRaLd7e3kRGRuLr60utWrXw9/enTp067Ny5EyMjowK3YWRkxLBhw5gxY0aRI+5NTEzYuXMnFSpUwMfHBzc3N6ZNm6Y8OdC1a1fmzZvHzJkzcXV1JSwsjOXLl//tJwYcHR355ZdfOHz4MO7u7gwZMoSBAwcybty4v7XegkyePJnx48cTGhqKi4sLnTp1Ytu2bVSvXv2519m9e3c6depE27ZtKV++POvWrQPA1tYWNzc3ypcvr9wYad26NTqdLk85mcDAQL744gtGjhyJm5sb27dvJyIiAmdn5+eKydzcnB07dnDv3j08PT3p0aMH7du3L/K4hJKdQ7Nnz8bW1pbmzZvj6+uLt7c3DRs2LHIbb7/9NkuWLGHevHm4u7uzc+fOEn/nNWvW5IMPPsDHx4d33nmH+vXr89133yntS5cu5f79+zRs2JC+ffsSGBhIhQoVlHYbGxuWLFlCixYtqF+/Prt37yYyMpKyZctiY2PDpk2baNeuHS4uLixevJh169bh6upaZFzffPMNrVq1wtfXlw4dOtCyZcs87yBYvnw5lSpVwsvLiw8++IBBgwbpxVYS77//Pp9//jnDhg3Dw8OD2NhYxo8frzdPmzZt2LBhAxEREXh4eNCuXTsOHz6stIeEhHDp0iXeeustypcvX+xtv+jjtjBbtmyR5WQkSSo1KvE8BbUk6Q2UkpJCmTJlePjwIdbW1qUdjp7IyEjs7Ow4ffo0VHLnsmY371dLp+n5/8J/EqC8izLv+fPn+fXXXxkwYADh4eE4Op6ieXMTfr/RjqmH/8und1z5vtxp1r23HgvjV1/7UJIkSZKk10d6ejoXL16kevXqeknp209uMWT3ILQ67SuLxdjAmMUd/kd586KTRO+//z4tW7Zk9OjRhc63du1aBgwYwMOHD19YTfF/k+zsbOLi4mjQoIGSKJekf6Lg4GDCw8PRaDSlHYr0Cty5c4eKFSty7dq1Ip/QkCTpn6Gg37ylpeDhDZIkvTK+vr6kp6dz+vRpOrpW4GHcJsre+es/GrX65WFyRyVptf/DzKw8aWlqdOl30B04CCZgkJnzH85pWWky4Z6P8/svodPqqNWuRmmHIkmSJEmlprx5BRZ3+B8pmSmvbJvWJtbFSrYDtGzZEj8/vzzTV61aRY0aNXB0dCQ+Pp4xY8bQq1cvmWyXJEmSFPfu3WP27Nky2S5JUqmRCXdJek3kJtKv3XmEmcoEdH+VhHmmpEzum9izsn5GrR5AeroppN8j49ut8PlbGKZnAcgXpxYg+dRNMtO0MuEuSZIk/euVN69Q7AT4q1bQyPY///yTCRMm8Oeff1KxYkV69uzJlClTXnF0L8/atWsZPHhwvm1OTk45T0O+IlOnTmXq1Kn5trVq1YqoqKhXFsubxtXVNc9LKHOFhYXRp0+fl7r9f+N3V1Sfl5YrV64U+kLQhIQEqlat+kK3+W/8/p9Vq1YtvXceSJIkvWoy4S5Jr4GYmBjS03Neghpx7Arv64xB/DWy/ZmEe25iPitLjVqdzf37xmCkxTgrpwa8QWYmgHxxagFa/b+mpR2CJEmSJEnPafTo0UWWmXmTvf/++zRtmv9vldxBF6/KkCFD6NWrV75t8omCwv3yyy9otfmXa3oVI27/jd9dUX1uZWVFcHDwqw0KqFSpUqFlbCpVqvTCt/lv/P4lSZJeNzLhLkmvAa1WS2pqKkZGRphkCbJUxqh0qX815h3hrlar0enMUauzSE83AiMtphk6yjwWGKfljnCXCXdJkiRJkqQ3iZWVFVZWVqUdBgB2dnbY2dmVdhhvJCcnp1Ld/r/xuyvtPi+IkZERNWvWfKXb/Dd+/5IkSa8bg9IOQJKknB9iWq0WY2NjjA0EF1U1SDb7603tzyTc7ezs6Nu3L+XKZaNWZ5KerkKoMqiUnMGstSqq3855D3KaVibcJUmSJEmSJEmSJEmSJOlVkgl3SXoNGBsbo9VqMTIywkgl2GDyEZH2Y3MaCxyp3gm12hEhVGRkCUw8PVGpzTF7lAFAWrZMuOfn3pD/xx2/j0o7DEmSJEmSJEmSJEmSJOkfSCbcJek1YGxsTFZWFkZGRqiNVJiodOiy0sDILM8I96ysLNatW8elS96Ymb0NQHqGCrP1KxndM5PEMo8xVBnKkjIFsPj4YywHBZR2GJIkSZIkSZIkSZIkSdI/kKzhLkmvgZo1a1KxYkV+//13PKvb0OjhMlwv/grG5nkS7gYGBjx69Ij09FvY2ubU+ExLU2FqLrhrlkWaEKiNrGTCvQCmLVuUdgiSJEmSJEmSJEmSJEnSP5Qc4S5JrwFra2sqVqyIkZERWVlZCENTDHWZBSbcDQ0Nycrai1o9F4C0NGPuNmgIQKZOi5mRWtZwlyRJkiRJkiRJkiRJkqRXTCbcJek1cP/+fQ4fPoyBgQFnbzzgeko2RiL/hDvwV2LeFGPjRxgaqkhPN8OojBkqHWh1WtRGajnCXZIkSZKkQj26/ZjbF+6+sr9Htx+/9H2Kjo5GpVLx4MGDl74t6dWIiYnBzc0NY2NjunbtWtrh/GOcOXOGt99+GzMzMzw8PEo7nOeyYsUKbGxsSjsMqRQEBwdjb2+PSqUiPDy8tMORntGmTRtGjBhR2mFIUqmSJWUk6TXw6NEjNBoNVapUITsri7Rso6cS7nkT57kJd5UqFbXaiLQ0NYY2ZhjrIFPkJtzzJuolSZIkSZIgJ9n+0//bQrZW98q2aWhsQO9FXbAqb1Gi5QYMGICjoyP//e9/X1JkxdOmTRv27dtXYLuXl1eh7QBCCG7fvs2ECRPYtm0bN2/exNbWFnd3dyZMmECLFsUvfRcaGsq4ceOYNm0ao0aN0mvLzs7mm2++YcWKFVy+fBm1Wo2zszMBAQF8+umnAPTv35+VK1cCOb8tK1euTM+ePQkJCcHMzKzYcbxsX3zxBR4eHkRFRWFpaVna4bwQwcHBhIeHo9FoSi2GiRMnYmFhQVJS0j+mX/+J+vfvz4MHD2RS+SmJiYlMmjSJzZs38/bbb2Nra1vaIb100dHRtG3blvv37/8rbzKdOHGC//znPxw5coTy5cvz2WefMXr06EKXCQwMJCYmhlOnTuHi4lLg9Xbfvn18/PHHXL169SVELv2byYS7JL0GjI2NgZxyMQboyMAEI6EFI3W+I9zbt2+PuXkU8Bi12pi0NDUGtiZ8Hq3G5vhFkvzlCHdJkiRJkgqWnpL+SpPtANlaHekp6SVKuGdnZ7N161a2bdv2EiMrnk2bNpGZmQnA1atXadKkCbt378bV1RWAzMxMTExMlPk9PT0ZNGgQAQH6L2vv3r07mZmZrFy5kho1anDz5k327NnD3bt3SxTPsmXLGD16NMuWLcuTcJ80aRJhYWEsXLiQxo0bk5KSwtGjR7l//77efN7e3owYMYI6deqg0Wjw9/dHpVIxffr0EsXyMl24cIEhQ4ZQuXLl517Hs9/NyySEIDs7GyOj1/s/tS9cuMB7772Hk5PTc6/jVfXrq/z+3lRarVb5b8p/ugsXLgDQpUsXVCrVc6/nVfaZPIafX0pKCu+88w4dOnRg8eLFnDx5kk8++QQbGxsGDRpU6LKffPIJhw4d4sSJEwXOs2XLFnx9fV902JIkS8pI0usg9x96lUqFCh3bDd5haJkf/xrhnvfxawcHB6ytrQFQq81yEu5lTKh1yxCbP1NlSRlJkiRJkv4RYmNjMTY2xtPTU/ns4eGBmZkZjRs3Jjw8HJVKVehI4Y0bN+Lq6oqpqSnVqlVj1qxZStvChQupV6+e8jl3fYsXL1amdejQgXHjxmFnZ4eDgwMODg6UL18egLJlyyrTqlatqvx/BwcHDA0NsbKy0pv24MED9u/fz/Tp02nbti1OTk40adKEL7/8kvfff7/Y/bJv3z7S0tIICQkhJSWF2NhYvfaIiAiGDh1Kz549qV69Ou7u7gwcOJCgoCC9+UxNTSlXrhxVqlSha9eudOjQgV27dhU7jmvXruHn54ednR0WFhY0btyYQ4cOKe2LFi3irbfewsTEhNq1a7N69Wq95VUqFd9//z3dunXD3NwcZ2dnIiIiALh06RIqlYq7d+/yySefoFKpWLFihbL/TZo0wdTUlIoVKzJ27FiysrKU9bZp04Zhw4YxYsQIypUrh7e3t1JuaMeOHTRo0AC1Wk27du24desWUVFRuLi4YG1tzUcffcSTJ/834EWn0xEaGkr16tVRq9W4u7vz888/K+25642KiqJRo0aYmppy4MCBAvtsxYoVTJo0ifj4+Jzf/n/tV1BQEJ07d1bmmzt3LiqViu3btyvTatasyffff6/EFRISQuXKlTE1NcXDw0Nv3sKoVCqOHTtGSEgIKpWK4OBgAE6ePEm7du1Qq9WULVuWQYMGkZqaqizXv39/unbtypQpU6hUqRK1a9cu0TkEOcnSLl26YG9vj6WlJZ6enuzevVsvvmrVqjF58mT69euHtbW1klRbsWIFVatWxdzcnG7dupXoJlVwcDAeHh6EhYVRpUoVzM3N6dWrFw8fPlTmOXLkCB07dqRcuXKUKVMGLy8vjh8/rrQLIQgODqZq1aqYmppSqVIlAgMDlfbvvvsOZ2dnzMzMsLe3p0ePHsWK7eeff8bNzU3p9w4dOvD48WOCg4NZuXIlW7ZsUY6V6Oho5dz46aef8PLywszMjLVr1xZ5TOQut2nTJtq2bYu5uTnu7u4cPHhQL54lS5YofdStWzdmz55dolHVkZGReHp6YmZmRrly5ejWrZvSdv/+ffr164etrS3m5ua8++67nDt3TmnPLRO0Y8cOXFxcsLS0pFOnTiQnJwM532NuctTAwEBJuBd335/ts9xjeurUqdjb22NjY0NISAhZWVmMGjUKOzs7KleuzPLly/X28erVq/Tq1QsbGxvs7Ozo0qULly5dUtrzO1eKkpGRwZgxY6hSpQqmpqbUrFmTpUuXcunSJdq2bQuAra0tKpWK/v37K/s9Y8YMatasiampKVWrVmXKlClFbiszM5Nhw4ZRsWJFzMzMcHJyIjQ0VGl/8OABgwcPxt7eHjMzM+rVq8fWrVsBuHv3Ln5+fjg6OmJubo6bmxvr1q0rct+CgoJwdHTEwsKCpk2bEh0dXWScAGvXriUzM5Nly5bh6urKhx9+SGBgILNnzy50ufnz5/Of//yHGjVqFDpfREREif79laTikgl3SXoN5I6AMTAwwEDoSMOM28IOTCwhM2/CPSkpifPn3YE9mJmpSUtTYzPlK/Z+4MzJupaoVaYy4S5JkiRJ0hsvIiICX19fVCoVKSkp+Pr64ubmxvHjx5k8eTJjxowpdPljx47Rq1cvPvzwQ06ePElwcDDjx49XErdeXl4kJCRw+/ZtICeRW65cOSURoNVqOXjwIG3atHkh+2NpaYmlpSXh4eFkZGQ893qWLl2Kn58fxsbG+Pn5sXTpUr12BwcHfv31V2W/iuPUqVPExsYWexRmamoqXl5eXL9+nYiICOLj4xk9ejQ6Xc6TE5s3b2b48OGMHDmSU6dOMXjwYAYMGMDevXv11jNp0iR69erFiRMn8PHxoU+fPty7d48qVaqQnJyMtbU1c+fOJTk5md69e3P9+nV8fHzw9PQkPj6eRYsWsXTp0jwlh1auXImJiQkxMTF6yd/g4GAWLlxIbGyskjSbO3cuP/zwA9u2bWPnzp0sWLBAmT80NJRVq1axePFiTp8+zeeff87HH3+cp3zQ2LFjmTZtGomJidSvX7/AfuvduzcjR47E1dWV5ORkZb+8vLw4cOAA2dnZQN5j8fr161y4cEE5FufNm8esWbOYOXMmJ06cwNvbm/fff18veVmQ5ORkXF1dGTlyJMnJyQQFBfH48WO8vb2xtbXlyJEjbNiwgd27dzNs2DC9Zffs2UNSUhK7du1i69atJT6HUlNT8fHxYc+ePcTFxdGpUyd8fX25cuWK3nZmzpyJu7s7cXFxjB8/nkOHDjFw4ECGDRuGRqOhbdu2JS4zdf78edavX09kZCTbt28nLi6OoUOHKu2PHj3C39+fAwcO8Pvvv+Ps7IyPjw+PHj0Ccm7ezZkzh7CwMM6dO0d4eDhubm4AHD16lMDAQEJCQkhKSmL79u20bt26WN+Fn58fn3zyCYmJiURHR/PBBx8ghCAoKIhevXopCefk5GSaN2+uLDt27FiGDx9OYmIi3t7exT4mvv76a4KCgtBoNNSqVQs/Pz/lhlVMTAxDhgxh+PDhaDQaOnbsWKwEbq5t27bRrVs3fHx8iIuLY8+ePTRp0kRp79+/P0ePHiUiIoKDBw8ihMDHxwetVqvM8+TJE2bOnMnq1av57bffuHLlinKzMCgoSEl+5/YJ/5+9Ow+romwfOP49h/UcdtxwRU1ANAQXNDVFLXNJUzP1VXJJU/uZkeXW4t6bVq9p2mK+Zi5pZuaG+1aYgrlycAERDXfMHdm38/z+IOb1KCCaAtb9uS68PPPMzHPPnJnhcJ9n7qHo58Od+wzg559/5uLFi/z666/MmDGDiRMn0qlTJ9zc3Ni7dy+vvfYaQ4cO5fz580DuMd2uXTucnJzYtWsX4eHh2hcDeXdBwd3nyr3069ePZcuWMXv2bGJiYpg7dy6Ojo5UrVqVlStXArl5gISEBGbNmgXAu+++y0cffcT48eOJjo7m+++/p0KFCvfsa/bs2YSGhvLjjz8SGxvL0qVLqV69OpCbxO/QoQPh4eEsWbKE6OhoPvroI6ysrABIT0+nYcOGbNiwgaNHjzJkyBD69u3Lvn37Cuxv+PDh7Nmzhx9++IHDhw/To0cP2rdvX6Tr1Z49e2jZsqXF76Z27doRGxt7111b9+vYsWNcvnyZNm3a/KX1CJEvJcQ/RGJiogJUYmJiSYdyl7S0NPXLL7+oX3/9VS1a/J1auPQ7FT6luVIr/qXUty3vmn/Dhg1qy5YtSimlfvvtZ/X99/9RSu1S/7fmZTXjjUA1Z+9M9caO14t5K4QQQghR2qSlpano6GiVlpZmMf3yyavq6xe+K/afyyev3lf8Xl5eav369UoppebMmaPKlCljsS3z5s1TgIqMjFRKKfXLL78oQN24cUMppVSfPn1U27ZtLdY5evRoVadOHaWUUmazWZUpU0atWLFCKaVUQECAmjZtmvLw8FBKKbV7925lY2OjUlJSLNYRHx9v0W9+PD091cyZM++a/tNPPyk3Nzdlb2+vmjVrpt59910VFRVV5H2SmJioDAaDMplMSimlIiMjlaOjo0pKStLmOXbsmPL19VV6vV75+fmpoUOHqo0bN1qsp3///srKykoZDAZlZ2enAKXX69VPP/1UpDjmzp2rnJyc1LVr1/Jtb9asmRo8eLDFtB49eqiOHTtqrwE1btw47XVycrIC1KZNm7RpLi4uasGCBdrr9957T/n4+Ciz2axN+/LLL5Wjo6PKyclRSikVFBSk6tevb9F33rGxfft2bdq0adMUoE6dOqVNGzp0qGrXrp1SSqn09HRlfA2uRQABAABJREFUNBpVRESExboGDRqkevfubbHeNWvW5Lsf8jNx4kTl7+9vMe3GjRtKr9er/fv3K7PZrNzd3dW0adNUkyZNlFJKLVmyRFWuXFmbv1KlSurDDz+0WEdgYKAaNmxYkWLw9/dXEydO1F7/97//VW5ubio5OVmbtmHDBqXX69WlS5eUUrnHTIUKFVRGRoY2z4OeQ7erW7eu+vzzz7XXnp6eqmvXrhbz9O7d2+LYUUqpXr16KRcXlyJt78SJE5WVlZU6f/68Nm3Tpk1Kr9erhISEfJfJyclRTk5Oat26dUoppT799FPl7e2tMjMz75p35cqVytnZWd26datI8eQ5ePCgAtTp06fzbe/fv7/q0qWLxbS8689nn31mMf1ex0Tect98843WfuzYMQWomJgYpVTuPn3++ect1hEcHFzk/dy0aVMVHBycb9uJEycUoMLDw7VpV69eVQaDQf34449KKaUWLFigAHXy5Eltni+//FJVqFBBe7169Wp1ZyqrqNt+5z7r37+/8vT01K4dSinl4+OjWrRoob3Ozs5WDg4OatmyZUoppb777ru7rkEZGRnKYDBof6Pnd64UJjY2VgFq27Zt+bbf+btNKaVu3bql7Ozs1Lx584rUx+3eeOMN1aZNG4ttyLNlyxal1+tVbGxskdf3/PPPq5EjR2qvg4KC1JtvvqmUUurMmTPKyspKXbhwwWKZZ555Rr377rv3XHfbtm3VkCFDLKblHbfR0dH3XD6/622eDz/8UL300kv3XId4PBT0mbekyAh3IUoBe3t7WrVqhZOTE8qcQ3VDKs1ywsHKDjKT75o/96GpiUAPDIYc0tPtSduyFutbqWTb6LFX1vLQ1ALcOJ/I9bM3SzoMIYQQQtxDTEwMFy9e5JlnngFyR/bVq1fP4oGet4+cLGgddz6ItHnz5sTFxZGTk4NOp6Nly5aEhYVx8+ZNoqOjGTZsGBkZGRw/fpydO3cSGBiI0Wh8aNvVvXt3Ll68SGhoKO3btycsLIwGDRpoo+7vZdmyZTzxxBP4+/sDEBAQgKenJ8uXL9fmqVOnDkePHuW3335j4MCBXL58mc6dO2sPTM3TqlUrli5dSkREBP379+eVV16he/fuRYrDZDJRv3593N3d820vaN/HxMRYTLt9NLiDgwPOzs5cvny5wH5jYmJo2rSpRe3m5s2bk5ycrI1ABWjYsGG+y9/eX4UKFTAajRYlBypUqKD1f/LkSVJTU2nbtq12d4KjoyOLFy/W6kjnadSoUYExF4Wrqyv+/v6EhYVx5MgRbG1tGTJkCJGRkSQnJ7Nz506CgoKA3JrGFy9eLNL+LaqYmBj8/f1xcPjfMxaaN2+O2WwmNjZWm+bn52cx0vR+z6Hk5GRGjRqFr68vrq6uODo6EhMTc9cI9zv3Z0xMDE2aNLGY1rRp0/vaxmrVqlG5cmWL5W/fvj/++IPBgwfj5eWFi4sLzs7OJCcna7H16NGDtLQ0atasyeDBg1m9erU2Mrxt27Z4enpSs2ZN+vbty9KlSy1KExXE39+fZ555Bj8/P3r06MG8efOKPGr39n10P8fE7edAxYoVAbRjPjY29q7r6r2us7czmUzaNftOMTExWFtbW7yPZcqUwcfHxyJGo9HIE088YRFjYdeE+9n2/M7TunXrotf/LzVWoUIF7c4FACsrK8qUKaPFEBUVxcmTJ3FyctKuCe7u7qSnp1tcF+48VwpjMpmwsrLSzvGiiImJISMjo8D9XZgBAwZgMpnw8fEhJCSErVu3WsRSpUoVvL298102JyeHDz74AD8/P9zd3XF0dGTLli13ncN5jhw5Qk5ODt7e3hbX0Z07d951HS1ua9eulXIy4pGRhLsQpcTNmzdRSpGVlc3xP/4sB2NtgIyku+bNTbibgXgMBj1ZWbZkXIjHOiWdTBsd9mYrKSlTgAPfR7Fn/sGSDkMIIYQQ9xAaGkrbtm0tEuyPQqtWrQgLC2PXrl3Ur18fZ2dnLYF4e5LzYbK3t6dt27aMHz+eiIgIBgwYwMSJE4u07Pz58zl27BjW1tbaT3R0NN9++63FfHq9nsDAQEaMGMGqVatYuHAh8+fPJz4+XpvHwcGBqlWr4u/vz7fffsvevXvvKk9TEIPBUPQNLsSdDy3U6XRaWZq/4vbEcUH96XS6QvvPq1++YcMGTCaT9hMdHW1Rx72w/u5H3rGYd9y5u7vj6+vL7t27H9mxeL/y2877OYdGjRrF6tWrmTp1Krt27cJkMuHn52dRiqOgfh61/v37YzKZmDVrFhEREZhMJsqUKaPFVrVqVWJjY/nqq68wGAwMGzaMli1bkpWVhZOTE4cOHWLZsmVUrFiRCRMm4O/vz82bNwvt08rKim3btrFp0ybq1KnD559/jo+Pj8V5WpAH3Ud3ngPAQznn4OFcF/I7J5VSf3m9kP8+y6+/e10XGjZsaHFNMJlMnDhxgj59+hTaV0EeZL/9lX3doEED4uPj+eCDD0hLS6Nnz57aMwfutd7//Oc/zJo1i7Fjx/LLL79gMplo167dXedwnuTkZKysrDh48KDF/oqJidFK4xTGw8ODP/74w2Ja3msPD4+ibG6+EhISiIyM5Pnnn3/gdQhRGEm4C1FKrFq1iuvXr2M253A4IR0AZW2b7wh3GxsbsrNzP3QYDLm/+DMcDNhkq9wR7jmScC9I04ENaTn8qZIOQwghhBD3sHbtWrp06aK99vHx4ciRIxa1z/fv31/oOnx9fQkPD7eYFh4ejre3t1aPNq8G9YoVK7Q6061atWL79u2Eh4c/tPrthalTpw4pKXc/t+dOR44c4cCBA4SFhVkkLsLCwtizZw/Hjx8vtA+gwH70ej3vvfce48aNIy3t3p8j69Wrh8lk4vr16/m2F7Tv8+J4UL6+vlrt59vX6+TkRJUqVf7Suu9Up04d7OzsOHv2LLVq1bL4qVq16gOv19bWVqvVfru8Ou47duywOBaXLVvGiRMntGnOzs5UqlTpoe5fX19foqKiLI6P8PBw9Hr9PR/4eD/nUHh4OAMGDKBbt274+fnh4eFh8bDJwuK7/YG8AL/99luRtw/g7NmzXLx40WL527cvPDyckJAQOnbsqD1o+erVqxbrMBgMdO7cmdmzZ2vn3ZEjR4DcQVHPPvssn3zyCYcPH+b06dP8/PPP94xLp9PRvHlzJk+eTGRkJLa2tqxevRoo+Fi508M6Jnx8fO66rt7rOnu7evXqsWPHjnzbfH19yc7Otngfr127Rmxs7F+6LjyK86EwDRo0IC4ujvLly991XXBxcXmgdfr5+WE2m+96NkSevJHytx8LXl5eGAyGAvf3vTg7O9OrVy/mzZvH8uXLWblyJdevX6devXqcP3+eEydO5LtceHg4Xbp04eWXX8bf35+aNWsWOC9A/fr1ycnJ4fLly3ftr6IkzJs2bcqvv/5qUed/27Zt+Pj44Obmdv8b/qd169bRrFmzAu/SEuKvkoS7EKWEjY2N9odDji73G/UcvR1k3j3C3cPDg2rVcj/kGwy5v3gy7ex4Mj4Hr7gU7LN1ZJmzyDZnF1P0jw/Hsg44lSv+ETNCCCGEKLrLly9z4MABOnXqpE3r06cPZrOZIUOGEBMTw5YtW5g+fTqARXmR240cOZIdO3bwwQcfcOLECRYtWsQXX3yhPYAPchNEbm5ufP/99xbJwrwHm95ZpuCvuHbtGm3atGHJkiUcPnyY+Ph4VqxYwSeffGLx5UJB5s+fT+PGjWnZsiVPPvmk9tOyZUsCAwO10ekvvfQSM2fOZO/evZw5c4awsDBef/11vL29qV27doHr79GjB1ZWVnz55Zf3jKV37954eHjQtWtXwsPD+f3331m5ciV79uwBYPTo0SxcuJA5c+YQFxfHjBkzWLVqlcW+fxDDhg3j3LlzvPHGGxw/fpy1a9cyceJE3n77bYuyEA+Dk5MTo0aN4q233mLRokWcOnWKQ4cO8fnnn7No0aIHXm/16tWJj4/HZDJx9epV7Uukli1bkpSUxPr16y2OxaVLl1KxYkWLEg+jR4/m448/Zvny5cTGxvLOO+9gMpl48803Hyim4OBg7O3t6d+/P0ePHuWXX37hjTfeoG/fvvd8COP9nENeXl6sWrUKk8lEVFSUdl7fS0hICJs3b2b69OnExcXxxRdfsHnz5vvaxrzti4qKYteuXYSEhNCzZ08t6efl5cV3331HTEwMe/fuJTg42GK0b95dIkePHuX3339nyZIlGAwGPD09Wb9+PbNnz8ZkMnHmzBkWL16M2Wy+55cVe/fuZerUqRw4cICzZ8+yatUqrly5gq+vL5B7rBw+fJjY2FiuXr1qkXS808M4Jt544w02btzIjBkziIuLY+7cuWzatKnAa+ydJk6cyLJly5g4cSIxMTEcOXKEjz/+GMjdv126dGHw4MHs3r2bqKgoXn75ZSpXrlyk619hHvb5UJjg4GDKli1Lly5d2LVrF/Hx8YSFhRESEmJR1up+VK9enf79+zNw4EDWrFmjrfPHH38EwNPTE51Ox/r167ly5QrJycnY29szduxYxowZo5W5+u2334p0l9KMGTNYtmwZx48f58SJE6xYsQIPDw9cXV0JCgqiZcuWdO/enW3bthEfH8+mTZu0883Ly4tt27YRERFBTEwMQ4cOvWsE+u28vb0JDg6mX79+rFq1ivj4ePbt28e0adPYsGHDPWPt06cPtra2DBo0iGPHjrF8+XJmzZrF22+/rc2zevXqu363nTx5EpPJxKVLl0hLS9O+oM4biR8aGirlZMQjJQl3IUoJa2tr7cPmZV0FPleDyDaUyx3hfseHUC8vLxo1yq19ZzDkjobPsLHluf0ZBO26hv2feXYZ5S6EEEKIx9G6deto3LgxZcuW1aY5Ozuzbt06TCYTAQEBvP/++0yYMAGgwLIzDRo04Mcff+SHH37gySefZMKECUyZMoUBAwZo8+h0Olq0aIFOp+Ppp58GchOIzs7ONGrU6KGWtnB0dKRJkybMnDlTS5qPHz+ewYMH88UXXxS6bGZmJkuWLCmwxnr37t1ZvHgxWVlZtGvXjnXr1tG5c2e8vb3p378/tWvXZuvWrVhbWxfYh7W1NcOHD+eTTz6554h7W1tbtm7dSvny5enYsSN+fn589NFH2p0DXbt2ZdasWUyfPp26desyd+5cFixY8JfvGKhcuTIbN25k3759+Pv789prrzFo0CDGjRv3l9ZbkA8++IDx48czbdo0fH19ad++PRs2bKBGjRoPvM7u3bvTvn17WrduTbly5Vi2bBkAbm5u+Pn5Ua5cOS151LJlS8xm813lZEJCQnj77bcZOXIkfn5+bN68mdDQULy8vB4oJqPRyJYtW7h+/TqBgYG89NJLPPPMM/c8LuH+zqEZM2bg5uZGs2bN6Ny5M+3ataNBgwb37OOpp55i3rx5zJo1C39/f7Zu3Xrf73mtWrV48cUX6dixI8899xz16tXjq6++0trnz5/PjRs3aNCgAX379iUkJITy5ctr7a6ursybN4/mzZtTr149tm/fzrp16yhTpgyurq6sWrWKNm3a4Ovry9dff82yZcuoW7duoTE5Ozvz66+/0rFjR7y9vRk3bhyffvopHTp0AGDw4MH4+PjQqFEjypUrd9co7ts9jGOiefPmfP3118yYMQN/f382b97MW2+9VeTSXq1atWLFihWEhoYSEBBAmzZt2Ldvn9a+YMECGjZsSKdOnWjatClKKTZu3HhXCZf79bDPh8IYjUZ+/fVXqlWrxosvvoivry+DBg0iPT0dZ2fnB17vnDlzeOmllxg2bBi1a9dm8ODB2nW4cuXKTJ48mXfeeYcKFSowfPhwAMaPH8/IkSOZMGECvr6+9OrVq9B693mcnJz45JNPaNSoEYGBgZw+fZqNGzdqX1quXLmSwMBAevfuTZ06dRgzZow2un7cuHE0aNCAdu3a0apVK+2L18IsWLCAfv36MXLkSHx8fOjatSv79++nWrVq94zVxcWFrVu3Eh8fT8OGDbXtHTJkiDZPYmKixbMmAF599VXq16/P3LlzOXHiBPXr16d+/fpcvHiRlJQUduzYIQl38Ujp1MMqhiVEKXfr1i1cXFxITEz8S78IH5WffvoJJycnzpw5w4+XKpOcY832zpdxXN8P3k0CO0dt3oyMDFJSUnB3P4zZ7M0336znab+LOB515/oXs0j/6B2mZqzhm+cWUN5YvpBe/3mSZs3GnJqKy7vvlHQoQgghxCOXnp5OfHw8NWrUsEiYJF1JYfn/rSUn6+HU7S0KKxs9veZ0KdKdZi+88AJPP/00Y8aMKXS+pUuX8sorr5CYmPjQaor/k+Tk5BAZGUn9+vW1RLkQf0eTJk1izZo1mEymkg7lsTN48GCOHz/Orl27SjoUIR6KVatWMW7cOKKjo0s6FPEQFfSZt6QUPLxBCFGs7OzstP8HVrFDndlJdlb13AmZlgn3uLg49u7dy6BBg9Drwc4uiwx7J3YEZBP3SjUGZuR+j5aWnVqcm/BY0BkM6OR7RiGEEP9wTuUc6DWnC+m30outT3tn+yKXdXv66afp3bv3XdMXL15MzZo1qVy5MlFRUYwdO5aePXtKsl0IIR6S6dOn07ZtWxwcHNi0aROLFi2yuBNAiMedo6OjVupIiEdFEu5ClBKdO3fm6tWrnDlzhs6+Rpqd/Tc3kv+d23jHg1Otra3JycnBbF6NXl8egyGHtKRMrBKTyLLWYZ+RA3ZSUiY/jkMGl3QIQgghRKngVK70PtekoJHtly5dYsKECVy6dImKFSvSo0cPPvzww2KO7tFZunQpQ4cOzbfN09OTY8eOFVssU6dOZerUqfm2tWjRgk2bNhVbLI+bunXrcubMmXzb5s6dS3Bw8CPt/5/43t1rn5eUs2fPFvrgzujo6CKV1ShO+/bt45NPPiEpKYmaNWsye/ZsXn31VaDkj+3H1a5du7QyQflJTk4usO1BPE7XgA4dOhR498R7773He++999D7fO655x76OoW4kyTchShF8mpq3krLvb07W/35mIWMpHzny84Oxda2FgaDA6mJGeRs+4UsP0fs0s2ScBdCCCHE386YMWPuWWbmcfbCCy/QpEmTfNv+ao3j+/Xaa6/Rs2fPfNvkjoLCbdy4scCHW97rAaQPwz/xvbvXPndycmLSpEnFGxRQqVKlQsvYVKpUqfiCKaK8B3Xmp6SP7cdVo0aNirWc0eN0Dfjmm29IS8s/b+Hu7l7M0Qjx8EjCXYhS4uDBg1y7dg2AJb+doz2QY/4z4X7HCPe8P7iys52wtU3GYHAgPckWm/Qssmz02Kdmg4sk3IUQQgghHidOTk44OTmVdBhAbqJDkh0PxtPTs0T7/ye+dyW9zwtibW1NrVq1SjqMh6a07ufSzmAwFOtx8DhdAypXrlzSIQjxSOhLOgAhRK60tDQSExNzX+hyH1qVnVdrPPPuEe5WVlZkZzsAKdjb60jLtMU20ww6HXapuaMOJOEuhBBCCCGEEEIIIUTxkYS7EKWEjY0N2dnZuS90ek6q6mTY/vmt9B0j3CtXrsygQYNwdrYDkjEarUjPsKXdtit8PDcZq9R0rPXWknAXQgghhBBCCCGEEKIYScJdiFIiL+Gu0+mw0sHLfM0fVbrkNt5Rw/1/AoCG2NvbkJ5hi5WPNzp7e1RaGgZroyTchRBCCCGEEEIIIYQoRpJwF6KUsLGxISsrCysra2z0uaVkMs2AjcNdI9yzs7NZuXIlZ87UB17HYLBFKT2/fzuFyS/bk52WisHaIAl3IYQQQgghhBBCCCGKkTw0VYhSolq1ajg5ObFr1y4GB9Wg2obnSTo2GGwd76rhbmVlRWJiIrduXQX0GAz2QBbJacmcd1dkZf6ZcM9KLZFtEUIIIYQQQgghhBDin0hGuAtRSri4uFC9enWsra1R5hysyIGsVLBzumuEu06nw2g0kpISDbz4Z8Idkmd+DkBGZrqMcBdCCCFE4W6ehYuHiu/n5tlHvklhYWHodDpu3rz5yPsSxSM8PBw/Pz9sbGzo2rVrSYfzt3H8+HGeeuop7O3tCQgIKOlwHsjChQtxdXUt6TBECZg0aRIVKlRAp9OxZs2akg7nsSTnj7hdq1atGDFiREmH8bciI9yFKCWSkpI4deoUVlZWbIk6zyBsUdkZYOuUbw13o9FIamoSoDAYbACwsrYGssjIkJIyBfl5ZjiZqVm0f79VSYcihBBClJybZ+ELH8hOL74+re1heCy4VruvxV555RUqV67Mv//970cUWNG0atWKnTt3FtgeFBRUaDuAUoorV64wYcIENmzYwB9//IGbmxv+/v5MmDCB5s2bFzmeadOmMW7cOD766CNGjx5t0ZaTk8N//vMfFi5cyJkzZzAYDHh5eTF48GBeffVVAAYMGMCiRYsAsLa2pkqVKvTo0YMpU6Zgb29f5DgetbfffpuAgAA2bdqEo6NjSYfzUEyaNIk1a9ZgMplKLIaJEyfi4OBAbGzs32a//h0NGDCAmzdvSlL5NjExMUyePJnVq1fz1FNP4ebmVtIhCXGXsLAwWrduzY0bN/6RX2wcPnyY119/nf3791OuXDneeOMNxowZU+gyISEhhIeHc/ToUXx9fQv8Hblz505efvllzp079wgif3gk4S5EKZGcnMy+fftwc3MjKS2DLJ0NZGf8WVIm+a75/5dwBxsbK6ysstEZDEAWmSmJGKwNpEpJmbs80cITc5a5pMMQQgghSlbq1eJNtkNuf6lX7yvhnpOTw/r169mwYcMjDKxoVq1aRWZmJgDnzp2jcePGbN++nbp16wKQmZmJra2tNn9gYCBDhgxh8ODBFuvp3r07mZmZLFq0iJo1a/LHH3+wY8cOrl27dl/xfPvtt4wZM4Zvv/32roT75MmTmTt3Ll988QWNGjXi1q1bHDhwgBs3bljM165dO0aMGEHt2rUxmUz0798fnU7Hxx9/fF+xPEqnTp3itddeo0qVKg+8jjvfm0dJKUVOTg7W1qX7T+1Tp07x/PPP4+np+cDrKK79Wpzv3+MqKysLGxubkg6jWJw6dQqALl26oNPpHng9xbnP5BgW/yS3bt3iueee49lnn+Xrr7/myJEjDBw4EFdXV4YMGVLosgMHDmTv3r0cPny4wHnWrl1L586dH3bYD52UlBGilMj7ZW9lZYWtXpGNDeRk/FlS5u4R7v7+/gQG5n5A1ukU9vbpGLBjWGRZHM9dw2BtlBHu+fBsVIUaTe9vZJ0QQgghSkZERAQ2NjYEBgZqrwMCArC3t6dRo0asWbMGnU5X6EjhlStXUrduXezs7KhevTqffvqp1vbFF1/w5JNPaq/z1vf1119r05599lnGjRuHu7s7Hh4eeHh4UK5cOQDKlCmjTatWrZr2fw8PD6ysrHBycrKYdvPmTXbt2sXHH39M69at8fT0pHHjxrz77ru88MILRd4vO3fuJC0tjSlTpnDr1i0iIiIs2kNDQxk2bBg9evSgRo0a+Pv7M2jQIEaNGmUxn52dHWXLlqVq1ap07dqVZ599lm3bthU5jvPnz9O7d2/c3d1xcHCgUaNG7N27V2ufM2cOTzzxBLa2tvj4+PDdd99ZLK/T6fjmm2/o1q0bRqMRLy8vQkNDATh9+jQ6nY5r164xcOBAdDodCxcu1La/cePG2NnZUbFiRd555x2ys7O19bZq1Yrhw4czYsQIypYtS7t27bRyQ1u2bKF+/foYDAbatGnD5cuX2bRpE76+vjg7O9OnTx9SU/83aMVsNjNt2jRq1KiBwWDA39+fn376SWvPW++mTZto2LAhdnZ27N69u8B9tnDhQiZPnkxUVBQ6nU7brlGjRtGpUydtvs8++wydTsfmzZu1abVq1eKbb77R4poyZQpVqlTBzs6OgIAAi3kLo9PpOHjwIFOmTEGn0zFp0iQAjhw5Qps2bTAYDJQpU4YhQ4aQnPy/gT8DBgyga9eufPjhh1SqVAkfH5/7OocgN1napUsXKlSogKOjI4GBgWzfvt0ivurVq/PBBx/Qr18/nJ2dtQTNwoULqVatGkajkW7dut3Xl1STJk0iICCAuXPnUrVqVYxGIz179iQxMVGbZ//+/bRt25ayZcvi4uJCUFAQhw4d0tqVUkyaNIlq1aphZ2dHpUqVCAkJ0dq/+uorvLy8sLe3p0KFCrz00ktFiu2nn37Cz89P2+/PPvssKSkpTJo0iUWLFrF27VrtWAkLC9POjeXLlxMUFIS9vT1Lly695zGRt9yqVato3bo1RqMRf39/9uzZYxHPvHnztH3UrVs3ZsyYcV8jdNetW0dgYCD29vaULVuWbt26aW03btygX79+uLm5YTQa6dChA3FxcVp7XpmTLVu24Ovri6OjI+3btychIQHIfR/zEm16vV5LuBd12+/cZ3nH9NSpU6lQoQKurq5MmTKF7OxsRo8ejbu7O1WqVGHBggUW23ju3Dl69uyJq6sr7u7udOnShdOnT2vt+Z0rhbnf8whyk44NGjTA3t6emjVrMnnyZIvr4IwZM/Dz88PBwYGqVasybNgwi/P5TleuXKFRo0Z069aNjIyMQuO9ceMGwcHBlCtXTruDKm8f5e3rH374gWbNmmFvb8+TTz551x1gR48epUOHDjg6OlKhQgX69u3L1atXtXaz2cwnn3xCrVq1sLOzo1q1anz44Yda+9ixY/H29sZoNFKzZk3Gjx9PVlaW1p73HtxuxIgRtGrVSnudlJREcHAwDg4OVKxYkZkzZ95XaZWMjAzGjh1L1apVsbOzo1atWsyfP5/Tp0/TunVrANzc3NDpdAwYMKBI21WQzMxMhg8fTsWKFbG3t8fT05Np06Zp7Tdv3mTo0KFUqFBB2+fr168H4Nq1a/Tu3ZvKlStjNBrx8/Nj2bJl99y2UaNGUblyZRwcHGjSpAlhYWFF2i9Lly4lMzOTb7/9lrp16/Kvf/2LkJAQZsyYUehys2fP5vXXX6dmzZqFzhcaGnpfn5lKiiTchSgl8kbB6PV6bPSKD6zHcajqa7kj3PMpKVOuXDkqVPDQXhuNqZjtDDRJKottwlUMVvaScBdCCCHEYy00NJTOnTuj0+m4desWnTt3xs/Pj0OHDvHBBx8wduzYQpc/ePAgPXv25F//+hdHjhxh0qRJjB8/XkvcBgUFER0dzZUrV4DcRG7ZsmW1PyqzsrLYs2ePxR/of4WjoyOOjo6sWbPmngmNwsyfP5/evXtjY2ND7969mT9/vkW7h4cHP//8s7ZdRXH06FEiIiKKPAozOTmZoKAgLly4QGhoKFFRUYwZMwazOfdOwtWrV/Pmm28ycuRIjh49ytChQ3nllVf45ZdfLNYzefJkevbsyeHDh+nYsSPBwcFcv36dqlWrkpCQgLOzM5999hkJCQn06tWLCxcu0LFjRwIDA4mKimLOnDnMnz//rpJDixYtwtbWlvDwcIuk1aRJk/jiiy+IiIjQkmafffYZ33//PRs2bGDr1q18/vnn2vzTpk1j8eLFfP311xw7doy33nqLl19++a7k0TvvvMNHH31ETEwM9erVK3C/9erVi5EjR1K3bl0SEhK07QoKCmL37t3k5OQAdx+LFy5c4NSpU9qxOGvWLD799FOmT5/O4cOHadeuHS+88IJF8rIgCQkJ1K1bl5EjR5KQkMCoUaNISUmhXbt2uLm5sX//flasWMH27dsZPny4xbI7duwgNjaWbdu2sX79+vs+h5KTk+nYsSM7duwgMjKS9u3b07lzZ86etXzGw/Tp0/H39ycyMpLx48ezd+9eBg0axPDhwzGZTLRu3fq+y0ydPHmSH3/8kXXr1rF582YiIyMZNmyY1p6UlET//v3ZvXs3v/32G15eXnTs2JGkpNy/xVauXMnMmTOZO3cucXFxrFmzBj8/PwAOHDhASEgIU6ZMITY2ls2bN9OyZcsivRe9e/dm4MCBxMTEEBYWxosvvohSilGjRtGzZ08t4ZyQkECzZs20Zd955x3efPNNYmJiaNeuXZGPiffff59Ro0ZhMpnw9vamd+/eWqI2PDyc1157jTfffBOTyUTbtm2LlAzMs2HDBrp160bHjh2JjIxkx44dNG7cWGsfMGAABw4cIDQ0lD179qCUomPHjhaJ0tTUVKZPn853333Hr7/+ytmzZ7UvC0eNGqUldvP2CRT9fLhznwH8/PPPXLx4kV9//ZUZM2YwceJEOnXqhJubG3v37uW1115j6NChnD9/Hsg9ptu1a4eTkxO7du0iPDxc+2Ig7y4ouPtcKcz9nke7du2iX79+vPnmm0RHRzN37lwWLlxo8V7p9Xpmz57NsWPHWLRoET///HOBJT3OnTtHixYtePLJJ/npp5+ws7MrNN7x48cTHR3Npk2biImJYc6cOZQtW9ZintGjRzNy5EgiIyNp2rQpnTt31r4ku3nzJm3atKF+/focOHCAzZs388cff9CzZ09t+XfffZePPvpI6+v777+nQoUKWruTkxMLFy4kOjqaWbNmMW/ePGbOnFlo3Hd6++23CQ8PJzQ0lG3btrFr1y6LL9nupV+/fixbtozZs2cTExPD3LlzcXR0pGrVqqxcuRKA2NhYEhISmDVrVpG2qyCzZ88mNDSUH3/8kdjYWJYuXUr16tWB3CR+hw4dCA8PZ8mSJURHR/PRRx9hZWUFQHp6Og0bNmTDhg0cPXqUIUOG0LdvX/bt21dgf8OHD2fPnj388MMPHD58mB49etC+ffsi/Y7Zs2cPLVu2tPg80a5dO2JjY++60+5+HTt2jMuXL9OmTZu/tJ5ioYT4h0hMTFSASkxMLOlQ8pWSkqLmzp2r1q5dqz744jv1zNTt6qttJ5RaM0ip/za5a/6bN2+q/fv3qaysDKXUObVx4/tq/cpv1A+rJqnDdWuoRfu/UgM39y/27SjtUrduU6nrN5R0GEIIIUSxSEtLU9HR0SotLc2y4cJBpSZS/D8XDt5X/F5eXmr9+vVKKaXmzJmjypQpY7Et8+bNU4CKjIxUSin1yy+/KEDduHFDKaVUnz59VNu2bS3WOXr0aFWnTh2llFJms1mVKVNGrVixQimlVEBAgJo2bZry8PBQSim1e/duZWNjo1JSUizWER8fb9Fvfjw9PdXMmTPvmv7TTz8pNzc3ZW9vr5o1a6beffddFRUVVeR9kpiYqAwGgzKZTEoppSIjI5Wjo6NKSkrS5jl27Jjy9fVVer1e+fn5qaFDh6qNGzdarKd///7KyspKGQwGZWdnpwCl1+vVTz/9VKQ45s6dq5ycnNS1a9fybW/WrJkaPHiwxbQePXqojh07aq8BNW7cOO11cnKyAtSmTZu0aS4uLmrBggXa6/fee0/5+Pgos9msTfvyyy+Vo6OjysnJUUopFRQUpOrXr2/Rd96xsX37dm3atGnTFKBOnTqlTRs6dKhq166dUkqp9PR0ZTQaVUREhMW6Bg0apHr37m2x3jVr1uS7H/IzceJE5e/vbzHtxo0bSq/Xq/379yuz2azc3d3VtGnTVJMmuX8HLFmyRFWuXFmbv1KlSurDDz+0WEdgYKAaNmxYkWLw9/dXEydO1F7/97//VW5ubio5OVmbtmHDBqXX69WlS5eUUrnHTIUKFVRGRoY2z4OeQ7erW7eu+vzzz7XXnp6eqmvXrhbz9O7d2+LYUUqpXr16KRcXlyJt78SJE5WVlZU6f/68Nm3Tpk1Kr9erhISEfJfJyclRTk5Oat26dUoppT799FPl7e2tMjMz75p35cqVytnZWd26datI8eQ5ePCgAtTp06fzbe/fv7/q0qWLxbS8689nn31mMf1ex0Tect98843WfuzYMQWomJgYpVTuPn3++ect1hEcHFzk/dy0aVMVHBycb9uJEycUoMLDw7VpV69eVQaDQf34449KKaUWLFigAHXy5Eltni+//FJVqFBBe7169Wp1ZyqrqNt+5z7r37+/8vT01K4dSinl4+OjWrRoob3Ozs5WDg4OatmyZUoppb777ru7rkEZGRnKYDCoLVu2aOu981wpzP2eR88884yaOnWqxTq+++47VbFixQL7WLFihSpTpoz2esGCBcrFxUUdP35cVa1aVYWEhFhsU2E6d+6sXnnllXzb8vb1Rx99pE3LyspSVapUUR9//LFSSqkPPvhAPffccxbLnTt3TgEqNjZW3bp1S9nZ2al58+YVKR6llPrPf/6jGjZsqL3O79x58803VVBQkFJKqVu3bikbGxttnyuVm2MxGo3qzTffvGd/sbGxClDbtm3Lt/3OzyN5fd7vduV54403VJs2bfJ9j7Zs2aL0er2KjY0t8vqef/55NXLkSO11UFCQtt1nzpxRVlZW6sKFCxbLPPPMM+rdd9+957rbtm2rhgwZYjEt71oTHR19z+Xz+x2Z58MPP1QvvfRSvm0FfuYtITLCXYhSwsbGhurVq2NjY4NnGXv+pVuL74Xv/qzhfvcI95SUFA4diiQlJQ0wYDCkka7Ts1S3jz8q2GGfZpYR7vlIW7+B1D+/bRZCCCFE6RUTE8PFixd55plngNxRYvXq1bN4oOftIycLWsedDyJt3rw5cXFx5OTkoNPpaNmyJWFhYdy8eZPo6GiGDRtGRkYGx48fZ+fOnQQGBmI0Gh/adnXv3p2LFy8SGhpK+/btCQsLo0GDBtqo+3tZtmwZTzzxBP7+/gAEBATg6enJ8uXLtXnq1KnD0aNH+e233xg4cCCXL1+mc+fO2gNT87Rq1YqlS5cSERFB//79eeWVV+jevXuR4jCZTNSvXx93d/d82wva9zExMRbTbh8N7uDggLOzM5cvXy6w35iYGJo2bWpRu7l58+YkJydrI1ABGjZsmO/yt/dXoUIFrRzB7dPy+j958iSpqam0bdtWuzvB0dGRxYsXa3Wk8zRq1KjAmIvC1dUVf39/wsLCOHLkCLa2tgwZMoTIyEiSk5PZuXMnQUFBQG593IsXLxZp/xZVTEwM/v7+ODg4WKzPbDYTGxurTfPz87MYtXi/51BycjKjRo3C19cXV1dXHB0diYmJuWuE+537MyYmhiZNmlhMa9q06X1tY7Vq1ahcubLF8rdv3x9//MHgwYPx8vLCxcUFZ2dnkpOTtdh69OhBWloaNWvWZPDgwaxevVobGd62bVs8PT2pWbMmffv2ZenSpRaliQri7+/PM888g5+fHz169GDevHlFHgF6+z66n2Pi9nOgYsWKANoxHxsbe9d19V7X2duZTCbtmn2nmJgYrK2tLd7HMmXK4OPjYxGj0WjkiSeesIixsGvC/Wx7fudp3bp10ev/lxqrUKGCducC5JZ8LVOmjBZDVFQUJ0+exMnJSbsmuLu7k56ebnFduPNcKcz9nkdRUVFMmTLF4ro0ePBgEhIStONu+/btPPPMM1SuXBknJyf69u3LtWvXLI7LtLQ0WrRowYsvvsisWbOKXBP///7v//jhhx8ICAhgzJgxd5U1A8vz09ramkaNGmnvR1RUFL/88otF/LVr1wZyy07FxMSQkZFR4LEEsHz5cpo3b46HhweOjo6MGzfurutIYX7//XeysrIsjm8XF5d7lv/JYzKZsLKy0q7LRVGU7SrIgAEDMJlM+Pj4EBISwtatWy1iqVKlCt7e3vkum5OTwwcffICfnx/u7u44OjqyZcuWAvfXkSNHyMnJwdvb2+I92rlz512/+4rb2rVrH4tyMiAlZYQoNWxsbHjuuedwcnLCaKOjgfkQVW7s+rOGe/4PTQVISZkA7MtNuF/PTcxnWeuwS80kLTsNpVRxbkap5z5rJmW+nX/vGYUQQghRokJDQ2nbtq1Fgv1RaNWqFWFhYezatYv69evj7OysJT5uT3I+TPb29rRt25bx48cTERHBgAEDmDhxYpGWnT9/PseOHcPa2lr7iY6O5ttvv7WYT6/XExgYyIgRI1i1ahULFy5k/vz5xMfHa/Pk1fb19/fn22+/Ze/evXeVpymIwWAo+gYX4s6HFup0Oq0szV9xe+K4oP50Ol2h/efVO96wYQMmk0n7iY6OtqjjXlh/9yPvWMw77tzd3fH19WX37t2P7Fi8X/lt5/2cQ6NGjWL16tVMnTqVXbt2YTKZ8PPzsyjFUVA/j1r//v0xmUzMmjWLiIgITCYTZcqU0WKrWrUqsbGxfPXVVxgMBoYNG0bLli3JysrCycmJQ4cOsWzZMipWrMiECRPw9/fn5s2bhfZpZWXFtm3b2LRpE3Xq1OHzzz/Hx8fH4jwtyIPuozvPAeChnHPwcK4L+Z2TD+tv2vz2WX793eu60LBhQ4trgslk4sSJE/Tp06fQvgpzP+dRcnIykydPtuj/yJEjxMXFYW9vz+nTp+nUqRP16tVj5cqVHDx4kC+//BLA4lyzs7Pj2WefZf369Vy4cKHIsXbo0IEzZ87w1ltvaV+M3/mMkMIkJyfTuXPnu/ZhXFwcLVu2vOdxtGfPHoKDg+nYsSPr168nMjKS999/32Lb9Hr9XcfN7aWL/qoHOdb/yvnRoEED4uPj+eCDD0hLS6Nnz57acyLutd7//Oc/zJo1i7Fjx/LLL79gMplo167dXdfdPMnJyVhZWXHw4EGL9ycmJkYrjVMYDw8P/vjjD4tpea89PDzyW6RIEhISiIyM5Pnnn3/gdRQnSbgLUYqkpqai0+lITEknQ9mgz8kssIZ7XsI9NfUGcBWDIY2M7NxTOstGj11SBjkqhyzzw/ulIoQQQghRXNauXUuXLl201z4+Phw5csSi9vn+/fsLXYevry/h4eEW08LDw/H29tZqm+bVzl2xYoVWH7dVq1Zs376d8PDwh1a/vTB16tQhJSXlnvMdOXKEAwcOEBYWZvFHcFhYGHv27OH48eOF9gEU2I9er+e9995j3LhxpKXd+y7JevXqYTKZuH79er7tBe37vDgelK+vr1b7+fb1Ojk5UaVKlb+07jvVqVMHOzs7zp49S61atSx+qlat+sDrtbW11Wq13y6vjvuOHTssjsVly5Zx4sQJbZqzszOVKlV6qPvX19eXqKgoi+MjPDwcvV5/zxGf93MOhYeHM2DAALp164afnx8eHh4WD5ssLL7bH8gL8NtvvxV5+wDOnj3LxYsXLZa/ffvCw8MJCQmhY8eO2oOWb3+II+Qmtjp37szs2bO18+7IkSNA7ijeZ599lk8++YTDhw9z+vRpfv7553vGpdPpaN68OZMnTyYyMhJbW1tWr14NFHys3OlhHRM+Pj53XVfvdZ29Xb169dixY0e+bb6+vmRnZ1u8j9euXSM2NvYvXRcexflQmAYNGhAXF0f58uXvui64uLg88Hrv5zxq0KABsbGxd/Vfq1Yt9Ho9Bw8exGw28+mnn/LUU0/h7e1tcezn0ev1fPfddzRs2JDWrVvnO09BypUrR//+/VmyZAmfffYZ//3vfy3abz8/s7OzOXjwIL6+vlr8x44do3r16nfF7+DggJeXFwaDocBjKSIiAk9PT95//30aNWqEl5cXZ86cuSu+vBr/eW5/wHrNmjWxsbGxOL4TExM5ceJEkbbfz88Ps9l81/M88uTd3XD7+Xuv7boXZ2dnevXqxbx581i+fDkrV67k+vXr1KtXj/PnzxcYe3h4OF26dOHll1/G39+fmjVrFrqd9evXJycnh8uXL9/1/hQlYd60aVN+/fVXiy84tm3bho+PD25ubve/4X9at24dzZo1K/DOutJGEu5ClCJ5F8yUtAzSzdbozZlgm/8Id1tbW2xsbEhNdQFSMRhyyNbZoldWZDs7YHcr9w8lKSsjhBBCiMfN5cuXOXDgAJ06ddKm9enTB7PZzJAhQ4iJiWHLli1Mnz4doMDb4EeOHMmOHTv44IMPOHHiBIsWLeKLL76wGIlXr1493Nzc+P777y2SHHkPNr2zTMFfce3aNdq0acOSJUs4fPgw8fHxrFixgk8++cTiy4WCzJ8/n8aNG9OyZUuefPJJ7adly5YEBgZqo9NfeuklZs6cyd69ezlz5gxhYWG8/vrreHt7a7ft56dHjx5YWVlpIyEL07t3bzw8POjatSvh4eH8/vvvrFy5kj179gC5D8xbuHAhc+bMIS4ujhkzZrBq1ar7GgWZn2HDhnHu3DneeOMNjh8/ztq1a5k4cSJvv/22RVmIh8HJyYlRo0bx1ltvsWjRIk6dOsWhQ4f4/PPPWbRo0QOvt3r16sTHx2Mymbh69ar2JVLLli1JSkpi/fr1Fsfi0qVLqVixokW5gNGjR/Pxxx+zfPlyYmNjeeeddzCZTLz55psPFFNwcDD29vb079+fo0eP8ssvv/DGG2/Qt2/fez7Q737OIS8vL1atWoXJZCIqKko7r+8lJCSEzZs3M336dOLi4vjiiy/YvHnzfW1j3vZFRUWxa9cuQkJC6Nmzp5ZA8vLy4rvvviMmJoa9e/cSHBxsMXI07y6Ro0eP8vvvv7NkyRIMBgOenp6sX7+e2bNnYzKZOHPmDIsXL8ZsNt/zy4q9e/cydepUDhw4wNmzZ1m1ahVXrlzREpPVq1fn8OHDxMbGcvXq1UJH6D6MY+KNN95g48aNzJgxg7i4OObOncumTZuKXGpk4sSJLFu2jIkTJxITE8ORI0f4+OOPgdz926VLFwYPHszu3buJiori5ZdfpnLlykW6/hXmYZ8PhQkODqZs2bJ06dKFXbt2ER8fT1hYGCEhIRZlre7X/ZxHEyZMYPHixUyePJljx44RExPDDz/8wLhx4wCoVasWWVlZfP755/z+++989913Fg+Pvp2VlRVLly7F39+fNm3acOnSpXvGOmHCBNauXcvJkyc5duwY69ev147ZPF9++SWrV6/m+PHjvP7669y4cYOBAwcC8Prrr3P9+nV69+7N/v37OXXqFFu2bOGVV14hJycHe3t7xo4dy5gxY7QSXr/99pv2O87Ly4uzZ8/yww8/cOrUKWbPnq19SZWnTZs2HDhwgMWLFxMXF8fEiRM5evSo1u7k5ET//v0ZPXo0v/zyC8eOHWPQoEHo9foiHe/Vq1enf//+DBw4kDVr1mjHwY8//giAp6cnOp2O9evXc+XKFZKTk++5XYWZMWMGy5Yt4/jx45w4cYIVK1bg4eGBq6srQUFBtGzZku7du7Nt2zbi4+PZtGmTdo308vJi27ZtREREEBMTw9ChQ+8agX47b29vgoOD6devH6tWrSI+Pp59+/Yxbdo0NmzYcM9Y+/Tpg62tLYMGDeLYsWMsX76cWbNm8fbbb2vzrF69+q7PIydPnsRkMnHp0iXS0tK0QQV5I/FDQ0Mfm3IyIAl3IUoVa2trAKx0ikydLXpzRu4Id3MWZGfcNb+Pjw/OzjlAMgZD7iifBjfK4KZ3wPbP8jJp2feuHSiEEEIIUZqsW7eOxo0bU7ZsWW2as7Mz69atw2QyERAQwPvvv8+ECRMACiw706BBA3788Ud++OEHnnzySSZMmMCUKVMYMGCANo9Op6NFixbodDqefvppIDfx4ezsTKNGjR5qaQtHR0eaNGnCzJkztaT5+PHjGTx4MF988UWhy2ZmZrJkyZICa6x3796dxYsXk5WVRbt27Vi3bh2dO3fG29ub/v37U7t2bbZu3ap93syPtbU1w4cP55NPPrnniHtbW1u2bt1K+fLl6dixI35+fnz00UfanQNdu3Zl1qxZTJ8+nbp16zJ37lwWLFjwl+8YqFy5Mhs3bmTfvn34+/vz2muvMWjQIC3R9LB98MEHjB8/nmnTpuHr60v79u3ZsGEDNWrUeOB1du/enfbt29O6dWvKlSvHsmXLAHBzc8PPz49y5cppiYiWLVtiNpvvKicTEhLC22+/zciRI/Hz82Pz5s2Ehobi5eX1QDEZjUa2bNnC9evXCQwM5KWXXuKZZ56553EJ93cOzZgxAzc3N5o1a0bnzp1p164dDRo0uGcfTz31FPPmzWPWrFn4+/uzdevW+37Pa9WqxYsvvkjHjh157rnnqFevHl999ZXWPn/+fG7cuEGDBg3o27cvISEhlC9fXmt3dXVl3rx5NG/enHr16rF9+3bWrVtHmTJlcHV1ZdWqVbRp0wZfX1++/vprli1bRt26dQuNydnZmV9//ZWOHTvi7e3NuHHj+PTTT+nQoQMAgwcPxsfHh0aNGlGuXLm7RnHf7mEcE82bN+frr79mxowZ+Pv7s3nzZt56660il/Zq1aoVK1asIDQ0lICAANq0acO+ffu09gULFtCwYUM6depE06ZNUUqxcePGu0q43K+HfT4Uxmg08uuvv1KtWjVefPFFfH19GTRoEOnp6Tg7Oz/weu/nPGrXrh3r169n69atBAYG8tRTTzFz5kw8PT2B3GcDzJgxg48//pgnn3ySpUuXMm3atAL7tra21o7XNm3aFFozH3Kv/++++y716tWjZcuWWFlZ8cMPP1jM89FHH/HRRx/h7+/P7t27CQ0N1X6n592RkJOTw3PPPYefnx8jRozA1dVV++J0/PjxjBw5kgkTJuDr60uvXr20uF544QXeeusthg8fTkBAABEREYwfP96i/3bt2jF+/HjGjBlDYGAgSUlJ9OvXz2KeGTNm0LRpUzp16sSzzz5L8+bN8fX1LfLxPmfOHF566SWGDRtG7dq1GTx4sPa7s3LlykyePJl33nmHChUqMHz48HtuV2GcnJz45JNPaNSoEYGBgZw+fZqNGzdq+2vlypUEBgbSu3dv6tSpw5gxY7TR9ePGjaNBgwa0a9eOVq1aaV+WF2bBggX069ePkSNH4uPjQ9euXdm/fz/VqlW7Z6wuLi5s3bqV+Ph4GjZsqG3vkCFDtHkSExMtng8C8Oqrr1K/fn3mzp3LiRMnqF+/PvXr1+fixYukpKSwY8eOxyrhrlNS4Fn8Q9y6dQsXFxcSExP/0i/CR2nlypXY2Nhw8dIfXLueQB2nFLq1eQqWvwhjroKxTD5LDQBqcvVqHKtWteCZ02dwPnGCM96uTGl8kVmtP6eGS818lhNCCCHE3116ejrx8fHUqFHD8g/Im2fhCx/ITi++YKztYXgsuN77j7UXXniBp59+mjFjxhQ639KlS3nllVdITEx8aDXF/0lycnKIjIykfv36WqJciL+jSZMmsWbNGouSEqJoBg8ezPHjx9m1a1dJhyIeA6dPn6ZGjRpERkYSEBBQ0uHcl5SUFCpXrsynn37KoEGDSjoccZtVq1Yxbtw4oqOjC5ynwM+8JaTg4Q1CiGJnbW2NUgo9ij3WLbjs5EQ32z+fUp+RdFfCPT09nfT0Abi6lsFgyL2lOtnfF/vEq9hezq2nKSVlhBBCCHEX12q5ye/Uq/ee92Exli1Ssh3g6aefpnfv3ndNX7x4MTVr1qRy5cpERUUxduxYevbsKcl2IYR4SKZPn07btm1xcHBg06ZNLFq0yOJOACH+LiIjIzl+/DiNGzcmMTGRKVOmAPzlEkfi4XN0dNTKUz0uJOEuRCliY2Oj1XD0srtKxdTfwfbP2xDzqeOeWyPwD3r1aoXBkHs6L7UyUaeumSabrwP2knAXQgghRP5cqxU5AV7cChrZfunSJSZMmMClS5eoWLEiPXr04MMPPyzm6B6dpUuXMnTo0HzbPD09OXbsWLHFMnXqVKZOnZpvW4sWLdi0aVOxxfK4qVu37l0P8Mszd+5cgoODH2n//8T37l77vKScPXu20Ad3RkdHF6lEQ3Hat28fn3zyCUlJSdSsWZPZs2fz6quvAiV/bD+udu3apZUJyk9y8t1/65ek1157jSVLluTb9vLLLxdYD/5xNH36dGJjY7G1taVhw4bs2rWLsmXLFvt79jhdtzt06FDgHS/vvfce77333kPv87nnnnvo63zUpKSM+Md4HErKZGdnc/78ebZu3YpXzhH8ryzHfejPMMcPBkVA1aYW8x8+fJiDB/fxyiuVgQ0sWliHk3bn8MxKpvXsX3lrXBXGBL7D05VblMwGCSGEEKJElbbba0XhkpKSCnyQmY2NjVaf92EprKTM9evXuX79er7LGQwGKleu/FBj+Ts5c+ZMgQ+3rFChAk5OTo+0/3/ie1fS+7wg2dnZnD59usD26tWrF/pchdKmtO7n0i4tLY0LFy4U2F6rVq1ijObeLl++zK1bt/Jtc3Z2tni2wd9Vcb9nj9N1+8KFC6Sl5T+w093dHXd392KOKFdp+8z7+FzZhfgHsLa21h4Yk6W3x0Zlgt2fH1ryGeFuNBrJyjKTmbkIW9uq2FulYptiJsvVFps/rgNVZIS7EEIIIcRjwsnJqdQkrEryj+bH3cP+YuR+/RPfu5Le5wWxtrYudcnUv6K07ufSzmAwPFbHQfny5f8RSfXCFPd79jhdt0tT8r8005d0AEKI/zl69ChRUVEAnL6Rg7XKBFvH3MaMpLvmNxqNAKSmmgED9nbp2JptyTbYYWUGW72tJNzvELUmmoM/HC7pMIQQQgghhBBCCCHE35Ak3IUoRVJSUrhxI/chqdk6G6zJAtuCR7g7ODhgbQ0ZGdmAEYMhHRuzHdl2uTevGHSScL9TTpaZnCxzSYchhBBCCCGEEEIIIf6GpKSMEKWIjY0N2dnZAKTqHLipc6eclQ1Y2ULm3SPcnZ2deeWVcuh0Z4EWGIxX8Uh0pLtvf66yAHuzNWnZqcW8FaVbgx5PlnQIQgghhBBCCCGEEOJvSka4C1GK3J5wj9IHEGy3DHS63LIy+ZSU0el06HRVgZaAHQaHNLIMRmzLewBgn6OTEe5CCCGEEEIIIYQQQhQTSbgLUYrY2NiQk5MDgB4zWTl/lj6xdcq3pAzA1q3XOXCgD+CM0TmDDHt7FhxfhN7NDftMSMuShPvtsi9cJPvcuZIOQwghhBBCCCGEEEL8DUnCXYhSpGLFirRs2RKAblVv8GPWvyDlSu4I93xKygBkZmZw8+ZlwBaD4RYAp66eQl++HPYZZhnhfodbUz7g5pixJR2GEEIIUQpcAo4X48+lR75FYWFh6HQ6bt68+cj7EsUjPDwcPz8/bGxs6Nq1a0mH87dx/PhxnnrqKezt7QkICCjpcB7IwoULcXV1LekwhBBCiLtIDXchShEXFxdcXFzYtWsXNlY6ynGNnMxUrOwKHuFuNCqSk/cD5TEYUgDITM/Aqmw57FKzJOF+B6cxoyEnu6TDEEIIIUrYJeBFILMY+7QFVgEe97XUK6+8QuXKlfn3v//9SKIqqlatWrFz584C24OCggptB1BKceXKFSZMmMCGDRv4448/cHNzw9/fnwkTJtC8efMixzNt2jTGjRvHRx99xOjRoy3acnJy+M9//sPChQs5c+YMBoMBLy8vBg8ezKuvvgrAgAEDWLRoEQDW1tZUqVKFHj16MGXKFOzt7Yscx6P29ttvExAQwKZNm3B0dCzpcB6KSZMmsWbNGkwmU4nFMHHiRBwcHIiNjf3b7NfHQWm5ngkhhHi0JOEuRCmSlpZGfHw86K2IvZTK80B2RhpWBdRwB3BwcOLyZSMABkNucj0zPQt9+XLYJZ/hhiTcLdg8UbOkQxBCCCFKgZsUb7KdP/u7yf0k3HNycli/fj0bNmx4VEEV2apVq8jMzN1n586do3Hjxmzfvp26desCkJmZia2trTZ/YGAgQ4YMYfDgwRbr6d69O5mZmSxatIiaNWvyxx9/sGPHDq5du3Zf8Xz77beMGTOGb7/99q6E++TJk5k7dy5ffPEFjRo14tatWxw4cIAbN25YzNeuXTtGjBhB7dq1MZlM9O/fH51Ox8cff3xfsTxKp06d4rXXXqNKlSoPvI4735tHSSlFTk4O1tal+0/tU6dO8fzzz+Pp6fnA6yiu/Vqc79+jVJquZ0IIIR4tKSkjRCmSkpLC7t27QafjZnpu/fbMjLRCa7gbjc6kphpRSmkJ95zMbKzKlcPuVjpp2anFFr8QQgghxMMUERGBjY0NgYGB2uuAgADs7e1p1KgRa9asQafTFTpSeOXKldStWxc7OzuqV6/Op59+qrV98cUXPPnkk9rrvPV9/fXX2rRnn32WcePG4e7ujoeHBx4eHpQrVw6AMmXKaNOqVaum/d/DwwMrKyucnJwspt28eZNdu3bx8ccf07p1azw9PWncuDHvvvsuL7zwQpH3y86dO0lLS2PKlCncunWLiIgIi/bQ0FCGDRtGjx49qFGjBv7+/gwaNIhRo0ZZzGdnZ0fZsmWpWrUqXbt25dlnn2Xbtm1FjuP8+fP07t0bd3d3HBwcaNSoEXv37tXa58yZwxNPPIGtrS0+Pj589913FsvrdDq++eYbunXrhtFoxMvLi9DQUABOnz6NTqfj2rVrDBw4EJ1Ox8KFC7Xtb9y4MXZ2dlSsWJF33nmH7Oz/3cHYqlUrhg8fzogRIyhbtizt2rXTyg1t2bKF+vXrYzAYaNOmDZcvX2bTpk34+vri7OxMnz59SE393+dns9nMtGnTqFGjBgaDAX9/f3766SetPW+9mzZtomHDhtjZ2eV+ni/AwoULmTx5MlFRUeh0Om27Ro0aRadOnbT5PvvsM3Q6HZs3b9am1apVi2+++UaLa8qUKVSpUgU7OzsCAgIs5i2MTqfj4MGDTJkyBZ1Ox6RJkwA4cuQIbdq0wWAwUKZMGYYMGUJy8v/+BhkwYABdu3blww8/pFKlSvj4+NzXOQS5if4uXbpQoUIFHB0dCQwMZPv27RbxVa9enQ8++IB+/frh7OzMkCFDtH1XrVo1jEYj3bp1u68vqSZNmkRAQABz586latWqGI1GevbsSWJiojbP/v37adu2LWXLlsXFxYWgoCAOHTqktSulmDRpEtWqVcPOzo5KlSoREhKitX/11Vd4eXlhb29PhQoVeOmllyxiuPN6JoQQ4u9LEu5ClCJ5I2H0Oj1KZwVAdlZ6oTXcq1evRfv2W4AcbGyy0JmzCXJtiq5cWexupkhJGSGEEEI8tkJDQ+ncuTM6nY5bt27RuXNn/Pz8OHToEB988AFjxxb+XJaDBw/Ss2dP/vWvf3HkyBEmTZrE+PHjtcRtUFAQ0dHRXLlyBchN5JYtW5awsDAAsrKy2LNnD61atXoo2+Po6IijoyNr1qwhIyPjgdczf/58evfujY2NDb1792b+/PkW7R4eHvz888/adhXF0aNHiYiIKPJI4uTkZIKCgrhw4QKhoaFERUUxZswYzObcQSOrV6/mzTffZOTIkRw9epShQ4fyyiuv8Msvv1isZ/LkyfTs2ZPDhw/TsWNHgoODuX79OlWrViUhIQFnZ2c+++wzEhIS6NWrFxcuXKBjx44EBgYSFRXFnDlzmD9//l0lOhYtWoStrS3h4eEWyd9JkybxxRdfEBERwblz5+jZsyefffYZ33//PRs2bGDr1q18/vnn2vzTpk1j8eLFfP311xw7doy33nqLl19++a7yQe+88w4fffQRMTEx1KtXr8D91qtXL0aOHEndunVJSEjQtisoKIjdu3eTk5MD3H0sXrhwgVOnTmnH4qxZs/j000+ZPn06hw8fpl27drzwwgvExcXd871LSEigbt26jBw5koSEBEaNGkVKSgrt2rXDzc2N/fv3s2LFCrZv387w4cMtlt2xYwexsbFs27aN9evX3/c5lJycTMeOHdmxYweRkZG0b9+ezp07c/bsWYt+pk+fjr+/P5GRkYwfP569e/cyaNAghg8fjslkonXr1vddluXkyZP8+OOPrFu3js2bNxMZGcmwYcO09qSkJPr378/u3bv57bff8PLyomPHjiQl5f4dtnLlSmbOnMncuXOJi4tjzZo1+Pn5AXDgwAFCQkKYMmUKsbGxbN68WXs2V57br2dCCCH+5pQQ/xCJiYkKUImJiSUdSoFSUlLU3Llz1fyFi9XITxer/5vwsbp46ZJS64cpNSegkCWDlFIzlFIN1eLP/qN+27JFpfy4Qi3oG6B6rXupeIIXQgghRKmTlpamoqOjVVpa2h0tMUqphiXwE3Nf8Xt5ean169crpZSaM2eOKlOmjMW2zJs3TwEqMjJSKaXUL7/8ogB148YNpZRSffr0UW3btrVY5+jRo1WdOnWUUkqZzWZVpkwZtWLFCqWUUgEBAWratGnKw8NDKaXU7t27lY2NjUpJSbFYR3x8vEW/+fH09FQzZ868a/pPP/2k3NzclL29vWrWrJl69913VVRUVJH3SWJiojIYDMpkMimllIqMjFSOjo4qKSlJm+fYsWPK19dX6fV65efnp4YOHao2btxosZ7+/fsrKysrZTAYlJ2dnQKUXq9XP/30U5HimDt3rnJyclLXrl3Lt71Zs2Zq8ODBFtN69OihOnbsqL0G1Lhx47TXycnJClCbNm3Sprm4uKgFCxZor9977z3l4+OjzGazNu3LL79Ujo6OKicnRymlVFBQkKpfv75F33nHxvbt27Vp06ZNU4A6deqUNm3o0KGqXbt2Siml0tPTldFoVBERERbrGjRokOrdu7fFetesWZPvfsjPxIkTlb+/v8W0GzduKL1er/bv36/MZrNyd3dX06ZNU02aNFFKKbVkyRJVuXJlbf5KlSqpDz/80GIdgYGBatiwYUWKwd/fX02cOFF7/d///le5ubmp5ORkbdqGDRuUXq9Xly5dUkrlHjMVKlRQGRkZ2jwPeg7drm7duurzzz/XXnt6eqquXbtazNO7d2+LY0cppXr16qVcXFyKtL0TJ05UVlZW6vz589q0TZs2Kb1erxISEvJdJicnRzk5Oal169YppZT69NNPlbe3t8rMzLxr3pUrVypnZ2d169atAmO4/XomhBDi4Sr4M2/JkBHuQpQieSPcdTo96PQcwp8MvUPuCPcCarhnZmayf/+HXL/+HAD2ZZ04lfEHSWWN2GeYSc9OQylVbNsghBBCCPEwxMTEcPHiRZ555hkAYmNjqVevnsUDPRs3bnzPddz5INLmzZsTFxdHTk4OOp2Oli1bEhYWxs2bN4mOjmbYsGFkZGRw/Phxdu7cSWBgIEaj8aFtV/fu3bl48SKhoaG0b9+esLAwGjRooI26v5dly5bxxBNP4O/vD0BAQACenp4sX75cm6dOnTocPXqU3377jYEDB3L58mU6d+6sPTA1T6tWrVi6dCkRERH079+fV155he7duxcpDpPJRP369XF3d8+3vaB9HxMTYzHt9tHgDg4OODs7c/ny5QL7jYmJoWnTphajhJs3b05ycjLnz5/XpjVs2DDf5W/vr0KFChiNRmrWrGkxLa//kydPkpqaStu2bbW7ExwdHVm8eDGnTp2yWG+jRo0KjLkoXF1d8ff3JywsjCNHjmBra8uQIUOIjIwkOTmZnTt3EhQUBMCtW7e4ePFikfZvUcXExODv74+Dg4PF+sxmM7Gxsdo0Pz8/i7sg7vccSk5OZtSoUfj6+uLq6oqjoyMxMTF3jXC/c3/GxMTQpEkTi2lNmza9r22sVq0alStXtlj+9u37448/GDx4MF5eXri4uODs7ExycrIWW48ePUhLS6NmzZoMHjyY1atXa6WM2rZti6enJzVr1qRv374sXbrUojTRndczIYQQf2+ScBeiFLGxsaFSpUoY7G3xKmvL//EtXD1eaA13vV5PZOQxrl7NfYiXrYstJ6/9ToKTGbt0M2YUGTkPfsuyEEIIIURJCA0NpW3bthYJ9kehVatWhIWFsWvXLurXr4+zs7OWQLw9yfkw2dvb07ZtW8aPH09ERAQDBgxg4sSJRVp2/vz5HDt2DGtra+0nOjqab7/91mI+vV5PYGAgI0aMYNWqVSxcuJD58+cTHx+vzePg4EDVqlXx9/fn22+/Ze/evXeVpymIwWAo+gYXwsbGxuK1TqfTytL8FbcnjgvqT6fTFdp/Xv3yDRs2YDKZtJ/o6GiLOu6F9Xc/8o7FvOPO3d0dX19fdu/e/ciOxfuV33bezzk0atQoVq9ezdSpU9m1axcmkwk/Pz/tgcSF9fOo9e/fH5PJxKxZs4iIiMBkMlGmTBkttqpVqxIbG8tXX32FwWBg2LBhtGzZkqysLJycnDh06BDLli2jYsWKTJgwAX9/f27evAkU3/VMCCFE6SAJdyFKEZ1OR6dOnXB1dqKcoxX9dT+iu36i0Bru1tbW2NkpUlP3A2C4eRF7s4FUR2vs03NrQMqDU4UQQgjxuFm7di1dunTRXvv4+HDkyBGL2uf79+8vdB2+vr6Eh4dbTAsPD8fb2xsrq9zn5eTVoF6xYoVWZ7pVq1Zs376d8PDwh1a/vTB16tQhJSXlnvMdOXKEAwcOEBYWZpEADgsLY8+ePRw/frzQPoAC+9Hr9bz33nuMGzeOtLR7PwOoXr16mEwmrl+/nm97Qfs+L44H5evry549eyzu4AwPD8fJyYkqVar8pXXfqU6dOtjZ2XH27Flq1apl8VO1atUHXq+tra1Wq/12eXXcd+zYYXEsLlu2jBMnTmjTnJ2dqVSp0kPdv76+vkRFRVkcH+Hh4ej1enx8fApd9n7OofDwcAYMGEC3bt3w8/PDw8OD06dPFym+2x/IC/Dbb78VefsAzp49y8WLFy2Wv337wsPDCQkJoWPHjtqDlq9evWqxDoPBQOfOnZk9e7Z23h05cgTI/bvs2Wef5ZNPPuHw4cOcPn2an3/+Gbj7eiaEEOLvTRLuQpQy2dnZ5Ci4kZIFgDkzDeycICsVzHd/MAcwGjNITb2BUjqczx3DMduRZFuFXe4q5MGpQgghhHisXL58mQMHDtCpUydtWp8+fTCbzQwZMoSYmBi2bNnC9OnTAQp8COHIkSPZsWMHH3zwASdOnGDRokV88cUXjBo1SpunXr16uLm58f3331skC/MebHpn2Y6/4tq1a7Rp04YlS5Zw+PBh4uPjWbFiBZ988kmRknHz58+ncePGtGzZkieffFL7admyJYGBgdro9JdeeomZM2eyd+9ezpw5Q1hYGK+//jre3t7Url27wPX36NEDKysrvvzyy3vG0rt3bzw8POjatSvh4eH8/vvvrFy5kj179gAwevRoFi5cyJw5c4iLi2PGjBmsWrXKYt8/iGHDhnHu3DneeOMNjh8/ztq1a5k4cSJvv/02ev3D/fPWycmJUaNG8dZbb7Fo0SJOnTrFoUOH+Pzzz1m0aNEDr7d69erEx8djMpm4evWq9iVSy5YtSUpKYv369RbH4tKlS6lYsSLe3t7aOkaPHs3HH3/M8uXLiY2N5Z133sFkMvHmm28+UEzBwcHY29vTv39/jh49yi+//MIbb7xB3759qVChQqHL3s855OXlxapVqzCZTERFRWnn9b2EhISwefNmpk+fTlxcHF988QWbN2++r23M276oqCh27dpFSEgIPXv2xMPDQ4vtu+++IyYmhr179xIcHGxxJ0feXSJHjx7l999/Z8mSJRgMBjw9PVm/fj2zZ8/GZDJx5swZFi9ejNlsxsfHJ9/rmRBCiL83SbgLUcr89NNP3LyZSMKN3FHp5qz03BHuAJn5j0gyGhUpKTrAgKvuGtZYcys5CYO9EyAJ99udNyVw9uCFkg5DCCGEEIVYt24djRs3pmzZsto0Z2dn1q1bh8lkIiAggPfff58JEyYAFFimoUGDBvz444/88MMPPPnkk0yYMIEpU6YwYMAAbR6dTkeLFi3Q6XQ8/fTTQG4C0dnZmUaNGj3U0haOjo40adKEmTNnaknz8ePHM3jwYL744otCl83MzGTJkiUF1ljv3r07ixcvJisri3bt2rFu3To6d+6Mt7c3/fv3p3bt2mzdulV7ZlB+rK2tGT58OJ988sk9R9zb2tqydetWypcvT8eOHfHz8+Ojjz7S7hzo2rUrs2bNYvr06dStW5e5c+eyYMGCv3zHQOXKldm4cSP79u3D39+f1157jUGDBjFu3Li/tN6CfPDBB4wfP55p06bh6+tL+/bt2bBhAzVq1HjgdXbv3p327dvTunVrypUrx7JlywBwc3PDz8+PcuXKaV+MtGzZErPZfFc5mZCQEN5++21GjhyJn58fmzdvJjQ0FC8vrweKyWg0smXLFq5fv05gYCAvvfQSzzzzzD2PS7i/c2jGjBm4ubnRrFkzOnfuTLt27WjQoME9+3jqqaeYN28es2bNwt/fn61bt973e16rVi1efPFFOnbsyHPPPUe9evX46quvtPb58+dz48YNGjRoQN++fQkJCaF8+fJau6urK/PmzaN58+bUq1eP7du3s27dOsqUKYOrqyurVq2iTZs2+Pr68vXXX7Ns2TLq1q2b7/VMCCHE35tOydMUxT/ErVu3cHFxITExEWdn55IOp0ArV64kIyubs9dSeefKQOICp+Pl5QvfPw9vXwDnSnctEx39KWbzZerWjeLSp9dY5zyYSg0qUu3jLxgXbM3Upz/mybJPlsDWlD7bPtlFZmomz0+SBxYJIYT4+0tPTyc+Pp4aNWrckZS+BLwIZBaw5KNgC6wCPO455wsvvMDTTz/NmDFjCp1v6dKlvPLKKyQmJj60muL/JDk5OURGRlK/fn0tUS7E39GkSZNYs2YNJpOp2Psu6vVMCCHEgyv4M2/JKHh4gxCiRFhbW5ORlY2VTrFadcDTWOO2Ee7513GvU8cKOAkYcXA8hzVQxboqBid34JbUcL9N2zEtSjoEIYQQohTwIDf5fbMY+3SlKMl2gKeffprevXvfNX3x4sXUrFmTypUrExUVxdixY+nZs6ck24UQpVZB1zMhhBB/X5JwF6KUsbGxgbR0rHWKj3mTie5+YPdHbmNmcr7LZGa24saNmpQv/wN2/l64xNlz9dpVyrmWJzfhLiVlhBBCCHEnD4qaAC9uBY0EvXTpEhMmTODSpUtUrFiRHj168OGHHxZzdI/O0qVLGTp0aL5tnp6eHDt2rNhimTp1KlOnTs23rUWLFmzatKnYYnnc1K1blzNnzuTbNnfuXIKDgx9p///E9+5e+7wkych2IYT455GEuxCljI2NDTqlsLNSVOMc+uRyUOXPEjgZ+Y9wP3/eme3bL9GvnxP2Tb1IuJBIwoVEGrqXA05Kwl0IIYQQfwtjxoz5WyevXnjhBZo0aZJvm42NTbHG8tprr9GzZ8982+SOgsJt3LiRrKysfNvu9QDSh+Gf+N7da587OTkxadKk4g1KCCHEP5Yk3IUoZVq2bMnx48fZv38/n+ve49rvvaHeu7mNBZSUMRpzH2qVmuqEbc5VrGzd0d2ww6pceewyzJJwv82Nse+ikpNw//LeD4ASQgghhChOTk5OODk5lXQYALi7u+Pu7l7SYTyWPD09S7T/f+J7V9L7XAghhLidJNyFKGXs7Oywt7fHbDaTgR3kZIDdn394FVBSxsHhAgCpqfY4nNyF9UV7lN6H9DLu2CfnkJqaWFzhl3r2TzdHZWSUdBhCCCGEEEIIIYQQ4m9IEu5ClDJxcXHExsYCkKEzQnYG2BgBXYElZYxGFwBSUuwo76DHmJFGigFuGR2wu2YmNel6cYVf6hk6dyrpEIQQQgghhBBCCCHE35S+pAMQQlhKSkri+vXcBHm63pg7wl2nA1vHAke4W1k54eiYRHa2FXojOKSmk63L5qaNFfbpOaSm3CzGLRBCCCGEEEIIIYQQ4p9JEu5ClDI2Njbk5OQAkKZzxGw25zbYOhZYwx0c6dNnGXXrpqIzQJNzNlQoU4FbOWbsM8ykpd8qnuCFEEIIIYQQQgghhPgHk5IyQpQytyfcP7V/n6eqe/Ik5NZxL2CEO7gADQAjOoPCNltHGfcyXL9+HbsMRWpGSvEEL4QQQgghhBBCCCHEP5gk3IUoZWxsbP73f72ZzGyV+8LWscAa7uDG/v2DuXr1MB062MCsDzmw7Vtcb7hhwIZb2amPPnAhhBBCPFZSrl4k49aNYuvPztkNh7KViq2/h6V69eqMGDGCESNGAKDT6Vi9ejVdu3Yt0bjytGrVioCAAD777LOSDkUIIYQQQiAJdyFKnbJly1K/fn0iIyN5Qb8N31NxwHqwLWyEOyiVw40bCkhHr1PEpEXTJKcpRms3/shJL7b4hRBCCFH6pVy9yPoRHTBnZRZbn3obWzp9tqnISfcBAwawaNEi7bW7uzuBgYF88skn1KtX71GFeU8JCQm4ubk98n4yMzOZNWsWy5YtIzY2Fmtra6pXr07nzp0ZNmwYlSo92i8vwsLCaN269V9ax8SJE5k0aRKrV6/m448/JiYmBrPZTLVq1Wjbtq18SSCEEEKIvyWp4S5EKePi4kLdunUBMJBJ+bTjuQ2F1nAHB4cFpKbmoJQirXdfkqxz5zXYlSWdrEcetxBCCCEeHxm3bhRrsh3AnJV53yPq27dvT0JCAgkJCezYsQNra2s6der0iCIsGg8PD+zs7B5pHxkZGbRt25apU6cyYMAAfv31V44cOcLs2bO5evUqn3/++SPtH6BZs2bavk9ISKBnz54W70dCQgJnzpzR/v/ZZ5/h7Oxs0T5q1Ch27NhBr1696N69O/v27ePgwYN8+OGHZGXJ51MhhBBC/D1Jwl2IUiYzM5OzZ88CkIQR++zE3IZCa7iD0agwm3VkZNih+z0abMzorHTY2LmTrs8pjtCFEEIIIR4qOzs7PDw88PDwICAggHfeeYdz585x5coVbZ6xY8fi7e2N0WikZs2ajB8/3iKZGxUVRevWrXFycsLZ2ZmGDRty4MABrX337t20aNECg8FA1apVCQkJISWl4Off6HQ61qxZA8Dp06fR6XSsWrWK1q1bYzQa8ff3Z8+ePRbL3G8fM2fOZPfu3fz888+EhITQsGFDqlWrRlBQEF9//TVTp04tcNkbN27Qr18/3NzcMBqNdOjQgbi4OACUUpQrV46ffvpJm79Pnz5UqVLFIlY7Ozuys7O1fe/h4YHBYLB4Pzw8PKhWrZr2fxcXF3Q6nUW7o6Mj69ato3nz5owePRofHx+8vb3p2rUrX375ZYHbIIQQQgjxOJOEuxClTGpqKr/++isAKcqIMecWKHWPGu5gNOpyl0lxQOegw1FvQGcAK2sX0q1VscT+OEi7lU7aTSmxI4QQQjxukpOTWbJkCbVq1aJMmTLadCcnJxYuXEh0dDSzZs1i3rx5zJw5U2sPDg6mSpUq7N+/n4MHD/LOO+9oz8w5deoU7du3p3v37hw+fJjly5eze/duhg8ffl+xvf/++4waNQqTyYS3tze9e/cmOzv7gftYtmwZbdu2pX79+vm263S6ApcdMGAABw4cIDQ0lD179qCUomPHjmRlZaHT6WjZsiVhYWFAbnL+9OnTpKWlcfx47l2VO3fuJDAwEKPReF/7oCAeHh4cO3aMo0ePPpT1CSGEEEKUdpJwF6KUsbW1BcAMZOqN2JAJWWn3rOHu7q7o1CkeZ+db6Iw6etk0pVzZ8mDlQIatjhyzjHIH2P31Pn6eGV7SYQghhBCiCNavX4+joyOOjo44OTkRGhrK8uXL0ev/92fMuHHjaNasmVbffNSoUfz4449a+9mzZ3n22WepXbs2Xl5e9OjRA39/fwCmTZtGcHAwI0aMwMvLi2bNmjF79mwWL15MenrRv6AfNWoUzz//PN7e3kyePJkzZ85w8uTJB+7jxIkT+Pj4WEzr1q2bti+aNWuW73JxcXGEhobyzTff0KJFC/z9/Vm6dCkXLlzQRuW3atVKS7jv2rULHx8fgoKCtGlhYWEEBQUVedvv5Y033iAwMBA/Pz+qV6/Ov/71L7799lsyMjIeWh9CCCGEEKWJJNyFKGWsrfOeZazjqnUVJth8AHrre9Zwt7ExUKnSDWxsstE76Hj6qjvVK1Qn22wDCtJuXilw2X+SBj39aNwvoKTDEEIIIUQRtG7dGpPJhMlkYt++fbRr144OHTpw5swZbZ7ly5fTvHlzrYTJuHHjtPJ8AG+//Tavvvoqzz77LB999BGnTp3S2qKioli4cKGWyHZ0dKRdu3aYzWbi4+OLHOftD3GtWLEiAJcvX36ofXz11VeYTCYGDhxIampqvvPExMRgbW1NkyZNtGllypTBx8eHmJgYAIKCgoiOjubKlSvs3LmTBg0aaAn3rKwsIiIiaNWqVZHjuhcHBwc2bNjAyZMnGTduHI6OjowcOZLGjRsXuB1CCCGEEI8zSbgLUcrkJdwVejKtjGzNDCRbZ33PGu4wCZOpB2fOVMNl4mjOBFbjKldQ6DCYDSRfvlg8G1DKlanuRrknytx7RiGEEEKUOAcHB2rVqkWtWrUIDAzkm2++ISUlhXnz5gGwZ88egoOD6dixI+vXrycyMpL333+fzMz/PRB20qRJHDt2jOeff56ff/6ZOnXqsHr1aiC3TM3QoUO1pL7JZCIqKoq4uDieeOKJIseZV6IG/lfuxWw2P3AfXl5exMbGWkyrWLEitWrVwt3dvchx5cfPzw93d3d27tzJrl27aNiwIUFBQezcuZP9+/eTlZVV4Aj6v+KJJ57g1Vdf5ZtvvuHQoUNER0ezfPnyh96PEEIIIURJs773LEKI4qTX66lQoQJXrt+kqq2OvgnLSUmoikteDXelIN+6nW6cOnWNChWq4vm0Dz9HHuLs1bPUwhunbGdSr14EGhT35gghhBBCPDQ6nQ69Xk9aWhoAEREReHp68v7772vz3D76PY+3tzfe3t689dZb9O7dmwULFtCtWzcaNGhAdHQ0tWrVemQxP0gfvXv3Zty4cURGRhZYxz0/vr6+ZGdns3fvXi1pfu3aNWJjY6lTpw6Quw9btGjB2rVrOXbsGAEBAdSrV4+MjAzmzp1Lo0aNcHBwuL+NvE/Vq1fHaDQW+uBYIYQQQojHlYxwF6IU6tKlC27OjlR0seV13QLSz0fm1nBXOZBdUD3RzRiNl0hNNZJ59AB2sae5ab6BlZUep2wnUq9fLtZtKK2SFy0m6eu5JR2GEEIIIYogIyODS5cucenSJWJiYnjjjTdITk6mc+fOQO5I8LNnz/LDDz9w6tQpZs+erY1eB0hLS2P48OGEhYVx5swZwsPD2b9/P76+vgCMHTuWiIgIhg8fjslkIi4ujrVr1973Q1ML8yB9vPXWWzRt2pRnnnmGWbNmcejQIeLj49myZQubNm3Cysoq3+W8vLzo0qULgwcPZvfu3URFRfHyyy9TuXJlunTpos3XqlUrli1bhr+/P0ajEb1eT8uWLVm6dOlDrd8OuXcYjBkzhrCwMOLj44mMjGTgwIFkZWXRtm3bh9qXEEIIIURpIAl3IUqpLDMkZSoAMpKu5paUgULKylzAaEwgJcWBnDMx2Ow9TFJ2Ek6uzjjmOJEiNdwByElIIOeilNcRQgghHgebN2+mYsWKVKxYkSZNmrB//35WrFih1Rh/4YUXeOuttxg+fDgBAQFEREQwfvx4bXkrKyuuXbtGv3798Pb2pmfPnnTo0IHJkycDubXXd+7cyYkTJ2jRogX169dnwoQJVKpU6aFtw4P0YW9vz44dOxg7diwLFizg6aefxtfXlxEjRtC8eXPtAaj5WbBgAQ0bNqRTp040bdoUpRQbN260KHsTFBRETk6ORXK9VatW5OTkPNT67Xl9/f777/Tr14/atWvToUMHLl26xNatW+96MKwQQgghxN+BTimlSjoIIYrDrVu3cHFxITExEWdn55IOp1CrVq3ij+u3uJZtT0jCYK76j6BmQCtY/CyEnAL3mvks9QMHDvxKbKwXL9U6xdrP9rCklwevO4UQdcZEYOo1Wg//pLg3RQghhBAlKD09nfj4eGrUqIG9vb02PeXqRdaP6IA5K7OQpR8uvY0tnT7bhEPZh5fMFn9NTk6OVramoFHzQgghhBClXUGfeUuK1HAXohSysrJCp9OhU2Zu6ZzISb2eW1IGChnh7kjFiucxmw3o3ewp80cqdVx8cHF2wfGUEykpp4otfiGEEEKUbg5lK9Hps01k3LpRbH3aObtJsl0IIYQQQvztScJdiFLIxsYGHaDHzB6rp6loWx0vW8fcxsykApZypHLli1SurCfnch1qxybTouwrXHJx4TCHSc7IKK7whRBCCPEYcChbSRLgQgghhBBCPGRSw12IUig34a7QKzM/urxBpMsLRajhXoucnDf54w8PMu1sMf6rFzn2dji75JbPSVNym7AQQgghhBBCCCGEEI+SJNyFKIVsbGzQ6cDOGirapaESz0LeCPeMgka4VyE9/UXWrm3AlUQbzP9+l17H3uJkWhw5ZJNpZVds8QshhBBCCCGEEEII8U8kJWWEKIUaN26MtbU1586dI/DSN1S/fhhsj+Q2FjjCPR2DIQJQpKTkUCbnOgDJWcmkW6dgZ+uIUgqdTlcs2yCEEEIIIYQQQgghxD+NjHAXohQyGo0YDAays7Mx27lhn50IVjZgZVdIDfdU9Pp3MRiySE1VpI5+H5scHcmZSWRZZ4C9K+rmzeLcDCGEEEIIIYQQQggh/lEk4S5EKXT27FmOHD/FrZQMlMENY05iboOdUyEj3B1y/3XIJiUlB6vKlXFIVyRlJaPsstHbupJ9+XLxbIAQQgghhBBCCCGEEP9AknAXohRKTEwkMzURK50ZDO4YSIOcrNw67gXWcLcDbHBxyUGnS8G6kgfGlGySM5PQGfXo9TYkXbhYnJshhBBCCCGEEEIIIcQ/iiTchSiFbGxsQCn0OlD2buSgJyf1OtgWNsIdwIFnnrlFixY7sa7lzBuzTtLHuzc2rgYArl2REe4R3xxg5+d7SjoMIYQQQgghhBBCCPE3JA9NFaIUsrGx0f6fWKk1T0euZ5PeDVdbx0JquAM8CVRGKbCqYYW7jQv2SRkYnBzIUVncTEx85LGXdmWfcCc7M6ekwxBCCCFKnEpMR6VmFVt/OqMNOhf7YuvvYalevTojRoxgxIgRAOh0OlavXk3Xrl1LNK48rVq1IiAggM8++6ykQxFCCCGEEEjCXTxm0tPT+de//kV0dDQGg4Hy5cszZ84catWqVdKhPVS3J9ztra1R6ElMy8K10BruAJ+RlHSdlSszeO45V46smcq5S6sx2Bi4pv+Dm2nGRx98KefdumZJhyCEEEKUOJWYTsaX+yDbXHydWuuxe71xkZPuAwYMYNGiRdprd3d3AgMD+eSTT6hXr96jivKeEhIScHNze+T9ZGZmMmvWLJYtW0ZsbCzW1tZUr16dzp07M2zYMCpVqvRI+w8LC6N169Z/aR0TJ05k0qRJrF69mo8//piYmBjMZjPVqlWjbdu2j92XBKXtyxYhhBBClE5SUkY8doYMGUJsbCxRUVF06dKFV199taRDeuhcXV2pUTP3SwQPuzS+YQRZp3bco4Z7LgcHZ3JyrLl69SoXky9w4NJ+7K0NJFslk6hUcYQvhBBCiFJOpWYVb7IdINt83yPq27dvT0JCAgkJCezYsQNra2s6der0iAIsGg8PD+zs7B5pHxkZGbRt25apU6cyYMAAfv31V44cOcLs2bO5evUqn3/++SPtH6BZs2bavk9ISKBnz54W70dCQgJnzpzR/v/ZZ5/h7Oxs0T5q1Ch27NhBr1696N69O/v27ePgwYN8+OGHZGUV390Vpc0/eduFEEKIfwJJuIvHir29PR07dkSn0wHw1FNPcfr06ZIN6hFwdnbGv96TADg6GHlSd5zs62f/rOFeWMJ9LHr9aMqWTefKlTR0S1eSlHQVg7WBRNtb3LK1Rf3Dk+4Z+w+QsUdquAshhBCPAzs7Ozw8PPDw8CAgIIB33nmHc+fOceXKFW2esWPH4u3tjdFopGbNmowfP94ioRkVFUXr1q1xcnLC2dmZhg0bcuDAAa199+7dtGjRAoPBQNWqVQkJCSElJaXAmHQ6HWvWrAHg9OnT6HQ6Vq1aRevWrTEajfj7+7Pnjs8a99vHzJkz2b17Nz///DMhISE0bNiQatWqERQUxNdff83UqVMLXPbGjRv069cPNzc3jEYjHTp0IC4uDgClFOXKleOnn37S5u/Tpw9VqlSxiNXOzo7s7Gxt33t4eGAwGCzeDw8PD6pVq6b938XFBZ1OZ9Hu6OjIunXraN68OaNHj8bHxwdvb2+6du3Kl19+WeA2LF68GEdHRy1ugGHDhlG7dm1SU1Pvmv/WrVsYDAY2bdpkMX316tU4OTlpy5w7d46ePXvi6uqKu7s7Xbp0uetviW+//Za6detiZ2dHxYoVGT58OJBbWgigW7du6HQ67TXAnDlzeOKJJ7C1tcXHx4fvvvvOYp06nY45c+bwwgsv4ODgwIcffljgtgshhBDi8ScJd/FYmzVrFl26dMm3LSMjg1u3bln8PC6ys7OJP38JgJQsRaqyJzv5au4I90JLytgCKZQtq+fqVSuMKdkk6zKxt7In0SaJHCsrkpMLW/7vL+Wb+STNfvSjwoQQQgjxcCUnJ7NkyRJq1apFmTJltOlOTk4sXLiQ6OhoZs2axbx585g5c6bWHhwcTJUqVdi/fz8HDx7knXfe0cr3nTp1ivbt29O9e3cOHz7M8uXL2b17t5ZkLar333+fUaNGYTKZ8Pb2pnfv3mRnZz9wH8uWLaNt27bUr18/3/a8wSf5GTBgAAcOHCA0NJQ9e/aglKJjx45kZWWh0+lo2bIlYWFhQG5y/vTp06SlpXH8+HEAdu7cSWBgIEbjwylF6OHhwbFjxzh69GiRl+nXrx8dO3YkODiY7OxsNmzYwDfffMPSpUvzjcvZ2ZlOnTrx/fffW0xfunQpXbt2xWg0kpWVRbt27XBycmLXrl2Eh4fj6OhI+/btyczMBHIT56+//jpDhgzhyJEjhIaGaqUr9+/fD8CCBQtISEjQXq9evZo333yTkSNHcvToUYYOHcorr7zCL7/8YhHLpEmT6NatG0eOHGHgwIFF34FCCCGEeOxIDXfx2Jo6dSonT55kx44d+bZPmzaNyZMnF3NUD0dmZiZRB34D4GZyBsk6J8yp18HN6R4lZRyBU5Qt68SxY9lUdiiD0t3CSqfnlnXucteuXcPJyenRb0Qp5frZDPiHj/IXQgghHhfr16/H0dERgJSUFCpWrMj69evR6/83bmjcuHHa/6tXr86oUaP44YcfGDNmDABnz55l9OjR1K5dGwAvLy9t/mnTphEcHKw9ENXLy4vZs2cTFBTEnDlzsLcvWr35UaNG8fzzzwMwefJk6taty8mTJ6ldu/YD9XHixAlatWplMa1bt25s27YNgHr16hEREXHXcnFxcYSGhhIeHk6zZs2A3KRz1apVWbNmDT169KBVq1bMnTsXgF27duHj40PNmjUJCwujdu3ahIWFERQUVKTtLoo33niDXbt24efnh6enJ0899RTPPfccwcHBhZbmmTt3LvXq1SMkJIRVq1YxadIkGjZsWOD8wcHB9O3bl9TUVIxGI7du3WLDhg2sXr0agOXLl2M2m/nmm2+0LywWLFiAq6srYWFhPPfcc/z73/9m5MiRvPnmm9p6AwMDAShXrhyQW/rRw8NDa58+fToDBgxg2LBhALz99tv89ttvTJ8+3aIGfp8+fXjllVfud/cJIYQQ4jEkI9zFY2n69OmsWrWKTZs2FTj65t133yUxMVH7OXfuXDFH+eCsrf/3XVhmZhapVs6Qdu3PkjKFjVB3AFKoUaMqwcFL8HJxp2eEwmhjJF2fhk1yEpcSEh55/KWZ3mBA/5BGbAkhhBDi0WrdujUmkwmTycS+ffto164dHTp04MyZM9o8y5cvp3nz5loJk3HjxnH27Fmt/e233+bVV1/l2Wef5aOPPuLUqVNaW1RUFAsXLsTR0VH7adeuHWazmfj4+CLHeftDXCtWrAjA5cuXH2ofX331FSaTiYEDB+ZbVgUgJiYGa2trmjRpok0rU6YMPj4+xMTEABAUFER0dDRXrlxh586dNGjQgKCgIMLCwsjKyiIiIuKuZP9f4eDgwIYNGzh58iTjxo3D0dGRkSNH0rhx4wK3A8DNzY358+dr5VreeecdrW3q1KkW+/Ps2bN07NgRGxsbQkNDAVi5ciXOzs48++yzQO77cPLkSZycnLTl3N3dSU9P59SpU1y+fJmLFy/yzDPP3Nf2xcTE0Lx5c4tpzZs31/Z3nkaNGt3XeoUQQgjx+JKEu3jszJgxg2XLlrFt2zZcXV0LnM/Ozg5nZ2eLn8fF7Qn3rOwsVru+zn7nF/4sKXOvEe7J2NpWx8Ehlco13Hlm0wVc7NxAB46XzpNw/vwjj18IIYQQ4mFwcHCgVq1a1KpVi8DAQL755htSUlKYN28eAHv27CE4OJiOHTuyfv16IiMjef/997USIZBbyuPYsWM8//zz/Pzzz9SpU0cb9ZycnMzQoUO1pL7JZCIqKoq4uDieeOKJIseZV6IG/lfuxWw2P3AfXl5exMbGWkyrWLEitWrVwt3dvchx5cfPzw93d3d27tzJrl27aNiwIUFBQezcuZP9+/eTlZWljY5/mJ544gleffVVvvnmGw4dOkR0dDTLly8vdJlff/0VKysrEhISLGrev/baaxb7s1KlStja2vLSSy9pZWW+//57evXqpX2uTk5OpmHDhhbLmUwmTpw4QZ8+fTAYDA99m2/n4ODwSNcvhBBCiNJDSsqIx8r58+cZOXIkNWvW1G7RtLOzY+/evSUc2cOl1+uxsrIiJyeHzMwszrsH5X47ZpcK2emQkw1W+Z2+XYG2gBuHDtUnw6M6mXNH45SdDoDdlfP8cfMmWVlZFn8YCiGEEEI8DnQ6HXq9nrS0NAAiIiLw9PTk/fff1+a5ffR7Hm9vb7y9vXnrrbfo3bs3CxYsoFu3bjRo0IDo6GitTvej8CB99O7dm3HjxhEZGVlgHff8+Pr6kp2dzd69e7Wk+bVr14iNjaVOnTpA7j5s0aIFa9eu5dixYwQEBFCvXj0yMjKYO3cujRo1euTJ4erVq2M0Ggt9cGxERAQff/wx69atY+zYsQwfPpxFixYB4O7unu8XD8HBwbRt25Zjx47x888/8+9//1tra9CgAcuXL6d8+fIFDsSpXr06O3bssCgFczsbGxtycnIspvn6+hIeHk7//v21aeHh4dr+FkIIIcQ/j4xwF4+VKlWqoJTi1KlT2qiUv1uyPY+bmzsKcLLT45cTRd0rq3NHuEMhZWVcgcqAkdRUd85eyubTy8s4n5xbTsf6xkWUUvzxxx+PfgOEEEIIIf6ijIwMLl26xKVLl4iJieGNN94gOTmZzp07A7kjwc+ePcsPP/zAqVOnmD17tjZ6HSAtLY3hw4cTFhbGmTNnCA8PZ//+/fj6+gIwduxYIiIiGD58OCaTibi4ONauXXvfD00tzIP08dZbb9G0aVOeeeYZZs2axaFDh4iPj2fLli1s2rQJKyurfJfz8vKiS5cuDB48mN27dxMVFcXLL79M5cqV6dKlizZfq1atWLZsGf7+/hiNRvR6PS1btmTp0qUPtX475N5hMGbMGMLCwoiPjycyMpKBAweSlZVF27Zt810mKSmJvn37EhISQocOHVi6dCnLly/np59+KrSvli1b4uHhQXBwMDVq1LAorRMcHEzZsmXp0qULu3btIj4+nrCwMEJCQjj/5x2gkyZN4tNPP2X27NnExcVx6NAhPv/8c20deQn5S5cucePGDQBGjx7NwoULmTNnDnFxccyYMYNVq1YxatSov7rrhBBCCPGYkoS7EKXUiy92w97ODjejNU+mR9A+cUFuDXcoJOF+EhgPJFKuHCQmgm22NRkJFwAwqxTsgIR/eB13IYQQQjweNm/eTMWKFalYsSJNmjRh//79rFixQqsx/sILL/DWW28xfPhwAgICiIiIYPz48dryVlZWXLt2jX79+uHt7U3Pnj3p0KEDkydPBnJrr+/cuZMTJ07QokUL6tevz4QJE6hUqdJD24YH6cPe3p4dO3YwduxYFixYwNNPP42vry8jRoygefPmrFmzpsBlFyxYQMOGDenUqRNNmzZFKcXGjRst7m4MCgoiJyfHIrneqlUrcnJyHmr99ry+fv/9d/r160ft2rXp0KEDly5dYuvWrfj4+OS7zJtvvomDgwNTp04FcsvgTJ06laFDh3LhwoUC+9LpdPTu3ZuoqCiCg4Mt2oxGI7/++ivVqlXjxRdfxNfXl0GDBpGenq6NeO/fvz+fffYZX331FXXr1qVTp07ExcVp6/j000/Ztm0bVatW1e486Nq1K7NmzWL69OnUrVuXuXPnsmDBgoe+H4UQQgjx+NAppVRJByFEcbh16xYuLi4kJiY+NvXcFy7+jidqeWM4tQqfU3NwemUjLGgBr0dDOd98ljgIDAVWcu3ad6xcWR6TbRhNHKuz0jqKgb+ATdU2mH28tZFhQgghhPj7Sk9PJz4+nho1amBvb69NV4npZHy5D7LNxReMtR671xujc7G/97yiWOTk5GhlawoaNS+EEEIIUdoV9Jm3pEgNdyFKqc2bN5OUmk78H4n4Gd1xIJkcayNWUMgI97x6mym4uVXAyiqbMplupKTcwNrVmqxqZalw6nei3VzJzs62eDirEEIIIf45dC722L3eGJWaVXx9Gm0k2S6EEEIIIf72JNsmRCllNpvRATk52dg4l0WPIikjEyeAjKQClvqzxjsp6PVVad16PmvWKRxTnTCUNZBVsRwuK3aSE+DPlStXqFixYrFsixBCCCFKH52LvSTAhRBCCCGEeMikhrsQpVRunU0dOTk5WJV5gjDVjKSsP78jK3CEe17CPRmoQs2a8Qy8aUfHfZkYrA1klHPB+fwFbK2s/rF13GN3nOLYphMlHYYQQgghhBBCCCGE+BuShLsQpZSNjQ3owJydhV3VRrzDBK7Z/DkiPbOwEe6DgWpAVZKSHIkJCET33LMYbAxkujmgU4pyev0/NuF+/cxNrsVfL+kwhBBCCCGEEEIIIcTfkJSUEaKUsrGxQYcOXXYGLvZWuHOdW6kZoNMXMsLdmtyHpubKzHTjyB9GVlc6isHaQLo+B6tq1Shz/TrRSmE2m9Hr/1nfuzUd2LCkQxBCCCGEEEIIIYQQf1P/rEybEI+RevXqEfBkbWzJxMUmi426PhjiN4GtYyE13AEOAfEAuLk5o9eb0SWBvc6OtOw0bOrWwf34CbKzs7l69WqxbIsQQgghhBBCCCGEEP8EknAXopRycnKifPnyZGRkYNbbkYU12clXwdapkJIyAP8GQgHQ6yvh4pqIfYYBu/Sc3IR7nTo47NuHtbU1Fy9eLJZtKU3MaWmYU1NLOgwhhBBCCCGEEEII8TckCXchSqmEhATW7zYBkJySQrLOGZV2PXeEe4ElZQAcyH1oKkAVypW/inOOKzbp2aRlp2JTxxeuXqW8qyuXLl16xFtR+twc8TbXB71a0mEIIYQQQgghhBBCiL8hqeEuRCmVmJiIQ9YNAJKTk7G2coa062DndI+SMo5Ayp//r0qtmlvZdC6HsinppDmATd26AJQ3m4m+dOkfV8fdYfCrkJ1V0mEIIYQQQgghhBBCiL8hSbgLUUrZ2NgAoICkpCQM1i5YZ9wEh/sb4V6lygVe/eUyPz9VjzS3TKyqVEHn7EyZS3+QaWvD9evXKVu27KPdmFLErpE8NFUIIYSA3C/009PTi60/e3t7HB0di62/h6V69eqMGDGCESNGAKDT6Vi9ejVdu3Yt0bgehYULFzJixAhu3rxZ0qHkKzU1lb59+7Jt2zaSkpK4ceMGrq6u/8/efcdVWb4PHP88Z7MOGxkiIEPEvfdMc6eZZWqZ7WXbxvdre+9hlm21beXIzJ0jV07UBBVQZImyx4FzOOv5/UHxzZ8jNRWx6/168UrOc4/rfh60w8XNddd3WEIIIYQQx5CEuxAXqT8T7jXoqaysZEHcR+SUuehgeOlvariHAxV//Dmydqy2SXi4fbA6c1EUBX3zRPQpKWg7diA/P/9flXAXQgghRG2yfc6cObhcrgs2p1arZezYsaeddJ80aRKzZ8+u+zwgIIBOnTrx6quv0rp16/MV5t/Kz8/H39//vI2/b98+mjdvzqZNm+jatWvd6127dmXnzp2UlZVhMpkAsNls+Pn58d5773HzzTeft5j+TkZGBi+88AIrVqygsLCQ8PBwunbtykMPPUTHjh3P2TyzZ89m3bp1bNy4kaCgIHx9fc/Z2EIIIYQQ58q/p46EEA3Mnwl3q0uLxWLBy9tMqdV1GjXcHwSe/uPPQaiqkbXBLbAFJ2B1WmvHbtECd0oqISEh5Ofnn89lCCGEEOIiZLPZLmiyHcDlcp3xjvrBgweTn59Pfn4+v/zyCzqdjuHDh5+nCE9PaGgoRqPxvI2fmJhIaGgoa9asqXutsrKSHTt2EBwczG+//Vb3+qZNm6ipqaF///7nLZ6/s23bNjp06EBaWhoffvghqampzJ8/n8TERB566KFzOteBAwdo3rw5LVu2JDQ0FEVRzngMl8uF2+0+p3Gdit1uv2BzCSGEEOLiIAl3IS5S3t7eRMclEhsRRGVlJZ1K53JX2ROnUcMdwAU4AQVojM77MO5KF07VicPlQJ+UhPPgQRoFBnLkyBFUVT3/CxJCCCGEOENGo5HQ0FBCQ0Np27Ytjz32GDk5ORQWFta1efTRR0lISMDT05OmTZvyxBNP4HD877yWXbt20a9fP3x8fDCbzXTo0IFt27bVXV+/fj29evXCw8ODyMhI7r33XqqqqjgZRVFYsGABAIcOHUJRFObNm0e/fv3w9PSkTZs2bNq06Zg+ZzpHv379jkm4r1+/noSEBEaMGHHM62vWrCEqKoqYmBgAfvzxR9q3b4/JZKJp06Y888wzOJ3OuvZvvvkmrVq1wsvLi8jISCZPnkx1dfVJ4ygsLKRjx45ceeWV1NTUHHddVVUmTZpEfHw869atY9iwYcTGxtK2bVueeuopfvzxx7q2v//+O/3798fDw4PAwEBuu+02LJb/bSKZNGkSo0aN4vXXXycsLIzAwEDuvvvuumfZt29f3njjDX799VcURaFv374AlJaWMnHiRPz9/fH09GTIkCGkp6fXjTtr1iz8/PxYuHAhSUlJGI1GsrOziY6O5vnnn2fixIl4e3sTFRXFwoULKSwsZOTIkXh7e9O6detjvlZO51lGR0fz3HPPMXHiRMxmM7fddttJ768QQgghLk2ScBfiIuXj48Pl/XvTtHEolZWV+KtltHLtRNX/3Q73EqA3sAEARWlMSHARilVBq2qxuqzoWySBqhJSY8dms120dTqFEEIIIf5ksVj48ssviYuLIzAwsO51Hx8fZs2aRWpqKu+88w4ff/wxb731Vt31CRMm0LhxY7Zu3cr27dt57LHH6n6T8MCBAwwePJirrrqK3bt3M2fOHNavX8/kyZPPKLapU6cyZcoUdu7cSUJCAuPGjatLdJ/NHP369WP9+vV1Y6xevZq+ffvSp08fVq9eXddu9erV9OvXD4B169YxceJE7rvvPlJTU/nwww+ZNWsWL7zwQl17jUbDtGnTSElJYfbs2axevZpp06adMIacnBx69epFy5Yt+eGHH064q3/nzp2kpKTw0EMPodEc/63ln/XVq6qqGDRoEP7+/mzdupXvv/+elStXHncPVq9ezYEDB1i9ejWzZ89m1qxZzJo1C4B58+Zx66230q1bN/Lz85k3bx5Qm6jftm0bCxcuZNOmTaiqytChQ4/5oUt1dTWvvPIKn3zyCSkpKYSEhADw1ltv0aNHD5KTkxk2bBjXX389EydO5LrrrmPHjh3ExsYyceLEus0pp/ssX3/9ddq0aUNycjJPPPHECe+vEEIIIS5dknAX4iLldrvJOJTLlsyy2l+/9gzErFZi13j8TQ13f2qPZzj4x+eRNAktRFE0mB2+WB1W9AkJoNXin1tb013KygghhBDiYrRo0SK8vb3x9vbGx8eHhQsXMmfOnGOSu48//jjdu3cnOjqaESNGMGXKFL777ru669nZ2QwYMIDExETi4+O5+uqradOmDQAvvfQSEyZM4P777yc+Pp7u3bszbdo0Pv/88zMqfzNlyhSGDRtGQkICzzzzDFlZWWRkZJz1HP369aOqqoqtW7cCtTvZ+/TpQ+/evdm8eTM2mw2r1cqWLVvqEu7PPPMMjz32GDfccANNmzZl4MCBPPfcc3z44Yd1495///3069eP6Oho+vfvz7PPPsvKlSuPm3///v306NGDQYMGMXPmTLRa7Qnj/HMneWJi4invz9dff43NZuPzzz+nZcuW9O/fn+nTp/PFF19w9OjRunb+/v5Mnz6dxMREhg8fzrBhw/jll1+A2hr+np6eGAwGQkNDCQgIID09nYULF/LJJ5/Qq1cv2rRpw1dffUVeXl7dbyEAOBwO3n//fbp3706zZs3w9PQEYOjQodx+++3Ex8fz5JNPUlFRQadOnbj66qtJSEjg0UcfZe/evXUxnu6z7N+/Pw899BCxsbHExsae8t4IIYQQ4tIjCXchLlJOp5NVyxezM7P2V6ZdpkB0iotql+5vdrgrQCz/S7g3JiasCLujGC1arE4rismELjYWde9egoODJeEuhBBCiItSv3792LlzJzt37mTLli0MGjSIIUOGkJWVVddmzpw59OjRg9DQULy9vXn88cfJzs6uu/7ggw9yyy23MGDAAF5++WUOHDhQd23Xrl3MmjWrLqnv7e3NoEGDcLvdZGZmnnacfz3ENSwsDICCgoKzniMuLo7GjRuzZs0aKioqSE5Opk+fPoSFhdGkSRM2bdpUV7/9z4T7rl27ePbZZ4+Z59ZbbyU/P7+ubMzKlSu57LLLiIiIwMfHhxtuuIHy8vJjyspYrVZ69erF6NGjeeedd05ZJ/10yxLu3buXNm3a4OXlVfdajx49cLvd7N+/v+61Fi1aHJPcDwsLq7uPJxtXp9PRpUuXutcCAwNp1qwZe/furXvNYDCc8KDdv77WqFEjAFq1anXca2f6LM/lQbFCCCGEaHgk4S7ERUqn0wHgVmv/mrr0ZgBqnK7ahPspv8Fpyl8T7ga9i8Zp31JkKMTqrP2GSt8iCUdKKqGhoeTn50sddyGEEEJcdLy8vIiLiyMuLo5OnTrxySefUFVVxccffwzUHho6YcIEhg4dyqJFi0hOTmbq1KnHHFT59NNPk5KSwrBhw1i1ahVJSUnMnz8fqC1Tc/vtt9cl9Xfu3MmuXbtIT08/o53Jf5aoAeoS1H8ezHm2c/Tt25fVq1ezbt064uPj68qg/FlWZvXq1cTFxREZGVk3zzPPPHPMPL///jvp6emYTCYOHTrE8OHDad26NXPnzmX79u28++67wLEHexqNRgYMGMCiRYvIy8s75boTEhIA2Ldv32nfq1P5632E2nt5Lg449fDwOOEPDk703M7Fs/zrDxaEEEII8e+jq+8AhBAnptFo0Ol0eJp0qCg4vCJ4Rp3CeI0/oaobHFYweJ6kd1NgCbWHpzYGoI3ThdFlpPrPhHtSErblKwgLDWX37t1UVlZiNpsvxNLqVdHBEtwuNyHxQfUdihBCCCHOkKIoaDQarFYrABs3biQqKoqpU6fWtfnr7vc/JSQkkJCQwAMPPMC4ceOYOXMmV155Je3btyc1NZW4uLjzFvPZztGvXz/uvfdekpKS6g4IBejduzcff/wxqqrW7W7/c579+/efdJ7t27fjdrt544036kryfPvtt8e102g0fPHFF4wfP77u8Nbw8PATjtm2bVuSkpJ44403GDt27HF13MvKyvDz86N58+bMmjWLqqqqumT0hg0b0Gg0NGvW7Izuy181b94cp9PJ5s2b6d69OwDFxcXs37+fpKSksx73ZC7E14sQQgghGj7Z4S7ERUyv12M2anBrDDhVHUsYQJniX3vxlHXchwM/A1ogFFXVkjd+PAOKB3Gk8kjt2EnNUauqCPpjR9O/paxM8g972PrlrvoOQwghhBCnoaamhiNHjnDkyBH27t3LPffcg8ViYcSIEQDEx8eTnZ3Nt99+y4EDB5g2bVrd7nWoLY8yefJk1qxZQ1ZWFhs2bGDr1q00b94cgEcffZSNGzcyefJkdu7cSXp6Oj/++OMZH5p6Kmc7x5913D/77DP69OlT93qfPn3YvHnzMfXbAZ588kk+//xznnnmGVJSUti7dy/ffvstjz/+OFBbpsbhcPDuu+9y8OBBvvjiCz766KMTzq3Vavnqq69o06YN/fv358iRIydspygKM2fOJC0tjV69erF48WIOHjzI7t27eeGFFxg5ciRQe3CtyWTihhtuYM+ePaxevZp77rmH66+/vq5sy9mIj49n5MiR3Hrrraxfv55du3Zx3XXXERERUTf3uXQhvl6EEEII0fBJwl2Ii5i3tzexjcyYPL2oslRyjW4JDktx7cVT1nE3A35//FmHxeFDsfdOFBTyjuYCoG/RAgBNegaBgYH/moR7rzu70P+hHvUdhhBCCCFOw9KlSwkLCyMsLIwuXbqwdetWvv/++7od31dccQUPPPAAkydPpm3btmzcuJEnnniirr9Wq6W4uJiJEyeSkJDANddcw5AhQ3jmmWeA2hrea9eurUsYt2vXjieffPKkO7rPxtnOERMTQ1RUFJWVlcck3Js0aUJ4eDh2u/2Yne+DBg1i0aJFLF++nE6dOtG1a1feeustoqKiAGjTpg1vvvkmr7zyCi1btuSrr77ihRdeOOn8Op2Ob775hhYtWtC/f/+T1lLv3Lkz27ZtIy4ujltvvZXmzZtzxRVXkJKSwttvvw2Ap6cny5Yto6SkhE6dOjFmzBguu+wypk+ffpp38eRmzpxJhw4dGD58ON26dUNVVRYvXnxceZpz4UJ8vQghhBCi4VNUKdws/iUqKirw9fWlvLy8wZVOWbNmDWWlpYzYNYadEbfQIe8juD0ZwtqeotdzQEvgSgqqx5JZepjkn8dREVLJI6MeBSC/bXu8JoxnT4/uZGZmMn78+FMejCWEEEKIhsVms5GZmUlMTAwmk6nudYvFwpw5c3C5XBcsFq1Wy9ixY/H29r5gc4pTc7lcJCcn065du2MOKxVCCCGEaEhO9p63vkgNdyEucpVWB9VuPZUWC9WKD06HrfbCKUvKABwCbMCV2F2NaOSdBZYjKMb/fZOrT2qOIyWFJuOuZc+ePRQXFxMUJLXNhRBCiEudt7c3Y8eOxWazXbA5TSaTJNuFEEIIIcQlTxLuQlzE1q1bR3ZRJUvSrPT2t2LRBeK21x56euqSMlB7cGoKACoRhHk5MR7OpMbckQpbBWaTGX2LFlh/XEhYWBh6vZ6srKxLPuFe/vIrqNXV+D37TH2HIoQQQtQrb29vSYALIYQQQghxjkkNdyEuYhqNBre1Aouz9mdj5YYIsFfVXqz5ux3usdTucnehU2Iw6qDJ4V38Ericw9V5QO0Od1deHkplJZGRkWRlZZ2vpVw0dOHhaCMi6jsMIYQQQgghhBBCCHEJkoS7EBcxs9lMjbUKi6u2pmaeuROHiKy9eFo73O1ALmHeHQFIclahKJBdng387+BUR+peoqOjKSoqwmL5u3EbNq+J1+Nz+231HYYQQgghhBBCCCGEuARJwl2Ii5iPjw9ulwu3WnuQaWboSD7nWtB5nEYN90TgacAPiEBVFXwnXU4bW1sObazdya5r2hSMRhypqURGRqIoCtnZ2edvQUIIIYQQQgghhBBCXMIk4S7ERcxsNgMQ469FozdhdFtRqotQDd6nscPdDAwHfHGreoptGo5098TH1wxVUF1djaLToW+WgCM1FaPRSFhY2L+irIwQQgghhBBCCCGEEOeDJNyFuIj5+vpyxRVX8MGdl9EoyB/fst+Zpd6FavA5jRruABuBxWgUDUer9ehdufhWlAKQl/dHHfcWLXCkpAIQHR1NXl4edrv9PK1ICCGEEEIIIYQQQohLlyTchbiIabVaQkND0ev1eHt7Y1M8MFOJU+t5GjvcAdYCswEosXpi0hQS8N1iKnTlZOf8Ucc9KQlHWhqqw0GTJk1wu93k5uaev0UJIYQQQgghhBBCCHGJkoS7EBe5vXv38vGCNaw/UInNrcek1ODQnk4Nd6g9ODULcFJu98HsYyUs30ahvpDDRw4DoE9qDnY7zowMzGYzAQEBUlZGCCGEEEIIIYQQQoizoKvvAIQQp3bkyBHUigLyLEYaeYILHQ4Mp7nDPRZwArlUOfwx6rKI8DaT4ZXG5e0vB2p3uAM4Uveib96cqKgoUlNTcbvdaDTyMzkhhBDiUmWxWLDZbBdsPpPJhLe39wWb71yJjo7m/vvv5/777wdAURTmz5/PqFGj6jUucbwNGzZwxx13sG/fPoYNG8aCBQvqOyQhhBBC/AtJwl2Ii5yPjw8aVzZHq4zgCRatPw5Ve5o13Jv+8d8DXNZkEnA//n0S8LZWkFddW8NdYzajjYzEkZoKV40mKiqK5ORkjhw5Qnh4+HlalRBCCCHqk8ViYc6cObhcrgs2p1arZezYsaeddJ80aRKzZ8+u+zwgIIBOnTrx6quv0rp16/MV5t/Kz8/H39//vM7hcrl47bXXmDVrFllZWXh4eBAfH8+tt97KLbfcAkDfvn1p27Ytb7/99nmN5VyYO3cu7777LsnJybhcLpo2bcqYMWOYPHkyAQEB52yeBx98kLZt27JkyZIG+cMdIYQQQlwaZPuqEBc5s9mM21GD1V371/U+w3QqdCGnucM9ABgO+BLk0QHQYhoUTYTTh+K0YlatWgWAvkVS3cGpwcHBeHp6XrJlZVS3iupW6zsMIYQQol7ZbLYLmmyH2iTyme6oHzx4MPn5+eTn5/PLL7+g0+kYPnz4eYrw9ISGhmI0Gs/rHM888wxvvfUWzz33HKmpqaxevZrbbruNsrKyMxpHVVWcTuf5CfI0TZ06lbFjx9KpUyeWLFnCnj17eOONN9i1axdffPHFOZ3rwIED9O/fn8aNG+Pn53dWY9jt9nMa06lcDM9HCCGEEOeeJNyFuMiZzWbgf39ZfTxNVHG6NdwBngY6svXI7xytCsDYUUtMu36UO8rIysrC7XZjaN0ae3IyqsOBoihERUWRlZWFql56iemVr69j8TOr6jsMIYQQQpwGo9FIaGgooaGhtG3blscee4ycnBwKCwvr2jz66KMkJCTg6elJ06ZNeeKJJ3A4HHXXd+3aRb9+/fDx8cFsNtOhQwe2bdtWd339+vX06tULDw8PIiMjuffee6mqqjppTIqi1JUqOXToEIqiMG/ePPr164enpydt2rRh06ZNx/Q50zkWLlzIXXfdxdVXX01MTAxt2rTh5ptvZsqUKUDt7v+1a9fyzjvvoCgKiqJw6NAh1qxZg6IoLFmyhA4dOmA0Glm/fj01NTXce++9hISEYDKZ6NmzJ1u3bq2b789+v/zyCx07dsTT05Pu3buzf//+Y+J6/vnnCQkJwcfHh1tuuYXHHnuMtm3bnnQdW7Zs4cUXX+SNN97gtddeo3v37kRHRzNw4EDmzp3LDTfcUNd2xowZxMbGYjAYaNas2XHJeEVR+OSTT7jyyivx9PQkPj6ehQsXHvMciouLuemmm1AUhVmzZgGwdu1aOnfujNFoJCwsjMcee+yYJHffvn2ZPHky999/P0FBQQwaNKjufixbtox27drh4eFB//79KSgoYMmSJTRv3hyz2cz48eOprq6uG8vtdvPSSy8RExODh4cHbdq04YcffjjuPv//5yOEEEKIS4sk3IW4yPn5+dGyVWueHNMOT09PBruWorcePc0d7gCVwB4OW/LYcqQG2EGEy0wmB3E4HBQUFGDs2wfVYsG+fTsAUVFRVFRUnPEuqoYgaXACrUc2r+8whBBCCHGGLBYLX375JXFxcQQGBta97uPjw6xZs0hNTeWdd97h448/5q233qq7PmHCBBo3bszWrVvZvn07jz32GHq9HqjdET148GCuuuoqdu/ezZw5c1i/fj2TJ08+o9imTp3KlClT2LlzJwkJCYwbN64uqXs2c4SGhrJq1apjfrDwV++88w7dunXj1ltvrfsNgMjIyLrrjz32GC+//DJ79+6ldevWPPLII8ydO5fZs2ezY8cO4uLiGDRoECUlJcet44033mDbtm3odDpuuummumtfffUVL7zwAq+88grbt2+nSZMmzJgx45T35auvvsLb25u77rrrhNf/3IU+f/587rvvPh566CH27NnD7bffzo033sjq1auPaf/MM89wzTXXsHv3boYOHcqECRMoKSkhMjKS/Px8zGYzb7/9Nvn5+YwdO5a8vDyGDh1Kp06d2LVrFzNmzODTTz/l+eefP2bc2bNnYzAY2LBhAx988EHd608//TTTp09n48aN5OTkcM011/D222/z9ddf8/PPP7N8+XLefffduvYvvfQSn3/+OR988AEpKSk88MADXHfddaxdu/aY+f7/8xFCCCHEpUVquAtxkTOZTHTv1hWAo2k+GIqdKPYqcJ/uDvelwOv4GJ5l42GFEbFHCflyJqU9degMOnJzc2nUvj2agABsq9dg7NqV8PBwdDodWVlZ571G6YUW0Tq0vkMQQgghxGlatGhRXS3uqqoqwsLCWLRo0TEHuz/++ON1f46OjmbKlCl8++23PPLIIwBkZ2fz8MMPk5iYCEB8fHxd+5deeokJEybUHYgaHx/PtGnT6NOnDzNmzMBkMp1WnFOmTGHYsGFAbVK4RYsWZGRkkJiYeFZzvPnmm4wZM4bQ0FBatGhB9+7dGTlyJEOGDAHA19cXg8GAp6cnoaHHv7d59tlnGThwYN19mzFjBrNmzarr//HHH7NixQo+++wzLrvssrp+L7zwAn369AFqk8LDhg3DZrNhMpl49913ufnmm7nxxhsBePLJJ1m+fDkWy8k3gaSnp9O0adO6H3CczOuvv86kSZPqEvMPPvggv/32G6+//jr9+vWrazdp0iTGjRsHwIsvvsi0adPYsmULgwcPJjQ0FEVR8PX1rbsn77//PpGRkUyfPh1FUUhMTOTw4cM8+uijPPnkk3VfR/Hx8bz66qt18+Tn5wO1O/p79OgBwM0338x//vMfDhw4QNOmteckjRkzhtWrV/Poo49SU1PDiy++yMqVK+nWrRsATZs2Zf369Xz44Yd19/X/Px8hhBBCXHpkh7sQDUBRURFf/bKLSpeOSl0wLpfzDErKNAVcBHlY2VtsACCmeyNQwCPAg7y8PBSNBmPfPtSsqd19o9PpaNy48SVbx10IIYQQDUO/fv3YuXMnO3fuZMuWLQwaNIghQ4Yc8x5lzpw59OjRg9DQULy9vXn88cfJzs6uu/7ggw9yyy23MGDAAF5++WUOHDhQd23Xrl3MmjULb2/vuo9BgwbhdrvJzMw87Tj/uks5LCwMgIKCgrOeIykpiT179vDbb79x0003UVBQwIgRI+oOTP07HTt2rPvzgQMHcDgcdYljAL1eT+fOndm3b99pr2P//v107tz5mPb///P/73TLE+7du/eY+AB69OjB3r17Txqfl5cXZrO5Lr6TjdutWzcURTlmXIvFQm5ubt1rHTp0OGH/v87XqFGjurJFf33tz/kzMjKorq5m4MCBxzzrzz///JivOTj2+QghhBDi0iMJdyEagO3bt5OfuZf8SpUqbQC47LUfztM51CkWAH9TGZUODXZXE3zbGfCpcOAMrqrbXWPq2xfHnj24/vimITo6mqNHjx5Tl/JSYP1pEdU/zK3vMIQQQghxGry8vIiLiyMuLo5OnTrxySefUFVVxccffwzApk2bmDBhAkOHDmXRokUkJyczderUYw6+fPrpp0lJSWHYsGGsWrWKpKQk5s+fD9SWqbn99tvrkvo7d+5k165dpKenExsbe9px/nUH95/JXbfb/Y/m0Gg0dOrUifvvv5958+Yxa9YsPv3009P6QYCXl9dpx3666zgbCQkJHDx48Jia+v/E/98pryjKP4rvTye7X///fpxq/j93+v/888/HPOvU1NRj6rifaj4hhBBCXBok4S5EA+Dj44OnYqfErsGqeKG6/jjo6bTquPsBAQR5lDG22bW41dZoGxcQdqSGnJJUPD09ATD26Q1AzdpfAWjSpAmKohyzQ+xSULNhA7Y1a+o7DCGEEEKcBUVR0Gg0WK1WADZu3EhUVBRTp06lY8eOxMfHn/A39BISEnjggQdYvnw5o0ePZubMmQC0b9+e1NTUuqT+Xz8MBsM5iflczZGUlARQd9iqwWDA5XL9bb8/DyLdsGFD3WsOh4OtW7fSvPnpn2vTrFmzYw5aBY77/P8bP348FouF999//4TX/zwvqHnz5sfEB7Bhw4a6NZ+t5s2bs2nTpmN22m/YsAEfHx8aN278j8b+/5KSkjAajWRnZx/3nP9aX18IIYQQlz6p4S5EA2A2m9G6aii0qsR4aFin9KAlv9cm3D0DTmOEFnjoNExofj2wDFhEU8WXFHsBW7duRavV0r59e/StW2FbswbPq8dgMplo1KgRWVlZdTVPLwV+L79U3yEIIYQQ4jTV1NRw5MgRAEpLS5k+fToWi4URI0YAtbW3s7Oz+fbbb+nUqRM///xz3e51AKvVysMPP8yYMWOIiYkhNzeXrVu3ctVVVwHw6KOP0rVrVyZPnswtt9yCl5cXqamprFixgunTp5+TNZzNHGPGjKFHjx50796d0NBQMjMz+c9//kNCQkLd+7Lo6Gg2b97MoUOH8Pb2JiDgxO8Jvby8uPPOO3n44YcJCAigSZMmvPrqq1RXV3PTTTdx6NCh01rHPffcw6233krHjh3p3r07c+bMYffu3ceUWPn/unTpwiOPPMJDDz1EXl4eV155JeHh4WRkZPDBBx/Qs2dP7rvvPh5++GGuueYa2rVrx4ABA/jpp5+YN28eK1euPK3YTuauu+7i7bff5p577mHy5Mns37+fp556igcffPCYcwDOBR8fH6ZMmcIDDzyA2+2mZ8+elJeXs2HDBsxmMzfccMM5nU8IIYQQFy9JuAvRAJjNZhRUiquc4AHpmkRwcQZ13N8C4EBZBi7VkwR/6Dzxclb+thGr1Up+fj7t27fH1LcvVV98iepyoWi1REVFsW3bNpxOJzqd/HMhhBBCiAtr6dKldbXEfXx8SExM5Pvvv6dv374AXHHFFTzwwANMnjyZmpoahg0bxhNPPMHTTz8NgFarpbi4mIkTJ3L06FGCgoIYPXo0zzzzDFBbo3vt2rVMnTqVXr16oaoqsbGxjB079pyt4WzmGDRoEN988w0vvfQS5eXlhIaG0r9/f55++um692RTpkzhhhtuICkpCavVespSMy+//DJut5vrr7+eyspKOnbsyLJly/D39z/thPuECRM4ePAgU6ZMwWazcc011zBp0iS2bNlyyn6vvPIKHTp04L333uODDz7A7XYTGxvLmDFj6pLQo0aN4p133uH111/nvvvuIyYmhpkzZ9Y957MVERHB4sWLefjhh2nTpg0BAQHcfPPNxxy0ey4999xzBAcH89JLL3Hw4EH8/Pxo3749//3vf8/LfEIIIYS4OCnq6Z5kI0QDV1FRga+vL+Xl5ZjN5voO54yUl5fz0+KllHvHos/fgbP0AHdZX4VJayG692mOovLylhepqKnkxV57Kaxuzs3Lf+eJ+KdJ3pDM+PHj0aemUnTlVQQvWoihXTvKysr47rvvuPzyy4mOjj6fSxRCCCHEeWCz2cjMzCQmJgaTyVT3usViYc6cOadVkuRc0Wq1jB07Fm9v7ws2pzg1l8tFcnIy7dq1Q6vVnnH/gQMHEhoayhdffHEeohNCCCGEOD0ne89bX2TLqhANgK+vL9eNq90F9fmnW4nTZtReKD1wmgn3fcBtdAi5lk/2JONW2+Kn7gSguqq2Rntubi7N2rdHMZuxrVmLoV07/Pz8CAgIICMjQxLuQgghxCXE29ubsWPHYrPZLticJpNJku0NWHV1NR988AGDBg1Cq9XyzTffsHLlSlasWFHfoQkhhBBCXFQk4S5EA+F0ufk9pwQPnYJd50ONRzjG4vTT7B0GVJMQoMfqtFJqiybAcwkBDj9ys3cSHNyevLw8EhMTMfbsSc3qNfDA/UBtbdRt27Zht9vP2eFhQgghhKh/3t7ekgAXp01RFBYvXswLL7yAzWajWbNmzJ07lwEDBtR3aEIIIYQQFxVJuAvRQKxYvoxf00po46dQqQ3E4tkYY0nGafb2BQIJ87ICsL/Ug+7hbrp5OMnJP8ikEXdjNBoBMPXrS9mjj+EuLUXj709sbCybN28mMzOTZs2anZe1CSGEEEKIi5uHh8c/PsRUCCGEEOLf4NwezS7ESeTk5JCbm1v3+ZYtW7j//vv56KOP6jGqhsXDwwN/gwunoq9NuOuCoeR0d7gDxGLQ5tA1rBt2VwgQSJtwHblqKaGhofj7+wNg7NMH3G5s69YDtbvfwsPDSU8/k7mEEEIIIYQQQgghhPj3kYS7uCDGjx/P6tWrAThy5AgDBw5ky5YtTJ06lWeffbaeo2sYzGYzXloHFaoXFm0AxbpwKE6H0z73uCmQyX+7PE7fyP5AO2IjVfL9VFzVVezbt4+NGzeiiwhH1yyBmjVr6nrGx8dz+PBhLBbLeViZEEIIIYQQQgghhBCXBkm4iwtiz549dO7cGYDvvvuOli1bsnHjRr766itmzZpVv8E1EGazGT0ucpwBoGjIMLQCRxVYjpzmCDcAH6CqKkerjuJytyEwqALFpFCkWnA4HKSmplJTU4Opb19sa9ag/pHMj4mJQavVcuDAgfO2PiGEEEKcP+pp/4BeCCGEEEKIhuVie68rCXdxQTgcjroa4StXruSKK64AIDExkfz8/PoMrcEwm80A6LUKAEddfrUXTvvg1GAgiLTS/dy64ibyLMFoFBfx/g5yKrOJjY1FVVUOHjyIsW9f3EcLcO7dB4DBYCAqKuqSKCuzfc5uNs9Oru8whBBCiAtCr9cDUF1dXc+RCCGEEEIIcX7Y7XYAtFptPUdSSw5NFRdEixYt+OCDDxg2bBgrVqzgueeeA+Dw4cMEBgbWc3QNQ2BgIOPHj8dgMDBr1kECqtMBBUoyILr3aYygAs/Q1K89WkVLSrGNSB8fWgc42P/1e3R8cBaNGzcmPT2dxMsvR/HwwLZmDfqk5kBtWZlly5ZRXFzcoJ+Z3qRHUZT6DkMIIYS4ILRaLX5+fhQUFADg6ekp/x8UdVwuFwA2m+2i+QZVCCGEEOJMuN1uCgsL8fT0RKe7OFLdF0cU4pL3yiuvcOWVV/Laa69xww030KZNGwAWLlxYV2pGnJpWq8Xb2xsAk7sSt0sF3yZncHCqAhxGrymniTmK9NIMhsS0oV3Adn4sy0JVVeLi4li9ejUWhwND9+7YVq/B5647AYiMjMRoNJKent6gE+6tRzav7xCEEEKICyo0NBSgLukuxJ/cbjdFRUUcOnQIjUZ++VkIIYQQDZNGo6FJkyYXzcYSSbiLC6Jv374UFRVRUVGBv79/3eu33XYbnp6e9RhZw7J09Xp+2nmEvsZKbCgQEHcGJWUAegIfkeg/mtSSdKAzTYM3csRfgys3l+joaEaMGIG3tzdKv76UP/MsbosFjbc3Go2G2NhYDhw4QOfOneWbMiGEEKKBUBSFsLAwQkJCcDgc9R2OuIhYLBaGDRvGtm3b6jZ2CCGEEEI0NAaD4aLKU0nCXVwQVqsVVVXrku1ZWVnMnz+f5s2bM2jQoHqOruGwV1sI0lZjVK1Ua7xRA+JQcjedwQg9gWl0DtPxW345TncrDDo3piQdNdu34zVqFGFhYQCY+vah/HEHNRs34nH55UBtWZnU1FTy8/OJiIg49wu8ABwHDoLLiT4hob5DEUIIIS4orVYrZUPEMex2O1lZWRgMBkwmU32HI4QQQghxSbh4Uv/ikjZy5Eg+//xzAMrKyujSpQtvvPEGo0aNYsaMGfUcXcMR5O+Lj86JXrXj1npg942treF+2qcxxwARtAupYtbgL9BpWuFS9cSFuyj4fQtQe6jawoULKfX2RhsdRc3qNXW9Q0JCMJvNDfrw1MpXX6P8qafrOwwhhBBCCCGEEEIIcQmShLu4IHbs2EGvXr0A+OGHH2jUqBFZWVl8/vnnTJs2rZ6jazj8/Hzx1jpJ8+1LjdZMpWc0OKqh8vBpjqAAT6FRJqIoCqqqw+lKpEWQg9IxlwFgMpkoLy8nPT0dU9++2FavQf0joa8oCvHx8WRmZuJ0Os/LGs8336eexO+1V+s7DCGEEEIIIYQQQghxCZKEu7ggqqur8fHxAWD58uWMHj0ajUZD165dycrKqufoGg6z2YxGAYvqgUaBw9SWf6Ek4wxGaQ9E8Pb2N3l7x5votV1ICnCQZ7AAtQdNxMXFkZGRgb5PH1w5OTgPZtb1jouLw+FwNNjnpg0PQ9e4cX2HIYQQQgghhBBCCCEuQZJwFxdEXFwcCxYsICcnh2XLlnH5HzXBCwoKMJvN9RxdwxEYGEhim06MiSwCIKPCBIrmDA9OBZhB+5Ac9pbsRaO0x2x0U7rja6rnzQdqa7XbbDaKoqPAaMS2fHldT19fX0JCQhp0WRkhhBBCCCGEEEIIIc4HSbiLC+LJJ59kypQpREdH07lzZ7p16wbU7nZv165dPUfXcHh4eNC7SzvivSvRuW3kF5WCbxMoOdPk9wFah+RwpCofiz0al1vBK7SI6u+/B2oT+/7+/hzMy8Nj4ECq5849pnd8fDw5OTlYrdZztDIhhBBCCCGEEEIIIRo+SbiLC2LMmDFkZ2ezbds2li1bVvf6ZZddxltvvVWPkTU8v2zZw/d7bAQ6cqmpKIKA+LPY4d4TX0M2Pno36WV5lNeEERJtp3Lrb7hLS1EUhQEDBtCrVy88rhqNc+8+HCmpdb1jY2MBOHjw4DlcmRBCCCGEEEIIIYQQDZsk3MUFExoaSrt27Th8+DC5ubkAdO7cmcTExHqOrGHJPbif7AoNQY5stI4qCIw/ix3uPVEUN13DIb00Da2mC61CbGTEGrGt/AUAf39/dDodxr590AQEHLPL3WQyERkZSVpa2jlcmRBCCCGEEEIIIYQQDZsk3MUF4Xa7efbZZ/H19SUqKoqoqCj8/Px47rnncLvd9R1eg+Lt7YNWayDIkY1J48Li1RRKDsAZ3ccgoDk3tUxgZOxIzIbR+BlVLJMisS5ZUtcqOTmZ5atW4TFqJNXzF6A6nXXXEhMTKSwsJD8//9wtTgghhBBCCCGEEEKIBkwS7uKCmDp1KtOnT+fll18mOTmZ5ORkXnzxRd59912eeOKJ+g6vQQnw98Og01DWZAiKopDuCAWnFSoPn+FI9+GlvwOjzoSiJFJq86VRTyc+jz1a18LDw4Ps7GwYMRx3QQE169fXXYuKiiIgIIDk5ORztDIhhBBCCCGEEEIIIRo2SbiLC2L27Nl88skn3HnnnbRu3ZrWrVtz11138fHHHzNr1qz6Dq9BaRTkj0GjcrTpeJwqZFZ51V4447IyHcmt9OaZTU9RYiul2tGLtqGVFIRp61o0bdoUrVZLpl6PLi6O6h/+V1ZGURTatWtHbm4uBQUF52BlQgghhBBCCCGEEEI0bJJwFxdESUnJCWu1JyYmUlJSUg8RNVyhwYGonoHEK5loXDUctbhB0ZzFwanga/yFYI9fSSvdT7DHBDz1Ktm7X6LilVcBMBgMxMbGsm/fPjyuGo1tyVLcFktd/5iYGHx9fdmxY8c5W9/5dmhzDgc3ZNV3GEIIIYQQQgghhBDiEiQJd3FBtGnThunTpx/3+vTp02ndunU9RNRwBQQEcPt1V9Hcuolm9h04rBbwiz6LHe7grc9mVFwNGaXpGHTx5Fl8MTc5gGXmLNSaGgCaN2+OxWKh+rL+qDYb1sX/q/Gu0Who164d2dnZFBUVnaslnleZm3JI//VQfYchhBBCCCGEEEIIIS5BuvoOQPw7vPrqqwwbNoyVK1fSrVs3ADZt2kROTg6LFy+u5+ganv25xaDGEGpfTppHN5z+iehKMs54HEXpRbj3QoqsO4GJlNV0oVn4cnKN1dRs2Iipfz9CQkIYP348Xl5eFHbrhvWHuXhdc3XdGHFxcWzfvp3k5GQGDhx47hZ5nvS7v3t9hyCEEEIIIYQQQgghLlGyw11cEH369CEtLY0rr7ySsrIyysrKGD16NCkpKXzxxRf1HV6Ds3L5Un7a5ybIkY2iQIFn0lmVlIHOuNxaAkypqKpKsMd4tBqw3NsY65LaneyKouDl5YXb7cZw1ZXUbNyIM+9/B7RqNBratm1LZmYmpaWl52iFQgghhBBCCCGEEEI0PJJwFxdMeHg4L7zwAnPnzmXu3Lk8//zzlJaW8umnn9Z3aA2OzuiF3a3gq1hQVTeH1HAoPQBu9xmO5IXd3YoRsQG4VTchni1JK/XBPESHbekyVJcLAFVV+f7770mLigKjAev8+ceMkpCQgJeXF8nJyedohUIIIYQQQgghhBBCNDyScBeiAfL09saEHaX1eJxOO4ftZnDaoCL3jMfy0N2Bv+lutBotAIXV7YkMs+D/6cugKEDtLvfw8HD2HzyIcdAgqufOQ1XVujG0Wi1t2rThwIEDlJeXn5tFnicl9z1A8U0313cYQgghhBBCCCGEEOISJAl3IRogP18znloXpT1f4ajSiNKaP/4qn8XBqdCR9Xlu1uetA8DfNBqXGywtM1A0//snonnz5lRXV1MyeBDOtDQce/YcM0piYiImk4mdO3ee5aouDI/hw/C86qr6DkMIIYQQQgghhBBCXIIk4S5EA9Qo0B+A0tISgg01uJ0OXIrhLOu4Q0HVHIqsMwBoFtCZ5EJPcPxEyR131u1kDwoKIiQkhAytFk1QENXfzz1mDJ1OR5s2bUhLS6OysvIfrO788hg4AI9hQ+s7DCGEEEIIIYQQQghxCdLVdwDi0jZ69OhTXi8rK7swgTRgqqqi/FHa5U8dW8TSsUUsmsPb8Dv6DD8GP0ppQEeCSjLOao62ITqCPNMprynE1xhMbmULOodu5cjvaTh27cLQti1Qu8v9999/Rz9qJNYFP+L7xFQUvb5unObNm5OcnMyuXbvo2bPnWa9ZCCGEEEIIIYQQQoiGSHa4i/PK19f3lB9RUVFMnDixvsO8KKmqSuHVYyl/6pnjrmk0GjQaDRU+Cfg7D6OqKke9Wp1lSRkI9rwVs0HlUMXHAJgNw7A6FPTX+2NdsrSuXXx8PFdddRXmq8fgLiqiZu2vx4yj1+tp3bo1+/bto6qq6qxiEUIIIYQQQgghhBCioZId7uK8mjlzZn2H0GApioKxU0f0LVqc8PpH81ZRdjSX+30j0TotHDZG0qL41xO2/Ts+hhZklAbhb1wJ/Jd2Id3YlG+k89UGLCN/xvzYoyiKguaPmu4VoaEozROpnjsX04DLjhmrRYsW7Nq1i507d9KjR4+zikcIIYQQQgghhBBCiIZIdrgLcZFxlZRi+eRTVFXF/MjDJ603Huxvxk9royqoA/6OPApdvlB6ANyus5pXo4ylibkC2EugRyD7S6PxDqxB45mLMy2trl1FRQXz5s2jZMxVWJcuw3X06DHjGAwG2rZty969e6moqDirWIQQQgghhBBCCCGEaIgk4S7ERaZmzRoqp72Lu6AAgOp586meO++4dm2bRQOQpmlBgCsfi8uA2+WE8pyzmrep3/XA00DtuD76/pTXaPGbPhRddHRdO7PZTFhYGAcbNUIxGLB8+tlxY7Vs2RKTycS2bdvOKhYhhBBCCCGEEEIIIRoiSbgLcZFQnU4APEdfSaNf16Bt1AiAmg0bqNm8+bj20WGBVLl1JGvasTrkTgDKdKFwlgengo4DZc35dt8CADo06sr6PANKbDqKUX9My6SkJI4UFuK6cRJVsz/HXV5+7Eg6HR06dCAjI4OioqKzjEcIIYQQQgghhBBCiIZFEu5CXATcpaUUDB6CddHPAGj8/Oqu+b3+Gv6vvnJcH0VRcBl8sVtKCWsUDECRIfqsD04FyLPk4Gd8n/KaT0gIaMbWIwHotSVUvD2Jqjlz6tpFR0djMpnI7tgB1W6n6vMvjhurWbNm+Pr6snXr1rOORwghhBBCCCGEEEKIhkQS7kJcBBRfX0y9e6NLTDz+mqKgqiruqqrjrl13RT9uHnclE1KuRnVaKfRuCcVnn3DvHNoVb72CRpmDVlHwNnSnoNqEsWselo8/QVVVALRaLS1btsQjIADPq6+urTlvtR4zlkajoVOnTuTk5HD48OGzjulcqyywUHHUUt9hCCGEEEIIIYQQQohLkCTchbgIKBoNvk8+gT4utu61mt/mULNtInCE0rsnU3r35OP6hQYF4OXlhc7THx/7UQp0Tf7RDneTzkR2ZRd8DKXAFjo26syCDD2GzpW4S9Kwb/qtrm379u1p3749PnfejrukhKrvvj9uvJiYGIKDg9myZUtdsr6+/TZzB+veP75EjxBCCCGEEEIIIYQQ/5Qk3IWoZ2WP/YfKae8CKpCC6joIgLvqdzR+maiuADzHXoPX7aOO6+tyqzzz0Tx+0/Um3JlBCQGo/2CHO0BT3yvJLNdR7fic9iHtWZ3tiQsdPvc3xjJz5jFtHQ4Hu0tL0Yy6AssHH9bVof+Toih07tyZgoICDh069I/iOlc6X9+W7rd2rO8whBBCCCGEEEIIIcQlSBLuQlwgqtWB60DJca87A3wpzPmZA998havwFpw77oK3ojD1fBh93BrsCz9G8TmEqduLwO5j+mo1Cjq3gyxXGLH2PbjQUl5hAbfrrONs36gjJbb+eOh2YDaqJAS0Z3N+MJ5Xa7CtW4W7tLSurcvlYteuXRwcNAhXdjbWRYuOGy8iIoKIiAi2bt2K2+0+67jOFd9wM/6Nfes7DCGEEEIIIYQQQghxCZKEuxAXiHNTDo7v9qBW2Y95PeiuloT3tuMuP4JtzVhqskZy1DSYmioXHN2LcddkHN/OxbH/aqoXHPijV35df0+/QOyqAX9H7WtFunAozz7rOA1aAx0aPYGizAP8GNBkIF/utaHxsBL227No/P3r2ppMJlq1asW+o0dxXz6Qyunvn7B0TOfOnSkrKyMtLe2s4xJCCCGEEEIIIYQQ4mInCXchLhBd10hQFJzr/5cMd6TuxZ73FdpmWuJufwivq++nPOFKflrVlxqHgWLPeNzXLsH7lR+pmlVC9dz5QDYwGlgDQHRkYxQF5iZ+Qo1LoUjf5B8dnApQ7VD5MnUlWRUH6BLWkbIaX/Iqm6DxW4paY0O1/++HBq1atUKn03Fw2FCce/dSs2r1ceMFBwfTtGlTtm/fjvP/lZ250Co//IiKt96u1xiEEEIIIYQQQgghxKVJEu5CXCCKpx5dt0hc2/JQK2wA5P/3CTa8YCZ3dicURQEgonUoN3xxNZ9sz+HR6Rv45ScvXC4Vn5tHEDR7FtAYeBLoDkCb+AhsLg1WxZsjdiNF+qh/dHAq1O5yX5u7iEDTzRi0v9KncV/m7FeBVIpv60H1D3Pr2hqNRlq3bk16WRmubt2ofO+9E47ZqVMnqqurSUlJ+Uex/WM2G6rNVr8xCCGEEEIIIYQQQohLkiTchbiAtF0bg0GL89csAIIeGE6/ph8RftcNx7TTm3SM7RrFhJ4xFGSXseK1d9F83h1115eoTjcwBDAAFUQHedOyQzf6+RygmWMnRYYo1KJ/lnDXaXS0C+lDTqWKqv7AZU0Gsja3BpszGJ87/LB8NvOY0jEtW7ZkyJAhBN1yE/bNW6jZuvW4MX19fUlMTGTnzp1YrdZ/FN8/4XPfvfj+57F6m18IIYQQQgghhBBCXLok4S7EBaQYdeh6RuFKzsddUo2pw3Lc9z2BMaIZAOlHKnji+13YnW4aB3jSr1cMRcPi+cGnLTVRj1E+P43iCdf/MdpCYBgaTQ39O7cg1rOcLo5fsSsmKoty/3GsvRv35scDOhRlJ3F+Kk3M0Ww4HI6hSyXukv3YN2+ua6vX64mIiMA0cCBKYiKW994/4ZgdO3ZEURQ2bNjwj+MTQgghhBBCCCGEEOJiIwl3IS4wbcdw8DZQPWMZh96rpHxmZt01q93FkXIbVTX/q3N+e/94Xh3ZloreD2HqPwCvUX3A7QY6A1MBhW0ZR/k83R8vtQqAouIiOMHhpWeieWAS6aXhVNq9UZRZ9I8cwMw9BaAY8Lk3AsunM4/rs3rNGvZcNwHbipU49u077rqHhwfdu3fn4MGDZGZmHnddCCGEEEIIIYQQQoiGTBLuQlxgil6LrlcUWqcfPiXlaHreyeaMIlRVpXUTfz66uTP+Xoa69iaDlg0fbWXDp1soW/UzpoNTIPlTIBQYDBipcYLVqaHQEI3GbafI7QdFxye8z4RW0XJzqzuodlwDHKBvZHcsDsiqaIXnWC2uglxUh+OYPmFhYRxy2Klu2YKK114/4bixsbFERUWxfv16bFJLXQghhBBCCCGEEEJcQiThLsQFpDpcAGjbhaEJt+Dbtgs5YYnc98V2NqYXAdQdnvpXXW7vxHRPHQv2u7AF3Yw1x++PK4eBN2nZxJOjdhO5xiQ0jkoKDTGQte4fx9s9vAeNvG4DvsbfFErHRp34dr8TjYeV4AV3oej1x7Rv1qwZ3t7eHBg/DtvSZdRs2HjcmIqi0LNnT1wuF7/99ts/jlEIIYQQQgghhBBCiIuFJNyFuEAcqw5in72z9s9H9qO75jloFkzLyADm3NOTHgnBJ+0b0tiXlyZ0YNyHz2MvDKHi3Q+hqgjcVmAFvp5HsWp9yDfEk2Hz5aghDlfW+nMS95b87Xzy+6dAGsNi2rLx8GGsjjYoyhxqtmzBVVJa11ar1dKhQweya2qo6tuX8meeRXW5jhvTy8uLbt26kZaWRnZ29jmJUwghhBBCCCGEEEKI+iYJdyEuEG1cILoujVFVlYOPvMnqOzpTktsB5285RAV5/W3/OJ2WubcvxHLZ1QTO+gBmtIJfvwR+BuLwCwwBRcMhVyOcip6juVnnJO5KRyWLDizA4X6ANiHr8TX4si4vDEil4s2bqXj5lWPax8fHExwcDJNuwJGSQvUPc084bkJCAo0bN2bdunXY7fZzEqsQQgghhBBCCCGEEPVJEu5CXCCaJr4o4T64UwoIG2qmX7OP+SlHR+UvB1Era/62v3+kL/79Y3h4zhaKP/gcddgM6HQXtX+NLQzpEkdAozB6OH5Bp6jkOgOgPOcfx92ncV8CPEJYnd0EjbKKK+Nb82XqAVS1MX4vtKT666+xJyf/b50aDaNGjSJh4AA8rhhBxSuv4K6uPm5cRVHo1asXdrudzZs3/+M4hRBCCCGEEEIIIYSob5JwF+ICcqcW4liZhs+YzSh3zKFZ/0QyxzRH8TH+bV9Fo9Dp6la0axWO08dM0RNfg1cw2PaD+zLax6QzqkM4d7tmoNFCnrE5ZP/zsjI6jY4r40bz4e4cnO5QBkXnUGavIKuiC7qmBzENSqBs6uPHlI5RFAW73c6+0VditTuwvD/jhGP7+PjQuXNn9u7dy+HDh/9xrEIIIYQQQgghhBBC1CdJuAtxAWm7RFDqWseR91VqsoPp3bwR7ZuFoFrsuFIL/rZ/4wBPRsXGcMgZj+my/qiqinvt16jLC8Aaxr2LStnlNQCshRTqo7BlHn9o6dm4POpyPHQ+bM5Pwku/mV4RoXy7rwZFCcHv9Sgcu3ZTPee7Y/q43W7SDx8m/bZbscz4ANfh/BOOnZSURFhYGGvXrsXhcJyTeE/l1/d/45c3zk19eyGEEEIIIYQQQggh/koS7kJcQIpBh+uoE+/SW3gt00B5dW3tcteOwzjmpuLKLP2bEcBebSfjiI1VuTbsTjeffWkl7cf+4BGL4nKy2fdqPMrSQVHIy8s9J3EbdSae7/ESXcKeBW6hbcgANh/ZQZVjElr/XQR+8zAew4Ye08dkMtG1a1eyTEaKmjWj/JVXTzi2oij07t2b6upqtmzZck7iPZWINmFEdgg/7/MIIYQQQgghhBBCiH8fSbgLcUEdImyCCXdABUcqXHgadABoezZBE+2HY24qarntlCO0GNqMtKZe/O4w4Xa5WBDdg215TnB/wr2+b6OoLoL11bhddvJs3lBdck4ij/aNRqcxUe2YSNew4SiKwoosBUjE1DsZja8Zt8VyTJ+EhATCwsJIuXIklvnzse/adcKxfX196dy5MykpKeTl5Z2TeE8mtkcUCX2bntc5hBBCCCGEEEIIIcS/kyTchbiA7Lu+gsY/4HPdON4d2Ay9rvavoKLRoL8qCfQa7N+noDpr66HbdyRj35Ny3DhP3zuEa4cPYv/idL67rSNjXp+KzfIzEWElYK8k29gKrVcgucYk1HNQx/1Pa3JWc+vymzBoVvBUVz0rslbgVu8BfseZM5sjnbpg376jrv2fB6NWazQU9+lN+TPPoqrqCcdu2bIl4eHhrFmzhpqavz9EVgghhBBCCCGEEEKIi40k3IW4gFJfzWPhXf2o2luN48vdqNb/1SxXPA0YrmmJWlCFc3E6rooKCkddiX379uPGUe1u8nYdARU8IyNwhzRh9sTRpPM122qisJrC2J/jxqILpHT3L+cs/lZBrbG6rOwu3EWbkEMYNAfYdNgBdEfbeAG6ppHHHaDq5+fH2LFjaX7zTdg3b8G2ZOkJx1YUhb59+2K329m48dzUnj8R27r12FatPm/jCyGEEEIIIYQQQoh/L0m4C3HBWGnSMZ8+CTNZaHdguKsTiof+mBaaMB/0wxNw7TyCdcaPoNPhMXDgcbvCDZ56+tzTjbZXtQDAw8/ELd+Pp3XvSJo1DSW05CBXVs0G1UVmcdk5W0GgRyD9Iy/jvV3pqGoT7mij5et9X+JSJ6MohwmYMQDH779T9cWXx/Tz9vbG2KcPxVdfRdnzz6NarScc39vbmx49epCens7BgwfPWdx/Vf3lV1g++eS8jC2EEEIIIYQQQggh/t0k4S7EBeIqeh6/WxV0Ny/jyh4xUOXA/t0eVPexyXRt61A0rQPRVofhM+ke0CgUDhl2TKmWE9HqtWj1t/Lg6E3099xIJ/1q9NgpcvhQ9cVMHOnp52Qdo+OvotRWwa7CrjQLKCTQlMGvObnAcHRNluJ54xgqXn0NV1HRMf0KCwv5LSmJrOBgKl5/46Tjx8fHEx0dzbp166iurj4nMf9VwIczCPr6q3M+rhBCCCGEEEIIIYQQknAX4gLJfjuH7JcrMEe3w8ukA60G7C6odhzX1rp7Ic6iTEztB6AJDkaf2AyMhtOY5TbsjitI7/g4B7y64ak4OGyIx7rgvZOWcjlT4d4R9G7chz1FoUB7xiT48M2+r3C6bwGs+P43HGOP7qj/7wDVkJAQ4uLi2Dd0CIXfzjnpDxD+rPuu0Wj49ddfT1rzXQghhBBCCCGEEEKIi40k3IW4QDIKytl64Chlh7MA0IT7YLiuDW6bHaftfzu5Xfn5WGbPRI2xoB+WhKLVYr7tP+jjE09jlp6UVMXw0Eo7G3yvxb80HYfGg31DB+Bz7z2oqoo9OfmYGutn48EOU7guaSLwGr7GNzlafZSVWbuACWg8FxD48XPooqOP69e9e3cMPj7smHgdRVMeRrXZTji+h4cHvXv3Jjs7m/379/+jWIUQQgghhBBCCCGEuFAk4S7EBRIzoBl6fw07vpvBqudvYumjo9lw323Y39vC4tuGsH3Wi9irK6l4exqKyQPv229BURTUyhoc8/fiWL+PwjFX48w7fMp5Qv02MrFPCp7OIsq9QjC4q7FYynC7VZzp6RQOv4KaX38FwJmTg6ug4IzXoigKDpeDtTnJNPZuwrjE5izJ/AK7axzgAXxAzcZNlL/w4jH9TCYTAwcOpDIggMzAACreevukc0RFRdGsWTM2bdpERUXFGccohBBCCCGEEEIIIcSFJgl3IS4U215wO8j+fRVH9mzGGBSBX4+2lDSvJHbkOA6umsvvn71M9bff4nPP3Wh8fABQfIwYJ3dB2z4S54GDWN/5GcfKA6gW+0km2k/f5ofIrPai1BCJl0HFpvOnPKcEXWwsQT8uwNi1KwCVb75F0fgJZ7WcQxWHeGv7Gyw6+D1XN9vOyLgclmSuBW4FFuGu3oXl/RnUbN16TL/g4GCuGDWKVr16YXl/BvadO086R7du3TCZTKxZswa3231WcQohhBBCCCGEEEIIcaFIwl2IC8Qn8EZG3OVgwjQn+2Iv41X3KPZ7JRJy2UASjP0Y9tR8mvo1QxsWRlnLJpQe2lfXV/E1ofX3xfepp3CkpeLcnE3NtN9wrs9Cdf3/RPRtVNqeZ7GlBQ5VQ7nTk0JdFDkzbqfa4cbYsQOKhwcA5sen4v/2WwA4D2bi2Lv3tNcT7x/PiNiRfJE6h4qa6+jfxMqugtlYnUOASEyXbUXfqgUVz71wXB324OBgfO66k7K+fTj07HOoNTUnnMNgMNC3b1+OHj0q9dyFEEIIIYQQQgghxEVPEu5CXCDpbYOZvTQefaWNJ+7dwEDjfmo+v5vn3v8Oy8FSTAHB+CQNwP/e99m37Asyls0BOCbJ7DFyBG7PAioWP4umbQjO1ZnYP92BO7/yLzPpaNnYj6u7VuDdqIbSympURUOluZqlu44tR6MNDMTQsiUApQ88SMXrb5zRmq5rfh0BpgBe27oPhyuWCUlHWHTgZ+C/KMou/Kf1w759O7alJziwVadj/5DBbO7SheJp0046R1hYGH379iUtLY2t/2+3vBBCCCGEEEIIIYQQFxNJuAtxgfQI74nHiAn8NjsYnY+LO3t8RJMB91IQ3px7Mtfy0bfLQK+gCfah/1OzaeUejGPVQVIXfMSKJ8bx+/fvUZy+E/Ozz+DMz8G6awGGm9uDqmL/ZDuOXw6iOmoPQ9VpNdw/ZB9jui3ivopHMavl2ILbMrxNOJtn78Bacfxhpf7vvoP/9HfPaE1GnYnJ7e5lT3EK+0tGEuvnoMQ2G4s9ERiBPmEJplE9sHw687i+iqIwYPhwXH6+rCsopGb37pPOEx8fT9euXdm5cye///77GcUohBBCCCGEEEIIIcSFIgl3IS4QRVEY13wCR4beS/6XbkwdtLTSvsdzwTkMPfoV3j9+SGXqatQeIWi0evQ9o9HGBxLknUCYT1v2L57NiifGs/DFCaQNakb6vE8o/H0V2htaoesbg+u3HOwfbkOtqq3t7nZPIT3vSYqMMegUO4VOHyy/fEtkyvWsXrfruPh0TZqg8fDAVViIq7DwtNfVOrgNr/R6jRZB47DY/8P6wyYWZMwH7gN0+L8eSuDns07Y12w20//yyymMi2XzJ5+i2k9Wlx5at25N69at2bRpExkZGacdnxBCCCGEEEIIIYQQF4ok3IW4wEa1uoo9MQ9jW1KO+SYTh/c+y48jwuj42iOklaYy96ExFFtqUFoEoYn0JcAWRkL4YK78eAMDn/uaZkOuxxHgTXqMnlWf/YcfbuyIrZkOw+0dqQ6soTg3BVVVqSxRuWthBfv9u1KOHxXaQBwbFlIa1oQ8ky+qW+XXj7eyN+VoXWyq203RmGuoeOnlM1pT88AkFEXhcFVLLou8guVZ8ymvUYCH0HisR+O5A2deHm6L5bi+TWJiaBMZSXZ4OCWvvnbKebp06UJ8fDxr1qwhNzf3jGL8U8ri/exakHpWfYUQQgghhBBCCCGEOBVJuAtRDy4feD3rDk7EtauM6CEwMmIozVr2pcnwO1gR0YuNuw+w6N7LObJ7I8rl0eiuaQGHKgjwaEqrqydz+QtzuPKlhbQ7ZKB1p1F4BoWiCfJi+/6PSV/xLe4DJRg/2k7/UDNhnUpwoQfVRXG3viTd8xM3REB12nai0u7k5ZkrKf1jV7yi0eD3xuuYH596xms6WHaAKWsfJN7fyYwBuSw99A4wGOiK6n6JwpGDsHzw4Qn7dh4yhCH+/thmfEDVN9+edA5FUejTpw8RERGsWLGCwjPYif+nqhIrVUXVZ9xPCCGEEEIIIYQQQoi/Iwl3IerBrsKdfBi1gw3z+vHF8iiKvFUUpQbFX0txy9/wCTpE484DqTJHsn/xbH66/3Jcm3Io+XEdB9cuAMCmV4lfsY6kB59Ho9ECcNmTs+l40xNoGvtSmWAnIUrHrNVd8XZYMODgcHE5jt2/U3jZQAw5u2mc5Mvdg5vimZlBytI0Pl6ZRnXzVmgDAnBXVaFarae9pqZ+sfRp3JcPd/2CwxVAp0aL2V+SAjyGoikjYHpLLB9+hOvo0eP6KopCwG23opl0Ayu3baNk1aqTzqPRaBgwYAD+/v4sWbKE8vLyM7r3na9rS/dbOp5RHyGEEEIIIYQQQgghTock3IW4gOyu2p3kSYEtuKXVbfR46gMG3fwmE8Jb4rb1I9SjgNf7vEnvhME4ut/CzfN/Zos7nFZj70N/TUsO6ragppVSvvcISx4exf7VC3DarJS99jq2lb+gaDToPb1xYWfjqhcwL3ua7PIkEqqjcWAit8YPTWwcgd98ja7v9Whv/IW4Hz7n8NNPwaJ7+PWXDLKKqlDtdgouH0zl9PfOaH23tLoNNxrmZ7ShidlFduV/cbnDgNswdDmIvq2BijffPmFfRVHweeRhyqOjWLF+A9WpJy/7otfrGTx4MCaTiZ9//hnLCUrVCCGEEEIIIYQQQghxoUnCXYgLJKVoD7etuJnDlsPoNXqGxAxFq9ES7x9P0TvzUTbnsGD5F0T7xqBVNLRs4kVgzGq+OLqTlzNCyamsodOtT9PY0QL9gTKq7OMIataXtGVfsXb7V9gz0lFVFQCdyZN+Uz/FXVVGv6MfMUfRE6d14VB05H+8Ea2lEerRalRVxf+tN2ly/2Caxx3kwyltaRvlD3o9C69/lPKho85ojb5GX25tfTvzM/aQVtKXy5ocZuPh94AJKEosAe9HUP3tV1iXLj1hf29fX4aMHIklMIAVX32N4wS74f9kMpkYOnQoAIsXL8Z6mrvxXSUluIqLz2hdQgghhBBCCCGEEEKcDkm4C3GBxPg2pW9kP/yMfsddazr1dTblPslibRmlRWtxVV2JlyGfjwfP4OXBt1FcWcM9H3zHJw8vwjkqEY9hzZj03G0ER4UR2qYXLW79L9633cqKJ8aRtXExAOaIpvSb+ikBrlK6ZLxG19KH8HRXciiwANf+AuyfJWN/fwuubQVo2l6H67LvKb9iLPu+30JBcTU/V/uQrnijOhx1ifzT0TuiD3e3vYemfk+TUtyC7/avpLC6FJiKJqiYwNmDMHTocNL+wU2acFn3HhyNbMzaN9/EfYpEure3N8OGDaOmpobFixdjt9v/Nr7y/0yl9J57T3s9QgghhBBCCCGEEEKcLkm4C3GBeOo9mdTiJjz1nsdd03t70H3Cbbx32QysM95BY0nH7bgWf8NaOkYF8Ui4mUE7NJQfKeSxOTvJyavAuSQd+/bDrH0vE7e2Ay67DbNVQf1mHjWW8trd69GJ9P3vxzirLKxLi8TDbeGAoxzt3R+gv24PSoQZ5/osVKsTbWwC+h5DsKxeQsWeAuZM7kmfSC8Khgxl/rRvsdgcp7VORVEYFD0Yk84Lf+MLVDp8+WzP+0BLFOUaTH33og2uwlVQQM3GTSccI7pdW7rFxWHet5/Syfegulwnnc/X15ehQ4dSWVnJ0qVLcTqdp4zP+57JmB995LTWIoQQQgghhBBCCCHEmZCEuxAXEb1Gj//A//DbNF80u4+iaF6gpvIyWg64j1u+/oz7v5jFS3dO5YZvFrG5byj67stJTCrh1+mbKT9cQ+tuY3D+vJwfb+1J7rLvAfCOSmJexG2UVOkpUQKxYyA7czzapgMxjGqOcUpTNME2NJ6emBs3p3WEQnyPUIx2F+71R2DIjXxZGcSqlJOXdzmR/Kp87l9zL5dFdmRii8WklX4ATAbCgMeofP9tiq6/nppNJ066txowgFaTJ2NdvoK8F1865VyBgYEMGTKEoqIiVqxYgesUCXpDyxYY2rQ5o7VcCKqqsu/n2dirKuo7FCGEEEIIIYQQQghxliThLsRFxty9OwXX3M0b6xKo+TIX486D6DM9MLhGoNPegUF7F40SlrNN/RHyM4jJCccn0IONn81DMziEJye+RZq2Az+//RMbB12F5cknCGsUjbNxU/RH9qG4nezfmQ80A0DRvwM8AKjo7xgMQwZROO4G8lbtx5VWhG9VOF+59QzacYTqd36kZH8BqvvvS8yEeYXRqVEnlh7aSKktkDCvmdicJcBLQA6+j5swdupM8Q03Yt++44RjeAwcQPHTT7LM34+Mjz855XyNGjVi0KBB5OXlsWrVKtxu9xnd9/pWXZzPnu+ns33Wi1Qeya7vcIQQQgghhBBCCCHEWVDUMynOLEQDVlFRga+vL+Xl5ZjN5voO5299m/Ili1Nmc9/mvbTVHUHr4cIV3B3NsBc5GpyAQWskwBTAuk3r2W89Qs+CZBKvXUal1Z+dBxPZu7yYQ9pYMq1xqLl2PP2rmOj4gbSYiYDKuHHj8fHxAcqBo0ACUIqrMJfCB15iq64FkVeMos3AOFwHSnD+loYztxqdwQOnUYshPhBdpwg0kb4nXUNFTTl3r7qLpIBw7mizFoujMZE+c4Efgedx1zxF8bUzcezbT9D3czC0bHncGE6nk8UffECBRkOvwCCajb3mlPft0KFDrFixgoSEBHr37o2iKGf/EC6QzHULCW3VHUWjYdG9g2h59d0kDptU32EJIYQQ4hLX0N4fCyGEEEI0BJJwF/8aDe0bClVV+WbfV8zZ/y1xNm8mL0smwisT7YB70Y56HbW6GEVr5MsD8zDuqWB4WivWWHbS9oZsQpvlseTRPTTtoyVxuJ4ah4FDhYE8t2A0/TQVuBQjMVk7CL75BZKiAtFrQNFogBeAbfBjAK6Da9Hctx9Fo62LyZaXz6aUSrprtXCgBF2fGLTNgnClF6PmV6LtFXVcgvu3w5t4ccvzXN88lqubbaTIehtBHrcCTwC/4rZ8SNG4x/C+5WY8R15xwnvhdDhY9vbbHPbxoWdkJM2HDTvlvUtPT2f16tVER0fTv39/dDrdP3sY55Gj2sLPDw6l2bBJNB9xE7byYozmgAbxgwIhhBBCNGwN7f2xEEIIIURDIAl38a/RUL+h2Feyl3eTp3HYksdo755c22syOr0H1bfH4tGkAs1/C6ix16DLqWbtthRyfsgl+tpoOl/eApO5AqdtPzrTEdbv38K+Hy8nyJyDU8mkvCaQzwsT+PiOXkQdHMxhdwwW7wQCo6Mx0xpTfiVV3yzANu6/eIaYMTfyroupctq7pG1J4aO+k3jumrYEpBbizijBcF0bVFXFuTQDJcwbTYQZJciT+Rnz6BLWhV2Fd5FbGcjNrT5Bq9iA6wETqusTFK0nqqriOnQIXUzMcffBZbOx4pVXsVVXM/T66zG0bHHK+3bo0CFWrVqFn58fgwYNwsvL6xw/mX8uf+d6zBExaPRGTL6BKIpCycEUUhd8RLd7XkOrN9R3iEIIIYS4hDXU98dCCCGEEBczqeEuxEUuMaA5b/edxtUJ1zDPsp6VeWugpga1xY242j0OGg1V38+k6uOmNM38lYEtfcn89hD7FiWz8qWnyXkzk+pPm9MrcRpDFB+GHV1Hp5pk3B7+vDEqiaZ+LrSNI/FOLKZ525VEBH2IT9DdaFv8B+9nt+Bw3U1GyvNsTCvEZncBP2Ds3QR35y6E+oO/pxNd10jeMOt4f0UaVNlxZ5XhXLgf+4yt1LyynuGbYgnZbCeh4HE27K/mu31fAt8DzwCHULTvAlD93XcUDLgc6/IVx90HrcnEwAcfoMuePRRPnEhFevop71t0dDRXXHEFVquVBQsWUFRUBMChzTnkpxac02d0NtwuJzs+f5m9P32Gh19Q3Y52RaOhxlJOTUVJPUcohBBCCCGEEEIIIc6U7HAX/xqXwg6enMpswr0i0Gq0rMxaQYxvDLF+cSxf8jS+e2fQoUKHk2gO6gJo6n6Il81v0DavL0FqM3q8Nox1+46i+2osYeZGrDIPoGnTGBKPWgkMT8JwWRyW33eTvWYBxYW70MY5adkxG40Otjna0Ck2HVvNNAJ97yY9vxPeHmWE+Y0EXsZlD6CwujFWRyQxwS0otYTx6XI9tyXF4llUjTuvEldeOYrFAcDOkN/pfPvXKO6mqOWXo/i/i6K8jGrrSck992Jbthy/V17Ga9y1x90DV2EhudeOY9WokSS1bk3nv6nTXl1dzbJlyygtLaV///6sfXIrtvIabvzmGgye9bODvORgCjqjB3ovMwYv8wl3srucdrQ62eEuhBBCiPPnUnh/LIQQQghxsZGEu/jXuJS+oai0V3Lf6slck3Atg2OGUGoroaymnEi3grL6LdQ9C9C6q3FTTLIrmP2uEOJGPcistdEM27WU9kkLWBT0EBpUWu/ZR1hkOyIevA7XmkPoOoWDl56aDRuomf8+Nes24fIPRr27GZvWDqLLNd3Y6/07gT45tGtyFVkf3IX39RUcLQ8myMdGkE8BWo0Lp0sDtEKnnQy0A+CzjTMozsjE08uH/Ea7eKpJIK5Z4zDc8jOa8C24Uj7AXWTCtmIZNZs2YBo8ENOIIShGHYqHDsVDD94GXNlZ/PbU06T27EFSQgI9+vQ5ZdLd6XSyevVqMjMzaRnfikNzjjL08X74NT75ga/ni6qqrHp2EjqTB30e/eCEbbZ99hwVeQfp/8TMCxydEEIIIf5NLqX3x0IIIYQQFwtJuIt/jX/dNxRlWbi2fMWen7/icGk1KQPDqW58PT5bF3GbZTULQh+nShuAZl82Xofn4UrswxCP0fza7Qh6H09MPj74ePvSSONHWEYxum13kpvVCPdaG749O+D3wvMoJhMWy2Eq3e/xS8pQfkvVojXtR1GqaRpSzvB2OWiUm1m9N5Abem4DZR8vbobtBdswao2094vnoRA/tHFzUTRBOH4aiiutDdhVcLhPuCzDze3RRJipmfMbqTu3sjXaQHxsLN2tjdEYdCgmHXj88V9PPYqnAcVLj+qhY/uuZJKTk4kMiWLQFQPRaC5sVa2qosPUVJbhFRQGgNHH/4Tt8ndvwFFVSZNugy9keEIIIYT4l/nXvT8WQgghhLgAJOEu/jX+rd9QuBx2NC47+0v2EewXy/zX7qOfZjkHzd3INA0i2H6I6NRZ7Cvxx1NvwtXEl+YBN1Clangt9GfaxLXmv12nUr1zJu9nzKdvcSeiftvB4R5dyF0xn8CkDoT0H4p/QiuqBowgdFkc9qBwPl17L0t2ZtEvaRObD7Tis1tVzJ65uNyT+Wj3NLSaRazIMnJ1wvVc0ywSiAbuAHSo6oeo7mBcm7JxpxRClA4y7Wj7xKCJ9kPjacC1rxDHzn38/vXrpFw+kKGG1vg6Tag2J1gd4Pp//7R5G9Df04XZ//kGZ3w1McERXDZqCIpLBVVFMejO+7PYOO1hyvMOMPilH1BOkexX3W5KDu7B5BuIV3DEeY9LCCGEEP9O/9b3x0IIIYQQ55Mk3MW/xr/5G4qsjYvZ/tnzDJ+2jBX7K3jux2QmRB3AZDeiKhqaVXyDX24Wh4sUyhwGYv0MNA904HJ7YfB5CI8HryLlp2QyqpJpN2wIXgtfQn9wLre16IHVy45WdeNSNCgqBOhNhPv5YdA25tqEHsQHPEF6wfP4erckK38lKql0bjocRXmAGpeBuek62ga/SIug7sC3wJs4fh4PSj90Q1qjVls52rMXhg7t8Xv2dRzfp2K4piWaMB8A7Lt2ceTGmzD6++P3xedoQ0LQ6XSoDhdUO1CrHKjVdnCpOBubWfPORvy0FezyO0JUdBR9w1qhLkhD8TdBoCfatqFoE4NOmRA/U/bqSiryDuLbOA67pexvk+hut4t5t3QncdgNtLzqrnMWhxBCCCHEX/2b3x8LIYQQQpwvknAX/xr/5m8oqksKyNrwM/GXXws6IxNnbKKm4gjT9M+x3Pd2WrTtQOfOnXE7nST/8Db7l36Oxuake6MmeIaOZFafcoZ815w4/2LWHdxBs8YjcblzsRjTCHYn4au8y15tS5TScHZZ1qAJi0L1D6bz2BtpZm7KDwcX8PPh5Qz174hBu49yQ2/ahwWQGLAdlfnUbjIfjckyEsX7BVx7zChaT7St/wMEYV2xkpJbb8Nj8HB8rrgb3YBY1CoHGn8PABzp6RRdO54dAy7D2bEDQ0aOxGA4+YGj+akFZGZksrdwD6F+QfSpjMDQyIx7byFYHOBrRNcxAm27MBRP/T++/8lfvkbW+kWMmLYcrcF4Wn0qDmfiHdIYje6fzy+EEEIIcSL/5vfHQgghhBDny4UtYCyEqBeeASHE9r+KtKVforgcPH5lSyJq0oio2kVczQ7S0tJwu91odDo6XDuFaz7cTLuJjxHxxkLSJrYmflce5sttVPrvY01iObleVhTrZlrwNr6aEmx2X/yrgon260LnNolcWRHDVYd7ELrlAI75Bxm6tyX/7fI4V2zvRpeah0k5tAHHDwdZmrydj5f2Z/9Pg8CxEPvMTJy//hddO2+0rdcCVwNH8Rg4gIAPZ2Bd8hOVP7+LaqnBPmMrrt+Poqoqurg4gn+cT0xaBsVHjvDTDz9gLatEdblRHS7UChuqquIss2I/YiG0eTAdnT5cHt+Fo2XFrLTtw5ngjTVtMZp2gWia+OFcfZCatzfh+Gk/apX9rO67y2mnKC2Z1tfcS7+pn5x2sh0AVWX7rBdw2WvOam4hhBBCCCGEEEIIceGd/6LFQoiLQk1FCSnzPiAkqTPN41qT6dWZUlsg1W491dXV5OXlERkZCYDO6EGzoRMB6B7Rg9UlM7EnaAif/BIj1nzJwY/+Q1Gjxuys6I6r4hPMTit67T6y+Ao1S4fdZMKzdQIvlH/FDQfj6dj/eoJNURS6d5C35Ev6V1cQYNJQuK+UVpQTYb6MHxbMJ8r3Y8J6KcSp35K9/jGK0lfR8aY7gY/IpRjH/ddR9MMCrFuX4tU1Cod/Nbqvk1FcoB/fkqY97scj7VfWxqn89NVcLu9zGT4YcMzbi/GxnpTN24sjvRhNzS8Y2l2Lt68Pw4YPY8mSJSxZv4K2K77D2cSENrIHnp5GamK0sPcQlrAj2CqK0OoN6D29/yg3o6AoGnybxOMZ0AhrWSFVBbkExrdFURQsBbkcXDOP/YtmMWL6Snwj48/oebkcNRTs3UZ1yRF8QqPO8VeDEEIIIYQQQgghhDgfpKSMaFDuvfdeFi5cSFZWFsnJybRt2/a0+8qvzEJNZSlavZGSgym8kqwhLu1d2pvL2O0zhKjoGC6//PK/HaOq6DD5u9ZTkXeQ6uKjoLpR3S7cljJcRw/gri4hyreQJl4ufhn8Asp7s2i2rZC1M+8hY9dKrjB2Yv/RalKOlqLXejK0fTRenhb2V2zlSHkhN1znZKttODEH21C4dw1d78oAjPx4dzHVxcXw//7JCvZqhoKGEmcWo/+zFFXvYunzEyluO4ykiEhiE2P5fcbrFFbvx6j4oFP1lNuyUVUFUFEUhcBuI8jWN0ZXWYYudSEmh5t+t71H6uavUA+UkVu+FT9TFIqiUGo9dMz8LcfcTdLIW9kzbwap8z/k2m9TSf78ZTJ//RG7pRxQ8AwMxSs4vPYjKByv4AiCmrXHHNEURVFOeb9VVf3bNkIIIYQQZ0PeHwshhBBCnHuyw100KGPGjOGRRx6hZ8+e9R1Kg2T08ef376eTvuxrbvzvXB5JG8S46vvY5TOUrKwsqqur8fT0POUYXkHhxF12zSnblNx8JTXVm+i64h1WmR6BcZWM6HQ9R1sMJlETTrROx8JfJuIuaM6h6m68d8WvJBo9+SHjNl6dP4vYlr4EmQ3kH85jw6HxBO19i9BWTjrfNgd7VST2agtFjzyEy+yF6frxuJx2VFWFOF8Ob19N9NArCF20HPucVJx3PIapfx9amPqj1eprd6drNDhsTvRGHbayQgLi2+Ax52v2N0rE0fVGmrdujrlzW9ppfNC4Cmg/4QVYnIVT78IwJoktHz5Bo5Zd8Y9uzqpnJxHaqjtegaGY/IJxuxwExrVG5+FDcEJbqooO134UHsZSkEdB6lasJQUAXPnxeow+/iet1/77d+9SfOB3+v7no3/24IUQQgghhBBCCCHEBSE73EWDFB0dzYIFC2SH+1lw2WuwFOTi4R/Cte+s4caa6ahBrThiTKBDhw506NDhjMdU3W4UjYaDq+fhsFqIa3858x8dRpiPF7giyC7ZSVi3Jwiu3MHu33/mqk9/Y+Vn/8GWncv0gHu59tBTWKOM3PHQj8yb1JmN3UJom6Si32Ajp3d/xulCqTw8k9bXmlg8xZdmg2+mUbFKyaOPYB47nsrR/XBaq2jSfQjzbu1B+4mPoaCQMvMVmu208eu999AkOorE0JYoToUmHSIAsFWUsHDyANpc+wAZn5eS6/DH1NZGTSOV6OhoevfujbEGMGpx/pKJbkg8iuZ/u82ddhulmXvxjWiKwdv3tO+X026j9GAqwYntUd1u5t/Rm9j+Y2hz7f24XU4URYOi0ZC3fTVVhYdJGDzhjJ+JEEIIIcTfkffHQgghhBDnnuxwF5esmpoaamr+d+BkRUVFPUZz8dAajJgjmrLq2UmMqoLXPSfzWdXTHDXGk5KSQrt27dBo/v48ZWtZIRqNjoK9W9n68dOMfH81FfmHcFRVoB0aSsfbnsWweRdeKS/jEd2Z7WsqOGwzEVlmxJ28my7D7mDur6l4l+n4JXQwCVEGjB7VjP6kP4f3eRIbuomSGC+yMovQdboTY8sgXM63adqnEP8YTyzB/mzpGUDXb74mp2gntE6iab/RXDF9JSZzAABRfa6g/NVX8dj5I7nu4RzOzMecH0Roog+7v/uQI4fa0Pa6lyg7EkiudR8toqrZm+xF4yEh5Ocf5vvvv6dPnz5EVBhxpRWhG9AUd6kNJcADxaBFZzAR3KzdGT8DncFEcGL72k8Uhb6PfViXsN+3aBa5W1fSYdJUIjr0o6owD2tpAR7+IWc8jxBCCCGEEEIIIYS4sP4+qyZEA/XSSy/h6+tb9/HngaACFEWhzfgH6TDxEVwu8PMxMrRqFjabjUOHDv1tf4e1imWPXUXutl/wa5JA4oibcLuctB3/IJ1ufRqA6B7D0P+2G5R2xATYMXj54hfpS1rwZCy/biQwrjX9hw1jytAkxgyfyIqMtvySUoLbo4zDVamkFI1hVoonNpeNR399gNmpv/PMFn+ajdARGPcpftHhtL7uITxfepaoFXtpF9MXoC7ZDqDTGwmc+gT9EvvQ7cMP0dqKKQnLJTN1F9kbFoDzKJaycJLn7qPz9W3pOe02et7RmaTWiVx99dUEBQWxdOlSNhTvR3NXB1SnG/tnO3D9lnNOn0VA0xZ4hzQGICi+Nc4aK8unXsOm9/7DkkdHk7FizjmbTwghhBBCCCGEEEKcP1JSRjRIp1NS5kQ73CMjI+VXZv+iprKULyaPpGljPf31q/ix2Sc49L6MGTPmhO3dbheZa+YT02cU2b8tI7RlV0y+gScff9MmtO5slEPfkbM9kii/90k52hdXVjRtFh1bl/zhr3dwuNTKl3d1w+Kowsfgwzf7viar4lOuT7Kh13zDgozFpBTP5ZVeVozaKBTlZSAS+5496Fu0OOXhotZFP5P+5BQyhg9nyH2Poff25EhGGUufWk3T7pH0vjYW28+LqfrmGxqt+gVVVakutZJ15BC//fYbRo2OltZA4mNi0SQXYLynC4q38azu+99xu5wcWPUDu+e8g6vGSuKIm2lx5e1o9YbzMp8QQggh/p2kpIwQQgghxLknO9zFJctoNGI2m4/5EMcyePthaDOE97gOh6pBX7KPkpIS8vPzT9i+PDuNbZ8+S0HKFqJ7DDtlsh3A2K0buh5jUS97D+OvG6k82JSWwSsorbLhLiurazd9+X7sTjfPX9MGRdHgY9ABD3JNQhO0NCPUs4bcyulMaH49hdWBPPKrJ053Oqp6DXAQQ8uWKIqC9adFlNx5F6rdflwsHsOHceTyl4hcmknFlVdhSd7N8o1LMHZU6NjDxNFOXUCjwXPsWAC2fbObHx9dRkJsAmPGjCE0OJQt2jzmFWxlr0cptjUHzva2/y2NVkf8wGsZ/vYSmnQbSsrcGfz84DCKD+w5b3MKIYQQQgghhBBCiH9OEu6iQbn99ttp3Lgxubm5DBo0iLi4uPoOqUFTFIW+E++lxqkyPyOR2EPfALBm5TLcTkddu6K0ZNa9cS/mxrGMmLac0NbdT3sO1eGg9LY78BnRCjdlqKqCIcJBzcZNdW1aNPajX1IjooO8/njFCHij1Wh4uPP75FY2I8JnDW9vf5Uh0UPJrjDy0hYzKg5UdTyw649uRqxLl1Fy+x2of/nthj/pw0Lwe+xhMPtQce04gg5bsfpWsnD/XiqmT8Nj3LX43H4bAIkD4+h6Uwd0Rh1ms5nLhl3OmFFXEeEfwjbPAr7P2cTOjdtwOBzHzXOuGL39SBw+Cb2nNxqNjs0fTMXtdp23+YQQQgghhBBCCCHEPyMJd9GgfPjhh+Tm5uJ0Ojl69CgZGRn1HVKD1yTIi5DGUaTGjKGx4Sh+1iwqq2s4evQoacu+In35NygaLQ6rBae1Cs/A0DMaX9HrMQ0djLF9Et7N/akpMdHW8xdq1q2ra9MvqRGjOkayJ7eciR9sxGJzAc8CtYn9KN8naOTpxqRbx1HrUab1n05hdTOe3uiHW3WiqrcAK/C4fCCBn36Cbe2vFN98C66CgmNi6Xdfd+JGdWZn94coGPtfkr7+jPaLNhJoNLKusJAt27djXbYMV0kpPsFeNO3WBFVVObK3dhyfQ1a67TZx9RVXEomZrXuS+eabb0hNTcXtdv+Tx3BSvpHxXPXpb3S9+yUCY1vhstvOyzxCCCGEEEIIIYQQ4p+ThLsQgsvax7JS352thm70snwHisL6jZuwHMmm8kh27QGnj3+G0cf/rMb3ueMO9CMeQrnpVxw5OoxB5dh+XXtMmxJLDct2HSbC35Pqmr/u4n4FWAZ058aWen7NXc26vF95o+9bxPiO5z/rInCjBx4HVmDq34/AWTOxb99B2cOP1o3idrlxWB3YrQ7MYT4EjxlM1M9ziNKW0frBKXTfvYemnl6U3HQLVbt31/XL2X6YHx9bzoH1WWjbhGK8pwt+oUH07tOHKwujiQwIZf369fz4448UFRWd1f05FUVRSFv6JfsWzaLLHc+jN3n9fSchhBBCCCGEEEIIUS909R2AEKL+XdE+gk/WZLDG/zb6FlxPmDeU2Wy0m/jYKQ8iPRPu0lLKHn0Eq0c0PobfSYvsSKOaGhRj7cGjiqLwS+pRnr+6DSG+pr/0jAJMQA8CTHfwaKereWXrt6zOXsX0y2agMg63u4wcyxSiff8DpGPqfSehv23EXV4OgG3Vag5/v4IVh5MIb90IjUZDtxs7AFD24BuUP/U0YT/+iHv7NlxaLYsPZBCuUejevTuRHcKJ6RbJbzO307RHE9y5FbiWH0A3ujk+oYF0P+wmcUQrNmzYwPz580lKSqJTp04YDOfugFPPwFDM4dEAHPjle1AUYvuf+GBbIYQQQgghhBBCCFF/ZIe7EAIfDz0j2kWwsSIMd2g7uhx6BavVSnZ2NqqqnpM5FB8fVIeD8PgU3KqGpv096pLtAP5eBhZN6UubJn4s3plHZoHljyvXAqOADkALekQcYGjMcAqsBXy77xtMWhNZFRbuX1PO6pwA4DPgDjS+JnRNmgCgVlWh3fYr7Q5+iyl9J42j9XXz5iQfoVAbjtekSehCGqFxuYhLSSE9PZ358+dTWlpK0uAELEXVFGeWgkYBlxvF7kZ/eSwYtIR6BzB69Gi6dOlCWloac+bMISMj45zdu8gul9N85K3UVJZSemgvZdlp52RcIYQQQgghhBBCCHFuScJdCAHA2K5RVNqcbA29iWD7QQLVAtasXk1a2rlJ7io6HUFffIktYRqOfD3hmm3Yk5OPaaPVKNicLt5fmc53m7P/cqUM+JDa5PsO7mjTk5tb3sK8jB94e/sbNDFH0S/yMj7e5UVWhRequv2PtoUAeIwYTpP1v9Di0XFkVwVSPuMTajZsBKDPTS1pvf9rDO3bEjT3ezT+foTN+Z6+q9aAw8H8+fOxGMoxeOrJ2pKLNsYf/TUtweZEE+mLcVI7FB8jGo2G1q1bc/XVVxMWFsaqVatYtGjROSkzo6oqPz8wlJT5H9HhxsfpMOm//3hMIYQQQgghhBBCCHHuKeq52oIpxEWuoqICX19fysvLMZvN9R3ORemxb5M5cLiET8pHcdSzJWv8b8RkMjFu3Dj0ev3fD3AabKtWUznzFY4Ue6IWu2j124K6sjVOl5sRb6wlrpE3KXnl/DylLx4GHbWJ82uBl4FioD9gYH76PGamfEq4Vziv9n6dspoyntn0OPe3z6FV8J875B8DxlB5dCE11Smk/FxGaE0gCXfdg+LhQU3yToqGjyDopx8xtm9P4VVjUIxGnJmHcFRWcOCRh4np04e0OdkcdeRhTNCiVjtwVdeAn4n4+HjaBcaiGLRoIv73dZWTk8OmTZsoKysjISGBTp064eV19vXX83dtwK9JPB7+IbjdLjLXLiCsdY8zPsRWCCGEEOJP8v5YCCGEEOLckx3uQog647pHk1PuZLXX1URZd2BQbdTU1JD8/3ai/xOVzz2I0ugQqV5dSe94wzE14nVaDQ8OTeSmPrFY7S5+STn6x5VgYCnQCRgMGACVK+NHMyHxeirtlTy49gFcqovB0cN5fnMg5bYpuNxhuNVXKKyeRkVBMh6+y+h91y/E3zMfxWM7jv37OXrjLaxqOYXsgtryNtrgYHC5CVm+FK/+lxH/n6n4vPY6Ua0Cqcq2ERIQQuPoSKJjomka05SgoCCcKw/g2Jl/zDojIyMZM2YMPXr0IDs7mzlz5rB9+3YcDsdZ3bfQ1t3J2byCw8lrcdms7PrqDX7/fvpZjSWEEEIIIYQQQgghzg9JuAsh6rSO9CMpwswqr5FoVSfxzt1oFIXdu3dTWlp6Tubwm/4J5pgQ+rb+hSDrz1grbMdcH9gyjHbRAXSJDeTH7bl/uaIH7NTudp8GvATA2MRreavfNExaE1PWPoSPwYyPwZepG35lS/4UfjrgSbDn52T6r+Stxd35bNxd2Pb7Aw+hCazC4GkioiQZ3a+LUe12NCEhuAoL0Pj4EDDtbfzfexfbyl8wPn4LylEtwdZguvfpRZd2nehgb0R0dDT2kU1ZWL2bI0eOHLMWjUZDixYtGDt2LElJSSQnJzNnzhzS0tLOuL67oigcTl5Lccbv6D29aXHVnWSumU95bsaZPgIhhBBCCCGEEEIIcZ5Iwl0IUUdRFMZ1i2ZLgYmtxr6EV2zG5Xbj4eFBWVnZOZlD36IDduMNmPZux6C1kvboW8e1Wbg9lwh/T37PKePA0cq/XLmP2kR7FBBb92qwRzBaRYOf0Zf3d02nTXBbiqyFrM5dx+XRS8mzTKZruJM7h23BK6AKfcJ83OrrKIFtMXTpTHNSMHz1PoVXjkbR6XAXFNaN7TlqFCG/rMDcuyv+FZmkTfsBy6zZuPPLce06gmpz4hFgxmQysWTxkhPWbDcajXTt2pVrrrmG0NBQ1qxZw/fff09aWhput/u0713vR2fQcszdOGusxA0ci1dIBLu+fvO0+wshhBBCCCGEEEKI80sS7kKIY/RLakQjXxObA64hpmYPCT6W/2PvruPsqM7Hj39m5rqsu2UtycbdEwLEgCSEENzdKVZqQKEUqlCkWIu7Q3AS4u6e3c26u9yV6yO/P25YCAnWpt9fac779ZrXhb0zZ2bOTTbnPPPc56AFvGRkZByV9rW2NoLbtlGlnElJ4zTqCjswQqFD9tlX58EwINZp+UaW+9XAz4AFwNl9P5UkiZ+NvoUHpj/EpUMuZ3n1F6Q609jUuJGPyj8g3XUJ+z+4A6tm5vQHX8dsXce7pY3cu/EejBF7iXkqnsCDz2AYBpaxY3Ccfx66pvW1b0pPJ/ahv3H8faczId9D15130XbVGaixFRiSjslkYma/0UT5ZT79+JNv/TZAVFQUM2fO5LTTTiMqKopVq1bx5ptvUlhYiKqq39t3sqyw6o9XsfOlP6OYLAw/+ybqt6+kpWjbj/gEBEEQBEEQBEEQBEEQhP8UsWiqcMwQi0L9cK+ur+TJZSWsiv85ft3Mm9YrGDEgE82eyMiRI7HZbP9y20YgQPfVU4jO2cFndX+ku0VnwW9OxDZx4lf7GAaSJPHY0gN8uKOOj247HqtZ+UZLHcDzwJXAV5+nL+xjRe0KXi96Bd3Q8ak+fjvpHtQlCm0VtQxf8A6Zowpp90/il2ubGREb4LpRLbSWJeKMfQJ3ciZ6Tw+t8xfgvOhCnBdegPSNBWPDpaX0/O0htKIOnJPOhlEatlNPpfuxDSyNr0ezyZx11lkoyjev+VDt7e3s3LmTiooK7HY7w4cPZ/Dgwd+5QG3NpiXYomJJGjweQ9dZesdZSIqJWb9//ZB6+IIgCIIgCN9HjI8FQRAEQRCOPpHhLgjCYU4dnYHFpLDafQbOjl0M1Paxr6SSoqJCtmzZ8m+1LdlsRD/xOb7oG5mZej8F6etpXrL50H0kCcMwmDIgkbBmUNL09bIy+4EbgADwLvDWIce+sP95Pix7n78e9zdSnCkA/GnLH8g8PRmzLZo9iy8C7ibevod/zOzBZI7njrXxxOZ140q6ESNYSHDzZswjRtD127tpmX0SgTVr+trf+tputm/oIe7JJ4j+y52ogSo6b/8VrfPmYovXmdmUyrTxk7432A4QHx/PzJkzOeuss8jKymLLli289tprbN26FZ/Pd8RjsibOQZIVGnevR5Jlhp97C+2lu2nas+H7O18QBEEQBEEQBEEQBEH4jxIBd0EQDuO2m5k/Op1HGsbgxYXkrcdAIklqo7i4mObm5n/vBM5Ewv40gtUy6e591O1oOGyXp5aXcs97e/nk58czLDPma+9EARKRX1+LgJeBr0q4XDD4Qu6Z/HvS3Gn8+bgHOCHzRIJakDtW/JoBJ+UwYuEQYD7wOnIoiWtH7uWcglie2TcOsAKP0XHxpdjnnkLi558ix8bQfu759Dz6dwDMqg+2bqDnqacIVxVhOWUU8Q+9iBwTQ8d912MPaiRuacQwDNasWcO7777LZ599xqpVq9iyZcsRa+HHxMQwffp0zj33XPr378/evXt57bXXWL169RHL0xz49CVKl7wKQMqwycTlDaNw8T//lU9CEARBEARBEARBEARBOIpESRnhmCG+Mvvj1Hf4OPPRtTyQtYRxNX/ng7Tf02W4iY5LQJJNLFy4EFn+157Z+T/5lN57LsY3MZ1+8bv5aMPtzH33LmS3u2+f6jYv7b1BRmbF4g9rqJpOtMPyjZY8wGnAKcAvDnlH0zXeKX2bU/MW8FHRB3TeqVJ3Uhnn7asgNT6XmHvvIbhpA8GNN+G+2UTQm0TZmgvxjnBSUV3JaSMmYXcOwjCsBD7+BKxW7LNnEdy6jc6bbkLv6MTo6cGSMxbXzBuw3DSJ8M7NBN/cjjluAJ7OJdSfvoCgw4HP58Pn8+H3+zn++ONJTU2lsLAQgIKCgsP6MRgMUlRUxL59+/D5fGRlZTF8+HBSU1ORJImQtxuz3QWShCRJ1G9fSfO+TYy84HZkxfQvfSaCIAiCIBx7xPhYEARBEATh6BMBd+GYISYUP96v39xFfXML/+w9n89D42nNXERudj8qKio46aSTyMzM/Jfa1VpaUN/7NeGid3HFdlG/Ooe4X/8D++xZh+2r6wanP7KGGYNTuHHOwIM/NYiUlnEBa4DHgTeB7L7jqrur+M3aX/HrCXcwKHowm5ZtZenWZVT2K+KyhElMShyPdfz4g3uX4e/6JVZXLYWdU7l3Yyl/P7ENuykWm+kRLEr/Q66pq7EHX6eflLxoQnv3o9c1YVtwMoRC6D1hQk9sxb/vQ/wb3sV20hzc112HZfSoQ9pYv349+/fvJz4+nkmTJpGWlnZ4P2ka5eXl7N69m87OTmJiYujfvz/5+flUfPIsvrZGJt3w53/pMxAEQRAEQRDjY0EQBEEQhKNPBNyFY4aYUPx4u2s6ufrZLbw6egs5O3/Ha4PeINDTydyYQlIX/gWUb1/c84domXcq8SPXEmywEsq4hph77znk/dKmbl7fUM2JQ5LJT3aTEmM/+I4OLASOI1LP/UygP/DgIcf7wj4cZgcAHe2dvH3NJ+w4bh2NmbWM2N3F1bPuJmPyl0H+MPBP4EUCDbF8WprA+NFlJNgNvOGbibef19fuiofW017ZyZmPzotcTWMP4cVF+Ko+Rqsuwz3/Noz2EFpCNb1PPolaUYFl0iTc11+L9fjj+xY3bWlpYcOGDbS0tJCbm8v06dOPuGCqYRjU19dTUlJCVVUVqqoSYzeTaINJ88/FZrOhhgKUfv4qaaOPJzoj71/+TARBEARBOHaI8bEgCIIgCMLRJ2q4C4LwrYZnxjCqXyz3109FcqdwtvwBVpPCgbpOjJX3UFNTw7/6zC64dRuazUVrbSxScoii8sN/HekGVLb2kndIsB0iv7qeBG4hUnf9emA1sP2Q478Mti/eupi/vP5Xznr8RO4adiq3D7+FmlHp3NzwMK89cgWqrgJmtPA1qKEnMJu6WTihFIfpcmp7coi3/w14m6VVS6jvXc+oM9aQOXoZge7XgWVIsSGkVDf2E2cQLi3B8+Qd4AlimziHpFUriHv6nxgBP+0XXETr7JPwLV6MoaokJSWxYMECTjjhBGRZxmQyoes6ra2th/SrJElkZGRw4okncuGFF3LCCSfgTkihzBPm5ZdfZsmSJVRUVVGy/B3aS3f/S5+HIAiCIAiCIAiCIAiC8O8TGe7CMUNk8Pxrvsxyf270bgbv/BXvDHuLjrZ2pne+yOq4SxgxYgQTJkz40e12P/Qwyv4/0BvjJtlVwc6sjxl12dxv3f/jnfVsq2jnnkXDv/FOD5HSMpcQyXx/kW8+S9z+xS62PbaP8385kE03/wPl9NPZPnMf6sdL2DjCRr/oHK4dcR0br9vD2PNHkLn+CWyz9mCf6QWmA2MJa7FctvRlsqOauWW0H6duYHGEkSQDyMUw3kCv8EC0QdeddxJcsw3rjMnEPvowkiRhGAbdy9ax9R+r6b/5eaxpSbguvwzHueccUru+qamJDz/8EIfDQVZWFllZWaSnpx8x8339P++htqkN67AZtLa2YjKZ6NevH3l5eWRmZqIoyo/+XARBEARBOHaI8bEgCIIgCMLRJwLuwjFDTCj+dbe9uoP6Vg+vcwWd7qG8GFpAnl5KjlbCRttJTJgwgREjRvyoNg1VRd/1Fp23/Yz4Ezph/j8wBp2H7HActm99h4/tlR384cP9vP2zqWTGOw++sxq4G3gdaAfqgNkc6cs7hUtLKfr0AJbBfmSbm8XJbyJV1nD2u8188ovplHmrmNM7j4VTFuB8/UX8H39MyobfA/cDJuAXhPWp7Gjeyeq6VajPmUE2uO2Rc7CaOqivcRL/Qi3mM9cjF0zC/34H4eIy3Ff/DFwKxR/tY8vicgBmnpeN4/PX8H/wAZLdjvO8c3Fefhmm9HR0XaepqYmamhqqq6vp6uoiPj6eRYsWAaCqKiZTZGFUX0czitmC1R1Ld3c35eXllJeV0dHZicViITs7m5ycHNLS0o4YsBcEQRAE4dgmxseCIAiCIAhHnwi4C8cMMaH415U2dXPhkxt5fFQhY3bdyuLhb9LS5uGknudpGn4ruyo7mT59OgMHDvz+xr6h6YQZRI0P0dsURTB6BJmP/uGQ91u6A5z2t9XcPm8wT3xRwmljM7l+1oCD73qBxcDZRILiXzIA6ZB2tr66iwPLKyi6bAtJjmROM4/j17t+T4oSy+8XPc2q+tW8XPgiZsXCha35DLn3ddJKDyBJ7cB9wDogBzgfOJntHxxg+4t7ueSVM5FtMud9cjbjFTdnTK4jO8ZDSIuDDVejbUjki9JaGlsN+sX2MPXuBbhyIgukao2N9D7/At5XXsXo7cU+fx6uyy/HPGpkX533rq4u/H4/KSkpdHZ2snjxYnJzcykoKCApKYnq9Z/QUriF8VfdC8D+9//Bns/fIvei31FVV09XVxeyLJOcnExmZiYZGRnEx8f3tS8IgiAIwrFLjI8FQRAEQRCOPhFwF44ZYkLx77nr7d3sqW7jfesNGNHZ/CN8Li1eWLRwPpSnxkcAAQAASURBVJ2VewkGg8ycOfNHBXI7fnYzwVAVO5tz6HWPJibNzew/nXbYfpvL2xiZFctjX5SwbF8TH946HbPpm1nsYSJB9zuJLKB6Sd87ez8qpviLMuReD8dN7iHu8qsIfbGcHXffwMO/HsKIpJH8avSvqK1p4v3li1mVvJTBhT3cdOULpCbmHmxlF/AKkaz6OII9C3n9GhPTrptFzuRMyjylHGgopN9ajY3pK+k/bA/T4yzUfD6etUtHMSqrjvg3noGwhvOyS3FdeglKSgoAuteL78236H3mGbTqGpR+WdjnzcM+by7mYcP6+tTv91NYWMiBAwfo7e0lJiaGVKuGpXEf46++D0mSCHZ38sENMxg071KGnXUjXV1d1NXVUVtbS0NDA6qqYrfbSU9PJzc3V5SeEQRBEIRjmBgfC4IgCIIgHH0i4C4cM8SE4t9T0+7l3MfW86dhpUzbcwNlcz5ixd4GjjvuOAbsvx+GnI1cMA9N035wANf70stY6+6kWRtOr3UIRRXZnPbUNd+6f1lzDxc8sYE/nD2CEwenfO2ddcCfgZeBd4FMIqVlIvZ+VMzeD4uIVtuYaNqG+4brKN62hE8qPmLGDQ/yx033MqnEYP6oh9jwzHYGXhXm6ZqX8cY7OXfwBSzIOw2T/GUGfRXwGvAxatCgsXASmaN+AyRgGAbht/dT0Rtg/dJSTBY/Ixbk8ojlBY5PbmfB8E6a9iRhubOI1Fv+hv3kk/F/+hnBtWsxDxuGafBg9I52Ap8vIfDpZ+idnUcMvhuGQX19PcXFxTgcDiZNmkThsrdpV+LJys2jeeXr1K39gFOfWI7Z5uzrB03TaG5upq6ujpqaGjo6OvpKz+Tn55OWloYsi7W0BUEQBOFYIcbHgiAIgiAIR58IuAvHDDGh+Pf96cP9rCps5JOo25BtMXyadDs9vb3MD7yCo2kDbWet4otN+5g9ezYJCQk/qE2trozmk+eTsqiKlVWXMuaaq4mZeHg9+FfXV1HV1ktVqxeHReGRi8Z+7d12ItnnVwKH14AHePtnH5M6NJnB259D7+nmwNBY3omt4HeXv8GmTe/wWMe7nJlzJhcMuxi1opya2TNY9o/L+cy7layoflwz4joGxw/+Wosd1O/+O/G5X2B1yTTsm4sj9jJiMxIp/eQAvW0+8k7qT1Syi56P9xCubKT89CcYmtyAVTEIhUdgs1yL97VSep95BrW0DHQdyeEg6vaf47zsUoIbNuD/+JOvgu85OThOX4hj4WmYcnL6riTk62HxXZfiHzyHoBb5lS73tpGRksRJ510BgGEYh337oLOzk/LycsrKyuju7sZms5Gbm0t2djYpKSl9teIFQRAEQfjfJMbHgiAIgiAIR58IuAvHDDGh+Pe1dAU449G13DGokjn7rqbz9I95Z3MDNSE3N3fehispm08TbqXX62PBggXf28+GphHauYvOJ56h2YhmU8dQpg7tYcj91x6276e76qnr8JEWY+f+D/fz7k3TSIs9UnDdALqBB4jUdh9KOKjy6mXvMWLhYIafmA6GTuf1N4LbRcLT/0Q3dN4ve48X9z/PbWNvZ5p7FI2DhxL31JPUTxvI4zv/TnlXOYPiBnNa/kLGp05AkRS6m3vxdTaT1P894C3UUBJm6+0EHzKjDE/BPCsPAL2hh9Cz2zHNyqNnpEyr7xUGxJVhGGfz6M59TEtPZFhUBvp+B8F1G7AMH47txBMIrF1H4PPPsZ96KrrfR+CDD/F/+hlGby/mUaNwLDod+6nzUeLjCfZ0YnHFULt3CwFbLLtXfESgrZ7zfvknNANee+014uPjSUxMJCEhgaSkpL7PxzAM2tvbKSsro7y8HK/Xi6IopKSkkJ6eTnp6OvHx8SL7XRAEQRD+x4jxsSAIgiAIwtEnAu7CMUNMKI6OR5ccYPHWGpYm3olJ0tk07FH27i9ke2OAx/RbCI26ho/8U5BlmdNOOw2z2fytbRmqStPQAlynqaytP4P2nv5kWFo44a27vvWYQEhj3oOrOGN8FtfM6P+NdzcDTwCPArcADcBLvHzpWnwdfkbWLWbEX67DNuNE2i64EMuoURg3XM49G+7iwrxzqf/4TUz1J9JvWgH5ib2Y8vOQo6PRDZ0tTZtZXPY+he37SXWmcWreAmZkzcRmsgGga2XIysPAJvSaU5CSL0Ky5vddWfizUrTdTVivG48UZQXAG/bypy33Myl1Lafk+vGFozDJp2JRFgGZ+N5/n6777kdvakbpl4VjwQJs8+ailpXjf/99AitXgWFgnTYV67SptMVIbFr8CHP/9gmGrvHpbfMZf9W9ZEw9lcLCQtra2mhtbaW3txdZlrnooouwWCyHlAEyDIPOzk7q6uqor6+nsbERVVWxWq2kpaWRkpJCcnIy8fHxova7IAiCIPzEifGxIAiCIAjC0ScC7sIxQ0wojg6PN8Tpj6zhmvxmziq8gNCcx3irPBrN4qZx/3IW5IZInnc/iz/4gLy8PKZPn/6d7YXLymDDb+hpiMPlfZXNpYuY+vrzR1x81RdU+XxPIx29QeJdVhaOy/zGHrXAP4GfE1lE9WIgjv2f/px1/9jLieMD5Fw4G1NWVt8Rmq7x1J4nmNtvLra5F1I681Ys07JZGb2EG0fdhNPsPOQMJZ0HWFz2Phvq1+M0Ozkp52ROzTuNaGs0kez6tcBDqOsGIEXlowyfAeRiBMIEH9+CnB2DZdGQQ9qs7Cpna9MzxFjXMzU9gMOsA/eh6bOQDQht2oxv8WL8n36K+8YbcV9zNWp9A1prC+Hdewh8+hmhbdvQAwG6k10kDhqDMm40+zv30tpQwtwHP8YaFdt3vkAgQFdXF8nJyaiqyuuvv05qaioDBw4kPT39kEx2TdNoaWmhvr6e+vp62tra+gL0iYmJJCcnk5ycTFJSEg7Hkcv5CIIgCILw30mMjwVBEARBEI4+EXAXjhliQnH0PLOyjJfWVfL5kLdwFL9B2bxlrNi0m1DSMN7b7+W9m4+jq6mKqLhEYmNjv7e90L79tM6ZQ/zlQSrah5F709PYBuQdtt+XC7c+fOEYxuXG/4ArLQauwN89npcuHMVZj59KbEY0X/7a+2ZQP6gG8Kl+Gr0NvLDiL9weOoHE8y85YsvN3mY+qviAL6qXYhgGp+Yt4LT803FZXECI0LtfoAz+HKxt6MUnYDqpH9qWgahLqzBfMBwlN+6wNjsDHdT2lDE8sYMOfz43rriTm0bbyI9xE227EDk8HEPVkR0Ouu7/A71PPIl5xHDs8+ZhGTcOQ9MIb93KzvVv0tvdSkGhj12jXYwYNIt+1/wcU+Y3H1BAOBymsLCQkpISOjs7cTqd5OXlMWHChCM+9NA0jfb2dpqammhubqa5uRmfzweA3W4nPj6ehIQE4uPjiY+PJyoqSpSiEQRBEIT/UmJ8LAiCIAiCcPSJgLtwzBATiqPHG1RZ9PAaZvW3c1vlGRgpo/k46iq8Xi8TTjiFnPZl8PnNcMkq1Kgsenp6vjXwrlZW4vnDH2gpLsQ+JExCXAXtGU+Sfd2ZR9zf4w0R47RQ3+FjW2UHC8ZkHGGvXcCrwO8JB1Zjtt2Bv34hUt1MbBMmEFi2nI6f3UTymlUoX1vc9Yldj7OvZQ/3D/kzPP4XZKcL/82X4lf95ETnHvF6ukPdvFf6Dh9XfIxZNrEw/3Tm5Z6KPWwGk4ZeshZtRzuWix4g9PrV6HU5SA47UkY8ytAk5OwYCKhITssh7XYGOvmk4mMU+R2Oz2wi1anRHXQTZT0fOJ2g14S+Yg2+Dz8ksGIFBIK4b7mZqJ/fRtO6pfjLS3DkDsT4fDn6ux9i9PZinX4czvPOwzZ7FtI3Sv0YhkFrayslJSV4vV7mzJmDYRgsX76cpKQkMjIyiI2NPSwIbxgGvb29tLW10dbWRnt7O+3t7Xi9XgBMJhPJycmiFrwgCIIg/BcS42NBEARBEISjTwTchWOGmFAcXW9urObhJcW8PrOd7GXn03HyK7y7x8e4ceMYkp2E96nJuK0SG4Y/QVVDG4sWLTpiyRGtqYnu2y4gtv9y9lXPZmi/pdT7biD9L3//1nMbhsHbm2t4bnU57958HE6r6Rt7FBFZNPUJWst7qdp0D+PO30jnHRZi79+AWlGJ/9NPcV13LdLXgr/ld91GUbeN+qpBXPLqWVhdFv669c9sa97KL8f9mtHJY771mjoDHbxT8jafVX2Kw+RgUf8zOSV3LlbFenCPSvTWT9Db9qO+cwa4wphOzka2pxB6cReWa8ZhdAcxeoKYRqUecq9lngOUdr5F/9gD9I+tJqA+yfmf3sWopETi7UNItabTVV/J+flnY+rXj7veuoxKo45JW1qpK3BjEM30HUFG1FvRt+9Cjo/HccYirGPGYBo4EFN2PyTTN/sQgsEgy5cvp7GxEU3TsNvtmEwmzjnnHCRJYsmSJbS0tABgs9lITU1l8ODBxMXFEQgEaG9vp7W1lcbGxkNqwaemppKenk5SUhJOpxObzSaC8IIgCILw/4EYHwuCIAiCIBx9IuAuHDPEhOLoUjWdq57djDeo8VrSIyjVq9k48Q2KyqqYdcpp3P3yMv7i/xm2mDQWx95MVHQM8+bNO3JgVdcIvPJn2n/7OGkXNeOty8f1XPG3nvv213ZgUmTuOX0YVvO3LdypAzLQQOma5UQlriZpYBGS/ALwzcVWI3zvv4+/V8U/fCpf8Blx9mhm557CX7f+me3N2zin4DzOGng2ivTti4W2+lp5q+QNllV/gd1kZ3TyGMYlj2d08hjcFjcQQNvzBXpNOaa5b0LgTPSK05AHZaOuqsJo6MF89lCkb70vP76wwaq6lYxPeQi7qYftzVZcZhMjk7KQpd+ytLKEPMtrtH64k35TTESnSyz5TYBJNyzi0xqF8tZVzE3wEvdAB+7SEJjNmPr3x1wwEPPAgZgLCjANGoSSlookSaiqSlNTE01NTei6zrhx45AkieLiYnw+H5Ik0dPTQ2NjI1OnTiU9PZ2SkhKam5tJTU0lPj4ep9NJe3s79fX1NDQ00NzczNf/+bHb7X2bw+EgLS2N7OxsrFbrt/SDIAiCIAj/LjE+FgRBEARBOPpEwF04ZogJxdFX0dLLxU9t4LIxTi7dO49Q/9N503c8qamp9Bs6gXuffZfH9Z/jzVvIx97xDBkyhMmTJx/WjmEYqJVVNE0/kdgzVPSQH9dfa5C/ZRHODaWt2M0Ko7LjaOkKoMgS8e5vC8z+nZD/cwo/v5ORC7cCl+Nfsg4lNRXL8OFHPMIwDJ5595fYPlzOBc9vQZfh7QNv8nrxawxPHM6tY24n1vbdtekbvY2sqFnGtqatlHeVIyNTED+IcSnjGZc8jkx3EpL0Jnrj50jJjUjyBRjGeUiSE73Nh5zwQxYgrQI+ArYB0UA8cAnQDygHOvG2NdOwYz25J2SjmIewpUqnrPZFFk7cjSIblKyEmN/7cIyfj1ZSQmjfPggEAJBiojEPGvTVNmQw5mHDDvlWwJH6TpIkCgsL2bdvHx6PJ9KWJDFu3DhGjhxJb28vdXV16LpOKBTq2wD8fj8ej4fOzk5kWSYzM5P8/HyysrIwf6MMjiAIgiAI/x4xPhYEQRAEQTj6RMBdOGaICcV/xvOry3lmVTlvTyshbc2NlM58j5WFrZx88sk0BO088spiJo8YyPH9Y9mwYQOnn346CV+rmw7Q+/wL9PzlXuQZMi2hHIakrqD30kqisrO+89yabnDmo2sZkRXL3acPO+I+FRuraNhbyJADK7Avmolt8kRaz5uLZcQMon957yH76l1dhEtKqOqOQynfj/1315Oyeydbw6UMjR9KeVcFD277CxISt429neGJI35QH7X729jWvI2tTVvY3bqLoBZkeMIIrsi9hJQXmzCdWINpwuNAFFrplYRfT8ByzTjkJOcPav+7lH3xJvvefYJTHvwISVEoWvw0gxZcScjkpbjjbgbGbsNhUpDln6P7TqFpxCiMg4ugSm43kt2G5HCi1dSAriOnpGCbMxv7SXNQkpNRkpKQY2MxNA1k+bAa736/n87OTjweD/Hx8SQnJ1NRUcGyZcsO2S8+Pp5FixYB8MwzzyDLMtHR0YRCIXp6ejCZTPTr14+srCxsNhsWi+WQzWQyHXGRV0EQBEEQvp0YHwuCIAiCIBx9IuAuHDPEhOI/Q9V0Lnt6E5qq87LrbiRPJZ/mP0x7h4fTTz+d5Qc8lDX3cPNkN23LHiR5wR8IGQqdnZ0kJydH2qipIVy0H7b+mpY1QfpNLoYz34YhZ3zreStbenlhbQXDM2P46ydFPHPFBIZmxhy2X/n6aoqWlDCq+GWSH7aguTvR2+sxhQdi7v/iIfv6P/6EjquvYefFTxPjNsh57CrcSz7k+toHmJc7n7MHnkNnoIO/bX+Ava17OXfQ+Zw98Jwf1V8hLcS25q28UvgS9b31nN0wmJmTTidpVD/C5b9AyTyAUTkIeYAXSZoETAJGA7YfdZ4vGbpOOOBFDfgI+Xr54jdnkZE1gkF6KtH334cnWE+s7TM0YyTP7t3O3MwhJLWaCO9rInzgAGrxAeL+8SQYBq2nnU54375D2necew4x99+H/+NP8Nx5F+YBAzANHIh54AAsI0diGTP6kP3b/W3YTQ4UXeHV3a+QHZ3DyMSRKIpCdHQ0AM3NzdTX11NZWUl7ezuKojBixAiqqqro6Og44n1KkoTJZEKWZWw2G06nE7fbTVxcHLGxscTHx2O32/+lPhQEQRCE/1VifCwIgiAIgnD0iYC7cMwQE4r/nNKmbi75xyZuGKtw7s55BEbfyHuekdjtdubPn4/JZILajRgvzUTKmkrR8N+zdvMukpKSGDp0KLm5uciyjNbSQtPosSRcEo0WNw3HrU986zmr27zc8dYu7jtzBL99dw8mWeKZKyYiy4dmORuGwTNnvM6kS0czdF4sO1/9iO6lW5lw9UJsk086ZF+9qwutqQklNxe9uZnmCZOIf+0VescPIc4WhyzJaLoGUqTEDMA5Bef9qL7Su7rovOVWHL+6neVGIa/teIaw3cLlSRcwbV883c/ciOO0POyDz8E09RPkhGLASiToPg04EUj4znN8kxoK8NGNs8g78Qxs0Qlsf/4+RvvSSMofQcwf/4Bks9Hia+HO9b/hqmFFjE4OUdeTSUdgCiOTbgQsBLUgcmklhs+P7vMSXL+ewNJlqMXFSDExWEZHMuMNvx+9oxOtqQnrtKnEv/QiemsrO+dPZ9nsJDaPdLJwk87schsv/mIcG5o2cvmQyzm1/8IjXnt3dzctLS3k5+ej6zqvvPIKgYMlb0wmEzabjSFDhmA2m6moqKCjo4NQKISu64e1ZbVaSUxMJCkpiYSEBBISEnA6nSIzXhAEQThmifGxIAiCIAjC0ScC7sIxQ0wo/rOeXlnGC2sqWDx+M4lb7qF10Rd8uLmS/v37c9xxx7GzqoPXXnmGPyp/QpYVasf/hb3eRBoaGnA6nYxNSSFl5y5qV27EE51Chz6IU9+4/jvP+WW98F3VnVzz3BbuPG0o80alH7JPb5uPVy9/j1m/nEbu5H4EVq2i/eILSdn1G5TYucAzwK+BQ7OfjUCAhrz+xD78EI4zI5n25Z5y/rL1T9w58S4y3V+Vu3m39B0cJgcn55zyvf3ke/sdOm++hZRtW1BSU+kN9fJWyRs07tjPzdXzaY/34X/pXjJm/ALbxdNRBvQAG4H1wHYii8GOIhJ4n4Huc6KWlGAZOfI7z9uway0J+cMx2V2suPdifC0NjPi0jIQ//wXnOZEs/bAWZknVW8BShiRUkhPtA6IxjAc58+N7scoWHGYHTrOFZIfBNSMW4GpM4MPPXqbdUka84cOzw4utSyW3wkdWrZ+6nCg+XpjJ7jyFtLDBZVE6I4f4CK1OxX7Oq7xb9jivFi1hZomNi5MX4Jg+HTkhAekIgXBN02hqasLpdOJwOLBYLN96v+FwmN7eXkwmE7qus3v3boqLIwvxyrLcF5BXFAWXy4XT6Tzk9cvseMe3rCMgCIIgCP8LxPhYEARBEATh6BMBd+GYISYU/1lhVefSf27EhMbzll8hdZRxYMbbrN5+gGnTppGbP4CfvbSN1sYafh/1IoM8XyDdWEyHHsW+fftIa2wk6ulnUCa2ous6G2tO5+QHL8SSkv+d5230+Nlb62FtcQvbqzp4+8ZpOG2mvvffu+1TWss6mFr9AoO3L8H78st4X7+fpM+TkaSfAY8Bg4BHMHQL3X/6M92DprJ+aQfj1/2BxGsvwX3dtQB0Bbt4peglLht6BXbTVwH6p/f8E4fZzvmDLvzefmq/+FJ0j4fED94/9D68jaxZ8T6zducRkMO84/gEizXMyFkXMThzBFHWaKALWA0sAzZjGDrhvTK+tztxXfMWpvSR33nu+u0rKXr/n4yafy0rnryV2JCFoU02kpcvP2KWt2GUI0mfoukXsaZ+OymOd+kXtQ+H2fu1ve7m7RI/sdY3mNmvhqAmUdhmwegZzOD6aeyorGVl8kYuTOkic7APZAgsC9L7dAC1PorExdBQK/HzxiQWvNnI8avbAVDy83FdcD720xeixMd/b7/+EF6vl+rqaqqqqmhoaCA9PZ2MjAxaW1upqanBMAx0XUfTtL5jnE4nNpuN6OhoYmNjSUhIICoqCrfbHfnmhiAIgiD8hInxsSAIgiAIwtEnAu7CMUNMKP7zihu6ufzpTVw3JY7zD1wMoV7WDf8HxZV1nHrqqdjdsbyyvpLPdjeidFdx3ZmzmTUwFn3700hjrkKXTXz2wbs41mxhivsJ/AOuJebCB7/znM+sLOPT3Q08cuFYLnhyPWeOz+KG2QP73t/+5l62vbabhadA0tUX4Ln7HoIrV5G85n0gFtgF3AgMA/5G88z5SBddQ1m4H+kv/5bo4ycQc8/dh5233d9GTU8to5JGAV9l27914E16wz2cW3D+IUF5AL27m8YRo4j+za9xXXnFEe+ns7WJ4MfFxNRCQAqxIaaYpzKXkB2Vw6ikUYxLGc/A2AJC77xIaNuDOBbFYBkdArOEJI0GZhHJfj88SN1ZfYD9j/+OzDfWIr/8JOue+AWZtUHG/uFZbMcf/539HPE4oACpQPrB12TARCTzvhTYgmFsBnYhSediGNdh8Bmy9CywAK1zCmpJG2ppGVprK6YBTdhnrcbf6yT8xVz0nS2EiotQ4hMJLl8OmoZ59Chc116LfeYMpK8FubWWFoLr1hNcs4bgps2YcrKJffghlINrA3yXUCiEqqo4HA48Hg/79u0jFAoRCoUIBoMoisLgwYNpa2tjz549h5WoiY2NJSkpqa/kjcViwWazkZiYSH5+PhkZGT+gPwVBEATh/y8xPhYEQRAEQTj6RMBdOGaICcX/jSeXlfLqhkpeOq8fuR/NQTM7+Sjtd3j9QU4//XTsdjuabrC9soMhGdE4a5ejvzKXRnMOJWP/ihq2UtlQi7klSG6TwfTHfvad5wuGNVTNwGkz8eyqMp5fU8Fr108hK94JQNHSUtY8sZkr3jkPxSTTOGIUGAape3YBBvAm4AL+SKRUywN8uUBp6xlnoSQnEff4Y4ed99m9T7O5aTOPz3gSs2zu+/kHZe/zctHLRFuiuHL41UxImdiXPe577306b/wZyVs2YUpPP6zNLxmGgb6vhdD7+9ADfg7kNrBmZC87WrfjCXpwmhwM2tnGGHsBU6+8h/B1V2ObqeC6NB3YfPC+xhAJvs8Aovva7rj9F9TsW0v2P16kcddadr36AEOlbIa98dl39vOPFzq4uQANkIFvq5VeBtwK+KntvpkHtn3GmQPPZoiRRmDBOehNTZHd7HaskydjHlSAZLPR8/e/QzCEkpGBefAgdK+P+BeeQ3Y46H3ueSwjR2IeNfI7a7QboRCGz4dksyHZbGjNzajlFRiahnngAJSkJHRdJxQK4fF4aGlpobOzk3A4THd3N52dnX0Z8ZIkYTabycjIYPr06XR2drJ7925SU1NJSUkhLi4OWZaPVgcLgiAIwr9NjI8FQRAEQRCOPhFwF44ZYkLxfyOk6lz2z430BlSeXRRP/Fsz8EYX8J7tcmJiY5k7d+5hQceNa5eStvYm+oWKWWycTNA3FH9uKmrIzryzTyMlJeV7z9vlC1HW3Mtzq8u56sR8RmTFYhgGS/+0hqbd9Zx371hMOTk0DCjAseh0Yh/4KxAALgJOBQYCNwN5wF/paXXh+cNfcMleYh984LDzabpGZ7CTBHsCrb4WJEkmwR5ZzLTJ28iTu59gZ8sOhsQP5eIhl1IQV0D7ZZejtbSS9PGHP6gv9d4g/r98hiy7sVw9inBzNdWxGtt9B9hav4Hy3ipkZPICboauqmLGH18lMyYGSVoFfAFsI5KRfgKwABhH4/QT2ZrpI3fhJQw5/VrW/+oCvNu3cMKjH2AZPPgHXdd/RidwB+3+M7h/84eUeUqRkMiNzuV402CmvrqbwJKlEA5DRjqdljCNjiBhSWfEnm4APj4lmX51QQaFEjBX12P4/SipqVhPPAHJ4SD67t8iSRId199AaMtWtI52CAQBiH3sURwLF9L77HN0/farbzTISUk4zjyD6N/8GkNV0RoaUDIz+4L4hmHg9XrxeDy0tbVRWVlJa2sriqKQmJhIIBCgu7sbXdcxm83079+fqVOnYhgGmqaJsjSCIAjC/1difCwIgiAIgnD0iYC7cMwQE4r/Oy1dAa58djMuq4l/zjXjfH0Wjckn8bE2k6FDhzJp0qTDD9I1AhsfR1l+BytMl5PaXkpJ5mikmES22KZx54KhuO3mw4876I8f7mdnVQdv3DAVWY4EQ0O+MM+f+yYOtYtTp/USddPP8L37HpZJkzDn5R480s9XC6YWo3ddCUaYjW9fRW9rHnN+M/177/eRHQ9T3FHIEzP+cUggdnvzNl4sfIHq7iomJo5jzm1vMeCSm3Bfc/UP7svwqgr06nYsZw+jacp03Auvwfmri5BMCh2BDrY1bWVz8VJ2dxUSssqkOtMYnzKBCakTGBSXjCIvBRYDVRhaMj1/K4cBt+I+9UraSnYRmzmAluOOx37cccT+7bvL9/znGUSy4A10YyZBTcETBIloUpwF1Lefyn1bniQluhG3NUhvSMZuSuK2wb+it8Pgtl1/pVnrxKxLDGyUGbK9hSnLGzCrBsgylimTsY4bh9bSgux0oqSlIUVFITudMHwI7TEKDc2lNHVU41acTGx2Ed67FyUjA+f55xEuLKJl1mzkuDgsY8dgGTeu7/XrWfTd3d1UVFRQUVFBW1sbiqIQFxcHgMPhIDc3F0mSWLlyJQkJCcTFxREdHU1MTAz9+vX7zox8QRAEQTiaxPhYEARBEATh6BMBd+GYISYU/7cqW3u5+tnN5CW5eWS6D8vrJ7Mv62o2BAYzdepUBn9bNrW/E8MWw74pp5Nzwmq6owZyiXEfUxJ9XHnyWNLSUo94WHtvEMOABLeV+g4fr22o4uaTCvji/lVg6Jx02wRkt/s7rvgLoBf/chXLsFcI2Y5DC16DK9H5vffqC/to9DaSF5OHJ+jh/dL3OHPAmbgsbjRDY03tal7e8Q/a9R5+O/BmxgyZ/b1tfunLX9FGhx91bwn6xm4sV41Fjnd8tY+q4m9pZL/cyJamzWxt2kJHoAOX2cX4lAlMy5jGiEQFGp5CjtuOZFdo2JnDmj/v4aS//BzLlkZq/vQCTfOnMO3XT2Gy2r/tcv6PqMDrgIfIQrGR16qua1hStYV5uRtJdxd+45hrMYzLaPWtIKi/xIGOIIXtfq7JuQd9Xzf31T1HT6CTmHAvNjWEFYPZFWYyonJ5N8vKhzE1fPmPoUk2cfHgS1iQv5Ci9kKe2fs0wxKHMcQ1gPwyL8rOfYS2biO0YwdyQgIpG9cD0PPIo5gG9McybhxKQuTbDl1dXVRUVNDa2kpPTw+9vb0Eg8FDrtxsNqPrOhaLhQsvjCy8+8knn2AYBoqiIMsyiqIwduxYYmJiqKyspLGxEUVR+rbExEQyMjIwDANVVTGbv/3hlCAIgiB8SYyPBUEQBEEQjj4RcBeOGWJC8X9vT00nN760jUn5Cdw/sh75rYVszLmT/YE0Zs2aRXZ29hGP63n+ecqeeo0hs9diloM0DrqGl9rGEWdRGTBgABMmTMBuP3JQOBDW2F7ZwYOfFvHoRWNp/qIMq8vK0LkD8b72Oqb8PKzjxx/hyL8CvcA9RAK+Mv5PluB99efEP78Vyfr9gXeAHc3beWzXozxywmO4LW68YS9Os5OOpx5nedUXnHb/25gVM2vr1jA4fgjx9sMXN/0mdWMt6uoqrLdMAt1AspsxVA31k1KUSZnISYdem27olHvK2Ny4ifUN66jvrcdtdjO6ycbYNWVMe/4WJGkFrUWFJA7qJtQD3jadPW9ITPrZJKyuEcB4YCiRBVH/GwWBHiKfWQ+QCKQAW4F/AhVEgvUA43i1aDLeUDtXjXjlsJY2XyxT4w1w3HUSCWMUDJ8MQQt6l5O60n68FZapdrehW720+8xMSprCbZN+jR4O01ZXQlLOEHSvl5bpJ6A1NgKgZGdjGTuWmHvvQY6O7ltUFyILtvb29tLb24vH46G6uprGg8elpqaSnZ2Nx+MhGAyi6zq6rqNpGpMnTyY2NpZdu3ZRWlqKpml924ABA5g4cSJNTU188sknZGVlkZubS1ZWlgi+C4IgCN9KjI8FQRAEQRCOPhFwF44ZYkLx/8faAy386o1dLBiTwe2ZO+D9i1g+8GGqfU7mzZtHcnLyYcf4V67kswc3MG/k77GYgqBY6LWm8FfjJjITYzErMuPHj2fQoEGHHfvrN3fR0h3gqUvH0VHeyc4XNzKydQmJf76X9vMuwDZnNlG33HyEK1UBBb27B7VmKcHEqRS+t4nxV/4RQ/8ZsuX8H3zPqq5ikk2ousplSy7mjAFncWregr6ga1ANcMXSy1g04ExOy194SDD2SAxvCKPVBzYFvbwTZUI6RleQ8Ot7MTr9KGPT0WyteO64naTPP0P+2p9vwzCo6q5kbf1aVm97i9YoiLZEMyF1ItlR2ZiXLydYtIeT/3w9ZksdUEGodzcWlxdwEll8dcLBrR/fvvDpfxsDaCcSeA8BUwEdWA9YDm5mIp/7UPQuL1rrYgzfPozeJgy1Hdndje9dA987ndhODhP3UDS6bhDsAKXZoLvKzmXhGBKDZi4YaOAmA7Mym/4VENq2nfC+fSS88zaSotBy8imoJaVIDkdkc0ZqytumTye0cyc9e/fRmJxETShEQ3Mzuq4THR2N3W7HZrP1vX753zExMcTGxqIoyiF37fP5KC0t7cuqVxSFwYMHM2nSJHRdJxAIYLVaDztOEARBODaJ8bEgCIIgCMLRJwLuwjFDTCj+//lwex1/+HA/V52Yz2XGq6irfs9nBU/RETSxYMECYmJiDjsm7A/RMmYwKQuqUKZeDa1F1ERNIG7OXWzbugWz2cyUKVMOC1aXNfdgVmT6JTgp31bH4kfWM1DZzilP/g7ZbsdQVaTvWKgysGY5pvyfo5rmsfjuscy5I4nYjHFEMr07gLgffN+qrrK+fh05agyZKQNZ37GNfW17uWr4NQTUAIokYzXZeHbv03SHujljwJlkurO+vb2djWjrqrHcMAFtbTW4reAPo66thrCGqtZju/B4THnphx2re700DBpCxx9vYfsIF9uat9HobcDu8RHVHaYxw0UibtJCDgYu2U3yjAlMOrMAh3kvsIdIYDoFmAssPPjfxw7d34TRvQ3dXwrBWoxwC4GGMBuWS1RFtXPhbR6cNoPeoISyOhs54Xr+GlqDVbGS5krDXlpHuKeLKZ0JuHs1tpsbqBqbgRQfh21HEfb3lpJZ7SOlJYjeP5/Os86kd+RI/B4P3qpqgrJMUJYIAtrBa5Jlmbi4OBISEkhISCA+Pp74+Pi+hVi7u7uprKzEYrEwaNAg2traeO+994BIGRur1YrT6WTBggUA7NixA1VVsVqtfVtycjIOh+MIPSIIgiD8LxDjY0EQBEEQhKPvv7VWgCAI/0NOHZNBW2+Qf64oI37+pSwYdoDZxbfzYc7DfPbZZyxYsOCwoJ6ihZDdiQRqGnFUrEa6YS9ZugaKiXzvOtToHGAKe/fupb6+nrFjx5KYmEh+cqROezCsoUVZcXWHeW3AdAo6AuSn278z2A5gGTMRrfVvWBOHcfbfYwisehdVT8OUFQIuAa4ALgK+P0PYJJuYnnk8HddcS1tTM4FHrsUX9iFLMg6zg/reetJd6aS7Mlh34HVW1a5kQupE5mSfxMikUSjSoecwjUpFGZGCJEkYnQEkRUYZnYp2oA05xQ37zaivlaIP78Y0JQs54atSM0YwiPvqq0iZsoDh2dlcOvRyNEOj3d9OQ3cdZU/eT7e3mZoB8VTlxSB9sIK76nbjGZHPsIT5TEqzUhDXSpTldSTpeWAKcAYw8Qf1xU+dbE8B+7xD7tQyFE46WI7fMAwCVZvROh/CeVw5au3NOF5NpLkghX3u3Xjxo0QrjJt7JdExeTQWvUxJ2xfMiWpBnR4gNDUam2UwiT1x7P7IweOpK5nq3o5MDEbxVlIbAkzZ040RCqElJWH5cDFtbW00fPY5Tc3NHFCUyJKzkkRCQgLJyckkJyeTl5eHy+UCwO12M2fOHAKBAMFgkEAgwNefube0tNDZ2UkwGCQUCgFwyimn4HA42LlzJ0VFRbhcLlwuF06nk5SUFPr164eqqnR0dPRl4JvNZrHwqyAIgiAIgiAIgnDMEhnuwjFDZPD8/2UYBg9+WsR7W2v5w+kDOX7LefR62vgg+Q5sDhfz58/HYrH07R8sLuaD695m+ugXSHZVwDW7IWU4hq6z+4EZjPStwj/gDJpH/YbNe0ro6uqiX79+jBkzhoSEBB74pJCtRc3cN6Uf92+pp7O1lYc615L7+EM//Jo1L1rjVPT2qVhGPESkNvjzwFjgXiJ1w79fuLwCvaMD67ixfT8rai/kl2tv50/T/srg+MGEtTArapfzUfmH1PRUk2BP4MTMmczsN5MU55EXigXQO/2oH5dgXjiIcGEN6tYDyKFYCGlYb52MZFYwdANJ/u4A6L53nyQ2oz/pE2ZiGAYbX7iX6s/fIDR3FvuzzZR5ylB1lSx3AhcNTmFUUgVmpRJII5LxPpNI1ruoF27obYT2for3mW2Edn2G60oLRlc/rNMTMeWHkOzDkaRfAy3A9YANzQiDoaHIFhq9D7C8+gvm5z1DtNVHQ6+ZovZ4ZvS7B8MYwfXLbyTGGkOaM5WYzzeRsL2cvD1thGMS6Ro2FN+i02np7qanpwcAezBIvM9HdEwsUUOH4kpLxW6343A4cDgcfRnxX6frOqFQCLPZjKIoNDQ0UFdXR29vL16vF6/XS05ODhMmTKC1tZX333+/71hFUYiKiuLMM88EYNeuXQA4HA7sdjt2u53o6GhRW14QBOG/gBgfC4IgCIIgHH0i4C4cM8SE4v8/TTf43Xt7WVHYxEMLMxi3fC4d1mw+sF1EUlISJ5100iG1pbc88DHShucYNWwlpn7D4NLVIEl09gZ58cn7uNz3d1ySD2PQmZQN/y07du6ku7ub0047DcURzZonNhPesIdhGVXc4pxIul3iyTsXYjHJ33md3X/+C5bJk9lWaMHS9CyD0jNxX3EnEAZ2A3cRqQt+DzDtX+sLQ2NzwyYmpk1ClmTW1q1hWOJwoi3RlHpK+KJ6KWvqVuNX/czPPZUrh1/9vW36/7aC0K7N2O85F8WIQsmLwwioBB/dhJHpxTxpIEpmFpJy5PsPdHew/bn7GHXRL7HHJrH9+fsoXfo6E6/7IxlTTqGoo5BVtStZ37AOv+pjdr8MTss3SHftR5JCROq7f7l4aRqQenDrB+QCsd9zB0GgBqgDRvBjyvf8t9K9y5GUe5BsftRqjdDOMKFtNgzvcViPPx7rtGkocd/WLz5gC7AOw1iLJLWj6W/yevEGZGk3tT2d7GjuxK8Fear/3UTvKuP97jWoE0Yyvt9xxL+3nubSUtptdtqdDnyKQjAqim/+o2+1WomLiyMuLo74+HhiJAlH8QGkqipMA/pjmz0b6TtqvquqSldXF36/n0AggN/vR1VVRo0aBcBHH31ER0cHwWCw75i5c+eSnp7Orl27KCkp6XsAYLfbSUtLIzs7G1VV6ezsxGw2YzKZUBQFk8kkAvWCIAhHkRgfC4IgCIIgHH0i4C4cM8SE4r+Dqun8+s1dbClv58l5DgZ/djINGYv4NDSFfv36MWPGDGT5q4Bw+/U3IJUvI+5ns2DWX8FsA6C6zcstT3/BiepSFubrpJ/7FJ7uXtrWP0/etLORXEl88PJHhKu76UpwEffi0/xtzo2c1C+Oa07MJ77ftwd/W087HceZZ9CaP422e/5A/ogYYv70O+Ay4DQi2dy/A9YC5wA3AtYjttX1xz9hSk/HedGF33o+X9jHlV9czlkDzmZB/ml4gh5kScYqW1jfsB63xc24lPEc6Chmec0yLhlyGQ7z4XW1tQ4PzROmEv3z36F4krBePQ7DIqNta6D91gtwXnEhtuwT0cs7kPPjkQfGI2dFIx3s70BXO8vuvoDjf/1PrO5YTDYHW5++m4qV7zH5pgfImnQyAEE1wKamTaysWcGulp1EWSVmZKWTG20n1SURbwvjtvSgSK1IUguRxUohEnDPIRJ8zyGyKGsVkYVNKzGMeiQpsm9Yt6BIlyNL5wO2b+27n4YgEMQIWAhu2UJw5SoCq1ejHigBScI8aBCW8eOwjB+PdcJ4lJQj1cfXgTKgP5EHGxcCRRiGk7A+ELM8Gkmax4v7l7G69nO6Q93YTVGMTh7Pov5nkBWVhd7biwGETSaaH3gQz+dLCPfPJzigPx5NozslhR794Gel6zg9Hpxtbdh1g+jhw4mZOAGn09m3WSyWH1U6RlVVAoEAPp+PmJgYLBYLNTU11NXV4fP58Pv9+P1+cnJyGDduHC0tLSxevPiQNiwWC5dccgkAn3zyCaqq4na7iYqKIioqioyMDBwOBx6Ph7a2Nrq7u/u2nJwchg0bRmtrKytXrsRisWC1WrFYLNjtdiZPnhz5tILBH31vgiAIP1VifCwIgiAIgnD0iYC7cMwQE4r/HsGwxm2v7aCwvosXTvSQteRsqobfybL2zEOC7sGSMvaefzt+u5UpV/uR5z0G0Zl97dS0e1m5v5mZQ1NIj3Pw+jtvs2jf+UhAVeJsdjCTLpMdHQlTfStxU05gy2u15EQ5uOrReT8ooNZ2wYVIVivxzz4FvABMJxL01IG3gEeIZHP/Hhh8yLGG30/jiFG4rruWqJtv+s7zdIe6sSt2zIqZF/c/z+q6VTw350UAVtauIC86nwZvPYvL3ucPU/+ELMmsrF3B8IThxNsT+tppXbAQOSWT6Mt/gTIunfBre5FSXCiTUtCrPGCyYJS0o5W2Q08I7CaUAQnIBQnIubFoeqR296c/P5UBJ53PgJMvZPMTv6Z6w2dMveVhMsbNOOS6OwIdrK5dyf72fdT11NHkbUI/GGB3m91kRqUxND6K/rFmMlxh4uwebEojklQNqKh6Aq0+J8UdQfa1e2nyOoi25lEQt4u5OX4M4jHJNwInA9/9zYSfGq2hkcDaNYQ2byG4eQtaVRUASr8srOPHYx42DDkxESUxIfKakIAUHX3wz20AKCSyoO3ug68PAiPRjYeRpVci59BBkizI0iKe3xfL3tbVTE7vpqnXRXOTzMg9ElOX1ePLz6B2/jj6TzsNyaPS0dpKZyBAV309vY1N+G1Wgt/4+2I2m3FaLJhsCkqUHamzheC6lcR6/QxLHUTUccdjnTwZ+WAN+R9LVVU8Hg/hcBhN01BVFcMwyMnJASKlajo7O+np6aG7uxufz8f8+fNJTU1l48aN7N27F6vV2heMz8nJITc3l66uLgoLC/tq1YdCIaxWK7NmzcIwDF566SWAvqx/t9tNQUEBFouF4uJimpqaCIVCfdfTv39/BgwYQGtrK1u3bkWSJCRJQpZlnE4nU6ZMAWDz5s1omobD4SAmJobY2FjcbvchDxgFQRD+r4nxsSAIgiAIwtEnAu7CMUNMKP67+IIqN728neq2Xl4du4PEdb+getKjfFFrJysrixkzZqA3t/DiNZ8hKypnjf87jsEnIEfFwgm/O2KbFS297CwswbL/FQraPiJfL6daHU6dspBql4NArBu3I5an9zm4adEw5o3N/s5rVIMqZTfdh7N+P5kfvf21dzTgduAUItnafwB+DhQccrx/yRI6LruCpNUrMefn/+C+afW10OxrYWjCUHRD58LPzuesAWexIH8hvrAPk2wiqAW5bMnFhLUwI5JGMjV9GhNSJ8Jjz9L7zLOk7t2NpCio2xuQ3BakJCehRzdjPnsoksuCVtSKnB+HXt6JfqANo80HZhk5Lw7TaQVUrH2P5CET8He04OtopnbLMqIzchl+1s++89rDWphGbyN1PbXU9dZS21NLfW8ddT11BLQAAGbZTIY7FUMPUtXTjN1kZ3zKBCalTmZ08hhsJhtF7YW8UfxnTsopZ1JaAMMYiCTdQqR+/v8mrbmZ0JatBLduJbR5C+GSEji4eGkfsxklIQHz8GFYJ0/GOmkSpkEFB2v0G0QeShwg8q2B8Ne2XDY2qHQGVjM7ezEmWQMgoMZgM01lQ8Ms/rTlD9wxwYPbImM32XCZnSQ6phFUz+KPW57G4++kt60dFRmrYeeMpUF02cKBiXkEZRN2zY7FOLgOg6HjamvHJuvYp42hf2o+cU1tOAwDvaMDvaOdkBamc9EJeIIeePsjck3J2AcOwlxQgJyS8qMzzFVVRZZlZFkmEAggy/Ih60L8EIZhUFVVRUdHBx0dHXR2dtLb28uiRYuIjo5m27Zt1NfX95W5kWWZ3NxccnNzaWtrY8eOHX3t6LqO3W7n+OOPByKldQKBAL29vYTDYQAWLlxIYmIiJSUldHd3k5iYSFJSEna7/UddtyAIwr9KjI8FQRAEQRCOPhFwF44ZYkLx36fHH+b6F7bS1hPgjYKPiNrxMNVj7uOL5mQyMzOZOXMm3lYf+z85wL4P9nFG/nPEzhoFJz0M3xOM03WDF898mhi1kon1y9lwylxmKI8QY3TSIqfyUfKdJMXYGT/9ZJK/UcKj+4EHCW7eguMfz/PKpe8x3vMpo1a/9rU9AsCfgblEAsAGkTIfKvArIuU+RtBx402EC/eTvHzZv9VPmq6hGipWxcqL+19gU+NGHpvxBAE1wLr6taysXUFReyGSJDHEks3QF9Yw4+ePkTQuUl++48abUNLScF9xA1K0Db20HXV9DZYrx6Auq0ByWZD7x6MVt2K0+bCcNgiA4DPbqQvtorJlFcf/6hlUNYDNFU3DztUkDZmAyfLDS70YhkGbv4263rq+YLxu6ExImciIxJGYlcPrcoe1MG+VvMH+tle4aniA7GgvMBLIBBK+tiV+7fV/p763YRgY3d1orW3oba3orW1obW1oTU2Etm8ntGMnBINIMdFYJ07EOmkSlvHjMPfvj/SdAVuVSK38EqAUCGEYt9IeaEc37sUfbqcn7MUsKwyM82EYL/Lnrc8wKM6HoaWjFHpw7KtgZOwwnMNG0Nk/DVfCu9hNm9HVJjyeGNrb42mrPYmS5l7UoIqkfxn41jDJPqLbPBgBjV0DQ6TEdBOUA3jDYRyVPSx4uhKrZCbxpRewjxhJcNt21C4Pneku0vIGIJvdvHXgXZq8+zGQ8KtWJCRmZ89hVNJoCtv3s6tlJ7nReeTG5JFoT/zO4L1hGBg9PUguV195pf8kwzDw+Xx0dnaSkpKCyWRiy5YtFBcXEwhEHkq53W7Gjx9PXl4e4XD4kJI7fr8fu91OTk4OwWCQNWvW9GXVf5lZP3XqVEwmE2VlZQQCAWw2W98WFRX1ox9ECILwv0uMjwVBEARBEI4+EXAXjhliQvHfqdMb4prnthAMqbw0YgNR6+6gZshtfNE9iPT0dGbOnEnwQAXv3L6MFGsNs38/GmnoWT+o7devXkxGfze5D11C7FNPsW/AcDau+pzhoY1Y/W1UuSbRa4onJj6JDIef8SecisnmJLByJWpNLc6LLqTx0efRHv0TGWUHviNo93tgNDAZuAP4GUYwJ1JO5qoribr1lqPTWUB9bz1VXZVMSZ9KWAuztHoJM7Jm4ld9bGrcxIb6dext3oUhS1wy9DJOy1tI/fDhuC+7jOhbbz2svfDySMBdGZ5M6OntmBcUIGVEYRgG2upqlPw49GQLvct2I2/tRE5zU1H8ObHjRpExfz6S+8i164+mqq4qHtv1MMmOvZyW7yLOpuM0+7EoPciS9rU9JSAeSCaycOuXrxlEAvX/W3/vjUCA0I6dBDduJLhxY18AHklC6ZeFecAATAMGYB44ENOAAZiyMpHc7h+ZOa4TyZo3iKxf0ACMO7gVEvl2h5nImgYKkb8DMUAjMAXdiKLT/3fC/lV4uxS8Xhc+nxNv7xB6e9Pp7m0j6A+h64cvyqqjY7WGsFp92B1+3E4fTocf47MQ+wZmkju8hin5RRhSiBaPCUuNDedKF9uDybw9qZtERzsGYNPNDJUyODnqBHw96WxL9RPnrEfbthmjohy6u8gp6kStsOO++be4zjoL3edDMpmQfmBgOqyHaextpMnbSKO3EU/QQ7Q1mtPyFwJQ3FGMWQa3JUS8LQ9Fdh7+eRoGvb29NDc309LSQm5uLikpKezbt48NGzb07SdJErm5ucyYMYNAIMDy5csj/aXrkYcHhsHcuXMxmUwsWbKE2tpa9C9r8wPHHXccBQUFlJaWsmXLFqxWK1arFZvNRlJSEiNGjEBV1b5zfhnIt9lsDB8+HIvFQnd3N7Is43A4REkcQfiJE+NjQRAEQRCEo08E3IVjhphQ/Pdq6QpwzfNbCKs6/xh7gLTV11ObezFLg5NIsVrRn96NHptMavJmRqWvQJ7wM5SsYTB40be2aRgGz531BiNGmkh94lZSdu1ASUyk55FH0X0+2i65jt7OBj7e2Ui6Vk+KZxPTO56lKO4UfP3PYsjEWcTExOL/6GM6r72O1MJ9yNHRh51H7+pArbsRJWUeSvy5BDdtILR9F1pjLbYTPsY89GqU5Kv5T2Re727dzb0b7+aREx4jw52BpmsoskLVtZexw9XO8DseoF+Txrt3n82qC4bz2NznMckmdENHlg4Nkhm9QdR1NZimZKHta0Hb3YTlqjGgGUhmhWB1C+2fryUhqj+himZMWuR+DKeCkhGLnOZGHpqEHPufKYWhGRofl3/E8ppltPvb6An3IGHgshjE2TRSnWYy3VZSnTJJDoM4W5goix+nuQdFVjEMGUkqACYQCRaP4NsWuv2pMgIBwoVFhEsOoB4oIVxSgnqgBK2xsW8fyelESU09uKVEXvv1wzp1Cqb09O85Qy+wDPgU2AsMJxJoP9Iirz/4qjEMlWCwg2CwmWCwjWDQT68/l+3124lT9qCF7IT9DjSfFdVnIhAyEf7an1+bFCDG3kVcfCfutjDu1lziLx+F1XoHFksIWY4Mc9RqlX3ze/jtvQW8dHILMdZDhz/e1+dwX0wX0wpqGRvbgb/Sj+RxE62mIlfHURs9jJaJsUTpG+kuKyYgaSSHbRSoGRzoGshvHUuZ1c+H26wQZbWRYDc4LqMAuJHLltzN6f0rmJfrx69K1HTnkeq8jCjrDCIPKr6dx+OhtauVkBzEJ/nJiEkn1ZVGUXshn1d9Row1lmRHEkmOZFJdaaS7Dv0cDcMgHA4TCAQIBAK4XC4cDgdtbW1UVVURCATo8XUTDqkkxCUwYeIENFXjk08+6TveMAwCgQBnnnkmFouFzz77jNraWgCsVitms5mxY8cyYMAAGhoa2Lt3L2azuS8YHxUVxejRozEMgzVr1gD0lf9RFIWRI0dis9moqqqit7e3LxvfbrfjcrmwWv+3/q4Kwn8TMT4WBEEQBEE4+kTAXThmiAnFf7e2niC3v7aDylYvf5/UzLBNV1GXfApLpDm4giaGF0yi7JG36FYdnN7/b9gyDKQbD4DVfcT2Oms9vHXDxwy3lzDAXkf8888B0PvPp/H7AlwcHsqpozO4ZkZ/dF1n/YZ1BHa/SXLPLjbFXQyAxWzGYVgx1fVw2k3nIEdHU1xc3JctahgGRlcXjptuJv3RR7BOmkRoz3mES4roflAl9s+J2I7rIbKo6rXAbI72wp/doW6iLJGM9NvX3MqUtKnM2uCl667fkrp/L7733mf3M3+k+R93c/rgc9AMjauXXkF2dDYjk0YzMnEU6a70Q7Ke9bpu9MYelLFphJ7YgjIyFWVyJoR1dEnji7vOJX/i6cRHDaB28fukZ0zAacRhPmsoSk4s6rZ6jIYezKdGatob/jCS/eg+cAhqQToCHbT722n3t9EeaMcT7MQT8NAV6sIT6MQT9NAV8pBoVxmeGGJsMgxLCOCyhNANM7oxDJM8hEgm/Nez4mOJZMv/b9C7u1FLy1Dr6tAaGw9uTWiNjeiNjWhNTWAYmPLzsU4/Dtv06VgmTUR2OL6j1S/LKP3/oaoqPT09dHZ29tVa7+jooLu7m28Oa8xmBYvZhEWWsJlsRCcnEx0r4462445yYHWYibK6gXiWVa8ipH1BrHkfdksXCQ6VZFkj+J6Nt0LDKR1Qxr2TO5Clg1WtdNBboHaWD+/KNymI/y2yvw4jqKO3y+geC77FmXgXXIVeoONr2E6PsZPMzBpSXCHgVrY19SfZGUemOxdV16jtqSHTnYVJNvHs3qdZXbsEm6kHswJm2WBB/lxOyJzBnlaNV4teoX9sOWbJg9OikumOZkJqAZp+Hbeu/hsTUjzkx/YQ0hyENCeT0uZiNw3ljeKtFHdsJtZai0/tBklnTr9ZjE6ewMoag6f2PMGw+Dji7anE27PJjR7M2JQcfGEz75V+TKxRSJzUihw20EIWZKMfOf3GkJw8i/r6evbu3Us4HO4L1sfFxTFt2jQMQ+PDD9/DMDR0XUHTIpn5c+fOxeVysWbNGkpKSg7JyB87diyjR4+mtraWVatWYTKZ+rbo6GhOPPFEANavX48kSVgsFiwWC2azmZycHGw2G9XV1bS0tPQtkhsKhcjKyqKgoICenh6Ki4v7jrNYLJhMJrKzswEoLCwkEAgQVIOgg4TEkCFDcLvdVFZWUldXh2EYmM1mrFYrSUlJZGRkEA6HaW9vx2QyoapqX39kZWUBUFxcTDAYBOj7/ZudnU1UVBRtbW20tbVhMplQFAWTyYTT6SQuLg5N0+jq6gLoe6AhyzLuH/3tFUGIEONjQRAEQRCEo08E3IVjhphQ/PcLhDTufX8vK4uauXuclzn7rqTBPY6l9rNwOJyMlhysermNIb2fMGn6h0iTfgZzHjhiWzXb6/ns3pVMzO9gxIOHL/S5vbKDgtQonDYTAA9+WsQ7W2q4cHI2EztXEfj8Hazn/Jz91W1Ee3eTlOymK3EctdX1GIaOZBggSRjAxBNPITE+Dj3QS1L8FsxmFVhApFZ2OfAPYA0wALieSNmNoxsY0XSNTyo/Ji86jwI9iZL9a2jKjmbYA4vRq2tJ+vhDIBKo/rj8Q7Y3b6e4owjVUEmwJzIycSQjk0YxInEk0dZIJr+h62h7mpGTnBgBjfCbe7FePx6ttRejN8y+va9QuWoxQW8XcdkFjDjvNlKGTULb3YTe3It5dj6GphP841qwmZCTnEhJTqREZ+S/Ex1Itv9szXXd0Gn3t1PuKaPUU0JpZwlBbT/9Yz0MTwyR6TZIsKmYla/+KdQME6oWjywNwKwMAfoT+exSOPxz04EuoJ1Ibf/BHO2HKv9pusdDcP0GAqtXE1y1Gq2+HiwWrOPGYeqfjxwdjRQVhRwTjRwdjRwdg5wQjykvD0n57uzs/2uqqtLV1RUJkAaDhwRYg8EgPp8Pj8dDd3c3mhYpR6QoCjExMTgcDux2+yH1zoNSkISoeOJi4lHMCoqioEiH37OhaX194V+yBLWyKrI4bHs7ens77ltuxjJiBN0PPUzPAw9iAJZRVgxSufviVGaNaGJ6RpiwrmMzGUTJEqGVaSzfGY/r/IEcn/nmIefTvW6Ca3+JZfx4lLgLMVQPaq+M2iOjtBu0PSHz7sR8hs8yMTC2BLvkw2HTMCsGes983qnNR5X2cd6gL75xJ7HU9jzLtqatnJj1d6KtvYe86w//jRtWPMfJOb2MSuqmOxSNpsuMSbYiSbN5v9TB6GSZLPdSJGkEkQczjUQeZF0HeICZX/WbEY0kZdDY+xvqeruwK4U4TAGssh2LZsVQFez2objdg/B4tlJRsY2wGiAUDmBoGna7mxJXHN2hZlIq/QSCNsJhM1rYQjiskDklnuVtGxjus6C1JSObQlgtEtEOG0mZydxX/iqj7HFkNI1A18zoYTMg4XRCZV4jlV3lnNAxDDVkQVE0FMVAkcFREMUrtUs41ZGM1JYJEhiqFV21kp0bxXpzDcmGTnh30iH9ZzYbtA/rorB9PzO6BhLojcJAQkYBZAZPzKZCakVpCNJVrh5ybE5OGqG8yDdZGtZ1HPZn8KJLL8Jm/uHragjCl8T4WBAEQRAE4egTAXfhmCEmFD8Num7wjxVlvLi2gksHB7mq4Ua6iWap+1o8IYmoHe2clPAo5m4v9uQg0rW7IWnwYe3U7mzg03tWcNZvxxIzeuC3Zv619QRZd6CFU0dn8NK6Sp5eWUZugoO7xsfSf3g++4t2Yf74GvLVPSjoeA0HleYRxD5Vh+/G27jGl4UXB2BwZnIDFlln5NBBDBk8iMquf5AZv4va9r8zNLMOq+kJYBeReu83ECnJ8Z/x1oE3WVm7grt+tRPnglMpvXIOA+IGEmX56s++X/Wzv20fu1p3sqtlFzU91QCclH0y1428gbAWpsFbT4Y7E7lHRdvfgjIxA3VZBXptF+qpKeivHkBLNbPii1+TJOVhZDkYct71xOUOAcDQdPSSdowWL3qLF6PVi9Hui8ThAOwm5Nw4LIsin6G2uwmpXzRyzH+mNA1EvpnQ5GuitLOEJm8jbf42/OEGDJowyW04zD2kODWyo8LkRuu4LJHArKrb0Y18zHIUktROJMjeAXy9jvwY4C4ideN/egzDQC2vILhmDcE1a1Dr6jG6utC7ujC83kP2lRwOzCNHYhkzGsuYMVjGjEaJi/v/dOU/jq7r9Pb24vF4+ja/308gEOh7DYVChxxjNptxuVy43W6ioqJwu93Y7fZDMqq//t/fVttc6+hALS1FLS0jXFoKQwuoPyGI5vsUZU85zi6F6C4zVEdjdGUR99RfgGK6//II4ap69JYutKZOtEqVhHfewjppHN0PPYbvzbdQkpORk5NRUpKxHX88thNPILRjJ+0XX4Le0YHklEAByZpA6q7NQBeeO+4GXUJKSEaOioKQGcfpC1FSOwjtXYdaU4RhCSH5XWjt6Vj6j8U6dQp6ZyeBlauQrFakqCiCbiu31j9KvLuJCwbpDIgNIWHGasoGRnPvxjZKOw+QH9uKLyyRaNc4b9CJpLkMXi3qx5sH3uSvx3UwMC58SH91B2/m3k3bmZDq4YTMA3gCBl7VzIjE6cBg7t5QSEjrYma/BmyKjlUxGBiXhctsYkPDSWxv3s9xGftIdbYiyxJ2xYbL4sCnLmBVrQm3eT+D41dhoGEYBrGWRCQpj48qR+EN9zIxdR2y5EDCTZIjDYdZodwzlr1tVaQ5txBnr0YihMtsI9kZhzc0lT9v3UOKvY0TkhowdBlkg4zodCzmRFY0jKMz2MnE1LXYFA8muYc4m4FZ6WZzw9U8uWcZ5wysZXY/L5qmoGkKqmpCNU7hspUbGBAV5tbBBoYhYRgSui4DLmyxjxNn/2n8/RP+u4jxsSAIgiAIwtEnAu7CMUNMKH5aPtlVzx8/3M/0tDC/03+P0bSHz+230xidTkpdBaM/f4+UE+pRUpORzv0Qkocecry3w0ftSx/jfOAXpG5ahynjyAHQtzdX89K6Sl67bgpuu5nihm7ueW8PDZ1+rp3Rn7MmZNE0YCDun99M1MlDCa15Dd/7b6NnXoT7z/ejPJCAZo3B7+xHk30QpfJAOuRU/IEgkknCmVzIhi3J5ESbiHGYiEt04HC1kpxcyYDMW3DED/mP9F9w3Xpan3oMaeU6bM8+zhXBZ7h2xPXMzp5Dm7+NoBY8rNZzR6CD3S27cFlcjEsZT2F7Ib9aezsPHf8IeTH57GjejmZoDIwrwG1yIcky6o4GvKE2tr56L1MSr2d79xuEOtspyFuI+6LJuOLSwWZGkr964GGoGkabL7J1BsCiYJqQgRFUCf55HebTByEXJKLtakTbUIsUY+vbiLIi2UxgMyHZTJGfH+Us+ZAWosXXQmVXBRVdZbT5CzGMEpKdXeREqzhMZhQpGbclm0RHAW5LDpHFWj3AX4kE4q8Hzub76nP/lBiqit7djeHpQmtqIrRrF6Ht2wlt34He2gqAkpODedAgTFmZKJmZmLKyULIyMWVkINl+Wtm3mqb1ZcV3d3fT09Nz2PZllvw3SZJEVFQU0dHRREdHExMT0/dqtVr7FiL9V0uAGLqO7vEgO51IP7C+ue7zodXXo9XXYwQC2E86CYCOG29Cq65Ga25G7+kBSSLh1ZexjBxJ9wMP4n31tS87BCMcxnH2WcTcczeh3btpPWXeodcV5aZ9zWssr17GhqqVoOs8+kgvJoeDTydasZwwndT+o3Dtq4QtO0jXo3GaHPgcCsag/rhnnoC/t42mreuwRyWSnTSEDofOm42f4FN9JNoTSXGmkupMZVTS6P+xEipfDscloJ7Iw7yviydSnqwXKEU3whhGGFkykCQTujH+sLU5BOGHEONjQRAEQRCEo08E3IVjhphQ/PTsrOrgl2/sIs4u8be090nb/3dK+l3B2vA4HM0tjFy6mP7H16DYfEgLX4LBp/cdu+uNHex4eRuLpnmI+uXt3xqYMQyDbn+YaIel72eBsMYjf32T94PxjMuIYfjn5Zxw3ViyEgO0nXEWlgnjiX/uWSQ0KHoX2kugoww6yqGjDP3GMqqbO2le8Rjjah9BQWPXwIV0RPUj0N0fovtRX1fL8R3PIUtB9JkDqPAsInvQyQxMi8YbUGnpCaDIEookocgSFpNMnCsSWKts7UXVdFTNIKxFah33T3Fjt5j67sH/xTI6LrkUgJS9e+hyGNgUG45wgOL3zia5eh3uGX/ENPHmb+3/oBqgpLOEwfFDUGSF+zf9ns1NmwDIcGVQEDeIgrhBDIofRIotCaMnwIo/XUZ2vxnY6qHCvo2pebeAImE5exjqljrkvDjkeAfegEqXP0xqtBV8YXCYCb+5D3lwElK0lfC7hZhP6o/e2IPhCfRt+A7NfjXNHYBpTBrqjgbU5RVYb52MpMioa6sxfGEklwXJZQGXBcltRYqygNX0owN1hmHQEWinoquC/e372NO6m3JPOQYGqc40RiSOZGTiSMYkD8Jqeg54ExgG/BbI/lHn+qkxDAOttrYv+K6WlaPW1qDV1YP6VVkMOTkJU24eprw8zHm5mPLzMeXlomRk/NeVpvkhDMPoq8399dI1oVCIQCBAV1cXHo+Hrq4uenp6Dqst/6UvA++KopCUlERKSgqpqakkJSVhMpmOeMx/A0PXIRjECATQe3oiD2P8fqzjxgHgefVlaGlD8vkxfD4MrxfXVVdhHjwI7+tv4H31VYxAACMQhGAQ2+xZxNx/H+GyclqmH3/oycxm0spLkRSFtvPOJ1xYFCmiLwGSTMx992I/+WT8n36G99VXkRxOZJcTyW7HPGgQzgsvQO/poeu3d2PoBugaksWCHBuL+9ZbkB0OQrt3Y4RCyNHRGMEgRm8vpuxslNRUwsXFBFatAlWLZPTbbCjp6dhOPAHDMAiuXYdktyPZ7cgOB5LdhpyU1Pfn2jAM0PWvNkVBMpkwDON/7KGB8FMkxseCIAiCIAhHnwi4C8cMMaH4aapt93Lf4n3srvFwUWoJV7beRXs4ni9iribssDNk6RJGZOzAFtcI85+GMVcAsOut3XRsP8D0W45DSUn53vMEwhq/e28vxw9KYs7wNNouvJjC8TN5IJRFel03d56Rg3zdhSiZGSS89eb3LCh5UPNe0MJgjwV7M1gKQb4MgG27d+Hd9ymZ2hIqEsdTW5NBvNzNsJnncaBwN8b2p7Fr3fhtqXQ5+qOZnCTkjyM2NpbXVuxkpz+VIF9ltr5y3WT6xdl4ZlkhW2v9pETbSG3ZjdHbQ9rwgWTEueit2srg8oeIVptZa5lKb8pMhp1yGe9WPckFgy8mKyrrO2/HMAyafc0UdxRR1FFIcXsR1d3V6OjYTXay7Oksqopl0EkXUVRbQsBnEOjWyJRlWna8w3j7xVjnFuCzKlS8sZffqCHudDvo77AQf814tM9KkfvHISe5UHc2Yjo+G3VpOVKMDdOEyDcUDE2HgIoRUDF6Q+hVnSiDk9AOtKGtqMR622T0sg7UjbWgGxjdQQh9IwvZJCO5LVguH4PkMKNub0AyyyjDUzBUHb3ag+Q0Izks4DQjKUfOGu0J9bC3bQ+7W3exp3U39b31OEwOpmUcx/zcLDLdLyJJTcBVwAXAf2/w9D/B0DS0pia0mhrUmtrIa3k5ankF4YpyCEQWjMRqRUlNRYmPR46PQ46LQ46PR46LQ4mPR8nuhykvDzk29icbnNQ0jZ6eHjweD6FQqG8x0a9voVCI5uZmmpqaCIVCyLJMYmIiKSkpuN1udF0/bANwuVx9mfR2u/0n20dfMjQNvbMzUgO/owO9oxO9pxvn2WcD4H39jchCvwAHA9n2+fMwDxxIYNlyvG++ieH1Ynh9GD4flokTiPn9vehdXbRfeDEoMihK5EFBZyfJy5ch2Wy0nnEWoY0bD7mWmD/9EeeFF+B7+x08d/0WFKXvIYNl0iQS334Tw++nIX/AYfeRvGUzpvQ02q+8msCnnx7yXtRvfo37+uvwL1lCx1XXIB0M0kt2O+aCAuKffQaA1kVnYPj9X90rEPvYY5jzcul5/An8n32OJMsgSbhuuB77rJkIwo8lxseCIAiCIAhHnwi4C8cMMaH46TIMg7UHWnn8ixICLTU85v8Dye4yVsddQ6V1MDn79jFtUDe28/8AUWkArH1sA91rtzD7dydhLij43nOEVZ2/fVbECYNTGJ8X3/fzHn+YDX97lqFP3E94QAGb7nqUU6f0x2H9d4KnK4C/Ay8A0XS1NVCyfQ0lzX68gUgG99SYNaR3NVFNPyrJwWSxQ0IBHk8n6a3Lmd71Mm1xE1hiOwerxURAduL3B5BNZprixtHcFSDZV4pFUklwmnCadFRPPflGMQ2DrqWttRXDU4eGRLRRS2a0nf7TLsAa78JlchEKhmj0NLChZiPjEsbhsDhY3hNZYPF4x4mYTCYsFgvFLR7e3bWFXr2WqGQ4xTKF+uoKVFUFPUx6ZjYp0Ro71zyPv+AU7F0SLjVMXDiBnkF57C/spaolAOlRPHvlhEOChYZhoC6vQIqxoQxOQl1fg2lKJtqeZgjrKJMzCT6yCfPMXOSBCWhFrSgjUtC21GO0eDHPH0jw8c3IObHI49PRN9YhpblAjQTiTTNykWSJ8IfFYDVhnpOP3uEj9NiWQz8uq4LktIDDjOQ0I6dHYZraD0PTUVdUogxLQk5x01RdSXHxdtb0bqRUryU+PobrRprpH7sVSUoBph/cRnKsBd+/ydB1tIYG1LIy1LJytMZG9PZ2tI5O9I72gwuOdmD0frVopxQTjSknN5Ihn5uDKT8f86BBKNn9IkHH/xGGYdDR0UFTUxONjY00NTXh9/uRZfmQ7cu/Kz6fr+9Ys9ncV8rG5XLhcDj6NrvdjsPhwGKx/OSD8v8JWkcHelsbuseDZLMhOV0oyUnILtdh+xqGAZoWyVLXdbS6Ogy//6vN58c6dQqS1UpgzdpIKR8JAkiEAT27H1pKCkpnJ7F79mL4ffj9ARS/H3NMDFHXXQuA5867MEIHv9Vz8DOLuulnKGmp+N55l+CmTZGMecPAcfZZWCdO/L/qLuF/iBgfC4IgCIIgHH0i4C4cM8SE4qdP1XQ+3FHPc8uKWRB6jcuMl9hrnsvW+FNI0mqZteA8pC27sPW+SG3DifQ8+wEDPn0Jc//+P/pcf/pwPyOzYzlpeBo1v7ifps82Ev7nA/xmeS1v3jCVlBg7qqZj+pbs5+9WSiTofvXB/98JjMAw/Ph8b2K1foLJVE1k4c1TgXlAUmRXXUNv3IXcuB1v7W72t2j4AiFcE68gKjaBqH1PkxyqREodAYmDoeQTmPM3sMeArx0ckYcJ4XCYhqZm6hua8Javp7XLT4Z/D2syeshIWUSo+NAFI2NjY8mYkk5JZwmhDeHDymOc3XwnlVoKDzvuYmp+HCPTQsQmpxAdlli37mNedtVg11TSg1HkNzkw3MlgthMIFtOQESQ5ahJTowYi2W28X7ad00fNYHRWRl9gUKvsJLy4COtVY9G2N2CENMwz8zA0/Vsz0AEMbwhkCcMTIPTiLiyXj46Up2n1okzKjGSNagYYoFd1IqW50eu70fe3IhckRMrYBNVIkN4XAm8YKcGBeXY+Rkgl9PR2TLPzUfrHo26oQV1W0XduVdZpMXvwOjwkxAeJcfmwjtiMlNWG0TwHvXQsypTxSLIbraQN/CooUiQDV5aQrKZIzfooC5Lpp1dy5Wgw/H7UqirUispIdnxFBWpFJeHycgyPBwDJbsdUMBDzoEEHtwLMBQXIsbH/fy/+/4iqqvT09NDV1dW3dXd309vbi8/nizz8+hpZlvsWdTWZTIe8fn3hV6vVesjrlwvGOp3Ob10Q9j/FMAwCgQA2m+2oPSz4cuHc7u5uPB4PSUlJJCUlUVdXx5YtW7DZbH1bTEwMgwcPxjAMiouL0TQNVVXRNA1N0xg+fDg2m429e/dSX19PKBQiHA4TDocZOnQoQ4cOpaqqiqVLlx5yDbGxsZx55pkAPP/884TD4UM+n7lz5xIXF8e2bdsoLy9HkiQMw0DXdQoKChg1ahRNTU18+umnTJ06lQEDDs+0F4TvI8bHgiAIgiAIR58IuAvHDDGh+N/hDaq8+NIyPPu2cXX03/CZU1gRdyWaKYrx7zzH4BPK2FV2HA2l/Zi74j4k849brFHVdO77y7sM2beeM199mIp1lax8dBPnPLkA3WHGbTcTUnXOe3wd4/MSOG1MBv1T3P9iIKgKOAN4ADj+4M8MIkH4D4BlQBiYBMwGJgPfCCSqITAdrEG/5n6oWAZNuyHQCa5UOGcxZIz/zqvYs/wj7CtvJs9UyYe2U1gZcyNTB6UxO0ulx57JnqYgNrPC0l3VbCjrYGpeObdW/YGQMx0171QSklIw+ZpYHn85/eIsDH59MG2uQSwvsRLu6iRrYBLBfosYccJ0HO+fSWdZKaWBLFp6bBhBH1LOUPz5swjrB3vA0PGq0JjeheHuZpCaQ1JMEqmxabhNbsyYyc7ORpIkysvL8Xg8dPrCxES5iI9ykZSUiMvlQtM0dF2P1NX2+QlrKsbeZuKbQTl3KNue/Ag12U44xkygqAk11c6JQyairKqlbnYc6o4Gkj1mYq6aRGhxEXJWNMqIFPT9Lci5seCwgETfZ28EwpGAflcwEuRv76KzvhGfrwc1FKI6rhx12gaOq5qIZfs4LL+8B6N8FuFlk6H1O/6cOsxYrxqDFGVD3dUIBphGpWKENbSt9WCSI6VyFPmroP3BV8luQk6L/M4zugNgNyOZf/oBfK21lXBREeHCIsJFxahFRYRLSyEUeVgkpyRHAvAFkQC8qaAAU1ZmX6bwN0ku1/9k5nc4HMbn8+H3+/H5fH1BeF3XD3v9ej36YDBIMBgkFAodsjisJEm43e5DNpfL1bcdzYB8W1sbZWVlVFZW0tPTgyzLjB07lpEjR9Ld3U1VVRVRUVFIkoTf70dRFPr374+u63z44Yf4/f6+kj0A8+fPJyoqivXr11NUVNRXlkeWZcaPH8/w4cNpaWmhuLiYQCBAMBgkEAgQFRXFnDlzMAyDZ555pu8hhaIoKIrCvHnzcLvd7Nq1i+bm5r4HF2azmYyMDNLT0/H7/bS1tWG1WvseYgDY7XYAampq+vr7y7JDBQUFOBwOKisraW5uRtf1vm84pKSkkJWVhdfrpby8nIyMDOLi4o5KvwvHFjE+FgRBEARBOPpEwF04ZogJxf+W9tXbePehQgpH2jhX/hvDKOQD5y/pcSYwVtpLcGsHlkY7o4/7EClvJhz/O0j44dl/wQ0bCRcV4br8Mv6x9ADZcQ7mjM3sez8Q0nhtYxVvb66h0xsiJ9HJ7GGpzBmeSlqsA0PTMHp6kGNifsDZ9gKDAQV4HnATCcIbQC/wBfDRwf1uBC4GGgAPMIjIyoHfYBjQ0wD2ODDbj3hWQ9MI7dyFdewYDMOg6w9/xJPbQ0fQzxfxVzI1U2LK4iHosoVyLZ12YslVGlk/Zz0zR6TRXPYO+YPOBsXEr9b+ggkpE1nY/3Q6u+uoXXkHaU3VOJu3o5td6O50lmyXGXvZXSTZewl5u4nJyEPtqKFh31ZqmoM0FO4ibMhk58cT5VCR1QB53s2sTxzBAcflmIxDy7Ac1/l7nJqP3WNepKOpjbC/C02O3GtxKIlQVAIXDYth19YNhxzXjYNSr5OZk0cRKFyNbITwh/yYkZFMEO+UUDLHI3k7qK6uBiKZqClhJ4PzBxDbP53Q3zdjvmA4+FXCHxZjvXUyWmErRnMv5pP6E3x+J3K/aEyTMgn+dT3mM4cQllV48wBvzS7FVtTDsI5k1s58jjM3X4o9pQnLKe8QeuQOTDP2ISenoRXlIqUng9eB0atimpyFZJIJf3wAZAnzKQMwekMEH98Mqh7J1D8CKdWF9cqxkcUd71uN6eT+mMamo+1vIfxFOZJVAYuCZDGBRYmU0LFEfibnxqHkxmJ4AmglbSgjUpCsJvTaLgxfGMxf7itH2jArkeC/BJgUJFnqC3YeKZit7WkChwU5LxZ9bzNyblxkkdt/kREOo1ZUEC4ujgThi4sJFx9Aq6393mMllwtTXqRkTWRh1zxM+XmYcnKQbD/uod3/GlVV6e7upq2tjfb2djweDz09Pei63heY/zqbzYbT6cThcPQFps1mM2azGZPJhNls7nvf6XTidDpRFAVVVWlqaiI6OpqoqCh27NjB/v376devH2lpaQQCARISEkhJSaG6uprly5cfksGfkpLCqaeeCsC6deswm80oX1uQd+jQodhsNqqqqujt7e2rfe9yuX7wQwKx0Knwv0aMjwVBEARBEI4+EXAXjhliQvG/p7WsHUuam188tYoxHW9xmfwCax0XURo3EaNRYfTn7zJs6CqsaX6QJKSCBWyrnUNbqICT7jj+B51D1w3u/2AfuUkuzhmfhccXpr7Lz7DMGCRJQtV0tpS38/meRtYUtxAIawzLiGbKusVMTzaR85f7fsQdacD9wADgHKAWuAx4lEhgvRmwAjHAU8DbwFIigfpVQC6QyRED8EfgfettPD+/nZRNG1HSUg/fQQ1C3SZo2YfauAetsxLLgJOQxl17WBD/vdJ3yYnOZVTSKEo6D3D3+rt44PiHSHel8+zeZ9jWvJVHJz+IYrHy4F/nk1Hayln/3EjZ6vfxR9sZMWY+WtBPw661xGQNICoxlcI3/sz+pe9xyu2/wzFsASte/gt5pU+gWk30Wp1026y0GRamX/EB+/5+J23/j72zjpejuvv/e2xdr/u9cfeQhBBIAkEDgeBetFBKKcUpFCvS4u6luFtwAkQIxN1zk+vue9d3x35/7M0FWspT4Wn7e5j363VeZ3bvmZkzs7N7z3zOdz7f+pXsV9qAP50mpuSyMCjzac5YsilBVtMURzsZnmhhVLSKfLWDpw95kl/sezaJhydi79yEiNF/PE/m/pGf//IqImtf4suvlhPyDictepi6/2xGDq5gw9p1VNfW4nO68aoKwRElZDVpBAwHypxBaOubEQIOxAFBjD3diIVecEiZBK5OBUEQaIo0sbZxNRu7N7K7fTv5nhinRqeRN7aefEPHeP007L+5BW3lbIwd47H/chnaikkIfh/i8IHoa72IA3MQ7BJ6ZRfiyNy+BLFmRjzX+0R4AQSfI2NFUd2DmONC8DswWiLoOzshrUFKx0zrkNYxU3rmvbSOtE8x8rRS9Kpu1Ne2Yr94KoLPTvr1rRg7O3/w+rKdMxGxxIf66W70qm6UQ4YgDgiQenAlJDXEYh9GeyyToLbQg7G5HXFoNtglMEyUo4ahLW9AKPAgD8/FDCfRt3VkIvdlEcEuI3htGdsdr/0HrYWMSAR1VyV6c/P3iqXf8ZSvqkbbswejpyfzR0HIJHWtqEAeMAB5QAVyRXnf8gAEu/2vtvfvYK/Xu2mayLKMx+NBluX+aHRd14nFYsRiMZxOJ9nZ2XR3d7NmzRqcTme/17vf7/9OZLSmaYRCIbq7u+np6WHixIkoisInn3xCfX19fzuHw8GUKVMYPnw4u3fvZsWKFaRSqf4JFofDQUFBAaqq0tTUBHzrSZD/YegZCATIyspCkqT+SPG94rksy/1FFEV0XcdmsxEMBnG5XP92uxsLi//fscbHFhYWFhYWFhY/PpbgbvGTwbqh+L/Lpp9dx4rQcLaP6OA23z20UsLSwFkIgsg4U6Xs3YdRtHa8UzVkewTVVYGy30Uw6kQIlH/vNo1EAnXzZpSRIxG9XpKRFK//8n2EWeU83RTiwytn4XEoqJqBImcEnkRa48ud7Szc0srKynZ+OcrNqSfuT2VLmJ3NYY4YX/QPer63A28BpwE+4HYyEe+3AxrQCFQASTJ2NBqQTSYp53hgAjCYv5Wg00ylULdvxzZhwj/Qp7+fvZGgLbEWelO9DM/KJK/9uOoD8mIik8YewVuXH8p6f5gLL3iWtTecx/ALrqOgaBhqTxfOnAJa6rZSMeFAZETeOHsfjFQSUbHhLx6EK6eQpnWLGXvSrykYNwNsCrFwJ3VvPcw+wyT0lq9ZetQDJOKdzH/rPETToN2Tx+5gKVt9+bQVjuOGGbcDcML7x3LGsNOYV34oq5uW8sSOF3A5s5jVXsPUmjWUpLoA6BI8vOo+jEmHXUW6O8Huhla0VBxBS1NQMZSZM6ajJ6OsX7+enJwcsrOzycnJwW63I4oi6XSaVatW0d3dTXd3N6qqYrfbOfaEY6mM7GJd3TrW96yjNdFIgctgSJaLyUYppbof99hK/B/OQsqvQ95vMak//h7l6DXgKUJ9oQLbL0ehb4ygb2jBftl0jB0dCEFnRuz/Fz9DoymMGUoijcoj/dpWBJ8NaUY52pJaxMFZCC4ZM60jGIBmYKo64pBs9C/rEAJ2TN1EX1SD7dyJaCsbMXsSEHBAUuvzyDcwdZPMUx0CYsCBcsoYUvcuR7DL2C+eSvqFjRgN4UySSON7OutWkMYVZLz9wym0JTVIM8oRs5zou7swWyLfsdrJWPB8Y78jFvsQvHbMhAppHUOPZ3zjq6rQamrRa+syfvI1NZixWGafsow8ZDDKyFEoI0egjBqFMmok0t+w9vih6Oi9diF/Dxs2bGDnzp1EIpH+9+bNm0dBQQErVqxgy5Yt32k/cuRIZsyYQW9vL8uXLyeRSNDb24uqqng8Hk499VQAFixYQHt7e78g7vF4mDt3Ln6/n9bW1v72Ho8HRVG+9/jS6XS/lUswGMQwDCorK/s9zVVVRdd1Ro8ejWEYVFdXEwqF0DSNdDrdb5mi63p/e03T+tfTNO1vCvaCIOBwOL6TLHZvhP1ekX7vsiRJCIKAIAj9SWj3Ln/bhmav7cze199OWvvtJLZ77WX+8vXe/VpY/LdijY8tLCwsLCwsLH58LMHd4ieDdUPxfxctpbLni0oWKwpvfbWFh8w/UiHvYKXvZ+xxjcWrKIxvaCR7zWJ8xV+D7MKWE0VAg9M+giGHg6GD+I31gLpnD+0zZ5Pz9pvYp04FYMv7OykeX0jILjEwz4OmGxz/4DLOnDGQY/cppbW+jY3LNjDrxINJpHUE08Cxfg3vyCW8sqKeBZcdgCAI3P3hdrI8dkYU+Rhe5Cfo/nstNBYDMTJJVMPAK8BJZCLeo8AmYCMZ//dtZLzfbWRE+RnARYBJ+OEbIO7Fd9VV/+KZ/9fRDI3Kzh0MtBdR+fELvOLZRVljnOzlW5j+wFvc+/SZHDPiRA448le8tflFlq19neNDA+ip3UmvkETq6IK+iN7AwJGMP+UyKj9+kaKJB+DwZVMy5eCMwLn7YyiYAN6Cv+qDaZq0xJpxKx78dj914VqWNy8nnOolnA4TTveiRtvJ7aqiPNTIVk+Qoftcwqmin83v38KiYJqFLZcQ0YqwFaxgUpHJwGgRQlzKCNBAMDfIoUccgkt2s+DdBQSDQbKysvD5fESjUcaOHQvAq6++mrG6yPKjO3RiaoyurA4a1AaMDoNgKgtBMPEGYowamGRsaZgCTxuKGM4cS2QcRtcBSBVTSD0WQRyagzyjDPWdHciHDsbsjKOvakQ5bSza59WYPQlsJ44m9af1iAODyNNLST22BuWIoQg2ifTLm7H/Zl+05Q0YuzqxXzQFbUUDQqEHMcdF+s8bkOcOhZSO+tZ27JdNR/u8CjOUxHbmeNIvb0YalYc4Og+zJ4mQ7fyH7DiMpjDoBkKpH/WdHUgjchECDtJPrUM5YxxGQy/6miak2QMwq3sQvDaUQ4eg13SjflGDbd5wxDw36pIa9PUtfdY7fZH/homJiYDAHmcv9RVgC7qRulNIbQnyDh7N8OHDiT65iq2pZlTZJC0ZpESDtKkxxyxGjEbYpLcRCtcht7biED3YYlGyqrbhSaSJD5lIa34QXRTRJBFdEnGpGiNjacyKEhYWeFElkbRhYBgGgUCAI444ArfbTSQSwel0IssymqZRX19PRUUFoiiyaNEiJEli8ODB2Gw2NE0jOzsbm81GZ2cn3d3diKLY76nucrm+Y62y97pPJpMkEgmysrIwTZNVq1b1R5cHAoF+n/H/JvYmDd0rvmua1n8cez3q95ZEItHf5tuJTv8ykez/Nna7/Tv2OXuLzWb7q6h9WZYRBKHfP36vZc/eZcMw+icH/nKyYMKECd87EWJh8UNY42MLCwsLCwsLix8fS3C3+Mlg3VD8NHjp2j/TvVPBN3oLJ+d9QqS3m+X+M2i1V1BWVsZEmw39qmsg0UP+OTri/leQMiai7LwDMacIjnwMDAMzFUdrakUuKfmb/s0pVefjTc2MKPYzrNDHgrue5Y5oIZ9dMhVvdoAnX/2a5PPPc8Fvz0Scti+yJGCYcPlL69jW2EskmRF9CgIORhT5GVHkY1iRj+GFPvyu/0noWg1cC7xOJqp9J1BARnwHSJER3SuBKiAHuADoBA4j8ekhOA+9HVgDVAODyETDB/hP0hCpR9dVshMS9rwiPnvo12T7C9nnjGv44NLD2ffqR0g21tBVtZWlwwSGZ49kumMEO7Yv4cWtf+aKc56n2FHAG2dNxjR0pv/yTnRNZc3r9+AM5pOTV4EjkIsrKw9HMBdPbgnewnLsvqy/Swg2TZOElkAQBJw1S9CW3ozUuBoEkWTRfnweHMu6wlwi6W7qeluRNQO/5sfEpNXRgoDAA7MfptxXzgfV79OV7OSsUecA8HndZ8gJGb3XoKUxhJZUEQSRvCHjcLgD+NItVFfvJpKIo8ZTCCbUemrY6tpEiUNiWn6QaRVpBvqbkcU4ppkP6mzMyAy0j+zIcwZjJjX09S0o84djVHZhxlTkSUVo65pJuUXCHp3utdUUjR2M3+ejdXM1XUGdnLw8snNz/qYAa4QSGNU9yBOL0Gt6QDWQhmb/qNfGdz6HhAo2CbMthlHTg7xfGer7OzFVA9uxI0ne9RXyvqWIo/NQn9+EctxI0A20jS1E9sujZtVW6rtaGDZ+NEO73HTakmwO16F2RFGVTKLRXJuPWcccSuLLat6uXY5NVrDpIjYkbKLMlGQhNkFiA820FwmkkkkSoSgpdCZrKkM0Gw2pfFb72pFNEdkUkE2RHNXBtHA+JiarhV2Y279ENkw8E+bTTTMTjAT2rGF8akbplJL4RSdxUyVtahxWNJEify7YJcTyAGK+BzOaxuiIIZb7EUQRszeJaZgIstgXyd8XxS8K/7D3uGmaGHUhBJ8dIZixkfq/4F++N4LdMIzvLO99/W1B+9vlL9vtXd6bnPnby99O2ByPx/vtffaWvU8B/D1IktSfbFWSpP59A985hvnz5+P4iecbsPjHscbHFhYWFhYWFhY/PpbgbvGTwbqh+GmQjqf5+Lm1PNabIJRQObtwFyerL9AVM1kZPJW44GHwrkqmnHwCzp63McsOoevaR3FWRPCc9TOMsrmkPnkeR9U1CKX7QcVMqJgFxVNAtlP1VR1qUmP4nEH9++y33dB1umoayR2csan505I9mO1tnHvCdCJJjeMf+JJbTxjPlEHZpFSd9nCSXS0RdjT3srM5YzsTS2lU5Lp59eIZALy8vJYZQ3Mpy3F/z9GqwN5oxmOBicD1ZCxmWslEtv8lSTIi+xgy4voTZBK17o34zAYGACXfKpP5Twvx6XiEHe/9iWD5cMr2Peyv/t6V6GRr51b2KZiCS3GxqmkFDRuXcOyhV/D1/Zexu3I57oqhuNtDpFIxYuEuFO0bXxL9sDmcfvZDdFVt5f2P72HwUT9jRvksOpt2EzESFOcPwWb7/uSzRFph1wKo/ACGzIV9LoSqz+G9c0nmTaTWMZDdaTvVcZ34oLFcsu9RdC58kKW7V+C1J8lKZaMkO3hoqI2YLHNZ3UYO6GkmJUps8uSwxl3MSncFQyrGc9OM33H9G5tY3fUOhVo5Rf5BBAqj2FNVuJrspKQECSGJ05GmrDjCIfutwy6G2bp1EqaZi6r6UFUvmuZi330HIstFfP11A3v21PYnvhQEgZkzZzJ06FC2bt3KqlWr0HUdQRAIBAIMGzaMsWPHEolE2LJlC+l0mnQ6TSqVQhRF5s6dC0B1dTV2u51gMIjT+d3I9lQqRTQaJRaLEY/HAcjLy+uPtN7bD8h8v1RVxWazkU6nWbx4MV1dXaiq2v+kwJQpU/ojvWVZRqvtJiZrRBIxfNVJvPsOYNeGbazbtYUYaRRRoljJYtScKeR+2Y1Y7keaWET6qbXIhw0BSUR9Zzv2Cyajr29B39KG/ZcZWxtcCrbjRpG840vkgwYilgdIP7Me21kTMFMaWmUX0oEVUNkNqo40IjdjvVMeQMhzoy3cgzihECJp9E3NmENS6GuboEciWbUQ2TkIMxYj5HfSWz6QLiGMYggMVnPxJXUEyY4g20nVL0Ht3YF9yHRsrokw1UQaMRh9cSfU9X7/tSpn7HNs501CzHahLqmBSArlqOEYhoH66lYEu4TZnQTDQCj2YmxuR8h3I2S7MCq7sJ03CcFvx9jWjpDnRizwZkT/5gjIQsZL/y/EfkEW+5Lxyj+YRPenhGEYfxV9v3fZMIx+gd3hcFiWNBb/q1jjYwsLCwsLCwuLHx9LcLf4yWDdUPy0SKk6n29r5a3V9Wxv6uUQz04uUN6gVctig/dw/G4bMw85CuHCi5AGVBAcvQVhwH4kjQPo+flpuAbHsZfq2ApSiJKKKciQM4L2SBm9DGLoOT+HvFHoLS10nX0ugT/cjm38+L/Zn1A4wdsbmpk7voh8v5PHv9jN6qpO/nT+tH7hyTBMGrvj9CZUxpQG6I2nOfb+ZdwwfzQzR+Tz7toG3lvfSFHQRVHASVHQmVkOOinwR5AlHSgik0D1CuBdMoL5VsABDCa9fgNSWSlSTs63eqcB9WQi4ff0LTf2lQjwJBkx/1kyljX39633Khlv+XwgFwgCHv7epK3/LhrXLkKNR6jYfx4fXXYkuTMOpqpAhoceZfrFd7Jq7dto69ZxyvMbWXrHBTRtW07ZHx/F99V6Kpe+hdadSQ4qO1yYLiemw062vwjF6UaTJfa94DZcngB1X3+I7HBRPGk2RttWUiufwtG1EaFlHagxKJ0O534NhoF+u5/OpIPdXR6K8hVkXzbbpzzA1MmDSe54m562PUjJDrKaVpLduZPPJ/yM9sEHcnpwNLHuJp7Z/BgDk0E8PWmWml42DehkWsjGAT0aCdFNRPYimV0grOSLEWMYVncEimAgKSqKomK3qcyd+yF2e5rNW0YTTuSQlt2YtjLycyaT483DZ/PjlJ39yTk7Ozvp6OggJyeHESNG0N3dzRdffIHNZusvTqeT6dOnA/DCCy+QSCSAjKWG1+tlzpw5+Hw+li5dyq5du77zOU2cOJHJkyfT1NTEp59+itvtxuFw0Nvbi9frZf78+ZimyaeffkogEEBRFHp6eujt7WX+/PmIosj7779Pd3c36XS6X9gdN2U/7MEiAmYvzc3NuIL5jBhUht32t603QrE0q6u7WLm7k/NmD6Io6GLJ9lY21vWQ7bIR8NrJViRKc9yUeOxoW9qQxhdgVHahr2vBfu5E0u/uAMPEduxI0s9vRBydhzQ0J2PvM2dg5mmD5fUoJ41B39iC2RFDOXwo6uIaBJ+CmaWiL6pHpx0jEkaK5aGKu5DUfCQzh2RsCTZlAnq4m/iyF/EffQux5S9immm8B/ycVGQjsr8Q0cxFGCxC3IEgKkjDcjFaIkhDsjHjKtqXddhOGo3Rm0R7dydCuR+zNwWageC1Yap6xlo/nantl+6L9sEu9C1tyDMrkCYUoteF0N7c/oPfQ2lyEfKBAzA64qh/3oBy9gTEEh/a4hqMbe0Zkb5PqBcU8ZvXsoQ8rQSx0Ite3YPZ0Is8swIzkkJb1YjgkDPJdz02hCxnZn1R6PfqF4flIIgCRmsUFBEx24WpG5ihZCbqXxRgb5G+tSz2bef/Y0zDgLiGUdWNOCiI4PnPJPi1+O/GGh9bWFhYWFhYWPz4WIK7xU8G64bip8v2pl7eXF3P51tbGWNu5eeez9hjm0i3UsJYR5Qxg6fikjeia15SbX5sgxzw5Z10vZ3CiKhIRhO2rARKroatUED2JxFm34Qx9iL0LR9ifvRbxHM+QB4yBtq2gs0N/rJ+T/jQb6/D6O0l65GH+/u0qb6Hhq44R04oJqXq/PqFdVx40BDGlweJpTQ03cDvsmEYJoZpIksiK/d08sXWVpp64jSHErT3JjH6fsFFAfJ8Dq6YO4IZw3w0dS9ne/MIDh5dCFxISvWgG3+g95BZZN2ZjX3qPWQsZP4negEnGS/4JWTE+DPJZK08FOj5i/YyGeE9SEbsv7Pv/deB4cBYMn7zbYCfjEBv598p0pumSTrWS9OaRRSOn0EqEqJl4zJGzDuXpvVLSIV7GDhrPsvuvhhHQSlRr43Wl59k8JyT2NW5Hb2tjSGDppDoaWd76yYqfn0DcwfP45O7zqcx2cpp172J2RPi/V/NAVHCFczF5vZhSiIOTxbdVVvwFg0gb/gkmjd+yZybX2LtUzdRMvUQyqcfTm/jHrqrt6E43dh92TjsMo5gAbIvB+GjX8GaR/pOtQOCA9EmXUhozOlosUYa1i6gtbEWZ6odd7qLmCDwxpA55AVS/G7xXdiMjN89IuC18dCoGTgKRI50tVJQJGWSn6oG1EXZ0q7wllnE+blHUfDuDcRTOpoA4CUk5/PI+NMYVRJg3ue3okS6ETEQTZOY5OPZwkuZf/Tx5IYjfLB6Nw1xGwoGCXcxNqeHWYPcVGQ76ErAzvYkZdluRpf4cNhtRCIRampqiEajJJNJfD4feXl5lJWV7f0A2bHwSRoaG2l1j6TNMRRVsDO6JMD4XIOaxla+2NFFcxQawjphTUaRJZZcNwdRFDjm3qX0xNOMLPYztjTIuPIAE8qDOG0yry3bQfXGJXi71jHS3EWuPQVnLGRMaYDE7bnY091oSBimyB4G8MmUt7li7gh2Nvdy/tOrCLhtBF02LjhoCPsNzf3fuX51A2Iqgs+Ovr0dHApihR912U6MSCtq/R6M2hDp6vXQk0RUckhu+RT7qDkIipN0w3Jck09G66pGbd+JY8hs0k3rMXUdOa8CfDpyRRlyRQXygAFIFRVIhQUI30roqld2QlpHGJRF+r4VyEcMQVAk1Le2o5w2BmNXF/q2dmwnjkb9rAoEAeXIoaSf24i0TzFIAvqSWpQzx2Hs6UZf14w4Nh+zOYKZ1BALPJjtMZAETJuEVB5AnliEtqoRfWMr9suno320G31LGygiJLTMj6Dx10Na+/UHYDaESX9UiVjoRSzxgU1Ce3fnD55nsSKAcsoYTN3IHONRw5BG5aFvakX/su6b5Lt9tSlkovYFRUQo9iGNycfsSaAtqkY5ZgSCy4a2pjGTFliWQBERlIw9jCCJmeOIphGH5yA4FfT6XgSvDakgk/TYCCUyn8F3JgW+KYIgYCZVzM44Yomf9AsbEfI8yLMHkLrzK5STRwMC2rI6bKeOyUyqyAJilitj0aSImX5Z/OSwxscWFhYWFhYWFj8+luBu8ZPBuqGwCMXSvLe+kbfWNJDXu57jgrtocI4jaHYze1wZypfNxN94i/zXbkNYdjtR80xsEyeiNDyNlvKSToxC3bkD+4GzSA8ejbxiKfE7f0XOb6YgnLqA8H0P4Irch0wjpqCAtwQCJehhE1PyoYzfHzwFMOpEsLkg2QuKi864wX0f7+D82YOpyPXw1KI9vL+hifcunwnAmY8tZ/LAbC45dBjxlMaKPZ1MG5SDXRFp7U3S1BOnpSdBc0+CQ8YWMjjfy/PLqnllRR0fXzUbSHLuk5+zrUmhKNDL3ae9wDNLT6IrOpTDx33FxIo1fLr5Fn62/yBkqZnaDjseh48cr8w3iVfFv3FWE2TE804y4vu3iwRc2dfuOOBoMmL9UuDyb21DIiO8u79V5gAn923ni77Xgb7XOplJAOcP9OvHIx0L07R2EUWTZtGw4lO2L3iSeQ9/wbL7LqWnp4l9r3mEFVedimfKfqwoiDPy7dVMueAWPlz6GM5NOxl14Kk0rV1EV3cD7qGjcHSG0WWB3nwfJ172LJKq8/a50/AOH8fh1z3HljceZvs7T/xVPySbA4cvC7vbxYhDT6Zs9il0VG5k18cvMO2XdyDbHOxe+AqxjiZkhwvZ7kK2O5EczkwtSZhaDCMg0hOppqtxG5udPrYJXeS3bqEsHKUo10dhoZ2cfJ2s/BRun9Ef5ZtKiCQiAumIm1jYxSeGl/q4ndG7t2Km4+iCgSEIBNUk7+UOIOnO5WXdB+ufRkOgw5YNhofP3bP4YpjMpHSI07d9DIZBRHRQb8ulLVBO1eh5TCsdwwHFBxDXEqyo+YRJiQSRynW0T/0VQZ9B8E+H441UI6OjI9EkD2TN2Hs4bt5RhDubuO/zOnKycygOOinOclEcdFIYyFgCbWvsZVN9iC31nfTWbSKeSHDjL89ioFmD8dgERHQ0yYlRMAnbgBlw0O0gCLD5ZUhHwdDQdZW46EMddSpZHjtdkRSLtrcSiql0x9LMnVDE6JLA//q1+fdgqip6ayt6YyNaQyNGSwumqoJp9hdzbx0Oo9XVodXWojc0Qp9POA47ckkpUlkpclkZUmmmFotKEA0f0sA8BFnCqAshDsnG7E5gdsSQxuSj1/RkkntWBNB3dSLkuBDcNozKTsRBWZjhFPqODuTZA9DXt2D2JlEOHEj6lc2IpRmrn9TdX6OcMArBZ0dbVocybxikjYzQ7LNn+q+bkFTRVjYiTSpC39aOvrQWx3UzSb+9PZPI94RRpF/Zgjg0GzHXjfr2dqSZAyCtoy+vRz56OMa2doy2KMq84WhLajP9zXejL6xCPnIomKB9WIk4rgCzJ4HZHMkI8TXdYIBY4sOoDSFPLUHIdaG+vQPl1DGY4RTae7vAo2QmCHQzM8/4F6Nwac7ATKLfl7dAvht5RC761nbMzvgPf9BuBXlyMdrKBvDbEXPcSBMLEWSJ9Hs7M0K9ZkBSg4ADQkkwTMRiH0ZzBGmfYqQROaSfXId81DAEnx31w0rEETnQm4K4ijggiNEVR7DLkOXA7IwjjclHzHOj7+kGRUIq80Nax0xomLrRl0ugb2Jgr42QpoMigUOGaBr8doikQTcRc90YzWGwywhZTsyGXoRsFyhiX+JlF6Q0zFgaMc+TSawMiMU+tA0tiAUehGwnRlUPYrkfDDB7EgglPoilQTMRAg7MWDrzBIVNAtXI2B8JQuZzkfr6aYIgZiYyMEBwKRhtUQS3DZx9fffYMhMm/8h3cu+tl2ZkJq7+7sTp/ztY42MLCwsLCwsLix8fS3C3+Mlg3VBY7EXTDZbsaOfVFbU421YzJStOUvIzQVvFmPFTsE85G1O00XbATDxnn42neDN62kdkDfjOOQrz5UN5d/sV7L9PNo7enfjOORHKptNz+RXYw8+jtqYJScVIOTr5rioMw4HkBtGuIoopuCZEavMulA1XIvqCcMq7EO+C108ATwG9Sj49ch4VA0eAv5QlTTYCucWMr8hifW03F/15Da9evB8VuR6W7Wonqep9kezfJZnWcdgyEYtrq7vojqUJx1XCCZVQPE0onibPt5k8/x5e+vpA3v3NAQjCkby7diI7mk/m2nkmcBZXvnwV0VQFx0/5hLLsej7ceAVum4zLLuKyKZTluJg0IBtVM9jR3MuAXA9ep0I8paEbJk6bhPwdQeJNYB1wOBAnE/Ee+1aJAPsARwGbgfOB18h40t8MvP+tbTkAFxnxfW99BTCSTET+DuAXfW1f55sJBKWv/naxAxP62rb2bcvPN4rYd6Pwk71daKkknrxiape9j7doAN6CMnZ99AIV+x+JloxT8+V7jDvlN/Q07mZrx2aGj5pFgbuQdW1reXbbn7l/1oNIosRty2/GUNOcxj6sefIG3j2sgNMGHM+UrPHs6drNqvVvM7tkNkY8TlPdFrzT9mf/mWfRvmMtX79+J1Muu5eyrIEseegy2nesQdZMtGQcPZX4q+tixmX348oupPKTF4m0NXDwzS/R0tvI0gsP/au2hghkuXHkugkM8DHiuHK8tjhGVzMufweKS0DXCjC00SCNRTVHk9DziWsp0rrKIHsWZutm9lS+i9RQT7rXIPfg43h/81rkRDeD3G10bO7C7tYodXaSMOHuoYdyyMB9+dnH1xOXXDgjtUiYtJh5PDThF2xlDTZDxwAqkhGGJqIMS0b5sHwf0q4cbmytIbvyI1RnkHaHj+LSA2DsabyqdaN0bGdEw1pyQ3UEu2uQtSQdBZNonP8ULkFkSN1yxNLphPzFyJIdj837k/UcN9NptIZG9NpatJoatPoG9Po6tIYG9PoGzPi3BGBRRAwGEbOyELOzMnUwC9HjRnA6/6I4EL0+5MGDkMrKvhM5/zf7oukgCP+QsGmaJsRVBLct81TA9ySN7R8Cp/WMmJvvxmyNYsZUpMFZ6FXdCHa5z8u+DaHEh2CX0Hd2Io3KwwwlMRrDyPsUY9SHwASxPIAZToJTQVC+iRg30xpmbyojKDf0YkZSSCPz0Hd3ZtpmOTGbowgFbgRFwqjtgaATIaVjdMQQAk70jS2giEiDs9FWNiKW+BA8Cvq2DqRReUhj8jA1A6OyCzHfg1gewOiIoa9vyUyuGGZ/baYNzLSeEcT7xHpTN1Bf24py5FAEtw31g0rMaCpjJ6QZGYE8rvYJ5yYYZIT6kbmkn9sINgl5/3K05fUILgWz669/f76NPHcI2oe7ESoCmL1JBLuM7aTRpB5YmRHobSIkdbBLmX0mtYzA7ZQxYyr2y6eT+uNXCDku7OdNInnnV+CQEdwKZlMEodQHqoHZGkUYnYfZHEEwwf6rqaQeXgWyiHLqWNL3r0CaXISZ0jC2tCPtV4rZGsNo7EU+eBD6qkaQRWynjSX10CqkCYWZfAzv7cJ21nj0Pd2ZZNTHj8LY1YEZSSNPL0P9bE/mqYqRuahvbEM5cljGxmnBTuyXTUdb2YC+rR37xVP/YdH+x8QaH1tYWFhYWFhY/PhYgrvFTwbrhsLi+9jaEOLVFTVIDSso9ogoZpoB6hZGDCrH3eQl+uwbFHz9FcklS+i99TbyXn0Cff2z7H4lSrB2E8GZPdjyDXrb5uM+8USUtb9GDcxk46cu5EA34xwP0Wu/ik2bZEZrfybr1xcj7nsR7UcehWOUF9/FF6OmC+g+Yz7+yZ1IHhPRlkQUIgjo/f00JQfC8KPhhFfp6AmTs+wKhH1+wR/X2tG6qrhulh/DmcOVC+o5YdYEpg3NJ5HWSKR1gm4bgiDQde55OI8+Gte8o/7G2TCBbTT1SGCWU5yVpie2lFdXlNASksnxbqYoWMUbq+aQVNM8cc4dPP7FHFT9UG47sYSe6B4OvyvEfadPYt8hKV5dUc/9n0TI9fZyzbz3ef6ruXRFipk7fhXDimp5feXZnDnDy8QB17Gl4Tc8v8zBXadOBOCZJVV0RFK47RIeh4TbLuG228j1NeKxd2CTU5TnCMhSimgyjEACtyONacYIJ05DFAZgl99EllYD9yKKApnEsp1Amm+SxH4bBVjRt3wqMA64GtgJ/IyMuC+QEedlMrY6Zl89ncxkQAz4LfBzYBRQ27fPbMDL37LQiatxNFPDhY3mTcvoKAvScvctFAyfjOvIo9l0yclM/eUduLMKWfT7s6g7ey5HJYay68NnefbIIGdV5VEWHEj60APZ+dsLmHzibygdtR+fXD2fqmOmc2rhkex470+8PhmOrHSQYwtSftL5rLn9YoYddgaDDjiGDy45hNJ5Z+DSRXZ9+BzxI+cgbdqG1NlNJNeDvSvM7kEeto/wc9JrtXSOL2TEsZPwb6qi+q0d/cciKiApIpJiQ5BtJHuijDj6bBy+PHZ++BzB8mEobh+yzUHWwFFsfetR/KVDsXuDtG5dTuGkg3B5fbTt/IqezjbaskbjGHs0U4aU4rOF0QpyiGsJ4okwSVTiWpyEFs+8Fw1xqKeUAVqChrol9LauZbTogonn8we1mWDNlxxX/RV7XEF2Ob3sdPmodvpJSJmklK/OfQOX4uJ3X1+HR/Fw9ZRr6Yi3c/5n52KX7N8qDuySHYecWR7oH8jpI8/ENE1e3PE8+xXNYGBgEPXhenZ270ARFRRJQRGVvvUc2CUHTtmBz+bHpbj+1k/UfyWmaWJ0d6PX16M3NWP09GRed3djdPdg9HRjdHVhxuKYicQ3JZn8znYEhwN58GDkoUNRhg5BHjYUqbAQ0e9H9PsRvN6/S5C3+Pdh7hXtRQEz3mdFIwgYXQkEh4SAkPHH99owqntANxCLvGg7OxECTgSfDbMpjJDrQawIQE8CQzUQVA0hz4PgtmWi9CETgR5NZ6LQTTJR6W4bgkNGGpSFkOdG/agSaWQe0sAgWnU3xqY2TF3PRK2b9EeRI4uYaR1pWDbKzAFoqxrR1jZhO3McZl0vemUnRm1vpq3Qt57+3Vsk27kTQRTQ1jRiNEVQDh6EWOIjdc/yv2r7HRwS0pQSpFF5pF/ejJDtwnbiaIwdHagLdiKNL0CZN/x/6yP7H7HGxxYWFhYWFhYWPz6W4G7xk8G6obD4IVpDCd5cXknrrnWU28OYsouA2sJgtYER8y/EWT75O+3jCxYgSDLOmRMxYkk6Tj4X1+9uoNs3mNz61fTefAv5G9cjCgK1V93B0toSjvFfg/uAg4gc+DB+sRXh9SMQjnsJXakg8fw90LWbZKMHva0dh2cbWlcKPSxhK0jhmxpDPOgG9BEXEPn5dPxTQginvEFiZxK+uh6nsr6/byYCyF4iYoD6tItRZYWw76Vc/UI3IwujnDWyFe2AG7njg52ck7uBYkeCuCaQ1EWCPjeC4sK0edAVD7LDjx4YSHtMJ+CUcdoVDMNEEJIIwquY5nR0YwiytAC4jZr2xeT5nbjtlxFLyazacxVJNc7EittYU30Cu1rKiaVUDBPiKY3pQzSOmfwha2vO5vWV3dx1qhOo4LYFVexp68GpdFLd7iOa0pkzaj3Z3igvfb0/AB9eOYNsj5srX16PYcI9p00kFEtz2J2L/+rztckidlnEoUgMLfRxz2njgTRXvryKYybns99QP1vqO3jmSxVRECjPqUM3nPTGCykKNFOeuwevI8y+Q95BEI4lngrQ2B2mPCcLuyLTEysgkpiJxxkm4LwTUbyAjGf9Q8Bzf9EbmYz4vleAv5CMYL8WWARcBUB39TMoLhFPXhldVe148wciKgEiLd34y0YRaW4h3FxD6dRDqF78FoIkU3HAPCoXvkLekPEEyoaSCHdj92cjSzKaobGyZQXljkJylSxWhDby5vu3cdNh9xMsHsTDL19EoqyAS8ZfQvuu9Vza9igXZh/NSLmE7iGFLHn5Vg4ecwLOMeNYffMFtE0eTLPew4TPdrFuUg4D43by4iql0yuoX7Aef5GNnGEqHTs0Bh1sY/CBFfTUBtn8WiNTLzwBh38Ym19dTPPGzRiahpaMkwr3YPP6SUVCmYSPksLwI89i4Iy5bHv3SRpXf86R939M84YvWf3E7zJirCAgiBK+ogGE6ivxFpTjKxlEtKWWmdc8gSu7gF0fv4CvaCCFY6eTjPTQunk5ssOFYLejKzKaIqDLEqVZA1EcbqoiNUiizKDAIGJqjC8bl5LSUyTjYdTGOpIlBYiLv0RXU7TPGEORp4hzRp9HWk9z0RcXcvaoc9iveAYf1XzI45se/cHfntNHnMmJw05idcsq/rDmdp459DkC9gAPbXiALZ1bUEQFWZSRBRlJFJEEGUmQkESJC8b+giJPEYsbFtEeb+ekYScD8FblG4iChCJl1lVEpX87iqjglF2MzhkNQEOkHo/iJegIohoqKS2FQ3YgizLJ3i52vPcnRhx9HuloL4Io4i0o/+Ef0x/ANAzMVAqjuxttzx60XZWou3dn6spKzEjkuysIAoLPlxHgfT4EhwPB4QC7PbNst2ci5v1+pPx8xLw8pIJ8pPx8pLw8BKfzn+6rhQX0PQVh0j/JIAgCZloH3UBwZhIvG6FE5umBvWVve6OvFkAsyow7jYZecCmZ5L2xNEZND0LAgVji/48dozU+trCwsLCwsLD48ZH/0x2wsLCw+G+gIODk4iPGkZwzmo83NbFs1TqGaF2EnRNZ98kayoR3GVSSQ/nEQ1AKRiJMmsry13YzcqBE4cgB5C9ZxOb3drDu6a855YljKDzu2P5tB5QYxx4l4jm1Hq22jh1XPcC0e09FGDGf+NL16KF1eCc7YNMGVPNkPGefjaPhFjT3GEIfRHGccSxm7+fEOwegPvNn7JNHYebHSVUZpLfvwKNvJ96eR7zKhyiGsWXFMOImCU8Cr9tA9yWRbU6mFTgo/uoRTL2T6NTfUbV6C279KkxnGy4hY8iyF4Fv/kHEflHF/Ed3817BfTj9Nt4f+ggPf7COhTn3gP0JmiMCusvNgEFDqFCvY1snlA7y4M8rZ9KALLY1SRQ0HspR5YN4blkLh5cmOHdgC9uaw7zyQQszhfHs49/J6EkiaHdBcgLXHfgb8HYCt0HnwxCYiC7uQkvFOHnMcNKIZLkPA/MaLjp4JpLQCryPy344d54yAYeyB00XCcVLUXUNl62K7lgO4YSLfH8UWANMxu/KxmNXAR3VKMEm1yEJSWo7StEMmDv+NSZWrOOqV25gavRjinIrqDjzt2xr6sSpnI+qT8OuXM09H23i861f9Z2xw7DJDXgcLQRdIynL+R35/gQnTcumMKBR1dZCLBVibJkERFlXoxJLtVMUrKPQv42mnjAORaKw/DMUaTcAOUO++WyyBvZdV2UQKFsMCAw6cAuZT1Bk+KFHArcAHtxZHjKivgdZdDCjWAHCQA6zfQcy/YJ9sctbgQSnn3I3kMbtzKIi+wgej0/C3xd9He3cijljOqMmnYwgCDxzygy8Ni+3jvoV28Z8xivNT+Nrd9HZ3MLzdJK9Xx45hUMYUjqK1JidaH6dQeZQAuWNjLmkEZvjWSDN2JNh7MlgmrkIwgB6U+NI63lEVqdR025qh5Sx47qbcAWyKdjvMFp2rSMZ7cWVlU/B2OkUTZhJZ+VGtFQchz8H2Z4RWGPtjYRbakEQ2PP562x/9ymGHnoqOUPH0129nRUPXcn3sbavLt/vSEYcfR5tTatY8fDVZA0azdRjf0HlVy9Rs/QdygaORk3GMDSN4XTQseNjFg9cia9kEH+ccRnZxaPprt7GgG1tvHv0+2iGRtXSd0mGuzAkAUORMWwymiyRk8wmVF9Jrq5w9shzcMkuDENnVNZovDYvqq6hmxq6qaMZOoap9y1rSELGsqQ70UVLtBnICITvVS0gqSdRDRXN+OunOYL2IM8d/iIANy+/kVmlB3L6yDPY3rWN3319HRU1EQRRpKcki9mL9vCqsYai3R14umK4LrmU48uPJkSCRzc9zNmjzqXMV8by5q/Z2rkFm2TDLjmwSba+SQIJWZARBZGxuWMpcBfS6hdoGuZkn5nnA1AfrkM3DeTuXugOQTgKkShEIpiRKGY4grc7jpBKYyQTkExhRiMYnR2YySRGKITe1gbJ1HeOU/B6EWw2kCUEUQJZBklCkCQEnw+5tCTjR19SgtS3LBUVZURVVc143afTmOl0ZhkQnC5ElxPB5QKb7SdnNfRTQxCEvgeSvvmcBZtEJvdIBjHw90/siKXfCOuC24Y0Ov9H6KWFhYWFhYWFhcV/G1aEu8VPBiuCx+IfwTRN1u5q5a3PNxKIb6TYpZOw5SGZaUqMWsoad9PeNJCKX15K0ZhiFIeMoRtE2mP4C71/c7upr74mdOut5Lz0IlJ2NuH7H0BvbCR4152QCtP581/jOm4+rqOPJr11G+Hbbyd47z1IBQVEHnkUdds2sh59BICWMeNwHjufwC+OJb27jq5Lbybv3vORFl9IYtqbGFETh/ohol0mmXU6YtCL/Z1JcPSfYcJZxO+5EHvvG4Tbj6YrDr1iNxXtzWg9abb68nClQ0x9/FaMAQew+BfXMdqzh8KLzqdKG8mKS6/mGP8nCIpBS04+dilNvh7CdECvy0mQCErxWBZMfIu73tvKMulohMPvZ13PeEqW3UW+/O73n6CADQyT6LBfs9B9LIeab+D++n4+O2AZVZ02zg/djFT/YSbB3bhszNoYZgj0ybnIh+XAfR20HPwcnkGv4U20IXyq0z3vRbI8B8KKLNgjwkAN9gvBO4PBkGFaI0gmrBwEx/wJmAI7hkPqYOIjpmFPbEX6aiGRlt2YkWa8ww6BZCc4t0LOdIR4IT2BbFpyp9MVysVd9zGN7vF0mlkk4xEiKY3etMyFc4ZQlu3mmSVVbKzv4cEzM09NzLz1M1Kq8b2nQ5E0CgMar18yAYjy5KKNjCyWmDHMS1c0zJ+WjMRpszO+7CtkyU53bDZ+Z5hRxQ+iyHHschxFjmOaUSCFIGh91/cEBOEpMtY604CbgCPJ+Ov/gYyY5CZjo7PX437v8rHE1JmIVOJU3sU0ryCUUvHYvkakhZZYN3XhFqKqRlOknZZ4N2ldwDTt9KbyaYn1Mip7IGNyS0nrTbTG1nDGyIMIOqK0xNYStEdxKWr/OYhF3bjcI2iJOViwZxNnjf49TnkkD6x/lria4Nqp1wHw8o6XmFo4lUGBwXQnu6kOVTEhbyK1S9+ltnIVBcf9jJpbL6ds+hHI4yew6Xc/Z8oFvycVCbHp5XvY77IHqFn8Nj21O5h+yV1sfPlePHmluHMKadqwlPGnXk4qGqJp3WIkxYGpq+jpFOlElEhTNYrLg5qIY+oqc+/9kDV/uoXm9Us54bm1fHHzz4h3tZDo6UBPf9dW5dsc+/RymtYtYffCl3EG88kbOZmsQWP4+r7fYKhp7N4Ahq6hpZN480tJ9LQjyDZKJs3GlVNI9uCxVC95B3/xQAYdeDxt29dQ99X7BIeMpbexCk1NkjV6Cm3rvySrcCA5g8ZSue4TKg48noDNx8a3HkaefwydbzyPrqsI+88gbaRJo6PqKkYsSlnOECKPPcjoX97CO+YGzhx5FiXeEt7d8w5f1H9OWk+T0lOk9RSakZko0E0deyzNBUPO4sB9TuGNpy5hibiHh85+n2hrPb/degf18aa/eV7gG7ufG5f/Dq/NyxWTr6In2c31S65GkRQEWUY0QNR0BFVDTGsIqkZpys3pXUMxdY378jdzSFcBI0NutgnNLPG1IMTiEIsjGCaSZmBP6aiKhCkKjN0SZvS2CM2Fdr7cP5t577fiShis3idAa74d0RSQJQVJkpFsDkSnA9HuRHI6mZIsJsuTy54cnbBPZt+cfRCzs1hpViO43YiyjIgIsTiEw9AbwQz1IobCjOh2IHjc7Amk8buyKAqUkXDLVEk9IIkZ+xLTAEMH3cQ0DUqkbArGTUdQ+qKuDR1RlKha9CZ2XxYlkw/ENE1rgsDir7DGxxYWFhYWFhYWPz5WhLuFhYXF9yAIAhODIkV3/JzkY39iedYQdu2sIie0EcGRS135UOTSFKkVd1LzocqQg46kaPrcHxTbAaLPPosgy0jZ2QD4Lv31N390+Ml5/tn+l7bRo8h5+aX+195fXvSdbQWfeJyuE0/CefDBpLc14Tr2WIR9zoAJR5K88R602lrc1x+O0dtN92mn45h3FPZfvko67KX3+BPJuuUCpAYP9th08lvbGOx6HVwVxOVTOGBQMfKCGZjpXiRTYPbJZUib34bBhzEglab0BCcYx6IGj6AwlULuXEDaHIqe9GKLdZDMdaCc+3um9SZ5ufYh0sf8Afuk8xn17ovYhQX0bBhDqtWBo6QLxd9LZGsum3MH4E90M/qomewuPZ3732lm8BsLGfXye3SGcmj/+nM6F65B9mTz9sTDGb15F8O7dtMRyOHL5BSOeGYR+cfO44PdGus/ms4fq+7Ff+qxnPXEWk5qncgx0beICzZ215cyamETjtAeOhx+UrUuyrRelCIHv3puNfPtM9g/sZ6uoha2vnM+49Md+PUWknYnSVHGtfRpBElFtwtoNOBUBAKnTiJQ8DWJz6fjqvkVE688GUM9BnPRCqS6RzFHZcOzcdBtnONzgWSHR+0g2fn06GuJDzgcs/JTXFsfpP3w39ETG0n2mruQ03WkTTd8tgJsbsY0JsiKZ0Myn3jYYE9jF90pmU3rFeJplWp9KwIGeUxHRWbWqFKuOno89SGNUx5dziNnTWHCAB+Pf7GTF79eiCIJDMi9irSuAF9TkWNneNE5+JwppgxyUBgQ6QiH6QiHGVniBNJsbdBo6uklx9vF4PxaKlu7EQUvA3JX4HOuodCdptjzjbj/bd6qnMHukMmskhUUuFdw6eIgBk5OGbGA1piAYdroSvqIqG6ckgOHLON0awhCJ/kuuHBcHEG4FICLxnmIqbnApehGMbq5jLiaBJLU9m7h6S3Pct+sxxk0+1De8uwmsuMFfn7q5XgLKzhv9W84/eTTKBx/ABtb1rBqWj6HjhzPhJLBvLbxzzzW+yGXX3IPks3OVetvYN7Fv6So/ADqwrWscOzgvDE/J+gIsqljE+FUL8eUHADAju2LiW1ej83jx1c0EFd2AQB5I6eQM2QcuSMmsfvTlyne5yAiLbVUfvISE06/gl0fvUCobheKy0vNlwtw5xQzcNZ8vn7gMiaceQ2F42fQsOJTckZMJt7RTKSlBm/RQLRkAkPXQBCo/PgFhh52Oh3b11D1+WtkDRxN45rPqfv6Q+pXLcTUMpMYDUvfAzJpgQFkh5uhkw+juW4dras+Z87cc8i54s98ff9lNDz0UOa3qK8A9PTVG++5gkMOPYVw6ydsSacQlrzNteffRPbA0XxyzbE4gnmYOkRbm8gfux89NdsILX6YNZsqsW3cyjmzjyHR3c6HvzmCk+edga1sFk3vvoBn9ERSbU3oiTiesZOIV+1C8vpoWbGQxpULmTlqOPZgDh9cejgjzriMqdvjSNt3ET73ZGwr1qG7nSRGDETo7kHN9+LLKscx8FgEpxN52c3IU2YTGDYHY/VrmPVfEMvxMWDBCtpGlZIUTEoXbmHj3LH4W3vp1T1kX3MdNY3LaWczvuNvQ2zroMlYzWa9AXd3lK4sO45YCm8oSUOZjQG7mzB1KNvawNZEK40FdraP8KI98BDl9WmevnYo/nCaunIP3oiKpJv0ZNnJb02QcEoYisjV77fh607x1Pn5jN0SZu7HHVQOcfHSqSV05jrwhtMYokDMo+ANp0k6JE58vYlJZ11JxSEnUvnxi9R8+S5z7/mAxjWf4yseRMGYfXn/V4cw5cLfkzVwFJHmWnKGjicZ7kaNR/GXDGL7gqcJDhiBr2gAyx+8kgmnX4kgyVR98ToTz7yGzj2biXe1MnDmMTRvXIbN7SNnyDhaNn2Nv3QINreXRE877pwiBEn+XnFfT6cw+xJR99TswFdUgSDJpKNh3DmFGRuhf2BSYO/EQqS1LvN/sqCclk1f4y2swObx0bZ1Jfkjp5COR+ltqKRo4iyibfUYahp/6RBiHU3IDheK20esrQFHMBeARHc7nvxS0rEwajyKt6CMWEcTgiTjyson3FSNw5+N5HCS6O7AGczFNHS0ZByHPxtdSyMgIMrK330sFhYWFhYWFhYW/3ewItwtfjJYETwW/yimrqPV1CAXF/d7AUeTKquru1i9vQ6jaT15UgxD8YAg4jSiFHoFCgaNoXDIBLKysv5KOFArKxHcbuTi4n+9f6ZJ8qOPUcaPp33WbAJ//AOuY+f3/82MxRA9HgAijz+ObepU7BMmkN66jehjjxG47VbEQIDw/Q+gVVWT9YfrQY3TvN9cvL+6EO8kiVQoh86zLiP/3YeQQyuJbC9C3bOHrGN8ICl0PVuL84g5uGouQd/3NiKL2vAdmI246Feop2wDQ0BZdzmmINK9pAjX0UfhzKkm2ZlL1wVXU/DCb5Ai20mXX4wYDCJv/D1MOBuzdDo0rsXc9i7CIb9HEEWMt36BmVLRh12EqaWQtj2Ann8wpmsgRJsRezYgz7uehMND+oM/4E5GsZ3+B1bt6WDAu7/EbRtGl1HIirjE/mIbbl1mveqiWTc4Sm7Hd+MfeOnLXYz97GYGj5iBPv98ql+/ldylSzGWNGJmZWPLzsIIhdBUjRfHHM7E1l1MHe8lMTLEg8zi59ffTeHLT1JZtpDty3zMuuNRHAdLuP5QRM0lUQrau5B/nYcw0I52ew/OiaMRzw3Rs3MW8uPr8Z8gwsxmmh+ZS1bTAmzHphGKZMynmkFQEaZ7Eap6oCUOHhkuehO1bgDS8isQ8wTUQ+8mtscg8Pp4GOiF7hSE0uCSIcueWU83SWSN5qNpH6LqBvO/GMeq8t+wOuskSjo+Y07TXaSx4fd5cbu9tCVE6nphyrBSUFzctbuCt8KTyKODQ1jCexxGGC+j2U4uXehI3HL8eBw2kT8tq8TlhFOmlxJOJ/jlh36Sci6TCnaS646ypWcGdlucOaPeQVDC2O1RnPY4mhFGFjWcsolNMklqCvesHolP8XHT/qtojRaS1ooZEGzB79j9P3xTjiKuXglU41LOxjT/RHWvi2LP2zjkDzFMUA0Tm+hBEBzEVQPVkPDb84HzeXXnDvYtEij3NbK752ie2/Ys108bjEPWWNWynvZ4iKMGHQ/YeHjDE0zKn86+RTPZ2unhhuU38vicK8lzFfFG5Vpqe3dx5T4nAE4eWPckY3P3ZXbZETREGnly8+NcNP5XFLoLWdG8nJreGk4dcRoAn9UtpMhdxKic0cTUGBva1zM2dxw+m4+uRCcxNUaZL+OtnkrFSXV34AzmIEoKpqEj2RxgmuhaGiOdwjB0TF3DNAxkhwub24eajBHvaMZbWIEoK0Ra60iFezK+64aGrqkYaho9nerfTqyzBTURpXDcDNY/dwcjjjqHwvH78/FV8wkOGImpqcQ6m3HnFWcmBzQVQRAQFRuH3PoqWjrJ5zecRuGEmRRPOIBt7zxB154tqMkoptb3NIahf+fTzB0+mSkX3MKO956hevGbTLngVuxeP93V29j29uN/8yqQbA6KJhxAx671TDrrt6x6/HryR03lgKseZcFFs1GTcQRBxNBVBEkG08Q0dOzeIInudsqmH86UC27h9dPGUTRxFiOOOpsvbv4ZpfseTqKnjZ6qbYyYdy6tW1YgSBIl+8yhZeMyckdMpmTMDNY+83tyi4aRivRQs2Uxkycez86qZWi6yuDZx7Nr8WsEho+nePYxrP/jJUw+53ckRINtT9/GEb99ge2fvkDL7rVMOf06Nr37MIrLx9BDTmflE9dSsf/RFFSMYcVzN3PIba9j6iqhukoGzTmx//jVeITKj1+gfMZRtG1bydqnb+H4P69mzdM3EW1v4uBbXuLzG0+nePJBDDnkZNY8fTMjjjqHZKiTTa/ez5ybXmDLm4/Qvn01h9z6Kp9eewLBASOZfO7veO3UMUz9xe148kv54qYzmHvvhzStX8KO95/h2Ce/Yu0zt2KoKaZc8HveOmcaI44+l5J95vDhb45gzs0vEmlrYNWj13LiS5vY8NwfCNVXMufmF1n6xwvJGTqBYXN/xue/O5Vxp16OzeNn3TO/Z+bVj1P56cvUfPku8x76jEW/Pxu7N8h+l97L62dMYNypl5E3Yh8+uXo+h9z2Ot3VW1n37O2c/PIWVjxyDbH2Rubc/CIfXHoYxZMPYuTR5/H2edOZcfmDiJLMl3dexDFPfMnuT16i9qsPmPfw5yz6/dk4/NlMv+RuXj99PONOu5y8EZP55Opjv9nHn2/j5Fe2suKRa4i2NXDwLS/x0RXzKJ58IMOPPIsPLjmMaRf/AVFSWPHwVRxx93vo6STu3H99TPDPYo2PLSwsLCwsLCx+fCzB3eIng3VDYQGw6Z3taCmNSSeP/ae3EXvhRcTcHByHHsquljAfr68ltGMpQ8R6XHaFbqUUQ5Cxiwbl2XbKy8spGToRxRPo34be3UP4ttvwXXM1Um7uP7R/U9PQdlWijBr5zfZaWpAKC//pY/rO9g0DNA3BZkNvbSW59Etc845CcDqJv/MOelMz3ot/CUDouuuxz5yJ85CDSW/YQM+vf0P2s48g2+OEHnmX1OrV5L/zPDiC9Fx5LY7DDsV52GGYiQTpbduxT54EQPuR81DK8whOqkSfcAmxz2pwT3Uirb2D1Iw3UbfuwDOsE2we4g0FiEEXju2/wdj/98TXhnEO6EH68gpSh68gtWIVvoqNAISrxiAG3Hi6rseYcy+Rhc24JyrIyy9HO3Ur6R17cEWfAlEmPfJmBElAeXMc2pTb6b5/KdnP/hmpqBAjGu2fvPg2kQceJP3xw7jmBXhl6DOcOXM40uLr+EofT6s8mnnubrSuZn63y8t8X5zxRhcrhTCvCNncXlVD1knH8H56BZW7/Vy4fCnBa07h5HdbmNfSzmHVH1E3zMUrFQdy7lML8Ca78H3iYfOfg5Q/toXCLfch+v/Ixl9OoNyI47w7h5jaQWTc13jy4wSWllP1uo3cZ6tQ9nXhvT2bmksMckUvnt9OwszNpmPeagInVGCbn0tqTymJx97GMaAOeZqAtlRHUA3EchPBbkBtCtHrgP3OIZZ3AqmPnyIr9DBdp68g2mGQvfpyfG2f/uC19eH4F6l2TmafmrsY2r2QPw5cQCKtc1vtwXiNEKpgR7E7MWUHHXETu1NBUkR6NTgrcAqiHOOaro+odnp4t7CE0nSEC9t2odtdZBX5yS31gF9Ad6fw5BgIIui6QHVHKc3d+QwQq9nRO4peM59BnkryXS0gQp7PgU300tqjkDRMKgqcIBl8uOkg2hLjGZq3mMH5S/lix82IoshBI2/A62pBEjUUSUMQ0sB3heHOxLusatnIYRULkMRcvmo6nHBqB0cMfPKvzoth2klo4JA9SMJ43quazvauTVwzZStwMb9e/AbzB+cxq7SbaFpjZcsGJucfQMCRz9bOXVSFajh68PHAZH616EmmF1ZwyohBdMQnc8vKP3Dl5GMp82WzvbOanT01HDvkZEDm3T3vke3IZ/+S2fSmNJ7Z+izzBx9DhX8Atb11VIV2c1D5wQDU9FZjl+wUeYrRDI3acA0FrkI8Ng8JLUFSSxKwB350yxLD0DHUdKboGoIkYfcE0LU04cZqPPmlKE430bYGIm31mLqGrqaJNNeiuL0Yqkpvw27ceSUEK4ZnrF8kiZpl7zPp7N8iyTb2fP46yd5OBFFGEMX+SQZD1zA0DUNLM+yIn+HKLmDtM7/H7g0w8pifE27cw+onb0RLJTE0FVPXMDQVQ1cztaYSKBvKoXe8CcBrp41lwplXM3D2cTSsWsjKh6/+wWMfftS5DD/yZ/TW72Hxbedw0I0vkDdyMkvvvIjmdX+dHPrbHHTjc+SNnMLm1x+kad0SDv/j2wB89rtTUBNxBAEUlxddUxEEEcXpRhBFJJuD/S9/EICNL9+Dr3AAA2cfS6yjie3vPpXxvxclQEAQRURZQUsnkG0ufEXluHOKCZQPZdu7T+LwZjHymPPZ/PqDJLrbyR0xmZ6a7bhyCnFl5ZPs7caVlZexWRJEKmYcSf2qTwnVVTLm+F+y88NnkWwOsgaOZNeHz1O272FINgc1S99h5DE/J9HTTqyjmUFzTiTaWg+AK7uAdCySOR5ZRkvEsbm9mLpOOh7BGcgh3t2Gnk7hLSijc/cm7N4A7pwiOis34CsZjCAI9DZWkT1kLMmeDpLhHrIHjSZUX4koK/iKBtCxawPu3GIUp5uu3ZvIHjyWVLSX3oZKiifNpmPXBrREjMLxM6j5cgGevFKCA0ZQ+cmLlOwzB0EQqF/xCUOPOANT07B5rKSpFhYWFhYWFhb/l7AEd4ufDNYNhQXA+te3oKV0ppwx/u9qH33qaQSfF/dJJ/W/13X+z5HLyvD/7vr+9zTdYPnuTj5dX4O5+2P2U7bid8i02IfToxQhmWmKtGoq7CEqsu3I5BF6ZCFZLy9Aysv7h44h+tzz9N5yCwUrV/yVWJ9Y+Bn2qVMQ/ZmbdyMUouu88wncfPN3BPp/B0ZvL0Z3N/KAAf9z23AYIxJBLi5Gq66h8+RTyHr6SWxjxxJ54knir75G/uIvAOg49jiUMWMI3HwTWmMj7TNnk/3np7BP35fY628TffIp8pcsAiD0uxuQiovxXngBemcnHUfOI/D7K3CUiERXhei96RaKv3oVRInO39yNmBUk68F7MFI6oSuvwnfVlT/Yf721ldTqNbiOOhK9s5PwHXfgH7QEcfolqM5pGJvewb7jt3BZE+naTuTNtyMmaogdtxBh2RKc288mNOlyuktPo7xtCfKSs9l9wjqyykaSveTXpOtX8erYtzltvwFIT07ic8dRLPPM58apBsKaOzmr5hCOGT+Zo+WlNIV2ctHumTw+Lp/8PXezWBrC18n9uNKxG6XnVf7oO4kRPdnMzW0lfECStXEX41+KkjP/EIzJD9C0bTrBB7cgjWiBszXqbiinqLUN6ZIEeolE+lwD/9ln4TrrBcK79id22PPkb3wSKXA9TdeORHjpM1y3BbFNsNEzvxUJE9/NflLLUqQWJch++QFs46H3D+tRV35Nzp9+BflFtE67CkdeG9IACTNmImoCyAKCTKY4bDgPPgTj4Ltpv+kWnPk70SYeQoM0gabPH2GQsJi0lEaTUggYKIaBwxDwigKefCfRIcPoKR1BvnsnAW8nhqCgmyKSqSMZKpiACNgk0Ayoj0JVGKojPB66kPfEI5mjfsxl6bs4xPYpminygPprXCS41PMM718xC4Bj71/EEeNyOW92KaACOWQSLbb37SCn7/09QBxI9NXfXtaBfOBoMv76DwCHAaOAr4G3MM0khhlDFNIIQgrdTGGaKrIIcA6rWwZQ7K2i2HMfPck3eKPyE84cuRGHvDcl7PcTST/OrStf47dTRfz2ZhbsOZZXd73CK3O7AJNIOgHIeG1Z6IZAY7SFHGchbqWUj2oO48nNj/POvP0QhAncunIVJV6Bs0Z5UQ2ThTULGZ+/D8WeMurDjaxr28C8QSciiUN4btt2ZDHFaSMGY5gTuH3Vwxw3ZF9GZOdSH27my8blnDj0VGyyi9Ut60jpafYvmQ0EWNqwksHBcoo9uYRSGnt6djMudxyKZKM+XE9KTzEkmMk4XNNbQ9ARJGAPkNbT9KZCZDmykUSJmBpDNzR8dn/fuYhgExXssgPN0IirMdyKB0mUUI2MNY8i/mtWIaZpoqspjHQKLZ1CTyf7SgpDS2MaBq6cQjx5JaSiIbqrtpE7fCKy3Ul39TbiXS19EwM6Rl9tGkb/kwvFk2bhDObRsXMd4ZZaBs0+DoDNrz1AOhbB0DJPK5jfXtfQEUSJGZfdD8DqJ2/AXzqEYYefQW/jHlY+cg2GpvW3Nwztm/V1nYKx+zHtottJhDr44NeHsd+l91E04QC2vvUYW15/8AfPx+TzbmTIwSdTvfRdVj16LSe9vAVRkvnshtPo3LX+B9c96qHP8eQV8/UDl5Ps7eKgG55FSyV448yJAAiCmJkokGREUcr4/Ysy3sJy5tycSR786W9PZPBBJzDooBNo3bKCDc//EUQRURQRRAlBFEEQEfpel045mKGHnUakpZYNL97FxJ9diyevhKpFb9K2bTWiJPW1lfvX2VsPOvA4/CWDadu2mq49mxl59Hn/0rX0r2KNjy0sLCwsLCwsfnwswd3iJ4N1Q2Hxz9Bz1dVI2dn4rr7qO+//UPK53niahVtaWFvdTXdnK87wHkptEfwOBWyZa68ovYvB8VWUuuK4Bh5A5JM9OC+8HWXUuP+xT6aqkl69Bvt+07/zvtHTQ+v0GfguvwzPeecCoNXWErrhJoJ/vONHi4D/v4Kp65ipFKLLBYDe1QXQ76//j6LV1tL9q18TvOuPKMOHE777HhJvvUT+s7fAgANpO+IYXNOK8f7sRDTbSNqmzyDvwZ+j7H8ckTeWEH3iYQoXL4BABR3HnYQyeiiBqy7B0J30XH4F/sPdyFNOQI1moy1/C6eyGI59keS6Xcgd7yMqPaiHPob+1TIcbQ8jjjkOveQI9F3LsdU8DvOewvAUIX76GxK7PuX3ha9w24njEB4YyEcczNdFF3Hbfio8NYVLXE9z4tFHMaPubmIbX+do7UEWXnMU4ieXsEgW2KQfzKX7TUTf9SyPtMYZHjyWg9Qt1EZX8FxyEJdmTcHbs5KuyWuoqZ/ChMhwlHER5JL76Vx3I+5mA/HQ7QjiOpKPzYZkAtcFC4iuL4fPKhCyenCesJ3InwYhxoIE754FVNL963rsU6fgPrUdtdZDzwVvIniSOI9MEn0LWtImXdMgPlzgky4nzcVORueliKXtsD7G4LHTKRkYILx0N8aStdhTOo6UgSOtUxZQKRoj4JhuxzbFhugSwfChNeWS/noXrlmHQ/7B9Fz/KFRtg4RAvLcQWZYQFJkdgTICpCk2k2Q98Rii30/k8ccRRAnPz8/HiMWI3H0P2GwIsgyKgrB32aYgyApibg7OQw8FIPH+ByhjRiNXVKC3taFVVSM4HQgOB4LTmakdjsz2FAXkv/TM3ju8E4AuIAIkyYj7GhlxX/tWmQp4gY1ACJiFbupIwquASjQdRhQMXIqCYaaJpLtxyXYUyUt7/BTqwrXsU/A+MIWvmgJk2RsYmfM2pqkRU8M4ZBuyCJqRRjeT2EQRQTiMBXtG41U6OLD8CXTjKW5f9R4XjEuS5/rsh7+/5m3MX/Awd+w/nhHZS1jdcje3rrqFd+Y5kcR6NAN0Q8AuOwCRSDqGTbRjl51s6byZ6766lVfnjsGlBHl8k5f68CZu3z8JyOzq3k3QESTPlU9cTbAntIehwWE45JE8uy2HFc0reOJgB3Ayv178KkcPKuTAsg4Saort3TsZFhyBx+alOdpKe7yT8XkTgNncuvIrJuYFOWJgD53xU/nd8ju5cdpECjxhGsJN1IYb2L9kJiCxpnUdLtnDqJxxRNKzuHnFo1w8fgYVfhvLm4O8X/Ued+w/EVBZ1bISt3IQo3Pm/1O/Xf8Ovpkc0PsFelPX+0R7E8XlRnG4URMxkr1dePJLEQSBSEst6XgUU1cxdB1D1zA1DdM0ME0DTJP80dOQ7U46Kzeiq2nyR03B0FRql73/3ckBXcfQ9czTC5qGze1j6GEZ26Ytrz9E3qip5I+aQk/tDqoWvdm3bsZayOyzGNp7HIXjZjBw1nzCzTVseOFOJp19PZ68YnZ+8CxN6xb17afvOL993IbBlPNvIm/kFHZ99Dy1y97rfwLiP4U1PrawsLCwsLCw+PGxBHeLnwzWDYXFj4ERj/cLtH/3OoZJezhJQ3ecutYeWpoaSHfX4yGJgEFxcjujEssoSu+GosnIvgEIpeMRcoZB9lAIVIAoobe2YkRjKIMH/c19aXV1SGVlP7qtg8U/jqnrmNFo/9MGWmMjgsuFlJWVEW0SiYxoKknoXV0YrW39TyHE33sfKSsL+4z90Nva6LniKvzXXI0yaiSRJ54k+tjjFG7MRH12zDsGefAggvfeg97eTuuESWQ9+2ecB8/JPA1xw40U19UA0HXe+Uh5uQRu/C2maCf62OO4xtkxh+2HVt1LauHH+C86GYKD6LnmeuQcBe/p89ByJhB74AG8uYvoGXY83YGDKKv9DNumy6g6Zgl+zU3W7kegcxUbD/6EMfEWlIVHsMZ3JGsLL+L8rEqUhcfzM/NBzjzxeA5qe5TEumc4LPkEi66bi/TioXxtL2SJ4zSuO3AsxsrLWJQlYdiu5RB/iI7eZ9kiKkwd9ADu3W/Qkfse1dHZTC05GfY8TGLwIjqj91KqC6S0hzBzm5DE9zB3vIk28El2hAaweEc2wxMrOfKoGLd8XUJVm8bhg0IcMEjlws9zALhyUi89vV6qdg5g2pgsJg5ah5h0I2k9iIE4mQj1vs9XFTHCDrS6IHqrEwSN9IYARr1C4J7rEd0xeu94G0GS8F11Inp3mM75l2BqKeQSFa1RxwilESQN7BpGSxpl7BjyPvoQgKbScgK334b7jNOJvfYaocuu+MHrzfvrS/BddSWpr5fTde555H3xGXJxMaHrf0dy0aKML7kiI8jKX9X+m29EGTaM+NvvoG7fjv/66wAI33MvGAaCzQayDFImQhdJyizbHbhPORmA5BeLEPNysY0Zg9HbS3rjxu/ZlwyKDUGREbzeb74LqTiCXUMQPYBMJjVriG8mA9S+2iAzUWAAQ1ANP9CAItaT1qcTSUcIONYjCb0k1CgGadyKCzDoSnTiku04FQfh9NHs6aljTE4NiuSiLjySuNrKiOzPAY2uRAcO2YFbcaHqaXrTvQTsAWSxnKrQwXQkOphW+A5wHAtrQwwJ9jDAv4q0nqYj3kquKwebJBFO9ZLQYuS784C5vLvHYJA/wZjcz4ikbuDN3Ys4YWgrHtsWElqMlJYg4PACBjE1giSAQ1ZIaLfz9JavOGNEhICjkk0dl7OscSkXT/gUiJHWVdrjZ1DivfCf+amy+IljjY8tLCwsLCwsLH58LMHd4ieDdUNhAaA1NYOhI5eW/lPrd8w7BmXsGAK3/v5f7ktrV4gV67fR2liLpMYwDQ1/ooay1DZGpVbhN7sB0AUbaV8FWpeK2Z3EfcSxSJ48cOVkiqcAckeCO6d/26k1a5AKCzHaO1DGj8s8Dm/xfxJT08A0ERQlE8HZ1YXo8yE4HOjdPRgtLd8I+W+9jeBy4jz8cPTWVtoOOpisRx/GMXMm8XffJfrkU+R++AGCIBB9+k8IXi/uk05E7+igY+5RBO6+E8cBBxB99jl6b7qZ4tpqADpPOgUxGCDr8ccwolFaho0g+NBduI48iti7H9F75aXkffEiza6RiH+8C5+9A/GUudTmHEzpK3/CM6KH5twJhOVRDNjxGc7kK6wY9QeKTA8lzS+iN33EkyPe47wyE8fSM9gqjWZR8ZX8aoKA8OQYrpDuYPbcUzky/graklvYX32NT646CP8rB7JZzeJPrit44NhhcH8hDxX+hpKx5zPfXISx+VruKriU+VMuJH/h2XQPjvCeMZzWuJ3zd75O/KgKHt+TTXF7mtOyW0lNLKY6PI+JsfV4K6pJSgECrgAZm5h03ycSBDxAI3Bk3/JSMtHjJwI+4ErgNuBQ4H3gZmAlpiEiiFcBAkbkBgSbhGA/HSNxPkbLcBA2IgY/QN1+GmbcRMxeAaRQd49FGTEc25hdaC2FJBZswX36XERPG/H361C37gYxnrlWon3XjJTATBqQMPBedTHKIDfR5xaRXr+FrAfuBQTaDz4UIxTCTKUwdQ10AwwD9EykruByUrRtKwBtsw7EPvMAAjffRGrNWjqP+eFoa8fcuWQ/+Th6cwut+0wh+8XnccyeTfj+B4g+/EifwJ+x/0DO2IEgSSCK+K+9BueRc0l8/DGR+x8k95OPEASB0DXXou6pQpAkkCUQJRAEBFEAIVMCd9+FlJVF9KmnMZNJvL+6GDORIHTjzQiyBLICYsaffO/+EASkvDw855wNQOSRR7Hvuy+2iRNQ9+wh+enCzPb38p1lsI0bh33ffdHb20l+8inOo45EDAZJrV2HXlcHkgh9VidIGeuSvU8o2CZORMrJQd29G72pCcesWQAkv1wGqprZlyigDB2GVGQ9xWTxj2ONjy0sLCwsLCwsfnwswd3iJ4N1Q2EB0H3BLzAiYXJefunvah9/4016b/k9BZs3IggCiU8/RQwGsU+Z8uP2q7ubLdt3UVNTQzoRBUBFJh2PIMZbyE/vJtdsJ0AYP2GCQhg/vcjfStSYdOSj547GUTCGyGNvo4uFJNc3kr9s2d/lo27x0+SH7JH+FkY0ihEKIZeUAJnofQQRubgIU9dRt29HLi1FDATQu7rQa+tQJk5AEATi77wDgoDrmGMwwmHaD5yD/5abcR5xOLHXXid02eUU1VYjKApdZ58Dhkn2c3/G1HWayyoI3Hs37pNOIvHBh3RfcCGF27ci+v30XH4FRk8P7ieeJJbUSM7an8CVl2E/4URSS5YQOv/nFKxYhhrIIvrI48gt27GfdSRV/v0peOFJ/EN6qc8ZQrW4D9M2fIy7eAuPp/dFdEsMjiylrGcN1xbNALGTs5o2oQsizxaNY4icw6DCYVQ2dDO7zMMhFSb27B6gO5OAWIghCCEyHu2pb51FG1BOxrPdCczoe90EuPtea8AjwMHASGAD8Dzwx7717wViwO/ICLQzgCuA+cCSvuXPgQBwY9+2n+7b/wzgYuBkYAXwK+ADoAD4A1AN7E3weh1wIHAQUAv8GbgEyAYWA42YieMz4rbjM8x0KXpHLujdYNuA2TsSM21HkOowhS6MzkFIWVkoo2wYCRvJT9Zhnz4VKd9Het1O0hs2YRppMFRIZZ4WgSRm2gTNxDn3CGwTJpBas4bE2+8QuON2AML33odWUwOahqnpoGcmozBNTCNTBx+4Dykri/C992Emk/h/ey1GNErniSeBpmNqKhgmGEbm8zMN0A3kARXkvPIyAK37zcD7i1/gPv00Eh9/TM8VV/7Al8XE/bMz8V9zdWYi4rjjyfviM5QhQ+j5zWXEX3/jb68LZL/yEo4DDiB8193EX3+DgjWrAGiZOAmjrb2/XeDuu/qfNrCw+EewxscWFhYWFhYWFj8+luBu8ZPhP31DYZompHUEu/xv37fFN6hV1aBrKEOH/n3tt20nuexLPOeem/FJ/jcQj8dpbm6mqamJpvp6ookEIGB3OpFsTkzZgSbaSBkKaU1FjXVjdOwgJ76LwdQwWKilkLZM/0UneukMHEPmwIADoXBCJurTwuK/ENM0Qdczkc2CkImuNox+6xF1w0akslKk3Fy0pibSq1fjPPJIBEUh8dnnmIkErnlHAX1RyPvPwDZ2LFpDA8nPPsd18kmILhex117H6OjAe/EvAWg//AjcZ52F+6QTSa1YQffPLyTv00+QigoJXf870uvXf2P1Mn4CyfNPoue4g6ja/hWVX7xB64wRNKXaMTAAyHXmZpJsbt+NO5CLZ+hIHHEVcfEyhh99GMMHF5NTuQoxsgPH7AqgDuj85jwYbvQmATEwFtE7HLU2jl7VieOgeYCX9Po9CO58lGGTMVUBra4eqbgI0enENPRMckch1bfNQkACdpLxcB/ft5clwCCgFAiTEdhHAHZgDdBNJgIf4HoyYvvsvu3cDdwB5JIR8LcB9/W1PRqYB5wLbAXOAl4FBgMPkhHo3+lrO79vm5eQeUrgZOBZYDQZsf8d4OO+tqf09f1qMhMHp/btcyLwNvAm8HJf2+uAEuAXZKxpLgYuByYAX/T156m+tg+SmeA4t+/8XA+c3revjcB7wG/JWN28S2ZiYz4ZW5v7+s7RaGA38BFwAeAgM9GRAI7q28+zwBQyEyeNwOeY6nzQbJisBrMXM7k/GDqC7VNMbRAYgxF9KQTbKozE/pBSEAP1QCd659jMd8X2JahFCO7xiG43Fhb/KP/p8bGFhYWFhYWFxf9FLMHd4ifDf/qGIv3SZrBJ2E4Y9W/ft8WPQ+zVV5EHDMA+deq/db/hcJiWlhZ6e3uJRqNEo1EikQjxeJy9P+FOp5PcvHwEVxY9hpOmzl5SzZsJdq1hgrmR8cJ2HCTRFB9CxQFIpdNAjUOsA2LtEO+rYx3gyYfh82HEsVC8z3ftESwsfuKY6TSIIoIsY6bTGN3diNnZaCLUVK2jtquSVr9JXI0TrdtN0imTcikk4mGiXS10OFVUU0NEoCTpYviwGQwODqHonc8oG1VG4JDR6KGtpFe/jX2/MkR3N6bRgSB+/3DN1PJILmpAGX4Ectls4m9sJPT7FyjavA2AzjPORC4rI3Dbrejd3bQffCjB++7BccABxBcsIHL/g+Qv/gKA0LW/RXC78V9/HUYiQeexx+G7+iocs2aRWr6C6DPPkPXwQwgOB4mPPgYBnIcfjmmaJN5+B9ukicgVFWhNzagbNuA45EAEm4Fa2QC6iTKiHEijVnUj5WQj+rsxkxJG1IUYlBGk1ZjqBJCyEcRqMsL0rL4j/YqMXc8oMhME7wFzyETkbwDWAef1tX0FyCIjhkeBh4ATyIj+a4CFZER5yEwYeMiI/QngGjKTBBP69vlMXxsRuJOM4H41GS/5U4CL+vr4NXAP8CLgIvMUQpiMdRDAXDJi/DxgJRkR/w0yTwn85RMFB/X14QxgLZmJg3fITCLcCawnM2kAcASZSY4Lvvf6sLD4n/hPj48tLCwsLCwsLP4vYgnuFj8Z/tM3FHp1D4IkIJYH/u37tvjnMVWV9Jq1yIMH0XX2OThmzcJ35Q8nL/x3YRgG8Xicnp4eWlpaaGlpob29HdM0cTqdFBYW4vb6aYuZVHXECTdupSi6gcnmOoYL1aREN2ExSFgM0Cv4CQkBQvipEJqZlP4Kl9aD5ilGGjkfYcRxUDYDJOsJDQuLfwXVUKkL17K7Zze7eyrZHdpNQ7i+Pzo+aA9S6Cmi0F1IobuQAnchWY4sXLKIS9FxKTr2VBhZSiK5UpjqbszYJgRfO4KYiZLPeMGXAxWou1Kgl6CMPBwjlkv0sZdwHnMMyuBBpNasJfnpp/1JUqPP/BnB4cB96imYySShG2/GfcpJ2MaPJ7nsK6JPPkn2c88iiCLdF/8KDIOsRx/B1DSaywcQuO9e3CeeQPy99+n5xUUU7tqB6PHQfeEvMHpC5Lz2CgBNFQPx33QjnrN+RuKzz+k+62wKNqxDysuj5/IrUCt3k/f+AgBa990PzwXn4znrLNLrN9Dzm8vIfvlF5OJiIo8/gbpjJ1kPZKLru849D8chh+A+6UTUykpCV19D8L57kSsqiL/5FukNGwjcdisA4T/eiTJmDM4jDkdvayPy6GN4zj8PuaSE1Fdfk968Ge9FvwAg9sqrSMVFOA44ACMcJv7qazjmzkUuLiK9dSvqlq39di6JhQsRfT7s06ZhJhLE33sfx/77IxUVolZVo27ehGt+xt8+tWIFgs2ObdJETE0juXgJtjGjkQoK0FtaUHfuxD5zJoIokt68GQDb2LGYpkFq6Zcow4YhFeaid3SCDlJBwf/25Wvxf5D/9PjYwsLCwsLCwuL/IpZyYmHxb0IaGPxPd8Hin8BUVTpPOJHgQw+S+8H7oGn/6S71I4oiHo8Hj8dDaV8SWFVVaWtro7m5mZaWFpqbm0kmk3gBr9cG3qmsYxqrRAVVcqMpHky7FxxeZMWOLAp8Fk7xUGMnOT1rmRX5mtlrXiN39cMkZT8pdymmKxfRm4/dl4/NX4DgyQdX7jdJXF054PBbkfEWFt+DIioMDgxhcGAIhw84AoCklqQ2XENLtIWWWAstsWYaIg2sbl1NJB3+3u2Igohb8VDkLqLEO5FSbykVvmzKfRpBRzcCtUAdyrA6YDnwOqIbfFf4ySRxlbDvkykZexYZzzkeMhYzLyM4ygj+8SIyljTg2H8Gjv1n9O8/6+GHvumMJFFUvSeTZBRwHn4Yju1bEfosTvw335RJ1NpHzmuvIJeXA2AbP46sPz+D6PcD4Dr5JMxwpL+t5+yzsI0blznmQADHgbMRXa7MbnNzMaPRb7pRXIzozwiGgs2GVFqGYLcDYGoqZuobD311927EvDwAjEiU1NIvcZ90UuZvO3aQ+OijfsE9/uab2CZNygjuPT2E77obZewY5OIiUl8vJ/rIo/2Ce/ThR5GHDMY+bRpGOEzossvJfu5ZpKJCUsu+pPemW/oF98j9DyJmBcma9ChmIkH3WWcTfOxRXPOOIrnsK0K/uYyiuhoQRSL33Q+mSfazfwbDpOu0M/rzGaRXrsWIRi0PdwsLCwsLCwsLC4v/EqwId4ufDFYEj8U/i1pVjZSfh+jx/Ke78k+h6zqJRIJ4PN5fIpEInZ2ddHR0kE6nAfD5fOTm5pKdnY3P50NQnDRGTXa1xAhXryC3bQnudDsBegkSIkiILCGEj+hf7dMQZDR7EMOZA4FylJzBSNmDITgQgoMgOABEBXrroGs3dFVmSvdu6KmB/DEZW5uhc8FpTVZZ/HSJpqP0pnuJq3ESWpyEliDeV0fTEZqizTRGGmiMNpDQEgDYJDslnhLKfRWU+8oZ4Cugwi8TsIcQhEYyyVt1MklZ9W8t9wINQD3fJHiVyFiZlJFJ6lr2rZILWBNrf4v+nASiiCCKmUkHVUVwOgEw4nEARJcL0zAwOjsRvV4EpxMjHscM9SIWFiAIAnp3DwBSVhDTNNGbWxADfkS3O7Mdw/j/9n+UxX8Wa3xsYWFhYWFhYfHjYwnuFj8ZrBsKi3+F9sOOwHHYofgu/fV/uis/KqZp0tvbS0dHR3/p6enpF+EB7HY7Pp8Pn8+HotjQEEkbIgkN4ppANKmSjEdIxcPosQ5IdCEnu/CZvWQRopB2immhSGjFzjfb1QUZycxEvWqCjW57KZ1KGSGlgIHp7RREN2EKMkb5TKSR82H4MeAr/nefIguL/y8wTZPORCeN0Qbqw/U0ROqpDddSH64jqScBcCtuyrzleG1eHLIDh+TALjlwyHbskgOvzUueK498Vx55LgGb1EImoWsdGRG+HmghI9ADOIEiMj7kATK+6cG+kgX4IPN8DRmfdBcZL3QLC4v/FqzxsYWFhYWFhYXFj48luFv8ZLBuKCz+WaLPPkfsxZcI3Pb7f3vC1P8EpmmSSqUIh8PfKZFIhHQ6/Z3yl/9CnE4ngUAAn8+P3eXBVJxE0ybhhEYorpKKdCCEG1FiTZhqnE6pkHZbKWG5AEmWkUUBQRBoDSVQQw3MMFcyk+VMEjYho9PlHIThLkLx5+EOFqH4+uxs3HngCIDdB3ZvX+0D2WFZ21j8pDFMg/Z4O3XhWurCdTRE6ompMVJ6kqSWIqknSWlJknqSqBrFMI3+dbMcWeS58sl35VPoLqLIU0SxJ58iN7htnWQE+CYgBHQDPX2lFzD+ujOIZIR3PxmhvphM9Hzxt5atKG0Li38n1vjYwsLCwsLCwuLHxxLcLX4yWDcUFv8soZtuBiBw043/4Z78d2GaJrquo6oqsViMUChEKBSit7e3v9b+Ds97SZJwOBzY7XYcDgcOh4OcnBxycguI4qC2K05Tcwuuuk8Idq/FluokYPYSoJdssRevGUbk+/+VGYKEKnnQ7QFMRwDRlYXNnY3kzgJHMCPUewvBWwSewsyy3ftjnyoLi/8v0A2drmQXbbFW2uNttH2rtESb6Un19Lf12/wUeYopcBeS48wm25FNtjOHbGc22Y4AfruIKESBCLC33lt6yAj1e0vsW73w840A/+1SQCaiXgFsfUXCsrSxsPjXsMbHFhYWFhYWFhY/PpbgbvGTwbqhsLD492KaJvF4HE3TMAzjr4qmaaRSKZLJ5HdKIpGgo6MDTdNQFIXCwkKKioooKioiKyuLtGZS2xmjuj1CVXuU6tZeutqbEdNhXMRx9xUXCVwksBtxbGoPPiJ4ieIjSkCM4ReiBMwe7GbiO/3WZDequxi5dBrKgP2hbD/IGW5Fylv85ImrcVpizTRFm2iONtMcbaI13kJXoovuZDe6qfe3lQQJr82LR/HgsXlwKx48Sqb22Xzku/LIdxeQ78ojy6kgCc1AI9DMd8X4Nr4/Wh4yYruNjGVNLpDTV+8t2WQEeqmviIDcV7v72rh+3JNkYfH/Gdb42MLCwsLCwsLix8cS3C1+Mlg3FBYAjRtbMHSDskmWF/h/M4Zh0N7eTnNzMy0tLbS2tqLrOpIkYbPZsNls2O32/mWbzYamaf2C/d7aMDJCncPhxBsIIjn9aIqHsO6gI2HSE0uTioUQY63YEq3Yk+0E9E6KaGGssIPB1CBioNqCULovSsX+kD0kY1UjOzO10lfb/eAr+g+fOQuL/wyGadCb6qUr2UlXoouuZBfhVJiYGiWqRompMaLpzHJvKvSdaHlZkMlx5ZLvyifPlUeuM5dcZy45rlxynQH+X3v3GR5HefVh/J7ZplXvtiy5yb13Y4NN74ReExJwEmoCpEACpBBIAoRACCQkECC00HsH0zEuGNu4915UrN5WW2fm/bC2wC/GWELW2tL/xzXXrrRzZs6slvXsmWfPk+O38LlqgRAQBSI7bsM7buuBKqByx1JFvMXN3pzi7iy87yzY5wJJxIvyrv+3eHY8trvFv2NbKTvWEzkw6PxYREREpP2p4C5dhj5QCMC7f51BpDnKSTcelehUpBUsy6KiooLq6updesiHw+GW+263u6Uljd/vb7k1DIPq6mqqqqqorKwkFIpPIOn3+0lNTcXlcuFyuXC73bhcLgzDJIaLeieZDdUhmjd/Rq/AQkYaKxhprCLp/42I/zKn8CCM8ZfCsHPBq5GzIl8nbIWpbK6It6wJlLe0rqlorqAqWElduG6X9dO86aS4k/F7kvG7/SS7k0necT/Dm0GOP5fcHUuOP5c0jx/DqAdiOxaL+Eh5a8fPTXxRpK/40v0q4kV8azfLzt9/Ew/xkfMpxHvS5xIfbf/lJRsI7tjf/18CO+JTd7N4iV8M2N3yHeLFf5G9p/NjERERkfangrt0GfpAISKO4xAIBKisrGwpvluWRSwWw7KslvuhUIj6+noAcnJyyMjtRp2Tyspqi5qaGkLNAULBANFQAJcTwUeEfKo40/M+Y2KfYXszMEdfAOMvhfxhCT5qkQNPxIpQFayiKlhJZbCS6mA1wVgzzbFmgtEgwVgwfj/WTF24nppQ9S4TvnpNL1lJWbhNN2BgAIZh7Lhv4Hf7yUvOI9efS54/P36bnEdOUi7JnmS8pnfH+v9flPhI+y8vQaD5S0vgS/cbiI+2r96xVBEfmb+TQbz4nsMXI+xTd8Q27WaJEr9w8OXFIj6afzqQ2danXLoonR+LiIiItD8V3KXL0AcKEWmNQCBASUlJy9Lc3IxpmuTl5dGtWzfy8/PJz88Ht4/65ijbapt5Z0kZK5cv4vjY65xmvke6XYNddDDmuIthyOmQlJHowxLplCzHoi5UR9WO4nxVqIraHX3l42e6Tvy/HWe9gWjTLgX9qB39yjZ9Lh9elw/fjsVrevC4PLgMN24zvnhMN27Tg9/tJ8WTQrI7hRRPMsmeFFLcKaR4U8nwZpDuSyfdm47bdBEvyNcQb0OTBbiJWlEao400RRoJWaEd+0wiyZ1EkisJr8uLaZgd9XRKF6LzYxEREZH2p4K7dBn6QCEibeU4DnV1dZSUlFBeXk5FRQVNTU0ApKSktBTgu3fvTnJaJh+tquTthZvI2PwmZ5pvMtZZhG16of/xmCO+C4NOBm9Kgo9KRCD+/3dDpIGqYCVVwSpCsRBhK7xj+eJ+xIoQs2PxxYnfRq0oUTu6Y8R9gEC0meZogJAV2u2+UtwppO0ovkftKI2RL4rs38Tn8uE23ZiGC9MwcRkmpmFiEr+94/C/k+7V+Y20js6PRURERNqfCu7SZegDhQDU/vo6nOYA2ff8M9GpyAEuEAhQUVHB9u3bqaiooLKysmVi153Fd3dKFvNKYsxftoyhde9yvGsGg+1V2O5kjEHfwRh6NmT3B38W+LPBmwq7bWMhIgeSmB2jOdZMU6SJhkgDDeF6GiIN1EfqaQg30BBpwOvykOZJI82bRqo3jTRP/DbJ5SNiRwjFQoSsEOFYmJAVIhQLEXNi2I7dsjg7bi3H5txB55HkVg93aR2dH4uIiIi0PxXcpcvYnz5QOI7zNb1hZV9rfvU1iERIPuvMRKcinYxlWVRVVbF9+3bKy8spLy9vmaA1OzsbX1o2m5vcLN+4heGNH3CC6xOK7XW7bMM23MS8GVjeDJyUbiTl9cfM6Q/Z/SCrGLL6QUqeivIiItIu9qfzYxEREZHOQgV36TL2lw8UsYVlxD7YgO+XB6voLtKJOY5DQ0NDS/G9vLy8ZSJWb1IyjUYK26qbCDU3QKSeNKeRdJpIo4k0GsmlhiKjnF5mGel23Rfb9aZh9JoCA06A/sdDzoAEHaGIiBzo9pfzYxEREZHORAV36TIS/YFiY2UTONDbdrA31eGaUIjh0gRoIl1Jc3Mz27dvp6ysjO3bt1NVVYXjOPh8Prp160ZOXjeycvNIScuksinKqtIGVpY2sHFbGVbNegqdUopdpRzqXcqA8CJcThQ7qx9m/+PjBfg+h6s3vIiI7LVEnx+LiIiIdEYquEuXkegPFE+8dwuGk8T3jvllh+9bRPZPkUiEioqKlhHw27dvb+kDn52dTXJyMn6/H7/fj8vtoybsUFJvsaoyzPKt1QwMLeBgYz5TXQvIs8pwDBdWzmDcheOgYGx86T4afGmJPlQREdkPJfr8WERERKQzUsFduoxEf6ConzkJu8FF1omzOnzfInJgsG2bqqoqysvLqampIRQKEQwGaW5uJhgMYtt2y7oul4uk5FQiho/qsEldbRUZgbX0ja5kpLmGvs56PE4EBwMnewBm7qAdfeD77rgthsw+GhEvItKFJfr8WERERKQzcic6AZGuIvBymJiRSdaJic5ERPZXpmmSn59Pfn7+Vx5zHIdIJEIwGKShoYGGhgbq6+tpaGjAX19PRoqFk9yXGvrygftM6i0vDQ31pIW20qd2JQMaSigylpITK8PthL/Ybko3jJwBkDMQsnfc5gyA7P7g8Xfk4YuIiIiIiIgc8DTCXbqMRI/gsaIWptvURKkisk/Ytk1dXR1VVVVUVVVRWVlJdXU1sVgs/rgnmUZSKAm4Ka9rID26nR6U0dssZ5BvO72NUnKjW/DFGr/YaHZ/6DEeCsZBjx1tapIyEnSEIiLS3hJ9fiwiIiLSGangLl2GPlCISFdj2zb19fVUVlayfft2ysvLqa2tBcCX5MeXlk3YlUJVyGRrg8W6yjCxUB29KKWvWcLopK0MNdbSI7Qajx0EwMkegFEwFrqNgPzhkDcs3qbGdCXyUEVEpA10fiwiIiLS/lRwly5DHyhERCAUCu0yUWtlZSWWZbU8bpomHp8fy+UjYHvZHnKzodbCDJQywFnHUGMdIzwb6G1txG/HR8Pbbj9G3hCM/OGQnAuOA44N7Lh1HHB5ofhoKD4K3L4EHb2IiHyZzo9FRERE2p8K7tJl6AOFAATrQ+CAPzMp0amI7BccxyEcDtPU1PSVpba2lrq6OnaeKniTkrE9KTTaPsqbobq2ltTgVnrZGxlgbmGweytpRgDDiLfPMkzXjlsTn9VIcvM28KXDwJNh6JnQ7zjwJif4GRAR6bp0fiwiIiLS/lRwly5DHygE4N3bZhBpjnLSTUclOhWRA4JlWdTV1VFTU7PLEggEWtYxXW7w+AnYXpotF0HbpDlm0BQzaYxAfRgaItDT2cqp/rkcYcwiL7gWx5OMMeBE6DUlPjLenxO/Tc6J3/elgea9EBHZZ3R+LCIiItL+VHCXLiPRHyjKl87BdLnIHzqxw/ctX6jeWItt2+T1y0l0KiIHtFgsRkNDAw0NDdTX17fcNjc3EwqFCIVCX4lx+/w0G8lsbHTRUFfF2NinHO+eTVFsAx4n/JX1bdOLk1aImdUbI6MXtCy947eZfcCjb6uIiLRVos+PRURERDojd6ITEOkqVr72EB5/qgruCZbTNyvRKYh0Cm63m+zsbLKzs3f7uG3bRCKRluJ7IBCgsrKSyspKkmOVxDw2MJE3zMNosDxEYxa2FYFoCLcTxusE8dsB0oNV9GguoXfpIgqct0mLVmLwpbECqQXxSVsz+35xm9pt19HyvgwwzY55YkRERERERKRL0wh36TISPYInFg7i8iZhqD2CiHRxtm1TW1tLRUUFFRUVBAIBotEosViMaDRKJBolFo0Ri0VbYhwMwnioi7gIR8K4YwGSrWoKnHL6mlspMsrJi5WSGq34yv4cw4Xhz4bU7pBV/NVFI+VFpItK9PmxiIiISGekgrt0GfpAIQBNjz6GEwqRdukliU5FRL6Bbds0NTW1tK7Z2bamrr6exoZGbNsCwAGihpdGy0NtCCLRKFghPFYAn9VAqlVLnruJInctPV0VdLPLyAyX4HIiX+wsJR/SCiG9ENJ6fHE/tTskZUFS5heLx6/e8iLSKej8WERERKT9qaWMiHQpVlkZTnMw0WmIyF4wTZP09PTdFoEcxyEQCOxSiN/ZS76xMUo0agJpO5YibI+PDYaXpbab2rBBZcDGiQZIs6rJtcspDFfSw6qjW101Oc46Mq1KUmLVu83LMT2QlIlxyK/gkF/t0+dAREREREREDiwa4S5dxv42gsepDxF5aime7wzCLEp8PiIinUkkEqGpqekrSyAQaLm1bXuXGMdwYRkuoo6LiG0QioEVi4AdxeVEcTtRPE4ErxPGS4gadwHBgoMYUJjLkMIMBhWkk+73JOiIRURab387PxYRERHpDDTCXaSDOI4DTRHCPjemaeBJ9mD2zACfK9GpiYh0Ol6vd4+TujqOQzAYbCnEh8NhIpEIkUhkl/uRSIRYzCISi8X7ylsWlmVhWzFybQsaFlFd6+aFBV4qIj6MpHS6d8vn1ycPIyPZ28FHLSIiIiIiIommEe7SZSR6BE/0zTVEN1bx55zZHD/0NA4d2b/DcxARkfaxs6VNRUUF5eXb2VZaTn1tNY4THzVvGAamaeJyuXa5TU5OJiMjg4yMDDIzM8nIyCA9PR23W2MgRKTjJfr8WERERKQz0qc7kQ7iGtuDiGcuNx/9NKXvZoAK7iIiByzDMEhNTSU1NZXi4mIALMuipqaG2tpaYrEYtm3HR8N/6TYQCFBbW8umTZuIRL6YtDUlJQWv14vb7W5ZPB4Pbrcbr9dLSkoKycnJLbfJycl4vRpBLyIiIiIisr9RwV2kg5jdU2l+PYLvlu74hiYnOh0REWlnLpeLvLw88vLyvnFdx3EIhULU1dW1TPYai8Valmg0SjgcJhAItNxGo9FdtuF2u/H5fC2L1+ttuZ+UlLRLgX5nQd8wjH11+CIiIiIiIoIK7iIdKr3oEMLBgWQcNz7RqYiISAIZhoHf78fv91NQULBXMdFolObmZpqbmwkEAjQ3NxMOh1t6zofDYerr6wmHwwSDQcLh8C7xLpfrK0X4L9/3+/0tI+s9Hg+mae6LQxcREREREenUVHAX6UDeowfiPW5QotMQEZEDkMfjaen/vjcsy9qlOB8IBHa5X11dTSAQIBaL7TbeNM2W4rvX621ZvjyafmfbG5fL1dIKZ+f9nSPtk5KSVLwXEREREZEuQwV3kQ5kuE2iH23EKWnAe/6oRKcjIiKdmMvlIi0tjbS0tK9dx3EcotEogUCAUChENBptaWnz5fuRSKRlFH1jY2PL/Ugk0tKffk+8Xi9+v5+kpKSWgv3OZWdB3+PxkJSU1DLyPykpSZPJioiIiIjIAUefYkQ6mFmYjpPixXEc9dIVEZGEMgyjpfD9beycGDYWi7XchsNhQqEQwWCQUCi0y7Jz8tgvF/N3V7T3eDz4/X58Pt/XjpLfuc7OyWR3LjuL9l6vVyPsRURERESkw6jgLtLBXANycBrCOFvqMXpnJjqdLmfWg/OJBaMcduXkRKciItJpmKbZ0oKmrXYW6YPB4FeWcDiM4zi7jYtGozQ0NFBeXk5zczOWZX1lnZ0tbna2wnG5XC0XCWzbbll2XgzfeTz/f/m6x3w+X8vI/C8vHo+nZT879/Xl+47j7HK78/7X2XlxYefFBF1IEBERERHZ/6jgLtKBbCtGQ8kGkj6PYJQ24718gka5d7C84mxi0a8WY0REJLF29oBPSUlp8zZ2tsjZObnsztY3X55YdmcbnJ3FcpfLtUtB/cvF769bvlyotyyr5UJBNBptx2fkm325Bc/RRx9NUlJSh+5fRERERES+SgV3kQ4UCTTw1q9OZeoV/6Dw+CNUbE+AgUcWJzoFERHZR77cIiczM7PD9x+LxVra6ASDQSKRCC6Xa5dld0X+nbc773+dSCSy228ABINB9bsXEREREdlPGM6evrcq0ok0NDSQkZFBfX096enpCcnBcRyq1iwio2d/zJWNONXNeI7tn5BcRERERKRr2x/Oj0VEREQ6GzV+FOlAhmGQN2gM3uQ0cBywnD32apX2F543n/CcOYlOQ0REREREREREOiF991Skg6yuWYVhGAzMGgSAe3whjm1DQxgyknAsG0xDbWb2saYHHsRpasQ3WZOmioiIiIiIiIhI+9IId5EO8uSqJ3hhzfO7/C762moizy7Drm4m/Pc5OCWNCcqu68i6++9kP/hAotMQEREREREREZFOSCPcRTrIL8ddg9/t3+V37oN6gu1gZPlxjeuBkepNUHZdh+n3f/NKIiIiIiIiIiIibaAR7iIdJMOXgdcVL6h/sGINFz3wOka3FJzmKNaiMjxH9MXITEpwliIiIiIiIiIiItJWGuEukgDjfVdSNNzEsk/E2VSLs70JxvZIdFoiIiIiIiIiIiLyLWiEuxxw1q5dy8EHH8zAgQOZMGECy5cvT3RKrRZ7dTOZH5bgdpm4j+yL9/xRODE70WmJiIiIiIiIiIjIt6CCuxxwLr30Ui655BLWrFnDtddey7Rp0xKdUquFiq7DHvUHAAzTJPrBBiL/W5TYpERERERERERERORbMRzHcRKdhMjeqqiooH///tTU1OB2u3Ech4KCAmbOnEn//v33GNvQ0EBGRgb19fWkp6d3UMZ7x9pUi1MXwjWqO4ZhJDodEREREekC9ufzYxEREZEDlUa4ywFl69atFBQU4HbHpx8wDINevXqxZcuWr6wbDodpaGjYZdlfufpkYfbOxF5ZmehUREREREREREREpI1UcJdO69ZbbyUjI6Nl6dmzZ6JT2iN76Xai09fhWOrlLiIiIiIiIiIiciBSSxk5oLSmpUw4HCYcDrf83NDQQM+ePffbr8w64RiYBrhNtZXZh1a9tx4rajHshIGJTkVEREQkodRSRkRERKT9aYS7HFDy8/MZO3Ysjz/+OAAvvPACRUVFu+3f7vP5SE9P32XZn9ix6C4/Gz439ppqIo8sRNfB9p3aLXVUb6xJdBoiIiIiIiIiItIJaYS7HHBWr17NtGnTqK6uJj09nYcffpgRI0Z8Y9z+NIJn7fQnWfTUnZz18LxdRrPbW+uxVlTiPqIvhteVwAxFREREpLPbn86PRURERDoLFdyly9ifPlDUb11L9fpl9Dn0FExz18K6E7Oxt9Xj6pOVoOxEREREpCvYn86PRURERDoLtZQRSYCMngMoPvz0rxTbAawl5UT/txgnEAFQe5l2ZgeD2M3NiU5DREREREREREQ6IRXcRTqQ4zhUBatoijR+7Tqu4fl4L5+AkeLFLm0kcs9cnMbw164vrVP7s19Qc9HFiU5DREREREREREQ6IRXcRTqQg8Ml7/yYGds+/tp1DK8bIhaRZ5ZCug+zbxbYGuXeXlIvuZi0q65MdBoiIiIiIiIiItIJuROdgEhXYhomfzj4jxSlFu15RY8LQhaGZeP5zqCOSa6L8I0fl+gURERERERERESkk1LBXaSDjcob1XL/wQ/Xkexz872D++yyjpmXgvfC0dg1QYwOzk9ERERERERERETaRi1lRBLEcZZy/sQLMNd9sNvHrY21RO6Zi13e1MGZiYiIiIiIiIiISFtohLtIB1nxyoPYsQjDz/wJADWvfEBaUhlHh7fudn2zVwaes4Zi5CV3ZJoiIiIiIiIiIiLSRhrhLtJBHCuGbcVafvb2O4yST0bjnXTKbtc3XCZmYTqxDzbixKyOSlNERERERERERETaSCPcRTrIsDMuw7YtHNvGME3SRowmbcRLe4xxojbW0u24RnbD6JbaQZmKiIiIiIiIiIhIW2iEu0gHaSjdyAvTJlK9fulex5i5yfh+PlltZURERERERERERA4AKriLdJCUvEKGn/UT/Fn5rYqzN9cRvnMOTiCyjzITERERERERERGR9qCCu0gHcXm89Dr4RMINNa2KM7ul4BrXA4x9lFgXU7Whhoq1VYlOQ0REREREREREOiEV3EU60LLn7+Gz//y+VTFGshf3wT2xt9Tvo6y6loXPLWPe44sTnYaIiIiIiIiIiHRCmjRVpAMNP+unmG5Py89z7/st/uxujDznqj3G2etriD6/AvNnkzAykvZ1mp3a1MsPwsFJdBoiIiIiIiIiItIJaYS7SAfyJKex7t1naSjdCEBG0QDSuvX6xjhzYC6+n6vY3h6S0n340/U8ioiIiIiIiIhI+1PBXaQDmS43a999isbyzQAM/s40+h522jfGGW4TuzpI5JmlOI6DtaGWyBOLcWyN1BYREREREREREdlfqKWMSAdy+/yc/p9PMAwDx4kXyw1j72ZDNdwmOEAohpHkAp8bglFI8e7DjDuf+r/chtMcJPOPNyY6FRERERERERER6WQ0wl2kg61950neuu1HnP36mZQGSvc6zuyZgefc4RCxMHuk4z1rGIaK7a3mKijAXVSY6DRERERERERERKQT0gh3kQ7mz8wju8cAfjBkCCmelFbFWp+VEPtwI76rD8bwuPZRhp1b6oUXJDoFERERERERERHppFRwF+lgPQ86loJRUwBw+5IBeH1hCaGoxVkT9zyBqmtwLka2H1x714ZGREREREREREREOo5ayoh0sFg4yPM/Oogtc94GwKr6I6mbf8v60rpvjDUykjBSvVjz9r4VjYiIiIiIiIiIiHQMjXAX6WBun5/JV9xG7oBRADTNmc6oxgBTTyraq3i7pAHrs224xvWIT6QqIiIiIiIiIiIi+wUV3EUSILt4OLWbVpKSV0jtnG5gGmT9IHuPMXZjI3ZDI64xBbjG9eigTEVERERERERERGRvaXisSAJsm/c+n/7rehzbps8tL9Lnzy98Y0zVd8+n/sabMFwm1mclRB5Z2AGZioiIiIiIiIiIyN7SCHeRBOh/1NkMOPY8DHPvr3ll/vEmXAXdATDyU3BFc3BsB8PUBKoiIiIiIiIiIiL7A41wF0kAd1IyS56+i7LFs/Y6xjt2DK6CAgBcfbNwjS3AKW3YVymKiIiIiIiIiIhIK6ngLpIAhmlSt3UtwbrKNm8j9uFGoi+txHGcdsys83NsB8fWcyYiIiIiIiIiIu3PcFStky6ioaGBjIwM6uvrSU9PT3Q635rTEAKXiZHiTXQqB5R3b5tBpDnKSTcdlehURERERBKqs50fi4iIiOwPNMJdJEE2zXydV684Gse2Wfj47ayd/mSr4o30JKzVVcRmbt5HGXZOQ08YyMhThyQ6DRERERERERER6YQ0aapIgqQXFlN8xBlYsQg4Do5tt34jjRGcpggATjiGvaoKc3g+hkvX0r5O4cjuiU5BREREREREREQ6KRXcRRIku+9Q/Jm5RAMNjPnBr9u0DfdhfXAcBycUw2kIEX1lFd7MJIzeme2brIiIiIiIiIiIiHwjDYMVSaB3f/9dVr3x6LfaRvTpZURfX42Zn4rvF5MxVWzfo+ZXX6P5+RcSnYaIiIiIiIiIiHRCKriLJJDv3O/xev72b7UN14RC3BMKATDSfO2RVqcWnjWb0EcfJToNERERERERERHphNRSRiSBMrIKKFr5KbZtY5q7Xv8KRmI0RyxyUvdcRHf1z8ZaX4O9uU6j2/dC1m23JjoFERERERERERHppDTCXSSBekVTSJ29kHB91Zd+GwNiXPTAXB74YN1ebSc2czPW4vJ9kqOIiIiIiIiIiIjsHcNxHCfRSYh0hIaGBjIyMqivryc9PT3R6QBgWzEMw8RoGd1ej2Ofhh39FYtKJ9E9I4nC7ORv3I4TioLPjWEY+zZhEREREek09sfzYxEREZEDnUa4iySQ6XKz8PHbWfP2EwBEFq0l+toG1v37Jcb1zd7LYnsIq7GO6IsriM0r2dcpi4iIiIiIiIiIyNdQwV0kwQzThB0D0z3DR1O38lCS+5241/GVZ5xJ4y23YmT6MZI9+yhLERERERERERER+SZqKSNdxv78lVkrFsF0edrUEiY8cxZmQQGefsU4DWFwGRgp3n2QpYiIiIh0Jvvz+bGIiIjIgUoj3EUSrGLFZzx/wXjqNq9qU7xvyiHxYrtlE75vHrHP1FZGREREREREREQkEdyJTkCkq8sZOJpR5/+StII+32o7hsvEe95wjPzU9klMREREREREREREWkUj3EUSzOX2MvCEH7D6zccoWfDht9qWUZBG7NOt2GWN7ZSdiIiIiIiIiIiI7C0V3EX2A4ZhUr12MQ2lG1t+11CyYZef94rLxF5RiVMZaOcMO48Fzyxh7qMLE52GiIiIiIiIiIh0Qiq4i+wHDMNg6jX3MOiEH1CzYTmO4zDjjitY9dpDrduOaeC9fALmkDycxjAAjmVjrapE8yPHeZI8ePzqpiUiIiIiIiIiIu3PcFSFky6ioaGBjIwM6uvrSU9PT3Q6u7X8xftY+dpDnHrvhwSrt5OSV4jL62v1diL/Wwymgff8kVgba4n+bzHei8Zh9kjbB1mLiIiIyIHoQDg/FhERETnQqOAuXcaB8IEi3FRHoLKUrD5DMAyjzduxtzWA342Zk4zjODjVQczc5HbMVEREREQOdAfC+bGIiIjIgUYtZUT2I00ui6SMXN793XlUr1/2tet99r9FvH3zR0Sao7t93CxKh5hN+KHPIRhVsf1LouvWE12zJtFpiIiIiIiIiIhIJ6SCu8h+YkPden78zjTWR8tI7dbra0a4L8K2o6xoDmMPycWb7Pna7RkpXoxkD07E2ndJH4Aa/no79TfelOg0RERERERERESkE1JLGeky9vevzNqOzftb3mNq4aEkuZOo3byacGMt3YdP2rFGDXAycBVXPzGAkT0zufDQ4m/e7pY6MAzMnhn7MPsDR6ykFBwbd1FRolMRERERSaj9/fxYRERE5EDkTnQCIhJnGibH9D625edlz/+LaLCJ7sMn4USj2Js24Or3HzAHcvt3PZjmN/d4dxyH6AcbMTJ8eFVwB8Bd2CPRKYiIiIiIiIiISCelgrvIfmriJTfh9qdQvW4J5n8eJMN7H86Jt2AcMhxzL5pBOaEQDX+7k9QfXYLZLQenKYyR6tv3iYuIiIiIiIiIiHRR6uEusp/ypWURaazjvRt/QMWYgVgT/4gx7uK9jrcqKmh+8SVi61djr6sm/I+52NXN+zBjERERERERERGRrk0j3EX2Y/6sfI783UNk9x/BphmvklW6jezivWsN4+7Vi+6zPsFISsKJWbiP64+RlbSPMxYREREREREREem6NMJdZD+XN3gchmGy/oPn2fbZu7RmnmMjKV5gN9wuXGMLiL23gdjMzfsqVRERERERERERkS5NI9xFDgCmy81RNzyK4XKx/IV/01yznQkX30T12sWAQ+7AMXuItgETwzAwktzgcXVQ1iIiIiIiIiIiIl2LCu4iBwiXNz7haXJuD0y3F8e2WP7Sf4iFAhx5w6MYhvE1kbcDAeCPuA/tg2PbRN9cgzkoF1e/7I5KX0REREREREREpNNTwV3kAFN8+OkArHjlQarWLOK4m5/dQ7EdYCyltVXkptl43fEuUk5jBAKR+H3LxpqzFdeEQgyf3hJERERERERERETaSj3cRQ5Q/Y85l4Mu+xP+3G6sfO0hrGhkt+uFokfyo/u78fDH6wEwTBPPOcMwh+YRfXMN9rZ6YnO2Ym+u78j0E2bT3K1smKU+9iIiIiIiIiIi0v5UcBc5QHmT0yiacDQ165ez7Pl/Ub9t3S4Tqs5/egnbFpWR5HFxz7QJnDe5d8tjhmFAxMLeUg9RG99Vk3ANzEnEYXS4jXO2snbGpkSnISIiIiIiIiIinZDhfLlCJ9KJNTQ0kJGRQX19Penp6YlOp03+t+JRhuUMZ2y3cbv8PtxUh9uXzEe3XMzg70yj+6jDmH7zR/Qc24MRJw/+2u05tgMxi9iMzbgP64Oxy4SqDhAGkvbJsYiIiIhIYnWG82MRERGR/Y1GuIscIGJ2jI31G6lorvjKY77UTGwrSnJOdzw1jdSu+ITx52Yx/DuD9rhNwzRwaoJYS7bjVDaz6/W3TcBRwLL2PAwREREREREREZFOSyPcpcvoDCN4bMfGNL7+OpldW0vg0v4szcogkHcQx/z5KbZ+9i7dhk/Cm5z2tXHhhYuJzluAxzMaz5HFmL0zgRrgDeBsNMpdREREpPPpDOfHIiIiIvsbd6ITEJG9t6diO4CZlYX3kvs5KLOJSP8TCdZVMuuuX5J17gVU5vs5Ie8wfGmZJOd0x3R7WuIiMz8h9P4MvN+bAGle7MoARno6hu8H+/qQOlzNVT/HCTSR898HE52KiIiIiIiIiIh0MhrhLl1GVx3B01xTwXsVn1D29nPkLtuMLzWL3IGjmfSTW3ZZzwmFMJKScByHyAMLcDKTuDfNxfcO7kO3DH+Csm9/wXfehWgU/0knJjoVERERkYTqqufHIiIiIvuSRriLdHLJ2fmckn0m9sDTaK4sJVBdzpx/XEPJ5x9ROPbwlvWMpHjbGMMw8JwzjI3bmyh9eTneMDjfGYThbs2UDy8ArwP/ZX+bKsJ/7DGJTkFERERERERERDqp/asSJiL7jGm6SO3Wk+y+Q+kz9WSyi4dRunAGFSs+++q6mX76DcrjluMG0VxRwt8+vx27LtjyuNMU+Ya99QQOQW8xIiIiIiIiIiLSlagaJtLFePwpjD7/GvyZeWz48AVWv/U4juMQbqz96rqjC9hwgoeBkZ5E/jkXa2MtdkUT4bvnYG346vpfmAhctM+OQUREREREREREZH+kHu7SZahH5Vc5tk0sHGT7sk/55G9XcvI/3qG5qoxIoJ6iCUd/aT0He9l2zOHdiM3eAoEI7qP7Ybj2fM2uPFBOfbiOgVmDMAxjL7NaAoSBCW0+LhERERH5Zjo/FhEREWl/GuEu0oUZponHn0JKt6H48s8nEk5ly6dvs/K1hwGYeefP2PDhiximgWtkd8DBXl+DkeYD28GJxHa73UAo/vsPtrzPn+f+qRXFdoj3f7//2x2YiIiIiIiIiIhIAmjSVJEuLrZ5M/a6LSTlTiYp1cf4H/2eWDiI4zj4s/LxpmZQv209a95+nDEXXIf3gtHgQOyDDdhrqvFeNgHD/KKgHrNszvnnJ1wwpZgzJpzJYT0Pb2VGNwKNOI7TykK9iIiIiIiIiIhIYmmEu0gXF7z/D2S9fyQnXJxDcpYfALfPj2EYjPvhbymacBRr332ade8+TfmyOeA48RHv43rgPrQ32A7hhz7H2lDTss0rjxvExP45JLmTKEwtbGVGBpDOjJKP+eHbFxCOhVoRuwiY38r9iYiIiIiIiIiItA+NcBfp4lJ//Rec99Mx8od97Trjf/hbio84HcN08+Y1JzPplKvIOfw4yPLjNEcwsvwY6T6s9TVQ1cxxEwu/9ej0Xmm9OKHvifjcSa2Ieg6oBcZ/q32LiIiIiIiIiIi0hUa4i3RxRkZ3zDP+Aa49X3/L7jMUrz+FTF82gWmXUvHxdGzbwkj24j19CGZuCk5JA/aaagzDwFpSjtMcaYl3IhatmaO5b0Yx5ww6r5VH8yfgNtbVreWid35EaVNJyyMbP93KtkVle4i1W7kvERERERERERGRXangLiJ7LSWvkINvfpSM//ybjx68js2fvEY0GCAWDgLgPrQPnvNH4DSGib6+BntjHXZdELu0kdj764k8tmiPRfctVQGenL2J5vDuJ2P9ZiaQRoonlSmFU8jwZbY8suq9daz9aOMeYu8DLsBxHCqaK4ja0TbmICIiIiIiIiIiXZXhtGbIqcgBrKGhgYyMDOrr60lPT090Oge8ihWfkdFrIOvefZa10x/nlHveJ9xYS1JmHoZhxEe3+9zEPtqEtagMz1nDcLbW45rcE8O1+2t97y4t4443V/La1Yfjdbf/9cBYxMLtdX3No58DW2iKHM333jyXX0+4jimFU/dyyyHAAfztkqeIiIhIR9D5sYiIiEj7U8Fdugx9oNg3mrZvpWbjCnpOPIZXrzyaPlNPYcTZVxCoLCWtey+2zX2PbkVjcHfLJPy32bgOKsI9pRdEbIxkz1e2F7Ns3F9TkO8IUSvK0qol9M3oS1ZS9l5GvQr8EZjNf5c+xsCsgUwtOnQfZikiIiLy7en8WERERKT9qaWMiLRJcMYnOKEQqd160mvScQBMvPRP9JlyMmWLZ/L6z46jbPFMPrnzSlbMeAzD7cL7w7G4xxdiLdlO+O45OMEoTszaZbttLbYHIzFi1rfvw+5xeRjbbVwriu0Qn6T1VsBLbbiG5lhzK2KrgL8A21hYsZA5pbNbk66IiIiIiIiIiOxHVHAXkVaza2tZd99NLP7jnS2/M0yTgpGHkFHUj/whEzj02nvpPvIQ+kw9me0rPgNg3ou3smnh27gG5+I5ZTAkuYk8sojojt7q3+YLN8/N3cIpd36Mbe95G433/YeGu+5u8352rwdwDADXjP81x/U5vhWxDcASIMbMkhm8vuG1Vu77LWADm+o38dLaF4jZbe1/LyIiIiIiIiIi35Y70QmIyIHHSPEycOhq6ntN2e3jHn8KhWMPB2DyFX8lGgpg2xaxUABvchqNdSVsXPoKQ4ovwjW+B2Z2MnZJA5FnluH94RiIWBC1MIsycBrCOE1hjII0DMP42pymDs6nINOPaX79OgBOKIQTDLb52NtfMfAkAFeO+VkbLjr8GbiKjQ15PLfmWU7rf0YrYpcBbhojhTy58nFOKj6ZorSiVu5fRERERERERER2Ug936TLUo7KdWVFwbHD7Wh26efabLH32n5zw15fZvuIzcoqH4wl5sJZV4D68D7E312KXNOC7dALhBxfgVDThu3YqOGDsg8lUS2ubqWwMM7Jn5h6L+vsni/iErW25fvpTIJWK5qv506c3cdWYnzEga+Bexq4F1gPHc/u82xidP4Zjeh/b6gy2NGymOdbM4OwhrY4VERGRb0fnxyIiIiLtTy1lRKRtXJ69LrYHnnqa4Btvtvzc++ATOfFvr4FpMPffv2H1m4/iZHoI9I/h4OA+YQChw9IJNdRg5CbjOrQPTn2I8O0zsbfV49SHsKubv1ULmi97e3EZv35qYbtsq+O5aPuXlf4CXE9+cj7/PPJfrSi2A8wE/gZAhi8Dv9vfitjyHfuu4qV1L/HfpQ+2IvYLa2vX8vyaZ9v0OtC1ZhERERERERHZF1RwF5F9LjxrFuG5cwFw7PjEpqbLjcvt5cQ7XmXwyT9i/QfP89avT8OOhFn99mN8fM9PmfPPX9E00sYelY7hc+M+tA9GfgqxeSVEHokXyGMLSrE21Hyr/M4/pA//vXhSm0a31zSFmbehmkjs20/Y2vHSgMw2xv4QiF9EuWTkZUwpnNqK2CbifeubmDbsh/x+8h9aue+TgJfZ1LCRNze+0cq/21zgM8oCpZz2ysksr1rWyn3HfVo2h031m9oUKyIiIiIiIiKdlwruIrLPZd/zTzJu+D0AdT+/jNprrm55zJeehTclnb6Hnsoxf3wSd1IyOFA4/gjGXHA9H91yMWvefoJQtIGZM/5Mw/aNxEamEDk6GwBr2XbsTXU4wSjhe+Zib6nDaY7g1IX2Oj+fx0VRdnKbju3zTbVc+eh8QlGrTfEHNk8b4/oT71vfhwxfBune1n6F/WxgIMf0PpaHjnu0lbFPAc+Q7k3nkpGXUZDaoxWxHwG/AuC+xfcyp2x2K/cdt2D7fGaVzGxTrIiIiIiIiIjs3zRpqoh0CMMdf7vxFa7A62r8yuOe5FRyB44GYPB3pgHxth9H//EJ3EnJxEIBDNOFy+dn09y3WPrcPznrkXls7r4CjyuVPlYhZv9sjPQkrCXbiX2wEWNgDkaqF/eYAsxuqfvkuA4bnM9zV00hLan1b6d1gQjXPbOIK48dyLCizPZPrtOa9i1i/w5YpHrdnNj3pFbGugAvAA8c818cWtOWZjVwFfBv5pTOpjJYySGFu590ePdKgUyWVq7jrU1v8stx1+A2W/eacxwH27Fxma5WxYmIiIiIiIjI3tMIdxHpMIGaZt5efDylfa7+5pUBwzBI79GX5OxupHXvzWHX3ktqfhH9jjyTo254FNN0UbdpFXVbVmP7DD785HdUli4hkB/G9d1hmOk+nLXVWPNKcCyb6DvrsGua2/WYPG6TnjkpbWpHYzsOBZl+/N62Xft8ef5Wlm2ta1Ns12XQ9mvNU4GbAfC4PHhd3lbEZhIfmZ/NFWOu4qaD/9TKfZ8LvEzUjtIYacRltKZo/hHwEdWhak5/9RQWbJ/fyn3Hzdj2MatqVrUpVkRERERERKSr0Ah3EekwyVl+pt50Oek90r7Vdrwp6eT0HwHAxEvjhctQfTVpPfriTk7jrd+cjtuXxOn/mUljvzA+XzKuuhDWikpcw/OxlldgfV6G5/wROHUhjGQPRlJb26O0XXaqjz+cMaLN8U/M3sTJYwoZ3jOz1bGLNtdi2Tbj+ua0ef/SGt2Ai75F/J1AEWO7FTC227hWxr4L2CS7J3LVmJ/TJ71PK2LfAv4HPMkzq59iQveJDM4evJexzcCnwFieWvUm6+vW8btJN7QudaA6WMXKmpVM7H5QKy9yiIiIiIiIiHQ8jXAXkQ5jGAZ5A3Lwpexd0Sz4zjtEFi8G4u0wKr5zMsE339rtukkZOUz+6V/I7DmAiRffyMATfoDL62PBo7ew8Lk7MbL9rMj8iPrwNhyvATl+DNMk+tpqoq+uxnGc+Aj40gacmEVsfgl2VaDdjn1feO6qqVwwtbhNsU/P2cRjn2xsU+zGyiZeX1iC47SmpYp8OxOAgjbG3gzcSrInmaN7H0OOP7cVsd2ByQD866j7uHDoD1sRWw78GthM3/S+jMgd2YpYgF8AL7Gmdg1/nfcXQtbez8sAK4D5RKwIl7x7EZ+VzW3lvuM+2TaDhRUL2xRrORa2cyBOpiwiIiIiIiLfhgruIrLfarrn3zQ/9XT8h2AzWeNW4jI37THGdLkpPuJMig66gFkPzmfST+9i9PnXEG6spWzpLEL1NZTXLeHlJ88h1FBDVc8KtrAQQjFiayqI1TRib6wl9uZarJWVWCsqiH0c36ddF8TZB5OjOraNE7FwmiJYi8txYvt+AtabzxnNX84b3abY+Ruquf2DLkPEAAA+kElEQVT1FW1qo1PdFOaPLy5l835+MUN2GgNc2fJT6/7mvYH3gKFM6jGZU/uf1sp99wVymNj9IJ466VlSPa2Zh+FZ4F4ADulxCLmtusjwHnAo0Mw7m99mTumsVsSGgAeBTTyz6ml+PH1aK2IBtgP1lDaV8Lf5t1MVrGplfNzn2xewPbC9TbEiIiIiIiLy7ajgLiL7rdyXXiD9t78BYPuaMoK5g/AM2bsWLE1VAUoWl5GcnU1qfiE+Xwon/e11CkZPIaPnAEadfzW+tCxqazdQvm0Bht/D++v/zEu3nsC2LXPYkLSApoIAscoGotuq4yPgn1lG7J11OJZN5Jml2NsacJqj2KWNOPY3j2R1HAenIQyAtbKS2LwSAML/mIs1Zyuh+mqir6zCLmnECUT2aptt5TKNNveOP/ug3rz/m6PaFBuOWmyrbSZqte3Yzv/3LJ6Y1baR+StL6lm0ubZNsdIWLuK969varukq4FBcposUTwqm0ZpTluuAu/G6vFw47IcUZ/ZrRWx/4BIgiT8dcgs/GX1FK2JDwHNACQcVTOLHIy5uRSzAL4F7idpRakLVrRwh/zzx44ZbP7uZueWftiK2HHgcaOSO+X/l1rk3tyIWoAIIsaRyMXd/flcrY+NCsRCfbJtBbaht/482hOsJxoJtihUREREREWlPKriLyH7LcLkw0+L93ktWNfPO+p9g9J6yV7G9xhVyzj9PxuVx4dg2ZSNGEXjsfwCkde/FoBN+gGEYDD/zcqb88i4ADrrkTww84QKSCrpTGliIY0KJs5SXX/sBsXAzlb2qKDdWQyiGE7PBAHt9DZEHF0DEJjZzM5GXVhJ5YgmRN1ZjVwZwmiJEnluGXd6EvWQ74bvm4EQt7NIGYusqcRyHDbHZlAWWEiXIW6uvpy66hcjLK4k+t2KfPK/twe1q2z8fPbKSuf/HB9G/W9v6+J8ytqhNPesBnv50M//5YG2bYhdtruWmF5cSialFyIEhCWjNiPgv6wN8n7adImUC04FD6JfZjymFU1sZfz1wHr3T+3DzlL+Qn5zfyn0XAnD/MQ9ydK9jWhFbAjwANHJo4WEc0fPIVsQCnAy8TnO0me2B8lbG3gbcSW24ltvn38aWxi2tiP0c+CcAv5pxDc+sfqoVsU3Aa0A1jyx/iOs/ubYVsQBLgRKWVy3jlx/9jIZIQytia4FKLNviz5/+kSWVi1sRGyM+P4LDC2uf5+1Nu2+zJiIiIiIiiaNJU0XkgDDuvJGMOXv4Xq3rOA6Vp5xG5s1/wjtyJEQjdL+gCruwbo9xeUPGkTckPiFlt5seByA5pzuHX3c/nqQUykvnEQ02UXTCybw3/zcMKbqYwpGHUjcVcghTsWUh6ek9ScrPxFq2Hctt4j6iGCcYw4nECKWHqeq3nSIrxpItT1O5+nOO/+4LBDKbSMl0kdajL4fedD/Z/Yaz4PnfkddvDD1r+xF9eRWe0wZjZvm/1XPYGZw7qXebY68/eVibR9YHIzHK6oK4zda30alvjnDLq8u56PB+DOie3qb9S1exd+9xu3f0jgWykrJbGTsO+BiAiQU92rDvO4F+TOrRnUk9Jrcyth/gpltyN54+6blWToxbBnwGwE9GX0GWL6sVsZXATcCDjMobQ1Fqz1bEQvzbBCeT7DmO/pkDcButOaX+F7AWh/9iOzatmw3jox37/pDK5krC3nCrokVEREREZN9TwV1EDhjmXo6qdpqaMJKSMPzxArVh2BhTrsQcfGir95mUkYPrd3+l4ch5jP/lDTiOgx2L0nvKSWQUFlOzZSUf3Xc5Jw16k1lv3oQ3LYPT7v2Izc58/Jlh8u0evDHjJ4zr91uSMvOY+/ZfyDn6YPpMPZnuow4BYMJFf2jZX/pKD9FN6/H0zsXTP5/g9jLsaCPeVC+Rl1ZCJIb33BGEH/oc17B8XMPziTy/HM/R/TByk8EAo42tYjq7JK+LJFxtip08II/JA/LaFBuO2oSjbR8Zf+Wj85kyKK9NFxtCEQuXaeBx6wttsi8d8i1izwLANCDZk9zK2JN2LDAqb1QrY/sAnwImY/Lb8v/HA0AyfTMyW9l2COLfoAjgNt3cMPnGVsYOJz4RchKXjbq8lbEiIiIiItIRVJURkU7HTEsj77lnvviFNxkO/8PXB3yDrCNqcXo1AvFJI10eL8PP/AkQn/D0lH99gD87n8N/+wA1G5cDULFqPh5/CjkhF/0HTyWj5wDSi/px1qPzMU0Xqd12HU1ZtmQWydndSMlLwfR7GHX0LwBY/NTf2bToVb7DdMIFNv60eNHXNTAHIy8lXmBP9kKSm9jMLVifbsN37RTsDbUYPhdm70wc28YwVXBNlPyMJO76wbg2x4/pnUXP7NYWIuP+9tZKNlQ08d+LJ7U6trQ2yLJtdRw5tFubWwiJ7L8Mvt1pcFu+CbBTn28R233HIiIiIiIi+yt9ghYR+Qaevn3xDh6028cM0yQltwDTdJE/ZDyDT7wQgIOvup0JF99I+OVHKFy0hsxeAzFNF6a5+xHW8x/8Ixs+egn3pJ64RsWLKVZNDUPGnshRN/4Px4rxxl3nsHn7TOq3rWfRmseI5UKMCO4zBmHmJOM0hSHFjeE2seZuI7awDMdxCN/6CbEFpdhVASKPLsKuCWJtqCX67noAYvNKiM7agtMcIfLGaqwVFTjhGLFPNmPXBnEaw1gba3EsG6c5Et8P4MQsHLt1zRCk9X50eD8OHti20fWnjSvikiP7tyl28ZZabnh+CW35EzcGo1z+0Gcs3tK2CTCrGsM0haJtihURERERERFJJBXcRUS+yRmPwfBz2xSaMa6C7BNj37jeCbe/zLDTL93ld8FXXqHyuBNIySvEdHs46sbH6DH2cEJ1VVQs/wxXkp8lz/6D1392PFvnvsOympcpG1KOY9uUFKyjOWs7sfp6XMf3w+yVARiQ6sXwmtAYxt4Wn+TPaQjjbK0nfMdsaIqA5eA0R4nN3QYNYewNtUT/txgch9hHm4g8uRSAyEMLib29FjtqEfrbLGIrKrHrgsQ+2YwTjMaX8DcfO4BdFcBaXQVAdPpaYvNKWvEsy9cZVpTJQf1y2xR73IgCPvjNUXhcre9bD/GR/T5321r4/Oyx+fzng3Vtiv1gRTkPfbS+TbHBSIySmmZibez1LyIiIiIiIqKCu4jIvnTc3zCOuvUbV3P7/HhTdp1QM7lwMz0ua8YwDEy3h7zB4/Bn5tJt+EGc+LfXcHuTKD78dFLyerBp5utYVhjLFSPUUMOnD/yOzVdMo3T687xw+3GEPc1sXPoWS+qex0j1URZZRt3EKI7jsM2zlPDEFDi5D5X9qrD6JhGc8Q7mSdmYvTMxh+bhvWIihtuFa2IhnhMGxHM+vG98NH4oBoEoNIRwqoPE5mwFIDZ7K5EHFgAQeXop0bfXAhB+dCHW6irsrfWE/jYLe3sT1vJKoq+tjh+4zw0RCycUI/zIQuyyxt0+Z47tYFcFcCIx7M11xD7ehBOzsCsC2KU7LiZELRxn74ZoO7aDE7FwmsLEZmzCrg3uVVxnZZoGyT43htH6gnua38NNZ45kcI+2TRL765OHcsb41k5iGVdWG2Lt9t2/Zr7Jws21nHn3J9QEIq2OdRyHP760lEWb2zaqX0RERERERDoH9XAXEdmXcnffimZvmMNPhpzCPa6T1WcIR/3hMRzH2aUwetaN/8B44WyCg3sx/qI/4EvPBsdpKT4vf+l+souHUbd5FZ8/eisHXX4LqflFzLjpJ3zn7rdZ8Y/rKOmRzBn/W8Cqtx/D7Uui/zHnsWrWU3QfMRlvRSNL3/kHI8/9GdWLZ1HvXciQAeOwU0xiPTYT+99Kks88H7N3JgCuIXmQ5MZxHMxMP/hcGJlJuMb1IPL8csy+mfh+PgknGsV9cCF4PDh1IYwkN0aKh9j8Eux1NXjOHU7s7bWYPdIxemcQ+fc83CcOwMjyE1tQimtqb6y5W7G3B/BdNI7Ifz/H7J2J+5h+RJ9agvuwPhgZSVgbanENy8cuacCpC+EeU0Dk359hDs3DPbknsdlb8fbPwaqowl5Xg/uE/t/YB9+JWmA7GD43TjAanwXS64KGMPg9GN62jfbuikb1ympz7PmH9Glz7LDCDO65cDxZyd5Wx8Ysh201zTTv5bc6REREREREpHNSwV1EZH/VY1x82Qv/fxSyp8dgOOxa0gZOIG1UvHjZ78iz6HfkWQAcd8uzAGxf/hkjzr2KPlNPBsfhtP/MICk9hwEHbSOv+AcANFeX4UlKxjAM1k5/Al9qBvnDJtJQuomVrz1E9xEH05RajzsnjQ9vuRj3lrWMzu1L+dbB5A0cgwta+tIDeE4d/MX9w/ti9srASPZiuF1UP/ww2+78M4NnLcSXlYX3vBHx40v1YuSnxI/TcnBsBzMjCXNgDrH5pSRdNgHj4hE03XcfSceegPfQPgC4j+iLkeaFqAV+D7hM7LJGYq+txuiWQmzGJrAc3GMKcB3ZFzPbj+H34Lt2CgBOVQAnEMEwTSLPLsPsmYFrRDdiH2/ENaknTlUzsenr8F4xkdj0ddhljfguHk/ksUWYvTJwH92P8N2f4jl1MEZmEpFnl+G9aBxOSQPWuhq8pw3BWlkJbhPXgBzs2mD8WD0qzidCRrKX8cU5bYr1uE3u//FB7ZyRiHxZc00F6955kn5Hn0Nj6SbWvvMkU67+J0uf+ydN5Vs4+Ko7Ep2iiIiIiIhayoiIdEoZPWHq9eDf80jhbsMmMvyMyzFdbky3B39mHoZhkH3hUxSf+SsAxk37DSPP+zkAp/77Q/oddTZp3Xsz5vu/Yuun75DdbwSTr7gNgEEnXsCAgTauAbV8fOsllC2ZRdniWbz1q9OINDeyZc7bLH/xPhzH4bMHbmTDxy8RyzV49caTKPn8IwKsYuUwP4Zpsu7dZ1j+0v0AuAbn4TmyGADPdwbhHlNAQ8kG6gc04zljEC9fdhgrX7qPusfvZN7jf6IpWEGwtoIGXxVG91QMvwfvWcMwC9NxDc7D95tDoTGCs70J7/dGAlB92Tk0PnQPEL+AYRgGrpHd8Z4zPD4yv1sqRlYSGGBvayTy8EKcuhDmsHzC735IuHQ+7qPiObqP649rbA9wm3i+NxKzXzak+3BP7omR4sFuDEMs3ifcWlyOtbwCx3GI3DsP6/My7KoA4QcXYFcGcOpD2BVNe90aZ285toPThtYpIiKJEmmqo2TBR4TqqnFwsC0Lx4qRUdiP7H4jCNZWMO+BG4mGAolOVURERES6MI1wFxGRXRkGDPrON66WP3QCp9//yS6/6zF6KgybDnaMk0+oJyk9m4bSjeQNHos7KZmmim3UblqFFQ6y/r1nCNVV0XfqqfQ76mxS84tImXAIp/or8KZmEGqoJtxQi2PbTL/+LIaedgkpeYWsfvOxeHubNx4mWL2d4259jhFnX0F2phfzsC00NpWBY7N51pssefYfnP3oAj5/9FYc22bcD3/L+g+eJ7t4OBkDBhC9oDce0yJUVUH4KJvskV5KF31CqK6K4sNPJxZqxr1jdL/7sD4tx+n90RhiM7dg9s3CzE8hdMs/sTaswXXJ+QC4+nxxocPVPzv+tALmlN4A2MsqMHukxVcYFKPpoQfJOPpmvN8biZGVhGM7GLnJGCleYnO3YX1eiu+XBxP9cGO8SO51YVg25vBuOLEw9pxyPCcPwt5ch7WsAu95I+K99B0H98G9iH64EbN3BkaGj+hzK3CfMginvInY62vw/e5QYu+ux6kP4z1nOLF5JZjdUjAK0nDKGjHyU3GqAlhLt+M+fgCxd9bHL1RcMJro+xswC9MwB+bibKvH6JYKpoHTFMHM8mNvb8JpjuLqm0VsYRlGhg+zTxbWwjLMvpkYPjf2lnrMgTnYG+uwt9XjObwvkZdWYCR5cB/fn8gDC3Af0guzXzZ2aQNmz4xdvgHgRK34xQu3ibWoHLM4CyMzKf6cuzSuQKSz2DbvPVLye3LC7S+3/K5g5CEA9D7kJCD+ra2KFfOIBQO4vf5vbAUmIiIiIrIv6CxURETal8cPvjRS84twJyWTXTyM8T++AdN0MfTUi5jyy7tw+fycfv9MDr7yrximyYizryCjqD/u4afjP+8xAIaf+RPG/fC3WJEQ3UZMJiWvEMeO0VxdxoKH/oTbl8JRN/0PgH5HnU3WiKPJuPxDjrv5WdIK+lB8xBkc88cnMAyD9KJ+pBf1w3EcFv7vNpa/dB+NJRt4/WfHUbd1LaULZzB7ZSXuXgVsm/sOJQs+BOCNq7/Dsuf/RbS5iaXP/pNAVSnBuipqNi/Hc0RfAlYl9VvXkjaoAntEA8G6yr16imoHN9PUK4JtW6yf8Tixpk8wXSZmn0yMjCTMLD/e04ZgJHtwH9wT7/dHxdvp7Jig1qkLYW+px6mso+o7J2NVVoDjgMeFkRrvP+6EYjjBeD9xe1MdTm0Iu7IZpyIAoRiu4mys7DJCb03H7JOFOSDeSsVaUBrfdmOEyCOLsEsbcAJR7G0NRN9ei5HmxTWuB3YggF0eX89pCMXX3dqAvbKSyD/n4kQtrM9Lib2zLr7dRWXYq6vBsom9sQanpBG7IkD0ueU4dSGcuiD25jqAeD69MsCyMftmYWT4sLfUEX18CU4gQmxhGdFXVwEQeXghsQ82gmkQe2cdTlkj9ppqwnfOxmmO4AQi7f7tABHpWI7jsPLVh1g7/Yk9rtdt2EROuOMVrGiUt351KjUblndQhiIiIiIiXzAcfQqVLqKhoYGMjAzq6+tJT09PdDoi8i2EG2oB8KW3fnLNpc//i9LPP+bw6/9D3eY1ZBcPA8MgFg6SlJHT0g/fcRy2fjqdtILeGKaLD/70Q8ZO+w3LnruHQGUp5z6xmNn/+BXB2gqOuuYOXv31ufSecjKDT5rGaz8/nkN+fife5DTWTH+S8T/6Pctfuo/ajSs54rcP8sYvTqJg9BT6H3Meb139HY7otYXYua+x4aOXmXzlX7HCQTwp6V/pzf//OVUbsR86FufYu3GPPvEbj90JRLA312EOyMHwuKj/ycmYfYaT9utbd13PceKT7FYFMbKTMNyueMub++bhPqwPrqH51N/6F4KvvUb32bNwLBunOoiR4YOIhV3VHC+YRy0wDAyfm8gTi8Hrxnv2MCKrVtF0192k33gjrszs+Ij9PYxEtTbVYm2oxT2yG0ZOMuFnP8ZwZeI7azTWxlqMZA9mt9T4NwNMA7smiL22GvdBRUT+twh2tBSyt9Rh5KWA24RgDNK83/gcAzjNEUjy4Gytxy5txD25J5Fnl2GkevGcOJDIk0twjeuBWZBGbPYW3JN74jgOTm0Is08m8NV5Fg4EjuNgb9jx/Bak4Vi2vjUg7cKxbcqWzKJg1JRvfp9zHJqry0jKzMWORvH4U75x++GGWj7/322MveBarGiU5Oz8VudoRcK4vD42zXyd1PxC/Nnd+fi2y5h48U2EGmpY+L/bOP4vL1K+dDah2koGHPc96reuJSkjt03/NiWKzo9FRERE2p8+NYmIyAHHl57V5oLGiLN+ynG3PIsvLYtuww/Ck5yKx5+CPzN3l8KPYRj0mnw8WX2GkNlrIKffP5P0HsWkFxZz5O8fBmD0+Vdz0OW3QEoeh//2vww49rsYrvhI/rTuvYkGAzSVb8Hl8ZI7cAz1W9dQsuBDjv7TE4y54DrSe/TlzIfnkfuneA93wzRxebzM+sc1zP7HNQDM/sevKFsyi5LPP2TV6w8TbW6iaftWyhbNxEhKYZN7KJu3bATgw1suZsuctwjVVzP/oT/RWL6F+m3rWffes9i2RUPNZup8FRgeF4HKEvzFy0gdA1Zs11HghmFgmCZmfgqG29XyO9/lE3ENjReuUgdVkPeD1Phjrh3r+twYaT5cfbMwXCZGkgfDF+9e5z60D+6De8Z3ULcRj7OA5qrN1JWvwzBNAlWlxMLB3f7NnNoQzoZazNwUDKD6mguIBZcB4OqbhdltRx5m/O9nZvtxH1QUvz+6AHtLPdaaKiKPLKL+t3+l4Xd3Er5rDgRjRN9bT/j++QBEnlxC9O21AITumoO1dDvRjzYSvmM2Tm2QyJylRN5ZjOM4uIbkYfbNij9vfg+4TZxQLP5tgqiFvaKS6NNLAYi+vIrIM0sIzZhB5KVlWKurcIJRoh9uxK4NYtcEsZaUxwvcm+viE+myo7//hlocx8FaU43T1DGj9e1t9cTmbMUwDGLvrsdaXI69vYnwnbPjbYJse5/nIJ2T4zhEmhupXreYj2+9hMqV86las3CPr6nSzz/i9auOp6l8614V2yH+b8Tkn/4F24rx5tXfYf2HLxCsq6KxfMvX/j8Ubqxl69x3cByH+Q/9mQ9v/jEAy1+6j5LPP8aXnkXeoLF4/Ckk53Sn50HH4k5KpmbDcsqXzgbgk79dyfKX7ycaDPDWr0+nYsU8mrZvZf37zxELB2mqKKF+W/xbP+GGWmKh5tY8fSIiIiJygFDBXUREZC8YhkF23yEc+qt/kTd4LADJOd1JzS8EIL1HX5JzuuNNSWfoqReTml9E9xGTOeZPT2K6PRSMmkLPScfHRz+mZrYU991JyZheP4XjjuCQn98JwNBTL6b/Uedgx6JEAvXYsSiLnvw7C//3V4J1lWz5dDqz/nE1pOZTkz6G2qr4iP/U/CJc3iSiwSYqVs4nFmqmas1C5v/3JpY8fTcrX3+Ezx+5GYCPbrmEZZnfJzrmMp49fxRbP51O+ZLZvHjRwQRrK1jz9hN88Kcf0lxTwVu/Oo1P7/0NAC9efAir3niUYG4/ZqyP0lC6kbota9jw8cs4jkP91rXUbFwBwMYZr1C9fhnhhloWvv8vAq46tsx5mzceuIGU7vNY+fHzfHb/HwD48M8/ZskzdxMNBph+/dlUrJxPY/lm1kx/AoZkYHxvIFY0ApEAhT/ein+Itcvfx4pFCFSW4Nj2LgU1V+9MXKO6Y3RLxXvFRJL7Lyepfyme746AJBeugbktxXnXsHzM4viFHNfo7hg5yVhzt2GOyMdI8eLYi4isuTk+oe6IbriGxCcZ9p4+BFe/bMz8FHyXTcDMTcE1sRBzaB7RV1bhGpILOQ7V3z0fu6IOIhZOKIa1uBwC0Xi7nJdXge1gLa8gNmsLdm2Q2MzN2OurIRQj+vRSAv9+EntDLaHbPsGpD2EtryD65hoAYnO2EltYBkD0o43YJQ049SGib62h6cHHabj5XiIvrYyv+9k2YjM2xe9/vAlrTRVOxCLy4or4BYCyJqzF5TiWjXl4NpHKz8Dl4BpfiJGbTOztdUReiP+NHduJL1ELu7oZx7bjFxA21OJYFtFFa7BKquPrNkVwYlZ89H8bLxzsjLPWVmMtKY8f76ursFZVxrcbtfYU3uVYlY3ESuvb5UKNFf32F3zm/PPXzPnnr8gdOIbjb3uRlPxC3r/xQjbOeOVrY7qPOJiJl/+Z9MLiVu8vKSOXcdN+Q8+DjmXjRy8x/fqzAFj0xB0sfe5fxMJBPrv/BipXLaBq7WJm3vkzApWl9Jx4DINOuhCAE257iVHn/Ry3N4kJF/2BjJ4DyO47lNHfuxrDMBh13s+Zek18wu2p19zDwOO/jx2NkDtwFL70LKrXLWHef/+IYZisev0hZv8jPiH5h7dcxML//bXVxyQiIiIi+z9NmioiItIBXB4v46b9Zq/W7TZsYsv9w6+/H4C8IeMJ11WRkl9E/2POpd+RZwIw4aIbW9adcNEfWu6feHu8gJXVZzBWNELJgg85+KrbsSJhACb99Fa8Kem40rsz6Se3ktN/BLYVY9BJ0/D4U0nJLyR/6EQCFVtpKNtI/2POBWD4GZfTbcQkHJcbd/dVuLw+yhZ9wtLn/0XxYaex9Ll7iAYDHPHbB1ny9N0kZeQw7IzLKF8ym16Tjie9sJiBJ/0Y+6QZDG+oASN+7f+gy2/Bl5qBHY2Q1Wcw3pR0qtcuZuH//krxEWey5Mk7qVjxGSf+5Xnm+88jpzJKj6Y6pl9/NuN/fAN2NMInd1zB6ffPZO30J9m+fC5H3/Q4pWtnk9y/B1kZ8YlUvX3zIaMIdvSsN3plQK+M+N9oVPeW589zeF8AfFfHJ2U03Cb+7pX4x23bq7+h4XbhKs7GiVq4Budh9suk29w5uHJzMZLiuST9fHJ83cI0XMO7gWngOXEgALEFpTjVQdxH9wPA7l+DZ8BIjGw/7qm9IdWLE4rFJ4wFnOpmSIn377eXbMf6bBueYwdgb6kHKwaRGDRH48mFrS/6+2+rx0xyQw8LpzIATZH45LTje2C4TBoWzSHw299QeNopeI6IPydmcVZ8G+EY4Ttn4zl1MHhdRJ9ciueC0VhLy7HX1+KdNoTgv9/BM3ww/quOJvzPT3Ef0RezbxaR/8zH+6Ox2FUBYtPX4fv1FGLT1+HUhfCcO5zYG2tofvt56G6SfNA5uEZ1x6lpJvrGGnw/m4y9thqnPhSfODhige3glDcR+e/neC8aS+ijj4ktXUn6zb/CLmsEt4mZl4K1sRYzxw8eV3zC3t6ZOI1hnNJGXKO6Y62pxqqoJPjxiySf9n3cRfmQ7oNwDHzub25/Yjs0P/48nlFDcRf2xV5ViWt8D5ymKDRFMPtkxic+dpst3/74sujyFTiOjXf48L16nX1l/45DrLGJyGsr8R7Ulzl3Xc3E/B8Rmdafdc8/TvExZ+LqmUksFCS1W8+9anVkRcI012znnd+ew9Rr7sG2YliNzfSYdMRexTdt38rc+37LQZffSvHhp8OO9lFZfYYAcOQNj5AzcBSlCz+m+4iDMd2eltj5D/2Z1G5FDD5pWpueD8Mw6HvYaQAUH3km+cMmYhgGnuR0XF4fLm8SjWWbCDfWUjBqKqf9Zwb+zLyWC6nALvl8k4yi/i33d743ZxT1p+igY3C5vQw7/VKiwQAAYy+4Dk9yWpuOS0RERET2b+rhLl2GelSKiLSd4zh7LK5ZsQgut5dgbQWG6SIpIwfbsnj3999l2OmXUDTh6Fbv84M//wiPP42pV99N7ebVhOqqKBh1CPP/+0fSi/rR/+hzWfLM3fSZcjJJGTnUblxJ3tDxVK1eSOWqBeT0H8nnj95K4fgjGX7G5bzz23OZcPGNeFMz2PLp2ww95SKCdVU4tkV6j740lG7E5U3Cn51P1aoFpPUoxrFilMz/gL5HnMG2OW+xfelsDrridj7+y6X4MnKZdPnNzLzz5/Q97FRyBoxi04xX6T3lOxiGQbixjvTC4jb1b3dsGyIWRtLeF/taYoNRYnO34RrZHTPb3+r46PS12NkeGJTBy5cfxvgf/R7bttk27z0O+/W/WwqQTnMUa00VZu9MjCQ3zvYAsWXbsbc14Pv+SPCZhD/+DHdxX9zFPbDWVmPkJGP43VgrK3ENysVpimBvrMU9qSfRDzZgzdyC75cHE5uxiejm5Ri9UjA3ZuA+cQBGug97RSWug4riff+/9Lw6lk30lVUYqT7cR/YleO/bUGmR/MeTCT+yECMzCe9pQwj9+WPcx/fH7JFG5MHP8V48DntrPbF31+O9eDzWp1uxSquoe/w3ZJ52M65xRbjH9yD89znxb0U4Trzof/kErKUVOGWNeE4ZTOSFFZh5ybgOKiJ820ysrO34TzmOyLPL8P1kIrFPt2Evr8B31SQijy2CFA/eM4cRfmA+7sk9MXtnEptXQuMzd+FEHTKv/QOuQbnxFkW2g6s4C2tJOUZuCkZuMtaKClzF2WA78fx7J9H4wqekpxXx+fbHKSofQMH3T2Fz6Uzyc4YSy4TAQ3PILh7GhtQFWDO3Muy661j53iMkG5n0Ped71CxZRGp2Ib7e3YiV1mL6fMx5/Pekx/IZ9qMrWfXOY/TufTibPnubXnVD8J8+inCBTXJ6PpgmhnvXL86u//AFrHCI4sNPZ9Zdv2Dkeb8gq8/g3b7mAlVlvP7z45lw0Y3xojzx95wlT99FSn4h/Y86p9WvY9k7Oj8WERERaX8a4S4iIiLf6JuKxi53fHS1P+uLyQlNl4vjbnm2zfscdvplmK54D/ms3oOg9yAAxv/4hpZ1Rn/v6pb7BaOnANB9xGSq1y3h039fz2n3foQVCROLBCkYPYWkzFwaSjaw4cMXGXbGZax67SFqNizjuFufZ9bff0HekHEMOOa7vH/ThYy54Dqy+w5hwaO30n3UFHB7sY14PsVHnoXpcu9oYWPH+9BXlrL02X+SnNud+m3rWfnqfzn70QXMve+3WJEwB191BzNuv4KeE48mf+gE3v/jNCZf8VcCVaXM/df1nPnQpyx78V6q1y3lqBse4ZN7fkZm70EMP/MnzLrrlww8/nzSCnpT+vnH9Jx8fLzl0I6ifrCuCtN04UvPImoHcR1SCKZJsK4Kb2o6djRKuKGG1G49iYWaMdzulr/ZTrYVw3S5Wbr9BSo+nMdxtz7PIb+4i27DDqJy1QKyi4dhuNx8/uit9D38DLJ6D8I9uqAl3uiTiSc/BaIWRqoPgKSjD/niNbLjWwUA7rE94jEp3pYe/O7xhZi5yeB34zlxIB4GfuU1YR66aw9vx3GwwkFMlw+7qolYTxOP2yR0Yi8I2iQD4UNSScrKA8B7xUSMHT333T+bgJHmp6Z2FckZDubsLczf+jC9J59AwSUfEquox52WCh4XnrOGYnZPxQnGcI0piBf8fS6cZA+x2VuwN9biGpyL4XPjvXA0Rn4Kht9D0q/ir0n31N4wMT5q2n1kMZhGfJLfbqnEPi/D7XVhLdlO+rXXYW9oIPrySlzXTiU2bxtELFzFWUQ/2Ih7bAGuFA+xV1djfG8ElW9/TGZNNo2np7JyzuOMPvuXDD34EgzThat7LsWDTmt5rjJuGAChKP0aemFvWIlT0UxKUxoF5UVYjc2UPPw8xUVH0nxuHc33zSRnzDh6TT6e3Oke7HW1DJ56PpEHFzDoh9OIfbSR6CureG3ZTznphPvxkYL3wtEE75lNRWwNhT88m9xP/WxPqcBJq2Jy0U/wFPTHWrYdu7wJz9H9iH22DSPFi2tYPt5lIU64+klS+/Wj4vG3ST9mHGWzPmRo3zPxTOqFta4GLBvXoFyspdsxcvwYuSlYy7bj6peNYzvxv8GIbvE5H5ojuPpkYVcFMDwujIwk7JogRooHXAZOYwQj3QdRG8IxjIykeDsiw/jKhQMRERERkdbSGaWIiIjsl7oNm0je4HFtih100oWc9LfXMd0ePMmp+DPzGHvh9aT36EvRhKM47d6PcLm9DD/7ivjEt8DBV93OkFMuAsMgd9BYuo+YTO7gcZz7+GLSuveizyEnMfmnfwGg58RjKBx3BIZpMvXqf9BjzGHk9BvO2Y8tYO69vwMHjrrhEQzDoMeYwygcdwQAKbkFeFLS8SSn0fuQk0jKyCGneBhjLrwW0+ujqXwLOPE2MXlDxpPZayBWJEQ0FMC2Leq2rOWzB/5ALBhg7fQn+eBPPwTg039fz5x/Xcu2+R/w6k+PYu30J2ko2cDLl06ldsNytsx+k9euOhbHcfj80Vt57/fnA/DhzRex4pUHiEVCvHrF0VSvX0avyScw/KyfAlA0/kg8/hR6jDmUUef9nFB9NWWLZxFuqKGhZAPbl80FYMPHL1O2aCaWK8bMB66hYsVn1G9dy8w7f0awtoLKVZ+z5u0nAKhas4iqtYsB2Dz7Teq3rSPcVMf6uS8T6eWmvmQdq15/BICSBR+y/sMXAFj89F1snvUG4aY63rz6ZMqXzKZk/vs8d+E4Is11rEqdyQePXQnAwsdvZ/VHT+A4Dm/deCab5r9B7aaVvHDVFOrK1rH67cd45RdHYZgma95+nEX1L+A5ph92LIoVi1C7YQUv/nwqdZUbqNmygm118yHVSzQpApPy4xMcj+yO5+h+mD0zcB/WB9ew+MUms3dmvKj/JYbXhZEWvwhhFqVj9kjDMA3ck3tiGGDkpZD088m4i3vgOWwAvp9NAsBzxlA858XbPdkXFOM+tA+rPn6KzzPfxOyXTWp1CrWF9WQPHc2E2/5G+jFjSO/Rl7Tuvb7y/4RhGhjJXpK65+O/+lCslRX0SBqF97LxmKl+el8xDfc5w3Bsi+ZxHoxDi+g58RiSrpqEa1Q3jO4p+H51CK7CdHxnDsMzbSQH/eQWko8YxobQLLbOfYfY4BQ2bfqIQFUJyWMG0KfoUKyFZeBzxS8yBGM4jREA7K0N2OVNAFiLyklx5xLcVkbSWosVT/6L5pmriH0YnxDaWlKONb8UIP5NiDXxuQ1ir6/BrgjglDUSe31NfB6EhWXE3liDXdFE9JVVxD7eBEDknrlYyyvirYf+ORenOoi1qIzwvfPi231lVctEx+F/fkrsk804DSFCt87A2lCDtbKS0K0zcMI7Jlt+YMdky48tIvrmGhzHIfTXmVhLdkwy/MD8+HwGq6uIvLJj/oS524jN3hLf35trWiZIFhEREZHORS1lpMvQV2ZFRKQj1G1ZQ1JmLknp2a2OXf/+c1ixCAOPO/9r17FjUQyXm+bqcsKNtWT3HUrNhuVs/exdVr7yIFN+eTfphcX4s/KpWPEZuYPGYEUiNJRuoNuwg6hZv4xIcwMFIw9h5av/Jb2wmOTcAqZffzYHXXYLfQ89eY852raFYZjM/+8fqVw5nxP/9hqv/PRIMnsN4tBf/YsZt/+EwSf9EE9yKoufupODr7yDDR+/xIaPXuSkv73OB3/+Ed7kNKb88m6enzaB/sd+l5x+I5j5959xzB+foLFsMwsevpkzH5rLwsdvp7F0A4dd9x9m/+NX5A4YRb9jzmHR43dQfPgZ+NKzqVjxGUUTjiJUX024sY6cfsMJ1lbg8vjwpKRTtfpzUvIKMUyTzbPfpO+hpxKsraR200r6TDmZWDiI2+fHML8YhxJqqKFk3vv0OexUlj//b7Z+9h4n3fk6795wPmnde3HQ5bfw3IXjGP/D35HZexCf3HElR/zuv2xf9ikrX32QU+55n9n/+BXRYBOHXXsvr15xFH0PO4PiI87g1Z8eyWHX349jxZj/3z9ywu2vsGXO29RtXsX4H9/AqtcfwZeRTc8JRzP9+rMZdf7VuNxePrr1Yk655z0q1yyisWQDI865Etu2MQyjTW2L7PJGsB3MHt/unMhxHBb+7zY8/jRGnP1THNtueS4dy4awhZG8962RAlVlpOQWEHpnJcbmAL6Lx+91HgBEbaz1NcSeW47n+/F5D8xMf7x/f25yvH9/WSNmYRoEY9g1QVx9s7C31OPYNq4+WYRun4lrQiHuyT2xFpXH2x9ZNva6GlzjeuDsmJTYNbI71rLt4PdgFmdhzdkanx/BY0JjGPdhfbG31GEtq8B7znCiH26EmI3nmH5Enl+Oa2AOrpHd93xg+5jOj0VERETanwru0mXoA4WIiHRmViRMNNhEUkbON6/8/0QCDaz/4AV6TT6OlNweexVj2xah2kqSc7oz665fkDdk/B4vFLTsq7kR03ThTkrGioT5/LFbqVq7hBNue7HVeZctmsmcf1/HiXe82uoLHLFIiI9vvYRhp19G95EH73ndUDPupGQqVy/E5fWR1XswM/56OVnFw+h35Nms/+A5Bhz7PZqryqhcvYDBJ02jdNEn2NEIRROOYuOMV0jvUUxGUT82z3qDzD5DCFaXU7tpJcPO+gkbP3yRuq1rGTftN8y66xdk9RnKkFMvYtHjt9P7kJNIyetB9bol5A4ai1cTbX4jJxTDqQpgdE/FcLtaHR/7eBPmgOw2XYyIvrUWXAaeY/t/88r7AZ0fi4iIiLQ/Fdyly9AHChERkf1PsK4KKxwktVvPVsc2lG5k66fTGXTShbh9rZsg1rYtPv3X9Qw45jzyBo9t9b4XPHwz/qx8hp52catjlz3/L9a99wyn3Tej1bG1m1cz5x/XMPWaf5JW0KfV8Uue/Qfdh08mf+iE1u9700psyyKn3/BWx1qRMFYkhCclvU0j8mXf0PmxiIiISPtTD3cRERERSRh/Zm6biu0A6T36MuyMy1pdbAcwTRcHX/nXNhXbAcb98LdtKrYD9DvqbA677v42xXr8qXQfeTDupOQ2xZcu+IjG7VvaFLv8xftY8szdbYrd9MmrvPDjSW2KDdZVMf0351C1ZlGb4le9/gilCz9uU2xj+RZqNq5oU6yIiIiIdE3uRCcgIiIiItKV+LPy8Wfltyk2Nb+QsRde3+Z9H9+G1j07Tbj4Rtr65dhuIyYz5Zd3t2l0u+lykdVnMJ7k1Dbtu3TRDKxomB5jDmt17Jq3/sf2FZ9x4u2vtDq2fOkc5tzza46/7UX8mXmtjhcRERGRA5NaykiXoa/MioiIiEhrhOqriYWDpOYXtTq2sWwTm2e/xeCTLmzzNxL2NZ0fi4iIiLQ/jXAXERERERHZjbZMQrxTWkEfhp95eTtmIyIiIiIHAvVwFxERERERERERERFpByq4i4iIiIiIiIiIiIi0AxXcRURERERERERERETagQruIiIiIiIiIiIiIiLtQAV3EREREREREREREZF2oIK7iIiIiIiIiIiIiEg7cCc6AZGO4jgOAA0NDQnOREREREQk8XaeF+88TxYRERGRb08Fd+kyGhsbAejZs2eCMxERERER2X80NjaSkZGR6DREREREOgXD0XAG6SJs26a0tJS0tDQMw9gn+2hoaKBnz55s3bqV9PT0fbIPOTDotSA76bUgO+m1IDvptSA7Jfq14DgOjY2N9OjRA9NUt1ERERGR9qAR7tJlmKZJUVFRh+wrPT1dH6AF0GtBvqDXguyk14LspNeC7JTI14JGtouIiIi0Lw1jEBERERERERERERFpByq4i4iIiIiIiIiIiIi0AxXcRdqRz+fjD3/4Az6fL9GpSILptSA76bUgO+m1IDvptSA76bUgIiIi0vlo0lQRERERERERERERkXagEe4iIiIiIiIiIiIiIu1ABXcRERERERERERERkXaggruIiIiIiIiIiIiISDtQwV2kHa1du5aDDz6YgQMHMmHCBJYvX57olKQDhEIhTjvtNAYOHMioUaM45phjWLduHQAVFRUcf/zxDBgwgOHDhzNjxowEZysd5eGHH8YwDF5++WVAr4WuKBwOc8UVVzBgwABGjBjB97//fUD/VnQ1b775JmPHjmX06NEMHz6cRx99FNB7Qldw1VVX0adPHwzDYNGiRS2/39N7gN4fRERERA58KriLtKNLL72USy65hDVr1nDttdcybdq0RKckHeSSSy5h9erVLF68mFNPPZWLLroIgOuuu45Jkyaxdu1aHn74Yb73ve8RjUYTnK3sa5s2beKBBx5g0qRJLb/Ta6Hrue666zAMgzVr1rB06VLuuOMOQP9WdCWO4/D973+fRx55hEWLFvH6669z6aWX0tjYqPeELuCss85i5syZ9O7de5ff7+k9QO8PIiIiIgc+w3EcJ9FJiHQGFRUV9O/fn5qaGtxuN47jUFBQwMyZM+nfv3+i05MONH/+fM466yw2bdpEamoq69ato3v37gBMnDiRW265haOPPjrBWcq+Yts2xx57LLfddhtXX301P//5zznttNP0WuhiAoEABQUFbNu2jfT09Jbf69+KrsVxHHJzc3nppZc49NBDWbJkCSeccAIbN24kOztb7wldRJ8+fXj55ZcZPXr0Ht8D0tPT9f4gIiIi0glohLtIO9m6dSsFBQW43W4ADMOgV69ebNmyJcGZSUe7++67OfXUU6muriYajbYUUyD+oVuvic7tzjvv5JBDDmHcuHEtv9NroetZv3492dnZ3HLLLYwfP56pU6fy/vvv69+KLsYwDJ555hnOOOMMevfuzZQpU3j00UdpbGzUe0IXtaf3AL0/iIiIiHQO7kQnICLSmdxyyy2sW7eO999/n2AwmOh0pIMtW7aMF154Qb2YhVgsxubNmxk6dCh/+ctfWLhwIccccwxvvPFGolOTDhSLxfjzn//Miy++yKGHHsq8efM45ZRTdunnLSIiIiIinYtGuIu0k549e1JWVkYsFgPiXyPfsmULvXr1SnBm0lHuuOMOXnzxRd566y2Sk5PJycnB7XZTXl7ess6mTZv0mujEPvnkEzZt2sSAAQPo06cPn376KZdccgnPPvusXgtdTK9evTBNk/PPPx+AMWPG0LdvXzZv3qx/K7qQRYsWUVpayqGHHgrAhAkTKCoqYsmSJXpP6KL2dL6oc0kRERGRzkEFd5F2kp+fz9ixY3n88ccBeOGFFygqKlLPzS7izjvv5KmnnuLdd98lMzOz5fdnn3029913HwDz5s2jpKSEww47LEFZyr52+eWXU1ZWxqZNm9i0aROTJk3i/vvv5/LLL9droYvJzc3lqKOOYvr06QBs3LiRjRs3csghh+jfii5kZwF15cqVAKxbt47169czaNAgvSd0UXs6X9S5pIiIiEjnoElTRdrR6tWrmTZtGtXV1aSnp/Pwww8zYsSIRKcl+9i2bdvo2bMnxcXFpKWlAeDz+Zg7dy7bt2/nBz/4ARs3bsTr9XLPPfdwxBFHJDhj6SiHH354y6Spei10PRs2bODHP/4xVVVVmKbJDTfcwJlnnql/K7qYp556iltuuQXTNLFtm+uvv57vfe97ek/oAi699FLeeOMNysvLycnJIS0tjXXr1u3xPUDvDyIiIiIHPhXcRURERERERERERETagVrKiIiIiIiIiIiIiIi0AxXcRURERERERERERETagQruIiIiIiIiIiIiIiLtQAV3EREREREREREREZF2oIK7iIiIiIiIiIiIiEg7UMFdRERERERERERERKQdqOAuIiIi+yXDMHj55ZcTnYaIiIiIiIjIXlPBXURERL5i2rRpGIbxleX4449PdGoiIiIiIiIi+y13ohMQERGR/dPxxx/Pww8/vMvvfD5fgrIRERERERER2f9phLuIiIjsls/no3v37rssWVlZQLzdy7333ssJJ5yA3++nuLiY559/fpf4pUuXcuSRR+L3+8nJyeGSSy6hqalpl3Ueeughhg0bhs/no6CggCuuuGKXx6uqqjj99NNJTk5mwIABvPrqqy2P1dbWcv7555OXl4ff72fAgAFfuUAgIiIiIiIi0pFUcBcREZE2+f3vf8+ZZ57J4sWLOf/88znvvPNYuXIlAIFAgOOOO46srCzmzZvHc889x3vvvbdLQf3ee+/lpz/9KZdccglLly7l1VdfpX///rvs46abbuKcc85hyZIlnHjiiZx//vnU1NS07H/FihW89dZbrFy5knvvvZfc3NyOewJERERERERE/h/DcRwn0UmIiIjI/mXatGk8/vjjJCUl7fL73/zmN/zmN7/BMAwuu+wy7r333pbHJk2axNixY/n3v//NAw88wLXXXsvWrVtJSUkB4M033+Tkk0+mtLSUbt26UVhYyA9/+EP+/Oc/7zYHwzD43e9+x5/+9CcgXsRPTU3lrbfe4vjjj+eUU04hNzeXhx56aB89CyIiIiIiIiKtox7uIiIisltHHHHELgV1gOzs7Jb7kydP3uWxyZMns2jRIgBWrlzJqFGjWortAIcccgi2bbN69WoMw6C0tJSjjjpqjzmMHDmy5X5KSgrp6elUVFQAcPnll3PmmWfy+eefc+yxx3Laaadx8MEHt+lYRURERERERNqDCu4iIiKyWykpKV9p8dJe/H7/Xq3n8Xh2+dkwDGzbBuCEE05g8+bNvPnmm7z77rscddRR/PSnP+WOO+5o93xFRERERERE9oZ6uIuIiEibfPrpp1/5eciQIQAMGTKExYsXEwgEWh6fNWsWpmkyaNAg0tLS6NOnD++///63yiEvL48LL7yQxx9/nLvuuov777//W21PRERERERE5NvQCHcRERHZrXA4THl5+S6/c7vdLROTPvfcc4wfP54pU6bwxBNP8Nlnn/Hf//4XgPPPP58//OEPXHjhhdx4441UVlZy5ZVX8oMf/IBu3boBcOONN3LZZZeRn5/PCSecQGNjI7NmzeLKK6/cq/xuuOEGxo0bx7BhwwiHw7z++ustBX8RERERERGRRFDBXURERHbr7bffpqCgYJffDRo0iFWrVgFw00038fTTT/OTn/yEgoICnnrqKYYOHQpAcnIy06dP52c/+xkTJkwgOTmZM888kzvvvLNlWxdeeCGhUIi///3vXHPNNeTm5nLWWWftdX5er5frr7+eTZs24ff7mTp1Kk8//XQ7HLmIiIiIiIhI2xiO4ziJTkJEREQOLIZh8NJLL3HaaaclOhURERERERGR/YZ6uIuIiIiIiIiIiIiItAMV3EVERERERERERERE2oF6uIuIiEirqSOdiIiIiIiIyFdphLuIiIiIiIiIiIiISDtQwV1EREREREREREREpB2o4C4iIiIiIiIiIiIi0g5UcBcRERERERERERERaQcquIuIiIiIiIiIiIiItAMV3EVERERERERERERE2oEK7iIiIiIiIiIiIiIi7UAFdxERERERERERERGRdqCCu4iIiIiIiIiIiIhIO1DBXURERERERERERESkHajgLiIiIiIiIiIiIiLSDlRwFxERERERERERERFpByq4i4iIiIiIiIiIiIi0AxXcRURERERERERERETagQruIiIiIiIiIiIiIiLtQAV3EREREREREREREZF2oIK7iIiIiIiIiIiIiEg7UMFdRERERERERERERKQdqOAuIiIiIiIiIiIiItIOVHAXEREREREREREREWkHKriLiIiIiIiIiIiIiLQDFdxFRERERERERERERNqBCu4iIiIiIiIiIiIiIu1ABXcRERERERERERERkXaggruIiIiIiIiIiIiISDtQwV1EREREREREREREpB2o4C4iIiIiIiIiIiIi0g5UcBcRERERERERERERaQcquIuIiIiIiIiIiIiItAMV3EVERERERERERERE2oEK7iIiIiIiIiIiIiIi7UAFdxERERERERERERGRdqCCu4iIiIiIiIiIiIhIO1DBXURERERERERERESkHajgLiIiIiIiIiIiIiLSDlRwFxERERERERERERFpByq4i4iIiIiIiIiIiIi0AxXcRURERERERERERETagQruIiIiIiIiIiIiIiLtQAV3EREREREREREREZF2oIK7iIiIiIiIiIiIiEg7UMFdRERERERERERERKQdqOAuIiIiIiIiIiIiItIOVHAXEREREREREREREWkHKriLiIiIiIiIiIiIiLQDFdxFRERERERERERERNqBCu4iIiIiIiIiIiIiIu1ABXcRERERERERERERkXaggruIiIiIiIiIiIiISDtQwV1EREREREREREREpB2o4C4iIiIiIiIiIiIi0g5UcBcRERERERERERERaQcquIuIiIiIiIiIiIiItAMV3EVERERERERERERE2oEK7iIiIiIiIiIiIiIi7UAFdxERERERERERERGRdqCCu4iIiIiIiIiIiIhIO1DBXURERERERERERESkHajgLiIiIiIiIiIiIiLSDv4Pfw4U9EAWEpwAAAAASUVORK5CYII=", "text/html": [ "\n", "
\n", "
\n", " Figure\n", "
\n", - " \n", + " \n", "
\n", " " ], @@ -225,9 +262,9 @@ " plot_lr=False,\n", " large_font=False,\n", " shrink_axes=0.6,\n", - " # ylim_max=4,\n", + " ylim_max=4,\n", " ylim_min=-0.9,\n", - " keys_exclude=\"devtrain\",\n", + " keys_exclude=\"devtrain_loss_(ctc|mle)\",\n", " color_map=\"Set1\",\n", " draggable=True,\n", ")" diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/config.py b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/config.py index 669e1954b..c96fd1fcb 100644 --- a/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/config.py +++ b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/config.py @@ -110,6 +110,7 @@ def get_forward_config( target="audio", train_data=False, joint_data=False, + cv_asr=False, ): """ Returns the RETURNN config serialized by :class:`ReturnnCommonSerializer` in returnn_common for forward_ctc_aligner @@ -125,6 +126,8 @@ def get_forward_config( fd = forward_dataset.train.as_returnn_opts() elif joint_data: fd = forward_dataset.joint.as_returnn_opts() + elif cv_asr: + fd = forward_dataset.cv_asr.as_returnn_opts() else: fd = forward_dataset.cv.as_returnn_opts() @@ -191,3 +194,49 @@ def get_search_config( ) returnn_config = ReturnnConfig(config=config, post_config=post_config, python_epilog=[serializer]) return returnn_config + +def get_prior_config( + training_datasets: TrainingDataset, + network_module: str, + net_args: Dict[str, Any], + config: Dict[str, Any], + debug: bool = False, + use_custom_engine=False, + target="prior", + **kwargs, +): + """ + Returns the RETURNN config serialized by :class:`ReturnnCommonSerializer` in returnn_common for the ctc_aligner + :param returnn_common_root: returnn_common version to be used, usually output of CloneGitRepositoryJob + :param training_datasets: datasets for training + :param kwargs: arguments to be passed to the network construction + :return: RETURNN training config + """ + + # changing these does not change the hash + post_config = { + } + + base_config = { + ############# + "batch_size": 50000 * 160, + "max_seqs": 60, + ############# + "forward": training_datasets.prior.as_returnn_opts() if target == "prior" else training_datasets.devtrain.as_returnn_opts() + + } + config = {**base_config, **copy.deepcopy(config)} + post_config["backend"] = "torch" + + serializer = get_serializer( + network_module=network_module, + net_args=net_args, + debug=debug, + use_custom_engine=use_custom_engine, + forward=True, + target=target, + ) + returnn_config = ReturnnConfig( + config=config, post_config=post_config, python_epilog=[serializer] + ) + return returnn_config diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/data.py b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/data.py index 8e1229403..32960285d 100644 --- a/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/data.py +++ b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/data.py @@ -74,6 +74,7 @@ class TrainingDataset: devtrain: Dataset cv_asr: Dataset datastreams: Dict[str, Datastream] + prior:Dataset @dataclass() @@ -555,7 +556,17 @@ def build_training_dataset( ) devtrain_dataset = make_meta_dataset(devtrain_zip_dataset, joint_speaker_dataset, train_eow_phonemes_dataset, duration_dataset=duration_dataset, xvector_dataset=xvector_dataset) - return TrainingDataset(train=train_dataset, cv=cv_dataset, cv_asr=cv_dataset_asr, devtrain=devtrain_dataset, datastreams=datastreams) + prior_zip_dataset = OggZipDataset( + files=train_ogg, + audio_options=training_audio_opts, + target_options=train_phoneme_datastream_tts.as_returnn_targets_opts(), + partition_epoch=1, + seq_ordering="sorted_reverse", + additional_options=additional_opts, + ) + prior_dataset = make_meta_dataset(prior_zip_dataset, joint_speaker_dataset, train_eow_phonemes_dataset) + + return TrainingDataset(train=train_dataset, cv=cv_dataset, cv_asr=cv_dataset_asr, devtrain=devtrain_dataset, datastreams=datastreams, prior=prior_dataset) @lru_cache() diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/exp_joint_2step/experiments.py b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/exp_joint_2step/experiments.py index 277fae3fd..167f98973 100644 --- a/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/exp_joint_2step/experiments.py +++ b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/exp_joint_2step/experiments.py @@ -15,8 +15,8 @@ get_text_lexicon, get_bliss_corpus_dict ) -from ..config import get_training_config, get_extract_durations_forward__config, get_forward_config, get_search_config -from ..pipeline import training, forward, search, compute_phoneme_pred_accuracy +from ..config import get_training_config, get_extract_durations_forward__config, get_forward_config, get_search_config, get_prior_config +from ..pipeline import training, forward, search, compute_phoneme_pred_accuracy, compute_prior from i6_experiments.users.rilling.experiments.librispeech.common.tts_eval import tts_eval @@ -74,6 +74,8 @@ def run_exp( assert num_epochs == len(args["config"]["learning_rates"]), "Number of Epochs and Number of LR steps differs!" + with_prior = "prior_scale" in search_args + if given_train_job_for_forward is None: training_config = get_training_config( training_datasets=dataset, @@ -121,6 +123,18 @@ def run_exp( train_job = given_train_job_for_forward exp["train_job"] = train_job + if with_prior: + returnn_config = get_prior_config(training_datasets=dataset, **args) + prior_file = compute_prior( + prefix + name, + returnn_config, + checkpoint=train_job.out_checkpoints[num_epochs], + returnn_exe=RETURNN_PYTORCH_ASR_SEARCH_EXE, + returnn_root=MINI_RETURNN_ROOT, + ) + tk.register_output(prefix + name + "/prior.txt", prior_file) + search_args["prior_file"] = prior_file + if tts_forward: forward_job_gl = tts_eval( checkpoint=train_job.out_checkpoints[num_epochs], @@ -587,4 +601,22 @@ def run_exp( search_args=default_search_args, asr_search=True, asr_cv_set=True, - ) \ No newline at end of file + phoneme_pred=False, + ) + + for lm_w in [2, 2.5, 3.0, 3.5, 4.0, 4.5]: + for ps in [0, 0.3, 0.5]: + additional_search_args = {"lm_weight": lm_w} if ps == 0 else {"lm_weight": lm_w, "prior_scale": ps} + suffix = f"/tuning/lm_{lm_w}" if ps == 0 else f"/tuning/lm_{lm_w}_ps_{ps}" + exp_dict = run_exp( + "second_step_asr/" + net_module.replace(".", "/") + suffix, + train_args, + training_datasets_pe3, + asr_test_datasets, + 250, + forward_args=forward_args, + search_args={**default_search_args, **additional_search_args}, + asr_search=True, + asr_cv_set=True, + phoneme_pred=False, + ) \ No newline at end of file diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/exp_joint_2step/training_comparison.ipynb b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/exp_joint_2step/training_comparison.ipynb index 51ba86d4c..d5f74bf85 100644 --- a/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/exp_joint_2step/training_comparison.ipynb +++ b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/exp_joint_2step/training_comparison.ipynb @@ -144,18 +144,18 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "8879ad67b2a94651b6ff26731340937c", + "model_id": "6b994cc2a036408b805ee43ad71b84b6", "version_major": 2, "version_minor": 0 }, - "image/png": "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", + "image/png": "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", "text/html": [ "\n", "
\n", "
\n", " Figure\n", "
\n", - " \n", + " \n", "
\n", " " ], @@ -237,33 +237,33 @@ " \n", " /\n", " 1\n", - " 3.854557\n", - " 3.863975\n", - " 3.834595\n", + " 3.864722\n", + " 3.874153\n", + " 3.841878\n", " \n", " \n", " 2\n", - " 3.742074\n", - " 3.567398\n", - " 3.467777\n", + " 3.768973\n", + " 3.639531\n", + " 3.550206\n", " \n", " \n", " 3\n", - " 2.479751\n", - " 2.167383\n", - " 1.838922\n", + " 2.512775\n", + " 2.184052\n", + " 1.858979\n", " \n", " \n", " 4\n", - " 2.051774\n", - " 1.811539\n", - " 1.417094\n", + " 2.055174\n", + " 1.809958\n", + " 1.418657\n", " \n", " \n", " 5\n", - " 1.835545\n", - " 1.586035\n", - " 1.171362\n", + " 1.839511\n", + " 1.598297\n", + " 1.182285\n", " \n", " \n", "\n", @@ -271,11 +271,11 @@ ], "text/plain": [ " ctc dev_loss_ctc devtrain_loss_ctc\n", - "/ 1 3.854557 3.863975 3.834595\n", - " 2 3.742074 3.567398 3.467777\n", - " 3 2.479751 2.167383 1.838922\n", - " 4 2.051774 1.811539 1.417094\n", - " 5 1.835545 1.586035 1.171362" + "/ 1 3.864722 3.874153 3.841878\n", + " 2 3.768973 3.639531 3.550206\n", + " 3 2.512775 2.184052 1.858979\n", + " 4 2.055174 1.809958 1.418657\n", + " 5 1.839511 1.598297 1.182285" ] }, "execution_count": 6, @@ -333,7 +333,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.13" + "version": "3.10.12" } }, "nbformat": 4, diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/exp_tts/experiments.py b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/exp_tts/experiments.py index 4e74cd979..72af00dba 100644 --- a/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/exp_tts/experiments.py +++ b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/exp_tts/experiments.py @@ -16,7 +16,7 @@ get_text_lexicon, get_bliss_corpus_dict, ) -from ..config import get_training_config, get_extract_durations_forward__config, get_forward_config, get_search_config +from ..config import get_training_config, get_extract_durations_forward__config, get_forward_config, get_search_config, get_prior_config from ..pipeline import training, forward, search, compute_phoneme_pred_accuracy from i6_experiments.users.rilling.experiments.librispeech.common.tts_eval import tts_eval @@ -39,11 +39,8 @@ def get_glow_tts(x_vector_exp, joint_exps, tts_exps, gl_checkpoint): """ - Baseline for the glow TTS in returnn_common with serialization - - Uses updated RETURNN_COMMON - - :return: durations_hdf + Contains TTS-only experiments similar to the experiments in ../../librispeech_glowtts/glowTTS/experiments.py + but in a cleaner setup similar to the setup used for joint training and joint training with external alignments """ prefix = "experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/" @@ -52,44 +49,56 @@ def run_exp( name, args, dataset, - test_dataset, num_epochs=100, - use_custom_engine=False, training_args={}, forward_args={}, keep_epochs=None, - extract_x_vector=False, - asr_cv_set=False, - given_train_job_for_forward=None, nisqa_evaluation=True, swer_evaluation=True, tts_eval_datasets=None, eval_invertibility=False, nisqa_confidence=False, + large_gpu=False, + compute_feature_stats=False, ): + """Creates the training and forward configs and runs additional evaluations according to the given parameters + + :param str name: name to be used in alias creation + :param dict args: General training/forward arguments passed to the config creation + :param TrainingDataset dataset: Dataset to be used for training + :param int num_epochs: Number of Epochs for training, defaults to 100 + :param dict training_args: Arguments passed to the train steps, defaults to {} + :param dict forward_args: Arguments passed to the forward steps, defaults to {} + :param list keep_epochs: List of epoch numbers to be kept during training, defaults to None + :param bool nisqa_evaluation: whether autoMOS should be evaluated using NISQA, defaults to True + :param bool swer_evaluation: whether synthetic WER should be evaluated, defaults to True + :param dict[MetaDataset] tts_eval_datasets: Datasets to be used for TTS evaluation, defaults to None + :param bool eval_invertibility: whether invertibility of coupling blocks should be evaluated, defaults to False + :param bool nisqa_confidence: if autoMOS is evaluated, whether confidence intervals should be computed, defaults to False + :param bool large_gpu: whether 24gb should be required for training, defaults to False + :param bool compute_feature_stats: for invertibility, also run a forward pass calculating the dataset statistics for comparison; typically only necessary once not for all experiments, defaults to False + :return dict: Dictionary of this experiment containing all jobs that are created + """ exp = {} assert len(args["config"]["learning_rates"]) == num_epochs, "Length of LR schedule and number of epochs differ." - if given_train_job_for_forward is None: - training_config = get_training_config( - training_datasets=dataset, - **args, - training_args=training_args, - use_custom_engine=use_custom_engine, - keep_epochs=keep_epochs, - asr_cv_set=asr_cv_set, - ) # implicit reconstruction loss - - if given_train_job_for_forward is None: - train_job = training( - config=training_config, - returnn_exe=RETURNN_PYTORCH_EXE, - returnn_root=MINI_RETURNN_ROOT, - prefix=prefix + name, - num_epochs=num_epochs, - ) - else: - train_job = given_train_job_for_forward + + training_config = get_training_config( + training_datasets=dataset, + **args, + training_args=training_args, + use_custom_engine=False, + keep_epochs=keep_epochs, + ) # implicit reconstruction loss + + train_job = training( + config=training_config, + returnn_exe=RETURNN_PYTORCH_EXE, + returnn_root=MINI_RETURNN_ROOT, + prefix=prefix + name, + num_epochs=num_epochs, + large_gpu=large_gpu, + ) exp["train_job"] = train_job for ds_k, ds in tts_eval_datasets.items(): @@ -117,33 +126,29 @@ def run_exp( nisqa_confidence=nisqa_confidence, ) - if extract_x_vector: - forward_x_vector_config = get_forward_config( - forward_dataset=dataset, **args, forward_args=forward_args, target="xvector", train_data=True - ) + if eval_invertibility: + forward_invertibility_config = get_prior_config(dataset, target="invertibility", **args) forward_xvector_job = forward( checkpoint=train_job.out_checkpoints[num_epochs], - config=forward_x_vector_config, + config=forward_invertibility_config, returnn_exe=RETURNN_PYTORCH_EXE, returnn_root=MINI_RETURNN_ROOT, prefix=prefix + name, - target="xvector", + target="invertibility", ) - exp["forward_xvector_job"] = forward_xvector_job + exp["forward_invertibility_job"] = forward_xvector_job - if eval_invertibility: - forward_x_vector_config = get_forward_config( - forward_dataset=dataset, **args, forward_args=forward_args, target="invertibility" - ) + if compute_feature_stats: + forward_statistics_config = get_prior_config(dataset, target="statistics", **args) forward_xvector_job = forward( checkpoint=train_job.out_checkpoints[num_epochs], - config=forward_x_vector_config, + config=forward_statistics_config, returnn_exe=RETURNN_PYTORCH_EXE, returnn_root=MINI_RETURNN_ROOT, prefix=prefix + name, - target="invertibility", + target="statistics", ) - exp["forward_invertibility_job"] = forward_xvector_job + exp["forward_features_statistics"] = forward_xvector_job return exp @@ -250,23 +255,6 @@ def run_exp( xvectors_file=x_vector_extractions["x_vector_cnn/1e-3_not_silence_preprocessed/test-clean"]["hdf"], ) - asr_test_datasets = {} - - asr_test_datasets["dev-other"] = build_test_dataset(librispeech_key="train-clean-100", dataset_key="dev-other") - - asr_test_datasets2 = copy.deepcopy(asr_test_datasets) - asr_test_datasets2["train-clean-100-cv"] = build_test_dataset( - librispeech_key="train-clean-100", dataset_key="train-clean-100", test_on_tts_cv=True - ) - asr_test_datasets2["dev-clean"] = build_test_dataset(librispeech_key="train-clean-100", dataset_key="dev-clean") - - dev_dataset_tuples_with_phon = {} - for testset in ["train-clean"]: - dev_dataset_tuples_with_phon[testset] = ( - training_datasets_pe1_tts_segments.cv, - get_bliss_corpus_dict()["train-clean-100"], - ) - specaug_config = SpecaugConfig( repeat_per_n_frames=100, max_dim_time=20, @@ -387,7 +375,6 @@ def run_exp( net_module + "/enc768/100ep/dec_drop_0.05", train_args_TTS_xvector, training_datasets_pe1_tts_segments, - asr_test_datasets, 100, forward_args=forward_args, tts_eval_datasets=tts_forward_datasets_xvectors, @@ -409,7 +396,6 @@ def run_exp( net_module + "/enc768/100ep/dec_drop_0.05", train_args_TTS_xvector, training_datasets_pe1_tts_segments, - asr_test_datasets, 100, forward_args=forward_args, tts_eval_datasets=tts_forward_datasets_xvectors, @@ -423,13 +409,20 @@ def run_exp( ), ) + add_tts_model( + net_module + "/enc768/100ep/dec_drop_0.05", + TTSModel( + config=ModelConfigV1.from_dict(train_args_TTS_xvector["net_args"]["model_config"]), + checkpoint=exp_dict["train_job"].out_checkpoints[100], + ), + ) + train_args_TTS_xvector_200ep = copy.deepcopy(train_args_TTS_xvector) train_args_TTS_xvector_200ep["config"]["learning_rates"] = lr_schedule_200ep exp_dict = run_exp( net_module + "/enc768/200ep/dec_drop_0.05", train_args_TTS_xvector_200ep, training_datasets_pe1_tts_segments, - asr_test_datasets, 200, forward_args=forward_args, tts_eval_datasets=tts_forward_datasets_xvectors, @@ -450,7 +443,6 @@ def run_exp( net_module + "/enc192/200ep/dec_drop_0.05", train_args_TTS_xvector_200ep, training_datasets_pe1_tts_segments, - asr_test_datasets, 200, forward_args=forward_args, tts_eval_datasets=tts_forward_datasets_xvectors, @@ -476,7 +468,6 @@ def run_exp( net_module + "/enc768/200ep/dec_drop_0.0", train_args_TTS_xvector_200ep_no_dec_dropout, training_datasets_pe1_tts_segments, - asr_test_datasets, 200, forward_args=forward_args, tts_eval_datasets=tts_forward_datasets_xvectors, @@ -490,7 +481,6 @@ def run_exp( net_module + "/enc192/200ep/dec_drop_0.0", train_args_TTS_xvector_200ep_no_dec_dropout, training_datasets_pe1_tts_segments, - asr_test_datasets, 200, forward_args=forward_args, tts_eval_datasets=tts_forward_datasets_xvectors, @@ -507,7 +497,6 @@ def run_exp( net_module + "/enc768/200ep_long_cooldown/dec_drop_0.05", train_args_xvector_altLR, training_datasets_pe1_tts_segments, - asr_test_datasets, 200, forward_args=forward_args, tts_eval_datasets=tts_forward_datasets_xvectors, @@ -522,7 +511,6 @@ def run_exp( net_module + "/enc768/200ep_long_cooldown/dec_drop_0.0", train_args_xvector_altLR_no_dec_drop, training_datasets_pe1_tts_segments, - asr_test_datasets, 200, forward_args=forward_args, tts_eval_datasets=tts_forward_datasets_xvectors, @@ -538,7 +526,6 @@ def run_exp( net_module + "/enc768/100ep/dec_drop_0.05", train_args_TTS, training_datasets_pe1_tts_segments, - asr_test_datasets, 100, forward_args=forward_args, tts_eval_datasets=tts_forward_datasets, @@ -553,7 +540,6 @@ def run_exp( net_module + "/enc768/100ep/dec_drop_0.00", train_args_TTS_100ep_no_dec_dropout, training_datasets_pe1_tts_segments, - asr_test_datasets, 100, forward_args=forward_args, tts_eval_datasets=tts_forward_datasets, @@ -575,13 +561,13 @@ def run_exp( net_module + "/enc768/200ep/dec_drop_0.05", train_args_TTS_200ep, training_datasets_pe1_tts_segments, - asr_test_datasets, 200, forward_args=forward_args, swer_evaluation=True, tts_eval_datasets=tts_forward_datasets, eval_invertibility=True, nisqa_confidence=True, + compute_feature_stats=True, ) add_tts_model( net_module + "/enc768/200ep/dec_drop_0.05", @@ -595,7 +581,6 @@ def run_exp( net_module + "/enc768/200ep/dec_drop_0.05_epsilon_1e-8", train_args_TTS_200ep_alt_epsilon, training_datasets_pe1_tts_segments, - asr_test_datasets, 200, forward_args=forward_args, tts_eval_datasets=tts_forward_datasets, @@ -608,7 +593,6 @@ def run_exp( net_module + "/enc192/100ep/dec_drop_0.05", train_args_TTS, training_datasets_pe1_tts_segments, - asr_test_datasets, 100, forward_args=forward_args, swer_evaluation=True, @@ -619,7 +603,6 @@ def run_exp( net_module + "/enc192/200ep/dec_drop_0.05", train_args_TTS_200ep, training_datasets_pe1_tts_segments, - asr_test_datasets, 200, forward_args=forward_args, tts_eval_datasets=tts_forward_datasets, @@ -636,7 +619,6 @@ def run_exp( net_module + "/enc192/200ep/dec_drop_0.05_epsilon_1e-8", train_args_TTS_200ep_alt_epsilon, training_datasets_pe1_tts_segments, - asr_test_datasets, 200, forward_args=forward_args, tts_eval_datasets=tts_forward_datasets, @@ -651,7 +633,6 @@ def run_exp( net_module + "/enc768/200ep/dec_drop_0.0/epsilon_1e-8", train_args_TTS_no_dec_dropout, training_datasets_pe1_tts_segments, - asr_test_datasets, 200, forward_args=forward_args, tts_eval_datasets=tts_forward_datasets, @@ -662,7 +643,6 @@ def run_exp( net_module + "/enc192/200ep/dec_drop_0.0/epsilon_1e-8", train_args_TTS_no_dec_dropout, training_datasets_pe1_tts_segments, - asr_test_datasets, 200, forward_args=forward_args, tts_eval_datasets=tts_forward_datasets, @@ -676,7 +656,6 @@ def run_exp( net_module + "/enc768/200ep/dec_drop_0.0/grad_clip_10", train_args_TTS_no_dec_dropout, training_datasets_pe1_tts_segments, - asr_test_datasets, 200, forward_args=forward_args, tts_eval_datasets=tts_forward_datasets, @@ -687,7 +666,6 @@ def run_exp( net_module + "/enc192/200ep/dec_drop_0.0/grad_clip_10", train_args_TTS_no_dec_dropout, training_datasets_pe1_tts_segments, - asr_test_datasets, 200, forward_args=forward_args, tts_eval_datasets=tts_forward_datasets, @@ -729,7 +707,6 @@ def run_exp( net_module + "/12cb/200ep/dec_drop_0.05", train_args_TTS_simple_encoder, training_datasets_pe1_tts_segments, - asr_test_datasets, 200, forward_args=forward_args, swer_evaluation=True, @@ -742,7 +719,6 @@ def run_exp( net_module + "/20cb/200ep/dec_drop_0.05", train_args_TTS_simple_encoder, training_datasets_pe1_tts_segments, - asr_test_datasets, 200, forward_args=forward_args, swer_evaluation=True, @@ -788,7 +764,6 @@ def run_exp( net_module + "/enc768/200ep/dec_drop_0.05", train_args_TTS_xvector_200ep_conformer_coupling, training_datasets_pe1_tts_segments, - asr_test_datasets, 200, forward_args=forward_args, tts_eval_datasets=tts_forward_datasets_xvectors, @@ -820,7 +795,6 @@ def run_exp( net_module + "/enc768/200ep/dec_drop_0.05", train_args_TTS_xvector_200ep_multiscale, training_datasets_pe1_tts_segments, - asr_test_datasets, 200, forward_args=forward_args, tts_eval_datasets=tts_forward_datasets_xvectors, @@ -837,7 +811,6 @@ def run_exp( net_module + f"/ed_scale_{s}", train_args_xvector_dist_loss, training_datasets_pe1_tts_segments, - asr_test_datasets, 200, training_args={"ed_scale": s}, forward_args=forward_args, @@ -852,7 +825,6 @@ def run_exp( net_module + f"/ed_scale_{s}", train_args_xvector_dist_loss, training_datasets_pe1_tts_segments, - asr_test_datasets, 200, training_args={"ed_scale": s}, forward_args=forward_args, @@ -865,7 +837,6 @@ def run_exp( net_module + f"_grad_clip_10/ed_scale_{s}", train_args_xvector_dist_loss, training_datasets_pe1_tts_segments, - asr_test_datasets, 200, training_args={"ed_scale": s}, forward_args=forward_args, @@ -882,7 +853,6 @@ def run_exp( net_module + "/enc768/200ep/dec_drop_0.05", train_args_TTS_200ep_batch_norm, training_datasets_pe1_tts_segments, - asr_test_datasets, 200, forward_args=forward_args, swer_evaluation=True, @@ -923,7 +893,6 @@ def run_exp( net_module + "/enc768/400ep/gin512/dec_drop_0.05", train_args_400_gin512, training_datasets_pe1_tts_segments, - asr_test_datasets, 400, forward_args=forward_args, swer_evaluation=True, @@ -938,7 +907,6 @@ def run_exp( net_module + "/enc768/400ep/gin512/grad_clip_10/dec_drop_0.05", train_args_400_gin512_grad_norm, training_datasets_pe1_tts_segments, - asr_test_datasets, 400, forward_args=forward_args, swer_evaluation=True, @@ -959,7 +927,6 @@ def run_exp( net_module + "/enc768/400ep/dec_drop_0.05", train_args_400, training_datasets_pe1_tts_segments, - asr_test_datasets, 400, forward_args=forward_args, swer_evaluation=True, @@ -974,7 +941,6 @@ def run_exp( net_module + "/enc768/400ep/grad_clip_10/dec_drop_0.05", train_args_400_grad_norm, training_datasets_pe1_tts_segments, - asr_test_datasets, 400, forward_args=forward_args, swer_evaluation=True, @@ -996,7 +962,6 @@ def run_exp( net_module + "/enc192/400ep/grad_clip_10/dec_drop_0.05", train_args_400_grad_norm, training_datasets_pe1_tts_segments, - asr_test_datasets, 400, forward_args=forward_args, swer_evaluation=True, @@ -1023,7 +988,6 @@ def run_exp( net_module + "/enc768/400ep/gin512/dec_drop_0.05", train_args_400_xvector_gin512, training_datasets_pe1_tts_segments, - asr_test_datasets, 400, forward_args=forward_args, swer_evaluation=True, @@ -1044,13 +1008,13 @@ def run_exp( net_module + "/enc768/400ep/dec_drop_0.05", train_args_400_xvector, training_datasets_pe1_tts_segments, - asr_test_datasets, 400, forward_args=forward_args, swer_evaluation=True, nisqa_evaluation=True, tts_eval_datasets=tts_forward_datasets_xvectors, nisqa_confidence=True, + large_gpu=True ) add_tts_model( @@ -1067,7 +1031,6 @@ def run_exp( net_module + "/enc192/400ep/dec_drop_0.05", train_args_400_xvector, training_datasets_pe1_tts_segments, - asr_test_datasets, 400, forward_args=forward_args, swer_evaluation=True, diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/exp_tts/training_comparison.ipynb b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/exp_tts/training_comparison.ipynb index 72d769622..f611192ee 100644 --- a/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/exp_tts/training_comparison.ipynb +++ b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/exp_tts/training_comparison.ipynb @@ -23,21 +23,36 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{'/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc192/200ep/dec_drop_0.0/grad_clip_10/training': '/enc192/200ep/dec_drop_0.0/grad_clip_10/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/200ep/dec_drop_0.0/grad_clip_10/training': '/enc768/200ep/dec_drop_0.0/grad_clip_10/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc192/200ep/dec_drop_0.05_epsilon_1e-8/training': '/enc192/200ep/dec_drop_0.05_epsilon_1e-8/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc192/200ep/dec_drop_0.05/training': '/enc192/200ep/dec_drop_0.05/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/200ep/dec_drop_0.05_epsilon_1e-8/training': '/enc768/200ep/dec_drop_0.05_epsilon_1e-8/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/200ep/dec_drop_0.05/training': '/enc768/200ep/dec_drop_0.05/'}" + "{'/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc192/200ep/dec_drop_0.0/grad_clip_10/training': '/glowTTS/enc192/200ep/dec_drop_0.0/grad_clip_10/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/200ep/dec_drop_0.0/grad_clip_10/training': '/glowTTS/enc768/200ep/dec_drop_0.0/grad_clip_10/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc192/200ep/dec_drop_0.05_epsilon_1e-8/training': '/glowTTS/enc192/200ep/dec_drop_0.05_epsilon_1e-8/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc192/200ep/dec_drop_0.05/training': '/glowTTS/enc192/200ep/dec_drop_0.05/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc192/100ep/dec_drop_0.05/training': '/glowTTS/enc192/100ep/dec_drop_0.05/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/100ep/dec_drop_0.00/training': '/glowTTS/enc768/100ep/dec_drop_0.00/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/100ep/dec_drop_0.05/training': '/glowTTS/enc768/100ep/dec_drop_0.05/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/200ep/dec_drop_0.05_epsilon_1e-8/training': '/glowTTS/enc768/200ep/dec_drop_0.05_epsilon_1e-8/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/200ep/dec_drop_0.05/training': '/glowTTS/enc768/200ep/dec_drop_0.05/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/400ep/dec_drop_0.05/training': '/glowTTS/enc768/400ep/dec_drop_0.05/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc192/400ep/grad_clip_10/dec_drop_0.05/training': '/glowTTS/enc192/400ep/grad_clip_10/dec_drop_0.05/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/400ep/grad_clip_10/dec_drop_0.05/training': '/glowTTS/enc768/400ep/grad_clip_10/dec_drop_0.05/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/400ep/dec_drop_0.05/training': '/glowTTS_x_vector_v2/enc768/400ep/dec_drop_0.05/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/200ep/dec_drop_0.0/training': '/glowTTS_x_vector_v2/enc768/200ep/dec_drop_0.0/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/200ep/dec_drop_0.05/training': '/glowTTS_x_vector_v2/enc768/200ep/dec_drop_0.05/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/100ep/dec_drop_0.05/training': '/glowTTS_x_vector_v2/enc768/100ep/dec_drop_0.05/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/200ep_long_cooldown/dec_drop_0.0/training': '/glowTTS_x_vector_v2/enc768/200ep_long_cooldown/dec_drop_0.0/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/200ep_long_cooldown/dec_drop_0.05/training': '/glowTTS_x_vector_v2/enc768/200ep_long_cooldown/dec_drop_0.05/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc192/200ep/dec_drop_0.0/training': '/glowTTS_x_vector_v2/enc192/200ep/dec_drop_0.0/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc192/200ep/dec_drop_0.05/training': '/glowTTS_x_vector_v2/enc192/200ep/dec_drop_0.05/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc192/400ep/dec_drop_0.05/training': '/glowTTS_x_vector_v2/enc192/400ep/dec_drop_0.05/'}" ] }, - "execution_count": 3, + "execution_count": 2, "metadata": {}, "output_type": "execute_result" } @@ -47,8 +62,10 @@ " # \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS*/enc768/400ep/dec_drop_0.05/training\",\n", " # \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/400ep/grad_clip_10/dec_drop_0.05/training\",\n", " # \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc192/200ep/dec_drop_0.0*/training\",\n", - " \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc*/200ep/dec_drop_0.0*/grad_clip_10/training\",\n", - " \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc*/200ep/dec_drop_0.0*/training\",\n", + " \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc*/*/dec_drop_0.0*/grad_clip_10/training\",\n", + " \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc*/*/dec_drop_0.0*/training\",\n", + " \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc*/*/grad_clip_10/dec_drop_0.0*/training\",\n", + " \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc*/*/dec_drop_0.0*/training\",\n", "]\n", "breakpoint()\n", "lr_files = []\n", @@ -68,7 +85,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -78,6 +95,17 @@ "files[lr_files[-1]] = \"Baseline Glow-TTS 768\"" ] }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "pes = {\n", + " x: int(x.split(\"/enc\")[1][4:].split(\"00ep\")[0]) for x in lr_files\n", + "}" + ] + }, { "cell_type": "code", "execution_count": 5, @@ -87,13 +115,28 @@ "name": "stdout", "output_type": "stream", "text": [ - "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc192/200ep/dec_drop_0.0/grad_clip_10/training: 1\n", - "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/200ep/dec_drop_0.0/grad_clip_10/training: 1\n", - "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc192/200ep/dec_drop_0.05_epsilon_1e-8/training: 1\n", - "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc192/200ep/dec_drop_0.05/training: 1\n", - "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/200ep/dec_drop_0.05_epsilon_1e-8/training: 1\n", - "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/200ep/dec_drop_0.05/training: 1\n", - "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/200ep/dec_drop_0.05/training/: 1\n", + "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc192/200ep/dec_drop_0.0/grad_clip_10/training: 2\n", + "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/200ep/dec_drop_0.0/grad_clip_10/training: 2\n", + "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc192/200ep/dec_drop_0.05_epsilon_1e-8/training: 2\n", + "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc192/200ep/dec_drop_0.05/training: 2\n", + "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc192/100ep/dec_drop_0.05/training: 1\n", + "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/100ep/dec_drop_0.00/training: 1\n", + "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/100ep/dec_drop_0.05/training: 1\n", + "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/200ep/dec_drop_0.05_epsilon_1e-8/training: 2\n", + "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/200ep/dec_drop_0.05/training: 2\n", + "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/400ep/dec_drop_0.05/training: 4\n", + "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc192/400ep/grad_clip_10/dec_drop_0.05/training: 4\n", + "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/400ep/grad_clip_10/dec_drop_0.05/training: 4\n", + "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/400ep/dec_drop_0.05/training: 4\n", + "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/200ep/dec_drop_0.0/training: 2\n", + "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/200ep/dec_drop_0.05/training: 2\n", + "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/100ep/dec_drop_0.05/training: 1\n", + "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/200ep_long_cooldown/dec_drop_0.0/training: 2\n", + "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/200ep_long_cooldown/dec_drop_0.05/training: 2\n", + "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc192/200ep/dec_drop_0.0/training: 2\n", + "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc192/200ep/dec_drop_0.05/training: 2\n", + "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc192/400ep/dec_drop_0.05/training: 4\n", + "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/200ep/dec_drop_0.05/training/: 2\n", "Large Font: False\n", "Setup Interactive Legend\n", "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous view', 'arrow-left', 'back'), ('Forward', 'Forward to next view', 'arrow-right', 'forward'), ('Pan', 'Left button pans, Right button zooms\\nx/y fixes axis, CTRL fixes aspect', 'arrows', 'pan'), ('Zoom', 'Zoom to rectangle\\nx/y fixes axis', 'square-o', 'zoom'), ('Download', 'Download plot', 'floppy-o', 'save_figure')]))\n" @@ -102,18 +145,18 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "2084e635587446d2aab96b81f3fa6006", + "model_id": "8a172637e75a4d7c9eb3ccf1e74c6551", "version_major": 2, "version_minor": 0 }, - "image/png": "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", + "image/png": "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", "text/html": [ "\n", "
\n", "
\n", " Figure\n", "
\n", - " \n", + " \n", "
\n", " " ], @@ -132,7 +175,7 @@ " data = get_epoch_data(lr_file, epoch=None)\n", " if data is None:\n", " continue\n", - " p_e = 1\n", + " p_e = pes[lr_file]\n", " print(f\"{lr_file}: {p_e}\")\n", " error_data_tmp = []\n", " for ep, ep_data in data.items():\n", @@ -152,7 +195,7 @@ " shrink_axes=0.6,\n", " ylim_max=2,\n", " ylim_min=-0.9,\n", - " keys_exclude=\"devtrain|ctc|100ep|ed\",\n", + " keys_exclude=\"devtrain|ctc|ed\",\n", " # color_map=\"Set1\",\n", " draggable=True\n", ")" @@ -160,7 +203,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -169,7 +212,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -197,34 +240,32 @@ " \n", " \n", " \n", - " dev_loss_dp\n", - " dev_loss_mle\n", + " dev_loss_dp\n", " ...\n", - " dp\n", - " mle\n", + " mle\n", " \n", " \n", " level_0\n", - " /enc192/200ep/dec_drop_0.0/grad_clip_10/\n", - " /enc192/200ep/dec_drop_0.05/\n", - " /enc192/200ep/dec_drop_0.05_epsilon_1e-8/\n", - " /enc768/200ep/dec_drop_0.0/grad_clip_10/\n", - " /enc768/200ep/dec_drop_0.05/\n", - " /enc768/200ep/dec_drop_0.05_epsilon_1e-8/\n", - " Baseline Glow-TTS 768\n", - " /enc192/200ep/dec_drop_0.0/grad_clip_10/\n", - " /enc192/200ep/dec_drop_0.05/\n", - " /enc192/200ep/dec_drop_0.05_epsilon_1e-8/\n", + " /glowTTS/enc192/100ep/dec_drop_0.05/\n", + " /glowTTS/enc192/200ep/dec_drop_0.0/grad_clip_10/\n", + " /glowTTS/enc192/200ep/dec_drop_0.05/\n", + " /glowTTS/enc192/200ep/dec_drop_0.05_epsilon_1e-8/\n", + " /glowTTS/enc192/400ep/grad_clip_10/dec_drop_0.05/\n", + " /glowTTS/enc768/100ep/dec_drop_0.00/\n", + " /glowTTS/enc768/100ep/dec_drop_0.05/\n", + " /glowTTS/enc768/200ep/dec_drop_0.0/grad_clip_10/\n", + " /glowTTS/enc768/200ep/dec_drop_0.05/\n", + " /glowTTS/enc768/200ep/dec_drop_0.05_epsilon_1e-8/\n", " ...\n", - " /enc768/200ep/dec_drop_0.05/\n", - " /enc768/200ep/dec_drop_0.05_epsilon_1e-8/\n", - " Baseline Glow-TTS 768\n", - " /enc192/200ep/dec_drop_0.0/grad_clip_10/\n", - " /enc192/200ep/dec_drop_0.05/\n", - " /enc192/200ep/dec_drop_0.05_epsilon_1e-8/\n", - " /enc768/200ep/dec_drop_0.0/grad_clip_10/\n", - " /enc768/200ep/dec_drop_0.05/\n", - " /enc768/200ep/dec_drop_0.05_epsilon_1e-8/\n", + " /glowTTS_x_vector_v2/enc192/200ep/dec_drop_0.0/\n", + " /glowTTS_x_vector_v2/enc192/200ep/dec_drop_0.05/\n", + " /glowTTS_x_vector_v2/enc192/400ep/dec_drop_0.05/\n", + " /glowTTS_x_vector_v2/enc768/100ep/dec_drop_0.05/\n", + " /glowTTS_x_vector_v2/enc768/200ep/dec_drop_0.0/\n", + " /glowTTS_x_vector_v2/enc768/200ep/dec_drop_0.05/\n", + " /glowTTS_x_vector_v2/enc768/200ep_long_cooldown/dec_drop_0.0/\n", + " /glowTTS_x_vector_v2/enc768/200ep_long_cooldown/dec_drop_0.05/\n", + " /glowTTS_x_vector_v2/enc768/400ep/dec_drop_0.05/\n", " Baseline Glow-TTS 768\n", " \n", " \n", @@ -255,123 +296,123 @@ " \n", " \n", " 1\n", - " 1.238803\n", - " 1.230068\n", - " 1.229908\n", - " 1.076835\n", - " 1.238104\n", - " 1.235275\n", - " 1.238104\n", - " 0.046450\n", - " 0.073396\n", - " 0.073425\n", + " 1.230100\n", + " 1.221815\n", + " 1.235547\n", + " 1.237038\n", + " 1.256802\n", + " 1.076987\n", + " 1.237908\n", + " 1.094651\n", + " 1.295716\n", + " 1.296690\n", " ...\n", - " 1.145111\n", - " 1.145046\n", - " 1.145111\n", - " 0.537252\n", - " 0.568119\n", - " 0.569599\n", - " 0.502620\n", - " 0.530890\n", - " 0.532545\n", - " 0.530890\n", + " 0.287960\n", + " 0.290018\n", + " 0.029518\n", + " 0.541159\n", + " 0.266416\n", + " 0.267837\n", + " 0.798228\n", + " 0.798930\n", + " 0.004251\n", + " 0.232372\n", " \n", " \n", " 2\n", - " 1.204827\n", - " 1.241025\n", - " 1.244168\n", - " 1.112467\n", - " 1.353328\n", - " 1.358104\n", - " 1.353328\n", - " -0.219648\n", - " -0.152898\n", - " -0.153953\n", + " 1.246446\n", + " 1.173005\n", + " 1.247849\n", + " 1.251819\n", + " 1.329956\n", + " 1.101618\n", + " 1.429635\n", + " 1.071850\n", + " 1.645345\n", + " 1.645638\n", " ...\n", - " 1.166236\n", - " 1.166261\n", - " 1.166236\n", - " -0.101299\n", - " -0.082530\n", - " -0.082966\n", - " -0.083080\n", - " -0.066146\n", - " -0.066379\n", - " -0.066146\n", + " -0.235335\n", + " -0.231702\n", + " -0.455761\n", + " -0.029426\n", + " -0.264689\n", + " -0.259478\n", + " -0.206659\n", + " -0.201726\n", + " -0.479359\n", + " -0.332803\n", " \n", " \n", " 3\n", - " 1.180695\n", - " 1.246691\n", - " 1.245888\n", - " 1.089663\n", - " 1.722623\n", - " 1.748128\n", - " 1.722623\n", - " -0.341818\n", - " -0.295465\n", - " -0.295729\n", + " 1.255786\n", + " 1.157437\n", + " 1.267252\n", + " 1.275061\n", + " 1.074281\n", + " 1.093754\n", + " 1.723272\n", + " 1.056306\n", + " 1.434315\n", + " 1.437929\n", " ...\n", - " 1.148909\n", - " 1.149577\n", - " 1.148909\n", - " -0.294475\n", - " -0.281159\n", - " -0.281597\n", - " -0.293310\n", - " -0.281814\n", - " -0.282104\n", - " -0.281814\n", + " -0.421064\n", + " -0.418663\n", + " -0.553655\n", + " -0.247951\n", + " -0.447814\n", + " -0.443378\n", + " -0.453987\n", + " -0.448675\n", + " -0.573150\n", + " -0.450035\n", " \n", " \n", " 4\n", - " 1.165315\n", - " 1.249006\n", - " 1.257749\n", - " 1.054037\n", - " 1.568067\n", - " 1.543148\n", - " 1.568067\n", - " -0.392180\n", - " -0.361857\n", - " -0.362248\n", + " 1.246023\n", + " 1.232874\n", + " 1.308826\n", + " 1.298183\n", + " 1.002807\n", + " 1.051502\n", + " 1.547274\n", + " 1.042766\n", + " 1.238428\n", + " 1.253040\n", " ...\n", - " 1.126033\n", - " 1.126183\n", - " 1.126033\n", - " -0.371938\n", - " -0.375815\n", - " -0.375824\n", - " -0.381286\n", - " -0.383792\n", - " -0.383782\n", - " -0.383792\n", + " -0.494228\n", + " -0.492276\n", + " -0.606141\n", + " -0.392323\n", + " -0.518874\n", + " -0.515698\n", + " -0.540485\n", + " -0.536202\n", + " -0.618904\n", + " -0.507752\n", " \n", " \n", " 5\n", - " 1.159592\n", - " 1.247790\n", - " 1.248264\n", - " 1.055813\n", - " 1.463525\n", - " 1.484941\n", - " 1.463525\n", - " -0.419574\n", - " -0.413436\n", - " -0.414346\n", + " 1.236534\n", + " 1.229356\n", + " 1.346720\n", + " 1.328731\n", + " 1.011019\n", + " 1.074268\n", + " 1.308311\n", + " 1.062859\n", + " 1.124593\n", + " 1.129739\n", " ...\n", - " 1.104397\n", - " 1.104511\n", - " 1.104397\n", - " -0.410438\n", - " -0.422834\n", - " -0.422658\n", - " -0.422354\n", - " -0.433206\n", - " -0.433054\n", - " -0.433206\n", + " -0.533924\n", + " -0.536283\n", + " -0.640664\n", + " -0.467505\n", + " -0.559829\n", + " -0.558296\n", + " -0.586900\n", + " -0.583516\n", + " -0.647800\n", + " -0.551041\n", " \n", " \n", " ...\n", @@ -398,315 +439,420 @@ " ...\n", " \n", " \n", - " 196\n", - " 0.430796\n", - " 0.678780\n", - " 0.824717\n", - " 0.445126\n", - " 0.442368\n", - " 0.438285\n", - " 0.442368\n", - " -0.837367\n", - " -0.813777\n", - " -0.816068\n", + " 96\n", + " 0.795653\n", + " 0.431044\n", + " 0.795220\n", + " 0.750872\n", + " NaN\n", + " 0.438743\n", + " 0.433290\n", + " 0.445215\n", + " 0.442588\n", + " 0.438332\n", " ...\n", - " 0.388870\n", - " 0.387081\n", - " 0.388870\n", - " -0.850404\n", - " -0.808053\n", - " -0.806879\n", - " -0.848083\n", - " -0.811209\n", - " -0.810240\n", - " -0.811209\n", + " -0.836890\n", + " -0.808481\n", + " NaN\n", + " -0.792415\n", + " -0.808796\n", + " -0.806530\n", + " -0.842475\n", + " -0.805711\n", + " NaN\n", + " -0.809823\n", " \n", " \n", - " 197\n", - " 0.429870\n", - " 0.745400\n", - " 0.824725\n", - " 0.444218\n", - " 0.440721\n", - " 0.437338\n", - " 0.440721\n", - " -0.837755\n", - " -0.810379\n", - " -0.815329\n", + " 97\n", + " 0.805976\n", + " 0.430928\n", + " 0.700293\n", + " 0.790482\n", + " NaN\n", + " 0.438660\n", + " 0.434222\n", + " 0.446601\n", + " 0.442310\n", + " 0.439489\n", " ...\n", - " 0.388216\n", - " 0.386526\n", - " 0.388216\n", - " -0.850987\n", - " -0.808369\n", - " -0.807225\n", - " -0.848792\n", - " -0.811539\n", - " -0.810735\n", - " -0.811539\n", + " -0.837922\n", + " -0.809084\n", + " NaN\n", + " -0.793009\n", + " -0.809899\n", + " -0.807328\n", + " -0.843173\n", + " -0.806196\n", + " NaN\n", + " -0.810414\n", " \n", " \n", - " 198\n", - " 0.432065\n", - " 0.682156\n", - " 0.812607\n", - " 0.445028\n", - " 0.441705\n", - " 0.437170\n", - " 0.441705\n", - " -0.830906\n", - " -0.814995\n", - " -0.817098\n", + " 98\n", + " 0.772572\n", + " 0.430030\n", + " 0.646661\n", + " 0.820845\n", + " NaN\n", + " 0.438703\n", + " 0.433427\n", + " 0.445311\n", + " 0.442427\n", + " 0.437876\n", " ...\n", - " 0.388245\n", - " 0.386545\n", - " 0.388245\n", - " -0.851446\n", - " -0.808689\n", - " -0.807542\n", - " -0.849257\n", - " -0.810812\n", - " -0.811058\n", - " -0.810812\n", + " -0.838980\n", + " -0.809520\n", + " NaN\n", + " -0.793083\n", + " -0.811023\n", + " -0.808048\n", + " -0.844026\n", + " -0.806705\n", + " NaN\n", + " -0.811041\n", " \n", " \n", - " 199\n", - " 0.430398\n", - " 0.600570\n", - " 0.808616\n", - " 0.446232\n", - " 0.442230\n", - " 0.437704\n", - " 0.442230\n", - " -0.835626\n", - " -0.814634\n", - " -0.816613\n", + " 99\n", + " 0.793428\n", + " 0.430968\n", + " 0.713778\n", + " 0.818666\n", + " NaN\n", + " 0.439357\n", + " 0.433838\n", + " 0.444623\n", + " 0.441213\n", + " 0.437254\n", " ...\n", - " 0.387994\n", - " 0.386290\n", - " 0.387994\n", - " -0.852212\n", - " -0.809059\n", - " -0.807872\n", - " -0.849940\n", - " -0.811891\n", - " -0.811443\n", - " -0.811891\n", + " -0.840099\n", + " -0.810355\n", + " NaN\n", + " -0.793955\n", + " -0.812145\n", + " -0.808773\n", + " -0.845038\n", + " -0.807293\n", + " NaN\n", + " -0.811176\n", " \n", " \n", - " 200\n", - " 0.431975\n", - " 0.615026\n", - " 0.814173\n", - " 0.445801\n", - " 0.441218\n", - " 0.438248\n", - " 0.441218\n", - " -0.773976\n", - " -0.815064\n", - " -0.817505\n", + " 100\n", + " 0.777391\n", + " 0.431187\n", + " 0.607798\n", + " 0.811394\n", + " NaN\n", + " 0.437995\n", + " 0.432689\n", + " 0.446017\n", + " 0.441724\n", + " 0.437976\n", " ...\n", - " 0.387377\n", - " 0.386067\n", - " 0.387377\n", - " -0.852834\n", - " -0.809477\n", - " -0.808277\n", - " -0.850649\n", - " -0.812429\n", - " -0.811807\n", - " -0.812429\n", + " -0.841319\n", + " -0.811221\n", + " NaN\n", + " -0.795013\n", + " -0.813296\n", + " -0.809496\n", + " -0.846297\n", + " -0.807831\n", + " NaN\n", + " -0.812160\n", " \n", " \n", "\n", - "

200 rows × 28 columns

\n", + "

100 rows × 88 columns

\n", "" ], "text/plain": [ - " dev_loss_dp \\\n", - "level_0 /enc192/200ep/dec_drop_0.0/grad_clip_10/ /enc192/200ep/dec_drop_0.05/ \n", - "level_1 \n", - "1 1.238803 1.230068 \n", - "2 1.204827 1.241025 \n", - "3 1.180695 1.246691 \n", - "4 1.165315 1.249006 \n", - "5 1.159592 1.247790 \n", - "... ... ... \n", - "196 0.430796 0.678780 \n", - "197 0.429870 0.745400 \n", - "198 0.432065 0.682156 \n", - "199 0.430398 0.600570 \n", - "200 0.431975 0.615026 \n", + " dev_loss_dp \\\n", + "level_0 /glowTTS/enc192/100ep/dec_drop_0.05/ \n", + "level_1 \n", + "1 1.230100 \n", + "2 1.246446 \n", + "3 1.255786 \n", + "4 1.246023 \n", + "5 1.236534 \n", + "... ... \n", + "96 0.795653 \n", + "97 0.805976 \n", + "98 0.772572 \n", + "99 0.793428 \n", + "100 0.777391 \n", "\n", - " \\\n", - "level_0 /enc192/200ep/dec_drop_0.05_epsilon_1e-8/ \n", - "level_1 \n", - "1 1.229908 \n", - "2 1.244168 \n", - "3 1.245888 \n", - "4 1.257749 \n", - "5 1.248264 \n", - "... ... \n", - "196 0.824717 \n", - "197 0.824725 \n", - "198 0.812607 \n", - "199 0.808616 \n", - "200 0.814173 \n", + " \\\n", + "level_0 /glowTTS/enc192/200ep/dec_drop_0.0/grad_clip_10/ \n", + "level_1 \n", + "1 1.221815 \n", + "2 1.173005 \n", + "3 1.157437 \n", + "4 1.232874 \n", + "5 1.229356 \n", + "... ... \n", + "96 0.431044 \n", + "97 0.430928 \n", + "98 0.430030 \n", + "99 0.430968 \n", + "100 0.431187 \n", "\n", - " \\\n", - "level_0 /enc768/200ep/dec_drop_0.0/grad_clip_10/ /enc768/200ep/dec_drop_0.05/ \n", - "level_1 \n", - "1 1.076835 1.238104 \n", - "2 1.112467 1.353328 \n", - "3 1.089663 1.722623 \n", - "4 1.054037 1.568067 \n", - "5 1.055813 1.463525 \n", - "... ... ... \n", - "196 0.445126 0.442368 \n", - "197 0.444218 0.440721 \n", - "198 0.445028 0.441705 \n", - "199 0.446232 0.442230 \n", - "200 0.445801 0.441218 \n", + " \\\n", + "level_0 /glowTTS/enc192/200ep/dec_drop_0.05/ \n", + "level_1 \n", + "1 1.235547 \n", + "2 1.247849 \n", + "3 1.267252 \n", + "4 1.308826 \n", + "5 1.346720 \n", + "... ... \n", + "96 0.795220 \n", + "97 0.700293 \n", + "98 0.646661 \n", + "99 0.713778 \n", + "100 0.607798 \n", "\n", - " \\\n", - "level_0 /enc768/200ep/dec_drop_0.05_epsilon_1e-8/ Baseline Glow-TTS 768 \n", - "level_1 \n", - "1 1.235275 1.238104 \n", - "2 1.358104 1.353328 \n", - "3 1.748128 1.722623 \n", - "4 1.543148 1.568067 \n", - "5 1.484941 1.463525 \n", - "... ... ... \n", - "196 0.438285 0.442368 \n", - "197 0.437338 0.440721 \n", - "198 0.437170 0.441705 \n", - "199 0.437704 0.442230 \n", - "200 0.438248 0.441218 \n", + " \\\n", + "level_0 /glowTTS/enc192/200ep/dec_drop_0.05_epsilon_1e-8/ \n", + "level_1 \n", + "1 1.237038 \n", + "2 1.251819 \n", + "3 1.275061 \n", + "4 1.298183 \n", + "5 1.328731 \n", + "... ... \n", + "96 0.750872 \n", + "97 0.790482 \n", + "98 0.820845 \n", + "99 0.818666 \n", + "100 0.811394 \n", "\n", - " dev_loss_mle \\\n", - "level_0 /enc192/200ep/dec_drop_0.0/grad_clip_10/ /enc192/200ep/dec_drop_0.05/ \n", - "level_1 \n", - "1 0.046450 0.073396 \n", - "2 -0.219648 -0.152898 \n", - "3 -0.341818 -0.295465 \n", - "4 -0.392180 -0.361857 \n", - "5 -0.419574 -0.413436 \n", - "... ... ... \n", - "196 -0.837367 -0.813777 \n", - "197 -0.837755 -0.810379 \n", - "198 -0.830906 -0.814995 \n", - "199 -0.835626 -0.814634 \n", - "200 -0.773976 -0.815064 \n", + " \\\n", + "level_0 /glowTTS/enc192/400ep/grad_clip_10/dec_drop_0.05/ \n", + "level_1 \n", + "1 1.256802 \n", + "2 1.329956 \n", + "3 1.074281 \n", + "4 1.002807 \n", + "5 1.011019 \n", + "... ... \n", + "96 NaN \n", + "97 NaN \n", + "98 NaN \n", + "99 NaN \n", + "100 NaN \n", "\n", - " ... \\\n", - "level_0 /enc192/200ep/dec_drop_0.05_epsilon_1e-8/ ... \n", - "level_1 ... \n", - "1 0.073425 ... \n", - "2 -0.153953 ... \n", - "3 -0.295729 ... \n", - "4 -0.362248 ... \n", - "5 -0.414346 ... \n", - "... ... ... \n", - "196 -0.816068 ... \n", - "197 -0.815329 ... \n", - "198 -0.817098 ... \n", - "199 -0.816613 ... \n", - "200 -0.817505 ... \n", + " \\\n", + "level_0 /glowTTS/enc768/100ep/dec_drop_0.00/ \n", + "level_1 \n", + "1 1.076987 \n", + "2 1.101618 \n", + "3 1.093754 \n", + "4 1.051502 \n", + "5 1.074268 \n", + "... ... \n", + "96 0.438743 \n", + "97 0.438660 \n", + "98 0.438703 \n", + "99 0.439357 \n", + "100 0.437995 \n", "\n", - " dp \\\n", - "level_0 /enc768/200ep/dec_drop_0.05/ \n", - "level_1 \n", - "1 1.145111 \n", - "2 1.166236 \n", - "3 1.148909 \n", - "4 1.126033 \n", - "5 1.104397 \n", - "... ... \n", - "196 0.388870 \n", - "197 0.388216 \n", - "198 0.388245 \n", - "199 0.387994 \n", - "200 0.387377 \n", + " \\\n", + "level_0 /glowTTS/enc768/100ep/dec_drop_0.05/ \n", + "level_1 \n", + "1 1.237908 \n", + "2 1.429635 \n", + "3 1.723272 \n", + "4 1.547274 \n", + "5 1.308311 \n", + "... ... \n", + "96 0.433290 \n", + "97 0.434222 \n", + "98 0.433427 \n", + "99 0.433838 \n", + "100 0.432689 \n", "\n", - " \\\n", - "level_0 /enc768/200ep/dec_drop_0.05_epsilon_1e-8/ Baseline Glow-TTS 768 \n", - "level_1 \n", - "1 1.145046 1.145111 \n", - "2 1.166261 1.166236 \n", - "3 1.149577 1.148909 \n", - "4 1.126183 1.126033 \n", - "5 1.104511 1.104397 \n", - "... ... ... \n", - "196 0.387081 0.388870 \n", - "197 0.386526 0.388216 \n", - "198 0.386545 0.388245 \n", - "199 0.386290 0.387994 \n", - "200 0.386067 0.387377 \n", + " \\\n", + "level_0 /glowTTS/enc768/200ep/dec_drop_0.0/grad_clip_10/ \n", + "level_1 \n", + "1 1.094651 \n", + "2 1.071850 \n", + "3 1.056306 \n", + "4 1.042766 \n", + "5 1.062859 \n", + "... ... \n", + "96 0.445215 \n", + "97 0.446601 \n", + "98 0.445311 \n", + "99 0.444623 \n", + "100 0.446017 \n", "\n", - " mle \\\n", - "level_0 /enc192/200ep/dec_drop_0.0/grad_clip_10/ /enc192/200ep/dec_drop_0.05/ \n", - "level_1 \n", - "1 0.537252 0.568119 \n", - "2 -0.101299 -0.082530 \n", - "3 -0.294475 -0.281159 \n", - "4 -0.371938 -0.375815 \n", - "5 -0.410438 -0.422834 \n", - "... ... ... \n", - "196 -0.850404 -0.808053 \n", - "197 -0.850987 -0.808369 \n", - "198 -0.851446 -0.808689 \n", - "199 -0.852212 -0.809059 \n", - "200 -0.852834 -0.809477 \n", + " \\\n", + "level_0 /glowTTS/enc768/200ep/dec_drop_0.05/ \n", + "level_1 \n", + "1 1.295716 \n", + "2 1.645345 \n", + "3 1.434315 \n", + "4 1.238428 \n", + "5 1.124593 \n", + "... ... \n", + "96 0.442588 \n", + "97 0.442310 \n", + "98 0.442427 \n", + "99 0.441213 \n", + "100 0.441724 \n", "\n", - " \\\n", - "level_0 /enc192/200ep/dec_drop_0.05_epsilon_1e-8/ \n", - "level_1 \n", - "1 0.569599 \n", - "2 -0.082966 \n", - "3 -0.281597 \n", - "4 -0.375824 \n", - "5 -0.422658 \n", - "... ... \n", - "196 -0.806879 \n", - "197 -0.807225 \n", - "198 -0.807542 \n", - "199 -0.807872 \n", - "200 -0.808277 \n", + " ... \\\n", + "level_0 /glowTTS/enc768/200ep/dec_drop_0.05_epsilon_1e-8/ ... \n", + "level_1 ... \n", + "1 1.296690 ... \n", + "2 1.645638 ... \n", + "3 1.437929 ... \n", + "4 1.253040 ... \n", + "5 1.129739 ... \n", + "... ... ... \n", + "96 0.438332 ... \n", + "97 0.439489 ... \n", + "98 0.437876 ... \n", + "99 0.437254 ... \n", + "100 0.437976 ... \n", "\n", - " \\\n", - "level_0 /enc768/200ep/dec_drop_0.0/grad_clip_10/ /enc768/200ep/dec_drop_0.05/ \n", - "level_1 \n", - "1 0.502620 0.530890 \n", - "2 -0.083080 -0.066146 \n", - "3 -0.293310 -0.281814 \n", - "4 -0.381286 -0.383792 \n", - "5 -0.422354 -0.433206 \n", - "... ... ... \n", - "196 -0.848083 -0.811209 \n", - "197 -0.848792 -0.811539 \n", - "198 -0.849257 -0.810812 \n", - "199 -0.849940 -0.811891 \n", - "200 -0.850649 -0.812429 \n", + " mle \\\n", + "level_0 /glowTTS_x_vector_v2/enc192/200ep/dec_drop_0.0/ \n", + "level_1 \n", + "1 0.287960 \n", + "2 -0.235335 \n", + "3 -0.421064 \n", + "4 -0.494228 \n", + "5 -0.533924 \n", + "... ... \n", + "96 -0.836890 \n", + "97 -0.837922 \n", + "98 -0.838980 \n", + "99 -0.840099 \n", + "100 -0.841319 \n", + "\n", + " \\\n", + "level_0 /glowTTS_x_vector_v2/enc192/200ep/dec_drop_0.05/ \n", + "level_1 \n", + "1 0.290018 \n", + "2 -0.231702 \n", + "3 -0.418663 \n", + "4 -0.492276 \n", + "5 -0.536283 \n", + "... ... \n", + "96 -0.808481 \n", + "97 -0.809084 \n", + "98 -0.809520 \n", + "99 -0.810355 \n", + "100 -0.811221 \n", + "\n", + " \\\n", + "level_0 /glowTTS_x_vector_v2/enc192/400ep/dec_drop_0.05/ \n", + "level_1 \n", + "1 0.029518 \n", + "2 -0.455761 \n", + "3 -0.553655 \n", + "4 -0.606141 \n", + "5 -0.640664 \n", + "... ... \n", + "96 NaN \n", + "97 NaN \n", + "98 NaN \n", + "99 NaN \n", + "100 NaN \n", + "\n", + " \\\n", + "level_0 /glowTTS_x_vector_v2/enc768/100ep/dec_drop_0.05/ \n", + "level_1 \n", + "1 0.541159 \n", + "2 -0.029426 \n", + "3 -0.247951 \n", + "4 -0.392323 \n", + "5 -0.467505 \n", + "... ... \n", + "96 -0.792415 \n", + "97 -0.793009 \n", + "98 -0.793083 \n", + "99 -0.793955 \n", + "100 -0.795013 \n", "\n", - " \n", - "level_0 /enc768/200ep/dec_drop_0.05_epsilon_1e-8/ Baseline Glow-TTS 768 \n", + " \\\n", + "level_0 /glowTTS_x_vector_v2/enc768/200ep/dec_drop_0.0/ \n", + "level_1 \n", + "1 0.266416 \n", + "2 -0.264689 \n", + "3 -0.447814 \n", + "4 -0.518874 \n", + "5 -0.559829 \n", + "... ... \n", + "96 -0.808796 \n", + "97 -0.809899 \n", + "98 -0.811023 \n", + "99 -0.812145 \n", + "100 -0.813296 \n", + "\n", + " \\\n", + "level_0 /glowTTS_x_vector_v2/enc768/200ep/dec_drop_0.05/ \n", + "level_1 \n", + "1 0.267837 \n", + "2 -0.259478 \n", + "3 -0.443378 \n", + "4 -0.515698 \n", + "5 -0.558296 \n", + "... ... \n", + "96 -0.806530 \n", + "97 -0.807328 \n", + "98 -0.808048 \n", + "99 -0.808773 \n", + "100 -0.809496 \n", + "\n", + " \\\n", + "level_0 /glowTTS_x_vector_v2/enc768/200ep_long_cooldown/dec_drop_0.0/ \n", + "level_1 \n", + "1 0.798228 \n", + "2 -0.206659 \n", + "3 -0.453987 \n", + "4 -0.540485 \n", + "5 -0.586900 \n", + "... ... \n", + "96 -0.842475 \n", + "97 -0.843173 \n", + "98 -0.844026 \n", + "99 -0.845038 \n", + "100 -0.846297 \n", + "\n", + " \\\n", + "level_0 /glowTTS_x_vector_v2/enc768/200ep_long_cooldown/dec_drop_0.05/ \n", "level_1 \n", - "1 0.532545 0.530890 \n", - "2 -0.066379 -0.066146 \n", - "3 -0.282104 -0.281814 \n", - "4 -0.383782 -0.383792 \n", - "5 -0.433054 -0.433206 \n", - "... ... ... \n", - "196 -0.810240 -0.811209 \n", - "197 -0.810735 -0.811539 \n", - "198 -0.811058 -0.810812 \n", - "199 -0.811443 -0.811891 \n", - "200 -0.811807 -0.812429 \n", + "1 0.798930 \n", + "2 -0.201726 \n", + "3 -0.448675 \n", + "4 -0.536202 \n", + "5 -0.583516 \n", + "... ... \n", + "96 -0.805711 \n", + "97 -0.806196 \n", + "98 -0.806705 \n", + "99 -0.807293 \n", + "100 -0.807831 \n", "\n", - "[200 rows x 28 columns]" + " \n", + "level_0 /glowTTS_x_vector_v2/enc768/400ep/dec_drop_0.05/ Baseline Glow-TTS 768 \n", + "level_1 \n", + "1 0.004251 0.232372 \n", + "2 -0.479359 -0.332803 \n", + "3 -0.573150 -0.450035 \n", + "4 -0.618904 -0.507752 \n", + "5 -0.647800 -0.551041 \n", + "... ... ... \n", + "96 NaN -0.809823 \n", + "97 NaN -0.810414 \n", + "98 NaN -0.811041 \n", + "99 NaN -0.811176 \n", + "100 NaN -0.812160 \n", + "\n", + "[100 rows x 88 columns]" ] }, - "execution_count": 14, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -717,7 +863,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -755,7 +901,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/pipeline.py b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/pipeline.py index ed5402169..a2e532e79 100644 --- a/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/pipeline.py +++ b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/pipeline.py @@ -14,7 +14,7 @@ from .default_tools import SCTK_BINARY_PATH, NISQA_REPO -def training(config, returnn_exe, returnn_root, prefix, num_epochs=65): +def training(config, returnn_exe, returnn_root, prefix, num_epochs=65, large_gpu=False): train_job = ReturnnTrainingJob( config, log_verbosity=5, @@ -25,6 +25,10 @@ def training(config, returnn_exe, returnn_root, prefix, num_epochs=65): returnn_python_exe=returnn_exe, returnn_root=returnn_root, ) + + if large_gpu: + train_job.rqmt["gpu_mem"] = 24 + train_job.add_alias(prefix + "/training") tk.register_output(prefix + "/training.models", train_job.out_model_dir) @@ -240,3 +244,36 @@ def compute_phoneme_pred_accuracy( tk.register_output(prefix_name + f"/{target}_pred/{key}/accuracy", mean_accuracy_job.out_accuracy) jobs.append(search_job) return jobs + +@tk.block() +def compute_prior( + prefix_name, + returnn_config, + checkpoint, + returnn_exe, + returnn_root, + mem_rqmt=8, +): + """ + Run search for a specific test dataset + + :param str prefix_name: + :param ReturnnConfig returnn_config: + :param Checkpoint checkpoint: + :param Path returnn_exe: + :param Path returnn_root: + """ + search_job = ReturnnForwardJobV2( + model_checkpoint=checkpoint, + returnn_config=returnn_config, + log_verbosity=5, + mem_rqmt=mem_rqmt, + time_rqmt=1, + device="gpu", + cpu_rqmt=4, + returnn_python_exe=returnn_exe, + returnn_root=returnn_root, + output_files=["prior.txt"], + ) + search_job.add_alias(prefix_name + "/prior_job") + return search_job.out_files["prior.txt"] diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/pytorch_networks/frozen_glowtts/glowASR_conformer_x_vector.py b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/pytorch_networks/frozen_glowtts/glowASR_conformer_x_vector.py index 0d34a2d53..ae4660b7a 100644 --- a/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/pytorch_networks/frozen_glowtts/glowASR_conformer_x_vector.py +++ b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/pytorch_networks/frozen_glowtts/glowASR_conformer_x_vector.py @@ -380,7 +380,7 @@ def train_step(*, model: nn.Module, data, run_ctx, **kwargs): phon_labels, input_lengths=audio_features_len, target_lengths=phon_labels_len, - blank=model.cfg.label_target_size, + blank=model.conf_cfg.label_target_size, reduction="sum", zero_infinity=True ) @@ -388,7 +388,7 @@ def train_step(*, model: nn.Module, data, run_ctx, **kwargs): run_ctx.mark_as_loss(name="ctc", loss=ctc_loss, inv_norm_factor=num_phonemes) -def forward_init_hook(run_ctx, **kwargs): +def search_init_hook(run_ctx, **kwargs): # we are storing durations, but call it output.hdf to match # the default output of the ReturnnForwardJob from torchaudio.models.decoder import ctc_decoder @@ -403,44 +403,26 @@ def forward_init_hook(run_ctx, **kwargs): vocab = Vocabulary.create_vocab( vocab_file=kwargs["returnn_vocab"], unknown_label=None) labels = vocab.labels - print(f"labels from vocab:{labels}") - if "asr_data" in kwargs.keys() and kwargs["asr_data"]: - print(f"Using ctc_decoder for ASR data...") - run_ctx.ctc_decoder = ctc_decoder( - lexicon=kwargs["lexicon"], - lm=lm, - lm_weight=kwargs["lm_weight"], - tokens=labels + ["[blank]", "[SILENCE]", "[UNK]"], - # "[SILENCE]" and "[UNK]" are not actually part of the vocab, - # but the decoder is happy as long they are defined in the token list - # even if they do not exist as label index in the softmax output, - blank_token="[blank]", - sil_token="[SILENCE]", - unk_word="[unknown]", - nbest=1, - beam_size=kwargs["beam_size"], - beam_size_token=kwargs.get("beam_size_token", None), - beam_threshold=kwargs["beam_threshold"], - sil_score=kwargs.get("sil_score", 0.0), - word_score=kwargs.get("word_score", 0.0), - ) - else: - print(f"Using ctc_decoder for TTS data...") - - run_ctx.ctc_decoder = ctc_decoder( - lexicon=kwargs["lexicon"], - lm=lm, - lm_weight=kwargs["lm_weight"], - tokens=labels, - blank_token="[blank]", - sil_token="[space]", # [space] is our actual silence - unk_word="[UNKNOWN]", - nbest=1, - beam_size=kwargs["beam_size"], - beam_threshold=kwargs["beam_threshold"], - sil_score=kwargs.get("sil_score", 0.0), - word_score=kwargs.get("word_score", 0.0), - ) + print(f"Using ctc_decoder for ASR data...") + run_ctx.ctc_decoder = ctc_decoder( + lexicon=kwargs["lexicon"], + lm=lm, + lm_weight=kwargs["lm_weight"], + tokens=labels + ["[blank]", "[SILENCE]", "[UNK]"], + # "[SILENCE]" and "[UNK]" are not actually part of the vocab, + # but the decoder is happy as long they are defined in the token list + # even if they do not exist as label index in the softmax output, + blank_token="[blank]", + sil_token="[SILENCE]", + unk_word="[unknown]", + nbest=1, + beam_size=kwargs["beam_size"], + beam_size_token=kwargs.get("beam_size_token", None), + beam_threshold=kwargs["beam_threshold"], + sil_score=kwargs.get("sil_score", 0.0), + word_score=kwargs.get("word_score", 0.0), + ) + run_ctx.labels = labels run_ctx.blank_log_penalty = kwargs.get("blank_log_penalty", None) @@ -451,12 +433,12 @@ def forward_init_hook(run_ctx, **kwargs): run_ctx.prior = None -def forward_finish_hook(run_ctx, **kwargs): +def search_finish_hook(run_ctx, **kwargs): run_ctx.recognition_file.write("}\n") run_ctx.recognition_file.close() -def forward_step(*, model, data, run_ctx, **kwargs): +def search_step(*, model, data, run_ctx, **kwargs): raw_audio = data["raw_audio"] # [B, T', F] raw_audio_len = data["raw_audio:size1"] # [B] logprobs, audio_features_len = model( @@ -480,4 +462,38 @@ def forward_step(*, model, data, run_ctx, **kwargs): print(sequence) run_ctx.recognition_file.write("%s: %s,\n" % (repr(tag), repr(sequence))) +def forward_init_hook_prior(run_ctx, **kwargs): + # we are storing durations, but call it output.hdf to match + # the default output of the ReturnnForwardJob + run_ctx.sum_probs = None + run_ctx.sum_frames = 0 + + +def forward_finish_hook_prior(run_ctx, **kwargs): + all_frames = run_ctx.sum_frames.detach().cpu().numpy() + all_probs = run_ctx.sum_probs.detach().cpu().numpy() + average_probs = all_probs / all_frames + log_average_probs = np.log(average_probs) + print("Prior sum in std-space (should be close to 1.0):", np.sum(average_probs)) + with open("prior.txt", 'w') as f: + np.savetxt(f, log_average_probs, delimiter=' ') + print("Saved prior in prior.txt in +log space.") + + +def forward_step_prior(*, model, data, run_ctx, **kwargs): + raw_audio = data["audio_features"] # [B, T', F] + raw_audio_len = data["audio_features:size1"] # [B] + + logprobs, audio_features_len = model( + raw_audio=raw_audio, + raw_audio_len=raw_audio_len + ) + + probs = torch.exp(logprobs) + run_ctx.sum_frames = run_ctx.sum_frames + torch.sum(audio_features_len) + if run_ctx.sum_probs is None: + run_ctx.sum_probs = torch.sum(probs, dim=(0, 1)) + else: + run_ctx.sum_probs += torch.sum(probs, dim=(0, 1)) + diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/pytorch_networks/glowTTS.py b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/pytorch_networks/glowTTS.py index 4ebb7b991..caacb4de7 100644 --- a/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/pytorch_networks/glowTTS.py +++ b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/pytorch_networks/glowTTS.py @@ -20,6 +20,8 @@ from .shared.eval_invertibility import * +from .shared.feature_statistics import * + class DurationPredictor(nn.Module): """ Duration Predictor module, trained using calculated durations coming from monotonic alignment search diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/pytorch_networks/shared/eval_invertibility.py b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/pytorch_networks/shared/eval_invertibility.py index 3cdc198d0..92ee59238 100644 --- a/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/pytorch_networks/shared/eval_invertibility.py +++ b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/pytorch_networks/shared/eval_invertibility.py @@ -66,7 +66,7 @@ def forward_step_invertibility(*, model, data, run_ctx, **kwargs): mae.sum() / current_num_of_obs ) # This considers the masking by only using the mean over all unmasked elements - current_var = (mae - current_mae).sum() / ( + current_var = (mae - current_mae).pow(2).sum() / ( current_num_of_obs - 1 ) # Variance over unmasked elements with bias correction 1 diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/pytorch_networks/shared/feature_statistics.py b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/pytorch_networks/shared/feature_statistics.py new file mode 100644 index 000000000..26642ded3 --- /dev/null +++ b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/pytorch_networks/shared/feature_statistics.py @@ -0,0 +1,65 @@ +import multiprocessing +import torch +import numpy as np +from returnn.datasets.hdf import SimpleHDFWriter +from . import commons + +def forward_init_hook_statistics(run_ctx, **kwargs): + run_ctx.total_mean = 0 + run_ctx.total_var = 0 + run_ctx.total_max = torch.tensor(-np.inf) + run_ctx.total_min = torch.tensor(np.inf) + run_ctx.num_of_obs = 0 + +def forward_finish_hook_statistics(run_ctx, **kwargs): + with open("output.hdf", "w+") as f: + f.write("total, mean, var, max, min \n") + f.write( + f"{run_ctx.num_of_obs}, {str(float(run_ctx.total_mean))}, {str(float(run_ctx.total_var))}, {str(float(run_ctx.total_max))}, {str(float(run_ctx.total_min))}" + ) + +def forward_step_statistics(*, model, data, run_ctx, **kwargs): + raw_audio = data["audio_features"] # [B, N] (sparse) + raw_audio_len = data["audio_features:size1"] # [B] + + + squeezed_audio = torch.squeeze(raw_audio) + y, y_lengths = model.feature_extraction(squeezed_audio, raw_audio_len) # [B, T, F] + y = y.transpose(1,2) + y_max_length = y.size(2) + + y, y_lengths, y_max_length = model.preprocess(y, y_lengths, y_max_length) + z_mask = torch.unsqueeze(commons.sequence_mask(y_lengths, y_max_length), 1).to(torch.int32) + + # y = torch.nn.functional.l1_loss(y_hat * z_mask, y * z_mask, reduction="none") # [B, F, T] + current_num_of_obs = y.shape[1] * y_lengths.sum() # F * total_number_of_frames_in_batch + + old_mean = run_ctx.total_mean + + masked_y = y * z_mask + current_mean = ( + masked_y.sum() / current_num_of_obs + ) # This considers the masking by only using the mean over all unmasked elements + + current_var = (masked_y - current_mean).pow(2).sum() / ( + current_num_of_obs - 1 + ) # Variance over unmasked elements with bias correction 1 + + run_ctx.total_mean = ((run_ctx.num_of_obs / (run_ctx.num_of_obs + current_num_of_obs)) * old_mean) + ( + (current_num_of_obs / (run_ctx.num_of_obs + current_num_of_obs)) * current_mean + ) + + run_ctx.total_var = ( + (run_ctx.num_of_obs / (run_ctx.num_of_obs + current_num_of_obs)) * run_ctx.total_var + + ((current_num_of_obs / (run_ctx.num_of_obs + current_num_of_obs)) * current_var) + + ((run_ctx.num_of_obs * current_num_of_obs) / (run_ctx.num_of_obs + current_num_of_obs) ** 2) + * (old_mean - current_mean) ** 2 + ) + + run_ctx.total_max = torch.max(run_ctx.total_max, masked_y.max()) + + run_ctx.total_min = torch.min( + run_ctx.total_min, (masked_y + (-1 * z_mask + 1) * torch.tensor(float("inf")).nan_to_num(0.0)).min() + ) # Masked Min operation + + run_ctx.num_of_obs += current_num_of_obs diff --git a/users/rilling/joint_training/text_hdf/text_hdf_from_bliss.py b/users/rilling/joint_training/text_hdf/text_hdf_from_bliss.py index 821678647..9aff54205 100644 --- a/users/rilling/joint_training/text_hdf/text_hdf_from_bliss.py +++ b/users/rilling/joint_training/text_hdf/text_hdf_from_bliss.py @@ -12,7 +12,7 @@ class TextHDFFromBliss(Job): """ Extract text from a bliss corpus and save to HDF format - Used for joint training, where additional ASR corpus is necessary. + E.g. used for joint training, where additional ASR corpus is necessary. """ def __init__( @@ -43,7 +43,7 @@ def run(self): vocab_num_labels=vocabs[-1].num_labels else: assert vocabs[-1].num_labels == vocab_num_labels - + hdf_writer = SimpleHDFWriter(self.out_text_hdf.get_path(), dim=vocab_num_labels, ndim=1) for b, v in zip(self.bliss_corpora, vocabs): diff --git a/users/rilling/speakers/pooling.py b/users/rilling/speakers/pooling.py index 1213f7c61..c112be5c8 100644 --- a/users/rilling/speakers/pooling.py +++ b/users/rilling/speakers/pooling.py @@ -6,8 +6,15 @@ class AverageXVectorSpeakerEmbeddingsJob(Job): + """ + Job to compute the average x-vector for each speaker in a corpus + Takes an HDF containing an x-vector for each sequence in a corpus in combination with the speaker id, + collects all x-vectors for every speaker id and pools them using the mean vector. + + :param tk.Path x_vector_hdf: Path to HDF from x-vector forward job + :param tk.Path returnn_root: Path to Returnn Root + """ def __init__(self, x_vector_hdf: tk.Path, returnn_root: tk.Path): - # def __init__(self, x_vector_hdf: str, returnn_root: str): self.x_vector_hdf = x_vector_hdf self.returnn_root = returnn_root @@ -17,10 +24,7 @@ def task(self): yield Task("run", mini_task=True, rqmt={"sbatch_args": ["-p", "cpu_slow"]}) def run(self): - print(f"self.x_vector_hdf: {self.x_vector_hdf}") x_vectors, seq_tags, speaker_labels = self.load_xvector_data(self.x_vector_hdf.get_path()) - # x_vectors, seq_tags, speaker_labels = self.load_xvector_data(self.x_vector_hdf) - print(f"x_vectors.shape: {x_vectors.shape}") speaker_labels, indices = torch.sort(torch.Tensor(speaker_labels)) x_vectors = x_vectors[indices, :] @@ -61,23 +65,11 @@ def load_xvector_data(self, hdf_filename): seq_tags = input_data["seqTags"] lengths = input_data["seqLengths"] + # break if targets are not given hence no speaker_labels are in the HDF assert "targets" in input_data.keys() assert "speaker_labels" in input_data["targets"]["data"] speaker_labels = input_data["targets"]["data"]["speaker_labels"] - # data_seqs = [] - # data_tags = [] - # data_speaker_label = [] - # offset = 0 - - # for tag, length, speaker_label in zip(seq_tags, lengths, speaker_labels): - # tag = tag if isinstance(tag, str) else tag.decode() - # in_data = inputs[offset : offset + length[0]] - # data_seqs.append(in_data) - # offset += length[0] - # data_tags.append(tag) - # data_speaker_label.append(speaker_label) - x_vectors = np.array(inputs) x_vectors = x_vectors.reshape((lengths.shape[0], 512)) From 8ac7da62a88a79cce00c024fb5f47f8efa115203 Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Thu, 16 May 2024 10:36:47 +0000 Subject: [PATCH 027/227] fix --- users/zeineldeen/models/asr/encoder/conformer_encoder_v2.py | 2 -- users/zeineldeen/models/asr/encoder/ebranchformer_encoder.py | 2 -- 2 files changed, 4 deletions(-) diff --git a/users/zeineldeen/models/asr/encoder/conformer_encoder_v2.py b/users/zeineldeen/models/asr/encoder/conformer_encoder_v2.py index 89d0d2557..9831b8e61 100644 --- a/users/zeineldeen/models/asr/encoder/conformer_encoder_v2.py +++ b/users/zeineldeen/models/asr/encoder/conformer_encoder_v2.py @@ -151,8 +151,6 @@ def __init__( self.enc_val_per_head_dim = enc_key_dim // att_num_heads self.ff_dim = ff_dim - if self.ff_dim is None: - self.ff_dim = 2 * self.enc_key_dim self.target = target diff --git a/users/zeineldeen/models/asr/encoder/ebranchformer_encoder.py b/users/zeineldeen/models/asr/encoder/ebranchformer_encoder.py index 3f06572c9..01c65076c 100644 --- a/users/zeineldeen/models/asr/encoder/ebranchformer_encoder.py +++ b/users/zeineldeen/models/asr/encoder/ebranchformer_encoder.py @@ -106,8 +106,6 @@ def __init__( self.enc_val_per_head_dim = enc_key_dim // att_num_heads self.ff_dim = ff_dim - if self.ff_dim is None: - self.ff_dim = 2 * self.enc_key_dim self.target = target From 6e1a700213ef7a0c1a1b3fffeae56c3b310ca429 Mon Sep 17 00:00:00 2001 From: Lukas Rilling Date: Thu, 16 May 2024 17:11:20 +0200 Subject: [PATCH 028/227] Glow-TTS-ASR: Cleanup and comments/documentation --- .../configs/__init__.py | 0 .../configs/legacy_baseline.py | 320 ------------ .../configs/pytorch_baseline.py | 204 -------- .../configs/rc_baseline.py | 220 -------- .../librispeech_100_hybrid/data.py | 304 ----------- .../librispeech_100_hybrid/default_tools.py | 26 - .../librispeech_100_hybrid/experiments.py | 86 ---- .../librispeech_100_hybrid/gmm_baseline.py | 77 --- .../librispeech_100_hybrid/lm/__init__.py | 9 - .../librispeech_100_hybrid/lm/config.py | 92 ---- .../librispeech_100_hybrid/lm/data.py | 154 ------ .../lm/default_tools.py | 13 - .../librispeech_100_hybrid/lm/experiment.py | 36 -- .../pytorch_networks/__init__.py | 0 .../pytorch_networks/blstm8x1024.py | 94 ---- .../blstm8x1024_custom_engine.py | 121 ----- .../blstm8x1024_more_specaug.py | 115 ----- .../blstm8x1024_more_specaug_backup.py | 75 --- .../blstm8x1024_more_specaug_fp16.py | 176 ------- .../espnet_conformer_large.py | 121 ----- .../pytorch_networks/espnet_conformer_test.py | 124 ----- .../pytorch_networks/mlp_test.py | 31 -- .../pytorch_networks/torchaudio_conformer.py | 423 ---------------- .../torchaudio_conformer_debug.py | 425 ---------------- .../torchaudio_conformer_large_fp16.py | 476 ------------------ .../torchaudio_conformer_subsample.py | 426 ---------------- ...torchaudio_conformer_subsample_upsample.py | 440 ---------------- .../rc_networks/__init__.py | 0 .../rc_networks/debug.py | 142 ------ .../rc_networks/debug_random_mask.py | 54 -- .../rc_networks/default_hybrid.py | 162 ------ .../rc_networks/default_hybrid_v2.py | 167 ------ .../specaugment_clean_legacy.py | 141 ------ .../experiments.py | 76 ++- .../librispeech_glow_asr/experiments.py | 19 + .../{glowTTS => }/feature_config.py | 0 .../glowTTS/experiments.py | 39 +- .../glowTTS/gt_extraction.py | 2 +- .../glowTTS/vocoder/__init__.py | 0 .../pytorch_networks/feature_extraction.py | 3 +- .../pytorch_networks/glowTTS.py | 2 +- .../pytorch_networks/glowTTS_ddi_actnorm.py | 2 +- .../glowTTS_decoder_test_blstm.py | 2 +- .../glowTTS_decoder_test_multi_layer_ffn.py | 2 +- .../glowTTS_decoder_test_simple_linear.py | 2 +- .../glowTTS_encoder_sample_test_blstm.py | 2 +- ...der_sample_test_maxlike_alignment_blstm.py | 2 +- ..._test_maxlike_alignment_multi_layer_ffn.py | 2 +- ...le_test_maxlike_alignment_simple_linear.py | 2 +- ...TTS_encoder_sample_test_multi_layer_ffn.py | 2 +- ...owTTS_encoder_sample_test_simple_linear.py | 2 +- .../glowTTS_nar_taco_encoder.py | 2 +- .../glowTTS_nar_taco_encoder_no_blstm.py | 2 +- .../glowTTS_one_hot_encoder_mean.py | 2 +- .../glowTTS_one_hot_encoder_std.py | 2 +- .../glowTTS_simple_encoder.py | 2 +- ..._test_maxlike_alignment_multi_layer_ffn.py | 2 +- ...st_maxlike_alignment_multi_layer_ffn_v2.py | 2 +- .../pytorch_networks/glowTTS_x_vector.py | 2 +- .../pytorch_networks/glowTTS_x_vector_eval.py | 2 +- .../pytorch_networks/glowTTS_x_vector_v2.py | 2 +- .../pytorch_networks/glowTTS_x_vector_v3.py | 2 +- .../glowTTS_x_vector_v3_norm_xvector.py | 2 +- .../pytorch_networks/gt_extractor.py | 2 +- .../vocoder}/__init__.py | 0 .../vocoder}/config.py | 93 ++-- .../librispeech_glowtts/vocoder/data.py | 370 ++++++++++++++ .../librispeech_glowtts/vocoder/pipeline.py | 81 +++ .../{glowTTS => }/vocoder/simple_gl.py | 10 +- .../librispeech_joint_training/experiments.py | 36 +- .../README.md | 15 + .../exp_joint/experiments.py | 111 ++-- .../exp_joint_2step/experiments.py | 77 ++- .../exp_joint_flow_ga/experiments.py | 169 ++----- .../experiments.py | 133 ++--- .../x_vectors/experiments.py | 9 +- .../__init__.py | 0 .../ctc_aligner/__init__.py | 0 .../ctc_aligner/data.py | 115 ----- .../ctc_aligner/experiments.py | 309 ------------ .../ctc_aligner/pipeline.py | 35 -- .../tts_architecture_improvement_23/data.py | 320 ------------ .../default_tools.py | 17 - .../pytorch_networks/__init__.py | 0 .../pytorch_networks/ctc_aligner_rf.py | 120 ----- .../pytorch_networks/ctc_aligner_v1.py | 296 ----------- .../ctc_aligner_v1_ctc_sum.py | 109 ---- .../ctc_aligner_v1_ctc_sum_nobroad.py | 103 ---- .../ctc_aligner_v1_gradaccum.py | 149 ------ .../pytorch_networks/ctc_aligner_v2.py | 265 ---------- .../rc_networks/__init__.py | 0 .../rc_networks/ctc_aligner/__init__.py | 0 .../rc_networks/ctc_aligner/conv_blstm_rec.py | 211 -------- .../rc_networks/ctc_aligner/parameters.py | 16 - .../rc_networks/shared/__init__.py | 0 .../rc_networks/shared/convolution.py | 128 ----- .../serializer.py | 117 ----- .../storage.py | 13 - 98 files changed, 839 insertions(+), 8029 deletions(-) delete mode 100644 users/rilling/experiments/librispeech/librispeech_100_hybrid/configs/__init__.py delete mode 100644 users/rilling/experiments/librispeech/librispeech_100_hybrid/configs/legacy_baseline.py delete mode 100644 users/rilling/experiments/librispeech/librispeech_100_hybrid/configs/pytorch_baseline.py delete mode 100644 users/rilling/experiments/librispeech/librispeech_100_hybrid/configs/rc_baseline.py delete mode 100644 users/rilling/experiments/librispeech/librispeech_100_hybrid/data.py delete mode 100644 users/rilling/experiments/librispeech/librispeech_100_hybrid/default_tools.py delete mode 100644 users/rilling/experiments/librispeech/librispeech_100_hybrid/experiments.py delete mode 100644 users/rilling/experiments/librispeech/librispeech_100_hybrid/gmm_baseline.py delete mode 100644 users/rilling/experiments/librispeech/librispeech_100_hybrid/lm/__init__.py delete mode 100644 users/rilling/experiments/librispeech/librispeech_100_hybrid/lm/config.py delete mode 100644 users/rilling/experiments/librispeech/librispeech_100_hybrid/lm/data.py delete mode 100644 users/rilling/experiments/librispeech/librispeech_100_hybrid/lm/default_tools.py delete mode 100644 users/rilling/experiments/librispeech/librispeech_100_hybrid/lm/experiment.py delete mode 100644 users/rilling/experiments/librispeech/librispeech_100_hybrid/pytorch_networks/__init__.py delete mode 100644 users/rilling/experiments/librispeech/librispeech_100_hybrid/pytorch_networks/blstm8x1024.py delete mode 100644 users/rilling/experiments/librispeech/librispeech_100_hybrid/pytorch_networks/blstm8x1024_custom_engine.py delete mode 100644 users/rilling/experiments/librispeech/librispeech_100_hybrid/pytorch_networks/blstm8x1024_more_specaug.py delete mode 100644 users/rilling/experiments/librispeech/librispeech_100_hybrid/pytorch_networks/blstm8x1024_more_specaug_backup.py delete mode 100644 users/rilling/experiments/librispeech/librispeech_100_hybrid/pytorch_networks/blstm8x1024_more_specaug_fp16.py delete mode 100644 users/rilling/experiments/librispeech/librispeech_100_hybrid/pytorch_networks/espnet_conformer_large.py delete mode 100644 users/rilling/experiments/librispeech/librispeech_100_hybrid/pytorch_networks/espnet_conformer_test.py delete mode 100644 users/rilling/experiments/librispeech/librispeech_100_hybrid/pytorch_networks/mlp_test.py delete mode 100644 users/rilling/experiments/librispeech/librispeech_100_hybrid/pytorch_networks/torchaudio_conformer.py delete mode 100644 users/rilling/experiments/librispeech/librispeech_100_hybrid/pytorch_networks/torchaudio_conformer_debug.py delete mode 100644 users/rilling/experiments/librispeech/librispeech_100_hybrid/pytorch_networks/torchaudio_conformer_large_fp16.py delete mode 100644 users/rilling/experiments/librispeech/librispeech_100_hybrid/pytorch_networks/torchaudio_conformer_subsample.py delete mode 100644 users/rilling/experiments/librispeech/librispeech_100_hybrid/pytorch_networks/torchaudio_conformer_subsample_upsample.py delete mode 100644 users/rilling/experiments/librispeech/librispeech_100_hybrid/rc_networks/__init__.py delete mode 100644 users/rilling/experiments/librispeech/librispeech_100_hybrid/rc_networks/debug.py delete mode 100644 users/rilling/experiments/librispeech/librispeech_100_hybrid/rc_networks/debug_random_mask.py delete mode 100644 users/rilling/experiments/librispeech/librispeech_100_hybrid/rc_networks/default_hybrid.py delete mode 100644 users/rilling/experiments/librispeech/librispeech_100_hybrid/rc_networks/default_hybrid_v2.py delete mode 100644 users/rilling/experiments/librispeech/librispeech_100_hybrid/specaugment_clean_legacy.py rename users/rilling/experiments/librispeech/librispeech_glowtts/{glowTTS => }/feature_config.py (100%) delete mode 100644 users/rilling/experiments/librispeech/librispeech_glowtts/glowTTS/vocoder/__init__.py rename users/rilling/experiments/librispeech/{librispeech_100_hybrid => librispeech_glowtts/vocoder}/__init__.py (100%) rename users/rilling/experiments/librispeech/{tts_architecture_improvement_23/ctc_aligner => librispeech_glowtts/vocoder}/config.py (64%) create mode 100644 users/rilling/experiments/librispeech/librispeech_glowtts/vocoder/data.py create mode 100644 users/rilling/experiments/librispeech/librispeech_glowtts/vocoder/pipeline.py rename users/rilling/experiments/librispeech/librispeech_glowtts/{glowTTS => }/vocoder/simple_gl.py (93%) create mode 100644 users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/README.md delete mode 100644 users/rilling/experiments/librispeech/tts_architecture_improvement_23/__init__.py delete mode 100644 users/rilling/experiments/librispeech/tts_architecture_improvement_23/ctc_aligner/__init__.py delete mode 100644 users/rilling/experiments/librispeech/tts_architecture_improvement_23/ctc_aligner/data.py delete mode 100644 users/rilling/experiments/librispeech/tts_architecture_improvement_23/ctc_aligner/experiments.py delete mode 100644 users/rilling/experiments/librispeech/tts_architecture_improvement_23/ctc_aligner/pipeline.py delete mode 100644 users/rilling/experiments/librispeech/tts_architecture_improvement_23/data.py delete mode 100644 users/rilling/experiments/librispeech/tts_architecture_improvement_23/default_tools.py delete mode 100644 users/rilling/experiments/librispeech/tts_architecture_improvement_23/pytorch_networks/__init__.py delete mode 100644 users/rilling/experiments/librispeech/tts_architecture_improvement_23/pytorch_networks/ctc_aligner_rf.py delete mode 100644 users/rilling/experiments/librispeech/tts_architecture_improvement_23/pytorch_networks/ctc_aligner_v1.py delete mode 100644 users/rilling/experiments/librispeech/tts_architecture_improvement_23/pytorch_networks/ctc_aligner_v1_ctc_sum.py delete mode 100644 users/rilling/experiments/librispeech/tts_architecture_improvement_23/pytorch_networks/ctc_aligner_v1_ctc_sum_nobroad.py delete mode 100644 users/rilling/experiments/librispeech/tts_architecture_improvement_23/pytorch_networks/ctc_aligner_v1_gradaccum.py delete mode 100644 users/rilling/experiments/librispeech/tts_architecture_improvement_23/pytorch_networks/ctc_aligner_v2.py delete mode 100644 users/rilling/experiments/librispeech/tts_architecture_improvement_23/rc_networks/__init__.py delete mode 100644 users/rilling/experiments/librispeech/tts_architecture_improvement_23/rc_networks/ctc_aligner/__init__.py delete mode 100644 users/rilling/experiments/librispeech/tts_architecture_improvement_23/rc_networks/ctc_aligner/conv_blstm_rec.py delete mode 100644 users/rilling/experiments/librispeech/tts_architecture_improvement_23/rc_networks/ctc_aligner/parameters.py delete mode 100644 users/rilling/experiments/librispeech/tts_architecture_improvement_23/rc_networks/shared/__init__.py delete mode 100644 users/rilling/experiments/librispeech/tts_architecture_improvement_23/rc_networks/shared/convolution.py delete mode 100644 users/rilling/experiments/librispeech/tts_architecture_improvement_23/serializer.py delete mode 100644 users/rilling/experiments/librispeech/tts_architecture_improvement_23/storage.py diff --git a/users/rilling/experiments/librispeech/librispeech_100_hybrid/configs/__init__.py b/users/rilling/experiments/librispeech/librispeech_100_hybrid/configs/__init__.py deleted file mode 100644 index e69de29bb..000000000 diff --git a/users/rilling/experiments/librispeech/librispeech_100_hybrid/configs/legacy_baseline.py b/users/rilling/experiments/librispeech/librispeech_100_hybrid/configs/legacy_baseline.py deleted file mode 100644 index f7ff3c35d..000000000 --- a/users/rilling/experiments/librispeech/librispeech_100_hybrid/configs/legacy_baseline.py +++ /dev/null @@ -1,320 +0,0 @@ -import copy -import numpy as np -from typing import List - -from i6_core.returnn.config import ReturnnConfig -from i6_experiments.common.setups.rasr.util import HybridArgs - - -def blstm_network(layers, input_layers, dropout=0.1, l2=0.0): - num_layers = len(layers) - assert num_layers > 0 - - network = {} - - for idx, size in enumerate(layers): - idx += 1 - for direction, name in [(1, "fwd"), (-1, "bwd")]: - if idx == 1: - from_layers = input_layers - else: - from_layers = [ - "lstm_fwd_{}".format(idx - 1), - "lstm_bwd_{}".format(idx - 1), - ] - network["lstm_{}_{}".format(name, idx)] = { - "class": "rec", - "unit": "nativelstm2", - "direction": direction, - "n_out": size, - "dropout": dropout, - "L2": l2, - "from": from_layers, - } - - output_layers = ["lstm_fwd_{}".format(num_layers), "lstm_bwd_{}".format(num_layers)] - - return network, output_layers - - -def get_nn_args(num_outputs: int = 12001, num_epochs: int = 250, extra_exps=False): - evaluation_epochs = list(np.arange(num_epochs, num_epochs + 1, 10)) - - returnn_configs = get_returnn_configs( - num_inputs=50, num_outputs=num_outputs, batch_size=5000, - evaluation_epochs=evaluation_epochs, extra_exps=extra_exps, - ) - - returnn_recog_configs = get_returnn_configs( - num_inputs=50, num_outputs=num_outputs, batch_size=5000, - evaluation_epochs=evaluation_epochs, - recognition=True, extra_exps=extra_exps, - ) - - - training_args = { - "log_verbosity": 5, - "num_epochs": num_epochs, - "num_classes": num_outputs, - "save_interval": 1, - "keep_epochs": None, - "time_rqmt": 168, - "mem_rqmt": 7, - "cpu_rqmt": 3, - "partition_epochs": {"train": 40, "dev": 20}, - "use_python_control": False, - } - recognition_args = { - "dev-other": { - "epochs": evaluation_epochs, - "feature_flow_key": "gt", - "prior_scales": [0.3], - "pronunciation_scales": [6.0], - "lm_scales": [20.0], - "lm_lookahead": True, - "lookahead_options": None, - "create_lattice": True, - "eval_single_best": True, - "eval_best_in_lattice": True, - "search_parameters": { - "beam-pruning": 12.0, - "beam-pruning-limit": 100000, - "word-end-pruning": 0.5, - "word-end-pruning-limit": 15000, - }, - "lattice_to_ctm_kwargs": { - "fill_empty_segments": True, - "best_path_algo": "bellman-ford", - }, - "optimize_am_lm_scale": True, - "rtf": 50, - "mem": 8, - "lmgc_mem": 16, - "cpu": 4, - "parallelize_conversion": True, - "forward_output_layer": "log_output", - "native_ops": ["NativeLstm2"], - }, - } - test_recognition_args = None - - nn_args = HybridArgs( - returnn_training_configs=returnn_configs, - returnn_recognition_configs=returnn_recog_configs, - training_args=training_args, - recognition_args=recognition_args, - test_recognition_args=test_recognition_args, - ) - - return nn_args - -def get_realign_args(num_outputs: int = 12001, num_epochs: int = 250, extra_exps=False): - evaluation_epochs = list(np.arange(num_epochs, num_epochs + 1, 10)) - - returnn_configs = get_returnn_configs( - num_inputs=50, num_outputs=num_outputs, batch_size=5000, - evaluation_epochs=evaluation_epochs, extra_exps=extra_exps, - ) - - returnn_recog_configs = get_returnn_configs( - num_inputs=50, num_outputs=num_outputs, batch_size=5000, - evaluation_epochs=evaluation_epochs, - recognition=True, extra_exps=extra_exps, - ) - - - training_args = { - "log_verbosity": 5, - "num_epochs": num_epochs, - "num_classes": num_outputs, - "save_interval": 1, - "keep_epochs": None, - "time_rqmt": 168, - "mem_rqmt": 7, - "cpu_rqmt": 3, - "partition_epochs": {"train": 40, "dev": 20}, - "use_python_control": False, - } - recognition_args = { - "dev-other": { - "epochs": evaluation_epochs, - "feature_flow_key": "gt", - "prior_scales": [0.3], - "pronunciation_scales": [6.0], - "lm_scales": [20.0], - "lm_lookahead": True, - "lookahead_options": None, - "create_lattice": True, - "eval_single_best": True, - "eval_best_in_lattice": True, - "search_parameters": { - "beam-pruning": 12.0, - "beam-pruning-limit": 100000, - "word-end-pruning": 0.5, - "word-end-pruning-limit": 15000, - }, - "lattice_to_ctm_kwargs": { - "fill_empty_segments": True, - "best_path_algo": "bellman-ford", - }, - "optimize_am_lm_scale": True, - "rtf": 50, - "mem": 8, - "lmgc_mem": 16, - "cpu": 4, - "parallelize_conversion": True, - "forward_output_layer": "log_output", - "native_ops": ["NativeLstm2"], - }, - } - test_recognition_args = None - - nn_args = HybridArgs( - returnn_training_configs=returnn_configs, - returnn_recognition_configs=returnn_recog_configs, - training_args=training_args, - recognition_args=recognition_args, - test_recognition_args=test_recognition_args, - ) - - return nn_args - - -def get_feature_extraction_args(fix_features_output=False): - dc_detection = False - samples_options = { - 'audio_format': "wav", - 'dc_detection': dc_detection, - } - - return { - "gt": { - "gt_options": { - "minfreq": 100, - "maxfreq": 7500, - "channels": 50, - # "warp_freqbreak": 7400, - "tempint_type": "hanning", - "tempint_shift": 0.01, - "tempint_length": 0.025, - "flush_before_gap": True, - "do_specint": False, - "specint_type": "hanning", - "specint_shift": 4, - "specint_length": 9, - "normalize": True, - "preemphasis": True, - "legacy_scaling": False, - "without_samples": False, - "samples_options": samples_options, - "normalization_options": {}, - "add_features_output": fix_features_output, - } - }, - } - -def get_returnn_configs( - num_inputs: int, num_outputs: int, batch_size: int, evaluation_epochs: List[int], - recognition=False, extra_exps=False -): - # ******************** blstm base ******************** - - base_config = { - "extern_data": { - "data": {"dim": num_inputs}, - "classes": {"dim": num_outputs, "sparse": True}, - }, - } - base_post_config = { - "use_tensorflow": True, - "debug_print_layer_output_template": True, - "log_batch_size": True, - "tf_log_memory_usage": True, - "cache_size": "0", - - } - if not recognition: - base_post_config["cleanup_old_models"] = { - "keep_last_n": 5, - "keep_best_n": 5, - "keep": evaluation_epochs, - } - - network, last_layer = blstm_network([1024]*8, ["specaug"], dropout=0.0, l2=0.0) - from ..specaugment_clean_legacy import specaug_layer, get_funcs - - network["specaug"] = specaug_layer(["data"]) - network["out_linear"] = { - "class": "linear", - "activation": None, - "from": last_layer, - "n_out": num_outputs, - } - network["output"] = { - "class": "activation", - "activation": "softmax", - "from": ["out_linear"], - "loss": "ce", - 'loss_opts': {'focal_loss_factor': 2.0}, - "target": "classes" - } - network["log_output"] = { - "class": "activation", - "activation": "log_softmax", - "from": ["out_linear"], - } - - if recognition: - network["log_output"]["is_output_layer"] = True - - - blstm_base_config = copy.deepcopy(base_config) - blstm_base_config.update( - { - "batch_size": batch_size, # {"classes": batch_size, "data": batch_size}, - "chunking": "50:25", - "optimizer": {"class": "nadam", "epsilon": 1e-8}, - "gradient_noise": 0.3, - "learning_rates": list(np.linspace(2.5e-5, 2.5e-4, 10)), - "learning_rate_control": "newbob_multi_epoch", - "learning_rate_control_min_num_epochs_per_new_lr": 3, - "learning_rate_control_relative_error_relative_lr": True, - #"min_learning_rate": 1e-5, - "newbob_learning_rate_decay": 0.707, - "newbob_multi_num_epochs": 40, - "newbob_multi_update_interval": 1, - "network": network, - } - ) - - def make_returnn_config(config): - return ReturnnConfig( - config=config, - post_config=base_post_config, - hash_full_python_code=True, - python_prolog=get_funcs(), - pprint_kwargs={"sort_dicts": False}, - ) - blstm_base_returnn_config = make_returnn_config(blstm_base_config) - - if extra_exps: - oclr_v1_config = copy.deepcopy(blstm_base_config) - oclr_v1_config["learning_rates"] = list(np.linspace(2.5e-5, 3e-4, 50)) + list(np.linspace(3e-4, 2.5e-5, 50)) - oclr_v1_config["newbob_multi_num_epochs"] = 3 - oclr_v1_nofl_config = copy.deepcopy(oclr_v1_config) - oclr_v1_nofl_config["network"]["output"]["loss_opts"] = None - oclr_v2_config = copy.deepcopy(blstm_base_config) - oclr_v2_config["learning_rates"] = list(np.linspace(2.5e-5, 4e-4, 50)) + list(np.linspace(4e-4, 2.5e-5, 50)) - oclr_v2_config["newbob_multi_num_epochs"] = 3 - - return { - "blstm_oclr_v1": make_returnn_config(oclr_v1_config), - "blstm_oclr_v1_nofl": make_returnn_config(oclr_v1_nofl_config), - "blstm_oclr_v2": make_returnn_config(oclr_v2_config), - "blstm_base": blstm_base_returnn_config, - } - else: - return { - "blstm_base": blstm_base_returnn_config, - } - diff --git a/users/rilling/experiments/librispeech/librispeech_100_hybrid/configs/pytorch_baseline.py b/users/rilling/experiments/librispeech/librispeech_100_hybrid/configs/pytorch_baseline.py deleted file mode 100644 index 888adbc40..000000000 --- a/users/rilling/experiments/librispeech/librispeech_100_hybrid/configs/pytorch_baseline.py +++ /dev/null @@ -1,204 +0,0 @@ -import copy -from dataclasses import dataclass -import numpy as np -from typing import List, Dict, Any - -from i6_core.returnn.config import ReturnnConfig -from i6_experiments.common.setups.rasr.util import HybridArgs - -from i6_experiments.common.setups.serialization import Import, ExplicitHash, ExternalImport -from i6_experiments.common.setups.returnn_pytorch.serialization import PyTorchModel, Collection - - -from ..default_tools import PACKAGE - - -def get_nn_args(num_outputs: int = 12001, num_epochs: int = 250, use_rasr_returnn_training=True, debug=False, **net_kwargs): - evaluation_epochs = list(range(num_epochs, num_epochs + 1, 10)) - - returnn_configs = get_pytorch_returnn_configs( - num_inputs=50, num_outputs=num_outputs, batch_size=5000, - evaluation_epochs=evaluation_epochs, debug=debug, - ) - - returnn_recog_configs = get_pytorch_returnn_configs( - num_inputs=50, num_outputs=num_outputs, batch_size=5000, - evaluation_epochs=evaluation_epochs, - recognition=True, debug=debug, - ) - - - training_args = { - "log_verbosity": 5, - "num_epochs": num_epochs, - "save_interval": 1, - "keep_epochs": None, - "time_rqmt": 168, - "mem_rqmt": 8, - "cpu_rqmt": 3, - } - - if use_rasr_returnn_training: - training_args["num_classes"] = num_outputs - training_args["use_python_control"] = False - training_args["partition_epochs"] = {"train": 40, "dev": 20} - - recognition_args = { - "dev-other": { - "epochs": evaluation_epochs, - "feature_flow_key": "gt", - "prior_scales": [0.3], - "pronunciation_scales": [6.0], - "lm_scales": [20.0], - "lm_lookahead": True, - "lookahead_options": None, - "create_lattice": True, - "eval_single_best": True, - "eval_best_in_lattice": True, - "search_parameters": { - "beam-pruning": 12.0, - "beam-pruning-limit": 100000, - "word-end-pruning": 0.5, - "word-end-pruning-limit": 15000, - }, - "lattice_to_ctm_kwargs": { - "fill_empty_segments": True, - "best_path_algo": "bellman-ford", - }, - "optimize_am_lm_scale": True, - "rtf": 50, - "mem": 7, - "lmgc_mem": 16, - "needs_features_size": False, - "cpu": 2, - "parallelize_conversion": True, - } - } - test_recognition_args = None - - nn_args = HybridArgs( - returnn_training_configs=returnn_configs, - returnn_recognition_configs=returnn_recog_configs, - training_args=training_args, - recognition_args=recognition_args, - test_recognition_args=test_recognition_args, - ) - - return nn_args - - -def get_pytorch_returnn_configs( - num_inputs: int, num_outputs: int, batch_size: int, evaluation_epochs: List[int], - recognition=False, debug=False, -): - # ******************** blstm base ******************** - - base_config = { - "extern_data": { - "data": {"dim": num_inputs}, - "classes": {"dim": num_outputs, "sparse": True}, - }, - } - base_post_config = { - "backend": "torch", - "debug_print_layer_output_template": True, - "log_batch_size": True, - "tf_log_memory_usage": True, - "cache_size": "0", - - } - - blstm_base_config = copy.deepcopy(base_config) - blstm_base_config.update( - { - "behavior_version": 15, - "batch_size": batch_size, # {"classes": batch_size, "data": batch_size}, - "chunking": "50:25", - "optimizer": {"class": "nadam", "epsilon": 1e-8}, - "gradient_noise": 0.3, - "learning_rates": list(np.linspace(2.5e-5, 3e-4, 50)) + list(np.linspace(3e-4, 2.5e-5, 50)), - "learning_rate_control": "newbob_multi_epoch", - "learning_rate_control_min_num_epochs_per_new_lr": 3, - "learning_rate_control_relative_error_relative_lr": True, - #"min_learning_rate": 1e-5, - "newbob_learning_rate_decay": 0.707, - "newbob_multi_num_epochs": 40, - "newbob_multi_update_interval": 1, - } - ) - if not recognition: - base_post_config["cleanup_old_models"] = { - "keep_last_n": 5, - "keep_best_n": 5, - "keep": evaluation_epochs, - } - - high_lr_config = copy.deepcopy(blstm_base_config) - high_lr_config["learning_rates"] = list(np.linspace(2.5e-4, 3e-3, 50)) + list(np.linspace(3e-3, 2.5e-4, 50)) - - # those are hashed - pytorch_package = PACKAGE + ".pytorch_networks" - - def construct_from_net_kwargs(base_config, net_kwargs, explicit_hash=None, use_tracing=False, use_custom_engine=False, use_espnet=False): - model_type = net_kwargs.pop("model_type") - pytorch_model_import = Import( - PACKAGE + ".pytorch_networks.%s.Model" % model_type - ) - pytorch_train_step = Import( - PACKAGE + ".pytorch_networks.%s.train_step" % model_type - ) - pytorch_model = PyTorchModel( - model_class_name=pytorch_model_import.object_name, - model_kwargs=net_kwargs, - ) - serializer_objects = [ - pytorch_model_import, - pytorch_train_step, - pytorch_model, - ] - if use_espnet: - from i6_core.tools.git import CloneGitRepositoryJob - espnet_path = CloneGitRepositoryJob( - url="https://github.com/espnet/espnet", - checkout_folder_name="espnet" - ).out_repository - espnet_path.hash_overwrite = "DEFAULT_ESPNET" - serializer_objects.insert(0, ExternalImport(espnet_path)) - if use_custom_engine: - pytorch_engine = Import( - PACKAGE + ".pytorch_networks.%s.CustomEngine" % model_type - ) - serializer_objects.append(pytorch_engine) - if recognition: - if use_tracing: - pytorch_export = Import( - PACKAGE + ".pytorch_networks.%s.export_trace" % model_type, - import_as="export" - ) - else: - pytorch_export = Import( - PACKAGE + ".pytorch_networks.%s.export" % model_type - ) - serializer_objects.append(pytorch_export) - if explicit_hash: - serializer_objects.append(ExplicitHash(explicit_hash)) - serializer = Collection( - serializer_objects=serializer_objects, - make_local_package_copy=not debug, - packages={ - pytorch_package, - }, - ) - - blstm_base_returnn_config = ReturnnConfig( - config=base_config, - post_config=base_post_config, - python_epilog=[serializer], - pprint_kwargs={"sort_dicts": False}, - ) - - return blstm_base_returnn_config - - return { - "torchaudio_conformer": construct_from_net_kwargs(high_lr_config, {"model_type": "torchaudio_conformer"}, use_tracing=False),# here the config is wrong, it does use tracing - } diff --git a/users/rilling/experiments/librispeech/librispeech_100_hybrid/configs/rc_baseline.py b/users/rilling/experiments/librispeech/librispeech_100_hybrid/configs/rc_baseline.py deleted file mode 100644 index b0ccd6eed..000000000 --- a/users/rilling/experiments/librispeech/librispeech_100_hybrid/configs/rc_baseline.py +++ /dev/null @@ -1,220 +0,0 @@ -import copy -from dataclasses import dataclass -import numpy as np -from typing import List, Dict, Any - -from i6_core.returnn.config import ReturnnConfig -from i6_experiments.common.setups.rasr.util import HybridArgs - -from i6_experiments.common.setups.returnn_common.serialization import ( - DataInitArgs, - DimInitArgs, - Collection, - Network, - ExternData, - Import, - ExplicitHash -) - - -from ..default_tools import RETURNN_COMMON - - -def get_nn_args(num_outputs: int = 12001, num_epochs: int = 250, use_rasr_returnn_training=True, **net_kwargs): - evaluation_epochs = list(range(num_epochs, num_epochs + 1, 10)) - - returnn_configs = get_rc_returnn_configs( - num_inputs=50, num_outputs=num_outputs, batch_size=5000, - evaluation_epochs=evaluation_epochs, - ) - - returnn_recog_configs = get_rc_returnn_configs( - num_inputs=50, num_outputs=num_outputs, batch_size=5000, - evaluation_epochs=evaluation_epochs, - recognition=True, - ) - - - training_args = { - "log_verbosity": 5, - "num_epochs": num_epochs, - "save_interval": 1, - "keep_epochs": None, - "time_rqmt": 168, - "mem_rqmt": 8, - "cpu_rqmt": 3, - } - - if use_rasr_returnn_training: - training_args["num_classes"] = num_outputs - training_args["use_python_control"] = False - training_args["partition_epochs"] = {"train": 40, "dev": 20} - - recognition_args = { - "dev-other": { - "epochs": evaluation_epochs, - "feature_flow_key": "gt", - "prior_scales": [0.3], - "pronunciation_scales": [6.0], - "lm_scales": [20.0], - "lm_lookahead": True, - "lookahead_options": None, - "create_lattice": True, - "eval_single_best": True, - "eval_best_in_lattice": True, - "search_parameters": { - "beam-pruning": 12.0, - "beam-pruning-limit": 100000, - "word-end-pruning": 0.5, - "word-end-pruning-limit": 15000, - }, - "lattice_to_ctm_kwargs": { - "fill_empty_segments": True, - "best_path_algo": "bellman-ford", - }, - "optimize_am_lm_scale": True, - "rtf": 50, - "mem": 8, - "lmgc_mem": 16, - "cpu": 4, - "parallelize_conversion": True, - "use_epoch_for_compile": True, - "native_ops": ["NativeLstm2"], - }, - } - test_recognition_args = None - - nn_args = HybridArgs( - returnn_training_configs=returnn_configs, - returnn_recognition_configs=returnn_recog_configs, - training_args=training_args, - recognition_args=recognition_args, - test_recognition_args=test_recognition_args, - ) - - return nn_args - - -def get_default_data_init_args(num_inputs: int, num_outputs: int): - """ - default for this hybrid model - - :param num_inputs: - :param num_outputs: - :return: - """ - time_dim = DimInitArgs("data_time", dim=None) - data_feature = DimInitArgs("data_feature", dim=num_inputs, is_feature=True) - classes_feature = DimInitArgs("classes_feature", dim=num_outputs, is_feature=True) - - return [ - DataInitArgs(name="data", available_for_inference=True, dim_tags=[time_dim, data_feature], sparse_dim=None), - DataInitArgs(name="classes", available_for_inference=False, dim_tags=[time_dim], sparse_dim=classes_feature) - ] - - - -def get_rc_returnn_configs( - num_inputs: int, num_outputs: int, batch_size: int, evaluation_epochs: List[int], - recognition=False -): - # ******************** blstm base ******************** - - base_config = { - } - base_post_config = { - "use_tensorflow": True, - "debug_print_layer_output_template": True, - "log_batch_size": True, - "tf_log_memory_usage": True, - "cache_size": "0", - - } - - blstm_base_config = copy.deepcopy(base_config) - blstm_base_config.update( - { - "behavior_version": 15, - "batch_size": batch_size, # {"classes": batch_size, "data": batch_size}, - "chunking": "50:25", - "optimizer": {"class": "nadam", "epsilon": 1e-8}, - "gradient_noise": 0.3, - "learning_rates": list(np.linspace(2.5e-5, 3e-4, 50)) + list(np.linspace(3e-4, 2.5e-5, 50)), - "learning_rate_control": "newbob_multi_epoch", - "learning_rate_control_min_num_epochs_per_new_lr": 3, - "learning_rate_control_relative_error_relative_lr": True, - #"min_learning_rate": 1e-5, - "newbob_learning_rate_decay": 0.707, - "newbob_multi_num_epochs": 40, - "newbob_multi_update_interval": 1, - } - ) - if not recognition: - base_post_config["cleanup_old_models"] = { - "keep_last_n": 5, - "keep_best_n": 5, - "keep": evaluation_epochs, - } - - rc_extern_data = ExternData(extern_data=get_default_data_init_args(num_inputs=num_inputs, num_outputs=num_outputs)) - - # those are hashed - rc_package = "i6_experiments.users.rossenbach.experiments.librispeech.librispeech_100_hybrid.rc_networks" - rc_construction_code = Import(rc_package + ".default_hybrid_v2.construct_hybrid_network") - - - net_kwargs = { - "train": not recognition, - "num_layers": 8, - "size": 1024, - "dropout": 0.0, - "specaugment_options": { - "min_frame_masks": 1, - "mask_each_n_frames": 100, - "max_frames_per_mask": 20, - "min_feature_masks": 1, - "max_feature_masks": 2, - "max_features_per_mask": 10 - } - } - - net_kwargs_focal_loss = copy.deepcopy(net_kwargs) - net_kwargs_focal_loss["focal_loss_scale"] = 2.0 - - def construct_from_net_kwargs(base_config, net_kwargs, explicit_hash=None): - rc_network = Network( - net_func_name=rc_construction_code.object_name, - net_func_map={ - "audio_data": "data", # name of the constructor parameter vs name of the data object in RETURNN - "label_data": "classes" - }, # this is hashed - net_kwargs=net_kwargs, - ) - serializer_objects = [ - rc_extern_data, - rc_construction_code, - rc_network, - ] - if explicit_hash: - serializer_objects.append(ExplicitHash(explicit_hash)) - serializer = Collection( - serializer_objects=serializer_objects, - returnn_common_root=RETURNN_COMMON, - make_local_package_copy=True, - packages={ - rc_package, - }, - ) - - blstm_base_returnn_config = ReturnnConfig( - config=base_config, - post_config=base_post_config, - python_epilog=[serializer], - pprint_kwargs={"sort_dicts": False}, - ) - return blstm_base_returnn_config - - return { - "blstm_oclr_v1": construct_from_net_kwargs(blstm_base_config, net_kwargs), - "blstm_oclr_v1_focal_loss": construct_from_net_kwargs(blstm_base_config, net_kwargs_focal_loss), - } diff --git a/users/rilling/experiments/librispeech/librispeech_100_hybrid/data.py b/users/rilling/experiments/librispeech/librispeech_100_hybrid/data.py deleted file mode 100644 index 0f4a7d88b..000000000 --- a/users/rilling/experiments/librispeech/librispeech_100_hybrid/data.py +++ /dev/null @@ -1,304 +0,0 @@ -from i6_core import corpus as corpus_recipe -from i6_core import text - -from i6_experiments.common.setups.rasr.gmm_system import GmmSystem - -from .default_tools import RETURNN_EXE, RETURNN_RC_ROOT - - -def get_corpus_data_inputs(gmm_system): - """ - - :param GmmSystem gmm_system: - :return: - """ - - - train_corpus_path = gmm_system.corpora["train-clean-100"].corpus_file - total_train_num_segments = 28539 - cv_size = 1000 / total_train_num_segments - - all_segments = corpus_recipe.SegmentCorpusJob( - train_corpus_path, 1 - ).out_single_segment_files[1] - - splitted_segments_job = corpus_recipe.ShuffleAndSplitSegmentsJob( - all_segments, {"train": 1 - cv_size, "cv": cv_size} - ) - train_segments = splitted_segments_job.out_segments["train"] - cv_segments = splitted_segments_job.out_segments["cv"] - devtrain_segments = text.TailJob( - train_segments, num_lines=1000, zip_output=False - ).out - - # ******************** NN Init ******************** - - nn_train_data = gmm_system.outputs["train-clean-100"][ - "final" - ].as_returnn_rasr_data_input(shuffle_data=True) - nn_train_data.update_crp_with(segment_path=train_segments, concurrent=1) - nn_train_data_inputs = { - "train-clean-100.train": nn_train_data, - } - - nn_cv_data = gmm_system.outputs["train-clean-100"][ - "final" - ].as_returnn_rasr_data_input() - nn_cv_data.update_crp_with(segment_path=cv_segments, concurrent=1) - nn_cv_data_inputs = { - "train-clean-100.cv": nn_cv_data, - } - - nn_devtrain_data = gmm_system.outputs["train-clean-100"][ - "final" - ].as_returnn_rasr_data_input() - nn_devtrain_data.update_crp_with(segment_path=devtrain_segments, concurrent=1) - nn_devtrain_data_inputs = { - "train-clean-100.devtrain": nn_devtrain_data, - } - nn_dev_data_inputs = { - # "dev-clean": gmm_system.outputs["dev-clean"][ - # "final" - # ].as_returnn_rasr_data_input(), - "dev-other": gmm_system.outputs["dev-other"][ - "final" - ].as_returnn_rasr_data_input(), - } - nn_test_data_inputs = { - # "test-clean": gmm_system.outputs["test-clean"][ - # "final" - # ].as_returnn_rasr_data_input(), - # "test-other": gmm_system.outputs["test-other"][ - # "final" - # ].as_returnn_rasr_data_input(), - } - - - return nn_train_data_inputs, nn_cv_data_inputs, nn_devtrain_data_inputs, nn_dev_data_inputs, nn_test_data_inputs - - -def get_corpus_data_inputs_newcv(gmm_system): - """ - - :param GmmSystem gmm_system: - :return: - """ - train_corpus_path = gmm_system.corpora["train-clean-100"].corpus_file - total_train_num_segments = 28539 - cv_size = 300 / total_train_num_segments - - all_segments = corpus_recipe.SegmentCorpusJob( - train_corpus_path, 1 - ).out_single_segment_files[1] - - splitted_segments_job = corpus_recipe.ShuffleAndSplitSegmentsJob( - all_segments, {"train": 1 - cv_size, "cv": cv_size} - ) - train_segments = splitted_segments_job.out_segments["train"] - cv_segments = splitted_segments_job.out_segments["cv"] - devtrain_segments = text.TailJob( - train_segments, num_lines=1000, zip_output=False - ).out - - # ******************** NN Init ******************** - - nn_train_data = gmm_system.outputs["train-clean-100"][ - "final" - ].as_returnn_rasr_data_input(shuffle_data=True) - nn_train_data.update_crp_with(segment_path=train_segments, concurrent=1) - nn_train_data_inputs = { - "train-clean-100.train": nn_train_data, - } - - nn_cv_data = gmm_system.outputs["train-clean-100"][ - "final" - ].as_returnn_rasr_data_input() - nn_cv_data.update_crp_with(segment_path=cv_segments, concurrent=1) - nn_cv_data_inputs = { - "train-clean-100.cv": nn_cv_data, - } - - nn_devtrain_data = gmm_system.outputs["train-clean-100"][ - "final" - ].as_returnn_rasr_data_input() - nn_devtrain_data.update_crp_with(segment_path=devtrain_segments, concurrent=1) - nn_devtrain_data_inputs = { - "train-clean-100.devtrain": nn_devtrain_data, - } - nn_dev_data_inputs = { - # "dev-clean": gmm_system.outputs["dev-clean"][ - # "final" - # ].as_returnn_rasr_data_input(), - "dev-other": gmm_system.outputs["dev-other"][ - "final" - ].as_returnn_rasr_data_input(), - } - nn_test_data_inputs = { - # "test-clean": gmm_system.outputs["test-clean"][ - # "final" - # ].as_returnn_rasr_data_input(), - # "test-other": gmm_system.outputs["test-other"][ - # "final" - # ].as_returnn_rasr_data_input(), - } - - - return nn_train_data_inputs, nn_cv_data_inputs, nn_devtrain_data_inputs, nn_dev_data_inputs, nn_test_data_inputs - - -def get_corpus_data_inputs_newcv_hdf(gmm_system): - """ - - :param GmmSystem gmm_system: - :return: - """ - from i6_experiments.common.setups.rasr.util.nn import SingleHdfDataInput - train_corpus_path = gmm_system.corpora["train-clean-100"].corpus_file - total_train_num_segments = 28539 - cv_size = 300 / total_train_num_segments - - all_segments = corpus_recipe.SegmentCorpusJob( - train_corpus_path, 1 - ).out_single_segment_files[1] - - splitted_segments_job = corpus_recipe.ShuffleAndSplitSegmentsJob( - all_segments, {"train": 1 - cv_size, "cv": cv_size} - ) - train_segments = splitted_segments_job.out_segments["train"] - cv_segments = splitted_segments_job.out_segments["cv"] - devtrain_segments = text.TailJob( - train_segments, num_lines=300, zip_output=False - ).out - - # ******************** NN Init ******************** - - nn_train_data = gmm_system.outputs["train-clean-100"][ - "final" - ].as_returnn_rasr_data_input(shuffle_data=True) - nn_train_data.update_crp_with(segment_path=train_segments, concurrent=1) - nn_train_data_inputs = { - "train-clean-100.train": SingleHdfDataInput.from_returnn_rasr_data( - nn_train_data, - feature_flow_key="uncached_gt", - returnn_python_exe=RETURNN_EXE, - returnn_root=RETURNN_RC_ROOT, - parition_epoch=10, - seq_ordering="laplace:.1000" - ) - } - - nn_cv_data = gmm_system.outputs["train-clean-100"][ - "final" - ].as_returnn_rasr_data_input() - nn_cv_data.update_crp_with(segment_path=cv_segments, concurrent=1) - nn_cv_data_inputs = { - "train-clean-100.cv": SingleHdfDataInput.from_returnn_rasr_data( - nn_cv_data, - feature_flow_key="uncached_gt", - returnn_python_exe=RETURNN_EXE, - returnn_root=RETURNN_RC_ROOT, - parition_epoch=1, - seq_ordering="sorted" - ) - } - - nn_devtrain_data = gmm_system.outputs["train-clean-100"][ - "final" - ].as_returnn_rasr_data_input() - nn_devtrain_data.update_crp_with(segment_path=devtrain_segments, concurrent=1) - nn_devtrain_data_inputs = { - "train-clean-100.devtrain": SingleHdfDataInput.from_returnn_rasr_data( - nn_devtrain_data, - feature_flow_key="uncached_gt", - returnn_python_exe=RETURNN_EXE, - returnn_root=RETURNN_RC_ROOT, - parition_epoch=1, - seq_ordering="sorted" - ), - } - - nn_dev_data_inputs = { - # "dev-clean": gmm_system.outputs["dev-clean"][ - # "final" - # ].as_returnn_rasr_data_input(), - "dev-other": gmm_system.outputs["dev-other"][ - "final" - ].as_returnn_rasr_data_input(), - } - nn_test_data_inputs = { - # "test-clean": gmm_system.outputs["test-clean"][ - # "final" - # ].as_returnn_rasr_data_input(), - # "test-other": gmm_system.outputs["test-other"][ - # "final" - # ].as_returnn_rasr_data_input(), - } - - - return nn_train_data_inputs, nn_cv_data_inputs, nn_devtrain_data_inputs, nn_dev_data_inputs, nn_test_data_inputs - - -def get_corpus_data_inputs_devcv(gmm_system): - """ - - :param GmmSystem gmm_system: - :return: - """ - train_corpus_path = gmm_system.corpora["train-clean-100"].corpus_file - dev_corpus_path = gmm_system.corpora["dev-other"].corpus_file - total_train_num_segments = 28539 - devtrain_size = 300 / total_train_num_segments - - all_segments = corpus_recipe.SegmentCorpusJob( - train_corpus_path, 1 - ).out_single_segment_files[1] - splitted_segments_job = corpus_recipe.ShuffleAndSplitSegmentsJob( - all_segments, {"_": 1 - devtrain_size, "devtrain": devtrain_size} - ) - devtrain_segments = splitted_segments_job.out_segments["devtrain"] - - - # ******************** NN Init ******************** - - nn_train_data = gmm_system.outputs["train-clean-100"][ - "final" - ].as_returnn_rasr_data_input(shuffle_data=True) - nn_train_data.update_crp_with(concurrent=1) - nn_train_data_inputs = { - "train-clean-100.train": nn_train_data, - } - - nn_cv_data = gmm_system.outputs["dev-other"][ - "final" - ].as_returnn_rasr_data_input() - nn_cv_data.update_crp_with(concurrent=1) - nn_cv_data_inputs = { - "train-clean-100.cv": nn_cv_data, - } - - nn_devtrain_data = gmm_system.outputs["train-clean-100"][ - "final" - ].as_returnn_rasr_data_input() - nn_devtrain_data.update_crp_with(segment_path=devtrain_segments, concurrent=1) - nn_devtrain_data_inputs = { - "train-clean-100.devtrain": nn_devtrain_data, - } - nn_dev_data_inputs = { - # "dev-clean": gmm_system.outputs["dev-clean"][ - # "final" - # ].as_returnn_rasr_data_input(), - "dev-other": gmm_system.outputs["dev-other"][ - "final" - ].as_returnn_rasr_data_input(), - } - nn_test_data_inputs = { - # "test-clean": gmm_system.outputs["test-clean"][ - # "final" - # ].as_returnn_rasr_data_input(), - # "test-other": gmm_system.outputs["test-other"][ - # "final" - # ].as_returnn_rasr_data_input(), - } - - - return nn_train_data_inputs, nn_cv_data_inputs, nn_devtrain_data_inputs, nn_dev_data_inputs, nn_test_data_inputs \ No newline at end of file diff --git a/users/rilling/experiments/librispeech/librispeech_100_hybrid/default_tools.py b/users/rilling/experiments/librispeech/librispeech_100_hybrid/default_tools.py deleted file mode 100644 index d769bd62a..000000000 --- a/users/rilling/experiments/librispeech/librispeech_100_hybrid/default_tools.py +++ /dev/null @@ -1,26 +0,0 @@ -from sisyphus import tk -from i6_core.tools.git import CloneGitRepositoryJob -from i6_experiments.common.tools.rasr import compile_rasr_binaries_i6mode - - -PACKAGE = __package__ - -#RASR_BINARY_PATH = compile_rasr_binaries_i6mode(commit="907eec4f4e36c11153f6ab6b5dd7675116f909f6") -RASR_BINARY_PATH = compile_rasr_binaries_i6mode(branch="bene_unpushed_assert") -RASR_BINARY_PATH.hash_overwrite = "LIBRISPEECH_DEFAULT_RASR_BINARY_PATH" - -RASR_BINARY_PATH_U22 = tk.Path("/work/asr4/rossenbach/neon_test/rasr_versions/rasr_no_tf/arch/linux-x86_64-standard/") -RASR_BINARY_PATH_U22.hash_overwrite = "LIBRISPEECH_DEFAULT_RASR_BINARY_PATH" - -RASR_BINARY_PATH_APPTAINER = tk.Path("/work/asr4/rossenbach/rescale/pytorch_mixed_precision/onnx_extended_rasr/arch/linux-x86_64-standard") -RASR_BINARY_PATH_APPTAINER.hash_overwrite = "LIBRISPEECH_DEFAULT_RASR_BINARY_PATH" - -RETURNN_EXE = tk.Path("/u/rossenbach/bin/returnn/returnn_tf2.3.4_mkl_launcher.sh", hash_overwrite="GENERIC_RETURNN_LAUNCHER") -RETURNN_DATA_ROOT = CloneGitRepositoryJob("https://github.com/rwth-i6/returnn", - commit="37ba06ab2697e7af4de96037565fdf4f78acdb80").out_repository - -RETURNN_RC_ROOT = CloneGitRepositoryJob("https://github.com/rwth-i6/returnn", commit="ac52150e2309e00d55af70e879c176c6400cc536").out_repository -RETURNN_RC_ROOT.hash_overwrite = "LIBRISPEECH_DEFAULT_RETURNN_RC_ROOT" - -RETURNN_COMMON = CloneGitRepositoryJob("https://github.com/rwth-i6/returnn_common", commit="e3083fac1899bb764710ca46ff9257247e4e6b14", checkout_folder_name="returnn_common").out_repository -RETURNN_COMMON.hash_overwrite = "LIBRISPEECH_DEFAULT_RETURNN_COMMON" diff --git a/users/rilling/experiments/librispeech/librispeech_100_hybrid/experiments.py b/users/rilling/experiments/librispeech/librispeech_100_hybrid/experiments.py deleted file mode 100644 index 96782b6d6..000000000 --- a/users/rilling/experiments/librispeech/librispeech_100_hybrid/experiments.py +++ /dev/null @@ -1,86 +0,0 @@ -import copy -from sisyphus import tk, gs - -from i6_core.tools.git import CloneGitRepositoryJob - -from i6_experiments.common.setups.rasr.util import RasrSteps -from i6_experiments.common.setups.rasr.hybrid_system import HybridSystem -from i6_experiments.common.baselines.librispeech.default_tools import RASR_BINARY_PATH - - -from .data import get_corpus_data_inputs -from .configs.legacy_baseline import get_nn_args, get_feature_extraction_args -from .configs.rc_baseline import get_nn_args as get_rc_nn_args -from .configs.pytorch_baseline import get_nn_args as get_pytorch_nn_args -from .default_tools import RETURNN_RC_ROOT, RASR_BINARY_PATH_APPTAINER - -from .data import get_corpus_data_inputs_newcv, get_corpus_data_inputs_newcv_hdf - - -def run_gmm_system(): - from .gmm_baseline import run_librispeech_100_common_baseline - - system = run_librispeech_100_common_baseline(extract_additional_rasr_features=get_feature_extraction_args()) - return system - - -def run_gmm_system_v2(): - from .gmm_baseline import run_librispeech_100_common_baseline - - system = run_librispeech_100_common_baseline( - extract_additional_rasr_features=get_feature_extraction_args(fix_features_output=True) - ) - return system - - -def run_hybrid_baseline_pytorch(): - from i6_experiments.users.rossenbach.common_setups.rasr.pytorch_onnx_hybrid_system import PyTorchOnnxHybridSystem - - gs.ALIAS_AND_OUTPUT_SUBDIR = "experiments/librispeech/librispeech_100_hybrid/common_baseline_pytorch" - - gmm_system = run_gmm_system() - rasr_init_args = copy.deepcopy(gmm_system.rasr_init_args) - rasr_init_args.feature_extraction_args = get_feature_extraction_args() - ( - nn_train_data_inputs, - nn_cv_data_inputs, - nn_devtrain_data_inputs, - nn_dev_data_inputs, - nn_test_data_inputs, - ) = get_corpus_data_inputs_newcv(gmm_system) - - nn_args = get_pytorch_nn_args(num_epochs=125, debug=True) - nn_args.training_args["partition_epochs"] = {"train": 10, "dev": 1} - nn_steps = RasrSteps() - nn_steps.add_step("nn", nn_args) - - # ******************** NN System ******************** - - # image only, so just python3 - returnn_exe = tk.Path("/usr/bin/python3", hash_overwrite="GENERIC_RETURNN_LAUNCHER") - - # returnn_root = tk.Path("/u/rossenbach/src/returnn", hash_overwrite="LIBRISPEECH_DEFAULT_RETURNN_ROOT") - returnn_root_experimental = tk.Path( - "/u/lukas.rilling/github/MiniReturnn", hash_overwrite="LIBRISPEECH_DEFAULT_MINIRETURNN_ROOT" - ) - lbs_nn_system = PyTorchOnnxHybridSystem( - returnn_root=returnn_root_experimental, - returnn_python_exe=returnn_exe, - rasr_arch="linux-x86_64-standard", - rasr_binary_path=RASR_BINARY_PATH_APPTAINER, - ) - # manually override RASR binary for trainer - # lbs_nn_system.crp["base"].nn_trainer_exe = RASR_BINARY_PATH_U22.join_right(f"nn-trainer.linux-x86_64-standard") - lbs_nn_system.init_system( - rasr_init_args=rasr_init_args, - train_data=nn_train_data_inputs, - cv_data=nn_cv_data_inputs, - devtrain_data=nn_devtrain_data_inputs, - dev_data=nn_dev_data_inputs, - test_data=nn_test_data_inputs, - train_cv_pairing=[tuple(["train-clean-100.train", "train-clean-100.cv"])], - ) - - lbs_nn_system.run(nn_steps) - - gs.ALIAS_AND_OUTPUT_SUBDIR = "" diff --git a/users/rilling/experiments/librispeech/librispeech_100_hybrid/gmm_baseline.py b/users/rilling/experiments/librispeech/librispeech_100_hybrid/gmm_baseline.py deleted file mode 100644 index 510f8db3e..000000000 --- a/users/rilling/experiments/librispeech/librispeech_100_hybrid/gmm_baseline.py +++ /dev/null @@ -1,77 +0,0 @@ -""" -Definition of the pipeline in terms of inputs and steps that are executed -""" -from sisyphus import gs - -from typing import Any, Dict, Optional - -from i6_experiments.common.setups.rasr import gmm_system -from i6_experiments.common.setups.rasr.util import RasrSteps, OutputArgs - -from i6_experiments.common.baselines.librispeech.ls100.gmm import baseline_args -from i6_experiments.common.baselines.librispeech.data import get_corpus_data_inputs - -from i6_experiments.common.baselines.librispeech.default_tools import RASR_BINARY_PATH - - -def run_librispeech_100_common_baseline( - alias_prefix="baselines/librispeech/ls100/gmm/common_baseline", - extract_additional_rasr_features: Optional[Dict[str, Any]] = None, -) -> gmm_system.GmmSystem: - """ - - :param alias_prefix: - :param extract_additional_rasr_features: a dict of : , - used to extract additional RASR-based features to be used on subsequent systems such as Hybrid - """ - - stored_alias_subdir = gs.ALIAS_AND_OUTPUT_SUBDIR - gs.ALIAS_AND_OUTPUT_SUBDIR = alias_prefix - - rasr_init_args = baseline_args.get_init_args() - - if extract_additional_rasr_features is not None: - for feature_key, feature_options in extract_additional_rasr_features.items(): - rasr_init_args.feature_extraction_args[feature_key] = feature_options - - mono_args = baseline_args.get_monophone_args() - # no unknown question needed when G2P is used - cart_args = baseline_args.get_cart_args(add_unknown=False) - tri_args = baseline_args.get_triphone_args() - vtln_args = baseline_args.get_vtln_args() - sat_args = baseline_args.get_sat_args() - vtln_sat_args = baseline_args.get_vtln_sat_args() - - final_output_args = OutputArgs("final") - final_output_args.define_corpus_type("train-clean-100", "train") - final_output_args.define_corpus_type("dev-clean", "dev") - final_output_args.define_corpus_type("dev-other", "dev") - - if extract_additional_rasr_features: - for feature_key in extract_additional_rasr_features.keys(): - final_output_args.add_feature_to_extract(feature_key) - - steps = RasrSteps() - steps.add_step("extract", rasr_init_args.feature_extraction_args) - steps.add_step("mono", mono_args) - steps.add_step("cart", cart_args) - steps.add_step("tri", tri_args) - steps.add_step("vtln", vtln_args) - steps.add_step("sat", sat_args) - steps.add_step("vtln+sat", vtln_sat_args) - steps.add_step("output", final_output_args) - - corpus_data = get_corpus_data_inputs(corpus_key="train-clean-100", use_g2p_training=True, use_stress_marker=False) - - system = gmm_system.GmmSystem(rasr_binary_path=RASR_BINARY_PATH) - system.init_system( - rasr_init_args=rasr_init_args, - train_data=corpus_data.train_data, - dev_data=corpus_data.dev_data, - test_data=corpus_data.test_data, - ) - system.run(steps) - - gs.ALIAS_AND_OUTPUT_SUBDIR = stored_alias_subdir - - return system \ No newline at end of file diff --git a/users/rilling/experiments/librispeech/librispeech_100_hybrid/lm/__init__.py b/users/rilling/experiments/librispeech/librispeech_100_hybrid/lm/__init__.py deleted file mode 100644 index 6b28960dd..000000000 --- a/users/rilling/experiments/librispeech/librispeech_100_hybrid/lm/__init__.py +++ /dev/null @@ -1,9 +0,0 @@ -from i6_experiments.common.datasets.librispeech.language_model import get_librispeech_normalized_lm_data -from i6_experiments.common.datasets.librispeech.vocab import get_lm_vocab - - -def test_train_lm(): - pass - # lm_index_vocab = get_lm_vocab() - # lm_training_data = get_librispeech_normalized_lm_data() - diff --git a/users/rilling/experiments/librispeech/librispeech_100_hybrid/lm/config.py b/users/rilling/experiments/librispeech/librispeech_100_hybrid/lm/config.py deleted file mode 100644 index 541d27bb7..000000000 --- a/users/rilling/experiments/librispeech/librispeech_100_hybrid/lm/config.py +++ /dev/null @@ -1,92 +0,0 @@ -from i6_core.returnn.config import ReturnnConfig - -from .data import TrainingDatasets, SOURCE_DATASTREAM_KEY, TARGET_DATASTREAM_KEY - -# changing these does not change the hash -post_config = { - 'use_tensorflow': True, - 'tf_log_memory_usage': True, - 'cleanup_old_models': True, - 'log_batch_size': True, - 'debug_print_layer_output_template': True, - 'debug_mode': False, - 'batching': 'random' -} - -CF_CODE = """ -import os -from subprocess import check_output - -_cf_cache = {} - -def cf(filename): - if filename in _cf_cache: - return _cf_cache[filename] - cached_fn = check_output(["cf", filename]).strip().decode("utf8") - assert os.path.exists(cached_fn) - _cf_cache[filename] = cached_fn - return cached_fn -""" - -STACK_CODE = """ -# https://github.com/rwth-i6/returnn/issues/957 -# https://stackoverflow.com/a/16248113/133374 -import resource -import sys -try: - resource.setrlimit(resource.RLIMIT_STACK, (2 ** 29, -1)) -except Exception as exc: - print(f"resource.setrlimit {type(exc).__name__}: {exc}") -sys.setrecursionlimit(10 ** 6) -""" - - -def get_training_config(datasets: TrainingDatasets): - config = { - "batch_size": 900, - "max_seq_length": 602, - "max_seqs": 32, - "chunking": "0", - "calculate_exp_loss": True, - "gradient_clip_global_norm": 2.0, - "gradient_noise": 0., - "learning_rate": 1., - "learning_rate_control": "newbob_rel", - "learning_rate_control_relative_error_relative_lr": False, - "newbob_learning_rate_decay": 0.8, - "newbob_relative_error_threshold": 0, - "learning_rate_control_error_measure": "dev_score_output:exp", - ############# - "train": datasets.train.as_returnn_opts(), - "dev": datasets.cv.as_returnn_opts(), - } - - config["network"] = { - "input": {"class": "linear", "n_out": 128, "activation": "identity", - "forward_weights_init": "random_normal_initializer(mean=0.0, stddev=0.1)", - "from": [f"data:{SOURCE_DATASTREAM_KEY}"]}, - "lstm0": {"class": "rec", "unit": "lstm", - "forward_weights_init" : "random_normal_initializer(mean=0.0, stddev=0.1)", - "recurrent_weights_init": "random_normal_initializer(mean=0.0, stddev=0.1)", - "bias_init": "random_normal_initializer(mean=0.0, stddev=0.1)", - "n_out": 4096, "dropout": 0.2, "L2": 0.0, "direction": 1, "from": ["input"]}, - "lstm1": {"class": "rec", "unit": "lstm", - "forward_weights_init" : "random_normal_initializer(mean=0.0, stddev=0.1)", - "recurrent_weights_init": "random_normal_initializer(mean=0.0, stddev=0.1)", - "bias_init": "random_normal_initializer(mean=0.0, stddev=0.1)", - "n_out": 4096, "dropout": 0.2, "L2": 0.0, "direction": 1, "from": ["lstm0"]}, - "output": {"class": "softmax", "dropout": 0.2, "use_transposed_weights": True, - "loss_opts": {'num_sampled': 16384, 'use_full_softmax': True, 'nce_loss': False}, - "forward_weights_init": "random_normal_initializer(mean=0.0, stddev=0.1)", - "bias_init": "random_normal_initializer(mean=0.0, stddev=0.1)", - "loss": "sampling_loss", "target": f"data:{TARGET_DATASTREAM_KEY}", "from": ["lstm1"]} - } - - returnn_config = ReturnnConfig( - config=config, - post_config=post_config, - python_prolog=[CF_CODE, STACK_CODE], - python_prolog_hash="", - ) - - return returnn_config diff --git a/users/rilling/experiments/librispeech/librispeech_100_hybrid/lm/data.py b/users/rilling/experiments/librispeech/librispeech_100_hybrid/lm/data.py deleted file mode 100644 index c88cfc87f..000000000 --- a/users/rilling/experiments/librispeech/librispeech_100_hybrid/lm/data.py +++ /dev/null @@ -1,154 +0,0 @@ -from sisyphus import tk -from sisyphus.delayed_ops import DelayedFormat - -from dataclasses import dataclass -from typing import Any, Dict, Optional, Union - -from i6_core.corpus.convert import CorpusToTxtJob -from i6_core.text.processing import ConcatenateJob -from i6_core.returnn.config import CodeWrapper - -from i6_experiments.common.datasets.librispeech import get_bliss_corpus_dict -from i6_experiments.common.datasets.librispeech.language_model import get_librispeech_normalized_lm_data -from i6_experiments.common.datasets.librispeech.vocab import get_lm_vocab - -from returnn_common.datasets import Dataset, ControlDataset -from i6_experiments.users.rossenbach.common_setups.returnn.datastreams.vocabulary import LmLabelDatastream - - -SOURCE_DATASTREAM_KEY = "delayed" -TARGET_DATASTREAM_KEY = "data" - - -@dataclass(frozen=True) -class TrainingDatasets: - train: Dataset - cv: Dataset - devtrain: Dataset - extern_data: Dict[str, Dict[str, Any]] - - -class LmDataset(ControlDataset): - - def __init__( - self, - *, - corpus_file: tk.Path, - vocab_file: tk.Path, - unknown_symbol: Union[str, tk.Variable] = "", - auto_replace_unknown_symbol: bool = False, - # super parameters - partition_epoch: Optional[int] = None, - segment_file: Optional[tk.Path] = None, - seq_ordering: Optional[str] = None, - random_subset: Optional[int] = None, - additional_options: Optional[Dict] = None, - ): - super().__init__( - partition_epoch=partition_epoch, - segment_file=segment_file, - seq_ordering=seq_ordering, - random_subset=random_subset, - additional_options=additional_options - ) - - self.corpus_file = corpus_file - self.vocab_file = vocab_file - self.unknown_symbol = unknown_symbol - self.auto_replace_unknown_symbol = auto_replace_unknown_symbol - - def as_returnn_opts(self) -> Dict[str, Any]: - d = { - "class": "LmDataset", - "corpus_file": CodeWrapper(DelayedFormat('lambda: cf("{}")', self.corpus_file)), - "orth_symbols_map_file": self.vocab_file, - "orth_replace_map_file": "", - "word_based": True, - "seq_end_symbol": "", - "auto_replace_unknown_symbol": self.auto_replace_unknown_symbol, - "unknown_symbol": self.unknown_symbol, - "add_delayed_seq_data": True, - "delayed_seq_data_start_symbol": "", - } - sd = super().as_returnn_opts() - assert all([k not in sd.keys() for k in d.keys()]), ( - "conflicting keys in %s and %s" - % (str(list(sd.keys())), str(list(d.keys()))), - ) - d.update(sd) - - return d - - -def build_training_data(output_prefix="", partition_epoch=20): - # conversion factor for PPL computation is 1.448 - ls_bliss_corpus_dict = get_bliss_corpus_dict() - lm_vocab = get_lm_vocab(output_prefix=output_prefix) - label_datastream = LmLabelDatastream( - available_for_inference=True, - lm_index_vocab=lm_vocab - ) - - #### Training Data #### - - lm_data = get_librispeech_normalized_lm_data() - ls_train_bliss = ls_bliss_corpus_dict["train-other-960"] - ls_train_text = CorpusToTxtJob( - bliss_corpus=ls_train_bliss, - gzip=True, - ).out_txt - full_train_text = ConcatenateJob( - text_files=[lm_data, ls_train_text], - zip_out=True, - ).out - - #### Dev Data #### - - dev_clean_text = CorpusToTxtJob(bliss_corpus=ls_bliss_corpus_dict["dev-clean"], gzip=True).out_txt - dev_other_text = CorpusToTxtJob(bliss_corpus=ls_bliss_corpus_dict["dev-other"], gzip=True).out_txt - cv_text = ConcatenateJob( - text_files=[dev_clean_text, dev_other_text], - zip_out=True, - ).out - - #### datasets #### - lm_train_dataset = LmDataset( - corpus_file=full_train_text, - vocab_file=lm_vocab.vocab, - unknown_symbol=lm_vocab.unknown_token, - auto_replace_unknown_symbol=True, - partition_epoch=partition_epoch, - segment_file=None, - seq_ordering="sort_bin_shuffle:.32" - ) - - lm_cv_dataset = LmDataset( - corpus_file=cv_text, - vocab_file=lm_vocab.vocab, - unknown_symbol=lm_vocab.unknown_token, - auto_replace_unknown_symbol=True, - partition_epoch=1, - segment_file=None, - seq_ordering="sorted" - ) - - lm_devtrain_dataset = LmDataset( - corpus_file=full_train_text, - vocab_file=lm_vocab.vocab, - unknown_symbol=lm_vocab.unknown_token, - auto_replace_unknown_symbol=True, - partition_epoch=1, - segment_file=None, - seq_ordering="sorted", - random_subset=3000, - ) - - return TrainingDatasets( - train=lm_train_dataset, - cv=lm_cv_dataset, - devtrain=lm_devtrain_dataset, - extern_data={ - SOURCE_DATASTREAM_KEY: label_datastream.as_returnn_extern_data_opts(available_for_inference=True), - TARGET_DATASTREAM_KEY: label_datastream.as_returnn_extern_data_opts(available_for_inference=False) - } - ) diff --git a/users/rilling/experiments/librispeech/librispeech_100_hybrid/lm/default_tools.py b/users/rilling/experiments/librispeech/librispeech_100_hybrid/lm/default_tools.py deleted file mode 100644 index 78a0ce27a..000000000 --- a/users/rilling/experiments/librispeech/librispeech_100_hybrid/lm/default_tools.py +++ /dev/null @@ -1,13 +0,0 @@ -from sisyphus import tk -from i6_core.tools.git import CloneGitRepositoryJob - - -RETURNN_EXE = tk.Path("/u/rossenbach/bin/returnn/returnn_tf2.3.4_mkl_launcher.sh", hash_overwrite="GENERIC_RETURNN_LAUNCHER") - -# RETURNN_ROOT = CloneGitRepositoryJob("https://github.com/rwth-i6/returnn", commit="45fad83c785a45fa4abfeebfed2e731dd96f960c").out_repository - -# run with LM vocab fix -RETURNN_ROOT = CloneGitRepositoryJob("https://github.com/rwth-i6/returnn", commit="9e7b7f24b090f4a4909c9be3e276194f026a6932").out_repository -RETURNN_ROOT.hash_overwrite = "LIBRISPEECH_DEFAULT_RETURNN_ROOT" - - diff --git a/users/rilling/experiments/librispeech/librispeech_100_hybrid/lm/experiment.py b/users/rilling/experiments/librispeech/librispeech_100_hybrid/lm/experiment.py deleted file mode 100644 index de06613e1..000000000 --- a/users/rilling/experiments/librispeech/librispeech_100_hybrid/lm/experiment.py +++ /dev/null @@ -1,36 +0,0 @@ -from sisyphus import tk - -from i6_core.returnn.training import ReturnnTrainingJob - -from .default_tools import RETURNN_EXE, RETURNN_ROOT -from .data import build_training_data -from .config import get_training_config - -def train(config, num_epochs=50): - default_rqmt = { - 'mem_rqmt': 15, - 'time_rqmt': 168, - 'log_verbosity': 5, - 'returnn_python_exe': RETURNN_EXE, - 'returnn_root': RETURNN_ROOT, - } - - train_job = ReturnnTrainingJob( - returnn_config=config, - num_epochs=num_epochs, - **default_rqmt - ) - return train_job - - -def test_train_lm(): - - exp_prefix = "experiments/librispeech/librispeech_100_hybrid/lm/kazuki_lstm_2x4k_samp16k_v2" - training_data = build_training_data(output_prefix=exp_prefix) - - config = get_training_config(training_data) - config.config["batch_size"] = 950 - train_job = train(config) - train_job.add_alias(exp_prefix + "/training") - tk.register_output(exp_prefix + "/learning_rates", train_job.out_learning_rates) - diff --git a/users/rilling/experiments/librispeech/librispeech_100_hybrid/pytorch_networks/__init__.py b/users/rilling/experiments/librispeech/librispeech_100_hybrid/pytorch_networks/__init__.py deleted file mode 100644 index e69de29bb..000000000 diff --git a/users/rilling/experiments/librispeech/librispeech_100_hybrid/pytorch_networks/blstm8x1024.py b/users/rilling/experiments/librispeech/librispeech_100_hybrid/pytorch_networks/blstm8x1024.py deleted file mode 100644 index 0b7c34f08..000000000 --- a/users/rilling/experiments/librispeech/librispeech_100_hybrid/pytorch_networks/blstm8x1024.py +++ /dev/null @@ -1,94 +0,0 @@ -import time -import torch -from torch import nn -from torch.onnx import export as onnx_export -from torchaudio.functional import mask_along_axis - -from returnn.torch.engine import TrainCtx - - -class Model(torch.nn.Module): - - def __init__(self): - super().__init__() - lstm_size = 1024 - target_size=12001 - self.blstm1 = nn.LSTM(input_size=50, hidden_size=lstm_size, bidirectional=True, batch_first=False) - self.blstm_stack = nn.LSTM(input_size=2*lstm_size, hidden_size=lstm_size, bidirectional=True, num_layers=7, batch_first=False) - self.final_linear = nn.Linear(2*lstm_size, target_size) - self.lstm_size = lstm_size - - def forward( - self, - audio_features: torch.Tensor, - audio_features_len: torch.Tensor, - ): - if self.training: - audio_features_time_masked = mask_along_axis(audio_features, mask_param=20, mask_value=0.0, axis=1) - audio_features_masked = mask_along_axis(audio_features_time_masked, mask_param=10, mask_value=0.0, axis=2) - else: - audio_features_masked = audio_features - blstm_in = torch.swapaxes(audio_features_masked, 0, 1) # [B, T, F] -> [T, B, F] - - blstm_packed_in = nn.utils.rnn.pack_padded_sequence(blstm_in, audio_features_len) - blstm_first, _ = self.blstm1(blstm_packed_in) - blstm_packed_out, _ = self.blstm_stack(blstm_first) - blstm_out, _ = nn.utils.rnn.pad_packed_sequence(blstm_packed_out, padding_value=0.0, batch_first=False) # [T, B, F] - - logits = self.final_linear(blstm_out) # [T, B, F] - logits_rasr_order = torch.permute(logits, dims=(1, 0, 2)) # RASR expects [B, T, F] - logits_ce_order = torch.permute(logits, dims=(1, 2, 0)) # CE expects [B, F, T] - log_probs = torch.log_softmax(logits_rasr_order, dim=2) - - return log_probs, logits_ce_order - - -scripted_model = None - -def train_step(*, model: Model, data, train_ctx, **_kwargs): - global scripted_model - audio_features = data["data"] - audio_features_len = data["data:seq_len"] - - audio_features_len, indices = torch.sort(audio_features_len, descending=True) - audio_features = audio_features[indices, :, :] - - phonemes = data["classes"][indices, :] - phonemes_len = data["classes:seq_len"][indices] - - if scripted_model is None: - scripted_model = torch.jit.script(model) - - log_probs, logits = model( - audio_features=audio_features, - audio_features_len=audio_features_len, - ) - - targets_packed = nn.utils.rnn.pack_padded_sequence(phonemes, phonemes_len, batch_first=True, enforce_sorted=False) - targets_masked, _ = nn.utils.rnn.pad_packed_sequence(targets_packed, batch_first=True, padding_value=-100) - - loss = nn.functional.cross_entropy(logits, targets_masked) - - train_ctx.mark_as_loss(name="CE", loss=loss) - - -def export(*, model: Model, model_filename: str): - scripted_model = torch.jit.optimize_for_inference(torch.jit.script(model.eval())) - dummy_data = torch.randn(1, 30, 50, device="cpu") - dummy_data_len, _ = torch.sort(torch.randint(low=10, high=30, size=(1,), device="cpu", dtype=torch.int32), descending=True) - onnx_export( - scripted_model, - (dummy_data, dummy_data_len), - f=model_filename, - verbose=True, - input_names=["data", "data_len"], - output_names=["classes"], - dynamic_axes={ - # dict value: manually named axes - "data": {0: "batch", 1: "time"}, - "data_len": {0: "batch"}, - "classes": {0: "batch", 1: "time"} - } - ) - - diff --git a/users/rilling/experiments/librispeech/librispeech_100_hybrid/pytorch_networks/blstm8x1024_custom_engine.py b/users/rilling/experiments/librispeech/librispeech_100_hybrid/pytorch_networks/blstm8x1024_custom_engine.py deleted file mode 100644 index f9d1bc455..000000000 --- a/users/rilling/experiments/librispeech/librispeech_100_hybrid/pytorch_networks/blstm8x1024_custom_engine.py +++ /dev/null @@ -1,121 +0,0 @@ -from random import random -import torch -import time -from typing import Dict, Optional -from torch import nn -from torch.onnx import export as onnx_export -from torchaudio.functional import mask_along_axis - -from returnn.torch.engine import Engine as TorchEngine -from returnn.util import NumbersDict -from returnn.log import log - - - -class Model(torch.nn.Module): - - def __init__(self): - super().__init__() - lstm_size = 1024 - target_size=12001 - self.blstm1 = nn.LSTM(input_size=50, hidden_size=lstm_size, bidirectional=True, batch_first=False) - self.blstm_stack = nn.LSTM(input_size=2*lstm_size, hidden_size=lstm_size, bidirectional=True, num_layers=7, batch_first=False) - self.final_linear = nn.Linear(2*lstm_size, target_size) - self.lstm_size = lstm_size - - def forward( - self, - audio_features: torch.Tensor, - audio_features_len: torch.Tensor, - ): - if self.training: - audio_features_time_masked = mask_along_axis(audio_features, mask_param=20, mask_value=0.0, axis=1) - audio_features_time_masked_2 = mask_along_axis(audio_features_time_masked, mask_param=20, mask_value=0.0, axis=1) - audio_features_masked = mask_along_axis(audio_features_time_masked_2, mask_param=10, mask_value=0.0, axis=2) - audio_features_masked_2 = mask_along_axis(audio_features_masked, mask_param=10, mask_value=0.0, axis=2) - else: - audio_features_masked_2 = audio_features - blstm_in = torch.swapaxes(audio_features_masked_2, 0, 1) # [B, T, F] -> [T, B, F] - - blstm_packed_in = nn.utils.rnn.pack_padded_sequence(blstm_in, audio_features_len) - blstm_first, _ = self.blstm1(blstm_packed_in) - blstm_packed_out, _ = self.blstm_stack(blstm_first) - blstm_out, _ = nn.utils.rnn.pad_packed_sequence(blstm_packed_out, padding_value=0.0, batch_first=False) # [T, B, F] - - logits = self.final_linear(blstm_out) # [T, B, F] - logits_rasr_order = torch.permute(logits, dims=(1, 0, 2)) # RASR expects [B, T, F] - logits_ce_order = torch.permute(logits, dims=(1, 2, 0)) # CE expects [B, F, T] - log_probs = torch.log_softmax(logits_rasr_order, dim=2) - - return log_probs, logits_ce_order - - -scripted_model = None - -def train_step(*, model: Model, data, run_ctx, **_kwargs): - global scripted_model - audio_features = data["data"] - audio_features_len = data["data:seq_len"] - - audio_features_len, indices = torch.sort(audio_features_len, descending=True) - audio_features = audio_features[indices, :, :] - - phonemes = data["classes"][indices, :] - phonemes_len = data["classes:seq_len"][indices] - - if scripted_model is None: - scripted_model = torch.jit.script(model) - - # distributed_model = DataParallel(model) - log_probs, logits = model( - audio_features=audio_features, - audio_features_len=audio_features_len, - ) - - targets_packed = nn.utils.rnn.pack_padded_sequence(phonemes, phonemes_len, batch_first=True, enforce_sorted=False) - targets_masked, _ = nn.utils.rnn.pad_packed_sequence(targets_packed, batch_first=True, padding_value=-100) - - loss = nn.functional.cross_entropy(logits, targets_masked) - - run_ctx.mark_as_loss(name="ce", loss=loss) - - -def export(*, model: Model, model_filename: str): - scripted_model = torch.jit.optimize_for_inference(torch.jit.script(model.eval())) - dummy_data = torch.randn(1, 30, 50, device="cpu") - dummy_data_len, _ = torch.sort(torch.randint(low=10, high=30, size=(1,), device="cpu", dtype=torch.int32), descending=True) - onnx_export( - scripted_model, - (dummy_data, dummy_data_len), - f=model_filename, - verbose=True, - input_names=["data", "data_len"], - output_names=["classes"], - dynamic_axes={ - # dict value: manually named axes - "data": {0: "batch", 1: "time"}, - "data_len": {0: "batch"}, - "classes": {0: "batch", 1: "time"} - } - ) - - -def export_trace(*, model: Model, model_filename: str): - dummy_data = torch.randn(1, 30, 50, device="cpu") - dummy_data_len, _ = torch.sort(torch.randint(low=10, high=30, size=(1,), device="cpu", dtype=torch.int32), descending=True) - scripted_model = torch.jit.optimize_for_inference(torch.jit.trace(model.eval(), example_inputs=(dummy_data, dummy_data_len))) - onnx_export( - scripted_model, - (dummy_data, dummy_data_len), - f=model_filename, - verbose=True, - input_names=["data", "data_len"], - output_names=["classes"], - dynamic_axes={ - # dict value: manually named axes - "data": {0: "batch", 1: "time"}, - "data_len": {0: "batch"}, - "classes": {0: "batch", 1: "time"} - } - ) - diff --git a/users/rilling/experiments/librispeech/librispeech_100_hybrid/pytorch_networks/blstm8x1024_more_specaug.py b/users/rilling/experiments/librispeech/librispeech_100_hybrid/pytorch_networks/blstm8x1024_more_specaug.py deleted file mode 100644 index b2e0a2fd5..000000000 --- a/users/rilling/experiments/librispeech/librispeech_100_hybrid/pytorch_networks/blstm8x1024_more_specaug.py +++ /dev/null @@ -1,115 +0,0 @@ -import time -import torch -from torch import nn -from torch.onnx import export as onnx_export -from torchaudio.functional import mask_along_axis - - -class Model(torch.nn.Module): - - def __init__(self): - super().__init__() - lstm_size = 1024 - target_size=12001 - self.blstm1 = nn.LSTM(input_size=50, hidden_size=lstm_size, bidirectional=True, batch_first=False) - self.blstm_stack = nn.LSTM(input_size=2*lstm_size, hidden_size=lstm_size, bidirectional=True, num_layers=7, batch_first=False) - self.final_linear = nn.Linear(2*lstm_size, target_size) - self.lstm_size = lstm_size - - def forward( - self, - audio_features: torch.Tensor, - audio_features_len: torch.Tensor, - ): - if self.training: - audio_features_time_masked = mask_along_axis(audio_features, mask_param=20, mask_value=0.0, axis=1) - audio_features_time_masked_2 = mask_along_axis(audio_features_time_masked, mask_param=20, mask_value=0.0, axis=1) - audio_features_masked = mask_along_axis(audio_features_time_masked_2, mask_param=10, mask_value=0.0, axis=2) - audio_features_masked_2 = mask_along_axis(audio_features_masked, mask_param=10, mask_value=0.0, axis=2) - else: - audio_features_masked_2 = audio_features - blstm_in = torch.swapaxes(audio_features_masked_2, 0, 1) # [B, T, F] -> [T, B, F] - - blstm_packed_in = nn.utils.rnn.pack_padded_sequence(blstm_in, audio_features_len) - blstm_first, _ = self.blstm1(blstm_packed_in) - blstm_packed_out, _ = self.blstm_stack(blstm_first) - blstm_out, _ = nn.utils.rnn.pad_packed_sequence(blstm_packed_out, padding_value=0.0, batch_first=False) # [T, B, F] - - logits = self.final_linear(blstm_out) # [T, B, F] - logits_rasr_order = torch.permute(logits, dims=(1, 0, 2)) # RASR expects [B, T, F] - logits_ce_order = torch.permute(logits, dims=(1, 2, 0)) # CE expects [B, F, T] - log_probs = torch.log_softmax(logits_rasr_order, dim=2) - - return log_probs, logits_ce_order - - -scripted_model = None - -def train_step(*, model: Model, data, run_ctx, **_kwargs): - global scripted_model - audio_features = data["data"] - audio_features_len = data["data:seq_len"] - - audio_features_len, indices = torch.sort(audio_features_len, descending=True) - audio_features = audio_features[indices, :, :] - - phonemes = data["classes"][indices, :] - phonemes_len = data["classes:seq_len"][indices] - - if scripted_model is None: - scripted_model = torch.jit.script(model) - - # distributed_model = DataParallel(model) - log_probs, logits = model( - audio_features=audio_features, - audio_features_len=audio_features_len, - ) - - targets_packed = nn.utils.rnn.pack_padded_sequence(phonemes, phonemes_len, batch_first=True, enforce_sorted=False) - targets_masked, _ = nn.utils.rnn.pad_packed_sequence(targets_packed, batch_first=True, padding_value=-100) - - loss = nn.functional.cross_entropy(logits, targets_masked) - - run_ctx.mark_as_loss(name="CE", loss=loss) - - -def export(*, model: Model, model_filename: str): - scripted_model = torch.jit.optimize_for_inference(torch.jit.script(model.eval())) - dummy_data = torch.randn(1, 30, 50, device="cpu") - dummy_data_len, _ = torch.sort(torch.randint(low=10, high=30, size=(1,), device="cpu", dtype=torch.int32), descending=True) - onnx_export( - scripted_model, - (dummy_data, dummy_data_len), - f=model_filename, - verbose=True, - input_names=["data", "data_len"], - output_names=["classes"], - dynamic_axes={ - # dict value: manually named axes - "data": {0: "batch", 1: "time"}, - "data_len": {0: "batch"}, - "classes": {0: "batch", 1: "time"} - } - ) - - -def export_trace(*, model: Model, model_filename: str): - dummy_data = torch.randn(1, 30, 50, device="cpu") - dummy_data_len, _ = torch.sort(torch.randint(low=10, high=30, size=(1,), device="cpu", dtype=torch.int32), descending=True) - scripted_model = torch.jit.optimize_for_inference(torch.jit.trace(model.eval(), example_inputs=(dummy_data, dummy_data_len))) - onnx_export( - scripted_model, - (dummy_data, dummy_data_len), - f=model_filename, - verbose=True, - input_names=["data", "data_len"], - output_names=["classes"], - dynamic_axes={ - # dict value: manually named axes - "data": {0: "batch", 1: "time"}, - "data_len": {0: "batch"}, - "classes": {0: "batch", 1: "time"} - } - ) - - diff --git a/users/rilling/experiments/librispeech/librispeech_100_hybrid/pytorch_networks/blstm8x1024_more_specaug_backup.py b/users/rilling/experiments/librispeech/librispeech_100_hybrid/pytorch_networks/blstm8x1024_more_specaug_backup.py deleted file mode 100644 index d553b6c08..000000000 --- a/users/rilling/experiments/librispeech/librispeech_100_hybrid/pytorch_networks/blstm8x1024_more_specaug_backup.py +++ /dev/null @@ -1,75 +0,0 @@ -import time -import torch -from torch import nn -from torch.onnx import export -from torchaudio.functional import mask_along_axis - -from returnn.torch.engine import TrainCtx - - -class Model(torch.nn.Module): - - def __init__(self): - super().__init__() - lstm_size = 1024 - target_size=12001 - self.blstm1 = nn.LSTM(input_size=50, hidden_size=lstm_size, bidirectional=True, batch_first=False) - self.blstm_stack = nn.LSTM(input_size=2*lstm_size, hidden_size=lstm_size, bidirectional=True, num_layers=7, batch_first=False) - self.final_linear = nn.Linear(2*lstm_size, target_size) - self.lstm_size = lstm_size - - def forward( - self, - audio_features: torch.Tensor, - audio_features_len: torch.Tensor, - ): - audio_features_time_masked = mask_along_axis(audio_features, mask_param=20, mask_value=0.0, axis=1) - audio_features_time_masked_2 = mask_along_axis(audio_features_time_masked, mask_param=20, mask_value=0.0, axis=1) - audio_features_masked = mask_along_axis(audio_features_time_masked_2, mask_param=10, mask_value=0.0, axis=2) - audio_features_masked_2 = mask_along_axis(audio_features_masked, mask_param=10, mask_value=0.0, axis=2) - blstm_in = torch.swapaxes(audio_features_masked_2, 0, 1) # [B, T, F] -> [T, B, F] - - blstm_packed_in = nn.utils.rnn.pack_padded_sequence(blstm_in, audio_features_len) - blstm_first, _ = self.blstm1(blstm_packed_in) - blstm_packed_out, _ = self.blstm_stack(blstm_first) - blstm_out, _ = nn.utils.rnn.pad_packed_sequence(blstm_packed_out, padding_value=0.0, batch_first=False) # [T, B, F] - - logits = self.final_linear(blstm_out) # [T, B, F] - logits = torch.permute(logits, dims=(1, 2, 0)) # CE expects [B, F, T] - log_probs = torch.log_softmax(logits, dim=2) - - return log_probs, logits - -scripted_model = None - -def train_step(*, model: Model, data, train_ctx, **_kwargs): - global scripted_model - audio_features = data["data"] - audio_features_len = data["data:seq_len"] - - audio_features_len, indices = torch.sort(audio_features_len, descending=True) - audio_features = audio_features[indices, :, :] - - phonemes = data["classes"][indices, :] - phonemes_len = data["classes:seq_len"][indices] - - if scripted_model is None: - scripted_model = torch.jit.script(model) - - log_probs, logits = model( - audio_features=audio_features, - audio_features_len=audio_features_len, - ) - - targets_packed = nn.utils.rnn.pack_padded_sequence(phonemes, phonemes_len, batch_first=True, enforce_sorted=False) - targets_masked, _ = nn.utils.rnn.pad_packed_sequence(targets_packed, batch_first=True, padding_value=-100) - - loss = nn.functional.cross_entropy(logits, targets_masked) - - train_ctx.mark_as_loss(name="CE", loss=loss) - - - - - - diff --git a/users/rilling/experiments/librispeech/librispeech_100_hybrid/pytorch_networks/blstm8x1024_more_specaug_fp16.py b/users/rilling/experiments/librispeech/librispeech_100_hybrid/pytorch_networks/blstm8x1024_more_specaug_fp16.py deleted file mode 100644 index e41fe158f..000000000 --- a/users/rilling/experiments/librispeech/librispeech_100_hybrid/pytorch_networks/blstm8x1024_more_specaug_fp16.py +++ /dev/null @@ -1,176 +0,0 @@ -import time -import torch -from torch import nn, autocast -from torch.onnx import export as onnx_export -from torch.cuda.amp import GradScaler -from torchaudio.functional import mask_along_axis - -from returnn.log import log -from returnn.torch.engine import Engine as TorchEngine -from returnn.util.basic import NumbersDict -from returnn.torch.context import get_run_ctx, init_train_step_run_ctx - - -class CustomEngine(TorchEngine): - - def train_epoch(self): - """ - train one (sub)epoch - """ - print("start", self.get_epoch_str(), "with learning rate", self.learning_rate, "...", file=log.v4) - - self._model.train() - init_train_step_run_ctx(device=self._device) - - # Creates a GradScaler once at the beginning of training. - scaler = GradScaler() - - accumulated_losses_dict = NumbersDict() - step_idx = 0 - for data in self._train_dataloader: - step_time_start = time.time() - run_ctx = get_run_ctx() - run_ctx.init_step() - - self._updater.get_optimizer().zero_grad() - with autocast(device_type='cuda', dtype=torch.bfloat16): - self._run_step(data) - - losses_dict = run_ctx.losses - total_loss = run_ctx.total_loss() - - scaler.scale(total_loss).backward() - scaler.step(self._updater.get_optimizer()) - scaler.update() - - losses_dict = { - "train_loss_" + name: float(loss.loss.detach().cpu().numpy()) - for name, loss in losses_dict.items() - } - accumulated_losses_dict += NumbersDict(losses_dict) - print("step %i, loss: %f, took: %.3fs" % ( - step_idx, total_loss.detach().cpu().numpy(), time.time() - step_time_start - ), file=log.v4) - - step_idx += 1 - - print("Trained %i steps" % step_idx) - - accumulated_losses_dict = accumulated_losses_dict / step_idx - self.learning_rate_control.set_epoch_error(self.epoch, dict(accumulated_losses_dict)) - self.learning_rate_control.save() - - if self.epoch % self._save_model_epoch_interval == 0 or self.epoch == self._final_epoch: - self._save_model() - self._save_optimizer() - - self.eval_model() - -class Model(torch.nn.Module): - - def __init__(self): - super().__init__() - lstm_size = 1024 - target_size=12001 - self.blstm1 = nn.LSTM(input_size=50, hidden_size=lstm_size, bidirectional=True, batch_first=False) - self.blstm_stack = nn.LSTM(input_size=2*lstm_size, hidden_size=lstm_size, bidirectional=True, num_layers=7, batch_first=False) - self.final_linear = nn.Linear(2*lstm_size, target_size) - self.lstm_size = lstm_size - - def forward( - self, - audio_features: torch.Tensor, - audio_features_len: torch.Tensor, - ): - if self.training: - audio_features_time_masked = mask_along_axis(audio_features, mask_param=20, mask_value=0.0, axis=1) - audio_features_time_masked_2 = mask_along_axis(audio_features_time_masked, mask_param=20, mask_value=0.0, axis=1) - audio_features_masked = mask_along_axis(audio_features_time_masked_2, mask_param=10, mask_value=0.0, axis=2) - audio_features_masked_2 = mask_along_axis(audio_features_masked, mask_param=10, mask_value=0.0, axis=2) - else: - audio_features_masked_2 = audio_features - blstm_in = torch.swapaxes(audio_features_masked_2, 0, 1) # [B, T, F] -> [T, B, F] - - blstm_packed_in = nn.utils.rnn.pack_padded_sequence(blstm_in, audio_features_len) - blstm_first, _ = self.blstm1(blstm_packed_in) - blstm_packed_out, _ = self.blstm_stack(blstm_first) - blstm_out, _ = nn.utils.rnn.pad_packed_sequence(blstm_packed_out, padding_value=0.0, batch_first=False) # [T, B, F] - - logits = self.final_linear(blstm_out) # [T, B, F] - logits_rasr_order = torch.permute(logits, dims=(1, 0, 2)) # RASR expects [B, T, F] - logits_ce_order = torch.permute(logits, dims=(1, 2, 0)) # CE expects [B, F, T] - log_probs = torch.log_softmax(logits_rasr_order, dim=2) - - return log_probs, logits_ce_order - - -scripted_model = None - -def train_step(*, model: Model, data, run_ctx, **_kwargs): - global scripted_model - audio_features = data["data"] - audio_features_len = data["data:seq_len"] - - audio_features_len, indices = torch.sort(audio_features_len, descending=True) - audio_features = audio_features[indices, :, :] - - phonemes = data["classes"][indices, :] - phonemes_len = data["classes:seq_len"][indices] - - if scripted_model is None: - scripted_model = torch.jit.script(model) - - # distributed_model = DataParallel(model) - log_probs, logits = model( - audio_features=audio_features, - audio_features_len=audio_features_len, - ) - - targets_packed = nn.utils.rnn.pack_padded_sequence(phonemes, phonemes_len, batch_first=True, enforce_sorted=False) - targets_masked, _ = nn.utils.rnn.pad_packed_sequence(targets_packed, batch_first=True, padding_value=-100) - - loss = nn.functional.cross_entropy(logits, targets_masked) - - run_ctx.mark_as_loss(name="CE", loss=loss) - - -def export(*, model: Model, model_filename: str): - scripted_model = torch.jit.optimize_for_inference(torch.jit.script(model.eval())) - dummy_data = torch.randn(1, 30, 50, device="cpu") - dummy_data_len, _ = torch.sort(torch.randint(low=10, high=30, size=(1,), device="cpu", dtype=torch.int32), descending=True) - onnx_export( - scripted_model, - (dummy_data, dummy_data_len), - f=model_filename, - verbose=True, - input_names=["data", "data_len"], - output_names=["classes"], - dynamic_axes={ - # dict value: manually named axes - "data": {0: "batch", 1: "time"}, - "data_len": {0: "batch"}, - "classes": {0: "batch", 1: "time"} - } - ) - - -def export_trace(*, model: Model, model_filename: str): - dummy_data = torch.randn(1, 30, 50, device="cpu") - dummy_data_len, _ = torch.sort(torch.randint(low=10, high=30, size=(1,), device="cpu", dtype=torch.int32), descending=True) - scripted_model = torch.jit.optimize_for_inference(torch.jit.trace(model.eval(), example_inputs=(dummy_data, dummy_data_len))) - onnx_export( - scripted_model, - (dummy_data, dummy_data_len), - f=model_filename, - verbose=True, - input_names=["data", "data_len"], - output_names=["classes"], - dynamic_axes={ - # dict value: manually named axes - "data": {0: "batch", 1: "time"}, - "data_len": {0: "batch"}, - "classes": {0: "batch", 1: "time"} - } - ) - - diff --git a/users/rilling/experiments/librispeech/librispeech_100_hybrid/pytorch_networks/espnet_conformer_large.py b/users/rilling/experiments/librispeech/librispeech_100_hybrid/pytorch_networks/espnet_conformer_large.py deleted file mode 100644 index 44188e011..000000000 --- a/users/rilling/experiments/librispeech/librispeech_100_hybrid/pytorch_networks/espnet_conformer_large.py +++ /dev/null @@ -1,121 +0,0 @@ -import os -from random import random -import torch -import time -from typing import Dict, Optional -from torch import nn -from torch.onnx import export as onnx_export -from torchaudio.functional import mask_along_axis - -from returnn.torch.engine import Engine as TorchEngine -from returnn.util import NumbersDict -from returnn.log import log -from returnn.torch.context import get_run_ctx - -from espnet.nets.pytorch_backend.e2e_asr_conformer import Encoder - - -def lengths_to_mask(lengths, max_len): - return torch.arange(max_len).expand(lengths.size()[0], max_len) < lengths.unsqueeze(1) - - -class Model(torch.nn.Module): - - def __init__(self): - super().__init__() - target_size=12001 - attention_dim = 512 - self.espnet_conformer = Encoder(idim=50, num_blocks=12, attention_dim=attention_dim, attention_heads=8, input_layer="linear") - self.final_linear = nn.Linear(attention_dim, target_size) - - def forward( - self, - audio_features: torch.Tensor, # [B T D] - audio_features_len: torch.Tensor, # [B] - ): - - if self.training: - audio_features_time_masked = mask_along_axis(audio_features, mask_param=20, mask_value=0.0, axis=1) - audio_features_time_masked_2 = mask_along_axis(audio_features_time_masked, mask_param=20, mask_value=0.0, axis=1) - audio_features_masked = mask_along_axis(audio_features_time_masked_2, mask_param=10, mask_value=0.0, axis=2) - audio_features_masked_2 = mask_along_axis(audio_features_masked, mask_param=10, mask_value=0.0, axis=2) - else: - audio_features_masked_2 = audio_features - - run_ctx = get_run_ctx() - mask = lengths_to_mask(audio_features_len, max_len=audio_features.size()[1]) - mask = torch.unsqueeze(mask, dim=1).to(run_ctx.device) - - - conformer_out, mask = self.espnet_conformer(audio_features_masked_2, mask) - - logits = self.final_linear(conformer_out) # [B, T, F] - logits_ce_order = torch.permute(logits, dims=(0, 2, 1)) # CE expects [B, F, T] - log_probs = torch.log_softmax(logits, dim=2) - - return log_probs, logits_ce_order - - -scripted_model = None - -def train_step(*, model: Model, data, run_ctx, **_kwargs): - global scripted_model - audio_features = data["data"] - audio_features_len = data["data:seq_len"] - - audio_features_len, indices = torch.sort(audio_features_len, descending=True) - audio_features = audio_features[indices, :, :] - - phonemes = data["classes"][indices, :] - phonemes_len = data["classes:seq_len"][indices] - - #if scripted_model is None: - # # check exportability - # tmp_filename = "/var/tmp/onnx_export/export.onnx" - # os.makedirs(os.path.dirname(tmp_filename), exist_ok=True) - # scripted_model = export(model=model, model_filename=tmp_filename) - # os.unlink(tmp_filename) - - # distributed_model = DataParallel(model) - log_probs, logits = model( - audio_features=audio_features, - audio_features_len=audio_features_len, - ) - - targets_packed = nn.utils.rnn.pack_padded_sequence(phonemes, phonemes_len, batch_first=True, enforce_sorted=False) - targets_masked, _ = nn.utils.rnn.pad_packed_sequence(targets_packed, batch_first=True, padding_value=-100) - - loss = nn.functional.cross_entropy(logits, targets_masked) - - run_ctx.mark_as_loss(name="ce", loss=loss) - - -def export(*, model: Model, model_filename: str): - from returnn.torch import context - context._run_ctx = context.RunCtx(stage="forward_step", device="cpu") - dummy_data = torch.randn(1, 30, 50, device="cpu") * 10 - #dummy_data_len, _ = torch.sort(torch.randint(low=10, high=30, size=(1,), device="cpu", dtype=torch.int32), descending=True) - dummy_data_len = torch.ones((1,)) * 25 - dummy_data_len2 = torch.ones((1,)) * 25 - scripted_model = torch.jit.optimize_for_inference(torch.jit.trace(model.eval(), example_inputs=(dummy_data, dummy_data_len))) - l1 = scripted_model(dummy_data, dummy_data_len) - l2 = scripted_model(dummy_data, dummy_data_len2) - print(l1) - print(l2) - assert False - onnx_export( - scripted_model, - (dummy_data, dummy_data_len), - f=model_filename, - verbose=True, - input_names=["data", "data_len"], - output_names=["classes"], - dynamic_axes={ - # dict value: manually named axes - "data": {0: "batch", 1: "time"}, - "data_len": {0: "batch"}, - "classes": {0: "batch", 1: "time"} - } - ) - return scripted_model - diff --git a/users/rilling/experiments/librispeech/librispeech_100_hybrid/pytorch_networks/espnet_conformer_test.py b/users/rilling/experiments/librispeech/librispeech_100_hybrid/pytorch_networks/espnet_conformer_test.py deleted file mode 100644 index db32f29f4..000000000 --- a/users/rilling/experiments/librispeech/librispeech_100_hybrid/pytorch_networks/espnet_conformer_test.py +++ /dev/null @@ -1,124 +0,0 @@ -import os -from random import random -import torch -import time -from typing import Dict, Optional -from torch import nn -from torch.onnx import export as onnx_export -from torchaudio.functional import mask_along_axis - -from returnn.torch.engine import Engine as TorchEngine -from returnn.util import NumbersDict -from returnn.log import log -from returnn.torch.context import get_run_ctx - -from espnet.nets.pytorch_backend.e2e_asr_conformer import Encoder - - -def lengths_to_mask(lengths, max_len): - return torch.arange(max_len).expand(lengths.size()[0], max_len) < lengths.unsqueeze(1) - - -class Model(torch.nn.Module): - - def __init__(self): - super().__init__() - target_size=12001 - attention_dim = 256 - self.espnet_conformer = Encoder(idim=50, attention_dim=attention_dim, input_layer="linear") - self.final_linear = nn.Linear(attention_dim, target_size) - - def forward( - self, - audio_features: torch.Tensor, # [B T D] - audio_features_len: torch.Tensor, # [B] - ): - - if self.training: - audio_features_time_masked = mask_along_axis(audio_features, mask_param=20, mask_value=0.0, axis=1) - audio_features_time_masked_2 = mask_along_axis(audio_features_time_masked, mask_param=20, mask_value=0.0, axis=1) - audio_features_masked = mask_along_axis(audio_features_time_masked_2, mask_param=10, mask_value=0.0, axis=2) - audio_features_masked_2 = mask_along_axis(audio_features_masked, mask_param=10, mask_value=0.0, axis=2) - else: - audio_features_masked_2 = audio_features - - run_ctx = get_run_ctx() - mask = lengths_to_mask(audio_features_len, max_len=audio_features.size()[1]) - mask = torch.unsqueeze(mask, dim=1).to(run_ctx.device) - - conformer_out, mask = self.espnet_conformer(audio_features_masked_2, mask) - - logits = self.final_linear(conformer_out) # [B, T, F] - logits_ce_order = torch.permute(logits, dims=(0, 2, 1)) # CE expects [B, F, T] - log_probs = torch.log_softmax(logits, dim=2) - - return log_probs, logits_ce_order - - -scripted_model = None - -def train_step(*, model: Model, data, run_ctx, **_kwargs): - global scripted_model - audio_features = data["data"] - audio_features_len = data["data:seq_len"] - - audio_features_len, indices = torch.sort(audio_features_len, descending=True) - audio_features = audio_features[indices, :, :] - - phonemes = data["classes"][indices, :] - phonemes_len = data["classes:seq_len"][indices] - - #if scripted_model is None: - # # check exportability - # tmp_filename = "/var/tmp/onnx_export/export.onnx" - # os.makedirs(os.path.dirname(tmp_filename), exist_ok=True) - # scripted_model = export(model=model, model_filename=tmp_filename) - # os.unlink(tmp_filename) - - # distributed_model = DataParallel(model) - log_probs, logits = model( - audio_features=audio_features, - audio_features_len=audio_features_len, - ) - - targets_packed = nn.utils.rnn.pack_padded_sequence(phonemes, phonemes_len, batch_first=True, enforce_sorted=False) - targets_masked, _ = nn.utils.rnn.pad_packed_sequence(targets_packed, batch_first=True, padding_value=-100) - - loss = nn.functional.cross_entropy(logits, targets_masked) - - run_ctx.mark_as_loss(name="ce", loss=loss) - - -def export(*, model: Model, model_filename: str): - # create new run context - from returnn.torch import context - context._run_ctx = context.RunCtx(stage="forward_step", device="cpu") - model.eval() - dummy_data = torch.randn(1, 30, 50, device="cpu") - dummy_data2 = torch.randn(1, 50, 50, device="cpu") - #dummy_data_len, _ = torch.sort(torch.randint(low=29, high=30, size=(1,), device="cpu", dtype=torch.int32), descending=True) - dummy_data_len = torch.ones((1,), device="cpu", dtype=torch.int32)*30 - dummy_data2_len = torch.ones((1,), device="cpu", dtype=torch.int32)*40 - log_probs, logits = model(dummy_data2, dummy_data2_len) - scripted_model = torch.jit.optimize_for_inference(torch.jit.trace(model.eval(), example_inputs=(dummy_data, dummy_data_len))) - s_log_probs, s_logits = scripted_model(dummy_data2, dummy_data2_len) - print(log_probs) - print(s_log_probs) - assert False - #scripted_model = torch.jit.optimize_for_inference(torch.jit.script(model.eval())) - onnx_export( - scripted_model, - (dummy_data, dummy_data_len), - f=model_filename, - verbose=True, - input_names=["data", "data_len"], - output_names=["classes"], - dynamic_axes={ - # dict value: manually named axes - "data": {0: "batch", 1: "time"}, - "data_len": {0: "batch"}, - "classes": {0: "batch", 1: "time"} - } - ) - return scripted_model - diff --git a/users/rilling/experiments/librispeech/librispeech_100_hybrid/pytorch_networks/mlp_test.py b/users/rilling/experiments/librispeech/librispeech_100_hybrid/pytorch_networks/mlp_test.py deleted file mode 100644 index 07a3e2bae..000000000 --- a/users/rilling/experiments/librispeech/librispeech_100_hybrid/pytorch_networks/mlp_test.py +++ /dev/null @@ -1,31 +0,0 @@ -import torch -from torch import nn -from torch.onnx import export - -class Model(torch.nn.Module): - def __init__(self): - super().__init__() - self.linear_relu_stack = nn.Sequential( - nn.Linear(50, 512), - nn.ReLU(), - nn.Linear(512, 512), - nn.ReLU(), - nn.Linear(512, 12001), - ) - - def forward(self, x): - y = self.linear_relu_stack(x) - return y - - -def train_step(*, model: Model, data, train_ctx, **_kwargs): - frames = data["data"] - scripted_model = torch.jit.script(model) - dummy_input = torch.randn(10, 3, 50, device="cuda") - export(scripted_model, dummy_input, "model.onnx", verbose=True, input_names=["features"], output_names=["output"]) - assert False - outputs = scripted_model(frames) - print(scripted_model.graph) - targets = data["classes"] - loss = nn.CrossEntropyLoss(reduction="sum")(torch.swapaxes(outputs, 1, 2), targets) - train_ctx.mark_as_loss(name="ce", loss=loss) diff --git a/users/rilling/experiments/librispeech/librispeech_100_hybrid/pytorch_networks/torchaudio_conformer.py b/users/rilling/experiments/librispeech/librispeech_100_hybrid/pytorch_networks/torchaudio_conformer.py deleted file mode 100644 index 4e9ea9828..000000000 --- a/users/rilling/experiments/librispeech/librispeech_100_hybrid/pytorch_networks/torchaudio_conformer.py +++ /dev/null @@ -1,423 +0,0 @@ -import time -import torch -from torch import nn -from torch.onnx import export as onnx_export -from torchaudio.functional import mask_along_axis -from torchaudio.models.conformer import Conformer - - - -from typing import Optional, Tuple - -import torch - - -__all__ = ["Conformer"] - - -def _lengths_to_padding_mask(lengths: torch.Tensor) -> torch.Tensor: - batch_size = lengths.shape[0] - max_length = int(torch.max(lengths).item()) - padding_mask = torch.arange(max_length, device=lengths.device, dtype=lengths.dtype).expand( - batch_size, max_length - ) >= lengths.unsqueeze(1) - return padding_mask - - -class _ConvolutionModule(torch.nn.Module): - r"""Conformer convolution module. - - Args: - input_dim (int): input dimension. - num_channels (int): number of depthwise convolution layer input channels. - depthwise_kernel_size (int): kernel size of depthwise convolution layer. - dropout (float, optional): dropout probability. (Default: 0.0) - bias (bool, optional): indicates whether to add bias term to each convolution layer. (Default: ``False``) - use_group_norm (bool, optional): use GroupNorm rather than BatchNorm. (Default: ``False``) - """ - - def __init__( - self, - input_dim: int, - num_channels: int, - depthwise_kernel_size: int, - dropout: float = 0.0, - bias: bool = False, - use_group_norm: bool = False, - ) -> None: - super().__init__() - if (depthwise_kernel_size - 1) % 2 != 0: - raise ValueError("depthwise_kernel_size must be odd to achieve 'SAME' padding.") - self.layer_norm = torch.nn.LayerNorm(input_dim) - self.sequential = torch.nn.Sequential( - torch.nn.Conv1d( - input_dim, - 2 * num_channels, - 1, - stride=1, - padding=0, - bias=bias, - ), - torch.nn.GLU(dim=1), - torch.nn.Conv1d( - num_channels, - num_channels, - depthwise_kernel_size, - stride=1, - padding=(depthwise_kernel_size - 1) // 2, - groups=num_channels, - bias=bias, - ), - torch.nn.GroupNorm(num_groups=1, num_channels=num_channels) - if use_group_norm - else torch.nn.BatchNorm1d(num_channels), - torch.nn.SiLU(), - torch.nn.Conv1d( - num_channels, - input_dim, - kernel_size=1, - stride=1, - padding=0, - bias=bias, - ), - torch.nn.Dropout(dropout), - ) - - def forward(self, input: torch.Tensor) -> torch.Tensor: - r""" - Args: - input (torch.Tensor): with shape `(B, T, D)`. - - Returns: - torch.Tensor: output, with shape `(B, T, D)`. - """ - x = self.layer_norm(input) - x = x.transpose(1, 2) - x = self.sequential(x) - return x.transpose(1, 2) - - -class _FeedForwardModule(torch.nn.Module): - r"""Positionwise feed forward layer. - - Args: - input_dim (int): input dimension. - hidden_dim (int): hidden dimension. - dropout (float, optional): dropout probability. (Default: 0.0) - """ - - def __init__(self, input_dim: int, hidden_dim: int, dropout: float = 0.0) -> None: - super().__init__() - self.sequential = torch.nn.Sequential( - torch.nn.LayerNorm(input_dim), - torch.nn.Linear(input_dim, hidden_dim, bias=True), - torch.nn.SiLU(), - torch.nn.Dropout(dropout), - torch.nn.Linear(hidden_dim, input_dim, bias=True), - torch.nn.Dropout(dropout), - ) - - def forward(self, input: torch.Tensor) -> torch.Tensor: - r""" - Args: - input (torch.Tensor): with shape `(*, D)`. - - Returns: - torch.Tensor: output, with shape `(*, D)`. - """ - return self.sequential(input) - - -class ConformerLayer(torch.nn.Module): - r"""Conformer layer that constitutes Conformer. - - Args: - input_dim (int): input dimension. - ffn_dim (int): hidden layer dimension of feedforward network. - num_attention_heads (int): number of attention heads. - depthwise_conv_kernel_size (int): kernel size of depthwise convolution layer. - dropout (float, optional): dropout probability. (Default: 0.0) - use_group_norm (bool, optional): use ``GroupNorm`` rather than ``BatchNorm1d`` - in the convolution module. (Default: ``False``) - convolution_first (bool, optional): apply the convolution module ahead of - the attention module. (Default: ``False``) - """ - - def __init__( - self, - input_dim: int, - ffn_dim: int, - num_attention_heads: int, - depthwise_conv_kernel_size: int, - dropout: float = 0.0, - use_group_norm: bool = False, - convolution_first: bool = False, - ) -> None: - super().__init__() - - self.ffn1 = _FeedForwardModule(input_dim, ffn_dim, dropout=dropout) - - self.self_attn_layer_norm = torch.nn.LayerNorm(input_dim) - self.self_attn = torch.nn.MultiheadAttention(input_dim, num_attention_heads, dropout=dropout) - self.self_attn_dropout = torch.nn.Dropout(dropout) - - self.conv_module = _ConvolutionModule( - input_dim=input_dim, - num_channels=input_dim, - depthwise_kernel_size=depthwise_conv_kernel_size, - dropout=dropout, - bias=True, - use_group_norm=use_group_norm, - ) - - self.ffn2 = _FeedForwardModule(input_dim, ffn_dim, dropout=dropout) - self.final_layer_norm = torch.nn.LayerNorm(input_dim) - self.convolution_first = convolution_first - - def _apply_convolution(self, input: torch.Tensor) -> torch.Tensor: - residual = input - input = input.transpose(0, 1) - input = self.conv_module(input) - input = input.transpose(0, 1) - input = residual + input - return input - - def forward(self, input: torch.Tensor, key_padding_mask: Optional[torch.Tensor]) -> torch.Tensor: - r""" - Args: - input (torch.Tensor): input, with shape `(T, B, D)`. - key_padding_mask (torch.Tensor or None): key padding mask to use in self attention layer. - - Returns: - torch.Tensor: output, with shape `(T, B, D)`. - """ - residual = input - x = self.ffn1(input) - x = x * 0.5 + residual - - if self.convolution_first: - x = self._apply_convolution(x) - - residual = x - x = self.self_attn_layer_norm(x) - x, _ = self.self_attn( - query=x, - key=x, - value=x, - key_padding_mask=key_padding_mask, - need_weights=False, - ) - x = self.self_attn_dropout(x) - x = x + residual - - if not self.convolution_first: - x = self._apply_convolution(x) - - residual = x - x = self.ffn2(x) - x = x * 0.5 + residual - - x = self.final_layer_norm(x) - return x - - -class Conformer(torch.nn.Module): - r"""Conformer architecture introduced in - *Conformer: Convolution-augmented Transformer for Speech Recognition* - :cite:`gulati2020conformer`. - - Args: - input_dim (int): input dimension. - num_heads (int): number of attention heads in each Conformer layer. - ffn_dim (int): hidden layer dimension of feedforward networks. - num_layers (int): number of Conformer layers to instantiate. - depthwise_conv_kernel_size (int): kernel size of each Conformer layer's depthwise convolution layer. - dropout (float, optional): dropout probability. (Default: 0.0) - use_group_norm (bool, optional): use ``GroupNorm`` rather than ``BatchNorm1d`` - in the convolution module. (Default: ``False``) - convolution_first (bool, optional): apply the convolution module ahead of - the attention module. (Default: ``False``) - - Examples: - >>> conformer = Conformer( - >>> input_dim=80, - >>> num_heads=4, - >>> ffn_dim=128, - >>> num_layers=4, - >>> depthwise_conv_kernel_size=31, - >>> ) - >>> lengths = torch.randint(1, 400, (10,)) # (batch,) - >>> input = torch.rand(10, int(lengths.max()), input_dim) # (batch, num_frames, input_dim) - >>> output = conformer(input, lengths) - """ - - def __init__( - self, - input_dim: int, - num_heads: int, - ffn_dim: int, - num_layers: int, - depthwise_conv_kernel_size: int, - dropout: float = 0.0, - use_group_norm: bool = False, - convolution_first: bool = False, - ): - super().__init__() - - self.conformer_layers = torch.nn.ModuleList( - [ - ConformerLayer( - input_dim, - ffn_dim, - num_heads, - depthwise_conv_kernel_size, - dropout=dropout, - use_group_norm=use_group_norm, - convolution_first=convolution_first, - ) - for _ in range(num_layers) - ] - ) - self.export_mode = False - - def forward(self, input: torch.Tensor, lengths: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]: - r""" - Args: - input (torch.Tensor): with shape `(B, T, input_dim)`. - lengths (torch.Tensor): with shape `(B,)` and i-th element representing - number of valid frames for i-th batch element in ``input``. - - Returns: - (torch.Tensor, torch.Tensor) - torch.Tensor - output frames, with shape `(B, T, input_dim)` - torch.Tensor - output lengths, with shape `(B,)` and i-th element representing - number of valid frames for i-th batch element in output frames. - """ - encoder_padding_mask = None if self.export_mode else _lengths_to_padding_mask(lengths) - - x = input.transpose(0, 1) - for layer in self.conformer_layers: - x = layer(x, encoder_padding_mask) - return x.transpose(0, 1), lengths - -class Model(torch.nn.Module): - - def __init__(self, **kwargs): - super().__init__() - conformer_size = 384 - target_size=12001 - self.initial_linear = nn.Linear(50, conformer_size) - self.conformer = Conformer( - input_dim=conformer_size, - num_heads=4, - ffn_dim=1024, - num_layers=8, - depthwise_conv_kernel_size=31, - dropout=0.1 - ) - self.final_linear = nn.Linear(conformer_size, target_size) - - def forward( - self, - audio_features: torch.Tensor, - audio_features_len: torch.Tensor, - ): - if self.training: - audio_features_time_masked = mask_along_axis(audio_features, mask_param=20, mask_value=0.0, axis=1) - audio_features_time_masked_2 = mask_along_axis(audio_features_time_masked, mask_param=20, mask_value=0.0, axis=1) - audio_features_masked = mask_along_axis(audio_features_time_masked_2, mask_param=10, mask_value=0.0, axis=2) - audio_features_masked_2 = mask_along_axis(audio_features_masked, mask_param=10, mask_value=0.0, axis=2) - else: - audio_features_masked_2 = audio_features - - - conformer_in = self.initial_linear(audio_features_masked_2) - - conformer_out, _ = self.conformer(conformer_in, audio_features_len) - - logits = self.final_linear(conformer_out) # [B, T, F] - logits_ce_order = torch.permute(logits, dims=(0, 2, 1)) # CE expects [B, F, T] - log_probs = torch.log_softmax(logits, dim=2) - - return log_probs, logits_ce_order - - -scripted_model = None - -def train_step(*, model: Model, data, run_ctx, **_kwargs): - global scripted_model - audio_features = data["data"] - audio_features_len = data["data:size1"] - - audio_features_len, indices = torch.sort(audio_features_len, descending=True) - audio_features = audio_features[indices, :, :] - - phonemes = data["classes"][indices, :] - phonemes_len = data["classes:size1"][indices] - - #if scripted_model is None: - # model.to("cpu") - # export_trace(model=model, model_filename="testdump.onnx") - # model.to("cuda") - # model.train() - - # distributed_model = DataParallel(model) - log_probs, logits = model( - audio_features=audio_features, - audio_features_len=audio_features_len, - ) - - targets_packed = nn.utils.rnn.pack_padded_sequence(phonemes, phonemes_len.to("cpu"), batch_first=True, enforce_sorted=False) - targets_masked, _ = nn.utils.rnn.pad_packed_sequence(targets_packed, batch_first=True, padding_value=-100) - - loss = nn.functional.cross_entropy(logits, targets_masked, reduction="sum") - - num_frames = torch.sum(phonemes_len) - - run_ctx.mark_as_loss(name="CE", loss=loss, inv_norm_factor=num_frames) - - -# def export(*, model: Model, model_filename: str): -# scripted_model = torch.jit.optimize_for_inference(torch.jit.script(model.eval())) -# dummy_data = torch.randn(1, 30, 50, device="cpu") -# dummy_data_len, _ = torch.sort(torch.randint(low=10, high=30, size=(1,), device="cpu", dtype=torch.int32), descending=True) -# onnx_export( -# scripted_model, -# (dummy_data, dummy_data_len), -# f=model_filename, -# verbose=True, -# input_names=["data", "data_len"], -# output_names=["classes"], -# dynamic_axes={ -# # dict value: manually named axes -# "data": {0: "batch", 1: "time"}, -# "data_len": {0: "batch"}, -# "classes": {0: "batch", 1: "time"} -# } -# ) -# - -def export(*, model: Model, model_filename: str): - model.conformer.export_mode = True - dummy_data = torch.randn(1, 30, 50, device="cpu") - # dummy_data_len, _ = torch.sort(torch.randint(low=10, high=30, size=(1,), device="cpu", dtype=torch.int32), descending=True) - dummy_data_len = torch.ones((1,))*30 - scripted_model = torch.jit.optimize_for_inference(torch.jit.trace(model.eval(), example_inputs=(dummy_data, dummy_data_len))) - onnx_export( - scripted_model, - (dummy_data, dummy_data_len), - f=model_filename, - verbose=True, - input_names=["data", "data_len"], - output_names=["classes"], - dynamic_axes={ - # dict value: manually named axes - "data": {0: "batch", 1: "time"}, - "data_len": {0: "batch"}, - "classes": {0: "batch", 1: "time"} - } - ) - - diff --git a/users/rilling/experiments/librispeech/librispeech_100_hybrid/pytorch_networks/torchaudio_conformer_debug.py b/users/rilling/experiments/librispeech/librispeech_100_hybrid/pytorch_networks/torchaudio_conformer_debug.py deleted file mode 100644 index 0282fa789..000000000 --- a/users/rilling/experiments/librispeech/librispeech_100_hybrid/pytorch_networks/torchaudio_conformer_debug.py +++ /dev/null @@ -1,425 +0,0 @@ -import time -import torch -from torch import nn -from torch.onnx import export as onnx_export -from torchaudio.functional import mask_along_axis -from torchaudio.models.conformer import Conformer - - - -from typing import Optional, Tuple - -import torch - - -__all__ = ["Conformer"] - - -def lengths_to_mask(lengths, max_len: int): - return torch.arange(max_len).expand(lengths.size()[0], max_len) < lengths.unsqueeze(1) - - -class _ConvolutionModule(torch.nn.Module): - r"""Conformer convolution module. - - Args: - input_dim (int): input dimension. - num_channels (int): number of depthwise convolution layer input channels. - depthwise_kernel_size (int): kernel size of depthwise convolution layer. - dropout (float, optional): dropout probability. (Default: 0.0) - bias (bool, optional): indicates whether to add bias term to each convolution layer. (Default: ``False``) - use_group_norm (bool, optional): use GroupNorm rather than BatchNorm. (Default: ``False``) - """ - - def __init__( - self, - input_dim: int, - num_channels: int, - depthwise_kernel_size: int, - dropout: float = 0.0, - bias: bool = False, - use_group_norm: bool = False, - ) -> None: - super().__init__() - if (depthwise_kernel_size - 1) % 2 != 0: - raise ValueError("depthwise_kernel_size must be odd to achieve 'SAME' padding.") - self.layer_norm = torch.nn.LayerNorm(input_dim) - self.sequential = torch.nn.Sequential( - torch.nn.Conv1d( - input_dim, - 2 * num_channels, - 1, - stride=1, - padding=0, - bias=bias, - ), - torch.nn.GLU(dim=1), - torch.nn.Conv1d( - num_channels, - num_channels, - depthwise_kernel_size, - stride=1, - padding=(depthwise_kernel_size - 1) // 2, - groups=num_channels, - bias=bias, - ), - torch.nn.GroupNorm(num_groups=1, num_channels=num_channels) - if use_group_norm - else torch.nn.BatchNorm1d(num_channels), - torch.nn.SiLU(), - torch.nn.Conv1d( - num_channels, - input_dim, - kernel_size=1, - stride=1, - padding=0, - bias=bias, - ), - torch.nn.Dropout(dropout), - ) - - def forward(self, input: torch.Tensor) -> torch.Tensor: - r""" - Args: - input (torch.Tensor): with shape `(B, T, D)`. - - Returns: - torch.Tensor: output, with shape `(B, T, D)`. - """ - x = self.layer_norm(input) - x = x.transpose(1, 2) - x = self.sequential(x) - return x.transpose(1, 2) - - -class _FeedForwardModule(torch.nn.Module): - r"""Positionwise feed forward layer. - - Args: - input_dim (int): input dimension. - hidden_dim (int): hidden dimension. - dropout (float, optional): dropout probability. (Default: 0.0) - """ - - def __init__(self, input_dim: int, hidden_dim: int, dropout: float = 0.0) -> None: - super().__init__() - self.sequential = torch.nn.Sequential( - torch.nn.LayerNorm(input_dim), - torch.nn.Linear(input_dim, hidden_dim, bias=True), - torch.nn.SiLU(), - torch.nn.Dropout(dropout), - torch.nn.Linear(hidden_dim, input_dim, bias=True), - torch.nn.Dropout(dropout), - ) - - def forward(self, input: torch.Tensor) -> torch.Tensor: - r""" - Args: - input (torch.Tensor): with shape `(*, D)`. - - Returns: - torch.Tensor: output, with shape `(*, D)`. - """ - return self.sequential(input) - - -class ConformerLayer(torch.nn.Module): - r"""Conformer layer that constitutes Conformer. - - Args: - input_dim (int): input dimension. - ffn_dim (int): hidden layer dimension of feedforward network. - num_attention_heads (int): number of attention heads. - depthwise_conv_kernel_size (int): kernel size of depthwise convolution layer. - dropout (float, optional): dropout probability. (Default: 0.0) - use_group_norm (bool, optional): use ``GroupNorm`` rather than ``BatchNorm1d`` - in the convolution module. (Default: ``False``) - convolution_first (bool, optional): apply the convolution module ahead of - the attention module. (Default: ``False``) - """ - - def __init__( - self, - input_dim: int, - ffn_dim: int, - num_attention_heads: int, - depthwise_conv_kernel_size: int, - dropout: float = 0.0, - use_group_norm: bool = False, - convolution_first: bool = False, - ) -> None: - super().__init__() - - self.ffn1 = _FeedForwardModule(input_dim, ffn_dim, dropout=dropout) - - self.self_attn_layer_norm = torch.nn.LayerNorm(input_dim) - self.self_attn = torch.nn.MultiheadAttention(input_dim, num_attention_heads, dropout=dropout) - self.self_attn_dropout = torch.nn.Dropout(dropout) - - self.conv_module = _ConvolutionModule( - input_dim=input_dim, - num_channels=input_dim, - depthwise_kernel_size=depthwise_conv_kernel_size, - dropout=dropout, - bias=True, - use_group_norm=use_group_norm, - ) - - self.ffn2 = _FeedForwardModule(input_dim, ffn_dim, dropout=dropout) - self.final_layer_norm = torch.nn.LayerNorm(input_dim) - self.convolution_first = convolution_first - - def _apply_convolution(self, input: torch.Tensor) -> torch.Tensor: - residual = input - input = input.transpose(0, 1) - input = self.conv_module(input) - input = input.transpose(0, 1) - input = residual + input - return input - - def forward(self, input: torch.Tensor, key_padding_mask: Optional[torch.Tensor]) -> torch.Tensor: - r""" - Args: - input (torch.Tensor): input, with shape `(T, B, D)`. - key_padding_mask (torch.Tensor or None): key padding mask to use in self attention layer. - - Returns: - torch.Tensor: output, with shape `(T, B, D)`. - """ - residual = input - x = self.ffn1(input) - x = x * 0.5 + residual - - if self.convolution_first: - x = self._apply_convolution(x) - - residual = x - x = self.self_attn_layer_norm(x) - x, _ = self.self_attn( - query=x, - key=x, - value=x, - key_padding_mask=None, - need_weights=False, - ) - x = self.self_attn_dropout(x) - x = x + residual - - if not self.convolution_first: - x = self._apply_convolution(x) - - residual = x - x = self.ffn2(x) - x = x * 0.5 + residual - - x = self.final_layer_norm(x) - return x - - -class Conformer(torch.nn.Module): - r"""Conformer architecture introduced in - *Conformer: Convolution-augmented Transformer for Speech Recognition* - :cite:`gulati2020conformer`. - - Args: - input_dim (int): input dimension. - num_heads (int): number of attention heads in each Conformer layer. - ffn_dim (int): hidden layer dimension of feedforward networks. - num_layers (int): number of Conformer layers to instantiate. - depthwise_conv_kernel_size (int): kernel size of each Conformer layer's depthwise convolution layer. - dropout (float, optional): dropout probability. (Default: 0.0) - use_group_norm (bool, optional): use ``GroupNorm`` rather than ``BatchNorm1d`` - in the convolution module. (Default: ``False``) - convolution_first (bool, optional): apply the convolution module ahead of - the attention module. (Default: ``False``) - - Examples: - >>> conformer = Conformer( - >>> input_dim=80, - >>> num_heads=4, - >>> ffn_dim=128, - >>> num_layers=4, - >>> depthwise_conv_kernel_size=31, - >>> ) - >>> lengths = torch.randint(1, 400, (10,)) # (batch,) - >>> input = torch.rand(10, int(lengths.max()), input_dim) # (batch, num_frames, input_dim) - >>> output = conformer(input, lengths) - """ - - def __init__( - self, - input_dim: int, - num_heads: int, - ffn_dim: int, - num_layers: int, - depthwise_conv_kernel_size: int, - dropout: float = 0.0, - use_group_norm: bool = False, - convolution_first: bool = False, - ): - super().__init__() - - self.conformer_layers = torch.nn.ModuleList( - [ - ConformerLayer( - input_dim, - ffn_dim, - num_heads, - depthwise_conv_kernel_size, - dropout=dropout, - use_group_norm=use_group_norm, - convolution_first=convolution_first, - ) - for _ in range(num_layers) - ] - ) - - def forward(self, input: torch.Tensor, lengths: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]: - r""" - Args: - input (torch.Tensor): with shape `(B, T, input_dim)`. - lengths (torch.Tensor): with shape `(B,)` and i-th element representing - number of valid frames for i-th batch element in ``input``. - - Returns: - (torch.Tensor, torch.Tensor) - torch.Tensor - output frames, with shape `(B, T, input_dim)` - torch.Tensor - output lengths, with shape `(B,)` and i-th element representing - number of valid frames for i-th batch element in output frames. - """ - encoder_padding_mask = lengths_to_mask(lengths, input.size()[1]) - - x = input.transpose(0, 1) - for layer in self.conformer_layers: - x = layer(x, encoder_padding_mask) - return x.transpose(0, 1), lengths - -class Model_(torch.nn.Module): - - def __init__(self): - super().__init__() - conformer_size = 384 - target_size=12001 - self.initial_linear = nn.Linear(50, conformer_size) - #self.conformer = Conformer( - # input_dim=conformer_size, - # num_heads=4, - # ffn_dim=1024, - # num_layers=8, - # depthwise_conv_kernel_size=31, - # dropout=0.1 - #) - self.self_attn = torch.nn.MultiheadAttention(conformer_size, 4, dropout=0.1) - self.final_linear = nn.Linear(conformer_size, target_size) - - def forward( - self, - audio_features: torch.Tensor, - audio_features_len: torch.Tensor, - ): - if self.training: - audio_features_time_masked = mask_along_axis(audio_features, mask_param=20, mask_value=0.0, axis=1) - audio_features_time_masked_2 = mask_along_axis(audio_features_time_masked, mask_param=20, mask_value=0.0, axis=1) - audio_features_masked = mask_along_axis(audio_features_time_masked_2, mask_param=10, mask_value=0.0, axis=2) - audio_features_masked_2 = mask_along_axis(audio_features_masked, mask_param=10, mask_value=0.0, axis=2) - else: - audio_features_masked_2 = audio_features - - - conformer_in = self.initial_linear(audio_features_masked_2) - - conformer_out, _ = self.self_attn(query=conformer_in, key=conformer_in, value=conformer_in) - - logits = self.final_linear(conformer_out) # [B, T, F] - logits_ce_order = torch.permute(logits, dims=(0, 2, 1)) # CE expects [B, F, T] - log_probs = torch.log_softmax(logits, dim=2) - - return log_probs, logits_ce_order - - -class Model(torch.nn.Module): - - def __init__(self): - super().__init__() - self.self_attn = torch.nn.MultiheadAttention(50, 5, dropout=0.1) - - def forward( - self, - input: torch.Tensor, - ): - conformer_out, _ = self.self_attn(query=input, key=input, value=input) - - return conformer_out - - -scripted_model = None - -def train_step(*, model: Model, data, run_ctx, **_kwargs): - global scripted_model - audio_features = data["data"] - audio_features_len = data["data:seq_len"] - - audio_features_len, indices = torch.sort(audio_features_len, descending=True) - audio_features = audio_features[indices, :, :] - - phonemes = data["classes"][indices, :] - phonemes_len = data["classes:seq_len"][indices] - - if scripted_model is None: - scripted_model = torch.jit.script(model) - export(model=model, model_filename="testdump.onnx") - - # distributed_model = DataParallel(model) - log_probs, logits = model( - audio_features=audio_features, - audio_features_len=audio_features_len.to("cuda"), - ) - - targets_packed = nn.utils.rnn.pack_padded_sequence(phonemes, phonemes_len, batch_first=True, enforce_sorted=False) - targets_masked, _ = nn.utils.rnn.pad_packed_sequence(targets_packed, batch_first=True, padding_value=-100) - - loss = nn.functional.cross_entropy(logits, targets_masked) - - run_ctx.mark_as_loss(name="CE", loss=loss) - - -def export(*, model: Model, model_filename: str): - scripted_model = torch.jit.optimize_for_inference(torch.jit.script(model.eval())) - dummy_data = torch.randn(1, 30, 50, device="cpu") - dummy_data_len, _ = torch.sort(torch.randint(low=10, high=30, size=(1,), device="cpu", dtype=torch.int32), descending=True) - onnx_export( - scripted_model, - (dummy_data, dummy_data_len), - f=model_filename, - verbose=True, - input_names=["in"], - output_names=["out"], - dynamic_axes={ - # dict value: manually named axes - "in": {0: "batch", 1: "time"}, - "out": {0: "batch", 1: "time"} - } - ) - - -def export_trace(*, model: Model, model_filename: str): - dummy_data = torch.randn(1, 30, 50, device="cpu") - dummy_data_len, _ = torch.sort(torch.randint(low=10, high=30, size=(1,), device="cpu", dtype=torch.int32), descending=True) - scripted_model = torch.jit.optimize_for_inference(torch.jit.trace(model.eval(), example_inputs=(dummy_data,))) - onnx_export( - scripted_model, - (dummy_data,), - f=model_filename, - verbose=True, - input_names=["in"], - output_names=["out"], - dynamic_axes={ - # dict value: manually named axes - "in": {0: "batch", 1: "time"}, - "out": {0: "batch", 1: "time"} - } - ) - - diff --git a/users/rilling/experiments/librispeech/librispeech_100_hybrid/pytorch_networks/torchaudio_conformer_large_fp16.py b/users/rilling/experiments/librispeech/librispeech_100_hybrid/pytorch_networks/torchaudio_conformer_large_fp16.py deleted file mode 100644 index 678e4a4c2..000000000 --- a/users/rilling/experiments/librispeech/librispeech_100_hybrid/pytorch_networks/torchaudio_conformer_large_fp16.py +++ /dev/null @@ -1,476 +0,0 @@ -import time - -from typing import Optional, Tuple - -import torch -from torch import nn, autocast -from torch.onnx import export as onnx_export -from torch.cuda.amp import GradScaler -from torchaudio.functional import mask_along_axis - -from returnn.log import log -from returnn.torch.engine import Engine as TorchEngine -from returnn.util.basic import NumbersDict -from returnn.torch.context import get_run_ctx, init_train_step_run_ctx - - -class CustomEngine(TorchEngine): - - def train_epoch(self): - """ - train one (sub)epoch - """ - print("start", self.get_epoch_str(), "with learning rate", self.learning_rate, "...", file=log.v4) - - self._model.train() - init_train_step_run_ctx(device=self._device) - - # Creates a GradScaler once at the beginning of training. - scaler = GradScaler() - - accumulated_losses_dict = NumbersDict() - step_idx = 0 - for data in self._train_dataloader: - step_time_start = time.time() - run_ctx = get_run_ctx() - run_ctx.init_step() - - self._updater.get_optimizer().zero_grad() - with autocast(device_type='cuda', dtype=torch.bfloat16): - self._run_step(data) - - losses_dict = run_ctx.losses - total_loss = run_ctx.total_loss() - - scaler.scale(total_loss).backward() - scaler.step(self._updater.get_optimizer()) - scaler.update() - - losses_dict = { - "train_loss_" + name: float(loss.loss.detach().cpu().numpy()) - for name, loss in losses_dict.items() - } - accumulated_losses_dict += NumbersDict(losses_dict) - print("step %i, loss: %f, took: %.3fs" % ( - step_idx, total_loss.detach().cpu().numpy(), time.time() - step_time_start - ), file=log.v4) - - step_idx += 1 - - print("Trained %i steps" % step_idx) - - accumulated_losses_dict = accumulated_losses_dict / step_idx - self.learning_rate_control.set_epoch_error(self.epoch, dict(accumulated_losses_dict)) - self.learning_rate_control.save() - - if self.epoch % self._save_model_epoch_interval == 0 or self.epoch == self._final_epoch: - self._save_model() - self._save_optimizer() - - self.eval_model() - - -def _lengths_to_padding_mask(lengths: torch.Tensor) -> torch.Tensor: - batch_size = lengths.shape[0] - max_length = int(torch.max(lengths).item()) - padding_mask = torch.arange(max_length, device=lengths.device, dtype=lengths.dtype).expand( - batch_size, max_length - ) >= lengths.unsqueeze(1) - return padding_mask - - -class _ConvolutionModule(torch.nn.Module): - r"""Conformer convolution module. - - Args: - input_dim (int): input dimension. - num_channels (int): number of depthwise convolution layer input channels. - depthwise_kernel_size (int): kernel size of depthwise convolution layer. - dropout (float, optional): dropout probability. (Default: 0.0) - bias (bool, optional): indicates whether to add bias term to each convolution layer. (Default: ``False``) - use_group_norm (bool, optional): use GroupNorm rather than BatchNorm. (Default: ``False``) - """ - - def __init__( - self, - input_dim: int, - num_channels: int, - depthwise_kernel_size: int, - dropout: float = 0.0, - bias: bool = False, - use_group_norm: bool = False, - ) -> None: - super().__init__() - if (depthwise_kernel_size - 1) % 2 != 0: - raise ValueError("depthwise_kernel_size must be odd to achieve 'SAME' padding.") - self.layer_norm = torch.nn.LayerNorm(input_dim) - self.sequential = torch.nn.Sequential( - torch.nn.Conv1d( - input_dim, - 2 * num_channels, - 1, - stride=1, - padding=0, - bias=bias, - ), - torch.nn.GLU(dim=1), - torch.nn.Conv1d( - num_channels, - num_channels, - depthwise_kernel_size, - stride=1, - padding=(depthwise_kernel_size - 1) // 2, - groups=num_channels, - bias=bias, - ), - torch.nn.GroupNorm(num_groups=1, num_channels=num_channels) - if use_group_norm - else torch.nn.BatchNorm1d(num_channels), - torch.nn.SiLU(), - torch.nn.Conv1d( - num_channels, - input_dim, - kernel_size=1, - stride=1, - padding=0, - bias=bias, - ), - torch.nn.Dropout(dropout), - ) - - def forward(self, input: torch.Tensor) -> torch.Tensor: - r""" - Args: - input (torch.Tensor): with shape `(B, T, D)`. - - Returns: - torch.Tensor: output, with shape `(B, T, D)`. - """ - x = self.layer_norm(input) - x = x.transpose(1, 2) - x = self.sequential(x) - return x.transpose(1, 2) - - -class _FeedForwardModule(torch.nn.Module): - r"""Positionwise feed forward layer. - - Args: - input_dim (int): input dimension. - hidden_dim (int): hidden dimension. - dropout (float, optional): dropout probability. (Default: 0.0) - """ - - def __init__(self, input_dim: int, hidden_dim: int, dropout: float = 0.0) -> None: - super().__init__() - self.sequential = torch.nn.Sequential( - torch.nn.LayerNorm(input_dim), - torch.nn.Linear(input_dim, hidden_dim, bias=True), - torch.nn.SiLU(), - torch.nn.Dropout(dropout), - torch.nn.Linear(hidden_dim, input_dim, bias=True), - torch.nn.Dropout(dropout), - ) - - def forward(self, input: torch.Tensor) -> torch.Tensor: - r""" - Args: - input (torch.Tensor): with shape `(*, D)`. - - Returns: - torch.Tensor: output, with shape `(*, D)`. - """ - return self.sequential(input) - - -class ConformerLayer(torch.nn.Module): - r"""Conformer layer that constitutes Conformer. - - Args: - input_dim (int): input dimension. - ffn_dim (int): hidden layer dimension of feedforward network. - num_attention_heads (int): number of attention heads. - depthwise_conv_kernel_size (int): kernel size of depthwise convolution layer. - dropout (float, optional): dropout probability. (Default: 0.0) - use_group_norm (bool, optional): use ``GroupNorm`` rather than ``BatchNorm1d`` - in the convolution module. (Default: ``False``) - convolution_first (bool, optional): apply the convolution module ahead of - the attention module. (Default: ``False``) - """ - - def __init__( - self, - input_dim: int, - ffn_dim: int, - num_attention_heads: int, - depthwise_conv_kernel_size: int, - dropout: float = 0.0, - use_group_norm: bool = False, - convolution_first: bool = False, - ) -> None: - super().__init__() - - self.ffn1 = _FeedForwardModule(input_dim, ffn_dim, dropout=dropout) - - self.self_attn_layer_norm = torch.nn.LayerNorm(input_dim) - self.self_attn = torch.nn.MultiheadAttention(input_dim, num_attention_heads, dropout=dropout) - self.self_attn_dropout = torch.nn.Dropout(dropout) - - self.conv_module = _ConvolutionModule( - input_dim=input_dim, - num_channels=input_dim, - depthwise_kernel_size=depthwise_conv_kernel_size, - dropout=dropout, - bias=True, - use_group_norm=use_group_norm, - ) - - self.ffn2 = _FeedForwardModule(input_dim, ffn_dim, dropout=dropout) - self.final_layer_norm = torch.nn.LayerNorm(input_dim) - self.convolution_first = convolution_first - - def _apply_convolution(self, input: torch.Tensor) -> torch.Tensor: - residual = input - input = input.transpose(0, 1) - input = self.conv_module(input) - input = input.transpose(0, 1) - input = residual + input - return input - - def forward(self, input: torch.Tensor, key_padding_mask: Optional[torch.Tensor]) -> torch.Tensor: - r""" - Args: - input (torch.Tensor): input, with shape `(T, B, D)`. - key_padding_mask (torch.Tensor or None): key padding mask to use in self attention layer. - - Returns: - torch.Tensor: output, with shape `(T, B, D)`. - """ - residual = input - x = self.ffn1(input) - x = x * 0.5 + residual - - if self.convolution_first: - x = self._apply_convolution(x) - - residual = x - x = self.self_attn_layer_norm(x) - x, _ = self.self_attn( - query=x, - key=x, - value=x, - key_padding_mask=key_padding_mask, - need_weights=False, - ) - x = self.self_attn_dropout(x) - x = x + residual - - if not self.convolution_first: - x = self._apply_convolution(x) - - residual = x - x = self.ffn2(x) - x = x * 0.5 + residual - - x = self.final_layer_norm(x) - return x - - -class Conformer(torch.nn.Module): - r"""Conformer architecture introduced in - *Conformer: Convolution-augmented Transformer for Speech Recognition* - :cite:`gulati2020conformer`. - - Args: - input_dim (int): input dimension. - num_heads (int): number of attention heads in each Conformer layer. - ffn_dim (int): hidden layer dimension of feedforward networks. - num_layers (int): number of Conformer layers to instantiate. - depthwise_conv_kernel_size (int): kernel size of each Conformer layer's depthwise convolution layer. - dropout (float, optional): dropout probability. (Default: 0.0) - use_group_norm (bool, optional): use ``GroupNorm`` rather than ``BatchNorm1d`` - in the convolution module. (Default: ``False``) - convolution_first (bool, optional): apply the convolution module ahead of - the attention module. (Default: ``False``) - - Examples: - >>> conformer = Conformer( - >>> input_dim=80, - >>> num_heads=4, - >>> ffn_dim=128, - >>> num_layers=4, - >>> depthwise_conv_kernel_size=31, - >>> ) - >>> lengths = torch.randint(1, 400, (10,)) # (batch,) - >>> input = torch.rand(10, int(lengths.max()), input_dim) # (batch, num_frames, input_dim) - >>> output = conformer(input, lengths) - """ - - def __init__( - self, - input_dim: int, - num_heads: int, - ffn_dim: int, - num_layers: int, - depthwise_conv_kernel_size: int, - dropout: float = 0.0, - use_group_norm: bool = False, - convolution_first: bool = False, - ): - super().__init__() - - self.conformer_layers = torch.nn.ModuleList( - [ - ConformerLayer( - input_dim, - ffn_dim, - num_heads, - depthwise_conv_kernel_size, - dropout=dropout, - use_group_norm=use_group_norm, - convolution_first=convolution_first, - ) - for _ in range(num_layers) - ] - ) - self.export_mode = False - - def forward(self, input: torch.Tensor, lengths: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]: - r""" - Args: - input (torch.Tensor): with shape `(B, T, input_dim)`. - lengths (torch.Tensor): with shape `(B,)` and i-th element representing - number of valid frames for i-th batch element in ``input``. - - Returns: - (torch.Tensor, torch.Tensor) - torch.Tensor - output frames, with shape `(B, T, input_dim)` - torch.Tensor - output lengths, with shape `(B,)` and i-th element representing - number of valid frames for i-th batch element in output frames. - """ - encoder_padding_mask = None if self.export_mode else _lengths_to_padding_mask(lengths) - - x = input.transpose(0, 1) - for layer in self.conformer_layers: - x = layer(x, encoder_padding_mask) - return x.transpose(0, 1), lengths - -class Model(torch.nn.Module): - - def __init__(self): - super().__init__() - conformer_size = 512 - target_size=12001 - self.initial_linear = nn.Linear(50, conformer_size) - self.conformer = Conformer( - input_dim=conformer_size, - num_heads=8, - ffn_dim=2048, - num_layers=12, - depthwise_conv_kernel_size=31, - dropout=0.1 - ) - self.final_linear = nn.Linear(conformer_size, target_size) - - def forward( - self, - audio_features: torch.Tensor, - audio_features_len: torch.Tensor, - ): - if self.training: - audio_features_time_masked = mask_along_axis(audio_features, mask_param=20, mask_value=0.0, axis=1) - audio_features_time_masked_2 = mask_along_axis(audio_features_time_masked, mask_param=20, mask_value=0.0, axis=1) - audio_features_masked = mask_along_axis(audio_features_time_masked_2, mask_param=10, mask_value=0.0, axis=2) - audio_features_masked_2 = mask_along_axis(audio_features_masked, mask_param=10, mask_value=0.0, axis=2) - else: - audio_features_masked_2 = audio_features - - - conformer_in = self.initial_linear(audio_features_masked_2) - - conformer_out, _ = self.conformer(conformer_in, audio_features_len) - - logits = self.final_linear(conformer_out) # [B, T, F] - logits_ce_order = torch.permute(logits, dims=(0, 2, 1)) # CE expects [B, F, T] - log_probs = torch.log_softmax(logits, dim=2) - - return log_probs, logits_ce_order - - -scripted_model = None - -def train_step(*, model: Model, data, run_ctx, **_kwargs): - global scripted_model - audio_features = data["data"] - audio_features_len = data["data:seq_len"] - - audio_features_len, indices = torch.sort(audio_features_len, descending=True) - audio_features = audio_features[indices, :, :] - - phonemes = data["classes"][indices, :] - phonemes_len = data["classes:seq_len"][indices] - - #if scripted_model is None: - # model.to("cpu") - # export_trace(model=model, model_filename="testdump.onnx") - # model.to("cuda") - # model.train() - - # distributed_model = DataParallel(model) - log_probs, logits = model( - audio_features=audio_features, - audio_features_len=audio_features_len.to("cuda"), - ) - - targets_packed = nn.utils.rnn.pack_padded_sequence(phonemes, phonemes_len, batch_first=True, enforce_sorted=False) - targets_masked, _ = nn.utils.rnn.pad_packed_sequence(targets_packed, batch_first=True, padding_value=-100) - - loss = nn.functional.cross_entropy(logits, targets_masked) - - run_ctx.mark_as_loss(name="CE", loss=loss) - - -# def export(*, model: Model, model_filename: str): -# scripted_model = torch.jit.optimize_for_inference(torch.jit.script(model.eval())) -# dummy_data = torch.randn(1, 30, 50, device="cpu") -# dummy_data_len, _ = torch.sort(torch.randint(low=10, high=30, size=(1,), device="cpu", dtype=torch.int32), descending=True) -# onnx_export( -# scripted_model, -# (dummy_data, dummy_data_len), -# f=model_filename, -# verbose=True, -# input_names=["data", "data_len"], -# output_names=["classes"], -# dynamic_axes={ -# # dict value: manually named axes -# "data": {0: "batch", 1: "time"}, -# "data_len": {0: "batch"}, -# "classes": {0: "batch", 1: "time"} -# } -# ) -# - -def export_trace(*, model: Model, model_filename: str): - model.conformer.export_mode = True - dummy_data = torch.randn(1, 30, 50, device="cpu") - # dummy_data_len, _ = torch.sort(torch.randint(low=10, high=30, size=(1,), device="cpu", dtype=torch.int32), descending=True) - dummy_data_len = torch.ones((1,))*30 - scripted_model = torch.jit.optimize_for_inference(torch.jit.trace(model.eval(), example_inputs=(dummy_data, dummy_data_len))) - onnx_export( - scripted_model, - (dummy_data, dummy_data_len), - f=model_filename, - verbose=True, - input_names=["data", "data_len"], - output_names=["classes"], - dynamic_axes={ - # dict value: manually named axes - "data": {0: "batch", 1: "time"}, - "data_len": {0: "batch"}, - "classes": {0: "batch", 1: "time"} - } - ) - - diff --git a/users/rilling/experiments/librispeech/librispeech_100_hybrid/pytorch_networks/torchaudio_conformer_subsample.py b/users/rilling/experiments/librispeech/librispeech_100_hybrid/pytorch_networks/torchaudio_conformer_subsample.py deleted file mode 100644 index f48d2322c..000000000 --- a/users/rilling/experiments/librispeech/librispeech_100_hybrid/pytorch_networks/torchaudio_conformer_subsample.py +++ /dev/null @@ -1,426 +0,0 @@ -import time -import torch -from torch import nn -from torch.onnx import export as onnx_export -from torchaudio.functional import mask_along_axis -from torchaudio.models.conformer import Conformer - - - -from typing import Optional, Tuple - -import torch - - -__all__ = ["Conformer"] - - -def _lengths_to_padding_mask(lengths: torch.Tensor) -> torch.Tensor: - batch_size = lengths.shape[0] - max_length = int(torch.max(lengths).item()) - padding_mask = torch.arange(max_length, device=lengths.device, dtype=lengths.dtype).expand( - batch_size, max_length - ) >= lengths.unsqueeze(1) - return padding_mask - - -class _ConvolutionModule(torch.nn.Module): - r"""Conformer convolution module. - - Args: - input_dim (int): input dimension. - num_channels (int): number of depthwise convolution layer input channels. - depthwise_kernel_size (int): kernel size of depthwise convolution layer. - dropout (float, optional): dropout probability. (Default: 0.0) - bias (bool, optional): indicates whether to add bias term to each convolution layer. (Default: ``False``) - use_group_norm (bool, optional): use GroupNorm rather than BatchNorm. (Default: ``False``) - """ - - def __init__( - self, - input_dim: int, - num_channels: int, - depthwise_kernel_size: int, - dropout: float = 0.0, - bias: bool = False, - use_group_norm: bool = False, - ) -> None: - super().__init__() - if (depthwise_kernel_size - 1) % 2 != 0: - raise ValueError("depthwise_kernel_size must be odd to achieve 'SAME' padding.") - self.layer_norm = torch.nn.LayerNorm(input_dim) - self.sequential = torch.nn.Sequential( - torch.nn.Conv1d( - input_dim, - 2 * num_channels, - 1, - stride=1, - padding=0, - bias=bias, - ), - torch.nn.GLU(dim=1), - torch.nn.Conv1d( - num_channels, - num_channels, - depthwise_kernel_size, - stride=1, - padding=(depthwise_kernel_size - 1) // 2, - groups=num_channels, - bias=bias, - ), - torch.nn.GroupNorm(num_groups=1, num_channels=num_channels) - if use_group_norm - else torch.nn.BatchNorm1d(num_channels), - torch.nn.SiLU(), - torch.nn.Conv1d( - num_channels, - input_dim, - kernel_size=1, - stride=1, - padding=0, - bias=bias, - ), - torch.nn.Dropout(dropout), - ) - - def forward(self, input: torch.Tensor) -> torch.Tensor: - r""" - Args: - input (torch.Tensor): with shape `(B, T, D)`. - - Returns: - torch.Tensor: output, with shape `(B, T, D)`. - """ - x = self.layer_norm(input) - x = x.transpose(1, 2) - x = self.sequential(x) - return x.transpose(1, 2) - - -class _FeedForwardModule(torch.nn.Module): - r"""Positionwise feed forward layer. - - Args: - input_dim (int): input dimension. - hidden_dim (int): hidden dimension. - dropout (float, optional): dropout probability. (Default: 0.0) - """ - - def __init__(self, input_dim: int, hidden_dim: int, dropout: float = 0.0) -> None: - super().__init__() - self.sequential = torch.nn.Sequential( - torch.nn.LayerNorm(input_dim), - torch.nn.Linear(input_dim, hidden_dim, bias=True), - torch.nn.SiLU(), - torch.nn.Dropout(dropout), - torch.nn.Linear(hidden_dim, input_dim, bias=True), - torch.nn.Dropout(dropout), - ) - - def forward(self, input: torch.Tensor) -> torch.Tensor: - r""" - Args: - input (torch.Tensor): with shape `(*, D)`. - - Returns: - torch.Tensor: output, with shape `(*, D)`. - """ - return self.sequential(input) - - -class ConformerLayer(torch.nn.Module): - r"""Conformer layer that constitutes Conformer. - - Args: - input_dim (int): input dimension. - ffn_dim (int): hidden layer dimension of feedforward network. - num_attention_heads (int): number of attention heads. - depthwise_conv_kernel_size (int): kernel size of depthwise convolution layer. - dropout (float, optional): dropout probability. (Default: 0.0) - use_group_norm (bool, optional): use ``GroupNorm`` rather than ``BatchNorm1d`` - in the convolution module. (Default: ``False``) - convolution_first (bool, optional): apply the convolution module ahead of - the attention module. (Default: ``False``) - """ - - def __init__( - self, - input_dim: int, - ffn_dim: int, - num_attention_heads: int, - depthwise_conv_kernel_size: int, - dropout: float = 0.0, - use_group_norm: bool = False, - convolution_first: bool = False, - ) -> None: - super().__init__() - - self.ffn1 = _FeedForwardModule(input_dim, ffn_dim, dropout=dropout) - - self.self_attn_layer_norm = torch.nn.LayerNorm(input_dim) - self.self_attn = torch.nn.MultiheadAttention(input_dim, num_attention_heads, dropout=dropout) - self.self_attn_dropout = torch.nn.Dropout(dropout) - - self.conv_module = _ConvolutionModule( - input_dim=input_dim, - num_channels=input_dim, - depthwise_kernel_size=depthwise_conv_kernel_size, - dropout=dropout, - bias=True, - use_group_norm=use_group_norm, - ) - - self.ffn2 = _FeedForwardModule(input_dim, ffn_dim, dropout=dropout) - self.final_layer_norm = torch.nn.LayerNorm(input_dim) - self.convolution_first = convolution_first - - def _apply_convolution(self, input: torch.Tensor) -> torch.Tensor: - residual = input - input = input.transpose(0, 1) - input = self.conv_module(input) - input = input.transpose(0, 1) - input = residual + input - return input - - def forward(self, input: torch.Tensor, key_padding_mask: Optional[torch.Tensor]) -> torch.Tensor: - r""" - Args: - input (torch.Tensor): input, with shape `(T, B, D)`. - key_padding_mask (torch.Tensor or None): key padding mask to use in self attention layer. - - Returns: - torch.Tensor: output, with shape `(T, B, D)`. - """ - residual = input - x = self.ffn1(input) - x = x * 0.5 + residual - - if self.convolution_first: - x = self._apply_convolution(x) - - residual = x - x = self.self_attn_layer_norm(x) - x, _ = self.self_attn( - query=x, - key=x, - value=x, - key_padding_mask=key_padding_mask, - need_weights=False, - ) - x = self.self_attn_dropout(x) - x = x + residual - - if not self.convolution_first: - x = self._apply_convolution(x) - - residual = x - x = self.ffn2(x) - x = x * 0.5 + residual - - x = self.final_layer_norm(x) - return x - - -class Conformer(torch.nn.Module): - r"""Conformer architecture introduced in - *Conformer: Convolution-augmented Transformer for Speech Recognition* - :cite:`gulati2020conformer`. - - Args: - input_dim (int): input dimension. - num_heads (int): number of attention heads in each Conformer layer. - ffn_dim (int): hidden layer dimension of feedforward networks. - num_layers (int): number of Conformer layers to instantiate. - depthwise_conv_kernel_size (int): kernel size of each Conformer layer's depthwise convolution layer. - dropout (float, optional): dropout probability. (Default: 0.0) - use_group_norm (bool, optional): use ``GroupNorm`` rather than ``BatchNorm1d`` - in the convolution module. (Default: ``False``) - convolution_first (bool, optional): apply the convolution module ahead of - the attention module. (Default: ``False``) - - Examples: - >>> conformer = Conformer( - >>> input_dim=80, - >>> num_heads=4, - >>> ffn_dim=128, - >>> num_layers=4, - >>> depthwise_conv_kernel_size=31, - >>> ) - >>> lengths = torch.randint(1, 400, (10,)) # (batch,) - >>> input = torch.rand(10, int(lengths.max()), input_dim) # (batch, num_frames, input_dim) - >>> output = conformer(input, lengths) - """ - - def __init__( - self, - input_dim: int, - num_heads: int, - ffn_dim: int, - num_layers: int, - depthwise_conv_kernel_size: int, - dropout: float = 0.0, - use_group_norm: bool = False, - convolution_first: bool = False, - ): - super().__init__() - - self.downsample_conv = torch.nn.Conv1d(in_channels=input_dim, out_channels=input_dim, kernel_size=5, stride=2, padding=2) - self.conformer_layers = torch.nn.ModuleList( - [ - ConformerLayer( - input_dim, - ffn_dim, - num_heads, - depthwise_conv_kernel_size, - dropout=dropout, - use_group_norm=use_group_norm, - convolution_first=convolution_first, - ) - for _ in range(num_layers) - ] - ) - self.upsample_conv = torch.nn.ConvTranspose1d(in_channels=input_dim, out_channels=input_dim, kernel_size=5, stride=2, padding=1) - self.export_mode = False - - def forward(self, input: torch.Tensor, lengths: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]: - r""" - Args: - input (torch.Tensor): with shape `(B, T, input_dim)`. - lengths (torch.Tensor): with shape `(B,)` and i-th element representing - number of valid frames for i-th batch element in ``input``. - - Returns: - (torch.Tensor, torch.Tensor) - torch.Tensor - output frames, with shape `(B, T, input_dim)` - torch.Tensor - output lengths, with shape `(B,)` and i-th element representing - number of valid frames for i-th batch element in output frames. - """ - - - input = self.downsample_conv.forward(input.transpose(1,2)).transpose(1, 2) - encoder_padding_mask = None if self.export_mode else _lengths_to_padding_mask((lengths+1)//2) - - x = input.transpose(0, 1) - for layer in self.conformer_layers: - x = layer(x, encoder_padding_mask) - return x.transpose(0, 1), lengths - -class Model(torch.nn.Module): - - def __init__(self): - super().__init__() - conformer_size = 384 - target_size=12001 - self.initial_linear = nn.Linear(50, conformer_size) - self.conformer = Conformer( - input_dim=conformer_size, - num_heads=4, - ffn_dim=1024, - num_layers=8, - depthwise_conv_kernel_size=31, - dropout=0.1 - ) - self.final_linear = nn.Linear(conformer_size, target_size) - - def forward( - self, - audio_features: torch.Tensor, - audio_features_len: torch.Tensor, - ): - if self.training: - audio_features_time_masked = mask_along_axis(audio_features, mask_param=20, mask_value=0.0, axis=1) - audio_features_time_masked_2 = mask_along_axis(audio_features_time_masked, mask_param=20, mask_value=0.0, axis=1) - audio_features_masked = mask_along_axis(audio_features_time_masked_2, mask_param=10, mask_value=0.0, axis=2) - audio_features_masked_2 = mask_along_axis(audio_features_masked, mask_param=10, mask_value=0.0, axis=2) - else: - audio_features_masked_2 = audio_features - - - conformer_in = self.initial_linear(audio_features_masked_2) - - conformer_out, _ = self.conformer(conformer_in, audio_features_len) - - logits = self.final_linear(conformer_out) # [B, T, F] - logits_ce_order = torch.permute(logits, dims=(0, 2, 1)) # CE expects [B, F, T] - log_probs = torch.log_softmax(logits, dim=2) - - return log_probs, logits_ce_order - - -scripted_model = None - -def train_step(*, model: Model, data, run_ctx, **_kwargs): - global scripted_model - audio_features = data["data"] - audio_features_len = data["data:seq_len"] - - audio_features_len, indices = torch.sort(audio_features_len, descending=True) - audio_features = audio_features[indices, :, :] - - phonemes = data["classes"][indices, :] - phonemes_len = data["classes:seq_len"][indices] - - #if scripted_model is None: - # model.to("cpu") - # export_trace(model=model, model_filename="testdump.onnx") - # model.to("cuda") - # model.train() - - # distributed_model = DataParallel(model) - log_probs, logits = model( - audio_features=audio_features, - audio_features_len=audio_features_len.to("cuda"), - ) - - targets_packed = nn.utils.rnn.pack_padded_sequence(phonemes[:,::2], (phonemes_len+1)//2, batch_first=True, enforce_sorted=False) - targets_masked, _ = nn.utils.rnn.pad_packed_sequence(targets_packed, batch_first=True, padding_value=-100) - - loss = nn.functional.cross_entropy(logits, targets_masked) - - run_ctx.mark_as_loss(name="CE", loss=loss) - - -# def export(*, model: Model, model_filename: str): -# scripted_model = torch.jit.optimize_for_inference(torch.jit.script(model.eval())) -# dummy_data = torch.randn(1, 30, 50, device="cpu") -# dummy_data_len, _ = torch.sort(torch.randint(low=10, high=30, size=(1,), device="cpu", dtype=torch.int32), descending=True) -# onnx_export( -# scripted_model, -# (dummy_data, dummy_data_len), -# f=model_filename, -# verbose=True, -# input_names=["data", "data_len"], -# output_names=["classes"], -# dynamic_axes={ -# # dict value: manually named axes -# "data": {0: "batch", 1: "time"}, -# "data_len": {0: "batch"}, -# "classes": {0: "batch", 1: "time"} -# } -# ) -# - -def export_trace(*, model: Model, model_filename: str): - model.conformer.export_mode = True - dummy_data = torch.randn(1, 30, 50, device="cpu") - # dummy_data_len, _ = torch.sort(torch.randint(low=10, high=30, size=(1,), device="cpu", dtype=torch.int32), descending=True) - dummy_data_len = torch.ones((1,))*30 - scripted_model = torch.jit.optimize_for_inference(torch.jit.trace(model.eval(), example_inputs=(dummy_data, dummy_data_len))) - onnx_export( - scripted_model, - (dummy_data, dummy_data_len), - f=model_filename, - verbose=True, - input_names=["data", "data_len"], - output_names=["classes"], - dynamic_axes={ - # dict value: manually named axes - "data": {0: "batch", 1: "time"}, - "data_len": {0: "batch"}, - "classes": {0: "batch", 1: "time"} - } - ) - - diff --git a/users/rilling/experiments/librispeech/librispeech_100_hybrid/pytorch_networks/torchaudio_conformer_subsample_upsample.py b/users/rilling/experiments/librispeech/librispeech_100_hybrid/pytorch_networks/torchaudio_conformer_subsample_upsample.py deleted file mode 100644 index 8251c4d1e..000000000 --- a/users/rilling/experiments/librispeech/librispeech_100_hybrid/pytorch_networks/torchaudio_conformer_subsample_upsample.py +++ /dev/null @@ -1,440 +0,0 @@ -import time -import torch -from torch import nn -from torch.onnx import export as onnx_export -from torchaudio.functional import mask_along_axis -from torchaudio.models.conformer import Conformer - - - -from typing import Optional, Tuple - -import torch - - -__all__ = ["Conformer"] - - -def _lengths_to_padding_mask(lengths: torch.Tensor) -> torch.Tensor: - batch_size = lengths.shape[0] - max_length = int(torch.max(lengths).item()) - padding_mask = torch.arange(max_length, device=lengths.device, dtype=lengths.dtype).expand( - batch_size, max_length - ) >= lengths.unsqueeze(1) - return padding_mask - - -class _ConvolutionModule(torch.nn.Module): - r"""Conformer convolution module. - - Args: - input_dim (int): input dimension. - num_channels (int): number of depthwise convolution layer input channels. - depthwise_kernel_size (int): kernel size of depthwise convolution layer. - dropout (float, optional): dropout probability. (Default: 0.0) - bias (bool, optional): indicates whether to add bias term to each convolution layer. (Default: ``False``) - use_group_norm (bool, optional): use GroupNorm rather than BatchNorm. (Default: ``False``) - """ - - def __init__( - self, - input_dim: int, - num_channels: int, - depthwise_kernel_size: int, - dropout: float = 0.0, - bias: bool = False, - use_group_norm: bool = False, - ) -> None: - super().__init__() - if (depthwise_kernel_size - 1) % 2 != 0: - raise ValueError("depthwise_kernel_size must be odd to achieve 'SAME' padding.") - self.layer_norm = torch.nn.LayerNorm(input_dim) - self.sequential = torch.nn.Sequential( - torch.nn.Conv1d( - input_dim, - 2 * num_channels, - 1, - stride=1, - padding=0, - bias=bias, - ), - torch.nn.GLU(dim=1), - torch.nn.Conv1d( - num_channels, - num_channels, - depthwise_kernel_size, - stride=1, - padding=(depthwise_kernel_size - 1) // 2, - groups=num_channels, - bias=bias, - ), - torch.nn.GroupNorm(num_groups=1, num_channels=num_channels) - if use_group_norm - else torch.nn.BatchNorm1d(num_channels), - torch.nn.SiLU(), - torch.nn.Conv1d( - num_channels, - input_dim, - kernel_size=1, - stride=1, - padding=0, - bias=bias, - ), - torch.nn.Dropout(dropout), - ) - - def forward(self, input: torch.Tensor) -> torch.Tensor: - r""" - Args: - input (torch.Tensor): with shape `(B, T, D)`. - - Returns: - torch.Tensor: output, with shape `(B, T, D)`. - """ - x = self.layer_norm(input) - x = x.transpose(1, 2) - x = self.sequential(x) - return x.transpose(1, 2) - - -class _FeedForwardModule(torch.nn.Module): - r"""Positionwise feed forward layer. - - Args: - input_dim (int): input dimension. - hidden_dim (int): hidden dimension. - dropout (float, optional): dropout probability. (Default: 0.0) - """ - - def __init__(self, input_dim: int, hidden_dim: int, dropout: float = 0.0) -> None: - super().__init__() - self.sequential = torch.nn.Sequential( - torch.nn.LayerNorm(input_dim), - torch.nn.Linear(input_dim, hidden_dim, bias=True), - torch.nn.SiLU(), - torch.nn.Dropout(dropout), - torch.nn.Linear(hidden_dim, input_dim, bias=True), - torch.nn.Dropout(dropout), - ) - - def forward(self, input: torch.Tensor) -> torch.Tensor: - r""" - Args: - input (torch.Tensor): with shape `(*, D)`. - - Returns: - torch.Tensor: output, with shape `(*, D)`. - """ - return self.sequential(input) - - -class ConformerLayer(torch.nn.Module): - r"""Conformer layer that constitutes Conformer. - - Args: - input_dim (int): input dimension. - ffn_dim (int): hidden layer dimension of feedforward network. - num_attention_heads (int): number of attention heads. - depthwise_conv_kernel_size (int): kernel size of depthwise convolution layer. - dropout (float, optional): dropout probability. (Default: 0.0) - use_group_norm (bool, optional): use ``GroupNorm`` rather than ``BatchNorm1d`` - in the convolution module. (Default: ``False``) - convolution_first (bool, optional): apply the convolution module ahead of - the attention module. (Default: ``False``) - """ - - def __init__( - self, - input_dim: int, - ffn_dim: int, - num_attention_heads: int, - depthwise_conv_kernel_size: int, - dropout: float = 0.0, - use_group_norm: bool = False, - convolution_first: bool = False, - ) -> None: - super().__init__() - - self.ffn1 = _FeedForwardModule(input_dim, ffn_dim, dropout=dropout) - - self.self_attn_layer_norm = torch.nn.LayerNorm(input_dim) - self.self_attn = torch.nn.MultiheadAttention(input_dim, num_attention_heads, dropout=dropout) - self.self_attn_dropout = torch.nn.Dropout(dropout) - - self.conv_module = _ConvolutionModule( - input_dim=input_dim, - num_channels=input_dim, - depthwise_kernel_size=depthwise_conv_kernel_size, - dropout=dropout, - bias=True, - use_group_norm=use_group_norm, - ) - - self.ffn2 = _FeedForwardModule(input_dim, ffn_dim, dropout=dropout) - self.final_layer_norm = torch.nn.LayerNorm(input_dim) - self.convolution_first = convolution_first - - def _apply_convolution(self, input: torch.Tensor) -> torch.Tensor: - residual = input - input = input.transpose(0, 1) - input = self.conv_module(input) - input = input.transpose(0, 1) - input = residual + input - return input - - def forward(self, input: torch.Tensor, key_padding_mask: Optional[torch.Tensor]) -> torch.Tensor: - r""" - Args: - input (torch.Tensor): input, with shape `(T, B, D)`. - key_padding_mask (torch.Tensor or None): key padding mask to use in self attention layer. - - Returns: - torch.Tensor: output, with shape `(T, B, D)`. - """ - residual = input - x = self.ffn1(input) - x = x * 0.5 + residual - - if self.convolution_first: - x = self._apply_convolution(x) - - residual = x - x = self.self_attn_layer_norm(x) - x, _ = self.self_attn( - query=x, - key=x, - value=x, - key_padding_mask=key_padding_mask, - need_weights=False, - ) - x = self.self_attn_dropout(x) - x = x + residual - - if not self.convolution_first: - x = self._apply_convolution(x) - - residual = x - x = self.ffn2(x) - x = x * 0.5 + residual - - x = self.final_layer_norm(x) - return x - - -class Conformer(torch.nn.Module): - r"""Conformer architecture introduced in - *Conformer: Convolution-augmented Transformer for Speech Recognition* - :cite:`gulati2020conformer`. - - Extended version with very simple downsampling and upsampling - - Args: - input_dim (int): input dimension. - num_heads (int): number of attention heads in each Conformer layer. - ffn_dim (int): hidden layer dimension of feedforward networks. - num_layers (int): number of Conformer layers to instantiate. - depthwise_conv_kernel_size (int): kernel size of each Conformer layer's depthwise convolution layer. - dropout (float, optional): dropout probability. (Default: 0.0) - use_group_norm (bool, optional): use ``GroupNorm`` rather than ``BatchNorm1d`` - in the convolution module. (Default: ``False``) - convolution_first (bool, optional): apply the convolution module ahead of - the attention module. (Default: ``False``) - - Examples: - >>> conformer = Conformer( - >>> input_dim=80, - >>> num_heads=4, - >>> ffn_dim=128, - >>> num_layers=4, - >>> depthwise_conv_kernel_size=31, - >>> ) - >>> lengths = torch.randint(1, 400, (10,)) # (batch,) - >>> input = torch.rand(10, int(lengths.max()), input_dim) # (batch, num_frames, input_dim) - >>> output = conformer(input, lengths) - """ - - def __init__( - self, - input_dim: int, - num_heads: int, - ffn_dim: int, - num_layers: int, - depthwise_conv_kernel_size: int, - dropout: float = 0.0, - use_group_norm: bool = False, - convolution_first: bool = False, - ): - super().__init__() - - self.downsample_conv = torch.nn.Conv1d(in_channels=input_dim, out_channels=input_dim, kernel_size=5, stride=2, padding=2) - self.conformer_layers = torch.nn.ModuleList( - [ - ConformerLayer( - input_dim, - ffn_dim, - num_heads, - depthwise_conv_kernel_size, - dropout=dropout, - use_group_norm=use_group_norm, - convolution_first=convolution_first, - ) - for _ in range(num_layers) - ] - ) - self.upsample_conv = torch.nn.ConvTranspose1d(in_channels=input_dim, out_channels=input_dim, kernel_size=5, stride=2, padding=1) - self.export_mode = False - - def forward(self, input: torch.Tensor, lengths: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]: - r""" - Args: - input (torch.Tensor): with shape `(B, T, input_dim)`. - lengths (torch.Tensor): with shape `(B,)` and i-th element representing - number of valid frames for i-th batch element in ``input``. - - Returns: - (torch.Tensor, torch.Tensor) - torch.Tensor - output frames, with shape `(B, T, input_dim)` - torch.Tensor - output lengths, with shape `(B,)` and i-th element representing - number of valid frames for i-th batch element in output frames. - """ - - # downsampling is done as [B, F, T] - input_downsampled = self.downsample_conv.forward(input.transpose(1,2)).transpose(1, 2) - - # also downsample the mask for training, in ONNX export we currently ignore the mask - encoder_padding_mask = None if self.export_mode else _lengths_to_padding_mask((lengths+1)//2) - - # Conformer is applied as [T, B, F] - x = input_downsampled.transpose(0, 1) - for layer in self.conformer_layers: - x = layer(x, encoder_padding_mask) # [T, B, F] - - conf_output = torch.permute(x, (1, 2 ,0)) # [B, F, T] for upsampling - upsampled = self.upsample_conv(conf_output).transpose(1, 2) # final upsampled [B, T, F] - - # slice for correct length - out_upsampled = upsampled[:,0:input.size()[1],:] - - return out_upsampled, lengths - -class Model(torch.nn.Module): - - def __init__(self, epoch, step, **kwargs): - super().__init__() - conformer_size = 384 - target_size=12001 - self.initial_linear = nn.Linear(50, conformer_size) - self.conformer = Conformer( - input_dim=conformer_size, - num_heads=4, - ffn_dim=1024, - num_layers=8, - depthwise_conv_kernel_size=31, - dropout=0.1 - ) - self.final_linear = nn.Linear(conformer_size, target_size) - - def forward( - self, - audio_features: torch.Tensor, - audio_features_len: torch.Tensor, - ): - if self.training: - audio_features_time_masked = mask_along_axis(audio_features, mask_param=20, mask_value=0.0, axis=1) - audio_features_time_masked_2 = mask_along_axis(audio_features_time_masked, mask_param=20, mask_value=0.0, axis=1) - audio_features_masked = mask_along_axis(audio_features_time_masked_2, mask_param=10, mask_value=0.0, axis=2) - audio_features_masked_2 = mask_along_axis(audio_features_masked, mask_param=10, mask_value=0.0, axis=2) - else: - audio_features_masked_2 = audio_features - - - conformer_in = self.initial_linear(audio_features_masked_2) - - conformer_out, _ = self.conformer(conformer_in, audio_features_len) - - logits = self.final_linear(conformer_out) # [B, T, F] - logits_ce_order = torch.permute(logits, dims=(0, 2, 1)) # CE expects [B, F, T] - log_probs = torch.log_softmax(logits, dim=2) - - return log_probs, logits_ce_order - - -# scripted_model = None - -def train_step(*, model: Model, data, run_ctx, **_kwargs): - global scripted_model - audio_features = data["data"] - audio_features_len = data["data:size1"] - - audio_features_len, indices = torch.sort(audio_features_len, descending=True) - audio_features = audio_features[indices, :, :] - - phonemes = data["classes"][indices, :] - phonemes_len = data["classes:size1"][indices] - - #if scripted_model is None: - # model.eval() - # model.to("cpu") - # export_trace(model=model, model_filename="testdump.onnx") - # assert False - - # distributed_model = DataParallel(model) - log_probs, logits = model( - audio_features=audio_features, - audio_features_len=audio_features_len.to("cuda"), - ) - - - targets_packed = nn.utils.rnn.pack_padded_sequence(phonemes, phonemes_len.to("cpu"), batch_first=True, enforce_sorted=False) - targets_masked, _ = nn.utils.rnn.pad_packed_sequence(targets_packed, batch_first=True, padding_value=-100) - - loss = nn.functional.cross_entropy(logits, targets_masked) - - run_ctx.mark_as_loss(name="CE", loss=loss) - - -# def export(*, model: Model, model_filename: str): -# scripted_model = torch.jit.optimize_for_inference(torch.jit.script(model.eval())) -# dummy_data = torch.randn(1, 30, 50, device="cpu") -# dummy_data_len, _ = torch.sort(torch.randint(low=10, high=30, size=(1,), device="cpu", dtype=torch.int32), descending=True) -# onnx_export( -# scripted_model, -# (dummy_data, dummy_data_len), -# f=model_filename, -# verbose=True, -# input_names=["data", "data_len"], -# output_names=["classes"], -# dynamic_axes={ -# # dict value: manually named axes -# "data": {0: "batch", 1: "time"}, -# "data_len": {0: "batch"}, -# "classes": {0: "batch", 1: "time"} -# } -# ) -# - -def export_trace(*, model: Model, model_filename: str): - model.conformer.export_mode = True - dummy_data = torch.randn(1, 30, 50, device="cpu") - # dummy_data_len, _ = torch.sort(torch.randint(low=10, high=30, size=(1,), device="cpu", dtype=torch.int32), descending=True) - dummy_data_len = torch.ones((1,))*30 - scripted_model = torch.jit.optimize_for_inference(torch.jit.trace(model.eval(), example_inputs=(dummy_data, dummy_data_len))) - onnx_export( - scripted_model, - (dummy_data, dummy_data_len), - f=model_filename, - verbose=True, - input_names=["data", "data_len"], - output_names=["classes"], - opset_version=14, - dynamic_axes={ - # dict value: manually named axes - "data": {0: "batch", 1: "time"}, - "data_len": {0: "batch"}, - "classes": {0: "batch", 1: "time"} - } - ) - - diff --git a/users/rilling/experiments/librispeech/librispeech_100_hybrid/rc_networks/__init__.py b/users/rilling/experiments/librispeech/librispeech_100_hybrid/rc_networks/__init__.py deleted file mode 100644 index e69de29bb..000000000 diff --git a/users/rilling/experiments/librispeech/librispeech_100_hybrid/rc_networks/debug.py b/users/rilling/experiments/librispeech/librispeech_100_hybrid/rc_networks/debug.py deleted file mode 100644 index 06f22404b..000000000 --- a/users/rilling/experiments/librispeech/librispeech_100_hybrid/rc_networks/debug.py +++ /dev/null @@ -1,142 +0,0 @@ -from .default_hybrid import construct_hybrid_network, BLSTMEncoder -from returnn_common import nn -from returnn_common.asr.specaugment import random_mask_v2 -from returnn_common.nn.encoder import ISeqFramewiseEncoder - -from returnn.datasets import init_dataset -from returnn.config import Config -from returnn.tf.engine import Engine - -import better_exchook -better_exchook.install() - - -def specaugment_v2(x: nn.Tensor, *, - spatial_dim: nn.Dim, - feature_dim: nn.Dim = nn.NotSpecified, - global_train_step_dependent: bool = True, - only_on_train: bool = True, - ) -> nn.Tensor: - """ - SpecAugment reimplementation of :func:`specaugment_v1` - """ - if feature_dim is nn.NotSpecified: - assert x.feature_dim - feature_dim = x.feature_dim - if global_train_step_dependent: - step = nn.global_train_step() - step1 = nn.where(step >= 1000, 1, 0) - step2 = nn.where(step >= 2000, 1, 0) - else: - step1 = step2 = 1 - time_factor = 1 - - #with nn.Cond(nn.train_flag() | (not only_on_train)) as cond: - # x_masked = x - # spatial_len = nn.dim_value(spatial_dim) - # # time mask - # x_masked = random_mask_v2( - # x_masked, mask_axis=spatial_dim, broadcast_axis=feature_dim, - # min_num=nn.minimum(step1 + step2, spatial_len), - # max_num=nn.minimum(nn.maximum(spatial_len // 100, 2) * (1 + step1 + step2 * 2), spatial_len), - # max_dims=20 // time_factor) - # # feature mask - # # x_masked = random_mask_v2( - # # x_masked, mask_axis=feature_dim, broadcast_axis=spatial_dim, - # # min_num=step1 + step2, max_num=2 + step1 + step2 * 2, - # # max_dims=feature_dim.dimension // 5) - # # cond.true = x_masked - # cond.false = x - - spatial_len = nn.dim_value(spatial_dim) - # return cond.result - x_masked = random_mask_v2( - x, mask_axis=spatial_dim, broadcast_axis=feature_dim, - min_num=nn.minimum(step1 + step2, spatial_len), - max_num=nn.minimum(nn.maximum(spatial_len // 100, 2) * (1 + step1 + step2 * 2), spatial_len), - max_dims=20 // time_factor) - return x_masked - - - - - -class BLSTMEncoderMinimal(ISeqFramewiseEncoder): - """ - BLSTM encoder with specaugment - """ - - def __init__(self, label_feature_dim): - super().__init__() - - def __call__(self, source: nn.Tensor, *, spatial_dim: nn.Dim) -> nn.Tensor: - return specaugment_v2(source, spatial_dim=spatial_dim, feature_dim=source.feature_dim) - - -data_time = nn.SpatialDim("data_time", None) -data_feature = nn.FeatureDim("data_feature", 5) -classes_feature = nn.FeatureDim("classes_feature", 12) -data = nn.Data( - name="data", - dim_tags=[nn.batch_dim, data_time, data_feature], - available_for_inference=True, -) -classes = nn.Data( - name="classes", - dim_tags=[nn.batch_dim, data_time], - sparse_dim=classes_feature, - available_for_inference=False, -) - -def _config_get_network(epoch: int, **_kwargs) -> dict: - nn.reset_default_root_name_ctx() - net = construct_hybrid_network( - epoch=0, - train=True, - encoder=BLSTMEncoderMinimal, - audio_data=data, - label_data=classes, - ) - return nn.get_returnn_config().get_net_dict_raw_dict(net) - -class DummyNet(nn.Module): - - def __init__(self): - super().__init__() - - def __call__(self, source: nn.Tensor, spatial_dim: nn.Dim): - return random_mask_v2(x=source, mask_axis=spatial_dim, broadcast_axis=source.feature_dim, min_num=1, max_num=2, max_dims=3) - -def _config_get_spec_network(epoch: int) -> dict: - nn.reset_default_root_name_ctx() - net = DummyNet() - data_tensor = nn.get_extern_data(data) - spatial_dim = data.dim_tags[data.time_dim_axis] - out = net( - source=data_tensor, - spatial_dim=spatial_dim - ) - out.mark_as_default_output() - return nn.get_returnn_config().get_net_dict_raw_dict(net) - - -data_args = data.get_kwargs() -data_args.pop("name") -classes_args = classes.get_kwargs() -classes_args.pop("name") - -extern_data = { - "data": data_args, - "classes": classes_args, -} - -config = Config({ - "task": "train", "num_epochs": 1, "start_epoch": 1, - "get_network": _config_get_spec_network, - "extern_data": extern_data, -}) -train_dataset = init_dataset( - {"class": "DummyDataset", "input_dim": 5, "output_dim": 12, "num_seqs": 3}) -engine = Engine(config) -engine.init_train_from_config(config, train_data=train_dataset) -engine.train() \ No newline at end of file diff --git a/users/rilling/experiments/librispeech/librispeech_100_hybrid/rc_networks/debug_random_mask.py b/users/rilling/experiments/librispeech/librispeech_100_hybrid/rc_networks/debug_random_mask.py deleted file mode 100644 index b1d2fd202..000000000 --- a/users/rilling/experiments/librispeech/librispeech_100_hybrid/rc_networks/debug_random_mask.py +++ /dev/null @@ -1,54 +0,0 @@ -from returnn_common import nn -from returnn_common.asr.specaugment import random_mask_v2, specaugment_v2 - -from returnn.datasets import init_dataset -from returnn.config import Config -from returnn.tf.engine import Engine - -import better_exchook -better_exchook.install() - -data_time = nn.SpatialDim("data_time", None) -data_feature = nn.FeatureDim("data_feature", 5) -data = nn.Data( - name="data", - dim_tags=[nn.batch_dim, data_time, data_feature], - available_for_inference=True, -) - -class DummyNet(nn.Module): - - def __init__(self): - super().__init__() - - def __call__(self, source: nn.Tensor, spatial_dim: nn.Dim): - return specaugment_v2(x=source, spatial_dim=spatial_dim) - # return random_mask_v2(x=source, mask_axis=spatial_dim, broadcast_axis=source.feature_dim, min_num=1, max_num=2, max_dims=3) - - -def _config_get_spec_network(epoch: int) -> dict: - nn.reset_default_root_name_ctx() - net = DummyNet() - data_tensor = nn.get_extern_data(data) - spatial_dim = data.dim_tags[data.time_dim_axis] - out = net(source=data_tensor, spatial_dim=spatial_dim) - out.mark_as_default_output() - config_code = nn.get_returnn_config().get_complete_py_code_str(net) - print(config_code) # I will also provide this as gist - return nn.get_returnn_config().get_net_dict_raw_dict(net) - -data_args = data.get_kwargs() -data_args.pop("name") -extern_data = {"data": data_args,} - -config = Config({ - "task": "train", "num_epochs": 1, "start_epoch": 1, - "get_network": _config_get_spec_network, - "extern_data": extern_data, - "behavior_version": 12 -}) -train_dataset = init_dataset( - {"class": "DummyDataset", "input_dim": 5, "output_dim": 12, "num_seqs": 3}) -engine = Engine(config) -engine.init_train_from_config(config, train_data=train_dataset) -engine.train() diff --git a/users/rilling/experiments/librispeech/librispeech_100_hybrid/rc_networks/default_hybrid.py b/users/rilling/experiments/librispeech/librispeech_100_hybrid/rc_networks/default_hybrid.py deleted file mode 100644 index 1b718644b..000000000 --- a/users/rilling/experiments/librispeech/librispeech_100_hybrid/rc_networks/default_hybrid.py +++ /dev/null @@ -1,162 +0,0 @@ -from typing import Any, Callable, Optional, Tuple - -from returnn_common import nn -from returnn_common.nn.hybrid_hmm import IHybridHMM, EncoderType, ISeqFramewiseEncoder, ISeqDownsamplingEncoder -from returnn_common.asr.specaugment import specaugment_v2, random_mask_v2 - - -def flexible_specaugment( - x: nn.Tensor, *, - spatial_dim: nn.Dim, - feature_dim: nn.Dim = nn.NotSpecified, - only_on_train: bool = True, - min_frame_masks=2, - mask_each_n_frames=25, - max_frames_per_mask=20, - min_feature_masks=2, - max_feature_masks=5, - max_features_per_mask=8 - ) -> nn.Tensor: - """ - SpecAugment :func:`specaugment_v2` but with adjustable parameters - """ - if feature_dim is nn.NotSpecified: - assert x.feature_dim - feature_dim = x.feature_dim - - with nn.Cond(nn.train_flag() | (not only_on_train)) as cond: - x_masked = x - spatial_len = nn.dim_value(spatial_dim) - # time mask - x_masked = random_mask_v2( - x_masked, mask_axis=spatial_dim, broadcast_axis=feature_dim, - min_num=nn.minimum(min_frame_masks, spatial_len), - max_num=nn.minimum(nn.maximum(spatial_len // mask_each_n_frames, min_frame_masks), spatial_len), - max_dims=max_frames_per_mask) - # feature mask - x_masked = random_mask_v2( - x_masked, mask_axis=feature_dim, broadcast_axis=spatial_dim, - min_num=min_feature_masks, max_num=max_feature_masks, - max_dims=max_features_per_mask) - cond.true = x_masked - cond.false = x - return cond.result - - -class BLSTMLayer(nn.Module): - """ - BLSTM with time broadcasted dropout - """ - def __init__(self, size=512, dropout: float = 0.0): - super().__init__() - self.lstm_dim = nn.FeatureDim(description="BLSTM-out-dim", dimension=size) - self.out_dim = self.lstm_dim * 2 - self.fwd_lstm = nn.LSTM(out_dim=self.lstm_dim) - self.bwd_lstm = nn.LSTM(out_dim=self.lstm_dim) - self.dropout = dropout - - def __call__(self, source: nn.Tensor, time_dim: nn.Dim): - fwd, _ = self.fwd_lstm(source, axis=time_dim, direction=1) - bwd, _ = self.bwd_lstm(source, axis=time_dim, direction=-1) - concat = nn.concat((fwd, self.lstm_dim), (bwd, self.lstm_dim)) - if self.dropout > 0.0: - return nn.dropout(concat, self.dropout, axis=[nn.batch_dim, concat.feature_dim]) - else: - return concat - - -class BLSTMEncoder(ISeqFramewiseEncoder): - """ - BLSTM encoder with specaugment - """ - - def __init__(self, label_dim: nn.Dim, num_layers: int, size: int, dropout: float, specaugment_options=None): - super().__init__() - self.specaugment_options = specaugment_options - self.out_dim = label_dim - self.blstm_stack = nn.Sequential( - [ - BLSTMLayer(size=size, dropout=dropout) - for _ in range(num_layers) - ] - ) - - def __call__(self, source: nn.Tensor, *, spatial_dim: nn.Dim) -> nn.Tensor: - if self.specaugment_options: - source = flexible_specaugment( - source, - spatial_dim=spatial_dim, - feature_dim=source.feature_dim, - **self.specaugment_options) - return self.blstm_stack(source, time_dim=spatial_dim) - - -class HybridHMM(IHybridHMM): - """ - Hybrid NN-HMM - """ - - def __init__(self, *, encoder: EncoderType, out_dim: nn.Dim, focal_loss_scale: float = 1.0): - super().__init__() - self.encoder = encoder - self.out_dim = out_dim - self.focal_loss_scale = focal_loss_scale - self.out_projection = nn.Linear(out_dim) - - def __call__(self, source: nn.Tensor, *, - state: Optional[nn.LayerState] = None, - train: bool = False, targets: Optional[nn.Tensor] = None) -> Tuple[nn.Tensor, Optional[nn.LayerState]]: - assert source.data.time_dim_axis is not None - in_spatial_dim = source.data.dim_tags[source.data.time_dim_axis] - assert state is None, f"{self} stateful hybrid HMM not supported yet" - if isinstance(self.encoder, ISeqFramewiseEncoder): - encoder_output = self.encoder(source, spatial_dim=in_spatial_dim) - out_spatial_dim = in_spatial_dim - elif isinstance(self.encoder, ISeqDownsamplingEncoder): - encoder_output, out_spatial_dim = self.encoder(source, in_spatial_dim=in_spatial_dim) - else: - raise TypeError(f"unsupported encoder type {type(self.encoder)}") - out_embed = self.out_projection(encoder_output) - if train: - assert out_spatial_dim in targets.shape - ce_loss = nn.sparse_softmax_cross_entropy_with_logits(logits=out_embed, targets=targets, axis=self.out_dim) - # focal loss (= more emphasis on "low" scores), might not be correct yet - if self.focal_loss_scale != 1.0: - ce_loss *= (1.0 - nn.exp(-ce_loss)) ** self.focal_loss_scale - ce_loss.mark_as_loss(name="default_ce") - return nn.log_softmax(out_embed, axis=self.out_dim), None - - -def construct_hybrid_network( - epoch: int, - train: bool, - encoder: Callable[[nn.Dim, Any], EncoderType], - audio_data: nn.Data, - label_data: nn.Data, - **kwargs -): - """ - :param epoch: - :param train: - :param encoder: - :param audio_data: - :param label_data: - :param kwargs: encoder kwargs - :return: - """ - label_feature_dim = label_data.sparse_dim - focal_loss_scale = kwargs.pop("focal_loss_scale", 1.0) - enc = encoder(label_feature_dim, **kwargs) - net = HybridHMM( - encoder=enc, - out_dim=label_feature_dim, - focal_loss_scale=focal_loss_scale - ) - out, _ = net( - source=nn.get_extern_data(audio_data), - train=train, - targets=nn.get_extern_data(label_data) - ) - out.mark_as_default_output() - - return net diff --git a/users/rilling/experiments/librispeech/librispeech_100_hybrid/rc_networks/default_hybrid_v2.py b/users/rilling/experiments/librispeech/librispeech_100_hybrid/rc_networks/default_hybrid_v2.py deleted file mode 100644 index a4fd55263..000000000 --- a/users/rilling/experiments/librispeech/librispeech_100_hybrid/rc_networks/default_hybrid_v2.py +++ /dev/null @@ -1,167 +0,0 @@ -""" -Like the original, but with the updated syntax -""" -from typing import Any, Callable, Optional, Tuple - -from returnn_common import nn -from returnn_common.nn.hybrid_hmm import IHybridHMM, EncoderType, ISeqFramewiseEncoder, ISeqDownsamplingEncoder -from returnn_common.asr.specaugment import specaugment_v2, random_mask_v2 - - -def flexible_specaugment( - x: nn.Tensor, *, - spatial_dim: nn.Dim, - feature_dim: nn.Dim = nn.NotSpecified, - only_on_train: bool = True, - min_frame_masks=2, - mask_each_n_frames=25, - max_frames_per_mask=20, - min_feature_masks=2, - max_feature_masks=5, - max_features_per_mask=8 - ) -> nn.Tensor: - """ - SpecAugment :func:`specaugment_v2` but with adjustable parameters - """ - if feature_dim is nn.NotSpecified: - assert x.feature_dim - feature_dim = x.feature_dim - - with nn.Cond(nn.train_flag() | (not only_on_train)) as cond: - x_masked = x - spatial_len = nn.dim_value(spatial_dim) - # time mask - x_masked = random_mask_v2( - x_masked, mask_axis=spatial_dim, broadcast_axis=feature_dim, - min_num=nn.minimum(min_frame_masks, spatial_len), - max_num=nn.minimum(nn.maximum(spatial_len // mask_each_n_frames, min_frame_masks), spatial_len), - max_dims=max_frames_per_mask) - # feature mask - x_masked = random_mask_v2( - x_masked, mask_axis=feature_dim, broadcast_axis=spatial_dim, - min_num=min_feature_masks, max_num=max_feature_masks, - max_dims=max_features_per_mask) - cond.true = x_masked - cond.false = x - return cond.result - - -class BLSTMLayer(nn.Module): - """ - BLSTM with time broadcasted dropout - """ - def __init__(self, in_dim: nn.Dim, size=512, dropout: float = 0.0): - super().__init__() - self.lstm_dim = nn.FeatureDim(description="BLSTM-out-dim", dimension=size) - self.out_dim = 2*self.lstm_dim - self.fwd_lstm = nn.LSTM(in_dim=in_dim, out_dim=self.lstm_dim) - self.bwd_lstm = nn.LSTM(in_dim=in_dim, out_dim=self.lstm_dim) - self.dropout = dropout - - def __call__(self, source: nn.Tensor, time_dim: nn.Dim): - fwd, _ = self.fwd_lstm(source, spatial_dim=time_dim, direction=1) - bwd, _ = self.bwd_lstm(source, spatial_dim=time_dim, direction=-1) - concat, _ = nn.concat((fwd, self.lstm_dim), (bwd, self.lstm_dim)) - if self.dropout > 0.0: - return nn.dropout(concat, self.dropout, axis=[nn.batch_dim, concat.feature_dim]) - else: - return concat - - -class BLSTMEncoder(ISeqFramewiseEncoder): - """ - BLSTM encoder with specaugment - """ - - def __init__(self, in_dim: nn.Dim, num_layers: int, size: int, dropout: float, specaugment_options=None): - super().__init__() - self.specaugment_options = specaugment_options - - running_dim = in_dim - blstm_layers = [] - for _ in range(num_layers): - blstm_layer = BLSTMLayer(in_dim=running_dim, size=size, dropout=dropout) - blstm_layers.append(blstm_layer) - running_dim = blstm_layer.out_dim - - self.out_dim = running_dim - self.blstm_stack = nn.Sequential(blstm_layers) - - def __call__(self, source: nn.Tensor, *, spatial_dim: nn.Dim) -> nn.Tensor: - if self.specaugment_options: - source = flexible_specaugment( - source, - spatial_dim=spatial_dim, - feature_dim=source.feature_dim, - **self.specaugment_options) - return self.blstm_stack(source, time_dim=spatial_dim) - - -class HybridHMM(IHybridHMM): - """ - Hybrid NN-HMM - """ - - def __init__(self, *, encoder: EncoderType, out_dim: nn.Dim, focal_loss_scale: float = 0.0): - super().__init__() - self.encoder = encoder - self.focal_loss_scale = focal_loss_scale - self.out_dim = out_dim - self.out_projection = nn.Linear(in_dim=self.encoder.out_dim, out_dim=out_dim) - - def __call__(self, source: nn.Tensor, *, - state: Optional[nn.LayerState] = None, - train: bool = False, targets: Optional[nn.Tensor] = None) -> Tuple[nn.Tensor, Optional[nn.LayerState]]: - assert source.data.time_dim_axis is not None - in_spatial_dim = source.data.dim_tags[source.data.time_dim_axis] - assert state is None, f"{self} stateful hybrid HMM not supported yet" - if isinstance(self.encoder, ISeqFramewiseEncoder): - encoder_output = self.encoder(source, spatial_dim=in_spatial_dim) - out_spatial_dim = in_spatial_dim - elif isinstance(self.encoder, ISeqDownsamplingEncoder): - encoder_output, out_spatial_dim = self.encoder(source, in_spatial_dim=in_spatial_dim) - else: - raise TypeError(f"unsupported encoder type {type(self.encoder)}") - out_embed = self.out_projection(encoder_output) - if train: - assert out_spatial_dim in targets.shape - ce_loss = nn.sparse_softmax_cross_entropy_with_logits(logits=out_embed, targets=targets, axis=self.out_dim) - # focal loss (= more emphasis on "low" scores), might not be correct yet - if self.focal_loss_scale > 0.0: - ce_loss *= (1.0 - nn.exp(-ce_loss)) ** self.focal_loss_scale - ce_loss.mark_as_loss(name="default_ce") - return nn.log_softmax(out_embed, axis=self.out_dim), None - - -def construct_hybrid_network( - epoch: int, - train: bool, - audio_data: nn.Data, - label_data: nn.Data, - **kwargs -): - """ - :param epoch: - :param train: - :param encoder: - :param audio_data: - :param label_data: - :param kwargs: encoder kwargs - :return: - """ - label_feature_dim = label_data.sparse_dim - focal_loss_scale = kwargs.pop("focal_loss_scale", 0.0) - enc = BLSTMEncoder(in_dim=audio_data.feature_dim_or_sparse_dim, **kwargs) - net = HybridHMM( - encoder=enc, - out_dim=label_feature_dim, - focal_loss_scale=focal_loss_scale - ) - out, _ = net( - source=nn.get_extern_data(audio_data), - train=train, - targets=nn.get_extern_data(label_data) - ) - out.mark_as_default_output() - - return net diff --git a/users/rilling/experiments/librispeech/librispeech_100_hybrid/specaugment_clean_legacy.py b/users/rilling/experiments/librispeech/librispeech_100_hybrid/specaugment_clean_legacy.py deleted file mode 100644 index 28bf33463..000000000 --- a/users/rilling/experiments/librispeech/librispeech_100_hybrid/specaugment_clean_legacy.py +++ /dev/null @@ -1,141 +0,0 @@ -from dataclasses import dataclass - - -def _mask(x, batch_axis, axis, pos, max_amount): - """ - :param tf.Tensor x: (batch,time,feature) - :param int batch_axis: - :param int axis: - :param tf.Tensor pos: (batch,) - :param int|tf.Tensor max_amount: inclusive - """ - from returnn.tf.compat import v1 as tf - ndim = x.get_shape().ndims - n_batch = tf.shape(x)[batch_axis] - dim = tf.shape(x)[axis] - amount = tf.random_uniform(shape=(n_batch,), minval=1, maxval=max_amount + 1, dtype=tf.int32) - pos2 = tf.minimum(pos + amount, dim) - idxs = tf.expand_dims(tf.range(0, dim), 0) # (1,dim) - pos_bc = tf.expand_dims(pos, 1) # (batch,1) - pos2_bc = tf.expand_dims(pos2, 1) # (batch,1) - cond = tf.logical_and(tf.greater_equal(idxs, pos_bc), tf.less(idxs, pos2_bc)) # (batch,dim) - if batch_axis > axis: - cond = tf.transpose(cond) # (dim,batch) - cond = tf.reshape(cond, [tf.shape(x)[i] if i in (batch_axis, axis) else 1 for i in range(ndim)]) - from TFUtil import where_bc - x = where_bc(cond, 0.0, x) - return x - - -def _random_mask(x, batch_axis, axis, min_num, max_num, max_dims): - """ - :param tf.Tensor x: (batch,time,feature) - :param int batch_axis: - :param int axis: - :param int|tf.Tensor min_num: - :param int|tf.Tensor max_num: inclusive - :param int|tf.Tensor max_dims: inclusive - """ - from returnn.tf.compat import v1 as tf - n_batch = tf.shape(x)[batch_axis] - if isinstance(min_num, int) and isinstance(max_num, int) and min_num == max_num: - num = min_num - else: - num = tf.random_uniform(shape=(n_batch,), minval=min_num, maxval=max_num + 1, dtype=tf.int32) - # https://github.com/tensorflow/tensorflow/issues/9260 - # https://timvieira.github.io/blog/post/2014/08/01/gumbel-max-trick-and-weighted-reservoir-sampling/ - z = -tf.log(-tf.log(tf.random_uniform((n_batch, tf.shape(x)[axis]), 0, 1))) - _, indices = tf.nn.top_k(z, num if isinstance(num, int) else tf.reduce_max(num)) - # indices should be sorted, and of shape (batch,num), entries (int32) in [0,dim) - # indices = tf.Print(indices, ["indices", indices, tf.shape(indices)]) - if isinstance(num, int): - for i in range(num): - x = _mask(x, batch_axis=batch_axis, axis=axis, pos=indices[:, i], max_amount=max_dims) - else: - _, x = tf.while_loop( - cond=lambda i, _: tf.less(i, tf.reduce_max(num)), - body=lambda i, x: ( - i + 1, - tf.where( - tf.less(i, num), - _mask(x, batch_axis=batch_axis, axis=axis, pos=indices[:, i], max_amount=max_dims), - x)), - loop_vars=(0, x)) - return x - - -def specaugment_eval_func(data, network, - min_frame_masks=2, mask_each_n_frames=25, max_frames_per_mask=20, - min_feature_masks=2, max_feature_masks=5, max_features_per_mask=8): - x = data.placeholder - from returnn.tf.compat import v1 as tf - def get_masked(): - x_masked = x - x_masked = _random_mask( - x_masked, batch_axis=data.batch_dim_axis, axis=data.time_dim_axis, - min_num=min_frame_masks, - max_num=tf.maximum(tf.shape(x)[data.time_dim_axis] // mask_each_n_frames, min_frame_masks), - max_dims=max_frames_per_mask) - x_masked = _random_mask( - x_masked, batch_axis=data.batch_dim_axis, axis=data.feature_dim_axis, - min_num=min_feature_masks, max_num=max_feature_masks, - max_dims=max_features_per_mask) - return x_masked - x = network.cond_on_train(get_masked, lambda: x) - return x - - -@dataclass(eq=False, frozen=True) -class SpecAugmentSettings: - """ - default hybrid settings from chris - """ - min_frame_masks: int = 1 - mask_each_n_frames: int = 100 - max_frames_per_mask: int = 20 - min_feature_masks: int = 1 - max_feature_masks: int = 2 - max_features_per_mask: int = 10 - - def get_options(self): - return self.__dict__ - - -def specaug_layer(in_layer, min_frame_masks=1, mask_each_n_frames=100, max_frames_per_mask=20, - min_feature_masks=1, max_feature_masks=2, max_features_per_mask=10): - """ - specaug layer with default hybrid settings - - :param in_layer: - :param min_frame_masks: - :param mask_each_n_frames: - :param max_frames_per_mask: - :param min_feature_masks: - :param max_feature_masks: - :param max_features_per_mask: - :return: - """ - return { - "class": "eval", - "from": in_layer, - "eval":"self.network.get_config().typed_value('specaugment_eval_func')(" - "source(0, as_data=True), " - "network=self.network, " - "min_frame_masks=%i, " - "mask_each_n_frames=%i, " - "max_frames_per_mask=%i, " - "min_feature_masks=%i, " - "max_feature_masks=%i, " - "max_features_per_mask=%i)" % ( - min_frame_masks, mask_each_n_frames, max_frames_per_mask, - min_feature_masks, max_feature_masks, max_features_per_mask - ), - } - - -def get_funcs(): - funcs = [] - for k, v in list(globals().items()): - if k in ["_mask", "_random_mask", "specaugment_eval_func"]: - funcs.append(v) - return funcs \ No newline at end of file diff --git a/users/rilling/experiments/librispeech/librispeech_conformer_cb_joint/experiments.py b/users/rilling/experiments/librispeech/librispeech_conformer_cb_joint/experiments.py index 3504f73c8..30ce07a10 100644 --- a/users/rilling/experiments/librispeech/librispeech_conformer_cb_joint/experiments.py +++ b/users/rilling/experiments/librispeech/librispeech_conformer_cb_joint/experiments.py @@ -44,12 +44,11 @@ def get_conformer_coupling_glow(x_vector_exp, gl_checkpoint): - """ - Baseline for the glow TTS in returnn_common with serialization - - Uses updated RETURNN_COMMON + """Different experiments similar to the experiments in ../librispeech_glowtts and ../librispeech_joint_training but using Conformers as coupling function instead of wavenet-like CNN - :return: durations_hdf + :param dict x_vector_exp: Dictionary containing experiments from ../librispeech_x_vectors to import pre-trained x-vector models for on-the-fly speaker embedding generation + : param dict gl_checkpoint: Dictionary containing checkpoint and config of BLSTM transforming log-mel into linear spectrograms for G&L vocoding + :return dict: Dictionary containing experiment dictionaries """ prefix = "experiments/librispeech/joint_training/conformer_coupling/raw_audio/" @@ -66,28 +65,43 @@ def run_exp( forward_args={}, search_args={}, keep_epochs=None, - extract_x_vector=False, tts_forward=True, asr_search=True, use_speaker_labels_in_dev=False, - given_train_job_for_forward=None, tts_eval_datasets=None, ): + """Creates jobs for training, TTS forward/evaluation and ASR search + + :param str name: Name of the experiment for aliases + :param dict args: General arguments for training, forwarding and search + :param TrainingDataset dataset: Dataset for training and TTS forwarding without evaluation + :param dict test_dataset: Dictionary of datasets for ASR evaluation + :param int num_epochs: Number of epochs for training, defaults to 100 + :param bool use_custom_engine: whether custom engine should be used in Returnn, defaults to False + :param dict training_args: Additional arguments for training passed to train_step function, defaults to {} + :param dict forward_args: Additional arguments for TTS forward passed to froward_step, defaults to {} + :param dict search_args: Additional arguments for ASR search passed to search_step_init, defaults to {} + :param list[int] keep_epochs: List of checkpoints that should be kept during training, defaults to None + :param bool tts_forward: whether TTS should be evaluated, defaults to True + :param bool asr_search: whether ASR search sould be performend and evaluated, defaults to True + :param bool use_speaker_labels_in_dev: whether validation set for training should contain speaker labels (uses devtrain split instead of dev-other/-clean for validation), defaults to False + :param dict tts_eval_datasets: Dictionary of datasets used for TTS evaluation, defaults to None + :return dict: Dictionary containing all jobs of the experiment + """ assert not tts_forward or ( "x_vector" not in name or tts_eval_datasets is not None ), "Attempting to evaluate a model with x-vector speaker embeddings, but missing explicit forward dataset with precalculated x-vector speaker embeddings." exp = {} - if given_train_job_for_forward is None: - training_config = get_training_config( - training_datasets=dataset, - **args, - training_args=training_args, - use_custom_engine=use_custom_engine, - keep_epochs=keep_epochs, - use_speaker_labels_in_dev=use_speaker_labels_in_dev, - ) # implicit reconstruction loss + training_config = get_training_config( + training_datasets=dataset, + **args, + training_args=training_args, + use_custom_engine=use_custom_engine, + keep_epochs=keep_epochs, + use_speaker_labels_in_dev=use_speaker_labels_in_dev, + ) if tts_forward: forward_config = get_forward_config( @@ -102,16 +116,13 @@ def run_exp( search_args=search_args, ) - if given_train_job_for_forward is None: - train_job = training( - config=training_config, - returnn_exe=RETURNN_PYTORCH_EXE, - returnn_root=MINI_RETURNN_ROOT, - prefix=prefix + name, - num_epochs=num_epochs, - ) - else: - train_job = given_train_job_for_forward + train_job = training( + config=training_config, + returnn_exe=RETURNN_PYTORCH_EXE, + returnn_root=MINI_RETURNN_ROOT, + prefix=prefix + name, + num_epochs=num_epochs, + ) exp["train_job"] = train_job if tts_forward: @@ -139,19 +150,6 @@ def run_exp( swer_eval_corpus_key=ds_key ) - if extract_x_vector: - forward_x_vector_config = get_forward_config( - forward_dataset=dataset, **args, forward_args=forward_args, target="xvector", train_data=True - ) - forward_xvector_job = forward( - checkpoint=train_job.out_checkpoints[num_epochs], - config=forward_x_vector_config, - returnn_exe=RETURNN_PYTORCH_EXE, - returnn_root=MINI_RETURNN_ROOT, - prefix=prefix + name, - target="xvector", - ) - exp["forward_xvector_job"] = forward_xvector_job if asr_search: search( prefix + name + "/search", diff --git a/users/rilling/experiments/librispeech/librispeech_glow_asr/experiments.py b/users/rilling/experiments/librispeech/librispeech_glow_asr/experiments.py index de7fb6b1b..90c4d0fbd 100644 --- a/users/rilling/experiments/librispeech/librispeech_glow_asr/experiments.py +++ b/users/rilling/experiments/librispeech/librispeech_glow_asr/experiments.py @@ -33,6 +33,10 @@ def glowASR(TTS_experiments: dict): + """Contains the ASR-only experiments using both frozen Glow-TTS decoder and unfrozen coupling blocks as a frontend for BLSTMs or Conformers trained on ASR + + :param dict TTS_experiments: Dictionary containing the TTS-only experiments from ../librispeech_glowtts to import Glow-TTS decoder parameters + """ prefix_name = "experiments/librispeech/librispeech_glow_asr/pytorch/" train_settings = TrainingDatasetSettings( @@ -137,6 +141,21 @@ def run_exp( only_forward_no_search=False, eval_invertibility=False, ): + """Creates the jobs for training and search of the experiment + + :param str ft_name: Name of the experiment to be used for aliases + :param TrainingDataset datasets: Dataset to be used for training + :param dict train_args: Dictionary containing arguments for training + :param dict search_args: Dictionary containing arguments for search used in search init step, defaults to None + :param bool with_prior: whether the prior on the test dataset should be evaluated for internal language model correction (if set to False will default to True if search_args["prior_scale"]!= 0), defaults to False + :param int num_epochs: Number of epochs in training, defaults to 100 + :param int extra_evaluate_epoch: Number of checkpoint that should be additionally evaluated to evaluate WER during training, defaults to None + :param dict test_datasets: Dictionary of datasets to be used for evaluation, keys are used for aliases, defaults to dev_dataset_tuples + :param bool large_gpu_training: whether training should require 24GB or memory, defaults to False + :param bool only_forward_no_search: whether ASR search / evaluation should be skipped, defaults to False + :param bool eval_invertibility: whether coupling blocks should be evaluated for invertibility, defaults to False + :return dict: Dictionary containing all the jobs of the experiment + """ search_args = copy.deepcopy(search_args) if search_args is not None else {} with_prior = with_prior or ("prior_scale" in search_args and search_args["prior_scale"] != 0) diff --git a/users/rilling/experiments/librispeech/librispeech_glowtts/glowTTS/feature_config.py b/users/rilling/experiments/librispeech/librispeech_glowtts/feature_config.py similarity index 100% rename from users/rilling/experiments/librispeech/librispeech_glowtts/glowTTS/feature_config.py rename to users/rilling/experiments/librispeech/librispeech_glowtts/feature_config.py diff --git a/users/rilling/experiments/librispeech/librispeech_glowtts/glowTTS/experiments.py b/users/rilling/experiments/librispeech/librispeech_glowtts/glowTTS/experiments.py index 84b577d6a..56164bf9f 100644 --- a/users/rilling/experiments/librispeech/librispeech_glowtts/glowTTS/experiments.py +++ b/users/rilling/experiments/librispeech/librispeech_glowtts/glowTTS/experiments.py @@ -21,13 +21,13 @@ def get_pytorch_glowTTS(x_vector_exp: dict, gl_checkpoint: dict): - """ - Baseline for the glow TTS in returnn_common with serialization + """Experiments training Glow-TTS on TTS-only. Most experiments have the bug, that the decoder dropout is set using the wrong keyword, which is why the value of 0.05 is overwritten by the default of 0.0 + The TTS-only experiments in ../librispeech_joing_training_given_alignment/exp_TTS fixed that and are therefore more current - Uses updated RETURNN_COMMON - - :return: durations_hdf - """ + :param dict x_vector_exp: Dictionary containing x-vector experiments from ../librispeech_x_vectors to import x-vector model for on-the-fly speaker embedding generatino + :param dict gl_checkpoint: Dictionary containing checkpoint and config of a BLSTM network to transform log-mel into linear for G&L vocoding + :return dict: Dictionary containing the experiment dictionaries to import attributes of experiment jobs in other experiment folders (should be done using storage) + """ prefix = "experiments/librispeech/tts_architecture/glow_tts/raw_audio/" experiments = {} @@ -53,6 +53,29 @@ def run_exp( tts_eval_datasets=None, forward_device="gpu", ): + """Creates the jobs for training, forwarding and evaluation of the experiment + + :param str name: Name of the experiment to be used in aliases + :param dict args: General arguments to be used in Returnn configs in training and forward + :param TrainingDataset dataset: Dataset used for training and TTS forwarding (not evaluation) + :param int num_epochs: Number of epochs in training, defaults to 100 + :param bool use_custom_engine: whether a custom engine is used in Returnn, defaults to False + :param Optional[int] extra_evaluate_epoch: if an epoch is given the forward run is also performed using that epoch's checkpoint, defaults to None + :param dict forward_args: Additional arguments for the forward step, defaults to {} + :param bool further_training: whether an additional training should be run after the first num_epochs epochs for again num_epochs, defaults to False + :param bool spectrogram_foward: whether an additional forward run should produce spectrograms, defaults to False + :param bool durations_forward: whether an additional forward run should compute the phoneme durations / alignments, defaults to False + :param bool latent_space_forward: whether an additional forward run should output the latent space into an HDF, defaults to False + :param bool joint_data_forward: whether the forwarding/generation should be run on the full data (train and val. split), defaults to False + :param bool train_data_forward: whether the forwarding/generation should be run on the train split of the dataset, defaults to False + :param bool joint_durations_forward: whether the phoneme durations extraction should be run on the full dataset (train + val. split), defaults to False + :param list[int] keep_epochs: List of checkpoints that should be kept during training (not cleaned up), defaults to None + :param bool skip_forward: whether forwarding/generation should be skipped, defaults to False + :param bool nisqa_evaluation: whether the autoMOS should be evaluated using NISQA, defaults to False + :param dict tts_eval_datasets: Dictionary containing the datasets for TTS evaluation (autoMOS + sWER), defaults to None + :param str forward_device: define whether the forward steps are run on "gpu" or "cpu", defaults to "gpu" + :return dict: Dictionary containing the jobs of the experiment + """ exp = {} assert not nisqa_evaluation or (nisqa_evaluation and not skip_forward), "NISQA evaluation with skipping forward jobs is not possible" @@ -154,7 +177,7 @@ def run_exp( # vocoder="univnet" # ) # exp["forward_job_univnet"] = forward_job_univnet - + for ds_k, ds in tts_eval_datasets.items(): forward_config_gl = get_forward_config( returnn_common_root=RETURNN_COMMON, @@ -339,7 +362,7 @@ def get_lr_scale(dim_model, step_num, warmup_steps): ) from .data import get_tts_log_mel_datastream - from .feature_config import DbMelFeatureExtractionConfig + from ..feature_config import DbMelFeatureExtractionConfig from i6_experiments.users.rossenbach.common_setups.returnn.datastreams.audio import DBMelFilterbankOptions log_mel_datastream = get_tts_log_mel_datastream(silence_preprocessing=False) diff --git a/users/rilling/experiments/librispeech/librispeech_glowtts/glowTTS/gt_extraction.py b/users/rilling/experiments/librispeech/librispeech_glowtts/glowTTS/gt_extraction.py index df81f04c2..d63eda851 100644 --- a/users/rilling/experiments/librispeech/librispeech_glowtts/glowTTS/gt_extraction.py +++ b/users/rilling/experiments/librispeech/librispeech_glowtts/glowTTS/gt_extraction.py @@ -66,7 +66,7 @@ def run_exp(name, args, dataset): training_datasets_silence_preprocessed = build_training_dataset(settings=train_settings, librispeech_key="train-clean-100", silence_preprocessing=True) from .data import get_tts_log_mel_datastream - from .feature_config import DbMelFeatureExtractionConfig + from ..feature_config import DbMelFeatureExtractionConfig from i6_experiments.users.rossenbach.common_setups.returnn.datastreams.audio import DBMelFilterbankOptions log_mel_datastream = get_tts_log_mel_datastream(silence_preprocessing=False) diff --git a/users/rilling/experiments/librispeech/librispeech_glowtts/glowTTS/vocoder/__init__.py b/users/rilling/experiments/librispeech/librispeech_glowtts/glowTTS/vocoder/__init__.py deleted file mode 100644 index e69de29bb..000000000 diff --git a/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/feature_extraction.py b/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/feature_extraction.py index e4fefba90..283631dbe 100644 --- a/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/feature_extraction.py +++ b/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/feature_extraction.py @@ -4,8 +4,7 @@ from librosa import filters -from ..glowTTS.feature_config import DbMelFeatureExtractionConfig - +from ..feature_config import DbMelFeatureExtractionConfig class DbMelFeatureExtraction(nn.Module): diff --git a/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS.py b/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS.py index f68e79991..05d00a75d 100644 --- a/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS.py +++ b/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS.py @@ -16,7 +16,7 @@ from .monotonic_align import maximum_path from .feature_extraction import DbMelFeatureExtraction -from ..glowTTS.feature_config import DbMelFeatureExtractionConfig +from ..feature_config import DbMelFeatureExtractionConfig from .eval_forward import * diff --git a/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_ddi_actnorm.py b/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_ddi_actnorm.py index 17e1d9e9a..bcf11bd06 100644 --- a/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_ddi_actnorm.py +++ b/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_ddi_actnorm.py @@ -16,7 +16,7 @@ from .monotonic_align import maximum_path from .feature_extraction import DbMelFeatureExtraction -from ..glowTTS.feature_config import DbMelFeatureExtractionConfig +from ..feature_config import DbMelFeatureExtractionConfig from .eval_forward import * diff --git a/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_decoder_test_blstm.py b/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_decoder_test_blstm.py index cbb99c159..9a3618ccf 100644 --- a/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_decoder_test_blstm.py +++ b/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_decoder_test_blstm.py @@ -16,7 +16,7 @@ from .monotonic_align import maximum_path from .feature_extraction import DbMelFeatureExtraction -from ..glowTTS.feature_config import DbMelFeatureExtractionConfig +from ..feature_config import DbMelFeatureExtractionConfig from i6_models.parts.blstm import BlstmEncoderV1, BlstmEncoderV1Config diff --git a/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_decoder_test_multi_layer_ffn.py b/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_decoder_test_multi_layer_ffn.py index ae813a8e7..db30fb87b 100644 --- a/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_decoder_test_multi_layer_ffn.py +++ b/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_decoder_test_multi_layer_ffn.py @@ -16,7 +16,7 @@ from .monotonic_align import maximum_path from .feature_extraction import DbMelFeatureExtraction -from ..glowTTS.feature_config import DbMelFeatureExtractionConfig +from ..feature_config import DbMelFeatureExtractionConfig class DurationPredictor(nn.Module): diff --git a/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_decoder_test_simple_linear.py b/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_decoder_test_simple_linear.py index 1167aab99..7ead486c4 100644 --- a/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_decoder_test_simple_linear.py +++ b/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_decoder_test_simple_linear.py @@ -16,7 +16,7 @@ from .monotonic_align import maximum_path from .feature_extraction import DbMelFeatureExtraction -from ..glowTTS.feature_config import DbMelFeatureExtractionConfig +from ..feature_config import DbMelFeatureExtractionConfig class DurationPredictor(nn.Module): diff --git a/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_encoder_sample_test_blstm.py b/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_encoder_sample_test_blstm.py index 90bc2b906..bd8f2a551 100644 --- a/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_encoder_sample_test_blstm.py +++ b/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_encoder_sample_test_blstm.py @@ -16,7 +16,7 @@ from .monotonic_align import maximum_path from .feature_extraction import DbMelFeatureExtraction -from ..glowTTS.feature_config import DbMelFeatureExtractionConfig +from ..feature_config import DbMelFeatureExtractionConfig from i6_models.parts.blstm import BlstmEncoderV1, BlstmEncoderV1Config diff --git a/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_encoder_sample_test_maxlike_alignment_blstm.py b/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_encoder_sample_test_maxlike_alignment_blstm.py index 5db783e86..fe3d788ef 100644 --- a/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_encoder_sample_test_maxlike_alignment_blstm.py +++ b/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_encoder_sample_test_maxlike_alignment_blstm.py @@ -16,7 +16,7 @@ from .monotonic_align import maximum_path from .feature_extraction import DbMelFeatureExtraction -from ..glowTTS.feature_config import DbMelFeatureExtractionConfig +from ..feature_config import DbMelFeatureExtractionConfig from i6_models.parts.blstm import BlstmEncoderV1, BlstmEncoderV1Config diff --git a/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_encoder_sample_test_maxlike_alignment_multi_layer_ffn.py b/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_encoder_sample_test_maxlike_alignment_multi_layer_ffn.py index d46e6a0e9..19b94415f 100644 --- a/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_encoder_sample_test_maxlike_alignment_multi_layer_ffn.py +++ b/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_encoder_sample_test_maxlike_alignment_multi_layer_ffn.py @@ -16,7 +16,7 @@ from .monotonic_align import maximum_path from .feature_extraction import DbMelFeatureExtraction -from ..glowTTS.feature_config import DbMelFeatureExtractionConfig +from ..feature_config import DbMelFeatureExtractionConfig class DurationPredictor(nn.Module): diff --git a/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_encoder_sample_test_maxlike_alignment_simple_linear.py b/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_encoder_sample_test_maxlike_alignment_simple_linear.py index 572791718..1e3b7b311 100644 --- a/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_encoder_sample_test_maxlike_alignment_simple_linear.py +++ b/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_encoder_sample_test_maxlike_alignment_simple_linear.py @@ -16,7 +16,7 @@ from .monotonic_align import maximum_path from .feature_extraction import DbMelFeatureExtraction -from ..glowTTS.feature_config import DbMelFeatureExtractionConfig +from ..feature_config import DbMelFeatureExtractionConfig class DurationPredictor(nn.Module): diff --git a/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_encoder_sample_test_multi_layer_ffn.py b/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_encoder_sample_test_multi_layer_ffn.py index 5042be9c8..f67c5211e 100644 --- a/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_encoder_sample_test_multi_layer_ffn.py +++ b/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_encoder_sample_test_multi_layer_ffn.py @@ -16,7 +16,7 @@ from .monotonic_align import maximum_path from .feature_extraction import DbMelFeatureExtraction -from ..glowTTS.feature_config import DbMelFeatureExtractionConfig +from ..feature_config import DbMelFeatureExtractionConfig class DurationPredictor(nn.Module): diff --git a/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_encoder_sample_test_simple_linear.py b/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_encoder_sample_test_simple_linear.py index bf0e52169..29f1886a8 100644 --- a/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_encoder_sample_test_simple_linear.py +++ b/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_encoder_sample_test_simple_linear.py @@ -16,7 +16,7 @@ from .monotonic_align import maximum_path from .feature_extraction import DbMelFeatureExtraction -from ..glowTTS.feature_config import DbMelFeatureExtractionConfig +from ..feature_config import DbMelFeatureExtractionConfig class DurationPredictor(nn.Module): diff --git a/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_nar_taco_encoder.py b/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_nar_taco_encoder.py index a75ebe0ee..23a8ce473 100644 --- a/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_nar_taco_encoder.py +++ b/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_nar_taco_encoder.py @@ -17,7 +17,7 @@ from .monotonic_align import maximum_path from .feature_extraction import DbMelFeatureExtraction -from ..glowTTS.feature_config import DbMelFeatureExtractionConfig +from ..feature_config import DbMelFeatureExtractionConfig from .eval_forward import * class Config: diff --git a/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_nar_taco_encoder_no_blstm.py b/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_nar_taco_encoder_no_blstm.py index 6328749d5..0fbf5aa39 100644 --- a/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_nar_taco_encoder_no_blstm.py +++ b/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_nar_taco_encoder_no_blstm.py @@ -17,7 +17,7 @@ from .monotonic_align import maximum_path from .feature_extraction import DbMelFeatureExtraction -from ..glowTTS.feature_config import DbMelFeatureExtractionConfig +from ..feature_config import DbMelFeatureExtractionConfig from .eval_forward import * class Config: diff --git a/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_one_hot_encoder_mean.py b/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_one_hot_encoder_mean.py index 38192665c..2c4a5afd7 100644 --- a/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_one_hot_encoder_mean.py +++ b/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_one_hot_encoder_mean.py @@ -16,7 +16,7 @@ from .monotonic_align import maximum_path from .feature_extraction import DbMelFeatureExtraction -from ..glowTTS.feature_config import DbMelFeatureExtractionConfig +from ..feature_config import DbMelFeatureExtractionConfig class DurationPredictor(nn.Module): diff --git a/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_one_hot_encoder_std.py b/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_one_hot_encoder_std.py index 64d10af1a..ffeb99945 100644 --- a/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_one_hot_encoder_std.py +++ b/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_one_hot_encoder_std.py @@ -16,7 +16,7 @@ from .monotonic_align import maximum_path from .feature_extraction import DbMelFeatureExtraction -from ..glowTTS.feature_config import DbMelFeatureExtractionConfig +from ..feature_config import DbMelFeatureExtractionConfig class DurationPredictor(nn.Module): diff --git a/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_simple_encoder.py b/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_simple_encoder.py index 9fe7baaa9..7f3d982e3 100644 --- a/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_simple_encoder.py +++ b/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_simple_encoder.py @@ -16,7 +16,7 @@ from .monotonic_align import maximum_path from .feature_extraction import DbMelFeatureExtraction -from ..glowTTS.feature_config import DbMelFeatureExtractionConfig +from ..feature_config import DbMelFeatureExtractionConfig from .eval_forward import * diff --git a/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_simple_encoder_test_maxlike_alignment_multi_layer_ffn.py b/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_simple_encoder_test_maxlike_alignment_multi_layer_ffn.py index 6261dd1a1..a3e3a1451 100644 --- a/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_simple_encoder_test_maxlike_alignment_multi_layer_ffn.py +++ b/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_simple_encoder_test_maxlike_alignment_multi_layer_ffn.py @@ -16,7 +16,7 @@ from .monotonic_align import maximum_path from .feature_extraction import DbMelFeatureExtraction -from ..glowTTS.feature_config import DbMelFeatureExtractionConfig +from ..feature_config import DbMelFeatureExtractionConfig from .eval_forward import * diff --git a/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_simple_encoder_test_maxlike_alignment_multi_layer_ffn_v2.py b/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_simple_encoder_test_maxlike_alignment_multi_layer_ffn_v2.py index cdfeb90ee..8321f2187 100644 --- a/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_simple_encoder_test_maxlike_alignment_multi_layer_ffn_v2.py +++ b/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_simple_encoder_test_maxlike_alignment_multi_layer_ffn_v2.py @@ -16,7 +16,7 @@ from .monotonic_align import maximum_path from .feature_extraction import DbMelFeatureExtraction -from ..glowTTS.feature_config import DbMelFeatureExtractionConfig +from ..feature_config import DbMelFeatureExtractionConfig from .eval_forward import * diff --git a/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_x_vector.py b/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_x_vector.py index 9f41c67fa..19c7f04bf 100644 --- a/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_x_vector.py +++ b/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_x_vector.py @@ -16,7 +16,7 @@ from .monotonic_align import maximum_path from .feature_extraction import DbMelFeatureExtraction -from ..glowTTS.feature_config import DbMelFeatureExtractionConfig +from ..feature_config import DbMelFeatureExtractionConfig from .eval_forward import * diff --git a/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_x_vector_eval.py b/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_x_vector_eval.py index dd69ca93e..33c4579e7 100644 --- a/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_x_vector_eval.py +++ b/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_x_vector_eval.py @@ -16,7 +16,7 @@ from .monotonic_align import maximum_path from .feature_extraction import DbMelFeatureExtraction -from ..glowTTS.feature_config import DbMelFeatureExtractionConfig +from ..feature_config import DbMelFeatureExtractionConfig class XVector(nn.Module): diff --git a/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_x_vector_v2.py b/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_x_vector_v2.py index 64a6397fb..0c1e3f652 100644 --- a/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_x_vector_v2.py +++ b/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_x_vector_v2.py @@ -17,7 +17,7 @@ from .monotonic_align import maximum_path from .feature_extraction import DbMelFeatureExtraction -from ..glowTTS.feature_config import DbMelFeatureExtractionConfig +from ..feature_config import DbMelFeatureExtractionConfig class XVector(nn.Module): diff --git a/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_x_vector_v3.py b/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_x_vector_v3.py index b4f7c4df2..1a341b9a9 100644 --- a/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_x_vector_v3.py +++ b/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_x_vector_v3.py @@ -17,7 +17,7 @@ from .monotonic_align import maximum_path from .feature_extraction import DbMelFeatureExtraction -from ..glowTTS.feature_config import DbMelFeatureExtractionConfig +from ..feature_config import DbMelFeatureExtractionConfig class DurationPredictor(nn.Module): """ diff --git a/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_x_vector_v3_norm_xvector.py b/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_x_vector_v3_norm_xvector.py index ee42f1b39..498c83e28 100644 --- a/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_x_vector_v3_norm_xvector.py +++ b/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/glowTTS_x_vector_v3_norm_xvector.py @@ -17,7 +17,7 @@ from .monotonic_align import maximum_path from .feature_extraction import DbMelFeatureExtraction -from ..glowTTS.feature_config import DbMelFeatureExtractionConfig +from ..feature_config import DbMelFeatureExtractionConfig class DurationPredictor(nn.Module): diff --git a/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/gt_extractor.py b/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/gt_extractor.py index 20c973003..859b54970 100644 --- a/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/gt_extractor.py +++ b/users/rilling/experiments/librispeech/librispeech_glowtts/pytorch_networks/gt_extractor.py @@ -16,7 +16,7 @@ from .monotonic_align import maximum_path from .feature_extraction import DbMelFeatureExtraction -from ..glowTTS.feature_config import DbMelFeatureExtractionConfig +from ..feature_config import DbMelFeatureExtractionConfig class Model(nn.Module): """ diff --git a/users/rilling/experiments/librispeech/librispeech_100_hybrid/__init__.py b/users/rilling/experiments/librispeech/librispeech_glowtts/vocoder/__init__.py similarity index 100% rename from users/rilling/experiments/librispeech/librispeech_100_hybrid/__init__.py rename to users/rilling/experiments/librispeech/librispeech_glowtts/vocoder/__init__.py diff --git a/users/rilling/experiments/librispeech/tts_architecture_improvement_23/ctc_aligner/config.py b/users/rilling/experiments/librispeech/librispeech_glowtts/vocoder/config.py similarity index 64% rename from users/rilling/experiments/librispeech/tts_architecture_improvement_23/ctc_aligner/config.py rename to users/rilling/experiments/librispeech/librispeech_glowtts/vocoder/config.py index a1ec66639..83c9d41e5 100644 --- a/users/rilling/experiments/librispeech/tts_architecture_improvement_23/ctc_aligner/config.py +++ b/users/rilling/experiments/librispeech/librispeech_glowtts/vocoder/config.py @@ -7,19 +7,20 @@ from i6_experiments.users.rossenbach.common_setups.returnn.datasets import ( GenericDataset, ) -from .data import AlignmentTrainingDatasets +from .data import TrainingDataset from ..serializer import get_network_serializer, get_pytorch_serializer def get_training_config( - returnn_common_root: tk.Path, - training_datasets: AlignmentTrainingDatasets, - network_module: str, - net_args: Dict[str, Any], - config: Dict[str, Any], - debug: bool = False, - pytorch_mode=False, - use_custom_engine=False, + returnn_common_root: tk.Path, + training_datasets: TrainingDataset, + network_module: str, + net_args: Dict[str, Any], + config: Dict[str, Any], + debug: bool = False, + pytorch_mode=False, + use_custom_engine=False, + keep_epochs: set = None, ): """ Returns the RETURNN config serialized by :class:`ReturnnCommonSerializer` in returnn_common for the ctc_aligner @@ -31,14 +32,15 @@ def get_training_config( # changing these does not change the hash post_config = { - "cleanup_old_models": True, - "stop_on_nonfinite_train_score": False, # this might break now with True + "cleanup_old_models": True if keep_epochs is None else {"keep": keep_epochs}, + "stop_on_nonfinite_train_score": True, # this might break now with True + "allow_missing_optimizer_checkpoint": True, } base_config = { ############# "train": training_datasets.train.as_returnn_opts(), - "dev": training_datasets.cv.as_returnn_opts() + "dev": training_datasets.cv.as_returnn_opts(), } config = {**base_config, **copy.deepcopy(config)} @@ -56,16 +58,19 @@ def get_training_config( network_module=network_module, net_args=net_args, debug=debug, - use_custom_engine=use_custom_engine - ) - returnn_config = ReturnnConfig( - config=config, post_config=post_config, python_epilog=[serializer] + use_custom_engine=use_custom_engine, ) + returnn_config = ReturnnConfig(config=config, post_config=post_config, python_epilog=[serializer]) return returnn_config -def get_forward_config( - returnn_common_root, forward_dataset: GenericDataset, datastreams, network_module, net_args, debug=False, pytorch_mode=False, +def get_extract_durations_forward__config( + returnn_common_root, + forward_dataset: GenericDataset, + network_module, + net_args, + debug=False, + pytorch_mode=False, ): """ Returns the RETURNN config serialized by :class:`ReturnnCommonSerializer` in returnn_common for forward_ctc_aligner @@ -76,30 +81,39 @@ def get_forward_config( """ config = { "behavior_version": 16, - "forward_batch_size": 28000, + "batch_size": 28000, "max_seq_length": {"audio_features": 1000}, "max_seqs": 200, "forward_use_search": True, - "target": "extract_alignment", ############# - "eval": forward_dataset.as_returnn_opts() + "eval": forward_dataset.joint.as_returnn_opts(), } get_serializer = get_pytorch_serializer if pytorch_mode else get_network_serializer serializer = get_serializer( training=False, returnn_common_root=returnn_common_root, - datastreams=datastreams, network_module=network_module, net_args=net_args, - debug=debug + forward=True, + debug=debug, ) returnn_config = ReturnnConfig(config=config, python_epilog=[serializer]) return returnn_config -def get_pt_forward_config( - returnn_common_root, forward_dataset: GenericDataset, datastreams, network_module, net_args, debug=False, pytorch_mode=False, +def get_forward_config( + returnn_common_root, + forward_dataset: GenericDataset, + network_module, + net_args, + config, + debug=False, + pytorch_mode=False, + forward_args={}, + target="audio", + train_data=False, + joint_data=False, ): """ Returns the RETURNN config serialized by :class:`ReturnnCommonSerializer` in returnn_common for forward_ctc_aligner @@ -108,24 +122,35 @@ def get_pt_forward_config( :param kwargs: arguments to be passed to the network construction :return: RETURNN forward config """ - config = { - "batch_size": 28000, - "max_seqs": 200, + fd = None + if isinstance(forward_dataset, tuple): + fd = forward_dataset[0].as_returnn_opts() + elif train_data: + fd = forward_dataset.train.as_returnn_opts() + elif joint_data: + fd = forward_dataset.joint.as_returnn_opts() + else: + fd = forward_dataset.cv.as_returnn_opts() + + base_config = { + "behavior_version": 16, + "forward_use_search": True, ############# - "forward": forward_dataset.as_returnn_opts() + "forward": fd, } + + config = {**base_config, **copy.deepcopy(config)} get_serializer = get_pytorch_serializer if pytorch_mode else get_network_serializer serializer = get_serializer( training=False, returnn_common_root=returnn_common_root, - datastreams=datastreams, network_module=network_module, - forward=True, net_args=net_args, - debug=debug + forward_args=forward_args, + forward=True, + debug=debug, + target=target, ) returnn_config = ReturnnConfig(config=config, python_epilog=[serializer]) return returnn_config - - diff --git a/users/rilling/experiments/librispeech/librispeech_glowtts/vocoder/data.py b/users/rilling/experiments/librispeech/librispeech_glowtts/vocoder/data.py new file mode 100644 index 000000000..3d92b0075 --- /dev/null +++ b/users/rilling/experiments/librispeech/librispeech_glowtts/vocoder/data.py @@ -0,0 +1,370 @@ +from dataclasses import dataclass +import os +from functools import lru_cache +from sisyphus import tk +from typing import Dict, List, Optional, Tuple + +from i6_core.returnn.dataset import SpeakerLabelHDFFromBlissJob +from i6_core.returnn import CodeWrapper, BlissToOggZipJob + +from returnn_common.datasets import Dataset, OggZipDataset, HDFDataset, MetaDataset +from i6_experiments.users.rossenbach.common_setups.returnn.datastreams.base import Datastream +from i6_experiments.users.rossenbach.common_setups.returnn.datastreams.vocabulary import LabelDatastream + +from i6_experiments.users.rossenbach.datasets.librispeech import get_librispeech_tts_segments + +from ..data import ( + get_tts_log_mel_datastream, + get_audio_raw_datastream, + get_train_bliss_and_zip, + get_vocab_datastream, + get_mixed_cv_segments, + get_bliss_corpus_dict, + get_lexicon, +) +from ..default_tools import MINI_RETURNN_ROOT, RETURNN_PYTORCH_EXE + +EpochWiseFilter = Tuple[int, int, int] + +@dataclass(frozen=True) +class TrainingDataset: + """ + Dataclass for Alignment Datasets + """ + + train: Dataset + cv: Dataset + joint: Dataset + datastreams: Dict[str, Datastream] + +@dataclass() +class TrainingDatasetSettings: + # features settings + custom_processing_function: Optional[str] + + # training settings + partition_epoch: int + epoch_wise_filters: List[EpochWiseFilter] + seq_ordering: str + +def make_meta_dataset(audio_dataset, speaker_dataset, duration_dataset=None, xvector_dataset=None): + """ + Shared function to create a metadatset with joined audio and speaker information + + :param datasets.OggZipDataset audio_dataset: + :param datasets.HDFDataset speaker_dataset: + :return: + :rtype: MetaDataset + """ + data_map = { + "audio_features": ("audio", "data"), + "phonemes": ("audio", "classes"), + "speaker_labels": ("speaker", "data"), + } + + ds = { + "audio": audio_dataset.as_returnn_opts(), + "speaker": speaker_dataset.as_returnn_opts() + } + + if duration_dataset: + data_map["durations"] = ("durations", "data") + ds["durations"] = duration_dataset.as_returnn_opts() + + if xvector_dataset is not None: + data_map["xvectors"] = ("xvectors", "data") + ds["xvectors"] = xvector_dataset.as_returnn_opts() + + meta_dataset = MetaDataset( + data_map=data_map, + datasets=ds, + seq_order_control_dataset="audio", + ) + return meta_dataset + +def build_training_dataset( + librispeech_key: str, + settings: TrainingDatasetSettings, + silence_preprocessing=False, + xvectors_file=None, +) -> TrainingDataset: + """ + + :param settings: + :param output_path: + """ + train_bliss, train_ogg = get_train_bliss_and_zip("train-clean-100", silence_preprocessed=silence_preprocessing) + # _, dev_clean_ogg = get_train_bliss_and_zip("dev-clean", silence_preprocessed=silence_preprocessing, remove_unk_seqs=True) + # _, dev_other_ogg = get_train_bliss_and_zip("dev-other", silence_preprocessed=silence_preprocessing, remove_unk_seqs=True) + + train_bpe_datastream = get_vocab_datastream(corpus_key=librispeech_key, with_blank=True) + audio_datastream = get_audio_raw_datastream() + + train_segments, cv_segments = get_librispeech_tts_segments(ls_corpus_key=librispeech_key) + + speaker_label_job = SpeakerLabelHDFFromBlissJob( + bliss_corpus=train_bliss, + returnn_root=MINI_RETURNN_ROOT, + ) + joint_speaker_hdf = speaker_label_job.out_speaker_hdf + + joint_speaker_dataset = HDFDataset( + files=[joint_speaker_hdf] + ) + speaker_datastream = LabelDatastream( + available_for_inference=True, + vocab_size=speaker_label_job.out_num_speakers, + vocab=speaker_label_job.out_speaker_dict, + ) + + datastreams = { + "audio_features": audio_datastream, + "phonemes": train_bpe_datastream, + "speaker_labels": speaker_datastream, + } + + if xvectors_file is not None: + xvector_dataset = HDFDataset(files=[xvectors_file]) + xvector_dataset_train = HDFDataset(files=[xvectors_file], segment_file=train_segments) + xvector_dataset_cv = HDFDataset(files=[xvectors_file], segment_file=cv_segments) + else: + xvector_dataset, xvector_dataset_train, xvector_dataset_cv = (None, None, None) + + training_audio_opts = audio_datastream.as_returnn_audio_opts() + if settings.custom_processing_function: + training_audio_opts["pre_process"] = CodeWrapper(settings.custom_processing_function) + + additional_opts = {} + if settings.epoch_wise_filters: + additional_opts["epoch_wise_filter"] = {} + for fr, to, max_mean_len in settings.epoch_wise_filters: + additional_opts["epoch_wise_filter"][(fr, to)] = {"max_mean_len": max_mean_len} + + train_zip_dataset = OggZipDataset( + files=train_ogg, + audio_options=training_audio_opts, + target_options=train_bpe_datastream.as_returnn_targets_opts(), + partition_epoch=settings.partition_epoch, + segment_file=train_segments, + seq_ordering=settings.seq_ordering, + additional_options=additional_opts, + ) + train_dataset = make_meta_dataset(train_zip_dataset, joint_speaker_dataset, xvector_dataset=xvector_dataset_train) + + cv_zip_dataset = OggZipDataset( + files=train_ogg, + audio_options=audio_datastream.as_returnn_audio_opts(), + target_options=train_bpe_datastream.as_returnn_targets_opts(), + segment_file=cv_segments, + seq_ordering="sorted_reverse", + ) + cv_dataset = make_meta_dataset(cv_zip_dataset, joint_speaker_dataset, xvector_dataset=xvector_dataset_cv) + + devtrain_zip_dataset = OggZipDataset( + files=train_ogg, + audio_options=audio_datastream.as_returnn_audio_opts(), + target_options=train_bpe_datastream.as_returnn_targets_opts(), + seq_ordering="sorted_reverse", + # random_subset=3000, + ) + devtrain_dataset = make_meta_dataset(devtrain_zip_dataset, joint_speaker_dataset, xvector_dataset=xvector_dataset) + + return TrainingDataset(train=train_dataset, cv=cv_dataset, joint=devtrain_dataset, datastreams=datastreams) + +def build_training_dataset2( + settings: TrainingDatasetSettings, + ls_corpus_key="train-clean-100", + durations_file=None, + silence_preprocessed=True, + ) -> TrainingDataset: + """ + + :param center: do feature centering + """ + # bliss_dataset, zip_dataset = get_train_bliss_and_zip(ls_corpus_key=ls_corpus_key, silence_preprocessed=silence_preprocessed) + + train_bliss, train_ogg = get_train_bliss_and_zip(ls_corpus_key=ls_corpus_key, silence_preprocessed=silence_preprocessed) + _, dev_clean_ogg = get_train_bliss_and_zip("dev-clean", silence_preprocessed=False, remove_unk_seqs=True) + _, dev_other_ogg = get_train_bliss_and_zip("dev-other", silence_preprocessed=False, remove_unk_seqs=True) + + # segments for train-clean-100-tts-train and train-clean-100-tts-dev + # (1004 segments for dev, 4 segments for each of the 251 speakers) + train_segments, cv_segments = get_librispeech_tts_segments(ls_corpus_key=ls_corpus_key) + + vocab_datastream = get_vocab_datastream(with_blank=True, corpus_key=ls_corpus_key) + # log_mel_datastream = get_tts_log_mel_datastream(center=center) + + audio_datastream = get_audio_raw_datastream() + + # we currently assume that train and cv share the same corpus file + speaker_label_job = SpeakerLabelHDFFromBlissJob( + bliss_corpus=train_bliss, + returnn_root=MINI_RETURNN_ROOT, + ) + joint_speaker_hdf = speaker_label_job.out_speaker_hdf + + joint_speaker_dataset = HDFDataset( + files=[joint_speaker_hdf] + ) + speaker_datastream = LabelDatastream( + available_for_inference=True, + vocab_size=speaker_label_job.out_num_speakers, + vocab=speaker_label_job.out_speaker_dict, + ) + + if durations_file: + duration_dataset = HDFDataset( + files=[durations_file] + ) + + # ----- Ogg and Meta datasets + training_audio_opts = audio_datastream.as_returnn_audio_opts() + + if settings.custom_processing_function: + training_audio_opts["pre_process"] = CodeWrapper(settings.custom_processing_function) + + additional_opts = {} + if settings.epoch_wise_filters: + additional_opts["epoch_wise_filter"] = {} + for fr, to, max_mean_len in settings.epoch_wise_filters: + additional_opts["epoch_wise_filter"][(fr, to)] = {"max_mean_len": max_mean_len} + + train_ogg_dataset = OggZipDataset( + path=train_ogg, + audio_options=training_audio_opts, + target_options=vocab_datastream.as_returnn_targets_opts(), + segment_file=train_segments, + partition_epoch=settings.partition_epoch, + seq_ordering="laplace:.1000" + ) + if durations_file: + train_dataset = make_meta_dataset(train_ogg_dataset, joint_speaker_dataset, duration_dataset=duration_dataset) + else: + train_dataset = make_meta_dataset(train_ogg_dataset, joint_speaker_dataset) + + cv_ogg_dataset = OggZipDataset( + path=train_ogg, + audio_options=audio_datastream.as_returnn_audio_opts(), + target_options=vocab_datastream.as_returnn_targets_opts(), + segment_file=cv_segments, + partition_epoch=1, + seq_ordering="sorted", + ) + if durations_file: + cv_dataset = make_meta_dataset(cv_ogg_dataset, joint_speaker_dataset, duration_dataset=duration_dataset) + else: + cv_dataset = make_meta_dataset(cv_ogg_dataset, joint_speaker_dataset) + + joint_ogg_zip = OggZipDataset( + path=train_ogg, + audio_options=audio_datastream.as_returnn_audio_opts(), + target_options=vocab_datastream.as_returnn_targets_opts(), + partition_epoch=1, + seq_ordering="sorted", + ) + joint_metadataset = make_meta_dataset(joint_ogg_zip, joint_speaker_dataset) + + # ----- final outputs + + datastreams = { + "audio_features": audio_datastream, + "phonemes": vocab_datastream, + "speaker_labels": speaker_datastream, + } + + align_datasets = TrainingDataset( + train=train_dataset, + cv=cv_dataset, + joint=joint_metadataset, + datastreams=datastreams, + ) + + return align_datasets + +def build_swer_test_dataset(synthetic_bliss, preemphasis: Optional[float] = None, peak_normalization: bool = False): + """ + + :param synthetic_bliss: + :param preemphasis: + :param peak_normalization: + """ + zip_dataset_job = BlissToOggZipJob( + bliss_corpus=synthetic_bliss, + no_conversion=True, # for Librispeech we are already having ogg + returnn_python_exe=RETURNN_PYTORCH_EXE, + returnn_root=MINI_RETURNN_ROOT, + ) + + audio_datastream = get_audio_raw_datastream(preemphasis, peak_normalization) + + data_map = {"raw_audio": ("zip_dataset", "data")} + + test_zip_dataset = OggZipDataset( + files=[zip_dataset_job.out_ogg_zip], + audio_options=audio_datastream.as_returnn_audio_opts(), + seq_ordering="sorted_reverse", + ) + test_dataset = MetaDataset( + data_map=data_map, datasets={"zip_dataset": test_zip_dataset}, seq_order_control_dataset="zip_dataset" + ) + + return test_dataset + + +@lru_cache() +def build_tts_forward_dataset(librispeech_key: str, dataset_key: str, xvectors_file: tk.Path = None): + """ + + :param librispeech_key: base librispeech training set for vocab generation + :param dataset_key: test dataset to generate + :param silence_preprocessing: use a setup with silence preprocessing + """ + + _, test_ogg = get_train_bliss_and_zip(ls_corpus_key=dataset_key, silence_preprocessed=False, remove_unk_seqs=True) + bliss_dict = get_bliss_corpus_dict() + # audio_datastream = get_audio_raw_datastream() + tts_lexicon = get_lexicon(with_blank=True) + phonemes_datastream = get_vocab_datastream(corpus_key=librispeech_key, with_blank=True) + + bliss_corpus = bliss_dict[dataset_key] + + data_map = {"audio": ("zip_dataset", "data"), "phonemes": ("zip_dataset", "classes")} + + audio_datastream = get_audio_raw_datastream() + test_zip_dataset = OggZipDataset( + files=[test_ogg], + audio_options=audio_datastream.as_returnn_audio_opts(), + target_options=phonemes_datastream.as_returnn_targets_opts(), + seq_ordering="sorted_reverse", + ) + + if xvectors_file is not None: + x_vectors_dataset = HDFDataset(files=[xvectors_file]) + data_map["xvectors"] = ("xvectors", "data") + test_dataset = MetaDataset( + data_map=data_map, + datasets={"zip_dataset": test_zip_dataset, "xvectors": x_vectors_dataset}, + seq_order_control_dataset="zip_dataset", + ) + else: + speaker_label_job = SpeakerLabelHDFFromBlissJob( + bliss_corpus=bliss_corpus, + returnn_root=MINI_RETURNN_ROOT, + ) + joint_speaker_hdf = speaker_label_job.out_speaker_hdf + + joint_speaker_dataset = HDFDataset(files=[joint_speaker_hdf]) + speaker_datastream = LabelDatastream( + available_for_inference=True, + vocab_size=speaker_label_job.out_num_speakers, + vocab=speaker_label_job.out_speaker_dict, + ) + + data_map["speaker_labels"] = ("speakers", "data") + test_dataset = MetaDataset( + data_map=data_map, + datasets={"zip_dataset": test_zip_dataset, "speakers": joint_speaker_dataset}, + seq_order_control_dataset="zip_dataset", + ) + + return test_dataset, bliss_corpus diff --git a/users/rilling/experiments/librispeech/librispeech_glowtts/vocoder/pipeline.py b/users/rilling/experiments/librispeech/librispeech_glowtts/vocoder/pipeline.py new file mode 100644 index 000000000..49a7915e7 --- /dev/null +++ b/users/rilling/experiments/librispeech/librispeech_glowtts/vocoder/pipeline.py @@ -0,0 +1,81 @@ +import os +import copy +from sisyphus import tk +from i6_core.returnn import ReturnnTrainingJob +from i6_core.returnn.forward import ReturnnForwardJob, ReturnnForwardJobV2 +from i6_core.returnn.search import SearchBPEtoWordsJob +from i6_experiments.users.rossenbach.common_setups.returnn.datasets import GenericDataset +from i6_experiments.users.rossenbach.tts.evaluation.nisqa import NISQAMosPredictionJob + +from ..default_tools import NISQA_REPO, SCTK_BINARY_PATH + +def training(config, returnn_exe, returnn_root, prefix, num_epochs=65): + + train_job = ReturnnTrainingJob( + config, + log_verbosity=5, + num_epochs=num_epochs, + time_rqmt=100, + mem_rqmt=10, + cpu_rqmt=4, + returnn_python_exe=returnn_exe, + returnn_root=returnn_root, +) + train_job.add_alias(prefix + "/training") + tk.register_output(prefix + "/training.models", train_job.out_model_dir) + + return train_job + +def glowTTS_forward(checkpoint, config, returnn_exe, returnn_root, prefix, alias_addition=None, target="audio", extra_evaluation_epoch=None, joint_data=False, device="gpu"): + hdf_outputs = [] if target != "audio" else ["/var/tmp/lukas.rilling/out"] + if target == "audio": + hdf_outputs = ["/var/tmp/lukas.rilling/out"] + elif target == "latent_space": + hdf_outputs = ["samples.hdf", "mean.hdf"] + # hdf_outputs = ["samples.hdf"] + else: + hdf_outputs = [] + + last_forward_job = ReturnnForwardJob( + model_checkpoint=checkpoint, + returnn_config=config, + hdf_outputs=hdf_outputs, + returnn_python_exe=returnn_exe, + returnn_root=returnn_root, + mem_rqmt=20, + device=device + ) + + if (target == "spectrogram" and joint_data): + last_forward_job.rqmt["gpu_mem"] = 24 + + forward_prefix = prefix + "/forward" + + if target != "audio": + forward_prefix += f"_{target}" + + if extra_evaluation_epoch is not None: + forward_prefix += f"_extra_evaluation_{extra_evaluation_epoch}" + + if alias_addition: + forward_prefix += alias_addition + + forward_suffix = f"/{target}" + + last_forward_job.add_alias(forward_prefix) + + tts_hdf = None + + if target == "audio": + tts_hdf = last_forward_job.out_hdf_files["/var/tmp/lukas.rilling/out"] + tk.register_output(forward_prefix + forward_suffix, tts_hdf) + elif target == "latent_space": + samples_hdf = last_forward_job.out_hdf_files["samples.hdf"] + mean_hdf = last_forward_job.out_hdf_files["mean.hdf"] + tk.register_output(forward_prefix + forward_suffix + "/samples", samples_hdf) + tk.register_output(forward_prefix + forward_suffix + "/mean", mean_hdf) + else: + tts_hdf = last_forward_job.out_hdf_files["output.hdf"] + tk.register_output(forward_prefix + forward_suffix, tts_hdf) + + return last_forward_job diff --git a/users/rilling/experiments/librispeech/librispeech_glowtts/glowTTS/vocoder/simple_gl.py b/users/rilling/experiments/librispeech/librispeech_glowtts/vocoder/simple_gl.py similarity index 93% rename from users/rilling/experiments/librispeech/librispeech_glowtts/glowTTS/vocoder/simple_gl.py rename to users/rilling/experiments/librispeech/librispeech_glowtts/vocoder/simple_gl.py index 7cc513e06..841d37dd9 100644 --- a/users/rilling/experiments/librispeech/librispeech_glowtts/glowTTS/vocoder/simple_gl.py +++ b/users/rilling/experiments/librispeech/librispeech_glowtts/vocoder/simple_gl.py @@ -7,10 +7,10 @@ from i6_core.tools.git import CloneGitRepositoryJob -from ..data import build_training_dataset, TrainingDatasetSettings -from ..config import get_training_config -from ..pipeline import glowTTS_training as training -from ...data import get_tts_log_mel_datastream +from .data import build_training_dataset, TrainingDatasetSettings +from .config import get_training_config +from .pipeline import training +from ..data import get_tts_log_mel_datastream from i6_experiments.users.rossenbach.common_setups.returnn.datastreams.audio import DBMelFilterbankOptions @@ -75,7 +75,7 @@ def run_exp(name, params, net_module, config, use_custom_engine=False, debug=Fal norm = (log_mel_datastream.additional_options["norm_mean"], log_mel_datastream.additional_options["norm_std_dev"]) - from ...pytorch_networks.vocoder.simple_gl.blstm_gl_predictor import BlstmGLPredictorConfig + from ..pytorch_networks.vocoder.simple_gl.blstm_gl_predictor import BlstmGLPredictorConfig from ..feature_config import DbMelFeatureExtractionConfig assert isinstance(log_mel_datastream.options.feature_options, DBMelFilterbankOptions) fe_config = DbMelFeatureExtractionConfig( diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training/experiments.py b/users/rilling/experiments/librispeech/librispeech_joint_training/experiments.py index 3b116ab20..dd1ecffe2 100644 --- a/users/rilling/experiments/librispeech/librispeech_joint_training/experiments.py +++ b/users/rilling/experiments/librispeech/librispeech_joint_training/experiments.py @@ -34,13 +34,12 @@ def get_glow_joint(x_vector_exp, gl_checkpoint): - """ - Baseline for the glow TTS in returnn_common with serialization + """Experiments on joint training of Glow-TTS and a Conformer ASR using the latent space of Glow-TTS as features. - Uses updated RETURNN_COMMON - - :return: durations_hdf - """ + :param dict x_vector_exp: Dictionary of x-vector experiments from ../librispeech_x_vectors to import x-vector model for on-the-fly speaker embedding generation for TTS and ASR + :param dict gl_checkpoint: Dictionary containing checkpoint and config of a BLSTM transforming log-mel into linear spectrogram for G&L vocoding + :return dict: Dictionary containing the experiments with all their jobs to be used to import checkpoints or other job attributes in other experiments + """ prefix = "experiments/librispeech/joint_training/default/raw_audio/" experiments = {} @@ -68,6 +67,31 @@ def run_exp( large_gpu_training=False, with_prior=False, ): + """Creates the Jobs for training, TTS generation/forwarding, ASR search and evaluations + + :param str name: Name of the experiment for alias creation + :param dict args: General arguments for training, forward and search configs + :param TrainingDataset dataset: Dataset used for training and TTS forwarding (without eval.) + :param dict test_dataset: Dictionary containing datasets to be used for ASR evaluation + :param int num_epochs: Number of epochs in training, defaults to 100 + :param bool use_custom_engine: whether a custom engine is to be used in Returnn, defaults to False + :param dict training_args: Additional arguments for training, passed to the train step, defaults to {} + :param dict forward_args: Additional arguments for forwarding passed to the forward step, defaults to {} + :param dict search_args: Additional arguments for search passed to the search init step, defaults to {} + :param list[int] keep_epochs: List of checkpoints that should be kept during training, defaults to None + :param bool extract_x_vector: whether the x-vectors whould be extracted into an HDF (only useful if x-vector model is unfrozen), defaults to False + :param bool tts_forward: whether TTS forwarding should be run (not evaluation, uses training dataset), defaults to True + :param bool asr_search: whether ASR search should be run, defaults to True + :param bool use_speaker_labels_in_dev: whether the validation set should contain speaker labels, defaults to False + :param ReturnnTrainingJob given_train_job_for_forward: , defaults to None + :param bool eval_tts: whether TTS should be evaluated, defaults to False + :param dict tts_eval_datasets: Dictionary containing datasets for TTS evaluation, defaults to None + :param bool eval_invertibility: whether invertibility of coupling blocks should be evaluated, defaults to False + :param bool eval_asr_invertibility: whether the invertibility of the ASR usage of the coupling blocks should be evaluated (only useful if separate passes are used for TTS and ASR), defaults to False + :param bool large_gpu_training: whether the GPU memory requirement for trianing should be set to 24GB, defaults to False + :param bool with_prior: Whether the prior of the internal language model should be estimated for prior correction (defaults to True if search_args["prior_scale]!=0), defaults to False + :return dict: Dictionary containing all the jobs for this experiment + """ exp = {} with_prior = with_prior or ("prior_scale" in search_args and search_args["prior_scale"] != 0) diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/README.md b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/README.md new file mode 100644 index 000000000..13872af24 --- /dev/null +++ b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/README.md @@ -0,0 +1,15 @@ +# Joint Training using given alignments + +The naming of this folder might be confusing: Despite the name "joint training" this does not contain experiments jointly training TTS and ASR like it is done in "librispeech_joint_training", but this folder contains experiments using an additional auxiliary loss to influence the latent space of Glow-TTS during TTS training. + +Additionally this setup is the newest of the setups dealing with joint modelling of TTS and ASR and therefore contains functions to create datasets for TTS and ASR with additional external durations and x-vector speaker embeddings for TTS forwarding as well as explicit model configs that are written to the Returnn Config to enforce that all model parameters are stored in the Returnn config and considered for hash computation of the returnn jobs. + +Therefore the folder [`exp_tts`](./exp_tts/) contains additional TTS-only experiments similar to the experiments in [`librispeech_glowtts`](../librispeech_glowtts/). + +The folder [`exp_joint`](./exp_joint/) contains TTS trainings with auxiliary loss, where the aux. loss is computed on the phoneme labels that are upsampled using an external Glow-TTS Viterbi alignment, given as an HDF. + +The folder [`exp_joint_flow_ga`](./exp_joint_flow_ga/) contains similar experiments but instead of using MAS to compute the Viterbi alignment during training the external alignment is also used for the TTS itself. + +[`exp_joint_flow_ga_frozen_glowtts`](./exp_joint_flow_ga_frozen_glowtts/) additionally freezes the Glow-TTS parameters and only trains the phoneme reconstruction from different parts of the latent space, making it similar to the "encoder_test/decoder_test/encoder_sample" experiments in [`librispeech_glowtts`](../librispeech_glowtts/) and [`librispeech_glow_asr`](../librispeech_glow_asr/). + +[`exp_joint_2step`](./exp_joint_2step/) contains a mixture of experiments using two steps of training. The first block in the respective experiment.py contains trainings where in the first step a very strong auxiliary loss was used, after which the TTS is then further trained without an aux. loss in a second training. Additionally, it contains further ASR trainings using BLSTM or Conformer on a TTS trained with aux. loss to see the effect of the aux. loss on WER. diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/exp_joint/experiments.py b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/exp_joint/experiments.py index adf39a1bc..9e4f161a4 100644 --- a/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/exp_joint/experiments.py +++ b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/exp_joint/experiments.py @@ -36,14 +36,13 @@ from ..storage import tts_models, add_tts_model, TTSModel -def get_glow_joint(x_vector_exp, joint_exps, tts_exps, gl_checkpoint): - """ - Baseline for the glow TTS in returnn_common with serialization +def get_glow_joint(x_vector_exp, tts_exps, gl_checkpoint): + """Experiments training TTS jointly with phoneme prediction network as an auxiliary loss - Uses updated RETURNN_COMMON - - :return: durations_hdf - """ + :param dict x_vector_exp: Dictionary containing x-vector experiments from ../../librispeech_x_vectors + :param dict tts_exps: Dictionary containing TTS-only experiments from ../../librispeech_glowtts + :param dict gl_checkpoint: _description_ + """ prefix = "experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/" experiments = {} @@ -59,26 +58,40 @@ def run_exp( forward_args={}, search_args={}, keep_epochs=None, - extract_x_vector=False, tts_forward=True, asr_search=True, phoneme_pred=True, encoder_phoneme_pred=False, - asr_cv_set=False, - given_train_job_for_forward=None, tts_eval_datasets=None, ): + """Creates the job for an experiment + + :param str name: Name of the experiment used for aliases + :param dict args: General arguments used for the Returnn Configs + :param TrainingDataset dataset: Dataset for training + :param dict test_dataset: Dictionary of datasets used for evaluation + :param int num_epochs: Number of epochs for training, defaults to 100 + :param bool use_custom_engine: whether a custom engine is used in Returnn, defaults to False + :param dict training_args: Additional arguments for training, defaults to {} + :param dict forward_args: Additional arguments for TTS forward, defaults to {} + :param dict search_args: Additional arguments for phoneme prediction, defaults to {} + :param list[int] keep_epochs: List of numbers of checkpoints that are supposed to be kept during training, defaults to None + :param bool tts_forward: whether TTS evaluation should be run (autoMOS, NISQA), defaults to True + :param bool asr_search: whether ASR search should be run, defaults to True + :param bool phoneme_pred: whether phoneme prediction evaluation should be run, defaults to True + :param bool encoder_phoneme_pred: whether phoneme prediction evaluation should be run using encoder output instead of inverse decoder output as the input, defaults to False + :param dict tts_eval_datasets: Dictionary containing datasets for TTS evaluation, defaults to None + :return dict: Dictionary containing all the job references for the given experiment + """ exp = {} - if given_train_job_for_forward is None: - training_config = get_training_config( - training_datasets=dataset, - **args, - training_args=training_args, - use_custom_engine=use_custom_engine, - keep_epochs=keep_epochs, - asr_cv_set=asr_cv_set, - ) # implicit reconstruction loss + training_config = get_training_config( + training_datasets=dataset, + **args, + training_args=training_args, + use_custom_engine=use_custom_engine, + keep_epochs=keep_epochs, + ) if asr_search or phoneme_pred: search_config = get_search_config( @@ -95,16 +108,13 @@ def run_exp( if encoder_phoneme_pred: encoder_phoneme_pred_config = get_search_config(**args, search_args=search_args, target="encoder_phoneme") - if given_train_job_for_forward is None: - train_job = training( - config=training_config, - returnn_exe=RETURNN_PYTORCH_EXE, - returnn_root=MINI_RETURNN_ROOT, - prefix=prefix + name, - num_epochs=num_epochs, - ) - else: - train_job = given_train_job_for_forward + train_job = training( + config=training_config, + returnn_exe=RETURNN_PYTORCH_EXE, + returnn_root=MINI_RETURNN_ROOT, + prefix=prefix + name, + num_epochs=num_epochs, + ) exp["train_job"] = train_job if tts_forward: @@ -133,19 +143,6 @@ def run_exp( ) exp["forward_job_gl"] = forward_job_gl - if extract_x_vector: - forward_x_vector_config = get_forward_config( - forward_dataset=dataset, **args, forward_args=forward_args, target="xvector", train_data=True - ) - forward_xvector_job = forward( - checkpoint=train_job.out_checkpoints[num_epochs], - config=forward_x_vector_config, - returnn_exe=RETURNN_PYTORCH_EXE, - returnn_root=MINI_RETURNN_ROOT, - prefix=prefix + name, - target="xvector", - ) - exp["forward_xvector_job"] = forward_xvector_job if asr_search: search( prefix + name + "/search", @@ -175,19 +172,10 @@ def run_exp( ) return exp - # def get_lr_scale(dim_model, step_num, warmup_steps): - # return np.power(dim_model, -0.5) * np.min( - # [np.power(step_num + 1, -0.5), step_num + 1 * np.power(warmup_steps, -1.5)] - # ) - train_settings = TrainingDatasetSettings( custom_processing_function=None, partition_epoch=3, epoch_wise_filters=[], seq_ordering="laplace:.1000" ) - # training_datasets = build_training_dataset( - # settings=train_settings, librispeech_key="train-clean-100", silence_preprocessing=False - # ) - glowTTS_durations_job = tts_exps["glowTTS/enc192/200ep/long_cooldown/not_silence_preprocessed"]["forward_job_joint_durations"] training_datasets_tts_segments = build_training_dataset( settings=train_settings, @@ -196,9 +184,6 @@ def run_exp( use_tts_train_segments=True, durations_file=glowTTS_durations_job.out_hdf_files["output.hdf"] ) - # training_datasets_silence_preprocessed = build_training_dataset( - # settings=train_settings, librispeech_key="train-clean-100", silence_preprocessing=True - # ) train_settings_pe1 = TrainingDatasetSettings( custom_processing_function=None, partition_epoch=1, epoch_wise_filters=[], seq_ordering="laplace:.1000" ) @@ -306,24 +291,6 @@ def run_exp( max_dim_feat=8, num_repeat_feat=5, ) - frontend_config = VGG4LayerActFrontendV1Config_mod( - in_features=80, - conv1_channels=16, - conv2_channels=16, - conv3_channels=16, - conv4_channels=16, - conv_kernel_size=(3, 3), - conv_padding=None, - pool1_kernel_size=(2, 1), - pool1_stride=(2, 1), - pool1_padding=None, - pool2_kernel_size=(2, 1), - pool2_stride=(2, 1), - pool2_padding=None, - activation_str="ReLU", - out_features=96, - activation=None, - ) text_encoder_config = TextEncoderConfig( n_vocab=label_datastream_tts.vocab_size, hidden_channels=192, diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/exp_joint_2step/experiments.py b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/exp_joint_2step/experiments.py index 167f98973..119e2e8c7 100644 --- a/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/exp_joint_2step/experiments.py +++ b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/exp_joint_2step/experiments.py @@ -42,12 +42,10 @@ def get_glow_joint_2step(x_vector_exp, joint_exps, tts_exps, gl_checkpoint): """ - Baseline for the glow TTS in returnn_common with serialization - - Uses updated RETURNN_COMMON - - :return: durations_hdf - """ + Experiments performing two step training (first block) or further training on pre-trained models from ../exp_joint and ../exp_joint_ga (second and third block) + The experiments contain further TTS training after a first train step with very strong auxiliary loss (first block) + but also ASR and phoneme prediction trainings after a pre-training (last blocks) + """ prefix = "experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/" experiments = {} @@ -63,28 +61,43 @@ def run_exp( forward_args={}, search_args={}, keep_epochs=None, - extract_x_vector=False, tts_forward=True, asr_search=True, phoneme_pred=True, asr_cv_set=False, - given_train_job_for_forward=None, ): + """Creates the jobs to run training, forwarding/TTS evaluation and phoneme prediction evaluation for the given experiment + + :param str name: Name of the experiment used for aliases + :param dict args: General arguments used for the Returnn Configs + :param TrainingDataset dataset: Dataset for training + :param dict test_dataset: Dictionary of datasets used for evaluation + :param int num_epochs: Number of epochs for training, defaults to 100 + :param bool use_custom_engine: whether a custom engine is used in Returnn, defaults to False + :param dict training_args: Additional arguments for training, defaults to {} + :param dict forward_args: Additional arguments for TTS forward, defaults to {} + :param dict search_args: Additional arguments for phoneme prediction, defaults to {} + :param list[int] keep_epochs: List of numbers of checkpoints that are supposed to be kept during training, defaults to None + :param bool tts_forward: whether TTS evaluation should be run (autoMOS, NISQA), defaults to True + :param bool asr_search: whether ASR search should be run, defaults to True + :param bool phoneme_pred: whether phoneme prediction evaluation should be run, defaults to True + :param bool asr_cv_set: whether the training should use the ASR validation set for CV during training (necessary for ASR trainings), defaults to False + :return dict: Dictionary containing all the jobs of the experiment + """ exp = {} assert num_epochs == len(args["config"]["learning_rates"]), "Number of Epochs and Number of LR steps differs!" with_prior = "prior_scale" in search_args - if given_train_job_for_forward is None: - training_config = get_training_config( - training_datasets=dataset, - **args, - training_args=training_args, - use_custom_engine=use_custom_engine, - keep_epochs=keep_epochs, - asr_cv_set=asr_cv_set, - ) # implicit reconstruction loss + training_config = get_training_config( + training_datasets=dataset, + **args, + training_args=training_args, + use_custom_engine=use_custom_engine, + keep_epochs=keep_epochs, + asr_cv_set=asr_cv_set, + ) if tts_forward: forward_config_gl = get_forward_config( @@ -111,16 +124,13 @@ def run_exp( target="phoneme" ) - if given_train_job_for_forward is None: - train_job = training( - config=training_config, - returnn_exe=RETURNN_PYTORCH_EXE, - returnn_root=MINI_RETURNN_ROOT, - prefix=prefix + name, - num_epochs=num_epochs, - ) - else: - train_job = given_train_job_for_forward + train_job = training( + config=training_config, + returnn_exe=RETURNN_PYTORCH_EXE, + returnn_root=MINI_RETURNN_ROOT, + prefix=prefix + name, + num_epochs=num_epochs, + ) exp["train_job"] = train_job if with_prior: @@ -147,19 +157,6 @@ def run_exp( ) exp["forward_job_gl"] = forward_job_gl - if extract_x_vector: - forward_x_vector_config = get_forward_config( - forward_dataset=dataset, **args, forward_args=forward_args, target="xvector", train_data=True - ) - forward_xvector_job = forward( - checkpoint=train_job.out_checkpoints[num_epochs], - config=forward_x_vector_config, - returnn_exe=RETURNN_PYTORCH_EXE, - returnn_root=MINI_RETURNN_ROOT, - prefix=prefix + name, - target="xvector", - ) - exp["forward_xvector_job"] = forward_xvector_job if asr_search: search( prefix + name + "/search", diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/exp_joint_flow_ga/experiments.py b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/exp_joint_flow_ga/experiments.py index 08197c92d..1ca31d2b2 100644 --- a/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/exp_joint_flow_ga/experiments.py +++ b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/exp_joint_flow_ga/experiments.py @@ -38,11 +38,8 @@ def get_glow_joint_flow_ga(x_vector_exp, joint_exps, tts_exps, gl_checkpoint): """ - Baseline for the glow TTS in returnn_common with serialization - - Uses updated RETURNN_COMMON - - :return: durations_hdf + Experiments training Glow-TTS with an additional auxiliary loss using a simple model for phoneme reconstruction (FFN or CNN). + Other than the models in ../exp_joint these models also use the given external alignment for the Glow-TTS training so MAS/Viterbi is completely omitted """ prefix = "experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/" @@ -59,33 +56,38 @@ def run_exp( forward_args={}, search_args={}, keep_epochs=None, - extract_x_vector=False, - tts_forward=True, - asr_search=True, phoneme_pred=True, encoder_phoneme_pred=False, - asr_cv_set=False, - given_train_job_for_forward=None, eval_invertibility=False, tts_eval_datasets=None, ): + """Creates the jobs for training, TTS generation/forwarding and phoneme prediction evaluation + + :param str name: Name of the experiment used for alias + :param dict args: General arguments used for Returnn config generation + :param TrainingDataset dataset: Dataset used for training + :param dict test_dataset: Dictionary containing datasets used for phoneme prediction evaluation + :param int num_epochs: Number of epochs for training, defaults to 100 + :param bool use_custom_engine: whether a custom engine should be used in Returnn, defaults to False + :param dict training_args: Additional arguments passed to the training config and the train steps, defaults to {} + :param dict forward_args: Additional arguments passed to the TTS forward config and forward steps, defaults to {} + :param dict search_args: Additional arguments passed to the phoneme prediction and respective steps, defaults to {} + :param list[int] keep_epochs: List containing the number of checkpoints that are not supposed to be deleted during training, defaults to None + :param bool phoneme_pred: whether phoneme prediction using the inverse decoder output should be run and evaluated, uses test_dataset for evaluation, defaults to True + :param bool encoder_phoneme_pred: whether phoneme prediction using the encoder output should be run, uses test_dataset for evaluation, defaults to False + :param bool eval_invertibility: whether invertibility of the models coupling blocks should be run, defaults to False + :param dict tts_eval_datasets: Dictionary of datasets to be used for TTS evaluation (autoMOS, NISQA), defaults to None + :return dict: Dictionary containing all the jobs created for + """ exp = {} - if given_train_job_for_forward is None: - training_config = get_training_config( - training_datasets=dataset, - **args, - training_args=training_args, - use_custom_engine=use_custom_engine, - keep_epochs=keep_epochs, - asr_cv_set=asr_cv_set, - ) # implicit reconstruction loss - - if asr_search or phoneme_pred: - search_config = get_search_config( - **args, - search_args=search_args, - ) + training_config = get_training_config( + training_datasets=dataset, + **args, + training_args=training_args, + use_custom_engine=use_custom_engine, + keep_epochs=keep_epochs, + ) if phoneme_pred: phoneme_pred_config = get_search_config( @@ -102,65 +104,40 @@ def run_exp( if encoder_phoneme_pred: encoder_phoneme_pred_config = get_search_config(**args, search_args=search_args, target="encoder_phoneme") - if given_train_job_for_forward is None: - train_job = training( - config=training_config, - returnn_exe=RETURNN_PYTORCH_EXE, - returnn_root=MINI_RETURNN_ROOT, - prefix=prefix + name, - num_epochs=num_epochs, - ) - else: - train_job = given_train_job_for_forward + train_job = training( + config=training_config, + returnn_exe=RETURNN_PYTORCH_EXE, + returnn_root=MINI_RETURNN_ROOT, + prefix=prefix + name, + num_epochs=num_epochs, + ) + exp["train_job"] = train_job - if tts_forward: - for ds_k, ds in tts_eval_datasets.items(): - forward_config_gl = get_forward_config( - forward_dataset=ds, - **{**args, **{"config": {"batch_size": 50 * 16000}}}, - forward_args={ - **forward_args, - "gl_net_checkpoint": gl_checkpoint["checkpoint"], - "gl_net_config": gl_checkpoint["config"], - }, - target="corpus_gl", - ) - forward_job_gl = tts_eval( - checkpoint=train_job.out_checkpoints[num_epochs], - prefix_name=prefix + name, - returnn_config=forward_config_gl, - returnn_exe=RETURNN_PYTORCH_EXE, - returnn_exe_asr=RETURNN_PYTORCH_ASR_SEARCH_EXE, - returnn_root=MINI_RETURNN_ROOT, - vocoder="gl", - nisqa_eval=True, - swer_eval=True, - swer_eval_corpus_key=ds_k - ) - - if extract_x_vector: - forward_x_vector_config = get_forward_config( - forward_dataset=dataset, **args, forward_args=forward_args, target="xvector", train_data=True + for ds_k, ds in tts_eval_datasets.items(): + forward_config_gl = get_forward_config( + forward_dataset=ds, + **{**args, **{"config": {"batch_size": 50 * 16000}}}, + forward_args={ + **forward_args, + "gl_net_checkpoint": gl_checkpoint["checkpoint"], + "gl_net_config": gl_checkpoint["config"], + }, + target="corpus_gl", ) - forward_xvector_job = forward( + forward_job_gl = tts_eval( checkpoint=train_job.out_checkpoints[num_epochs], - config=forward_x_vector_config, + prefix_name=prefix + name, + returnn_config=forward_config_gl, returnn_exe=RETURNN_PYTORCH_EXE, + returnn_exe_asr=RETURNN_PYTORCH_ASR_SEARCH_EXE, returnn_root=MINI_RETURNN_ROOT, - prefix=prefix + name, - target="xvector", - ) - exp["forward_xvector_job"] = forward_xvector_job - if asr_search: - search( - prefix + name + "/search", - search_config, - train_job.out_checkpoints[num_epochs], - test_dataset, - RETURNN_PYTORCH_EXE, - MINI_RETURNN_ROOT, + vocoder="gl", + nisqa_eval=True, + swer_eval=True, + swer_eval_corpus_key=ds_k ) + if phoneme_pred: compute_phoneme_pred_accuracy( prefix + name, @@ -192,8 +169,6 @@ def run_exp( target="invertibility", ) exp["invertibility_job"] = forward_job - # if "ce_loss_scale" in training_args and training_args["ce_loss_scale"] == 0.01: - # breakpoint() return exp glowTTS_durations_job = tts_exps["glowTTS/enc192/200ep/long_cooldown/not_silence_preprocessed"]["forward_job_joint_durations"] @@ -296,30 +271,6 @@ def run_exp( get_bliss_corpus_dict()["train-clean-100"], ) - specaug_config = SpecaugConfig( - repeat_per_n_frames=100, - max_dim_time=20, - max_dim_feat=8, - num_repeat_feat=5, - ) - frontend_config = VGG4LayerActFrontendV1Config_mod( - in_features=80, - conv1_channels=16, - conv2_channels=16, - conv3_channels=16, - conv4_channels=16, - conv_kernel_size=(3, 3), - conv_padding=None, - pool1_kernel_size=(2, 1), - pool1_stride=(2, 1), - pool1_padding=None, - pool2_kernel_size=(2, 1), - pool2_stride=(2, 1), - pool2_padding=None, - activation_str="ReLU", - out_features=96, - activation=None, - ) text_encoder_config = TextEncoderConfig( n_vocab=label_datastream_tts.vocab_size, hidden_channels=192, @@ -428,7 +379,6 @@ def run_exp( training_args={"ce_loss_scale": 0.1}, search_args=default_search_args, tts_eval_datasets=tts_forward_datasets_xvectors, - asr_search=False, encoder_phoneme_pred=True, ) @@ -442,7 +392,6 @@ def run_exp( training_args={"ce_loss_scale": 0.1}, search_args=default_search_args, tts_eval_datasets=tts_forward_datasets_xvectors, - asr_search=False, encoder_phoneme_pred=True, ) @@ -460,7 +409,6 @@ def run_exp( training_args={"ce_loss_scale": 0.1}, search_args=default_search_args, tts_eval_datasets=tts_forward_datasets_xvectors, - asr_search=False, encoder_phoneme_pred=True, ) @@ -474,7 +422,6 @@ def run_exp( training_args={"ce_loss_scale": 0.1}, search_args=default_search_args, tts_eval_datasets=tts_forward_datasets_xvectors, - asr_search=False, encoder_phoneme_pred=True, ) @@ -488,7 +435,6 @@ def run_exp( training_args={"ce_loss_scale": 1.0}, search_args=default_search_args, tts_eval_datasets=tts_forward_datasets_xvectors, - asr_search=False, encoder_phoneme_pred=True, ) @@ -502,7 +448,6 @@ def run_exp( training_args={"ce_loss_scale": 1.0}, search_args=default_search_args, tts_eval_datasets=tts_forward_datasets_xvectors, - asr_search=False, encoder_phoneme_pred=True, ) @@ -537,7 +482,6 @@ def run_exp( training_args={"ce_loss_scale": 0.1}, search_args=default_search_args, tts_eval_datasets=tts_forward_datasets_xvectors, - asr_search=False, ) exp_dict = run_exp( @@ -550,7 +494,6 @@ def run_exp( training_args={"ce_loss_scale": 0.1}, search_args=default_search_args, tts_eval_datasets=tts_forward_datasets_xvectors, - asr_search=False, ) net_module = "ga_glowTTS_ASR_cnn_x_vector_v2" @@ -566,7 +509,6 @@ def run_exp( training_args={"ce_loss_scale": 0.1}, search_args=default_search_args, tts_eval_datasets=tts_forward_datasets_xvectors, - asr_search=False, encoder_phoneme_pred=True, ) @@ -580,7 +522,6 @@ def run_exp( training_args={"ce_loss_scale": 0.1}, search_args=default_search_args, tts_eval_datasets=tts_forward_datasets_xvectors, - asr_search=False, encoder_phoneme_pred=True, ) @@ -594,7 +535,6 @@ def run_exp( training_args={"ce_loss_scale": 0.01}, search_args=default_search_args, tts_eval_datasets=tts_forward_datasets_xvectors, - asr_search=False, encoder_phoneme_pred=True, ) @@ -608,6 +548,5 @@ def run_exp( training_args={"ce_loss_scale": 0.01}, search_args=default_search_args, tts_eval_datasets=tts_forward_datasets_xvectors, - asr_search=False, encoder_phoneme_pred=True, ) diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/exp_joint_flow_ga_frozen_glowtts/experiments.py b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/exp_joint_flow_ga_frozen_glowtts/experiments.py index a460aa1ed..5274592d7 100644 --- a/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/exp_joint_flow_ga_frozen_glowtts/experiments.py +++ b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/exp_joint_flow_ga_frozen_glowtts/experiments.py @@ -37,11 +37,10 @@ def get_glow_joint_flow_ga_frozen_glowtts(x_vector_exp, joint_exps, tts_exps, gl_checkpoint): """ - Baseline for the glow TTS in returnn_common with serialization - - Uses updated RETURNN_COMMON - - :return: durations_hdf + Experiments using frozen coupling blocks pre-trained on TTS in combination with a trainable simple phoneme reconstruction network. + The experiments are therefore similar to the "decoder_test"/"encoder_test"/"encoder_sample" experiments in ../../librispeech_glowtts and ../../librispeech_glow_asr + but instead of the MAS/Viterbi alignment, the experiments here make use of the external given alignment. The only exceptions for this are marked with "_mas" in the + module filename. """ prefix = "experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/" @@ -55,48 +54,37 @@ def run_exp( num_epochs=100, use_custom_engine=False, training_args={}, - forward_args={}, search_args={}, keep_epochs=None, - extract_x_vector=False, - tts_forward=False, - asr_search=False, phoneme_pred=True, - asr_cv_set=False, - given_train_job_for_forward=None, eval_invertibility=False, ): + """Creates the jobs for training, generation/search and evaluation + + :param str name: Name of the experiment group to be used for aliases + :param dict args: Arguments passed to the training and forward configs + :param TrainingDataset dataset: Dataset to be used for training and the tts forwarding not used for automatic evaluation + :param dict test_dataset: Dictionary of dataset to test phoneme prediction accuracy, keys should be corpus names/corpus keys and are used for aliases + :param int num_epochs: Number of Epochs for training, defaults to 100 + :param bool use_custom_engine: whether a custom engine is to be used in Returnn, defaults to False + :param dict training_args: Additional training only arguments for Returnn config and train steps, defaults to {} + :param dict search_args: Additional search/phoneme prediction only arguments for Returnn config and search* steps, defaults to {} + :param list keep_epochs: List of numbers marking the model checkpoints that are not supposed to be cleaned, defaults to None + :param bool phoneme_pred: whether a phoneme prediction and evaluation should be run after training, defaults to True + :param bool eval_invertibility: whether the invertibility of the coupling blocks should be evaluated, defaults to False + :return dict: Dictionary containing all the jobs for this experiment + """ exp = {} assert len(args["config"]["learning_rates"]) == num_epochs, "Number of epochs and number of learning rates differ!" - if given_train_job_for_forward is None: - training_config = get_training_config( - training_datasets=dataset, - **args, - training_args=training_args, - use_custom_engine=use_custom_engine, - keep_epochs=keep_epochs, - asr_cv_set=asr_cv_set, - ) # implicit reconstruction loss - - if tts_forward: - forward_config_gl = get_forward_config( - forward_dataset=dataset, - **{**args, **{"config": {"batch_size": 50 * 16000}}}, - forward_args={ - **forward_args, - "gl_net_checkpoint": gl_checkpoint["checkpoint"], - "gl_net_config": gl_checkpoint["config"], - }, - target="corpus_gl", - ) - - if asr_search or phoneme_pred: - search_config = get_search_config( - **args, - search_args=search_args, - ) + training_config = get_training_config( + training_datasets=dataset, + **args, + training_args=training_args, + use_custom_engine=use_custom_engine, + keep_epochs=keep_epochs, + ) if phoneme_pred: phoneme_pred_config_encoder = get_search_config( @@ -115,54 +103,15 @@ def run_exp( forward_dataset=dataset, **{**args, **{"config": {"batch_size": 50 * 16000}}}, target="invertibility" ) - if given_train_job_for_forward is None: - train_job = training( - config=training_config, - returnn_exe=RETURNN_PYTORCH_EXE, - returnn_root=MINI_RETURNN_ROOT, - prefix=prefix + name, - num_epochs=num_epochs, - ) - else: - train_job = given_train_job_for_forward + train_job = training( + config=training_config, + returnn_exe=RETURNN_PYTORCH_EXE, + returnn_root=MINI_RETURNN_ROOT, + prefix=prefix + name, + num_epochs=num_epochs, + ) exp["train_job"] = train_job - if tts_forward: - forward_job_gl = tts_eval( - checkpoint=train_job.out_checkpoints[num_epochs], - prefix_name=prefix + name, - returnn_config=forward_config_gl, - returnn_exe=RETURNN_PYTORCH_EXE, - returnn_exe_asr=RETURNN_PYTORCH_ASR_SEARCH_EXE, - returnn_root=MINI_RETURNN_ROOT, - vocoder="gl", - nisqa_eval=True, - swer_eval=True - ) - exp["forward_job_gl"] = forward_job_gl - - if extract_x_vector: - forward_x_vector_config = get_forward_config( - forward_dataset=dataset, **args, forward_args=forward_args, target="xvector", train_data=True - ) - forward_xvector_job = forward( - checkpoint=train_job.out_checkpoints[num_epochs], - config=forward_x_vector_config, - returnn_exe=RETURNN_PYTORCH_EXE, - returnn_root=MINI_RETURNN_ROOT, - prefix=prefix + name, - target="xvector", - ) - exp["forward_xvector_job"] = forward_xvector_job - if asr_search: - search( - prefix + name + "/search", - search_config, - train_job.out_checkpoints[num_epochs], - test_dataset, - RETURNN_PYTORCH_EXE, - MINI_RETURNN_ROOT, - ) if phoneme_pred: compute_phoneme_pred_accuracy( prefix + name + "/encoder_eval/", @@ -192,8 +141,6 @@ def run_exp( target="invertibility", ) exp["invertibility_job"] = forward_job - # if "ce_loss_scale" in training_args and training_args["ce_loss_scale"] == 0.01: - # breakpoint() return exp glowTTS_durations_job = tts_exps["glowTTS/enc192/200ep/long_cooldown/not_silence_preprocessed"]["forward_job_joint_durations"] @@ -406,7 +353,6 @@ def run_exp( training_datasets_pe1_tts_segments, dev_dataset_tuples_with_phon, 100, - forward_args=forward_args, training_args={"recognition_input": "encoder"}, search_args=default_search_args, phoneme_pred=True, @@ -418,7 +364,6 @@ def run_exp( training_datasets_pe1_tts_segments, dev_dataset_tuples_with_phon, 100, - forward_args=forward_args, training_args={"recognition_input": "decoder"}, search_args=default_search_args, phoneme_pred=True, @@ -434,7 +379,6 @@ def run_exp( training_datasets_pe1_tts_segments, dev_dataset_tuples_with_phon, 100, - forward_args=forward_args, training_args={"recognition_input": "encoder"}, search_args=default_search_args, phoneme_pred=True, @@ -446,7 +390,6 @@ def run_exp( training_datasets_pe1_tts_segments, dev_dataset_tuples_with_phon, 100, - forward_args=forward_args, training_args={"recognition_input": "decoder"}, search_args=default_search_args, phoneme_pred=True, @@ -462,7 +405,6 @@ def run_exp( training_datasets_pe1_tts_segments, dev_dataset_tuples_with_phon, 100, - forward_args=forward_args, training_args={"recognition_input": "encoder"}, search_args=default_search_args, phoneme_pred=True, @@ -474,7 +416,6 @@ def run_exp( training_datasets_pe1_tts_segments, dev_dataset_tuples_with_phon, 100, - forward_args=forward_args, training_args={"recognition_input": "decoder"}, search_args=default_search_args, phoneme_pred=True, @@ -498,7 +439,6 @@ def run_exp( training_datasets_pe1_tts_segments, dev_dataset_tuples_with_phon, 100, - forward_args=forward_args, training_args={"recognition_input": "encoder"}, search_args=default_search_args, phoneme_pred=True, @@ -510,7 +450,6 @@ def run_exp( training_datasets_pe1_tts_segments, dev_dataset_tuples_with_phon, 100, - forward_args=forward_args, training_args={"recognition_input": "decoder"}, search_args=default_search_args, phoneme_pred=True, @@ -526,7 +465,6 @@ def run_exp( training_datasets_pe1_tts_segments, dev_dataset_tuples_with_phon, 100, - forward_args=forward_args, training_args={"recognition_input": "encoder"}, search_args=default_search_args, phoneme_pred=True, @@ -538,7 +476,6 @@ def run_exp( training_datasets_pe1_tts_segments, dev_dataset_tuples_with_phon, 100, - forward_args=forward_args, training_args={"recognition_input": "decoder"}, search_args=default_search_args, phoneme_pred=True, @@ -554,7 +491,6 @@ def run_exp( training_datasets_pe1_tts_segments, dev_dataset_tuples_with_phon, 100, - forward_args=forward_args, training_args={"recognition_input": "encoder"}, search_args=default_search_args, phoneme_pred=True, @@ -566,7 +502,6 @@ def run_exp( training_datasets_pe1_tts_segments, dev_dataset_tuples_with_phon, 100, - forward_args=forward_args, training_args={"recognition_input": "decoder"}, search_args=default_search_args, phoneme_pred=True, @@ -582,7 +517,6 @@ def run_exp( training_datasets_pe1_tts_segments, dev_dataset_tuples_with_phon, 100, - forward_args=forward_args, training_args={"recognition_input": "encoder"}, search_args=default_search_args, phoneme_pred=True, @@ -594,7 +528,6 @@ def run_exp( training_datasets_pe1_tts_segments, dev_dataset_tuples_with_phon, 100, - forward_args=forward_args, training_args={"recognition_input": "decoder"}, search_args=default_search_args, phoneme_pred=True, diff --git a/users/rilling/experiments/librispeech/librispeech_x_vectors/x_vectors/experiments.py b/users/rilling/experiments/librispeech/librispeech_x_vectors/x_vectors/experiments.py index 39e1a8d84..677ea57ca 100644 --- a/users/rilling/experiments/librispeech/librispeech_x_vectors/x_vectors/experiments.py +++ b/users/rilling/experiments/librispeech/librispeech_x_vectors/x_vectors/experiments.py @@ -14,13 +14,10 @@ def get_pytorch_xvector(): - """ - Baseline for the glow TTS in returnn_common with serialization + """Contains experiments training x-vector TDNN models, which can for example be used for Glow-TTS with x-vector embeddings - Uses updated RETURNN_COMMON - - :return: durations_hdf - """ + :return dict: Dictionary containing the experiments used by some Glow-TTS experiments to load the x-vector model parameters from the training jobs checkpoint (should be done using storage instead) + """ prefix = "experiments/librispeech/x_vector/" diff --git a/users/rilling/experiments/librispeech/tts_architecture_improvement_23/__init__.py b/users/rilling/experiments/librispeech/tts_architecture_improvement_23/__init__.py deleted file mode 100644 index e69de29bb..000000000 diff --git a/users/rilling/experiments/librispeech/tts_architecture_improvement_23/ctc_aligner/__init__.py b/users/rilling/experiments/librispeech/tts_architecture_improvement_23/ctc_aligner/__init__.py deleted file mode 100644 index e69de29bb..000000000 diff --git a/users/rilling/experiments/librispeech/tts_architecture_improvement_23/ctc_aligner/data.py b/users/rilling/experiments/librispeech/tts_architecture_improvement_23/ctc_aligner/data.py deleted file mode 100644 index 7344b4e5a..000000000 --- a/users/rilling/experiments/librispeech/tts_architecture_improvement_23/ctc_aligner/data.py +++ /dev/null @@ -1,115 +0,0 @@ -from dataclasses import dataclass -import os -from sisyphus import tk -from typing import Dict - -from i6_core.returnn.dataset import SpeakerLabelHDFFromBlissJob -from i6_core.returnn.oggzip import BlissToOggZipJob - -from i6_experiments.users.rossenbach.common_setups.returnn.datasets import GenericDataset, OggZipDataset, HDFDataset -from i6_experiments.users.rossenbach.common_setups.returnn.datastreams.base import Datastream -from i6_experiments.users.rossenbach.common_setups.returnn.datastreams.vocabulary import LabelDatastream - -from i6_experiments.users.rossenbach.datasets.librispeech import get_librispeech_tts_segments - -from ..data import ( - get_tts_log_mel_datastream, - get_bliss_and_zip, - get_vocab_datastream, - make_meta_dataset -) -from ..default_tools import RETURNN_ROOT - -@dataclass(frozen=True) -class AlignmentTrainingDatasets: - """ - Dataclass for Alignment Datasets - """ - - train: GenericDataset - cv: GenericDataset - joint: GenericDataset - datastreams: Dict[str, Datastream] - - -def build_training_dataset( - ls_corpus_key="train-clean-100", - silence_preprocessed=True, - partition_epoch=1, - center : bool = False) -> AlignmentTrainingDatasets: - """ - - :param center: do feature centering - """ - bliss_dataset, zip_dataset = get_bliss_and_zip(ls_corpus_key=ls_corpus_key, silence_preprocessed=silence_preprocessed) - - # segments for train-clean-100-tts-train and train-clean-100-tts-dev - # (1004 segments for dev, 4 segments for each of the 251 speakers) - train_segments, cv_segments = get_librispeech_tts_segments(ls_corpus_key=ls_corpus_key) - - vocab_datastream = get_vocab_datastream(with_blank=True, corpus_key=ls_corpus_key) - log_mel_datastream = get_tts_log_mel_datastream() - - # we currently assume that train and cv share the same corpus file - speaker_label_job = SpeakerLabelHDFFromBlissJob( - bliss_corpus=bliss_dataset, - returnn_root=RETURNN_ROOT, - ) - joint_speaker_hdf = speaker_label_job.out_speaker_hdf - - joint_speaker_dataset = HDFDataset( - files=[joint_speaker_hdf] - ) - speaker_datastream = LabelDatastream( - available_for_inference=True, - vocab_size=speaker_label_job.out_num_speakers, - vocab=speaker_label_job.out_speaker_dict, - ) - - # ----- Ogg and Meta datasets - - train_ogg_dataset = OggZipDataset( - path=zip_dataset, - audio_options=log_mel_datastream.as_returnn_audio_opts(), - target_options=vocab_datastream.as_returnn_targets_opts(), - segment_file=train_segments, - partition_epoch=partition_epoch, - seq_ordering="laplace:.1000" - ) - train_dataset = make_meta_dataset(train_ogg_dataset, joint_speaker_dataset) - - cv_ogg_dataset = OggZipDataset( - path=zip_dataset, - audio_options=log_mel_datastream.as_returnn_audio_opts(), - target_options=vocab_datastream.as_returnn_targets_opts(), - segment_file=cv_segments, - partition_epoch=1, - seq_ordering="sorted", - ) - cv_dataset = make_meta_dataset(cv_ogg_dataset, joint_speaker_dataset) - - joint_ogg_zip = OggZipDataset( - path=zip_dataset, - audio_options=log_mel_datastream.as_returnn_audio_opts(), - target_options=vocab_datastream.as_returnn_targets_opts(), - partition_epoch=1, - seq_ordering="sorted", - ) - joint_metadataset = make_meta_dataset(joint_ogg_zip, joint_speaker_dataset) - - # ----- final outputs - - datastreams = { - "audio_features": log_mel_datastream, - "phonemes": vocab_datastream, - "speaker_labels": speaker_datastream, - } - - align_datasets = AlignmentTrainingDatasets( - train=train_dataset, - cv=cv_dataset, - joint=joint_metadataset, - datastreams=datastreams, - ) - - return align_datasets \ No newline at end of file diff --git a/users/rilling/experiments/librispeech/tts_architecture_improvement_23/ctc_aligner/experiments.py b/users/rilling/experiments/librispeech/tts_architecture_improvement_23/ctc_aligner/experiments.py deleted file mode 100644 index 7b7c32829..000000000 --- a/users/rilling/experiments/librispeech/tts_architecture_improvement_23/ctc_aligner/experiments.py +++ /dev/null @@ -1,309 +0,0 @@ -import copy -import os -import numpy as np -from sisyphus import tk -from dataclasses import asdict - -from .data import build_training_dataset -from .config import get_training_config, get_forward_config, get_pt_forward_config -from .pipeline import ctc_training, ctc_forward -from ..data import get_tts_log_mel_datastream - -from i6_experiments.users.rossenbach.common_setups.returnn.datastreams.audio import DBMelFilterbankOptions - -from ..default_tools import RETURNN_EXE, RETURNN_ROOT, RETURNN_COMMON, RETURNN_PYTORCH_EXE, MINI_RETURNN_ROOT -from ..storage import add_duration - - -from ..rc_networks.ctc_aligner.parameters import ConvBlstmRecParams - -def get_baseline_ctc_alignment(): - """ - Baseline for the ctc aligner in returnn_common with serialization - - Uses updated RETURNN_COMMON - - :return: durations_hdf - """ - - name = "experiments/librispeech/tts_architecture/ctc_aligner/baseline" - training_datasets = build_training_dataset(silence_preprocessed=True) - - - config = { - "behavior_version": 16, - ############ - "optimizer": {"class": "adam", "epsilon": 1e-8}, - "learning_rate_control": "newbob_multi_epoch", - "learning_rate_control_min_num_epochs_per_new_lr": 5, - "learning_rate_control_relative_error_relative_lr": True, - "learning_rates": [0.001], - "use_learning_rate_control_always": True, - ############ - "accum_grad_multiple_step": 2, - "gradient_clip": 1, - "gradient_noise": 0, - "learning_rate_control_error_measure": "dev_score_reconstruction_output", - ############ - "newbob_learning_rate_decay": 0.9, - "newbob_multi_num_epochs": 5, - "newbob_multi_update_interval": 1, - "newbob_relative_error_threshold": 0, - ############# - "batch_size": 28000, - "max_seq_length": {"audio_features": 1600}, - "max_seqs": 200, - } - - net_module = "ctc_aligner.conv_blstm_rec" - params = ConvBlstmRecParams( - audio_emb_size=256, - speaker_emb_size=256, - conv_hidden_size=256, - enc_lstm_size=256, - rec_lstm_size=512, - dropout=0.5, - reconstruction_scale=0.5, - training=True - ) - - aligner_config = get_training_config( - returnn_common_root=RETURNN_COMMON, - training_datasets=training_datasets, - network_module=net_module, - net_args=asdict(params), - config=config, - ) # implicit reconstruction loss - params.training = False - forward_config = get_forward_config( - returnn_common_root=RETURNN_COMMON, - forward_dataset=training_datasets.joint, - datastreams=training_datasets.datastreams, - network_module=net_module, - net_args=asdict(params) - ) - train_job = ctc_training( - config=aligner_config, - returnn_exe=RETURNN_EXE, - returnn_root=RETURNN_ROOT, - prefix=name, - ) - duration_hdf = ctc_forward( - checkpoint=train_job.out_checkpoints[100], - config=forward_config, - returnn_exe=RETURNN_EXE, - returnn_root=RETURNN_ROOT, - prefix=name - ) - return duration_hdf - -def get_pytorch_ctc_alignment(): - """ - Baseline for the ctc aligner in returnn_common with serialization - - Uses updated RETURNN_COMMON - - :return: durations_hdf - """ - - config = { - "optimizer": {"class": "adam", "epsilon": 1e-8}, - "learning_rate_control": "newbob_multi_epoch", - "learning_rate_control_min_num_epochs_per_new_lr": 5, - "learning_rate_control_relative_error_relative_lr": True, - "learning_rates": [0.001], - "gradient_clip": 1.0, - "use_learning_rate_control_always": True, - "learning_rate_control_error_measure": "dev_ctc", - ############ - "newbob_learning_rate_decay": 0.9, - "newbob_multi_num_epochs": 5, - "newbob_multi_update_interval": 1, - "newbob_relative_error_threshold": 0, - ############# - "batch_size": 56000, - "max_seq_length": {"audio_features": 1600}, - "max_seqs": 200, - } - - prefix = "experiments/librispeech/tts_architecture/ctc_aligner/pytorch/" - training_datasets = build_training_dataset(silence_preprocessed=True) - - def run_exp(name, params, net_module, config, use_custom_engine=False, debug=False): - aligner_config = get_training_config( - returnn_common_root=RETURNN_COMMON, - training_datasets=training_datasets, - network_module=net_module, - net_args=params, - config=config, - debug=debug, - use_custom_engine=use_custom_engine, - pytorch_mode=True - ) # implicit reconstruction loss - forward_config = get_pt_forward_config( - returnn_common_root=RETURNN_COMMON, - forward_dataset=training_datasets.joint, - datastreams=training_datasets.datastreams, - network_module=net_module, - net_args=params, - pytorch_mode=True - ) - train_job = ctc_training( - config=aligner_config, - returnn_exe=RETURNN_PYTORCH_EXE, - returnn_root=MINI_RETURNN_ROOT, - prefix=prefix + name, - ) - duration_hdf = ctc_forward( - checkpoint=train_job.out_checkpoints[100], - config=forward_config, - returnn_exe=RETURNN_PYTORCH_EXE, - returnn_root=MINI_RETURNN_ROOT, - prefix=prefix + name - ) - return duration_hdf - - net_module = "ctc_aligner_v1" - params = { - "conv_hidden_size": 256, - "lstm_size": 512, - "speaker_embedding_size": 256, - "dropout": 0.35, - "target_size": 44 - } - - duration_hdf = run_exp(net_module + "_drop035_bs56k", params, net_module, config, debug=True) - - #net_module = "ctc_aligner_v1_gradaccum" - config_gradaccum = copy.deepcopy(config) - #run_exp(net_module + "_drop1d035_bs28k_accum2", params, net_module, config, use_custom_engine=True, debug=True) - - - # net_module = "ctc_aligner_v2" - # params_v2 = { - # "conv_hidden_size": 256, - # "lstm_size": 512, - # "speaker_embedding_size": 256, - # "conv_dropout": 0.5, - # "final_dropout": 0.1, - # "target_size": 44 - # } - # run_exp(net_module + "_drop05_01", params_v2, net_module, config, use_custom_engine=False, debug=False) - - #net_module = "ctc_aligner_v1_ctc_sum" - #run_exp(net_module + "_drop01", params, net_module, config) - - #net_module = "ctc_aligner_v1_ctc_sum_nobroad" - #params = copy.deepcopy(params) - #params["dropout"] = 0.35 - #run_exp(net_module + "_drop035", params, net_module, config) - - return duration_hdf - - -def get_pytorch_raw_ctc_alignment(): - """ - Baseline for the ctc aligner in returnn_common with serialization - - Uses updated RETURNN_COMMON - - :return: durations_hdf - """ - - samples_per_frame = int(16000*0.0125) - config = { - "optimizer": {"class": "adam", "epsilon": 1e-8}, - "learning_rate_control": "newbob_multi_epoch", - "learning_rate_control_min_num_epochs_per_new_lr": 5, - "learning_rate_control_relative_error_relative_lr": True, - "learning_rates": [0.001], - "gradient_clip": 1.0, - "use_learning_rate_control_always": True, - "learning_rate_control_error_measure": "dev_ctc", - ############ - "newbob_learning_rate_decay": 0.9, - "newbob_multi_num_epochs": 5, - "newbob_multi_update_interval": 1, - "newbob_relative_error_threshold": 0, - ############# - "batch_size": 56000*samples_per_frame, - "max_seq_length": {"audio_features": 1600*samples_per_frame}, - "max_seqs": 200, - } - - prefix = "experiments/librispeech/tts_architecture/ctc_aligner/pytorch/" - training_datasets = build_training_dataset(silence_preprocessed=True, raw_audio=True) - - def run_exp(name, params, net_module, config, use_custom_engine=False, debug=False): - aligner_config = get_training_config( - returnn_common_root=RETURNN_COMMON, - training_datasets=training_datasets, - network_module=net_module, - net_args=params, - config=config, - debug=debug, - use_custom_engine=use_custom_engine, - pytorch_mode=True - ) # implicit reconstruction loss - forward_config = get_forward_config( - returnn_common_root=RETURNN_COMMON, - forward_dataset=training_datasets.joint, - datastreams=training_datasets.datastreams, - network_module=net_module, - net_args=params, - pytorch_mode=True - ) - train_job = ctc_training( - config=aligner_config, - returnn_exe=RETURNN_PYTORCH_EXE, - returnn_root=MINI_RETURNN_ROOT, - prefix=prefix + name, - ) - duration_hdf = ctc_forward( - checkpoint=train_job.out_checkpoints[100], - config=forward_config, - returnn_exe=RETURNN_PYTORCH_EXE, - returnn_root=MINI_RETURNN_ROOT, - prefix=prefix + name - ) - return duration_hdf - - net_module = "ctc_aligner_v1_fe" - log_mel_datastream = get_tts_log_mel_datastream() - - # verify that normalization exists - assert "norm_mean" in log_mel_datastream.additional_options - assert "norm_std_dev" in log_mel_datastream.additional_options - - norm = (log_mel_datastream.additional_options["norm_mean"], log_mel_datastream.additional_options["norm_std_dev"]) - - from ..pytorch_networks.ctc_aligner_v1_fe import DbMelFeatureExtractionConfig, Config - assert isinstance(log_mel_datastream.options.feature_options, DBMelFilterbankOptions) - fe_config = DbMelFeatureExtractionConfig( - sample_rate=log_mel_datastream.options.sample_rate, - win_size=log_mel_datastream.options.window_len, - hop_size=log_mel_datastream.options.step_len, - f_min=log_mel_datastream.options.feature_options.fmin, - f_max=log_mel_datastream.options.feature_options.fmax, - min_amp=log_mel_datastream.options.feature_options.min_amp, - num_filters=log_mel_datastream.options.num_feature_filters, - center=log_mel_datastream.options.feature_options.center, - norm=norm - ) - model_config = Config( - conv_hidden_size=256, - lstm_size=512, - speaker_embedding_size=256, - dropout=0.35, - target_size=44, - feature_extraction_config=fe_config, - ) - - params = { - "config": asdict(model_config) - } - - - duration_hdf = run_exp(net_module + "_drop035_bs56k", params, net_module, config, debug=True) - - return duration_hdf diff --git a/users/rilling/experiments/librispeech/tts_architecture_improvement_23/ctc_aligner/pipeline.py b/users/rilling/experiments/librispeech/tts_architecture_improvement_23/ctc_aligner/pipeline.py deleted file mode 100644 index d055f1b2f..000000000 --- a/users/rilling/experiments/librispeech/tts_architecture_improvement_23/ctc_aligner/pipeline.py +++ /dev/null @@ -1,35 +0,0 @@ -from sisyphus import tk -from i6_core.returnn import ReturnnTrainingJob -from i6_core.returnn.forward import ReturnnForwardJob - -def ctc_training(config, returnn_exe, returnn_root, prefix, num_epochs=100): - - train_job = ReturnnTrainingJob( - config, - log_verbosity=5, - num_epochs=num_epochs, - time_rqmt=100, - mem_rqmt=16, - cpu_rqmt=4, - returnn_python_exe=returnn_exe, - returnn_root=returnn_root, - ) - train_job.add_alias(prefix + "/training") - tk.register_output(prefix + "/training.models", train_job.out_model_dir) - - return train_job - - -def ctc_forward(checkpoint, config, returnn_exe, returnn_root, prefix): - last_forward_job = ReturnnForwardJob( - model_checkpoint=checkpoint, - returnn_config=config, - hdf_outputs=[], - returnn_python_exe=returnn_exe, - returnn_root=returnn_root, - ) - last_forward_job.add_alias(prefix + "/forward") - alignment_hdf = last_forward_job.out_hdf_files["output.hdf"] - tk.register_output(prefix + "/training.alignment", alignment_hdf) - - return alignment_hdf diff --git a/users/rilling/experiments/librispeech/tts_architecture_improvement_23/data.py b/users/rilling/experiments/librispeech/tts_architecture_improvement_23/data.py deleted file mode 100644 index 1888c91ae..000000000 --- a/users/rilling/experiments/librispeech/tts_architecture_improvement_23/data.py +++ /dev/null @@ -1,320 +0,0 @@ -from dataclasses import asdict -from functools import lru_cache -import os -from sisyphus import tk -from typing import List - -from i6_core.returnn.oggzip import BlissToOggZipJob -from i6_core.returnn.vocabulary import ReturnnVocabFromPhonemeInventory - -from i6_experiments.common.datasets.librispeech import get_g2p_augmented_bliss_lexicon_dict, get_bliss_corpus_dict - -from i6_experiments.users.rossenbach.common_setups.returnn.datastreams.audio import AudioFeatureDatastream, DBMelFilterbankOptions, ReturnnAudioFeatureOptions, FeatureType -from i6_experiments.users.rossenbach.common_setups.returnn.datastreams.vocabulary import LabelDatastream -from i6_experiments.users.rossenbach.common_setups.returnn import datasets - -from i6_experiments.users.rossenbach.datasets.librispeech import ( - get_librispeech_tts_segments, - get_ls_train_clean_100_tts_silencepreprocessed, - get_ls_train_clean_360_tts_silencepreprocessed, - get_ls_train_other_500_tts_silencepreprocessed -) - - -from i6_experiments.users.rossenbach.setups.tts.preprocessing import ( - process_corpus_text_with_extended_lexicon, - extend_lexicon_with_tts_lemmas, - extend_lexicon_with_blank -) - -from .default_tools import RETURNN_EXE, RETURNN_ROOT - -DATA_PREFIX = "experiments/alignment_analysis_tts/data/" - - -@lru_cache -def get_librispeech_lexicon(corpus_key="train-clean-100") -> tk.Path: - """ - get the TTS-extended g2p bliss lexicon with [start], [end] and [space] marker - :return: - """ - return extend_lexicon_with_tts_lemmas(get_g2p_augmented_bliss_lexicon_dict(use_stress_marker=False)[corpus_key]) - - -def get_tts_extended_bliss(ls_corpus_key) -> tk.Path: - """ - get a modified ls corpus using the TTS processing - :return: - """ - ls_bliss = get_bliss_corpus_dict(audio_format="ogg")[ls_corpus_key] - tts_ls_bliss = process_corpus_text_with_extended_lexicon( - bliss_corpus=ls_bliss, - lexicon=get_librispeech_lexicon(corpus_key=ls_corpus_key)) - - return tts_ls_bliss - - -@lru_cache -def get_ls100_silence_preprocessed_bliss() -> tk.Path: - """ - Get the modified ls100 corpus for the TTS task with silence preprocessing - :return: Bliss xml file - """ - # this is the FFmpeg silence preprocessed version of LibriSpeech train-clean-100 - sil_pp_train_clean_100_co = get_ls_train_clean_100_tts_silencepreprocessed() - - # convert the corpus transcriptions into phoneme and marker representation - sil_pp_train_clean_100_tts = process_corpus_text_with_extended_lexicon( - bliss_corpus=sil_pp_train_clean_100_co.corpus_file, - lexicon=get_librispeech_lexicon()) - - return sil_pp_train_clean_100_tts - - -@lru_cache -def get_ls460_silence_preprocessed_bliss() -> tk.Path: - """ - Get the modified ls100 corpus for the TTS task - :return: Bliss xml file - """ - # this is the FFmpeg silence preprocessed version of LibriSpeech train-clean-100 - sil_pp_train_clean_100_co = get_ls_train_clean_100_tts_silencepreprocessed() - sil_pp_train_clean_360_co = get_ls_train_clean_360_tts_silencepreprocessed() - - from i6_core.corpus.transform import MergeCorporaJob, MergeStrategy - spp_460_corpus = MergeCorporaJob( - bliss_corpora=[ - sil_pp_train_clean_100_co.corpus_file, - sil_pp_train_clean_360_co.corpus_file, - ], - merge_strategy=MergeStrategy.FLAT, - name="train-clean-460" - ).out_merged_corpus - - # convert the corpus transcriptions into phoneme and marker representation - sil_pp_train_clean_100_tts = process_corpus_text_with_extended_lexicon( - bliss_corpus=spp_460_corpus, - lexicon=get_librispeech_lexicon("train-clean-460")) - - return sil_pp_train_clean_100_tts - - -@lru_cache -def get_ls960_silence_preprocessed_bliss() -> tk.Path: - """ - Get the modified ls960 corpus for the TTS task - :return: Bliss xml file - """ - # this is the FFmpeg silence preprocessed version of LibriSpeech train-clean-100 - sil_pp_train_clean_100_co = get_ls_train_clean_100_tts_silencepreprocessed() - sil_pp_train_clean_360_co = get_ls_train_clean_360_tts_silencepreprocessed() - sil_pp_train_other_500_co = get_ls_train_other_500_tts_silencepreprocessed() - - from i6_core.corpus.transform import MergeCorporaJob, MergeStrategy - spp_960_corpus = MergeCorporaJob( - bliss_corpora=[ - sil_pp_train_clean_100_co.corpus_file, - sil_pp_train_clean_360_co.corpus_file, - sil_pp_train_other_500_co.corpus_file, - ], - merge_strategy=MergeStrategy.FLAT, - name="train-other-960" - ).out_merged_corpus - - # convert the corpus transcriptions into phoneme and marker representation - sil_pp_train_other_960_tts = process_corpus_text_with_extended_lexicon( - bliss_corpus=spp_960_corpus, - lexicon=get_librispeech_lexicon("train-other-960")) - - return sil_pp_train_other_960_tts - - -@lru_cache -def get_ls360_zip_for_synthesis_only() -> tk.Path: - """ - TTS label processed librispeech 360 without audio - - :return: - """ - ls460_lexicon = extend_lexicon_with_tts_lemmas(get_g2p_augmented_bliss_lexicon_dict(use_stress_marker=False)["train-clean-460"]) - corpus = get_bliss_corpus_dict()["train-clean-360"] # original corpus as .flac - tts_corpus = process_corpus_text_with_extended_lexicon( - bliss_corpus=corpus, - lexicon=ls460_lexicon - ) - zip_dataset = BlissToOggZipJob( - bliss_corpus=tts_corpus, - no_audio=True, - returnn_python_exe=RETURNN_EXE, - returnn_root=RETURNN_ROOT, - ).out_ogg_zip - - return zip_dataset - - -@lru_cache -def get_ls100_silence_preprocess_ogg_zip() -> tk.Path: - """ - :return: Returnn OggZip .zip file - """ - - sil_pp_train_clean_100_tts = get_ls100_silence_preprocessed_bliss() - - zip_dataset = BlissToOggZipJob( - bliss_corpus=sil_pp_train_clean_100_tts, - no_conversion=True, - returnn_python_exe=RETURNN_EXE, - returnn_root=RETURNN_ROOT, - ).out_ogg_zip - - return zip_dataset - - -@lru_cache -def get_ls460_silence_preprocess_ogg_zip() -> tk.Path: - """ - :return: Returnn OggZip .zip file - """ - - sil_pp_train_clean_460_tts = get_ls460_silence_preprocessed_bliss() - - zip_dataset = BlissToOggZipJob( - bliss_corpus=sil_pp_train_clean_460_tts, - no_conversion=True, - returnn_python_exe=RETURNN_EXE, - returnn_root=RETURNN_ROOT, - ).out_ogg_zip - - return zip_dataset - - -def get_bliss_and_zip(ls_corpus_key, silence_preprocessed=True): - """ - :param ls_corpus_key: e.g. train-clean-100, see LibriSpeech data definition - :param silence_preprocessed: - :return: - """ - if silence_preprocessed: - if ls_corpus_key == "train-clean-100": - bliss_dataset = get_ls100_silence_preprocessed_bliss() - elif ls_corpus_key == "train-clean-460": - bliss_dataset = get_ls460_silence_preprocessed_bliss() - elif ls_corpus_key == "train-other-960": - bliss_dataset = get_ls960_silence_preprocessed_bliss() - else: - assert False, "invalid key %s" % ls_corpus_key - else: - bliss_dataset = get_tts_extended_bliss(ls_corpus_key=ls_corpus_key) - - zip_dataset = BlissToOggZipJob( - bliss_corpus=bliss_dataset, - no_conversion=True, - returnn_python_exe=RETURNN_EXE, - returnn_root=RETURNN_ROOT, - ).out_ogg_zip - - return bliss_dataset, zip_dataset - - -def make_meta_dataset(audio_dataset, speaker_dataset): - """ - Shared function to create a metadatset with joined audio and speaker information - - :param datasets.OggZipDataset audio_dataset: - :param datasets.HDFDataset speaker_dataset: - :return: - :rtype: MetaDataset - """ - meta_dataset = datasets.MetaDataset( - data_map={'audio_features': ('audio', 'data'), - 'phonemes': ('audio', 'classes'), - 'speaker_labels': ('speaker', 'data'), - }, - datasets={ - 'audio': audio_dataset.as_returnn_opts(), - 'speaker': speaker_dataset.as_returnn_opts() - }, - seq_order_control_dataset="audio", - ) - return meta_dataset - - -def get_tts_log_mel_datastream() -> AudioFeatureDatastream: - """ - Returns the AudioFeatureDatastream using the default feature parameters - (non-adjustable for now) based on statistics calculated over the provided dataset - - This function serves as an example for ASR Systems, and should be copied and modified in the - specific experiments if changes to the default parameters are needed - - Supports both centered and non-centered windowing, as we need non-centered windowing for RASR-compatible - feature extraction, but centered windowing to support linear-features for the vocoder mel-to-linear training. - - :param center: use center for CTC and Attention alignment, but not for GMM for RASR compatibility - """ - feature_options_center = ReturnnAudioFeatureOptions( - window_len=0.050, - step_len=0.0125, - num_feature_filters=80, - features=FeatureType.DB_MEL_FILTERBANK, - peak_normalization=False, - preemphasis=0.97, - sample_rate=16000, - feature_options=DBMelFilterbankOptions( - fmin=60, - fmax=7600, - min_amp=1e-10, - center=True, - ) - ) - audio_datastream = AudioFeatureDatastream( - available_for_inference=False, options=feature_options_center - ) - - ls100_ogg_zip = get_ls100_silence_preprocess_ogg_zip() - train_segments, _ = get_librispeech_tts_segments() - - audio_datastream.add_global_statistics_to_audio_feature_datastream( - [ls100_ogg_zip], - segment_file=train_segments, - use_scalar_only=True, - returnn_python_exe=RETURNN_EXE, - returnn_root=RETURNN_ROOT, - alias_path=DATA_PREFIX + "/ls100/", - ) - return audio_datastream - - -def get_lexicon(with_blank: bool = False, corpus_key="train-clean-100") -> tk.Path: - """ - Get the TTS/CTC lexicon - - :param with_blank: add blank (e.g. for CTC training or extraction) - :return: path to bliss lexicon file - """ - lexicon = get_librispeech_lexicon(corpus_key=corpus_key) - lexicon = extend_lexicon_with_tts_lemmas(lexicon) - if with_blank: - lexicon = extend_lexicon_with_blank(lexicon) - return lexicon - - -def get_vocab_datastream(with_blank: bool = False, corpus_key="train-clean-100") -> LabelDatastream: - """ - Default VocabularyDatastream for LibriSpeech (uppercase ARPA phoneme symbols) - - :param with_blank: datastream for CTC training - """ - lexicon = get_lexicon(with_blank, corpus_key=corpus_key) - blacklist = {"[SILENCE]"} - returnn_vocab_job = ReturnnVocabFromPhonemeInventory(lexicon, blacklist=blacklist) - name = "returnn_vocab_from_lexicon_with_blank" if with_blank else "returnn_vocab_from_lexicon" - returnn_vocab_job.add_alias(os.path.join(DATA_PREFIX, name)) - - vocab_datastream = LabelDatastream( - available_for_inference=True, - vocab=returnn_vocab_job.out_vocab, - vocab_size=returnn_vocab_job.out_vocab_size - ) - - return vocab_datastream diff --git a/users/rilling/experiments/librispeech/tts_architecture_improvement_23/default_tools.py b/users/rilling/experiments/librispeech/tts_architecture_improvement_23/default_tools.py deleted file mode 100644 index dbc5ae58c..000000000 --- a/users/rilling/experiments/librispeech/tts_architecture_improvement_23/default_tools.py +++ /dev/null @@ -1,17 +0,0 @@ -from sisyphus import tk -from i6_core.tools.git import CloneGitRepositoryJob -from i6_experiments.common.tools.rasr import compile_rasr_binaries_i6mode - - - -RETURNN_EXE = tk.Path("/u/rossenbach/bin/returnn/returnn_tf_dynamic_version_mkl_launcher.sh", hash_overwrite="GENERIC_RETURNN_LAUNCHER") -RETURNN_PYTORCH_EXE = tk.Path("/u/lukas.rilling/bin/returnn/returnn_pt20_experimental.sh", hash_overwrite="GENERIC_RETURNN_LAUNCHER") - -# outdated version using DataLoader v1 and the Tensor fix for RC networks -RETURNN_ROOT = CloneGitRepositoryJob("https://github.com/rwth-i6/returnn", commit="d98a6c606d2c007e2a6771684e77a7650bb3fad6").out_repository.copy() -RETURNN_ROOT.hash_overwrite = "LIBRISPEECH_DEFAULT_RETURNN_ROOT" - -MINI_RETURNN_ROOT = tk.Path("/u/lukas.rilling/github/MiniReturnn", hash_overwrite="LIBRISPEECH_DEFAULT_RETURNN_ROOT") - -RETURNN_COMMON = CloneGitRepositoryJob("https://github.com/rwth-i6/returnn_common", commit="d1fc1c7dc6ae63658e5aa01dc2aad41eb2758573", checkout_folder_name="returnn_common").out_repository.copy() -RETURNN_COMMON.hash_overwrite = "LIBRISPEECH_DEFAULT_RETURNN_COMMON" diff --git a/users/rilling/experiments/librispeech/tts_architecture_improvement_23/pytorch_networks/__init__.py b/users/rilling/experiments/librispeech/tts_architecture_improvement_23/pytorch_networks/__init__.py deleted file mode 100644 index e69de29bb..000000000 diff --git a/users/rilling/experiments/librispeech/tts_architecture_improvement_23/pytorch_networks/ctc_aligner_rf.py b/users/rilling/experiments/librispeech/tts_architecture_improvement_23/pytorch_networks/ctc_aligner_rf.py deleted file mode 100644 index 953abf6a3..000000000 --- a/users/rilling/experiments/librispeech/tts_architecture_improvement_23/pytorch_networks/ctc_aligner_rf.py +++ /dev/null @@ -1,120 +0,0 @@ -import time -import torch -from torch import nn -from typing import Dict -from torch.onnx import export - - -from returnn.tensor import Tensor, Dim, batch_dim -from returnn import frontend as rf - -feature_time_dim = Dim(None, name="feature_time") -phoneme_time_dim = Dim(None, name="phoneme_time") -speaker_time_dim = Dim(None, name="speaker_time") -in_dim = Dim(80, name="in") -out_dim = Dim(44, name="out") -spk_dim = Dim(1, name="spk") - -def get_extern_data(**kwargs): - - extern_data = { - "audio_features": {"dims": (batch_dim, feature_time_dim, in_dim), "dtype": "float32"}, - "phonemes": {"dims": (batch_dim, phoneme_time_dim), "sparse_dim": out_dim, "dtype": "int32"}, - "speaker_labels": {"dims": (batch_dim, spk_dim), "dtype": "int32"}, - } - return extern_data - - - - -class Conv1DBlock(rf.Module): - - def __init__(self, in_dim, out_dim, filter_size, dropout): - super().__init__() - self.out_dim = out_dim - self.conv = rf.Conv1d(in_dim=in_dim, out_dim=out_dim, filter_size=filter_size, padding="same") - # self.bn = rf.BatchNorm(in_dim=out_dim, epsilon=1e-5, use_mask=True) - self.dropout = dropout - - def __call__(self, x: Tensor, spatial_dim: Dim): - x, out_spatial_dim = self.conv(x, in_spatial_dim=spatial_dim) - x = rf.relu(x) - # x = self.bn(x) - # x = rf.dropout(x, drop_prob=0.1, axis=x.dims) # does this broadcast also over batch? - return x, out_spatial_dim - -class Model(rf.Module): - - def __init__(self, conv_hidden_size: int, lstm_size: int, target_size: int, **kwargs): - super().__init__() - self.conv_hidden_size = rf.Dim(name="conv_hidden", dimension=conv_hidden_size) - self.audio_embedding = rf.Linear(in_dim, out_dim=self.conv_hidden_size) - - out_dims = [ - rf.Dim(name="conv_dim_%s" % str(x), dimension=conv_hidden_size) - for x in range(5) - ] - - sequential_list = [] - temp_in_dim = self.conv_hidden_size - for x in range(5): - sequential_list.append( - Conv1DBlock( - in_dim=temp_in_dim, - out_dim=out_dims[x], - filter_size=5, - dropout=0.1, - ) - ) - temp_in_dim = out_dims[x] - - self.convs = rf.Sequential(sequential_list) - #self.blstm = rf.LSTM( - # input_size=conv_hidden_size, - # hidden_size=lstm_size, - # bidirectional=True, - # batch_first=False) - self.out_dim = rf.Dim(name="target_out", dimension=target_size) - self.final_linear = rf.Linear(out_dims[-1], self.out_dim) - self.lstm_size = lstm_size - - def __call__( - self, - audio_features: Tensor, - audio_features_time_dim: Dim, - ): - - for dim in audio_features.dim_tags: - print(dim.get_dim_value()) - audio_embedding = self.audio_embedding(audio_features) - conv_out, _ = self.convs((audio_embedding, audio_features_time_dim)) - softmax_in = self.final_linear(conv_out) - - log_probs = rf.log_softmax(softmax_in, axis=self.out_dim, use_mask=True) - - return log_probs - -def train_step(*, model: Model, extern_data: Dict[str, Tensor], **_kwargs): - features = extern_data["audio_features"] - speaker_labels = extern_data["speaker_labels"] - logprobs = model(features, feature_time_dim) - - phonemes = extern_data["phonemes"] - - - raw_phonemes = phonemes.raw_tensor - raw_logprobs = logprobs.raw_tensor - - logprobs_len = feature_time_dim.dyn_size - phonemes_len = phoneme_time_dim.dyn_size - - print(logprobs_len) - print(phonemes_len) - print(logprobs_len.size()) - print(phonemes_len.size()) - print(raw_logprobs.size()) - - - loss = torch.nn.functional.ctc_loss(raw_logprobs.transpose(0, 1), raw_phonemes, input_lengths=logprobs_len, target_lengths=phonemes_len, blank=43) - - rf.get_run_ctx().mark_as_loss(loss, name="ce") diff --git a/users/rilling/experiments/librispeech/tts_architecture_improvement_23/pytorch_networks/ctc_aligner_v1.py b/users/rilling/experiments/librispeech/tts_architecture_improvement_23/pytorch_networks/ctc_aligner_v1.py deleted file mode 100644 index 28b7de571..000000000 --- a/users/rilling/experiments/librispeech/tts_architecture_improvement_23/pytorch_networks/ctc_aligner_v1.py +++ /dev/null @@ -1,296 +0,0 @@ -from dataclasses import dataclass -import torch -import numpy -from torch import nn -import multiprocessing - -from returnn.datasets.hdf import SimpleHDFWriter - - -class Conv1DBlock(torch.nn.Module): - """ - A 1D-Convolution with ReLU, batch-norm and non-broadcasted dropout - Will pad to the same output length - """ - - def __init__(self, in_size, out_size, filter_size, dropout): - """ - :param in_size: input feature size - :param out_size: output feature size - :param filter_size: filter size - :param dropout: dropout probability - """ - super().__init__() - assert filter_size % 2 == 1, "Only odd filter sizes allowed" - self.conv = nn.Conv1d(in_size, out_size, filter_size, padding=filter_size // 2) - self.bn = nn.BatchNorm1d(num_features=out_size) - self.dropout = dropout - - def forward(self, x): - """ - :param x: [B, F_in, T] - :return: [B, F_out, T] - """ - x = self.conv(x) - x = nn.functional.relu(x) - # TODO: does not consider masking! - x = self.bn(x) - x = nn.functional.dropout(x, p=self.dropout, training=self.training) - return x - - -class Model(torch.nn.Module): - """ - Default TTS aligner with 5 convolution blocks of size 5 followed by a BLSTM - """ - - def __init__( - self, - conv_hidden_size: int, - lstm_size: int, - speaker_embedding_size: int, - dropout: float, - target_size: int, - **kwargs, - ): - super().__init__() - self.audio_embedding = nn.Linear(80, conv_hidden_size) - self.speaker_embedding = nn.Embedding(251, speaker_embedding_size) - self.convs = nn.Sequential( - Conv1DBlock(conv_hidden_size + speaker_embedding_size, conv_hidden_size, filter_size=5, dropout=dropout), - Conv1DBlock(conv_hidden_size, conv_hidden_size, filter_size=5, dropout=dropout), - Conv1DBlock(conv_hidden_size, conv_hidden_size, filter_size=5, dropout=dropout), - Conv1DBlock(conv_hidden_size, conv_hidden_size, filter_size=5, dropout=dropout), - Conv1DBlock(conv_hidden_size, conv_hidden_size, filter_size=5, dropout=dropout), - ) - self.blstm = nn.LSTM(input_size=conv_hidden_size, hidden_size=lstm_size, bidirectional=True, batch_first=True) - self.final_linear = nn.Linear(2 * lstm_size, target_size) - self.lstm_size = lstm_size - self.target_size = target_size - self.dropout = dropout - - # initialize weights - self.apply(self._weight_init) - - @staticmethod - def _weight_init(module: torch.nn.Module): - if isinstance(module, torch.nn.Conv1d): - nn.init.xavier_normal_(module.weight) - - def forward( - self, - audio_features: torch.Tensor, - speaker_labels: torch.Tensor, - audio_features_len: torch.Tensor, - ): - """ - :param audio_features: [B, T, F] - :param speaker_labels: [B, 1] - :param audio_features_len: length of T as [B] - :return: logprobs as [B, T, #PHONES] - """ - speaker_embeddings: torch.Tensor = self.speaker_embedding(torch.squeeze(speaker_labels, dim=1)) - # manually broadcast speaker embeddings to each time step - speaker_embeddings = torch.repeat_interleave( - torch.unsqueeze(speaker_embeddings, 1), audio_features.size()[1], dim=1 - ) # [B, T, #SPK_EMB_SIZE] - audio_embedding = self.audio_embedding(audio_features) # [B, T, F] - - conv_in = torch.concat([speaker_embeddings, audio_embedding], dim=2) # [B, T, F] - conv_in = torch.swapaxes(conv_in, 1, 2) # [B, F, T] - conv_out = self.convs(conv_in) - blstm_in = torch.permute(conv_out, dims=(0, 2, 1)) # [B, F, T] -> [B, T, F] - - blstm_packed_in = nn.utils.rnn.pack_padded_sequence(blstm_in, audio_features_len.to("cpu"), batch_first=True) - blstm_packed_out, _ = self.blstm(blstm_packed_in) - blstm_out, _ = nn.utils.rnn.pad_packed_sequence( - blstm_packed_out, padding_value=0.0, batch_first=True - ) # [B, T, F] - blstm_out = nn.functional.dropout(blstm_out, p=self.dropout, training=self.training) - logits = self.final_linear(blstm_out) # [B, T, #PHONES] - log_probs = torch.log_softmax(logits, dim=2) # [B, T, #PHONES] - - return log_probs - - -def train_step(*, model: Model, data, run_ctx, **kwargs): - audio_features = data["audio_features"] # [B, T, F] - audio_features_len = data["audio_features:size1"] # [B] - - # perform local length sorting for more efficient packing - audio_features_len, indices = torch.sort(audio_features_len, descending=True) - - audio_features = audio_features[indices, :, :] - phonemes = data["phonemes"][indices, :] # [B, T] (sparse) - phonemes_len = data["phonemes:size1"][indices] # [B, T] - speaker_labels = data["speaker_labels"][indices, :] # [B, 1] (sparse) - - logprobs = model( - audio_features=audio_features, - audio_features_len=audio_features_len, - speaker_labels=speaker_labels, - ) - - transposed_logprobs = torch.permute(logprobs, (1, 0, 2)) # CTC needs [T, B, F] - ctc_loss = nn.functional.ctc_loss( - transposed_logprobs, - phonemes, - input_lengths=audio_features_len, - target_lengths=phonemes_len, - blank=model.target_size - 1, - reduction="sum", - ) - num_frames = torch.sum(phonemes_len) - run_ctx.mark_as_loss(name="ctc", loss=ctc_loss, inv_norm_factor=num_frames) - - -############# FORWARD STUFF ################ -import numpy as np -from scipy.sparse import coo_matrix -from scipy.sparse.csgraph import dijkstra - - -# Duration extraction helpers are taken from -# https://github.com/as-ideas/DeepForcedAligner/blob/main/dfa/duration_extraction.py -# with commit id d1f565604bba25d4c56e3e12b289ab335980e069 -# MIT license -def to_node_index(i, j, cols): - return cols * i + j - - -def from_node_index(node_index, cols): - return node_index // cols, node_index % cols - - -def to_adj_matrix(mat): - """ - :param mat: [T x N] matrix where for each time frame we have the N scores of our target phoneme labels - :return: A sparse CTC-style adjacent lattice matrix where the connection weight is the score of the "target" node - of each connection. - """ - rows = mat.shape[0] - cols = mat.shape[1] - - row_ind = [] - col_ind = [] - data = [] - - for i in range(rows): - for j in range(cols): - - node = to_node_index(i, j, cols) - - if j < cols - 1: - right_node = to_node_index(i, j + 1, cols) - weight_right = mat[i, j + 1] - row_ind.append(node) - col_ind.append(right_node) - data.append(weight_right) - - if i < rows - 1 and j < cols: - bottom_node = to_node_index(i + 1, j, cols) - weight_bottom = mat[i + 1, j] - row_ind.append(node) - col_ind.append(bottom_node) - data.append(weight_bottom) - - if i < rows - 1 and j < cols - 1: - bottom_right_node = to_node_index(i + 1, j + 1, cols) - weight_bottom_right = mat[i + 1, j + 1] - row_ind.append(node) - col_ind.append(bottom_right_node) - data.append(weight_bottom_right) - - adj_mat = coo_matrix((data, (row_ind, col_ind)), shape=(rows * cols, rows * cols)) - return adj_mat.tocsr() - - -@dataclass() -class AlignSequence: - """ - :param logprobs: [T x F] log probabilities - :param phonemes: [N] indexed tokens with indices in the range [0, F-1] - """ - logprobs: np.ndarray - phonemes: np.ndarray - - -def extract_durations_with_dijkstra(sequence: AlignSequence) -> np.array: - """ - Extracts durations from the attention matrix by finding the shortest monotonic path from - top left to bottom right. - - :return durations: [N] durations which sum to T - """ - - neg_log_weights = -sequence.logprobs[:, sequence.phonemes] - adj_matrix = to_adj_matrix(neg_log_weights) - dist_matrix, predecessors = dijkstra(csgraph=adj_matrix, directed=True, indices=0, return_predecessors=True) - path = [] - pr_index = predecessors[-1] - while pr_index != 0: - path.append(pr_index) - pr_index = predecessors[pr_index] - path.reverse() - - # append first and last node - path = [0] + path + [dist_matrix.size - 1] - cols = neg_log_weights.shape[1] - mel_text = {} - durations = np.zeros(sequence.phonemes.shape[0], dtype=np.int32) - - # collect indices (mel, text) along the path - for node_index in path: - i, j = from_node_index(node_index, cols) - mel_text[i] = j - - for j in mel_text.values(): - durations[j] += 1 - - return durations - - -def forward_init_hook(run_ctx, **kwargs): - run_ctx.hdf_writer = SimpleHDFWriter("durations.hdf", dim=None, ndim=1) - run_ctx.pool = multiprocessing.Pool(8) - - -def forward_finish_hook(run_ctx, **kwargs): - run_ctx.hdf_writer.close() - - -def forward_step(*, model: Model, data, run_ctx, **kwargs): - tags = data["seq_tag"] - audio_features = data["audio_features"] # [B, T, F] - audio_features_len = data["audio_features:size1"] # [B] - - # perform local length sorting for more efficient packing - audio_features_len, indices = torch.sort(audio_features_len, descending=True) - - audio_features = audio_features[indices, :, :] - phonemes = data["phonemes"][indices, :] # [B, T] (sparse) - phonemes_len = data["phonemes:size1"][indices] # [B, T] - speaker_labels = data["speaker_labels"][indices, :] # [B, 1] (sparse) - - logprobs = model( - audio_features=audio_features, - audio_features_len=audio_features_len, - speaker_labels=speaker_labels, - ) - - numpy_logprobs = logprobs.detach().cpu().numpy() - numpy_phonemes = phonemes.detach().cpu().numpy() - - align_sequences = [] - - for single_logprobs, single_phonemes, feat_len, phon_len in zip( - numpy_logprobs, numpy_phonemes, audio_features_len, phonemes_len - ): - align_sequences.append(AlignSequence(single_logprobs[:feat_len], single_phonemes[:phon_len])) - - durations = run_ctx.pool.map(extract_durations_with_dijkstra, align_sequences) - for tag, duration, feat_len, phon_len in zip(tags, durations, audio_features_len, phonemes_len): - total_sum = numpy.sum(duration) - assert total_sum == feat_len - assert len(duration) == phon_len - run_ctx.hdf_writer.insert_batch(numpy.asarray([duration]), [len(duration)], [tag]) diff --git a/users/rilling/experiments/librispeech/tts_architecture_improvement_23/pytorch_networks/ctc_aligner_v1_ctc_sum.py b/users/rilling/experiments/librispeech/tts_architecture_improvement_23/pytorch_networks/ctc_aligner_v1_ctc_sum.py deleted file mode 100644 index 783cb6ddc..000000000 --- a/users/rilling/experiments/librispeech/tts_architecture_improvement_23/pytorch_networks/ctc_aligner_v1_ctc_sum.py +++ /dev/null @@ -1,109 +0,0 @@ -import time -import torch -from torch import nn -from torch.onnx import export - - -class Conv1DBlock(torch.nn.Module): - - def __init__(self, in_size, out_size, filter_size, dropout): - super().__init__() - self.conv = nn.Conv1d(in_size, out_size, filter_size, padding=filter_size//2) - self.bn = nn.BatchNorm1d(num_features=out_size) - self.dropout = dropout - - def forward(self, x): - """ - - :param x: should be [B, C, T] - :return: - """ - x = self.conv(x) - x = nn.functional.relu(x) - # TODO: does not consider masking! - x = self.bn(x) - x = nn.functional.dropout1d(x, p=self.dropout) - return x - - -class Model(torch.nn.Module): - - - def __init__(self, - conv_hidden_size: int, - lstm_size: int, - speaker_embedding_size: int, - dropout: float, - target_size: int, - epoch: int, - step: int, - ): - super().__init__() - self.audio_embedding = nn.Linear(80, conv_hidden_size) - self.speaker_embedding = nn.Embedding(251, speaker_embedding_size) - self.convs = nn.Sequential( - Conv1DBlock(conv_hidden_size + speaker_embedding_size, conv_hidden_size, filter_size=5, dropout=dropout), - Conv1DBlock(conv_hidden_size, conv_hidden_size, filter_size=5, dropout=dropout), - Conv1DBlock(conv_hidden_size, conv_hidden_size, filter_size=5, dropout=dropout), - Conv1DBlock(conv_hidden_size, conv_hidden_size, filter_size=5, dropout=dropout), - Conv1DBlock(conv_hidden_size, conv_hidden_size, filter_size=5, dropout=dropout), - ) - self.blstm = nn.LSTM( - input_size=conv_hidden_size, - hidden_size=lstm_size, - bidirectional=True, - batch_first=True) - self.final_linear = nn.Linear(2*lstm_size, target_size) - self.lstm_size = lstm_size - self.target_size = target_size - self.dropout = dropout - - def forward( - self, - audio_features: torch.Tensor, - speaker_labels: torch.Tensor, - audio_features_len: torch.Tensor, - ): - speaker_embeddings: torch.Tensor = self.speaker_embedding(torch.squeeze(speaker_labels, dim=1)) - # manually broadcast speaker embeddings to each time step - speaker_embeddings = torch.repeat_interleave(torch.unsqueeze(speaker_embeddings, 1), audio_features.size()[1], dim=1) # [B, T, F] - audio_embedding = self.audio_embedding(audio_features) # [B, T, F] - - conv_in = torch.concat([speaker_embeddings, audio_embedding], dim=2) # [B, T, F] - conv_in = torch.swapaxes(conv_in, 1, 2) # [B, C, T] - conv_out = self.convs(conv_in) - blstm_in = torch.permute(conv_out, dims=(0, 2, 1)) # [B, C, T] -> [B, T, C] - - blstm_packed_in = nn.utils.rnn.pack_padded_sequence(blstm_in, audio_features_len.to("cpu"), batch_first=True) - blstm_packed_out, _ = self.blstm(blstm_packed_in) - blstm_out, _ = nn.utils.rnn.pad_packed_sequence(blstm_packed_out, padding_value=0.0, batch_first=True) # [B, T, C] - blstm_out = nn.functional.dropout1d(blstm_out, p=self.dropout) - logits = self.final_linear(blstm_out) # [B, T, #PHONES] - log_probs = torch.log_softmax(logits, dim=2) # [B, T, #PHONES] - - return log_probs - -def train_step(*, model: Model, data, run_ctx, **kwargs): - audio_features = data["audio_features"] # [B, T, F] - audio_features_len = data["audio_features:size1"] # [B] - - # perform local length sorting for more efficient packing - audio_features_len, indices = torch.sort(audio_features_len, descending=True) - - audio_features = audio_features[indices, :, :] - phonemes = data["phonemes"][indices, :] # [B, T] (sparse) - phonemes_len = data["phonemes:size1"][indices] # [B, T] - speaker_labels = data["speaker_labels"][indices, :] # [B, 1] (sparse) - - logprobs = model( - audio_features=audio_features, - audio_features_len=audio_features_len, - speaker_labels=speaker_labels, - ) - - transposed_logprobs = torch.permute(logprobs, (1, 0, 2)) - ctc_loss = nn.functional.ctc_loss(transposed_logprobs, phonemes, input_lengths=audio_features_len, target_lengths=phonemes_len, - blank=model.target_size-1, reduction="sum") - num_frames = torch.sum(phonemes_len) - run_ctx.mark_as_loss(name="ctc_sum", loss=ctc_loss, inv_norm_factor=None) - run_ctx.mark_as_loss(name="ctc", loss=ctc_loss, scale=0.0, inv_norm_factor=num_frames) diff --git a/users/rilling/experiments/librispeech/tts_architecture_improvement_23/pytorch_networks/ctc_aligner_v1_ctc_sum_nobroad.py b/users/rilling/experiments/librispeech/tts_architecture_improvement_23/pytorch_networks/ctc_aligner_v1_ctc_sum_nobroad.py deleted file mode 100644 index b2b8aaa20..000000000 --- a/users/rilling/experiments/librispeech/tts_architecture_improvement_23/pytorch_networks/ctc_aligner_v1_ctc_sum_nobroad.py +++ /dev/null @@ -1,103 +0,0 @@ -import time -import torch -from torch import nn -from torch.onnx import export - - -class Conv1DBlock(torch.nn.Module): - """ - Variant without dropout broadcasting - """ - def __init__(self, in_size, out_size, filter_size, dropout): - super().__init__() - self.conv = nn.Conv1d(in_size, out_size, filter_size, padding=filter_size//2) - self.bn = nn.BatchNorm1d(num_features=out_size) - self.dropout = dropout - - def forward(self, x): - """ - - :param x: should be [B, C, T] - :return: - """ - x = self.conv(x) - x = nn.functional.relu(x) - # TODO: does not consider masking! - x = self.bn(x) - x = nn.functional.dropout(x, p=self.dropout) - return x - - -class Model(torch.nn.Module): - - - def __init__(self, conv_hidden_size: int, lstm_size: int, speaker_embedding_size: int, dropout: float, target_size: int): - super().__init__() - self.audio_embedding = nn.Linear(80, conv_hidden_size) - self.speaker_embedding = nn.Embedding(251, speaker_embedding_size) - self.convs = nn.Sequential( - Conv1DBlock(conv_hidden_size + speaker_embedding_size, conv_hidden_size, filter_size=5, dropout=dropout), - Conv1DBlock(conv_hidden_size, conv_hidden_size, filter_size=5, dropout=dropout), - Conv1DBlock(conv_hidden_size, conv_hidden_size, filter_size=5, dropout=dropout), - Conv1DBlock(conv_hidden_size, conv_hidden_size, filter_size=5, dropout=dropout), - Conv1DBlock(conv_hidden_size, conv_hidden_size, filter_size=5, dropout=dropout), - ) - self.blstm = nn.LSTM( - input_size=conv_hidden_size, - hidden_size=lstm_size, - bidirectional=True, - batch_first=True) - self.final_linear = nn.Linear(2*lstm_size, target_size) - self.lstm_size = lstm_size - self.target_size = target_size - self.dropout = dropout - - def forward( - self, - audio_features: torch.Tensor, - speaker_labels: torch.Tensor, - audio_features_len: torch.Tensor, - ): - speaker_embeddings: torch.Tensor = self.speaker_embedding(torch.squeeze(speaker_labels, dim=1)) - # manually broadcast speaker embeddings to each time step - speaker_embeddings = torch.repeat_interleave(torch.unsqueeze(speaker_embeddings, 1), audio_features.size()[1], dim=1) # [B, T, F] - audio_embedding = self.audio_embedding(audio_features) # [B, T, F] - - conv_in = torch.concat([speaker_embeddings, audio_embedding], dim=2) # [B, T, F] - conv_in = torch.swapaxes(conv_in, 1, 2) # [B, C, T] - conv_out = self.convs(conv_in) - blstm_in = torch.permute(conv_out, dims=(0, 2, 1)) # [B, C, T] -> [B, T, C] - - blstm_packed_in = nn.utils.rnn.pack_padded_sequence(blstm_in, audio_features_len.to("cpu"), batch_first=True) - blstm_packed_out, _ = self.blstm(blstm_packed_in) - blstm_out, _ = nn.utils.rnn.pad_packed_sequence(blstm_packed_out, padding_value=0.0, batch_first=True) # [B, T, C] - blstm_out = nn.functional.dropout1d(blstm_out, p=self.dropout) - logits = self.final_linear(blstm_out) # [B, T, #PHONES] - log_probs = torch.log_softmax(logits, dim=2) # [B, T, #PHONES] - - return log_probs - -def train_step(*, model: Model, data, run_ctx, **kwargs): - audio_features = data["audio_features"] # [B, T, F] - audio_features_len = data["audio_features:size1"] # [B] - - # perform local length sorting for more efficient packing - audio_features_len, indices = torch.sort(audio_features_len, descending=True) - - audio_features = audio_features[indices, :, :] - phonemes = data["phonemes"][indices, :] # [B, T] (sparse) - phonemes_len = data["phonemes:size1"][indices] # [B, T] - speaker_labels = data["speaker_labels"][indices, :] # [B, 1] (sparse) - - logprobs = model( - audio_features=audio_features, - audio_features_len=audio_features_len, - speaker_labels=speaker_labels, - ) - - transposed_logprobs = torch.permute(logprobs, (1, 0, 2)) - ctc_loss = nn.functional.ctc_loss(transposed_logprobs, phonemes, input_lengths=audio_features_len, target_lengths=phonemes_len, - blank=model.target_size-1, reduction="sum") - num_frames = torch.sum(phonemes_len) - run_ctx.mark_as_loss(name="ctc_sum", loss=ctc_loss, inv_norm_factor=None) - run_ctx.mark_as_loss(name="ctc", loss=ctc_loss, scale=0.0, inv_norm_factor=num_frames) diff --git a/users/rilling/experiments/librispeech/tts_architecture_improvement_23/pytorch_networks/ctc_aligner_v1_gradaccum.py b/users/rilling/experiments/librispeech/tts_architecture_improvement_23/pytorch_networks/ctc_aligner_v1_gradaccum.py deleted file mode 100644 index 10bf6811b..000000000 --- a/users/rilling/experiments/librispeech/tts_architecture_improvement_23/pytorch_networks/ctc_aligner_v1_gradaccum.py +++ /dev/null @@ -1,149 +0,0 @@ -from random import random -import time -import torch -from torch import nn, Tensor -from torch.onnx import export -from typing import Dict, Tuple - -from returnn.torch.engine import Engine as TorchEngine -from returnn.torch.context import RunCtx, Loss - - -class CustomEngine(TorchEngine): - - def run_train_step(self, data: dict[str, torch.Tensor], run_ctx: RunCtx) -> Tuple[Tensor, Dict[str, Loss]]: - """ - :param data: model inputs for the step - :param run_ctx: the current run ctx object - :return: total loss (weighted sum) calculated for the step, and individual losses as a name -> value mapping - """ - assert isinstance(data, dict) and data - # move all data to the target device as default - # note that in some cases, e.g. for using rnn.pack_padded_sequence you need to have - # length tensors on CPU - data = {k: v.to(self._device) for (k, v) in data.items()} - - sentinel_kw = {"__fwd_compatible_random_arg_%i" % int(random() * 100): None} - self._train_step_func(model=self._model, data=data, run_ctx=run_ctx, **sentinel_kw) - - losses_dict = run_ctx.losses - total_loss = run_ctx.total_loss() - - total_loss.backward() - if self.grad_clip_value > 0.0: - torch.nn.utils.clip_grad_value_(self._model.parameters(), self.grad_clip_value) - - if self._train_step % 2 == 0: - self._updater.get_optimizer().step() - self._updater.get_optimizer().zero_grad() - - return total_loss, losses_dict - -class Conv1DBlock(torch.nn.Module): - - def __init__(self, in_size, out_size, filter_size, dropout): - super().__init__() - self.conv = nn.Conv1d(in_size, out_size, filter_size, padding=filter_size//2) - self.bn = nn.BatchNorm1d(num_features=out_size) - self.dropout = dropout - - def forward(self, x): - """ - - :param x: should be [B, C, T] - :return: - """ - x = self.conv(x) - x = nn.functional.relu(x) - # TODO: does not consider masking! - x = self.bn(x) - x = nn.functional.dropout(x, p=self.dropout) - return x - - -class Model(torch.nn.Module): - """ - """ - - def __init__(self, conv_hidden_size: int, lstm_size: int, speaker_embedding_size: int, dropout: float, target_size: int, **kwargs): - super().__init__() - self.audio_embedding = nn.Linear(80, conv_hidden_size) - self.speaker_embedding = nn.Embedding(251, speaker_embedding_size) - self.convs = nn.Sequential( - Conv1DBlock(conv_hidden_size + speaker_embedding_size, conv_hidden_size, filter_size=5, dropout=dropout), - Conv1DBlock(conv_hidden_size, conv_hidden_size, filter_size=5, dropout=dropout), - Conv1DBlock(conv_hidden_size, conv_hidden_size, filter_size=5, dropout=dropout), - Conv1DBlock(conv_hidden_size, conv_hidden_size, filter_size=5, dropout=dropout), - Conv1DBlock(conv_hidden_size, conv_hidden_size, filter_size=5, dropout=dropout), - ) - self.blstm = nn.LSTM( - input_size=conv_hidden_size, - hidden_size=lstm_size, - bidirectional=True, - batch_first=True) - self.final_linear = nn.Linear(2*lstm_size, target_size) - self.lstm_size = lstm_size - self.target_size = target_size - self.dropout = dropout - - # initialize weights - self.apply(self._weight_init) - - @staticmethod - def _weight_init(module: torch.nn.Module): - if isinstance(module, torch.nn.Conv1d): - nn.init.xavier_normal_(module.weight) - - def forward( - self, - audio_features: torch.Tensor, - speaker_labels: torch.Tensor, - audio_features_len: torch.Tensor, - ): - speaker_embeddings: torch.Tensor = self.speaker_embedding(torch.squeeze(speaker_labels, dim=1)) - # manually broadcast speaker embeddings to each time step - speaker_embeddings = torch.repeat_interleave(torch.unsqueeze(speaker_embeddings, 1), audio_features.size()[1], dim=1) # [B, T, F] - audio_embedding = self.audio_embedding(audio_features) # [B, T, F] - - conv_in = torch.concat([speaker_embeddings, audio_embedding], dim=2) # [B, T, F] - conv_in = torch.swapaxes(conv_in, 1, 2) # [B, C, T] - conv_out = self.convs(conv_in) - blstm_in = torch.permute(conv_out, dims=(0, 2, 1)) # [B, C, T] -> [B, T, C] - - blstm_packed_in = nn.utils.rnn.pack_padded_sequence(blstm_in, audio_features_len.to("cpu"), batch_first=True) - blstm_packed_out, _ = self.blstm(blstm_packed_in) - blstm_out, _ = nn.utils.rnn.pad_packed_sequence(blstm_packed_out, padding_value=0.0, batch_first=True) # [B, T, C] - blstm_out = nn.functional.dropout1d(blstm_out, p=self.dropout) - logits = self.final_linear(blstm_out) # [B, T, #PHONES] - log_probs = torch.log_softmax(logits, dim=2) # [B, T, #PHONES] - - return log_probs - - -def train_step(*, model: Model, data, run_ctx, **kwargs): - audio_features = data["audio_features"] # [B, T, F] - audio_features_len = data["audio_features:size1"] # [B] - - # perform local length sorting for more efficient packing - audio_features_len, indices = torch.sort(audio_features_len, descending=True) - - audio_features = audio_features[indices, :, :] - phonemes = data["phonemes"][indices, :] # [B, T] (sparse) - phonemes_len = data["phonemes:size1"][indices] # [B, T] - speaker_labels = data["speaker_labels"][indices, :] # [B, 1] (sparse) - - logprobs = model( - audio_features=audio_features, - audio_features_len=audio_features_len, - speaker_labels=speaker_labels, - ) - - #params = 0 - #for parameter in model.parameters(): - # params += parameter.data.size().numel() - #print(params) - transposed_logprobs = torch.permute(logprobs, (1, 0, 2)) # Needs [T, B, F] - ctc_loss = nn.functional.ctc_loss(transposed_logprobs, phonemes, input_lengths=audio_features_len, target_lengths=phonemes_len, - blank=model.target_size-1, reduction="sum") - num_frames = torch.sum(phonemes_len) - run_ctx.mark_as_loss(name="ctc", loss=ctc_loss, inv_norm_factor=num_frames) diff --git a/users/rilling/experiments/librispeech/tts_architecture_improvement_23/pytorch_networks/ctc_aligner_v2.py b/users/rilling/experiments/librispeech/tts_architecture_improvement_23/pytorch_networks/ctc_aligner_v2.py deleted file mode 100644 index 098a772c6..000000000 --- a/users/rilling/experiments/librispeech/tts_architecture_improvement_23/pytorch_networks/ctc_aligner_v2.py +++ /dev/null @@ -1,265 +0,0 @@ -""" - -Aligner version 2 with some updates: - - Separate CTC and Final dropout values - - xavier_uniform instead of xavier_normal -""" -import tempfile -import h5py - -import torch -from torch import nn - - -class Conv1DBlock(torch.nn.Module): - def __init__(self, in_size, out_size, filter_size, dropout): - super().__init__() - self.conv = nn.Conv1d(in_size, out_size, filter_size, padding=filter_size // 2) - self.bn = nn.BatchNorm1d(num_features=out_size) - self.dropout = dropout - - def forward(self, x): - """ - - :param x: should be [B, C, T] - :return: - """ - x = self.conv(x) - x = nn.functional.relu(x) - # TODO: does not consider masking! - x = self.bn(x) - x = nn.functional.dropout(x, p=self.dropout, training=self.training) - return x - - -class Model(torch.nn.Module): - """ """ - - def __init__( - self, - conv_hidden_size: int, - lstm_size: int, - speaker_embedding_size: int, - conv_dropout: float, - final_dropout: float, - target_size: int, - **kwargs, - ): - super().__init__() - self.audio_embedding = nn.Linear(80, conv_hidden_size) - self.speaker_embedding = nn.Embedding(251, speaker_embedding_size) - self.convs = nn.Sequential( - Conv1DBlock( - conv_hidden_size + speaker_embedding_size, conv_hidden_size, filter_size=5, dropout=conv_dropout - ), - Conv1DBlock(conv_hidden_size, conv_hidden_size, filter_size=5, dropout=conv_dropout), - Conv1DBlock(conv_hidden_size, conv_hidden_size, filter_size=5, dropout=conv_dropout), - Conv1DBlock(conv_hidden_size, conv_hidden_size, filter_size=5, dropout=conv_dropout), - Conv1DBlock(conv_hidden_size, conv_hidden_size, filter_size=5, dropout=conv_dropout), - ) - self.blstm = nn.LSTM(input_size=conv_hidden_size, hidden_size=lstm_size, bidirectional=True, batch_first=True) - self.final_linear = nn.Linear(2 * lstm_size, target_size) - self.lstm_size = lstm_size - self.target_size = target_size - self.final_dropout = final_dropout - - # initialize weights - self.apply(self._weight_init) - - @staticmethod - def _weight_init(module: torch.nn.Module): - if isinstance(module, torch.nn.Conv1d): - nn.init.xavier_uniform_(module.weight) - - def forward( - self, - audio_features: torch.Tensor, - speaker_labels: torch.Tensor, - audio_features_len: torch.Tensor, - ): - speaker_embeddings: torch.Tensor = self.speaker_embedding(torch.squeeze(speaker_labels, dim=1)) - # manually broadcast speaker embeddings to each time step - speaker_embeddings = torch.repeat_interleave( - torch.unsqueeze(speaker_embeddings, 1), audio_features.size()[1], dim=1 - ) # [B, T, F] - audio_embedding = self.audio_embedding(audio_features) # [B, T, F] - - conv_in = torch.concat([speaker_embeddings, audio_embedding], dim=2) # [B, T, F] - conv_in = torch.swapaxes(conv_in, 1, 2) # [B, C, T] - conv_out = self.convs(conv_in) - blstm_in = torch.permute(conv_out, dims=(0, 2, 1)) # [B, C, T] -> [B, T, C] - - blstm_packed_in = nn.utils.rnn.pack_padded_sequence(blstm_in, audio_features_len.to("cpu"), batch_first=True) - blstm_packed_out, _ = self.blstm(blstm_packed_in) - blstm_out, _ = nn.utils.rnn.pad_packed_sequence( - blstm_packed_out, padding_value=0.0, batch_first=True - ) # [B, T, C] - blstm_out = nn.functional.dropout(blstm_out, p=self.final_dropout, training=self.training) - logits = self.final_linear(blstm_out) # [B, T, #PHONES] - log_probs = torch.log_softmax(logits, dim=2) # [B, T, #PHONES] - - return log_probs - - -def train_step(*, model: Model, data, run_ctx, **kwargs): - audio_features = data["audio_features"] # [B, T, F] - audio_features_len = data["audio_features:size1"] # [B] - - # perform local length sorting for more efficient packing - audio_features_len, indices = torch.sort(audio_features_len, descending=True) - - audio_features = audio_features[indices, :, :] - phonemes = data["phonemes"][indices, :] # [B, T] (sparse) - phonemes_len = data["phonemes:size1"][indices] # [B, T] - speaker_labels = data["speaker_labels"][indices, :] # [B, 1] (sparse) - - logprobs = model( - audio_features=audio_features, - audio_features_len=audio_features_len, - speaker_labels=speaker_labels, - ) - - # params = 0 - # for parameter in model.parameters(): - # params += parameter.data.size().numel() - # print(params) - transposed_logprobs = torch.permute(logprobs, (1, 0, 2)) # Needs [T, B, F] - ctc_loss = nn.functional.ctc_loss( - transposed_logprobs, - phonemes, - input_lengths=audio_features_len, - target_lengths=phonemes_len, - blank=model.target_size - 1, - reduction="sum", - ) - num_frames = torch.sum(phonemes_len) - run_ctx.mark_as_loss(name="ctc", loss=ctc_loss, inv_norm_factor=num_frames) - - -############# FORWARD STUFF ################ - -import numpy as np -from scipy.sparse import coo_matrix -from scipy.sparse.csgraph import dijkstra - - -def to_node_index(i, j, cols): - return cols * i + j - - -def from_node_index(node_index, cols): - return node_index // cols, node_index % cols - - -def to_adj_matrix(mat): - rows = mat.shape[0] - cols = mat.shape[1] - - row_ind = [] - col_ind = [] - data = [] - - for i in range(rows): - for j in range(cols): - - node = to_node_index(i, j, cols) - - if j < cols - 1: - right_node = to_node_index(i, j + 1, cols) - weight_right = mat[i, j + 1] - row_ind.append(node) - col_ind.append(right_node) - data.append(weight_right) - - if i < rows - 1 and j < cols: - bottom_node = to_node_index(i + 1, j, cols) - weight_bottom = mat[i + 1, j] - row_ind.append(node) - col_ind.append(bottom_node) - data.append(weight_bottom) - - if i < rows - 1 and j < cols - 1: - bottom_right_node = to_node_index(i + 1, j + 1, cols) - weight_bottom_right = mat[i + 1, j + 1] - row_ind.append(node) - col_ind.append(bottom_right_node) - data.append(weight_bottom_right) - - adj_mat = coo_matrix((data, (row_ind, col_ind)), shape=(rows * cols, rows * cols)) - return adj_mat.tocsr() - - -def extract_durations_with_dijkstra(tokens: np.array, log_probs: np.array) -> np.array: - """ - Extracts durations from the attention matrix by finding the shortest monotonic path from - top left to bottom right. - - :param tokens: - - """ - - neg_log_weights = -pred[:, tokens] - adj_matrix = to_adj_matrix(neg_log_weights) - dist_matrix, predecessors = dijkstra(csgraph=adj_matrix, directed=True, indices=0, return_predecessors=True) - path = [] - pr_index = predecessors[-1] - while pr_index != 0: - path.append(pr_index) - pr_index = predecessors[pr_index] - path.reverse() - - # append first and last node - path = [0] + path + [dist_matrix.size - 1] - cols = neg_log_weights.shape[1] - mel_text = {} - durations = np.zeros(tokens.shape[0], dtype=np.int32) - - # collect indices (mel, text) along the path - for node_index in path: - i, j = from_node_index(node_index, cols) - mel_text[i] = j - - for j in mel_text.values(): - durations[j] += 1 - - return durations - - -def forward_init_hook(run_ctx): - fd, fname = tempfile.mkstemp("durations.hdf") - # run_ctx.hdf_writer = - - -def forward_finish_hook(run_ctx): - pass - - -def forward_step(*, model: Model, data, run_ctx, **kwargs): - if not hasattr(run_ctx, "hdf_writer"): - run_ctx.hdf_writer = SimpleHDFWriter() - - audio_features = data["audio_features"] # [B, T, F] - audio_features_len = data["audio_features:size1"] # [B] - - # perform local length sorting for more efficient packing - audio_features_len, indices = torch.sort(audio_features_len, descending=True) - - audio_features = audio_features[indices, :, :] - phonemes = data["phonemes"][indices, :] # [B, T] (sparse) - phonemes_len = data["phonemes:size1"][indices] # [B, T] - speaker_labels = data["speaker_labels"][indices, :] # [B, 1] (sparse) - - logprobs = model( - audio_features=audio_features, - audio_features_len=audio_features_len, - speaker_labels=speaker_labels, - ) - - numpy_logprobs = logprobs.detach().cpu().numpy() - numpy_phonemes = phonemes.detach().cpu().numpy() - for single_logprobs, single_phonemes, len in zip(numpy_logprobs, numpy_phonemes, phonemes_len): - durations = extract_durations_with_dijkstra( - single_phonemes, - single_logprobs, - ) - assert numpy.sum(durations) == len.detach().cpu().numpy() diff --git a/users/rilling/experiments/librispeech/tts_architecture_improvement_23/rc_networks/__init__.py b/users/rilling/experiments/librispeech/tts_architecture_improvement_23/rc_networks/__init__.py deleted file mode 100644 index e69de29bb..000000000 diff --git a/users/rilling/experiments/librispeech/tts_architecture_improvement_23/rc_networks/ctc_aligner/__init__.py b/users/rilling/experiments/librispeech/tts_architecture_improvement_23/rc_networks/ctc_aligner/__init__.py deleted file mode 100644 index e69de29bb..000000000 diff --git a/users/rilling/experiments/librispeech/tts_architecture_improvement_23/rc_networks/ctc_aligner/conv_blstm_rec.py b/users/rilling/experiments/librispeech/tts_architecture_improvement_23/rc_networks/ctc_aligner/conv_blstm_rec.py deleted file mode 100644 index b8b5d895a..000000000 --- a/users/rilling/experiments/librispeech/tts_architecture_improvement_23/rc_networks/ctc_aligner/conv_blstm_rec.py +++ /dev/null @@ -1,211 +0,0 @@ -""" -Implementation of the CTC Aligner, updated for the new non-lazy init -""" -from typing import Tuple, Union -from returnn_common import nn -from ..shared.convolution import Conv1DStack -from .parameters import ConvBlstmRecParams - - -class TTSDecoder(nn.Module): - """ - Decoder for audio reconstruction - """ - - def __init__(self, in_dim: nn.Dim, lstm_dim: int = 512): - """ - :param lstm_dim: LSTM dimension size - """ - super(TTSDecoder, self).__init__() - self.lstm_dim = nn.FeatureDim("dec_lstm_dim", lstm_dim) - self.lstm_1_fw = nn.LSTM(in_dim=in_dim, out_dim=self.lstm_dim) - self.lstm_1_bw = nn.LSTM(in_dim=in_dim, out_dim=self.lstm_dim) - self.lstm_2_fw = nn.LSTM(in_dim=2*self.lstm_dim, out_dim=self.lstm_dim) - self.lstm_2_bw = nn.LSTM(in_dim=2*self.lstm_dim, out_dim=self.lstm_dim) - - def __call__( - self, phoneme_probs: nn.Tensor, speaker_embedding: nn.Tensor, audio_time: nn.Dim - ): - """ - :param phoneme_probs: - :param speaker_embedding: - :param audio_time: - :return: - """ - cat, _ = nn.concat( - (phoneme_probs, phoneme_probs.feature_dim), - (speaker_embedding, speaker_embedding.feature_dim), - allow_broadcast=True, - ) - lstm_fw, _ = self.lstm_1_fw(cat, spatial_dim=audio_time, direction=1) - lstm_bw, _ = self.lstm_1_bw(cat, spatial_dim=audio_time, direction=-1) - # TODO maybe dropout? - cat, _ = nn.concat((lstm_fw, lstm_fw.feature_dim), (lstm_bw, lstm_bw.feature_dim)) - lstm_fw, _ = self.lstm_2_fw(cat, spatial_dim=audio_time, direction=1) - lstm_bw, _ = self.lstm_2_bw(cat, spatial_dim=audio_time, direction=-1) - cat, _ = nn.concat((lstm_fw, lstm_fw.feature_dim), (lstm_bw, lstm_bw.feature_dim)) - return cat - - -class CTCAligner(nn.Module): - """ - CTC Aligner from Timur Schümann implemented in returnn common - """ - - def __init__( - self, - audio_feature_dim: nn.Dim, - speaker_label_dim: nn.Dim, - phoneme_dim: nn.Dim, - parameters: ConvBlstmRecParams, - ): - """ - - :param audio_feature_dim: - :param speaker_label_dim: - :param phoneme_dim: - :param parameters: - """ - super(CTCAligner, self).__init__() - - self.audio_hidden_dim = nn.FeatureDim("audio_hidden_dim", parameters.audio_emb_size) - self.speaker_embedding_dim = nn.FeatureDim("speaker_embedding_dim", parameters.speaker_emb_size) - self.hidden_dim = nn.FeatureDim("hidden_size", parameters.conv_hidden_size) - self.enc_lstm_dim = nn.FeatureDim("enc_lstm_dim", parameters.enc_lstm_size) - - self.audio_embedding = nn.Linear(in_dim=audio_feature_dim, out_dim=self.audio_hidden_dim) - self.speaker_embedding = nn.Embedding(in_dim=speaker_label_dim, out_dim=self.speaker_embedding_dim) - self.enc_conv_stack = Conv1DStack(in_dim=self.speaker_embedding_dim + self.audio_hidden_dim, dropout=[parameters.dropout]*5) - self.enc_lstm_fw = nn.LSTM(in_dim=self.enc_conv_stack.out_dim, out_dim=self.enc_lstm_dim) - self.enc_lstm_bw = nn.LSTM(in_dim=self.enc_conv_stack.out_dim, out_dim=self.enc_lstm_dim) - - self.softmax_dim = nn.FeatureDim("softmax_linear", phoneme_dim.dimension) - - self.softmax_lin = nn.Linear( - in_dim=2*self.enc_lstm_dim, - out_dim=self.softmax_dim, - ) - self.tts_decoder = TTSDecoder(in_dim=self.softmax_dim + self.speaker_embedding_dim, lstm_dim=parameters.rec_lstm_size) - self.reconstruction_lin = nn.Linear( - in_dim=2*self.tts_decoder.lstm_dim, - out_dim=nn.FeatureDim("reconstruction_dim", 80) - ) - - self.spectrogram_drop = parameters.dropout - self.reconstruction_scale = parameters.reconstruction_scale - self.training = parameters.training - - def __call__( - self, - audio_features: nn.Tensor, - speaker_labels: nn.Tensor, - phonemes: nn.Tensor, - audio_time: nn.Dim, - speaker_label_time: nn.Dim, - phoneme_time: nn.Dim, - ): - """ - :param audio_features: - :param speaker_labels: - :param phonemes: - :param audio_time: - :param speaker_label_time: - :return: - """ - speaker_label_notime = nn.squeeze(speaker_labels, axis=speaker_label_time) - - # embedding - speaker_embedding = self.speaker_embedding(speaker_label_notime) - audio_embedding = self.audio_embedding(audio_features) - # encoder - cat, _ = nn.concat( - (speaker_embedding, speaker_embedding.feature_dim), - (audio_embedding, audio_embedding.feature_dim), - allow_broadcast=True, - ) - enc_conv = self.enc_conv_stack(cat, time_dim=audio_time) - enc_fw, _ = self.enc_lstm_fw(enc_conv, spatial_dim=audio_time, direction=1) - enc_bw, _ = self.enc_lstm_bw(enc_conv, spatial_dim=audio_time, direction=-1) - cat, _ = nn.concat((enc_fw, enc_fw.feature_dim), (enc_bw, enc_bw.feature_dim)) - - # spectogram loss - spectogram_encoder = nn.dropout( - cat, dropout=self.spectrogram_drop, axis=cat.feature_dim - ) - spectogram_encoder = self.softmax_lin(spectogram_encoder) - softmax = nn.softmax(spectogram_encoder, axis=spectogram_encoder.feature_dim) - ctc = nn.ctc_loss(logits=spectogram_encoder, targets=phonemes) - ctc.mark_as_loss(name="ctc", custom_inv_norm_factor=nn.length(dim=phoneme_time)) - - if self.training: - # TTS decoder - tts_decoder = self.tts_decoder( - phoneme_probs=softmax, - speaker_embedding=speaker_embedding, - audio_time=audio_time, - ) - reconstruction_lin = self.reconstruction_lin(tts_decoder) - audio_features, _ = nn.replace_dim( - audio_features, - in_dim=audio_features.feature_dim, - out_dim=reconstruction_lin.feature_dim, - ) - reconstruction_loss = nn.mean_squared_difference( - reconstruction_lin, audio_features - ) - reconstruction_loss.mark_as_loss(name="mse", scale=self.reconstruction_scale) - return reconstruction_lin - else: - # replace the CTC blank label probability manually with zero - # within the RETURNN backend this will be replaced via safe_log with 1e-20 - slice_out, slice_dim = nn.slice( - softmax, axis=softmax.feature_dim, slice_start=0, slice_end=self.softmax_dim.dimension - 1, - ) - padding = nn.pad( - slice_out, - axes=slice_out.feature_dim, - mode="constant", - padding=[(0, 1)], - value=0, - ) - extract_alignment = nn.forced_alignment( - padding, align_target=phonemes, topology="ctc", input_type="prob", blank_included=True - ) - dur_dump = nn.hdf_dump(extract_alignment, filename="durations.hdf") - return dur_dump - - -def construct_network( - epoch: int, - audio_features: nn.Data, - phonemes: nn.Data, - speaker_labels: nn.Data, - **kwargs -): - """ - - :param epoch: - :param audio_features - :param phonemes - :param speaker_labels - :param kwargs: - :return: - """ - params = ConvBlstmRecParams(**kwargs) - net = CTCAligner( - audio_feature_dim=audio_features.feature_dim_or_sparse_dim, - speaker_label_dim=speaker_labels.feature_dim_or_sparse_dim, - phoneme_dim=phonemes.feature_dim_or_sparse_dim, - parameters=params, - ) - out = net( - audio_features=nn.get_extern_data(audio_features), - speaker_labels=nn.get_extern_data(speaker_labels), - phonemes=nn.get_extern_data(phonemes), - audio_time=audio_features.dim_tags[audio_features.time_dim_axis], - speaker_label_time=speaker_labels.dim_tags[speaker_labels.time_dim_axis], - phoneme_time=phonemes.dim_tags[phonemes.time_dim_axis], - ) - out.mark_as_default_output() - - return net diff --git a/users/rilling/experiments/librispeech/tts_architecture_improvement_23/rc_networks/ctc_aligner/parameters.py b/users/rilling/experiments/librispeech/tts_architecture_improvement_23/rc_networks/ctc_aligner/parameters.py deleted file mode 100644 index 555022984..000000000 --- a/users/rilling/experiments/librispeech/tts_architecture_improvement_23/rc_networks/ctc_aligner/parameters.py +++ /dev/null @@ -1,16 +0,0 @@ -""" -Parameters, to be imported from Sisyphus so make sure there is nothing unnecessary loaded -""" - -from dataclasses import dataclass - -@dataclass -class ConvBlstmRecParams: - audio_emb_size: int - speaker_emb_size: int - conv_hidden_size: int - enc_lstm_size: int - rec_lstm_size: int - dropout: float - reconstruction_scale: float - training: bool \ No newline at end of file diff --git a/users/rilling/experiments/librispeech/tts_architecture_improvement_23/rc_networks/shared/__init__.py b/users/rilling/experiments/librispeech/tts_architecture_improvement_23/rc_networks/shared/__init__.py deleted file mode 100644 index e69de29bb..000000000 diff --git a/users/rilling/experiments/librispeech/tts_architecture_improvement_23/rc_networks/shared/convolution.py b/users/rilling/experiments/librispeech/tts_architecture_improvement_23/rc_networks/shared/convolution.py deleted file mode 100644 index b97377f90..000000000 --- a/users/rilling/experiments/librispeech/tts_architecture_improvement_23/rc_networks/shared/convolution.py +++ /dev/null @@ -1,128 +0,0 @@ -from typing import Tuple, Union, Sequence -from returnn_common import nn - - -class Conv1DBlock(nn.Module): - """ - 1D Convolutional Block with batchnorm, l2 and full axis dropout - """ - - def __init__( - self, - in_dim: nn.Dim, - dim: Union[int, nn.Dim] = 256, - filter_size: int = 5, - bn_epsilon: float = 1e-5, - dropout: float = 0.5, - l2: float = 1e-07, - ): - """ - :param dim: feature dimension of the convolution - :param filter_size: filter size of the conv, int because we are doing 1D here - :param bn_epsilon: batch_normalization epsilon value - :param dropout: dropout value - :param l2: weight decay value - """ - super(Conv1DBlock, self).__init__() - if isinstance(dim, int): - self.conv_dim = nn.FeatureDim("conv_dim_%d" % dim, dim) - elif isinstance(dim, nn.Dim): - self.conv_dim = dim - else: - raise Exception("Wrong Dim given!") - self.conv = nn.Conv1d( - in_dim=in_dim, - out_dim=self.conv_dim, - filter_size=filter_size, - padding="same", - with_bias=False, - ) - self.bn = nn.BatchNorm( - in_dim=self.conv_dim, - epsilon=bn_epsilon, use_mask=False - ) - self.dropout = dropout - self.l2 = l2 - - def __call__(self, inp: nn.Tensor, time_dim: nn.SpatialDim): - conv, _ = self.conv(inp, in_spatial_dim=time_dim) - # set weight decay - for param in self.conv.parameters(): - param.weight_decay = self.l2 - - conv = nn.relu(conv) - bn = self.bn(conv) - drop = nn.dropout( - bn, dropout=self.dropout, axis=[nn.batch_dim, time_dim, bn.feature_dim] - ) - - return drop - - -class Conv1DStack(nn.Module): - """ - Stacks :class:`Conv1DBlock` modules - """ - - def __init__( - self, - in_dim: nn.Dim, - num_layers: int = 5, - dim_sizes: Tuple[int] = (256,), - filter_sizes: Tuple[int] = (5, 5, 5, 5, 5), - bn_epsilon: float = 1e-5, - dropout: Sequence[float] = (0.35, 0.35, 0.35, 0.35, 0.35), - l2: float = 1e-07, - ): - """ - :param num_layers: number of conv block layers - :param dim_sizes: dimensions for the convolutions in the block - :param filter_sizes: sizes for the filters in the block - :param bn_epsilon: batch_normalization epsilon value - :param dropout: dropout values - :param l2: weight decay value - """ - super(Conv1DStack, self).__init__() - assert ( - len(dim_sizes) == num_layers or len(dim_sizes) == 1 - ) # mismatch in dim_sizes - assert len(filter_sizes) == num_layers # mismatch in filter_sizes - assert len(dropout) == num_layers # mismatch in dropout - - self.num_layers = num_layers - # simplify tags a bit if possible - if len(set(dim_sizes)) == 1: # all sizes equal - out_dims = [nn.FeatureDim("conv_dim", dim_sizes[0])] * num_layers - else: - out_dims = [ - nn.FeatureDim("conv_dim_%s" % str(x), dim_sizes[x]) - for x in range(num_layers) - ] - - sequential_list = [] - temp_in_dim = in_dim - for x in range(num_layers): - sequential_list.append( - Conv1DBlock( - in_dim=temp_in_dim, - dim=out_dims[x], - filter_size=filter_sizes[x], - bn_epsilon=bn_epsilon, - dropout=dropout[x], - l2=l2, - ) - ) - temp_in_dim = out_dims[x] - - self.stack = nn.Sequential(sequential_list) - self.out_dim = out_dims[-1] - - def __call__(self, inp: nn.Tensor, time_dim: nn.Dim): - """ - Applies all conv blocks in sequence - - :param inp: input tensor - :return: - """ - out = self.stack(inp, time_dim=time_dim) - return out \ No newline at end of file diff --git a/users/rilling/experiments/librispeech/tts_architecture_improvement_23/serializer.py b/users/rilling/experiments/librispeech/tts_architecture_improvement_23/serializer.py deleted file mode 100644 index 473365147..000000000 --- a/users/rilling/experiments/librispeech/tts_architecture_improvement_23/serializer.py +++ /dev/null @@ -1,117 +0,0 @@ -import copy -from sisyphus import tk -from typing import Any, Dict - -from i6_experiments.common.setups.returnn_common.serialization import ( - Collection, - ExternData, - Import, - Network, - PythonEnlargeStackWorkaroundNonhashedCode, - ExplicitHash -) - -from i6_experiments.common.setups.returnn_pytorch.serialization import ( - Collection as TorchCollection, - PyTorchModel, -) - -from i6_experiments.users.rossenbach.common_setups.returnn.datastreams.base import Datastream - -PACKAGE = __package__ - - -def get_network_serializer( - training: bool, - returnn_common_root: tk.Path, - datastreams: Dict[str, Datastream], - network_module: str, - net_args: Dict[str, Any], - debug=False, - **kwargs, -) -> Collection: - """ - - :param training - :param returnn_common_root - :param datastreams: - :param net_args: - :param debug: - :return: - """ - extern_data = [ - datastream.as_nnet_constructor_data(key) - for key, datastream in datastreams.items() - ] - - rc_recursionlimit = PythonEnlargeStackWorkaroundNonhashedCode - rc_extern_data = ExternData(extern_data=extern_data) - - rc_package = PACKAGE + ".rc_networks" - rc_construction_code = Import(rc_package + "." + network_module + ".construct_network") - - d = copy.deepcopy(net_args) - if training is False: - d["training"] = False - - rc_network = Network( - net_func_name=rc_construction_code.object_name, - net_func_map={key: key for key in datastreams.keys()}, # names just have to match - net_kwargs=d, - ) - - serializer = Collection( - serializer_objects=[ - rc_recursionlimit, - rc_extern_data, - rc_construction_code, - rc_network, - ], - returnn_common_root=returnn_common_root, - make_local_package_copy=not debug, - packages={ - rc_package, - }, - ) - - return serializer - -def get_pytorch_serializer( - network_module: str, - net_args: Dict[str, Any], - use_custom_engine=False, - debug=False, - **kwargs -) -> TorchCollection: - - package = PACKAGE + ".pytorch_networks" - - pytorch_model_import = Import( - package + ".%s.Model" % network_module - ) - pytorch_train_step = Import( - package + ".%s.train_step" % network_module - ) - pytorch_model = PyTorchModel( - model_class_name=pytorch_model_import.object_name, - model_kwargs=net_args, - ) - serializer_objects = [ - pytorch_model_import, - pytorch_train_step, - pytorch_model, - ] - if use_custom_engine: - pytorch_engine = Import( - package + ".%s.CustomEngine" % network_module - ) - serializer_objects.append(pytorch_engine) - serializer = TorchCollection( - serializer_objects=serializer_objects, - make_local_package_copy=not debug, - packages={ - package, - }, - ) - - return serializer diff --git a/users/rilling/experiments/librispeech/tts_architecture_improvement_23/storage.py b/users/rilling/experiments/librispeech/tts_architecture_improvement_23/storage.py deleted file mode 100644 index d3e017c53..000000000 --- a/users/rilling/experiments/librispeech/tts_architecture_improvement_23/storage.py +++ /dev/null @@ -1,13 +0,0 @@ -from sisyphus import tk - -synthetic_ogg_zip_data = {} - -def add_ogg_zip(name: str, ogg_zip: tk.Path): - global synthetic_ogg_zip_data - synthetic_ogg_zip_data[name] = ogg_zip - -duration_alignments = {} - -def add_duration(name: str, duration_hdf: tk.Path): - global duration_alignments - duration_alignments[name] = duration_hdf \ No newline at end of file From 729c2776d9df347fd74ef8f5910439826b7e7ce6 Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Thu, 16 May 2024 10:32:51 +0200 Subject: [PATCH 029/227] small fixes --- users/zeyer/datasets/librispeech.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/users/zeyer/datasets/librispeech.py b/users/zeyer/datasets/librispeech.py index 5fdf35cb7..e68134709 100644 --- a/users/zeyer/datasets/librispeech.py +++ b/users/zeyer/datasets/librispeech.py @@ -97,9 +97,9 @@ def _get_spm_vocab( @cache def _get_vocab_by_str(vocab: str) -> Union[SentencePieceModel, Bpe]: if re.match("^spm[0-9]+.*$", vocab): - return _get_spm_vocab(dim=vocab[3:], model_type=SentencePieceType.UNIGRAM) + return _get_spm_vocab(dim=vocab[len("spm") :], model_type=SentencePieceType.UNIGRAM) elif re.match("^spm_bpe[0-9]+.*$", vocab): - return _get_spm_vocab(dim=vocab[3:], model_type=SentencePieceType.BPE) + return _get_spm_vocab(dim=vocab[len("spm_bpe") :], model_type=SentencePieceType.BPE) elif vocab == "bpe10k": # predefined return bpe10k else: From 69b4185a7c0db2c22f775dbe2eb09dd4e9f948ce Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Thu, 16 May 2024 21:27:31 +0200 Subject: [PATCH 030/227] spm20k --- users/zeyer/datasets/librispeech.py | 2 +- users/zeyer/experiments/exp2024_04_23_baselines/ctc.py | 1 + 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/users/zeyer/datasets/librispeech.py b/users/zeyer/datasets/librispeech.py index e68134709..020e285fe 100644 --- a/users/zeyer/datasets/librispeech.py +++ b/users/zeyer/datasets/librispeech.py @@ -57,7 +57,7 @@ def _get_spm_vocab( ) -> SentencePieceModel: if isinstance(dim, str): # Not sure if power-of-two or just multiple-of-64, but 10240 has more 2s in it (2048*5) than 10048. - dim = {"10k": 10_240, "5k": 5_120, "4k": 4_096, "1k": 1_024}[dim] + dim = {"20k": 20_480, "10k": 10_240, "5k": 5_120, "4k": 4_096, "1k": 1_024}[dim] assert isinstance(dim, int) and dim >= 10 # https://github.com/google/sentencepiece/blob/master/doc/options.md diff --git a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py index 65265722d..25943285b 100644 --- a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py +++ b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py @@ -31,6 +31,7 @@ def py(): for vocab in [ + "spm20k", "bpe10k", # 8.23 "spm10k", # 8.12 "spm_bpe10k", From 40000a5180e7b3a7b8fc3acd202011708f175cb2 Mon Sep 17 00:00:00 2001 From: Nick Rossenbach Date: Fri, 17 May 2024 17:16:23 +0200 Subject: [PATCH 031/227] more ctc and rnn-t librispeech experiments --- .../experiments/ctc_bpe/baseline.py | 34 +++++- .../experiments/ctc_bpe/low_vocab_exps.py | 61 ++++++++--- .../experiments/rnnt_bpe/low_vocab_exps.py | 100 ++++++++++++++++++ 3 files changed, 179 insertions(+), 16 deletions(-) diff --git a/users/rossenbach/experiments/librispeech/ctc_rnnt_standalone_2024/experiments/ctc_bpe/baseline.py b/users/rossenbach/experiments/librispeech/ctc_rnnt_standalone_2024/experiments/ctc_bpe/baseline.py index e46ee5583..34693e1cb 100644 --- a/users/rossenbach/experiments/librispeech/ctc_rnnt_standalone_2024/experiments/ctc_bpe/baseline.py +++ b/users/rossenbach/experiments/librispeech/ctc_rnnt_standalone_2024/experiments/ctc_bpe/baseline.py @@ -13,7 +13,7 @@ from ...data.bpe import build_bpe_training_datasets, get_text_lexicon from ...default_tools import RETURNN_EXE, MINI_RETURNN_ROOT from ...lm import get_4gram_binary_lm -from ...pipeline import training, prepare_asr_model, search +from ...pipeline import training, prepare_asr_model, search, ASRModel from ...storage import add_ctc_model @@ -60,6 +60,9 @@ def bpe_ls960_1023_base(): "returnn_root": MINI_RETURNN_ROOT, } + from ...pytorch_networks.ctc.decoder.flashlight_ctc_v1 import DecoderConfig + from ...pytorch_networks.ctc.decoder.greedy_bpe_ctc_v3 import DecoderConfig as GreedyDecoderConfig + def tune_and_evaluate_helper(training_name, asr_model, base_decoder_config, lm_scales, prior_scales): tune_parameters = [] tune_values_clean = [] @@ -94,9 +97,26 @@ def tune_and_evaluate_helper(training_name, asr_model, base_decoder_config, lm_s decoder_args={"config": asdict(decoder_config)}, test_dataset_tuples={key: test_dataset_tuples[key]}, **default_returnn ) - - - from ...pytorch_networks.ctc.decoder.flashlight_ctc_v1 import DecoderConfig + + def greedy_search_helper( + training_name: str, + asr_model: ASRModel, + decoder_config: GreedyDecoderConfig + ): + # remove prior if exists + asr_model = copy.deepcopy(asr_model) + asr_model.prior_file = None + + search_name = training_name + "/search_greedy" + search_jobs, wers = search( + search_name, + forward_config={}, + asr_model=asr_model, + decoder_module="ctc.decoder.greedy_bpe_ctc_v3", + decoder_args={"config": asdict(decoder_config)}, + test_dataset_tuples=dev_dataset_tuples, + **default_returnn, + ) default_decoder_config_bpe5000 = DecoderConfig( lexicon=get_text_lexicon(prefix=prefix_name, librispeech_key="train-other-960", bpe_size=5000), @@ -191,6 +211,12 @@ def tune_and_evaluate_helper(training_name, asr_model, base_decoder_config, lm_s add_ctc_model("ls960_ctc_bpe_5k." + network_module + ".512dim_sub6_24gbgpu_50eps_ckpt500", asr_model) tune_and_evaluate_helper(training_name, asr_model, default_decoder_config_bpe5000, lm_scales=[1.6, 1.8, 2.0], prior_scales=[0.2, 0.3, 0.4]) + + greedy_decoder_config = GreedyDecoderConfig( + returnn_vocab=label_datastream_bpe5000.vocab, + ) + greedy_search_helper(training_name, asr_model=asr_model, decoder_config=greedy_decoder_config) + for token in [16, 32, 64]: decoder_config = copy.deepcopy(default_decoder_config_bpe5000) decoder_config.lm_weight = 1.8 diff --git a/users/rossenbach/experiments/librispeech/ctc_rnnt_standalone_2024/experiments/ctc_bpe/low_vocab_exps.py b/users/rossenbach/experiments/librispeech/ctc_rnnt_standalone_2024/experiments/ctc_bpe/low_vocab_exps.py index 54e3de754..f78e75ee1 100644 --- a/users/rossenbach/experiments/librispeech/ctc_rnnt_standalone_2024/experiments/ctc_bpe/low_vocab_exps.py +++ b/users/rossenbach/experiments/librispeech/ctc_rnnt_standalone_2024/experiments/ctc_bpe/low_vocab_exps.py @@ -13,7 +13,7 @@ from ...data.bpe import build_bpe_training_datasets, get_text_lexicon from ...default_tools import RETURNN_EXE, MINI_RETURNN_ROOT from ...lm import get_4gram_binary_lm -from ...pipeline import training, prepare_asr_model, search +from ...pipeline import training, prepare_asr_model, search, ASRModel from ...storage import add_ctc_model @@ -37,6 +37,7 @@ def bpe_ls960_1023_low_vocab_test(): } from ...pytorch_networks.ctc.decoder.flashlight_ctc_v1 import DecoderConfig + from ...pytorch_networks.ctc.decoder.greedy_bpe_ctc_v3 import DecoderConfig as GreedyDecoderConfig @@ -133,6 +134,26 @@ def tune_and_evaluate_helper(training_name, dev_dataset_tuples, test_dataset_tup **default_returnn ) + def greedy_search_helper( + training_name: str, + asr_model: ASRModel, + decoder_config: GreedyDecoderConfig + ): + # remove prior if exists + asr_model = copy.deepcopy(asr_model) + asr_model.prior_file = None + + search_name = training_name + "/search_greedy" + search_jobs, wers = search( + search_name, + forward_config={}, + asr_model=asr_model, + decoder_module="ctc.decoder.greedy_bpe_ctc_v3", + decoder_args={"config": asdict(decoder_config)}, + test_dataset_tuples={**dev_dataset_tuples, **test_dataset_tuples}, + **default_returnn, + ) + for BPE_SIZE in [128, 256, 512, 1024]: # build the training datasets object containing train, cv, dev-train and the extern_data dict @@ -271,20 +292,36 @@ def tune_and_evaluate_helper(training_name, dev_dataset_tuples, test_dataset_tup for search_job in search_jobs: search_job.rqmt["sbatch_args"] = "-A rescale_speed -p rescale_amd" + if BPE_SIZE == 128 or BPE_SIZE == 512: # Extra long training for the BPE 128 one train_args_conv_first_ep100 = copy.deepcopy(train_args_conv_first) train_args_conv_first_ep100["config"]["learning_rates"] = list(np.linspace(7e-6, 5e-4, 240)) + list( np.linspace(5e-4, 5e-5, 720)) + list(np.linspace(5e-5, 1e-7, 40)) train_args_conv_first_ep100["config"]["gradient_clip"] = 1.0 - training_name = prefix_name + "/" + str( - BPE_SIZE) + "/" + network_module_conv_first + ".512dim_sub4_24gbgpu_100eps" - train_job = training(training_name, train_data_bpe, train_args_conv_first_ep100, num_epochs=1000, **default_returnn) - train_job.rqmt["gpu_mem"] = 24 - asr_model = prepare_asr_model( - training_name, train_job, train_args_conv_first_ep100, with_prior=True, datasets=train_data_bpe, - get_specific_checkpoint=1000 - ) - tune_and_evaluate_helper(training_name, dev_dataset_tuples, test_dataset_tuples, asr_model, - default_decoder_config_bpe, lm_scales=[1.6, 1.8, 2.0], - prior_scales=[0.2, 0.3, 0.4]) \ No newline at end of file + train_args_conv_first_ep100_sp = copy.deepcopy(train_args_conv_first_ep100) + train_args_conv_first_ep100_sp["use_speed_perturbation"] = True + + train_args_pairs = [ + (".512dim_sub4_24gbgpu_100eps", train_args_conv_first_ep100), + (".512dim_sub4_24gbgpu_100eps_sp", train_args_conv_first_ep100_sp) + ] + + for name, train_args in train_args_pairs: + training_name = prefix_name + "/" + str( + BPE_SIZE) + "/" + network_module_conv_first + name + train_job = training(training_name, train_data_bpe, train_args, num_epochs=1000, **default_returnn) + train_job.rqmt["gpu_mem"] = 24 + asr_model = prepare_asr_model( + training_name, train_job, train_args, with_prior=True, datasets=train_data_bpe, + get_specific_checkpoint=1000 + ) + add_ctc_model(f"ls960_ctc_bpe_{BPE_SIZE}." + network_module_conv_first + name + "_ckpt1000", + asr_model) + tune_and_evaluate_helper(training_name, dev_dataset_tuples, test_dataset_tuples, asr_model, + default_decoder_config_bpe, lm_scales=[1.6, 1.8, 2.0], + prior_scales=[0.2, 0.3, 0.4]) + greedy_decoder_config = GreedyDecoderConfig( + returnn_vocab=label_datastream_bpe.vocab, + ) + greedy_search_helper(training_name, asr_model=asr_model, decoder_config=greedy_decoder_config) \ No newline at end of file diff --git a/users/rossenbach/experiments/librispeech/ctc_rnnt_standalone_2024/experiments/rnnt_bpe/low_vocab_exps.py b/users/rossenbach/experiments/librispeech/ctc_rnnt_standalone_2024/experiments/rnnt_bpe/low_vocab_exps.py index d1b5ab180..f6e26cb62 100644 --- a/users/rossenbach/experiments/librispeech/ctc_rnnt_standalone_2024/experiments/rnnt_bpe/low_vocab_exps.py +++ b/users/rossenbach/experiments/librispeech/ctc_rnnt_standalone_2024/experiments/rnnt_bpe/low_vocab_exps.py @@ -230,4 +230,104 @@ def evaluate_helper( decoder_config_bpe5000, ) + if BPE_SIZE == 128: + # DO HERE AGAIN IN CORRECT + KEEP = [300, 400, 500, 600, 700, 800, 900, 950, 980] + network_module = "rnnt.conformer_1023.i6modelsV1_VGG4LayerActFrontendV1_v9_i6_native_conv_first" + train_args_warprnnt_fullspec_from_ctc100 = copy.deepcopy(train_args_fullspec) + train_args_warprnnt_fullspec_from_ctc100["network_module"] = network_module + train_args_warprnnt_fullspec_from_ctc100["config"]["preload_from_files"] = { + "encoder": { + "filename": get_ctc_model( + f"ls960_ctc_bpe_{BPE_SIZE}.ctc.conformer_1023.i6modelsV1_VGG4LayerActFrontendV1_v6_conv_first.512dim_sub4_24gbgpu_100eps_ckpt1000" + ).checkpoint, + "init_for_train": True, + "ignore_missing": True, + } + } + train_args_warprnnt_fullspec_from_ctc100["config"]["learning_rates"] = list( + np.linspace(5e-5, 5e-4, 240)) + list( + np.linspace(5e-4, 5e-5, 720)) + list(np.linspace(5e-5, 1e-7, 40)) + train_args_warprnnt_fullspec_from_ctc100["config"]["cleanup_old_models"] = { + "keep_last_n": 4, + "keep_best_n": 4, + "keep": KEEP + } + train_args_warprnnt_fullspec_from_ctc100["config"]["gradient_clip"] = 1.0 + + # small BPE saves a lot of memory, train without grad accum + train_args_warprnnt_fullspec_from_ctc100_noacumm = copy.deepcopy(train_args_warprnnt_fullspec_from_ctc100) + train_args_warprnnt_fullspec_from_ctc100_noacumm["config"]["accum_grad_multiple_step"] = 1 + train_args_warprnnt_fullspec_from_ctc100_noacumm["config"]["batch_size"] = 240 * 16000 + + training_name = prefix_name + "/" + str( + BPE_SIZE) + "/" + network_module + ".512dim_sub4_24gbgpu_100eps_accum1_gradclip_fullspec1_continue_from_ctc100eps" + train_job = training(training_name, train_data_bpe, train_args_warprnnt_fullspec_from_ctc100_noacumm, + num_epochs=1000, **default_returnn) + train_job.rqmt["gpu_mem"] = 24 + train_job.set_env("PYTORCH_CUDA_ALLOC_CONF", "expandable_segments:True") + for keep in KEEP: + asr_model = prepare_asr_model( + training_name, train_job, train_args_warprnnt_fullspec_from_ctc100_noacumm, with_prior=False, + datasets=train_data_bpe, get_specific_checkpoint=keep + ) + evaluate_helper( + training_name + "/keep_%i" % keep, + asr_model, + decoder_config_bpe5000, + use_gpu=True + ) + asr_model = prepare_asr_model( + training_name, train_job, train_args_warprnnt_fullspec_from_ctc100_noacumm, with_prior=False, + datasets=train_data_bpe, get_specific_checkpoint=1000 + ) + evaluate_helper( + training_name + "/keep_%i" % 1000, + asr_model, + decoder_config_bpe5000, + use_gpu=True, + ) + + asr_model = prepare_asr_model( + training_name, train_job, train_args_warprnnt_fullspec_from_ctc100_noacumm, with_prior=False, + datasets=train_data_bpe, get_best_averaged_checkpoint=(1, "dev_loss_rnnt"), + ) + evaluate_helper( + training_name + "/best", + asr_model, + decoder_config_bpe5000, + use_gpu=True, + ) + + # With speed perturbation + train_args_warprnnt_fullspec_from_ctc100_noacumm_sp = copy.deepcopy(train_args_warprnnt_fullspec_from_ctc100_noacumm) + train_args_warprnnt_fullspec_from_ctc100_noacumm["use_speed_perturbation"] = True + training_name = prefix_name + "/" + str( + BPE_SIZE) + "/" + network_module + ".512dim_sub4_24gbgpu_100eps_accum1_gradclip_fullspec1_sp_continue_from_ctc100eps" + train_job = training(training_name, train_data_bpe, train_args_warprnnt_fullspec_from_ctc100_noacumm, + num_epochs=1000, **default_returnn) + train_job.rqmt["gpu_mem"] = 24 + train_job.set_env("PYTORCH_CUDA_ALLOC_CONF", "expandable_segments:True") + for keep in KEEP: + asr_model = prepare_asr_model( + training_name, train_job, train_args_warprnnt_fullspec_from_ctc100_noacumm, with_prior=False, + datasets=train_data_bpe, get_specific_checkpoint=keep + ) + evaluate_helper( + training_name + "/keep_%i" % keep, + asr_model, + decoder_config_bpe5000, + use_gpu=True + ) + asr_model = prepare_asr_model( + training_name, train_job, train_args_warprnnt_fullspec_from_ctc100_noacumm, with_prior=False, + datasets=train_data_bpe, get_specific_checkpoint=1000 + ) + evaluate_helper( + training_name + "/keep_%i" % 1000, + asr_model, + decoder_config_bpe5000, + use_gpu=True, + ) + From 9f067cbc603ed2f6e32ba9bd63dd297ea318147c Mon Sep 17 00:00:00 2001 From: Nick Rossenbach Date: Fri, 17 May 2024 17:16:47 +0200 Subject: [PATCH 032/227] add greedy decoder --- .../ctc/decoder/greedy_bpe_ctc_v3.py | 86 +++++++++++++++++++ 1 file changed, 86 insertions(+) create mode 100644 example_setups/librispeech/ctc_rnnt_standalone_2024/pytorch_networks/ctc/decoder/greedy_bpe_ctc_v3.py diff --git a/example_setups/librispeech/ctc_rnnt_standalone_2024/pytorch_networks/ctc/decoder/greedy_bpe_ctc_v3.py b/example_setups/librispeech/ctc_rnnt_standalone_2024/pytorch_networks/ctc/decoder/greedy_bpe_ctc_v3.py new file mode 100644 index 000000000..1738f7442 --- /dev/null +++ b/example_setups/librispeech/ctc_rnnt_standalone_2024/pytorch_networks/ctc/decoder/greedy_bpe_ctc_v3.py @@ -0,0 +1,86 @@ +""" +Greedy CTC decoder without any extras + +v3: add config objects +""" +from dataclasses import dataclass +import time +import torch + + +@dataclass +class DecoderConfig: + returnn_vocab: str + + +@dataclass +class ExtraConfig: + # used for RTF logging + print_rtf: bool = True + sample_rate: int = 16000 + + # Hypothesis logging + print_hypothesis: bool = True + + +def forward_init_hook(run_ctx, **kwargs): + # we are storing durations, but call it output.hdf to match + # the default output of the ReturnnForwardJob + config = DecoderConfig(**kwargs["config"]) + extra_config_dict = kwargs.get("extra_config", {}) + extra_config = ExtraConfig(**extra_config_dict) + + run_ctx.recognition_file = open("search_out.py", "wt") + run_ctx.recognition_file.write("{\n") + + from returnn.datasets.util.vocabulary import Vocabulary + vocab = Vocabulary.create_vocab( + vocab_file=config.returnn_vocab, unknown_label=None) + run_ctx.labels = vocab.labels + + run_ctx.print_rtf = extra_config.print_rtf + if run_ctx.print_rtf: + run_ctx.running_audio_len_s = 0 + run_ctx.total_time = 0 + + run_ctx.print_hypothesis = extra_config.print_hypothesis + +def forward_finish_hook(run_ctx, **kwargs): + run_ctx.recognition_file.write("}\n") + run_ctx.recognition_file.close() + + print("Total-time: %.2f, Batch-RTF: %.3f" % (run_ctx.total_time, run_ctx.total_time / run_ctx.running_audio_len_s)) + + +def forward_step(*, model, data, run_ctx, **kwargs): + raw_audio = data["raw_audio"] # [B, T', F] + raw_audio_len = data["raw_audio:size1"] # [B] + + audio_len_batch = torch.sum(raw_audio_len).detach().cpu().numpy() / 16000 + + if run_ctx.print_rtf: + run_ctx.running_audio_len_s += audio_len_batch + am_start = time.time() + + logprobs, audio_features_len = model( + raw_audio=raw_audio, + raw_audio_len=raw_audio_len, + ) + batch_indices = [] + for lp, l in zip(logprobs, audio_features_len): + batch_indices.append(torch.unique_consecutive(torch.argmax(lp[:l], dim=-1), dim=0).detach().cpu().numpy()) + + if run_ctx.print_rtf: + am_time = time.time() - am_start + run_ctx.total_time += am_time + print("Batch-time: %.2f, Batch-RTF: %.3f" % (am_time, am_time / audio_len_batch)) + + tags = data["seq_tag"] + + for indices, tag in zip(batch_indices, tags): + sequence = [run_ctx.labels[idx] for idx in indices if idx < len(run_ctx.labels)] + sequence = [s for s in sequence if (not s.startswith("<") and not s.startswith("["))] + text = " ".join(sequence).replace("@@ ", "") + if run_ctx.print_hypothesis: + print(text) + run_ctx.recognition_file.write("%s: %s,\n" % (repr(tag), repr(text))) From 411a162f55b31d190dd0a19c7cf4ad119bb074dd Mon Sep 17 00:00:00 2001 From: Nick Rossenbach Date: Fri, 17 May 2024 18:10:42 +0200 Subject: [PATCH 033/227] black --- .../experiments/ctc_bpe/baseline.py | 23 +++++++++++++++++++ .../ctc/decoder/greedy_bpe_ctc_v3.py | 7 +++--- 2 files changed, 27 insertions(+), 3 deletions(-) diff --git a/example_setups/librispeech/ctc_rnnt_standalone_2024/experiments/ctc_bpe/baseline.py b/example_setups/librispeech/ctc_rnnt_standalone_2024/experiments/ctc_bpe/baseline.py index d423f4a16..e77d46613 100644 --- a/example_setups/librispeech/ctc_rnnt_standalone_2024/experiments/ctc_bpe/baseline.py +++ b/example_setups/librispeech/ctc_rnnt_standalone_2024/experiments/ctc_bpe/baseline.py @@ -61,6 +61,7 @@ def bpe_ls960_1023_base(): } from ...pytorch_networks.ctc.decoder.flashlight_ctc_v1 import DecoderConfig + from ...pytorch_networks.ctc.decoder.greedy_bpe_ctc_v3 import DecoderConfig as GreedyDecoderConfig def tune_and_evaluate_helper( training_name: str, @@ -121,6 +122,22 @@ def tune_and_evaluate_helper( **default_returnn, ) + def greedy_search_helper(training_name: str, asr_model: ASRModel, decoder_config: GreedyDecoderConfig): + # remove prior if exists + asr_model = copy.deepcopy(asr_model) + asr_model.prior_file = None + + search_name = training_name + "/search_greedy" + search_jobs, wers = search( + search_name, + forward_config={}, + asr_model=asr_model, + decoder_module="ctc.decoder.greedy_bpe_ctc_v3", + decoder_args={"config": asdict(decoder_config)}, + test_dataset_tuples=dev_dataset_tuples, + **default_returnn, + ) + default_decoder_config_bpe5000 = DecoderConfig( lexicon=get_text_lexicon(prefix=prefix_name, librispeech_key="train-other-960", bpe_size=5000), returnn_vocab=label_datastream_bpe5000.vocab, @@ -200,6 +217,7 @@ def tune_and_evaluate_helper( "max_seq_length": {"audio_features": 35 * 16000}, "accum_grad_multiple_step": 1, "torch_amp_options": {"dtype": "bfloat16"}, + "gradient_clip": 1.0, } network_module = "ctc.conformer_1023.i6modelsV1_VGG4LayerActFrontendV1_v6" @@ -224,3 +242,8 @@ def tune_and_evaluate_helper( lm_scales=[1.6, 1.8, 2.0], prior_scales=[0.2, 0.3, 0.4], ) + + greedy_decoder_config = GreedyDecoderConfig( + returnn_vocab=label_datastream_bpe5000.vocab, + ) + greedy_search_helper(training_name=training_name, asr_model=asr_model, decoder_config=greedy_decoder_config) diff --git a/example_setups/librispeech/ctc_rnnt_standalone_2024/pytorch_networks/ctc/decoder/greedy_bpe_ctc_v3.py b/example_setups/librispeech/ctc_rnnt_standalone_2024/pytorch_networks/ctc/decoder/greedy_bpe_ctc_v3.py index 1738f7442..323c68488 100644 --- a/example_setups/librispeech/ctc_rnnt_standalone_2024/pytorch_networks/ctc/decoder/greedy_bpe_ctc_v3.py +++ b/example_setups/librispeech/ctc_rnnt_standalone_2024/pytorch_networks/ctc/decoder/greedy_bpe_ctc_v3.py @@ -29,13 +29,13 @@ def forward_init_hook(run_ctx, **kwargs): config = DecoderConfig(**kwargs["config"]) extra_config_dict = kwargs.get("extra_config", {}) extra_config = ExtraConfig(**extra_config_dict) - + run_ctx.recognition_file = open("search_out.py", "wt") run_ctx.recognition_file.write("{\n") from returnn.datasets.util.vocabulary import Vocabulary - vocab = Vocabulary.create_vocab( - vocab_file=config.returnn_vocab, unknown_label=None) + + vocab = Vocabulary.create_vocab(vocab_file=config.returnn_vocab, unknown_label=None) run_ctx.labels = vocab.labels run_ctx.print_rtf = extra_config.print_rtf @@ -45,6 +45,7 @@ def forward_init_hook(run_ctx, **kwargs): run_ctx.print_hypothesis = extra_config.print_hypothesis + def forward_finish_hook(run_ctx, **kwargs): run_ctx.recognition_file.write("}\n") run_ctx.recognition_file.close() From bb9f282aa1d071bd818e794709a0ac01dd0f3901 Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Fri, 17 May 2024 19:58:31 +0200 Subject: [PATCH 034/227] add ebranchformer --- .../asr/encoder/ebranchformer_encoder.py | 463 +++--------------- 1 file changed, 58 insertions(+), 405 deletions(-) diff --git a/users/zeineldeen/models/asr/encoder/ebranchformer_encoder.py b/users/zeineldeen/models/asr/encoder/ebranchformer_encoder.py index 01c65076c..4eb066d42 100644 --- a/users/zeineldeen/models/asr/encoder/ebranchformer_encoder.py +++ b/users/zeineldeen/models/asr/encoder/ebranchformer_encoder.py @@ -1,252 +1,16 @@ -from i6_experiments.users.zeineldeen.modules.network import ReturnnNetwork +from i6_experiments.users.zeineldeen.models.asr.encoder.conformer_encoder_v2 import ConformerEncoderV2 -class EBranchformerEncoder: +class EBranchformerEncoder(ConformerEncoderV2): """ Implement E-branchformer Encoder Architecture * Ref: https://arxiv.org/pdf/2210.00077.pdf """ - def __init__( - self, - input="data", - input_layer="conv-6", - input_layer_conv_act="relu", - num_blocks=16, - conv_kernel_size=32, - specaug=True, - pos_enc="rel", - activation="swish", - ff_dim=512, - ff_bias=True, - ctc_loss_scale=None, - dropout=0.1, - att_dropout=0.1, - enc_key_dim=256, - att_num_heads=4, - target="bpe", - l2=0.0, - lstm_dropout=0.1, - rec_weight_dropout=0.0, - with_ctc=False, - native_ctc=False, - ctc_dropout=0.0, - ctc_l2=0.0, - ctc_opts=None, - subsample=None, - start_conv_init=None, - conv_module_init=None, - mhsa_init=None, - mhsa_out_init=None, - ff_init=None, - rel_pos_clipping=16, - dropout_in=0.1, - batch_norm_opts=None, - self_att_l2=0.0, - sandwich_conv=False, - add_to_prefix_name=None, - output_layer_name="encoder", - rezero=False, - ): - """ - :param str input: input layer name - :param str input_layer: type of input layer which does subsampling - :param int num_blocks: number of Conformer blocks - :param int conv_kernel_size: kernel size for conv layers in Convolution module - :param bool|None specaug: If true, then SpecAug is appliedi wi - :param str|None activation: activation used to sandwich modules - :param bool final_norm: if True, apply layer norm to the output of the encoder - :param int|None ff_dim: dimension of the first linear layer in FF module - :param str|None ff_init: FF layers initialization - :param bool|None ff_bias: If true, then bias is used for the FF layers - :param float embed_dropout: dropout applied to the source embedding - :param float dropout: general dropout - :param float att_dropout: dropout applied to attention weights - :param int enc_key_dim: encoder key dimension, also denoted as d_model, or d_key - :param int att_num_heads: the number of attention heads - :param str target: target labels key name - :param float l2: add L2 regularization for trainable weights parameters - :param float lstm_dropout: dropout applied to the input of the LSTMs in case they are used - :param float rec_weight_dropout: dropout applied to the hidden-to-hidden weight matrices of the LSTM in case used - :param bool with_ctc: if true, CTC loss is used - :param bool native_ctc: if true, use returnn native ctc implementation instead of TF implementation - :param float ctc_dropout: dropout applied on input to ctc - :param float ctc_l2: L2 applied to the weight matrix of CTC softmax - :param dict[str] ctc_opts: options for CTC - :param bool rezero: rezero initialization, ref: https://arxiv.org/abs/2003.04887 - """ - - self.input = input - self.input_layer = input_layer - self.input_layer_conv_act = input_layer_conv_act - - self.num_blocks = num_blocks - self.conv_kernel_size = conv_kernel_size - - self.pos_enc = pos_enc - self.rel_pos_clipping = rel_pos_clipping - - self.ff_bias = ff_bias - - self.specaug = specaug - - self.activation = activation - - self.dropout = dropout - self.att_dropout = att_dropout - self.lstm_dropout = lstm_dropout - - self.dropout_in = dropout_in - - # key and value dimensions are the same - self.enc_key_dim = enc_key_dim - self.enc_value_dim = enc_key_dim - self.att_num_heads = att_num_heads - self.enc_key_per_head_dim = enc_key_dim // att_num_heads - self.enc_val_per_head_dim = enc_key_dim // att_num_heads - - self.ff_dim = ff_dim - - self.target = target - - self.l2 = l2 - self.self_att_l2 = self_att_l2 - self.rec_weight_dropout = rec_weight_dropout - - if batch_norm_opts is None: - batch_norm_opts = {} - - bn_momentum = batch_norm_opts.pop("momentum", 0.1) - bn_eps = batch_norm_opts.pop("epsilon", 1e-3) - bn_update_sample_only_in_train = batch_norm_opts.pop("update_sample_only_in_training", True) - bn_delay_sample_update = batch_norm_opts.pop("delay_sample_update", True) - self.batch_norm_opts = { - "momentum": bn_momentum, - "epsilon": bn_eps, - "update_sample_only_in_training": bn_update_sample_only_in_train, - "delay_sample_update": bn_delay_sample_update, - } - self.batch_norm_opts.update(**batch_norm_opts) - - self.with_ctc = with_ctc - self.native_ctc = native_ctc - self.ctc_dropout = ctc_dropout - self.ctc_loss_scale = ctc_loss_scale - self.ctc_l2 = ctc_l2 - self.ctc_opts = ctc_opts - if not self.ctc_opts: - self.ctc_opts = {} - - self.start_conv_init = start_conv_init - self.conv_module_init = conv_module_init - self.mhsa_init = mhsa_init - self.mhsa_out_init = mhsa_out_init - self.ff_init = ff_init - - self.sandwich_conv = sandwich_conv - - # add maxpooling layers - self.subsample = subsample - self.subsample_list = [1] * num_blocks - if subsample: - for idx, s in enumerate(map(int, subsample.split("_")[:num_blocks])): - self.subsample_list[idx] = s - - self.network = ReturnnNetwork() - - self.add_to_prefix_name = add_to_prefix_name - self.output_layer_name = output_layer_name - - self.rezero = rezero - - def _create_ff_module(self, prefix_name, i, source, block_scale_var): - """ - Add Feed Forward Module: - LN -> FFN -> Swish -> Dropout -> FFN -> Dropout - :param str prefix_name: some prefix name - :param int i: FF module index - :param str source: name of source layer - :return: last layer name of this module - :rtype: str - """ - prefix_name = prefix_name + "_ffmod_{}".format(i) - - ln = self.network.add_layer_norm_layer("{}_ln".format(prefix_name), source) - - ff1 = self.network.add_linear_layer( - "{}_ff1".format(prefix_name), - ln, - n_out=self.ff_dim, - l2=self.l2, - forward_weights_init=self.ff_init, - with_bias=self.ff_bias, - ) - - swish_act = self.network.add_activation_layer("{}_swish".format(prefix_name), ff1, activation="swish") - - drop1 = self.network.add_dropout_layer("{}_drop1".format(prefix_name), swish_act, dropout=self.dropout) - - ff2 = self.network.add_linear_layer( - "{}_ff2".format(prefix_name), - drop1, - n_out=self.enc_key_dim, - l2=self.l2, - forward_weights_init=self.ff_init, - with_bias=self.ff_bias, - ) + def __init__(self, **kwargs): + super().__init__(**kwargs) - drop2 = self.network.add_dropout_layer("{}_drop2".format(prefix_name), ff2, dropout=self.dropout) - - if self.rezero: - drop2 = self.network.add_eval_layer( - "{}_scaled_dropout".format(prefix_name), [block_scale_var, drop2], eval="source(0) * source(1)" - ) - - half_step_ff = self.network.add_eval_layer("{}_half_step".format(prefix_name), drop2, eval="0.5 * source(0)") - - ff_module_res = self.network.add_combine_layer( - "{}_res".format(prefix_name), kind="add", source=[half_step_ff, source], n_out=self.enc_key_dim - ) - - return ff_module_res - - def _create_global_extractor(self, prefix_name, source): - prefix_name = "{}_global_extractor".format(prefix_name) - - ln = self.network.add_layer_norm_layer("{}_ln".format(prefix_name), source) - - ln_rel_pos_enc = self.network.add_relative_pos_encoding_layer( - "{}_ln_rel_pos_enc".format(prefix_name), - ln, - n_out=self.enc_key_per_head_dim, - forward_weights_init=self.ff_init, - ) - - mhsa = self.network.add_self_att_layer( - "{}".format(prefix_name), - ln, - n_out=self.enc_value_dim, - num_heads=self.att_num_heads, - total_key_dim=self.enc_key_dim, - att_dropout=self.att_dropout, - forward_weights_init=self.ff_init, - key_shift=ln_rel_pos_enc if ln_rel_pos_enc is not None else None, - ) - - mhsa_linear = self.network.add_linear_layer( - "{}_linear".format(prefix_name), - mhsa, - n_out=self.enc_key_dim, - l2=self.l2, - forward_weights_init=self.ff_init, - with_bias=False, - ) - - dropout = self.network.add_dropout_layer("{}_dropout".format(prefix_name), mhsa_linear, dropout=self.dropout) - - return dropout - - def _create_local_extractor(self, prefix_name, source): + def _create_conv_gating_mlp(self, prefix_name, source, layer_index): prefix_name = "{}_local_extractor".format(prefix_name) ln = self.network.add_layer_norm_layer("{}_ln".format(prefix_name), source) @@ -258,6 +22,9 @@ def _create_local_extractor(self, prefix_name, source): l2=self.l2, forward_weights_init=self.ff_init, with_bias=False, + param_dropout=self.ff_weight_drop, + param_dropout_min_ndim=2, + param_variational_noise=self.ff_weight_noise, ) gelu_act = self.network.add_activation_layer("{}_gelu".format(prefix_name), ff1, activation="gelu") @@ -279,6 +46,9 @@ def _create_local_extractor(self, prefix_name, source): filter_size=(self.conv_kernel_size,), groups=self.enc_key_dim * 3, l2=self.l2, + param_dropout=self.conv_weight_drop, + param_dropout_min_ndim=2, + param_variational_noise=self.conv_weight_noise, ) br_merge = self.network.add_eval_layer( @@ -294,18 +64,19 @@ def _create_local_extractor(self, prefix_name, source): l2=self.l2, forward_weights_init=self.ff_init, with_bias=False, + param_dropout=self.ff_weight_drop, + param_dropout_min_ndim=2, + param_variational_noise=self.ff_weight_noise, ) return br_merge_ff - def _create_merge_mod(self, prefix_name, source, block_scale_var): - prefix_name = "{}_merge_mod".format(prefix_name) + def _create_merge_module(self, prefix_name, *, source, global_extracter, local_extracter, layer_index): + prefix_name = "{}_merge_module".format(prefix_name) - glb_ext = self._create_global_extractor(prefix_name, source) - - lcl_ext = self._create_local_extractor(prefix_name, source) - - glb_lcl_merge = self.network.add_copy_layer("{}_global_local_merge".format(prefix_name), [glb_ext, lcl_ext]) + glb_lcl_merge = self.network.add_copy_layer( + "{}_global_local_merge".format(prefix_name), [global_extracter, local_extracter] + ) dpt_conv = self.network.add_conv_layer( "{}_dpt_conv".format(prefix_name), @@ -314,6 +85,9 @@ def _create_merge_mod(self, prefix_name, source, block_scale_var): filter_size=(self.conv_kernel_size,), groups=2 * self.enc_key_dim, l2=self.l2, + param_dropout=self.conv_weight_drop, + param_dropout_min_ndim=2, + param_variational_noise=self.conv_weight_noise, ) dpt_conv_res = self.network.add_combine_layer( @@ -330,179 +104,58 @@ def _create_merge_mod(self, prefix_name, source, block_scale_var): l2=self.l2, forward_weights_init=self.ff_init, with_bias=False, + param_dropout=self.ff_weight_drop, + param_dropout_min_ndim=2, + param_variational_noise=self.ff_weight_noise, ) dropout = self.network.add_dropout_layer("{}_dropout".format(prefix_name), ff, dropout=self.dropout) - if self.rezero: - dropout = self.network.add_eval_layer( - "{}_scaled_dropout".format(prefix_name), [block_scale_var, dropout], eval="source(0) * source(1)" - ) - merge_mod_res = self.network.add_combine_layer( "{}_res".format(prefix_name), kind="add", source=[source, dropout], n_out=self.enc_key_dim ) return merge_mod_res - def _create_e_branchformer_block(self, i, source): - prefix_name = "ebranchformer_block_%02i" % i - - if self.rezero: - self.network["mod_%02i_var" % i] = { - "class": "variable", - "init": 1e-8, - "trainable": True, - "add_batch_axis": True, - "shape": (1,), - } + def _block_prefix_name(self, layer_index: int) -> str: + assert layer_index >= 1 + if self.add_to_prefix_name: + prefix_name = "ebranchformer_block_%s_%02i" % (self.add_to_prefix_name, layer_index) + else: + prefix_name = "ebranchformer_block_%02i" % layer_index + return prefix_name - ff_module1 = self._create_ff_module(prefix_name, 1, source, "mod_%02i_var" % i) - - merge_module = self._create_merge_mod(prefix_name, ff_module1, "mod_%02i_var" % i) + def _create_conformer_block(self, i, source): + """ + Create an ebranchformer block: - ff_module2 = self._create_ff_module(prefix_name, 2, merge_module, "mod_%02i_var" % i) + FF -> [MHSA, Conv] -> Merger -> FF -> LN + """ - block_ln = self.network.add_layer_norm_layer("{}_ln".format(prefix_name), ff_module2) + prefix_name = self._block_prefix_name(i) - block_ln = self.network.add_copy_layer(prefix_name, block_ln) + ff_module1 = self._create_ff_module(prefix_name, 1, source, i) - return block_ln + # create branch 1: MHSA + mhsa = self._create_mhsa_module(prefix_name, ff_module1, i) - def _create_all_network_parts(self): - """ - ConvSubsampling/LSTM -> Linear -> Dropout -> [Conformer Blocks] x N - """ + # create branch 2: Convolutional gating MLP + conv_gating_mlp = self._create_conv_gating_mlp(prefix_name, ff_module1, i) - data = self.input - if self.specaug: - data = self.network.add_eval_layer( - "source", - data, - eval="self.network.get_config().typed_value('transform')(source(0, as_data=True), network=self.network)", - ) - - subsampled_input = None - if self.input_layer is None: - subsampled_input = data - elif "lstm" in self.input_layer: - sample_factor = int(self.input_layer.split("-")[1]) - pool_sizes = None - if sample_factor == 2: - pool_sizes = [2, 1] - elif sample_factor == 4: - pool_sizes = [2, 2] - elif sample_factor == 6: - pool_sizes = [3, 2] - # add 2 LSTM layers with max pooling to subsample and encode positional information - subsampled_input = self.network.add_lstm_layers( - data, - num_layers=2, - lstm_dim=self.enc_key_dim, - dropout=self.lstm_dropout, - bidirectional=True, - rec_weight_dropout=self.rec_weight_dropout, - l2=self.l2, - pool_sizes=pool_sizes, - ) - elif self.input_layer == "conv-4": - # conv-layer-1: 3x3x32 followed by max pool layer on feature axis (1, 2) - # conv-layer-2: 3x3x64 with striding (2, 1) on time axis - # conv-layer-3: 3x3x64 with striding (2, 1) on time axis - - # TODO: make this more generic - - conv_input = self.network.add_conv_block( - "conv_out", - data, - hwpc_sizes=[((3, 3), (1, 2), 32)], - l2=self.l2, - activation=self.input_layer_conv_act, - init=self.start_conv_init, - merge_out=False, - ) - - subsampled_input = self.network.add_conv_block( - "conv_merged", - conv_input, - hwpc_sizes=[((3, 3), (2, 1), 64), ((3, 3), (2, 1), 64)], - l2=self.l2, - activation=self.input_layer_conv_act, - init=self.start_conv_init, - use_striding=True, - split_input=False, - prefix_name="subsample_", - ) - elif self.input_layer == "conv-6": - conv_input = self.network.add_conv_block( - "conv_out", - data, - hwpc_sizes=[((3, 3), (1, 2), 32)], - l2=self.l2, - activation=self.input_layer_conv_act, - init=self.start_conv_init, - merge_out=False, - ) - - subsampled_input = self.network.add_conv_block( - "conv_merged", - conv_input, - hwpc_sizes=[((3, 3), (3, 1), 64), ((3, 3), (2, 1), 64)], - l2=self.l2, - activation=self.input_layer_conv_act, - init=self.start_conv_init, - use_striding=True, - split_input=False, - prefix_name="subsample_", - ) - - assert subsampled_input is not None - - source_linear = self.network.add_linear_layer( - "source_linear", - subsampled_input, - n_out=self.enc_key_dim, - l2=self.l2, - forward_weights_init=self.ff_init, - with_bias=False, + # merge two branches + merge_module = self._create_merge_module( + prefix_name, source=ff_module1, global_extracter=mhsa, local_extracter=conv_gating_mlp, layer_index=i ) - if self.dropout_in: - source_linear = self.network.add_dropout_layer("source_dropout", source_linear, dropout=self.dropout_in) - - conformer_block_src = source_linear - for i in range(1, self.num_blocks + 1): - conformer_block_src = self._create_e_branchformer_block(i, conformer_block_src) - - encoder = self.network.add_copy_layer(self.output_layer_name, conformer_block_src) - - if self.with_ctc: - default_ctc_loss_opts = {"beam_width": 1} - if self.native_ctc: - default_ctc_loss_opts["use_native"] = True - else: - self.ctc_opts.update({"ignore_longer_outputs_than_inputs": True}) # always enable - if self.ctc_opts: - default_ctc_loss_opts["ctc_opts"] = self.ctc_opts - self.network.add_softmax_layer( - "ctc", - encoder, - l2=self.ctc_l2, - target=self.target, - loss="ctc", - dropout=self.ctc_dropout, - loss_opts=default_ctc_loss_opts, - loss_scale=self.ctc_loss_scale, - ) - - return encoder - - def _create_e_branchformer_blocks(self, input): - conformer_block_src = input - for i in range(1, self.num_blocks + 1): - conformer_block_src = self._create_e_branchformer_block(i, conformer_block_src) - encoder = self.network.add_copy_layer(self.output_layer_name, conformer_block_src) - return encoder - - def create_network(self): - return self._create_all_network_parts() + ff_module2 = self._create_ff_module(prefix_name, 2, merge_module, i) + + res = ff_module2 + if self.block_final_norm: + res = self.network.add_layer_norm_layer("{}_ln".format(prefix_name), res) + if self.subsample: + assert 0 <= i - 1 < len(self.subsample) + subsample_factor = self.subsample_list[i - 1] + if subsample_factor > 1: + res = self.network.add_pool_layer(res + "_pool{}".format(i), res, pool_size=(subsample_factor,)) + res = self.network.add_copy_layer(prefix_name, res) + return res From 68552aee24ddf3d215103b1e1980ead7a50505ca Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Mon, 20 May 2024 22:43:10 +0200 Subject: [PATCH 035/227] more --- users/zeyer/experiments/exp2024_04_23_baselines/aed.py | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/users/zeyer/experiments/exp2024_04_23_baselines/aed.py b/users/zeyer/experiments/exp2024_04_23_baselines/aed.py index 38f6f4a69..2976cbafa 100644 --- a/users/zeyer/experiments/exp2024_04_23_baselines/aed.py +++ b/users/zeyer/experiments/exp2024_04_23_baselines/aed.py @@ -80,8 +80,14 @@ def py(): vocab="spm10k", ) + # Testing sampling in SPM. Baseline without sampling: 5.24 dev-other. + # The lower the alpha, the more aggressive the sampling. # alpha=0.1 seems too aggressive for AED, bad convergence - for alpha in [0.3, 0.5, 0.7]: + for alpha in [ + 0.3, # 5.26 + 0.5, + 0.7, # 4.98 (!!) + ]: train_exp( f"v6-bhv20-11gb-f32-bs15k-accgrad1-mgpu4-pavg100-wd1e_2-lrlin1e_5_295k-speedpertV2-spm10k" f"-spmSample{str(alpha).replace('.', '')}", From 857fbd6f1a4f6a59c8011a129cc38293c56bd837 Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Tue, 21 May 2024 10:33:26 +0200 Subject: [PATCH 036/227] more --- users/zeyer/experiments/exp2024_04_23_baselines/aed.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/users/zeyer/experiments/exp2024_04_23_baselines/aed.py b/users/zeyer/experiments/exp2024_04_23_baselines/aed.py index 2976cbafa..6a4ccc9df 100644 --- a/users/zeyer/experiments/exp2024_04_23_baselines/aed.py +++ b/users/zeyer/experiments/exp2024_04_23_baselines/aed.py @@ -86,7 +86,11 @@ def py(): for alpha in [ 0.3, # 5.26 0.5, + 0.6, 0.7, # 4.98 (!!) + 0.8, + 0.9, + 1.0, # sanity check ]: train_exp( f"v6-bhv20-11gb-f32-bs15k-accgrad1-mgpu4-pavg100-wd1e_2-lrlin1e_5_295k-speedpertV2-spm10k" From 41d336e42cd759f37edf9ebb40d1862283705668 Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Tue, 21 May 2024 14:39:59 +0000 Subject: [PATCH 037/227] better layer names for ebranchformer --- .../asr/encoder/ebranchformer_encoder.py | 80 ++++++++++--------- 1 file changed, 44 insertions(+), 36 deletions(-) diff --git a/users/zeineldeen/models/asr/encoder/ebranchformer_encoder.py b/users/zeineldeen/models/asr/encoder/ebranchformer_encoder.py index 4eb066d42..4870f7f25 100644 --- a/users/zeineldeen/models/asr/encoder/ebranchformer_encoder.py +++ b/users/zeineldeen/models/asr/encoder/ebranchformer_encoder.py @@ -10,38 +10,22 @@ class EBranchformerEncoder(ConformerEncoderV2): def __init__(self, **kwargs): super().__init__(**kwargs) - def _create_conv_gating_mlp(self, prefix_name, source, layer_index): - prefix_name = "{}_local_extractor".format(prefix_name) - - ln = self.network.add_layer_norm_layer("{}_ln".format(prefix_name), source) - - ff1 = self.network.add_linear_layer( - "{}_ff_1".format(prefix_name), - ln, - n_out=6 * self.enc_key_dim, - l2=self.l2, - forward_weights_init=self.ff_init, - with_bias=False, - param_dropout=self.ff_weight_drop, - param_dropout_min_ndim=2, - param_variational_noise=self.ff_weight_noise, - ) + def _create_conv_spatial_gating_unit(self, prefix_name, source, layer_index): + # see also here: https://github.com/espnet/espnet/blob/master/espnet2/asr/layers/cgmlp.py#L15 - gelu_act = self.network.add_activation_layer("{}_gelu".format(prefix_name), ff1, activation="gelu") - - br_part_A = self.network.add_slice_layer( - "{}_branch_a".format(prefix_name), gelu_act, "F", slice_start=0, slice_end=self.enc_key_dim * 3 + branch_a = self.network.add_slice_layer( + "{}_branch_a".format(prefix_name), source, "F", slice_start=0, slice_end=self.enc_key_dim * 3 ) - br_part_B = self.network.add_slice_layer( - "{}_branch_b".format(prefix_name), gelu_act, "F", slice_start=self.enc_key_dim * 3 + branch_b = self.network.add_slice_layer( + "{}_branch_b".format(prefix_name), source, "F", slice_start=self.enc_key_dim * 3 ) - br_part_B_ln = self.network.add_layer_norm_layer("{}_branch_b_ln".format(prefix_name), br_part_B) + br_part_b_ln = self.network.add_layer_norm_layer("{}_branch_b_ln".format(prefix_name), branch_b) - br_part_B_dpt_conv = self.network.add_conv_layer( - "{}_branch_b_dpt_conv".format(prefix_name), - br_part_B_ln, + br_part_b_depthwise_conv = self.network.add_conv_layer( + "{}_branch_b_depthwise_conv".format(prefix_name), + br_part_b_ln, n_out=self.enc_key_dim * 3, filter_size=(self.conv_kernel_size,), groups=self.enc_key_dim * 3, @@ -52,14 +36,37 @@ def _create_conv_gating_mlp(self, prefix_name, source, layer_index): ) br_merge = self.network.add_eval_layer( - "{}_branch_merge".format(prefix_name), [br_part_A, br_part_B_dpt_conv], "source(0)*source(1)" + "{}_branch_merge".format(prefix_name), [branch_a, br_part_b_depthwise_conv], "source(0) * source(1)" ) dropout = self.network.add_dropout_layer("{}_dropout".format(prefix_name), br_merge, dropout=self.dropout) + return dropout + + def _create_conv_gating_mlp(self, prefix_name, source, layer_index): + prefix_name = "{}_cgmlp".format(prefix_name) + + ln = self.network.add_layer_norm_layer("{}_ln".format(prefix_name), source) + + ff1 = self.network.add_linear_layer( + "{}_ff_1".format(prefix_name), + ln, + n_out=6 * self.enc_key_dim, # TODO: make it configurable + l2=self.l2, + forward_weights_init=self.ff_init, + with_bias=False, + param_dropout=self.ff_weight_drop, + param_dropout_min_ndim=2, + param_variational_noise=self.ff_weight_noise, + ) + + gelu_act = self.network.add_activation_layer("{}_gelu".format(prefix_name), ff1, activation="gelu") + + csgu = self._create_conv_spatial_gating_unit(prefix_name, gelu_act, layer_index) + br_merge_ff = self.network.add_linear_layer( "{}_ff_2".format(prefix_name), - dropout, + csgu, n_out=self.enc_key_dim, l2=self.l2, forward_weights_init=self.ff_init, @@ -74,12 +81,13 @@ def _create_conv_gating_mlp(self, prefix_name, source, layer_index): def _create_merge_module(self, prefix_name, *, source, global_extracter, local_extracter, layer_index): prefix_name = "{}_merge_module".format(prefix_name) + # concat on feature dim glb_lcl_merge = self.network.add_copy_layer( "{}_global_local_merge".format(prefix_name), [global_extracter, local_extracter] ) - dpt_conv = self.network.add_conv_layer( - "{}_dpt_conv".format(prefix_name), + depthwise_conv = self.network.add_conv_layer( + "{}_depthwise_conv".format(prefix_name), glb_lcl_merge, n_out=2 * self.enc_key_dim, filter_size=(self.conv_kernel_size,), @@ -90,16 +98,16 @@ def _create_merge_module(self, prefix_name, *, source, global_extracter, local_e param_variational_noise=self.conv_weight_noise, ) - dpt_conv_res = self.network.add_combine_layer( - "{}_dpt_conv_res".format(prefix_name), + depthwise_conv_res = self.network.add_combine_layer( + "{}_depthwise_conv_res".format(prefix_name), kind="add", - source=[glb_lcl_merge, dpt_conv], + source=[glb_lcl_merge, depthwise_conv], n_out=2 * self.enc_key_dim, ) ff = self.network.add_linear_layer( "{}_ff".format(prefix_name), - dpt_conv_res, + depthwise_conv_res, n_out=self.enc_key_dim, l2=self.l2, forward_weights_init=self.ff_init, @@ -140,11 +148,11 @@ def _create_conformer_block(self, i, source): mhsa = self._create_mhsa_module(prefix_name, ff_module1, i) # create branch 2: Convolutional gating MLP - conv_gating_mlp = self._create_conv_gating_mlp(prefix_name, ff_module1, i) + cgmlp = self._create_conv_gating_mlp(prefix_name, ff_module1, i) # merge two branches merge_module = self._create_merge_module( - prefix_name, source=ff_module1, global_extracter=mhsa, local_extracter=conv_gating_mlp, layer_index=i + prefix_name, source=ff_module1, global_extracter=mhsa, local_extracter=cgmlp, layer_index=i ) ff_module2 = self._create_ff_module(prefix_name, 2, merge_module, i) From e52414a30d7252e3aa307bf3064397449b525766 Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Tue, 21 May 2024 14:44:44 +0000 Subject: [PATCH 038/227] better --- users/zeineldeen/models/asr/encoder/ebranchformer_encoder.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/users/zeineldeen/models/asr/encoder/ebranchformer_encoder.py b/users/zeineldeen/models/asr/encoder/ebranchformer_encoder.py index 4870f7f25..f771363c3 100644 --- a/users/zeineldeen/models/asr/encoder/ebranchformer_encoder.py +++ b/users/zeineldeen/models/asr/encoder/ebranchformer_encoder.py @@ -36,7 +36,7 @@ def _create_conv_spatial_gating_unit(self, prefix_name, source, layer_index): ) br_merge = self.network.add_eval_layer( - "{}_branch_merge".format(prefix_name), [branch_a, br_part_b_depthwise_conv], "source(0) * source(1)" + "{}_merge".format(prefix_name), [branch_a, br_part_b_depthwise_conv], "source(0) * source(1)" ) dropout = self.network.add_dropout_layer("{}_dropout".format(prefix_name), br_merge, dropout=self.dropout) @@ -62,7 +62,7 @@ def _create_conv_gating_mlp(self, prefix_name, source, layer_index): gelu_act = self.network.add_activation_layer("{}_gelu".format(prefix_name), ff1, activation="gelu") - csgu = self._create_conv_spatial_gating_unit(prefix_name, gelu_act, layer_index) + csgu = self._create_conv_spatial_gating_unit(f"{prefix_name}_csgu", gelu_act, layer_index) br_merge_ff = self.network.add_linear_layer( "{}_ff_2".format(prefix_name), From 6987cd7c94ae97ba76754c300e16612c592c8cf0 Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Tue, 21 May 2024 14:52:05 +0000 Subject: [PATCH 039/227] better --- .../asr/encoder/ebranchformer_encoder.py | 19 +++++++++++-------- 1 file changed, 11 insertions(+), 8 deletions(-) diff --git a/users/zeineldeen/models/asr/encoder/ebranchformer_encoder.py b/users/zeineldeen/models/asr/encoder/ebranchformer_encoder.py index f771363c3..09d0e8e32 100644 --- a/users/zeineldeen/models/asr/encoder/ebranchformer_encoder.py +++ b/users/zeineldeen/models/asr/encoder/ebranchformer_encoder.py @@ -7,28 +7,31 @@ class EBranchformerEncoder(ConformerEncoderV2): * Ref: https://arxiv.org/pdf/2210.00077.pdf """ - def __init__(self, **kwargs): + def __init__(self, cgmlp_ff_dim, **kwargs): super().__init__(**kwargs) + assert cgmlp_ff_dim % 2 == 0, "cgmlp_dim must be even" + self.cgmlp_ff_dim = cgmlp_ff_dim + def _create_conv_spatial_gating_unit(self, prefix_name, source, layer_index): # see also here: https://github.com/espnet/espnet/blob/master/espnet2/asr/layers/cgmlp.py#L15 + split_size = self.cgmlp_ff_dim // 2 + branch_a = self.network.add_slice_layer( - "{}_branch_a".format(prefix_name), source, "F", slice_start=0, slice_end=self.enc_key_dim * 3 + "{}_branch_a".format(prefix_name), source, "F", slice_start=0, slice_end=split_size ) - branch_b = self.network.add_slice_layer( - "{}_branch_b".format(prefix_name), source, "F", slice_start=self.enc_key_dim * 3 - ) + branch_b = self.network.add_slice_layer("{}_branch_b".format(prefix_name), source, "F", slice_start=split_size) br_part_b_ln = self.network.add_layer_norm_layer("{}_branch_b_ln".format(prefix_name), branch_b) br_part_b_depthwise_conv = self.network.add_conv_layer( "{}_branch_b_depthwise_conv".format(prefix_name), br_part_b_ln, - n_out=self.enc_key_dim * 3, + n_out=split_size, filter_size=(self.conv_kernel_size,), - groups=self.enc_key_dim * 3, + groups=split_size, l2=self.l2, param_dropout=self.conv_weight_drop, param_dropout_min_ndim=2, @@ -51,7 +54,7 @@ def _create_conv_gating_mlp(self, prefix_name, source, layer_index): ff1 = self.network.add_linear_layer( "{}_ff_1".format(prefix_name), ln, - n_out=6 * self.enc_key_dim, # TODO: make it configurable + n_out=self.cgmlp_ff_dim, # TODO: make it configurable l2=self.l2, forward_weights_init=self.ff_init, with_bias=False, From b930a71f9b9e080d6a08b37663a6837b4ea445e0 Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Tue, 21 May 2024 15:11:17 +0000 Subject: [PATCH 040/227] decouple mhsa residual --- .../models/asr/encoder/conformer_encoder_v2.py | 14 ++++++++------ .../models/asr/encoder/ebranchformer_encoder.py | 5 +++++ 2 files changed, 13 insertions(+), 6 deletions(-) diff --git a/users/zeineldeen/models/asr/encoder/conformer_encoder_v2.py b/users/zeineldeen/models/asr/encoder/conformer_encoder_v2.py index 9831b8e61..fa8e11f26 100644 --- a/users/zeineldeen/models/asr/encoder/conformer_encoder_v2.py +++ b/users/zeineldeen/models/asr/encoder/conformer_encoder_v2.py @@ -903,12 +903,7 @@ def _create_mhsa_module(self, prefix_name, source, layer_index): drop = self.network.add_dropout_layer("{}_dropout".format(prefix_name), mhsa_linear, dropout=self.dropout) - res_inputs = [drop, source] - - mhsa_res = self.network.add_combine_layer( - "{}_res".format(prefix_name), kind="add", source=res_inputs, n_out=self.enc_value_dim - ) - return mhsa_res + return drop def _create_convolution_module(self, prefix_name, source, layer_index, half_step=False): """ @@ -1071,6 +1066,10 @@ def _create_conformer_block(self, i, source): if self.convolution_first: conv_module_ = self._create_convolution_module(prefix_name, ff_module1, i) mhsa_module = self._create_mhsa_module(prefix_name, conv_module_, i) + mhsa_module = self.network.add_combine_layer( + "{}_res".format(prefix_name), kind="add", source=[mhsa_module, conv_module_], n_out=self.enc_value_dim + ) + ff_module2_input = mhsa_module else: if self.no_mhsa_module: @@ -1083,6 +1082,9 @@ def _create_conformer_block(self, i, source): ) mhsa_input = conv_module1 mhsa = self._create_mhsa_module(prefix_name, mhsa_input, i) + mhsa = self.network.add_combine_layer( + "{}_res".format(prefix_name), kind="add", source=[mhsa, mhsa_input], n_out=self.enc_value_dim + ) conv_module = self._create_convolution_module(prefix_name, mhsa, i, half_step=self.sandwich_conv) ff_module2_input = conv_module diff --git a/users/zeineldeen/models/asr/encoder/ebranchformer_encoder.py b/users/zeineldeen/models/asr/encoder/ebranchformer_encoder.py index 09d0e8e32..508664380 100644 --- a/users/zeineldeen/models/asr/encoder/ebranchformer_encoder.py +++ b/users/zeineldeen/models/asr/encoder/ebranchformer_encoder.py @@ -14,6 +14,8 @@ def __init__(self, cgmlp_ff_dim, **kwargs): self.cgmlp_ff_dim = cgmlp_ff_dim def _create_conv_spatial_gating_unit(self, prefix_name, source, layer_index): + # Half split input into [A,B] -> A * DwConv(LN(B)) -> dropout + # # see also here: https://github.com/espnet/espnet/blob/master/espnet2/asr/layers/cgmlp.py#L15 split_size = self.cgmlp_ff_dim // 2 @@ -47,6 +49,8 @@ def _create_conv_spatial_gating_unit(self, prefix_name, source, layer_index): return dropout def _create_conv_gating_mlp(self, prefix_name, source, layer_index): + # GeLU(FF(LN(x))) -> Half split input into [A,B] -> A * DwConv(LN(B)) -> dropout -> FF + prefix_name = "{}_cgmlp".format(prefix_name) ln = self.network.add_layer_norm_layer("{}_ln".format(prefix_name), source) @@ -65,6 +69,7 @@ def _create_conv_gating_mlp(self, prefix_name, source, layer_index): gelu_act = self.network.add_activation_layer("{}_gelu".format(prefix_name), ff1, activation="gelu") + # Half split input into [A,B] -> A * DwConv(LN(B)) -> dropout csgu = self._create_conv_spatial_gating_unit(f"{prefix_name}_csgu", gelu_act, layer_index) br_merge_ff = self.network.add_linear_layer( From ba036c34176b2eaa5da5fa531304a54ed2d4c577 Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Tue, 21 May 2024 15:11:46 +0000 Subject: [PATCH 041/227] cleanup --- users/zeineldeen/models/asr/encoder/ebranchformer_encoder.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/users/zeineldeen/models/asr/encoder/ebranchformer_encoder.py b/users/zeineldeen/models/asr/encoder/ebranchformer_encoder.py index 508664380..b513e5af6 100644 --- a/users/zeineldeen/models/asr/encoder/ebranchformer_encoder.py +++ b/users/zeineldeen/models/asr/encoder/ebranchformer_encoder.py @@ -58,7 +58,7 @@ def _create_conv_gating_mlp(self, prefix_name, source, layer_index): ff1 = self.network.add_linear_layer( "{}_ff_1".format(prefix_name), ln, - n_out=self.cgmlp_ff_dim, # TODO: make it configurable + n_out=self.cgmlp_ff_dim, l2=self.l2, forward_weights_init=self.ff_init, with_bias=False, From 0ad3b4ad10f26e30e069136db5fee5b9cec1b16f Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Tue, 21 May 2024 16:56:09 +0000 Subject: [PATCH 042/227] refactor args. add ebranch config --- .../librispeech_960/attention_asr_config.py | 237 +--- .../tedlium2/configs/ebranch_baseline.py | 1023 +++++++++++++++++ .../tedlium2/configs/ted2_att_baseline.py | 98 +- users/zeineldeen/models/asr/decoder/args.py | 137 +++ users/zeineldeen/models/asr/encoder/args.py | 87 ++ .../asr/encoder/ebranchformer_encoder.py | 9 +- 6 files changed, 1317 insertions(+), 274 deletions(-) create mode 100644 users/zeineldeen/experiments/conformer_att_2023/tedlium2/configs/ebranch_baseline.py create mode 100644 users/zeineldeen/models/asr/decoder/args.py create mode 100644 users/zeineldeen/models/asr/encoder/args.py diff --git a/users/zeineldeen/experiments/conformer_att_2022/librispeech_960/attention_asr_config.py b/users/zeineldeen/experiments/conformer_att_2022/librispeech_960/attention_asr_config.py index 8e2d62658..0630cbd43 100644 --- a/users/zeineldeen/experiments/conformer_att_2022/librispeech_960/attention_asr_config.py +++ b/users/zeineldeen/experiments/conformer_att_2022/librispeech_960/attention_asr_config.py @@ -1,12 +1,22 @@ -import os.path - import numpy import copy -from typing import Any, Dict, Optional, List -from dataclasses import dataclass, asdict +from dataclasses import asdict +from i6_experiments.users.zeineldeen.models.asr.encoder.args import ( + EncoderArgs, + ConformerEncoderArgs, + ConformerEncoderV2Args, + EBranchformerEncoderArgs, +) from i6_experiments.users.zeineldeen.models.asr.encoder.conformer_encoder import ConformerEncoder from i6_experiments.users.zeineldeen.models.asr.encoder.conformer_encoder_v2 import ConformerEncoderV2 +from i6_experiments.users.zeineldeen.models.asr.encoder.ebranchformer_encoder import EBranchformerEncoder +from i6_experiments.users.zeineldeen.models.asr.decoder.args import ( + DecoderArgs, + TransformerDecoderArgs, + RNNDecoderArgs, + ConformerDecoderArgs, +) from i6_experiments.users.zeineldeen.models.asr.decoder.transformer_decoder import TransformerDecoder from i6_experiments.users.zeineldeen.models.asr.decoder.conformer_decoder import ConformerDecoder from i6_experiments.users.zeineldeen.models.asr.decoder.rnn_decoder import RNNDecoder @@ -213,7 +223,6 @@ def pretrain_layers_and_dims( """ InitialDimFactor = initial_dim_factor - encoder_keys = ["ff_dim", "enc_key_dim", "conv_kernel_size"] # TODO: effect of pretraining conv font-end? decoder_keys = ["ff_dim"] encoder_args_copy = copy.deepcopy(encoder_args) @@ -366,218 +375,6 @@ def pretrain_layers_and_dims( # -------------------------------------------------------------------- # -class EncoderArgs: - pass - - -@dataclass -class ConformerEncoderArgs(EncoderArgs): - num_blocks: int = 12 - enc_key_dim: int = 512 - att_num_heads: int = 8 - ff_dim: int = 2048 - conv_kernel_size: int = 32 - input: str = "data" - input_layer: str = "lstm-6" - input_layer_conv_act: str = "relu" - add_abs_pos_enc_to_input: bool = False - pos_enc: str = "rel" - - sandwich_conv: bool = False - subsample: Optional[str] = None - use_causal_layers: bool = False - - # ctc - with_ctc: bool = True - native_ctc: bool = True - ctc_loss_scale: Optional[float] = None - ctc_self_align_delay: Optional[int] = None - ctc_self_align_scale: float = 0.5 - ctc_dropout: float = 0.0 - - # param init - ff_init: Optional[str] = None - mhsa_init: Optional[str] = None - mhsa_out_init: Optional[str] = None - conv_module_init: Optional[str] = None - start_conv_init: Optional[str] = None - - # dropout - dropout: float = 0.1 - dropout_in: float = 0.1 - att_dropout: float = 0.1 - lstm_dropout: float = 0.1 - - # weight dropout - ff_weight_dropout: Optional[float] = None - mhsa_weight_dropout: Optional[float] = None - conv_weight_dropout: Optional[float] = None - - # norms - batch_norm_opts: Optional[Dict[str, Any]] = None - use_ln: bool = False - - # other regularization - l2: float = 0.0001 - frontend_conv_l2: float = 0.0001 - self_att_l2: float = 0.0 - rel_pos_clipping: int = 16 - - use_sqrd_relu: bool = False - - # weight noise - weight_noise: Optional[float] = None - weight_noise_layers: Optional[List[str]] = None - - convolution_first: bool = False - - -class ConformerEncoderV2Args(ConformerEncoderArgs): - # weight noise - ff_weight_noise: Optional[float] = None - mhsa_weight_noise: Optional[float] = None - conv_weight_noise: Optional[float] = None - frontend_conv_weight_noise: Optional[float] = None - - # weight dropout - frontend_conv_weight_dropout: Optional[float] = None - - -class DecoderArgs: - pass - - -@dataclass -class TransformerDecoderArgs(DecoderArgs): - num_layers: int = 6 - att_num_heads: int = 8 - ff_dim: int = 2048 - ff_act: str = "relu" - pos_enc: Optional[str] = None - embed_pos_enc: bool = False - - # param init - ff_init: Optional[str] = None - mhsa_init: Optional[str] = None - mhsa_out_init: Optional[str] = None - - # dropout - dropout: float = 0.1 - att_dropout: float = 0.1 - embed_dropout: float = 0.1 - softmax_dropout: float = 0.0 - - ff_weight_noise: Optional[float] = None - mhsa_weight_noise: Optional[float] = None - ff_weight_dropout: Optional[float] = None - mhsa_weight_dropout: Optional[float] = None - - # other regularization - l2: float = 0.0 - self_att_l2: float = 0.0 - rel_pos_clipping: int = 16 - label_smoothing: float = 0.1 - apply_embed_weight: bool = False - - length_normalization: bool = True - - # ILM - replace_cross_att_w_masked_self_att: bool = False - create_ilm_decoder: bool = False - ilm_type: bool = None - ilm_args: Optional[dict] = None - - -@dataclass -class ConformerDecoderArgs(DecoderArgs): - num_layers: int = 6 - att_num_heads: int = 8 - ff_dim: int = 2048 - pos_enc: Optional[str] = "rel" - - # conv module - conv_kernel_size: int = 32 - - # param init - ff_init: Optional[str] = None - mhsa_init: Optional[str] = None - mhsa_out_init: Optional[str] = None - conv_module_init: Optional[str] = None - - # dropout - dropout: float = 0.1 - att_dropout: float = 0.1 - embed_dropout: float = 0.1 - softmax_dropout: float = 0.1 - - # other regularization - l2: float = 0.0001 - frontend_conv_l2: float = 0.0001 - rel_pos_clipping: int = 16 - label_smoothing: float = 0.1 - apply_embed_weight: bool = False - - length_normalization: bool = True - - use_sqrd_relu: bool = False - - # ILM - replace_cross_att_w_masked_self_att: bool = False - create_ilm_decoder: bool = False - ilm_type: bool = None - ilm_args: Optional[dict] = None - - -@dataclass -class RNNDecoderArgs(DecoderArgs): - att_num_heads: int = 1 - lstm_num_units: int = 1024 - output_num_units: int = 1024 - embed_dim: int = 640 - enc_key_dim: int = 1024 # also attention dim # also attention dim - - # location feedback - loc_conv_att_filter_size: Optional[int] = None - - # param init - lstm_weights_init: Optional[str] = None - embed_weight_init: Optional[str] = None - - # dropout - dropout: float = 0.0 - softmax_dropout: float = 0.3 - att_dropout: float = 0.0 - embed_dropout: float = 0.1 - rec_weight_dropout: float = 0.0 - - # other regularization - l2: float = 0.0001 - zoneout: bool = True - reduceout: bool = True - - # lstm lm - lstm_lm_dim: int = 1024 - add_lstm_lm: bool = False - - length_normalization: bool = True - length_normalization_exponent: float = 1.0 - - coverage_scale: float = None - coverage_threshold: float = None - coverage_update: str = "sum" - - ce_loss_scale: Optional[float] = 1.0 - - label_smoothing: float = 0.1 - - use_zoneout_output: bool = False - - monotonic_att_weights_loss_opts: Optional[dict] = None - use_monotonic_att_weights_loss_in_recog: Optional[bool] = False - - include_eos_in_search_output: bool = False - - def create_config( training_datasets, encoder_args: EncoderArgs, @@ -752,10 +549,12 @@ def create_config( # -------------------------- network -------------------------- # - if isinstance(encoder_args, ConformerEncoderArgs): + if type(encoder_args) is ConformerEncoderArgs: encoder_type = ConformerEncoder - elif isinstance(encoder_args, ConformerEncoderV2Args): + elif type(encoder_args) is ConformerEncoderV2Args: encoder_type = ConformerEncoderV2 + elif type(encoder_args) is EBranchformerEncoderArgs: + encoder_type = EBranchformerEncoder else: raise ValueError("invalid encoder_args type") diff --git a/users/zeineldeen/experiments/conformer_att_2023/tedlium2/configs/ebranch_baseline.py b/users/zeineldeen/experiments/conformer_att_2023/tedlium2/configs/ebranch_baseline.py new file mode 100644 index 000000000..f90326966 --- /dev/null +++ b/users/zeineldeen/experiments/conformer_att_2023/tedlium2/configs/ebranch_baseline.py @@ -0,0 +1,1023 @@ +import copy, os + +import numpy + +import sisyphus.toolkit as tk + +from i6_experiments.users.zeineldeen.experiments.conformer_att_2022.librispeech_960.attention_asr_config import ( + create_config, + ConformerEncoderArgs, + TransformerDecoderArgs, + RNNDecoderArgs, + ConformerDecoderArgs, + EBranchformerEncoderArgs, +) +from i6_experiments.users.zeineldeen.experiments.conformer_att_2022.librispeech_960.additional_config import ( + apply_fairseq_init_to_conformer, + reset_params_init, + apply_fairseq_init_to_transformer_decoder, +) +from i6_experiments.users.zeineldeen.experiments.conformer_att_2023.tedlium2.data import ( + build_training_datasets, + build_test_dataset, +) +from i6_experiments.users.zeineldeen.experiments.conformer_att_2023.tedlium2.default_tools import ( + RETURNN_ROOT, + RETURNN_CPU_EXE, + SCTK_BINARY_PATH, +) +from i6_experiments.users.zeineldeen.experiments.conformer_att_2022.librispeech_960.feature_extraction_net import ( + log10_net_10ms, +) +from i6_experiments.users.zeineldeen.experiments.conformer_att_2022.librispeech_960.pipeline import ( + training, + search, + get_average_checkpoint, + get_best_checkpoint, + search_single, +) +from i6_experiments.users.zeineldeen.models.lm import generic_lm +from i6_experiments.users.zeineldeen.models.lm.transformer_lm import TransformerLM +from i6_experiments.users.zeineldeen.experiments.conformer_att_2022.librispeech_960 import ( + ilm_helpers, +) +from i6_experiments.users.rossenbach.experiments.librispeech.kazuki_lm.experiment import ( + get_lm, + ZeineldeenLM, +) + +train_jobs_map = {} # dict[str, ReturnnTrainJob] +train_job_avg_ckpt = {} +train_job_best_epoch = {} + +BPE_10K = 10000 +BPE_5K = 5000 +BPE_1K = 1000 +BPE_500 = 500 + +# train: +# ------ +# Seq-length 'data' Stats: +# 92973 seqs +# Mean: 819.1473868757647 +# Std dev: 434.7168733027807 +# Min/max: 26 / 2049 + +# --------------------------- LM --------------------------- # + +# LM data (runnnig words) +# trans 2250417 ~ 2.25M +# external: 12688261 ~ 12.7M +# Total: 14.9M + +lstm_10k_lm_opts = { + "lm_subnet": generic_lm.libri_lstm_bpe10k_net, + "lm_model": generic_lm.libri_lstm_bpe10k_model, + "name": "lstm", +} + +lstm_lm_opts_map = { + BPE_10K: lstm_10k_lm_opts, +} + +# Trafo LM trained by willi +# - setup dir: /u/michel/setups/language_modelling/tedlium/neurallm/trafo_kazuki19 +# - config: /u/michel/setups/language_modelling/tedlium/neurallm/trafo_kazuki19/tdl1.config +trafo_lm_net = TransformerLM( + source="prev:output", + num_layers=30, + vocab_size=1057, + use_as_ext_lm=True, + ff_dim=4096, + att_num_heads=12, + embed_dim=128, + qk_dim=768, + v_dim=768, + out_dim=768, + emb_cpu_lookup=False, + embed_pos=False, # wo abs pos encoding + conv_act="gelu", +) +trafo_lm_net.create_network() +trafo_1k_lm_opts = { + "lm_subnet": trafo_lm_net.network.get_net(), + "load_on_init_opts": { + "filename": "/work/asr4/michel/setups-data/language_modelling/tedlium/neurallm/trafo_kazuki19/net-model/network.020", + "params_prefix": "", + "load_if_prefix": "lm_output/", + }, + "name": "trafo", +} + +trafo_lm_opts_map = {BPE_1K: trafo_1k_lm_opts} + +# ----------------------------------------------------------- # + + +def compute_features_stats( + output_dirname, feat_dim, bpe_size=10000, feature_extraction_net=log10_net_10ms, model_checkpoint=None, **kwargs +): + train_data = build_training_datasets( + bpe_size=bpe_size, + use_raw_features=True, + epoch_wise_filter=None, + link_speed_perturbation=False, + seq_ordering="laplace:.1000", + partition_epoch=1, + ) + # Dump log-mel features into HDFDataset + dump_features_config = {} + dump_features_config["extern_data"] = train_data.extern_data + dump_features_config["network"] = copy.deepcopy(feature_extraction_net) + if model_checkpoint: + dump_features_config["network"]["output"] = { + "class": "hdf_dump", + "from": "log_mel_features", + "filename": "log_mel_features.hdf", + } + else: + dump_features_config["network"]["output"] = { + "class": "copy", + "from": "log_mel_features", + } + dump_features_config["forward_batch_size"] = 20_000 * 80 + dump_features_config["use_tensorflow"] = True + dump_features_config["eval"] = train_data.train.as_returnn_opts() + from i6_core.returnn import ReturnnForwardJob, ReturnnConfig + + hdf_filename = "log_mel_features.hdf" if model_checkpoint else "output.hdf" + + dump_features_job = ReturnnForwardJob( + returnn_config=ReturnnConfig(config=dump_features_config), + returnn_python_exe=RETURNN_CPU_EXE, + returnn_root=kwargs.get("returnn_root", RETURNN_ROOT), + model_checkpoint=model_checkpoint, + hdf_outputs=[hdf_filename] if model_checkpoint else [], + device="cpu", + mem_rqmt=15, + time_rqmt=72, + eval_mode=True if model_checkpoint else False, + ) + dump_features_job.add_alias(f"ted2_stats/{output_dirname}/dump_train_log_mel_features") + tk.register_output( + f"ted2_stats/{output_dirname}/log_mel_features.hdf", dump_features_job.out_hdf_files[hdf_filename] + ) + + # Extract features stats from HDFDataset + extract_stats_returnn_config = ReturnnConfig( + { + "extern_data": { + "data": {"dim": feat_dim}, + }, + "train": { + "class": "HDFDataset", + "files": [dump_features_job.out_hdf_files[hdf_filename]], + "use_cache_manager": True, + }, + "batch_size": 20_000 * 80, + "use_tensorflow": True, + } + ) + from i6_core.returnn.dataset import ExtractDatasetMeanStddevJob + + extract_mean_stddev_job = ExtractDatasetMeanStddevJob( + returnn_config=extract_stats_returnn_config, + returnn_python_exe=RETURNN_CPU_EXE, + returnn_root=kwargs.get("returnn_root", RETURNN_ROOT), + ) + extract_mean_stddev_job.add_alias(f"ted2_stats/{output_dirname}/extract_mean_stddev") + + tk.register_output(f"ted2_stats/{output_dirname}/mean_var", extract_mean_stddev_job.out_mean) + tk.register_output(f"ted2_stats/{output_dirname}/std_dev_var", extract_mean_stddev_job.out_std_dev) + tk.register_output(f"ted2_stats/{output_dirname}/mean_file", extract_mean_stddev_job.out_mean_file) + tk.register_output(f"ted2_stats/{output_dirname}/std_dev_file", extract_mean_stddev_job.out_std_dev_file) + + return ( + extract_mean_stddev_job.out_mean, + extract_mean_stddev_job.out_std_dev, + extract_mean_stddev_job.out_mean_file, + extract_mean_stddev_job.out_std_dev_file, + ) + + +def conformer_baseline(): + abs_name = os.path.abspath(__file__) + prefix_name = os.path.basename(abs_name)[: -len(".py")] + + def get_test_dataset_tuples(bpe_size): + test_dataset_tuples = {} + for testset in ["dev", "test"]: + test_dataset_tuples[testset] = build_test_dataset( + testset, + use_raw_features=True, + bpe_size=bpe_size, + ) + return test_dataset_tuples + + def run_train( + exp_name, + train_args, + train_data, + feature_extraction_net, + num_epochs, + recog_epochs, + **kwargs, + ): + exp_prefix = os.path.join(prefix_name, exp_name) + returnn_config = create_config( + training_datasets=train_data, + **train_args, + feature_extraction_net=feature_extraction_net, + recog_epochs=recog_epochs, + ) + train_job = training( + exp_prefix, + returnn_config, + RETURNN_CPU_EXE, + RETURNN_ROOT, + num_epochs=num_epochs, + gpu_mem=kwargs.get("gpu_mem", 11), + ) + return train_job + + def run_single_search( + exp_name, + train_data, + search_args, + checkpoint, + feature_extraction_net, + recog_dataset, + recog_ref, + recog_bliss, + mem_rqmt=8, + time_rqmt=4, + **kwargs, + ): + exp_prefix = os.path.join(prefix_name, exp_name) + returnn_search_config = create_config( + training_datasets=train_data, + **search_args, + feature_extraction_net=feature_extraction_net, + is_recog=True, + ) + search_single( + exp_prefix, + returnn_search_config, + checkpoint, + recognition_dataset=recog_dataset, + recognition_reference=recog_ref, + recognition_bliss_corpus=recog_bliss, + returnn_exe=RETURNN_CPU_EXE, + returnn_root=RETURNN_ROOT, + mem_rqmt=mem_rqmt, + time_rqmt=time_rqmt, + use_sclite=True, + ) + + def run_lm_fusion( + lm_type, + exp_name, + epoch, + test_set_names, + lm_scales, + train_job, + train_data, + feature_net, + bpe_size, + args, + beam_size=12, + prior_scales=None, + prior_type=None, + mini_lstm_ckpt=None, + length_norm=True, + length_norm_exponent=1.0, + prior_type_name=None, + coverage_scale=None, + coverage_threshold=None, + coverage_update=None, + monotonic_att_weights_loss_opts=None, + **kwargs, + ): + assert lm_type in ["lstm", "trafo"], "lm type should be lstm or trafo" + + if isinstance(lm_scales, float): + lm_scales = [lm_scales] + if prior_scales and isinstance(prior_scales, float): + prior_scales = [prior_scales] + if isinstance(test_set_names, str): + test_set_names = [test_set_names] + assert isinstance(test_set_names, list) + + if epoch == "avg": + search_checkpoint = train_job_avg_ckpt[exp_name] + elif epoch == "best": + search_checkpoint = train_job_best_epoch[exp_name] + else: + assert isinstance(epoch, int), "epoch must be either a defined integer or a string in {avg, best}." + search_checkpoint = train_job.out_checkpoints[epoch] + + ext_lm_opts = lstm_lm_opts_map[bpe_size] if lm_type == "lstm" else trafo_lm_opts_map[bpe_size] + + time_rqmt = 1.0 + + search_args = copy.deepcopy(args) + + if lm_type == "lstm": + if beam_size > 128: + search_args["batch_size"] = 4000 * 160 + + if lm_type == "trafo": + search_args["batch_size"] = 4000 * 160 if beam_size <= 32 else 2000 * 160 + time_rqmt = 2 + if beam_size > 50: + time_rqmt = 3 + + search_args["beam_size"] = beam_size + if kwargs.get("batch_size", None): + search_args["batch_size"] = kwargs["batch_size"] + + if not length_norm: + search_args["decoder_args"].length_normalization = False + else: + search_args["decoder_args"].length_normalization = True + search_args["decoder_args"].length_normalization_exponent = length_norm_exponent + + if "decoder_args" in kwargs: + for k, v in kwargs["decoder_args"].items(): + setattr(search_args["decoder_args"], k, v) + + scales = [(e,) for e in lm_scales] + + for test_set in test_set_names: + if prior_scales: + import itertools + + scales = itertools.product(lm_scales, prior_scales) + + for scale in scales: + lm_scale = scale[0] + prior_scale = scale[1] if len(scale) == 2 else None + if prior_scale and prior_scale > lm_scale: + continue + + # External LM opts + ext_lm_opts["lm_scale"] = lm_scale + search_args["ext_lm_opts"] = ext_lm_opts + + # ILM opts + if prior_scale: + ilm_opts = { + "scale": prior_scale, + "type": prior_type, + "ctx_dim": search_args["encoder_args"].enc_key_dim, # this is needed for mini-lstm + } + # this is needed for mini-self-att + if hasattr(search_args["decoder_args"], "num_layers"): + ilm_opts["num_dec_layers"] = search_args["decoder_args"].num_layers + search_args["decoder_args"].create_ilm_decoder = True + search_args["decoder_args"].ilm_type = prior_type + + ilm_opts.update(kwargs.get("ilm_train_opts", {})) # example for FFN, etc + + search_args["prior_lm_opts"] = ilm_opts + search_args["preload_from_files"] = { + "prior_lm": { + "filename": search_checkpoint, # copy ASR decoder to be used as ILM decoder + "prefix": "prior_", + } + } + if prior_type == "mini_lstm" or prior_type == "ffn": + assert mini_lstm_ckpt, "Mini-LSTM checkpoint not set." + search_args["preload_from_files"].update( + { + "mini_lstm": { + "filename": mini_lstm_ckpt, + "prefix": "mini_", + } + } + ) + + if prior_type_name is None: + prior_type_name = prior_type + + lm_desc = "" + if prior_scale: + lm_desc = f"ILM_{prior_type_name}/" + + lm_desc += f"lm-scale-{lm_scale}" + if prior_scale: + lm_desc += f"-prior-{prior_scale}" + lm_desc += f"-beam-{beam_size}" + if length_norm is False: + lm_desc += "-woLenNorm" + + if coverage_scale and coverage_threshold: + assert isinstance(search_args["decoder_args"], RNNDecoderArgs) + search_args["decoder_args"].coverage_scale = coverage_scale + search_args["decoder_args"].coverage_threshold = coverage_threshold + search_args["decoder_args"].coverage_update = coverage_update + lm_desc += f"_coverage-thre{coverage_threshold}-scale{coverage_scale}-{coverage_update}" + + if monotonic_att_weights_loss_opts: + search_args["decoder_args"].monotonic_att_weights_loss_opts = monotonic_att_weights_loss_opts + search_args["decoder_args"].use_monotonic_att_weights_loss_in_recog = True + lm_desc += "_monoAtt" + for k, v in monotonic_att_weights_loss_opts.items(): + lm_desc += f"-{k}{v}" + + if not length_norm: + lm_desc += "_noLenNorm" + elif length_norm_exponent != 1.0: + lm_desc += f"_lenNormExp{length_norm_exponent}" + + name = f"{exp_name}/recog-{lm_type}-lm/ep-{epoch}/{lm_desc}/{test_set}" + + test_dataset_tuples = get_test_dataset_tuples(bpe_size=bpe_size) + + run_single_search( + exp_name=name, + train_data=train_data, + search_args=search_args, + checkpoint=search_checkpoint, + feature_extraction_net=feature_net, + recog_dataset=test_dataset_tuples[test_set][0], + recog_ref=test_dataset_tuples[test_set][1], + recog_bliss=test_dataset_tuples[test_set][2], + time_rqmt=kwargs.get("time_rqmt", time_rqmt), + ) + + def run_search( + exp_name, + train_args, + train_data, + train_job, + feature_extraction_net, + num_epochs, + search_args, + recog_epochs, + bpe_size, + **kwargs, + ): + exp_prefix = os.path.join(prefix_name, exp_name) + + search_args = search_args if search_args is not None else train_args + + returnn_search_config = create_config( + training_datasets=train_data, + **search_args, + feature_extraction_net=feature_extraction_net, + is_recog=True, + ) + + num_avg = kwargs.get("num_avg", 4) + averaged_checkpoint = get_average_checkpoint( + train_job, + returnn_exe=RETURNN_CPU_EXE, + returnn_root=RETURNN_ROOT, + num_average=num_avg, + key=kwargs.get("avg_key", "dev_score_output/output_prob"), + ) + if num_avg == 4: # TODO: just for now to not break hashes + train_job_avg_ckpt[exp_name] = averaged_checkpoint + + best_checkpoint = get_best_checkpoint(train_job, key=kwargs.get("avg_key", "dev_score_output/output_prob")) + train_job_best_epoch[exp_name] = best_checkpoint + + if recog_epochs is None: + default_recog_epochs = [40] + default_recog_epochs += [80 * i for i in range(1, int(num_epochs / 80) + 1)] + if num_epochs % 80 != 0: + default_recog_epochs += [num_epochs] + else: + default_recog_epochs = recog_epochs + + test_dataset_tuples = get_test_dataset_tuples(bpe_size=bpe_size) + + run_only_avg = kwargs.get("run_only_avg", False) + + if not run_only_avg: + for ep in default_recog_epochs: + search( + exp_prefix + f"/recogs/ep-{ep}", + returnn_search_config, + train_job.out_checkpoints[ep], + test_dataset_tuples, + RETURNN_CPU_EXE, + RETURNN_ROOT, + ) + + search( + exp_prefix + "/default_last", + returnn_search_config, + train_job.out_checkpoints[num_epochs], + test_dataset_tuples, + RETURNN_CPU_EXE, + RETURNN_ROOT, + ) + + search( + exp_prefix + "/default_best", + returnn_search_config, + best_checkpoint, + test_dataset_tuples, + RETURNN_CPU_EXE, + RETURNN_ROOT, + use_sclite=True, + ) + + beam_size = search_args.get("beam_size", 12) + if beam_size != 12: + exp_prefix += f"_beam-{beam_size}" + if search_args["decoder_args"].coverage_scale: + exp_prefix += f"_coverage-thre{search_args['decoder_args'].coverage_threshold}-scale{search_args['decoder_args'].coverage_scale}" + search( + exp_prefix + f"/average_{num_avg}", + returnn_search_config, + averaged_checkpoint, + test_dataset_tuples, + RETURNN_CPU_EXE, + RETURNN_ROOT, + use_sclite=True, + ) + + def run_concat_seq_recog(exp_name, corpus_names, num, train_data, search_args, checkpoint, mem_rqmt=8, time_rqmt=1): + exp_prefix = os.path.join(prefix_name, exp_name) + + from i6_experiments.users.zeineldeen.experiments.chunkwise_att_2023.concat_seqs import ( + ConcatDatasetSeqsJob, + ConcatSeqsDataset, + CreateConcatSeqsCTMAndSTMJob, + ) + from i6_core.corpus.convert import CorpusToStmJob + + if isinstance(corpus_names, str): + corpus_names = [corpus_names] + assert isinstance(corpus_names, list) + + for corpus_name in corpus_names: + test_datasets = get_test_dataset_tuples(bpe_size=BPE_1K) + stm = CorpusToStmJob(bliss_corpus=test_datasets[corpus_name][2]).out_stm_path + tk.register_output(f"concat_seqs/{num}/orig_{corpus_name}_stm", stm) + concat_dataset_seqs = ConcatDatasetSeqsJob( + corpus_name="TED-LIUM-realease2", stm=stm, num=num, overlap_dur=None + ) + tk.register_output(f"concat_seqs/{num}/{corpus_name}_stm", concat_dataset_seqs.out_stm) + tk.register_output(f"concat_seqs/{num}/{corpus_name}_tags", concat_dataset_seqs.out_concat_seq_tags) + tk.register_output(f"concat_seqs/{num}/{corpus_name}_lens", concat_dataset_seqs.out_concat_seq_lens_py) + + returnn_search_config = create_config( + training_datasets=train_data, + **search_args, + feature_extraction_net=log10_net_10ms, + is_recog=True, + ) + + returnn_concat_dataset = ConcatSeqsDataset( + dataset=test_datasets[corpus_name][0].as_returnn_opts(), + seq_tags=concat_dataset_seqs.out_concat_seq_tags, + seq_lens_py=concat_dataset_seqs.out_orig_seq_lens_py, + ) + + _, search_words = search_single( + os.path.join(exp_prefix, corpus_name), + returnn_search_config, + checkpoint, + recognition_dataset=returnn_concat_dataset, + recognition_reference=test_datasets[corpus_name][1], + recognition_bliss_corpus=test_datasets[corpus_name][2], + returnn_exe=RETURNN_CPU_EXE, + returnn_root=RETURNN_ROOT, + mem_rqmt=mem_rqmt, + time_rqmt=time_rqmt, + # no scoring + use_sclite=False, + use_returnn_compute_wer=False, + ) + + from i6_core.corpus.convert import CorpusToStmJob + from i6_core.recognition.scoring import ScliteJob + + stm_file = concat_dataset_seqs.out_stm + + concat_ctm_and_stm_job = CreateConcatSeqsCTMAndSTMJob( + recog_words_file=search_words, stm_py_file=concat_dataset_seqs.out_stm_py, stm_file=stm_file + ) + tk.register_output(exp_prefix + f"/{corpus_name}/sclite/stm", concat_ctm_and_stm_job.out_stm_file) + tk.register_output(exp_prefix + f"/{corpus_name}/sclite/ctm", concat_ctm_and_stm_job.out_ctm_file) + + sclite_job = ScliteJob( + ref=concat_ctm_and_stm_job.out_stm_file, + hyp=concat_ctm_and_stm_job.out_ctm_file, + sctk_binary_path=SCTK_BINARY_PATH, + ) + tk.register_output(exp_prefix + f"/{corpus_name}/sclite/wer", sclite_job.out_wer) + tk.register_output(exp_prefix + f"/{corpus_name}/sclite/report", sclite_job.out_report_dir) + + def run_exp( + exp_name, + train_args, + feature_extraction_net=log10_net_10ms, + num_epochs=300, + search_args=None, + recog_epochs=None, + bpe_size=1000, + partition_epoch=4, + **kwargs, + ): + if train_args.get("retrain_checkpoint", None): + assert kwargs.get("epoch_wise_filter", None) is None, "epoch_wise_filter should be disabled for retraining." + train_data = build_training_datasets( + bpe_size=bpe_size, + use_raw_features=True, + epoch_wise_filter=kwargs.get("epoch_wise_filter", [(1, 5, 1000)]), + link_speed_perturbation=train_args.get("speed_pert", True), + seq_ordering=kwargs.get("seq_ordering", "laplace:.1000"), + partition_epoch=partition_epoch, + devtrain_subset=kwargs.get("devtrain_subset", 507), # same as num of dev segments + ) + train_job = run_train( + exp_name, + train_args, + train_data, + feature_extraction_net, + num_epochs, + recog_epochs, + **kwargs, + ) + train_jobs_map[exp_name] = train_job + + run_search( + exp_name, + train_args, + train_data, + train_job, + feature_extraction_net, + num_epochs, + search_args, + recog_epochs, + bpe_size=bpe_size, + **kwargs, + ) + + if kwargs.get("concat_recog_opts", None): + ckpt_ = kwargs["concat_recog_opts"]["checkpoint"] + if isinstance(ckpt_, str): + assert ckpt_ in ["best", "avg"] + if ckpt_ == "best": + concat_recog_ckpt = train_job_best_epoch[exp_name] + else: + concat_recog_ckpt = train_job_avg_ckpt[exp_name] + elif isinstance(ckpt_, int): + concat_recog_ckpt = train_job.out_checkpoints[ckpt_] + else: + raise TypeError(f"concat_recog_opts['checkpoint'] must be str or int, got {type(ckpt_)}") + concat_recog_search_args = kwargs["concat_recog_opts"].get("search_args", None) + search_args_ = copy.deepcopy(train_args) + if concat_recog_search_args: + search_args_.update(concat_recog_search_args) + run_concat_seq_recog( + exp_name=exp_name + f"_concat{kwargs['concat_recog_opts']['num']}", + corpus_names=kwargs["concat_recog_opts"]["corpus_names"], + num=kwargs["concat_recog_opts"]["num"], + train_data=train_data, + search_args=search_args_, + checkpoint=concat_recog_ckpt, + ) + + return train_job, train_data + + def train_mini_lstm( + exp_name, + checkpoint, + args, + epoch_split, + num_epochs=20, + lr=8e-4, + time_rqmt=4, + l2=1e-4, + name="mini_lstm", + w_drop=False, + use_dec_state=False, + use_ffn=False, + ffn_opts=None, + **kwargs, + ): + if not w_drop: + params_freeze_str = ilm_helpers.get_mini_lstm_params_freeze_str() + else: + if use_ffn: + params_freeze_str = ilm_helpers.get_ffn_params_freeze_str_w_drop(ffn_opts["num_ffn_layers"]) + else: + params_freeze_str = ilm_helpers.get_mini_lstm_params_freeze_str_w_drop() + + mini_lstm_args = copy.deepcopy(args) + mini_lstm_args["epoch_split"] = epoch_split + mini_lstm_args["batch_size"] = 20000 * 160 + mini_lstm_args["with_pretrain"] = False + mini_lstm_args["lr"] = lr + mini_lstm_args["learning_rates_list"] = None + mini_lstm_args["allow_lr_scheduling"] = False + mini_lstm_args["encoder_args"].with_ctc = False + mini_lstm_args["keep_all_epochs"] = True # keep everything + mini_lstm_args["extra_str"] = params_freeze_str + mini_lstm_args["preload_from_files"] = { + "import": { + "init_for_train": True, + "ignore_missing": True, + "filename": checkpoint, + } + } + mini_lstm_args.update(kwargs) + + exp_prefix = os.path.join(prefix_name, exp_name, name) + mini_lstm_train_data = build_training_datasets( + bpe_size=BPE_1K, + use_raw_features=True, + epoch_wise_filter=None, + link_speed_perturbation=False, # depends only on text + seq_ordering=kwargs.get("seq_ordering", "laplace:.1000"), + ) + returnn_config = create_config( + training_datasets=mini_lstm_train_data, + **mini_lstm_args, + feature_extraction_net=log10_net_10ms, + ) + + inp = "s" if use_dec_state else "prev:target_embed" + + if use_ffn: + x = inp + activations = ffn_opts["activations"] + for l in range(ffn_opts["num_ffn_layers"]): + returnn_config.config["network"]["output"]["unit"]["ffn_%02i" % (l + 1)] = { + "class": "linear", + "n_out": ffn_opts["ffn_dims"][l], + "L2": l2, + "from": inp, + "activation": activations[l] if activations and l < len(activations) else None, + } + x = "ffn_%02i" % (l + 1) + + returnn_config.config["network"]["output"]["unit"]["att"] = { + "class": "linear", + "from": x, + "activation": None, + "n_out": mini_lstm_args["encoder_args"].enc_key_dim, + "L2": l2, + } + else: + # Mini-LSTM + FF + + returnn_config.config["network"]["output"]["unit"]["att_lstm"] = { + "class": "rec", + "unit": "nativelstm2", + "from": inp, + "n_out": 50, + } + + returnn_config.config["network"]["output"]["unit"]["att"] = { + "class": "linear", + "from": "att_lstm", + "activation": None, + "n_out": mini_lstm_args["encoder_args"].enc_key_dim, + "L2": l2, + } + + train_job = training( + exp_prefix, + returnn_config, + RETURNN_CPU_EXE, + RETURNN_ROOT, + num_epochs=num_epochs, + time_rqmt=time_rqmt, + ) + return train_job + + def train_mini_self_att( + exp_name, + checkpoint, + args, + num_epochs=20, + lr=8e-4, + time_rqmt=4, + name="mini_self_att", + **kwargs, + ): + """ + Same idea as Mini-LSTM but use masked (mini-)self-attention models instead of cross attention. + Note that each layer has its own (mini-)self-attention. + + In the case of transformer decoder, we want to replace cross-attention layers namely: + transformer_decoder_{idx}_att_linear + with masked self-attention models. + """ + + params_freeze_str = ilm_helpers.get_mini_self_att_params_freeze_str_w_drop(args["decoder_args"].num_layers) + + mini_self_att = copy.deepcopy(args) + mini_self_att["batch_size"] = 20000 * 160 # TODO: does this fit now? + mini_self_att["with_pretrain"] = False + mini_self_att["lr"] = lr + mini_self_att["allow_lr_scheduling"] = False + mini_self_att["encoder_args"].with_ctc = False + # mini_self_att['keep_all_epochs'] = True # keep everything + mini_self_att["extra_str"] = params_freeze_str + mini_self_att["preload_from_files"] = { + "import": { + "init_for_train": True, + "ignore_missing": True, + "filename": checkpoint, + } + } + if "decoder_args" in kwargs: + assert isinstance(kwargs["decoder_args"], dict) + for k, v in kwargs["decoder_args"].items(): + setattr(mini_self_att["decoder_args"], k, v) + kwargs.pop("decoder_args") + mini_self_att.update(kwargs) + + exp_prefix = os.path.join(prefix_name, exp_name, name) + mini_self_att_train_data = build_training_datasets( + bpe_size=10000, + use_raw_features=True, + epoch_wise_filter=None, + link_speed_perturbation=False, # depends only on text + seq_ordering=kwargs.get("seq_ordering", "laplace:.1000"), + ) + + # use masked self-att instead of cross-att with layer names having "ilm_" as prefix + mini_self_att["decoder_args"].replace_cross_att_w_masked_self_att = True + + returnn_config = create_config( + training_datasets=mini_self_att_train_data, + **mini_self_att, + feature_extraction_net=log10_net_10ms, + ) + train_job = training( + exp_prefix, + returnn_config, + RETURNN_CPU_EXE, + RETURNN_ROOT, + num_epochs=num_epochs, + time_rqmt=time_rqmt, + ) + return train_job + + # --------------------------- General Settings --------------------------- # + + ebranch_enc_args = EBranchformerEncoderArgs( + num_blocks=12, + input_layer="conv-6", + att_num_heads=6, + ff_dim=1536, + enc_key_dim=384, + conv_kernel_size=31, + pos_enc="rel", + dropout=0.1, + att_dropout=0.1, + l2=0.0001, + ) + apply_fairseq_init_to_conformer(ebranch_enc_args) + ebranch_enc_args.ctc_loss_scale = 1.0 + + rnn_dec_args = RNNDecoderArgs() + + trafo_dec_args = TransformerDecoderArgs( + num_layers=6, + embed_dropout=0.1, + label_smoothing=0.1, + apply_embed_weight=True, + pos_enc="rel", + ) + apply_fairseq_init_to_transformer_decoder(trafo_dec_args) + + training_args = dict() + training_args["with_staged_network"] = True + training_args["speed_pert"] = True + + trafo_training_args = copy.deepcopy(training_args) + trafo_training_args["pretrain_opts"] = { + "variant": 3, + "initial_batch_size": 20000 * 160, + } + trafo_training_args["pretrain_reps"] = 5 + trafo_training_args["batch_size"] = 12000 * 160 # frames * samples per frame + + trafo_dec_exp_args = copy.deepcopy( + { + **trafo_training_args, + "encoder_args": ebranch_enc_args, + "decoder_args": trafo_dec_args, + } + ) + + lstm_training_args = copy.deepcopy(training_args) + lstm_training_args["pretrain_opts"] = { + "variant": 3, + "initial_batch_size": 22500 * 160, + } + lstm_training_args["pretrain_reps"] = 5 + lstm_training_args["batch_size"] = 15000 * 160 # frames * samples per frame + + lstm_dec_exp_args = copy.deepcopy( + { + **lstm_training_args, + "encoder_args": ebranch_enc_args, + "decoder_args": rnn_dec_args, + } + ) + + # --------------------------- Experiments --------------------------- # + + oclr_args = copy.deepcopy(lstm_dec_exp_args) + oclr_args["oclr_opts"] = { + "peak_lr": 9e-4, + "final_lr": 1e-6, + } + oclr_args["encoder_args"].input_layer = "conv-6" + oclr_args["encoder_args"].use_sqrd_relu = True + oclr_args["max_seq_length"] = None + + _, _, global_mean, global_std = compute_features_stats(output_dirname="logmel_80", feat_dim=80) + + # --------------------- V1 --------------------- + def get_base_v1_args(lr, ep, enc_drop=0.1, pretrain_reps=3, use_legacy_stats=True): + # base_bpe1000_peakLR0.0008_ep200_globalNorm_epochOCLR_pre3_fixZoneout_encDrop0.1_woDepthConvPre + # Average ckpt: 8.19/7.64 (50 epochs) + # - Epoch-based OCLR with peak LR 8e-4 + # - EncDrop 0.1, fixed zoneout + # - Pretrain 3, no depthwise conv pretrain + # - Feature global normalization + + base_v1_args = copy.deepcopy(oclr_args) + base_v1_args.pop("oclr_opts") + cyc_ep = int(0.45 * ep) + # Epoch-based OCLR + base_v1_args["learning_rates_list"] = ( + list(numpy.linspace(lr / 10, lr, cyc_ep)) + + list(numpy.linspace(lr, lr / 10, cyc_ep)) + + list(numpy.linspace(lr / 10, 1e-6, ep - 2 * cyc_ep)) + ) + base_v1_args["global_stats"] = { + "mean": global_mean, + "stddev": global_std, + "use_legacy_version": use_legacy_stats, + } + base_v1_args["pretrain_reps"] = pretrain_reps + base_v1_args["pretrain_opts"]["ignored_keys_for_reduce_dim"] = ["conv_kernel_size"] + base_v1_args["encoder_args"].dropout = enc_drop + base_v1_args["encoder_args"].dropout_in = enc_drop + base_v1_args["encoder_args"].att_dropout = enc_drop + base_v1_args["decoder_args"].use_zoneout_output = True + exp_name = f"ebranch_bpe1000_peakLR{lr}_ep{ep}_globalNorm_epochOCLR_pre{pretrain_reps}_fixZoneout_encDrop{enc_drop}_woDepthConvPre" + return base_v1_args, exp_name + + # base_bpe1000_peakLR0.0008_ep400_globalNorm_epochOCLR_pre3_fixZoneout_encDrop0.15_woDepthConvPre_weightDrop0.1_decAttDrop0.0_embedDim256_numBlocks12 + # 7.4 6.85 avg + # base_bpe1000_peakLR0.0008_ep200_globalNorm_epochOCLR_pre3_fixZoneout_encDrop0.1_woDepthConvPre + # 8.19 7.64 avg + # base_bpe1000_peakLR0.0008_ep200_globalNorm_epochOCLR_pre3_fixZoneout_encDrop0.15_woDepthConvPre_weightDrop0.1_decAttDrop0.0_embedDim256_numBlocks12_ctcScale0.3 + # 8.11 7.52 best + + for num_blocks in [12]: + for ep in [50 * 4]: + for lr in [8e-4]: + for target_embed_dim in [256]: + for dec_att_drop in [0.0]: + for weight_drop in [0.1]: + for enc_drop in [0.15]: + for ctc_scale in [1.0, 0.3]: + base_v1_args, exp_name = get_base_v1_args( + lr, ep, enc_drop=enc_drop, use_legacy_stats=False + ) + args = copy.deepcopy(base_v1_args) + + args["encoder_args"].num_blocks = num_blocks + + args["encoder_args"].frontend_conv_weight_dropout = weight_drop + args["encoder_args"].mhsa_weight_dropout = weight_drop + args["encoder_args"].ff_weight_dropout = weight_drop + args["encoder_args"].conv_weight_dropout = weight_drop + + args["decoder_args"].embed_dim = target_embed_dim + args["decoder_args"].att_dropout = dec_att_drop + + exp_name += f"_weightDrop{weight_drop}_decAttDrop{dec_att_drop}_embedDim{target_embed_dim}_numBlocks{num_blocks}" + + if ctc_scale != 1.0: + args["encoder_args"].ctc_loss_scale = ctc_scale + args["decoder_args"].ce_loss_scale = 1.0 - ctc_scale + exp_name += f"_ctcScale{ctc_scale}" + + run_exp( + exp_name, + args, + num_epochs=ep, + epoch_wise_filter=None, + bpe_size=BPE_1K, + partition_epoch=4, + ) + + +def py(): + conformer_baseline() diff --git a/users/zeineldeen/experiments/conformer_att_2023/tedlium2/configs/ted2_att_baseline.py b/users/zeineldeen/experiments/conformer_att_2023/tedlium2/configs/ted2_att_baseline.py index dfbed77d8..b9e6e4dde 100644 --- a/users/zeineldeen/experiments/conformer_att_2023/tedlium2/configs/ted2_att_baseline.py +++ b/users/zeineldeen/experiments/conformer_att_2023/tedlium2/configs/ted2_att_baseline.py @@ -1266,53 +1266,53 @@ def get_base_v1_args(lr, ep, enc_drop=0.1, pretrain_reps=3, use_legacy_stats=Tru partition_epoch=4, ) - # TODO: mixup - for num_blocks in [12]: - for ep in [50 * 4]: - for lr in [8e-4]: - for target_embed_dim in [256]: - for att_drop in [0.0]: - for weight_drop in [0.1]: - for enc_drop in [0.15]: - for ctc_scale in [0.3]: - for mixup_apply_prob in [0.2, 0.3, 0.4]: - base_v1_args, exp_name = get_base_v1_args( - lr, ep, enc_drop=enc_drop, use_legacy_stats=False - ) - - args = copy.deepcopy(base_v1_args) - args["encoder_args"].num_blocks = num_blocks - args["encoder_args"].mhsa_weight_dropout = weight_drop - args["encoder_args"].ff_weight_dropout = weight_drop - args["encoder_args"].conv_weight_dropout = weight_drop - - args["decoder_args"].embed_dim = target_embed_dim - args["decoder_args"].att_dropout = att_drop - - exp_name += f"_weightDrop{weight_drop}_decAttDrop{att_drop}_embedDim{target_embed_dim}_numBlocks{num_blocks}" - - args["mixup_aug_opts"] = { - "use_log10_features": True, - "buffer_size": 1_000_000, - "apply_prob": mixup_apply_prob, - "max_num_mix": 4, - "lambda_min": 0.15, - "lambda_max": 0.3, - } - exp_name += f"_mixup_{mixup_apply_prob}_4_0.15_0.3" - - if ctc_scale != 1.0: - args["encoder_args"].ctc_loss_scale = ctc_scale - args["decoder_args"].ce_loss_scale = 1.0 - ctc_scale - exp_name += f"_ctcScale{ctc_scale}" - - run_exp( - exp_name, - args, - num_epochs=ep, - epoch_wise_filter=None, - bpe_size=BPE_1K, - partition_epoch=4, - ) + # TODO: ebranchformer encoder - # TODO: smaller models + # # TODO: mixup + # for num_blocks in [12]: + # for ep in [50 * 4]: + # for lr in [8e-4]: + # for target_embed_dim in [256]: + # for att_drop in [0.0]: + # for weight_drop in [0.1]: + # for enc_drop in [0.15]: + # for ctc_scale in [0.3]: + # for mixup_apply_prob in [0.2, 0.3, 0.4]: + # base_v1_args, exp_name = get_base_v1_args( + # lr, ep, enc_drop=enc_drop, use_legacy_stats=False + # ) + # + # args = copy.deepcopy(base_v1_args) + # args["encoder_args"].num_blocks = num_blocks + # args["encoder_args"].mhsa_weight_dropout = weight_drop + # args["encoder_args"].ff_weight_dropout = weight_drop + # args["encoder_args"].conv_weight_dropout = weight_drop + # + # args["decoder_args"].embed_dim = target_embed_dim + # args["decoder_args"].att_dropout = att_drop + # + # exp_name += f"_weightDrop{weight_drop}_decAttDrop{att_drop}_embedDim{target_embed_dim}_numBlocks{num_blocks}" + # + # args["mixup_aug_opts"] = { + # "use_log10_features": True, + # "buffer_size": 1_000_000, + # "apply_prob": mixup_apply_prob, + # "max_num_mix": 4, + # "lambda_min": 0.15, + # "lambda_max": 0.3, + # } + # exp_name += f"_mixup_{mixup_apply_prob}_4_0.15_0.3" + # + # if ctc_scale != 1.0: + # args["encoder_args"].ctc_loss_scale = ctc_scale + # args["decoder_args"].ce_loss_scale = 1.0 - ctc_scale + # exp_name += f"_ctcScale{ctc_scale}" + # + # run_exp( + # exp_name, + # args, + # num_epochs=ep, + # epoch_wise_filter=None, + # bpe_size=BPE_1K, + # partition_epoch=4, + # ) diff --git a/users/zeineldeen/models/asr/decoder/args.py b/users/zeineldeen/models/asr/decoder/args.py new file mode 100644 index 000000000..fb7cf2592 --- /dev/null +++ b/users/zeineldeen/models/asr/decoder/args.py @@ -0,0 +1,137 @@ +from dataclasses import dataclass +from typing import Optional + + +class DecoderArgs: + pass + + +@dataclass +class TransformerDecoderArgs(DecoderArgs): + num_layers: int = 6 + att_num_heads: int = 8 + ff_dim: int = 2048 + ff_act: str = "relu" + pos_enc: Optional[str] = None + embed_pos_enc: bool = False + + # param init + ff_init: Optional[str] = None + mhsa_init: Optional[str] = None + mhsa_out_init: Optional[str] = None + + # dropout + dropout: float = 0.1 + att_dropout: float = 0.1 + embed_dropout: float = 0.1 + softmax_dropout: float = 0.0 + + ff_weight_noise: Optional[float] = None + mhsa_weight_noise: Optional[float] = None + ff_weight_dropout: Optional[float] = None + mhsa_weight_dropout: Optional[float] = None + + # other regularization + l2: float = 0.0 + self_att_l2: float = 0.0 + rel_pos_clipping: int = 16 + label_smoothing: float = 0.1 + apply_embed_weight: bool = False + + length_normalization: bool = True + + # ILM + replace_cross_att_w_masked_self_att: bool = False + create_ilm_decoder: bool = False + ilm_type: bool = None + ilm_args: Optional[dict] = None + + +@dataclass +class ConformerDecoderArgs(DecoderArgs): + num_layers: int = 6 + att_num_heads: int = 8 + ff_dim: int = 2048 + pos_enc: Optional[str] = "rel" + + # conv module + conv_kernel_size: int = 32 + + # param init + ff_init: Optional[str] = None + mhsa_init: Optional[str] = None + mhsa_out_init: Optional[str] = None + conv_module_init: Optional[str] = None + + # dropout + dropout: float = 0.1 + att_dropout: float = 0.1 + embed_dropout: float = 0.1 + softmax_dropout: float = 0.1 + + # other regularization + l2: float = 0.0001 + frontend_conv_l2: float = 0.0001 + rel_pos_clipping: int = 16 + label_smoothing: float = 0.1 + apply_embed_weight: bool = False + + length_normalization: bool = True + + use_sqrd_relu: bool = False + + # ILM + replace_cross_att_w_masked_self_att: bool = False + create_ilm_decoder: bool = False + ilm_type: bool = None + ilm_args: Optional[dict] = None + + +@dataclass +class RNNDecoderArgs(DecoderArgs): + att_num_heads: int = 1 + lstm_num_units: int = 1024 + output_num_units: int = 1024 + embed_dim: int = 640 + enc_key_dim: int = 1024 # also attention dim # also attention dim + + # location feedback + loc_conv_att_filter_size: Optional[int] = None + + # param init + lstm_weights_init: Optional[str] = None + embed_weight_init: Optional[str] = None + + # dropout + dropout: float = 0.0 + softmax_dropout: float = 0.3 + att_dropout: float = 0.0 + embed_dropout: float = 0.1 + rec_weight_dropout: float = 0.0 + + # other regularization + l2: float = 0.0001 + zoneout: bool = True + reduceout: bool = True + + # lstm lm + lstm_lm_dim: int = 1024 + add_lstm_lm: bool = False + + length_normalization: bool = True + length_normalization_exponent: float = 1.0 + + coverage_scale: float = None + coverage_threshold: float = None + coverage_update: str = "sum" + + ce_loss_scale: Optional[float] = 1.0 + + label_smoothing: float = 0.1 + + use_zoneout_output: bool = False + + monotonic_att_weights_loss_opts: Optional[dict] = None + use_monotonic_att_weights_loss_in_recog: Optional[bool] = False + + include_eos_in_search_output: bool = False diff --git a/users/zeineldeen/models/asr/encoder/args.py b/users/zeineldeen/models/asr/encoder/args.py new file mode 100644 index 000000000..56353430f --- /dev/null +++ b/users/zeineldeen/models/asr/encoder/args.py @@ -0,0 +1,87 @@ +from dataclasses import dataclass +from typing import Any, Dict, List, Optional + + +class EncoderArgs: + pass + + +@dataclass +class ConformerEncoderCommonArgs(EncoderArgs): + num_blocks: int = 12 + enc_key_dim: int = 512 + att_num_heads: int = 8 + ff_dim: int = 2048 + conv_kernel_size: int = 32 + input: str = "data" + input_layer: str = "lstm-6" + input_layer_conv_act: str = "relu" + add_abs_pos_enc_to_input: bool = False + pos_enc: str = "rel" + + sandwich_conv: bool = False + subsample: Optional[str] = None + use_causal_layers: bool = False + + # ctc + with_ctc: bool = True + native_ctc: bool = True + ctc_loss_scale: Optional[float] = None + ctc_self_align_delay: Optional[int] = None + ctc_self_align_scale: float = 0.5 + ctc_dropout: float = 0.0 + + # param init + ff_init: Optional[str] = None + mhsa_init: Optional[str] = None + mhsa_out_init: Optional[str] = None + conv_module_init: Optional[str] = None + start_conv_init: Optional[str] = None + + # dropout + dropout: float = 0.1 + dropout_in: float = 0.1 + att_dropout: float = 0.1 + lstm_dropout: float = 0.1 + + # weight dropout + ff_weight_dropout: Optional[float] = None + mhsa_weight_dropout: Optional[float] = None + conv_weight_dropout: Optional[float] = None + + # norms + batch_norm_opts: Optional[Dict[str, Any]] = None + use_ln: bool = False + + # other regularization + l2: float = 0.0001 + frontend_conv_l2: float = 0.0001 + self_att_l2: float = 0.0 + rel_pos_clipping: int = 16 + + use_sqrd_relu: bool = False + + convolution_first: bool = False + + +@dataclass +class ConformerEncoderArgs(ConformerEncoderCommonArgs): + weight_noise: Optional[float] = None + weight_noise_layers: Optional[List[str]] = None + + +@dataclass +class ConformerEncoderV2Args(ConformerEncoderCommonArgs): + # weight noise + ff_weight_noise: Optional[float] = None + mhsa_weight_noise: Optional[float] = None + conv_weight_noise: Optional[float] = None + frontend_conv_weight_noise: Optional[float] = None + + # weight dropout + frontend_conv_weight_dropout: Optional[float] = None + + +@dataclass +class EBranchformerEncoderArgs(ConformerEncoderV2Args): + pass diff --git a/users/zeineldeen/models/asr/encoder/ebranchformer_encoder.py b/users/zeineldeen/models/asr/encoder/ebranchformer_encoder.py index b513e5af6..6d6fda018 100644 --- a/users/zeineldeen/models/asr/encoder/ebranchformer_encoder.py +++ b/users/zeineldeen/models/asr/encoder/ebranchformer_encoder.py @@ -7,18 +7,15 @@ class EBranchformerEncoder(ConformerEncoderV2): * Ref: https://arxiv.org/pdf/2210.00077.pdf """ - def __init__(self, cgmlp_ff_dim, **kwargs): + def __init__(self, **kwargs): super().__init__(**kwargs) - assert cgmlp_ff_dim % 2 == 0, "cgmlp_dim must be even" - self.cgmlp_ff_dim = cgmlp_ff_dim - def _create_conv_spatial_gating_unit(self, prefix_name, source, layer_index): # Half split input into [A,B] -> A * DwConv(LN(B)) -> dropout # # see also here: https://github.com/espnet/espnet/blob/master/espnet2/asr/layers/cgmlp.py#L15 - split_size = self.cgmlp_ff_dim // 2 + split_size = self.enc_key_dim * 3 branch_a = self.network.add_slice_layer( "{}_branch_a".format(prefix_name), source, "F", slice_start=0, slice_end=split_size @@ -58,7 +55,7 @@ def _create_conv_gating_mlp(self, prefix_name, source, layer_index): ff1 = self.network.add_linear_layer( "{}_ff_1".format(prefix_name), ln, - n_out=self.cgmlp_ff_dim, + n_out=6 * self.enc_key_dim, l2=self.l2, forward_weights_init=self.ff_init, with_bias=False, From 502c327303e96bc408917cb8208c3a422c6c30f9 Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Tue, 21 May 2024 23:33:42 +0200 Subject: [PATCH 043/227] more --- .../exp2024_04_23_baselines/ctc.py | 53 +++++++++++++------ 1 file changed, 38 insertions(+), 15 deletions(-) diff --git a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py index 25943285b..480eefcd1 100644 --- a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py +++ b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py @@ -34,10 +34,10 @@ def py(): "spm20k", "bpe10k", # 8.23 "spm10k", # 8.12 - "spm_bpe10k", - "spm4k", + "spm_bpe10k", # 7.97 + "spm4k", # 9.86 "spm1k", - "spm_bpe1k", + "spm_bpe1k", # 11.76 ]: train_exp( # 8.23 f"v6-bhv20-11gb-f32-bs15k-accgrad1-mgpu4-pavg100-wd1e_2-lrlin1e_5_295k-speedpertV2-{vocab}", @@ -51,18 +51,41 @@ def py(): vocab=vocab, ) - train_exp( - "v6-bhv20-11gb-f32-bs15k-accgrad1-mgpu4-pavg100-wd1e_2-lrlin1e_5_295k-speedpertV2-spm10k-spmSample03", - config_11gb_v6_f32_accgrad1_mgpu4_pavg100_wd1e_4, - config_updates={ - **_get_cfg_lrlin_oclr_by_bs_nep(15_000, 500), - "optimizer.weight_decay": 1e-2, - "__train_audio_preprocess": speed_pert_librosa_config, - "speed_pert_discrete_values": [0.7, 0.8, 0.9, 1.0, 1.1], - }, - vocab="spm10k", - train_vocab_opts={"other_opts": {"enable_sampling": True, "alpha": 0.3}}, - ) + for alpha in [ + 0.3, # 7.88 + 0.5, + 0.7, + ]: + train_exp( + "v6-bhv20-11gb-f32-bs15k-accgrad1-mgpu4-pavg100-wd1e_2-lrlin1e_5_295k-speedpertV2-spm10k" + f"-spmSample{str(alpha).replace('.', '')}", + config_11gb_v6_f32_accgrad1_mgpu4_pavg100_wd1e_4, + config_updates={ + **_get_cfg_lrlin_oclr_by_bs_nep(15_000, 500), + "optimizer.weight_decay": 1e-2, + "__train_audio_preprocess": speed_pert_librosa_config, + "speed_pert_discrete_values": [0.7, 0.8, 0.9, 1.0, 1.1], + }, + vocab="spm10k", + train_vocab_opts={"other_opts": {"enable_sampling": True, "alpha": alpha}}, + ) + + for alpha in [ + 0.3, + ]: + train_exp( + "v6-bhv20-11gb-f32-bs15k-accgrad1-mgpu4-pavg100-wd1e_2-lrlin1e_5_295k-speedpertV2-spm_bpe10k" + f"-spmSample{str(alpha).replace('.', '')}", + config_11gb_v6_f32_accgrad1_mgpu4_pavg100_wd1e_4, + config_updates={ + **_get_cfg_lrlin_oclr_by_bs_nep(15_000, 500), + "optimizer.weight_decay": 1e-2, + "__train_audio_preprocess": speed_pert_librosa_config, + "speed_pert_discrete_values": [0.7, 0.8, 0.9, 1.0, 1.1], + }, + vocab="spm_bpe10k", + train_vocab_opts={"other_opts": {"enable_sampling": True, "alpha": alpha}}, + ) # noinspection PyShadowingNames From 7a7e810af1a4bd0c4c0d2b8c0b69fe01f3e14db2 Mon Sep 17 00:00:00 2001 From: Simon Berger Date: Wed, 22 May 2024 13:12:06 +0200 Subject: [PATCH 044/227] Update users/berger --- .../config_01a_ctc_blstm_raw_samples.py | 4 +- .../config_01c_ctc_conformer_raw_samples.py | 4 +- .../config_01d_ctc_conformer_rasr_features.py | 2 + .../config_02b_transducer_rasr_features.py | 41 +- ..._02f_transducer_rasr_features_am_scales.py | 445 ++++++++++++++++++ ...ig_03b_transducer_fullsum_rasr_features.py | 32 +- .../librispeech/viterbi_transducer_data.py | 2 +- users/berger/settings.py | 10 +- users/berger/systems/functors/seq2seq_base.py | 1 + 9 files changed, 528 insertions(+), 13 deletions(-) create mode 100644 users/berger/configs/librispeech/20230210_baselines/config_02f_transducer_rasr_features_am_scales.py diff --git a/users/berger/configs/librispeech/20230210_baselines/config_01a_ctc_blstm_raw_samples.py b/users/berger/configs/librispeech/20230210_baselines/config_01a_ctc_blstm_raw_samples.py index 5ed506441..471df20c7 100644 --- a/users/berger/configs/librispeech/20230210_baselines/config_01a_ctc_blstm_raw_samples.py +++ b/users/berger/configs/librispeech/20230210_baselines/config_01a_ctc_blstm_raw_samples.py @@ -138,8 +138,8 @@ def run_exp() -> Tuple[SummaryReport, Checkpoint, Dict[str, AlignmentData]]: ) recog_args = exp_args.get_ctc_recog_step_args(num_classes) - align_args = exp_args.get_ctc_align_step_args(num_classes) - recog_args["epochs"] = [320, 400, 480, 500, "best"] + align_args = exp_args.get_ctc_align_step_args(num_classes, epoch=500) + recog_args["epochs"] = [320, 500, "best"] recog_args["prior_scales"] = [0.3] recog_args["lm_scales"] = [0.9] diff --git a/users/berger/configs/librispeech/20230210_baselines/config_01c_ctc_conformer_raw_samples.py b/users/berger/configs/librispeech/20230210_baselines/config_01c_ctc_conformer_raw_samples.py index 64f90fd07..2c3536d75 100644 --- a/users/berger/configs/librispeech/20230210_baselines/config_01c_ctc_conformer_raw_samples.py +++ b/users/berger/configs/librispeech/20230210_baselines/config_01c_ctc_conformer_raw_samples.py @@ -142,8 +142,8 @@ def run_exp() -> Tuple[SummaryReport, Checkpoint, Dict[str, AlignmentData]]: ) recog_args = exp_args.get_ctc_recog_step_args(num_classes) - align_args = exp_args.get_ctc_align_step_args(num_classes) - recog_args["epochs"] = [320, 400, 480, 500, "best"] + align_args = exp_args.get_ctc_align_step_args(num_classes, epoch=500) + recog_args["epochs"] = [320, 500, "best"] recog_args["prior_scales"] = [0.3] recog_args["lm_scales"] = [0.9] diff --git a/users/berger/configs/librispeech/20230210_baselines/config_01d_ctc_conformer_rasr_features.py b/users/berger/configs/librispeech/20230210_baselines/config_01d_ctc_conformer_rasr_features.py index 133e125d7..9d08d868d 100644 --- a/users/berger/configs/librispeech/20230210_baselines/config_01d_ctc_conformer_rasr_features.py +++ b/users/berger/configs/librispeech/20230210_baselines/config_01d_ctc_conformer_rasr_features.py @@ -133,6 +133,7 @@ def run_exp() -> Tuple[SummaryReport, Checkpoint, Dict[str, AlignmentData]]: recog_args["feature_type"] = FeatureType.GAMMATONE_16K recog_args["prior_scales"] = [0.3] recog_args["lm_scales"] = [0.9] + recog_args["search_stats"] = True align_args["feature_type"] = FeatureType.GAMMATONE_16K # ********** System ********** @@ -146,6 +147,7 @@ def run_exp() -> Tuple[SummaryReport, Checkpoint, Dict[str, AlignmentData]]: SummaryKey.PRIOR, SummaryKey.LM, SummaryKey.WER, + SummaryKey.RTF, SummaryKey.SUB, SummaryKey.INS, SummaryKey.DEL, diff --git a/users/berger/configs/librispeech/20230210_baselines/config_02b_transducer_rasr_features.py b/users/berger/configs/librispeech/20230210_baselines/config_02b_transducer_rasr_features.py index bdddbde1e..f6deeff86 100644 --- a/users/berger/configs/librispeech/20230210_baselines/config_02b_transducer_rasr_features.py +++ b/users/berger/configs/librispeech/20230210_baselines/config_02b_transducer_rasr_features.py @@ -319,17 +319,19 @@ def run_exp( dev_data_config=data.cv_data_config, label_smoothing=None, loss_boost_v2=False, - loss_boost_scale=5.0, + loss_boost_scale=0.0, + specaug_v2=True, peak_lr=8e-04, model_preload=None, ), recog_configs={ - "recog_ilm": generate_returnn_config( + f"recog_ilm-{ilm_scale}": generate_returnn_config( train=False, train_data_config=data.train_data_config, dev_data_config=data.cv_data_config, - ilm_scale=0.2, + ilm_scale=ilm_scale, ) + for ilm_scale in [0.1, 0.2, 0.3] }, ), ) @@ -339,6 +341,39 @@ def run_exp( system.run_dev_recog_step(**recog_args) system.run_test_recog_step(**recog_args) + if "blstm" in name_suffix: + recog_args.update( + { + "epochs": [ + 245, + 294, + 320, + 321, + 323, + 369, + 376, + 381, + 382, + 384, + 385, + 386, + 387, + 393, + 394, + 395, + 397, + 399, + 400, + ], + "lm_scales": [0.4, 0.5, 0.6, 0.7, 0.8, 0.9], + } + ) + system.run_recog_step_for_corpora( + exp_names=[f"Conformer_Transducer_Viterbi_specaug-v2_{name_suffix}"], + corpora=["dev-other_4gram"], + **recog_args, + ) + train_job = system.get_train_job(f"Conformer_Transducer_Viterbi_lr-0.0008_{name_suffix}") model = train_job.out_checkpoints[400] assert isinstance(model, Checkpoint) diff --git a/users/berger/configs/librispeech/20230210_baselines/config_02f_transducer_rasr_features_am_scales.py b/users/berger/configs/librispeech/20230210_baselines/config_02f_transducer_rasr_features_am_scales.py new file mode 100644 index 000000000..320f83114 --- /dev/null +++ b/users/berger/configs/librispeech/20230210_baselines/config_02f_transducer_rasr_features_am_scales.py @@ -0,0 +1,445 @@ +import copy +import os +from typing import Dict, Tuple, Optional + +import i6_core.rasr as rasr +from i6_core.returnn import Checkpoint +from i6_core.returnn.config import ReturnnConfig +from i6_experiments.users.berger.args.experiments import transducer as exp_args +from i6_experiments.users.berger.args.returnn.config import get_returnn_config +from i6_experiments.users.berger.args.returnn.learning_rates import ( + LearningRateSchedules, +) +from i6_experiments.users.berger.corpus.librispeech.viterbi_transducer_data import ( + get_librispeech_data, +) +import i6_experiments.users.berger.network.models.context_1_transducer as transducer_model +from i6_experiments.users.berger.recipe.summary.report import SummaryReport +from i6_experiments.users.berger.systems.returnn_seq2seq_system import ( + ReturnnSeq2SeqSystem, +) +from i6_experiments.users.berger.systems.dataclasses import ReturnnConfigs, FeatureType, SummaryKey +from i6_experiments.users.berger.util import default_tools +from i6_private.users.vieting.helpers.returnn import serialize_dim_tags +from i6_experiments.users.berger.systems.dataclasses import AlignmentData +from i6_experiments.users.berger.recipe.returnn.hdf import MatchLengthsJob +from sisyphus import gs, tk + +tools = copy.deepcopy(default_tools) + +# ********** Settings ********** + +rasr.flow.FlowNetwork.default_flags = {"cache_mode": "task_dependent"} + + +num_classes = 79 +num_epochs = 600 + + +# ********** Return Config ********** + + +def generate_returnn_config( + train: bool, + *, + train_data_config: dict, + dev_data_config: dict, + **kwargs, +) -> ReturnnConfig: + specaug_v2 = kwargs.get("specaug_v2", False) + if specaug_v2: + specaug_args = { + "min_reps_time": 0, + "max_reps_time": 20, + "max_len_time": 20, + "min_reps_feature": 0, + "max_reps_feature": 1, + "max_len_feature": 15, + } + else: + specaug_args = { + "max_time_num": 1, + "max_time": 15, + "max_feature_num": 5, + "max_feature": 5, + } + + if train: + ( + network_dict, + extra_python, + ) = transducer_model.make_context_1_conformer_transducer( + num_outputs=num_classes, + specaug_args=specaug_args, + conformer_args={ + "num_blocks": 12, + "size": 512, + "dropout": 0.1, + "l2": 5e-06, + }, + decoder_args={ + "dec_mlp_args": { + "num_layers": 2, + "size": 640, + "activation": "tanh", + "dropout": 0.1, + "l2": 5e-06, + }, + "combination_mode": "concat", + "joint_mlp_args": { + "num_layers": 1, + "size": 1024, + "dropout": 0.1, + "l2": 5e-06, + "activation": "tanh", + }, + }, + output_args={ + "label_smoothing": kwargs.get("label_smoothing", None), + }, + loss_boost_scale=kwargs.get("loss_boost_scale", 5.0), + loss_boost_v2=kwargs.get("loss_boost_v2", False), + specaug_v2=specaug_v2, + ) + else: + ( + network_dict, + extra_python, + ) = transducer_model.make_context_1_conformer_transducer_recog( + num_outputs=num_classes, + conformer_args={ + "num_blocks": 12, + "size": 512, + }, + decoder_args={ + "dec_mlp_args": { + "num_layers": 2, + "size": 640, + "activation": "tanh", + }, + "combination_mode": "concat", + "joint_mlp_args": { + "num_layers": 1, + "size": 1024, + "activation": "tanh", + }, + "ilm_scale": kwargs.get("ilm_scale", 0.0), + }, + ) + + extra_config = { + "train": train_data_config, + "dev": dev_data_config, + "chunking": ( + { + "data": 256, + "classes": 64, + }, + { + "data": 128, + "classes": 32, + }, + ), + } + + if kwargs.get("model_preload", None) is not None: + extra_config["preload_from_files"] = { + "base": { + "init_for_train": True, + "ignore_missing": True, + "filename": kwargs.get("model_preload", None), + } + } + + returnn_config = get_returnn_config( + network=network_dict, + target="classes", + num_epochs=num_epochs, + python_prolog=[ + "import sys", + "sys.setrecursionlimit(10 ** 6)", + ], + extra_python=extra_python, + num_inputs=50, + num_outputs=num_classes, + extern_target_kwargs={"dtype": "int8" if train else "int32"}, + extern_data_config=True, + grad_noise=0.0, + grad_clip=0.0, + schedule=LearningRateSchedules.OCLR, + initial_lr=1e-05, + peak_lr=kwargs.get("peak_lr", 8e-04), + final_lr=1e-06, + n_steps_per_epoch=2450, + batch_size=12500, + extra_config=extra_config, + ) + returnn_config = serialize_dim_tags(returnn_config) + + return returnn_config + + +def subsample_by_4(orig_len: int) -> int: + return -(-orig_len // 4) + + +def run_exp( + alignments: Dict[str, AlignmentData], + ctc_model_checkpoint: Optional[Checkpoint] = None, + name_suffix: str = "", + data_control_train: bool = False, + data_control_cv: bool = False, + match_lengths: bool = False, +) -> Tuple[SummaryReport, Checkpoint]: + assert tools.returnn_root is not None + assert tools.returnn_python_exe is not None + assert tools.rasr_binary_path is not None + + data = get_librispeech_data( + tools.returnn_root, + tools.returnn_python_exe, + rasr_binary_path=tools.rasr_binary_path, + alignments=alignments, + add_unknown_phoneme_and_mapping=False, + # use_augmented_lexicon=False, + # use_wei_lexicon=True, + use_augmented_lexicon=True, + use_wei_lexicon=False, + feature_type=FeatureType.GAMMATONE_16K, + ) + changed_data_configs = [] + if data_control_train: + changed_data_configs.append(data.train_data_config) + if data_control_cv: + changed_data_configs.append(data.cv_data_config) + + data.train_data_config["datasets"]["classes"]["seq_ordering"] = "laplace:.384" + data.train_data_config["datasets"]["classes"]["partition_epoch"] = 40 + + for data_config in changed_data_configs: + data_config["datasets"]["data"].update( + { + "seq_ordering": data_config["datasets"]["classes"]["seq_ordering"], + "partition_epoch": data_config["datasets"]["classes"]["partition_epoch"], + } + ) + del data_config["datasets"]["classes"]["seq_ordering"] + del data_config["datasets"]["classes"]["partition_epoch"] + data_config["seq_order_control_dataset"] = "data" + if match_lengths: + for data_config in [data.train_data_config, data.cv_data_config]: + data_config["datasets"]["classes"]["files"] = [ + MatchLengthsJob(file, data_config["datasets"]["data"]["files"], subsample_by_4).out_hdf + for file in data_config["datasets"]["classes"]["files"] + ] + + # ********** System ********** + + system = ReturnnSeq2SeqSystem( + tools, + summary_keys=[ + SummaryKey.TRAIN_NAME, + SummaryKey.RECOG_NAME, + SummaryKey.CORPUS, + SummaryKey.EPOCH, + SummaryKey.LM, + SummaryKey.WER, + SummaryKey.SUB, + SummaryKey.INS, + SummaryKey.DEL, + SummaryKey.ERR, + ], + summary_sort_keys=[SummaryKey.ERR, SummaryKey.CORPUS], + ) + + system.init_corpora( + dev_keys=data.dev_keys, + test_keys=data.test_keys, + align_keys=data.align_keys, + corpus_data=data.data_inputs, + am_args=exp_args.transducer_recog_am_args, + ) + system.setup_scoring() + + # ********** Step args ********** + + train_args = exp_args.get_transducer_train_step_args( + num_epochs=num_epochs, + # gpu_mem_rqmt=24, + ) + + recog_args = exp_args.get_transducer_recog_step_args( + num_classes, + lm_scales=[0.8], + epochs=[num_epochs], + # lookahead_options={"scale": 0.5}, + search_parameters={"label-pruning": 12.0}, + feature_type=FeatureType.GAMMATONE_16K, + reduction_factor=4, + reduction_subtrahend=0, + ) + + # ********** Returnn Configs ********** + + for label_smoothing, loss_boost_v2, peak_lr, loss_boost_scale, ctc_init in [ + # (None, True, 4e-04, 5.0, False), + # (None, True, 8e-04, 5.0, False), + # # (None, False, 4e-04, 5.0, False), + # # (None, False, 8e-04, 5.0, False), + # # (None, False, 4e-04, 5.0, True), + # # (None, False, 8e-04, 5.0, True), + # (0.2, True, 4e-04, 5.0, False), + # (0.2, True, 8e-04, 5.0, False), + # # (0.2, False, 4e-04, 5.0, False), + # # (0.2, False, 8e-04, 5.0, False), + (None, False, 8e-04, 0.0, False), + # (None, False, 8e-04, 0.0, True), + ]: + ctc_init = ctc_init and (ctc_model_checkpoint is not None) + train_config = generate_returnn_config( + train=True, + train_data_config=data.train_data_config, + dev_data_config=data.cv_data_config, + label_smoothing=label_smoothing, + loss_boost_v2=loss_boost_v2, + loss_boost_scale=loss_boost_scale, + peak_lr=peak_lr, + model_preload=ctc_model_checkpoint if ctc_init else None, + specaug_v2=True, + ) + recog_config = generate_returnn_config( + train=False, + train_data_config=data.train_data_config, + dev_data_config=data.cv_data_config, + ) + recog_config_ilm = generate_returnn_config( + train=False, + train_data_config=data.train_data_config, + dev_data_config=data.cv_data_config, + ilm_scale=0.2, + ) + + returnn_configs = ReturnnConfigs( + train_config=train_config, + recog_configs={"recog": recog_config, "recog_ilm": recog_config_ilm}, + ) + + suffix = f"lr-{peak_lr}" + if loss_boost_scale: + if loss_boost_v2: + suffix += "_loss-boost-v2" + else: + suffix += "_loss-boost" + if label_smoothing: + suffix += f"_ls-{label_smoothing}" + + if ctc_init: + suffix += "_ctc-init" + + system.add_experiment_configs(f"Conformer_Transducer_Viterbi_{suffix}_{name_suffix}", returnn_configs) + + system.run_train_step(**train_args) + + system.run_dev_recog_step(**recog_args) + system.run_test_recog_step(**recog_args) + + train_job = system.get_train_job(f"Conformer_Transducer_Viterbi_lr-0.0008_{name_suffix}") + model = train_job.out_checkpoints[num_epochs] + assert isinstance(model, Checkpoint) + + assert system.summary_report + return system.summary_report, model + + +def py() -> SummaryReport: + filename_handle = os.path.splitext(os.path.basename(__file__))[0][len("config_") :] + gs.ALIAS_AND_OUTPUT_SUBDIR = f"{filename_handle}/" + + summary_report = SummaryReport() + + alignments_nour = {} + + alignment_paths_nour = { + 0.1: { + "train-other-960_align": tk.Path( + "/work/asr3/raissi/shared_workspaces/bayoumi/sisyphus_work/i6_experiments/users/berger/recipe/mm/alignment/Seq2SeqAlignmentJob.waHWItDFeH4p/output/alignment.cache.bundle" + ), + "dev-clean_align": tk.Path( + "/work/asr3/raissi/shared_workspaces/bayoumi/sisyphus_work/i6_experiments/users/berger/recipe/mm/alignment/Seq2SeqAlignmentJob.39RvKswiwE5X/output/alignment.cache.bundle" + ), + "dev-other_align": tk.Path( + "/work/asr3/raissi/shared_workspaces/bayoumi/sisyphus_work/i6_experiments/users/berger/recipe/mm/alignment/Seq2SeqAlignmentJob.UQcQtRgFJtri/output/alignment.cache.bundle" + ), + }, + 0.3: { + "train-other-960_align": tk.Path( + "/work/asr3/raissi/shared_workspaces/bayoumi/sisyphus_work/i6_experiments/users/berger/recipe/mm/alignment/Seq2SeqAlignmentJob.4bWrFMO9rBP7/output/alignment.cache.bundle" + ), + "dev-clean_align": tk.Path( + "/work/asr3/raissi/shared_workspaces/bayoumi/sisyphus_work/i6_experiments/users/berger/recipe/mm/alignment/Seq2SeqAlignmentJob.WAPZqf6YGRqV/output/alignment.cache.bundle" + ), + "dev-other_align": tk.Path( + "/work/asr3/raissi/shared_workspaces/bayoumi/sisyphus_work/i6_experiments/users/berger/recipe/mm/alignment/Seq2SeqAlignmentJob.8e6a0qmzOKPS/output/alignment.cache.bundle" + ), + }, + 0.5: { + "train-other-960_align": tk.Path( + "/work/asr3/raissi/shared_workspaces/bayoumi/sisyphus_work/i6_experiments/users/berger/recipe/mm/alignment/Seq2SeqAlignmentJob.9F7XAOE5SW6a/output/alignment.cache.bundle" + ), + "dev-clean_align": tk.Path( + "/work/asr3/raissi/shared_workspaces/bayoumi/sisyphus_work/i6_experiments/users/berger/recipe/mm/alignment/Seq2SeqAlignmentJob.NZ9KCbM3iaUM/output/alignment.cache.bundle" + ), + "dev-other_align": tk.Path( + "/work/asr3/raissi/shared_workspaces/bayoumi/sisyphus_work/i6_experiments/users/berger/recipe/mm/alignment/Seq2SeqAlignmentJob.NrLiIv3mx2Mi/output/alignment.cache.bundle" + ), + }, + 0.7: { + "train-other-960_align": tk.Path( + "/work/asr3/raissi/shared_workspaces/bayoumi/sisyphus_work/i6_experiments/users/berger/recipe/mm/alignment/Seq2SeqAlignmentJob.nOX1kOQx5Txi/output/alignment.cache.bundle" + ), + "dev-clean_align": tk.Path( + "/work/asr3/raissi/shared_workspaces/bayoumi/sisyphus_work/i6_experiments/users/berger/recipe/mm/alignment/Seq2SeqAlignmentJob.WhaHQ8VtCQWb/output/alignment.cache.bundle" + ), + "dev-other_align": tk.Path( + "/work/asr3/raissi/shared_workspaces/bayoumi/sisyphus_work/i6_experiments/users/berger/recipe/mm/alignment/Seq2SeqAlignmentJob.Z7Yc9kH2BYOc/output/alignment.cache.bundle" + ), + }, + 1.0: { + "train-other-960_align": tk.Path( + "/work/asr3/raissi/shared_workspaces/bayoumi/sisyphus_work/i6_experiments/users/berger/recipe/mm/alignment/Seq2SeqAlignmentJob.0a7MCFFN37Bg/output/alignment.cache.bundle" + ), + "dev-clean_align": tk.Path( + "/work/asr3/raissi/shared_workspaces/bayoumi/sisyphus_work/i6_experiments/users/berger/recipe/mm/alignment/Seq2SeqAlignmentJob.HjJgbxdZhWZj/output/alignment.cache.bundle" + ), + "dev-other_align": tk.Path( + "/work/asr3/raissi/shared_workspaces/bayoumi/sisyphus_work/i6_experiments/users/berger/recipe/mm/alignment/Seq2SeqAlignmentJob.UatqVP2YM55f/output/alignment.cache.bundle" + ), + }, + } + + for am_scale, alignment_paths in alignment_paths_nour.items(): + for key, path in alignment_paths.items(): + align_data = AlignmentData( + alignment_cache_bundle=path, + allophone_file=tk.Path( + "/work/asr3/raissi/shared_workspaces/bayoumi/sisyphus_work/i6_core/lexicon/allophones/StoreAllophonesJob.8Nygr67IZfVG/output/allophones" + ), + state_tying_file=tk.Path( + "/work/asr3/raissi/shared_workspaces/bayoumi/sisyphus_work/i6_core/lexicon/allophones/DumpStateTyingJob.6w7HRWTGkgEd/output/state-tying" + ), + silence_phone="", + ) + alignments_nour[key] = align_data + + report, _ = run_exp( + alignments_nour, + name_suffix=f"nour-align-am-{am_scale}", + data_control_train=True, + data_control_cv=False, + match_lengths=True, + ) + summary_report.merge_report(report, update_structure=True) + + tk.register_report(f"{gs.ALIAS_AND_OUTPUT_SUBDIR}/summary.report", summary_report) + + return summary_report diff --git a/users/berger/configs/librispeech/20230210_baselines/config_03b_transducer_fullsum_rasr_features.py b/users/berger/configs/librispeech/20230210_baselines/config_03b_transducer_fullsum_rasr_features.py index 09cbfb429..f45cac63e 100644 --- a/users/berger/configs/librispeech/20230210_baselines/config_03b_transducer_fullsum_rasr_features.py +++ b/users/berger/configs/librispeech/20230210_baselines/config_03b_transducer_fullsum_rasr_features.py @@ -158,6 +158,7 @@ def run_exp(alignments: Dict[str, AlignmentData], viterbi_model_checkpoint: Chec data = get_librispeech_data( tools.returnn_root, tools.returnn_python_exe, + lm_names=["4gram", "kazuki_transformer"], alignments=alignments, rasr_binary_path=tools.rasr_binary_path, add_unknown_phoneme_and_mapping=False, @@ -253,18 +254,43 @@ def run_exp(alignments: Dict[str, AlignmentData], viterbi_model_checkpoint: Chec system.run_recog_step_for_corpora(corpora=["test-clean_4gram", "test-other_4gram"], **recog_args) recog_args["lm_scales"] = [0.8] - recog_args["search_parameters"].update({"full-sum-decoding": True, "label-full-sum": True}) + recog_args["search_parameters"].update( + { + "full-sum-decoding": True, + "label-full-sum": True, + "label-recombination-limit": 1, + "separate-recombination-lm": True, + "recombination-lm.type": "simple-history", + } + ) system.run_recog_step_for_corpora( recog_descriptor="fs", recog_exp_names={"Conformer_Transducer_Fullsum_lr-0.0001_bs-9000": ["recog_ilm-0.2"]}, - corpora=["dev-clean_4gram", "dev-other_4gram"], + corpora=["dev-clean_4gram", "dev-other_4gram", "test-clean_4gram", "test-other_4gram"], **recog_args, ) + + recog_args["search_parameters"].update( + { + # "separate-lookahead-lm": True, + "label-full-sum": False, + "label-pruning": 16.2, + } + ) + recog_args["lookahead_options"].update({"lm_lookahead_scale": 0.45}) + recog_args["use_gpu"] = True + recog_args["rtf"] = 50 + system.run_recog_step_for_corpora( recog_descriptor="fs", recog_exp_names={"Conformer_Transducer_Fullsum_lr-0.0001_bs-9000": ["recog_ilm-0.2"]}, - corpora=["test-clean_4gram", "test-other_4gram"], + corpora=[ + # "dev-clean_kazuki_transformer", + "dev-other_kazuki_transformer", + # "test-clean_kazuki_transformer", + # "test-other_kazuki_transformer", + ], **recog_args, ) diff --git a/users/berger/corpus/librispeech/viterbi_transducer_data.py b/users/berger/corpus/librispeech/viterbi_transducer_data.py index f61868612..a3c8946e5 100644 --- a/users/berger/corpus/librispeech/viterbi_transducer_data.py +++ b/users/berger/corpus/librispeech/viterbi_transducer_data.py @@ -32,7 +32,7 @@ def get_librispeech_data( # ********** Data inputs ********** - (train_data_inputs, cv_data_inputs, dev_data_inputs, test_data_inputs,) = data.get_data_inputs( + train_data_inputs, cv_data_inputs, dev_data_inputs, test_data_inputs = data.get_data_inputs( train_key=train_key, cv_keys=cv_keys, dev_keys=dev_keys, diff --git a/users/berger/settings.py b/users/berger/settings.py index 04308e1af..9744555d6 100644 --- a/users/berger/settings.py +++ b/users/berger/settings.py @@ -23,7 +23,9 @@ def check_engine_limits(current_rqmt, task): i6 support for gpu_mem """ current_rqmt["time"] = min(168, current_rqmt.get("time", 2)) - if current_rqmt.get("gpu", 0) > 0 and "-p" not in current_rqmt.get("sbatch_args", []): + if current_rqmt.get("gpu", 0) > 0 and "-p" not in current_rqmt.get( + "sbatch_args", [] + ): if current_rqmt.get("gpu_mem", 0) > 11: current_rqmt["sbatch_args"] = ["-p", "gpu_24gb"] else: @@ -52,7 +54,9 @@ def engine(): return EngineSelector( engines={ "short": LocalEngine(cpus=4, mem=16), - "long": SimpleLinuxUtilityForResourceManagementEngine(default_rqmt=default_rqmt), + "long": SimpleLinuxUtilityForResourceManagementEngine( + default_rqmt=default_rqmt + ), }, default_engine="long", ) @@ -75,6 +79,8 @@ def worker_wrapper(job, task_name, call): "AdvancedTreeSearchJob", "AdvancedTreeSearchLmImageAndGlobalCacheJob", "GenericSeq2SeqSearchJob", + "CreateLmImageJob", + "BuildGenericSeq2SeqGlobalCacheJob", "GenericSeq2SeqLmImageAndGlobalCacheJob", "LatticeToCtmJob", "OptimizeAMandLMScaleJob", diff --git a/users/berger/systems/functors/seq2seq_base.py b/users/berger/systems/functors/seq2seq_base.py index ee897cae3..1944e0b56 100644 --- a/users/berger/systems/functors/seq2seq_base.py +++ b/users/berger/systems/functors/seq2seq_base.py @@ -81,6 +81,7 @@ def _get_tf_feature_flow_for_label_scorer( feature_flow = copy.deepcopy(base_feature_flow) feature_flow.config = feature_flow.config or rasr.RasrConfig() feature_flow.config.main_port_name = "samples" if feature_type == FeatureType.SAMPLES else "features" + label_scorer.set_input_config() label_scorer.set_loader_config(self._make_tf_model_loader_config(tf_graph, checkpoint)) else: raise NotImplementedError From 8b241f5c066db99f4f91ef4d0a6a5cd316c58301 Mon Sep 17 00:00:00 2001 From: Simon Berger Date: Wed, 22 May 2024 13:13:09 +0200 Subject: [PATCH 045/227] Update users/berger --- users/berger/network/helpers/label_context.py | 15 +- .../recipe/rasr/label_tree_and_scorer.py | 57 ++- .../recognition/generic_seq2seq_search.py | 385 ++++++++++++------ 3 files changed, 333 insertions(+), 124 deletions(-) diff --git a/users/berger/network/helpers/label_context.py b/users/berger/network/helpers/label_context.py index c592c3b76..8214634b7 100644 --- a/users/berger/network/helpers/label_context.py +++ b/users/berger/network/helpers/label_context.py @@ -263,6 +263,7 @@ def add_context_1_decoder( def add_context_1_decoder_recog( network: Dict, num_outputs: int, + blank_idx: int = 0, encoder: str = "encoder", embedding_size: int = 128, dec_mlp_args: Dict = {}, @@ -351,9 +352,21 @@ def add_context_1_decoder_recog( "reuse_params": "output", } + assert blank_idx == 0, "Blank idx != 0 not implemented for ilm" + # Set p(blank) = 1 and re-normalize the non-blank probs + # so we want P'[b, 0] = 1, sum(P'[b, 1:]) = 1, given a normalized tensor P, i.e. sum(P[b, :]) = 1 + # in log space logP'[b, 0] = 0, sum(exp(logP'[b, 1:])) = 1 + # so set logP'[b, 1:] <- logP[b, 1:] - log(1 - exp(P[b, 0])) + # then sum(exp(logP'[b, 1:])) = sum(P[1:] / (1 - exp(P[b, 0]))) = sum(P[b, 1:]) / sum(b, P[1:]) = 1 + output_unit["ilm_renorm"] = { + "class": "eval", + "from": ["ilm"], + "eval": "tf.concat([tf.zeros(tf.shape(source(0)[:, :1])), source(0)[:, 1:] - tf.math.log(1.0 - tf.exp(source(0)[:, :1]))], axis=-1)", + } + output_unit["output_sub_ilm"] = { "class": "eval", - "from": ["output", "ilm"], + "from": ["output", "ilm_renorm"], "eval": f"source(0) - {ilm_scale} * source(1)", } diff --git a/users/berger/recipe/rasr/label_tree_and_scorer.py b/users/berger/recipe/rasr/label_tree_and_scorer.py index cd1451d55..88a6d4fef 100644 --- a/users/berger/recipe/rasr/label_tree_and_scorer.py +++ b/users/berger/recipe/rasr/label_tree_and_scorer.py @@ -78,7 +78,7 @@ def __init__( use_prior: bool = False, prior_scale: float = 0.6, prior_file: Optional[tk.Path] = None, - extra_args: Dict = {}, + extra_args: Optional[Dict] = None, ): self.config = rasr.RasrConfig() self.post_config = rasr.RasrConfig() @@ -102,13 +102,64 @@ def __init__( self.config.priori_scale = prior_scale # sprint key values # - for key, value in extra_args.items(): - self.config[key.replace("_", "-")] = value + if extra_args is not None: + for key, value in extra_args.items(): + self.config[key.replace("_", "-")] = value @property def scorer_type(self): return self.config.label_scorer_type + @property + def scale(self): + return self.config.scale + + @property + def label_file(self): + if self.config._get("label-file") is not None: + return self.config.label_file + return None + + @property + def num_classes(self): + if self.config._get("number-of-classes") is not None: + return self.config.number_of_classes + return None + + @property + def use_prior(self): + if self.config._get("use-prior") is not None: + return self.config["use-prior"] + return False + + @property + def prior_scale(self): + if self.config._get("priori-scale") is not None: + return self.config["priori-scale"] + return 1.0 + + @property + def prior_file(self): + if self.config._get("prior-file") is not None: + return self.config["prior-file"] + return None + + @property + def extra_args(self): + return { + key: val + for key, val in self.config._items() + if key not in [ + "label-scorer-type", + "scale", + "label-file", + "number-of-classes", + "use-prior", + "priori-scale", + "prior-file", + ] + } + def apply_config( self, path: str, diff --git a/users/berger/recipe/recognition/generic_seq2seq_search.py b/users/berger/recipe/recognition/generic_seq2seq_search.py index 34cc1da5e..4ed1f4177 100644 --- a/users/berger/recipe/recognition/generic_seq2seq_search.py +++ b/users/berger/recipe/recognition/generic_seq2seq_search.py @@ -1,13 +1,17 @@ __all__ = ["GenericSeq2SeqLmImageAndGlobalCacheJob", "GenericSeq2SeqSearchJob"] +from typing import List, Optional, Tuple from sisyphus import * +assert __package__ is not None Path = setup_path(__package__) import shutil import copy from i6_core import rasr, util +from i6_core.lm.lm_image import CreateLmImageJob +from i6_experiments.users.berger.recipe.rasr.label_tree_and_scorer import LabelTree, LabelScorer class GenericSeq2SeqLmImageAndGlobalCacheJob(rasr.RasrCommand, Job): @@ -84,13 +88,15 @@ def find_arpa_lms(cls, config): lookahead_lm_config = config.flf_lattice_tool.network.recognizer.recognizer.lookahead_lm if separate_lookahead_lm: if lookahead_lm_config.type == "ARPA" and lookahead_lm_config._get("image") is None: - result.append(lookahead_lm_config) + pass + # result.append(lookahead_lm_config) # recombination lm # separate_recombination_lm = config.flf_lattice_tool.network.recognizer.recognizer.separate_recombination_lm recombination_lm_config = config.flf_lattice_tool.network.recognizer.recognizer.recombination_lm if separate_recombination_lm: if recombination_lm_config.type == "ARPA" and recombination_lm_config._get("image") is None: - result.append(recombination_lm_config) + pass + # result.append(recombination_lm_config) return result @classmethod @@ -168,8 +174,8 @@ def create_config( # lm images # arpa_lms = cls.find_arpa_lms(config) - for i, lm_config in enumerate(arpa_lms): - lm_config.image = "lm-%d.image" % (i + 1) + for i, lm_config in enumerate(arpa_lms, start=1): + lm_config.image = f"lm-{i}.image" # global cache # config.flf_lattice_tool.global_cache.file = "global.cache" @@ -185,42 +191,171 @@ def hash(cls, kwargs): return super().hash({"config": config, "exe": sprint_exe}) +class BuildGenericSeq2SeqGlobalCacheJob(rasr.RasrCommand, Job): + """ + Standalone job to create the global-cache for generic-seq2seq-tree-search + """ + + def __init__( + self, + crp: rasr.CommonRasrParameters, + label_tree: LabelTree, + label_scorer: LabelScorer, + extra_config: Optional[rasr.RasrConfig] = None, + extra_post_config: Optional[rasr.RasrConfig] = None, + ): + """ + :param crp: common RASR params (required: lexicon, acoustic_model, language_model, recognizer) + :param label_tree: label tree object for structuring the search tree + :param label_scorer: label scorer object for score computation + :param extra_config: overlay config that influences the Job's hash + :param extra_post_config: overlay config that does not influences the Job's hash + """ + self.set_vis_name("Build Global Cache") + + (self.config, self.post_config,) = BuildGenericSeq2SeqGlobalCacheJob.create_config( + crp=crp, + label_tree=label_tree, + label_scorer=label_scorer, + extra_config=extra_config, + extra_post_config=extra_post_config, + ) + + self.exe = self.select_exe(crp.speech_recognizer_exe, "speech-recognizer") + + self.out_log_file = self.log_file_output_path("build_global_cache", crp, False) + self.out_global_cache = self.output_path("global.cache", cached=True) + + self.rqmt = {"time": 1, "cpu": 1, "mem": 2} + + def tasks(self): + yield Task("create_files", mini_task=True) + yield Task("run", resume="run", rqmt=self.rqmt) + + def create_files(self): + self.write_config(self.config, self.post_config, "build_global_cache.config") + self.write_run_script(self.exe, "build_global_cache.config") + + def run(self): + self.run_script(1, self.out_log_file) + shutil.move("global.cache", self.out_global_cache.get_path()) + + @classmethod + def create_config( + cls, + crp: rasr.CommonRasrParameters, + label_tree: LabelTree, + label_scorer: LabelScorer, + extra_config: Optional[rasr.RasrConfig], + extra_post_config: Optional[rasr.RasrConfig], + ): + config, post_config = rasr.build_config_from_mapping( + crp, + { + "lexicon": "speech-recognizer.model-combination.lexicon", + "acoustic_model": "speech-recognizer.model-combination.acoustic-model", + "language_model": "speech-recognizer.model-combination.lm", + "recognizer": "speech-recognizer.recognizer", + }, + ) + + # Apply config from label tree + label_tree.apply_config( + "speech-recognizer.recognizer.label-tree", + config, + post_config, + ) + + # Optional lexicon overwrite + if label_tree.lexicon_config is not None: + config["speech-recognizer.model-combination.lexicon"]._update(label_tree.lexicon_config) + + # Apply config from label scorer and eliminate unnecessary arguments that don't affect the search space (scale, prior) + label_scorer_reduced = LabelScorer( + scorer_type=label_scorer.scorer_type, + scale=1.0, + label_file=label_scorer.label_file, + num_classes=label_scorer.num_classes, + use_prior=False, + extra_args=label_scorer.extra_args, + ) + + label_scorer_reduced.apply_config("speech-recognizer.recognizer.label-scorer", config, post_config) + + # skip conventional AM or load it without GMM # + if crp.acoustic_model_config is None: + config.speech_recognizer.recognizer.use_acoustic_model = False + else: + config.speech_recognizer.recognizer.use_mixture = False + if config.flf_lattice_tool.network.recognizer.acoustic_model._get("length") is not None: + del config.flf_lattice_tool.network.recognizer.acoustic_model["length"] + + # disable scaling + if config.flf_lattice_tool.network.recognizer.lm._get("scale") is not None: + del config.flf_lattice_tool.network.recognizer.lm["scale"] + + config.speech_recognizer.recognition_mode = "init-only" + config.speech_recognizer.search_type = "generic-seq2seq-tree-search" + config.speech_recognizer.global_cache.file = "global.cache" + config.speech_recognizer.global_cache.read_only = False + + config._update(extra_config) + post_config._update(extra_post_config) + + return config, post_config + + @classmethod + def hash(cls, kwargs): + config, _ = cls.create_config(**kwargs) + return super().hash({"config": config, "exe": kwargs["crp"].speech_recognizer_exe}) + + class GenericSeq2SeqSearchJob(rasr.RasrCommand, Job): __sis_hash_exclude__ = {"num_threads": None} def __init__( self, - crp, - feature_flow, - label_tree, - label_scorer, - search_parameters=None, - lm_lookahead=True, - lookahead_options=None, - eval_single_best=True, - eval_best_in_lattice=True, - use_gpu=False, - rtf=2, - mem=8, - hard_rqmt=False, - extra_config=None, - extra_post_config=None, - sprint_exe=None, # allow separat executable than default settings - lm_gc_job=None, - lm_gc_job_local=False, - lm_gc_job_mem=16, - lm_gc_job_default_search=False, - num_threads=None, - ): # TODO set this to true later + crp: rasr.CommonRasrParameters, + feature_flow: rasr.FlowNetwork, + label_tree: LabelTree, + label_scorer: LabelScorer, + rasr_exe: Optional[tk.Path] = None, + search_parameters: Optional[dict] = None, + lm_lookahead: bool = True, + lookahead_options: Optional[dict] = None, + eval_single_best: bool = True, + eval_best_in_lattice: bool = True, + use_gpu: bool = False, + global_cache: Optional[tk.Path] = None, + rtf: float = 2, + mem: float = 8, + extra_config: Optional[rasr.RasrConfig] = None, + extra_post_config: Optional[rasr.RasrConfig] = None, + num_threads: int = 2, + ): self.set_vis_name("Generic Seq2Seq Search") - kwargs = locals() - del kwargs["self"] - self.config, self.post_config = GenericSeq2SeqSearchJob.create_config(**kwargs) + self.config, self.post_config = GenericSeq2SeqSearchJob.create_config( + crp=crp, + feature_flow=feature_flow, + label_tree=label_tree, + label_scorer=label_scorer, + search_parameters=search_parameters, + lm_lookahead=lm_lookahead, + lookahead_options=lookahead_options, + eval_single_best=eval_single_best, + eval_best_in_lattice=eval_best_in_lattice, + extra_config=extra_config, + extra_post_config=extra_post_config, + global_cache=global_cache, + ) self.feature_flow = feature_flow - if sprint_exe is None: - sprint_exe = crp.flf_tool_exe - self.exe = self.select_exe(sprint_exe, "flf-tool") + if rasr_exe is not None: + self.rasr_exe = rasr_exe + else: + self.rasr_exe = crp.flf_tool_exe + assert self.rasr_exe is not None + self.concurrent = crp.concurrent self.use_gpu = use_gpu self.num_threads = num_threads @@ -237,21 +372,15 @@ def __init__( ) self.rqmt = { - "time": max(crp.corpus_duration * rtf / crp.concurrent, 4.5), - "cpu": 2, + "time": max(crp.corpus_duration * rtf / crp.concurrent, 24), + "cpu": num_threads, "gpu": 1 if self.use_gpu else 0, "mem": mem, } - # no automatic resume with doubled rqmt - self.hard_rqmt = hard_rqmt def tasks(self): yield Task("create_files", mini_task=True) - if self.hard_rqmt: # TODO - resume = None - else: - resume = "run" - yield Task("run", resume=resume, rqmt=self.rqmt, args=range(1, self.concurrent + 1)) + yield Task("run", resume="run", rqmt=self.rqmt, args=range(1, self.concurrent + 1)) def create_files(self): self.write_config(self.config, self.post_config, "recognition.config") @@ -261,16 +390,10 @@ def create_files(self): # sometimes crash without this if not self.use_gpu: extra_code += "\nexport CUDA_VISIBLE_DEVICES=" - if self.num_threads is None: - extra_code += "\nexport OMP_NUM_THREADS=%i" % self.rqmt["cpu"] - else: - extra_code += f"\nexport OMP_NUM_THREADS={self.num_threads}" - extra_code += f"\nexport MKL_NUM_THREADS={self.num_threads}" - self.write_run_script(self.exe, "recognition.config", extra_code=extra_code) - # TODO maybe not needed - def stop_run(self, task_id): - print("run job %d exceeds specified rqmt and stoped" % task_id) + extra_code += f"\nexport OMP_NUM_THREADS={self.num_threads}" + extra_code += f"\nexport MKL_NUM_THREADS={self.num_threads}" + self.write_run_script(self.rasr_exe, "recognition.config", extra_code=extra_code) def run(self, task_id): self.run_script(task_id, self.out_log_file[task_id]) @@ -279,45 +402,50 @@ def run(self, task_id): self.out_single_lattice_caches[task_id].get_path(), ) - def cleanup_before_run(self, cmd, retry, task_id, *args): - util.backup_if_exists("recognition.log.%d" % task_id) - util.delete_if_exists("lattice.cache.%d" % task_id) + @classmethod + def find_arpa_lms( + cls, lm_config: rasr.RasrConfig, lm_post_config: Optional[rasr.RasrConfig] = None + ) -> List[Tuple[rasr.RasrConfig, Optional[rasr.RasrConfig]]]: + result = [] + + if lm_config.type == "ARPA": + result.append((lm_config, lm_post_config)) + elif lm_config.type == "combine": + for i in range(1, lm_config.num_lms + 1): + sub_lm_config = lm_config["lm-%d" % i] + sub_lm_post_config = lm_post_config["lm-%d" % i] if lm_post_config is not None else None + result += cls.find_arpa_lms(sub_lm_config, sub_lm_post_config) + + return result + + @classmethod + def find_arpa_lms_without_image( + cls, lm_config: rasr.RasrConfig, lm_post_config: Optional[rasr.RasrConfig] = None + ) -> List[Tuple[rasr.RasrConfig, Optional[rasr.RasrConfig]]]: + def has_image(c, pc): + res = c._get("image") is not None + res = res or (pc is not None and pc._get("image") is not None) + return res + + return [(c, pc) for c, pc in cls.find_arpa_lms(lm_config, lm_post_config) if not has_image(c, pc)] @classmethod def create_config( cls, - crp, - feature_flow, - label_tree, - label_scorer, - search_parameters=None, - lm_lookahead=True, - lookahead_options=None, - eval_single_best=True, - eval_best_in_lattice=True, - extra_config=None, - extra_post_config=None, - sprint_exe=None, - lm_gc_job=None, - lm_gc_job_local=True, - lm_gc_job_mem=6, - lm_gc_job_default_search=False, - **kwargs, + crp: rasr.CommonRasrParameters, + feature_flow: rasr.FlowNetwork, + label_tree: LabelTree, + label_scorer: LabelScorer, + search_parameters: Optional[dict] = None, + lm_lookahead: bool = True, + lookahead_options: Optional[dict] = None, + eval_single_best: bool = True, + eval_best_in_lattice: bool = True, + extra_config: Optional[rasr.RasrConfig] = None, + extra_post_config: Optional[rasr.RasrConfig] = None, + global_cache: Optional[tk.Path] = None, + **_, ): - # optional individual lm-image and global-cache job # - if lm_gc_job is None: - lm_gc_job = GenericSeq2SeqLmImageAndGlobalCacheJob( - crp, - label_tree, - label_scorer, - extra_config, - extra_post_config, - mem=lm_gc_job_mem, - local_job=lm_gc_job_local, - sprint_exe=sprint_exe, - default_search=lm_gc_job_default_search, - ) - # get config from csp # config, post_config = rasr.build_config_from_mapping( crp, @@ -331,8 +459,8 @@ def create_config( parallelize=True, ) - # acoustic model maybe used for allophones and state-tying, but no mixture is needed # - # skip conventional AM or load it without GMM # + # acoustic model maybe used for allophones and state-tying, but no mixture is needed + # skip conventional AM or load it without GMM if crp.acoustic_model_config is None: config.flf_lattice_tool.network.recognizer.use_acoustic_model = False else: @@ -342,14 +470,17 @@ def create_config( config.flf_lattice_tool.network.recognizer.feature_extraction.file = "feature.flow" if feature_flow.outputs != {"features"}: assert len(feature_flow.outputs) == 1, "not implemented otherwise" - config.flf_lattice_tool.network.recognizer.feature_extraction.main_port_name = list(feature_flow.outputs)[0] + config.flf_lattice_tool.network.recognizer.feature_extraction.main_port_name = next( + iter(feature_flow.outputs) + ) + feature_flow.apply_config( "flf-lattice-tool.network.recognizer.feature-extraction", config, post_config, ) - # label tree and optional lexicon overwrite # + # label tree and optional lexicon overwrite label_tree.apply_config( "flf-lattice-tool.network.recognizer.recognizer.label-tree", config, @@ -358,14 +489,15 @@ def create_config( if label_tree.lexicon_config is not None: config["flf-lattice-tool.lexicon"]._update(label_tree.lexicon_config) - # label scorer # + # label scorer label_scorer.apply_config("flf-lattice-tool.network.recognizer.label-scorer", config, post_config) # search settings # search_config = rasr.RasrConfig() if search_parameters is not None: - for key in search_parameters.keys(): - search_config[key] = search_parameters[key] + for key, val in search_parameters.items(): + search_config[key.replace("_", "-")] = val + config.flf_lattice_tool.network.recognizer.recognizer._update(search_config) # lookahead settings # @@ -377,26 +509,23 @@ def create_config( if lookahead_options is not None: la_opts.update(lookahead_options) - config.flf_lattice_tool.network.recognizer.recognizer.lm_lookahead = rasr.RasrConfig() - config.flf_lattice_tool.network.recognizer.recognizer.lm_lookahead._value = lm_lookahead + config.flf_lattice_tool.network.recognizer.recognizer.optimize_lattice = True + + la_config = rasr.RasrConfig() + la_config._value = lm_lookahead + if "laziness" in la_opts: config.flf_lattice_tool.network.recognizer.recognizer.lm_lookahead_laziness = la_opts["laziness"] - config.flf_lattice_tool.network.recognizer.recognizer.optimize_lattice = True + if lm_lookahead: if "history_limit" in la_opts: - config.flf_lattice_tool.network.recognizer.recognizer.lm_lookahead.history_limit = la_opts[ - "history_limit" - ] + la_config.history_limit = la_opts["history_limit"] if "tree_cutoff" in la_opts: - config.flf_lattice_tool.network.recognizer.recognizer.lm_lookahead.tree_cutoff = la_opts["tree_cutoff"] + la_config.tree_cutoff = la_opts["tree_cutoff"] if "minimum_representation" in la_opts: - config.flf_lattice_tool.network.recognizer.recognizer.lm_lookahead.minimum_representation = la_opts[ - "minimum_representation" - ] + la_config.minimum_representation = la_opts["minimum_representation"] if "lm_lookahead_scale" in la_opts: - config.flf_lattice_tool.network.recognizer.recognizer.lm_lookahead.lm_lookahead_scale = la_opts[ - "lm_lookahead_scale" - ] + la_config.lm_lookahead_scale = la_opts["lm_lookahead_scale"] if "cache_low" in la_opts: post_config.flf_lattice_tool.network.recognizer.recognizer.lm_lookahead.cache_size_low = la_opts[ "cache_low" @@ -406,6 +535,8 @@ def create_config( "cache_high" ] + config.flf_lattice_tool.network.recognizer.recognizer.lm_lookahead = la_config + # flf network # config.flf_lattice_tool.network.initial_nodes = "segment" config.flf_lattice_tool.network.segment.type = "speech-segment" @@ -443,32 +574,46 @@ def create_config( post_config.flf_lattice_tool.network.sink.error_on_empty_lattice = False post_config["*"].output_channel.unbuffered = True - # update parameters # - config._update(extra_config) - post_config._update(extra_post_config) - # image and cache # - arpa_lms = GenericSeq2SeqLmImageAndGlobalCacheJob.find_arpa_lms(config) - assert len(arpa_lms) == lm_gc_job.num_images, "mismatch between image-cache config and recognition config" - for i, lm_config in enumerate(arpa_lms): - lm_config.image = lm_gc_job.lm_images[i + 1] + no_image_arpa_lms = GenericSeq2SeqSearchJob.find_arpa_lms_without_image( + lm_config=config.flf_lattice_tool.network.recognizer.lm + ) + if config.flf_lattice_tool.network.recognizer.recognizer._get("lookahead-lm") is not None: + no_image_arpa_lms += GenericSeq2SeqSearchJob.find_arpa_lms_without_image( + lm_config=config.flf_lattice_tool.network.recognizer.recognizer.lookahead_lm + ) + + for lm_config, lm_post_config in no_image_arpa_lms: + rp = rasr.CommonRasrParameters(base=crp) + rp.language_model_config = lm_config + rp.language_model_post_config = lm_post_config + lm_config.image = CreateLmImageJob(crp=rp, mem=8).out_image + + if global_cache is None: + global_cache = BuildGenericSeq2SeqGlobalCacheJob( + crp=crp, label_tree=label_tree, label_scorer=label_scorer + ).out_global_cache - if post_config.flf_lattice_tool.global_cache._get("file") is None: - post_config.flf_lattice_tool.global_cache.read_only = True - post_config.flf_lattice_tool.global_cache.file = lm_gc_job.global_cache + post_config.flf_lattice_tool.global_cache.read_only = True + post_config.flf_lattice_tool.global_cache.file = global_cache + # update parameters # + config._update(extra_config) + post_config._update(extra_post_config) + return config, post_config @classmethod def hash(cls, kwargs): - config, post_config = cls.create_config(**kwargs) - sprint_exe = kwargs["sprint_exe"] - if sprint_exe is None: - sprint_exe = kwargs["crp"].flf_tool_exe + config, _ = cls.create_config(**kwargs) + if kwargs["rasr_exe"] is not None: + rasr_exe = kwargs["rasr_exe"] + else: + rasr_exe = kwargs["crp"].flf_tool_exe return super().hash( { "config": config, "feature_flow": kwargs["feature_flow"], - "exe": sprint_exe, + "exe": rasr_exe, } ) From db7a0ca327588f370ed92c9c23a0d52c7eef0014 Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Wed, 22 May 2024 11:13:57 +0000 Subject: [PATCH 046/227] better --- .../tedlium2/configs/ebranch_baseline.py | 20 +++++++++++++++---- 1 file changed, 16 insertions(+), 4 deletions(-) diff --git a/users/zeineldeen/experiments/conformer_att_2023/tedlium2/configs/ebranch_baseline.py b/users/zeineldeen/experiments/conformer_att_2023/tedlium2/configs/ebranch_baseline.py index f90326966..b0d1887bf 100644 --- a/users/zeineldeen/experiments/conformer_att_2023/tedlium2/configs/ebranch_baseline.py +++ b/users/zeineldeen/experiments/conformer_att_2023/tedlium2/configs/ebranch_baseline.py @@ -1,6 +1,7 @@ import copy, os import numpy +from typing import Any, Tuple import sisyphus.toolkit as tk @@ -891,7 +892,7 @@ def train_mini_self_att( ) apply_fairseq_init_to_transformer_decoder(trafo_dec_args) - training_args = dict() + training_args: dict[str, Any] = dict() training_args["with_staged_network"] = True training_args["speed_pert"] = True @@ -919,7 +920,7 @@ def train_mini_self_att( lstm_training_args["pretrain_reps"] = 5 lstm_training_args["batch_size"] = 15000 * 160 # frames * samples per frame - lstm_dec_exp_args = copy.deepcopy( + lstm_dec_exp_args: dict[str, Any] = copy.deepcopy( { **lstm_training_args, "encoder_args": ebranch_enc_args, @@ -941,7 +942,7 @@ def train_mini_self_att( _, _, global_mean, global_std = compute_features_stats(output_dirname="logmel_80", feat_dim=80) # --------------------- V1 --------------------- - def get_base_v1_args(lr, ep, enc_drop=0.1, pretrain_reps=3, use_legacy_stats=True): + def get_base_v1_args(lr, ep, enc_drop=0.1, pretrain_reps=3, use_legacy_stats=True) -> Tuple[dict[str, Any], str]: # base_bpe1000_peakLR0.0008_ep200_globalNorm_epochOCLR_pre3_fixZoneout_encDrop0.1_woDepthConvPre # Average ckpt: 8.19/7.64 (50 epochs) # - Epoch-based OCLR with peak LR 8e-4 @@ -986,7 +987,7 @@ def get_base_v1_args(lr, ep, enc_drop=0.1, pretrain_reps=3, use_legacy_stats=Tru for dec_att_drop in [0.0]: for weight_drop in [0.1]: for enc_drop in [0.15]: - for ctc_scale in [1.0, 0.3]: + for ctc_scale in [0.3]: base_v1_args, exp_name = get_base_v1_args( lr, ep, enc_drop=enc_drop, use_legacy_stats=False ) @@ -994,6 +995,17 @@ def get_base_v1_args(lr, ep, enc_drop=0.1, pretrain_reps=3, use_legacy_stats=Tru args["encoder_args"].num_blocks = num_blocks + args["with_pretrain"] = False + specaug_steps = {"step0": 6_000, "step1": 12_000, "step2": 18_000} + args["specaug_str_func_opts"] = { + "version": 2, + **specaug_steps, + "max_time_num": 100, + "max_time_dim": 20, + "min_num_add_factor": 0, + "freq_dim_factor": 5, + } + args["encoder_args"].frontend_conv_weight_dropout = weight_drop args["encoder_args"].mhsa_weight_dropout = weight_drop args["encoder_args"].ff_weight_dropout = weight_drop From f87d62a5399e24babc6dcb78aa374f567a94d61f Mon Sep 17 00:00:00 2001 From: Nick Rossenbach Date: Wed, 22 May 2024 13:59:33 +0200 Subject: [PATCH 047/227] config enable write cache manager --- .../ctc_rnnt_standalone_2024/config.py | 26 ++++++++++++------- 1 file changed, 17 insertions(+), 9 deletions(-) diff --git a/users/rossenbach/experiments/librispeech/ctc_rnnt_standalone_2024/config.py b/users/rossenbach/experiments/librispeech/ctc_rnnt_standalone_2024/config.py index d12944632..ccd8cf851 100644 --- a/users/rossenbach/experiments/librispeech/ctc_rnnt_standalone_2024/config.py +++ b/users/rossenbach/experiments/librispeech/ctc_rnnt_standalone_2024/config.py @@ -24,6 +24,7 @@ def get_training_config( debug: bool = False, use_speed_perturbation: bool = False, post_config: Optional[Dict[str, Any]] = None, + add_cache_manager: bool = False, ) -> ReturnnConfig: """ Get a generic config for training a model @@ -61,21 +62,28 @@ def get_training_config( include_native_ops=include_native_ops, debug=debug, ) - python_prolog = None + python_prolog_serializer_objects = [] # TODO: maybe make nice (if capability added to RETURNN itself) if use_speed_perturbation: - prolog_serializer = TorchCollection( - serializer_objects=[ - Import( - code_object_path=PACKAGE + ".extra_code.speed_perturbation.legacy_speed_perturbation", - unhashed_package_root=PACKAGE, - ) - ] + python_prolog_serializer_objects.append( + Import( + code_object_path=PACKAGE + ".extra_code.speed_perturbation.legacy_speed_perturbation", + unhashed_package_root=PACKAGE, + ) ) - python_prolog = [prolog_serializer] config["train"]["datasets"]["zip_dataset"]["audio"]["pre_process"] = CodeWrapper("legacy_speed_perturbation") + if add_cache_manager: + from i6_experiments.common.setups.serialization import PythonCacheManagerFunctionNonhashedCode, Collection + python_prolog_serializer_objects.append(PythonCacheManagerFunctionNonhashedCode) + + python_prolog = None + if len(python_prolog_serializer_objects) > 0: + python_prolog = [ + TorchCollection(python_prolog_serializer_objects) + ] + returnn_config = ReturnnConfig( config=config, post_config=post_config, python_prolog=python_prolog, python_epilog=[serializer] ) From 8231aad85e2cd1d3141e87ce1678860d41eba7e0 Mon Sep 17 00:00:00 2001 From: Nick Rossenbach Date: Wed, 22 May 2024 14:00:02 +0200 Subject: [PATCH 048/227] standalone 2024 setup add LSTM lm pipeline --- .../ctc_rnnt_standalone_2024/data/bpe_lm.py | 186 ++++++++++++++++++ .../experiments/lm_bpe/__init__.py | 0 .../experiments/lm_bpe/kazuki_lstm.py | 77 ++++++++ .../pytorch_networks/lm/__init__.py | 0 .../pytorch_networks/lm/lstm/__init__.py | 0 .../lm/lstm/kazuki_lstm_zijian_variant_v1.py | 108 ++++++++++ .../lstm/kazuki_lstm_zijian_variant_v1_cfg.py | 15 ++ 7 files changed, 386 insertions(+) create mode 100644 users/rossenbach/experiments/librispeech/ctc_rnnt_standalone_2024/data/bpe_lm.py create mode 100644 users/rossenbach/experiments/librispeech/ctc_rnnt_standalone_2024/experiments/lm_bpe/__init__.py create mode 100644 users/rossenbach/experiments/librispeech/ctc_rnnt_standalone_2024/experiments/lm_bpe/kazuki_lstm.py create mode 100644 users/rossenbach/experiments/librispeech/ctc_rnnt_standalone_2024/pytorch_networks/lm/__init__.py create mode 100644 users/rossenbach/experiments/librispeech/ctc_rnnt_standalone_2024/pytorch_networks/lm/lstm/__init__.py create mode 100644 users/rossenbach/experiments/librispeech/ctc_rnnt_standalone_2024/pytorch_networks/lm/lstm/kazuki_lstm_zijian_variant_v1.py create mode 100644 users/rossenbach/experiments/librispeech/ctc_rnnt_standalone_2024/pytorch_networks/lm/lstm/kazuki_lstm_zijian_variant_v1_cfg.py diff --git a/users/rossenbach/experiments/librispeech/ctc_rnnt_standalone_2024/data/bpe_lm.py b/users/rossenbach/experiments/librispeech/ctc_rnnt_standalone_2024/data/bpe_lm.py new file mode 100644 index 000000000..54f92758f --- /dev/null +++ b/users/rossenbach/experiments/librispeech/ctc_rnnt_standalone_2024/data/bpe_lm.py @@ -0,0 +1,186 @@ +from sisyphus import tk +from sisyphus.delayed_ops import DelayedFormat + +from dataclasses import dataclass +import os +from typing import Any, Dict, Optional + +from i6_core.text.label.subword_nmt.apply import ApplyBPEToTextJob +from i6_core.corpus.convert import CorpusToTxtJob +from i6_core.text.processing import ConcatenateJob +from i6_core.returnn.config import CodeWrapper + +from i6_experiments.common.setups.returnn.datasets import MetaDataset, ControlDataset, Dataset +from i6_experiments.common.setups.returnn.datastreams.base import Datastream +from i6_experiments.common.setups.returnn.datastreams.vocabulary import BpeDatastream +from i6_experiments.common.helpers.text_labels.subword_nmt_bpe import get_returnn_subword_nmt + +from i6_experiments.common.datasets.librispeech import get_bliss_corpus_dict +from i6_experiments.common.datasets.librispeech.vocab import get_subword_nmt_bpe_v2 +from i6_experiments.common.datasets.librispeech.language_model import get_librispeech_normalized_lm_data + + + +SOURCE_DATASTREAM_KEY = "data" +TARGET_DATASTREAN_KEY = "delayed" + + +@dataclass(frozen=True) +class TrainingDatasets: + train: Dataset + cv: Dataset + devtrain: Dataset + datastreams: Dict[str, Datastream] + + +class LmDataset(ControlDataset): + + def __init__( + self, + *, + corpus_file: tk.Path, + vocab_file: tk.Path, + # super parameters + partition_epoch: Optional[int] = None, + segment_file: Optional[tk.Path] = None, + seq_ordering: Optional[str] = None, + random_subset: Optional[int] = None, + additional_options: Optional[Dict] = None, + ): + super().__init__( + partition_epoch=partition_epoch, + segment_file=segment_file, + seq_ordering=seq_ordering, + random_subset=random_subset, + additional_options=additional_options + ) + + self.corpus_file = corpus_file + self.vocab_file = vocab_file + + def as_returnn_opts(self) -> Dict[str, Any]: + d = { + "class": "LmDataset", + "corpus_file": CodeWrapper(DelayedFormat('lambda: cf("{}")', self.corpus_file)), + "orth_symbols_map_file": self.vocab_file, + "orth_replace_map_file": "", + "word_based": True, + "seq_end_symbol": "", + "auto_replace_unknown_symbol": False, + "unknown_symbol": "", + "add_delayed_seq_data": True, + "delayed_seq_data_start_symbol": "", + } + sd = super().as_returnn_opts() + assert all([k not in sd.keys() for k in d.keys()]), ( + "conflicting keys in %s and %s" + % (str(list(sd.keys())), str(list(d.keys()))), + ) + d.update(sd) + + return d + +@dataclass() +class LMDatasetSettings: + train_partition_epoch: int + train_seq_ordering: str + + +def get_subword_repo(): + """ + This is a for now very ugly helper to get the same subword_nmt repo + as the get_subword_nmt_bpe_v2 is using + :return: + """ + subword_nmt_repo = get_returnn_subword_nmt( + commit_hash="5015a45e28a958f800ef1c50e7880c0c9ef414cf", output_prefix="" + ) + # overwrite hash for future bugfixes, it is unlikely the logic will ever be changed + subword_nmt_repo.hash_overwrite = "I6_SUBWORD_NMT_V2" + return subword_nmt_repo + +def build_lm_training_datasets(prefix, librispeech_key, bpe_size, settings: LMDatasetSettings): + + #data_map = {SOURCE_DATASTREAM_KEY: ("lm_dataset", "data"), TARGET_DATASTREAN_KEY: ("lm_dataset", "delayed")} + #def make_meta(dataset: LmDataset): + # return MetaDataset( + # data_map=data_map, datasets={"lm_dataset": dataset}, seq_order_control_dataset="lm_dataset" + # ) + + bpe_settings = get_subword_nmt_bpe_v2(corpus_key=librispeech_key, bpe_size=bpe_size, unk_label='') + ls_bliss_corpus_dict = get_bliss_corpus_dict() + bpe_datastream = BpeDatastream(available_for_inference=False, bpe_settings=bpe_settings) + + #### Training Data #### + + lm_data = get_librispeech_normalized_lm_data() + ls_train_bliss = ls_bliss_corpus_dict["train-other-960"] + ls_train_text = CorpusToTxtJob( + bliss_corpus=ls_train_bliss, + gzip=True, + ).out_txt + full_train_text = ConcatenateJob( + text_files=[lm_data, ls_train_text], + zip_out=True, + ).out + lm_bpe_data_job = ApplyBPEToTextJob( + text_file=full_train_text, + bpe_codes=bpe_settings.bpe_codes, + bpe_vocab=bpe_settings.bpe_count_vocab, + gzip_output=True, + subword_nmt_repo=get_subword_repo(), + mini_task=False, # this is a large file, so run in cluster + ) + lm_bpe_data_job.add_alias(os.path.join(prefix, "apply_bpe_to_train")) + + #### Dev Data #### + + dev_clean_text = CorpusToTxtJob(bliss_corpus=ls_bliss_corpus_dict["dev-clean"], gzip=True).out_txt + dev_other_text = CorpusToTxtJob(bliss_corpus=ls_bliss_corpus_dict["dev-other"], gzip=True).out_txt + cv_text = ConcatenateJob( + text_files=[dev_clean_text, dev_other_text], + zip_out=True, + ).out + cv_bpe_data_job = ApplyBPEToTextJob( + text_file=cv_text, + bpe_codes=bpe_settings.bpe_codes, + bpe_vocab=bpe_settings.bpe_count_vocab, + gzip_output=True, + subword_nmt_repo=get_subword_repo(), + ) + + #### datasets #### + lm_train_dataset = LmDataset( + corpus_file=lm_bpe_data_job.out_bpe_text, + vocab_file=bpe_settings.bpe_vocab, + partition_epoch=settings.train_partition_epoch, + segment_file=None, + seq_ordering=settings.train_seq_ordering + ) + + lm_cv_dataset = LmDataset( + corpus_file=cv_bpe_data_job.out_bpe_text, + vocab_file=bpe_settings.bpe_vocab, + partition_epoch=1, + segment_file=None, + seq_ordering="sorted" + ) + + lm_devtrain_dataset = LmDataset( + corpus_file=lm_bpe_data_job.out_bpe_text, + vocab_file=bpe_settings.bpe_vocab, + partition_epoch=1, + segment_file=None, + seq_ordering="sorted", + random_subset=3000, + ) + + return TrainingDatasets( + train=lm_train_dataset, + cv=lm_cv_dataset, + # devtrain=lm_devtrain_dataset, + # TODO: Ultra hack for now + devtrain=lm_cv_dataset, + datastreams={"data": bpe_datastream, "delayed": bpe_datastream}, + ) + diff --git a/users/rossenbach/experiments/librispeech/ctc_rnnt_standalone_2024/experiments/lm_bpe/__init__.py b/users/rossenbach/experiments/librispeech/ctc_rnnt_standalone_2024/experiments/lm_bpe/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/users/rossenbach/experiments/librispeech/ctc_rnnt_standalone_2024/experiments/lm_bpe/kazuki_lstm.py b/users/rossenbach/experiments/librispeech/ctc_rnnt_standalone_2024/experiments/lm_bpe/kazuki_lstm.py new file mode 100644 index 000000000..64dfdfe00 --- /dev/null +++ b/users/rossenbach/experiments/librispeech/ctc_rnnt_standalone_2024/experiments/lm_bpe/kazuki_lstm.py @@ -0,0 +1,77 @@ +from sisyphus import tk + +from dataclasses import asdict +from typing import cast + +from i6_experiments.common.setups.returnn.datastreams.vocabulary import LabelDatastream + +from ...data.bpe_lm import build_lm_training_datasets, LMDatasetSettings +from ...default_tools import RETURNN_EXE, MINI_RETURNN_ROOT +from ...pipeline import training + + +def bpe_kazuki_lstm(): + prefix_name = "experiments/librispeech/ctc_rnnt_standalone_2024/kazuki_lstm/" + + train_settings = LMDatasetSettings( + train_partition_epoch=4, + train_seq_ordering="laplace:.100", + ) + + # build the training datasets object containing train, cv, dev-train and the extern_data dict + train_data_bpe10k = build_lm_training_datasets( + prefix=prefix_name, + librispeech_key="train-other-960", + bpe_size=10000, + settings=train_settings, + ) + label_datastream_bpe5000 = cast(LabelDatastream, train_data_bpe10k.datastreams["data"]) + vocab_size_without_blank = label_datastream_bpe5000.vocab_size + + default_returnn = { + "returnn_exe": RETURNN_EXE, + "returnn_root": MINI_RETURNN_ROOT, + } + + from ...pytorch_networks.lm.lstm.kazuki_lstm_zijian_variant_v1_cfg import ModelConfig + + default_init_args = { + 'init_args_w': {'func': 'normal', 'arg': {'mean': 0.0, 'std': 0.1}}, + 'init_args_b': {'func': 'normal', 'arg': {'mean': 0.0, 'std': 0.1}} + } + + lstm_base_config = ModelConfig( + vocab_dim=vocab_size_without_blank, + embed_dim=512, + hidden_dim=2048, + n_lstm_layers=2, + use_bottle_neck=False, + dropout=0.2, + init_args=default_init_args, + ) + + train_config_24gbgpu = { + "optimizer": {"class": "SGD"}, + ############# + "batch_size": 1280, # BPE tokens + "accum_grad_multiple_step": 1, + "learning_rate": 1.0, + "decay": 0.8, + "multi_num_epochs": train_settings.train_partition_epoch, + "relative_error_threshold": 0, + "multi_update_interval": 1, + "error_measure": "dev_ce", + } + + network_module = "lm.lstm.kazuki_lstm_zijian_variant_v1" + train_args = { + "config": train_config_24gbgpu, + "network_module": network_module, + "net_args": {"model_config_dict": asdict(lstm_base_config)}, + "debug": False, + "add_cache_manager": True, + } + + training_name = prefix_name + "/" + network_module + ".512dim_sub6_24gbgpu_50eps" + train_job = training(training_name, train_data_bpe10k, train_args, num_epochs=30, **default_returnn) + train_job.rqmt["gpu_mem"] = 24 diff --git a/users/rossenbach/experiments/librispeech/ctc_rnnt_standalone_2024/pytorch_networks/lm/__init__.py b/users/rossenbach/experiments/librispeech/ctc_rnnt_standalone_2024/pytorch_networks/lm/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/users/rossenbach/experiments/librispeech/ctc_rnnt_standalone_2024/pytorch_networks/lm/lstm/__init__.py b/users/rossenbach/experiments/librispeech/ctc_rnnt_standalone_2024/pytorch_networks/lm/lstm/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/users/rossenbach/experiments/librispeech/ctc_rnnt_standalone_2024/pytorch_networks/lm/lstm/kazuki_lstm_zijian_variant_v1.py b/users/rossenbach/experiments/librispeech/ctc_rnnt_standalone_2024/pytorch_networks/lm/lstm/kazuki_lstm_zijian_variant_v1.py new file mode 100644 index 000000000..2450df5d3 --- /dev/null +++ b/users/rossenbach/experiments/librispeech/ctc_rnnt_standalone_2024/pytorch_networks/lm/lstm/kazuki_lstm_zijian_variant_v1.py @@ -0,0 +1,108 @@ +import torch +from torch import nn + +from .kazuki_lstm_zijian_variant_v1_cfg import ModelConfig + +def mask_tensor(tensor: torch.Tensor, seq_len: torch.Tensor) -> torch.Tensor: + """ + mask a tensor with a "positive" mask (boolean true means position is used) + + :param tensor: [B,T,....] + :param seq_len: [B] + :return: [B,T] as boolean + """ + seq_len = seq_len.to(device=tensor.device) + r = torch.arange(tensor.shape[1], device=tensor.device) # [T] + seq_mask = torch.less(r[None, :], seq_len[:, None]) # broadcast to [B,T] + return seq_mask + + +class Model(nn.Module): + """ + Simple LSTM LM with an embedding, an LSTM, and a final linear + """ + def __init__(self, model_config_dict, **kwargs): + super().__init__() + self.cfg = ModelConfig(**model_config_dict) + if self.cfg.dropout > 0: + self.dropout = nn.Dropout(p=self.cfg.dropout) + else: + self.dropout = None + self.use_bottle_neck = self.cfg.use_bottle_neck + self.embed = nn.Embedding(self.cfg.vocab_dim, self.cfg.embed_dim) + self.lstm = nn.LSTM( + input_size=self.cfg.embed_dim, + hidden_size=self.cfg.hidden_dim, + num_layers=self.cfg.n_lstm_layers, + bias=self.cfg.bias, + batch_first=True, + dropout=self.cfg.dropout, + bidirectional=False, + ) + if self.cfg.use_bottle_neck: + self.bottle_neck = nn.Linear(self.cfg.hidden_dim,self.cfg.bottle_neck_dim, bias=True) + self.final_linear = nn.Linear(self.cfg.bottle_neck_dim, self.cfg.vocab_dim, bias=True) + else: + self.final_linear = nn.Linear(self.cfg.hidden_dim, self.cfg.vocab_dim, bias=True) + self._param_init(**self.cfg.init_args) + + + def _param_init(self, init_args_w=None, init_args_b=None): + if init_args_w is None: + init_args_w = {'func': 'normal', 'arg': {'mean': 0.0, 'std': 0.1}} + if init_args_b is None: + init_args_b = {'func': 'normal', 'arg': {'mean': 0.0, 'std': 0.1}} + + for m in self.modules(): + + for name, param in m.named_parameters(): + if 'bias' in name: + if init_args_b['func'] == 'normal': + init_func = nn.init.normal_ + else: + NotImplementedError + hyp = init_args_b['arg'] + else: + if init_args_w['func'] == 'normal': + init_func = nn.init.normal_ + else: + NotImplementedError + hyp = init_args_w['arg'] + init_func(param, **hyp) + + def forward(self, x): + """ + Return logits of each batch at each time step + x: (B, S, F) + """ + x = self.embed(x) + if self.dropout: + x = self.dropout(x) + batch_size = x.shape[0] + h0 = torch.zeros((self.cfg.n_lstm_layers, batch_size, self.cfg.hidden_dim), device=x.device).detach() + c0 = torch.zeros_like(h0, device=x.device).detach() + # This is a uni-directional LSTM, so sequence masking is not necessary + x, _ = self.lstm(x, (h0, c0)) + if self.dropout: + x = self.dropout(x) + if self.use_bottle_neck: + x = self.bottle_neck(x) + if self.dropout: + x = self.dropout(x) + x = self.final_linear(x) + return x + + +def train_step(*, model: Model, data, run_ctx, **kwargs): + labels = data["ldata"] + labels_len = data["data:size1"] + delayed_labels = data["delayed"] + + lm_logits = model(delayed_labels) # (B, S, F) + + ce_loss = torch.nn.functional.cross_entropy(lm_logits.transpose(1, 2), labels, reduction='none') + seq_mask = mask_tensor(labels, labels_len) + ce_loss = (ce_loss * seq_mask).sum() + total_length = torch.sum(labels_len) + + run_ctx.mark_as_loss(name="ce", loss=ce_loss, inv_norm_factor=total_length) diff --git a/users/rossenbach/experiments/librispeech/ctc_rnnt_standalone_2024/pytorch_networks/lm/lstm/kazuki_lstm_zijian_variant_v1_cfg.py b/users/rossenbach/experiments/librispeech/ctc_rnnt_standalone_2024/pytorch_networks/lm/lstm/kazuki_lstm_zijian_variant_v1_cfg.py new file mode 100644 index 000000000..8c8926917 --- /dev/null +++ b/users/rossenbach/experiments/librispeech/ctc_rnnt_standalone_2024/pytorch_networks/lm/lstm/kazuki_lstm_zijian_variant_v1_cfg.py @@ -0,0 +1,15 @@ +from dataclasses import dataclass + +from i6_models.config import ModelConfiguration + +@dataclass +class ModelConfig(): + vocab_dim: int + embed_dim: int + hidden_dim: int + n_lstm_layers: int + init_args: dict + bias: bool = True + use_bottle_neck: bool = False + bottle_neck_dim: int = 512 + dropout: float = 0.0 From ebbf720b5d0aef0e508007185acddd45bfada95e Mon Sep 17 00:00:00 2001 From: schmitt Date: Thu, 23 May 2024 10:18:49 +0200 Subject: [PATCH 049/227] update --- users/schmitt/augmentation/alignment.py | 605 +++++++++--------- .../att_weights.py | 2 - .../labels/v2/librispeech/label_singletons.py | 4 + .../returnn/config_builder/base.py | 21 +- .../returnn/config_builder/global_.py | 12 +- .../returnn/config_builder/segmental.py | 47 +- .../network_builder/network_builder.py | 73 ++- .../center_window_att/baseline_v2/__init__.py | 56 +- .../center_window_att/recog.py | 6 +- .../pipelines/pipeline_ls_conf/checkpoints.py | 3 +- .../global_att/baseline_v1/__init__.py | 11 + .../global_vs_segmental_2022_23/recog_new.py | 11 +- .../global_vs_segmental_2022_23/train_new.py | 13 +- .../returnn/config_builder_rf/base.py | 28 +- .../returnn/network_builder_rf/base.py | 3 - .../network_builder_rf/global_/model.py | 7 +- .../returnn/network_builder_rf/recog.py | 2 + .../network_builder_rf/segmental/model.py | 59 +- .../segmental/model_new/blank_model/model.py | 195 ++++-- .../segmental/model_new/blank_model/train.py | 113 +++- .../segmental/model_new/label_model/model.py | 80 +-- .../segmental/model_new/label_model/train.py | 41 +- .../network_builder_rf/segmental/recog.py | 271 ++++++-- .../network_builder_rf/segmental/train.py | 153 +++-- .../network_builder_rf/segmental/utils.py | 18 +- .../pipelines/pipeline_ls_conf/__init__.py | 5 +- .../center_window_att/baseline_v1/__init__.py | 24 +- .../center_window_att/baseline_v1/baseline.py | 62 +- .../center_window_att/baseline_v2/__init__.py | 40 -- .../center_window_att/baseline_v3/__init__.py | 56 ++ .../{baseline_v2 => baseline_v3}/alias.py | 2 +- .../center_window_att/baseline_v3/baseline.py | 20 + .../center_window_att/baseline_v4/__init__.py | 26 + .../center_window_att/baseline_v4/alias.py | 4 + .../center_window_att/baseline_v4/baseline.py | 18 + .../baseline.py => config_builder.py} | 40 +- .../center_window_att/train.py | 132 ++-- .../global_att/baseline_v1/__init__.py | 2 +- .../pipeline_ls_conf/global_att/train.py | 21 +- 39 files changed, 1432 insertions(+), 854 deletions(-) delete mode 100644 users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v2/__init__.py create mode 100644 users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v3/__init__.py rename users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/{baseline_v2 => baseline_v3}/alias.py (82%) create mode 100644 users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v3/baseline.py create mode 100644 users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v4/__init__.py create mode 100644 users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v4/alias.py create mode 100644 users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v4/baseline.py rename users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/{baseline_v2/baseline.py => config_builder.py} (62%) diff --git a/users/schmitt/augmentation/alignment.py b/users/schmitt/augmentation/alignment.py index 3953fbf19..e0aef7eca 100644 --- a/users/schmitt/augmentation/alignment.py +++ b/users/schmitt/augmentation/alignment.py @@ -1,119 +1,25 @@ -import tensorflow as tf import numpy as np from matplotlib import pyplot as plt -import contextlib import ast from collections import Counter +import torch +from torch.utils.data import DataLoader +from typing import Sequence from i6_experiments.users.schmitt.hdf import load_hdf_data -from i6_experiments.users.schmitt.visualization.visualization import PlotAlignmentJob +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental import utils + +import returnn.frontend as rf +from returnn.tensor import Dim +from returnn.datasets.hdf import HDFDataset +from returnn.datasets.basic import Dataset +from returnn.torch.data import extern_data as extern_data_util from sisyphus import Path -def shift_alignment_boundaries_v1(data, blank_idx, max_shift, network): - """ - We take as input a batch of alignments (B, T) and output a batch of new alignments by randomly moving the alignment - boundaries with a maximum shift of `max_shift`. - This was my first implementation, which led to errors in RETURNN and which had a bias. - :param data: - :param blank_idx: - :param max_shift: - :param network: - :return: - """ +def shift_alignment_boundaries_single_seq(alignment: np.ndarray, blank_idx: int, max_shift: int): import tensorflow as tf - - x = data.get_placeholder_as_batch_major() - seq_lens = data.get_sequence_lengths() - max_shift = tf.constant(max_shift) - - @tf.function - def get_augmented_alignment(): - # the batch with the new alignments - new_data = tf.TensorArray( - tf.int32, - size=tf.shape(x)[0], - dynamic_size=True, - clear_after_read=True - ) - - i = 0 - - # go over each alignment - for alignment in x: - # positions of non-blank labels in the original alignment - non_blank_pos = tf.cast(tf.where(tf.not_equal(alignment, blank_idx)), dtype=tf.dtypes.int32) - nb_labels = alignment[tf.not_equal(alignment, blank_idx)] - # prepend -1 and append seq_len of alignment to the positions - non_blank_pos_ext = tf.concat((tf.constant([[-1]]), non_blank_pos, [[seq_lens[i]]]), axis=0) - # from these extended positions, we get the amount of left and right space of each label - right_spaces = non_blank_pos_ext[2:] - non_blank_pos_ext[1:-1] - 1 - left_spaces = non_blank_pos_ext[1:-1] - non_blank_pos_ext[:-2] - 1 - # the maximum shifting amount is then determined by the amount of space and the max_shift parameter - max_left_shift = tf.where(tf.greater(left_spaces, max_shift), max_shift, left_spaces) - max_right_shift = tf.where(tf.greater(right_spaces, max_shift), max_shift, right_spaces) - - # concat the tensors in order to loop over them - nb_datas = tf.concat( - ( - non_blank_pos, - max_left_shift, - max_right_shift - ), - axis=-1) - - # create an array of new positions - new_non_blank_pos = tf.TensorArray( - tf.int32, - size=tf.shape(non_blank_pos)[0], - dynamic_size=True, - clear_after_read=True - ) - - # loop index - j = 0 - # store prev pos - prev_pos = tf.TensorArray( - tf.int32, - size=1, - dynamic_size=True, - clear_after_read=True - ) - for nb_data in nb_datas: - # the min and max value of the new position is given by the current position and the maximum left and right shift - minval = nb_data[0] - nb_data[1] - maxval = nb_data[0] + nb_data[2] - - # if we are past the first element, the left boundary is additionally constrained by the new position of - # the previous label - if j > 0: - minval = tf.maximum(minval, prev_pos.read(0) + 1) - # the new position is uniformly sampled within the possible boundaries - new_pos = tf.random.uniform((1,), minval=minval, maxval=maxval + 1, dtype=tf.dtypes.int32) - prev_pos = prev_pos.write(0, tf.squeeze(new_pos)) - new_non_blank_pos = new_non_blank_pos.write(j, new_pos) - j += 1 - - # stack the new positions into an array - new_non_blank_pos = new_non_blank_pos.stack() - - # scatter the labels into the new alignment according to the new positions - output_shape = tf.expand_dims(tf.shape(alignment)[0], axis=0) - # add 1 to the labels here because a label might have value 0 which is the same as the default value in scatter - new_alignment = tf.scatter_nd(new_non_blank_pos, nb_labels + 1, output_shape) - # subtract 1 again from the labels in the final alignment and replace the 0's with the blank idx - new_alignment = tf.where(tf.equal(new_alignment, 0), blank_idx, new_alignment - 1) - - new_data = new_data.write(i, new_alignment) - i += 1 - - return new_data.stack() - - return get_augmented_alignment() - - -def shift_alignment_boundaries_v2(alignment: np.ndarray, blank_idx: int, max_shift: int): alignment = tf.convert_to_tensor(alignment) labels = alignment[tf.not_equal(alignment, blank_idx)] label_positions = tf.cast(tf.where(tf.not_equal(alignment, blank_idx)), tf.int32)[:, 0] # [S] @@ -152,205 +58,203 @@ def shift_alignment_boundaries_v2(alignment: np.ndarray, blank_idx: int, max_shi return new_alignment.numpy() -shift_alignment_boundaries_func_str = """ -def shift_alignment_boundaries(data, network): - import tensorflow as tf +def shift_alignment_boundaries_batched( + alignment: rf.Tensor, + alignment_spatial_dim: Dim, + batch_dims: Sequence[Dim], + blank_idx: int, + max_shift: int, +): + non_blank_mask = rf.logical_and( + alignment != rf.convert_to_tensor(blank_idx), + rf.sequence_mask(alignment.dims) + ) + labels, labels_spatial_dim = utils.get_masked(alignment, non_blank_mask, alignment_spatial_dim, batch_dims) + + label_positions = rf.where( + non_blank_mask, rf.range_over_dim(alignment_spatial_dim), rf.convert_to_tensor(-1)) + label_positions, _ = utils.get_masked( + label_positions, + non_blank_mask, + alignment_spatial_dim, + batch_dims, + labels_spatial_dim + ) + + labels_spatial_dim.dyn_size_ext.raw_tensor = rf.copy_to_device(labels_spatial_dim.dyn_size_ext, alignment.device).raw_tensor + singleton_dim = Dim(description="singleton", dimension=1, kind=Dim.Types.Spatial) + label_positions_ext, label_positions_ext_spatial_dim = rf.concat( + (rf.expand_dim(rf.copy_to_device(alignment_spatial_dim.dyn_size_ext, alignment.device), singleton_dim), singleton_dim), + (rf.reverse_sequence(label_positions, axis=labels_spatial_dim), labels_spatial_dim), + allow_broadcast=True, + ) + label_positions_ext, label_positions_ext_spatial_dim = rf.concat( + (rf.expand_dim(rf.convert_to_tensor(-1, device=alignment.device), singleton_dim), singleton_dim), + (rf.reverse_sequence(label_positions_ext, axis=label_positions_ext_spatial_dim), label_positions_ext_spatial_dim), + allow_broadcast=True, + ) + + # for each label, the distance to the next label on the right and left (or to the sequence boundaries) + distance_right = rf.gather( + label_positions_ext, + indices=rf.range_over_dim(labels_spatial_dim) + 2, + axis=label_positions_ext_spatial_dim + ) - label_positions - 1 # [S] + distance_left = label_positions - rf.gather( + label_positions_ext, + indices=rf.range_over_dim(labels_spatial_dim), + axis=label_positions_ext_spatial_dim + ) - 1 # [S] + + # find the (common) uneven distances + # ignore the last right distance and the first left distance as they are not shared + labels_spatial_dim_minus_one = labels_spatial_dim - 1 + labels_spatial_dim_minus_one_range = rf.range_over_dim(labels_spatial_dim_minus_one) + distance_right_uneven = rf.gather( + rf.convert_to_tensor(distance_right % 2 != 0), + indices=labels_spatial_dim_minus_one_range, + axis=labels_spatial_dim + ) # [S-1] + distance_left_uneven = rf.gather( + rf.convert_to_tensor(distance_left % 2 != 0), + indices=labels_spatial_dim_minus_one_range + 1, + axis=labels_spatial_dim + ) # [S-1] + + assert rf.reduce_all( + distance_right_uneven == distance_left_uneven, + axis=labels_spatial_dim_minus_one, + use_mask=False, # not implemented otherwise + ), "Uneven distances are not equal." - blank_idx = {blank_idx} - max_shift = {max_shift} - - x = data.get_placeholder_as_batch_major() - seq_lens = data.get_sequence_lengths() - max_shift = tf.constant(max_shift) - - @tf.function - def get_augmented_alignment(): - # the batch with the new alignments - new_data = tf.TensorArray( - tf.int32, - size=tf.shape(x)[0], - dynamic_size=True, - clear_after_read=True + # randomly choose whether to ceil or floor the uneven distances + random_ceil = rf.random_uniform(dims=distance_right_uneven.dims, dtype="int32", minval=0, maxval=2) + + singleton_zero_tensor = rf.zeros(batch_dims + [singleton_dim], dtype="int32") + random_ceil_right = rf.where(distance_right_uneven, random_ceil, rf.zeros_like(random_ceil)) + random_ceil_right, _ = rf.concat( + (random_ceil_right, labels_spatial_dim_minus_one), + (singleton_zero_tensor, singleton_dim), + out_dim=labels_spatial_dim, + ) + random_ceil_left = rf.where(distance_left_uneven, random_ceil, rf.ones_like(random_ceil)) + random_ceil_left, _ = rf.concat( + (singleton_zero_tensor + 1, singleton_dim), + (random_ceil_left, labels_spatial_dim_minus_one), + out_dim=labels_spatial_dim, + ) + + # can at most use half of the space to the right except for the last (or first) label + # use floor division in both cases and then apply random ceil + distance_right, _ = rf.concat( + (rf.gather(distance_right, indices=labels_spatial_dim_minus_one_range, axis=labels_spatial_dim) // 2, labels_spatial_dim_minus_one), + (rf.gather(distance_right, indices=singleton_zero_tensor + labels_spatial_dim.dyn_size_ext - 1, axis=labels_spatial_dim), singleton_dim), + out_dim=labels_spatial_dim, + ) + distance_left, _ = rf.concat( + (rf.gather(distance_left, indices=singleton_zero_tensor, axis=labels_spatial_dim), singleton_dim), + (rf.gather(distance_left, indices=labels_spatial_dim_minus_one_range + 1, axis=labels_spatial_dim) // 2, labels_spatial_dim_minus_one), + out_dim=labels_spatial_dim, + ) + + distance_right += random_ceil_right + distance_left += 1 - random_ceil_left + + # random shift is either max_shift or the available space to the right or left + random_shift = rf.random_uniform( + dims=label_positions.dims, dtype="int32", minval=-max_shift, maxval=max_shift + 1) + random_shift = rf.clip_by_value(random_shift, -distance_left, distance_right) + + # new positions are the old positions plus the random shift + new_positions = label_positions + random_shift + assert rf.reduce_all( + rf.gather( + new_positions, indices=labels_spatial_dim_minus_one_range + 1, axis=labels_spatial_dim + ) > rf.gather( + new_positions, indices=labels_spatial_dim_minus_one_range, axis=labels_spatial_dim + ), + axis=labels_spatial_dim_minus_one, + use_mask=False, # not implemented otherwise + ), "New positions are not sorted anymore." + + # set new positions in the padded area to the (last + 1) position of the new alignment and cut that position off later + alignment_spatial_dim_plus_one = alignment_spatial_dim + 1 + new_positions = rf.cast(new_positions, "int64") + new_positions = rf.where( + rf.sequence_mask(new_positions.dims), + new_positions, + rf.copy_to_device( + rf.reduce_max( + alignment_spatial_dim_plus_one.dyn_size_ext, axis=alignment_spatial_dim_plus_one.dyn_size_ext.dims) - 1, + alignment.device ) + ) - i = 0 - - # go over each alignment - for alignment in x: - # positions of non-blank labels in the original alignment - non_blank_pos = tf.cast(tf.where(tf.not_equal(alignment, blank_idx)), dtype=tf.dtypes.int32) - nb_labels = alignment[tf.not_equal(alignment, blank_idx)] - # prepend -1 and append seq_len of alignment to the positions - non_blank_pos_ext = tf.concat((tf.constant([[-1]]), non_blank_pos, [[seq_lens[i]]]), axis=0) - # from these extended positions, we get the amount of left and right space of each label - right_spaces = non_blank_pos_ext[2:] - non_blank_pos_ext[1:-1] - 1 - left_spaces = non_blank_pos_ext[1:-1] - non_blank_pos_ext[:-2] - 1 - # the maximum shifting amount is then determined by the amount of space and the max_shift parameter - max_left_shift = tf.where(tf.greater(left_spaces, max_shift), max_shift, left_spaces) - max_right_shift = tf.where(tf.greater(right_spaces, max_shift), max_shift, right_spaces) - - # concat the tensors in order to loop over them - nb_datas = tf.concat( - ( - non_blank_pos, - max_left_shift, - max_right_shift - ), - axis=-1) - - # create an array of new positions - new_non_blank_pos = tf.TensorArray( - tf.int32, - size=tf.shape(non_blank_pos)[0], - dynamic_size=True, - clear_after_read=True - ) + # extend the alignment by one in the spatial dimension to store the labels in the padded area + new_alignment_ext = alignment.copy_template_replace_dim_tag( + axis=alignment.get_axis_from_description(alignment_spatial_dim), + new_dim_tag=alignment_spatial_dim_plus_one + ) + new_alignment_ext = new_alignment_ext.copy_transpose(batch_dims + [alignment_spatial_dim_plus_one]) - # loop index - j = 0 - # store prev pos - prev_pos = tf.TensorArray( - tf.int32, - size=1, - dynamic_size=True, - clear_after_read=True - ) - for nb_data in nb_datas: - # the min and max value of the new position is given by the current position and the maximum left and right shift - minval = nb_data[0] - nb_data[1] - maxval = nb_data[0] + nb_data[2] - - # if we are past the first element, the left boundary is additionally constrained by the new position of - # the previous label - if j > 0: - minval = tf.maximum(minval, prev_pos.read(0) + 1) - # the new position is uniformly sampled within the possible boundaries - new_pos = tf.random.uniform((1,), minval=minval, maxval=maxval + 1, dtype=tf.dtypes.int32) - prev_pos = prev_pos.write(0, tf.squeeze(new_pos)) - new_non_blank_pos = new_non_blank_pos.write(j, new_pos) - j += 1 - - # stack the new positions into an array - new_non_blank_pos = new_non_blank_pos.stack() - - # scatter the labels into the new alignment according to the new positions - output_shape = tf.expand_dims(tf.shape(alignment)[0], axis=0) - # add 1 to the labels here because a label might have value 0 which is the same as the default value in scatter - new_alignment = tf.scatter_nd(new_non_blank_pos, nb_labels + 1, output_shape) - # subtract 1 again from the labels in the final alignment and replace the 0's with the blank idx - new_alignment = tf.where(tf.equal(new_alignment, 0), blank_idx, new_alignment - 1) - - new_data = new_data.write(i, new_alignment) - i += 1 - - return new_data.stack() - - return get_augmented_alignment() -""" - - -@contextlib.contextmanager -def make_scope(): - """ - :rtype: tf.compat.v1.Session - """ - - import returnn.tf.compat as tf_compat - with tf.Graph().as_default() as graph: - with tf_compat.v1.Session(graph=graph) as session: - yield session - - -def test_alignment_augmentation_in_returnn(): - from returnn.config import Config - from returnn.tf.network import TFNetwork - import returnn.tf.compat as tf_compat - - with make_scope() as session: - config = Config() - config.update({ - "shift_alignment_boundaries": shift_alignment_boundaries_v1, - "extern_data": { - "data": { - "dim": 10, - "sparse": True - } - }, - "network": { - "augmented_align": { - "class": "eval", - "from": "data:data", - "eval": "self.network.get_config().typed_value('shift_alignment_boundaries')(source(0, as_data=True), blank_idx=0, max_shift=4, network=self.network)" - }, - "output": {"class": "copy", "from": ["augmented_align"]}, - }}) - network = TFNetwork(config=config, train_flag=True) - network.construct_from_dict(config.typed_value("network")) - - session.run(tf_compat.v1.global_variables_initializer()) - out = network.layers["output"].output.placeholder - n_batch = 2 - seq_len = 21 - input_data = np.array([ - [0, 0, 0, 4, 0, 0, 8, 0, 2, 0, 0, 0, 0, 6, 0, 0, 0, 0, 3, 0, 0], - [0, 7, 0, 6, 2, 0, 0, 7, 0, 6, 0, 0, 5, 0, 0, 0, 0, 0, 5, 0, 0] - ], - dtype="int32") - seq_lens = np.array([seq_len, seq_len], dtype="int32") - assert input_data.shape == (n_batch, seq_lens[0]) - feed = {network.extern_data.data["data"].placeholder: input_data, - network.extern_data.data["data"].size_placeholder[0]: seq_lens, - # network.extern_data.data["seq_tag"].placeholder: input_tags - } - - print("input: ", input_data) - out = session.run([out, network.get_post_control_dependencies()], feed_dict=feed) - - print("output: ", out) - - network.call_graph_reset_callbacks() - - -def calculate_shift_statistics_over_corpus(max_shift, num_iterations, alignment_data, blank_idx): - label_position_diff_counter = Counter() - for i, (seq_tag, alignment_old) in enumerate(alignment_data.items()): - if i % 100 == 0: - print(i) + # scatter the labels into the new alignment according to the new positions + new_alignment_ext.raw_tensor = torch.full( + rf.zeros_like(new_alignment_ext).raw_tensor.shape, + blank_idx, + dtype=torch.int32, + device=alignment.device + ).scatter( + dim=1, + index=new_positions.raw_tensor.long(), + src=labels.copy_transpose(batch_dims + [labels_spatial_dim]).raw_tensor, + ) - alignment_new = alignment_old.copy() - for _ in range(num_iterations): - alignment_new = shift_alignment_boundaries_v2(alignment_new, blank_idx=blank_idx, max_shift=max_shift) + new_alignment = alignment.copy() + # cut off the last position in the spatial dimension + new_alignment.raw_tensor = new_alignment_ext.raw_tensor[:, :-1] - label_positions_old = np.argwhere(alignment_old != blank_idx)[:, 0] - label_positions_new = np.argwhere(alignment_new != blank_idx)[:, 0] - label_position_diffs = label_positions_new - label_positions_old - label_position_diff_counter.update(label_position_diffs) + return new_alignment - plt.bar(label_position_diff_counter.keys(), label_position_diff_counter.values()) - plt.title(f"Label position differences for \nmax_shift={max_shift} and {num_iterations} iterations.") - plt.show() - plt.close() +def test_alignment_augmentation_single_seq(hdf_path: str): + def calculate_shift_statistics_over_corpus(max_shift, num_iterations, alignment_data, blank_idx): + label_position_diff_counter = Counter() + for i, (seq_tag, alignment_old) in enumerate(alignment_data.items()): + if i % 100 == 0: + print(i) -def compare_alignments(seq_tag, alignment_data, vocab, blank_idx, max_shift, num_iterations): - alignment_old = alignment_data[seq_tag] - alignment_new = alignment_old.copy() - for _ in range(num_iterations): - alignment_new = shift_alignment_boundaries_v2(alignment_new, blank_idx=blank_idx, max_shift=max_shift) + alignment_new = alignment_old.copy() + for _ in range(num_iterations): + alignment_new = shift_alignment_boundaries_single_seq(alignment_new, blank_idx=blank_idx, max_shift=max_shift) - labels_old = alignment_old[alignment_old != blank_idx] - labels_new = alignment_new[alignment_new != blank_idx] + label_positions_old = np.argwhere(alignment_old != blank_idx)[:, 0] + label_positions_new = np.argwhere(alignment_new != blank_idx)[:, 0] + label_position_diffs = label_positions_new - label_positions_old + label_position_diff_counter.update(label_position_diffs) - fig, ax_old = PlotAlignmentJob._get_fig_ax(alignment_old) - PlotAlignmentJob._set_ticks(ax_old, alignment_old, labels_old, vocab, blank_idx, ymin=0.5) - ax_new = ax_old.twiny() - PlotAlignmentJob._set_ticks(ax_new, alignment_new, labels_new, vocab, blank_idx, ymax=0.5, color="g") - plt.title(f"Comparison of alignment for {seq_tag} \nwith max_shift={max_shift} and {num_iterations} iterations.") - plt.show() - plt.close() + plt.bar(label_position_diff_counter.keys(), label_position_diff_counter.values()) + plt.title(f"Label position differences for \nmax_shift={max_shift} and {num_iterations} iterations.") + plt.show() + plt.close() + + def compare_alignments(seq_tag, alignment_data, vocab, blank_idx, max_shift, num_iterations): + from i6_experiments.users.schmitt.visualization.visualization import PlotAlignmentJob + alignment_old = alignment_data[seq_tag] + alignment_new = alignment_old.copy() + for _ in range(num_iterations): + alignment_new = shift_alignment_boundaries_single_seq(alignment_new, blank_idx=blank_idx, max_shift=max_shift) + + labels_old = alignment_old[alignment_old != blank_idx] + labels_new = alignment_new[alignment_new != blank_idx] + fig, ax_old = PlotAlignmentJob._get_fig_ax(alignment_old) + PlotAlignmentJob._set_ticks(ax_old, alignment_old, labels_old, vocab, blank_idx, ymin=0.5) + ax_new = ax_old.twiny() + PlotAlignmentJob._set_ticks(ax_new, alignment_new, labels_new, vocab, blank_idx, ymax=0.5, color="g") + plt.title(f"Comparison of alignment for {seq_tag} \nwith max_shift={max_shift} and {num_iterations} iterations.") + plt.show() + plt.close() -def test_alignment_augmentation(hdf_path: str): # load vocabulary as dictionary with open("/u/zeineldeen/setups/librispeech/2022-11-28--conformer-att/work/i6_core/text/label/subword_nmt/train/ReturnnTrainBpeJob.vTq56NZ8STWt/output/bpe.vocab", "r") as f: json_data = f.read() @@ -373,5 +277,122 @@ def test_alignment_augmentation(hdf_path: str): ) +def test_alignment_augmentation_batched(hdf_path: str): + from returnn.torch.data import pipeline as data_pipeline + from returnn.torch.data import returnn_dataset_wrapper + from returnn.tensor import batch_dim + + # from test_torch_dataset.py + def get_dataloader( + dataset: Dataset, mp_manager: torch.multiprocessing.Manager, *, batch_size: int = 5, max_seqs: int = 2 + ) -> DataLoader: + # Follow mostly similar logic as in the PT engine. + + epoch_mp_shared = mp_manager.Value("i", 0) + epoch_mp_shared.value = 1 + reset_callback = returnn_dataset_wrapper.ReturnnDatasetResetMpSharedEpochCallback( + dataset=dataset, epoch_mp_shared=epoch_mp_shared + ) + + wrapped_dataset = returnn_dataset_wrapper.ReturnnDatasetIterDataPipe(dataset, reset_callback=reset_callback) + + batches_dataset = data_pipeline.BatchingIterDataPipe(wrapped_dataset, batch_size=batch_size, max_seqs=max_seqs) + + # Test different ways to deepcopy/serialize the dataset. + # This is what DataLoader2 also would do, although DataLoader2 also uses dill as a fallback, + # if it is available. + # Dill is not always available though, + # so it is important that we make sure that it also works without dill. + + from copy import deepcopy + + deepcopy(batches_dataset) + + import pickle + + pickle.loads(pickle.dumps(batches_dataset)) + + return data_pipeline.create_data_loader_from_batches(batches_dataset, { + "num_workers": 1 + }) + + blank_idx = 10025 + max_shift = 2 + num_iterations = 2 + + hdf_dataset = HDFDataset([hdf_path]) + hdf_dataset.initialize() + hdf_dataset.init_seq_order(epoch=1) + + out_spatial_dim = Dim(description="out_spatial", dimension=None, kind=Dim.Types.Spatial) + vocab_dim = Dim(description="vocab", dimension=10026, kind=Dim.Types.Spatial) + + extern_data_dict = { + "data": { + "dim_tags": [batch_dim, out_spatial_dim], + "sparse_dim": vocab_dim + }, + } + extern_data = extern_data_util.extern_data_template_from_config_opts(extern_data_dict) + + mp_manager = torch.multiprocessing.Manager() + dataloader = get_dataloader(hdf_dataset, mp_manager, batch_size=10_000, max_seqs=10) + data_iter = iter(dataloader) + + label_position_diff_counter = Counter() + rf.select_backend_torch() + + seq_idx = 0 + while True: + try: + extern_data_raw = next(data_iter) + except StopIteration: + break + + extern_data_tensor_dict = extern_data_util.raw_dict_to_extern_data( + extern_data_raw, extern_data_template=extern_data, device="cpu" + ) + alignment_old = extern_data_tensor_dict["data"] + + batch_axis = alignment_old.get_axis_from_description(batch_dim) + seq_idx += alignment_old.dims[batch_axis].dyn_size_ext.raw_tensor.item() + print(f"Processing sequence {seq_idx}/{hdf_dataset.num_seqs}") + + alignment_new = alignment_old.copy() + for _ in range(num_iterations): + alignment_new = shift_alignment_boundaries_batched( + alignment_new, + alignment_spatial_dim=out_spatial_dim, + batch_dims=[batch_dim], + blank_idx=blank_idx, + max_shift=max_shift + ) + + alignment_old_raw = alignment_old.copy_transpose([batch_dim, out_spatial_dim]).raw_tensor + alignment_new_raw = alignment_new.copy_transpose([batch_dim, out_spatial_dim]).raw_tensor + seq_mask_raw = rf.sequence_mask(alignment_old.dims).copy_transpose([batch_dim, out_spatial_dim]).raw_tensor + + label_positions_old = torch.where( + torch.logical_and( + alignment_old_raw != blank_idx, + seq_mask_raw + ) + )[1] # [S] + label_positions_new = torch.where( + torch.logical_and( + alignment_new_raw != blank_idx, + seq_mask_raw + ) + )[1] # [S] + + label_position_diffs = label_positions_new - label_positions_old + label_position_diff_counter.update(label_position_diffs.numpy()) + + plt.bar(label_position_diff_counter.keys(), label_position_diff_counter.values()) + plt.title(f"Label position differences for \nmax_shift={max_shift} and {num_iterations} iterations.") + plt.show() + plt.close() + + if __name__ == "__main__": - test_alignment_augmentation("/work/asr3/zeyer/schmitt/sisyphus_work_dirs/segmental_models_2021_22/i6_core/returnn/forward/ReturnnForwardJob.1fohfY7LLczN/output/alignments.hdf") + test_alignment_augmentation_batched("/work/asr3/zeyer/schmitt/sisyphus_work_dirs/segmental_models_2021_22/i6_core/returnn/forward/ReturnnForwardJob.1fohfY7LLczN/output/alignments.hdf") diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/att_weights.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/att_weights.py index b83e65f2e..1bef63d9f 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/att_weights.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/att_weights.py @@ -96,8 +96,6 @@ def dump_att_weights( hdf_filenames["att_energies"] = "att_energies.hdf" if isinstance(config_builder, SegmentalConfigBuilder): - if hdf_alias == "ground_truth": - assert hdf_targets == ref_alignment dump_frame_probs_opts["use_train_net"] = True hdf_filenames.update({ diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/dependencies/labels/v2/librispeech/label_singletons.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/dependencies/labels/v2/librispeech/label_singletons.py index eea5f52d4..a248e57ae 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/dependencies/labels/v2/librispeech/label_singletons.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/dependencies/labels/v2/librispeech/label_singletons.py @@ -1,5 +1,9 @@ from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23.dependencies.labels.v2.librispeech.bpe.bpe_labels import LibrispeechBPE10025Labels, LibrispeechBPE10025LabelsWithSilence from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23.dependencies.labels.v2.librispeech.bpe.bpe_alignments import LibrispeechBpe10025CtcAlignment, LibrispeechBpe10025CtcAlignmentEos +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23.dependencies.corpora.librispeech import LibrispeechCorpora + + +LIBRISPEECH_CORPUS = LibrispeechCorpora() LibrispeechBPE10025_LABELS = LibrispeechBPE10025Labels() LibrispeechBPE10025_LABELS_WITH_SILENCE = LibrispeechBPE10025LabelsWithSilence(LibrispeechBPE10025_LABELS) diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/dependencies/returnn/config_builder/base.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/dependencies/returnn/config_builder/base.py index 9f8d733dd..b2d55452b 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/dependencies/returnn/config_builder/base.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/dependencies/returnn/config_builder/base.py @@ -99,8 +99,6 @@ def get_train_config(self, opts: Dict, python_epilog: Optional[Dict] = None): ) ) net_dict = self.get_net_dict("train", config_dict=config_dict, python_prolog=python_prolog) - if opts.get("align_augment", False): - self.add_align_augment(net_dict=net_dict, networks_dict=networks_dict, python_prolog=python_prolog) if opts.get("dataset_opts", {}).get("use_speed_pert"): python_prolog.append(speed_pert_str) @@ -126,8 +124,10 @@ def get_train_config(self, opts: Dict, python_epilog: Optional[Dict] = None): version=decoder_version, net_dict=net_dict, train=True, - target_num_labels=self.dependencies.model_hyperparameters.target_num_labels_wo_blank + target_num_labels=self.dependencies.model_hyperparameters.target_num_labels_wo_blank, + python_prolog=python_prolog, ) + config_dict["network"] = net_dict if opts.get("cleanup_old_models"): @@ -185,7 +185,8 @@ def get_recog_config(self, opts: Dict): net_dict = self.get_net_dict("search", config_dict=config_dict, python_prolog=python_prolog) if net_dict is not None: - net_dict.pop("ctc") # not needed during recognition + if not opts.get("ctc_shallow_fusion_opts"): + net_dict.pop("ctc") # not needed during recognition # set beam size net_dict["output"]["unit"]["output"]["beam_size"] = opts.get("beam_size", self.get_default_beam_size()) @@ -315,15 +316,19 @@ def edit_network_only_train_length_model(self, net_dict: Dict): def edit_network_freeze_encoder(self, net_dict: Dict): pass - def edit_network_modify_decoder(self, version: int, net_dict: Dict, train: bool, target_num_labels: int): + def edit_network_modify_decoder( + self, + version: int, + net_dict: Dict, + train: bool, + target_num_labels: int, + python_prolog: Optional[List] = None + ): raise NotImplementedError def edit_network_use_same_static_padding(self, net_dict: Dict): raise NotImplementedError - def add_align_augment(self, net_dict, networks_dict, python_prolog): - raise NotImplementedError - def edit_network_freeze_layers_excluding( self, net_dict: Dict, diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/dependencies/returnn/config_builder/global_.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/dependencies/returnn/config_builder/global_.py index e92abd7f5..956f70147 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/dependencies/returnn/config_builder/global_.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/dependencies/returnn/config_builder/global_.py @@ -255,8 +255,16 @@ def get_dump_scores_config(self, corpus_key: str, opts: Dict): def edit_network_only_train_length_model(self, net_dict: Dict): raise NotImplementedError - def edit_network_modify_decoder(self, version: int, net_dict: Dict, train: bool, target_num_labels: int): - network_builder.modify_decoder(version, net_dict, "output", target_num_labels, False, train) + def edit_network_modify_decoder( + self, + version: int, + net_dict: Dict, + train: bool, + target_num_labels: int, + python_prolog: Optional[List] = None + ): + network_builder.modify_decoder( + version, net_dict, "output", target_num_labels, False, train, python_prolog) class SWBBlstmGlobalAttentionConfigBuilder(GlobalConfigBuilder, SWBBlstmConfigBuilder, ConfigBuilder): diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/dependencies/returnn/config_builder/segmental.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/dependencies/returnn/config_builder/segmental.py index 08a1b9744..2d206a4e9 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/dependencies/returnn/config_builder/segmental.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/dependencies/returnn/config_builder/segmental.py @@ -1,5 +1,4 @@ from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23.dependencies.labels.v2.general import SegmentalLabelDefinition -from i6_experiments.users.schmitt.augmentation.alignment import shift_alignment_boundaries_func_str from i6_experiments.users.schmitt.chunking import custom_chunkin_func_str, custom_chunkin_w_reduction_func_str from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23.dependencies.returnn.network_builder import network_builder from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23.dependencies.returnn.network_builder.lm import lm_irie, lstm_bpe_10k @@ -120,6 +119,15 @@ def get_recog_config(self, opts: Dict): lm_embedding_layer_name=lm_embedding_layer_name ) + ctc_shallow_fusion_opts = opts.get("ctc_shallow_fusion_opts", None) + if ctc_shallow_fusion_opts is not None: + network_builder.add_ctc_shallow_fusion( + network=recog_config.config["network"], + rec_layer_name="output", + ctc_scale=ctc_shallow_fusion_opts["ctc_scale"], + target_num_labels_w_blank=self.dependencies.model_hyperparameters.target_num_labels, + ) + return recog_config def get_compile_tf_graph_config(self, opts: Dict): @@ -133,11 +141,20 @@ def edit_network_only_train_length_model(self, net_dict: Dict): if type(net_dict[item]) == dict and item != "output": self.edit_network_only_train_length_model(net_dict[item]) - def edit_network_modify_decoder(self, version: int, net_dict: Dict, train: bool, target_num_labels: int): + def edit_network_modify_decoder( + self, + version: int, + net_dict: Dict, + train: bool, + target_num_labels: int, + python_prolog: Optional[List] = None + ): if train: - network_builder.modify_decoder(version, net_dict, "label_model", target_num_labels, False, train) + network_builder.modify_decoder( + version, net_dict, "label_model", target_num_labels, False, train, python_prolog) else: - network_builder.modify_decoder(version, net_dict, "output", target_num_labels, True, train) + network_builder.modify_decoder( + version, net_dict, "output", target_num_labels, True, train, python_prolog) def get_dump_scores_config(self, corpus_key: str, opts: Dict): returnn_config = self.get_eval_config(eval_corpus_key=corpus_key, opts=opts) @@ -327,28 +344,6 @@ def get_recog_config_for_forward_job(self, opts: Dict): return forward_recog_config - def add_align_augment(self, net_dict, networks_dict, python_prolog): - python_prolog.append(shift_alignment_boundaries_func_str.format( - blank_idx=self.dependencies.model_hyperparameters.blank_idx, - max_shift=2 - )) - - def _add_align_augment_layer(network_dict): - network_dict.update({ - "existing_alignment0": copy.deepcopy(network_dict["existing_alignment"]), - "existing_alignment": { - "class": "eval", - "from": "existing_alignment0", - "eval": "self.network.get_config().typed_value('shift_alignment_boundaries')(source(0, as_data=True), network=self.network)" - } - }) - - if net_dict is not None: - _add_align_augment_layer(net_dict) - if networks_dict is not None: - for net_dict in networks_dict: - _add_align_augment_layer(net_dict) - @staticmethod def get_att_t_dim_tag_code_wrapper(): return CodeWrapper( diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/dependencies/returnn/network_builder/network_builder.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/dependencies/returnn/network_builder/network_builder.py index a51bcc457..449aa5854 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/dependencies/returnn/network_builder/network_builder.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/dependencies/returnn/network_builder/network_builder.py @@ -636,39 +636,41 @@ def modify_decoder( target_num_labels: int, masked_computation: bool, train: bool, + python_prolog: Optional[List] = None, ): """ Modify the decoder part of the network. - V1: Replace Zoneout LSTM with a normal LSTM. - V2: Simply remove the att vector from the LSTM input. - V3: Like https://arxiv.org/abs/2404.01716 but without CE loss on non-blank predictor. - V4: Like V3 but with CE loss on non-blank predictor. + V1: Simply remove the att vector from the LSTM input. + V2: Like https://arxiv.org/abs/2404.01716 but without CE loss on non-blank predictor. + V3: Like V3 but with CE loss on non-blank predictor. :param version: :param net_dict: :param rec_layer_name: :param target_num_labels: :param masked_computation: :param train: + :param python_prolog: :return: """ - # otherwise we need to add extra checks for masked layers in recog and layer names (e.g. output prob vs label log prob) - assert "s_length_model" in net_dict["output"][ - "unit"], "This function is only supported for our segmental model for now" if masked_computation: + assert not train, "expected train=False for masked computation" + net_dict[rec_layer_name]["unit"]["s_masked"]["unit"]["subnetwork"]["s"]["name_scope"] = "/output/rec/s_wo_att/rec" s_layer = net_dict[rec_layer_name]["unit"]["s_masked"]["unit"]["subnetwork"]["s"] else: - s_layer = net_dict[rec_layer_name]["unit"]["s"] + if train: + net_dict[rec_layer_name]["unit"]["s_wo_att"] = copy.deepcopy(net_dict[rec_layer_name]["unit"]["s"]) + del net_dict[rec_layer_name]["unit"]["s"] + s_layer = net_dict[rec_layer_name]["unit"]["s_wo_att"] + net_dict[rec_layer_name]["unit"]["s"] = { + "class": "copy", + "from": "s_wo_att" + } + else: + net_dict[rec_layer_name]["unit"]["s"]["name_scope"] = "/output/rec/s_wo_att/rec" + s_layer = net_dict[rec_layer_name]["unit"]["s"] - if version in (1, 2, 3, 4): - # before: Zoneout LSTM - s_layer.update({ - "class": "rec", - "dropout": 0.3, - "unit": "nativelstm2", - "unit_opts": {"rec_weight_dropout": 0.3}, - }) - if version in (2, 3, 4): + if version in (1, 2, 3): if masked_computation: # before: ["data", "prev:att"] s_layer["from"] = ["data"] @@ -677,7 +679,7 @@ def modify_decoder( s_layer["from"] = ["prev:target_embed"] # before: "except_batch" -> does not work since att layer is optimized out of the loop now net_dict[rec_layer_name]["unit"]["att"]["axes"] = "except_time" - if version in (3, 4): + if version in (2, 3): ####### Label Model ####### # project directly to the target labels s_layer["n_out"] = target_num_labels @@ -728,7 +730,7 @@ def modify_decoder( } }) net_dict["output"]["unit"]["emit_prob0"]["from"] = "s_length_model_plus_encoder" - if version == 4 and train: + if version == 3 and train: net_dict[rec_layer_name]["unit"]["s_softmax"] = { "class": "activation", "from": "s_log_softmax", @@ -736,7 +738,7 @@ def modify_decoder( "loss": "ce", "target": net_dict[rec_layer_name]["unit"]["output_prob"]["target"] } - if version not in (1, 2, 3, 4): + if version not in (1, 2, 3): raise ValueError("Invalid version %d" % version) @@ -1059,6 +1061,7 @@ def add_length_model_pos_probs( } }) + def add_att_weight_interpolation( network: Dict, rec_layer_name: str, interpolation_layer_name: str, interpolation_scale: float): # just to make sure the network looks as we expect @@ -1076,6 +1079,36 @@ def add_att_weight_interpolation( }) +def add_ctc_shallow_fusion(network: Dict, rec_layer_name: str, ctc_scale: float, target_num_labels_w_blank: int): + + assert "s_length_model" in network["output"]["unit"], "This function is only supported for our segmental model for now" + assert network["output"]["unit"]["output_log_prob"]["from"] == [ + "label_log_prob_plus_emit", "blank_log_prob"], "output_log_prob layer does not look as expected" + assert 0 <= ctc_scale <= 1, "CTC scale must be in [0, 1]" + + del network["ctc"]["loss"] + del network["ctc"]["loss_opts"] + del network["ctc"]["loss_scale"] + del network["ctc"]["target"] + network["ctc"]["n_out"] = target_num_labels_w_blank + + network["output"]["unit"]["output_log_prob0"] = copy.deepcopy(network["output"]["unit"]["output_log_prob"]) + + network[rec_layer_name]["unit"].update({ + "gather_ctc_prob": { + "class": "gather", + "from": "base:ctc", + "position": ":i", + "axis": "t" + }, + "output_log_prob": { + "class": "eval", + "from": ["output_log_prob0", "gather_ctc_prob"], + "eval": f"{1 - ctc_scale} * source(0) + {ctc_scale} * tf.math.log(source(1))" + } + }) + + def get_segment_starts_and_lengths(segment_center_window_size: Optional[int]): if segment_center_window_size is None: return { diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/pipelines/pipeline_ls_conf/center_window_att/baseline_v2/__init__.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/pipelines/pipeline_ls_conf/center_window_att/baseline_v2/__init__.py index 19db5cf73..1f5ab56ed 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/pipelines/pipeline_ls_conf/center_window_att/baseline_v2/__init__.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/pipelines/pipeline_ls_conf/center_window_att/baseline_v2/__init__.py @@ -49,6 +49,15 @@ def run_exps(): checkpoint_aliases=("last",) ) + for ctc_scale in (0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9): + recog.center_window_returnn_frame_wise_beam_search( + alias=train_alias, + config_builder=config_builder, + checkpoint=checkpoint, + checkpoint_aliases=("last",), + ctc_shallow_fusion_opts={"ctc_scale": ctc_scale} + ) + recog.center_window_returnn_frame_wise_beam_search_use_global_att_ilm( alias=train_alias, config_builder=config_builder, @@ -167,50 +176,3 @@ def run_exps(): lm_scale_list=(0.52, 0.54, 0.56, 0.58, 0.6), ilm_scale_list=(0.3, 0.4, 0.5) ) - - for model_alias, config_builder in baseline.center_window_att_baseline( - win_size_list=(5,), - ): - for train_alias, checkpoint in train.train_center_window_att_import_global_global_ctc_align_only_import_encoder( - alias=model_alias, - config_builder=config_builder, - n_epochs_list=(40, 100), - ): - recog.center_window_returnn_frame_wise_beam_search( - alias=train_alias, - config_builder=config_builder, - checkpoint=checkpoint, - ) - - for decoder_version in (2,): - for model_alias, config_builder in decoder_variations.center_window_att_decoder_variation( - win_size_list=(5,), - decoder_version=decoder_version, - ): - for train_alias, checkpoint in train.train_center_window_att_import_global_global_ctc_align_only_import_encoder( - alias=model_alias, - config_builder=config_builder, - n_epochs_list=(40,), - time_rqmt=1 - ): - recog.center_window_returnn_frame_wise_beam_search( - alias=train_alias, - config_builder=config_builder, - checkpoint=checkpoint, - ) - - for model_alias, config_builder in att_weight_interpolation.center_window_att_gaussian_att_weight_interpolation( - win_size_list=(1, 3, 129), - n_epochs_list=(10,), - gauss_scale_list=(1.,) - ): - for train_alias, checkpoint in train.train_center_window_att_import_global_global_ctc_align( - alias=model_alias, - config_builder=config_builder, - n_epochs_list=(10,), - ): - recog.center_window_returnn_frame_wise_beam_search( - alias=train_alias, - config_builder=config_builder, - checkpoint=checkpoint, - ) diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/pipelines/pipeline_ls_conf/center_window_att/recog.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/pipelines/pipeline_ls_conf/center_window_att/recog.py index 4f10be904..1cb2cc913 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/pipelines/pipeline_ls_conf/center_window_att/recog.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/pipelines/pipeline_ls_conf/center_window_att/recog.py @@ -19,7 +19,8 @@ def center_window_returnn_frame_wise_beam_search( beam_size_list: Tuple[int, ...] = (12,), checkpoint_aliases: Tuple[str, ...] = ("last", "best", "best-4-avg"), run_analysis: bool = False, - att_weight_seq_tags: Optional[List] = None + att_weight_seq_tags: Optional[List] = None, + ctc_shallow_fusion_opts: Optional[Dict] = None ): ilm_opts = {"type": ilm_type} if ilm_type == "mini_att": @@ -38,7 +39,8 @@ def center_window_returnn_frame_wise_beam_search( ilm_scales=ilm_scale_list, ilm_opts=ilm_opts, run_analysis=run_analysis, - analysis_opts={"att_weight_seq_tags": att_weight_seq_tags} + analysis_opts={"att_weight_seq_tags": att_weight_seq_tags}, + recog_opts={"ctc_shallow_fusion_opts": ctc_shallow_fusion_opts}, ).run() diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/pipelines/pipeline_ls_conf/checkpoints.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/pipelines/pipeline_ls_conf/checkpoints.py index 01ba58e7f..1d6058266 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/pipelines/pipeline_ls_conf/checkpoints.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/pipelines/pipeline_ls_conf/checkpoints.py @@ -2,7 +2,8 @@ from i6_core.returnn.training import Checkpoint external_checkpoints = { - "glob.conformer.mohammad.5.6": Checkpoint(Path("/work/asr4/zeineldeen/setups-data/librispeech/2022-11-28--conformer-att/models-backup/best_att_100/avg_ckpt/epoch.2029.index", cached=True)) + "glob.conformer.mohammad.5.6": Checkpoint(Path("/work/asr4/zeineldeen/setups-data/librispeech/2022-11-28--conformer-att/models-backup/best_att_100/avg_ckpt/epoch.2029.index", cached=True)), + "glob.conformer.mohammad.5.4": Checkpoint(Path("/work/asr4/zeineldeen/setups-data/librispeech/2022-11-28--conformer-att/work/i6_core/returnn/training/AverageTFCheckpointsJob.BxqgICRSGkgb/output/model/average.index", cached=True)) } default_import_model_name = "glob.conformer.mohammad.5.6" diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/pipelines/pipeline_ls_conf/global_att/baseline_v1/__init__.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/pipelines/pipeline_ls_conf/global_att/baseline_v1/__init__.py index 111041353..55356acbd 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/pipelines/pipeline_ls_conf/global_att/baseline_v1/__init__.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/pipelines/pipeline_ls_conf/global_att/baseline_v1/__init__.py @@ -62,6 +62,17 @@ def run_exps(): } ) + # this is Mohammad's 5.4 WER model + for train_alias, checkpoint in ( + (f"{model_alias}/no-finetuning", external_checkpoints["glob.conformer.mohammad.5.4"]),): + train_alias = train_alias.replace(default_import_model_name, "glob.conformer.mohammad.5.4") + recog.global_att_returnn_label_sync_beam_search( + alias=train_alias, + config_builder=config_builder, + checkpoint=checkpoint, + checkpoint_aliases=("best-4-avg",), + ) + # continue training for 1 epoch for train_alias, checkpoint in train.train_global_att_import_global( alias=model_alias, diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/recog_new.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/recog_new.py index a91ce3104..a301f504c 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/recog_new.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/recog_new.py @@ -196,6 +196,12 @@ def __init__(self, config_builder: SegmentalConfigBuilder, **kwargs): super().__init__(config_builder=config_builder, **kwargs) self.config_builder = config_builder + ctc_shallow_fusion_opts = self.recog_opts.get("ctc_shallow_fusion_opts") + if ctc_shallow_fusion_opts: + self.alias += "/time-sync-recog-w-ctc_shallow_fusion-%f" % ctc_shallow_fusion_opts["ctc_scale"] + else: + self.alias += "/time-sync-recog" + def get_mini_att_checkpoint(self, train_mini_lstm_opts: Dict) -> Checkpoint: train_opts = {} if train_mini_lstm_opts["use_eos"]: @@ -290,6 +296,8 @@ def get_ctm_path(self) -> Path: returnn_root=self.returnn_root, returnn_python_exe=self.returnn_python_exe, output_files=["output.py.gz"], + mem_rqmt=6, + time_rqmt=1, ) search_job.add_alias("%s/search_%s" % (self.alias, self.stm_corpus_key)) search_take_best_job = SearchTakeBestJob(search_py_output=search_job.out_files["output.py.gz"]) @@ -313,9 +321,6 @@ def run_analysis(self, analysis_opts: Optional[Dict] = None): if analysis_opts is not None: _analysis_opts.update(analysis_opts) - if _analysis_opts["ground_truth_hdf"] is not None: - assert _analysis_opts["ground_truth_hdf"] == _analysis_opts["att_weight_ref_alignment_hdf"] - forward_recog_config = self.config_builder.get_recog_config_for_forward_job(opts=self.recog_opts) forward_search_job = ReturnnForwardJob( model_checkpoint=self.checkpoint, diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/train_new.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/train_new.py index ffca3cd18..e903aba56 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/train_new.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/train_new.py @@ -1,6 +1,6 @@ from sisyphus import tk, Path import copy -from typing import Dict, List, Optional, Tuple +from typing import Dict, List, Optional, Tuple, Union from abc import ABC, abstractmethod from i6_core.returnn.training import Checkpoint, ReturnnTrainingJob @@ -8,6 +8,7 @@ from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23.dependencies.returnn.config_builder.base import ConfigBuilder from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23.dependencies.returnn.config_builder.segmental import SegmentalConfigBuilder from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23.dependencies.returnn.config_builder.global_ import GlobalConfigBuilder +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.config_builder_rf.base import GlobalAttConfigBuilderRF, SegmentalAttConfigBuilderRF, ConfigBuilderRF from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23.dependencies.returnn.config_builder.ctc import CtcConfigBuilder from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23.pipelines.pipeline_ls_conf.checkpoints import external_checkpoints from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23.dependencies.labels.v2.librispeech.label_singletons import LibrispeechBPE10025_LABELS_WITH_SILENCE, LibrispeechBPE10025_CTC_ALIGNMENT @@ -18,7 +19,7 @@ class TrainExperiment(ABC): def __init__( self, - config_builder: ConfigBuilder, + config_builder: Union[ConfigBuilder, ConfigBuilderRF], alias: str, num_epochs: int, train_opts: Optional[Dict] = None, @@ -33,6 +34,10 @@ def __init__( dataset_opts = _train_opts.pop("dataset_opts", {}) self.train_opts.update(_train_opts) self.train_opts["dataset_opts"].update(dataset_opts) + if "cleanup_old_models" not in self.train_opts: + self.train_opts["cleanup_old_models"] = { + "keep_best_n": 4, "keep_last_n": 1, "keep": [num_epochs] + } self.train_rqmt = train_rqmt if train_rqmt is not None else {} self.alias = self.alias + "/train" @@ -76,7 +81,7 @@ def run_train(self) -> Tuple[Dict[int, Checkpoint], Path, Path]: class SegmentalTrainExperiment(TrainExperiment): - def __init__(self, config_builder: SegmentalConfigBuilder, **kwargs): + def __init__(self, config_builder: Union[SegmentalConfigBuilder, SegmentalAttConfigBuilderRF], **kwargs): super().__init__(config_builder=config_builder, **kwargs) @property @@ -99,7 +104,7 @@ def default_train_opts(self) -> Dict: class GlobalTrainExperiment(TrainExperiment): - def __init__(self, config_builder: GlobalConfigBuilder, **kwargs): + def __init__(self, config_builder: Union[GlobalConfigBuilder, GlobalAttConfigBuilderRF], **kwargs): super().__init__(config_builder=config_builder, **kwargs) @property diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/config_builder_rf/base.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/config_builder_rf/base.py index 156565816..b94dca43a 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/config_builder_rf/base.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/config_builder_rf/base.py @@ -467,8 +467,10 @@ class SegmentalAttConfigBuilderRF(LibrispeechConformerConfigBuilderRF): def __init__( self, center_window_size: int, - decoder_version: Optional[int] = None, - length_model_opts: Optional[Dict] = None, + label_decoder_version: int, + blank_decoder_version: Optional[int] = None, + use_joint_model: bool = False, + use_weight_feedback: bool = True, **kwargs ): super(SegmentalAttConfigBuilderRF, self).__init__(**kwargs) @@ -477,9 +479,25 @@ def __init__( center_window_size=center_window_size, )) - print(decoder_version) - if decoder_version: - self.config_dict["label_decoder_version"] = decoder_version + if use_joint_model: + assert not blank_decoder_version, "Either use joint model or separate label and blank model" + + if label_decoder_version != 1: + self.config_dict["label_decoder_version"] = label_decoder_version + if blank_decoder_version is not None and blank_decoder_version != 1: + self.config_dict["blank_decoder_version"] = blank_decoder_version + if use_joint_model: + self.config_dict["use_joint_model"] = use_joint_model + if not use_weight_feedback: + self.config_dict["use_weight_feedback"] = use_weight_feedback + + def get_train_config(self, opts: Dict): + train_config = super(SegmentalAttConfigBuilderRF, self).get_train_config(opts) + + if opts.get("alignment_augmentation_opts"): + train_config.config["alignment_augmentation_opts"] = opts["alignment_augmentation_opts"] + + return train_config def get_recog_config(self, opts: Dict): recog_config = super(SegmentalAttConfigBuilderRF, self).get_recog_config(opts) diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/base.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/base.py index 8f02d397a..c6f58441c 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/base.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/base.py @@ -23,7 +23,6 @@ def __init__( att_num_heads: Dim = Dim(name="att_num_heads", dimension=1), att_dropout: float = 0.1, l2: float = 0.0001, - language_model: Optional[RFModelWithMakeLabelScorer] = None, ): super(BaseLabelDecoder, self).__init__() @@ -67,5 +66,3 @@ def __init__( # Instead, it is intended to make a separate label scorer for it. self.language_model = None self.language_model_make_label_scorer = None - if language_model: - self.language_model, self.language_model_make_label_scorer = language_model diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/model.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/model.py index e9d4165ab..0d4f54109 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/model.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/model.py @@ -59,10 +59,15 @@ def __init__( blank_idx=blank_idx, enc_key_total_dim=enc_key_total_dim, l2=l2, - language_model=language_model, eos_idx=eos_idx, ) + if language_model: + self.language_model, self.language_model_make_label_scorer = language_model + else: + self.language_model = None + self.language_model_make_label_scorer = None + self.blank_idx = blank_idx self.target_dim = target_dim diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/recog.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/recog.py index 6269b3fe0..37a07cc37 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/recog.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/recog.py @@ -24,6 +24,8 @@ def _returnn_v2_forward_step(*, model, extern_data: TensorDict, **_kwargs_unused default_target_key = config.typed_value("target") targets = extern_data[default_target_key] extra.update(dict(targets=targets, targets_spatial_dim=targets.get_time_dim_tag())) + if config.bool("use_recombination", False): + extra.update(dict(use_recombination=True)) recog_out = recog_def(model=model, data=data, data_spatial_dim=data_spatial_dim, **extra) if len(recog_out) == 5: # recog results including beam {batch, beam, out_spatial}, diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model.py index da3bba4c0..e4cd2de4d 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model.py @@ -6,7 +6,10 @@ from i6_experiments.users.schmitt.returnn_frontend.model_interfaces.model import ModelDef from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.base import _batch_size_factor, _log_mel_feature_dim -from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model_new.blank_model.model import BlankDecoder +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model_new.blank_model.model import ( + BlankDecoderV1, + BlankDecoderV3, +) from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model_new.label_model.model import ( SegmentalAttLabelDecoder, SegmentalAttLabelDecoderWoCtxInState @@ -39,6 +42,9 @@ def __init__( dec_att_num_heads: Dim = Dim(name="att_num_heads", dimension=1), enc_dropout: float = 0.1, label_decoder_version: int = 1, + blank_decoder_version: int = 1, + use_joint_model: bool = False, + use_weight_feedback: bool = True, ): super(SegmentalAttentionModel, self).__init__() @@ -59,11 +65,12 @@ def __init__( l2=l2, ) - print("using label_decoder_version", label_decoder_version) + assert label_decoder_version in {1, 2} + assert blank_decoder_version in {1, 3} + if label_decoder_version == 1: label_decoder_class = SegmentalAttLabelDecoder else: - assert label_decoder_version == 2 label_decoder_class = SegmentalAttLabelDecoderWoCtxInState self.label_decoder = label_decoder_class( @@ -75,19 +82,37 @@ def __init__( enc_key_total_dim=enc_key_total_dim, l2=l2, center_window_size=center_window_size, - language_model=language_model, - ) - self.blank_decoder = BlankDecoder( - length_model_state_dim=length_model_state_dim, - length_model_embed_dim=length_model_embed_dim, - align_target_dim=align_target_dim, - encoder_out_dim=self.encoder.out_dim, + use_weight_feedback=use_weight_feedback, ) + if not use_joint_model: + if blank_decoder_version == 1: + self.blank_decoder = BlankDecoderV1( + length_model_state_dim=length_model_state_dim, + length_model_embed_dim=length_model_embed_dim, + align_target_dim=align_target_dim, + encoder_out_dim=self.encoder.out_dim, + ) + else: + self.blank_decoder = BlankDecoderV3( + length_model_state_dim=length_model_state_dim, + label_state_dim=self.label_decoder.get_lstm().out_dim, + encoder_out_dim=self.encoder.out_dim, + ) + else: + self.blank_decoder = None + + if language_model: + self.language_model, self.language_model_make_label_scorer = language_model + else: + self.language_model = None + self.language_model_make_label_scorer = None + self.blank_idx = self.label_decoder.blank_idx self.center_window_size = center_window_size self.target_dim = self.label_decoder.target_dim self.align_target_dim = align_target_dim + self.use_joint_model = use_joint_model class MakeModel: @@ -125,6 +150,9 @@ def make_model( pos_emb_dropout: float = 0.0, language_model: Optional[Dict[str, Any]] = None, label_decoder_version: int, + blank_decoder_version: int, + use_joint_model: bool, + use_weight_feedback: bool, **extra, ) -> SegmentalAttentionModel: """make""" @@ -162,12 +190,15 @@ def make_model( ), target_dim=target_dim, align_target_dim=align_target_dim, - blank_idx=target_dim.dimension, + blank_idx=0 if use_joint_model else target_dim.dimension, language_model=lm, length_model_state_dim=Dim(name="length_model_state", dimension=128, kind=Dim.Types.Feature), length_model_embed_dim=Dim(name="length_model_embed", dimension=128, kind=Dim.Types.Feature), center_window_size=center_window_size, label_decoder_version=label_decoder_version, + blank_decoder_version=blank_decoder_version, + use_joint_model=use_joint_model, + use_weight_feedback=use_weight_feedback, **extra, ) @@ -189,6 +220,9 @@ def from_scratch_model_def( raise ValueError("center_window_size is not set!") label_decoder_version = config.int("label_decoder_version", 1) + blank_decoder_version = config.int("blank_decoder_version", 1) + use_joint_model = config.bool("use_joint_model", False) + use_weight_feedback = config.bool("use_weight_feedback", True) return MakeModel.make_model( in_dim, @@ -199,6 +233,9 @@ def from_scratch_model_def( pos_emb_dropout=pos_emb_dropout, language_model=lm_opts, label_decoder_version=label_decoder_version, + blank_decoder_version=blank_decoder_version, + use_joint_model=use_joint_model, + use_weight_feedback=use_weight_feedback, ) diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/blank_model/model.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/blank_model/model.py index 8b57923e8..746349237 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/blank_model/model.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/blank_model/model.py @@ -1,4 +1,5 @@ from typing import Optional, Dict, Any, Sequence, Tuple, List +from abc import ABC, abstractmethod import functools from returnn.tensor import Tensor, Dim, single_step_dim @@ -9,30 +10,22 @@ from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.base import BaseLabelDecoder -class BlankDecoder(rf.Module): - def __init__( - self, - length_model_state_dim: Dim, - length_model_embed_dim: Dim, - align_target_dim: Dim, - encoder_out_dim: Dim, - ): - super(BlankDecoder, self).__init__() +class BlankDecoderBase(rf.Module, ABC): + def __init__(self, length_model_state_dim: Dim): + super(BlankDecoderBase, self).__init__() self.length_model_state_dim = length_model_state_dim - self.length_model_embed_dim = length_model_embed_dim self.emit_prob_dim = Dim(name="emit_prob", dimension=1) - - self.target_embed = rf.Embedding(align_target_dim, self.length_model_embed_dim) - self.s = rf.LSTM( - encoder_out_dim + self.length_model_embed_dim, - self.length_model_state_dim, - ) self.emit_prob = rf.Linear(self.length_model_state_dim, self.emit_prob_dim) + @property + @abstractmethod + def _s(self) -> rf.LSTM: + pass + def default_initial_state(self, *, batch_dims: Sequence[Dim]) -> rf.State: """Default initial state""" state = rf.State( - s_blank=self.s.default_initial_state(batch_dims=batch_dims), + s_blank=self._s.default_initial_state(batch_dims=batch_dims), i=rf.zeros(batch_dims, dtype="int32"), ) return state @@ -42,29 +35,14 @@ def loop_step_output_templates(self, batch_dims: List[Dim]) -> Dict[str, Tensor] return { "s_blank": Tensor( "s_blank", - dims=batch_dims + [self.s.out_dim], + dims=batch_dims + [self._s.out_dim], dtype=rf.get_default_float_dtype(), feature_dim_axis=-1 ), } - def loop_step( - self, - *, - enc: rf.Tensor, - enc_spatial_dim: Dim, - input_embed: rf.Tensor, - state: Optional[rf.State] = None, - spatial_dim=single_step_dim - ) -> Tuple[Dict[str, rf.Tensor], rf.State]: - """step of the inner loop""" - if state is None: - batch_dims = enc.remaining_dims( - remove=(enc.feature_dim, enc_spatial_dim) if enc_spatial_dim != single_step_dim else (enc.feature_dim,) - ) - state = self.default_initial_state(batch_dims=batch_dims) - state_ = rf.State() - + @staticmethod + def _get_am(enc: rf.Tensor, enc_spatial_dim: Dim, state: rf.State, spatial_dim) -> rf.Tensor: if spatial_dim == single_step_dim: i = state.i clip_to_valid = True @@ -75,7 +53,53 @@ def loop_step( i = rf.where(i < seq_lens, i, seq_lens - 1) clip_to_valid = False - am = rf.gather(enc, axis=enc_spatial_dim, indices=i, clip_to_valid=clip_to_valid) + return rf.gather(enc, axis=enc_spatial_dim, indices=i, clip_to_valid=clip_to_valid) + + def decode_logits(self, *, s_blank: Tensor) -> Tensor: + """logits for the decoder""" + logits = self.emit_prob(s_blank) + return logits + + def get_label_decoder_deps(self) -> Optional[List[str]]: + return None + + +class BlankDecoderV1(BlankDecoderBase): + def __init__( + self, + length_model_state_dim: Dim, + length_model_embed_dim: Dim, + align_target_dim: Dim, + encoder_out_dim: Dim, + ): + super(BlankDecoderV1, self).__init__(length_model_state_dim=length_model_state_dim) + self.length_model_state_dim = length_model_state_dim + self.length_model_embed_dim = length_model_embed_dim + self.emit_prob_dim = Dim(name="emit_prob", dimension=1) + + self.target_embed = rf.Embedding(align_target_dim, self.length_model_embed_dim) + self.s = rf.LSTM( + encoder_out_dim + self.length_model_embed_dim, + self.length_model_state_dim, + ) + self.emit_prob = rf.Linear(self.length_model_state_dim, self.emit_prob_dim) + + @property + def _s(self) -> rf.LSTM: + return self.s + + def loop_step( + self, + *, + enc: rf.Tensor, + enc_spatial_dim: Dim, + input_embed: rf.Tensor, + state: rf.State, + spatial_dim=single_step_dim + ) -> Tuple[Dict[str, rf.Tensor], rf.State]: + state_ = rf.State() + + am = self._get_am(enc, enc_spatial_dim, state, spatial_dim) s_blank, state_.s_blank = self.s( rf.concat_features(am, input_embed), state=state.s_blank, @@ -90,3 +114,102 @@ def decode_logits(self, *, s_blank: Tensor) -> Tensor: """logits for the decoder""" logits = self.emit_prob(s_blank) return logits + + +class BlankDecoderV2(BlankDecoderBase): + def __init__( + self, + length_model_state_dim: Dim, + length_model_embed_dim: Dim, + target_dim: Dim, + label_state_dim: Dim, + encoder_out_dim: Dim, + ): + super(BlankDecoderV2, self).__init__(length_model_state_dim=length_model_state_dim) + self.length_model_state_dim = length_model_state_dim + self.length_model_embed_dim = length_model_embed_dim + self.emit_prob_dim = Dim(name="emit_prob", dimension=1) + + self.target_embed = rf.Embedding(target_dim, self.length_model_embed_dim) + self.s = rf.LSTM( + encoder_out_dim + length_model_embed_dim + label_state_dim, + self.length_model_state_dim, + ) + self.emit_prob = rf.Linear(self.length_model_state_dim, self.emit_prob_dim) + + @property + def _s(self) -> rf.LSTM: + return self.s + + def loop_step( + self, + *, + enc: rf.Tensor, + enc_spatial_dim: Dim, + input_embed: rf.Tensor, + label_model_state: rf.Tensor, + state: rf.State, + spatial_dim=single_step_dim + ) -> Tuple[Dict[str, rf.Tensor], rf.State]: + state_ = rf.State() + + am = self._get_am(enc, enc_spatial_dim, state, spatial_dim) + s_blank, state_.s_blank = self.s( + rf.concat_features(am, input_embed, label_model_state), + state=state.s_blank, + spatial_dim=spatial_dim + ) + + state_.i = state.i + 1 + + return {"s_blank": s_blank}, state_ + + def get_label_decoder_deps(self) -> Optional[List[str]]: + return ["s"] + + +class BlankDecoderV3(BlankDecoderBase): + def __init__( + self, + length_model_state_dim: Dim, + label_state_dim: Dim, + encoder_out_dim: Dim, + ): + super(BlankDecoderV3, self).__init__(length_model_state_dim=length_model_state_dim) + self.length_model_state_dim = length_model_state_dim + self.emit_prob_dim = Dim(name="emit_prob", dimension=1) + + self.s = rf.LSTM( + encoder_out_dim + label_state_dim, + self.length_model_state_dim, + ) + self.emit_prob = rf.Linear(self.length_model_state_dim, self.emit_prob_dim) + + @property + def _s(self) -> rf.LSTM: + return self.s + + def loop_step( + self, + *, + enc: rf.Tensor, + enc_spatial_dim: Dim, + label_model_state: rf.Tensor, + state: rf.State, + spatial_dim=single_step_dim + ) -> Tuple[Dict[str, rf.Tensor], rf.State]: + state_ = rf.State() + + am = self._get_am(enc, enc_spatial_dim, state, spatial_dim) + s_blank, state_.s_blank = self.s( + rf.concat_features(am, label_model_state), + state=state.s_blank, + spatial_dim=spatial_dim + ) + + state_.i = state.i + 1 + + return {"s_blank": s_blank}, state_ + + def get_label_decoder_deps(self) -> Optional[List[str]]: + return ["s"] diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/blank_model/train.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/blank_model/train.py index 13daa8de3..1abef2546 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/blank_model/train.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/blank_model/train.py @@ -1,34 +1,23 @@ from typing import Optional, Dict, Any, Sequence, Tuple, List -from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model_new.blank_model.model import BlankDecoder +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model_new.blank_model.model import ( + BlankDecoderV1, + BlankDecoderV3, + BlankDecoderBase +) from returnn.tensor import Dim import returnn.frontend as rf -def viterbi_training( +def decode_logits( *, - model: BlankDecoder, - enc_args: Dict, - enc_spatial_dim: Dim, - align_targets: rf.Tensor, + model: BlankDecoderBase, + blank_loop_out: Dict, align_targets_spatial_dim: Dim, emit_ground_truth: rf.Tensor, - emit_blank_target_dim: Dim, - batch_dims: List[Dim], + batch_dims: List[Dim] ): - align_input_embeddings = model.target_embed(align_targets) - align_input_embeddings = rf.shift_right( - align_input_embeddings, axis=align_targets_spatial_dim, pad_value=0.0) - - blank_loop_out, _ = model.loop_step( - enc=enc_args["enc"], - enc_spatial_dim=enc_spatial_dim, - input_embed=align_input_embeddings, - state=model.default_initial_state(batch_dims=batch_dims,), - spatial_dim=align_targets_spatial_dim, - ) - blank_logits = model.decode_logits(**blank_loop_out) blank_logits_packed, pack_dim = rf.pack_padded( blank_logits, dims=batch_dims + [align_targets_spatial_dim], enforce_sorted=False) @@ -36,6 +25,16 @@ def viterbi_training( emit_ground_truth, dims=batch_dims + [align_targets_spatial_dim], enforce_sorted=False, out_dim=pack_dim ) + return blank_logits_packed, pack_dim, emit_ground_truth_packed + + +def calc_loss( + *, + blank_logits_packed: rf.Tensor, + emit_ground_truth_packed: rf.Tensor, + emit_blank_target_dim: Dim, + pack_dim: Dim +): # rf.log_sigmoid not implemented for torch backend emit_log_prob = rf.log(rf.sigmoid(blank_logits_packed)) blank_log_prob = rf.log(rf.sigmoid(-blank_logits_packed)) @@ -53,3 +52,77 @@ def viterbi_training( best = rf.reduce_argmax(emit_blank_log_prob, axis=emit_blank_target_dim) frame_error = best != emit_ground_truth_packed frame_error.mark_as_loss(name="emit_blank_fer", as_error=True) + + +def viterbi_training( + *, + model: BlankDecoderV1, + enc_args: Dict, + enc_spatial_dim: Dim, + align_targets: rf.Tensor, + align_targets_spatial_dim: Dim, + emit_ground_truth: rf.Tensor, + emit_blank_target_dim: Dim, + batch_dims: List[Dim], +): + align_input_embeddings = model.target_embed(align_targets) + align_input_embeddings = rf.shift_right( + align_input_embeddings, axis=align_targets_spatial_dim, pad_value=0.0) + + blank_loop_out, _ = model.loop_step( + enc=enc_args["enc"], + enc_spatial_dim=enc_spatial_dim, + input_embed=align_input_embeddings, + state=model.default_initial_state(batch_dims=batch_dims,), + spatial_dim=align_targets_spatial_dim, + ) + + blank_logits_packed, pack_dim, emit_ground_truth_packed = decode_logits( + model=model, + blank_loop_out=blank_loop_out, + align_targets_spatial_dim=align_targets_spatial_dim, + emit_ground_truth=emit_ground_truth, + batch_dims=batch_dims + ) + + calc_loss( + blank_logits_packed=blank_logits_packed, + emit_ground_truth_packed=emit_ground_truth_packed, + emit_blank_target_dim=emit_blank_target_dim, + pack_dim=pack_dim + ) + + +def viterbi_training_v3( + *, + model: BlankDecoderV3, + enc_args: Dict, + enc_spatial_dim: Dim, + label_states_unmasked: rf.Tensor, + label_states_unmasked_spatial_dim: Dim, + emit_ground_truth: rf.Tensor, + emit_blank_target_dim: Dim, + batch_dims: List[Dim], +): + blank_loop_out, _ = model.loop_step( + enc=enc_args["enc"], + enc_spatial_dim=enc_spatial_dim, + label_model_state=label_states_unmasked, + state=model.default_initial_state(batch_dims=batch_dims,), + spatial_dim=label_states_unmasked_spatial_dim, + ) + + blank_logits_packed, pack_dim, emit_ground_truth_packed = decode_logits( + model=model, + blank_loop_out=blank_loop_out, + align_targets_spatial_dim=label_states_unmasked_spatial_dim, + emit_ground_truth=emit_ground_truth, + batch_dims=batch_dims + ) + + calc_loss( + blank_logits_packed=blank_logits_packed, + emit_ground_truth_packed=emit_ground_truth_packed, + emit_blank_target_dim=emit_blank_target_dim, + pack_dim=pack_dim + ) diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/label_model/model.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/label_model/model.py index 2313ced51..03a3a756d 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/label_model/model.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/label_model/model.py @@ -8,12 +8,16 @@ class SegmentalAttLabelDecoder(BaseLabelDecoder): - def __init__(self, center_window_size: int, **kwargs): + def __init__(self, center_window_size: int, use_weight_feedback: bool, **kwargs): super(SegmentalAttLabelDecoder, self).__init__(**kwargs) self.center_window_size = center_window_size self.accum_att_weights_dim = Dim(name="accum_att_weights", dimension=center_window_size) + self.use_weight_feedback = use_weight_feedback + if not use_weight_feedback: + delattr(self, "weight_feedback") + def default_initial_state( self, *, @@ -23,22 +27,28 @@ def default_initial_state( ) -> rf.State: """Default initial state""" state = rf.State( - s=self._get_lstm().default_initial_state(batch_dims=batch_dims), + s=self.get_lstm().default_initial_state(batch_dims=batch_dims), att=rf.zeros(list(batch_dims) + [self.att_num_heads * self.enc_out_dim]), - accum_att_weights=rf.zeros( - list(batch_dims) + [self.accum_att_weights_dim, self.att_num_heads], feature_dim=self.att_num_heads - ), + # accum_att_weights=rf.zeros( + # list(batch_dims) + [self.accum_att_weights_dim, self.att_num_heads], feature_dim=self.att_num_heads + # ), segment_starts=rf.zeros(batch_dims, sparse_dim=segment_starts_sparse_dim, dtype="int32"), segment_lens=rf.zeros(batch_dims, sparse_dim=segment_lens_sparse_dim, dtype="int32"), ) state.att.feature_dim_axis = len(state.att.dims) - 1 + + if self.use_weight_feedback: + state.accum_att_weights = rf.zeros( + list(batch_dims) + [self.accum_att_weights_dim, self.att_num_heads], feature_dim=self.att_num_heads + ) + return state def loop_step_output_templates(self, batch_dims: List[Dim]) -> Dict[str, Tensor]: """loop step out""" return { "s": Tensor( - "s", dims=batch_dims + [self._get_lstm().out_dim], dtype=rf.get_default_float_dtype(), feature_dim_axis=-1 + "s", dims=batch_dims + [self.get_lstm().out_dim], dtype=rf.get_default_float_dtype(), feature_dim_axis=-1 ), "att": Tensor( "att", @@ -133,7 +143,7 @@ def _update_state( ): return self.s(rf.concat_features(input_embed, prev_att), state=prev_s_state, spatial_dim=single_step_dim) - def _get_lstm(self): + def get_lstm(self): return self.s def loop_step( @@ -146,20 +156,13 @@ def loop_step( input_embed: rf.Tensor, segment_starts: rf.Tensor, segment_lens: rf.Tensor, - state: Optional[rf.State] = None, + state: rf.State, ) -> Tuple[Dict[str, rf.Tensor], rf.State]: - """step of the inner loop""" - if state is None: - batch_dims = enc.remaining_dims( - remove=(enc.feature_dim, enc_spatial_dim) if enc_spatial_dim != single_step_dim else (enc.feature_dim,) - ) - state = self.default_initial_state(batch_dims=batch_dims) state_ = rf.State() # during search, these need to be the values from the previous "emit" step (not necessarily the previous time step) prev_att = state.att prev_s_state = state.s - prev_accum_att_weights = state.accum_att_weights prev_segment_starts = state.segment_starts prev_segment_lens = state.segment_lens @@ -173,16 +176,20 @@ def loop_step( enc_ctx_sliced = rf.gather(enc_ctx, axis=enc_spatial_dim, indices=gather_positions, clip_to_valid=True) enc_sliced = rf.gather(enc, axis=enc_spatial_dim, indices=gather_positions, clip_to_valid=True) - prev_accum_att_weights_scattered = self._get_prev_accum_att_weights_scattered( - prev_accum_att_weights=prev_accum_att_weights, - segment_starts=segment_starts, - prev_segment_starts=prev_segment_starts, - prev_segment_lens=prev_segment_lens, - ) - weight_feedback = self._get_weight_feedback( - prev_accum_att_weights_scattered=prev_accum_att_weights_scattered, - att_t_dim=slice_dim, - ) + if self.use_weight_feedback: + prev_accum_att_weights = state.accum_att_weights + prev_accum_att_weights_scattered = self._get_prev_accum_att_weights_scattered( + prev_accum_att_weights=prev_accum_att_weights, + segment_starts=segment_starts, + prev_segment_starts=prev_segment_starts, + prev_segment_lens=prev_segment_lens, + ) + weight_feedback = self._get_weight_feedback( + prev_accum_att_weights_scattered=prev_accum_att_weights_scattered, + att_t_dim=slice_dim, + ) + else: + weight_feedback = rf.zeros((self.enc_key_total_dim,)) energy_in = enc_ctx_sliced + weight_feedback + s_transformed energy = self.energy(rf.tanh(energy_in)) @@ -193,16 +200,17 @@ def loop_step( att, _ = rf.merge_dims(att0, dims=(self.att_num_heads, self.enc_out_dim)) state_.att = att - accum_att_weights = self._get_accum_att_weights( - att_t_dim=slice_dim, - enc_spatial_dim=enc_spatial_dim, - inv_fertility=inv_fertility, - att_weights=att_weights, - prev_accum_att_weights_scattered=prev_accum_att_weights_scattered, - gather_positions=gather_positions, - ) - accum_att_weights.feature_dim = self.att_num_heads - state_.accum_att_weights = accum_att_weights + if self.use_weight_feedback: + accum_att_weights = self._get_accum_att_weights( + att_t_dim=slice_dim, + enc_spatial_dim=enc_spatial_dim, + inv_fertility=inv_fertility, + att_weights=att_weights, + prev_accum_att_weights_scattered=prev_accum_att_weights_scattered, + gather_positions=gather_positions, + ) + accum_att_weights.feature_dim = self.att_num_heads + state_.accum_att_weights = accum_att_weights state_.segment_starts = segment_starts state_.segment_lens = segment_lens @@ -242,5 +250,5 @@ def _update_state( ): return self.s_wo_att(rf.concat_features(input_embed), state=prev_s_state, spatial_dim=single_step_dim) - def _get_lstm(self): + def get_lstm(self): return self.s_wo_att diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/label_model/train.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/label_model/train.py index fe2d14b7f..3a547e7bd 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/label_model/train.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/label_model/train.py @@ -3,7 +3,7 @@ from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.utils import get_non_blank_mask, get_masked from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model_new.label_model.model import SegmentalAttLabelDecoder -from returnn.tensor import Dim +from returnn.tensor import Dim, single_step_dim import returnn.frontend as rf from i6_experiments.users.schmitt.returnn_frontend.model_interfaces.training import TrainDef @@ -19,9 +19,10 @@ def viterbi_training( segment_starts: rf.Tensor, segment_lens: rf.Tensor, batch_dims: List[Dim], -): + output_tensors: Optional[List[str]] = None +) -> Optional[Dict[str, Tuple[rf.Tensor, Dim]]]: non_blank_input_embeddings = model.target_embed(non_blank_targets) - non_blank_input_embeddings = rf.shift_right( + non_blank_input_embeddings_shifted = rf.shift_right( non_blank_input_embeddings, axis=non_blank_targets_spatial_dim, pad_value=0.0) # ------------------- label loop ------------------- @@ -38,10 +39,10 @@ def _label_loop_body(xs, state: rf.State): ) return loop_out_, new_state - label_loop_out, _, _ = rf.scan( + label_loop_out, final_state, _ = rf.scan( spatial_dim=non_blank_targets_spatial_dim, xs={ - "input_embed": non_blank_input_embeddings, + "input_embed": non_blank_input_embeddings_shifted, "segment_starts": segment_starts, "segment_lens": segment_lens, }, @@ -57,7 +58,7 @@ def _label_loop_body(xs, state: rf.State): body=_label_loop_body, ) - logits = model.decode_logits(input_embed=non_blank_input_embeddings, **label_loop_out) + logits = model.decode_logits(input_embed=non_blank_input_embeddings_shifted, **label_loop_out) logits_packed, pack_dim = rf.pack_padded(logits, dims=batch_dims + [non_blank_targets_spatial_dim], enforce_sorted=False) non_blank_targets_packed, _ = rf.pack_padded( non_blank_targets, dims=batch_dims + [non_blank_targets_spatial_dim], enforce_sorted=False, out_dim=pack_dim @@ -73,3 +74,31 @@ def _label_loop_body(xs, state: rf.State): best = rf.reduce_argmax(logits_packed, axis=model.target_dim) frame_error = best != non_blank_targets_packed frame_error.mark_as_loss(name="non_blank_fer", as_error=True) + + if output_tensors is not None: + extended_outputs = {} + # need to run the loop one more time to get the last output (which is not needed for the loss computation) + last_embedding = rf.gather( + non_blank_input_embeddings, + axis=non_blank_targets_spatial_dim, + indices=rf.copy_to_device( + non_blank_targets_spatial_dim.get_size_tensor() - 1, non_blank_input_embeddings.device) + ) + last_loop_out, _ = model.loop_step( + **enc_args, + enc_spatial_dim=enc_spatial_dim, + input_embed=last_embedding, + segment_starts=final_state.decoder.segment_starts, + segment_lens=final_state.decoder.segment_lens, + state=final_state.decoder, + ) + for key, val in last_loop_out.items(): + if key not in output_tensors: + continue + extended_outputs[key] = rf.concat( + (label_loop_out[key], non_blank_targets_spatial_dim), + (rf.expand_dim(val, single_step_dim), single_step_dim), + ) + return extended_outputs + + return None diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/recog.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/recog.py index 4245362d5..730e67383 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/recog.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/recog.py @@ -1,7 +1,7 @@ from typing import Optional, Dict, Any, Tuple import tree -from returnn.tensor import Tensor, Dim +from returnn.tensor import Tensor, Dim, single_step_dim import returnn.frontend as rf from returnn.frontend.tensor_array import TensorArray @@ -9,6 +9,74 @@ from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.base import _batch_size_factor from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model import SegmentalAttentionModel from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.utils import get_masked, get_non_blank_mask +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.beam_search import utils as beam_search_utils +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model_new.blank_model.model import ( + BlankDecoderV1, + BlankDecoderV3, +) + + +def recombine_seqs( + seq_targets: list, + seq_log_prob: Tensor, + seq_backrefs: list, + seq_hash: Tensor, + beam_dim: Dim, + batch_dim: Dim, + i: int +) -> Tensor: + if len(seq_targets) in (0, 1): + return seq_log_prob + + print("seq_hash: ", seq_hash.raw_tensor) + print("seq_log_prob before: ", seq_log_prob.raw_tensor) + + seq_hash_cpu = rf.copy_to_device(seq_hash.copy_transpose([batch_dim, beam_dim]), device="cpu") + seq_log_prob = rf.copy_to_device(seq_log_prob.copy_transpose([batch_dim, beam_dim]), device="cpu") + + for b in range(batch_dim.get_dim_value()): + seq_sets = {} + for h in range(beam_dim.dimension): + seq_hash_value = seq_hash_cpu.raw_tensor[b, h] + if seq_hash_value not in seq_sets: + seq_sets[seq_hash_value] = [] + seq_sets[seq_hash_value].append(h) + + for seq_set in seq_sets.values(): + if len(seq_set) == 1: + continue + best_score = 0 + best_idx = -1 + for idx in seq_set: + if seq_log_prob.raw_tensor[b, idx] > best_score: + best_score = seq_log_prob.raw_tensor[b, idx] + best_idx = idx + for idx in seq_set: + if idx != best_idx: + seq_log_prob.raw_tensor[b, idx] = -float("inf") + else: + seq_log_prob.raw_tensor[b, idx] = best_score + + print("seq_log_prob after: ", seq_log_prob.raw_tensor) + exit() + + return rf.copy_to_device(seq_log_prob, device="gpu") + + +def update_seq_hash(seq_hash: Tensor, target: Tensor, backrefs: Tensor) -> Tensor: + print("update_seq_hash") + print("old seq_hash", seq_hash.raw_tensor) + print("target", target.raw_tensor) + print("backrefs", backrefs.raw_tensor) + print("\n\n") + + old_seq_hash = rf.gather(seq_hash, indices=backrefs) + seq_hash = rf.where( + target == 10025, + old_seq_hash, + (old_seq_hash * 257 + (target + 1)) % (10 ** 9 + 7) + ) + return seq_hash def model_recog( @@ -16,7 +84,7 @@ def model_recog( model: SegmentalAttentionModel, data: Tensor, data_spatial_dim: Dim, - max_seq_len: Optional[int] = None, + use_recombination: bool = False, ) -> Tuple[Tensor, Tensor, Dim, Dim]: """ Function is run within RETURNN. @@ -31,47 +99,79 @@ def model_recog( out_spatial_dim, final beam_dim """ - assert not model.label_decoder.language_model # not implemented here. use the pure PyTorch search instead + # assert not model.language_model # not implemented here. use the pure PyTorch search instead + assert any( + isinstance(model.blank_decoder, cls) for cls in (BlankDecoderV1, BlankDecoderV3) + ) or model.blank_decoder is None, "blank_decoder not supported" + if model.blank_decoder is None: + assert model.use_joint_model, "blank_decoder is None, so use_joint_model must be True" batch_dims = data.remaining_dims((data_spatial_dim, data.feature_dim)) enc_args, enc_spatial_dim = model.encoder.encode(data, in_spatial_dim=data_spatial_dim) beam_size = 12 - if max_seq_len is None: - max_seq_len = enc_spatial_dim.get_size_tensor() - else: - max_seq_len = rf.convert_to_tensor(max_seq_len, dtype="int32") + max_seq_len = enc_spatial_dim.get_size_tensor() print("** max seq len:", max_seq_len.raw_tensor) max_seq_len = rf.reduce_max(max_seq_len, axis=max_seq_len.dims) - # Eager-mode implementation of beam search. # Initial state. beam_dim = Dim(1, name="initial-beam") batch_dims_ = [beam_dim] + batch_dims + label_decoder_state = model.label_decoder.default_initial_state(batch_dims=batch_dims_, ) + if model.blank_decoder is not None: + blank_decoder_state = model.blank_decoder.default_initial_state(batch_dims=batch_dims_) + if model.language_model: + lm_state = model.language_model.default_initial_state(batch_dims=batch_dims_) - blank_decoder_state = model.blank_decoder.default_initial_state(batch_dims=batch_dims_) bos_idx = 0 - target = rf.constant(bos_idx, dims=batch_dims_, sparse_dim=model.align_target_dim) - target_non_blank = rf.constant(bos_idx, dims=batch_dims_, sparse_dim=model.target_dim) - # ended = rf.constant(False, dims=batch_dims_) + + if model.use_joint_model: + target = rf.constant(bos_idx, dims=batch_dims_, sparse_dim=model.target_dim) + else: + target = rf.constant(bos_idx, dims=batch_dims_, sparse_dim=model.align_target_dim) + update_state_mask = rf.convert_to_tensor(target != model.blank_idx) + target_non_blank = rf.constant(bos_idx, dims=batch_dims_, sparse_dim=model.target_dim) + seq_log_prob = rf.constant(0.0, dims=batch_dims_) + if use_recombination: + assert len(batch_dims) == 1 + seq_hash = rf.constant(0, dims=batch_dims_, dtype="int64") + + input_embed = rf.zeros( + batch_dims_ + [model.label_decoder.target_embed.out_dim], + feature_dim=model.label_decoder.target_embed.out_dim, + dtype="float32" + ) + + if isinstance(model.blank_decoder, BlankDecoderV1): + input_embed_length_model = rf.zeros( + batch_dims_ + [model.blank_decoder.target_embed.out_dim], feature_dim=model.blank_decoder.target_embed.out_dim) + else: + input_embed_length_model = None + + old_beam_dim = beam_dim.copy() + backrefs = rf.zeros(batch_dims_, dtype="int32") i = 0 seq_targets = [] seq_backrefs = [] while i < max_seq_len.raw_tensor: - if i == 0: - input_embed = rf.zeros( - batch_dims_ + [model.label_decoder.target_embed.out_dim], - feature_dim=model.label_decoder.target_embed.out_dim, - dtype="float32" - ) - input_embed_length_model = rf.zeros( - batch_dims_ + [model.blank_decoder.target_embed.out_dim], feature_dim=model.blank_decoder.target_embed.out_dim) - else: - input_embed_length_model = model.blank_decoder.target_embed(target) + if i > 0: + if model.use_joint_model: + input_embed = model.label_decoder.target_embed(target) + else: + target_non_blank = rf.where(update_state_mask, target, rf.gather(target_non_blank, indices=backrefs)) + target_non_blank.sparse_dim = model.label_decoder.target_embed.in_dim + input_embed = rf.where( + update_state_mask, + model.label_decoder.target_embed(target_non_blank), + rf.gather(input_embed, indices=backrefs, axis=old_beam_dim) + ) + if isinstance(model.blank_decoder, BlankDecoderV1): + input_embed_length_model = model.blank_decoder.target_embed(target) # ------------------- label step ------------------- + center_position = rf.minimum( rf.full(dims=[beam_dim] + batch_dims, fill_value=i, dtype="int32"), rf.copy_to_device(enc_spatial_dim.get_size_tensor() - 1, data.device) @@ -95,56 +195,113 @@ def model_recog( label_logits = model.label_decoder.decode_logits(input_embed=input_embed, **label_step_out) label_log_prob = rf.log_softmax(label_logits, axis=model.target_dim) + # ------------------- external LM step ------------------- + + if model.language_model: + lm_logits, lm_state_updated = model.language_model( + target_non_blank, + spatial_dim=single_step_dim, + state=lm_state, + ) + label_log_prob += rf.log_softmax(lm_logits, axis=model.target_dim) + # ------------------- blank step ------------------- - blank_step_out, blank_decoder_state = model.blank_decoder.loop_step( - enc=enc_args["enc"], - enc_spatial_dim=enc_spatial_dim, - input_embed=input_embed_length_model, - state=blank_decoder_state, - ) - blank_logits = model.blank_decoder.decode_logits(**blank_step_out) - emit_log_prob = rf.log(rf.sigmoid(blank_logits)) - emit_log_prob = rf.squeeze(emit_log_prob, axis=emit_log_prob.feature_dim) - blank_log_prob = rf.log(rf.sigmoid(-blank_logits)) - - # combine blank and label probs - label_log_prob += emit_log_prob - output_log_prob, _ = rf.concat( - (label_log_prob, model.target_dim), (blank_log_prob, blank_log_prob.feature_dim), - out_dim=model.align_target_dim - ) + if not model.use_joint_model: + blank_loop_step_kwargs = dict( + enc=enc_args["enc"], + enc_spatial_dim=enc_spatial_dim, + state=blank_decoder_state, + ) + if isinstance(model.blank_decoder, BlankDecoderV1): + blank_loop_step_kwargs["input_embed"] = input_embed_length_model + else: + blank_loop_step_kwargs["label_model_state"] = label_step_out["s"] + + blank_step_out, blank_decoder_state = model.blank_decoder.loop_step(**blank_loop_step_kwargs) + blank_logits = model.blank_decoder.decode_logits(**blank_step_out) + emit_log_prob = rf.log(rf.sigmoid(blank_logits)) + emit_log_prob = rf.squeeze(emit_log_prob, axis=emit_log_prob.feature_dim) + blank_log_prob = rf.log(rf.sigmoid(-blank_logits)) + # update blank decoder state + blank_decoder_state = tree.map_structure(lambda s: rf.gather(s, indices=backrefs), blank_decoder_state) + + # ------------------- combination ------------------- + + label_log_prob += emit_log_prob + output_log_prob, _ = rf.concat( + (label_log_prob, model.target_dim), (blank_log_prob, blank_log_prob.feature_dim), + out_dim=model.align_target_dim + ) + else: + output_log_prob = label_log_prob + + # ------------------- top-k ------------------- + + if use_recombination: + seq_log_prob = recombine_seqs(seq_targets, seq_log_prob, seq_backrefs, seq_hash, beam_dim, batch_dims[0], i) + if i== 3: + exit() - # top-k seq_log_prob = seq_log_prob + output_log_prob # Batch, InBeam, Vocab old_beam_dim = beam_dim.copy() seq_log_prob, (backrefs, target), beam_dim = rf.top_k( - seq_log_prob, k_dim=Dim(beam_size, name=f"dec-step{i}-beam"), axis=[beam_dim, model.align_target_dim] + seq_log_prob, + k_dim=Dim(beam_size, name=f"dec-step{i}-beam"), + axis=[beam_dim, model.target_dim if model.use_joint_model else model.align_target_dim] ) # seq_log_prob, backrefs, target: Batch, Beam seq_targets.append(target) seq_backrefs.append(backrefs) + if use_recombination: + seq_hash = update_seq_hash(seq_hash, target, backrefs) + + # mask for updating label-sync states update_state_mask = rf.convert_to_tensor(target != model.blank_idx) - def _get_masked_state(old, new, mask): - old = rf.gather(old, indices=backrefs, axis=old_beam_dim) - new = rf.gather(new, indices=backrefs, axis=old_beam_dim) - return rf.where(mask, new, old) + # ------------------- update label decoder state ------------------- - label_decoder_state = tree.map_structure( - lambda old_state, new_state: _get_masked_state(old_state, new_state, update_state_mask), - label_decoder_state, label_decoder_state_updated - ) + if model.use_joint_model: + label_decoder_state = tree.map_structure(lambda s: rf.gather(s, indices=backrefs), label_decoder_state) + else: + def _get_masked_state(old, new, mask): + old = rf.gather(old, indices=backrefs, axis=old_beam_dim) + new = rf.gather(new, indices=backrefs, axis=old_beam_dim) + return rf.where(mask, new, old) + + label_decoder_state = tree.map_structure( + lambda old_state, new_state: _get_masked_state(old_state, new_state, update_state_mask), + label_decoder_state, label_decoder_state_updated + ) - target_non_blank = rf.where(update_state_mask, target, rf.gather(target_non_blank, indices=backrefs)) - target_non_blank.sparse_dim = model.label_decoder.target_embed.in_dim - input_embed = rf.where( - update_state_mask, - model.label_decoder.target_embed(target_non_blank), - rf.gather(input_embed, indices=backrefs, axis=old_beam_dim) - ) + # ------------------- update external LM state ------------------- + + if model.language_model: + def _get_masked_state_lm(old: rf.Tensor, new: rf.Tensor, mask: rf.Tensor): + if isinstance(old, Dim): + return new + + def _update(tensor: rf.Tensor): + tensor = tensor.copy_transpose(batch_dims + [old_beam_dim] + tensor.remaining_dims(batch_dims_)) + tensor_raw_tensor = beam_search_utils.batch_gather( + tensor.raw_tensor, + indices=backrefs.copy_transpose(batch_dims + [beam_dim]).raw_tensor + ) + tensor = tensor.copy_template_replace_dim_tag(1, beam_dim) + tensor.raw_tensor = tensor_raw_tensor + return tensor + + old = _update(old) + new = _update(new) + + return rf.where(mask, new, old) + + lm_state = tree.map_structure( + lambda old_state, new_state: _get_masked_state_lm(old_state, new_state, update_state_mask), + lm_state, lm_state_updated + ) - blank_decoder_state = tree.map_structure(lambda s: rf.gather(s, indices=backrefs), blank_decoder_state) + exit() i += 1 diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/train.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/train.py index 599aa6ef8..fe38ba5cc 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/train.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/train.py @@ -1,13 +1,11 @@ +import torch + from i6_experiments.users.schmitt.returnn_frontend.model_interfaces.training import FramewiseTrainDef from returnn.tensor import TensorDict -from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.utils import ( - get_non_blank_mask, - get_masked, - get_emit_ground_truth, - get_segment_starts_and_lens -) +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental import utils +from i6_experiments.users.schmitt.augmentation.alignment import shift_alignment_boundaries_batched from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model import SegmentalAttentionModel from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model_new.label_model.train import ( viterbi_training as label_model_viterbi_training @@ -15,6 +13,13 @@ from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model_new.blank_model.train import ( viterbi_training as blank_model_viterbi_training ) +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model_new.blank_model.train import ( + viterbi_training_v3 as blank_model_viterbi_training_v3 +) +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model_new.blank_model.model import ( + BlankDecoderV1, + BlankDecoderV3, +) from returnn.tensor import Dim import returnn.frontend as rf @@ -63,17 +68,43 @@ def viterbi_training( batch_dims = data.remaining_dims(data_spatial_dim) - non_blank_targets, non_blank_targets_spatial_dim = get_masked( - align_targets, get_non_blank_mask(align_targets, model.blank_idx), align_targets_spatial_dim, batch_dims - ) - non_blank_targets.sparse_dim = model.target_dim - segment_starts, segment_lens = get_segment_starts_and_lens( - align_targets, - align_targets_spatial_dim, - model, - batch_dims, - non_blank_targets_spatial_dim - ) + alignment_augmentation_opts = config.typed_value("alignment_augmentation_opts", None) + if alignment_augmentation_opts is not None: + for _ in range(alignment_augmentation_opts["num_iterations"]): + align_targets = shift_alignment_boundaries_batched( + alignment=align_targets, + alignment_spatial_dim=align_targets_spatial_dim, + batch_dims=batch_dims, + blank_idx=model.blank_idx, + max_shift=alignment_augmentation_opts["max_shift"], + ) + + if model.use_joint_model: + non_blank_targets, non_blank_targets_spatial_dim = None, None + segment_starts, segment_lens = utils.get_segment_starts_and_lens( + utils.get_non_blank_mask(align_targets, blank_idx=-1), # this way, every frame is interpreted as non-blank + align_targets, + align_targets_spatial_dim, + model, + batch_dims, + align_targets_spatial_dim + ) + # set blank indices in alignment to 0 (= EOS index of imported global att model which is not used otherwise) + align_targets.raw_tensor[align_targets.raw_tensor == model.target_dim.dimension] = 0 + align_targets.sparse_dim = model.target_dim + else: + non_blank_targets, non_blank_targets_spatial_dim = utils.get_masked( + align_targets, utils.get_non_blank_mask(align_targets, model.blank_idx), align_targets_spatial_dim, batch_dims + ) + non_blank_targets.sparse_dim = model.target_dim + segment_starts, segment_lens = utils.get_segment_starts_and_lens( + utils.get_non_blank_mask(align_targets, model.blank_idx), + align_targets, + align_targets_spatial_dim, + model, + batch_dims, + non_blank_targets_spatial_dim + ) # ------------------- encoder aux loss ------------------- @@ -101,33 +132,67 @@ def viterbi_training( use_normalized_loss=True, ) - # ------------------- label loop ------------------- - - label_model_viterbi_training( - model=model.label_decoder, - enc_args=enc_args, - enc_spatial_dim=enc_spatial_dim, - non_blank_targets=non_blank_targets, - non_blank_targets_spatial_dim=non_blank_targets_spatial_dim, - segment_starts=segment_starts, - segment_lens=segment_lens, - batch_dims=batch_dims, - ) - - # ------------------- blank loop ------------------- - - emit_ground_truth, emit_blank_target_dim = get_emit_ground_truth(align_targets, model.blank_idx) - blank_model_viterbi_training( - model=model.blank_decoder, - enc_args=enc_args, - enc_spatial_dim=enc_spatial_dim, - align_targets=align_targets, - align_targets_spatial_dim=align_targets_spatial_dim, - emit_ground_truth=emit_ground_truth, - emit_blank_target_dim=emit_blank_target_dim, - batch_dims=batch_dims, - ) - + if model.use_joint_model: + # ------------------- joint loop ------------------- + label_model_viterbi_training( + model=model.label_decoder, + enc_args=enc_args, + enc_spatial_dim=enc_spatial_dim, + non_blank_targets=align_targets, + non_blank_targets_spatial_dim=align_targets_spatial_dim, + segment_starts=segment_starts, + segment_lens=segment_lens, + batch_dims=batch_dims, + ) + else: + # ------------------- label loop ------------------- + + label_decoder_outputs = label_model_viterbi_training( + model=model.label_decoder, + enc_args=enc_args, + enc_spatial_dim=enc_spatial_dim, + non_blank_targets=non_blank_targets, + non_blank_targets_spatial_dim=non_blank_targets_spatial_dim, + segment_starts=segment_starts, + segment_lens=segment_lens, + batch_dims=batch_dims, + output_tensors=model.blank_decoder.get_label_decoder_deps(), + ) + + # ------------------- blank loop ------------------- + + emit_ground_truth, emit_blank_target_dim = utils.get_emit_ground_truth(align_targets, model.blank_idx) + if isinstance(model.blank_decoder, BlankDecoderV1): + blank_model_viterbi_training( + model=model.blank_decoder, + enc_args=enc_args, + enc_spatial_dim=enc_spatial_dim, + align_targets=align_targets, + align_targets_spatial_dim=align_targets_spatial_dim, + emit_ground_truth=emit_ground_truth, + emit_blank_target_dim=emit_blank_target_dim, + batch_dims=batch_dims, + ) + else: + assert isinstance(model.blank_decoder, BlankDecoderV3) + assert "s" in label_decoder_outputs + + label_states_unmasked = utils.get_unmasked( + input=label_decoder_outputs["s"][0], + input_spatial_dim=label_decoder_outputs["s"][1], + mask=utils.get_non_blank_mask(align_targets, model.blank_idx), + mask_spatial_dim=align_targets_spatial_dim + ) + blank_model_viterbi_training_v3( + model=model.blank_decoder, + enc_args=enc_args, + enc_spatial_dim=enc_spatial_dim, + label_states_unmasked=label_states_unmasked, + label_states_unmasked_spatial_dim=align_targets_spatial_dim, + emit_ground_truth=emit_ground_truth, + emit_blank_target_dim=emit_blank_target_dim, + batch_dims=batch_dims, + ) viterbi_training: TrainDef[SegmentalAttentionModel] viterbi_training.learning_rate_control_error_measure = "dev_score_full_sum" diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/utils.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/utils.py index 707be5236..7b8a7281a 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/utils.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/utils.py @@ -43,14 +43,30 @@ def get_masked( return result, result_spatial_dim +def get_unmasked( + input: Tensor, input_spatial_dim: Dim, mask: Tensor, mask_spatial_dim: Dim +): + mask_shifted = rf.shift_right(mask, axis=mask_spatial_dim, pad_value=False) + mask_axis = mask.get_axis_from_description(mask_spatial_dim) + cumsum = rf.cast(mask_shifted, "int32").copy_template() + cumsum.raw_tensor = torch.cumsum( + mask_shifted.raw_tensor.to(torch.int32), dim=mask_axis, dtype=torch.int32 + ) + return rf.gather( + input, + indices=cumsum, + axis=input_spatial_dim, + ) + + def get_segment_starts_and_lens( + non_blank_mask: Tensor, align_targets: Tensor, align_targets_spatial_dim: Dim, model: SegmentalAttentionModel, batch_dims: Sequence[Dim], out_spatial_dim: Dim ): - non_blank_mask = get_non_blank_mask(align_targets, model.blank_idx) targets_range = rf.range_over_dim(align_targets_spatial_dim, dtype="int32") targets_range = rf.expand_dim(targets_range, batch_dims[0]) non_blank_positions, _ = get_masked( diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/__init__.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/__init__.py index 71d73b64b..c7797b8a9 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/__init__.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/__init__.py @@ -1,4 +1,6 @@ from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.pipelines.pipeline_ls_conf.center_window_att import baseline_v1 as center_window_baseline_v1 +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.pipelines.pipeline_ls_conf.center_window_att import baseline_v3 as center_window_baseline_v3 +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.pipelines.pipeline_ls_conf.center_window_att import baseline_v4 as center_window_baseline_v4 from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.pipelines.pipeline_ls_conf.global_att import baseline_v1 as global_att_baseline_v1 from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23.pipelines.pipeline_ls_conf.global_att import baseline_v1 as global_att_baseline_v1_no_rf @@ -9,4 +11,5 @@ def run_exps(): global_att_baseline_v1_no_rf.register_ctc_alignments() global_att_baseline_v1.run_exps() - center_window_baseline_v1.run_exps() + center_window_baseline_v3.run_exps() + center_window_baseline_v4.run_exps() diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v1/__init__.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v1/__init__.py index f9266f4f2..b33815fb9 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v1/__init__.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v1/__init__.py @@ -11,50 +11,34 @@ def run_exps(): for model_alias, config_builder in baseline.center_window_att_baseline_rf( win_size_list=(5,), ): - for train_alias, checkpoint in train.train_center_window_att_import_global_tf( + for train_alias, checkpoint in train.train_center_window_att_viterbi_import_global_tf( alias=model_alias, config_builder=config_builder, n_epochs_list=(10,), + const_lr_list=(1e-4, 2e-4, 3e-4), time_rqmt=4, - train_opts=dict( - aux_loss_layers=None, - accum_grad_multiple_step=2, - optimizer={"class": "adam", "epsilon": 1e-8} - ) ): recog.center_window_returnn_frame_wise_beam_search( alias=train_alias, config_builder=config_builder, checkpoint=checkpoint, - checkpoint_aliases=("last",) - ) - recog.center_window_returnn_frame_wise_beam_search( - alias=train_alias, - config_builder=config_builder, - checkpoint=checkpoint, - checkpoint_aliases=("last",), pure_torch=True, ) for model_alias, config_builder in baseline.center_window_att_baseline_rf( win_size_list=(5,), decoder_version=2 ): - for train_alias, checkpoint in train.train_center_window_att_import_global_tf( + for train_alias, checkpoint in train.train_center_window_att_viterbi_import_global_tf( alias=model_alias, config_builder=config_builder, n_epochs_list=(10,), + const_lr_list=(1e-4, 2e-4, 3e-4), time_rqmt=4, - train_opts=dict( - aux_loss_layers=None, - accum_grad_multiple_step=2, - optimizer={"class": "adam", "epsilon": 1e-8} - ), custom_missing_load_func=load_missing_params ): recog.center_window_returnn_frame_wise_beam_search( alias=train_alias, config_builder=config_builder, checkpoint=checkpoint, - checkpoint_aliases=("last",), pure_torch=True, ) diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v1/baseline.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v1/baseline.py index b80ee17cc..496bae2e0 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v1/baseline.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v1/baseline.py @@ -1,66 +1,18 @@ -from typing import Tuple, Optional, List, Dict, Union -import copy +from typing import Tuple, Optional -from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23.pipelines.pipeline_ls_conf.center_window_att.baseline_v1.alias import alias as base_alias -from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.config_builder_rf.base import SegmentalAttConfigBuilderRF -from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model import from_scratch_model_def, _returnn_v2_get_model -from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.model_variants.model_variants_ls_conf import models - - -def get_center_window_att_config_builder_rf( - win_size: int, - use_weight_feedback: bool = True, - use_positional_embedding: bool = False, - att_weight_recog_penalty_opts: Optional[Dict] = None, - length_model_opts: Optional[Dict] = None, - length_scale: float = 1.0, - blank_penalty: Union[float, str] = 0.0, - gaussian_att_weight_interpolation_opts: Optional[Dict] = None, - expected_position_aux_loss_opts: Optional[Dict] = None, - pos_pred_att_weight_interpolation_opts: Optional[Dict] = None, - search_remove_eos: bool = False, - decoder_version: Optional[int] = None, -) -> SegmentalAttConfigBuilderRF: - model_type = "librispeech_conformer_seg_att" - variant_name = "seg.conformer.like-global" - variant_params = copy.deepcopy(models[model_type][variant_name]) - variant_params["network"]["segment_center_window_size"] = win_size - variant_params["network"]["use_weight_feedback"] = use_weight_feedback - variant_params["network"]["use_positional_embedding"] = use_positional_embedding - variant_params["network"]["att_weight_recog_penalty_opts"] = att_weight_recog_penalty_opts - variant_params["network"]["gaussian_att_weight_interpolation_opts"] = gaussian_att_weight_interpolation_opts - variant_params["network"]["pos_pred_att_weight_interpolation_opts"] = pos_pred_att_weight_interpolation_opts - variant_params["network"]["expected_position_aux_loss_opts"] = expected_position_aux_loss_opts - variant_params["network"]["length_scale"] = length_scale - variant_params["network"]["blank_penalty"] = blank_penalty - variant_params["network"]["search_remove_eos"] = search_remove_eos - variant_params["network"]["decoder_version"] = decoder_version - - if length_model_opts: - # make sure that we do not add any params which are not present in the defaults - assert set(length_model_opts.keys()).issubset(set(variant_params["network"]["length_model_opts"].keys())) - variant_params["network"]["length_model_opts"].update(length_model_opts) - - config_builder = SegmentalAttConfigBuilderRF( - variant_params=variant_params, - center_window_size=win_size, - decoder_version=decoder_version, - model_def=from_scratch_model_def, - get_model_func=_returnn_v2_get_model, - ) - - return config_builder +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.pipelines.pipeline_ls_conf.center_window_att.baseline_v1.alias import alias as base_alias +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.pipelines.pipeline_ls_conf.center_window_att.config_builder import get_center_window_att_config_builder_rf def center_window_att_baseline_rf( win_size_list: Tuple[int, ...] = (5, 129), - decoder_version: Optional[int] = None, + decoder_version: int = 1, ): for win_size in win_size_list: alias = f"{base_alias}/baseline_rf/win-size-{win_size}/decoder-version-{decoder_version if decoder_version else 1}" yield alias, get_center_window_att_config_builder_rf( win_size=win_size, - use_weight_feedback=True, - length_model_opts={"use_label_model_state": False, "use_alignment_ctx": False}, - decoder_version=decoder_version, + label_decoder_version=decoder_version, + blank_decoder_version=1, + use_joint_model=False, ) diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v2/__init__.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v2/__init__.py deleted file mode 100644 index 6b74c4bc4..000000000 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v2/__init__.py +++ /dev/null @@ -1,40 +0,0 @@ -from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.pipelines.pipeline_ls_conf.center_window_att.baseline_v2 import ( - baseline, -) -from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.pipelines.pipeline_ls_conf.center_window_att import ( - train, recog -) - -from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model import MakeModel -from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model_import import map_param_func_v2 - -from i6_experiments.users.zeyer.returnn.convert_ckpt_rf import ConvertTfCheckpointToRfPtJob - -from i6_core.returnn.training import PtCheckpoint, Checkpoint - -from sisyphus import Path - - -def run_exps(): - for model_alias, config_builder in baseline.center_window_att_baseline_rf( - win_size_list=(5,), - ): - for train_alias, checkpoint in train.train_center_window_att_import_global_tf( - alias=model_alias, - config_builder=config_builder, - n_epochs_list=(1,), - time_rqmt=4 - ): - recog.center_window_returnn_frame_wise_beam_search( - alias=train_alias, - config_builder=config_builder, - checkpoint=checkpoint, - checkpoint_aliases=("last",) - ) - recog.center_window_returnn_frame_wise_beam_search( - alias=train_alias, - config_builder=config_builder, - checkpoint=checkpoint, - checkpoint_aliases=("last",), - pure_torch=True, - ) diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v3/__init__.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v3/__init__.py new file mode 100644 index 000000000..89d9f44d5 --- /dev/null +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v3/__init__.py @@ -0,0 +1,56 @@ +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.pipelines.pipeline_ls_conf.center_window_att.baseline_v3 import ( + baseline, +) +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.pipelines.pipeline_ls_conf.center_window_att import ( + train, recog +) +from i6_experiments.users.schmitt.custom_load_params import load_missing_params + + +def run_exps(): + for model_alias, config_builder in baseline.center_window_att_baseline_rf( + win_size_list=(5, 129), + ): + for train_alias, checkpoint in train.train_center_window_att_viterbi_import_global_tf( + alias=model_alias, + config_builder=config_builder, + n_epochs_list=(100,), + const_lr_list=(1e-4,), + ): + recog.center_window_returnn_frame_wise_beam_search( + alias=train_alias, + config_builder=config_builder, + checkpoint=checkpoint, + ) + + for model_alias, config_builder in baseline.center_window_att_baseline_rf( + win_size_list=(5, 129), decoder_version=2 + ): + for train_alias, checkpoint in train.train_center_window_att_viterbi_import_global_tf( + alias=model_alias, + config_builder=config_builder, + n_epochs_list=(100,), + const_lr_list=(1e-4,), + ): + recog.center_window_returnn_frame_wise_beam_search( + alias=train_alias, + config_builder=config_builder, + checkpoint=checkpoint, + ) + + for model_alias, config_builder in baseline.center_window_att_baseline_rf( + win_size_list=(5,), decoder_version=2 + ): + for max_shift, num_iterations in [(1, 1), (2, 1), (1, 2), (2, 2)]: + for train_alias, checkpoint in train.train_center_window_att_viterbi_import_global_tf( + alias=model_alias, + config_builder=config_builder, + n_epochs_list=(100,), + const_lr_list=(1e-4,), + alignment_augmentation_opts={"max_shift": max_shift, "num_iterations": num_iterations}, + ): + recog.center_window_returnn_frame_wise_beam_search( + alias=train_alias, + config_builder=config_builder, + checkpoint=checkpoint, + ) diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v2/alias.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v3/alias.py similarity index 82% rename from users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v2/alias.py rename to users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v3/alias.py index 3b09afcf4..c25647962 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v2/alias.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v3/alias.py @@ -1,4 +1,4 @@ from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23.pipelines.pipeline_ls_conf.center_window_att.alias import alias as base_alias -alias = f"{base_alias}/baseline_v2" +alias = f"{base_alias}/baseline_v3" diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v3/baseline.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v3/baseline.py new file mode 100644 index 000000000..ef8071026 --- /dev/null +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v3/baseline.py @@ -0,0 +1,20 @@ +from typing import Tuple, Optional + +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.pipelines.pipeline_ls_conf.center_window_att.baseline_v3.alias import alias as base_alias +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.pipelines.pipeline_ls_conf.center_window_att.config_builder import get_center_window_att_config_builder_rf + + +def center_window_att_baseline_rf( + win_size_list: Tuple[int, ...] = (5, 129), + decoder_version: int = 1, + use_weight_feedback: bool = True, +): + for win_size in win_size_list: + alias = f"{base_alias}/baseline_rf/win-size-{win_size}/{'w' if use_weight_feedback else 'wo'}-weight-feedback/decoder-version-{decoder_version if decoder_version else 1}" + yield alias, get_center_window_att_config_builder_rf( + win_size=win_size, + label_decoder_version=decoder_version, + blank_decoder_version=3, + use_joint_model=False, + use_weight_feedback=use_weight_feedback, + ) diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v4/__init__.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v4/__init__.py new file mode 100644 index 000000000..07a9ffbcc --- /dev/null +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v4/__init__.py @@ -0,0 +1,26 @@ +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.pipelines.pipeline_ls_conf.center_window_att.baseline_v4 import ( + baseline, +) +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.pipelines.pipeline_ls_conf.center_window_att import ( + train, recog +) +from i6_experiments.users.schmitt.custom_load_params import load_missing_params + + +def run_exps(): + for model_alias, config_builder in baseline.center_window_att_baseline_rf( + win_size_list=(1, 5,), + ): + for train_alias, checkpoint in train.train_center_window_att_viterbi_import_global_tf( + alias=model_alias, + config_builder=config_builder, + n_epochs_list=(10,), + time_rqmt=4, + ): + recog.center_window_returnn_frame_wise_beam_search( + alias=train_alias, + config_builder=config_builder, + checkpoint=checkpoint, + checkpoint_aliases=("last",), + pure_torch=False, + ) diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v4/alias.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v4/alias.py new file mode 100644 index 000000000..dc33bc1e9 --- /dev/null +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v4/alias.py @@ -0,0 +1,4 @@ +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23.pipelines.pipeline_ls_conf.center_window_att.alias import alias as base_alias + + +alias = f"{base_alias}/baseline_v4" diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v4/baseline.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v4/baseline.py new file mode 100644 index 000000000..069601d20 --- /dev/null +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v4/baseline.py @@ -0,0 +1,18 @@ +from typing import Tuple, Optional + +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.pipelines.pipeline_ls_conf.center_window_att.baseline_v4.alias import alias as base_alias +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.pipelines.pipeline_ls_conf.center_window_att.config_builder import get_center_window_att_config_builder_rf + + +def center_window_att_baseline_rf( + win_size_list: Tuple[int, ...] = (5, 129), + decoder_version: int = 1, +): + for win_size in win_size_list: + alias = f"{base_alias}/baseline_rf/win-size-{win_size}/decoder-version-{decoder_version if decoder_version else 1}" + yield alias, get_center_window_att_config_builder_rf( + win_size=win_size, + label_decoder_version=decoder_version, + blank_decoder_version=None, + use_joint_model=True, + ) diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v2/baseline.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/config_builder.py similarity index 62% rename from users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v2/baseline.py rename to users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/config_builder.py index ae2e7c93a..1f0687758 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v2/baseline.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/config_builder.py @@ -1,21 +1,21 @@ from typing import Tuple, Optional, List, Dict, Union -import copy -from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23.pipelines.pipeline_ls_conf.center_window_att.baseline_v2.alias import alias as base_alias -from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.config_builder_rf.base import SegmentalAttConfigBuilderRF -from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model import from_scratch_model_def, _returnn_v2_get_model -from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23.dependencies.general.returnn.exes import RETURNN_EXE_NEW, RETURNN_CURRENT_ROOT -from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23.dependencies.corpora.librispeech import LibrispeechCorpora from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23.dependencies.labels.v2.librispeech.label_singletons import ( LibrispeechBPE10025_CTC_ALIGNMENT, + LIBRISPEECH_CORPUS ) +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23.dependencies.general.returnn.exes import RETURNN_EXE_NEW, RETURNN_CURRENT_ROOT -LIBRISPEECH_CORPUS = LibrispeechCorpora() +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.config_builder_rf.base import SegmentalAttConfigBuilderRF +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model import from_scratch_model_def, _returnn_v2_get_model def get_center_window_att_config_builder_rf( win_size: int, - length_model_opts: Dict + label_decoder_version: int, + blank_decoder_version: Optional[int], + use_joint_model: bool, + use_weight_feedback: bool = True, ) -> SegmentalAttConfigBuilderRF: variant_params = { "dependencies": LibrispeechBPE10025_CTC_ALIGNMENT, @@ -23,29 +23,23 @@ def get_center_window_att_config_builder_rf( "feature_type": "raw", "corpus": LIBRISPEECH_CORPUS }, + "config": { + "train_seq_ordering": "laplace:.1000" + }, + "network": {"length_scale": 1.0}, "returnn_python_exe": RETURNN_EXE_NEW, "returnn_root": RETURNN_CURRENT_ROOT - }, + } config_builder = SegmentalAttConfigBuilderRF( variant_params=variant_params, model_def=from_scratch_model_def, get_model_func=_returnn_v2_get_model, center_window_size=win_size, - length_model_opts=length_model_opts, + label_decoder_version=label_decoder_version, + blank_decoder_version=blank_decoder_version, + use_joint_model=use_joint_model, + use_weight_feedback=use_weight_feedback, ) return config_builder - - -def center_window_att_baseline_rf( - win_size_list: Tuple[int, ...] = (5, 129), -): - for win_size in win_size_list: - alias = f"{base_alias}/baseline_rf/win-size-%d" % ( - win_size - ) - yield alias, get_center_window_att_config_builder_rf( - win_size=win_size, - length_model_opts={"use_label_model_state": True, "use_alignment_ctx": False}, - ) diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/train.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/train.py index d82fdf89d..c21b470f0 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/train.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/train.py @@ -10,7 +10,7 @@ ) -def train_center_window_att_from_scratch( +def train_center_window_att_viterbi_from_scratch( alias: str, config_builder: SegmentalAttConfigBuilderRF, n_epochs_list: Tuple[int, ...], @@ -42,99 +42,71 @@ def train_center_window_att_from_scratch( checkpoint = { "model_dir": model_dir, "learning_rates": learning_rates, - "key": "dev_score_label_model/output_prob", + "key": "dev_loss_non_blank_ce", "checkpoints": checkpoints, "n_epochs": n_epochs } yield alias, checkpoint -def train_center_window_att_import_global_tf( +def train_center_window_att_viterbi_import_global_tf( alias: str, config_builder: SegmentalAttConfigBuilderRF, n_epochs_list: Tuple[int, ...], - time_rqmt: int = 168, - train_opts: Optional[Dict] = None, - custom_missing_load_func: Optional[Callable] = None + const_lr_list: Tuple[float, ...] = (1e-4,), + time_rqmt: int = 30, + custom_missing_load_func: Optional[Callable] = None, + alignment_augmentation_opts: Optional[Dict] = None, ): - _train_opts = { - "preload_from_files": { - "pretrained_global_att_params": { - "filename": external_checkpoints[default_import_model_name], - "init_for_train": True, - "ignore_missing": True, # because of length model params - } - }, - "train_def": viterbi_training, - "train_step_func": _returnn_v2_train_step, - "batching": "random", - } - if custom_missing_load_func: - _train_opts["preload_from_files"]["pretrained_global_att_params"]["custom_missing_load_func"] = custom_missing_load_func - if train_opts: - _train_opts.update(train_opts) - for n_epochs in n_epochs_list: - alias += "/train_from_global_att_tf_checkpoint/standard-training/%d-epochs_wo-ctc-loss" % (n_epochs,) - - train_exp = SegmentalTrainExperiment( - config_builder=config_builder, - alias=alias, - num_epochs=n_epochs, - train_rqmt={ - "time": time_rqmt - }, - train_opts=_train_opts - ) - checkpoints, model_dir, learning_rates = train_exp.run_train() + for const_lr in const_lr_list: + train_alias = alias + f"/train_from_global_att_tf_checkpoint/standard-training/{n_epochs}-epochs_{const_lr}-const-lr_wo-ctc-loss" + if alignment_augmentation_opts: + opts = alignment_augmentation_opts + train_alias += f"_align-aug-{opts['num_iterations']}-iters_{opts['max_shift']}-max-shift" - checkpoint = { - "model_dir": model_dir, - "learning_rates": learning_rates, - "key": "dev_score_label_model/output_prob", - "checkpoints": checkpoints, - "n_epochs": n_epochs - } - yield alias, checkpoint - - -def train_center_window_att_import_center_window_tf( - alias: str, - config_builder: SegmentalAttConfigBuilderRF, - n_epochs_list: Tuple[int, ...], - time_rqmt: int = 168, -): - for n_epochs in n_epochs_list: - alias += "/train_from_center_window_baseline_v1_tf_checkpoint/standard-training/%d-epochs_wo-ctc-loss" % (n_epochs,) - - train_exp = SegmentalTrainExperiment( - config_builder=config_builder, - alias=alias, - num_epochs=n_epochs, - train_rqmt={ - "time": time_rqmt - }, - train_opts={ - # "preload_from_files": { - # "pretrained_global_att_params": { - # "filename": external_checkpoints["center-window_baseline-v1_tf"], - # "ignore_params_prefixes": ["emit_prob.", "s_length_model.", "target_embed_length_model."] - # } - # }, - "import_model_train_epoch1": get_center_window_baseline_v1_tf_checkpoint(), + train_opts = { + "preload_from_files": { + "pretrained_global_att_params": { + "filename": external_checkpoints[default_import_model_name], + "init_for_train": True, + "ignore_missing": True, # because of length model params + } + }, + "aux_loss_layers": None, + "accum_grad_multiple_step": 2, + "optimizer": {"class": "adam", "epsilon": 1e-8}, "train_def": viterbi_training, "train_step_func": _returnn_v2_train_step, "batching": "random", - "aux_loss_layers": None, + "lr_opts": { + "type": "const_then_linear", + "const_lr": const_lr, + "const_frac": 1 / 3, + "final_lr": 1e-6, + "num_epochs": n_epochs + }, + "alignment_augmentation_opts": alignment_augmentation_opts } - ) - checkpoints, model_dir, learning_rates = train_exp.run_train() + if custom_missing_load_func: + train_opts["preload_from_files"]["pretrained_global_att_params"]["custom_missing_load_func"] = custom_missing_load_func - checkpoint = { - "model_dir": model_dir, - "learning_rates": learning_rates, - "key": "dev_score_label_model/output_prob", - "checkpoints": checkpoints, - "n_epochs": n_epochs - } - yield alias, checkpoint + train_exp = SegmentalTrainExperiment( + config_builder=config_builder, + alias=train_alias, + num_epochs=n_epochs, + train_rqmt={ + "time": time_rqmt + }, + train_opts=train_opts + ) + checkpoints, model_dir, learning_rates = train_exp.run_train() + + checkpoint = { + "model_dir": model_dir, + "learning_rates": learning_rates, + "key": "dev_loss_non_blank_ce", + "checkpoints": checkpoints, + "n_epochs": n_epochs + } + yield train_alias, checkpoint diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/global_att/baseline_v1/__init__.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/global_att/baseline_v1/__init__.py index b291006ca..182f46415 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/global_att/baseline_v1/__init__.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/global_att/baseline_v1/__init__.py @@ -30,11 +30,11 @@ def run_exps(): alias=model_alias, config_builder=config_builder, n_epochs_list=(10,), + const_lr_list=(1e-4,), time_rqmt=4, ): recog.global_att_returnn_label_sync_beam_search( alias=train_alias, config_builder=config_builder, checkpoint=checkpoint, - checkpoint_aliases=("last",), ) diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/global_att/train.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/global_att/train.py index 9a8c7100d..d5e500543 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/global_att/train.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/global_att/train.py @@ -1,4 +1,5 @@ from typing import Tuple, Optional, List +import itertools from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.config_builder_rf.base import GlobalAttConfigBuilderRF from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23.train_new import GlobalTrainExperiment @@ -42,7 +43,7 @@ def train_from_scratch( checkpoint = { "model_dir": model_dir, "learning_rates": learning_rates, - "key": "dev_score_output/output_prob", + "key": "dev_loss_ce", "checkpoints": checkpoints, "n_epochs": n_epochs } @@ -54,14 +55,15 @@ def train_import_global_tf( alias: str, config_builder: GlobalAttConfigBuilderRF, n_epochs_list: Tuple[int, ...], + const_lr_list: Tuple[float, ...], time_rqmt: int = 168, ): - for n_epochs in n_epochs_list: - alias += "/train_from_global_att_tf_checkpoint/standard-training/%d-epochs_wo-ctc-loss" % (n_epochs,) + for n_epochs, const_lr in itertools.product(n_epochs_list, const_lr_list): + train_alias = alias + f"/train_from_global_att_tf_checkpoint/standard-training/{n_epochs}-epochs_{const_lr}-const-lr_wo-ctc-loss" train_exp = GlobalTrainExperiment( config_builder=config_builder, - alias=alias, + alias=train_alias, num_epochs=n_epochs, train_rqmt={ "time": time_rqmt @@ -77,6 +79,13 @@ def train_import_global_tf( "train_step_func": _returnn_v2_train_step, "batching": "random", "aux_loss_layers": None, + "lr_opts": { + "type": "const_then_linear", + "const_lr": const_lr, + "const_frac": 1 / 3, + "final_lr": 1e-6, + "num_epochs": n_epochs + }, } ) checkpoints, model_dir, learning_rates = train_exp.run_train() @@ -84,8 +93,8 @@ def train_import_global_tf( checkpoint = { "model_dir": model_dir, "learning_rates": learning_rates, - "key": "dev_score_label_model/output_prob", + "key": "dev_loss_ce", "checkpoints": checkpoints, "n_epochs": n_epochs } - yield alias, checkpoint + yield train_alias, checkpoint From 6a1257f190f66c76e79823dc530feb0d190ec5a0 Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Thu, 23 May 2024 10:16:16 +0000 Subject: [PATCH 050/227] add horovod to libri pipeline --- .../librispeech_960/pipeline.py | 17 +++++++++++++++-- 1 file changed, 15 insertions(+), 2 deletions(-) diff --git a/users/zeineldeen/experiments/conformer_att_2022/librispeech_960/pipeline.py b/users/zeineldeen/experiments/conformer_att_2022/librispeech_960/pipeline.py index aff3a22ca..6d30e979b 100644 --- a/users/zeineldeen/experiments/conformer_att_2022/librispeech_960/pipeline.py +++ b/users/zeineldeen/experiments/conformer_att_2022/librispeech_960/pipeline.py @@ -13,7 +13,15 @@ def training( - prefix_name, returnn_config, returnn_exe, returnn_root, num_epochs, mem_rqmt=15, time_rqmt=168, gpu_mem=None + prefix_name, + returnn_config, + returnn_exe, + returnn_root, + num_epochs, + mem_rqmt=15, + time_rqmt=168, + gpu_mem=None, + horovod_num_processes=None, ): """ @@ -31,7 +39,12 @@ def training( "returnn_root": returnn_root, } - train_job = ReturnnTrainingJob(returnn_config=returnn_config, num_epochs=num_epochs, **default_rqmt) + train_job = ReturnnTrainingJob( + returnn_config=returnn_config, + num_epochs=num_epochs, + horovod_num_processes=horovod_num_processes, + **default_rqmt, + ) if gpu_mem: assert gpu_mem in [11, 24] train_job.rqmt["gpu_mem"] = gpu_mem From 09661d7ccab0fba1455f0d78b4e4a0d780f1b005 Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Thu, 23 May 2024 10:22:06 +0000 Subject: [PATCH 051/227] update configs --- .../tedlium2/configs/ebranch_baseline.py | 11 ++-- .../tedlium2/configs/ted2_att_baseline.py | 53 ++++++++++++++++++- 2 files changed, 57 insertions(+), 7 deletions(-) diff --git a/users/zeineldeen/experiments/conformer_att_2023/tedlium2/configs/ebranch_baseline.py b/users/zeineldeen/experiments/conformer_att_2023/tedlium2/configs/ebranch_baseline.py index b0d1887bf..b8c368eeb 100644 --- a/users/zeineldeen/experiments/conformer_att_2023/tedlium2/configs/ebranch_baseline.py +++ b/users/zeineldeen/experiments/conformer_att_2023/tedlium2/configs/ebranch_baseline.py @@ -869,10 +869,10 @@ def train_mini_self_att( ebranch_enc_args = EBranchformerEncoderArgs( num_blocks=12, input_layer="conv-6", - att_num_heads=6, - ff_dim=1536, - enc_key_dim=384, - conv_kernel_size=31, + att_num_heads=8, + ff_dim=2048, + enc_key_dim=512, + conv_kernel_size=32, pos_enc="rel", dropout=0.1, att_dropout=0.1, @@ -996,7 +996,7 @@ def get_base_v1_args(lr, ep, enc_drop=0.1, pretrain_reps=3, use_legacy_stats=Tru args["encoder_args"].num_blocks = num_blocks args["with_pretrain"] = False - specaug_steps = {"step0": 6_000, "step1": 12_000, "step2": 18_000} + specaug_steps = {"step0": 12_000, "step1": 18_000, "step2": 24_000} args["specaug_str_func_opts"] = { "version": 2, **specaug_steps, @@ -1027,7 +1027,6 @@ def get_base_v1_args(lr, ep, enc_drop=0.1, pretrain_reps=3, use_legacy_stats=Tru num_epochs=ep, epoch_wise_filter=None, bpe_size=BPE_1K, - partition_epoch=4, ) diff --git a/users/zeineldeen/experiments/conformer_att_2023/tedlium2/configs/ted2_att_baseline.py b/users/zeineldeen/experiments/conformer_att_2023/tedlium2/configs/ted2_att_baseline.py index b9e6e4dde..22c0fce9c 100644 --- a/users/zeineldeen/experiments/conformer_att_2023/tedlium2/configs/ted2_att_baseline.py +++ b/users/zeineldeen/experiments/conformer_att_2023/tedlium2/configs/ted2_att_baseline.py @@ -1266,7 +1266,58 @@ def get_base_v1_args(lr, ep, enc_drop=0.1, pretrain_reps=3, use_legacy_stats=Tru partition_epoch=4, ) - # TODO: ebranchformer encoder + # TODO: multi-gpu + for num_blocks in [12]: + for ep in [50 * 4]: + for lr in [8e-4, 16e-4]: + for target_embed_dim in [256]: + for att_drop in [0.0]: + for weight_drop in [0.1]: + for enc_drop in [0.15]: + for ctc_scale in [0.3]: + for sync_step in [50]: + base_v1_args, exp_name = get_base_v1_args( + lr, ep, enc_drop=enc_drop, use_legacy_stats=False + ) + + args = copy.deepcopy(base_v1_args) + args["encoder_args"].num_blocks = num_blocks + args["encoder_args"].mhsa_weight_dropout = weight_drop + args["encoder_args"].ff_weight_dropout = weight_drop + args["encoder_args"].conv_weight_dropout = weight_drop + + args["decoder_args"].embed_dim = target_embed_dim + args["decoder_args"].att_dropout = att_drop + + args["horovod_params"] = { + "horovod_reduce_type": "param", + "horovod_param_sync_step": sync_step, + "horovod_dataset_distribution": "random_seed_offset", + } + + args["batch_size"] = 15_000 * 160 + args["accum_grad"] = 1 + gradient_clip_global_norm = 1 + args["gradient_clip_global_norm"] = gradient_clip_global_norm + + exp_name += f"_weightDrop{weight_drop}_decAttDrop{att_drop}_embedDim{target_embed_dim}_numBlocks{num_blocks}" + exp_name += f"_gradClipNorm{gradient_clip_global_norm}" + exp_name += f"_paramSync_step{sync_step}_accum1" + + if ctc_scale != 1.0: + args["encoder_args"].ctc_loss_scale = ctc_scale + args["decoder_args"].ce_loss_scale = 1.0 - ctc_scale + exp_name += f"_ctcScale{ctc_scale}" + + run_exp( + exp_name + "_gpu4", + args, + num_epochs=ep, + epoch_wise_filter=None, + bpe_size=BPE_1K, + partition_epoch=4 * 4, + horovod_num_processes=4, + ) # # TODO: mixup # for num_blocks in [12]: From c655f06f4e21ff4e1bcbf5fdf65ecd071dbde728 Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Thu, 23 May 2024 10:23:43 +0000 Subject: [PATCH 052/227] fix --- .../conformer_att_2023/tedlium2/configs/ted2_att_baseline.py | 1 + 1 file changed, 1 insertion(+) diff --git a/users/zeineldeen/experiments/conformer_att_2023/tedlium2/configs/ted2_att_baseline.py b/users/zeineldeen/experiments/conformer_att_2023/tedlium2/configs/ted2_att_baseline.py index 22c0fce9c..c8c13e602 100644 --- a/users/zeineldeen/experiments/conformer_att_2023/tedlium2/configs/ted2_att_baseline.py +++ b/users/zeineldeen/experiments/conformer_att_2023/tedlium2/configs/ted2_att_baseline.py @@ -236,6 +236,7 @@ def run_train( RETURNN_ROOT, num_epochs=num_epochs, gpu_mem=kwargs.get("gpu_mem", 11), + horovod_num_processes=kwargs.get("horovod_num_processes", None), ) return train_job From 2b1fe7751203b2dd8d2d61fb2d6ff535ef0ce93d Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Thu, 23 May 2024 14:46:06 +0200 Subject: [PATCH 053/227] more --- .../exp2024_04_23_baselines/aed.py | 27 +++++++++++-------- 1 file changed, 16 insertions(+), 11 deletions(-) diff --git a/users/zeyer/experiments/exp2024_04_23_baselines/aed.py b/users/zeyer/experiments/exp2024_04_23_baselines/aed.py index 6a4ccc9df..941f3086a 100644 --- a/users/zeyer/experiments/exp2024_04_23_baselines/aed.py +++ b/users/zeyer/experiments/exp2024_04_23_baselines/aed.py @@ -68,17 +68,22 @@ def py(): }, ) - train_exp( # 5.16 - "v6-bhv20-11gb-f32-bs15k-accgrad1-mgpu4-pavg100-wd1e_2-lrlin1e_5_295k-speedpertV2-spm10k", - config_11gb_v6_f32_accgrad1_mgpu4_pavg100_wd1e_4, - config_updates={ - **_get_cfg_lrlin_oclr_by_bs_nep(15_000, 500), - "optimizer.weight_decay": 1e-2, - "__train_audio_preprocess": speed_pert_librosa_config, - "speed_pert_discrete_values": [0.7, 0.8, 0.9, 1.0, 1.1], - }, - vocab="spm10k", - ) + for vocab in [ + "bpe10k", # 5.32 + "spm10k", # 5.16 + "spm_bpe10k", + ]: + train_exp( # 5.16 + f"v6-bhv20-11gb-f32-bs15k-accgrad1-mgpu4-pavg100-wd1e_2-lrlin1e_5_295k-speedpertV2-{vocab}", + config_11gb_v6_f32_accgrad1_mgpu4_pavg100_wd1e_4, + config_updates={ + **_get_cfg_lrlin_oclr_by_bs_nep(15_000, 500), + "optimizer.weight_decay": 1e-2, + "__train_audio_preprocess": speed_pert_librosa_config, + "speed_pert_discrete_values": [0.7, 0.8, 0.9, 1.0, 1.1], + }, + vocab=vocab, + ) # Testing sampling in SPM. Baseline without sampling: 5.24 dev-other. # The lower the alpha, the more aggressive the sampling. From 88e03e1c5747fbf40aa1edcb75780f080bdd8de7 Mon Sep 17 00:00:00 2001 From: "luca.gaudino" Date: Thu, 23 May 2024 17:03:47 +0200 Subject: [PATCH 054/227] update --- .../librispeech_960/default_tools.py | 8 +- .../conformer_import_moh_att_2023_06_30.py | 4 +- .../model_recogs/model_recog.py | 4 +- .../tedlium2/_import_model.py | 26 +- .../conformer_import_moh_att_2023_10_19.py | 17 +- .../conformer_import_moh_att_train.py | 97 ++++- .../librispeech_960/__init__.py | 0 .../librispeech_960/conformer_ctc_train.py | 338 ++++++++++++++++++ .../librispeech_960/sis_setup.py | 22 ++ .../tedlium2/conformer_ctc_train.py | 185 ++++++++-- .../tedlium2/conformer_rnnt_train.py | 8 +- .../models/asr/decoder/att_decoder_rf.py | 4 +- 12 files changed, 652 insertions(+), 61 deletions(-) create mode 100644 users/gaudino/experiments/rf_conformer_rnnt_2024/librispeech_960/__init__.py create mode 100644 users/gaudino/experiments/rf_conformer_rnnt_2024/librispeech_960/conformer_ctc_train.py create mode 100644 users/gaudino/experiments/rf_conformer_rnnt_2024/librispeech_960/sis_setup.py diff --git a/users/gaudino/experiments/ctc_rnnt_standalone_2024/librispeech_960/default_tools.py b/users/gaudino/experiments/ctc_rnnt_standalone_2024/librispeech_960/default_tools.py index accfd9035..f26ca58c3 100644 --- a/users/gaudino/experiments/ctc_rnnt_standalone_2024/librispeech_960/default_tools.py +++ b/users/gaudino/experiments/ctc_rnnt_standalone_2024/librispeech_960/default_tools.py @@ -10,10 +10,10 @@ from i6_experiments.common.tools.sctk import compile_sctk # python from apptainer/singularity/docker -RETURNN_EXE = tk.Path( - "/u/luca.gaudino/bin/returnn_launcher_nocuda.sh", hash_overwrite="GENERIC_RETURNN_LAUNCHER" -) -# RETURNN_EXE = tk.Path("/usr/bin/python3", hash_overwrite="GENERIC_RETURNN_LAUNCHER") +# RETURNN_EXE = tk.Path( +# "/u/luca.gaudino/bin/returnn_launcher_nocuda.sh", hash_overwrite="GENERIC_RETURNN_LAUNCHER" +# ) +RETURNN_EXE = tk.Path("/usr/bin/python3", hash_overwrite="GENERIC_RETURNN_LAUNCHER") MINI_RETURNN_ROOT = CloneGitRepositoryJob( "https://github.com/JackTemaki/MiniReturnn", commit="0dc69329b21ce0acade4fcb2bf1be0dc8cc0b121" diff --git a/users/gaudino/experiments/rf_conformer_att_2023/librispeech_960/conformer_import_moh_att_2023_06_30.py b/users/gaudino/experiments/rf_conformer_att_2023/librispeech_960/conformer_import_moh_att_2023_06_30.py index 2e9b4cf04..e692580cd 100644 --- a/users/gaudino/experiments/rf_conformer_att_2023/librispeech_960/conformer_import_moh_att_2023_06_30.py +++ b/users/gaudino/experiments/rf_conformer_att_2023/librispeech_960/conformer_import_moh_att_2023_06_30.py @@ -6,7 +6,7 @@ from typing import Optional, Any, Tuple, Dict, Sequence, List from itertools import product -from i6_experiments.users.gaudino.models.asr.rf.trafo_lm.lm_import_2023_11_09 import ( +from i6_experiments.users.gaudino.models.asr.rf.nn_lm.lm_import_2023_11_09 import ( Trafo_LM_Model, ) from sisyphus import tk @@ -19,7 +19,7 @@ LSTM_LM_Model, # MakeModel, ) -from i6_experiments.users.gaudino.experiments.rf_conformer_att_2023.tedlium2.ilm_import_2024_04_17 import ( +from i6_experiments.users.gaudino.models.asr.rf.ilm_import_2024_04_17 import ( MiniAtt_ILM_Model, ) from i6_experiments.users.gaudino.model_interfaces.model_interfaces import ModelDef, TrainDef diff --git a/users/gaudino/experiments/rf_conformer_att_2023/librispeech_960/model_recogs/model_recog.py b/users/gaudino/experiments/rf_conformer_att_2023/librispeech_960/model_recogs/model_recog.py index 92f158239..1c8d16b85 100644 --- a/users/gaudino/experiments/rf_conformer_att_2023/librispeech_960/model_recogs/model_recog.py +++ b/users/gaudino/experiments/rf_conformer_att_2023/librispeech_960/model_recogs/model_recog.py @@ -166,7 +166,9 @@ def model_recog( lm_state = lm_out["state"] lm_log_prob = rf.log_softmax(lm_out["output"], axis=model.target_dim) - if i > 0: + + + if not model.search_args.get("use_lm_first_label", False) and i > 0: label_log_prob = ( label_log_prob + model.search_args["lm_scale"] * lm_log_prob ) diff --git a/users/gaudino/experiments/rf_conformer_att_2023/tedlium2/_import_model.py b/users/gaudino/experiments/rf_conformer_att_2023/tedlium2/_import_model.py index 3971eae02..5971097fa 100644 --- a/users/gaudino/experiments/rf_conformer_att_2023/tedlium2/_import_model.py +++ b/users/gaudino/experiments/rf_conformer_att_2023/tedlium2/_import_model.py @@ -18,11 +18,11 @@ MakeModel, ) -from i6_experiments.users.gaudino.models.asr.rf.trafo_lm.lm_import_2023_11_09 import ( +from i6_experiments.users.gaudino.models.asr.rf.nn_lm.lm_import_2023_11_09 import ( MakeModel as MakeModelLM, ) -from i6_experiments.users.gaudino.experiments.rf_conformer_att_2023.tedlium2.ilm_import_2024_04_17 import ( +from i6_experiments.users.gaudino.models.asr.rf.ilm_import_2024_04_17 import ( MakeModel as MakeModelILM, ) @@ -598,9 +598,9 @@ def map_param_func_mini_att_ilm( def import_models(): # for model_name, sep_enc in product(list(models.keys())[-1:], [True, False]): - model_list = ["model_ctc0.5_att0.5"] + model_list = ["model_baseline"] # model_list = ["model_ctc0.9_att0.1", "model_ctc0.8_att0.2", "model_ctc0.7_att0.3", "model_ctc0.6_att0.4", "model_ctc0.5_att0.5", "model_ctc0.4_att0.6"] - for model_name, sep_enc, add_trafo_lm in product(model_list, [False], [True]): + for model_name, sep_enc, add_trafo_lm in product(model_list, [False], [False]): model_args = { "target_embed_dim": 256, "add_trafo_lm": add_trafo_lm, @@ -615,7 +615,7 @@ def import_models(): + " ..." ) out_dir = "/work/asr3/zeineldeen/hiwis/luca.gaudino/setups-data/2023-08-10--rf-librispeech/work/i6_experiments/users/gaudino/returnn/convert_ckpt_rf/tedlium2/without_lm/" - out_dir_postfix = model_name + ("__ctc_only" if sep_enc else "") + ("__trafo_lm" if add_trafo_lm else "") + out_dir_postfix = model_name + ("__ctc_only" if sep_enc else "") + ("__trafo_lm" if add_trafo_lm else "") + "_24_05_22" ckpt_path = models[model_name]["ckpt"].ckpt_path @@ -647,16 +647,16 @@ def import_models(): if __name__ == "__main__": - # import_models() + import_models() # convert_lm( # _ted2_lm_ckpt_filename, # "/work/asr3/zeineldeen/hiwis/luca.gaudino/setups-data/2023-08-10--rf-librispeech/work/i6_experiments/users/gaudino/returnn/convert_ckpt_rf/tedlium2/trafo_lm_only_24_02_05", # 1057, # ) - convert_mini_att_ilm( - ckpt_path_prior="/u/zeineldeen/setups/ubuntu_22_setups/2023-04-17--conformer-att/work/i6_core/returnn/training/AverageTFCheckpointsJob.yB4JK4GDCxWG/output/model/average", - ckpt_path_mini_att="/u/zeineldeen/setups/ubuntu_22_setups/2023-04-17--conformer-att/work/i6_core/returnn/training/GetBestTFCheckpointJob.70hGEsLQ6ynw/output/model/checkpoint", - model_in_dim=256, - model_target_dim=1057, - out_dir="/work/asr3/zeineldeen/hiwis/luca.gaudino/setups-data/2023-08-10--rf-librispeech/work/i6_experiments/users/gaudino/returnn/convert_ckpt_rf/tedlium2/mini_att_ilm_24_04_21", - ) + # convert_mini_att_ilm( + # ckpt_path_prior="/u/zeineldeen/setups/ubuntu_22_setups/2023-04-17--conformer-att/work/i6_core/returnn/training/AverageTFCheckpointsJob.yB4JK4GDCxWG/output/model/average", + # ckpt_path_mini_att="/u/zeineldeen/setups/ubuntu_22_setups/2023-04-17--conformer-att/work/i6_core/returnn/training/GetBestTFCheckpointJob.70hGEsLQ6ynw/output/model/checkpoint", + # model_in_dim=256, + # model_target_dim=1057, + # out_dir="/work/asr3/zeineldeen/hiwis/luca.gaudino/setups-data/2023-08-10--rf-librispeech/work/i6_experiments/users/gaudino/returnn/convert_ckpt_rf/tedlium2/mini_att_ilm_24_04_21", + # ) diff --git a/users/gaudino/experiments/rf_conformer_att_2023/tedlium2/conformer_import_moh_att_2023_10_19.py b/users/gaudino/experiments/rf_conformer_att_2023/tedlium2/conformer_import_moh_att_2023_10_19.py index dd8e5700c..526a7d6a6 100644 --- a/users/gaudino/experiments/rf_conformer_att_2023/tedlium2/conformer_import_moh_att_2023_10_19.py +++ b/users/gaudino/experiments/rf_conformer_att_2023/tedlium2/conformer_import_moh_att_2023_10_19.py @@ -403,7 +403,7 @@ def sis_run_with_prefix(prefix_name: str = None): # ctc beam search espnet for model_name in ctc_beam_search_model_names: for scales, beam_size in product( - ctc_beam_search_model_names[model_name]["scales"], [32] + ctc_beam_search_model_names[model_name]["scales"], [32] # 32 ): att_scale, ctc_scale, prior_scale = scales @@ -463,7 +463,8 @@ def sis_run_with_prefix(prefix_name: str = None): # att + ilm correction for model_name, lm_scale, ilm_scale, beam_size in product( - ["model_baseline", "model_ctc0.5_att0.5"], [0.36] ,[0.28], [12] + # ["model_baseline", "model_ctc0.5_att0.5"], [0.36] ,[0.28], [12] + ["model_baseline"], [0.36] ,[0.28], [12] ): ilm_model_args = copy.deepcopy(models_with_pt_ckpt[model_name]["model_args"]) ilm_model_args["preload_from_files"] = { @@ -526,14 +527,16 @@ def sis_run_with_prefix(prefix_name: str = None): models_with_pt_ckpt[model_name]["model_args"] = model_args # att + trafo lm - for model_name, lm_scale, beam_size in product( - ["model_ctc0.5_att0.5"], [0.15], [12] + for model_name, lm_scale, beam_size, use_first_lm in product( + ["model_baseline"], [0.15], [6, 12, 18], [True, False] ): + lm_model_args = copy.deepcopy(models_with_pt_ckpt[model_name]["model_args"]) name = ( prefix_name + "/" + model_name + f"/att_trafolm{lm_scale}" + + (f"_first_lm" if use_first_lm else "") + f"_beam{beam_size}" ) search_args = { @@ -542,13 +545,17 @@ def sis_run_with_prefix(prefix_name: str = None): "lm_scale": lm_scale, "bsf": bsf, } + if use_first_lm: + search_args["use_first_lm"] = True + else: + search_args.pop("use_first_lm", None) recog_res, recog_out = recog_model( task, models_with_pt_ckpt[model_name]["ckpt"], model_recog, dev_sets=["dev"], - model_args=models_with_pt_ckpt[model_name]["model_args"], + model_args=lm_model_args, search_args=search_args, prefix_name=name, ) diff --git a/users/gaudino/experiments/rf_conformer_att_2023/tedlium2/conformer_import_moh_att_train.py b/users/gaudino/experiments/rf_conformer_att_2023/tedlium2/conformer_import_moh_att_train.py index 74c413ba6..fe0451e21 100644 --- a/users/gaudino/experiments/rf_conformer_att_2023/tedlium2/conformer_import_moh_att_train.py +++ b/users/gaudino/experiments/rf_conformer_att_2023/tedlium2/conformer_import_moh_att_train.py @@ -105,7 +105,7 @@ def sis_run_with_prefix(prefix_name: Optional[str] = None): # train_exp("base-11gb", config_11gb, gpu_mem=11) # train_exp("base-11gb-v1", my_config_11gb, num_epochs=400, gpu_mem=11) - train_exp( + train_exp( # dev 8.77 test 8.26 "base-11gb-v3-lrlin1e_5_600k_aux4_8", my_config_11gb, config_updates={ @@ -120,6 +120,101 @@ def sis_run_with_prefix(prefix_name: Optional[str] = None): gpu_mem=11, ) + # train_exp( # aux 12: does not converge + # "base-11gb-v3-lrlin1e_5_261k", + # my_config_11gb, + # config_updates={ + # "learning_rate": 1.0, + # "dynamic_learning_rate": dyn_lr_piecewise_linear, + # "learning_rate_piecewise_steps": [261_000, 522_000, 580_000], # 45% 45 % 10% + # "learning_rate_piecewise_values": [1e-5, 1e-3, 1e-5, 1e-6], + # }, + # num_epochs=400, + # gpu_mem=11, + # ) + + train_exp( # dev 7.89 test 7.3 + "base-11gb-v3-lrlin1e_5_261k_aux4_8", + my_config_11gb, + config_updates={ + "learning_rate": 1.0, + "dynamic_learning_rate": dyn_lr_piecewise_linear, + "learning_rate_piecewise_steps": [261_000, 522_000, 580_000], # 45% 45 % 10% + "learning_rate_piecewise_values": [1e-5, 1e-3, 1e-5, 1e-6], + "aux_loss_layers": [4, 8], + }, + num_epochs=400, + gpu_mem=11, + ) + + train_exp( # + "base-11gb-v3-lrlin1e_5_261k_aux4_8_12", + my_config_11gb, + config_updates={ + "learning_rate": 1.0, + "dynamic_learning_rate": dyn_lr_piecewise_linear, + "learning_rate_piecewise_steps": [261_000, 522_000, 580_000], # 45% 45 % 10% + "learning_rate_piecewise_values": [1e-5, 1e-3, 1e-5, 1e-6], + "aux_loss_layers": [4, 8, 12], + }, + num_epochs=400, + gpu_mem=11, + ) + + # train_exp( # does not converge + # "base-11gb-v3-lrlin8e_5_261k_aux4_8", + # my_config_11gb, + # config_updates={ + # "learning_rate": 1.0, + # "dynamic_learning_rate": dyn_lr_piecewise_linear, + # "learning_rate_piecewise_steps": [261_000, 522_000, 580_000], # 45% 45 % 10% + # "learning_rate_piecewise_values": [8e-5, 8e-4, 8e-5, 1e-6], + # "aux_loss_layers": [4, 8], + # }, + # num_epochs=400, + # gpu_mem=11, + # ) + + model = train_exp( # with aux 4 8: dev 9.92 test 8.96 - wrong steps!!! + "base-24gb-v6-lrlin1e_5_261k", + config_24gb_v6, + config_updates={ + "learning_rate": 1.0, + "dynamic_learning_rate": dyn_lr_piecewise_linear, + "learning_rate_piecewise_steps": [261_000, 522_000, 580_000], + "learning_rate_piecewise_values": [1e-5, 1e-3, 1e-5, 1e-6], + }, + num_epochs=400, + ) + + + model = train_exp( # + "base-24gb-v6-lrlin1e_5_85k", + config_24gb_v6, + config_updates={ + "learning_rate": 1.0, + "dynamic_learning_rate": dyn_lr_piecewise_linear, + # total steps after 400 epochs: 189.995 + "learning_rate_piecewise_steps": [85_500, 171_000, 190_000], + "learning_rate_piecewise_values": [1e-5, 1e-3, 1e-5, 1e-6], + }, + num_epochs=400, + ) + + + # train_exp( # does not converge + # "base-11gb-v3-lrlin8e_5_lrmax8e_4_261k", + # my_config_11gb, + # config_updates={ + # "learning_rate": 1.0, + # "dynamic_learning_rate": dyn_lr_piecewise_linear, + # "learning_rate_piecewise_steps": [261_000, 522_000, 580_000], # 45% 45 % 10% + # "learning_rate_piecewise_values": [8e-5, 8e-4, 8e-5, 1e-6], + # }, + # num_epochs=400, + # gpu_mem=11, + # ) + # train_exp( # dev-other 7.6 # "base-24gb-bs30k-f32", # config_24gb, diff --git a/users/gaudino/experiments/rf_conformer_rnnt_2024/librispeech_960/__init__.py b/users/gaudino/experiments/rf_conformer_rnnt_2024/librispeech_960/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/users/gaudino/experiments/rf_conformer_rnnt_2024/librispeech_960/conformer_ctc_train.py b/users/gaudino/experiments/rf_conformer_rnnt_2024/librispeech_960/conformer_ctc_train.py new file mode 100644 index 000000000..25d1a4bb4 --- /dev/null +++ b/users/gaudino/experiments/rf_conformer_rnnt_2024/librispeech_960/conformer_ctc_train.py @@ -0,0 +1,338 @@ +"""Copied from Albert Zeyer 25.03.2024, then modified +""" + +from __future__ import annotations + +from typing import TYPE_CHECKING, Optional, Union, Tuple, Sequence, List, Collection +import tree +import math +import numpy as np +import hashlib +import contextlib +import functools + +from returnn.tensor import Tensor, Dim, single_step_dim +import returnn.frontend as rf +from returnn.frontend.tensor_array import TensorArray +from returnn.frontend.encoder.conformer import ConformerEncoder, ConformerConvSubsample + +from i6_experiments.users.gaudino.model_interfaces.supports_label_scorer_torch import ( + RFModelWithMakeLabelScorer, +) +from i6_experiments.users.gaudino.experiments.rf_conformer_att_2023.librispeech_960.configs import * +from i6_experiments.users.gaudino.experiments.rf_conformer_att_2023.librispeech_960.configs import ( + _batch_size_factor, + _cfg_lrlin1e_5_295k, + _get_cfg_lrlin_oclr_by_bs_nep, +) +# from .trafo_lm import trafo_lm_kazuki_import + +from i6_experiments.users.gaudino.models.asr.rf.conformer_ctc.model_conformer_ctc import from_scratch_model_def, from_scratch_training +from i6_experiments.users.gaudino.models.asr.rf.conformer_ctc.model_recog_ctc_greedy import model_recog + +if TYPE_CHECKING: + from i6_experiments.users.zeyer.model_interfaces import ModelDef, RecogDef, TrainDef + from i6_experiments.users.zeyer.model_with_checkpoints import ( + ModelWithCheckpoints, + ModelWithCheckpoint, + ) + +# From Mohammad, 2023-06-29 +# dev-clean 2.27 +# dev-other 5.39 +# test-clean 2.41 +# test-other 5.51 +# _returnn_tf_config_filename = ( +# "/work/asr4/zeineldeen/setups-data/librispeech/2022-11-28--conformer-att/work/i6_core/returnn/search/ReturnnSearchJobV2.1oORPHJTAcW0/output/returnn.config") +# E.g. via /u/zeineldeen/setups/librispeech/2022-11-28--conformer-att/work +_returnn_tf_ckpt_filename = "i6_core/returnn/training/AverageTFCheckpointsJob.BxqgICRSGkgb/output/model/average.index" +# /u/zeineldeen/setups/librispeech/2022-11-28--conformer-att/work/i6_core/returnn/training/AverageTFCheckpointsJob.BxqgICRSGkgb +# Main train (2035 subepochs): /work/asr4/zeineldeen/setups-data/librispeech/2022-11-28--conformer-att/work/i6_core/returnn/training/ReturnnTrainingJob.SAh74CLCNJQi +# 15k batch size, accum grad 2 (1350 steps per epoch?) +# (With batch size 40k (here default), I have usually 495 steps/epoch. Same accum grad 2.) +# peak_lr = 0.9e-3 (1e-3 should also be fine), with Adam, optimizer_epsilon = 1e-08 +# phase1: peak_lr / 10 -> peak_lr (45%) +# phase2: peak_lr -> peak_lr / 10 (45%) +# phase3: peak_lr / 10 -> 1e-6 (10%) +# all linear decay and step-based +# specaugment like my orig (same here, specaugorig), speed perturb same here. +# weight decay: L2 1e-4 in some layers (not all): FF, depthwise conv, self-att, output, LSTM, readout +# Final from learning_rates file: +# 2035: EpochData(learningRate=, error={ +# 'dev_error_ctc': 0.0520755184693418, +# 'dev_error_output/output_prob': 0.035661241551042944, +# 'dev_score_ctc': 0.2796084385705723, +# 'dev_score_output/output_prob': 0.1718613621694714, +# 'devtrain_error_ctc': 0.005757552549708462, +# 'devtrain_error_output/output_prob': 0.005408351877314902, +# 'devtrain_score_ctc': 0.022935187616968285, +# 'devtrain_score_output/output_prob': 0.05237826015574962, +# 'train_error_ctc': 0.05592114304093772, +# 'train_error_output/output_prob': 0.041970552995693494, +# 'train_score_ctc': 0.21249712733341475, +# 'train_score_output/output_prob': 0.20816428663741796, +# }), +# Retrain RETURNN training job (600 subepochs): /u/zeineldeen/setups/librispeech/2022-11-28--conformer-att/work/i6_core/returnn/training/ReturnnTrainingJob.ZhtaEElHqWlr +# Epoch-wise LR: +# Fixed for 20 subepochs: 1e-4 +# Linear(?) decay for remaining (?): 1e-4 to 1e-6 +# Final from learning_rates file: +# 600: EpochData(learningRate=1e-06, error={ +# 'dev_error_ctc': 0.04999311020358747, +# 'dev_error_output/output_prob': 0.03406881170076022, +# 'dev_score_ctc': 0.2881619431223589, +# 'dev_score_output/output_prob': 0.16851828029171323, +# 'devtrain_error_ctc': 0.003611245977923651, +# 'devtrain_error_output/output_prob': 0.004028583366881808, +# 'devtrain_score_ctc': 0.014762402644778178, +# 'devtrain_score_output/output_prob': 0.0458638666428664, +# 'train_error_ctc': 0.051649620746772214, +# 'train_error_output/output_prob': 0.03977601830532325, +# 'train_score_ctc': 0.19722012590584306, +# 'train_score_output/output_prob': 0.19768974342596793, +# }), + + +# The model gets raw features (16khz) and does feature extraction internally. +_log_mel_feature_dim = 80 + + +def sis_run_with_prefix(prefix_name: Optional[str] = None): + """run the exp""" + _sis_setup_global_prefix(prefix_name) + + # Moh: dev-clean 2.27, dev-other 5.39, test-clean 2.41, test-other 5.51 + # RF recog: {"dev-clean": 2.25, "dev-other": 5.34, "test-clean": 2.42, "test-other": 5.56} + # _recog_imported() + + # train_exp("from-scratch-train", config_11gb, gpu_mem=11) + + # model = train_exp( # 5.41 + # "base-24gb-v6-lrlin1e_5_600k", + # config_24gb_v6, + # config_updates={ + # "learning_rate": 1.0, + # "dynamic_learning_rate": dyn_lr_piecewise_linear, + # # total steps after 2000 epochs: 982.312 + # "learning_rate_piecewise_steps": [600_000, 900_000, 982_000], + # "learning_rate_piecewise_values": [1e-5, 1e-3, 1e-5, 1e-6], + # }, + # ) + + train_exp( # + "base-24gb-lrlin1e_5_600k_ctc_only", + config_24gb_v6, + config_updates={ + "learning_rate": 1.0, + "dynamic_learning_rate": dyn_lr_piecewise_linear, + # total steps after 2000 epochs: 982.312 + "learning_rate_piecewise_steps": [600_000, 900_000, 982_000], + "learning_rate_piecewise_values": [1e-5, 1e-3, 1e-5, 1e-6], + "aux_loss_layers":[], + }, + ) + + train_exp( # + "base-24gb-lrlin1e_5_600k_ctc_only_aux4_8", + config_24gb_v6, + config_updates={ + "learning_rate": 1.0, + "dynamic_learning_rate": dyn_lr_piecewise_linear, + # total steps after 2000 epochs: 982.312 + "learning_rate_piecewise_steps": [600_000, 900_000, 982_000], + "learning_rate_piecewise_values": [1e-5, 1e-3, 1e-5, 1e-6], + }, + ) + +_sis_prefix: Optional[str] = None + + +def _sis_setup_global_prefix(prefix_name: Optional[str] = None): + if not prefix_name: + from .sis_setup import get_prefix_for_config + + prefix_name = get_prefix_for_config(__file__) + global _sis_prefix + _sis_prefix = prefix_name + + +def _recog( + name: str, + model_with_checkpoint: ModelWithCheckpoint, + recog_def: RecogDef = None, + recog_config: Optional[Dict[str, Any]] = None, + *, + search_rqmt: Optional[Dict[str, Any]] = None, + dev_sets: Optional[Collection[str]] = None, +): + from sisyphus import tk + from i6_experiments.users.zeyer.recog import recog_model + + if recog_def is None: + recog_def = model_recog + + task = _get_ls_task() + + res = recog_model( + task, + model_with_checkpoint, + recog_def=recog_def, + config=recog_config, + search_rqmt=search_rqmt, + dev_sets=dev_sets, + ) + tk.register_output(_sis_prefix + "/" + name, res.output) + + +# noinspection PyShadowingNames +def train_exp( + name: str, + config: Dict[str, Any], + *, + config_updates: Optional[Dict[str, Any]] = None, + config_deletes: Optional[Sequence[str]] = None, + post_config_updates: Optional[Dict[str, Any]] = None, + num_epochs: int = 2000, + gpu_mem: Optional[int] = 24, + num_processes: Optional[int] = None, + fine_tune: Optional[Union[int, List[Tuple[int, Dict[str, Any]]]]] = None, + time_rqmt: Optional[int] = None, + model_avg: bool = False, +) -> ModelWithCheckpoints: + """ + Train experiment + """ + from i6_experiments.users.gaudino.experiments.rf_conformer_att_2023.train import ( + train, + ) + from i6_experiments.users.zeyer.recog import recog_training_exp + + if _sis_prefix is None: + _sis_setup_global_prefix() + + prefix = _sis_prefix + "/" + name + task = _get_ls_task() + config = config.copy() + config = dict_update_deep(config, config_updates, config_deletes) + if "__num_epochs" in config: + num_epochs = config.pop("__num_epochs") + if "__gpu_mem" in config: + gpu_mem = config.pop("__gpu_mem") + if "__num_processes" in config: + num_processes = config.pop("__num_processes") + + model_with_checkpoint = train( + prefix, + task=task, + config=config, + post_config=dict_update_deep(post_config, post_config_updates), + model_def=from_scratch_model_def, + train_def=from_scratch_training, + num_epochs=num_epochs, + gpu_mem=gpu_mem, + num_processes=num_processes, + distributed_launch_cmd="torchrun" if num_processes else "mpirun", + time_rqmt=time_rqmt, + ) + recog_training_exp( + prefix, task, model_with_checkpoint, recog_def=model_recog, model_avg=model_avg + ) + + if fine_tune: + if isinstance(fine_tune, int): + fine_tune = [(fine_tune, {})] + for ep, opts in fine_tune: + assert isinstance(ep, int) and isinstance(opts, dict) + suffix = f"/finetune/{ep}" + opts = opts.copy() + if opts: + for k, v in sorted(opts.items()): + k: str + suffix += "-" + k.lstrip("_") + v = str(v).replace("-", "_") + if len(v) > 16 and not k.startswith("_"): + suffix += "_" + hashlib.md5(v.encode("utf8")).hexdigest()[:8] + else: + suffix += v + num_epochs_ = opts.pop("num_epochs", 50) + config_ = config.copy() + config_["import_model_train_epoch1"] = model_with_checkpoint.get_epoch( + ep + ).checkpoint + config_.pop("dynamic_learning_rate") + lrs = opts.pop("learning_rates", None) + if lrs is None: + lr_decay_type = opts.pop( + "lr_decay_type", "geomspace" + ) # geomspace or linspace + lr_decay_func = getattr(np, lr_decay_type) + lr = config_["learning_rate"] + final_lr = opts.pop("final_lr", 1e-7) + lrs = list(lr_decay_func(lr, final_lr, num=num_epochs_)) + else: + assert isinstance(lrs, (list, tuple)) + assert len(lrs) == num_epochs_ + config_["learning_rates"] = lrs + config_["learning_rate"] = float(lrs[-1]) + config_["specaugment_steps"] = (0, 0, 0) + config_.update({k: v for k, v in opts.items() if not k.startswith("_")}) + + finetune_model_with_ckpt = train( + prefix + suffix, + task=task, + config=config_, + post_config=post_config, + model_def=from_scratch_model_def, + train_def=from_scratch_training, + num_epochs=num_epochs_, + gpu_mem=gpu_mem, + ) + # _recog(name + suffix + "/recog/last", finetune_model_with_ckpt.get_last_fixed_epoch()) + recog_training_exp( + prefix + suffix, task, finetune_model_with_ckpt, recog_def=model_recog + ) + + return model_with_checkpoint + + +_ls_task = None + + +def _get_ls_task(): + global _ls_task + if _ls_task: + return _ls_task + + from i6_experiments.users.zeyer.datasets.librispeech import ( + get_librispeech_task_bpe10k_raw, + ) + + _ls_task = get_librispeech_task_bpe10k_raw(with_eos_postfix=True) + return _ls_task + + +py = sis_run_with_prefix # if run directly via `sis m ...` + + +def model_warmup(*, model: Model, **_kwargs): + """warmup, for more reliable timing measures""" + import torch + import time + from returnn.config import get_global_config + from returnn.tensor import Dim + import returnn.frontend as rf + + config = get_global_config() + start_time = time.monotonic() + limit = start_time + config.float("model_warmup_time", 10.0) + + print("*** warming up...") + while time.monotonic() < limit: + batch_dim = Dim(10, name="dummy_batch") + time_dim = Dim(rf.full(dims=[batch_dim], fill_value=16_000), name="dummy_time") + feat_dim = Dim(1, name="dummy_feat") + source = rf.zeros([batch_dim, time_dim, feat_dim]) + res = model.encode(source=source, in_spatial_dim=time_dim) + if source.raw_tensor.device.type == "cuda": + torch.cuda.synchronize(source.raw_tensor.device) + res # noqa # keep ref to make sure it is calculated diff --git a/users/gaudino/experiments/rf_conformer_rnnt_2024/librispeech_960/sis_setup.py b/users/gaudino/experiments/rf_conformer_rnnt_2024/librispeech_960/sis_setup.py new file mode 100644 index 000000000..e477f6100 --- /dev/null +++ b/users/gaudino/experiments/rf_conformer_rnnt_2024/librispeech_960/sis_setup.py @@ -0,0 +1,22 @@ +""" +Helpers for the Sisyphus setup +""" + +from __future__ import annotations +import os + + +_my_dir = os.path.dirname(os.path.abspath(__file__)) + + +def get_prefix_for_config(src_filename: str): + """ + :param src_filename: pass `__file__` here + :return: some prefix name + """ + assert src_filename.endswith(".py") + assert src_filename.startswith(_my_dir + "/"), f"unexpected prefix in {src_filename}" + src_filename = src_filename[len(_my_dir) + 1 :] + assert "/" not in src_filename, f"unexpected path separator in {src_filename}" + exp_name = src_filename[:-3] + return "librispeech_960_exp2024_05_13_rf/" + exp_name diff --git a/users/gaudino/experiments/rf_conformer_rnnt_2024/tedlium2/conformer_ctc_train.py b/users/gaudino/experiments/rf_conformer_rnnt_2024/tedlium2/conformer_ctc_train.py index 11c06ed43..900926eae 100644 --- a/users/gaudino/experiments/rf_conformer_rnnt_2024/tedlium2/conformer_ctc_train.py +++ b/users/gaudino/experiments/rf_conformer_rnnt_2024/tedlium2/conformer_ctc_train.py @@ -51,50 +51,175 @@ def sis_run_with_prefix(prefix_name: Optional[str] = None): # RF recog: {"dev-clean": 2.25, "dev-other": 5.34, "test-clean": 2.42, "test-other": 5.56} # _recog_imported() - rnnt_train_config = dict( - batching="laplace:.1000", - batch_size=15_000 * _batch_size_factor, - max_seqs=200, - # max_seq_length_default_target=75, - specaugment_steps=(10_000, 20_000, 40_000), - # gradient_clip=0, - # gradient_clip_global_norm = 1.0 - optimizer={ - "class": "adamw", - "epsilon": 1e-8, - "weight_decay": 1e-6, - }, - # accum_grad_multiple_step=4, - # gradient_noise=0.0, - learning_rate=2.5e-3, - dynamic_learning_rate=dyn_lr_lin_warmup_invsqrt_decay, - learning_rate_warmup_steps=40_000, - learning_rate_invsqrt_norm=40_000, - # aux_loss_layers=[4, 8], - max_seq_length_default_target=None, - gradient_clip_global_norm=5.0, - accum_grad_multiple_step=2, - aux_loss_layers=[4,8], - # rnnt_loss=False, -) + ctc_train_config = dict( + batching="laplace:.1000", + batch_size=15_000 * _batch_size_factor, + max_seqs=200, + # max_seq_length_default_target=75, + specaugment_steps=(10_000, 20_000, 40_000), + # gradient_clip=0, + # gradient_clip_global_norm = 1.0 + optimizer={ + "class": "adamw", + "epsilon": 1e-8, + "weight_decay": 1e-6, + }, + # accum_grad_multiple_step=4, + # gradient_noise=0.0, + learning_rate=2.5e-3, + dynamic_learning_rate=dyn_lr_lin_warmup_invsqrt_decay, + learning_rate_warmup_steps=40_000, + learning_rate_invsqrt_norm=40_000, + max_seq_length_default_target=None, + gradient_clip_global_norm=5.0, + accum_grad_multiple_step=2, + aux_loss_layers=[4,8], + # rnnt_loss=False, + ) + + ctc_train_24gb_config = ctc_train_config.copy() + ctc_train_24gb_config.update( + dict( + torch_amp="bfloat16", + batch_size=40_000 * _batch_size_factor, + accum_grad_multiple_step=2, + learning_rate=1e-3, + learning_rate_warmup_steps=20_000, + learning_rate_invsqrt_norm=20_000, + specaugment_steps=(5_000, 15_000, 25_000), + grad_scaler=None, + rf_att_dropout_broadcast=False, + ) + ) + ctc_train_24gb_config["optimizer"]["epsilon"] = 1e-16 + ctc_train_24gb_config["optimizer"]["weight_decay_modules_blacklist"]: [ # wdblacklist2 + "rf.Embedding", + "rf.LearnedRelativePositionalEncoding", + ] + # train_exp("base-11gb", config_11gb, gpu_mem=11) # train_exp("base-11gb-v1", my_config_11gb, num_epochs=400, gpu_mem=11) + # train_exp( # does not converge + # "from-scratch-11gb_aux4_8_lrmaxs522k", + # ctc_train_config, + # config_updates={ + # "learning_rate": 1.0, + # "dynamic_learning_rate": dyn_lr_piecewise_linear, + # # total steps after 2000 epochs: 982.312 + # # total steps after 400 epochs: + # "learning_rate_piecewise_steps": [261_000, 522_000, 580_000], # 45% 45 % 10% + # # "learning_rate_piecewise_steps": [600_000, 900_000, 982_000], # 45% 45 % 10% + # "learning_rate_piecewise_values": [1e-5, 1e-3, 1e-5, 1e-6], + # }, + # num_epochs=400, + # gpu_mem=11, + # ) + + # train_exp(# does not converge + # "from-scratch-11gb_lrmaxs522k", + # ctc_train_config, + # config_updates={ + # "learning_rate": 1.0, + # "dynamic_learning_rate": dyn_lr_piecewise_linear, + # # total steps after 2000 epochs: 982.312 + # # total steps after 400 epochs: + # "learning_rate_piecewise_steps": [261_000, 522_000, 580_000], # 45% 45 % 10% + # # "learning_rate_piecewise_steps": [600_000, 900_000, 982_000], # 45% 45 % 10% + # "learning_rate_piecewise_values": [1e-5, 1e-3, 1e-5, 1e-6], + # "aux_loss_layers": [], + # }, + # num_epochs=400, + # gpu_mem=11, + # ) + + # train_exp( # does not converge + # "from-scratch-11gb_lrmaxs522k_lrmax5e-4", + # ctc_train_config, + # config_updates={ + # "learning_rate": 1.0, + # "dynamic_learning_rate": dyn_lr_piecewise_linear, + # # total steps after 2000 epochs: 982.312 + # # total steps after 400 epochs: + # "learning_rate_piecewise_steps": [261_000, 522_000, 580_000], # 45% 45 % 10% + # # "learning_rate_piecewise_steps": [600_000, 900_000, 982_000], # 45% 45 % 10% + # "learning_rate_piecewise_values": [1e-5, 3e-4, 1e-5, 1e-6], + # "aux_loss_layers": [], + # }, + # num_epochs=400, + # gpu_mem=11, + # ) + # + # train_exp( # does not converge + # "from-scratch-11gb_lrmaxs522k_lrmin8e-5_lrmax8e-4", + # ctc_train_config, + # config_updates={ + # "learning_rate": 1.0, + # "dynamic_learning_rate": dyn_lr_piecewise_linear, + # # total steps after 2000 epochs: 982.312 + # # total steps after 400 epochs: + # "learning_rate_piecewise_steps": [261_000, 522_000, 580_000], # 45% 45 % 10% + # # "learning_rate_piecewise_steps": [600_000, 900_000, 982_000], # 45% 45 % 10% + # "learning_rate_piecewise_values": [8e-5, 8e-4, 8e-5, 1e-6], + # "aux_loss_layers": [], + # }, + # num_epochs=400, + # gpu_mem=11, + # ) + train_exp( - "from-scratch-11gb_aux4_8", - rnnt_train_config, + "from-scratch-24gb_lrmaxs85k_lrmin1e-5_lrmax1e-3", + ctc_train_24gb_config, config_updates={ "learning_rate": 1.0, "dynamic_learning_rate": dyn_lr_piecewise_linear, - # total steps after 2000 epochs: 982.312 - "learning_rate_piecewise_steps": [600_000, 900_000, 982_000], + # total steps after 400 epochs: + "learning_rate_piecewise_steps": [85_500, 171_000, 190_000], # 45% 45 % 10% "learning_rate_piecewise_values": [1e-5, 1e-3, 1e-5, 1e-6], + "aux_loss_layers": [], + }, + num_epochs=400, + ) + + train_exp( + "from-scratch-24gb_lrmaxs85k_lrmin8e-5_lrmax8e-4", + ctc_train_24gb_config, + config_updates={ + "learning_rate": 1.0, + "dynamic_learning_rate": dyn_lr_piecewise_linear, + # total steps after 400 epochs: + "learning_rate_piecewise_steps": [85_500, 171_000, 190_000], # 45% 45 % 10% + "learning_rate_piecewise_values": [8e-5, 8e-4, 8e-5, 1e-6], + "aux_loss_layers": [], }, num_epochs=400, + ) + + # init for tf ctc only model + train_exp( # does not converge + "from-scratch-11gb_lrmaxs522k_lrmin8e-5_lrmax8e-4", + ctc_train_config, + config_updates={ + "learning_rate": 1.0, + "dynamic_learning_rate": dyn_lr_piecewise_linear, + # total steps after 2000 epochs: 982.312 + # total steps after 400 epochs: + "learning_rate_piecewise_steps": [66_000, 132_000, 145_000], # 45% 45 % 10% + # "learning_rate_piecewise_steps": [600_000, 900_000, 982_000], # 45% 45 % 10% + "learning_rate_piecewise_values": [8e-5, 8e-4, 8e-5, 1e-6], + "aux_loss_layers": [], + "preload_from_files": { + "filename": "", + "ignore_missing": True, + "init_for_train": True, + }, + }, + num_epochs=100, gpu_mem=11, ) + _sis_prefix: Optional[str] = None diff --git a/users/gaudino/experiments/rf_conformer_rnnt_2024/tedlium2/conformer_rnnt_train.py b/users/gaudino/experiments/rf_conformer_rnnt_2024/tedlium2/conformer_rnnt_train.py index a7e088a5c..9718aed90 100644 --- a/users/gaudino/experiments/rf_conformer_rnnt_2024/tedlium2/conformer_rnnt_train.py +++ b/users/gaudino/experiments/rf_conformer_rnnt_2024/tedlium2/conformer_rnnt_train.py @@ -74,7 +74,7 @@ def sis_run_with_prefix(prefix_name: Optional[str] = None): max_seq_length_default_target=None, gradient_clip_global_norm=5.0, accum_grad_multiple_step=2, - aux_loss_layers=[12], + # aux_loss_layers=[12], ) # train_exp("base-11gb", config_11gb, gpu_mem=11) @@ -86,11 +86,13 @@ def sis_run_with_prefix(prefix_name: Optional[str] = None): "learning_rate": 1.0, "dynamic_learning_rate": dyn_lr_piecewise_linear, # total steps after 2000 epochs: 982.312 - "learning_rate_piecewise_steps": [600_000, 900_000, 982_000], + # "learning_rate_piecewise_steps": [600_000, 900_000, 982_000], + # "learning_rate_piecewise_values": [1e-5, 1e-3, 1e-5, 1e-6], + "learning_rate_piecewise_steps": [261_000, 522_000, 580_000], # 45% 45 % 10% "learning_rate_piecewise_values": [1e-5, 1e-3, 1e-5, 1e-6], }, num_epochs=400, - gpu_mem=11, + gpu_mem=24, ) diff --git a/users/gaudino/models/asr/decoder/att_decoder_rf.py b/users/gaudino/models/asr/decoder/att_decoder_rf.py index 6cd44c2b3..f058f0414 100644 --- a/users/gaudino/models/asr/decoder/att_decoder_rf.py +++ b/users/gaudino/models/asr/decoder/att_decoder_rf.py @@ -4,7 +4,7 @@ import torch import torch.nn.functional as F from typing import Tuple -from typeguard import check_argument_types +from typeguard import typechecked from espnet2.asr.decoder.abs_decoder import AbsDecoder from espnet2.utils.get_default_kwargs import get_default_kwargs @@ -132,6 +132,7 @@ def build_attention_list( class RNNDecoder(AbsDecoder): + @typechecked def __init__( self, vocab_size: int, @@ -147,7 +148,6 @@ def __init__( att_conf: dict = get_default_kwargs(build_attention_list), ): # FIXME(kamo): The parts of num_spk should be refactored more more more - assert check_argument_types() if rnn_type not in {"lstm", "gru"}: raise ValueError(f"Not supported: rnn_type={rnn_type}") From 7a979475861976ce947fa7cde8c4962125047bde Mon Sep 17 00:00:00 2001 From: "luca.gaudino" Date: Fri, 24 May 2024 11:59:38 +0200 Subject: [PATCH 055/227] update zoneout fix ted2 --- .../conformer_import_moh_att_2023_06_30.py | 4 +- .../conformer_import_moh_att_train.py | 4 +- .../model_recogs/model_recog.py | 1 - .../conformer_import_moh_att_2023_10_19.py | 79 ++++++++++++++----- .../models/asr/rf/ilm_import_2024_04_17.py | 3 +- 5 files changed, 69 insertions(+), 22 deletions(-) diff --git a/users/gaudino/experiments/rf_conformer_att_2023/librispeech_960/conformer_import_moh_att_2023_06_30.py b/users/gaudino/experiments/rf_conformer_att_2023/librispeech_960/conformer_import_moh_att_2023_06_30.py index e692580cd..8aea3533c 100644 --- a/users/gaudino/experiments/rf_conformer_att_2023/librispeech_960/conformer_import_moh_att_2023_06_30.py +++ b/users/gaudino/experiments/rf_conformer_att_2023/librispeech_960/conformer_import_moh_att_2023_06_30.py @@ -799,6 +799,7 @@ def __init__( self.mel_normalization = model_args.get("mel_normalization", False) self.no_ctc = model_args.get("no_ctc", False) self.enc_layer_w_ctc = model_args.get("enc_layer_w_ctc", None) + self.s_use_zoneout_output = model_args.get("s_use_zoneout_output", True) self.encoder = ConformerEncoder( in_dim, @@ -887,7 +888,8 @@ def __init__( Dim(name="lstm", dimension=1024), zoneout_factor_cell=0.15, zoneout_factor_output=0.05, - use_zoneout_output=False, # like RETURNN/TF ZoneoutLSTM old default + use_zoneout_output=self.s_use_zoneout_output, # like RETURNN/TF ZoneoutLSTM old default + # use_zoneout_output=False, # like RETURNN/TF ZoneoutLSTM old default # this was a bug # parts_order="icfo", # like RETURNN/TF ZoneoutLSTM # parts_order="ifco", parts_order="jifo", # NativeLSTM (the code above converts it...) diff --git a/users/gaudino/experiments/rf_conformer_att_2023/librispeech_960/conformer_import_moh_att_train.py b/users/gaudino/experiments/rf_conformer_att_2023/librispeech_960/conformer_import_moh_att_train.py index 79cb8641f..85c0a7435 100644 --- a/users/gaudino/experiments/rf_conformer_att_2023/librispeech_960/conformer_import_moh_att_train.py +++ b/users/gaudino/experiments/rf_conformer_att_2023/librispeech_960/conformer_import_moh_att_train.py @@ -1302,7 +1302,9 @@ def __init__( Dim(name="lstm", dimension=1024), zoneout_factor_cell=0.15, zoneout_factor_output=0.05, - use_zoneout_output=False, # like RETURNN/TF ZoneoutLSTM old default + # TODO: was this a bug? + use_zoneout_output=True, + # use_zoneout_output=False, # like RETURNN/TF ZoneoutLSTM old default # parts_order="icfo", # like RETURNN/TF ZoneoutLSTM # parts_order="ifco", parts_order="jifo", # NativeLSTM (the code above converts it...) diff --git a/users/gaudino/experiments/rf_conformer_att_2023/librispeech_960/model_recogs/model_recog.py b/users/gaudino/experiments/rf_conformer_att_2023/librispeech_960/model_recogs/model_recog.py index 1c8d16b85..2d19622f4 100644 --- a/users/gaudino/experiments/rf_conformer_att_2023/librispeech_960/model_recogs/model_recog.py +++ b/users/gaudino/experiments/rf_conformer_att_2023/librispeech_960/model_recogs/model_recog.py @@ -174,7 +174,6 @@ def model_recog( ) if model.search_args.get("ilm_scale", 0.0) > 0: - breakpoint() ilm_out = model.ilm(input_embed, state=ilm_state, spatial_dim=single_step_dim) ilm_state = ilm_out["state"] ilm_log_prob = rf.log_softmax(ilm_out["output"], axis=model.target_dim) diff --git a/users/gaudino/experiments/rf_conformer_att_2023/tedlium2/conformer_import_moh_att_2023_10_19.py b/users/gaudino/experiments/rf_conformer_att_2023/tedlium2/conformer_import_moh_att_2023_10_19.py index 526a7d6a6..f1ca364cf 100644 --- a/users/gaudino/experiments/rf_conformer_att_2023/tedlium2/conformer_import_moh_att_2023_10_19.py +++ b/users/gaudino/experiments/rf_conformer_att_2023/tedlium2/conformer_import_moh_att_2023_10_19.py @@ -108,7 +108,7 @@ def sis_run_with_prefix(prefix_name: str = None): bsf = 10 prefix_name_single_seq = prefix_name + f"/single_seq" - prefix_name = prefix_name + f"/bsf{bsf}" + prefix_name = prefix_name + f"/bsf{bsf}" + "_fix_zoneout_output" ### Single model experiments @@ -287,9 +287,10 @@ def sis_run_with_prefix(prefix_name: str = None): opls_model_names = { # -------- tuning done ---------- - # "model_baseline":{ - # "scales": [(0.7, 0.3, 0.7, 0.4), (0.7, 0.3, 0.7, 0.5)], - # }, + "model_baseline":{ + "scales": [(0.7, 0.3, 0.7, 0.4), (0.7, 0.3, 0.7, 0.5)], + "scales_w_fix": [], + }, # "model_ctc0.43_att1.0": { # "scales": [(0.8,0.2, 0.6), (0.8, 0.2, 0.7), (0.8, 0.2, 0.9)], # }, @@ -355,9 +356,12 @@ def sis_run_with_prefix(prefix_name: str = None): } # opls att + ctc prefix scorer - for model_name in opls_model_names: - for scales, beam_size in product(opls_model_names[model_name]["scales"], []): - att_scale, ctc_scale, prior_scale, _ = scales + for model_name in ["model_baseline"]: + # for model_name in opls_model_names: + # for scales, beam_size in product(opls_model_names[model_name]["scales"], [12]): + for scales, beam_size in product([(0.6, 0.4), (0.65, 0.35), (0.7, 0.3), (0.75, 0.25), (0.8, 0.2)], [12]): + att_scale, ctc_scale, = scales + prior_scale = 0.0 search_args = { "beam_size": beam_size, @@ -369,6 +373,7 @@ def sis_run_with_prefix(prefix_name: str = None): "prior_corr": True if prior_scale > 0 else False, "prior_scale": prior_scale, "ctc_prior_file": models[model_name]["prior"], + "use_zoneout_output": True, } name = ( @@ -383,7 +388,7 @@ def sis_run_with_prefix(prefix_name: str = None): task, models_with_pt_ckpt[model_name]["ckpt"], model_recog, - dev_sets=["dev", "test"], # set to None for all + dev_sets=["dev"], # set to None for all model_args=models_with_pt_ckpt[model_name]["model_args"], search_args=search_args, prefix_name=name, @@ -461,10 +466,10 @@ def sis_run_with_prefix(prefix_name: str = None): } models_with_pt_ckpt[model_name]["model_args"] = copy.deepcopy(model_args) - # att + ilm correction + # att + trafo lm + ilm correction for model_name, lm_scale, ilm_scale, beam_size in product( # ["model_baseline", "model_ctc0.5_att0.5"], [0.36] ,[0.28], [12] - ["model_baseline"], [0.36] ,[0.28], [12] + ["model_baseline"], [0.3, 0.34, 0.36, 0.4] ,[0.28], [12] ): ilm_model_args = copy.deepcopy(models_with_pt_ckpt[model_name]["model_args"]) ilm_model_args["preload_from_files"] = { @@ -482,7 +487,7 @@ def sis_run_with_prefix(prefix_name: str = None): prefix_name + "/" + model_name - + f"/att_trafolm{lm_scale}_ilm1_{ilm_scale}" + + f"/att_trafolm{lm_scale}_ilm{ilm_scale}" + f"_beam{beam_size}" ) search_args = { @@ -491,6 +496,8 @@ def sis_run_with_prefix(prefix_name: str = None): "ilm_scale": ilm_scale, "lm_scale": lm_scale, "bsf": bsf, + "use_first_lm": True, + "use_zoneout_output": True, } recog_res, recog_out = recog_model( task, @@ -506,6 +513,45 @@ def sis_run_with_prefix(prefix_name: str = None): recog_res.output, ) + # opls att + ctc + trafo lm + ilm + for model_name, beam_size, ilm_scale in product(["model_baseline"], [12], [0.1, 0.2, 0.25, 0.3, 0.4]): + for scales in opls_model_names[model_name]["scales"]: + att_scale, ctc_scale, prior_scale, lm_scale = scales + name = ( + prefix_name + + "/" + + model_name + + f"/opls_att{att_scale}_ctc{ctc_scale}_trafolm{lm_scale}_ilm{ilm_scale}" + + (f"_prior{prior_scale}" if prior_scale > 0 else "") + + f"_beam{beam_size}" + ) + search_args = { + "beam_size": beam_size, + "att_scale": att_scale, + "ctc_scale": ctc_scale, + "use_ctc": True, + "add_trafo_lm": True, + "lm_scale": lm_scale, + "bsf": bsf, + "prior_corr": True if prior_scale > 0 else False, + "prior_scale": prior_scale, + "ctc_prior_file": models[model_name]["prior"], + } + + recog_res, recog_out = recog_model( + task, + models_with_pt_ckpt[model_name]["ckpt"], + model_recog, + dev_sets=["dev", "test"], + model_args=models_with_pt_ckpt[model_name]["model_args"], + search_args=search_args, + prefix_name=name, + ) + tk.register_output( + name + f"/recog_results", + recog_res.output, + ) + # ----------------- With Trafo LM ----------------- for model_name in model_names: @@ -527,8 +573,8 @@ def sis_run_with_prefix(prefix_name: str = None): models_with_pt_ckpt[model_name]["model_args"] = model_args # att + trafo lm - for model_name, lm_scale, beam_size, use_first_lm in product( - ["model_baseline"], [0.15], [6, 12, 18], [True, False] + for model_name, lm_scale, beam_size in product( + ["model_baseline"], [0.13, 0.15, 0.18, 0.2], [12] ): lm_model_args = copy.deepcopy(models_with_pt_ckpt[model_name]["model_args"]) name = ( @@ -536,7 +582,6 @@ def sis_run_with_prefix(prefix_name: str = None): + "/" + model_name + f"/att_trafolm{lm_scale}" - + (f"_first_lm" if use_first_lm else "") + f"_beam{beam_size}" ) search_args = { @@ -544,11 +589,9 @@ def sis_run_with_prefix(prefix_name: str = None): "att_scale": 1.0, "lm_scale": lm_scale, "bsf": bsf, + "use_zoneout_output": True, + "use_first_lm": True, } - if use_first_lm: - search_args["use_first_lm"] = True - else: - search_args.pop("use_first_lm", None) recog_res, recog_out = recog_model( task, diff --git a/users/gaudino/models/asr/rf/ilm_import_2024_04_17.py b/users/gaudino/models/asr/rf/ilm_import_2024_04_17.py index 737dbdd54..e7f671c18 100644 --- a/users/gaudino/models/asr/rf/ilm_import_2024_04_17.py +++ b/users/gaudino/models/asr/rf/ilm_import_2024_04_17.py @@ -54,7 +54,8 @@ def __init__( self.prior_dim, zoneout_factor_cell=0.15, zoneout_factor_output=0.05, - use_zoneout_output=False, # like RETURNN/TF ZoneoutLSTM old default + # use_zoneout_output=False, # like RETURNN/TF ZoneoutLSTM old default + use_zoneout_output=True, # parts_order="icfo", # like RETURNN/TF ZoneoutLSTM # parts_order="ifco", parts_order="jifo", # NativeLSTM (the code above converts it...) From be654cee7f56a97d878f24e900210c261167c4de Mon Sep 17 00:00:00 2001 From: Simon Berger Date: Fri, 24 May 2024 13:11:56 +0200 Subject: [PATCH 056/227] Update users/berger --- .../config_02a_transducer_raw_samples.py | 10 +- .../config_02b_transducer_rasr_features.py | 145 +++++- ...ig_02c_transducer_rasr_features_wei_lex.py | 10 +- ...nfig_03a_transducer_fullsum_raw_samples.py | 10 +- ...ig_03b_transducer_fullsum_rasr_features.py | 9 +- ...ransducer_fullsum_rasr_features_wei_lex.py | 10 +- ...ucer_fullsum_from_scratch_rasr_features.py | 10 +- .../helpers/returnn.py | 1 + ...config_01_conformer_hybrid_tfgridnet_v2.py | 8 +- .../config_01a_conformer_hybrid_pt.py | 8 +- .../config_02_conformer_hybrid_blstm_v2.py | 6 +- ..._03_conformer_hybrid_tfgridnet_seqtrain.py | 8 +- .../config_03_blstm_transducer.py | 32 +- .../config_03_blstm_transducer.py | 14 +- .../config_03_blstm_transducer.py | 14 +- .../config_03_blstm_transducer.py | 32 +- .../wsj_16kHz/config_03_blstm_transducer.py | 14 +- .../wsj_8kHz/config_02_blstm_ctc.py | 6 +- .../wsj_8kHz/config_03_blstm_transducer.py | 14 +- .../config_02a_transducer.py | 10 +- .../config_02b_transducer_wei_data.py | 10 +- ...config_02c_transducer_wei_data_tinaconf.py | 10 +- .../config_03a_transducer_fullsum.py | 10 +- .../config_03b_transducer_fullsum_wei_data.py | 10 +- users/berger/corpus/librispeech/lm_data.py | 10 +- .../switchboard/viterbi_transducer_data.py | 7 +- users/berger/helpers/rasr.py | 26 +- users/berger/helpers/rasr_lm_config.py | 42 +- users/berger/network/helpers/label_context.py | 216 ++++++++- .../network/models/context_1_transducer.py | 35 +- .../recipe/rasr/label_tree_and_scorer.py | 3 +- users/berger/recipe/recognition/__init__.py | 1 + .../recognition/generic_seq2seq_search_v2.py | 444 ++++++++++++++++++ users/berger/settings.py | 9 +- users/berger/systems/base_system.py | 3 +- .../functors/recognition/seq2seq_search.py | 27 +- users/berger/systems/functors/seq2seq_base.py | 8 +- 37 files changed, 995 insertions(+), 247 deletions(-) create mode 100644 users/berger/recipe/recognition/generic_seq2seq_search_v2.py diff --git a/users/berger/configs/librispeech/20230210_baselines/config_02a_transducer_raw_samples.py b/users/berger/configs/librispeech/20230210_baselines/config_02a_transducer_raw_samples.py index 4a1100e06..21fdb1c20 100644 --- a/users/berger/configs/librispeech/20230210_baselines/config_02a_transducer_raw_samples.py +++ b/users/berger/configs/librispeech/20230210_baselines/config_02a_transducer_raw_samples.py @@ -47,10 +47,7 @@ def generate_returnn_config( **kwargs, ) -> ReturnnConfig: if train: - ( - network_dict, - extra_python, - ) = transducer_model.make_context_1_conformer_transducer( + (network_dict, extra_python,) = transducer_model.make_context_1_conformer_transducer( num_outputs=num_classes, gt_args={ "sample_rate": 16000, @@ -87,10 +84,7 @@ def generate_returnn_config( }, ) else: - ( - network_dict, - extra_python, - ) = transducer_model.make_context_1_conformer_transducer_recog( + (network_dict, extra_python,) = transducer_model.make_context_1_conformer_transducer_recog( num_outputs=num_classes, gt_args={ "sample_rate": 16000, diff --git a/users/berger/configs/librispeech/20230210_baselines/config_02b_transducer_rasr_features.py b/users/berger/configs/librispeech/20230210_baselines/config_02b_transducer_rasr_features.py index f6deeff86..3953a13fa 100644 --- a/users/berger/configs/librispeech/20230210_baselines/config_02b_transducer_rasr_features.py +++ b/users/berger/configs/librispeech/20230210_baselines/config_02b_transducer_rasr_features.py @@ -44,6 +44,7 @@ def generate_returnn_config( *, train_data_config: dict, dev_data_config: dict, + precompute: bool = False, **kwargs, ) -> ReturnnConfig: specaug_v2 = kwargs.get("specaug_v2", False) @@ -102,30 +103,50 @@ def generate_returnn_config( specaug_v2=specaug_v2, ) else: - ( - network_dict, - extra_python, - ) = transducer_model.make_context_1_conformer_transducer_recog( - num_outputs=num_classes, - conformer_args={ - "num_blocks": 12, - "size": 512, - }, - decoder_args={ - "dec_mlp_args": { - "num_layers": 2, - "size": 640, - "activation": "tanh", + if precompute: + network_dict, extra_python = transducer_model.make_context_1_conformer_transducer_precomputed_recog( + num_outputs=num_classes, + conformer_args={ + "num_blocks": 12, + "size": 512, }, - "combination_mode": "concat", - "joint_mlp_args": { - "num_layers": 1, - "size": 1024, - "activation": "tanh", + decoder_args={ + "dec_mlp_args": { + "num_layers": 2, + "size": 640, + "activation": "tanh", + }, + "combination_mode": "concat", + "joint_mlp_args": { + "num_layers": 1, + "size": 1024, + "activation": "tanh", + }, + "ilm_scale": kwargs.get("ilm_scale", 0.0), }, - "ilm_scale": kwargs.get("ilm_scale", 0.0), - }, - ) + ) + else: + network_dict, extra_python = transducer_model.make_context_1_conformer_transducer_recog( + num_outputs=num_classes, + conformer_args={ + "num_blocks": 12, + "size": 512, + }, + decoder_args={ + "dec_mlp_args": { + "num_layers": 2, + "size": 640, + "activation": "tanh", + }, + "combination_mode": "concat", + "joint_mlp_args": { + "num_layers": 1, + "size": 1024, + "activation": "tanh", + }, + "ilm_scale": kwargs.get("ilm_scale", 0.0), + }, + ) extra_config = { "train": train_data_config, @@ -158,7 +179,8 @@ def generate_returnn_config( python_prolog=[ "import sys", "sys.setrecursionlimit(10 ** 6)", - ], + ] + + (["from returnn.tf.util.data import FeatureDim"] if precompute else []), extra_python=extra_python, num_inputs=50, num_outputs=num_classes, @@ -215,6 +237,7 @@ def run_exp( SummaryKey.CORPUS, SummaryKey.EPOCH, SummaryKey.LM, + SummaryKey.RTF, SummaryKey.WER, SummaryKey.SUB, SummaryKey.INS, @@ -249,6 +272,7 @@ def run_exp( feature_type=FeatureType.GAMMATONE_16K, reduction_factor=4, reduction_subtrahend=0, + search_stats=True, ) # ********** Returnn Configs ********** @@ -374,6 +398,81 @@ def run_exp( **recog_args, ) + recog_args.update( + { + "epochs": [382], + "lm_scales": [0.8], + } + ) + recog_args["search_parameters"].update( + { + "label-pruning": 11.0, + "label-pruning-limit": 300, + "word-end-pruning": 0.5, + "word-end-pruning-limit": 200, + } + ) + system.run_recog_step_for_corpora( + exp_names=[f"Conformer_Transducer_Viterbi_specaug-v2_{name_suffix}"], + corpora=["dev-other_4gram"], + recog_descriptor="lp-11_lpl-300_wep-0.5_wepl-200", + **recog_args, + ) + + system.add_experiment_configs( + f"Conformer_Transducer_Viterbi_specaug-v2_{name_suffix}", + ReturnnConfigs( + train_config=generate_returnn_config( + train=True, + train_data_config=data.train_data_config, + dev_data_config=data.cv_data_config, + label_smoothing=None, + loss_boost_v2=False, + loss_boost_scale=0.0, + specaug_v2=True, + peak_lr=8e-04, + model_preload=None, + ), + recog_configs={ + f"recog_precompute_ilm-{ilm_scale}": generate_returnn_config( + train=False, + train_data_config=data.train_data_config, + dev_data_config=data.cv_data_config, + ilm_scale=ilm_scale, + precompute=True, + ) + for ilm_scale in [0.3] + }, + ), + ) + + for data_input in data.data_inputs.values(): + data_input.create_lm_images(tools.rasr_binary_path) + system.init_corpora( + dev_keys=data.dev_keys, + test_keys=data.test_keys, + align_keys=data.align_keys, + corpus_data=data.data_inputs, + am_args=exp_args.transducer_recog_am_args, + ) + system.setup_scoring() + + recog_args.update( + { + "seq2seq_v2": True, + "label_scorer_type": "precomputed-log-posterior", + "model_flow_args": {"output_layer_name": "output_precompute"}, + } + ) + recog_args["label_scorer_args"]["extra_args"]["first_order"] = True + recog_args["label_scorer_args"]["extra_args"]["start_label_index"] = 0 + system.run_recog_step_for_corpora( + exp_names=[f"Conformer_Transducer_Viterbi_specaug-v2_{name_suffix}"], + corpora=["dev-other_4gram"], + recog_descriptor="lp-11_lpl-300_wep-0.5_wepl-200", + **recog_args, + ) + train_job = system.get_train_job(f"Conformer_Transducer_Viterbi_lr-0.0008_{name_suffix}") model = train_job.out_checkpoints[400] assert isinstance(model, Checkpoint) diff --git a/users/berger/configs/librispeech/20230210_baselines/config_02c_transducer_rasr_features_wei_lex.py b/users/berger/configs/librispeech/20230210_baselines/config_02c_transducer_rasr_features_wei_lex.py index 2d3875947..f492eb5f0 100644 --- a/users/berger/configs/librispeech/20230210_baselines/config_02c_transducer_rasr_features_wei_lex.py +++ b/users/berger/configs/librispeech/20230210_baselines/config_02c_transducer_rasr_features_wei_lex.py @@ -47,10 +47,7 @@ def generate_returnn_config( **kwargs, ) -> ReturnnConfig: if train: - ( - network_dict, - extra_python, - ) = transducer_model.make_context_1_conformer_transducer( + (network_dict, extra_python,) = transducer_model.make_context_1_conformer_transducer( num_outputs=num_classes, specaug_args={ "max_time_num": 1, @@ -88,10 +85,7 @@ def generate_returnn_config( loss_boost_v2=kwargs.get("loss_boost_v2", False), ) else: - ( - network_dict, - extra_python, - ) = transducer_model.make_context_1_conformer_transducer_recog( + (network_dict, extra_python,) = transducer_model.make_context_1_conformer_transducer_recog( num_outputs=num_classes, conformer_args={ "num_blocks": 12, diff --git a/users/berger/configs/librispeech/20230210_baselines/config_03a_transducer_fullsum_raw_samples.py b/users/berger/configs/librispeech/20230210_baselines/config_03a_transducer_fullsum_raw_samples.py index 95dcbd9ad..2ee08d156 100644 --- a/users/berger/configs/librispeech/20230210_baselines/config_03a_transducer_fullsum_raw_samples.py +++ b/users/berger/configs/librispeech/20230210_baselines/config_03a_transducer_fullsum_raw_samples.py @@ -47,10 +47,7 @@ def generate_returnn_config( model_preload: tk.Path, ) -> ReturnnConfig: if train: - ( - network_dict, - extra_python, - ) = transducer_model.make_context_1_conformer_transducer_fullsum( + (network_dict, extra_python,) = transducer_model.make_context_1_conformer_transducer_fullsum( num_outputs=num_classes, gt_args={ "sample_rate": 16000, @@ -88,10 +85,7 @@ def generate_returnn_config( }, ) else: - ( - network_dict, - extra_python, - ) = transducer_model.make_context_1_conformer_transducer_recog( + (network_dict, extra_python,) = transducer_model.make_context_1_conformer_transducer_recog( num_outputs=num_classes, gt_args={ "sample_rate": 16000, diff --git a/users/berger/configs/librispeech/20230210_baselines/config_03b_transducer_fullsum_rasr_features.py b/users/berger/configs/librispeech/20230210_baselines/config_03b_transducer_fullsum_rasr_features.py index f45cac63e..496d6fd5b 100644 --- a/users/berger/configs/librispeech/20230210_baselines/config_03b_transducer_fullsum_rasr_features.py +++ b/users/berger/configs/librispeech/20230210_baselines/config_03b_transducer_fullsum_rasr_features.py @@ -22,6 +22,7 @@ from i6_experiments.users.berger.util import default_tools from i6_private.users.vieting.helpers.returnn import serialize_dim_tags from i6_experiments.users.berger.systems.dataclasses import AlignmentData +from i6_experiments.users.berger.network.helpers.label_context import ILMMode from .config_01b_ctc_blstm_rasr_features import py as py_ctc from .config_02b_transducer_rasr_features import py as py_transducer from sisyphus import gs, tk @@ -106,6 +107,7 @@ def generate_returnn_config( "size": 1024, "activation": "tanh", }, + "ilm_mode": ILMMode.ZeroEnc, "ilm_scale": kwargs.get("ilm_scale", 0.0), }, ) @@ -167,6 +169,9 @@ def run_exp(alignments: Dict[str, AlignmentData], viterbi_model_checkpoint: Chec feature_type=FeatureType.GAMMATONE_16K, ) + for data_input in data.data_inputs.values(): + data_input.create_lm_images(tools.rasr_binary_path) + # ********** Step args ********** train_args = exp_args.get_transducer_train_step_args( @@ -254,6 +259,7 @@ def run_exp(alignments: Dict[str, AlignmentData], viterbi_model_checkpoint: Chec system.run_recog_step_for_corpora(corpora=["test-clean_4gram", "test-other_4gram"], **recog_args) recog_args["lm_scales"] = [0.8] + recog_args["seq2seq_v2"] = True recog_args["search_parameters"].update( { "full-sum-decoding": True, @@ -280,7 +286,8 @@ def run_exp(alignments: Dict[str, AlignmentData], viterbi_model_checkpoint: Chec ) recog_args["lookahead_options"].update({"lm_lookahead_scale": 0.45}) recog_args["use_gpu"] = True - recog_args["rtf"] = 50 + recog_args["rtf"] = 100 + recog_args["mem"] = 24 system.run_recog_step_for_corpora( recog_descriptor="fs", diff --git a/users/berger/configs/librispeech/20230210_baselines/config_03c_transducer_fullsum_rasr_features_wei_lex.py b/users/berger/configs/librispeech/20230210_baselines/config_03c_transducer_fullsum_rasr_features_wei_lex.py index 8e2aa71b9..e3b4d82bc 100644 --- a/users/berger/configs/librispeech/20230210_baselines/config_03c_transducer_fullsum_rasr_features_wei_lex.py +++ b/users/berger/configs/librispeech/20230210_baselines/config_03c_transducer_fullsum_rasr_features_wei_lex.py @@ -48,10 +48,7 @@ def generate_returnn_config( **kwargs, ) -> ReturnnConfig: if train: - ( - network_dict, - extra_python, - ) = transducer_model.make_context_1_conformer_transducer_fullsum( + (network_dict, extra_python,) = transducer_model.make_context_1_conformer_transducer_fullsum( num_outputs=num_classes, specaug_args={ "max_time_num": 1, @@ -85,10 +82,7 @@ def generate_returnn_config( }, ) else: - ( - network_dict, - extra_python, - ) = transducer_model.make_context_1_conformer_transducer_recog( + (network_dict, extra_python,) = transducer_model.make_context_1_conformer_transducer_recog( num_outputs=num_classes, conformer_args={ "num_blocks": 12, diff --git a/users/berger/configs/librispeech/20230210_baselines/config_04b_transducer_fullsum_from_scratch_rasr_features.py b/users/berger/configs/librispeech/20230210_baselines/config_04b_transducer_fullsum_from_scratch_rasr_features.py index 2f2941734..27b80179f 100644 --- a/users/berger/configs/librispeech/20230210_baselines/config_04b_transducer_fullsum_from_scratch_rasr_features.py +++ b/users/berger/configs/librispeech/20230210_baselines/config_04b_transducer_fullsum_from_scratch_rasr_features.py @@ -45,10 +45,7 @@ def generate_returnn_config( **kwargs, ) -> ReturnnConfig: if train: - ( - network_dict, - extra_python, - ) = transducer_model.make_context_1_conformer_transducer_fullsum( + (network_dict, extra_python,) = transducer_model.make_context_1_conformer_transducer_fullsum( num_outputs=num_classes, specaug_args={ "max_time_num": 1, @@ -82,10 +79,7 @@ def generate_returnn_config( }, ) else: - ( - network_dict, - extra_python, - ) = transducer_model.make_context_1_conformer_transducer_recog( + (network_dict, extra_python,) = transducer_model.make_context_1_conformer_transducer_recog( num_outputs=num_classes, conformer_args={ "num_blocks": 12, diff --git a/users/berger/configs/librispeech/20230420_dfg_multi_speaker/helpers/returnn.py b/users/berger/configs/librispeech/20230420_dfg_multi_speaker/helpers/returnn.py index 5d67124a3..51976cbb0 100644 --- a/users/berger/configs/librispeech/20230420_dfg_multi_speaker/helpers/returnn.py +++ b/users/berger/configs/librispeech/20230420_dfg_multi_speaker/helpers/returnn.py @@ -1,6 +1,7 @@ """ RETURNN-related helpers """ + from typing import Any from i6_core.returnn import ReturnnConfig, CodeWrapper diff --git a/users/berger/configs/librispeech/20230804_libri_css/config_01_conformer_hybrid_tfgridnet_v2.py b/users/berger/configs/librispeech/20230804_libri_css/config_01_conformer_hybrid_tfgridnet_v2.py index 473af68da..a61022c2f 100644 --- a/users/berger/configs/librispeech/20230804_libri_css/config_01_conformer_hybrid_tfgridnet_v2.py +++ b/users/berger/configs/librispeech/20230804_libri_css/config_01_conformer_hybrid_tfgridnet_v2.py @@ -173,9 +173,11 @@ def run_exp() -> SummaryReport: for lm_name in ["4gram", "kazuki_transformer"]: data_per_lm[lm_name] = get_hybrid_data( train_key="enhanced_tfgridnet_v1", - dev_keys=["segmented_libri_css_tfgridnet_dev_v1", "segmented_libri_css_tfgridnet_eval_v1"] - if lm_name == "4gram" - else [], + dev_keys=( + ["segmented_libri_css_tfgridnet_dev_v1", "segmented_libri_css_tfgridnet_eval_v1"] + if lm_name == "4gram" + else [] + ), test_keys=["segmented_libri_css_tfgridnet_eval_v1"] if lm_name == "kazuki_transformer" else [], gmm_system=gmm_system, returnn_root=tools.returnn_root, diff --git a/users/berger/configs/librispeech/20230804_libri_css/config_01a_conformer_hybrid_pt.py b/users/berger/configs/librispeech/20230804_libri_css/config_01a_conformer_hybrid_pt.py index 549771f3a..13bf26768 100644 --- a/users/berger/configs/librispeech/20230804_libri_css/config_01a_conformer_hybrid_pt.py +++ b/users/berger/configs/librispeech/20230804_libri_css/config_01a_conformer_hybrid_pt.py @@ -197,9 +197,11 @@ def run_exp() -> SummaryReport: for lm_name in ["4gram", "kazuki_transformer"]: data_per_lm[lm_name] = get_hybrid_data( train_key="enhanced_tfgridnet_v1", - dev_keys=["segmented_libri_css_tfgridnet_dev_v1", "segmented_libri_css_tfgridnet_eval_v1"] - if lm_name == "4gram" - else [], + dev_keys=( + ["segmented_libri_css_tfgridnet_dev_v1", "segmented_libri_css_tfgridnet_eval_v1"] + if lm_name == "4gram" + else [] + ), test_keys=["segmented_libri_css_tfgridnet_eval_v1"] if lm_name == "kazuki_transformer" else [], gmm_system=gmm_system, returnn_root=tools.returnn_root, diff --git a/users/berger/configs/librispeech/20230804_libri_css/config_02_conformer_hybrid_blstm_v2.py b/users/berger/configs/librispeech/20230804_libri_css/config_02_conformer_hybrid_blstm_v2.py index b38df7e6a..7bd586710 100644 --- a/users/berger/configs/librispeech/20230804_libri_css/config_02_conformer_hybrid_blstm_v2.py +++ b/users/berger/configs/librispeech/20230804_libri_css/config_02_conformer_hybrid_blstm_v2.py @@ -162,9 +162,9 @@ def run_exp() -> SummaryReport: for lm_name in ["4gram", "kazuki_transformer"]: data_per_lm[lm_name] = get_hybrid_data( train_key="enhanced_blstm_v1", - dev_keys=["segmented_libri_css_blstm_dev_v1", "segmented_libri_css_blstm_eval_v1"] - if lm_name == "4gram" - else [], + dev_keys=( + ["segmented_libri_css_blstm_dev_v1", "segmented_libri_css_blstm_eval_v1"] if lm_name == "4gram" else [] + ), test_keys=["segmented_libri_css_blstm_eval_v1"] if lm_name == "kazuki_transformer" else [], gmm_system=gmm_system, returnn_root=tools.returnn_root, diff --git a/users/berger/configs/librispeech/20230804_libri_css/config_03_conformer_hybrid_tfgridnet_seqtrain.py b/users/berger/configs/librispeech/20230804_libri_css/config_03_conformer_hybrid_tfgridnet_seqtrain.py index 368f768b5..02d10ba67 100644 --- a/users/berger/configs/librispeech/20230804_libri_css/config_03_conformer_hybrid_tfgridnet_seqtrain.py +++ b/users/berger/configs/librispeech/20230804_libri_css/config_03_conformer_hybrid_tfgridnet_seqtrain.py @@ -244,9 +244,11 @@ def run_exp() -> SummaryReport: for lm_name in ["4gram", "kazuki_transformer"]: data_per_lm[lm_name] = get_hybrid_data( train_key="enhanced_tfgridnet_v1", - dev_keys=["segmented_libri_css_tfgridnet_dev_v1", "segmented_libri_css_tfgridnet_eval_v1"] - if lm_name == "4gram" - else [], + dev_keys=( + ["segmented_libri_css_tfgridnet_dev_v1", "segmented_libri_css_tfgridnet_eval_v1"] + if lm_name == "4gram" + else [] + ), test_keys=["segmented_libri_css_tfgridnet_eval_v1"] if lm_name == "kazuki_transformer" else [], gmm_system=gmm_system, returnn_root=tools.returnn_root, diff --git a/users/berger/configs/sms_wsj/20220615_dfg_multi_speaker/sms_wsj_16kHz.bak/config_03_blstm_transducer.py b/users/berger/configs/sms_wsj/20220615_dfg_multi_speaker/sms_wsj_16kHz.bak/config_03_blstm_transducer.py index 9067bf3db..f4927a36c 100644 --- a/users/berger/configs/sms_wsj/20220615_dfg_multi_speaker/sms_wsj_16kHz.bak/config_03_blstm_transducer.py +++ b/users/berger/configs/sms_wsj/20220615_dfg_multi_speaker/sms_wsj_16kHz.bak/config_03_blstm_transducer.py @@ -218,21 +218,25 @@ def run_exp(**kwargs): "base_chunk_size": 256, "chunking_factors": {"data": 1, "classes": red_fact}, "extra_config": { - "pretrain": { - "repetitions": 6, - "construction_algo": CodeWrapper("pretrain_construction_algo"), - } - if kwargs.get("pretrain", False) - else None, - "preload_from_files": { - "base": { - "init_for_train": True, - "ignore_missing": True, - "filename": ctc_model, + "pretrain": ( + { + "repetitions": 6, + "construction_algo": CodeWrapper("pretrain_construction_algo"), } - } - if kwargs.get("ctc_init", False) - else None, + if kwargs.get("pretrain", False) + else None + ), + "preload_from_files": ( + { + "base": { + "init_for_train": True, + "ignore_missing": True, + "filename": ctc_model, + } + } + if kwargs.get("ctc_init", False) + else None + ), "train": {"reduce_target_factor": red_fact}, "dev": {"reduce_target_factor": red_fact}, }, diff --git a/users/berger/configs/sms_wsj/20220615_dfg_multi_speaker/sms_wsj_16kHz/config_03_blstm_transducer.py b/users/berger/configs/sms_wsj/20220615_dfg_multi_speaker/sms_wsj_16kHz/config_03_blstm_transducer.py index 4f18db9a4..7366a84d4 100644 --- a/users/berger/configs/sms_wsj/20220615_dfg_multi_speaker/sms_wsj_16kHz/config_03_blstm_transducer.py +++ b/users/berger/configs/sms_wsj/20220615_dfg_multi_speaker/sms_wsj_16kHz/config_03_blstm_transducer.py @@ -178,12 +178,14 @@ def run_exp(alignments: Dict[str, Any], **kwargs) -> SummaryReport: "base_chunk_size": 256, "chunking_factors": {"data": 1, "classes": red_fact}, "extra_config": { - "pretrain": { - "repetitions": 6, - "construction_algo": CodeWrapper("pretrain_construction_algo"), - } - if kwargs.get("pretrain", False) - else None, + "pretrain": ( + { + "repetitions": 6, + "construction_algo": CodeWrapper("pretrain_construction_algo"), + } + if kwargs.get("pretrain", False) + else None + ), "train": {"reduce_target_factor": red_fact}, "dev": {"reduce_target_factor": red_fact}, }, diff --git a/users/berger/configs/sms_wsj/20220615_dfg_multi_speaker/sms_wsj_8kHz/config_03_blstm_transducer.py b/users/berger/configs/sms_wsj/20220615_dfg_multi_speaker/sms_wsj_8kHz/config_03_blstm_transducer.py index ef429df11..a3340c710 100644 --- a/users/berger/configs/sms_wsj/20220615_dfg_multi_speaker/sms_wsj_8kHz/config_03_blstm_transducer.py +++ b/users/berger/configs/sms_wsj/20220615_dfg_multi_speaker/sms_wsj_8kHz/config_03_blstm_transducer.py @@ -175,12 +175,14 @@ def run_exp(alignments: Dict[str, Any], **kwargs) -> SummaryReport: "base_chunk_size": 256, "chunking_factors": {"data": 1, "classes": red_fact}, "extra_config": { - "pretrain": { - "repetitions": 6, - "construction_algo": CodeWrapper("pretrain_construction_algo"), - } - if kwargs.get("pretrain", False) - else None, + "pretrain": ( + { + "repetitions": 6, + "construction_algo": CodeWrapper("pretrain_construction_algo"), + } + if kwargs.get("pretrain", False) + else None + ), "train": {"reduce_target_factor": red_fact}, "dev": {"reduce_target_factor": red_fact}, }, diff --git a/users/berger/configs/sms_wsj/20220615_dfg_multi_speaker/wsj_16kHz.bak/config_03_blstm_transducer.py b/users/berger/configs/sms_wsj/20220615_dfg_multi_speaker/wsj_16kHz.bak/config_03_blstm_transducer.py index ee261aea8..61ee68a8a 100644 --- a/users/berger/configs/sms_wsj/20220615_dfg_multi_speaker/wsj_16kHz.bak/config_03_blstm_transducer.py +++ b/users/berger/configs/sms_wsj/20220615_dfg_multi_speaker/wsj_16kHz.bak/config_03_blstm_transducer.py @@ -208,21 +208,25 @@ def run_exp(**kwargs): "base_chunk_size": 256, "chunking_factors": {"data": 1, "classes": red_fact}, "extra_config": { - "pretrain": { - "repetitions": 6, - "construction_algo": CodeWrapper("pretrain_construction_algo"), - } - if kwargs.get("pretrain", False) - else None, - "preload_from_files": { - "base": { - "init_for_train": True, - "ignore_missing": True, - "filename": ctc_model, + "pretrain": ( + { + "repetitions": 6, + "construction_algo": CodeWrapper("pretrain_construction_algo"), } - } - if kwargs.get("ctc_init", False) - else None, + if kwargs.get("pretrain", False) + else None + ), + "preload_from_files": ( + { + "base": { + "init_for_train": True, + "ignore_missing": True, + "filename": ctc_model, + } + } + if kwargs.get("ctc_init", False) + else None + ), "train": {"reduce_target_factor": red_fact}, "dev": {"reduce_target_factor": red_fact}, }, diff --git a/users/berger/configs/sms_wsj/20220615_dfg_multi_speaker/wsj_16kHz/config_03_blstm_transducer.py b/users/berger/configs/sms_wsj/20220615_dfg_multi_speaker/wsj_16kHz/config_03_blstm_transducer.py index be1a98329..f198b0d87 100644 --- a/users/berger/configs/sms_wsj/20220615_dfg_multi_speaker/wsj_16kHz/config_03_blstm_transducer.py +++ b/users/berger/configs/sms_wsj/20220615_dfg_multi_speaker/wsj_16kHz/config_03_blstm_transducer.py @@ -176,12 +176,14 @@ def run_exp(alignments: Dict[str, Any], **kwargs) -> SummaryReport: "base_chunk_size": 256, "chunking_factors": {"data": 1, "classes": red_fact}, "extra_config": { - "pretrain": { - "repetitions": 6, - "construction_algo": CodeWrapper("pretrain_construction_algo"), - } - if kwargs.get("pretrain", False) - else None, + "pretrain": ( + { + "repetitions": 6, + "construction_algo": CodeWrapper("pretrain_construction_algo"), + } + if kwargs.get("pretrain", False) + else None + ), "train": {"reduce_target_factor": red_fact}, "dev": {"reduce_target_factor": red_fact}, }, diff --git a/users/berger/configs/sms_wsj/20220615_dfg_multi_speaker/wsj_8kHz/config_02_blstm_ctc.py b/users/berger/configs/sms_wsj/20220615_dfg_multi_speaker/wsj_8kHz/config_02_blstm_ctc.py index 32ce0678b..ae8dbeaef 100644 --- a/users/berger/configs/sms_wsj/20220615_dfg_multi_speaker/wsj_8kHz/config_02_blstm_ctc.py +++ b/users/berger/configs/sms_wsj/20220615_dfg_multi_speaker/wsj_8kHz/config_02_blstm_ctc.py @@ -66,9 +66,9 @@ def run_exp(**kwargs) -> Tuple[Dict[str, Any], SummaryReport]: train_keys=[train_key], dev_keys=[dev_key], test_keys=[test_key], - align_keys=[train_key, dev_key, speechsource_train_key, speechsource_dev_key] - if kwargs.get("align", False) - else [], + align_keys=( + [train_key, dev_key, speechsource_train_key, speechsource_dev_key] if kwargs.get("align", False) else [] + ), freq=frequency, lm_name="64k_3gram", recog_lex_name="nab-64k", diff --git a/users/berger/configs/sms_wsj/20220615_dfg_multi_speaker/wsj_8kHz/config_03_blstm_transducer.py b/users/berger/configs/sms_wsj/20220615_dfg_multi_speaker/wsj_8kHz/config_03_blstm_transducer.py index b56141405..aaead78bf 100644 --- a/users/berger/configs/sms_wsj/20220615_dfg_multi_speaker/wsj_8kHz/config_03_blstm_transducer.py +++ b/users/berger/configs/sms_wsj/20220615_dfg_multi_speaker/wsj_8kHz/config_03_blstm_transducer.py @@ -176,12 +176,14 @@ def run_exp(alignments: Dict[str, Any], **kwargs) -> SummaryReport: "base_chunk_size": 256, "chunking_factors": {"data": 1, "classes": red_fact}, "extra_config": { - "pretrain": { - "repetitions": 6, - "construction_algo": CodeWrapper("pretrain_construction_algo"), - } - if kwargs.get("pretrain", False) - else None, + "pretrain": ( + { + "repetitions": 6, + "construction_algo": CodeWrapper("pretrain_construction_algo"), + } + if kwargs.get("pretrain", False) + else None + ), "train": {"reduce_target_factor": red_fact}, "dev": {"reduce_target_factor": red_fact}, }, diff --git a/users/berger/configs/switchboard/20240202_phoneme_transducer_pipeline/config_02a_transducer.py b/users/berger/configs/switchboard/20240202_phoneme_transducer_pipeline/config_02a_transducer.py index 8063dd200..6194a422d 100644 --- a/users/berger/configs/switchboard/20240202_phoneme_transducer_pipeline/config_02a_transducer.py +++ b/users/berger/configs/switchboard/20240202_phoneme_transducer_pipeline/config_02a_transducer.py @@ -46,10 +46,7 @@ def generate_returnn_config( **kwargs, ) -> ReturnnConfig: if train: - ( - network_dict, - extra_python, - ) = transducer_model.make_context_1_conformer_transducer( + (network_dict, extra_python,) = transducer_model.make_context_1_conformer_transducer( num_outputs=num_classes, specaug_args={ "max_time_num": 1, @@ -87,10 +84,7 @@ def generate_returnn_config( loss_boost_v2=kwargs.get("loss_boost_v2", False), ) else: - ( - network_dict, - extra_python, - ) = transducer_model.make_context_1_conformer_transducer_recog( + (network_dict, extra_python,) = transducer_model.make_context_1_conformer_transducer_recog( num_outputs=num_classes, conformer_args={ "num_blocks": 12, diff --git a/users/berger/configs/switchboard/20240202_phoneme_transducer_pipeline/config_02b_transducer_wei_data.py b/users/berger/configs/switchboard/20240202_phoneme_transducer_pipeline/config_02b_transducer_wei_data.py index 99650ac74..9ec52b39d 100644 --- a/users/berger/configs/switchboard/20240202_phoneme_transducer_pipeline/config_02b_transducer_wei_data.py +++ b/users/berger/configs/switchboard/20240202_phoneme_transducer_pipeline/config_02b_transducer_wei_data.py @@ -70,10 +70,7 @@ def generate_returnn_config( } if train: - ( - network_dict, - extra_python, - ) = transducer_model.make_context_1_conformer_transducer( + (network_dict, extra_python,) = transducer_model.make_context_1_conformer_transducer( num_outputs=num_classes, specaug_args=specaug_args, conformer_args={ @@ -107,10 +104,7 @@ def generate_returnn_config( specaug_v2=specaug_v2, ) else: - ( - network_dict, - extra_python, - ) = transducer_model.make_context_1_conformer_transducer_recog( + (network_dict, extra_python,) = transducer_model.make_context_1_conformer_transducer_recog( num_outputs=num_classes, conformer_args={ "num_blocks": 12, diff --git a/users/berger/configs/switchboard/20240202_phoneme_transducer_pipeline/config_02c_transducer_wei_data_tinaconf.py b/users/berger/configs/switchboard/20240202_phoneme_transducer_pipeline/config_02c_transducer_wei_data_tinaconf.py index 4854e0857..5ad7a0e0e 100644 --- a/users/berger/configs/switchboard/20240202_phoneme_transducer_pipeline/config_02c_transducer_wei_data_tinaconf.py +++ b/users/berger/configs/switchboard/20240202_phoneme_transducer_pipeline/config_02c_transducer_wei_data_tinaconf.py @@ -45,10 +45,7 @@ def generate_returnn_config( **kwargs, ) -> ReturnnConfig: if train: - ( - network_dict, - extra_python, - ) = transducer_model.make_context_1_conformer_transducer( + (network_dict, extra_python,) = transducer_model.make_context_1_conformer_transducer( num_inputs=40, num_outputs=num_classes, specaug_args={ @@ -81,10 +78,7 @@ def generate_returnn_config( loss_boost_v2=kwargs.get("loss_boost_v2", False), ) else: - ( - network_dict, - extra_python, - ) = transducer_model.make_context_1_conformer_transducer_recog( + (network_dict, extra_python,) = transducer_model.make_context_1_conformer_transducer_recog( num_inputs=40, num_outputs=num_classes, decoder_args={ diff --git a/users/berger/configs/switchboard/20240202_phoneme_transducer_pipeline/config_03a_transducer_fullsum.py b/users/berger/configs/switchboard/20240202_phoneme_transducer_pipeline/config_03a_transducer_fullsum.py index c7e5bcf73..80e587212 100644 --- a/users/berger/configs/switchboard/20240202_phoneme_transducer_pipeline/config_03a_transducer_fullsum.py +++ b/users/berger/configs/switchboard/20240202_phoneme_transducer_pipeline/config_03a_transducer_fullsum.py @@ -48,10 +48,7 @@ def generate_returnn_config( **kwargs, ) -> ReturnnConfig: if train: - ( - network_dict, - extra_python, - ) = transducer_model.make_context_1_conformer_transducer_fullsum( + (network_dict, extra_python,) = transducer_model.make_context_1_conformer_transducer_fullsum( num_outputs=num_classes, specaug_args={ "max_time_num": 1, @@ -85,10 +82,7 @@ def generate_returnn_config( }, ) else: - ( - network_dict, - extra_python, - ) = transducer_model.make_context_1_conformer_transducer_recog( + (network_dict, extra_python,) = transducer_model.make_context_1_conformer_transducer_recog( num_outputs=num_classes, conformer_args={ "num_blocks": 12, diff --git a/users/berger/configs/switchboard/20240202_phoneme_transducer_pipeline/config_03b_transducer_fullsum_wei_data.py b/users/berger/configs/switchboard/20240202_phoneme_transducer_pipeline/config_03b_transducer_fullsum_wei_data.py index 15623ada2..6e103088c 100644 --- a/users/berger/configs/switchboard/20240202_phoneme_transducer_pipeline/config_03b_transducer_fullsum_wei_data.py +++ b/users/berger/configs/switchboard/20240202_phoneme_transducer_pipeline/config_03b_transducer_fullsum_wei_data.py @@ -47,10 +47,7 @@ def generate_returnn_config( **kwargs, ) -> ReturnnConfig: if train: - ( - network_dict, - extra_python, - ) = transducer_model.make_context_1_conformer_transducer_fullsum( + (network_dict, extra_python,) = transducer_model.make_context_1_conformer_transducer_fullsum( num_outputs=num_classes, specaug_args={ "max_time_num": 1, @@ -84,10 +81,7 @@ def generate_returnn_config( }, ) else: - ( - network_dict, - extra_python, - ) = transducer_model.make_context_1_conformer_transducer_recog( + (network_dict, extra_python,) = transducer_model.make_context_1_conformer_transducer_recog( num_outputs=num_classes, conformer_args={ "num_blocks": 12, diff --git a/users/berger/corpus/librispeech/lm_data.py b/users/berger/corpus/librispeech/lm_data.py index d2beef445..35eabaf8e 100644 --- a/users/berger/corpus/librispeech/lm_data.py +++ b/users/berger/corpus/librispeech/lm_data.py @@ -10,7 +10,7 @@ def get_lm(name: str) -> rasr_lm_config.LMData: lm_dict = {} for key, val in lbs_dataset.get_arpa_lm_dict().items(): - lm_dict[key] = rasr_lm_config.ArpaLMData(10, val) + lm_dict[key] = rasr_lm_config.ArpaLMData(scale=10, filename=val, lookahead_lm=None) kazuki_lstm_path = dependency_path.join_right("kazuki_lstmlm_27062019") lm_dict["kazuki_lstm"] = rasr_lm_config.RNNLMData( @@ -18,7 +18,9 @@ def get_lm(name: str) -> rasr_lm_config.LMData: vocab_file=kazuki_lstm_path.join_right("vocabulary"), model_file=returnn.Checkpoint(index_path=kazuki_lstm_path.join_right("network.040.index")), graph_file=kazuki_lstm_path.join_right("network.040.meta"), - lookahead_lm=rasr_lm_config.ArpaLMData(scale=1.0, filename=lbs_dataset.get_arpa_lm_dict()["4gram"]), + lookahead_lm=rasr_lm_config.ArpaLMData( + scale=1.0, filename=lbs_dataset.get_arpa_lm_dict()["4gram"], lookahead_lm=None + ), ) kazuki_transformer_path = dependency_path.join_right("kazuki_transformerlm_2019interspeech") @@ -27,7 +29,9 @@ def get_lm(name: str) -> rasr_lm_config.LMData: vocab_file=kazuki_transformer_path.join_right("vocabulary"), model_file=returnn.Checkpoint(index_path=kazuki_transformer_path.join_right("network.030.index")), graph_file=kazuki_transformer_path.join_right("inference.meta"), - lookahead_lm=rasr_lm_config.ArpaLMData(scale=1.0, filename=lbs_dataset.get_arpa_lm_dict()["4gram"]), + lookahead_lm=rasr_lm_config.ArpaLMData( + scale=1.0, filename=lbs_dataset.get_arpa_lm_dict()["4gram"], lookahead_lm=None + ), ) return lm_dict[name] diff --git a/users/berger/corpus/switchboard/viterbi_transducer_data.py b/users/berger/corpus/switchboard/viterbi_transducer_data.py index 1dc86e529..622c2b6b3 100644 --- a/users/berger/corpus/switchboard/viterbi_transducer_data.py +++ b/users/berger/corpus/switchboard/viterbi_transducer_data.py @@ -40,12 +40,7 @@ def get_switchboard_data( # ********** Data inputs ********** - ( - train_data_inputs, - cv_data_inputs, - dev_data_inputs, - test_data_inputs, - ) = data.get_data_inputs( + (train_data_inputs, cv_data_inputs, dev_data_inputs, test_data_inputs,) = data.get_data_inputs( train_key=train_key, cv_keys=cv_keys, dev_keys=dev_keys, diff --git a/users/berger/helpers/rasr.py b/users/berger/helpers/rasr.py index e30ebc8c9..aaaeba234 100644 --- a/users/berger/helpers/rasr.py +++ b/users/berger/helpers/rasr.py @@ -7,7 +7,7 @@ from i6_experiments.common.datasets.util import CorpusObject from sisyphus import tk -from .rasr_lm_config import LMData +from i6_experiments.users.berger.helpers.rasr_lm_config import ArpaLMData, LMData @dataclass @@ -99,6 +99,16 @@ class RasrDataInput: lm: Optional[LMData] = None concurrent: int = 10 + def create_lm_images(self, rasr_binary_path: tk.Path) -> None: + if self.lm is None: + return + + if isinstance(self.lm, ArpaLMData): + self.lm.create_image(rasr_binary_path=rasr_binary_path, lexicon_file=self.lexicon.filename) + + if self.lm.lookahead_lm is not None and isinstance(self.lm.lookahead_lm, ArpaLMData): + self.lm.lookahead_lm.create_image(rasr_binary_path=rasr_binary_path, lexicon_file=self.lexicon.filename) + def get_crp_for_data_input( data: RasrDataInput, @@ -114,12 +124,6 @@ def get_crp_for_data_input( data.corpus_object.corpus_file, data.concurrent ).out_segment_path - if data.lm is not None: - crp.language_model_config = data.lm.get_config(tool_paths) # type: ignore - lookahead_config = data.lm.get_lookahead_config(tool_paths) - if lookahead_config is not None: - crp.lookahead_language_model_config = lookahead_config # type: ignore - crp.lexicon_config = rasr.RasrConfig() # type: ignore crp.lexicon_config.file = data.lexicon.filename crp.lexicon_config.normalize_pronunciation = data.lexicon.normalize_pronunciation @@ -128,4 +132,12 @@ def get_crp_for_data_input( crp.acoustic_model_config.allophones.add_all = data.lexicon.add_all_allophones # type: ignore crp.acoustic_model_config.allophones.add_from_lexicon = data.lexicon.add_allophones_from_lexicon # type: ignore + if data.lm is not None: + lm_config = data.lm.get_config(tool_paths=tool_paths) # type: ignore + lookahead_lm_config = data.lm.get_lookahead_config(tool_paths=tool_paths) + + crp.language_model_config = lm_config + if lookahead_lm_config is not None: + crp.lookahead_language_model_config = lookahead_lm_config # type: ignore + return crp diff --git a/users/berger/helpers/rasr_lm_config.py b/users/berger/helpers/rasr_lm_config.py index b7a28a9a4..32f678c89 100644 --- a/users/berger/helpers/rasr_lm_config.py +++ b/users/berger/helpers/rasr_lm_config.py @@ -1,7 +1,9 @@ +from __future__ import annotations from abc import ABC, abstractmethod from dataclasses import dataclass from typing import Optional +from i6_core.lm.lm_image import CreateLmImageJob from sisyphus import tk from i6_core import rasr, returnn @@ -13,27 +15,45 @@ @dataclass class LMData(ABC): scale: float + lookahead_lm: Optional[LMData] @abstractmethod - def get_config(self, tool_paths: ToolPaths) -> rasr.RasrConfig: + def get_config(self, **kwargs) -> rasr.RasrConfig: ... - def get_lookahead_config(self, tool_paths: ToolPaths) -> Optional[rasr.RasrConfig]: - return None + def get_lookahead_config(self, **kwargs) -> Optional[rasr.RasrConfig]: + if self.lookahead_lm is None: + return None + return self.lookahead_lm.get_config(**kwargs) @dataclass class ArpaLMData(LMData): filename: tk.Path + image: Optional[tk.Path] = None - def get_config(self, tool_paths: ToolPaths) -> rasr.RasrConfig: + def get_config(self, **_) -> rasr.RasrConfig: config = rasr.RasrConfig() config.type = "ARPA" config.file = self.filename config.scale = self.scale + if self.image is not None: + config.image = self.image return config + def create_image(self, rasr_binary_path: tk.Path, lexicon_file: tk.Path) -> None: + if self.image is not None: + return + + lm_crp = rasr.CommonRasrParameters() + lm_crp.set_executables(rasr_binary_path=rasr_binary_path) + rasr.crp_add_default_output(lm_crp) + lm_crp.lexicon_config = rasr.RasrConfig() + lm_crp.lexicon_config.file = lexicon_file + lm_crp.language_model_config = self.get_config() + self.image = CreateLmImageJob(crp=lm_crp, mem=8).out_image + @dataclass class NNLMData(LMData, ABC): @@ -42,9 +62,8 @@ class NNLMData(LMData, ABC): returnn_config: Optional[returnn.ReturnnConfig] = None graph_file: Optional[tk.Path] = None unknown_word: str = "" - lookahead_lm: Optional[LMData] = None - def _get_graph(self, tool_paths: ToolPaths) -> tk.Path: + def _get_graph(self, tool_paths: ToolPaths, **_) -> tk.Path: if self.graph_file is not None: return self.graph_file assert self.returnn_config is not None, "Must specify either a graph .meta file or a returnn config" @@ -55,7 +74,7 @@ def _get_graph(self, tool_paths: ToolPaths) -> tk.Path: blas_lib=tool_paths.blas_lib, ).out_graph - def get_config(self, tool_paths: ToolPaths) -> rasr.RasrConfig: + def get_config(self, tool_paths: ToolPaths, **_) -> rasr.RasrConfig: config = rasr.RasrConfig() config.scale = self.scale config.vocab_file = self.vocab_file @@ -76,11 +95,6 @@ def get_config(self, tool_paths: ToolPaths) -> rasr.RasrConfig: return config - def get_lookahead_config(self, tool_paths: ToolPaths) -> Optional[rasr.RasrConfig]: - if self.lookahead_lm is None: - return None - return self.lookahead_lm.get_config(tool_paths) - @dataclass class RNNLMData(NNLMData): @@ -89,7 +103,7 @@ class RNNLMData(NNLMData): opt_batch_size: int = 64 allow_reduced_history: bool = True - def get_config(self, tool_paths: ToolPaths) -> rasr.RasrConfig: + def get_config(self, tool_paths: ToolPaths, **_) -> rasr.RasrConfig: config = super().get_config(tool_paths) config.type = "tfrnn" @@ -106,7 +120,7 @@ def get_config(self, tool_paths: ToolPaths) -> rasr.RasrConfig: class TransformerLMData(NNLMData): max_batch_size: int = 64 - def get_config(self, tool_paths: ToolPaths) -> rasr.RasrConfig: + def get_config(self, tool_paths: ToolPaths, **_) -> rasr.RasrConfig: config = super().get_config(tool_paths) config.type = "simple-transformer" diff --git a/users/berger/network/helpers/label_context.py b/users/berger/network/helpers/label_context.py index 8214634b7..bb66e332c 100644 --- a/users/berger/network/helpers/label_context.py +++ b/users/berger/network/helpers/label_context.py @@ -1,4 +1,5 @@ from typing import Dict, List, Optional, Tuple +from i6_core.returnn import CodeWrapper from i6_experiments.users.berger.network.helpers.mlp import add_feed_forward_stack from i6_experiments.users.berger.network.helpers.output import add_softmax_output from i6_experiments.users.berger.network.helpers.compressed_input import ( @@ -11,6 +12,7 @@ class ILMMode(Enum): ZeroEnc = auto() + ZeroEncInclBlank = auto() def add_context_label_sequence_blank( @@ -18,7 +20,6 @@ def add_context_label_sequence_blank( base_labels: str = "data:classes", blank_index: int = 0, ) -> Tuple[str, str]: - # Example: # Classes = ..AB..C.D. # Then base labels should be ABCD @@ -51,7 +52,6 @@ def add_context_label_sequence_noblank( nonword_labels: List[int], base_labels: str = "data:classes", ): - # Example: # Classes = AAABBCCCDD # Let A be a nonword label, e.g. silence @@ -192,7 +192,6 @@ def add_context_1_decoder( combination_mode: Optional[str] = "add", output_args: Dict = {}, ) -> Tuple[List[str], Dict]: - output_unit = {} decoder_ff = add_dec_ffnn_stack(output_unit, context_labels, embedding_size, dec_mlp_args) @@ -269,10 +268,9 @@ def add_context_1_decoder_recog( dec_mlp_args: Dict = {}, joint_mlp_args: Dict = {}, ilm_scale: float = 0.0, - ilm_mode: ILMMode = ILMMode.ZeroEnc, + ilm_mode: ILMMode = ILMMode.ZeroEncInclBlank, combination_mode: Optional[str] = "add", ): - output_unit = {} output_unit["output_choice"] = { @@ -324,7 +322,7 @@ def add_context_1_decoder_recog( } if ilm_scale: - if ilm_mode == ILMMode.ZeroEnc: + if ilm_mode == ILMMode.ZeroEnc or ilm_mode == ILMMode.ZeroEncInclBlank: output_unit["zero_enc"] = {"class": "eval", "from": "data:source", "eval": "source(0) * 0"} joint_input_ilm = ["zero_enc", "decoder"] else: @@ -352,21 +350,25 @@ def add_context_1_decoder_recog( "reuse_params": "output", } - assert blank_idx == 0, "Blank idx != 0 not implemented for ilm" - # Set p(blank) = 1 and re-normalize the non-blank probs - # so we want P'[b, 0] = 1, sum(P'[b, 1:]) = 1, given a normalized tensor P, i.e. sum(P[b, :]) = 1 - # in log space logP'[b, 0] = 0, sum(exp(logP'[b, 1:])) = 1 - # so set logP'[b, 1:] <- logP[b, 1:] - log(1 - exp(P[b, 0])) - # then sum(exp(logP'[b, 1:])) = sum(P[1:] / (1 - exp(P[b, 0]))) = sum(P[b, 1:]) / sum(b, P[1:]) = 1 - output_unit["ilm_renorm"] = { - "class": "eval", - "from": ["ilm"], - "eval": "tf.concat([tf.zeros(tf.shape(source(0)[:, :1])), source(0)[:, 1:] - tf.math.log(1.0 - tf.exp(source(0)[:, :1]))], axis=-1)", - } + if ilm_mode == ILMMode.ZeroEncInclBlank: + ilm_layer = "ilm" + else: + assert blank_idx == 0, "Blank idx != 0 not implemented for ilm" + # Set p(blank) = 1 and re-normalize the non-blank probs + # so we want P'[b, 0] = 1, sum(P'[b, 1:]) = 1, given a normalized tensor P, i.e. sum(P[b, :]) = 1 + # in log space logP'[b, 0] = 0, sum(exp(logP'[b, 1:])) = 1 + # so set logP'[b, 1:] <- logP[b, 1:] - log(1 - exp(P[b, 0])) + # then sum(exp(logP'[b, 1:])) = sum(P[1:] / (1 - exp(P[b, 0]))) = sum(P[b, 1:]) / sum(b, P[1:]) = 1 + output_unit["ilm_renorm"] = { + "class": "eval", + "from": ["ilm"], + "eval": "tf.concat([tf.zeros(tf.shape(source(0)[:, :1])), source(0)[:, 1:] - tf.math.log(1.0 - tf.exp(source(0)[:, :1]))], axis=-1)", + } + ilm_layer = "ilm_renorm" output_unit["output_sub_ilm"] = { "class": "eval", - "from": ["output", "ilm_renorm"], + "from": ["output", ilm_layer], "eval": f"source(0) - {ilm_scale} * source(1)", } @@ -382,6 +384,183 @@ def add_context_1_decoder_recog( return joint_output, output_unit +def add_precomputed_context_1_decoder_recog( + network: Dict, + num_outputs: int, + blank_idx: int = 0, + encoder: str = "encoder", + embedding_size: int = 128, + dec_mlp_args: Dict = {}, + joint_mlp_args: Dict = {}, + ilm_scale: float = 0.0, + ilm_mode: ILMMode = ILMMode.ZeroEncInclBlank, + combination_mode: Optional[str] = "add", +): + output_unit = {} + + # [V-1] + output_unit["all_context"] = { + "class": "constant", + "value": list(range(1, num_outputs)), # first index: out-of-bounds for all-zero-embedding of init history + "dtype": "int32", + "with_batch_dim": True, + "as_batch": True, + "sparse_dim": CodeWrapper(f"FeatureDim('label', dimension={num_outputs})"), + } + + # [V-1, F] + output_unit["context_embedding"] = { + "class": "linear", + "from": "all_context", + "n_out": embedding_size, + "with_bias": False, + "initial_output": None, + } + + # [V, F] + output_unit["context_embedding_padded"] = { + "class": "pad", + "from": "context_embedding", + "axes": "B", + "padding": (1, 0), + "value": 0, + "mode": "constant", + } + + # [V, D] + decoder_ff = add_feed_forward_stack( + output_unit, from_list="context_embedding_padded", name="dec_ff", **dec_mlp_args + ) + output_unit["decoder"] = { + "class": "copy", + "from": decoder_ff, + } + + # [V, T, E] + output_unit["tile_encoder"] = { + "class": "eval", + "from": f"base:base:{encoder}", + "eval": f"tf.tile(source(0), [{num_outputs}, 1, 1])", + } + + joint_input = ["tile_encoder", "decoder"] + if combination_mode is None or combination_mode == "concat": + # [V, T, E+D] + output_unit["joint_input"] = { + "class": "copy", + "from": joint_input, + } + else: + # [V, T, E] + output_unit["joint_input"] = { + "class": "combine", + "from": joint_input, + "kind": combination_mode, + } + + # [V, T, J] + joint_output = add_feed_forward_stack(output_unit, from_list="joint_input", name="joint_ff", **joint_mlp_args) + + # [V, T, V] + output_unit["output"] = { + "class": "linear", + "from": joint_output, + "activation": "log_softmax", + "n_out": num_outputs, + } + + if ilm_scale: + if ilm_mode == ILMMode.ZeroEnc or ilm_mode == ILMMode.ZeroEncInclBlank: + # [V, T, E] + output_unit["zero_enc"] = {"class": "eval", "from": "tile_encoder", "eval": "source(0) * 0"} + # [V, T, E+D] + joint_input_ilm = ["zero_enc", "decoder"] + else: + raise NotImplementedError + if combination_mode is None or combination_mode == "concat": + # [V, T, E+D] + output_unit["joint_input_ilm"] = { + "class": "copy", + "from": joint_input_ilm, + } + else: + # [V, T, E] + output_unit["joint_input_ilm"] = { + "class": "combine", + "from": joint_input_ilm, + "kind": combination_mode, + } + + # [V, T, J] + joint_output_ilm = add_feed_forward_stack( + output_unit, from_list="joint_input_ilm", name="joint_ff_ilm", reuse_from_name="joint_ff", **joint_mlp_args + ) + + # [V, T, V] + output_unit["ilm"] = { + "class": "linear", + "from": joint_output_ilm, + "activation": "log_softmax", + "n_out": num_outputs, + "reuse_params": "output", + } + + if ilm_mode == ILMMode.ZeroEncInclBlank: + ilm_layer = "ilm" + else: + assert blank_idx == 0, "Blank idx != 0 not implemented for ilm" + # Set p(blank) = 1 and re-normalize the non-blank probs + # so we want P'[b, 0] = 1, sum(P'[b, 1:]) = 1, given a normalized tensor P, i.e. sum(P[b, :]) = 1 + # in log space logP'[b, 0] = 0, sum(exp(logP'[b, 1:])) = 1 + # so set logP'[b, 1:] <- logP[b, 1:] - log(1 - exp(P[b, 0])) + # then sum(exp(logP'[b, 1:])) = sum(P[1:] / (1 - exp(P[b, 0]))) = sum(P[b, 1:]) / sum(b, P[1:]) = 1 + output_unit["ilm_renorm"] = { + "class": "eval", + "from": "ilm", + "eval": "tf.concat([tf.zeros(tf.shape(source(0)[:, :1])), source(0)[:, 1:] - tf.math.log(1.0 - tf.exp(source(0)[:, :1]))], axis=-1)", + } + ilm_layer = "ilm_renorm" + + # [V, T, V] + output_unit["output_sub_ilm"] = { + "class": "eval", + "from": ["output", ilm_layer], + "eval": f"source(0) - {ilm_scale} * source(1)", + "is_output_layer": True, + } + + out_layer = "output/rec/output_sub_ilm" + else: + out_layer = "output" + + network["output"] = { + "class": "subnetwork", + "from": encoder, + "subnetwork": { + "rec": { + "class": "subnetwork", + "from": "data", + "subnetwork": output_unit, + }, + "output": { + "class": "copy", + "from": "rec", + }, + }, + "is_output_layer": False, + } + + network["output_precompute"] = { + "class": "eval", + "from": out_layer, + "eval": f"tf.transpose(tf.reshape(tf.transpose(source(0, auto_convert=False, enforce_batch_major=True), [0, 2, 1]), [1, {num_outputs*num_outputs}, -1]), [0, 2, 1])", + "is_output_layer": True, + "out_type": {"shape": (None, num_outputs * num_outputs), "dim": num_outputs * num_outputs}, + } + + return output_unit + + def add_context_1_decoder_fullsum( network: Dict, context_labels: str, @@ -392,7 +571,6 @@ def add_context_1_decoder_fullsum( combination_mode: Optional[str] = "add", compress_joint_input: bool = True, ) -> Tuple[List[str], Dict, List]: - output_unit = {} extra_python = [] diff --git a/users/berger/network/models/context_1_transducer.py b/users/berger/network/models/context_1_transducer.py index de26d3805..38cd61d42 100644 --- a/users/berger/network/models/context_1_transducer.py +++ b/users/berger/network/models/context_1_transducer.py @@ -155,11 +155,7 @@ def make_context_1_conformer_transducer_fullsum( } context_labels = "pred_labels_int32" - ( - joint_output, - decoder_unit, - decoder_python, - ) = label_context.add_context_1_decoder_fullsum( + (joint_output, decoder_unit, decoder_python,) = label_context.add_context_1_decoder_fullsum( network, context_labels=context_labels, encoder="encoder", @@ -226,6 +222,29 @@ def make_context_1_conformer_transducer_recog( return network, python_code +def make_context_1_conformer_transducer_precomputed_recog( + num_outputs: int, + vgg_args: Dict = {}, + conformer_args: Dict = {}, + decoder_args: Dict = {}, +) -> Tuple[Dict, List]: + network = {} + python_code = [] + + from_list = ["data"] + + from_list = add_initial_conv(network, from_list, **vgg_args) + from_list, _ = add_conformer_stack(network, from_list, **conformer_args) + + network["encoder"] = {"class": "copy", "from": from_list} + + label_context.add_precomputed_context_1_decoder_recog( + network, num_outputs=num_outputs, encoder="encoder", **decoder_args + ) + + return network, python_code + + def make_context_1_blstm_transducer( num_outputs: int, blank_index: int = 0, @@ -342,11 +361,7 @@ def make_context_1_blstm_transducer_fullsum( } context_labels = "pred_labels_int32" - ( - joint_output, - decoder_unit, - decoder_python, - ) = label_context.add_context_1_decoder_fullsum( + (joint_output, decoder_unit, decoder_python,) = label_context.add_context_1_decoder_fullsum( network, context_labels=context_labels, encoder="encoder", diff --git a/users/berger/recipe/rasr/label_tree_and_scorer.py b/users/berger/recipe/rasr/label_tree_and_scorer.py index 88a6d4fef..62b7cf942 100644 --- a/users/berger/recipe/rasr/label_tree_and_scorer.py +++ b/users/berger/recipe/rasr/label_tree_and_scorer.py @@ -149,7 +149,8 @@ def extra_args(self): return { key: val for key, val in self.config._items() - if key not in [ + if key + not in [ "label-scorer-type", "scale", "label-file", diff --git a/users/berger/recipe/recognition/__init__.py b/users/berger/recipe/recognition/__init__.py index d115ab2e9..7d55d439b 100644 --- a/users/berger/recipe/recognition/__init__.py +++ b/users/berger/recipe/recognition/__init__.py @@ -1,4 +1,5 @@ from .generic_seq2seq_search import * +from .generic_seq2seq_search_v2 import * from .label_sync_search import * from .scoring import * from .statistics import * diff --git a/users/berger/recipe/recognition/generic_seq2seq_search_v2.py b/users/berger/recipe/recognition/generic_seq2seq_search_v2.py new file mode 100644 index 000000000..c469f615d --- /dev/null +++ b/users/berger/recipe/recognition/generic_seq2seq_search_v2.py @@ -0,0 +1,444 @@ +__all__ = ["BuildGenericSeq2SeqGlobalCacheJob", "GenericSeq2SeqSearchJobV2"] + +from typing import List, Optional, Tuple +from sisyphus import * + +assert __package__ is not None +Path = setup_path(__package__) + +import shutil + +from i6_core import rasr, util +from i6_experiments.users.berger.recipe.rasr.label_tree_and_scorer import LabelTree, LabelScorer + + +class BuildGenericSeq2SeqGlobalCacheJob(rasr.RasrCommand, Job): + """ + Standalone job to create the global-cache for generic-seq2seq-tree-search + """ + + def __init__( + self, + crp: rasr.CommonRasrParameters, + label_tree: LabelTree, + label_scorer: LabelScorer, + search_parameters: Optional[dict] = None, + extra_config: Optional[rasr.RasrConfig] = None, + extra_post_config: Optional[rasr.RasrConfig] = None, + ): + """ + :param crp: common RASR params (required: lexicon, acoustic_model, language_model, recognizer) + :param label_tree: label tree object for structuring the search tree + :param label_scorer: label scorer object for score computation + :param extra_config: overlay config that influences the Job's hash + :param extra_post_config: overlay config that does not influences the Job's hash + """ + self.set_vis_name("Build Global Cache") + + self.config, self.post_config = BuildGenericSeq2SeqGlobalCacheJob.create_config( + crp=crp, + label_tree=label_tree, + label_scorer=label_scorer, + search_parameters=search_parameters, + extra_config=extra_config, + extra_post_config=extra_post_config, + ) + + self.exe = self.select_exe(crp.flf_tool_exe, "flf-tool") + + self.out_log_file = self.log_file_output_path("build_global_cache", crp, False) + self.out_global_cache = self.output_path("global.cache", cached=True) + + self.rqmt = {"time": 1, "cpu": 1, "mem": 4} + + def tasks(self): + yield Task("create_files", mini_task=True) + yield Task("run", resume="run", rqmt=self.rqmt) + + def create_files(self): + self.write_config(self.config, self.post_config, "build_global_cache.config") + with open("dummy.corpus", "wt") as f: + f.write('\n') + with open("dummy.flow", "wt") as f: + f.write(f'\n') + extra_code = ( + ":${THEANO_FLAGS:=" + '}\nexport THEANO_FLAGS="$THEANO_FLAGS,device=cpu,force_device=True"\nexport TF_DEVICE="cpu"' + ) + self.write_run_script(self.exe, "build_global_cache.config", extra_code=extra_code) + + def run(self): + self.run_script(1, self.out_log_file) + shutil.move("global.cache", self.out_global_cache.get_path()) + + @classmethod + def create_config( + cls, + crp: rasr.CommonRasrParameters, + label_tree: LabelTree, + label_scorer: LabelScorer, + search_parameters: Optional[dict], + extra_config: Optional[rasr.RasrConfig], + extra_post_config: Optional[rasr.RasrConfig], + ): + config, post_config = rasr.build_config_from_mapping( + crp, + { + "lexicon": "flf-lattice-tool.lexicon", + "acoustic_model": "flf-lattice-tool.network.recognizer.acoustic-model", + "language_model": "flf-lattice-tool.network.recognizer.lm", + "lookahead_language_model": "flf-lattice-tool.network.recognizer.recognizer.lookahead-lm", + }, + ) + + # Apply config from label tree + label_tree.apply_config( + "flf-lattice-tool.network.recognizer.recognizer.label-tree", + config, + post_config, + ) + + # Optional lexicon overwrite + if label_tree.lexicon_config is not None: + config["flf-lattice-tool.lexicon"]._update(label_tree.lexicon_config) + + # Apply config from label scorer and eliminate unnecessary arguments that don't affect the search space (scale, prior) + label_scorer_reduced = LabelScorer( + scorer_type=label_scorer.scorer_type, + scale=1.0, + label_file=label_scorer.label_file, + num_classes=label_scorer.num_classes, + use_prior=False, + extra_args={key: val for key, val in label_scorer.extra_args.items() if key != "first-order"}, + ) + + label_scorer_reduced.apply_config("flf-lattice-tool.network.recognizer.label-scorer", config, post_config) + + # search settings # + search_config = rasr.RasrConfig() + if search_parameters is not None: + for key, val in search_parameters.items(): + search_config[key.replace("_", "-")] = val + + config.flf_lattice_tool.network.recognizer.recognizer._update(search_config) + + # flf network # + config.flf_lattice_tool.network.initial_nodes = "segment" + config.flf_lattice_tool.network.segment.type = "speech-segment" + config.flf_lattice_tool.network.segment.links = "1->recognizer:1" + config.flf_lattice_tool.corpus.file = "dummy.corpus" + config.flf_lattice_tool.network.recognizer.type = "recognizer" + config.flf_lattice_tool.network.recognizer.links = "sink" + config.flf_lattice_tool.network.recognizer.apply_non_word_closure_filter = False + config.flf_lattice_tool.network.recognizer.add_confidence_score = False + config.flf_lattice_tool.network.recognizer.apply_posterior_pruning = False + config.flf_lattice_tool.network.recognizer.search_type = "generic-seq2seq-tree-search" + config.flf_lattice_tool.network.recognizer.feature_extraction.file = "dummy.flow" + config.flf_lattice_tool.network.sink.type = "sink" + post_config.flf_lattice_tool.network.sink.warn_on_empty_lattice = True + post_config.flf_lattice_tool.network.sink.error_on_empty_lattice = False + + # skip conventional AM or load it without GMM # + if crp.acoustic_model_config is None: + config.flf_lattice_tool.network.recognizer.use_acoustic_model = False + else: + config.flf_lattice_tool.network.recognizer.use_mixture = False + if config.flf_lattice_tool.network.recognizer.acoustic_model._get("length") is not None: + del config.flf_lattice_tool.network.recognizer.acoustic_model["length"] + + # disable scaling + if config.flf_lattice_tool.network.recognizer.lm._get("scale") is not None: + del config.flf_lattice_tool.network.recognizer.lm["scale"] + + if config.flf_lattice_tool.network.recognizer.recognizer._get("lookahead-lm") is not None: + del config.flf_lattice_tool.network.recognizer.recognizer.lookahead_lm["scale"] + + config.flf_lattice_tool.network.recognition_mode = "init-only" + config.flf_lattice_tool.network.search_type = "generic-seq2seq-tree-search" + + config.flf_lattice_tool.global_cache.file = "global.cache" + config.flf_lattice_tool.global_cache.read_only = False + + config._update(extra_config) + post_config._update(extra_post_config) + + return config, post_config + + @classmethod + def hash(cls, kwargs): + config, _ = cls.create_config(**kwargs) + return super().hash({"config": config, "exe": kwargs["crp"].speech_recognizer_exe}) + + +class GenericSeq2SeqSearchJobV2(rasr.RasrCommand, Job): + __sis_hash_exclude__ = {"num_threads": None} + + def __init__( + self, + crp: rasr.CommonRasrParameters, + feature_flow: rasr.FlowNetwork, + label_tree: LabelTree, + label_scorer: LabelScorer, + rasr_exe: Optional[tk.Path] = None, + search_parameters: Optional[dict] = None, + lm_lookahead: bool = True, + lookahead_options: Optional[dict] = None, + eval_single_best: bool = True, + eval_best_in_lattice: bool = True, + use_gpu: bool = False, + global_cache: Optional[tk.Path] = None, + rtf: float = 2, + mem: float = 8, + extra_config: Optional[rasr.RasrConfig] = None, + extra_post_config: Optional[rasr.RasrConfig] = None, + num_threads: int = 2, + ): + self.set_vis_name("Generic Seq2Seq Search") + + self.config, self.post_config = GenericSeq2SeqSearchJobV2.create_config( + crp=crp, + feature_flow=feature_flow, + label_tree=label_tree, + label_scorer=label_scorer, + search_parameters=search_parameters, + lm_lookahead=lm_lookahead, + lookahead_options=lookahead_options, + eval_single_best=eval_single_best, + eval_best_in_lattice=eval_best_in_lattice, + extra_config=extra_config, + extra_post_config=extra_post_config, + global_cache=global_cache, + ) + self.feature_flow = feature_flow + if rasr_exe is not None: + self.rasr_exe = rasr_exe + else: + self.rasr_exe = crp.flf_tool_exe + assert self.rasr_exe is not None + + self.concurrent = crp.concurrent + self.use_gpu = use_gpu + self.num_threads = num_threads + + self.out_log_file = self.log_file_output_path("search", crp, True) + + self.out_single_lattice_caches = dict( + (task_id, self.output_path("lattice.cache.%d" % task_id, cached=True)) + for task_id in range(1, crp.concurrent + 1) + ) + self.out_lattice_bundle = self.output_path("lattice.bundle", cached=True) + self.out_lattice_path = util.MultiOutputPath( + self, "lattice.cache.$(TASK)", self.out_single_lattice_caches, cached=True + ) + + self.rqmt = { + "time": max(crp.corpus_duration * rtf / crp.concurrent, 24), + "cpu": num_threads, + "gpu": 1 if self.use_gpu else 0, + "mem": mem, + } + + def tasks(self): + yield Task("create_files", mini_task=True) + yield Task("run", resume="run", rqmt=self.rqmt, args=range(1, self.concurrent + 1)) + + def create_files(self): + self.write_config(self.config, self.post_config, "recognition.config") + self.feature_flow.write_to_file("feature.flow") + util.write_paths_to_file(self.out_lattice_bundle, self.out_single_lattice_caches.values()) + extra_code = 'export TF_DEVICE="{0}"'.format("gpu" if self.use_gpu else "cpu") + # sometimes crash without this + if not self.use_gpu: + extra_code += "\nexport CUDA_VISIBLE_DEVICES=" + + extra_code += f"\nexport OMP_NUM_THREADS={self.num_threads}" + extra_code += f"\nexport MKL_NUM_THREADS={self.num_threads}" + self.write_run_script(self.rasr_exe, "recognition.config", extra_code=extra_code) + + def stop_run(self, task_id): + print(f"run job {task_id} exceeds specified rqmt and stopped") + + def run(self, task_id): + self.run_script(task_id, self.out_log_file[task_id]) + shutil.move( + "lattice.cache.%d" % task_id, + self.out_single_lattice_caches[task_id].get_path(), + ) + + def cleanup_before_run(self, cmd, retry, task_id, *args): + util.backup_if_exists(f"recognition.log.{task_id}") + util.delete_if_exists(f"lattice.cache.{task_id}") + + @classmethod + def create_config( + cls, + crp: rasr.CommonRasrParameters, + feature_flow: rasr.FlowNetwork, + label_tree: LabelTree, + label_scorer: LabelScorer, + search_parameters: Optional[dict] = None, + lm_lookahead: bool = True, + lookahead_options: Optional[dict] = None, + eval_single_best: bool = True, + eval_best_in_lattice: bool = True, + extra_config: Optional[rasr.RasrConfig] = None, + extra_post_config: Optional[rasr.RasrConfig] = None, + global_cache: Optional[tk.Path] = None, + **_, + ): + # get config from csp # + config, post_config = rasr.build_config_from_mapping( + crp, + { + "corpus": "flf-lattice-tool.corpus", + "lexicon": "flf-lattice-tool.lexicon", + "acoustic_model": "flf-lattice-tool.network.recognizer.acoustic-model", + "language_model": "flf-lattice-tool.network.recognizer.lm", + "lookahead_language_model": "flf-lattice-tool.network.recognizer.recognizer.lookahead-lm", + }, + parallelize=True, + ) + + # acoustic model maybe used for allophones and state-tying, but no mixture is needed + # skip conventional AM or load it without GMM + if crp.acoustic_model_config is None: + config.flf_lattice_tool.network.recognizer.use_acoustic_model = False + else: + config.flf_lattice_tool.network.recognizer.use_mixture = False + + # feature flow # + config.flf_lattice_tool.network.recognizer.feature_extraction.file = "feature.flow" + if feature_flow.outputs != {"features"}: + assert len(feature_flow.outputs) == 1, "not implemented otherwise" + config.flf_lattice_tool.network.recognizer.feature_extraction.main_port_name = next( + iter(feature_flow.outputs) + ) + + feature_flow.apply_config( + "flf-lattice-tool.network.recognizer.feature-extraction", + config, + post_config, + ) + + # label tree and optional lexicon overwrite + label_tree.apply_config( + "flf-lattice-tool.network.recognizer.recognizer.label-tree", + config, + post_config, + ) + if label_tree.lexicon_config is not None: + config["flf-lattice-tool.lexicon"]._update(label_tree.lexicon_config) + + # label scorer + label_scorer.apply_config("flf-lattice-tool.network.recognizer.label-scorer", config, post_config) + + # search settings # + search_config = rasr.RasrConfig() + if search_parameters is not None: + for key, val in search_parameters.items(): + search_config[key.replace("_", "-")] = val + + config.flf_lattice_tool.network.recognizer.recognizer._update(search_config) + + # lookahead settings # + la_opts = { + "history_limit": 1, + "cache_low": 2000, + "cache_high": 3000, + } + if lookahead_options is not None: + la_opts.update(lookahead_options) + + config.flf_lattice_tool.network.recognizer.recognizer.optimize_lattice = True + + la_config = rasr.RasrConfig() + la_config._value = lm_lookahead + + if "laziness" in la_opts: + config.flf_lattice_tool.network.recognizer.recognizer.lm_lookahead_laziness = la_opts["laziness"] + + if lm_lookahead: + if "history_limit" in la_opts: + la_config.history_limit = la_opts["history_limit"] + if "tree_cutoff" in la_opts: + la_config.tree_cutoff = la_opts["tree_cutoff"] + if "minimum_representation" in la_opts: + la_config.minimum_representation = la_opts["minimum_representation"] + if "lm_lookahead_scale" in la_opts: + la_config.lm_lookahead_scale = la_opts["lm_lookahead_scale"] + if "cache_low" in la_opts: + post_config.flf_lattice_tool.network.recognizer.recognizer.lm_lookahead.cache_size_low = la_opts[ + "cache_low" + ] + if "cache_high" in la_opts: + post_config.flf_lattice_tool.network.recognizer.recognizer.lm_lookahead.cache_size_high = la_opts[ + "cache_high" + ] + + config.flf_lattice_tool.network.recognizer.recognizer.lm_lookahead = la_config + + # flf network # + config.flf_lattice_tool.network.initial_nodes = "segment" + config.flf_lattice_tool.network.segment.type = "speech-segment" + config.flf_lattice_tool.network.segment.links = "1->recognizer:1 0->archive-writer:1 0->evaluator:1" + + config.flf_lattice_tool.network.recognizer.type = "recognizer" + config.flf_lattice_tool.network.recognizer.search_type = "generic-seq2seq-tree-search" + config.flf_lattice_tool.network.recognizer.apply_non_word_closure_filter = False + config.flf_lattice_tool.network.recognizer.add_confidence_score = False + config.flf_lattice_tool.network.recognizer.apply_posterior_pruning = False + + if label_scorer.config.label_unit == "hmm": + config.flf_lattice_tool.network.recognizer.links = "expand" + config.flf_lattice_tool.network.expand.type = "expand-transits" + config.flf_lattice_tool.network.expand.links = "evaluator archive-writer" + else: + config.flf_lattice_tool.network.recognizer.links = "evaluator archive-writer" + + config.flf_lattice_tool.network.evaluator.type = "evaluator" + config.flf_lattice_tool.network.evaluator.links = "sink:0" + config.flf_lattice_tool.network.evaluator.word_errors = True + config.flf_lattice_tool.network.evaluator.single_best = eval_single_best + config.flf_lattice_tool.network.evaluator.best_in_lattice = eval_best_in_lattice + config.flf_lattice_tool.network.evaluator.edit_distance.format = "bliss" + config.flf_lattice_tool.network.evaluator.edit_distance.allow_broken_words = False + + config.flf_lattice_tool.network.archive_writer.type = "archive-writer" + config.flf_lattice_tool.network.archive_writer.links = "sink:1" + config.flf_lattice_tool.network.archive_writer.format = "flf" + config.flf_lattice_tool.network.archive_writer.path = "lattice.cache.$(TASK)" + post_config.flf_lattice_tool.network.archive_writer.info = True + + config.flf_lattice_tool.network.sink.type = "sink" + post_config.flf_lattice_tool.network.sink.warn_on_empty_lattice = True + post_config.flf_lattice_tool.network.sink.error_on_empty_lattice = False + post_config["*"].output_channel.unbuffered = True + + if global_cache is None: + global_cache = BuildGenericSeq2SeqGlobalCacheJob( + crp=crp, label_tree=label_tree, label_scorer=label_scorer + ).out_global_cache + + post_config.flf_lattice_tool.global_cache.read_only = True + post_config.flf_lattice_tool.global_cache.file = global_cache + + # update parameters # + config._update(extra_config) + post_config._update(extra_post_config) + + return config, post_config + + @classmethod + def hash(cls, kwargs): + config, _ = cls.create_config(**kwargs) + if kwargs["rasr_exe"] is not None: + rasr_exe = kwargs["rasr_exe"] + else: + rasr_exe = kwargs["crp"].flf_tool_exe + return super().hash( + { + "config": config, + "feature_flow": kwargs["feature_flow"], + "exe": rasr_exe, + } + ) diff --git a/users/berger/settings.py b/users/berger/settings.py index 9744555d6..1cb0369a1 100644 --- a/users/berger/settings.py +++ b/users/berger/settings.py @@ -23,9 +23,7 @@ def check_engine_limits(current_rqmt, task): i6 support for gpu_mem """ current_rqmt["time"] = min(168, current_rqmt.get("time", 2)) - if current_rqmt.get("gpu", 0) > 0 and "-p" not in current_rqmt.get( - "sbatch_args", [] - ): + if current_rqmt.get("gpu", 0) > 0 and "-p" not in current_rqmt.get("sbatch_args", []): if current_rqmt.get("gpu_mem", 0) > 11: current_rqmt["sbatch_args"] = ["-p", "gpu_24gb"] else: @@ -54,9 +52,7 @@ def engine(): return EngineSelector( engines={ "short": LocalEngine(cpus=4, mem=16), - "long": SimpleLinuxUtilityForResourceManagementEngine( - default_rqmt=default_rqmt - ), + "long": SimpleLinuxUtilityForResourceManagementEngine(default_rqmt=default_rqmt), }, default_engine="long", ) @@ -79,6 +75,7 @@ def worker_wrapper(job, task_name, call): "AdvancedTreeSearchJob", "AdvancedTreeSearchLmImageAndGlobalCacheJob", "GenericSeq2SeqSearchJob", + "GenericSeq2SeqSearchJobV2", "CreateLmImageJob", "BuildGenericSeq2SeqGlobalCacheJob", "GenericSeq2SeqLmImageAndGlobalCacheJob", diff --git a/users/berger/systems/base_system.py b/users/berger/systems/base_system.py index 73450cc71..1351a955d 100644 --- a/users/berger/systems/base_system.py +++ b/users/berger/systems/base_system.py @@ -59,7 +59,8 @@ def __init__( self._functors = self._initialize_functors() @abstractmethod - def _initialize_functors(self) -> Functors[types.TrainJobType, types.ConfigType]: ... + def _initialize_functors(self) -> Functors[types.TrainJobType, types.ConfigType]: + ... def get_train_job(self, exp_name: Optional[str] = None) -> types.TrainJobType: if exp_name is not None: diff --git a/users/berger/systems/functors/recognition/seq2seq_search.py b/users/berger/systems/functors/recognition/seq2seq_search.py index 7190de29d..0667834c4 100644 --- a/users/berger/systems/functors/recognition/seq2seq_search.py +++ b/users/berger/systems/functors/recognition/seq2seq_search.py @@ -42,6 +42,7 @@ def __call__( recognition_scoring_type=RecognitionScoringType.Lattice, rqmt_update: Optional[dict] = None, search_stats: bool = False, + seq2seq_v2: bool = False, **kwargs, ) -> List[Dict]: assert recog_corpus is not None @@ -135,14 +136,24 @@ def __call__( else: raise NotImplementedError - rec = recognition.GenericSeq2SeqSearchJob( - crp=crp, - feature_flow=feature_flow, - label_scorer=label_scorer, - label_tree=label_tree, - lookahead_options=lookahead_options, - **kwargs, - ) + if seq2seq_v2: + rec = recognition.GenericSeq2SeqSearchJobV2( + crp=crp, + feature_flow=feature_flow, + label_scorer=label_scorer, + label_tree=label_tree, + lookahead_options=lookahead_options, + **kwargs, + ) + else: + rec = recognition.GenericSeq2SeqSearchJob( + crp=crp, + feature_flow=feature_flow, + label_scorer=label_scorer, + label_tree=label_tree, + lookahead_options=lookahead_options, + **kwargs, + ) if rqmt_update is not None: rec.rqmt.update(rqmt_update) diff --git a/users/berger/systems/functors/seq2seq_base.py b/users/berger/systems/functors/seq2seq_base.py index 1944e0b56..46f95b3a2 100644 --- a/users/berger/systems/functors/seq2seq_base.py +++ b/users/berger/systems/functors/seq2seq_base.py @@ -73,10 +73,16 @@ def _get_tf_feature_flow_for_label_scorer( tf_graph: tk.Path, checkpoint: returnn.Checkpoint, feature_type: FeatureType = FeatureType.SAMPLES, + output_layer_name: str = "output", **_, ) -> rasr.FlowNetwork: if label_scorer.scorer_type == "precomputed-log-posterior": - feature_flow = self._make_precomputed_tf_feature_flow(base_feature_flow, tf_graph, checkpoint) + feature_flow = self._make_precomputed_tf_feature_flow( + base_flow=base_feature_flow, + tf_graph=tf_graph, + tf_checkpoint=checkpoint, + output_layer_name=output_layer_name, + ) elif label_scorer.scorer_type in ["tf-attention", "tf-rnn-transducer", "tf-ffnn-transducer", "tf-segmental"]: feature_flow = copy.deepcopy(base_feature_flow) feature_flow.config = feature_flow.config or rasr.RasrConfig() From f97194791f3eef9d8aac686c2aee6f2dde43e211 Mon Sep 17 00:00:00 2001 From: Simon Berger Date: Fri, 24 May 2024 13:52:38 +0200 Subject: [PATCH 057/227] Update users/berger --- .../20230602_rescale_baselines/__init__.py | 4 +- .../config_01_conformer_ctc.py | 102 +++-- .../config_01b_conformer_ctc_logmel.py | 197 --------- .../config_04a_conformer_transducer_bpe.py | 2 +- .../config_04b_conformer_transducer_phon.py | 24 +- users/berger/corpus/tedlium2/lm_data.py | 4 +- users/berger/pytorch/models/conformer_ctc.py | 7 +- .../pytorch/models/conformer_transducer_v2.py | 1 - .../recognition/generic_seq2seq_search.py | 385 ++++++------------ 9 files changed, 207 insertions(+), 519 deletions(-) delete mode 100644 users/berger/configs/tedlium2/20230602_rescale_baselines/config_01b_conformer_ctc_logmel.py diff --git a/users/berger/configs/tedlium2/20230602_rescale_baselines/__init__.py b/users/berger/configs/tedlium2/20230602_rescale_baselines/__init__.py index 949f5fa7d..d8ebae699 100644 --- a/users/berger/configs/tedlium2/20230602_rescale_baselines/__init__.py +++ b/users/berger/configs/tedlium2/20230602_rescale_baselines/__init__.py @@ -3,7 +3,6 @@ from i6_experiments.users.berger.systems.dataclasses import SummaryKey from sisyphus import tk, gs -from .config_01b_conformer_ctc_logmel import py as py_01b from .config_01_conformer_ctc import py as py_01 from .config_04a_conformer_transducer_bpe import py as py_04a @@ -21,6 +20,8 @@ def worker_wrapper(job, task_name, call): "FeatureExtractionJob", "GenericSeq2SeqSearchJob", "GenericSeq2SeqLmImageAndGlobalCacheJob", + "CreateLmImageJob", + "BuildGenericSeq2SeqGlobalCacheJob", "LatticeToCtmJob", "OptimizeAMandLMScaleJob", "AlignmentJob", @@ -87,7 +88,6 @@ def worker_wrapper(job, task_name, call): for subreport in [ copy.deepcopy(py_01()), - copy.deepcopy(py_01b()), copy.deepcopy(py_04a()), copy.deepcopy(py_04a_rasr()), copy.deepcopy(py_04b()), diff --git a/users/berger/configs/tedlium2/20230602_rescale_baselines/config_01_conformer_ctc.py b/users/berger/configs/tedlium2/20230602_rescale_baselines/config_01_conformer_ctc.py index f2c222a29..c9513483b 100644 --- a/users/berger/configs/tedlium2/20230602_rescale_baselines/config_01_conformer_ctc.py +++ b/users/berger/configs/tedlium2/20230602_rescale_baselines/config_01_conformer_ctc.py @@ -22,8 +22,6 @@ rasr.flow.FlowNetwork.default_flags = {"cache_mode": "task_dependent"} num_outputs = 79 -# num_subepochs = 250 -num_subepochs = 1 tools = copy.deepcopy(default_tools_v2) tools.rasr_binary_path = tk.Path("/u/berger/repositories/rasr_versions/gen_seq2seq_dev/arch/linux-x86_64-standard") @@ -32,48 +30,45 @@ # ********** Return Config generators ********** -def returnn_config_generator(variant: ConfigVariant, train_data_config: dict, dev_data_config: dict) -> ReturnnConfig: - model_config = conformer_ctc.get_default_config_v2(num_inputs=50, num_outputs=num_outputs) +def returnn_config_generator( + variant: ConfigVariant, train_data_config: dict, dev_data_config: dict, num_subepochs: int, **kwargs +) -> ReturnnConfig: + model_config = conformer_ctc.get_default_config_v3(num_outputs=num_outputs) extra_config = { "train": train_data_config, "dev": dev_data_config, + "max_seq_length": {"audio_features": 560000}, + "torch_amp": {"dtype": "bfloat16"}, } if variant == ConfigVariant.RECOG: + extra_config["extern_data"] = { + "sources": {"dim": 80, "dtype": "float32"}, + } extra_config["model_outputs"] = { "log_probs": { "dim": num_outputs, } } - extra_config["preload_from_files"] = { - "base": { - "init_for_train": True, - "filename": tk.Path( - "/work/asr4/berger/sisyphus_work_dirs/tedlium2/20230602_rescale_baselines/i6_core/returnn/training/ReturnnTrainingJob.yEnOhxiP8CgO/output/models/epoch.250.pt" - ), - } - } - return get_returnn_config( num_epochs=num_subepochs, - num_inputs=50, + num_inputs=1, num_outputs=num_outputs, target="classes", extra_python=[conformer_ctc.get_serializer(model_config, variant=variant)], extern_data_config=True, backend=Backend.PYTORCH, - grad_noise=0.0, + grad_noise=kwargs.get("grad_noise", 0.0), grad_clip=0.0, optimizer=Optimizers.AdamW, schedule=LearningRateSchedules.OCLR, max_seqs=60, - # initial_lr=2.2e-05, - # peak_lr=2.2e-04, - peak_lr=0.0, - # final_lr=1e-08, - batch_size=12000, - accum_grad=3, + initial_lr=7e-06, + peak_lr=7e-04, + decayed_lr=7e-05, + final_lr=1e-08, + batch_size=36000 * 160, use_chunking=False, extra_config=extra_config, ) @@ -82,16 +77,37 @@ def returnn_config_generator(variant: ConfigVariant, train_data_config: dict, de def get_returnn_config_collection( train_data_config: dict, dev_data_config: dict, + num_subepochs: int, + **kwargs, ) -> ReturnnConfigs[ReturnnConfig]: - generator_kwargs = {"train_data_config": train_data_config, "dev_data_config": dev_data_config} return ReturnnConfigs( - train_config=returnn_config_generator(variant=ConfigVariant.TRAIN, **generator_kwargs), - prior_config=returnn_config_generator(variant=ConfigVariant.PRIOR, **generator_kwargs), - recog_configs={"recog": returnn_config_generator(variant=ConfigVariant.RECOG, **generator_kwargs)}, + train_config=returnn_config_generator( + variant=ConfigVariant.TRAIN, + train_data_config=train_data_config, + dev_data_config=dev_data_config, + num_subepochs=num_subepochs, + **kwargs, + ), + prior_config=returnn_config_generator( + variant=ConfigVariant.PRIOR, + train_data_config=train_data_config, + dev_data_config=dev_data_config, + num_subepochs=num_subepochs, + **kwargs, + ), + recog_configs={ + "recog": returnn_config_generator( + variant=ConfigVariant.RECOG, + train_data_config=train_data_config, + dev_data_config=dev_data_config, + num_subepochs=num_subepochs, + **kwargs, + ) + }, ) -def run_exp() -> SummaryReport: +def run_exp(num_subepochs: int = 250) -> SummaryReport: assert tools.returnn_root assert tools.returnn_python_exe assert tools.rasr_binary_path @@ -101,28 +117,27 @@ def run_exp() -> SummaryReport: returnn_python_exe=tools.returnn_python_exe, rasr_binary_path=tools.rasr_binary_path, augmented_lexicon=True, - feature_type=FeatureType.GAMMATONE_16K, + feature_type=FeatureType.SAMPLES, ) + for data_input in data.data_inputs.values(): + data_input.create_lm_images(tools.rasr_binary_path) + # ********** Step args ********** - train_args = exp_args.get_ctc_train_step_args(num_epochs=num_subepochs) + train_args = exp_args.get_ctc_train_step_args(num_epochs=num_subepochs, gpu_mem_rqmt=24) recog_args = exp_args.get_ctc_recog_step_args( num_classes=num_outputs, - # epochs=[160, num_subepochs], - epochs=[1], + epochs=[ep for ep in [80, 160, 320, 640, 1280, num_subepochs] if ep <= num_subepochs], prior_scales=[0.5], lm_scales=[1.1], - feature_type=FeatureType.GAMMATONE_16K, + feature_type=FeatureType.SAMPLES, search_stats=True, + seq2seq_v2=True, ) # ********** System ********** - # tools.returnn_root = tk.Path("/u/berger/repositories/MiniReturnn") - # tools.rasr_binary_path = tk.Path( - # "/u/berger/repositories/rasr_versions/gen_seq2seq_onnx_apptainer/arch/linux-x86_64-standard" - # ) system = ReturnnSeq2SeqSystem(tools) system.init_corpora( @@ -135,9 +150,16 @@ def run_exp() -> SummaryReport: # ********** Returnn Configs ********** - system.add_experiment_configs( - "Conformer_CTC", get_returnn_config_collection(data.train_data_config, data.cv_data_config) - ) + for grad_noise in [0.0, 0.1]: + system.add_experiment_configs( + f"Conformer_CTC_{num_subepochs}-epochs_gn-{grad_noise}", + get_returnn_config_collection( + train_data_config=data.train_data_config, + dev_data_config=data.cv_data_config, + num_subepochs=num_subepochs, + grad_noise=grad_noise, + ), + ) system.run_train_step(**train_args) system.run_dev_recog_step(**recog_args) @@ -152,7 +174,9 @@ def py() -> SummaryReport: summary_report = SummaryReport() - summary_report.merge_report(run_exp(), update_structure=True) + summary_report.merge_report(run_exp(num_subepochs=250), update_structure=True) + summary_report.merge_report(run_exp(num_subepochs=500), update_structure=True) + summary_report.merge_report(run_exp(num_subepochs=1000), update_structure=True) tk.register_report(f"{gs.ALIAS_AND_OUTPUT_SUBDIR}/summary.report", summary_report) diff --git a/users/berger/configs/tedlium2/20230602_rescale_baselines/config_01b_conformer_ctc_logmel.py b/users/berger/configs/tedlium2/20230602_rescale_baselines/config_01b_conformer_ctc_logmel.py deleted file mode 100644 index 2e62a39cb..000000000 --- a/users/berger/configs/tedlium2/20230602_rescale_baselines/config_01b_conformer_ctc_logmel.py +++ /dev/null @@ -1,197 +0,0 @@ -import copy -import os -from typing import Any, Dict, Optional -from i6_core.returnn.config import ReturnnConfig - -from sisyphus import gs, tk - -import i6_core.rasr as rasr -from i6_experiments.users.berger.args.experiments import ctc as exp_args -from i6_experiments.users.berger.args.returnn.config import get_returnn_config, Backend -from i6_experiments.users.berger.args.returnn.learning_rates import LearningRateSchedules, Optimizers -from i6_experiments.users.berger.corpus.tedlium2.ctc_data import get_tedlium2_data_dumped_labels -from i6_experiments.users.berger.pytorch.models import conformer_ctc -from i6_experiments.users.berger.recipe.summary.report import SummaryReport -from i6_experiments.users.berger.systems.dataclasses import ConfigVariant, FeatureType, ReturnnConfigs -from i6_experiments.users.berger.systems.returnn_native_system import ReturnnNativeSystem -from i6_experiments.users.berger.util import default_tools_v2 -from i6_experiments.users.berger.systems.functors.recognition.returnn_search import LexiconType, LmType, VocabType - -# ********** Settings ********** - -rasr.flow.FlowNetwork.default_flags = {"cache_mode": "task_dependent"} - -num_outputs = 79 -num_subepochs = 250 - -tools = copy.deepcopy(default_tools_v2) - -# ********** Return Config generators ********** - - -def returnn_config_generator( - *, - variant: ConfigVariant, - train_data_config: dict, - dev_data_config: dict, - forward_data_config: Optional[dict] = None, - **kwargs, -) -> ReturnnConfig: - model_config = conformer_ctc.get_default_config_v3(num_outputs=num_outputs) - - extra_config = { - "train": train_data_config, - "dev": dev_data_config, - "torch_amp": {"dtype": "bfloat16"}, - } - - if variant == ConfigVariant.TRAIN: - extra_config["max_seq_length"] = {"audio_features": 560000} - - if variant == ConfigVariant.PRIOR: - extra_config = {"forward_data": train_data_config} - - if variant == ConfigVariant.RECOG: - assert forward_data_config is not None - extra_config = { - "forward_data": forward_data_config, - "model_outputs": { - "tokens": { - "dtype": "string", - "feature_dim_axis": None, - } - }, - } - - return get_returnn_config( - num_epochs=num_subepochs, - num_inputs=1, - num_outputs=num_outputs, - target="classes" if variant != ConfigVariant.RECOG else None, - extra_python=[ - conformer_ctc.get_serializer( - model_config, variant=variant, recog_type=conformer_ctc.RecogType.FLASHLIGHT, **kwargs - ) - ], - extern_data_config=True, - backend=Backend.PYTORCH, - grad_noise=0.0, - grad_clip=0.0, - optimizer=Optimizers.AdamW, - schedule=LearningRateSchedules.OCLR, - max_seqs=60, - initial_lr=7e-06, - peak_lr=7e-04, - decayed_lr=7e-05, - final_lr=1e-08, - batch_size=360 * 16000, - use_chunking=False, - extra_config=extra_config, - ) - - -def get_returnn_config_collection( - *, recog_variations: Optional[Dict[str, Any]] = None, forward_data_configs: dict, **kwargs -) -> ReturnnConfigs[ReturnnConfig]: - if recog_variations is None: - return ReturnnConfigs( - train_config=returnn_config_generator(variant=ConfigVariant.TRAIN, **kwargs), - prior_config=returnn_config_generator(variant=ConfigVariant.PRIOR, **kwargs), - recog_configs={ - f"recog_{key}": returnn_config_generator( - variant=ConfigVariant.RECOG, forward_data_config=forward_data_config, **kwargs - ) - for key, forward_data_config in forward_data_configs.items() - }, - ) - else: - return ReturnnConfigs( - train_config=returnn_config_generator(variant=ConfigVariant.TRAIN, **kwargs), - prior_config=returnn_config_generator(variant=ConfigVariant.PRIOR, **kwargs), - recog_configs={ - f"recog_{key}_{variation_name}": returnn_config_generator( - variant=ConfigVariant.RECOG, forward_data_config=forward_data_config, **variation_kwargs, **kwargs - ) - for key, forward_data_config in forward_data_configs.items() - for variation_name, variation_kwargs in recog_variations.items() - }, - ) - - -def run_exp() -> SummaryReport: - assert tools.returnn_root - assert tools.returnn_python_exe - assert tools.rasr_binary_path - data = get_tedlium2_data_dumped_labels( - num_classes=num_outputs, - returnn_root=tools.returnn_root, - returnn_python_exe=tools.returnn_python_exe, - rasr_binary_path=tools.rasr_binary_path, - augmented_lexicon=True, - feature_type=FeatureType.SAMPLES, - ) - - # ********** Step args ********** - - train_args = exp_args.get_ctc_train_step_args(num_epochs=num_subepochs, gpu_mem_rqmt=24) - recog_args = { - "epochs": [num_subepochs], - "lm_scales": [2.0], - "prior_scales": [0.5], - "lexicon_type": LexiconType.FLASHLIGHT, - "vocab_type": VocabType.RETURNN, - "lm_type": LmType.ARPA_FILE, - } - # ********** System ********** - - system = ReturnnNativeSystem(tools) - - system.init_corpora( - dev_keys=data.dev_keys, - test_keys=data.test_keys, - corpus_data=data.data_inputs, - am_args=exp_args.ctc_recog_am_args, - ) - system.setup_scoring() - - # ********** Returnn Configs ********** - - system.add_experiment_configs( - "Conformer_CTC_logmel", - get_returnn_config_collection( - train_data_config=data.train_data_config, - dev_data_config=data.cv_data_config, - forward_data_configs=data.forward_data_config, - beam_size=64, - beam_threshold=14.0, - ), - ) - - system.run_train_step(**train_args) - - system.run_dev_recog_step( - recog_exp_names={ - exp_name: [ - recog_exp_name for recog_exp_name in system.get_recog_exp_names()[exp_name] if dev_key in recog_exp_name - ] - for dev_key in data.dev_keys - for exp_name in system.get_exp_names() - }, - **recog_args, - ) - - assert system.summary_report - return system.summary_report - - -def py() -> SummaryReport: - filename_handle = os.path.splitext(os.path.basename(__file__))[0][len("config_") :] - gs.ALIAS_AND_OUTPUT_SUBDIR = f"{filename_handle}/" - - summary_report = SummaryReport() - - summary_report.merge_report(run_exp(), update_structure=True) - - tk.register_report(f"{gs.ALIAS_AND_OUTPUT_SUBDIR}/summary.report", summary_report) - - return summary_report diff --git a/users/berger/configs/tedlium2/20230602_rescale_baselines/config_04a_conformer_transducer_bpe.py b/users/berger/configs/tedlium2/20230602_rescale_baselines/config_04a_conformer_transducer_bpe.py index 301506b5c..d9610a62d 100644 --- a/users/berger/configs/tedlium2/20230602_rescale_baselines/config_04a_conformer_transducer_bpe.py +++ b/users/berger/configs/tedlium2/20230602_rescale_baselines/config_04a_conformer_transducer_bpe.py @@ -133,7 +133,7 @@ def run_exp() -> SummaryReport: train_args = exp_args.get_transducer_train_step_args(num_epochs=num_subepochs, gpu_mem_rqmt=24) recog_args = { - "epochs": [20, 40, 80, 160, 320, 500], + "epochs": [500], "prior_scales": [0.0], "lm_scales": [0.0], "lexicon_type": LexiconType.BLISS, diff --git a/users/berger/configs/tedlium2/20230602_rescale_baselines/config_04b_conformer_transducer_phon.py b/users/berger/configs/tedlium2/20230602_rescale_baselines/config_04b_conformer_transducer_phon.py index b6c026453..637357823 100644 --- a/users/berger/configs/tedlium2/20230602_rescale_baselines/config_04b_conformer_transducer_phon.py +++ b/users/berger/configs/tedlium2/20230602_rescale_baselines/config_04b_conformer_transducer_phon.py @@ -24,7 +24,7 @@ rasr.flow.FlowNetwork.default_flags = {"cache_mode": "task_dependent"} num_outputs = 79 -num_subepochs = 500 +num_subepochs = 1000 tools = copy.deepcopy(default_tools_v2) tools.rasr_binary_path = tk.Path("/u/berger/repositories/rasr_versions/gen_seq2seq_dev/arch/linux-x86_64-standard") @@ -61,10 +61,11 @@ def returnn_config_generator( optimizer=Optimizers.AdamW, schedule=LearningRateSchedules.OCLR, initial_lr=1e-06, - peak_lr=8e-05, + peak_lr=kwargs.get("peak_lr", 8e-05), decayed_lr=1e-05, final_lr=1e-08, - batch_size=10000 * 160, + batch_size=15000 * 160, + accum_grad=2, use_chunking=False, extra_config=extra_config, ) @@ -173,6 +174,7 @@ def run_exp() -> SummaryReport: label_scorer_type="onnx-ffnn-transducer", label_scorer_args={"extra_args": {"start_label_index": 0}}, reduction_subtrahend=3, + # reduction_subtrahend=0, reduction_factor=4, feature_type=FeatureType.LOGMEL_16K, ) @@ -206,13 +208,15 @@ def run_exp() -> SummaryReport: # ********** Returnn Configs ********** - system.add_experiment_configs( - "Conformer_Transducer", - get_returnn_config_collection( - data.train_data_config, - data.cv_data_config, - ), - ) + for peak_lr in [8e-06, 1e-05, 4e-05, 8e-05]: + system.add_experiment_configs( + f"Conformer_Transducer_lr-{peak_lr}", + get_returnn_config_collection( + data.train_data_config, + data.cv_data_config, + peak_lr=peak_lr, + ), + ) system.run_train_step(**train_args) diff --git a/users/berger/corpus/tedlium2/lm_data.py b/users/berger/corpus/tedlium2/lm_data.py index 6253f9830..63c54f87e 100644 --- a/users/berger/corpus/tedlium2/lm_data.py +++ b/users/berger/corpus/tedlium2/lm_data.py @@ -8,6 +8,8 @@ def get_lm(name: str) -> rasr_lm_config.LMData: ted_4gram = get_corpus_data_inputs()["dev"]["dev"].lm assert ted_4gram is not None - lm_dict["4gram"] = rasr_lm_config.ArpaLMData(filename=ted_4gram["filename"], scale=ted_4gram.get("scale", 1.0)) + lm_dict["4gram"] = rasr_lm_config.ArpaLMData( + filename=ted_4gram["filename"], scale=ted_4gram.get("scale", 1.0), lookahead_lm=None + ) return lm_dict[name] diff --git a/users/berger/pytorch/models/conformer_ctc.py b/users/berger/pytorch/models/conformer_ctc.py index 370bf4ea1..d85b144ee 100644 --- a/users/berger/pytorch/models/conformer_ctc.py +++ b/users/berger/pytorch/models/conformer_ctc.py @@ -322,17 +322,18 @@ def get_default_config_v3(num_outputs: int) -> ConformerCTCConfig: sample_rate=16000, win_size=0.025, hop_size=0.01, - min_amp=1e-10, + min_amp=1.175494e-38, num_filters=80, + alpha=0.97, ), ) specaugment = ModuleFactoryV1( module_class=SpecaugmentByLengthModuleV1, cfg=SpecaugmentByLengthConfigV1( - time_min_num_masks=2, + time_min_num_masks=1, time_max_mask_per_n_frames=25, time_mask_max_size=20, - freq_min_num_masks=2, + freq_min_num_masks=1, freq_max_num_masks=16, freq_mask_max_size=5, ), diff --git a/users/berger/pytorch/models/conformer_transducer_v2.py b/users/berger/pytorch/models/conformer_transducer_v2.py index 32ab9d10f..9df3af6c5 100644 --- a/users/berger/pytorch/models/conformer_transducer_v2.py +++ b/users/berger/pytorch/models/conformer_transducer_v2.py @@ -47,7 +47,6 @@ def forward( with torch.no_grad(): sources = sources.squeeze(-1) x, source_lengths = self.feature_extraction(sources, source_lengths) - print("Features: ", x[0, :3, :5]) sequence_mask = lengths_to_padding_mask(source_lengths) x = self.specaugment(x) # [B, T, F] diff --git a/users/berger/recipe/recognition/generic_seq2seq_search.py b/users/berger/recipe/recognition/generic_seq2seq_search.py index 4ed1f4177..34cc1da5e 100644 --- a/users/berger/recipe/recognition/generic_seq2seq_search.py +++ b/users/berger/recipe/recognition/generic_seq2seq_search.py @@ -1,17 +1,13 @@ __all__ = ["GenericSeq2SeqLmImageAndGlobalCacheJob", "GenericSeq2SeqSearchJob"] -from typing import List, Optional, Tuple from sisyphus import * -assert __package__ is not None Path = setup_path(__package__) import shutil import copy from i6_core import rasr, util -from i6_core.lm.lm_image import CreateLmImageJob -from i6_experiments.users.berger.recipe.rasr.label_tree_and_scorer import LabelTree, LabelScorer class GenericSeq2SeqLmImageAndGlobalCacheJob(rasr.RasrCommand, Job): @@ -88,15 +84,13 @@ def find_arpa_lms(cls, config): lookahead_lm_config = config.flf_lattice_tool.network.recognizer.recognizer.lookahead_lm if separate_lookahead_lm: if lookahead_lm_config.type == "ARPA" and lookahead_lm_config._get("image") is None: - pass - # result.append(lookahead_lm_config) + result.append(lookahead_lm_config) # recombination lm # separate_recombination_lm = config.flf_lattice_tool.network.recognizer.recognizer.separate_recombination_lm recombination_lm_config = config.flf_lattice_tool.network.recognizer.recognizer.recombination_lm if separate_recombination_lm: if recombination_lm_config.type == "ARPA" and recombination_lm_config._get("image") is None: - pass - # result.append(recombination_lm_config) + result.append(recombination_lm_config) return result @classmethod @@ -174,8 +168,8 @@ def create_config( # lm images # arpa_lms = cls.find_arpa_lms(config) - for i, lm_config in enumerate(arpa_lms, start=1): - lm_config.image = f"lm-{i}.image" + for i, lm_config in enumerate(arpa_lms): + lm_config.image = "lm-%d.image" % (i + 1) # global cache # config.flf_lattice_tool.global_cache.file = "global.cache" @@ -191,171 +185,42 @@ def hash(cls, kwargs): return super().hash({"config": config, "exe": sprint_exe}) -class BuildGenericSeq2SeqGlobalCacheJob(rasr.RasrCommand, Job): - """ - Standalone job to create the global-cache for generic-seq2seq-tree-search - """ - - def __init__( - self, - crp: rasr.CommonRasrParameters, - label_tree: LabelTree, - label_scorer: LabelScorer, - extra_config: Optional[rasr.RasrConfig] = None, - extra_post_config: Optional[rasr.RasrConfig] = None, - ): - """ - :param crp: common RASR params (required: lexicon, acoustic_model, language_model, recognizer) - :param label_tree: label tree object for structuring the search tree - :param label_scorer: label scorer object for score computation - :param extra_config: overlay config that influences the Job's hash - :param extra_post_config: overlay config that does not influences the Job's hash - """ - self.set_vis_name("Build Global Cache") - - (self.config, self.post_config,) = BuildGenericSeq2SeqGlobalCacheJob.create_config( - crp=crp, - label_tree=label_tree, - label_scorer=label_scorer, - extra_config=extra_config, - extra_post_config=extra_post_config, - ) - - self.exe = self.select_exe(crp.speech_recognizer_exe, "speech-recognizer") - - self.out_log_file = self.log_file_output_path("build_global_cache", crp, False) - self.out_global_cache = self.output_path("global.cache", cached=True) - - self.rqmt = {"time": 1, "cpu": 1, "mem": 2} - - def tasks(self): - yield Task("create_files", mini_task=True) - yield Task("run", resume="run", rqmt=self.rqmt) - - def create_files(self): - self.write_config(self.config, self.post_config, "build_global_cache.config") - self.write_run_script(self.exe, "build_global_cache.config") - - def run(self): - self.run_script(1, self.out_log_file) - shutil.move("global.cache", self.out_global_cache.get_path()) - - @classmethod - def create_config( - cls, - crp: rasr.CommonRasrParameters, - label_tree: LabelTree, - label_scorer: LabelScorer, - extra_config: Optional[rasr.RasrConfig], - extra_post_config: Optional[rasr.RasrConfig], - ): - config, post_config = rasr.build_config_from_mapping( - crp, - { - "lexicon": "speech-recognizer.model-combination.lexicon", - "acoustic_model": "speech-recognizer.model-combination.acoustic-model", - "language_model": "speech-recognizer.model-combination.lm", - "recognizer": "speech-recognizer.recognizer", - }, - ) - - # Apply config from label tree - label_tree.apply_config( - "speech-recognizer.recognizer.label-tree", - config, - post_config, - ) - - # Optional lexicon overwrite - if label_tree.lexicon_config is not None: - config["speech-recognizer.model-combination.lexicon"]._update(label_tree.lexicon_config) - - # Apply config from label scorer and eliminate unnecessary arguments that don't affect the search space (scale, prior) - label_scorer_reduced = LabelScorer( - scorer_type=label_scorer.scorer_type, - scale=1.0, - label_file=label_scorer.label_file, - num_classes=label_scorer.num_classes, - use_prior=False, - extra_args=label_scorer.extra_args, - ) - - label_scorer_reduced.apply_config("speech-recognizer.recognizer.label-scorer", config, post_config) - - # skip conventional AM or load it without GMM # - if crp.acoustic_model_config is None: - config.speech_recognizer.recognizer.use_acoustic_model = False - else: - config.speech_recognizer.recognizer.use_mixture = False - if config.flf_lattice_tool.network.recognizer.acoustic_model._get("length") is not None: - del config.flf_lattice_tool.network.recognizer.acoustic_model["length"] - - # disable scaling - if config.flf_lattice_tool.network.recognizer.lm._get("scale") is not None: - del config.flf_lattice_tool.network.recognizer.lm["scale"] - - config.speech_recognizer.recognition_mode = "init-only" - config.speech_recognizer.search_type = "generic-seq2seq-tree-search" - config.speech_recognizer.global_cache.file = "global.cache" - config.speech_recognizer.global_cache.read_only = False - - config._update(extra_config) - post_config._update(extra_post_config) - - return config, post_config - - @classmethod - def hash(cls, kwargs): - config, _ = cls.create_config(**kwargs) - return super().hash({"config": config, "exe": kwargs["crp"].speech_recognizer_exe}) - - class GenericSeq2SeqSearchJob(rasr.RasrCommand, Job): __sis_hash_exclude__ = {"num_threads": None} def __init__( self, - crp: rasr.CommonRasrParameters, - feature_flow: rasr.FlowNetwork, - label_tree: LabelTree, - label_scorer: LabelScorer, - rasr_exe: Optional[tk.Path] = None, - search_parameters: Optional[dict] = None, - lm_lookahead: bool = True, - lookahead_options: Optional[dict] = None, - eval_single_best: bool = True, - eval_best_in_lattice: bool = True, - use_gpu: bool = False, - global_cache: Optional[tk.Path] = None, - rtf: float = 2, - mem: float = 8, - extra_config: Optional[rasr.RasrConfig] = None, - extra_post_config: Optional[rasr.RasrConfig] = None, - num_threads: int = 2, - ): + crp, + feature_flow, + label_tree, + label_scorer, + search_parameters=None, + lm_lookahead=True, + lookahead_options=None, + eval_single_best=True, + eval_best_in_lattice=True, + use_gpu=False, + rtf=2, + mem=8, + hard_rqmt=False, + extra_config=None, + extra_post_config=None, + sprint_exe=None, # allow separat executable than default settings + lm_gc_job=None, + lm_gc_job_local=False, + lm_gc_job_mem=16, + lm_gc_job_default_search=False, + num_threads=None, + ): # TODO set this to true later self.set_vis_name("Generic Seq2Seq Search") + kwargs = locals() + del kwargs["self"] - self.config, self.post_config = GenericSeq2SeqSearchJob.create_config( - crp=crp, - feature_flow=feature_flow, - label_tree=label_tree, - label_scorer=label_scorer, - search_parameters=search_parameters, - lm_lookahead=lm_lookahead, - lookahead_options=lookahead_options, - eval_single_best=eval_single_best, - eval_best_in_lattice=eval_best_in_lattice, - extra_config=extra_config, - extra_post_config=extra_post_config, - global_cache=global_cache, - ) + self.config, self.post_config = GenericSeq2SeqSearchJob.create_config(**kwargs) self.feature_flow = feature_flow - if rasr_exe is not None: - self.rasr_exe = rasr_exe - else: - self.rasr_exe = crp.flf_tool_exe - assert self.rasr_exe is not None - + if sprint_exe is None: + sprint_exe = crp.flf_tool_exe + self.exe = self.select_exe(sprint_exe, "flf-tool") self.concurrent = crp.concurrent self.use_gpu = use_gpu self.num_threads = num_threads @@ -372,15 +237,21 @@ def __init__( ) self.rqmt = { - "time": max(crp.corpus_duration * rtf / crp.concurrent, 24), - "cpu": num_threads, + "time": max(crp.corpus_duration * rtf / crp.concurrent, 4.5), + "cpu": 2, "gpu": 1 if self.use_gpu else 0, "mem": mem, } + # no automatic resume with doubled rqmt + self.hard_rqmt = hard_rqmt def tasks(self): yield Task("create_files", mini_task=True) - yield Task("run", resume="run", rqmt=self.rqmt, args=range(1, self.concurrent + 1)) + if self.hard_rqmt: # TODO + resume = None + else: + resume = "run" + yield Task("run", resume=resume, rqmt=self.rqmt, args=range(1, self.concurrent + 1)) def create_files(self): self.write_config(self.config, self.post_config, "recognition.config") @@ -390,10 +261,16 @@ def create_files(self): # sometimes crash without this if not self.use_gpu: extra_code += "\nexport CUDA_VISIBLE_DEVICES=" + if self.num_threads is None: + extra_code += "\nexport OMP_NUM_THREADS=%i" % self.rqmt["cpu"] + else: + extra_code += f"\nexport OMP_NUM_THREADS={self.num_threads}" + extra_code += f"\nexport MKL_NUM_THREADS={self.num_threads}" + self.write_run_script(self.exe, "recognition.config", extra_code=extra_code) - extra_code += f"\nexport OMP_NUM_THREADS={self.num_threads}" - extra_code += f"\nexport MKL_NUM_THREADS={self.num_threads}" - self.write_run_script(self.rasr_exe, "recognition.config", extra_code=extra_code) + # TODO maybe not needed + def stop_run(self, task_id): + print("run job %d exceeds specified rqmt and stoped" % task_id) def run(self, task_id): self.run_script(task_id, self.out_log_file[task_id]) @@ -402,50 +279,45 @@ def run(self, task_id): self.out_single_lattice_caches[task_id].get_path(), ) - @classmethod - def find_arpa_lms( - cls, lm_config: rasr.RasrConfig, lm_post_config: Optional[rasr.RasrConfig] = None - ) -> List[Tuple[rasr.RasrConfig, Optional[rasr.RasrConfig]]]: - result = [] - - if lm_config.type == "ARPA": - result.append((lm_config, lm_post_config)) - elif lm_config.type == "combine": - for i in range(1, lm_config.num_lms + 1): - sub_lm_config = lm_config["lm-%d" % i] - sub_lm_post_config = lm_post_config["lm-%d" % i] if lm_post_config is not None else None - result += cls.find_arpa_lms(sub_lm_config, sub_lm_post_config) - - return result - - @classmethod - def find_arpa_lms_without_image( - cls, lm_config: rasr.RasrConfig, lm_post_config: Optional[rasr.RasrConfig] = None - ) -> List[Tuple[rasr.RasrConfig, Optional[rasr.RasrConfig]]]: - def has_image(c, pc): - res = c._get("image") is not None - res = res or (pc is not None and pc._get("image") is not None) - return res - - return [(c, pc) for c, pc in cls.find_arpa_lms(lm_config, lm_post_config) if not has_image(c, pc)] + def cleanup_before_run(self, cmd, retry, task_id, *args): + util.backup_if_exists("recognition.log.%d" % task_id) + util.delete_if_exists("lattice.cache.%d" % task_id) @classmethod def create_config( cls, - crp: rasr.CommonRasrParameters, - feature_flow: rasr.FlowNetwork, - label_tree: LabelTree, - label_scorer: LabelScorer, - search_parameters: Optional[dict] = None, - lm_lookahead: bool = True, - lookahead_options: Optional[dict] = None, - eval_single_best: bool = True, - eval_best_in_lattice: bool = True, - extra_config: Optional[rasr.RasrConfig] = None, - extra_post_config: Optional[rasr.RasrConfig] = None, - global_cache: Optional[tk.Path] = None, - **_, + crp, + feature_flow, + label_tree, + label_scorer, + search_parameters=None, + lm_lookahead=True, + lookahead_options=None, + eval_single_best=True, + eval_best_in_lattice=True, + extra_config=None, + extra_post_config=None, + sprint_exe=None, + lm_gc_job=None, + lm_gc_job_local=True, + lm_gc_job_mem=6, + lm_gc_job_default_search=False, + **kwargs, ): + # optional individual lm-image and global-cache job # + if lm_gc_job is None: + lm_gc_job = GenericSeq2SeqLmImageAndGlobalCacheJob( + crp, + label_tree, + label_scorer, + extra_config, + extra_post_config, + mem=lm_gc_job_mem, + local_job=lm_gc_job_local, + sprint_exe=sprint_exe, + default_search=lm_gc_job_default_search, + ) + # get config from csp # config, post_config = rasr.build_config_from_mapping( crp, @@ -459,8 +331,8 @@ def create_config( parallelize=True, ) - # acoustic model maybe used for allophones and state-tying, but no mixture is needed - # skip conventional AM or load it without GMM + # acoustic model maybe used for allophones and state-tying, but no mixture is needed # + # skip conventional AM or load it without GMM # if crp.acoustic_model_config is None: config.flf_lattice_tool.network.recognizer.use_acoustic_model = False else: @@ -470,17 +342,14 @@ def create_config( config.flf_lattice_tool.network.recognizer.feature_extraction.file = "feature.flow" if feature_flow.outputs != {"features"}: assert len(feature_flow.outputs) == 1, "not implemented otherwise" - config.flf_lattice_tool.network.recognizer.feature_extraction.main_port_name = next( - iter(feature_flow.outputs) - ) - + config.flf_lattice_tool.network.recognizer.feature_extraction.main_port_name = list(feature_flow.outputs)[0] feature_flow.apply_config( "flf-lattice-tool.network.recognizer.feature-extraction", config, post_config, ) - # label tree and optional lexicon overwrite + # label tree and optional lexicon overwrite # label_tree.apply_config( "flf-lattice-tool.network.recognizer.recognizer.label-tree", config, @@ -489,15 +358,14 @@ def create_config( if label_tree.lexicon_config is not None: config["flf-lattice-tool.lexicon"]._update(label_tree.lexicon_config) - # label scorer + # label scorer # label_scorer.apply_config("flf-lattice-tool.network.recognizer.label-scorer", config, post_config) # search settings # search_config = rasr.RasrConfig() if search_parameters is not None: - for key, val in search_parameters.items(): - search_config[key.replace("_", "-")] = val - + for key in search_parameters.keys(): + search_config[key] = search_parameters[key] config.flf_lattice_tool.network.recognizer.recognizer._update(search_config) # lookahead settings # @@ -509,23 +377,26 @@ def create_config( if lookahead_options is not None: la_opts.update(lookahead_options) - config.flf_lattice_tool.network.recognizer.recognizer.optimize_lattice = True - - la_config = rasr.RasrConfig() - la_config._value = lm_lookahead - + config.flf_lattice_tool.network.recognizer.recognizer.lm_lookahead = rasr.RasrConfig() + config.flf_lattice_tool.network.recognizer.recognizer.lm_lookahead._value = lm_lookahead if "laziness" in la_opts: config.flf_lattice_tool.network.recognizer.recognizer.lm_lookahead_laziness = la_opts["laziness"] - + config.flf_lattice_tool.network.recognizer.recognizer.optimize_lattice = True if lm_lookahead: if "history_limit" in la_opts: - la_config.history_limit = la_opts["history_limit"] + config.flf_lattice_tool.network.recognizer.recognizer.lm_lookahead.history_limit = la_opts[ + "history_limit" + ] if "tree_cutoff" in la_opts: - la_config.tree_cutoff = la_opts["tree_cutoff"] + config.flf_lattice_tool.network.recognizer.recognizer.lm_lookahead.tree_cutoff = la_opts["tree_cutoff"] if "minimum_representation" in la_opts: - la_config.minimum_representation = la_opts["minimum_representation"] + config.flf_lattice_tool.network.recognizer.recognizer.lm_lookahead.minimum_representation = la_opts[ + "minimum_representation" + ] if "lm_lookahead_scale" in la_opts: - la_config.lm_lookahead_scale = la_opts["lm_lookahead_scale"] + config.flf_lattice_tool.network.recognizer.recognizer.lm_lookahead.lm_lookahead_scale = la_opts[ + "lm_lookahead_scale" + ] if "cache_low" in la_opts: post_config.flf_lattice_tool.network.recognizer.recognizer.lm_lookahead.cache_size_low = la_opts[ "cache_low" @@ -535,8 +406,6 @@ def create_config( "cache_high" ] - config.flf_lattice_tool.network.recognizer.recognizer.lm_lookahead = la_config - # flf network # config.flf_lattice_tool.network.initial_nodes = "segment" config.flf_lattice_tool.network.segment.type = "speech-segment" @@ -574,46 +443,32 @@ def create_config( post_config.flf_lattice_tool.network.sink.error_on_empty_lattice = False post_config["*"].output_channel.unbuffered = True - # image and cache # - no_image_arpa_lms = GenericSeq2SeqSearchJob.find_arpa_lms_without_image( - lm_config=config.flf_lattice_tool.network.recognizer.lm - ) - if config.flf_lattice_tool.network.recognizer.recognizer._get("lookahead-lm") is not None: - no_image_arpa_lms += GenericSeq2SeqSearchJob.find_arpa_lms_without_image( - lm_config=config.flf_lattice_tool.network.recognizer.recognizer.lookahead_lm - ) - - for lm_config, lm_post_config in no_image_arpa_lms: - rp = rasr.CommonRasrParameters(base=crp) - rp.language_model_config = lm_config - rp.language_model_post_config = lm_post_config - lm_config.image = CreateLmImageJob(crp=rp, mem=8).out_image - - if global_cache is None: - global_cache = BuildGenericSeq2SeqGlobalCacheJob( - crp=crp, label_tree=label_tree, label_scorer=label_scorer - ).out_global_cache - - post_config.flf_lattice_tool.global_cache.read_only = True - post_config.flf_lattice_tool.global_cache.file = global_cache - # update parameters # config._update(extra_config) post_config._update(extra_post_config) - + + # image and cache # + arpa_lms = GenericSeq2SeqLmImageAndGlobalCacheJob.find_arpa_lms(config) + assert len(arpa_lms) == lm_gc_job.num_images, "mismatch between image-cache config and recognition config" + for i, lm_config in enumerate(arpa_lms): + lm_config.image = lm_gc_job.lm_images[i + 1] + + if post_config.flf_lattice_tool.global_cache._get("file") is None: + post_config.flf_lattice_tool.global_cache.read_only = True + post_config.flf_lattice_tool.global_cache.file = lm_gc_job.global_cache + return config, post_config @classmethod def hash(cls, kwargs): - config, _ = cls.create_config(**kwargs) - if kwargs["rasr_exe"] is not None: - rasr_exe = kwargs["rasr_exe"] - else: - rasr_exe = kwargs["crp"].flf_tool_exe + config, post_config = cls.create_config(**kwargs) + sprint_exe = kwargs["sprint_exe"] + if sprint_exe is None: + sprint_exe = kwargs["crp"].flf_tool_exe return super().hash( { "config": config, "feature_flow": kwargs["feature_flow"], - "exe": rasr_exe, + "exe": sprint_exe, } ) From 8a418d2127c33a7670554eac065386e2e18be302 Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Fri, 24 May 2024 14:03:40 +0200 Subject: [PATCH 058/227] more --- .../exp2024_04_23_baselines/ctc.py | 27 +++++++++++++++++++ 1 file changed, 27 insertions(+) diff --git a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py index 480eefcd1..1b07cc885 100644 --- a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py +++ b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py @@ -30,6 +30,33 @@ def py(): + train_exp( + f"v6-bhv20-11gb-f32-bs15k-accgrad1-mgpu4-pavg100-wd1e_4-lrlin1e_5_295k-bpe10k", + config_11gb_v6_f32_accgrad1_mgpu4_pavg100_wd1e_4, + config_updates={ + **_get_cfg_lrlin_oclr_by_bs_nep(15_000, 500), + }, + ) + + train_exp( + f"v6-bhv20-11gb-f32-bs15k-accgrad1-mgpu4-pavg100-wd1e_2-lrlin1e_5_295k-bpe10k", + config_11gb_v6_f32_accgrad1_mgpu4_pavg100_wd1e_4, + config_updates={ + **_get_cfg_lrlin_oclr_by_bs_nep(15_000, 500), + "optimizer.weight_decay": 1e-2, + }, + ) + + train_exp( + f"v6-bhv20-11gb-f32-bs15k-accgrad1-mgpu4-pavg100-wd1e_4-lrlin1e_5_295k-speedpertV2-bpe10k", + config_11gb_v6_f32_accgrad1_mgpu4_pavg100_wd1e_4, + config_updates={ + **_get_cfg_lrlin_oclr_by_bs_nep(15_000, 500), + "__train_audio_preprocess": speed_pert_librosa_config, + "speed_pert_discrete_values": [0.7, 0.8, 0.9, 1.0, 1.1], + }, + ) + for vocab in [ "spm20k", "bpe10k", # 8.23 From ce494fe4bc52cb2c0831412e69b37315dc2baab1 Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Fri, 24 May 2024 15:02:50 +0000 Subject: [PATCH 059/227] update --- .../tedlium2/configs/ebranch_baseline.py | 14 +-- .../tedlium2/configs/ted2_att_baseline.py | 94 ++++++++++--------- 2 files changed, 53 insertions(+), 55 deletions(-) diff --git a/users/zeineldeen/experiments/conformer_att_2023/tedlium2/configs/ebranch_baseline.py b/users/zeineldeen/experiments/conformer_att_2023/tedlium2/configs/ebranch_baseline.py index b8c368eeb..c65fa8c26 100644 --- a/users/zeineldeen/experiments/conformer_att_2023/tedlium2/configs/ebranch_baseline.py +++ b/users/zeineldeen/experiments/conformer_att_2023/tedlium2/configs/ebranch_baseline.py @@ -995,17 +995,6 @@ def get_base_v1_args(lr, ep, enc_drop=0.1, pretrain_reps=3, use_legacy_stats=Tru args["encoder_args"].num_blocks = num_blocks - args["with_pretrain"] = False - specaug_steps = {"step0": 12_000, "step1": 18_000, "step2": 24_000} - args["specaug_str_func_opts"] = { - "version": 2, - **specaug_steps, - "max_time_num": 100, - "max_time_dim": 20, - "min_num_add_factor": 0, - "freq_dim_factor": 5, - } - args["encoder_args"].frontend_conv_weight_dropout = weight_drop args["encoder_args"].mhsa_weight_dropout = weight_drop args["encoder_args"].ff_weight_dropout = weight_drop @@ -1014,6 +1003,9 @@ def get_base_v1_args(lr, ep, enc_drop=0.1, pretrain_reps=3, use_legacy_stats=Tru args["decoder_args"].embed_dim = target_embed_dim args["decoder_args"].att_dropout = dec_att_drop + args["batch_size"] = 10_000 * 160 + args["accum_grad"] = 3 + exp_name += f"_weightDrop{weight_drop}_decAttDrop{dec_att_drop}_embedDim{target_embed_dim}_numBlocks{num_blocks}" if ctc_scale != 1.0: diff --git a/users/zeineldeen/experiments/conformer_att_2023/tedlium2/configs/ted2_att_baseline.py b/users/zeineldeen/experiments/conformer_att_2023/tedlium2/configs/ted2_att_baseline.py index c8c13e602..ae8d5256a 100644 --- a/users/zeineldeen/experiments/conformer_att_2023/tedlium2/configs/ted2_att_baseline.py +++ b/users/zeineldeen/experiments/conformer_att_2023/tedlium2/configs/ted2_att_baseline.py @@ -1270,55 +1270,61 @@ def get_base_v1_args(lr, ep, enc_drop=0.1, pretrain_reps=3, use_legacy_stats=Tru # TODO: multi-gpu for num_blocks in [12]: for ep in [50 * 4]: - for lr in [8e-4, 16e-4]: + for lr in [8e-4, 13e-4, 16e-4]: for target_embed_dim in [256]: for att_drop in [0.0]: for weight_drop in [0.1]: for enc_drop in [0.15]: for ctc_scale in [0.3]: - for sync_step in [50]: - base_v1_args, exp_name = get_base_v1_args( - lr, ep, enc_drop=enc_drop, use_legacy_stats=False - ) - - args = copy.deepcopy(base_v1_args) - args["encoder_args"].num_blocks = num_blocks - args["encoder_args"].mhsa_weight_dropout = weight_drop - args["encoder_args"].ff_weight_dropout = weight_drop - args["encoder_args"].conv_weight_dropout = weight_drop - - args["decoder_args"].embed_dim = target_embed_dim - args["decoder_args"].att_dropout = att_drop - - args["horovod_params"] = { - "horovod_reduce_type": "param", - "horovod_param_sync_step": sync_step, - "horovod_dataset_distribution": "random_seed_offset", - } - - args["batch_size"] = 15_000 * 160 - args["accum_grad"] = 1 - gradient_clip_global_norm = 1 - args["gradient_clip_global_norm"] = gradient_clip_global_norm - - exp_name += f"_weightDrop{weight_drop}_decAttDrop{att_drop}_embedDim{target_embed_dim}_numBlocks{num_blocks}" - exp_name += f"_gradClipNorm{gradient_clip_global_norm}" - exp_name += f"_paramSync_step{sync_step}_accum1" - - if ctc_scale != 1.0: - args["encoder_args"].ctc_loss_scale = ctc_scale - args["decoder_args"].ce_loss_scale = 1.0 - ctc_scale - exp_name += f"_ctcScale{ctc_scale}" - - run_exp( - exp_name + "_gpu4", - args, - num_epochs=ep, - epoch_wise_filter=None, - bpe_size=BPE_1K, - partition_epoch=4 * 4, - horovod_num_processes=4, - ) + for sync_step in [100]: + for grad_clip in [None, 1.0, 5.0]: + if grad_clip is None and lr != 8e-4: + continue + + base_v1_args, exp_name = get_base_v1_args( + lr, ep, enc_drop=enc_drop, use_legacy_stats=False + ) + + args = copy.deepcopy(base_v1_args) + args["encoder_args"].num_blocks = num_blocks + args["encoder_args"].mhsa_weight_dropout = weight_drop + args["encoder_args"].ff_weight_dropout = weight_drop + args["encoder_args"].conv_weight_dropout = weight_drop + + args["decoder_args"].embed_dim = target_embed_dim + args["decoder_args"].att_dropout = att_drop + + args["horovod_params"] = { + "horovod_reduce_type": "param", + "horovod_param_sync_step": sync_step, + "horovod_dataset_distribution": "random_seed_offset", + } + + args["batch_size"] = 15_000 * 160 + args["pretrain_opts"]["initial_batch_size"] = 15_000 * 160 + args["accum_grad"] = 1 + + exp_name += f"_weightDrop{weight_drop}_decAttDrop{att_drop}_embedDim{target_embed_dim}_numBlocks{num_blocks}" + if grad_clip: + args["gradient_clip_global_norm"] = grad_clip + exp_name += f"_gradClipNorm{grad_clip}" + + exp_name += f"_paramSync_step{sync_step}_accum1" + + if ctc_scale != 1.0: + args["encoder_args"].ctc_loss_scale = ctc_scale + args["decoder_args"].ce_loss_scale = 1.0 - ctc_scale + exp_name += f"_ctcScale{ctc_scale}" + + run_exp( + exp_name + "_gpu4", + args, + num_epochs=ep, + epoch_wise_filter=None, + bpe_size=BPE_1K, + partition_epoch=4 * 4, + horovod_num_processes=4, + ) # # TODO: mixup # for num_blocks in [12]: From 46ad433ee79ed8ea1bf3f2d662e046999a165291 Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Fri, 24 May 2024 15:28:23 +0000 Subject: [PATCH 060/227] update --- .../tedlium2/configs/ted2_att_baseline.py | 33 +++++++++++++++++++ 1 file changed, 33 insertions(+) diff --git a/users/zeineldeen/experiments/conformer_att_2023/tedlium2/configs/ted2_att_baseline.py b/users/zeineldeen/experiments/conformer_att_2023/tedlium2/configs/ted2_att_baseline.py index ae8d5256a..3c9f21f2c 100644 --- a/users/zeineldeen/experiments/conformer_att_2023/tedlium2/configs/ted2_att_baseline.py +++ b/users/zeineldeen/experiments/conformer_att_2023/tedlium2/configs/ted2_att_baseline.py @@ -1267,7 +1267,40 @@ def get_base_v1_args(lr, ep, enc_drop=0.1, pretrain_reps=3, use_legacy_stats=Tru partition_epoch=4, ) + if ctc_scale == 0.3: + args_ = copy.deepcopy(args) + args_["with_pretrain"] = False + specaug_steps = {"step0": 10_000, "step1": 15_000, "step2": 20_000} + args_["specaug_str_func_opts"] = { + "version": 2, + **specaug_steps, + "max_time_num": 100, + "max_time_dim": 20, + "min_num_add_factor": 0, + "freq_dim_factor": 5, + } + run_exp( + exp_name + "_woPretrain", + args_, + num_epochs=ep, + epoch_wise_filter=[(1, 2, 400), (3, 4, 800)], + bpe_size=BPE_1K, + partition_epoch=4, + ) + args_["encoder_args"].with_ctc = False + run_exp( + exp_name + "_woPretrain_noCTC", + args_, + num_epochs=ep, + epoch_wise_filter=[(1, 2, 400), (3, 4, 800)], + bpe_size=BPE_1K, + partition_epoch=4, + ) + # TODO: multi-gpu + # base_bpe1000_peakLR0.0016_ep200_globalNorm_epochOCLR_pre3_fixZoneout_encDrop0.15_woDepthConvPre_weightDrop0.1_decAttDrop0.0_embedDim256_numBlocks12_gradClipNorm5.0_paramSync_step100_accum1_ctcScale0.3_gpu4 + # 8.66 7.97 avg + for num_blocks in [12]: for ep in [50 * 4]: for lr in [8e-4, 13e-4, 16e-4]: From df85a5fd09238d38f43ae7f9f3923ec0e3b3e4b7 Mon Sep 17 00:00:00 2001 From: Simon Berger Date: Sun, 26 May 2024 01:45:14 +0200 Subject: [PATCH 061/227] Update users/berger --- users/berger/args/returnn/learning_rates.py | 56 +++++++++++++++++ .../20230602_rescale_baselines/__init__.py | 1 + .../config_01_conformer_ctc.py | 19 +++--- users/berger/pytorch/models/conformer_ctc.py | 63 ++++++++++++------- users/berger/pytorch/train_steps/ctc.py | 6 +- .../recognition/generic_seq2seq_search_v2.py | 24 +++---- users/berger/recipe/returnn/forward.py | 3 + users/berger/systems/functors/rasr_base.py | 1 + 8 files changed, 129 insertions(+), 44 deletions(-) diff --git a/users/berger/args/returnn/learning_rates.py b/users/berger/args/returnn/learning_rates.py index a03c5aaff..9845dce64 100644 --- a/users/berger/args/returnn/learning_rates.py +++ b/users/berger/args/returnn/learning_rates.py @@ -10,6 +10,7 @@ class LearningRateSchedules(Enum): NewbobAbs = auto() OCLR = auto() OCLR_STEP = auto() + OCLR_STEP_TORCH = auto() CONST_DECAY = auto() CONST_DECAY_STEP = auto() @@ -38,6 +39,8 @@ def get_learning_rate_config( config.update(get_oclr_config(**kwargs)) elif schedule == LearningRateSchedules.OCLR_STEP: extra_python.append(get_oclr_function(**kwargs)) + elif schedule == LearningRateSchedules.OCLR_STEP_TORCH: + extra_python.append(get_oclr_function_torch(**kwargs)) elif schedule == LearningRateSchedules.CONST_DECAY: config.update(get_const_decay_config(**kwargs)) elif schedule == LearningRateSchedules.CONST_DECAY_STEP: @@ -153,6 +156,7 @@ def get_oclr_function( **kwargs, ) -> str: initial_lr = initial_lr or peak_lr / 10 + decayed_lr = decayed_lr or initial_lr final_lr = final_lr or initial_lr / 5 cycle_epoch = cycle_epoch or (num_epochs * 9) // 20 # 45% of the training @@ -184,6 +188,58 @@ def get_oclr_function( ) +def get_oclr_function_torch( + num_epochs: int, + n_steps_per_epoch: int, + peak_lr: float = 1e-03, + inc_epochs: Optional[int] = None, + dec_epochs: Optional[int] = None, + initial_lr: Optional[float] = None, + decayed_lr: Optional[float] = None, + final_lr: Optional[float] = None, + **kwargs, +) -> str: + initial_lr = initial_lr or peak_lr / 10 + decayed_lr = decayed_lr or initial_lr + final_lr = final_lr or initial_lr / 5 + inc_epochs = inc_epochs or (num_epochs * 9) // 20 + dec_epochs = dec_epochs or inc_epochs + + return dedent( + f"""def dynamic_learning_rate(*, global_train_step: int, **_): + # Increase linearly from initial_lr to peak_lr over the first inc_epoch epochs + # Decrease linearly from peak_lr to decayed_lr over the next dec_epoch epochs + # Decrease linearly from decayed_lr to final_lr over the remaining epochs + initial_lr = {initial_lr} + peak_lr = {peak_lr} + decayed_lr = {decayed_lr} + final_lr = {final_lr} + inc_epochs = {inc_epochs} + dec_epochs = {dec_epochs} + total_epochs = {num_epochs} + n_steps_per_epoch = {n_steps_per_epoch} + + # -- derived -- # + steps_increase = inc_epochs * n_steps_per_epoch + steps_decay = dec_epochs * n_steps_per_epoch + steps_final = (total_epochs - inc_epochs - dec_epochs) * n_steps_per_epoch + + step_size_increase = (peak_lr - initial_lr) / steps_increase + step_size_decay = (peak_lr - decayed_lr) / steps_decay + step_size_final = (decayed_lr - final_lr) / steps_final + + if global_train_step <= steps_increase: + return initial_lr + step_size_increase * global_train_step + if global_train_step <= steps_increase + steps_decay: + return peak_lr - step_size_decay * (global_train_step - steps_increase) + + return max( + decayed_lr - step_size_final * (global_train_step - steps_increase - steps_decay), + final_lr + )""" + ) + + def get_const_decay_config( num_epochs: int, const_lr: float = 1e-03, diff --git a/users/berger/configs/tedlium2/20230602_rescale_baselines/__init__.py b/users/berger/configs/tedlium2/20230602_rescale_baselines/__init__.py index d8ebae699..a6c351e5a 100644 --- a/users/berger/configs/tedlium2/20230602_rescale_baselines/__init__.py +++ b/users/berger/configs/tedlium2/20230602_rescale_baselines/__init__.py @@ -19,6 +19,7 @@ def worker_wrapper(job, task_name, call): "AdvancedTreeSearchLmImageAndGlobalCacheJob", "FeatureExtractionJob", "GenericSeq2SeqSearchJob", + "GenericSeq2SeqSearchJobV2", "GenericSeq2SeqLmImageAndGlobalCacheJob", "CreateLmImageJob", "BuildGenericSeq2SeqGlobalCacheJob", diff --git a/users/berger/configs/tedlium2/20230602_rescale_baselines/config_01_conformer_ctc.py b/users/berger/configs/tedlium2/20230602_rescale_baselines/config_01_conformer_ctc.py index c9513483b..7420c202f 100644 --- a/users/berger/configs/tedlium2/20230602_rescale_baselines/config_01_conformer_ctc.py +++ b/users/berger/configs/tedlium2/20230602_rescale_baselines/config_01_conformer_ctc.py @@ -1,5 +1,6 @@ import copy import os +from i6_models.config import ModuleFactoryV1 from i6_core.returnn.config import ReturnnConfig from sisyphus import gs, tk @@ -16,6 +17,7 @@ ReturnnSeq2SeqSystem, ) from i6_experiments.users.berger.util import default_tools_v2 +from i6_experiments.users.berger.pytorch.custom_parts.identity import IdentityConfig, IdentityModule # ********** Settings ********** @@ -38,18 +40,20 @@ def returnn_config_generator( extra_config = { "train": train_data_config, "dev": dev_data_config, - "max_seq_length": {"audio_features": 560000}, - "torch_amp": {"dtype": "bfloat16"}, } + if variant == ConfigVariant.TRAIN: + extra_config["max_seq_length"] = {"audio_features": 560000} + extra_config["torch_amp"] = {"dtype": "bfloat16"} if variant == ConfigVariant.RECOG: extra_config["extern_data"] = { - "sources": {"dim": 80, "dtype": "float32"}, + "data": {"dim": 80, "dtype": "float32"}, } extra_config["model_outputs"] = { "log_probs": { "dim": num_outputs, } } + model_config.feature_extraction = ModuleFactoryV1(IdentityModule, IdentityConfig()) return get_returnn_config( num_epochs=num_subepochs, @@ -62,12 +66,13 @@ def returnn_config_generator( grad_noise=kwargs.get("grad_noise", 0.0), grad_clip=0.0, optimizer=Optimizers.AdamW, - schedule=LearningRateSchedules.OCLR, + schedule=LearningRateSchedules.OCLR_STEP_TORCH, max_seqs=60, initial_lr=7e-06, peak_lr=7e-04, decayed_lr=7e-05, final_lr=1e-08, + n_steps_per_epoch=480, batch_size=36000 * 160, use_chunking=False, extra_config=extra_config, @@ -129,9 +134,9 @@ def run_exp(num_subepochs: int = 250) -> SummaryReport: recog_args = exp_args.get_ctc_recog_step_args( num_classes=num_outputs, epochs=[ep for ep in [80, 160, 320, 640, 1280, num_subepochs] if ep <= num_subepochs], - prior_scales=[0.5], - lm_scales=[1.1], - feature_type=FeatureType.SAMPLES, + prior_scales=[0.3, 0.5, 0.7], + lm_scales=[0.7, 0.9, 1.1, 1.3], + feature_type=FeatureType.LOGMEL_16K, search_stats=True, seq2seq_v2=True, ) diff --git a/users/berger/pytorch/models/conformer_ctc.py b/users/berger/pytorch/models/conformer_ctc.py index d85b144ee..7becad467 100644 --- a/users/berger/pytorch/models/conformer_ctc.py +++ b/users/berger/pytorch/models/conformer_ctc.py @@ -13,6 +13,7 @@ RasrCompatibleLogMelFeatureExtractionV1, RasrCompatibleLogMelFeatureExtractionV1Config, ) +from i6_models.parts.frontend.vgg_act import VGG4LayerActFrontendV1, VGG4LayerActFrontendV1Config from i6_models.parts.frontend.generic_frontend import ( GenericFrontendV1, GenericFrontendV1Config, @@ -330,36 +331,56 @@ def get_default_config_v3(num_outputs: int) -> ConformerCTCConfig: specaugment = ModuleFactoryV1( module_class=SpecaugmentByLengthModuleV1, cfg=SpecaugmentByLengthConfigV1( - time_min_num_masks=1, + time_min_num_masks=2, time_max_mask_per_n_frames=25, time_mask_max_size=20, - freq_min_num_masks=1, + freq_min_num_masks=2, freq_max_num_masks=16, freq_mask_max_size=5, ), ) + # frontend = ModuleFactoryV1( + # GenericFrontendV1, + # GenericFrontendV1Config( + # in_features=80, + # layer_ordering=[ + # FrontendLayerType.Conv2d, + # FrontendLayerType.Conv2d, + # FrontendLayerType.Pool2d, + # FrontendLayerType.Conv2d, + # FrontendLayerType.Conv2d, + # FrontendLayerType.Pool2d, + # FrontendLayerType.Activation, + # ], + # conv_kernel_sizes=[(3, 3), (3, 3), (3, 3), (3, 3)], + # conv_paddings=None, + # conv_out_dims=[32, 64, 64, 32], + # conv_strides=[(1, 1), (1, 1), (1, 1), (1, 1)], + # pool_kernel_sizes=[(2, 1), (2, 1)], + # pool_strides=None, + # pool_paddings=None, + # activations=[torch.nn.ReLU()], + # out_features=384, + # ), + # ) frontend = ModuleFactoryV1( - GenericFrontendV1, - GenericFrontendV1Config( + VGG4LayerActFrontendV1, + VGG4LayerActFrontendV1Config( in_features=80, - layer_ordering=[ - FrontendLayerType.Conv2d, - FrontendLayerType.Conv2d, - FrontendLayerType.Pool2d, - FrontendLayerType.Conv2d, - FrontendLayerType.Conv2d, - FrontendLayerType.Pool2d, - FrontendLayerType.Activation, - ], - conv_kernel_sizes=[(3, 3), (3, 3), (3, 3), (3, 3)], - conv_paddings=None, - conv_out_dims=[32, 64, 64, 32], - conv_strides=[(1, 1), (1, 1), (1, 1), (1, 1)], - pool_kernel_sizes=[(2, 1), (2, 1)], - pool_strides=None, - pool_paddings=None, - activations=[torch.nn.ReLU()], + conv1_channels=32, + conv2_channels=64, + conv3_channels=64, + conv4_channels=32, + conv_kernel_size=(3, 3), + conv_padding=None, + pool1_kernel_size=(2, 1), + pool1_stride=(2, 1), + pool1_padding=None, + pool2_kernel_size=(2, 1), + pool2_stride=(2, 1), + pool2_padding=None, + activation=torch.nn.ReLU(), out_features=384, ), ) diff --git a/users/berger/pytorch/train_steps/ctc.py b/users/berger/pytorch/train_steps/ctc.py index 932fb0276..4e1419607 100644 --- a/users/berger/pytorch/train_steps/ctc.py +++ b/users/berger/pytorch/train_steps/ctc.py @@ -1,12 +1,10 @@ import torch from returnn.tensor.tensor_dict import TensorDict -from ..helper_functions import map_tensor_to_minus1_plus1_interval def train_step(*, model: torch.nn.Module, extern_data: TensorDict, **_): - audio_features = extern_data["data"].raw_tensor + audio_features = extern_data["data"].raw_tensor.float() audio_features = audio_features.squeeze(-1) - audio_features = map_tensor_to_minus1_plus1_interval(audio_features) assert extern_data["data"].dims[1].dyn_size_ext is not None audio_features_len = extern_data["data"].dims[1].dyn_size_ext.raw_tensor @@ -37,8 +35,8 @@ def train_step(*, model: torch.nn.Module, extern_data: TensorDict, **_): zero_infinity=True, ) - from returnn.tensor import batch_dim import returnn.frontend as rf + from returnn.tensor import batch_dim rf.get_run_ctx().mark_as_loss( name="CTC", loss=loss, custom_inv_norm_factor=rf.reduce_sum(targets_len_rf, axis=batch_dim) diff --git a/users/berger/recipe/recognition/generic_seq2seq_search_v2.py b/users/berger/recipe/recognition/generic_seq2seq_search_v2.py index c469f615d..134b9c0d9 100644 --- a/users/berger/recipe/recognition/generic_seq2seq_search_v2.py +++ b/users/berger/recipe/recognition/generic_seq2seq_search_v2.py @@ -102,17 +102,8 @@ def create_config( if label_tree.lexicon_config is not None: config["flf-lattice-tool.lexicon"]._update(label_tree.lexicon_config) - # Apply config from label scorer and eliminate unnecessary arguments that don't affect the search space (scale, prior) - label_scorer_reduced = LabelScorer( - scorer_type=label_scorer.scorer_type, - scale=1.0, - label_file=label_scorer.label_file, - num_classes=label_scorer.num_classes, - use_prior=False, - extra_args={key: val for key, val in label_scorer.extra_args.items() if key != "first-order"}, - ) - - label_scorer_reduced.apply_config("flf-lattice-tool.network.recognizer.label-scorer", config, post_config) + # Apply config from label scorer + label_scorer.apply_config("flf-lattice-tool.network.recognizer.label-scorer", config, post_config) # search settings # search_config = rasr.RasrConfig() @@ -415,8 +406,17 @@ def create_config( post_config["*"].output_channel.unbuffered = True if global_cache is None: + # Eliminate unnecessary arguments that don't affect the search space (scale, prior) + label_scorer_reduced = LabelScorer( + scorer_type=label_scorer.scorer_type, + scale=1.0, + label_file=label_scorer.label_file, + num_classes=label_scorer.num_classes, + use_prior=False, + extra_args={key: val for key, val in label_scorer.extra_args.items() if key != "first-order"}, + ) global_cache = BuildGenericSeq2SeqGlobalCacheJob( - crp=crp, label_tree=label_tree, label_scorer=label_scorer + crp=crp, label_tree=label_tree, label_scorer=label_scorer_reduced ).out_global_cache post_config.flf_lattice_tool.global_cache.read_only = True diff --git a/users/berger/recipe/returnn/forward.py b/users/berger/recipe/returnn/forward.py index 03493bba0..69f867f16 100644 --- a/users/berger/recipe/returnn/forward.py +++ b/users/berger/recipe/returnn/forward.py @@ -75,6 +75,9 @@ def run(self): self.out_returnn_config_file.get_path(), ] ) + util.shutil.move("prior.txt", self.out_prior_txt_file.get_path()) + util.shutil.move("prior.xml", self.out_prior_xml_file.get_path()) + util.shutil.move("prior.png", self.out_prior_png_file.get_path()) @classmethod def create_returnn_config( diff --git a/users/berger/systems/functors/rasr_base.py b/users/berger/systems/functors/rasr_base.py index b14fac1dd..7915f0717 100644 --- a/users/berger/systems/functors/rasr_base.py +++ b/users/berger/systems/functors/rasr_base.py @@ -266,6 +266,7 @@ def _get_prior_file( returnn_config=prior_config, returnn_root=self.returnn_root, returnn_python_exe=self.returnn_python_exe, + mem_rqmt=8, ) return forward_job.out_prior_xml_file else: From fe595759d1cbe0460ad529510acedf4948517d77 Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Sat, 25 May 2024 23:18:11 +0200 Subject: [PATCH 062/227] more --- users/zeyer/experiments/exp2024_04_23_baselines/ctc.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py index 1b07cc885..41be5f7af 100644 --- a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py +++ b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py @@ -98,7 +98,8 @@ def py(): ) for alpha in [ - 0.3, + # 0.3, # very bad? + 0.7, ]: train_exp( "v6-bhv20-11gb-f32-bs15k-accgrad1-mgpu4-pavg100-wd1e_2-lrlin1e_5_295k-speedpertV2-spm_bpe10k" From fde3754e772f5c7d63528ac524405ff45284a3cd Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Mon, 27 May 2024 09:27:01 +0200 Subject: [PATCH 063/227] more --- users/zeyer/experiments/exp2024_04_23_baselines/aed.py | 6 +++--- users/zeyer/experiments/exp2024_04_23_baselines/ctc.py | 4 ++-- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/users/zeyer/experiments/exp2024_04_23_baselines/aed.py b/users/zeyer/experiments/exp2024_04_23_baselines/aed.py index 941f3086a..115e4f2c9 100644 --- a/users/zeyer/experiments/exp2024_04_23_baselines/aed.py +++ b/users/zeyer/experiments/exp2024_04_23_baselines/aed.py @@ -90,11 +90,11 @@ def py(): # alpha=0.1 seems too aggressive for AED, bad convergence for alpha in [ 0.3, # 5.26 - 0.5, - 0.6, + 0.5, # 5.13 + 0.6, # 5.13 0.7, # 4.98 (!!) 0.8, - 0.9, + 0.9, # 5.18 1.0, # sanity check ]: train_exp( diff --git a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py index 41be5f7af..4403ca6a0 100644 --- a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py +++ b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py @@ -58,7 +58,7 @@ def py(): ) for vocab in [ - "spm20k", + "spm20k", # 7.44 "bpe10k", # 8.23 "spm10k", # 8.12 "spm_bpe10k", # 7.97 @@ -81,7 +81,7 @@ def py(): for alpha in [ 0.3, # 7.88 0.5, - 0.7, + 0.7, # 6.99 ]: train_exp( "v6-bhv20-11gb-f32-bs15k-accgrad1-mgpu4-pavg100-wd1e_2-lrlin1e_5_295k-speedpertV2-spm10k" From 1d3a6263fc15a6abe8bac395bd662cd5151e5132 Mon Sep 17 00:00:00 2001 From: schmitt Date: Thu, 23 May 2024 15:51:53 +0200 Subject: [PATCH 064/227] update --- .../returnn/network_builder_rf/segmental/recog.py | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/recog.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/recog.py index 730e67383..dfdf2a8c3 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/recog.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/recog.py @@ -223,8 +223,6 @@ def model_recog( emit_log_prob = rf.log(rf.sigmoid(blank_logits)) emit_log_prob = rf.squeeze(emit_log_prob, axis=emit_log_prob.feature_dim) blank_log_prob = rf.log(rf.sigmoid(-blank_logits)) - # update blank decoder state - blank_decoder_state = tree.map_structure(lambda s: rf.gather(s, indices=backrefs), blank_decoder_state) # ------------------- combination ------------------- @@ -259,10 +257,15 @@ def model_recog( # mask for updating label-sync states update_state_mask = rf.convert_to_tensor(target != model.blank_idx) + # ------------------- update blank decoder state ------------------- + + if not model.use_joint_model: + blank_decoder_state = tree.map_structure(lambda s: rf.gather(s, indices=backrefs), blank_decoder_state) + # ------------------- update label decoder state ------------------- if model.use_joint_model: - label_decoder_state = tree.map_structure(lambda s: rf.gather(s, indices=backrefs), label_decoder_state) + label_decoder_state = tree.map_structure(lambda s: rf.gather(s, indices=backrefs), label_decoder_state_updated) else: def _get_masked_state(old, new, mask): old = rf.gather(old, indices=backrefs, axis=old_beam_dim) From 29d467ad10cbe4d3658db0be4b66c1ddf9c86d3c Mon Sep 17 00:00:00 2001 From: schmitt Date: Tue, 28 May 2024 10:36:54 +0200 Subject: [PATCH 065/227] update --- .../notes/commands | 2 +- .../global_vs_segmental_2022_23/train_new.py | 5 +- .../returnn/config_builder_rf/base.py | 70 +++--- .../returnn/network_builder_rf/base.py | 44 +++- .../network_builder_rf/global_/decoder.py | 65 ++++- .../network_builder_rf/global_/model.py | 31 ++- .../network_builder_rf/global_/train.py | 101 ++++++-- .../network_builder_rf/segmental/model.py | 51 ++-- .../segmental/model_new/blank_model/train.py | 15 ++ .../segmental/model_new/label_model/model.py | 91 ++++--- .../segmental/model_new/label_model/train.py | 237 +++++++++++++++--- .../network_builder_rf/segmental/recog.py | 25 +- .../network_builder_rf/segmental/train.py | 228 ++++++++++++++--- .../network_builder_rf/segmental/utils.py | 10 +- .../center_window_att/baseline_v1/__init__.py | 4 +- .../center_window_att/baseline_v1/baseline.py | 9 +- .../center_window_att/baseline_v3/__init__.py | 40 ++- .../center_window_att/baseline_v3/baseline.py | 9 +- .../center_window_att/baseline_v4/__init__.py | 22 +- .../center_window_att/baseline_v4/baseline.py | 13 +- .../center_window_att/config_builder.py | 17 +- .../center_window_att/train.py | 46 +++- .../global_att/baseline_v1/__init__.py | 77 ++++-- .../global_att/baseline_v1/baseline.py | 47 +++- .../pipeline_ls_conf/global_att/train.py | 51 ++-- 25 files changed, 1021 insertions(+), 289 deletions(-) diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/notes/commands b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/notes/commands index 1b134a42f..0e7d139c5 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/notes/commands +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/notes/commands @@ -1,4 +1,4 @@ -apptainer shell -B /work/asr4 -B /work/asr3 -B /work/common -B /work/tools -B /u/berger -B /u/zeineldeen -B /u/rossenbach -B /u/beck -B /work/speech/tuske -B /u/zeyer -B /u/schmitt -B /u/atanas.gruev -B /u/zhou +apptainer shell --nv -B /work/asr4 -B /work/asr3 -B /work/common -B /work/tools -B /u/berger -B /u/zeineldeen -B /u/rossenbach -B /u/beck -B /work/speech/tuske -B /u/zeyer -B /u/schmitt -B /u/atanas.gruev -B /u/zhou /work/asr4/berger/apptainer/images/i6_tensorflow-2.8_onnx-1.15.sif /work/asr4/berger/apptainer/images/i6_torch-2.2_onnx-1.16.sif export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/lib/python3.8/dist-packages/scipy/.libs \ No newline at end of file diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/train_new.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/train_new.py index e903aba56..4ca77a54c 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/train_new.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/train_new.py @@ -71,7 +71,10 @@ def run_train(self) -> Tuple[Dict[int, Checkpoint], Path, Path]: returnn_python_exe=config_builder.variant_params["returnn_python_exe"], returnn_root=config_builder.variant_params["returnn_root"], mem_rqmt=self.train_rqmt.get("mem", 24), - time_rqmt=self.train_rqmt.get("time", 30) + time_rqmt=self.train_rqmt.get("time", 30), + cpu_rqmt=self.train_rqmt.get("cpu", 4), + horovod_num_processes=self.train_rqmt.get("horovod_num_processes", None), + distributed_launch_cmd=self.train_rqmt.get("distributed_launch_cmd", "mpirun"), ) train_job.add_alias(self.alias) tk.register_output(train_job.get_one_alias() + "/models", train_job.out_model_dir) diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/config_builder_rf/base.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/config_builder_rf/base.py index b94dca43a..20af5a6d8 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/config_builder_rf/base.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/config_builder_rf/base.py @@ -31,6 +31,7 @@ def __init__( variant_params: Dict, model_def: ModelDef, get_model_func: Callable, + use_att_ctx_in_state: bool = True, ): self.variant_params = variant_params self.model_def = model_def @@ -45,18 +46,19 @@ def __init__( self.config_dict = dict( backend="torch", log_batch_size=True, - # truncation=-1, torch_log_memory_usage=True, debug_print_layer_output_template=True, max_seqs=200, - # gradient_clip=0.0, - # gradient_noise=0.0, optimizer={"class": "adamw", "epsilon": 1e-8, "weight_decay": 1e-6}, accum_grad_multiple_step=4, default_input="data", target="targets", ) + self.use_att_ctx_in_state = use_att_ctx_in_state + if not use_att_ctx_in_state: + self.config_dict["use_att_ctx_in_state"] = use_att_ctx_in_state + self.python_prolog = [] def get_train_config(self, opts: Dict): @@ -65,27 +67,12 @@ def get_train_config(self, opts: Dict): python_prolog = copy.deepcopy(self.python_prolog) python_epilog = copy.deepcopy(self.python_epilog) - dataset_opts = opts.get("dataset_opts", {}) + dataset_opts = opts.pop("dataset_opts", {}) config_dict.update(self.get_train_datasets(dataset_opts=dataset_opts)) extern_data_raw = self.get_extern_data_dict(dataset_opts) extern_data_raw = instanciate_delayed(extern_data_raw) - if opts.get("preload_from_files"): - config_dict["preload_from_files"] = opts["preload_from_files"] - elif opts.get("import_model_train_epoch1"): - config_dict.update({ - "import_model_train_epoch1": opts["import_model_train_epoch1"], - "load_ignore_missing_vars": True, - }) - - config_dict.update(dict( - batching=opts.get("batching", "laplace:.1000"), - aux_loss_layers=opts.get("aux_loss_layers", [4, 8]), - accum_grad_multiple_step=opts.get("accum_grad_multiple_step", config_dict["accum_grad_multiple_step"]), - optimizer=opts.get("optimizer", config_dict["optimizer"]), - )) - - if opts.get("dataset_opts", {}).get("use_speed_pert"): + if dataset_opts.pop("use_speed_pert", None): python_prolog += [ "import sys", 'sys.path.append("/work/asr4/zeineldeen/py_envs/py_3.10_tf_2.9/lib/python3.10/site-packages")' @@ -93,10 +80,22 @@ def get_train_config(self, opts: Dict): config_dict["speed_pert"] = speed_pert if opts.get("cleanup_old_models"): - post_config_dict["cleanup_old_models"] = opts["cleanup_old_models"] + post_config_dict["cleanup_old_models"] = opts.pop("cleanup_old_models") - config_dict.update(self.get_lr_settings(lr_opts=opts["lr_opts"], python_epilog=python_epilog)) - config_dict["batch_size"] = opts.get("batch_size", 15_000) * self.batch_size_factor + config_dict.update(self.get_lr_settings(lr_opts=opts.pop("lr_opts"), python_epilog=python_epilog)) + config_dict["batch_size"] = opts.pop("batch_size", 15_000) * self.batch_size_factor + + train_def = opts.pop("train_def") + train_step_func = opts.pop("train_step_func") + + remaining_opt_keys = [ + "aux_loss_layers", "preload_from_files", "accum_grad_multiple_step", "optimizer", "batching", + "torch_distributed", "pos_emb_dropout", "rf_att_dropout_broadcast", "grad_scaler", "gradient_clip_global_norm", + "spec_augment_steps", "torch_amp" + ] + config_dict.update( + {k: opts.pop(k) for k in remaining_opt_keys if k in opts} + ) python_epilog.append( serialization.Collection( @@ -107,8 +106,8 @@ def get_train_config(self, opts: Dict): ), *serialize_model_def(self.model_def), serialization.Import(self.get_model_func, import_as="get_model"), - serialization.Import(opts["train_def"], import_as="_train_def", ignore_import_as_for_hash=True), - serialization.Import(opts["train_step_func"], import_as="train_step"), + serialization.Import(train_def, import_as="_train_def", ignore_import_as_for_hash=True), + serialization.Import(train_step_func, import_as="train_step"), serialization.PythonEnlargeStackWorkaroundNonhashedCode, serialization.PythonCacheManagerFunctionNonhashedCode, serialization.PythonModelineNonhashedCode @@ -241,9 +240,9 @@ def get_lr_settings(self, lr_opts, python_epilog: Optional[List] = None): elif lr_opts["type"] == "dyn_lr_lin_warmup_invsqrt_decay": return dict( dynamic_learning_rate=dynamic_lr.dyn_lr_lin_warmup_invsqrt_decay, - learning_rate_warmup_steps=40_000, - learning_rate_invsqrt_norm=40_000, - learning_rate=2.5e-3, + learning_rate_warmup_steps=lr_opts["learning_rate_warmup_steps"], + learning_rate_invsqrt_norm=lr_opts["learning_rate_invsqrt_norm"], + learning_rate=lr_opts["learning_rate"], ) elif lr_opts["type"] == "const": const_lr = lr_opts["const_lr"] @@ -443,13 +442,20 @@ def batch_size_factor(self): class GlobalAttConfigBuilderRF(LibrispeechConformerConfigBuilderRF): - def __init__(self, **kwargs): + def __init__( + self, + use_weight_feedback: bool = True, + **kwargs + ): super(GlobalAttConfigBuilderRF, self).__init__(**kwargs) self.config_dict.update(dict( max_seq_length_default_target=75, )) + if not use_weight_feedback: + self.config_dict["use_weight_feedback"] = use_weight_feedback + def get_extern_data_dict(self, dataset_opts: Dict): extern_data_dict = super(GlobalAttConfigBuilderRF, self).get_extern_data_dict(dataset_opts) extern_data_dict["targets"]["vocab"] = { @@ -467,10 +473,10 @@ class SegmentalAttConfigBuilderRF(LibrispeechConformerConfigBuilderRF): def __init__( self, center_window_size: int, - label_decoder_version: int, blank_decoder_version: Optional[int] = None, use_joint_model: bool = False, use_weight_feedback: bool = True, + label_decoder_state: str = "nb-lstm", **kwargs ): super(SegmentalAttConfigBuilderRF, self).__init__(**kwargs) @@ -482,14 +488,14 @@ def __init__( if use_joint_model: assert not blank_decoder_version, "Either use joint model or separate label and blank model" - if label_decoder_version != 1: - self.config_dict["label_decoder_version"] = label_decoder_version if blank_decoder_version is not None and blank_decoder_version != 1: self.config_dict["blank_decoder_version"] = blank_decoder_version if use_joint_model: self.config_dict["use_joint_model"] = use_joint_model if not use_weight_feedback: self.config_dict["use_weight_feedback"] = use_weight_feedback + if label_decoder_state != "nb-lstm": + self.config_dict["label_decoder_state"] = label_decoder_state def get_train_config(self, opts: Dict): train_config = super(SegmentalAttConfigBuilderRF, self).get_train_config(opts) diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/base.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/base.py index c6f58441c..4151392f2 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/base.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/base.py @@ -23,6 +23,8 @@ def __init__( att_num_heads: Dim = Dim(name="att_num_heads", dimension=1), att_dropout: float = 0.1, l2: float = 0.0001, + use_weight_feedback: bool = True, + use_att_ctx_in_state: bool = True, ): super(BaseLabelDecoder, self).__init__() @@ -38,9 +40,8 @@ def __init__( self.target_embed = rf.Embedding(target_dim, Dim(name="target_embed", dimension=640)) - self.s = rf.ZoneoutLSTM( - self.target_embed.out_dim + att_num_heads * enc_out_dim, - Dim(name="lstm", dimension=1024), + zoneout_lstm_opts = dict( + out_dim=Dim(name="lstm", dimension=1024), zoneout_factor_cell=0.15, zoneout_factor_output=0.05, use_zoneout_output=False, # like RETURNN/TF ZoneoutLSTM old default @@ -49,12 +50,26 @@ def __init__( parts_order="jifo", # NativeLSTM (the code above converts it...) forget_bias=0.0, # the code above already adds it during conversion ) + self.use_att_ctx_in_state = use_att_ctx_in_state + if use_att_ctx_in_state: + self.s = rf.ZoneoutLSTM( + self.target_embed.out_dim + att_num_heads * enc_out_dim, + **zoneout_lstm_opts, + ) + else: + self.s_wo_att = rf.ZoneoutLSTM( + self.target_embed.out_dim, + **zoneout_lstm_opts, + ) - self.weight_feedback = rf.Linear(att_num_heads, enc_key_total_dim, with_bias=False) - self.s_transformed = rf.Linear(self.s.out_dim, enc_key_total_dim, with_bias=False) + self.use_weight_feedback = use_weight_feedback + if use_weight_feedback: + self.weight_feedback = rf.Linear(att_num_heads, enc_key_total_dim, with_bias=False) + + self.s_transformed = rf.Linear(self.get_lstm().out_dim, enc_key_total_dim, with_bias=False) self.energy = rf.Linear(enc_key_total_dim, att_num_heads, with_bias=False) self.readout_in = rf.Linear( - self.s.out_dim + self.target_embed.out_dim + att_num_heads * enc_out_dim, + self.get_lstm().out_dim + self.target_embed.out_dim + att_num_heads * enc_out_dim, Dim(name="readout", dimension=1024), ) self.output_prob = rf.Linear(self.readout_in.out_dim // 2, target_dim) @@ -66,3 +81,20 @@ def __init__( # Instead, it is intended to make a separate label scorer for it. self.language_model = None self.language_model_make_label_scorer = None + + def _update_state( + self, + input_embed: rf.Tensor, + prev_att: rf.Tensor, + prev_s_state: rf.LstmState, + ): + if self.use_att_ctx_in_state: + return self.s(rf.concat_features(input_embed, prev_att), state=prev_s_state, spatial_dim=single_step_dim) + else: + return self.s_wo_att(input_embed, state=prev_s_state, spatial_dim=single_step_dim) + + def get_lstm(self): + if self.use_att_ctx_in_state: + return self.s + else: + return self.s_wo_att diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/decoder.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/decoder.py index d55b163ae..6aed0ba96 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/decoder.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/decoder.py @@ -17,20 +17,23 @@ def __init__(self, eos_idx: int, **kwargs): def decoder_default_initial_state(self, *, batch_dims: Sequence[Dim], enc_spatial_dim: Dim) -> rf.State: """Default initial state""" state = rf.State( - s=self.s.default_initial_state(batch_dims=batch_dims), + s=self.get_lstm().default_initial_state(batch_dims=batch_dims), att=rf.zeros(list(batch_dims) + [self.att_num_heads * self.enc_out_dim]), - accum_att_weights=rf.zeros( - list(batch_dims) + [enc_spatial_dim, self.att_num_heads], feature_dim=self.att_num_heads - ), ) state.att.feature_dim_axis = len(state.att.dims) - 1 + + if self.use_weight_feedback: + state.accum_att_weights = rf.zeros( + list(batch_dims) + [enc_spatial_dim, self.att_num_heads], feature_dim=self.att_num_heads + ) + return state def loop_step_output_templates(self, batch_dims: List[Dim]) -> Dict[str, Tensor]: """loop step out""" return { "s": Tensor( - "s", dims=batch_dims + [self.s.out_dim], dtype=rf.get_default_float_dtype(), feature_dim_axis=-1 + "s", dims=batch_dims + [self.get_lstm().out_dim], dtype=rf.get_default_float_dtype(), feature_dim_axis=-1 ), "att": Tensor( "att", @@ -60,15 +63,22 @@ def loop_step( prev_att = state.att - s, state_.s = self.s(rf.concat_features(input_embed, prev_att), state=state.s, spatial_dim=single_step_dim) + # s, state_.s = self.s(rf.concat_features(input_embed, prev_att), state=state.s, spatial_dim=single_step_dim) + s, state_.s = self._update_state(input_embed, prev_att, state.s) + + if self.use_weight_feedback: + weight_feedback = self.weight_feedback(state.accum_att_weights) + else: + weight_feedback = rf.zeros((self.enc_key_total_dim,)) - weight_feedback = self.weight_feedback(state.accum_att_weights) s_transformed = self.s_transformed(s) energy_in = enc_ctx + weight_feedback + s_transformed energy = self.energy(rf.tanh(energy_in)) att_weights = rf.softmax(energy, axis=enc_spatial_dim) - state_.accum_att_weights = state.accum_att_weights + att_weights * inv_fertility * 0.5 + if self.use_weight_feedback: + state_.accum_att_weights = state.accum_att_weights + att_weights * inv_fertility * 0.5 + att0 = rf.dot(att_weights, enc, reduce=enc_spatial_dim, use_mask=False) att0.feature_dim = self.enc_out_dim att, _ = rf.merge_dims(att0, dims=(self.att_num_heads, self.enc_out_dim)) @@ -83,3 +93,42 @@ def decode_logits(self, *, s: Tensor, input_embed: Tensor, att: Tensor) -> Tenso readout = rf.dropout(readout, drop_prob=0.3, axis=self.dropout_broadcast and readout.feature_dim) logits = self.output_prob(readout) return logits + + +class GlobalAttEfficientDecoder(GlobalAttDecoder): + def __init__(self, **kwargs): + super(GlobalAttEfficientDecoder, self).__init__(**kwargs) + + assert not self.use_att_ctx_in_state and not self.use_weight_feedback, ( + "Cannot have alignment dependency for efficient implementation!" + ) + + def __call__( + self, + *, + enc: rf.Tensor, + enc_ctx: rf.Tensor, + enc_spatial_dim: Dim, + s: rf.Tensor, + ) -> rf.Tensor: + s_transformed = self.s_transformed(s) + + weight_feedback = rf.zeros((self.enc_key_total_dim,)) + + energy_in = enc_ctx + weight_feedback + s_transformed + energy = self.energy(rf.tanh(energy_in)) + att_weights = rf.softmax(energy, axis=enc_spatial_dim) + # we do not need use_mask because the softmax output is already padded with zeros + att0 = rf.dot(att_weights, enc, reduce=enc_spatial_dim, use_mask=False) + att0.feature_dim = self.enc_out_dim + att, _ = rf.merge_dims(att0, dims=(self.att_num_heads, self.enc_out_dim)) + + return att + + def decode_logits(self, *, s: Tensor, input_embed: Tensor, att: Tensor) -> Tensor: + """logits for the decoder""" + readout_in = self.readout_in(rf.concat_features(s, input_embed, att, allow_broadcast=True)) + readout = rf.reduce_out(readout_in, mode="max", num_pieces=2, out_dim=self.output_prob.in_dim) + readout = rf.dropout(readout, drop_prob=0.3, axis=self.dropout_broadcast and readout.feature_dim) + logits = self.output_prob(readout) + return logits diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/model.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/model.py index 0d4f54109..ed2961cd8 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/model.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/model.py @@ -5,7 +5,10 @@ import returnn.frontend as rf from i6_experiments.users.schmitt.returnn_frontend.model_interfaces.model import ModelDef -from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.global_.decoder import GlobalAttDecoder +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.global_.decoder import ( + GlobalAttDecoder, + GlobalAttEfficientDecoder +) from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.encoder.global_ import GlobalConformerEncoder from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.base import _batch_size_factor, _log_mel_feature_dim from i6_experiments.users.schmitt.returnn_frontend.model_interfaces.supports_label_scorer_torch import RFModelWithMakeLabelScorer @@ -31,6 +34,8 @@ def __init__( dec_att_num_heads: Dim = Dim(name="att_num_heads", dimension=1), enc_dropout: float = 0.1, eos_idx: int, + use_weight_feedback: bool = True, + use_att_ctx_in_state: bool = True, ): super(GlobalAttentionModel, self).__init__() @@ -51,7 +56,12 @@ def __init__( l2=l2, ) - self.label_decoder = GlobalAttDecoder( + if not use_weight_feedback and not use_att_ctx_in_state: + decoder_cls = GlobalAttEfficientDecoder + else: + decoder_cls = GlobalAttDecoder + + self.label_decoder = decoder_cls( enc_out_dim=self.encoder.out_dim, target_dim=target_dim, att_num_heads=dec_att_num_heads, @@ -60,6 +70,8 @@ def __init__( enc_key_total_dim=enc_key_total_dim, l2=l2, eos_idx=eos_idx, + use_weight_feedback=use_weight_feedback, + use_att_ctx_in_state=use_att_ctx_in_state, ) if language_model: @@ -101,6 +113,8 @@ def make_model( num_enc_layers: int = 12, pos_emb_dropout: float = 0.0, language_model: Optional[Dict[str, Any]] = None, + use_weight_feedback: bool = True, + use_att_ctx_in_state: bool = True, **extra, ) -> GlobalAttentionModel: """make""" @@ -140,6 +154,8 @@ def make_model( target_dim=target_dim, blank_idx=target_dim.dimension, language_model=lm, + use_weight_feedback=use_weight_feedback, + use_att_ctx_in_state=use_att_ctx_in_state, **extra, ) @@ -179,8 +195,17 @@ def from_scratch_model_def(*, epoch: int, in_dim: Dim, target_dim: Dim) -> Globa # real input is raw audio, internally it does logmel in_dim = Dim(name="logmel", dimension=_log_mel_feature_dim, kind=Dim.Types.Feature) lm_opts = config.typed_value("external_lm") + use_weight_feedback = config.bool("use_weight_feedback", True) + use_att_ctx_in_state = config.bool("use_att_ctx_in_state", True) + return MakeModel.make_model( - in_dim, target_dim, enc_aux_logits=enc_aux_logits or (), pos_emb_dropout=pos_emb_dropout, language_model=lm_opts + in_dim, + target_dim, + enc_aux_logits=enc_aux_logits or (), + pos_emb_dropout=pos_emb_dropout, + language_model=lm_opts, + use_weight_feedback=use_weight_feedback, + use_att_ctx_in_state=use_att_ctx_in_state, ) diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/train.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/train.py index d81959356..a2a1391d3 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/train.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/train.py @@ -1,9 +1,15 @@ +from typing import Dict, List, Tuple + from returnn.tensor import TensorDict from returnn.tensor import Tensor, Dim import returnn.frontend as rf from i6_experiments.users.schmitt.returnn_frontend.model_interfaces.training import TrainDef from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.global_.model import GlobalAttentionModel +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.global_.decoder import ( + GlobalAttDecoder, + GlobalAttEfficientDecoder +) def _returnn_v2_train_step(*, model, extern_data: TensorDict, **_kwargs_unused): @@ -26,6 +32,63 @@ def _returnn_v2_train_step(*, model, extern_data: TensorDict, **_kwargs_unused): ) +def get_s_and_att( + *, + model: GlobalAttDecoder, + enc_args: Dict[str, Tensor], + input_embeddings: Tensor, + enc_spatial_dim: Dim, + targets_spatial_dim: Dim, + batch_dims: List[Dim] +) -> Tuple[Tensor, Tensor]: + def _body(input_embed: Tensor, state: rf.State): + new_state = rf.State() + loop_out_, new_state.decoder = model.loop_step( + **enc_args, + enc_spatial_dim=enc_spatial_dim, + input_embed=input_embed, + state=state.decoder, + ) + return loop_out_, new_state + + loop_out, _, _ = rf.scan( + spatial_dim=targets_spatial_dim, + xs=input_embeddings, + ys=model.loop_step_output_templates(batch_dims=batch_dims), + initial=rf.State( + decoder=model.decoder_default_initial_state(batch_dims=batch_dims, enc_spatial_dim=enc_spatial_dim), + ), + body=_body, + ) + + return loop_out["s"], loop_out["att"] + + +def get_s_and_att_efficient( + *, + model: GlobalAttEfficientDecoder, + enc_args: Dict[str, Tensor], + input_embeddings: Tensor, + enc_spatial_dim: Dim, + targets_spatial_dim: Dim, + batch_dims: List[Dim] +) -> Tuple[Tensor, Tensor]: + s, _ = model.s_wo_att( + input_embeddings, + state=model.s_wo_att.default_initial_state(batch_dims=batch_dims), + spatial_dim=targets_spatial_dim, + ) + + att = model( + enc=enc_args["enc"], + enc_ctx=enc_args["enc_ctx"], + enc_spatial_dim=enc_spatial_dim, + s=s, + ) + + return s, att + + def from_scratch_training( *, model: GlobalAttentionModel, @@ -43,6 +106,8 @@ def from_scratch_training( aed_loss_scale = config.float("aed_loss_scale", 1.0) use_normalized_loss = config.bool("use_normalized_loss", True) + force_inefficient_loop = config.bool("force_inefficient_loop", False) + if data.feature_dim and data.feature_dim.dimension == 1: data = rf.squeeze(data, axis=data.feature_dim) assert not data.feature_dim # raw audio @@ -73,27 +138,27 @@ def from_scratch_training( input_embeddings = model.label_decoder.target_embed(targets) input_embeddings = rf.shift_right(input_embeddings, axis=targets_spatial_dim, pad_value=0.0) - def _body(input_embed: Tensor, state: rf.State): - new_state = rf.State() - loop_out_, new_state.decoder = model.label_decoder.loop_step( - **enc_args, + if type(model.label_decoder) is GlobalAttDecoder or force_inefficient_loop: + s, att = get_s_and_att( + model=model.label_decoder, + enc_args=enc_args, + input_embeddings=input_embeddings, enc_spatial_dim=enc_spatial_dim, - input_embed=input_embed, - state=state.decoder, + targets_spatial_dim=targets_spatial_dim, + batch_dims=batch_dims + ) + else: + assert type(model.label_decoder) is GlobalAttEfficientDecoder + s, att = get_s_and_att_efficient( + model=model.label_decoder, + enc_args=enc_args, + input_embeddings=input_embeddings, + enc_spatial_dim=enc_spatial_dim, + targets_spatial_dim=targets_spatial_dim, + batch_dims=batch_dims ) - return loop_out_, new_state - - loop_out, _, _ = rf.scan( - spatial_dim=targets_spatial_dim, - xs=input_embeddings, - ys=model.label_decoder.loop_step_output_templates(batch_dims=batch_dims), - initial=rf.State( - decoder=model.label_decoder.decoder_default_initial_state(batch_dims=batch_dims, enc_spatial_dim=enc_spatial_dim), - ), - body=_body, - ) - logits = model.label_decoder.decode_logits(input_embed=input_embeddings, **loop_out) + logits = model.label_decoder.decode_logits(input_embed=input_embeddings, s=s, att=att) logits_packed, pack_dim = rf.pack_padded(logits, dims=batch_dims + [targets_spatial_dim], enforce_sorted=False) targets_packed, _ = rf.pack_padded( targets, dims=batch_dims + [targets_spatial_dim], enforce_sorted=False, out_dim=pack_dim diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model.py index e4cd2de4d..55f63067a 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model.py @@ -11,8 +11,7 @@ BlankDecoderV3, ) from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model_new.label_model.model import ( - SegmentalAttLabelDecoder, - SegmentalAttLabelDecoderWoCtxInState + SegmentalAttLabelDecoder, SegmentalAttEfficientLabelDecoder ) from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.encoder.global_ import GlobalConformerEncoder from i6_experiments.users.schmitt.returnn_frontend.model_interfaces.supports_label_scorer_torch import RFModelWithMakeLabelScorer @@ -41,10 +40,11 @@ def __init__( encoder_layer_opts: Optional[Dict[str, Any]] = None, dec_att_num_heads: Dim = Dim(name="att_num_heads", dimension=1), enc_dropout: float = 0.1, - label_decoder_version: int = 1, + use_att_ctx_in_state: bool = True, blank_decoder_version: int = 1, use_joint_model: bool = False, use_weight_feedback: bool = True, + label_decoder_state: str = "nb-lstm", ): super(SegmentalAttentionModel, self).__init__() @@ -65,15 +65,17 @@ def __init__( l2=l2, ) - assert label_decoder_version in {1, 2} - assert blank_decoder_version in {1, 3} + assert blank_decoder_version in {1, 3, 4} + assert label_decoder_state in {"nb-lstm", "joint-lstm"} + if not use_joint_model: + assert label_decoder_state == "nb-lstm" - if label_decoder_version == 1: - label_decoder_class = SegmentalAttLabelDecoder + if not use_weight_feedback and not use_att_ctx_in_state: + label_decoder_cls = SegmentalAttEfficientLabelDecoder else: - label_decoder_class = SegmentalAttLabelDecoderWoCtxInState + label_decoder_cls = SegmentalAttLabelDecoder - self.label_decoder = label_decoder_class( + self.label_decoder = label_decoder_cls( enc_out_dim=self.encoder.out_dim, target_dim=target_dim, att_num_heads=dec_att_num_heads, @@ -83,6 +85,7 @@ def __init__( l2=l2, center_window_size=center_window_size, use_weight_feedback=use_weight_feedback, + use_att_ctx_in_state=use_att_ctx_in_state, ) if not use_joint_model: @@ -94,6 +97,7 @@ def __init__( encoder_out_dim=self.encoder.out_dim, ) else: + # the logic for blank_decoder_version == 4 is in the train/recog code self.blank_decoder = BlankDecoderV3( length_model_state_dim=length_model_state_dim, label_state_dim=self.label_decoder.get_lstm().out_dim, @@ -113,6 +117,8 @@ def __init__( self.target_dim = self.label_decoder.target_dim self.align_target_dim = align_target_dim self.use_joint_model = use_joint_model + self.blank_decoder_version = blank_decoder_version + self.label_decoder_state = label_decoder_state class MakeModel: @@ -149,10 +155,14 @@ def make_model( num_enc_layers: int = 12, pos_emb_dropout: float = 0.0, language_model: Optional[Dict[str, Any]] = None, - label_decoder_version: int, + use_att_ctx_in_state: bool, blank_decoder_version: int, use_joint_model: bool, use_weight_feedback: bool, + label_decoder_state: str, + enc_out_dim: int, + enc_key_total_dim: int, + enc_ff_dim: int, **extra, ) -> SegmentalAttentionModel: """make""" @@ -172,8 +182,9 @@ def make_model( return SegmentalAttentionModel( enc_in_dim=in_dim, enc_num_layers=num_enc_layers, - enc_out_dim=Dim(name="enc", dimension=512, kind=Dim.Types.Feature), - enc_ff_dim=Dim(name="enc-ff", dimension=2048, kind=Dim.Types.Feature), + enc_out_dim=Dim(name="enc", dimension=enc_out_dim, kind=Dim.Types.Feature), + enc_ff_dim=Dim(name="enc-ff", dimension=enc_ff_dim, kind=Dim.Types.Feature), + enc_key_total_dim=Dim(name="enc_key_total_dim", dimension=enc_key_total_dim), enc_num_heads=8, encoder_layer_opts=dict( conv_norm_opts=dict(use_mask=True), @@ -195,10 +206,11 @@ def make_model( length_model_state_dim=Dim(name="length_model_state", dimension=128, kind=Dim.Types.Feature), length_model_embed_dim=Dim(name="length_model_embed", dimension=128, kind=Dim.Types.Feature), center_window_size=center_window_size, - label_decoder_version=label_decoder_version, + use_att_ctx_in_state=use_att_ctx_in_state, blank_decoder_version=blank_decoder_version, use_joint_model=use_joint_model, use_weight_feedback=use_weight_feedback, + label_decoder_state=label_decoder_state, **extra, ) @@ -219,11 +231,16 @@ def from_scratch_model_def( if center_window_size is None: raise ValueError("center_window_size is not set!") - label_decoder_version = config.int("label_decoder_version", 1) + use_att_ctx_in_state = config.bool("use_att_ctx_in_state", True) + label_decoder_state = config.typed_value("label_decoder_state", "nb-lstm") blank_decoder_version = config.int("blank_decoder_version", 1) use_joint_model = config.bool("use_joint_model", False) use_weight_feedback = config.bool("use_weight_feedback", True) + enc_out_dim = config.int("enc_out_dim", 512) + enc_key_total_dim = config.int("enc_key_total_dim", 1024) + enc_ff_dim = config.int("enc_ff_dim", 2048) + return MakeModel.make_model( in_dim, align_target_dim, @@ -232,10 +249,14 @@ def from_scratch_model_def( enc_aux_logits=enc_aux_logits or (), pos_emb_dropout=pos_emb_dropout, language_model=lm_opts, - label_decoder_version=label_decoder_version, + use_att_ctx_in_state=use_att_ctx_in_state, blank_decoder_version=blank_decoder_version, use_joint_model=use_joint_model, use_weight_feedback=use_weight_feedback, + label_decoder_state=label_decoder_state, + enc_out_dim=enc_out_dim, + enc_key_total_dim=enc_key_total_dim, + enc_ff_dim=enc_ff_dim, ) diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/blank_model/train.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/blank_model/train.py index 1abef2546..101330b4e 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/blank_model/train.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/blank_model/train.py @@ -126,3 +126,18 @@ def viterbi_training_v3( emit_blank_target_dim=emit_blank_target_dim, pack_dim=pack_dim ) + + +# TODO: implement viterbi_training_v4 +def viterbi_training_v4( + *, + model: BlankDecoderV3, + enc_args: Dict, + enc_spatial_dim: Dim, + label_states_unmasked: rf.Tensor, + label_states_unmasked_spatial_dim: Dim, + emit_ground_truth: rf.Tensor, + emit_blank_target_dim: Dim, + batch_dims: List[Dim], +): + pass diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/label_model/model.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/label_model/model.py index 03a3a756d..be2c24c36 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/label_model/model.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/label_model/model.py @@ -8,16 +8,12 @@ class SegmentalAttLabelDecoder(BaseLabelDecoder): - def __init__(self, center_window_size: int, use_weight_feedback: bool, **kwargs): + def __init__(self, center_window_size: int, **kwargs): super(SegmentalAttLabelDecoder, self).__init__(**kwargs) self.center_window_size = center_window_size self.accum_att_weights_dim = Dim(name="accum_att_weights", dimension=center_window_size) - self.use_weight_feedback = use_weight_feedback - if not use_weight_feedback: - delattr(self, "weight_feedback") - def default_initial_state( self, *, @@ -29,9 +25,6 @@ def default_initial_state( state = rf.State( s=self.get_lstm().default_initial_state(batch_dims=batch_dims), att=rf.zeros(list(batch_dims) + [self.att_num_heads * self.enc_out_dim]), - # accum_att_weights=rf.zeros( - # list(batch_dims) + [self.accum_att_weights_dim, self.att_num_heads], feature_dim=self.att_num_heads - # ), segment_starts=rf.zeros(batch_dims, sparse_dim=segment_starts_sparse_dim, dtype="int32"), segment_lens=rf.zeros(batch_dims, sparse_dim=segment_lens_sparse_dim, dtype="int32"), ) @@ -135,17 +128,6 @@ def _get_weight_feedback( return self.weight_feedback(prev_accum_att_weights_sliced) - def _update_state( - self, - input_embed: rf.Tensor, - prev_att: rf.Tensor, - prev_s_state: rf.LstmState, - ): - return self.s(rf.concat_features(input_embed, prev_att), state=prev_s_state, spatial_dim=single_step_dim) - - def get_lstm(self): - return self.s - def loop_step( self, *, @@ -226,29 +208,58 @@ def decode_logits(self, *, s: Tensor, input_embed: Tensor, att: Tensor) -> Tenso return logits -class SegmentalAttLabelDecoderWoCtxInState(SegmentalAttLabelDecoder): +class SegmentalAttEfficientLabelDecoder(SegmentalAttLabelDecoder): def __init__(self, **kwargs): - super(SegmentalAttLabelDecoderWoCtxInState, self).__init__(**kwargs) - - # replace old state with new one - self.s_wo_att = rf.ZoneoutLSTM( - self.target_embed.out_dim, - self.s.out_dim, - zoneout_factor_cell=0.15, - zoneout_factor_output=0.05, - use_zoneout_output=False, - parts_order="jifo", - forget_bias=0.0, + super(SegmentalAttEfficientLabelDecoder, self).__init__(**kwargs) + + assert not self.use_att_ctx_in_state and not self.use_weight_feedback, ( + "Cannot have alignment dependency for efficient implementation!" ) - delattr(self, "s") - def _update_state( + def __call__( self, - input_embed: rf.Tensor, - prev_att: rf.Tensor, - prev_s_state: rf.LstmState, - ): - return self.s_wo_att(rf.concat_features(input_embed), state=prev_s_state, spatial_dim=single_step_dim) + *, + enc: rf.Tensor, + enc_ctx: rf.Tensor, + enc_spatial_dim: Dim, + s: rf.Tensor, + segment_starts: rf.Tensor, + segment_lens: rf.Tensor, + ) -> rf.Tensor: + s_transformed = self.s_transformed(s) + + slice_dim = Dim(name="slice", dimension=segment_lens) + gather_positions = rf.range_over_dim(slice_dim) + gather_positions += segment_starts + + # need to move size tensor to GPU since otherwise there is an error in some merge_dims call inside rf.gather + # because two tensors have different devices + # TODO: fix properly in the gather implementation + enc_spatial_dim.dyn_size_ext = rf.copy_to_device(enc_spatial_dim.dyn_size_ext, gather_positions.device) + + enc_ctx_sliced = rf.gather(enc_ctx, axis=enc_spatial_dim, indices=gather_positions, clip_to_valid=True) + enc_sliced = rf.gather(enc, axis=enc_spatial_dim, indices=gather_positions, clip_to_valid=True) + + # move size tensor back to CPU + enc_spatial_dim.dyn_size_ext = rf.copy_to_device(enc_spatial_dim.dyn_size_ext, "cpu") + + weight_feedback = rf.zeros((self.enc_key_total_dim,)) + + energy_in = enc_ctx_sliced + weight_feedback + s_transformed + + energy = self.energy(rf.tanh(energy_in)) + att_weights = rf.softmax(energy, axis=slice_dim) + # we do not need use_mask because the softmax output is already padded with zeros + att0 = rf.dot(att_weights, enc_sliced, reduce=slice_dim, use_mask=False) + att0.feature_dim = self.enc_out_dim + att, _ = rf.merge_dims(att0, dims=(self.att_num_heads, self.enc_out_dim)) - def get_lstm(self): - return self.s_wo_att + return att + + def decode_logits(self, *, s: Tensor, input_embed: Tensor, att: Tensor) -> Tensor: + """logits for the decoder""" + readout_in = self.readout_in(rf.concat_features(s, input_embed, att, allow_broadcast=True)) + readout = rf.reduce_out(readout_in, mode="max", num_pieces=2, out_dim=self.output_prob.in_dim) + readout = rf.dropout(readout, drop_prob=0.3, axis=self.dropout_broadcast and readout.feature_dim) + logits = self.output_prob(readout) + return logits diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/label_model/train.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/label_model/train.py index 3a547e7bd..94468db9a 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/label_model/train.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/label_model/train.py @@ -1,7 +1,10 @@ from typing import Optional, Dict, Any, Sequence, Tuple, List -from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.utils import get_non_blank_mask, get_masked -from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model_new.label_model.model import SegmentalAttLabelDecoder +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental import utils +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model_new.label_model.model import ( + SegmentalAttLabelDecoder, + SegmentalAttEfficientLabelDecoder +) from returnn.tensor import Dim, single_step_dim import returnn.frontend as rf @@ -9,6 +12,30 @@ from i6_experiments.users.schmitt.returnn_frontend.model_interfaces.training import TrainDef +def _calc_ce_loss_and_fer( + logits: rf.Tensor, + targets: rf.Tensor, + batch_dims: List[Dim], + targets_spatial_dim: Dim, + target_dim: Dim, +): + logits_packed, pack_dim = rf.pack_padded(logits, dims=batch_dims + [targets_spatial_dim], enforce_sorted=False) + non_blank_targets_packed, _ = rf.pack_padded( + targets, dims=batch_dims + [targets_spatial_dim], enforce_sorted=False, out_dim=pack_dim + ) + + log_prob = rf.log_softmax(logits_packed, axis=target_dim) + log_prob = rf.label_smoothed_log_prob_gradient(log_prob, 0.1, axis=target_dim) + loss = rf.cross_entropy( + target=non_blank_targets_packed, estimated=log_prob, estimated_type="log-probs", axis=target_dim + ) + loss.mark_as_loss("non_blank_ce", scale=1.0, use_normalized_loss=True) + + best = rf.reduce_argmax(logits_packed, axis=target_dim) + frame_error = best != non_blank_targets_packed + frame_error.mark_as_loss(name="non_blank_fer", as_error=True) + + def viterbi_training( *, model: SegmentalAttLabelDecoder, @@ -19,8 +46,8 @@ def viterbi_training( segment_starts: rf.Tensor, segment_lens: rf.Tensor, batch_dims: List[Dim], - output_tensors: Optional[List[str]] = None -) -> Optional[Dict[str, Tuple[rf.Tensor, Dim]]]: + return_label_model_states: bool = False, +) -> Optional[Tuple[rf.Tensor, Dim]]: non_blank_input_embeddings = model.target_embed(non_blank_targets) non_blank_input_embeddings_shifted = rf.shift_right( non_blank_input_embeddings, axis=non_blank_targets_spatial_dim, pad_value=0.0) @@ -59,24 +86,9 @@ def _label_loop_body(xs, state: rf.State): ) logits = model.decode_logits(input_embed=non_blank_input_embeddings_shifted, **label_loop_out) - logits_packed, pack_dim = rf.pack_padded(logits, dims=batch_dims + [non_blank_targets_spatial_dim], enforce_sorted=False) - non_blank_targets_packed, _ = rf.pack_padded( - non_blank_targets, dims=batch_dims + [non_blank_targets_spatial_dim], enforce_sorted=False, out_dim=pack_dim - ) - - log_prob = rf.log_softmax(logits_packed, axis=model.target_dim) - log_prob = rf.label_smoothed_log_prob_gradient(log_prob, 0.1, axis=model.target_dim) - loss = rf.cross_entropy( - target=non_blank_targets_packed, estimated=log_prob, estimated_type="log-probs", axis=model.target_dim - ) - loss.mark_as_loss("non_blank_ce", scale=1.0, use_normalized_loss=True) - - best = rf.reduce_argmax(logits_packed, axis=model.target_dim) - frame_error = best != non_blank_targets_packed - frame_error.mark_as_loss(name="non_blank_fer", as_error=True) + _calc_ce_loss_and_fer(logits, non_blank_targets, batch_dims, non_blank_targets_spatial_dim, model.target_dim) - if output_tensors is not None: - extended_outputs = {} + if return_label_model_states: # need to run the loop one more time to get the last output (which is not needed for the loss computation) last_embedding = rf.gather( non_blank_input_embeddings, @@ -92,13 +104,180 @@ def _label_loop_body(xs, state: rf.State): segment_lens=final_state.decoder.segment_lens, state=final_state.decoder, ) - for key, val in last_loop_out.items(): - if key not in output_tensors: - continue - extended_outputs[key] = rf.concat( - (label_loop_out[key], non_blank_targets_spatial_dim), - (rf.expand_dim(val, single_step_dim), single_step_dim), - ) - return extended_outputs + return rf.concat( + (label_loop_out["s"], non_blank_targets_spatial_dim), + (rf.expand_dim(last_loop_out["s"], single_step_dim), single_step_dim), + ) + + return None + + +def viterbi_training_efficient( + *, + model: SegmentalAttEfficientLabelDecoder, + enc_args: Dict, + enc_spatial_dim: Dim, + targets: rf.Tensor, + targets_spatial_dim: Dim, + segment_starts: rf.Tensor, + segment_lens: rf.Tensor, + batch_dims: List[Dim], + ce_targets: rf.Tensor, + ce_spatial_dim: Dim, + non_blank_mask: Optional[rf.Tensor] = None, + non_blank_mask_spatial_dim: Optional[Dim] = None, + return_label_model_states: bool = False, +) -> Optional[Tuple[rf.Tensor, Dim]]: + input_embeddings = model.target_embed(targets) + input_embeddings_shifted = rf.shift_right( + input_embeddings, axis=targets_spatial_dim, pad_value=0.0) + + label_lstm_out, final_state = model.s_wo_att( + input_embeddings_shifted, + state=model.s_wo_att.default_initial_state(batch_dims=batch_dims), + spatial_dim=targets_spatial_dim, + ) + + if non_blank_mask is not None: + label_lstm_out = utils.get_unmasked( + input=label_lstm_out, + input_spatial_dim=targets_spatial_dim, + mask=non_blank_mask, + mask_spatial_dim=non_blank_mask_spatial_dim, + ) + input_embeddings_shifted = utils.get_unmasked( + input=input_embeddings_shifted, + input_spatial_dim=targets_spatial_dim, + mask=non_blank_mask, + mask_spatial_dim=non_blank_mask_spatial_dim, + ) + + # need to move size tensor to GPU since otherwise there is an error in some merge_dims call inside rf.gather + # because two tensors have different devices + # TODO: fix properly in the gather implementation + targets_spatial_dim.dyn_size_ext = rf.copy_to_device(targets_spatial_dim.dyn_size_ext, label_lstm_out.device) + if non_blank_mask_spatial_dim is not None: + non_blank_mask_spatial_dim.dyn_size_ext = rf.copy_to_device(non_blank_mask_spatial_dim.dyn_size_ext, label_lstm_out.device) + att = model( + enc=enc_args["enc"], + enc_ctx=enc_args["enc_ctx"], + enc_spatial_dim=enc_spatial_dim, + s=label_lstm_out, + segment_starts=segment_starts, + segment_lens=segment_lens, + ) + targets_spatial_dim.dyn_size_ext = rf.copy_to_device(targets_spatial_dim.dyn_size_ext, "cpu") + if non_blank_mask_spatial_dim is not None: + non_blank_mask_spatial_dim.dyn_size_ext = rf.copy_to_device(non_blank_mask_spatial_dim.dyn_size_ext, "cpu") + + logits = model.decode_logits( + input_embed=input_embeddings_shifted, + att=att, + s=label_lstm_out, + ) + + _calc_ce_loss_and_fer(logits, ce_targets, batch_dims, ce_spatial_dim, model.target_dim) + + if return_label_model_states: + # need to run the lstm one more time to get the last output (which is not needed for the loss computation) + last_embedding = rf.gather( + input_embeddings, + axis=targets_spatial_dim, + indices=rf.copy_to_device( + targets_spatial_dim.get_size_tensor() - 1, input_embeddings.device), + clip_to_valid=True, + ) + last_lstm_out, _ = model.s_wo_att( + last_embedding, + state=final_state, + spatial_dim=single_step_dim, + ) + return rf.concat( + (label_lstm_out, targets_spatial_dim), + (rf.expand_dim(last_lstm_out, single_step_dim), single_step_dim), + ) + + return None + + +def full_sum_training( + *, + model: SegmentalAttEfficientLabelDecoder, + enc_args: Dict, + enc_spatial_dim: Dim, + non_blank_targets: rf.Tensor, + non_blank_targets_spatial_dim: Dim, + segment_starts: rf.Tensor, + segment_lens: rf.Tensor, + batch_dims: List[Dim], +) -> Optional[Dict[str, Tuple[rf.Tensor, Dim]]]: + # print("full_sum_training") + # print("model", model) + + import torch + from torch.profiler import profile, record_function, ProfilerActivity + + with profile(activities=[ProfilerActivity.CPU, ProfilerActivity.CUDA], record_shapes=True, profile_memory=True) as prof: + + non_blank_input_embeddings = model.target_embed(non_blank_targets) # [B, S, D] + singleton_dim = Dim(name="singleton", dimension=1) + singleton_zeros = rf.zeros(batch_dims + [singleton_dim, model.target_embed.out_dim]) + non_blank_input_embeddings_shifted, non_blank_targets_spatial_dim_ext = rf.concat( + (singleton_zeros, singleton_dim), + (non_blank_input_embeddings, non_blank_targets_spatial_dim), + allow_broadcast=True + ) # [B, S+1, D] + non_blank_input_embeddings_shifted.feature_dim = non_blank_input_embeddings.feature_dim + + label_lstm_out, _ = model.s_wo_att( + non_blank_input_embeddings_shifted, + state=model.s_wo_att.default_initial_state(batch_dims=batch_dims), + spatial_dim=non_blank_targets_spatial_dim_ext, + ) # [B, S+1, D] + + att = model( + enc=enc_args["enc"], + enc_ctx=enc_args["enc_ctx"], + enc_spatial_dim=enc_spatial_dim, + s=label_lstm_out, + segment_starts=segment_starts, + segment_lens=segment_lens, + ) # [B, S+1, T, D] + + logits = model.decode_logits( + input_embed=non_blank_input_embeddings_shifted, + att=att, + s=label_lstm_out, + ) # [B, S+1, T, D] + + print("logits", logits.raw_tensor.shape) + + logits_packed, pack_dim = rf.pack_padded( + logits, + dims=batch_dims + [enc_spatial_dim, non_blank_targets_spatial_dim_ext], + enforce_sorted=False + ) # [B * T * (S+1), D] + + print("logits_packed", logits_packed.raw_tensor.shape) + + print(prof.key_averages(group_by_input_shape=True).table(sort_by="self_cuda_memory_usage", row_limit=10)) + exit() + + from returnn.extern_private.BergerMonotonicRNNT.monotonic_rnnt.pytorch_binding import monotonic_rnnt_loss + + loss = monotonic_rnnt_loss( + acts=logits_packed.raw_tensor, + labels=non_blank_targets.copy_transpose(batch_dims + [non_blank_targets_spatial_dim]).raw_tensor, + input_lengths=rf.copy_to_device(enc_spatial_dim.dyn_size_ext, logits.device).raw_tensor, + label_lengths=rf.copy_to_device(non_blank_targets_spatial_dim.dyn_size_ext, logits.device).raw_tensor.int(), + blank_label=model.blank_idx, + ) + + # print("loss", loss.shape) + + exit() + + loss = rf.convert_to_tensor(loss, name="full_sum_loss") + loss.mark_as_loss("full_sum_loss", scale=1.0, use_normalized_loss=True) return None diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/recog.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/recog.py index dfdf2a8c3..cd7886330 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/recog.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/recog.py @@ -32,31 +32,38 @@ def recombine_seqs( print("seq_log_prob before: ", seq_log_prob.raw_tensor) seq_hash_cpu = rf.copy_to_device(seq_hash.copy_transpose([batch_dim, beam_dim]), device="cpu") + # convert from neg log prob to log prob seq_log_prob = rf.copy_to_device(seq_log_prob.copy_transpose([batch_dim, beam_dim]), device="cpu") - for b in range(batch_dim.get_dim_value()): + for b in range(batch_dim.dyn_size_ext.raw_tensor.item()): + # for each batch dim, we need to find the seqs that have the same hash value seq_sets = {} for h in range(beam_dim.dimension): - seq_hash_value = seq_hash_cpu.raw_tensor[b, h] + # hash value of current hypothesis + seq_hash_value = seq_hash_cpu.raw_tensor[b, h].item() if seq_hash_value not in seq_sets: seq_sets[seq_hash_value] = [] + # insert hypothesis index into the list of hypotheses with the same hash value seq_sets[seq_hash_value].append(h) - + # for each set of hypotheses with the same hash value, we keep the one with the highest log prob for seq_set in seq_sets.values(): if len(seq_set) == 1: continue - best_score = 0 + best_score = float("-inf") best_idx = -1 for idx in seq_set: if seq_log_prob.raw_tensor[b, idx] > best_score: best_score = seq_log_prob.raw_tensor[b, idx] best_idx = idx + # print("batch: ", b, "seq_set: ", seq_set, "best_idx: ", best_idx, "best_score: ", best_score) + # exit() for idx in seq_set: if idx != best_idx: - seq_log_prob.raw_tensor[b, idx] = -float("inf") + seq_log_prob.raw_tensor[b, idx] = float("-inf") else: seq_log_prob.raw_tensor[b, idx] = best_score + seq_log_prob = seq_log_prob print("seq_log_prob after: ", seq_log_prob.raw_tensor) exit() @@ -127,6 +134,8 @@ def model_recog( if model.use_joint_model: target = rf.constant(bos_idx, dims=batch_dims_, sparse_dim=model.target_dim) + if model.label_decoder_state == "nb-lstm": + target_non_blank = target.copy() else: target = rf.constant(bos_idx, dims=batch_dims_, sparse_dim=model.align_target_dim) update_state_mask = rf.convert_to_tensor(target != model.blank_idx) @@ -157,7 +166,7 @@ def model_recog( seq_backrefs = [] while i < max_seq_len.raw_tensor: if i > 0: - if model.use_joint_model: + if model.label_decoder_state == "joint-lstm": input_embed = model.label_decoder.target_embed(target) else: target_non_blank = rf.where(update_state_mask, target, rf.gather(target_non_blank, indices=backrefs)) @@ -238,7 +247,7 @@ def model_recog( if use_recombination: seq_log_prob = recombine_seqs(seq_targets, seq_log_prob, seq_backrefs, seq_hash, beam_dim, batch_dims[0], i) - if i== 3: + if i == 3: exit() seq_log_prob = seq_log_prob + output_log_prob # Batch, InBeam, Vocab @@ -264,7 +273,7 @@ def model_recog( # ------------------- update label decoder state ------------------- - if model.use_joint_model: + if model.label_decoder_state == "joint-lstm": label_decoder_state = tree.map_structure(lambda s: rf.gather(s, indices=backrefs), label_decoder_state_updated) else: def _get_masked_state(old, new, mask): diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/train.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/train.py index fe38ba5cc..082d8525d 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/train.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/train.py @@ -10,6 +10,12 @@ from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model_new.label_model.train import ( viterbi_training as label_model_viterbi_training ) +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model_new.label_model.train import ( + viterbi_training_efficient as label_model_viterbi_training_efficient +) +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model_new.label_model.train import ( + full_sum_training as label_model_full_sum_training +) from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model_new.blank_model.train import ( viterbi_training as blank_model_viterbi_training ) @@ -20,6 +26,10 @@ BlankDecoderV1, BlankDecoderV3, ) +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model_new.label_model.model import ( + SegmentalAttLabelDecoder, + SegmentalAttEfficientLabelDecoder +) from returnn.tensor import Dim import returnn.frontend as rf @@ -61,6 +71,7 @@ def viterbi_training( config = get_global_config() # noqa aux_loss_layers = config.typed_value("aux_loss_layers") aux_loss_scales = config.typed_value("aux_loss_scales", ([1.0] * len(aux_loss_layers)) if aux_loss_layers else None) + force_inefficient_loop = config.typed_value("force_inefficient_loop", False) if data.feature_dim and data.feature_dim.dimension == 1: data = rf.squeeze(data, axis=data.feature_dim) @@ -80,25 +91,33 @@ def viterbi_training( ) if model.use_joint_model: - non_blank_targets, non_blank_targets_spatial_dim = None, None + # TODO: use rf.window() instead segment_starts, segment_lens = utils.get_segment_starts_and_lens( - utils.get_non_blank_mask(align_targets, blank_idx=-1), # this way, every frame is interpreted as non-blank - align_targets, - align_targets_spatial_dim, - model, - batch_dims, - align_targets_spatial_dim + non_blank_mask=rf.sequence_mask(align_targets.dims), # this way, every frame is interpreted as non-blank + align_targets=align_targets, + align_targets_spatial_dim=align_targets_spatial_dim, + model=model, + batch_dims=batch_dims, + out_spatial_dim=align_targets_spatial_dim ) # set blank indices in alignment to 0 (= EOS index of imported global att model which is not used otherwise) align_targets.raw_tensor[align_targets.raw_tensor == model.target_dim.dimension] = 0 align_targets.sparse_dim = model.target_dim + + non_blank_mask = utils.get_non_blank_mask(align_targets, model.blank_idx) + non_blank_targets, non_blank_targets_spatial_dim = utils.get_masked( + align_targets, non_blank_mask, align_targets_spatial_dim, batch_dims + ) + non_blank_targets.sparse_dim = model.target_dim else: + non_blank_mask = utils.get_non_blank_mask(align_targets, model.blank_idx) non_blank_targets, non_blank_targets_spatial_dim = utils.get_masked( - align_targets, utils.get_non_blank_mask(align_targets, model.blank_idx), align_targets_spatial_dim, batch_dims + align_targets, non_blank_mask, align_targets_spatial_dim, batch_dims ) non_blank_targets.sparse_dim = model.target_dim + segment_starts, segment_lens = utils.get_segment_starts_and_lens( - utils.get_non_blank_mask(align_targets, model.blank_idx), + non_blank_mask, align_targets, align_targets_spatial_dim, model, @@ -133,31 +152,80 @@ def viterbi_training( ) if model.use_joint_model: + # ------------------- joint loop ------------------- - label_model_viterbi_training( - model=model.label_decoder, - enc_args=enc_args, - enc_spatial_dim=enc_spatial_dim, - non_blank_targets=align_targets, - non_blank_targets_spatial_dim=align_targets_spatial_dim, - segment_starts=segment_starts, - segment_lens=segment_lens, - batch_dims=batch_dims, - ) + + # isinstance() does not work here, since SegmentalAttEfficientJointLabelDecoder inherits from SegmentalAttLabelDecoder + if type(model.label_decoder) is SegmentalAttLabelDecoder: + assert model.label_decoder_state == "joint-lstm", "not implemented yet, simple to extend" + label_model_viterbi_training( + model=model.label_decoder, + enc_args=enc_args, + enc_spatial_dim=enc_spatial_dim, + non_blank_targets=align_targets, + non_blank_targets_spatial_dim=align_targets_spatial_dim, + segment_starts=segment_starts, + segment_lens=segment_lens, + batch_dims=batch_dims, + ) + else: + assert type(model.label_decoder) is SegmentalAttEfficientLabelDecoder + if model.label_decoder_state == "joint-lstm": + targets = align_targets + targets_spatial_dim = align_targets_spatial_dim + non_blank_mask_ = None + non_blank_mask_spatial_dim = None + else: + targets = non_blank_targets + targets_spatial_dim = non_blank_targets_spatial_dim + non_blank_mask_ = non_blank_mask + non_blank_mask_spatial_dim = align_targets_spatial_dim + + label_model_viterbi_training_efficient( + model=model.label_decoder, + enc_args=enc_args, + enc_spatial_dim=enc_spatial_dim, + targets=targets, + targets_spatial_dim=targets_spatial_dim, + segment_starts=segment_starts, + segment_lens=segment_lens, + non_blank_mask=non_blank_mask_, + non_blank_mask_spatial_dim=non_blank_mask_spatial_dim, + ce_targets=align_targets, + ce_spatial_dim=align_targets_spatial_dim, + batch_dims=batch_dims, + ) else: + # ------------------- label loop ------------------- - label_decoder_outputs = label_model_viterbi_training( - model=model.label_decoder, - enc_args=enc_args, - enc_spatial_dim=enc_spatial_dim, - non_blank_targets=non_blank_targets, - non_blank_targets_spatial_dim=non_blank_targets_spatial_dim, - segment_starts=segment_starts, - segment_lens=segment_lens, - batch_dims=batch_dims, - output_tensors=model.blank_decoder.get_label_decoder_deps(), - ) + if type(model.label_decoder) is SegmentalAttLabelDecoder or force_inefficient_loop: + label_decoder_outputs = label_model_viterbi_training( + model=model.label_decoder, + enc_args=enc_args, + enc_spatial_dim=enc_spatial_dim, + non_blank_targets=non_blank_targets, + non_blank_targets_spatial_dim=non_blank_targets_spatial_dim, + segment_starts=segment_starts, + segment_lens=segment_lens, + batch_dims=batch_dims, + return_label_model_states=model.blank_decoder.get_label_decoder_deps() is not None, + ) + else: + assert type(model.label_decoder) is SegmentalAttEfficientLabelDecoder + label_decoder_outputs = label_model_viterbi_training_efficient( + model=model.label_decoder, + enc_args=enc_args, + enc_spatial_dim=enc_spatial_dim, + targets=non_blank_targets, + targets_spatial_dim=non_blank_targets_spatial_dim, + segment_starts=segment_starts, + segment_lens=segment_lens, + batch_dims=batch_dims, + ce_targets=non_blank_targets, + ce_spatial_dim=non_blank_targets_spatial_dim, + return_label_model_states=model.blank_decoder.get_label_decoder_deps() is not None, + ) # ------------------- blank loop ------------------- @@ -174,13 +242,12 @@ def viterbi_training( batch_dims=batch_dims, ) else: - assert isinstance(model.blank_decoder, BlankDecoderV3) - assert "s" in label_decoder_outputs + assert isinstance(model.blank_decoder, BlankDecoderV3) and model.blank_decoder_version in (3,) label_states_unmasked = utils.get_unmasked( - input=label_decoder_outputs["s"][0], - input_spatial_dim=label_decoder_outputs["s"][1], - mask=utils.get_non_blank_mask(align_targets, model.blank_idx), + input=label_decoder_outputs[0], + input_spatial_dim=label_decoder_outputs[1], + mask=non_blank_mask, mask_spatial_dim=align_targets_spatial_dim ) blank_model_viterbi_training_v3( @@ -196,3 +263,94 @@ def viterbi_training( viterbi_training: TrainDef[SegmentalAttentionModel] viterbi_training.learning_rate_control_error_measure = "dev_score_full_sum" + + +def full_sum_training( + *, + model: SegmentalAttentionModel, + data: rf.Tensor, + data_spatial_dim: Dim, + align_targets: rf.Tensor, + align_targets_spatial_dim: Dim +): + assert model.use_joint_model + assert isinstance(model.label_decoder, SegmentalAttEfficientLabelDecoder) + assert model.label_decoder_state == "nb-lstm" + + from returnn.config import get_global_config + + # torch.cuda.memory._record_memory_history(enabled=True) + + config = get_global_config() # noqa + aux_loss_layers = config.typed_value("aux_loss_layers") + aux_loss_scales = config.typed_value("aux_loss_scales", ([1.0] * len(aux_loss_layers)) if aux_loss_layers else None) + + if data.feature_dim and data.feature_dim.dimension == 1: + data = rf.squeeze(data, axis=data.feature_dim) + assert not data.feature_dim # raw audio + + batch_dims = data.remaining_dims(data_spatial_dim) + + # set blank indices in alignment to 0 (= EOS index of imported global att model which is not used otherwise) + align_targets.raw_tensor[align_targets.raw_tensor == model.target_dim.dimension] = 0 + align_targets.sparse_dim = model.target_dim + + # get non-blank targets ([B,S]) + non_blank_mask = utils.get_non_blank_mask(align_targets, model.blank_idx) + non_blank_targets, non_blank_targets_spatial_dim = utils.get_masked( + align_targets, non_blank_mask, align_targets_spatial_dim, batch_dims + ) + + # ------------------- encoder aux loss ------------------- + + collected_outputs = {} + enc_args, enc_spatial_dim = model.encoder.encode( + data, in_spatial_dim=data_spatial_dim, collected_outputs=collected_outputs) + + if aux_loss_layers: + for i, layer_idx in enumerate(aux_loss_layers): + if layer_idx > len(model.encoder.layers): + continue + linear = getattr(model, f"enc_aux_logits_{layer_idx}") + aux_logits = linear(collected_outputs[str(layer_idx - 1)]) + aux_loss = rf.ctc_loss( + logits=aux_logits, + targets=non_blank_targets, + input_spatial_dim=enc_spatial_dim, + targets_spatial_dim=non_blank_targets_spatial_dim, + blank_index=model.blank_idx, + ) + aux_loss.mark_as_loss( + f"ctc_{layer_idx}", + scale=aux_loss_scales[i], + custom_inv_norm_factor=align_targets_spatial_dim.get_size_tensor(), + use_normalized_loss=True, + ) + + # for every frame position, get the corresponding window around it ([B,T,W]) + # TODO: use rf.window() instead + segment_starts, segment_lens = utils.get_segment_starts_and_lens( + utils.get_non_blank_mask(align_targets, blank_idx=-1), # this way, every frame is interpreted as non-blank + align_targets, + align_targets_spatial_dim, + model, + batch_dims, + enc_spatial_dim + ) + + # ------------------- joint loop ------------------- + + label_model_full_sum_training( + model=model.label_decoder, + enc_args=enc_args, + enc_spatial_dim=enc_spatial_dim, + non_blank_targets=non_blank_targets, + non_blank_targets_spatial_dim=non_blank_targets_spatial_dim, + segment_starts=segment_starts, + segment_lens=segment_lens, + batch_dims=batch_dims, + ) + + +full_sum_training: TrainDef[SegmentalAttentionModel] +full_sum_training.learning_rate_control_error_measure = "dev_score_full_sum" diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/utils.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/utils.py index 7b8a7281a..18074b34b 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/utils.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/utils.py @@ -48,14 +48,20 @@ def get_unmasked( ): mask_shifted = rf.shift_right(mask, axis=mask_spatial_dim, pad_value=False) mask_axis = mask.get_axis_from_description(mask_spatial_dim) - cumsum = rf.cast(mask_shifted, "int32").copy_template() + + # changelog + # 24.05.24: changed int32->int64 and added 'clip_to_valid=True' since i got an CUDA idx out of bounds error + # when testing a new feature. weirdly, i did not see this error in the log.run.1 file of existing trainings + # using this function. + cumsum = rf.cast(mask_shifted, "int64").copy_template() cumsum.raw_tensor = torch.cumsum( - mask_shifted.raw_tensor.to(torch.int32), dim=mask_axis, dtype=torch.int32 + mask_shifted.raw_tensor.to(torch.int64), dim=mask_axis, dtype=torch.int64 ) return rf.gather( input, indices=cumsum, axis=input_spatial_dim, + clip_to_valid=True ) diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v1/__init__.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v1/__init__.py index b33815fb9..05080ed11 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v1/__init__.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v1/__init__.py @@ -4,7 +4,6 @@ from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.pipelines.pipeline_ls_conf.center_window_att import ( train, recog ) -from i6_experiments.users.schmitt.custom_load_params import load_missing_params def run_exps(): @@ -26,7 +25,7 @@ def run_exps(): ) for model_alias, config_builder in baseline.center_window_att_baseline_rf( - win_size_list=(5,), decoder_version=2 + win_size_list=(5,), use_att_ctx_in_state=False ): for train_alias, checkpoint in train.train_center_window_att_viterbi_import_global_tf( alias=model_alias, @@ -34,7 +33,6 @@ def run_exps(): n_epochs_list=(10,), const_lr_list=(1e-4, 2e-4, 3e-4), time_rqmt=4, - custom_missing_load_func=load_missing_params ): recog.center_window_returnn_frame_wise_beam_search( alias=train_alias, diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v1/baseline.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v1/baseline.py index 496bae2e0..4034fdd07 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v1/baseline.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v1/baseline.py @@ -6,13 +6,14 @@ def center_window_att_baseline_rf( win_size_list: Tuple[int, ...] = (5, 129), - decoder_version: int = 1, + use_att_ctx_in_state: bool = True, ): for win_size in win_size_list: - alias = f"{base_alias}/baseline_rf/win-size-{win_size}/decoder-version-{decoder_version if decoder_version else 1}" - yield alias, get_center_window_att_config_builder_rf( + alias, config_builder = get_center_window_att_config_builder_rf( win_size=win_size, - label_decoder_version=decoder_version, + use_att_ctx_in_state=use_att_ctx_in_state, blank_decoder_version=1, use_joint_model=False, ) + alias = f"{base_alias}/baseline_rf/{alias}" + yield alias, config_builder diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v3/__init__.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v3/__init__.py index 89d9f44d5..21f3ce8fc 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v3/__init__.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v3/__init__.py @@ -4,10 +4,28 @@ from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.pipelines.pipeline_ls_conf.center_window_att import ( train, recog ) -from i6_experiments.users.schmitt.custom_load_params import load_missing_params + +from i6_core.returnn.training import PtCheckpoint +from sisyphus import Path def run_exps(): + # baseline model for checking consistency of train and recog implementations + for model_alias, config_builder in baseline.center_window_att_baseline_rf( + win_size_list=(5,), + ): + for train_alias, checkpoint in train.train_center_window_att_viterbi_import_global_tf( + alias=model_alias, + config_builder=config_builder, + n_epochs_list=(10,), + const_lr_list=(1e-4,), + ): + recog.center_window_returnn_frame_wise_beam_search( + alias=train_alias, + config_builder=config_builder, + checkpoint=checkpoint, + ) + for model_alias, config_builder in baseline.center_window_att_baseline_rf( win_size_list=(5, 129), ): @@ -24,7 +42,7 @@ def run_exps(): ) for model_alias, config_builder in baseline.center_window_att_baseline_rf( - win_size_list=(5, 129), decoder_version=2 + win_size_list=(5, 129), use_att_ctx_in_state=False, use_weight_feedback=False, ): for train_alias, checkpoint in train.train_center_window_att_viterbi_import_global_tf( alias=model_alias, @@ -39,9 +57,9 @@ def run_exps(): ) for model_alias, config_builder in baseline.center_window_att_baseline_rf( - win_size_list=(5,), decoder_version=2 + win_size_list=(5,) ): - for max_shift, num_iterations in [(1, 1), (2, 1), (1, 2), (2, 2)]: + for max_shift, num_iterations in [(1, 1), (2, 1), (1, 2)]: for train_alias, checkpoint in train.train_center_window_att_viterbi_import_global_tf( alias=model_alias, config_builder=config_builder, @@ -54,3 +72,17 @@ def run_exps(): config_builder=config_builder, checkpoint=checkpoint, ) + + for model_alias, config_builder in baseline.center_window_att_baseline_rf( + win_size_list=(5,), + ): + for train_alias, checkpoint in train.train_center_window_att_viterbi_from_scratch( + alias=model_alias, + config_builder=config_builder, + n_epochs_list=(500,), + ): + recog.center_window_returnn_frame_wise_beam_search( + alias=train_alias, + config_builder=config_builder, + checkpoint=checkpoint, + ) diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v3/baseline.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v3/baseline.py index ef8071026..d6fff6356 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v3/baseline.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v3/baseline.py @@ -6,15 +6,16 @@ def center_window_att_baseline_rf( win_size_list: Tuple[int, ...] = (5, 129), - decoder_version: int = 1, + use_att_ctx_in_state: bool = True, use_weight_feedback: bool = True, ): for win_size in win_size_list: - alias = f"{base_alias}/baseline_rf/win-size-{win_size}/{'w' if use_weight_feedback else 'wo'}-weight-feedback/decoder-version-{decoder_version if decoder_version else 1}" - yield alias, get_center_window_att_config_builder_rf( + alias, config_builder = get_center_window_att_config_builder_rf( win_size=win_size, - label_decoder_version=decoder_version, + use_att_ctx_in_state=use_att_ctx_in_state, blank_decoder_version=3, use_joint_model=False, use_weight_feedback=use_weight_feedback, ) + alias = f"{base_alias}/baseline_rf/{alias}" + yield alias, config_builder diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v4/__init__.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v4/__init__.py index 07a9ffbcc..d9f80c03e 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v4/__init__.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v4/__init__.py @@ -4,23 +4,33 @@ from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.pipelines.pipeline_ls_conf.center_window_att import ( train, recog ) -from i6_experiments.users.schmitt.custom_load_params import load_missing_params def run_exps(): for model_alias, config_builder in baseline.center_window_att_baseline_rf( - win_size_list=(1, 5,), + win_size_list=(5,), label_decoder_state="nb-lstm", use_att_ctx_in_state=False, use_weight_feedback=False, ): for train_alias, checkpoint in train.train_center_window_att_viterbi_import_global_tf( alias=model_alias, config_builder=config_builder, - n_epochs_list=(10,), - time_rqmt=4, + n_epochs_list=(100,), + ): + recog.center_window_returnn_frame_wise_beam_search( + alias=train_alias, + config_builder=config_builder, + checkpoint=checkpoint, + ) + + for model_alias, config_builder in baseline.center_window_att_baseline_rf( + win_size_list=(5,), label_decoder_state="joint-lstm", use_att_ctx_in_state=False, use_weight_feedback=False, + ): + for train_alias, checkpoint in train.train_center_window_att_viterbi_import_global_tf( + alias=model_alias, + config_builder=config_builder, + n_epochs_list=(100,), ): recog.center_window_returnn_frame_wise_beam_search( alias=train_alias, config_builder=config_builder, checkpoint=checkpoint, - checkpoint_aliases=("last",), - pure_torch=False, ) diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v4/baseline.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v4/baseline.py index 069601d20..8e5566d4f 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v4/baseline.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v4/baseline.py @@ -6,13 +6,18 @@ def center_window_att_baseline_rf( win_size_list: Tuple[int, ...] = (5, 129), - decoder_version: int = 1, + use_att_ctx_in_state: bool = True, + label_decoder_state: str = "nb-lstm", + use_weight_feedback: bool = True, ): for win_size in win_size_list: - alias = f"{base_alias}/baseline_rf/win-size-{win_size}/decoder-version-{decoder_version if decoder_version else 1}" - yield alias, get_center_window_att_config_builder_rf( + alias, config_builder = get_center_window_att_config_builder_rf( win_size=win_size, - label_decoder_version=decoder_version, + use_att_ctx_in_state=use_att_ctx_in_state, blank_decoder_version=None, use_joint_model=True, + label_decoder_state=label_decoder_state, + use_weight_feedback=use_weight_feedback, ) + alias = f"{base_alias}/baseline_rf/{alias}" + yield alias, config_builder diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/config_builder.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/config_builder.py index 1f0687758..a4f9b7d68 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/config_builder.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/config_builder.py @@ -12,11 +12,12 @@ def get_center_window_att_config_builder_rf( win_size: int, - label_decoder_version: int, + use_att_ctx_in_state: bool, blank_decoder_version: Optional[int], use_joint_model: bool, use_weight_feedback: bool = True, -) -> SegmentalAttConfigBuilderRF: + label_decoder_state: str = "nb-lstm", +) -> Tuple[str, SegmentalAttConfigBuilderRF]: variant_params = { "dependencies": LibrispeechBPE10025_CTC_ALIGNMENT, "dataset": { @@ -36,10 +37,18 @@ def get_center_window_att_config_builder_rf( model_def=from_scratch_model_def, get_model_func=_returnn_v2_get_model, center_window_size=win_size, - label_decoder_version=label_decoder_version, + use_att_ctx_in_state=use_att_ctx_in_state, blank_decoder_version=blank_decoder_version, use_joint_model=use_joint_model, use_weight_feedback=use_weight_feedback, + label_decoder_state=label_decoder_state ) - return config_builder + alias = ( + f"win-size-{win_size}/" + f"{'w' if use_weight_feedback else 'wo'}-weight-feedback/" + f"{'w' if use_att_ctx_in_state else 'wo'}-att-ctx-in-state/" + f"{label_decoder_state}" + ) + + return alias, config_builder diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/train.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/train.py index c21b470f0..468a525d2 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/train.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/train.py @@ -6,16 +6,17 @@ from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.pipelines.pipeline_ls_conf.checkpoints import ( external_checkpoints, default_import_model_name, - get_center_window_baseline_v1_tf_checkpoint ) +from i6_experiments.users.schmitt.custom_load_params import load_missing_params def train_center_window_att_viterbi_from_scratch( alias: str, config_builder: SegmentalAttConfigBuilderRF, n_epochs_list: Tuple[int, ...], - time_rqmt: int = 168, + time_rqmt: int = 80, ): + batch_size = 15_000 for n_epochs in n_epochs_list: alias += "/train_from_scratch/%d-epochs_w-ctc-loss" % (n_epochs,) @@ -24,15 +25,41 @@ def train_center_window_att_viterbi_from_scratch( alias=alias, num_epochs=n_epochs, train_rqmt={ - "time": time_rqmt + "time": time_rqmt, + "horovod_num_processes": 4, + "distributed_launch_cmd": "torchrun" }, train_opts={ "dataset_opts": { "use_speed_pert": False, "epoch_wise_filter": {(1, 5): {"max_mean_len": 1000}} }, - "import_model_train_epoch1": None, - "lr_opts": {"type": "dyn_lr_lin_warmup_invsqrt_decay"}, + # "import_model_train_epoch1": None, + "accum_grad_multiple_step": 4, + "torch_distributed": {}, + "pos_emb_dropout": 0.1, + "rf_att_dropout_broadcast": False, + "batch_size": batch_size, + "batching": "laplace:.1000", + "lr_opts": { + "type": "dyn_lr_piecewise_linear", + "batch_size": batch_size, + "num_epochs": n_epochs, + "learning_rate": 1e-3, + }, + "aux_loss_layers": None, + "specaugment_steps": (5_000, 15_000, 25_000), + "grad_scaler": None, + "gradient_clip_global_norm": 5.0, + "optimizer": { + "class": "adamw", + "weight_decay_modules_blacklist": [ + "rf.Embedding", + "rf.LearnedRelativePositionalEncoding", + ], + "epsilon": 1e-16, + "weight_decay": 1e-6, + }, "train_def": viterbi_training, "train_step_func": _returnn_v2_train_step, } @@ -54,10 +81,15 @@ def train_center_window_att_viterbi_import_global_tf( config_builder: SegmentalAttConfigBuilderRF, n_epochs_list: Tuple[int, ...], const_lr_list: Tuple[float, ...] = (1e-4,), - time_rqmt: int = 30, - custom_missing_load_func: Optional[Callable] = None, + time_rqmt: int = 80, alignment_augmentation_opts: Optional[Dict] = None, ): + if not config_builder.use_att_ctx_in_state: + # only randomly init FF weights, since only the input dim of the lstm layer is different + custom_missing_load_func = load_missing_params + else: + custom_missing_load_func = None + for n_epochs in n_epochs_list: for const_lr in const_lr_list: train_alias = alias + f"/train_from_global_att_tf_checkpoint/standard-training/{n_epochs}-epochs_{const_lr}-const-lr_wo-ctc-loss" diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/global_att/baseline_v1/__init__.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/global_att/baseline_v1/__init__.py index 182f46415..31c6c5bab 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/global_att/baseline_v1/__init__.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/global_att/baseline_v1/__init__.py @@ -8,33 +8,60 @@ def run_exps(): - for model_alias, config_builder in baseline.global_att_baseline_rf(): - for train_alias, checkpoint in ( - (f"{model_alias}/import-global-tf_no-finetuning", external_checkpoints[default_import_model_name]), - ): - recog.global_att_returnn_label_sync_beam_search( - alias=train_alias, + for use_weight_feedback in (True,): + for model_alias, config_builder in baseline.global_att_baseline_rf(use_weight_feedback=use_weight_feedback): + for train_alias, checkpoint in ( + (f"{model_alias}/import-global-tf_no-finetuning", external_checkpoints[default_import_model_name]), + ): + recog.global_att_returnn_label_sync_beam_search( + alias=train_alias, + config_builder=config_builder, + checkpoint=checkpoint, + checkpoint_aliases=("best-4-avg",), + ) + + for train_alias, checkpoint in train.train_import_global_tf( + alias=model_alias, config_builder=config_builder, - checkpoint=checkpoint, - checkpoint_aliases=("best-4-avg",), - ) - recog.global_att_returnn_label_sync_beam_search( - alias=train_alias, + n_epochs_list=(10, 100), + const_lr_list=(1e-4,), + ): + recog.global_att_returnn_label_sync_beam_search( + alias=train_alias, + config_builder=config_builder, + checkpoint=checkpoint, + ) + + for use_weight_feedback in (True,): + for model_alias, config_builder in baseline.global_att_baseline_rf( + use_weight_feedback=use_weight_feedback, + use_att_ctx_in_state=False, + ): + for train_alias, checkpoint in train.train_import_global_tf( + alias=model_alias, config_builder=config_builder, - checkpoint=checkpoint, - checkpoint_aliases=("best-4-avg",), - pure_torch=True, - ) + n_epochs_list=(100,), + const_lr_list=(1e-4,), + ): + recog.global_att_returnn_label_sync_beam_search( + alias=train_alias, + config_builder=config_builder, + checkpoint=checkpoint, + ) - for train_alias, checkpoint in train.train_import_global_tf( - alias=model_alias, - config_builder=config_builder, - n_epochs_list=(10,), - const_lr_list=(1e-4,), - time_rqmt=4, + for use_weight_feedback in (False,): + for model_alias, config_builder in baseline.global_att_baseline_rf( + use_weight_feedback=use_weight_feedback, + use_att_ctx_in_state=False, ): - recog.global_att_returnn_label_sync_beam_search( - alias=train_alias, + for train_alias, checkpoint in train.train_import_global_tf( + alias=model_alias, config_builder=config_builder, - checkpoint=checkpoint, - ) + n_epochs_list=(300,), + const_lr_list=(1e-4,), + ): + recog.global_att_returnn_label_sync_beam_search( + alias=train_alias, + config_builder=config_builder, + checkpoint=checkpoint, + ) diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/global_att/baseline_v1/baseline.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/global_att/baseline_v1/baseline.py index f136850e4..c9a3a3c95 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/global_att/baseline_v1/baseline.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/global_att/baseline_v1/baseline.py @@ -5,24 +5,51 @@ from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.global_.model import from_scratch_model_def, _returnn_v2_get_model from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23.model_variants.model_variants_ls_conf import models from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23.pipelines.pipeline_ls_conf.global_att.baseline_v1.alias import alias as base_alias +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23.dependencies.labels.v2.librispeech.label_singletons import ( + LibrispeechBPE10025_LABELS, +LIBRISPEECH_CORPUS +) +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23.dependencies.general.returnn.exes import RETURNN_EXE_NEW, RETURNN_CURRENT_ROOT -def get_global_att_config_builder_rf(use_weight_feedback: bool = True, decoder_version: Optional[int] = None): - model_type = "librispeech_conformer_glob_att" - variant_name = "glob.conformer.mohammad.5.6" - variant_params = copy.deepcopy(models[model_type][variant_name]) - variant_params["network"]["use_weight_feedback"] = use_weight_feedback - variant_params["network"]["decoder_version"] = decoder_version +def get_global_att_config_builder_rf( + use_weight_feedback: bool = True, + use_att_ctx_in_state: bool = True, +): + variant_params = { + "dependencies": LibrispeechBPE10025_LABELS, + "dataset": { + "feature_type": "raw", + "corpus": LIBRISPEECH_CORPUS + }, + "config": { + "train_seq_ordering": "laplace:.1000" + }, + "network": {"length_scale": 1.0}, + "returnn_python_exe": RETURNN_EXE_NEW, + "returnn_root": RETURNN_CURRENT_ROOT + } config_builder = GlobalAttConfigBuilderRF( variant_params=variant_params, model_def=from_scratch_model_def, get_model_func=_returnn_v2_get_model, + use_weight_feedback=use_weight_feedback, + use_att_ctx_in_state=use_att_ctx_in_state, ) - return config_builder + alias = ( + f"{'w' if use_weight_feedback else 'wo'}-weight-feedback/" + f"{'w' if use_att_ctx_in_state else 'wo'}-att-ctx-in-state" + ) + + return alias, config_builder -def global_att_baseline_rf(): - alias = f"{base_alias}/baseline_rf" - yield alias, get_global_att_config_builder_rf(use_weight_feedback=True) +def global_att_baseline_rf(use_weight_feedback: bool = True, use_att_ctx_in_state: bool = True): + alias, config_builder = get_global_att_config_builder_rf( + use_weight_feedback=use_weight_feedback, + use_att_ctx_in_state=use_att_ctx_in_state, + ) + alias = f"{base_alias}/baseline_rf/{alias}" + yield alias, config_builder diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/global_att/train.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/global_att/train.py index d5e500543..6d02cab56 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/global_att/train.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/global_att/train.py @@ -5,6 +5,7 @@ from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23.train_new import GlobalTrainExperiment from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.pipelines.pipeline_ls_conf.checkpoints import external_checkpoints, default_import_model_name from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.global_.train import _returnn_v2_train_step, from_scratch_training +from i6_experiments.users.schmitt.custom_load_params import load_missing_params def train_from_scratch( @@ -56,11 +57,39 @@ def train_import_global_tf( config_builder: GlobalAttConfigBuilderRF, n_epochs_list: Tuple[int, ...], const_lr_list: Tuple[float, ...], - time_rqmt: int = 168, + time_rqmt: int = 80, ): + if not config_builder.use_att_ctx_in_state: + # only randomly init FF weights, since only the input dim of the lstm layer is different + custom_missing_load_func = load_missing_params + else: + custom_missing_load_func = None + for n_epochs, const_lr in itertools.product(n_epochs_list, const_lr_list): train_alias = alias + f"/train_from_global_att_tf_checkpoint/standard-training/{n_epochs}-epochs_{const_lr}-const-lr_wo-ctc-loss" + train_opts = { + "preload_from_files": { + "pretrained_global_att_params": { + "filename": external_checkpoints[default_import_model_name], + "init_for_train": True, + } + }, + "train_def": from_scratch_training, + "train_step_func": _returnn_v2_train_step, + "batching": "random", + "aux_loss_layers": None, + "lr_opts": { + "type": "const_then_linear", + "const_lr": const_lr, + "const_frac": 1 / 3, + "final_lr": 1e-6, + "num_epochs": n_epochs + }, + } + if custom_missing_load_func: + train_opts["preload_from_files"]["pretrained_global_att_params"]["custom_missing_load_func"] = custom_missing_load_func + train_exp = GlobalTrainExperiment( config_builder=config_builder, alias=train_alias, @@ -68,25 +97,7 @@ def train_import_global_tf( train_rqmt={ "time": time_rqmt }, - train_opts={ - "preload_from_files": { - "pretrained_global_att_params": { - "filename": external_checkpoints[default_import_model_name], - "init_for_train": True, - } - }, - "train_def": from_scratch_training, - "train_step_func": _returnn_v2_train_step, - "batching": "random", - "aux_loss_layers": None, - "lr_opts": { - "type": "const_then_linear", - "const_lr": const_lr, - "const_frac": 1 / 3, - "final_lr": 1e-6, - "num_epochs": n_epochs - }, - } + train_opts=train_opts ) checkpoints, model_dir, learning_rates = train_exp.run_train() From fb8b0b1264380cd79526cd167c4d7bc931898b27 Mon Sep 17 00:00:00 2001 From: Nick Rossenbach Date: Tue, 28 May 2024 11:51:35 +0200 Subject: [PATCH 066/227] ConformerV2 setup --- .../ctc_rnnt_standalone_2024/default_tools.py | 4 +- .../ctc_bpe/low_vocab_exps_confv2.py | 229 ++++++++++++++++++ .../ctc/conformer_0524/__init__.py | 0 ...elsV2_VGG4LayerActFrontendV1_auxloss_v1.py | 197 +++++++++++++++ ...2_VGG4LayerActFrontendV1_auxloss_v1_cfg.py | 90 +++++++ 5 files changed, 518 insertions(+), 2 deletions(-) create mode 100644 users/rossenbach/experiments/librispeech/ctc_rnnt_standalone_2024/experiments/ctc_bpe/low_vocab_exps_confv2.py create mode 100644 users/rossenbach/experiments/librispeech/ctc_rnnt_standalone_2024/pytorch_networks/ctc/conformer_0524/__init__.py create mode 100644 users/rossenbach/experiments/librispeech/ctc_rnnt_standalone_2024/pytorch_networks/ctc/conformer_0524/i6modelsV2_VGG4LayerActFrontendV1_auxloss_v1.py create mode 100644 users/rossenbach/experiments/librispeech/ctc_rnnt_standalone_2024/pytorch_networks/ctc/conformer_0524/i6modelsV2_VGG4LayerActFrontendV1_auxloss_v1_cfg.py diff --git a/users/rossenbach/experiments/librispeech/ctc_rnnt_standalone_2024/default_tools.py b/users/rossenbach/experiments/librispeech/ctc_rnnt_standalone_2024/default_tools.py index 69fbddcc4..85883940d 100644 --- a/users/rossenbach/experiments/librispeech/ctc_rnnt_standalone_2024/default_tools.py +++ b/users/rossenbach/experiments/librispeech/ctc_rnnt_standalone_2024/default_tools.py @@ -13,13 +13,13 @@ RETURNN_EXE = tk.Path("/usr/bin/python3", hash_overwrite="GENERIC_RETURNN_LAUNCHER") MINI_RETURNN_ROOT = CloneGitRepositoryJob( - "https://github.com/JackTemaki/MiniReturnn", commit="3f47cb87f298254d86d9faf37916067dd2c74674" + "https://github.com/JackTemaki/MiniReturnn", commit="a8b6c2551d72d68b9173654c0254a8944e62b293" ).out_repository.copy() MINI_RETURNN_ROOT.hash_overwrite = "LIBRISPEECH_DEFAULT_RETURNN_ROOT" I6_MODELS_REPO_PATH = CloneGitRepositoryJob( url="https://github.com/rwth-i6/i6_models", - commit="933c6c13f7d6c74e5a59af0257e17c208dae9da3", + commit="918143c1011fe5a19c5fcfb61fe05050a8d58a2b", checkout_folder_name="i6_models", ).out_repository.copy() I6_MODELS_REPO_PATH.hash_overwrite = "LIBRISPEECH_DEFAULT_I6_MODELS" diff --git a/users/rossenbach/experiments/librispeech/ctc_rnnt_standalone_2024/experiments/ctc_bpe/low_vocab_exps_confv2.py b/users/rossenbach/experiments/librispeech/ctc_rnnt_standalone_2024/experiments/ctc_bpe/low_vocab_exps_confv2.py new file mode 100644 index 000000000..817aef167 --- /dev/null +++ b/users/rossenbach/experiments/librispeech/ctc_rnnt_standalone_2024/experiments/ctc_bpe/low_vocab_exps_confv2.py @@ -0,0 +1,229 @@ +from sisyphus import tk + +import copy +from dataclasses import asdict +import numpy as np +from typing import cast + +from i6_core.tools.parameter_tuning import GetOptimalParametersAsVariableJob + +from i6_experiments.common.setups.returnn.datastreams.vocabulary import LabelDatastream + +from ...data.common import DatasetSettings, build_test_dataset +from ...data.bpe import build_bpe_training_datasets, get_text_lexicon +from ...default_tools import RETURNN_EXE, MINI_RETURNN_ROOT +from ...lm import get_4gram_binary_lm +from ...pipeline import training, prepare_asr_model, search, ASRModel +from ...storage import add_ctc_model + + + +def bpe_ls960_1023_low_vocab_test_confv2(): + prefix_name = "experiments/librispeech/ctc_rnnt_standalone_2024/ls960_ctc_bpe_low_vocab" + + train_settings = DatasetSettings( + preemphasis=0.97, # TODO: Check if this is really useful + peak_normalization=True, # TODO: Also check if really useful, older Attention setups did not have that + # training + train_partition_epoch=10, + train_seq_ordering="laplace:.1000", + ) + + arpa_4gram_lm = get_4gram_binary_lm(prefix_name=prefix_name) + + default_returnn = { + "returnn_exe": RETURNN_EXE, + "returnn_root": MINI_RETURNN_ROOT, + } + + from ...pytorch_networks.ctc.decoder.flashlight_ctc_v1 import DecoderConfig + from ...pytorch_networks.ctc.decoder.greedy_bpe_ctc_v3 import DecoderConfig as GreedyDecoderConfig + + + + from ...pytorch_networks.ctc.conformer_0524.i6modelsV2_VGG4LayerActFrontendV1_auxloss_v1_cfg import \ + SpecaugConfig, VGG4LayerActFrontendV1Config_mod, ModelConfig, LogMelFeatureExtractionV1Config + + fe_config = LogMelFeatureExtractionV1Config( + sample_rate=16000, + win_size=0.025, + hop_size=0.01, + f_min=60, + f_max=7600, + min_amp=1e-10, + num_filters=80, + center=False, + ) + specaug_config = SpecaugConfig( + repeat_per_n_frames=25, + max_dim_time=20, + max_dim_feat=8, # Jingjing style + num_repeat_feat=5, + ) + frontend_config = VGG4LayerActFrontendV1Config_mod( + in_features=80, + conv1_channels=32, + conv2_channels=64, + conv3_channels=64, + conv4_channels=32, + conv_kernel_size=(3, 3), + conv_padding=None, + pool1_kernel_size=(2, 1), + pool1_stride=(2, 1), + pool1_padding=None, + pool2_kernel_size=(2, 1), + pool2_stride=(2, 1), + pool2_padding=None, + activation_str="ReLU", + out_features=512, + activation=None, + ) + + + + train_config_24gbgpu_amp = { + "optimizer": {"class": "adamw", "epsilon": 1e-16, "weight_decay": 1e-3}, + "learning_rates": list(np.linspace(7e-6, 5e-4, 240)) + list( + np.linspace(5e-4, 5e-5, 240)) + list(np.linspace(5e-5, 1e-7, 20)), + ############# + "batch_size": 360 * 16000, + "max_seq_length": {"audio_features": 35 * 16000}, + "accum_grad_multiple_step": 1, + "torch_amp_options": {"dtype": "bfloat16"}, + } + + network_module = "ctc.conformer_0524.i6modelsV2_VGG4LayerActFrontendV1_auxloss_v1" + global_train_args = { + "config": train_config_24gbgpu_amp, + "network_module": network_module, + "debug": True, + } + + def tune_and_evaluate_helper(training_name, dev_dataset_tuples, test_dataset_tuples, asr_model, base_decoder_config, lm_scales, prior_scales): + tune_parameters = [] + tune_values_clean = [] + tune_values_other = [] + for lm_weight in lm_scales: + for prior_scale in prior_scales: + decoder_config = copy.deepcopy(base_decoder_config) + decoder_config.lm_weight = lm_weight + decoder_config.prior_scale = prior_scale + search_name = training_name + "/search_lm%.1f_prior%.1f" % (lm_weight, prior_scale) + search_jobs, wers = search( + search_name, + forward_config={}, + asr_model=asr_model, + decoder_module="ctc.decoder.flashlight_ctc_v1", + decoder_args={"config": asdict(decoder_config)}, + test_dataset_tuples=dev_dataset_tuples, + **default_returnn + ) + tune_parameters.append((lm_weight, prior_scale)) + tune_values_clean.append((wers[search_name + "/dev-clean"])) + tune_values_other.append((wers[search_name + "/dev-other"])) + + for key, tune_values in [("test-clean", tune_values_clean), ("test-other", tune_values_other)]: + pick_optimal_params_job = GetOptimalParametersAsVariableJob(parameters=tune_parameters, values=tune_values, mode="minimize") + pick_optimal_params_job.add_alias(training_name + f"/pick_best_{key}") + decoder_config = copy.deepcopy(base_decoder_config) + decoder_config.lm_weight = pick_optimal_params_job.out_optimal_parameters[0] + decoder_config.prior_scale = pick_optimal_params_job.out_optimal_parameters[1] + search_jobs, wers = search( + training_name, forward_config={}, asr_model=asr_model, decoder_module="ctc.decoder.flashlight_ctc_v1", + decoder_args={"config": asdict(decoder_config)}, test_dataset_tuples={key: test_dataset_tuples[key]}, + **default_returnn + ) + + def greedy_search_helper( + training_name: str, + asr_model: ASRModel, + decoder_config: GreedyDecoderConfig + ): + # remove prior if exists + asr_model = copy.deepcopy(asr_model) + asr_model.prior_file = None + + search_name = training_name + "/search_greedy" + search_jobs, wers = search( + search_name, + forward_config={}, + asr_model=asr_model, + decoder_module="ctc.decoder.greedy_bpe_ctc_v3", + decoder_args={"config": asdict(decoder_config)}, + test_dataset_tuples={**dev_dataset_tuples, **test_dataset_tuples}, + **default_returnn, + ) + + for BPE_SIZE in [128, 512]: + + # build the training datasets object containing train, cv, dev-train and the extern_data dict + train_data_bpe = build_bpe_training_datasets( + prefix=prefix_name, + librispeech_key="train-other-960", + bpe_size=BPE_SIZE, + settings=train_settings, + use_postfix=False, + ) + label_datastream_bpe = cast(LabelDatastream, train_data_bpe.datastreams["labels"]) + vocab_size_without_blank = label_datastream_bpe.vocab_size + + dev_dataset_tuples = {} + for testset in ["dev-clean", "dev-other"]: + dev_dataset_tuples[testset] = build_test_dataset( + dataset_key=testset, + settings=train_settings, + ) + + test_dataset_tuples = {} + for testset in ["test-clean", "test-other"]: + test_dataset_tuples[testset] = build_test_dataset( + dataset_key=testset, + settings=train_settings, + ) + + model_config = ModelConfig( + feature_extraction_config=fe_config, + frontend_config=frontend_config, + specaug_config=specaug_config, + label_target_size=vocab_size_without_blank, + conformer_size=512, + num_layers=12, + num_heads=8, + ff_dim=2048, + att_weights_dropout=0.1, + conv_dropout=0.1, + ff_dropout=0.1, + mhsa_dropout=0.1, + conv_kernel_size=31, + final_dropout=0.1, + specauc_start_epoch=1, + module_list=["ff", "conv", "mhsa", "ff"], + module_scales=[0.5, 1.0, 1.0, 0.5], + aux_ctc_loss_layers=[3, 7, 11], # 4, 8, 12 when counting from 1 + aux_ctc_loss_scales=[0.3, 0.3, 1.0], + ) + model_config_decoding = copy.deepcopy(model_config) + model_config_decoding.aux_ctc_loss_scales = [0.0, 0.0, 1.0] # for decoding use result only of last layer + + default_decoder_config_bpe = DecoderConfig( + lexicon=get_text_lexicon(prefix=prefix_name, librispeech_key="train-other-960", bpe_size=BPE_SIZE), + returnn_vocab=label_datastream_bpe.vocab, + beam_size=1024, + beam_size_token=16, # makes it much faster + arpa_lm=arpa_4gram_lm, + beam_threshold=14, + ) + + train_args = copy.deepcopy(global_train_args) + train_args["net_args"] = {"model_config_dict": asdict(model_config)} + + train_args_decoding = copy.deepcopy(train_args) + train_args_decoding["net_args"] = {"model_config_dict": asdict(model_config_decoding)} + + training_name = prefix_name + "/" + str(BPE_SIZE) + "/" + network_module + ".512dim_convfirst_sub4_24gbgpu_50eps" + train_job = training(training_name, train_data_bpe, train_args, num_epochs=500, **default_returnn) + train_job.rqmt["gpu_mem"] = 24 + asr_model = prepare_asr_model( + training_name, train_job, train_args_decoding, with_prior=True, datasets=train_data_bpe, get_specific_checkpoint=500 + ) + tune_and_evaluate_helper(training_name, dev_dataset_tuples, test_dataset_tuples, asr_model, default_decoder_config_bpe, lm_scales=[1.6, 1.8, 2.0], prior_scales=[0.2, 0.3, 0.4]) diff --git a/users/rossenbach/experiments/librispeech/ctc_rnnt_standalone_2024/pytorch_networks/ctc/conformer_0524/__init__.py b/users/rossenbach/experiments/librispeech/ctc_rnnt_standalone_2024/pytorch_networks/ctc/conformer_0524/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/users/rossenbach/experiments/librispeech/ctc_rnnt_standalone_2024/pytorch_networks/ctc/conformer_0524/i6modelsV2_VGG4LayerActFrontendV1_auxloss_v1.py b/users/rossenbach/experiments/librispeech/ctc_rnnt_standalone_2024/pytorch_networks/ctc/conformer_0524/i6modelsV2_VGG4LayerActFrontendV1_auxloss_v1.py new file mode 100644 index 000000000..31c7f48ad --- /dev/null +++ b/users/rossenbach/experiments/librispeech/ctc_rnnt_standalone_2024/pytorch_networks/ctc/conformer_0524/i6modelsV2_VGG4LayerActFrontendV1_auxloss_v1.py @@ -0,0 +1,197 @@ +""" +Like v2, but with i6_models specaugment (v3) +and now controllable start time for when specaugment is applied (v4) +and with the proper feature extraction from i6-models +""" + +import numpy as np +import torch +from torch import nn + +from i6_models.parts.conformer.norm import LayerNormNC +from i6_models.assemblies.conformer.conformer_v2 import ConformerEncoderV2, ConformerEncoderV2Config, ConformerBlockV2Config +from i6_models.config import ModuleFactoryV1 +from i6_models.parts.frontend.vgg_act import VGG4LayerActFrontendV1 + +from i6_models.parts.conformer.convolution import ConformerConvolutionV1Config +from i6_models.parts.conformer.feedforward import ConformerPositionwiseFeedForwardV1Config +from i6_models.parts.conformer.mhsa import ConformerMHSAV1Config +from i6_models.primitives.specaugment import specaugment_v1_by_length +from i6_models.primitives.feature_extraction import LogMelFeatureExtractionV1 + +from returnn.torch.context import get_run_ctx + +from .i6modelsV2_VGG4LayerActFrontendV1_auxloss_v1_cfg import ModelConfig + + +def mask_tensor(tensor: torch.Tensor, seq_len: torch.Tensor) -> torch.Tensor: + """ + mask a tensor with a "positive" mask (boolean true means position is used) + + This function is traceable. + + :param tensor: [B,T,....] + :param seq_len: [B] + :return: [B,T] + """ + seq_len = seq_len.to(device=tensor.device) + r = torch.arange(tensor.shape[1], device=tensor.device) # [T] + seq_mask = torch.less(r[None, :], seq_len[:, None]) # broadcast to [B,T] + return seq_mask + + +class Model(torch.nn.Module): + def __init__(self, model_config_dict, **kwargs): + super().__init__() + self.cfg = ModelConfig.from_dict(model_config_dict) + frontend_config = self.cfg.frontend_config + conformer_size = self.cfg.conformer_size + conformer_config = ConformerEncoderV2Config( + num_layers=self.cfg.num_layers, + frontend=ModuleFactoryV1(module_class=VGG4LayerActFrontendV1, cfg=frontend_config), + block_cfg=ConformerBlockV2Config( + ff_cfg=ConformerPositionwiseFeedForwardV1Config( + input_dim=conformer_size, + hidden_dim=self.cfg.ff_dim, + dropout=self.cfg.ff_dropout, + activation=nn.functional.silu, + ), + mhsa_cfg=ConformerMHSAV1Config( + input_dim=conformer_size, + num_att_heads=self.cfg.num_heads, + att_weights_dropout=self.cfg.att_weights_dropout, + dropout=self.cfg.mhsa_dropout, + ), + conv_cfg=ConformerConvolutionV1Config( + channels=conformer_size, kernel_size=self.cfg.conv_kernel_size, dropout=self.cfg.conv_dropout, activation=nn.functional.silu, + norm=LayerNormNC(conformer_size) + ), + modules=self.cfg.module_list, + scales=self.cfg.module_scales, + ), + ) + + self.feature_extraction = LogMelFeatureExtractionV1(cfg=self.cfg.feature_extraction_config) + self.conformer = ConformerEncoderV2(cfg=conformer_config) + self.num_output_linears = 1 if self.cfg.aux_ctc_loss_layers is None else len(self.cfg.aux_ctc_loss_layers) + self.output_linears = nn.ModuleList([ + nn.Linear(conformer_size, self.cfg.label_target_size + 1) # + CTC blank + for _ in range(self.num_output_linears) + ]) + self.output_dropout = nn.Dropout(p=self.cfg.final_dropout) + self.specaug_start_epoch = self.cfg.specauc_start_epoch + + # No particular weight init! + + def forward( + self, + raw_audio: torch.Tensor, + raw_audio_len: torch.Tensor, + ): + """ + :param raw_audio: Audio samples as [B, T, 1] + :param raw_audio_len: length of T as [B] + :return: list of logprobs [B, T, #labels + blank], mask [B, T] + """ + + squeezed_features = torch.squeeze(raw_audio, dim=-1) + with torch.no_grad(): + audio_features, audio_features_len = self.feature_extraction(squeezed_features, raw_audio_len) + + run_ctx = get_run_ctx() + if self.training and run_ctx.epoch >= self.specaug_start_epoch: + audio_features_masked_2 = specaugment_v1_by_length( + audio_features, + time_min_num_masks=2, # TODO: make configurable + time_max_mask_per_n_frames=self.cfg.specaug_config.repeat_per_n_frames, + time_mask_max_size=self.cfg.specaug_config.max_dim_time, + freq_min_num_masks=2, + freq_mask_max_size=self.cfg.specaug_config.max_dim_feat, + freq_max_num_masks=self.cfg.specaug_config.num_repeat_feat, + ) + else: + audio_features_masked_2 = audio_features + + conformer_in = audio_features_masked_2 + # create the mask for the conformer input + mask = mask_tensor(conformer_in, audio_features_len) + + + return_layers = self.cfg.aux_ctc_loss_layers or [self.cfg.num_layers - 1] + print(return_layers) + conformer_out_layers, out_mask = self.conformer(conformer_in, mask, return_layers=return_layers) + log_probs_list = [] + for i, (out_layer, scale) in enumerate(zip(conformer_out_layers, self.cfg.aux_ctc_loss_scales)): + if scale == 0.0: + continue + conformer_out = self.output_dropout(out_layer) + logits = self.output_linears[i](conformer_out) + log_probs = torch.log_softmax(logits, dim=2) + log_probs_list.append(log_probs) + + if len(log_probs_list) == 1: + log_probs_list = log_probs_list[0] + + return log_probs_list, torch.sum(out_mask, dim=1) + + +def train_step(*, model: Model, data, run_ctx, **kwargs): + + raw_audio = data["raw_audio"] # [B, T', F] + raw_audio_len = data["raw_audio:size1"].to("cpu") # [B] + + labels = data["labels"] # [B, N] (sparse) + labels_len = data["labels:size1"] # [B, N] + + logprobs_list, audio_features_len = model( + raw_audio=raw_audio, + raw_audio_len=raw_audio_len, + ) + for logprobs, layer_index, scale in zip(logprobs_list, model.cfg.aux_ctc_loss_layers, model.cfg.aux_ctc_loss_scales): + transposed_logprobs = torch.permute(logprobs, (1, 0, 2)) # CTC needs [T, B, F] + ctc_loss = nn.functional.ctc_loss( + transposed_logprobs, + labels, + input_lengths=audio_features_len, + target_lengths=labels_len, + blank=model.cfg.label_target_size, + reduction="sum", + zero_infinity=True, + ) + num_phonemes = torch.sum(labels_len) + run_ctx.mark_as_loss(name=f"ctc_loss_layer{layer_index + 1}", loss=ctc_loss, scale=scale, inv_norm_factor=num_phonemes) + + +def prior_init_hook(run_ctx, **kwargs): + # we are storing durations, but call it output.hdf to match + # the default output of the ReturnnForwardJob + run_ctx.sum_probs = None + run_ctx.sum_frames = 0 + + +def prior_finish_hook(run_ctx, **kwargs): + all_frames = run_ctx.sum_frames.detach().cpu().numpy() + all_probs = run_ctx.sum_probs.detach().cpu().numpy() + average_probs = all_probs / all_frames + log_average_probs = np.log(average_probs) + print("Prior sum in std-space (should be close to 1.0):", np.sum(average_probs)) + with open("prior.txt", 'w') as f: + np.savetxt(f, log_average_probs, delimiter=' ') + print("Saved prior in prior.txt in +log space.") + + +def prior_step(*, model: Model, data, run_ctx, **kwargs): + raw_audio = data["raw_audio"] # [B, T', F] + raw_audio_len = data["raw_audio:size1"] # [B] + + logprobs, audio_features_len = model( + raw_audio=raw_audio, + raw_audio_len=raw_audio_len, + ) + + probs = torch.exp(logprobs) + run_ctx.sum_frames = run_ctx.sum_frames + torch.sum(audio_features_len) + if run_ctx.sum_probs is None: + run_ctx.sum_probs = torch.sum(probs, dim=(0, 1)) + else: + run_ctx.sum_probs += torch.sum(probs, dim=(0, 1)) diff --git a/users/rossenbach/experiments/librispeech/ctc_rnnt_standalone_2024/pytorch_networks/ctc/conformer_0524/i6modelsV2_VGG4LayerActFrontendV1_auxloss_v1_cfg.py b/users/rossenbach/experiments/librispeech/ctc_rnnt_standalone_2024/pytorch_networks/ctc/conformer_0524/i6modelsV2_VGG4LayerActFrontendV1_auxloss_v1_cfg.py new file mode 100644 index 000000000..b2e7bbd93 --- /dev/null +++ b/users/rossenbach/experiments/librispeech/ctc_rnnt_standalone_2024/pytorch_networks/ctc/conformer_0524/i6modelsV2_VGG4LayerActFrontendV1_auxloss_v1_cfg.py @@ -0,0 +1,90 @@ +""" +Config for the base CTC models v4, including specaug start time +""" + +from dataclasses import dataclass + +import torch +from torch import nn +from typing import Callable, List, Optional, Type, Union + +from i6_models.assemblies.conformer.conformer_v2 import ConformerBlockV2Config, ConformerBlockV2 +from i6_models.parts.frontend.vgg_act import VGG4LayerActFrontendV1Config +from i6_models.config import ModuleFactoryV1, ModelConfiguration +from i6_models.primitives.feature_extraction import LogMelFeatureExtractionV1Config + + +@dataclass(kw_only=True) +class VGG4LayerActFrontendV1Config_mod(VGG4LayerActFrontendV1Config): + activation_str: str = "" + activation: Optional[Union[nn.Module, Callable[[torch.Tensor], torch.Tensor]]] = None + + @classmethod + def from_dict(cls, d): + d = d.copy() + activation_str = d.pop("activation_str") + if activation_str == "ReLU": + from torch.nn import ReLU + activation = ReLU() + else: + assert False, "Unsupported activation %s" % d["activation_str"] + d["activation"] = activation + return VGG4LayerActFrontendV1Config(**d) + + +@dataclass +class ConformerEncoderV2Config(ModelConfiguration): + """ + Attributes: + num_layers: Number of conformer layers in the conformer encoder + frontend: A pair of ConformerFrontend and corresponding config + block_cfg: Configuration for ConformerBlockV1 + """ + + num_layers: int + + # nested configurations + frontend: ModuleFactoryV1 + block_cfg: ConformerBlockV2Config + + +@dataclass +class SpecaugConfig(ModelConfiguration): + repeat_per_n_frames: int + max_dim_time: int + num_repeat_feat: int + max_dim_feat: int + + + +@dataclass +class ModelConfig(): + feature_extraction_config: LogMelFeatureExtractionV1Config + frontend_config: VGG4LayerActFrontendV1Config + specaug_config: SpecaugConfig + specauc_start_epoch: int + label_target_size: int + conformer_size: int + num_layers: int + num_heads: int + ff_dim: int + att_weights_dropout: float + conv_dropout: float + ff_dropout: float + mhsa_dropout: float + conv_kernel_size: int + final_dropout: float + module_list: List[str] + module_scales: List[float] + aux_ctc_loss_layers: Optional[List[int]] + aux_ctc_loss_scales: Optional[List[float]] + + @classmethod + def from_dict(cls, d): + d = d.copy() + d["feature_extraction_config"] = LogMelFeatureExtractionV1Config(**d["feature_extraction_config"]) + d["frontend_config"] = VGG4LayerActFrontendV1Config_mod.from_dict(d["frontend_config"]) + d["specaug_config"] = SpecaugConfig(**d["specaug_config"]) + return ModelConfig(**d) + + From 5d5852c4620761f8bc835f5451c0b1b0d7ab36cf Mon Sep 17 00:00:00 2001 From: Benedikt Hilmes Date: Tue, 28 May 2024 13:26:27 +0200 Subject: [PATCH 067/227] updates --- .../common/setups/rasr/hybrid_system.py | 229 +++++-- users/hilmes/common/setups/rasr/nn_system.py | 2 +- .../hybrid/distil_hubert/corpus_data.py | 40 +- .../distil_hubert/distill_hubert_args.py | 129 +--- .../pytorch_networks/distill_hubert_v1.py | 70 +-- .../pytorch_networks/prior/basic.py | 12 +- .../pytorch_networks/prior/basic.py | 24 + .../pytorch_networks/prior/prior_callback.py | 16 + .../hybrid/torch_baselines/torch_args.py | 350 ++++++++--- .../experiments/tedlium2/standalone/config.py | 5 +- .../tedlium2/standalone/default_tools.py | 6 +- .../experiments/ctc_bpe/baseline.py | 2 +- .../experiments/ctc_phon/baseline.py | 567 ++++++++---------- .../experiments/ctc_phon/tune_eval.py | 135 +++++ .../conformer_v1_uni_aggr_cfg_v1.py | 85 +++ .../conformer_v1_uni_aggr_v1.py | 278 +++++++++ .../conformer_1023/quant/baseline_quant_v1.py | 5 +- .../modules/onnx_precomputed_hybrid_system.py | 11 +- .../modules/pytorch_onnx_hybrid_system.py | 139 ++++- users/hilmes/tools/onnx.py | 100 ++- 20 files changed, 1535 insertions(+), 670 deletions(-) create mode 100644 users/hilmes/experiments/tedlium2/standalone/experiments/ctc_phon/tune_eval.py create mode 100644 users/hilmes/experiments/tedlium2/standalone/pytorch_networks/ctc/conformer_1023/conformer_v1_uni_aggr_cfg_v1.py create mode 100644 users/hilmes/experiments/tedlium2/standalone/pytorch_networks/ctc/conformer_1023/conformer_v1_uni_aggr_v1.py diff --git a/users/hilmes/common/setups/rasr/hybrid_system.py b/users/hilmes/common/setups/rasr/hybrid_system.py index bfd1211d9..9bf853c9f 100644 --- a/users/hilmes/common/setups/rasr/hybrid_system.py +++ b/users/hilmes/common/setups/rasr/hybrid_system.py @@ -57,21 +57,31 @@ def calc_stat(ls): def hybrid_report_format(report: _Report_Type) -> str: quants = report.pop("quant") - extra_ls = ["iter", "filter", "quant_min_max", "quant_entropy", "quant_percentile", "rtf-intel"] + loss_tables = report.pop("loss_tables") + loss_values = {} + if len(loss_tables) > 0: + for job in loss_tables: + with open(loss_tables[job].out_files["loss_table"]) as f: + for line in f: + loss_values[line.split(" ")[0]] = float(line.split(" ")[1].strip()) + extra_ls = ["iter", "filter", "quant_min_max", "quant_entropy", "quant_percentile", "rtf-intel", "loss_table"] out = [(recog, str(report[recog])) for recog in report if not any(extra in recog for extra in extra_ls)] out = sorted(out, key=lambda x: float(x[1])) - best_ls = [out[0]] + best_ls = [] + if len(out) > 0: + best_ls.append(out[0]) for extra in extra_ls: if extra == "iter": - for quant, count in itertools.product(["min_max", "entropy", "percentile"], ["10", "500", "1000"]): + for quant, count in itertools.product(["min_max", "entropy", "percentile"], ["1", "2", "3", "4", "5", "10", "100", "500", "1000", "10000"]): others = ["seed", "avrg", "filter", "rtf"] out2 = [(recog, str(report[recog])) for recog in report if "iter" in recog and quant in recog and (recog.endswith(count) or recog.endswith(count + "-optlm")) and not any(x in report for x in others)] out2 = sorted(out2, key=lambda x: float(x[1])) if len(out2) > 0: ex_str = calc_stat(out2) + out.append(('', '')) out.append((extra + "_" + quant + "_" + count, ex_str)) - out.extend(out2[:3]) - out.extend(out2[-3:]) + out.extend(out2[:5]) + out.extend(out2[-5:]) best_ls.append(out2[0]) # avg list out2 = [(recog, str(report[recog])) for recog in report if "iter" in recog and quant in recog and ( @@ -80,9 +90,10 @@ def hybrid_report_format(report: _Report_Type) -> str: out2 = sorted(out2, key=lambda x: float(x[1])) if len(out2) > 0: ex_str = calc_stat(out2) + out.append(('', '')) out.append((extra + "_avrg" + "_" + quant + "_" + count, ex_str)) - out.extend(out2[:3]) - out.extend(out2[-3:]) + out.extend(out2[:5]) + out.extend(out2[-5:]) best_ls.append(out2[0]) # different seeds for seed in ["24, 2005, 5"]: @@ -93,20 +104,21 @@ def hybrid_report_format(report: _Report_Type) -> str: if len(out2) > 0: ex_str = calc_stat(out2) out.append((quant + "_seed_" + seed + "_" + extra + "-" + count, ex_str)) - out.extend(out2[:3]) - out.extend(out2[-3:]) + out.extend(out2[:5]) + out.extend(out2[-5:]) best_ls.append(out2[0]) elif extra == "filter": # max and min len filter methods - for quant, count, mode, thresh in itertools.product(["min_max", "entropy", "percentile"], ["10", "500", "1000"], ["max_calib_len_", "min_calib_len_"], ["500", "1000" "1500"]): + for quant, count, mode, thresh in itertools.product(["min_max", "entropy", "percentile"], ["10", "500", "1000"], ["max_calib_len_", "min_calib_len_"], ["50", "100", "250", "400", "500", "1000" "1500"]): out2 = [(recog, str(report[recog])) for recog in report if "filter" in recog and quant in recog and ( - recog.endswith(count) or recog.endswith(count + "-optlm")) and mode+thresh in recog] + recog.endswith(count) or recog.endswith(count + "-optlm")) and mode+thresh+"-" in recog] out2 = sorted(out2, key=lambda x: float(x[1])) if len(out2) > 0: ex_str = calc_stat(out2) + out.append(('', '')) out.append((extra + "_" + mode + thresh + "_" + quant + "_" + count, ex_str)) - out.extend(out2[:3]) - out.extend(out2[-3:]) + out.extend(out2[:5]) + out.extend(out2[-5:]) best_ls.append(out2[0]) # partition filter methods partitions = set() @@ -123,9 +135,10 @@ def hybrid_report_format(report: _Report_Type) -> str: out2 = sorted(out2, key=lambda x: float(x[1])) if len(out2) > 0: ex_str = calc_stat(out2) + out.append(('', '')) out.append((extra + "_" + mode + thresh + "_" + quant + "_" + count, ex_str)) - out.extend(out2[:3]) - out.extend(out2[-3:]) + out.extend(out2[:5]) + out.extend(out2[-5:]) best_ls.append(out2[0]) # budget filter methods budgets = set() @@ -135,21 +148,73 @@ def hybrid_report_format(report: _Report_Type) -> str: for i, x in enumerate(spl): if x == "budget": budgets.add(spl[i+1].split("-")[0]) # add the number after the partition which gives identification - for quant, thresh in itertools.product(["min_max", "entropy", "percentile"], budgets): + for quant, thresh, remaind in itertools.product(["min_max", "entropy", "percentile"], budgets, ["0.01", "0.005"]): mode = "budget_" - out2 = [(recog, str(report[recog])) for recog in report if "filter" in recog and quant in recog and mode+thresh in recog] + out2 = [(recog, str(report[recog])) for recog in report if "filter" in recog and quant in recog and mode+thresh+"_"+remaind in recog] out2 = sorted(out2, key=lambda x: float(x[1])) tmp = [] + sequences = [] + losses = [] + wers = [] for name, value in out2: job_ls = [quants[x] for x in quants if name.split("/")[1].split("-")[0] == x.split("/")[-2] and quant in x and mode+thresh in x] assert len(job_ls) == 1, (job_ls, out2, quants) + with open(job_ls[0].out_seq_info, "rt") as f: + loss_tmp = [] + sequences_tmp = [] + for line in f: + sequences_tmp.append(line.split(" ")[0].strip()[:-1]) + loss_tmp.append(loss_values[line.split(" ")[0].strip()[:-1]]) + losses.append(sum(loss_tmp)) + sequences.append(sequences_tmp) + wers.append(float(value)) tmp.append((name, value, str(job_ls[0].out_num_seqs))) out2 = tmp if len(out2) > 0: ex_str = calc_stat(out2) - out.append((extra + "_" + mode + thresh + "_" + quant, ex_str)) - out.extend(out2[:3]) - out.extend(out2[-3:]) + out.append(('', '')) + out.append((extra + "_" + mode + thresh + "_" + remaind + "_" + quant, ex_str)) + out.append(("Correlation between loss and drawn sequence", str(np.corrcoef(wers, losses)[0, 1]))) + out.extend(out2[:5]) + out.extend(out2[-5:]) + best_ls.append(out2[0]) + # range filter methods + ranges = set() + for recog in report: + if "range_len" in recog: + spl = recog.split("_") + for i, x in enumerate(spl): + if x == "range": + ranges.add(f"{spl[i+2]}_{spl[i+3].split('-')[0]}") # add the number after the partition which gives identification + for quant, ran in itertools.product(["min_max", "entropy", "percentile"], ranges): + mode = "range_len_" + out2 = [(recog, str(report[recog])) for recog in report if "filter" in recog and quant in recog and mode+ran in recog] + out2 = sorted(out2, key=lambda x: float(x[1])) + tmp = [] + sequences = [] + losses = [] + wers = [] + for name, value in out2: + job_ls = [quants[x] for x in quants if name.split("/")[1].split("-")[0] == x.split("/")[-2] and quant in x and mode+ran in x] + assert len(job_ls) == 1, (name, job_ls, out2, quants) + with open(job_ls[0].out_seq_info, "rt") as f: + sequence = [] + loss = [] + for line in f: + sequences.append(line.split(" ")[0].strip()) + wers.append(float(value)) + loss.append(loss_values[line.split(" ")[0].strip()[:-1]]) + losses.append(sum(loss)) + sequences.append(sequence) + tmp.append((name.split("/")[1], value, " ".join(f.readlines()).strip())) + out2 = tmp + if len(out2) > 0: + ex_str = calc_stat(out2) + out.append(('', '')) + out.append((extra + "_" + mode + ran + "_" + quant, ex_str)) + out.append(("Correlation between loss and drawn sequence", str(np.corrcoef(wers, losses)[0, 1]))) + out.extend(out2[:5]) + out.extend(out2[-5:]) best_ls.append(out2[0]) # single and unique tag filter methods for quant, count, mode in itertools.product(["min_max", "entropy", "percentile"], ["10", "20", "30", "50"], ["single_tag", "unique_tags"]): @@ -158,19 +223,75 @@ def hybrid_report_format(report: _Report_Type) -> str: out2 = sorted(out2, key=lambda x: float(x[1])) if len(out2) > 0: ex_str = calc_stat(out2) + out.append(('', '')) out.append((extra + "_" + mode + "_" + quant + "_" + count, ex_str)) - out.extend(out2[:3]) - out.extend(out2[-3:]) + out.extend(out2[:5]) + out.extend(out2[-5:]) + best_ls.append(out2[0]) + elif extra == "loss_table": + # loss table + for quant in ["min_max", "entropy", "percentile", "reverse"]: + out2 = [(recog, str(report[recog])) for recog in report if extra in recog and quant in recog] + out2 = sorted(out2, key=lambda x: float(x[1])) + tmp = [] + sequences = [] + losses = [] + wers = [] + for name, value in out2: + job_ls = [quants[x] for x in quants if + name.split("/")[1].split("-")[0] == x.split("/")[-2] and extra in x and x.endswith(name.split("/")[1].split("-")[1]) and name.split("/")[0].split("-")[-1] in x] + assert len(job_ls) == 1, (name, job_ls, len(out2), quants) + with open(job_ls[0].out_seq_info, "rt") as f: + for line in f: + sequences.append(line.split(" ")[0].strip()) + wers.append(float(value)) + losses.append(loss_values[line.split(" ")[0].strip()[:-1]]) + tmp.append((name.split("/")[0].split("-")[-1]+"/"+name.split("/")[1], value, " ".join(f.readlines()).strip())) + out2 = tmp + if len(out2) > 0: + ex_str = calc_stat(out2) + out.append(('', '')) + out.append((extra + " " + quant, ex_str)) + out.extend(out2) + out.extend(out2) best_ls.append(out2[0]) + quant = "reverse" + out2 = [(recog, str(report[recog])) for recog in report if extra in recog and quant not in recog] + out2 = sorted(out2, key=lambda x: float(x[1])) + tmp = [] + sequences = [] + losses = [] + wers = [] + for name, value in out2: + job_ls = [quants[x] for x in quants if + name.split("/")[1].split("-")[0] == x.split("/")[-2] and extra in x and x.endswith( + name.split("/")[1].split("-")[1]) and name.split("/")[0].split("-")[-1] in x] + assert len(job_ls) == 1, (name, job_ls, len(out2), quants) + with open(job_ls[0].out_seq_info, "rt") as f: + for line in f: + sequences.append(line.split(" ")[0].strip()) + wers.append(float(value)) + losses.append(loss_values[line.split(" ")[0].strip()[:-1]]) + tmp.append((name.split("/")[0].split("-")[-1] + "/" + name.split("/")[1], value, + " ".join(f.readlines()).strip())) + out2 = tmp + if len(out2) > 0: + ex_str = calc_stat(out2) + out.append(('', '')) + out.append((extra + " no " + quant, ex_str)) + out.extend(out2) + out.extend(out2) + best_ls.append(out2[0]) else: # mixed out2 = [(recog, str(report[recog])) for recog in report if extra in recog] out2 = sorted(out2, key=lambda x: float(x[1])) if len(out2) > 0: ex_str = calc_stat(out2) + out.append(('', '')) out.append((extra, ex_str)) - out.extend(out2[:3]) - out.extend(out2[-3:]) + out.extend(out2[:5]) + out.extend(out2[-5:]) best_ls.append(out2[0]) best_ls = sorted(best_ls, key=lambda x: float(x[1])) @@ -714,32 +835,40 @@ def run_nn_step(self, step_name: str, step_args: HybridArgs): train_job=returnn_train_job, ) print(f"NN Recog Iteration {time.time() - start}") - start = time.time() - from i6_core.report import GenerateReportStringJob, MailJob - - results = {} - for c in self.dev_corpora + self.test_corpora: - for job_name in self.jobs[c]: - if "scorer" not in job_name: - continue - if not name == job_name.split("-")[1]: - continue - scorer = self.jobs[c][job_name] - if scorer.out_wer: - results[job_name] = scorer.out_wer - tk.register_report(f"reports/{name.replace('/', '_')}", values=results) - quants = {} - for c in self.dev_corpora + self.test_corpora: - for job_name in self.jobs[c]: - if "quantize_static" in job_name and "budget" in job_name: - quants[job_name] = self.jobs[c][job_name] - results["quant"] = quants - report = GenerateReportStringJob(report_values=results, report_template=hybrid_report_format) - report.add_alias(f"report/report_{name}") - mail = MailJob(report.out_report, send_contents=True, subject=name) - mail.add_alias(f"report/mail_{name}") - tk.register_output("mail/" + name, mail.out_status) - print(f"NN Report Iteration {time.time() - start}") + for recog_name, _ in step_args.recognition_args.items(): + results = {} + from i6_core.report import GenerateReportStringJob, MailJob + for c in self.dev_corpora + self.test_corpora: + for job_name in self.jobs[c]: + if "scorer" not in job_name: + continue + if not name == job_name.split("-")[1]: + continue + if not f"{recog_name}-{c}" in job_name: # e.g. "quant_multile-dev + continue + scorer = self.jobs[c][job_name] + if scorer.out_wer: + results[job_name] = scorer.out_wer + tk.register_report(f"reports/{name.replace('/', '_')}/{recog_name}", values=results) + quants = {} + for c in self.dev_corpora + self.test_corpora: + for job_name in self.jobs[c]: + #if "quantize_static" in job_name and "budget" in job_name and f"{recog_name}" in job_name: + if "quantize_static" in job_name and f"{recog_name}" in job_name: + quants[job_name] = self.jobs[c][job_name] + results["quant"] = quants + loss_tables = {} + for c in self.dev_corpora + self.test_corpora: + for job_name in self.jobs[c]: + if "calculate_loss" in job_name and f"{recog_name}" in job_name: + loss_tables[job_name] = self.jobs[c][job_name] + results["loss_tables"] = loss_tables + report = GenerateReportStringJob(report_values=results, report_template=hybrid_report_format) + report.add_alias(f"report/report_{name}_{recog_name}") + mail = MailJob(report.out_report, send_contents=True, subject=name + " " + recog_name) + mail.add_alias(f"report/mail_{name}_{recog_name}") + tk.register_output("mail/" + name + "_" + recog_name, mail.out_status) + def run_nn_recog_step(self, step_args: NnRecogArgs): for eval_c in self.dev_corpora + self.test_corpora: diff --git a/users/hilmes/common/setups/rasr/nn_system.py b/users/hilmes/common/setups/rasr/nn_system.py index 10dcf88e2..72bc423ec 100644 --- a/users/hilmes/common/setups/rasr/nn_system.py +++ b/users/hilmes/common/setups/rasr/nn_system.py @@ -112,7 +112,7 @@ def returnn_training( ) #if any(sub in name for sub in ["larger", "whisper_medium", "whisper_large"]): #print(name, any(f"keepuntil_{x}_" in name for x in range(9))) - if any(sub in name for sub in ["larger", "medium", "large", "parakeet", "old_spec_baseline", "new_spec_baseline"]) and not any(f"keepuntil_{x}_" in name for x in range(9)): + if any(sub in name for sub in ["larger", "medium", "large", "parakeet", "hubert_fe_test"]) and not any(f"keepuntil_{x}_" in name for x in range(9)): returnn_training_job.rqmt["gpu_mem"] = 24 if any(sub in name for sub in ["whisper_large", "whisper_v2_large", "parakeet_1.1"]): returnn_training_job.rqmt["mem"] = 12 diff --git a/users/hilmes/experiments/tedlium2/asr_2023/hybrid/distil_hubert/corpus_data.py b/users/hilmes/experiments/tedlium2/asr_2023/hybrid/distil_hubert/corpus_data.py index b9e959e2b..999dd32d7 100644 --- a/users/hilmes/experiments/tedlium2/asr_2023/hybrid/distil_hubert/corpus_data.py +++ b/users/hilmes/experiments/tedlium2/asr_2023/hybrid/distil_hubert/corpus_data.py @@ -87,34 +87,34 @@ def build_data_input( return { "class": "MetaDataset", - #"data_map": {"classes": ("hdf_align", "data"), "data_raw": ("ogg", "data"), "data": ("hdf_feat", "data")}, - "data_map": {"classes": ("hdf_align", "data"), "data": ("hdf_feat", "data")}, + "data_map": {"classes": ("hdf_align", "data"), "data_raw": ("ogg", "data")}, + #"data_map": {"classes": ("hdf_align", "data"), "data": ("hdf_feat", "data")}, "datasets": { "hdf_align": { "class": "HDFDataset", "files": [align_hdf], "use_cache_manager": True, }, - # "ogg": { - # "class": "OggZipDataset", - # "audio": {"features": "raw", "peak_normalization": True, "sample_rate": 16000}, - # "partition_epoch": partition_epoch, - # "path": [raw_features], - # "seq_ordering": seq_ordering, - # "use_cache_manager": True, - # "segment_file": segment_list, - # "targets": None, - # }, - "hdf_feat": { - "class": "HDFDataset", - "files": [feat_hdf], - "use_cache_manager": True, - "seq_ordering": seq_ordering, + "ogg": { + "class": "OggZipDataset", + "audio": {"features": "raw", "peak_normalization": True, "sample_rate": 16000}, "partition_epoch": partition_epoch, - "seq_list_filter_file": segment_list, + "path": [raw_features], + "seq_ordering": seq_ordering, + "use_cache_manager": True, + "segment_file": segment_list, + "targets": None, }, + # "hdf_feat": { + # "class": "HDFDataset", + # "files": [feat_hdf], + # "use_cache_manager": True, + # "seq_ordering": seq_ordering, + # "partition_epoch": partition_epoch, + # "seq_list_filter_file": segment_list, + # }, }, - "seq_order_control_dataset": "hdf_feat", + "seq_order_control_dataset": "ogg", } @@ -255,7 +255,7 @@ def get_corpus_data_inputs( allophone_labeling=allophone_labeling, alias_prefix=alias_prefix + "/nn_train_data", partition_epoch=5, - acoustic_mixtures=gmm_system.outputs["train"]["final"].acoustic_mixtures, # TODO: NN Mixtures + #acoustic_mixtures=gmm_system.outputs["train"]["final"].acoustic_mixtures, # TODO: NN Mixtures seq_ordering="laplace:.1000", raw_features=train_features_raw, ) diff --git a/users/hilmes/experiments/tedlium2/asr_2023/hybrid/distil_hubert/distill_hubert_args.py b/users/hilmes/experiments/tedlium2/asr_2023/hybrid/distil_hubert/distill_hubert_args.py index 0abe0c9f0..3283213cb 100644 --- a/users/hilmes/experiments/tedlium2/asr_2023/hybrid/distil_hubert/distill_hubert_args.py +++ b/users/hilmes/experiments/tedlium2/asr_2023/hybrid/distil_hubert/distill_hubert_args.py @@ -131,9 +131,9 @@ def get_pytorch_returnn_configs( base_config = { "extern_data": { - "data": { - "dim": 80, - "shape": (None, 80), + "data_raw": { + "dim": 1, + "shape": (None, 1), "available_for_inference": True, }, # input: 1-dimensional waveforms "classes": { @@ -153,13 +153,7 @@ def get_pytorch_returnn_configs( "behavior_version": 16, "torch_log_memory_usage": True, } - if not recognition and False: - # add teacher features - base_config["extern_data"]["data_raw"] = { - "dim": 1, - "shape": (None, 1), - "available_for_inference": True, - } # input: 1-dimensional waveforms + base_post_config = { "backend": "torch", "debug_print_layer_output_template": True, @@ -188,6 +182,12 @@ def get_pytorch_returnn_configs( chunk_400_200_config = copy.deepcopy(hubert_config) chunk_400_200_config["chunking"] = "400:200" + + chunk_raw_config = copy.deepcopy(hubert_config) + chunk_400 = 400 * 16000 + chunk_200 = 200 * 16000 + chunk_raw_config["chunking"] = f"{chunk_400}:{chunk_200}" + #if not recognition: # del chunk_400_200_config['extern_data']['data_raw'] @@ -236,6 +236,11 @@ def construct_from_net_kwargs( base_config["max_seqs"] = 1 base_config["forward_data"] = "train" base_config["model_outputs"] = {"log_probs": {"dim": num_outputs, "shape": (None, num_outputs)}} + base_config["extern_data"]["data_raw"] = { + "dim": 80, + "shape": (None, 80), + "available_for_inference": True, + } if "min_seq_length" in base_config: del base_config["min_seq_length"] @@ -274,8 +279,8 @@ def construct_from_net_kwargs( return returnn_config return { - **{f"torch_distill_hubert_large_test_{x}": construct_from_net_kwargs( - hubert_config, + **{f"torch_distill_hubert_fe_test": construct_from_net_kwargs( + chunk_raw_config, { "model_type": "distill_hubert_v1", "hubert_dict": { @@ -301,107 +306,13 @@ def construct_from_net_kwargs( "upsample_kernel": 3, "upsample_stride": 3, "upsample_padding": 0, - "upsample_out_padding": 0, + "upsample_out_padding": 1, "dropout": 0.2, + "feat_extr": True }, }, models_commit="3c9173691521778b1e8b4070c172cbe929e4826b", - #max_seqs=2, - #grad_acc=14, - ) for x in [0.00]}, # 6.4 - **{f"torch_old_spec_baseline": construct_from_net_kwargs( - chunk_400_200_config, - { - "model_type": "conformer_baseline", - "conformer_size": 384, - "conv_kernel_size": 7, - "att_heads": 6, - "ff_dim": 1536, - "spec_num_time": 20, - "spec_max_time": 20, - "spec_num_feat": 5, - "spec_max_feat": 16, - "pool_1_stride": (3, 1), - "pool_1_kernel_size": (1, 2), - "pool_1_padding": None, - "pool_2_stride": None, - "pool_2_kernel_size": (1, 2), - "pool_2_padding": None, - "num_layers": 12, - "upsample_kernel": 3, - "upsample_stride": 3, - "upsample_padding": 0, - "upsample_out_padding": 0, - "dropout": 0.2, - "old_spec": True - }, - models_commit="3c9173691521778b1e8b4070c172cbe929e4826b", - # max_seqs=2, - # grad_acc=14, - ) for x in [0.00]}, # 6.2 - **{f"torch_new_spec_baseline": construct_from_net_kwargs( - chunk_400_200_config, - { - "model_type": "conformer_baseline", - "conformer_size": 384, - "conv_kernel_size": 7, - "att_heads": 6, - "ff_dim": 1536, - "spec_num_time": 20, - "spec_max_time": 20, - "spec_num_feat": 5, - "spec_max_feat": 16, - "pool_1_stride": (3, 1), - #"pool_1_kernel_size": (1, 2), - #"pool_1_padding": None, - #"pool_2_stride": None, - #"pool_2_kernel_size": (1, 2), - #"pool_2_padding": None, - "num_layers": 12, - "upsample_kernel": 3, - "upsample_stride": 3, - "upsample_padding": 0, - #"upsample_out_padding": 0, - #"dropout": 0.2, - "old_spec": False, - }, - models_commit="3c9173691521778b1e8b4070c172cbe929e4826b", # max_seqs=2, # grad_acc=14, - ) for x in [0.00]}, # 6.2 - # **{f"torch_distill_hubert_large_test_chunk_{x}": construct_from_net_kwargs( - # chunk_400_200_config, - # { - # "model_type": "distill_hubert_v1", - # "hubert_dict": { - # "model_name": "base-ls960", - # "distill_scale": x - # }, - # "conformer_dict": { - # "hidden_d": 384, - # "conv_kernel_size": 7, - # "att_heads": 6, - # "ff_dim": 1536, - # "spec_num_time": 20, - # "spec_max_time": 20, - # "spec_num_feat": 5, - # "spec_max_feat": 16, - # "pool_1_stride": (3, 1), - # "pool_1_kernel_size": (1, 2), - # "pool_1_padding": None, - # "pool_2_stride": None, - # "pool_2_kernel_size": (1, 2), - # "pool_2_padding": None, - # "num_layers": 12, - # "upsample_kernel": 3, - # "upsample_stride": 3, - # "upsample_padding": 0, - # "upsample_out_padding": 0, - # "dropout": 0.2, - # }, - # }, - # models_commit="3c9173691521778b1e8b4070c172cbe929e4826b", - # max_seqs=2, - # grad_acc=14, - # ) for x in [0.00]}, + ) for x in [0.00]}, } diff --git a/users/hilmes/experiments/tedlium2/asr_2023/hybrid/distil_hubert/pytorch_networks/distill_hubert_v1.py b/users/hilmes/experiments/tedlium2/asr_2023/hybrid/distil_hubert/pytorch_networks/distill_hubert_v1.py index 5c5eba78a..706f805d9 100644 --- a/users/hilmes/experiments/tedlium2/asr_2023/hybrid/distil_hubert/pytorch_networks/distill_hubert_v1.py +++ b/users/hilmes/experiments/tedlium2/asr_2023/hybrid/distil_hubert/pytorch_networks/distill_hubert_v1.py @@ -17,6 +17,7 @@ from i6_models.parts.conformer.norm import LayerNormNC from i6_models.config import ModelConfiguration, ModuleFactoryV1 from i6_models.parts.frontend.vgg_act import VGG4LayerActFrontendV1, VGG4LayerActFrontendV1Config +from i6_models.primitives.feature_extraction import LogMelFeatureExtractionV1, LogMelFeatureExtractionV1Config, RasrCompatibleLogMelFeatureExtractionV1Config, RasrCompatibleLogMelFeatureExtractionV1 def _lengths_to_padding_mask(lengths: torch.Tensor, x: torch.Tensor) -> torch.Tensor: """ @@ -55,6 +56,7 @@ class ConformerStudentConfig: upsample_padding: int upsample_out_padding: int dropout: float + feat_extr: bool class Model(nn.Module): @@ -65,7 +67,7 @@ def __init__(self, epoch, step, hubert_dict, conformer_dict, **kwargs): self.conformer_cfg = ConformerStudentConfig(**conformer_dict) self.distill_scale = self.hubert_cfg.distill_scale self.config = HubertConfig.from_pretrained(f"facebook/hubert-{self.hubert_cfg.model_name}", cache_dir='/work/asr4/hilmes/debug/whisper/hubert_for_ctc') - if not run_ctx.stage == "train_step" and not run_ctx.stage == "init": + if not run_ctx.stage == "train_step" and not run_ctx.stage == "init" or True: import logging logging.warning("Hubert not loaded") self.hubert = None @@ -86,8 +88,6 @@ def __init__(self, epoch, step, hubert_dict, conformer_dict, **kwargs): for param in self.hubert.parameters(): param.requires_grad_(False) - self.upsample_conv = torch.nn.ConvTranspose1d( - in_channels=self.config.hidden_size, out_channels=self.config.hidden_size, kernel_size=5, stride=2, padding=1) self.final_linear = nn.Linear(self.conformer_cfg.hidden_d, 9001) if len(kwargs) >= 2: assert False, f"You did not use all kwargs: {kwargs}" @@ -95,6 +95,16 @@ def __init__(self, epoch, step, hubert_dict, conformer_dict, **kwargs): assert "random" in list(kwargs.keys())[0], "This must only be RETURNN random arg" # else len == 0 + if self.conformer_cfg.feat_extr is True: + self.fe_cfg = RasrCompatibleLogMelFeatureExtractionV1Config( + sample_rate=16000, + win_size=0.025, + hop_size=0.01, + min_amp=1e-10, + num_filters=80, + ) + self.feature_extraction = RasrCompatibleLogMelFeatureExtractionV1(self.fe_cfg) + conv_cfg = ConformerConvolutionV1Config( channels=self.conformer_cfg.hidden_d, kernel_size=self.conformer_cfg.conv_kernel_size, @@ -148,16 +158,20 @@ def __init__(self, epoch, step, hubert_dict, conformer_dict, **kwargs): ) # self.initial_linear = nn.Linear(80, conformer_size) - def forward(self, - audio_features: torch.Tensor, audio_features_len: torch.Tensor, - raw_audio: torch.Tensor = None, - raw_audio_len: torch.Tensor = None): + def forward(self, raw_audio: torch.Tensor, raw_audio_len: torch.Tensor): run_ctx = rf.get_run_ctx() + if self.conformer_cfg.feat_extr is True and (self.training or run_ctx.stage == "train_step"): + squeezed_features = torch.squeeze(raw_audio, dim=-1) + audio_features, audio_features_len = self.feature_extraction(raw_audio=squeezed_features, length=raw_audio_len) + else: + # for export / forward we take external features + audio_features = raw_audio + audio_features_len = raw_audio_len + # Hubert teacher: if (self.training or run_ctx.stage == "train_step") and raw_audio is not None and raw_audio_len is not None and False: assert False, "Since this is just testing this should not happen, if entering here is correct please just delete this line" - squeezed_features = torch.squeeze(raw_audio, dim=-1) hubert_outputs = self.hubert(input_values=squeezed_features) audio_features_size = self.hubert._get_feat_extract_output_lengths(raw_audio_len).to(dtype=torch.int64) encoder_output = hubert_outputs.last_hidden_state @@ -182,7 +196,8 @@ def forward(self, conformer_out, _ = self.conformer(audio_features_masked, mask) upsampled = self.upsample_conv(conformer_out.transpose(1, 2)).transpose(1, 2) # final upsampled [B, T, F] - upsampled = upsampled[:, 0: audio_features.size()[1], :] + print(upsampled.shape, audio_features.shape, audio_features_len, conformer_out.shape) + upsampled = upsampled[:, 0: audio_features.size()[1]+1, :] student_features = upsampled upsampled_dropped = nn.functional.dropout(student_features, p=self.conformer_cfg.dropout, training=self.training) @@ -191,27 +206,22 @@ def forward(self, log_probs = torch.log_softmax(final_out, dim=2) if teacher_features is not None: - return log_probs, logits_ce_order, teacher_features, student_features + return log_probs, logits_ce_order, teacher_features, student_features, audio_features_len elif self.training or run_ctx.stage == "train_step": - return log_probs, logits_ce_order, None, None + return log_probs, logits_ce_order, None, None, audio_features_len else: - return log_probs, logits_ce_order + return log_probs, logits_ce_order, audio_features_len def train_step(*, model: Model, extern_data, **_kwargs): - audio_features = extern_data["data"].raw_tensor - audio_features_len = extern_data["data"].dims[1].dyn_size_ext.raw_tensor - audio_raw = extern_data["data_raw"].raw_tensor audio_raw_len = extern_data["data_raw"].dims[1].dyn_size_ext.raw_tensor phonemes = extern_data["classes"].raw_tensor phonemes_len = extern_data["classes"].dims[1].dyn_size_ext.raw_tensor - log_probs, logits_ce_order, teacher_features, student_features = model( + log_probs, logits_ce_order, teacher_features, student_features, audio_features_len = model( raw_audio=audio_raw, raw_audio_len=audio_raw_len.to("cuda"), - audio_features=audio_features, - audio_features_len=audio_features_len.to("cuda") ) targets_packed = nn.utils.rnn.pack_padded_sequence( @@ -219,7 +229,7 @@ def train_step(*, model: Model, extern_data, **_kwargs): ) targets_masked, _ = nn.utils.rnn.pad_packed_sequence(targets_packed, batch_first=True, padding_value=-100) targets_masked = targets_masked.long() - + print(f"{logits_ce_order.shape=}, {targets_masked.shape=}") loss_ce = nn.functional.cross_entropy(logits_ce_order, targets_masked) #loss_features = nn.functional.l1_loss(student_features, teacher_features, reduction="mean") @@ -227,25 +237,3 @@ def train_step(*, model: Model, extern_data, **_kwargs): # TODO: KL div loss # TODO: look if Hubert model has a softmax somewhere #rf.get_run_ctx().mark_as_loss(name="L1 Dist", loss=loss_features, scale=model.distill_scale) - - -def export2(*, model: Model, f: str): - model.export_mode = True - dummy_data = torch.randn(1, 45000, 1, device="cpu") - dummy_data_len = torch.IntTensor([45000]) - scripted_model = torch.jit.trace(model.eval(), example_inputs=(dummy_data, dummy_data_len)) - onnx_export( - scripted_model, - (dummy_data, dummy_data_len), - f=f, - verbose=True, - input_names=["data", "data_len"], - output_names=["classes"], - opset_version=17, - dynamic_axes={ - # dict value: manually named axes - "data": {0: "batch", 1: "time"}, - "data_len": {0: "batch"}, - "classes": {0: "batch", 1: "time"}, - }, - ) diff --git a/users/hilmes/experiments/tedlium2/asr_2023/hybrid/distil_hubert/pytorch_networks/prior/basic.py b/users/hilmes/experiments/tedlium2/asr_2023/hybrid/distil_hubert/pytorch_networks/prior/basic.py index 4ad5fdada..7c51bf69e 100644 --- a/users/hilmes/experiments/tedlium2/asr_2023/hybrid/distil_hubert/pytorch_networks/prior/basic.py +++ b/users/hilmes/experiments/tedlium2/asr_2023/hybrid/distil_hubert/pytorch_networks/prior/basic.py @@ -4,13 +4,13 @@ def forward_step(*, model: torch.nn.Module, extern_data: TensorDict, **kwargs): - audio_features = extern_data["data"].raw_tensor - audio_features_len = extern_data["data"].dims[1].dyn_size_ext.raw_tensor + audio_features = extern_data["data_raw"].raw_tensor + audio_features_len = extern_data["data_raw"].dims[1].dyn_size_ext.raw_tensor - log_probs, logits_ce_order = model( - audio_features=audio_features, - audio_features_len=audio_features_len.to(audio_features.device) + log_probs, logits_ce_order, features_len = model( + raw_audio=audio_features, + raw_audio_len=audio_features_len.to(audio_features.device) ) # [B, T, F] - features_len = audio_features_len.to(dtype=torch.int32) + features_len = features_len.to(dtype=torch.int32) rf.get_run_ctx().expected_outputs["log_probs"].dims[1].dyn_size_ext.raw_tensor = features_len rf.get_run_ctx().mark_as_output(log_probs, name="log_probs") diff --git a/users/hilmes/experiments/tedlium2/asr_2023/hybrid/torch_baselines/pytorch_networks/prior/basic.py b/users/hilmes/experiments/tedlium2/asr_2023/hybrid/torch_baselines/pytorch_networks/prior/basic.py index f49fe12b9..0f4cd722d 100644 --- a/users/hilmes/experiments/tedlium2/asr_2023/hybrid/torch_baselines/pytorch_networks/prior/basic.py +++ b/users/hilmes/experiments/tedlium2/asr_2023/hybrid/torch_baselines/pytorch_networks/prior/basic.py @@ -1,6 +1,7 @@ from returnn.tensor.tensor_dict import TensorDict import returnn.frontend as rf import torch +from torch import nn def forward_step(*, model: torch.nn.Module, extern_data: TensorDict, **kwargs): @@ -16,3 +17,26 @@ def forward_step(*, model: torch.nn.Module, extern_data: TensorDict, **kwargs): ) # [B, T, F] rf.get_run_ctx().mark_as_output(log_probs, name="log_probs") + + +def loss_forward_step(*, model: torch.nn.Module, extern_data: TensorDict, **kwargs): + audio_features = extern_data["data"].raw_tensor + audio_features_len = extern_data["data"].dims[1].dyn_size_ext.raw_tensor + + audio_features_len, indices = torch.sort(audio_features_len, descending=True) + audio_features = audio_features[indices, :, :] + + log_probs, logits = model( + audio_features=audio_features, + audio_features_len=audio_features_len.to("cuda"), + ) # [B, T, F] + phonemes = extern_data["classes"].raw_tensor[indices, :].long() + phonemes_len = extern_data["classes"].dims[1].dyn_size_ext.raw_tensor[indices] + targets_packed = nn.utils.rnn.pack_padded_sequence( + phonemes, phonemes_len.to("cpu"), batch_first=True, enforce_sorted=False + ) + targets_masked, _ = nn.utils.rnn.pad_packed_sequence(targets_packed, batch_first=True, padding_value=-100) + + loss = nn.functional.cross_entropy(logits, targets_masked) + loss = torch.unsqueeze(torch.unsqueeze(loss, dim=0), dim=0) + rf.get_run_ctx().mark_as_output(loss, "ce_score") diff --git a/users/hilmes/experiments/tedlium2/asr_2023/hybrid/torch_baselines/pytorch_networks/prior/prior_callback.py b/users/hilmes/experiments/tedlium2/asr_2023/hybrid/torch_baselines/pytorch_networks/prior/prior_callback.py index b6c87c599..f24eb451e 100644 --- a/users/hilmes/experiments/tedlium2/asr_2023/hybrid/torch_baselines/pytorch_networks/prior/prior_callback.py +++ b/users/hilmes/experiments/tedlium2/asr_2023/hybrid/torch_baselines/pytorch_networks/prior/prior_callback.py @@ -58,3 +58,19 @@ def finish(self): plt.ylabel("prior") plt.grid(True) plt.savefig("../output/prior.png") + + +class PrintLossCallback(ForwardCallbackIface): + def init(self, *, model: torch.nn.Module): + self.seq_loss_pairs = [] + + def process_seq(self, *, seq_tag: str, outputs: TensorDict): + loss: torch.Tensor = outputs["ce_score"].raw_tensor + self.seq_loss_pairs.append((seq_tag, loss.cpu().numpy()[0])) + + def finish(self): + # Write txt file + sorted_pairs = sorted(self.seq_loss_pairs, key=lambda x: x[1]) + with open("loss_table", "wt") as f: + for x in sorted_pairs: + f.write(f"{x[0]} {x[1]}\n") diff --git a/users/hilmes/experiments/tedlium2/asr_2023/hybrid/torch_baselines/torch_args.py b/users/hilmes/experiments/tedlium2/asr_2023/hybrid/torch_baselines/torch_args.py index 5ffd16a5c..fcb8a5f70 100644 --- a/users/hilmes/experiments/tedlium2/asr_2023/hybrid/torch_baselines/torch_args.py +++ b/users/hilmes/experiments/tedlium2/asr_2023/hybrid/torch_baselines/torch_args.py @@ -106,12 +106,52 @@ def get_nn_args(num_outputs: int = 9001, num_epochs: int = 250, debug=False, **n # "needs_features_size": True, # "training_whitelist": ["torch_jj_config2", "torch_jj_config2_large"], # }, - # "quant": { + "quant": { + "epochs": evaluation_epochs, + "feature_flow_key": "fb", + "prior_scales": [0.9], + "pronunciation_scales": [0.0], + "lm_scales": [10.0], + "lm_lookahead": True, + "lookahead_options": None, + "create_lattice": True, + "eval_single_best": True, + "eval_best_in_lattice": True, + "search_parameters": { + "beam-pruning": 15.0, + "beam-pruning-limit": 10000, + "word-end-pruning": 0.5, + "word-end-pruning-limit": 15000, + }, + "lattice_to_ctm_kwargs": { + "fill_empty_segments": True, + "best_path_algo": "bellman-ford", + }, + "optimize_am_lm_scale": True, + "rtf": 50, + "mem": 7, + "lmgc_mem": 16, + "cpu": 2, + "parallelize_conversion": True, + "needs_features_size": True, + #"quantize": [10, 15, 25, 100, 250, 500, 750, 1000, 2500, 5000], + "quantize": [5, 10, 25, 100, 500, 1000, 5000, 10000, 50000, 100000, 100001, 100002, 100003], + "quant_modes": [CalibrationMethod.MinMax, CalibrationMethod.Percentile], + "quant_ops": [["Conv", "MatMul"]], + "quant_sym_modes": [False], + "quant_avg_modes": [False], + "quant_percentiles": [99.999], + "quant_num_bin_ls": [2048], + "training_whitelist": [ + "torch_jj_config2", + ], + }, + # "quant-base": { # "epochs": evaluation_epochs, # "feature_flow_key": "fb", # "prior_scales": [0.7, 0.9], # "pronunciation_scales": [0.0], - # "lm_scales": [10.0, 7.5], + # "lm_scales": [10.0], # "lm_lookahead": True, # "lookahead_options": None, # "create_lattice": True, @@ -129,26 +169,26 @@ def get_nn_args(num_outputs: int = 9001, num_epochs: int = 250, debug=False, **n # }, # "optimize_am_lm_scale": True, # "rtf": 50, - # "mem": 7, + # "mem": 6, # "lmgc_mem": 16, # "cpu": 2, # "parallelize_conversion": True, # "needs_features_size": True, - # #"quantize": [10, 15, 25, 100, 250, 500, 750, 1000, 2500, 5000], - # "quantize": [5, 11, 10, 25, 100, 500, 1000, 5000, 10000, 50000, 100000], + # "quant_ops": [["Conv", "MatMul"]], + # "quantize": [5, 10, 25, 100, 500, 1000, 5000, 10000, 50000],#, 100000], # "quant_modes": [CalibrationMethod.MinMax, CalibrationMethod.Percentile], # "quant_sym_modes": [False], # "quant_avg_modes": [False], - # "quant_percentiles": [90.0, 95.0, 99.0, 99.999, 99.9], - # "quant_num_bin_ls": [512, 1024, 2048, 4096], + # "quant_percentiles": [99.999], + # "quant_num_bin_ls": [2048], # "training_whitelist": [ # "torch_jj_config2", # ], # }, - # "quant-base": { + # "quant-ops": { # "epochs": evaluation_epochs, # "feature_flow_key": "fb", - # "prior_scales": [0.7, 0.9], + # "prior_scales": [0.7], # "pronunciation_scales": [0.0], # "lm_scales": [10.0], # "lm_lookahead": True, @@ -173,21 +213,20 @@ def get_nn_args(num_outputs: int = 9001, num_epochs: int = 250, debug=False, **n # "cpu": 2, # "parallelize_conversion": True, # "needs_features_size": True, - # "quant_ops": [["Conv", "MatMul"]], - # "quantize": [5, 10, 25, 100, 500, 1000, 5000, 10000, 50000],#, 100000], - # "quant_modes": [CalibrationMethod.MinMax, CalibrationMethod.Percentile], + # # "quantize": [10, 15, 25, 100, 250, 500, 750, 1000, 2500, 5000], + # "quantize": [10, 25, 100, 500], + # "quant_modes": [CalibrationMethod.MinMax], # "quant_sym_modes": [False], # "quant_avg_modes": [False], - # "quant_percentiles": [99.999], - # "quant_num_bin_ls": [2048], + # "quant_ops": [None, ["Conv"], ["MatMul"], ["Conv", "MatMul"], ["Conv", "MatMul", "Mul", "Add"]], # "training_whitelist": [ # "torch_jj_config2", # ], # }, - # "quant-ops": { + # "quant-rtf-intel-speed": { # "epochs": evaluation_epochs, # "feature_flow_key": "fb", - # "prior_scales": [0.7], + # "prior_scales": [0.9], # "pronunciation_scales": [0.0], # "lm_scales": [10.0], # "lm_lookahead": True, @@ -196,8 +235,8 @@ def get_nn_args(num_outputs: int = 9001, num_epochs: int = 250, debug=False, **n # "eval_single_best": True, # "eval_best_in_lattice": True, # "search_parameters": { - # "beam-pruning": 15.0, - # "beam-pruning-limit": 10000, + # "beam-pruning": 12.0, + # "beam-pruning-limit": 2000, # "word-end-pruning": 0.5, # "word-end-pruning-limit": 15000, # }, @@ -209,20 +248,20 @@ def get_nn_args(num_outputs: int = 9001, num_epochs: int = 250, debug=False, **n # "rtf": 50, # "mem": 6, # "lmgc_mem": 16, - # "cpu": 2, + # "cpu": 1, # "parallelize_conversion": True, # "needs_features_size": True, # # "quantize": [10, 15, 25, 100, 250, 500, 750, 1000, 2500, 5000], - # "quantize": [10, 25, 100, 500], + # "quantize": [10], # "quant_modes": [CalibrationMethod.MinMax], # "quant_sym_modes": [False], # "quant_avg_modes": [False], - # "quant_ops": [None, ["Conv"], ["MatMul"], ["Conv", "MatMul"], ["Conv", "MatMul", "Mul", "Add"]], + # "quant_ops": [None, ["Conv"], ["MatMul"], ["Conv", "MatMul"], ["Conv", "MatMul", "Mul", "Add"], ["ConvTranspose"], ["Conv", "MatMul", "ConvTranspose"]], # "training_whitelist": [ # "torch_jj_config2", # ], # }, - # "quant-rtf-intel-speed": { + # "quant-multiple": { # "epochs": evaluation_epochs, # "feature_flow_key": "fb", # "prior_scales": [0.9], @@ -234,8 +273,8 @@ def get_nn_args(num_outputs: int = 9001, num_epochs: int = 250, debug=False, **n # "eval_single_best": True, # "eval_best_in_lattice": True, # "search_parameters": { - # "beam-pruning": 12.0, - # "beam-pruning-limit": 2000, + # "beam-pruning": 15.0, + # "beam-pruning-limit": 10000, # "word-end-pruning": 0.5, # "word-end-pruning-limit": 15000, # }, @@ -247,23 +286,24 @@ def get_nn_args(num_outputs: int = 9001, num_epochs: int = 250, debug=False, **n # "rtf": 50, # "mem": 6, # "lmgc_mem": 16, - # "cpu": 1, + # "cpu": 2, # "parallelize_conversion": True, # "needs_features_size": True, - # # "quantize": [10, 15, 25, 100, 250, 500, 750, 1000, 2500, 5000], - # "quantize": [10], - # "quant_modes": [CalibrationMethod.MinMax], + # "quantize": [1, 2, 3, 5, 10, 100, 500, 1000, 10000], + # "quant_modes": [CalibrationMethod.MinMax, CalibrationMethod.Percentile], + # #"quant_modes": [CalibrationMethod.MinMax], + # "random_seed_draws": 100, # "quant_sym_modes": [False], # "quant_avg_modes": [False], - # "quant_ops": [None, ["Conv"], ["MatMul"], ["Conv", "MatMul"], ["Conv", "MatMul", "Mul", "Add"], ["ConvTranspose"], ["Conv", "MatMul", "ConvTranspose"]], + # "quant_percentiles": [99.999], + # "quant_num_bin_ls": [2048], # "training_whitelist": [ - # "torch_jj_config2", # ], # }, - "quant-multiple": { + "quant-multiple-convmatmul": { "epochs": evaluation_epochs, "feature_flow_key": "fb", - "prior_scales": [0.7], + "prior_scales": [0.9], "pronunciation_scales": [0.0], "lm_scales": [10.0], "lm_lookahead": True, @@ -288,22 +328,20 @@ def get_nn_args(num_outputs: int = 9001, num_epochs: int = 250, debug=False, **n "cpu": 2, "parallelize_conversion": True, "needs_features_size": True, - "quantize": [10, 500, 1000, 10000], - "quant_modes": [CalibrationMethod.MinMax, CalibrationMethod.Percentile, CalibrationMethod.Entropy], - #"quant_modes": [CalibrationMethod.MinMax], + "quantize": [1, 2, 10, 100, 500, 1000, 10000], + "quant_modes": [CalibrationMethod.MinMax, CalibrationMethod.Percentile], + # "quant_modes": [CalibrationMethod.MinMax], "random_seed_draws": 100, "quant_sym_modes": [False], - "quant_avg_modes": [False, True], + "quant_avg_modes": [False], "quant_percentiles": [99.999], "quant_num_bin_ls": [2048], + "quant_ops": [["Conv", "MatMul"]], "training_whitelist": [ "torch_jj_config2", - "torch_jj_seed_24", - "torch_jj_seed_5", - "torch_jj_seed_2005", ], }, - "quant-filter": { + "quant-loss": { "epochs": evaluation_epochs, "feature_flow_key": "fb", "prior_scales": [0.9], @@ -331,18 +369,148 @@ def get_nn_args(num_outputs: int = 9001, num_epochs: int = 250, debug=False, **n "cpu": 2, "parallelize_conversion": True, "needs_features_size": True, - "quantize": [1000], - "quant_filter_opts": [{"max_seq_len": 500}, {"min_seq_len": 1500}], + "quantize": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 50, 100, 200, 300, 400, 500, 1000, 2000, 3000, 4000, 5000, 10000], "quant_modes": [CalibrationMethod.MinMax, CalibrationMethod.Percentile], - "random_seed_draws": 50, + # "quant_modes": [CalibrationMethod.MinMax], + "random_seed_draws": 1, "quant_sym_modes": [False], "quant_avg_modes": [False], "quant_percentiles": [99.999], "quant_num_bin_ls": [2048], + "quant_ops": [["Conv", "MatMul"]], + "loss_table_args": [{}, {"reverse"}], "training_whitelist": [ "torch_jj_config2", ], }, + # "quant-filter": { + # "epochs": evaluation_epochs, + # "feature_flow_key": "fb", + # "prior_scales": [0.9], + # "pronunciation_scales": [0.0], + # "lm_scales": [10.0], + # "lm_lookahead": True, + # "lookahead_options": None, + # "create_lattice": True, + # "eval_single_best": True, + # "eval_best_in_lattice": True, + # "search_parameters": { + # "beam-pruning": 15.0, + # "beam-pruning-limit": 10000, + # "word-end-pruning": 0.5, + # "word-end-pruning-limit": 15000, + # }, + # "lattice_to_ctm_kwargs": { + # "fill_empty_segments": True, + # "best_path_algo": "bellman-ford", + # }, + # "optimize_am_lm_scale": True, + # "rtf": 50, + # "mem": 6, + # "lmgc_mem": 16, + # "cpu": 2, + # "parallelize_conversion": True, + # "needs_features_size": True, + # "quantize": [10], + # "quant_filter_opts": [{"max_seq_len": 500}, {"min_seq_len": 1500}], + # "quant_modes": [CalibrationMethod.MinMax, CalibrationMethod.Percentile], + # "random_seed_draws": 50, + # "quant_sym_modes": [False], + # "quant_avg_modes": [False], + # "quant_percentiles": [99.999], + # "quant_num_bin_ls": [2048], + # "training_whitelist": [ + # "torch_jj_config2", + # ], + # }, + # "quant-filter-small": { + # "epochs": evaluation_epochs, + # "feature_flow_key": "fb", + # "prior_scales": [0.9], + # "pronunciation_scales": [0.0], + # "lm_scales": [10.0], + # "lm_lookahead": True, + # "lookahead_options": None, + # "create_lattice": True, + # "eval_single_best": True, + # "eval_best_in_lattice": True, + # "search_parameters": { + # "beam-pruning": 15.0, + # "beam-pruning-limit": 10000, + # "word-end-pruning": 0.5, + # "word-end-pruning-limit": 15000, + # }, + # "lattice_to_ctm_kwargs": { + # "fill_empty_segments": True, + # "best_path_algo": "bellman-ford", + # }, + # "optimize_am_lm_scale": True, + # "rtf": 50, + # "mem": 6, + # "lmgc_mem": 16, + # "cpu": 2, + # "parallelize_conversion": True, + # "needs_features_size": True, + # "quantize": [10], + # "quant_filter_opts": [{"min_seq_len": 100}, {"min_seq_len": 50}, {"min_seq_len": 250}, {"min_seq_len": 400}], + # "quant_modes": [CalibrationMethod.MinMax], + # "random_seed_draws": 100, + # "quant_sym_modes": [False], + # "quant_avg_modes": [False], + # "quant_percentiles": [99.999], + # "quant_num_bin_ls": [2048], + # "training_whitelist": [ + # "torch_jj_config2", + # ], + # }, + # "quant-filter-hun": { + # "epochs": evaluation_epochs, + # "feature_flow_key": "fb", + # "prior_scales": [0.9], + # "pronunciation_scales": [0.0], + # "lm_scales": [10.0], + # "lm_lookahead": True, + # "lookahead_options": None, + # "create_lattice": True, + # "eval_single_best": True, + # "eval_best_in_lattice": True, + # "search_parameters": { + # "beam-pruning": 15.0, + # "beam-pruning-limit": 10000, + # "word-end-pruning": 0.5, + # "word-end-pruning-limit": 15000, + # }, + # "lattice_to_ctm_kwargs": { + # "fill_empty_segments": True, + # "best_path_algo": "bellman-ford", + # }, + # "optimize_am_lm_scale": True, + # "rtf": 50, + # "mem": 6, + # "lmgc_mem": 16, + # "cpu": 2, + # "parallelize_conversion": True, + # "needs_features_size": True, + # "quantize": [1], + # "quant_filter_opts": [ + # {"range_len": (95, 105)}, + # {"range_len": (195, 205)}, + # {"range_len": (495, 505)}, + # {"range_len": (595, 605)}, + # {"range_len": (1000, 1100)}, + # {"range_len": (1900, 2000)}, + # {"range_len": (2000, 3000)}, + # ], + # "quant_modes": [CalibrationMethod.MinMax], + # "random_seed_draws": 100, + # "quant_sym_modes": [False], + # "quant_avg_modes": [False], + # "quant_percentiles": [99.999], + # "quant_num_bin_ls": [2048], + # "training_whitelist": [ + # "torch_jj_config2", + # ], + # }, # "quant-filter-partition": { # "epochs": evaluation_epochs, # "feature_flow_key": "fb", @@ -393,51 +561,57 @@ def get_nn_args(num_outputs: int = 9001, num_epochs: int = 250, debug=False, **n # "torch_jj_config2", # ], # }, - "quant-filter-budget": { - "epochs": evaluation_epochs, - "feature_flow_key": "fb", - "prior_scales": [0.9], - "pronunciation_scales": [0.0], - "lm_scales": [10.0], - "lm_lookahead": True, - "lookahead_options": None, - "create_lattice": True, - "eval_single_best": True, - "eval_best_in_lattice": True, - "search_parameters": { - "beam-pruning": 15.0, - "beam-pruning-limit": 10000, - "word-end-pruning": 0.5, - "word-end-pruning-limit": 15000, - }, - "lattice_to_ctm_kwargs": { - "fill_empty_segments": True, - "best_path_algo": "bellman-ford", - }, - "optimize_am_lm_scale": True, - "rtf": 50, - "mem": 6, - "lmgc_mem": 16, - "cpu": 2, - "parallelize_conversion": True, - "needs_features_size": True, - "quantize": [None], - # "quant_filter_opts": [None, {"min_seq_len": 1000}, {"max_seq_len": 1000}], - "quant_filter_opts": [ - {"budget": (30000, 0.01)}, {"budget": (10000, 0.01)}, {"budget": (30000, 0.005)}, {"budget": (80000, 0.01)}, - ], - # "quant_modes": [CalibrationMethod.MinMax, CalibrationMethod.Percentile], - "quant_modes": [CalibrationMethod.MinMax, CalibrationMethod.Percentile], - "random_seed_draws": 100, - "quant_sym_modes": [False], - "quant_avg_modes": [False], - "quant_percentiles": [99.999], - "quant_num_bin_ls": [2048], - "quant_ops": [["Conv", "MatMul"]], - "training_whitelist": [ - "torch_jj_config2", - ], - }, + # "quant-filter-budget": { + # "epochs": evaluation_epochs, + # "feature_flow_key": "fb", + # "prior_scales": [0.9], + # "pronunciation_scales": [0.0], + # "lm_scales": [10.0], + # "lm_lookahead": True, + # "lookahead_options": None, + # "create_lattice": True, + # "eval_single_best": True, + # "eval_best_in_lattice": True, + # "search_parameters": { + # "beam-pruning": 15.0, + # "beam-pruning-limit": 10000, + # "word-end-pruning": 0.5, + # "word-end-pruning-limit": 15000, + # }, + # "lattice_to_ctm_kwargs": { + # "fill_empty_segments": True, + # "best_path_algo": "bellman-ford", + # }, + # "optimize_am_lm_scale": True, + # "rtf": 50, + # "mem": 6, + # "lmgc_mem": 16, + # "cpu": 2, + # "parallelize_conversion": True, + # "needs_features_size": True, + # "quantize": [None], + # # "quant_filter_opts": [None, {"min_seq_len": 1000}, {"max_seq_len": 1000}], + # "quant_filter_opts": [ + # {"budget": (30000, 0.01)}, + # {"budget": (10000, 0.01)}, + # {"budget": (30000, 0.005)}, + # {"budget": (80000, 0.01)}, + # {"budget": (2500, 0.01)}, + # {"budget": (4000, 0.01)}, + # {"budget": (1000, 0.01)}, + # ], + # # "quant_modes": [CalibrationMethod.MinMax, CalibrationMethod.Percentile], + # "quant_modes": [CalibrationMethod.MinMax, CalibrationMethod.Percentile], + # "random_seed_draws": 100, + # "quant_sym_modes": [False], + # "quant_avg_modes": [False], + # "quant_percentiles": [99.999], + # "quant_num_bin_ls": [2048], + # "quant_ops": [["Conv", "MatMul"]], + # "training_whitelist": [ + # "torch_jj_config2", + # ], + # }, # "quant-filter-seqtags": { # "epochs": evaluation_epochs, # "feature_flow_key": "fb", diff --git a/users/hilmes/experiments/tedlium2/standalone/config.py b/users/hilmes/experiments/tedlium2/standalone/config.py index 7f8c5d738..5cb3bd1ee 100644 --- a/users/hilmes/experiments/tedlium2/standalone/config.py +++ b/users/hilmes/experiments/tedlium2/standalone/config.py @@ -2,7 +2,7 @@ Universal helpers to create configuration objects (i6_core ReturnnConfig) for RETURNN training/forwarding """ import copy -from typing import Any, Dict, Optional +from typing import Any, Dict, Optional, List from i6_core.returnn.config import ReturnnConfig, CodeWrapper @@ -183,6 +183,7 @@ def get_static_quant_config( config: Dict[str, Any], num_samples: int, dataset_seed: int, + dataset_filter_args: Optional[Dict[str, Any]], debug: bool = False, ): """ @@ -206,6 +207,8 @@ def get_static_quant_config( base_config['forward']['seq_ordering'] = 'random' base_config['forward']['datasets']['zip_dataset']['fixed_random_subset'] = num_samples base_config['forward']['datasets']['zip_dataset']['fixed_random_subset_seed'] = dataset_seed + if dataset_filter_args is not None: + base_config['forward']['datasets']['zip_dataset']['random_subset_filter_args'] = dataset_filter_args config = {**base_config, **copy.deepcopy(config)} post_config["backend"] = "torch" assert net_args.keys().isdisjoint(quant_args.keys()) diff --git a/users/hilmes/experiments/tedlium2/standalone/default_tools.py b/users/hilmes/experiments/tedlium2/standalone/default_tools.py index 2cd71d3d6..8c1b48070 100644 --- a/users/hilmes/experiments/tedlium2/standalone/default_tools.py +++ b/users/hilmes/experiments/tedlium2/standalone/default_tools.py @@ -19,7 +19,7 @@ I6_MODELS_REPO_PATH = CloneGitRepositoryJob( url="https://github.com/rwth-i6/i6_models", - commit="933c6c13f7d6c74e5a59af0257e17c208dae9da3", + commit="3c9173691521778b1e8b4070c172cbe929e4826b", checkout_folder_name="i6_models", ).out_repository.copy() I6_MODELS_REPO_PATH.hash_overwrite = "TEDLIUM_STANDALONE_DEFAULT_I6_MODELS" @@ -35,3 +35,7 @@ commit_hash="5015a45e28a958f800ef1c50e7880c0c9ef414cf", ).copy() SUBWORD_NMT_REPO.hash_overwrite = "I6_SUBWORD_NMT_V2" + +QUANT_RETURNN = CloneGitRepositoryJob( + "https://github.com/JackTemaki/MiniReturnn", commit="f31614f2a071aa75588eff6f2231b54751fb962c" +).out_repository.copy() diff --git a/users/hilmes/experiments/tedlium2/standalone/experiments/ctc_bpe/baseline.py b/users/hilmes/experiments/tedlium2/standalone/experiments/ctc_bpe/baseline.py index d37553098..8ca22093c 100644 --- a/users/hilmes/experiments/tedlium2/standalone/experiments/ctc_bpe/baseline.py +++ b/users/hilmes/experiments/tedlium2/standalone/experiments/ctc_bpe/baseline.py @@ -281,7 +281,7 @@ def tune_and_evaluate_helper( activation=None, ) - for bpe in [0, 32, 64, 100, 128, 256, 512, 1024]: + for bpe in [32, 64, 100, 128, 256, 512, 1024]: prefix_name_bpe = f"experiments/tedlium2/ctc_rnnt_standalone_2024/bpe_ctc_bpe_{bpe}" train_data_bpe = build_bpe_training_datasets( prefix=prefix_name_bpe, diff --git a/users/hilmes/experiments/tedlium2/standalone/experiments/ctc_phon/baseline.py b/users/hilmes/experiments/tedlium2/standalone/experiments/ctc_phon/baseline.py index 48e054f81..77e80e7b9 100644 --- a/users/hilmes/experiments/tedlium2/standalone/experiments/ctc_phon/baseline.py +++ b/users/hilmes/experiments/tedlium2/standalone/experiments/ctc_phon/baseline.py @@ -1,36 +1,19 @@ -import copy -from dataclasses import asdict, dataclass +from dataclasses import asdict import numpy as np -from typing import cast, List, Dict, Any, Optional - -from i6_core.tools.parameter_tuning import GetOptimalParametersAsVariableJob -from i6_core.tools.git import CloneGitRepositoryJob +from typing import cast from i6_experiments.common.setups.returnn.datastreams.vocabulary import LabelDatastream - -from ...data.common import DatasetSettings, build_test_dataset, TrainingDatasets +from .tune_eval import QuantArgs +from ...data.common import DatasetSettings, build_test_dataset from ...data.phon import build_eow_phon_training_datasets, get_text_lexicon from ...default_tools import RETURNN_EXE, MINI_RETURNN_ROOT from ...lm import get_4gram_binary_lm -from ...pipeline import training, prepare_asr_model, search, ASRModel, quantize_static +from ...pipeline import training, prepare_asr_model from ...report import generate_report -from ...config import get_static_quant_config - -@dataclass -class QuantArgs: - sample_ls: List[int] - quant_config_dict: Dict[str, Any] - decoder: str - num_iterations: int - datasets: TrainingDatasets - network_module: str - -QUANT_RETURNN = CloneGitRepositoryJob( - "https://github.com/JackTemaki/MiniReturnn", commit="f31614f2a071aa75588eff6f2231b54751fb962c" -).out_repository.copy() +from .tune_eval import tune_and_evaluate_helper -def eow_phon_ted_1023_base(): +def eow_phon_ted_1023_base(quant=False): prefix_name = "experiments/tedlium2/ctc_rnnt_standalone_2024/ctc_eow_phon" train_settings = DatasetSettings( @@ -72,115 +55,6 @@ def eow_phon_ted_1023_base(): from ...pytorch_networks.ctc.decoder.flashlight_ctc_v1 import DecoderConfig - def tune_and_evaluate_helper( - training_name: str, - asr_model: ASRModel, - base_decoder_config: DecoderConfig, - lm_scales: List[float], - prior_scales: List[float], - quant_str: Optional[str] = None, - eval_test: bool = False, - quant_args: Optional[QuantArgs] = None, - ): - """ - Example helper to execute tuning over lm_scales and prior scales. - With the best values runs test-clean and test-other. - - This is just a reference helper and can (should) be freely changed, copied, modified etc... - - :param training_name: for alias and output names - :param asr_model: ASR model to use - :param base_decoder_config: any decoder config dataclass - :param lm_scales: lm scales for tuning - :param prior_scales: prior scales for tuning, same length as lm scales - """ - tune_parameters = [] - tune_values = [] - results = {} - for lm_weight in lm_scales: - for prior_scale in prior_scales: - decoder_config = copy.deepcopy(base_decoder_config) - decoder_config.lm_weight = lm_weight - decoder_config.prior_scale = prior_scale - search_name = training_name + "/search_lm%.1f_prior%.1f" % (lm_weight, prior_scale) - search_jobs, wers = search( - search_name, - forward_config={}, - asr_model=asr_model, - decoder_module="ctc.decoder.flashlight_ctc_v1", - decoder_args={"config": asdict(decoder_config)}, - test_dataset_tuples=dev_dataset_tuples, - **default_returnn, - ) - tune_parameters.append((lm_weight, prior_scale)) - tune_values.append((wers[search_name + "/dev"])) - results.update(wers) - if quant_args is not None: - assert quant_str is not None, "You want your quant to have a name" - for num_samples in quant_args.sample_ls: - for seed in range(quant_args.num_iterations): - it_name = training_name + quant_str + f"/quantize_static/samples_{num_samples}/seed_{seed}" - quant_config = get_static_quant_config( - training_datasets=quant_args.datasets, - network_module=quant_args.network_module, - net_args=asr_model.net_args, - quant_args=quant_args.quant_config_dict, - config={}, - num_samples=num_samples, - dataset_seed=seed, - debug=False, - ) - quant_chkpt = quantize_static( - prefix_name=it_name, - returnn_config=quant_config, - checkpoint=asr_model.checkpoint, - returnn_exe=RETURNN_EXE, - returnn_root=QUANT_RETURNN, - ) - quant_model = ASRModel( - checkpoint=quant_chkpt, - net_args=asr_model.net_args | quant_args.quant_config_dict, - network_module=quant_args.network_module, - prior_file=asr_model.prior_file, - prefix_name=it_name - ) - for lm_weight in lm_scales: - for prior_scale in prior_scales: - decoder_config = copy.deepcopy(base_decoder_config) - decoder_config.lm_weight = lm_weight - decoder_config.prior_scale = prior_scale - search_name = it_name + "/search_lm%.1f_prior%.1f" % (lm_weight, prior_scale) - search_jobs, wers = search( - search_name, - forward_config={}, - asr_model=quant_model, - decoder_module=quant_args.decoder, - decoder_args={"config": asdict(decoder_config)}, - test_dataset_tuples=dev_dataset_tuples, - **default_returnn, - ) - results.update(wers) - pick_optimal_params_job = GetOptimalParametersAsVariableJob( - parameters=tune_parameters, values=tune_values, mode="minimize" - ) - pick_optimal_params_job.add_alias(training_name + f"/pick_best_dev") - if eval_test: - for key, tune_values in [("test", tune_values)]: - decoder_config = copy.deepcopy(base_decoder_config) - decoder_config.lm_weight = pick_optimal_params_job.out_optimal_parameters[0] - decoder_config.prior_scale = pick_optimal_params_job.out_optimal_parameters[1] - search_jobs, wers = search( - training_name, - forward_config={}, - asr_model=asr_model, - decoder_module="ctc.decoder.flashlight_ctc_v1", - decoder_args={"config": asdict(decoder_config)}, - test_dataset_tuples={key: test_dataset_tuples[key]}, - **default_returnn, - ) - results.update(wers) - return results, pick_optimal_params_job - default_decoder_config = DecoderConfig( lexicon=get_text_lexicon(), returnn_vocab=label_datastream.vocab, @@ -277,7 +151,9 @@ def tune_and_evaluate_helper( training_name, train_job, train_args, with_prior=True, datasets=train_data, get_specific_checkpoint=250 ) res, _ = tune_and_evaluate_helper( - training_name, asr_model, default_decoder_config, lm_scales=[1.4, 1.6, 1.8, 2.0, 2.2, 2.4], prior_scales=[0.0, 0.3, 0.5, 0.7, 1.0] + training_name, asr_model, default_decoder_config, + lm_scales=[1.4, 1.6, 1.8, 2.0, 2.2, 2.4], prior_scales=[0.0, 0.3, 0.5, 0.7, 1.0], + dev_dataset_tuples=dev_dataset_tuples ) results.update(res) generate_report(results=results, exp_name=training_name) @@ -309,7 +185,7 @@ def tune_and_evaluate_helper( prior_scales = [0.7, 0.9] res, _ = tune_and_evaluate_helper( training_name, asr_model, default_decoder_config, lm_scales=lm_scales, - prior_scales=prior_scales + prior_scales=prior_scales, dev_dataset_tuples=dev_dataset_tuples ) results.update(res) asr_model_best4 = prepare_asr_model( @@ -317,228 +193,260 @@ def tune_and_evaluate_helper( get_best_averaged_checkpoint=(4, "dev_loss_ctc") ) res, _ = tune_and_evaluate_helper(training_name + "/best4", asr_model_best4, default_decoder_config, - lm_scales=lm_scales, prior_scales=prior_scales) + lm_scales=lm_scales, prior_scales=prior_scales, dev_dataset_tuples=dev_dataset_tuples) results.update(res) asr_model_best = prepare_asr_model( training_name + "/best", train_job, train_args, with_prior=True, datasets=train_data, get_best_averaged_checkpoint=(1, "dev_loss_ctc") ) res, _ = tune_and_evaluate_helper(training_name + "/best", asr_model_best, default_decoder_config, - lm_scales=lm_scales, prior_scales=prior_scales) + lm_scales=lm_scales, prior_scales=prior_scales, dev_dataset_tuples=dev_dataset_tuples) results.update(res) generate_report(results=results, exp_name=training_name) # TODO current best with 7.083 del results - from ...pytorch_networks.ctc.conformer_1023.quant.baseline_quant_v1_cfg import QuantModelConfigV1 - num_iterations = 100 - # what if we give more information to the activation instead? - for activation_bit in [8, 7, 6, 5, 4, 3, 2, 1]: - for weight_bit in [8, 7, 6, 5, 4, 3, 2, 1]: - results = {} - model_config_quant_v1 = QuantModelConfigV1( - weight_quant_dtype="qint8", - weight_quant_method="per_tensor", - activation_quant_dtype="qint8", - activation_quant_method="per_tensor", - dot_quant_dtype="qint8", - dot_quant_method="per_tensor", - Av_quant_dtype="qint8", - Av_quant_method="per_tensor", - moving_average=0.01, - weight_bit_prec=weight_bit, - activation_bit_prec=activation_bit, - linear_quant_output=False, - ) - quant_args = QuantArgs( - sample_ls=[10] if weight_bit < 8 or activation_bit < 8 else [10, 100, 1000, 10000], - quant_config_dict={"quant_config_dict": asdict(model_config_quant_v1)}, - decoder="ctc.decoder.flashlight_quant_stat_phoneme_ctc", - num_iterations=num_iterations, - datasets=train_data, - network_module="ctc.conformer_1023.quant.baseline_quant_v1", - ) - quant_str = f"_weight_{weight_bit}_act_{activation_bit}" - asr_model = prepare_asr_model( - training_name+quant_str, - train_job, - train_args, - with_prior=True, - datasets=train_data, - get_specific_checkpoint=250, - ) - res, _ = tune_and_evaluate_helper( # only take best for now, since otherwise too many searches - training_name, asr_model, default_decoder_config, lm_scales=[2.8], - prior_scales=[0.7], quant_args=quant_args, quant_str=quant_str, - ) - results.update(res) - generate_report(results=results, exp_name=training_name + quant_str) - del results - - num_iterations = 100 - for activation_bit in [8]: - for weight_bit in [8, 7, 6, 5, 4, 3, 2, 1]: - results = {} - model_config_quant_v1 = QuantModelConfigV1( - weight_quant_dtype="qint8", - weight_quant_method="per_tensor", - activation_quant_dtype="qint8", - activation_quant_method="per_tensor", - dot_quant_dtype="qint8", - dot_quant_method="per_tensor", - Av_quant_dtype="qint8", - Av_quant_method="per_tensor", - moving_average=0.01, - weight_bit_prec=weight_bit, - activation_bit_prec=activation_bit, - linear_quant_output=True, - ) - quant_args = QuantArgs( - sample_ls=[10] if weight_bit < 8 or activation_bit < 8 else [10, 100, 1000, 10000], - quant_config_dict={"quant_config_dict": asdict(model_config_quant_v1)}, - decoder="ctc.decoder.flashlight_quant_stat_phoneme_ctc", - num_iterations=num_iterations, - datasets=train_data, - network_module="ctc.conformer_1023.quant.baseline_quant_v1", - ) - quant_str = f"_weight_{weight_bit}_act_{activation_bit}_qlin" - asr_model = prepare_asr_model( - training_name+quant_str, train_job, train_args, with_prior=True, datasets=train_data, get_specific_checkpoint=250 - ) - res, _ = tune_and_evaluate_helper( # only take best for now, since otherwise too many searches - training_name, asr_model, default_decoder_config, lm_scales=[2.8], - prior_scales=[0.7], quant_args=quant_args, quant_str=quant_str - ) - results.update(res) - generate_report(results=results, exp_name=training_name+quant_str) - del results + if quant is True: + from ...pytorch_networks.ctc.conformer_1023.quant.baseline_quant_v1_cfg import QuantModelConfigV1 + num_iterations = 100 + # what if we give more information to the activation instead? + for activation_bit in [8, 7, 6, 5, 4, 3, 2, 1]: + for weight_bit in [8, 7, 6, 5, 4, 3, 2, 1]: + results = {} + model_config_quant_v1 = QuantModelConfigV1( + weight_quant_dtype="qint8", + weight_quant_method="per_tensor", + activation_quant_dtype="qint8", + activation_quant_method="per_tensor", + dot_quant_dtype="qint8", + dot_quant_method="per_tensor", + Av_quant_dtype="qint8", + Av_quant_method="per_tensor", + moving_average=0.01, + weight_bit_prec=weight_bit, + activation_bit_prec=activation_bit, + linear_quant_output=False, + ) + quant_args = QuantArgs( + sample_ls=[10] if weight_bit < 8 or activation_bit < 8 else [10, 100, 1000, 10000], + quant_config_dict={"quant_config_dict": asdict(model_config_quant_v1)}, + decoder="ctc.decoder.flashlight_quant_stat_phoneme_ctc", + num_iterations=num_iterations, + datasets=train_data, + network_module="ctc.conformer_1023.quant.baseline_quant_v1", + ) + quant_str = f"_weight_{weight_bit}_act_{activation_bit}" + asr_model = prepare_asr_model( + training_name+quant_str, + train_job, + train_args, + with_prior=True, + datasets=train_data, + get_specific_checkpoint=250, + ) + res, _ = tune_and_evaluate_helper( # only take best for now, since otherwise too many searches + training_name, asr_model, default_decoder_config, lm_scales=[2.8], + prior_scales=[0.7], quant_args=quant_args, quant_str=quant_str, + dev_dataset_tuples=dev_dataset_tuples, + ) + results.update(res) + generate_report(results=results, exp_name=training_name + quant_str) + del results + num_iterations = 250 + for filter in [ + ({"unique_tags": 0.0}, "unique"), + ({"single_tag": 0.0}, "single"), + ({"max_dur": 1.0}, "max_dur_1"), + ({"min_dur": 15.0}, "min_dur_15") + ]: + for activation_bit in [8]: + for weight_bit in [8]: + results = {} + model_config_quant_v1 = QuantModelConfigV1( + weight_quant_dtype="qint8", + weight_quant_method="per_tensor", + activation_quant_dtype="qint8", + activation_quant_method="per_tensor", + dot_quant_dtype="qint8", + dot_quant_method="per_tensor", + Av_quant_dtype="qint8", + Av_quant_method="per_tensor", + moving_average=0.01, + weight_bit_prec=weight_bit, + activation_bit_prec=activation_bit, + linear_quant_output=False, + ) + quant_args = QuantArgs( + sample_ls=[1], #§, 10, 25, 5], + quant_config_dict={"quant_config_dict": asdict(model_config_quant_v1)}, + decoder="ctc.decoder.flashlight_quant_stat_phoneme_ctc", + num_iterations=num_iterations, + datasets=train_data, + network_module="ctc.conformer_1023.quant.baseline_quant_v1", + filter_args=filter[0], + ) + quant_str = f"_weight_{weight_bit}_act_{activation_bit}_{filter[1]}" + asr_model = prepare_asr_model( + training_name+quant_str, + train_job, + train_args, + with_prior=True, + datasets=train_data, + get_specific_checkpoint=250, + ) + res, _ = tune_and_evaluate_helper( # only take best for now, since otherwise too many searches + training_name, asr_model, default_decoder_config, lm_scales=[2.8], + prior_scales=[0.7], quant_args=quant_args, quant_str=quant_str, dev_dataset_tuples=dev_dataset_tuples + ) + results.update(res) + generate_report(results=results, exp_name=training_name + quant_str) + del results - for activation_bit in [8]: - for weight_bit in [8]: - results = {} - model_config_quant_v1 = QuantModelConfigV1( - weight_quant_dtype="qint8", - weight_quant_method="per_tensor", - activation_quant_dtype="qint8", - activation_quant_method="per_tensor", - dot_quant_dtype="qint8", - dot_quant_method="per_tensor", - Av_quant_dtype="qint8", - Av_quant_method="per_tensor", - moving_average=None, - weight_bit_prec=weight_bit, - activation_bit_prec=activation_bit, - linear_quant_output=False, - ) - quant_args = QuantArgs( - sample_ls=[10] if weight_bit < 8 or activation_bit < 8 else [10, 100, 1000, 10000], - quant_config_dict={"quant_config_dict": asdict(model_config_quant_v1)}, - decoder="ctc.decoder.flashlight_quant_stat_phoneme_ctc", - num_iterations=num_iterations, - datasets=train_data, - network_module="ctc.conformer_1023.quant.baseline_quant_v1", - ) - quant_str = f"_weight_{weight_bit}_act_{activation_bit}_no_avg" - asr_model = prepare_asr_model( - training_name+quant_str, - train_job, - train_args, - with_prior=True, - datasets=train_data, - get_specific_checkpoint=250, - ) - res, _ = tune_and_evaluate_helper( # only take best for now, since otherwise too many searches - training_name, asr_model, default_decoder_config, lm_scales=[2.8], - prior_scales=[0.7], quant_args=quant_args, quant_str=quant_str, - ) - results.update(res) - generate_report(results=results, exp_name=training_name + quant_str) - del results + num_iterations = 100 + for activation_bit in [8]: + for weight_bit in [8, 7, 6, 5, 4, 3, 2, 1]: + results = {} + model_config_quant_v1 = QuantModelConfigV1( + weight_quant_dtype="qint8", + weight_quant_method="per_tensor", + activation_quant_dtype="qint8", + activation_quant_method="per_tensor", + dot_quant_dtype="qint8", + dot_quant_method="per_tensor", + Av_quant_dtype="qint8", + Av_quant_method="per_tensor", + moving_average=0.01, + weight_bit_prec=weight_bit, + activation_bit_prec=activation_bit, + linear_quant_output=True, + ) + quant_args = QuantArgs( + sample_ls=[10] if weight_bit < 8 or activation_bit < 8 else [10, 100, 1000, 10000], + quant_config_dict={"quant_config_dict": asdict(model_config_quant_v1)}, + decoder="ctc.decoder.flashlight_quant_stat_phoneme_ctc", + num_iterations=num_iterations, + datasets=train_data, + network_module="ctc.conformer_1023.quant.baseline_quant_v1", + ) + quant_str = f"_weight_{weight_bit}_act_{activation_bit}_qlin" + asr_model = prepare_asr_model( + training_name+quant_str, train_job, train_args, with_prior=True, datasets=train_data, get_specific_checkpoint=250 + ) + res, _ = tune_and_evaluate_helper( # only take best for now, since otherwise too many searches + training_name, asr_model, default_decoder_config, lm_scales=[2.8], + prior_scales=[0.7], quant_args=quant_args, quant_str=quant_str, dev_dataset_tuples=dev_dataset_tuples + ) + results.update(res) + generate_report(results=results, exp_name=training_name+quant_str) + del results - model_config_drop_03 = ModelConfig( - feature_extraction_config=fe_config, - frontend_config=frontend_config, - specaug_config=specaug_config, - label_target_size=vocab_size_without_blank, - conformer_size=384, - num_layers=12, - num_heads=4, - ff_dim=1536, - att_weights_dropout=0.3, - conv_dropout=0.3, - ff_dropout=0.3, - mhsa_dropout=0.3, - conv_kernel_size=31, - final_dropout=0.3, - specauc_start_epoch=1, - ) + for activation_bit in [8]: + for weight_bit in [8]: + results = {} + model_config_quant_v1 = QuantModelConfigV1( + weight_quant_dtype="qint8", + weight_quant_method="per_tensor", + activation_quant_dtype="qint8", + activation_quant_method="per_tensor", + dot_quant_dtype="qint8", + dot_quant_method="per_tensor", + Av_quant_dtype="qint8", + Av_quant_method="per_tensor", + moving_average=None, + weight_bit_prec=weight_bit, + activation_bit_prec=activation_bit, + linear_quant_output=False, + ) + quant_args = QuantArgs( + sample_ls=[10] if weight_bit < 8 or activation_bit < 8 else [10, 100, 1000, 10000], + quant_config_dict={"quant_config_dict": asdict(model_config_quant_v1)}, + decoder="ctc.decoder.flashlight_quant_stat_phoneme_ctc", + num_iterations=num_iterations, + datasets=train_data, + network_module="ctc.conformer_1023.quant.baseline_quant_v1", + ) + quant_str = f"_weight_{weight_bit}_act_{activation_bit}_no_avg" + asr_model = prepare_asr_model( + training_name+quant_str, + train_job, + train_args, + with_prior=True, + datasets=train_data, + get_specific_checkpoint=250, + ) + res, _ = tune_and_evaluate_helper( # only take best for now, since otherwise too many searches + training_name, asr_model, default_decoder_config, lm_scales=[2.8], + prior_scales=[0.7], quant_args=quant_args, quant_str=quant_str, dev_dataset_tuples=dev_dataset_tuples, + ) + results.update(res) + generate_report(results=results, exp_name=training_name + quant_str) + del results - train_config_24gbgpu_amp = { + # E-Branchformer + branchformer_module = "ctc.conformer_1023.i6models_ebranchformer_v1" + train_config = { "optimizer": {"class": "adamw", "epsilon": 1e-16, "weight_decay": 1e-3}, - "learning_rates": list(np.linspace(7e-6, 5e-4, 210)) - + list(np.linspace(5e-4, 5e-5, 210)) - + list(np.linspace(5e-5, 1e-7, 30)), + "learning_rates": list(np.linspace(7e-6, 5e-4, 110)) + + list(np.linspace(5e-4, 5e-5, 110)) + + list(np.linspace(5e-5, 1e-7, 30)), ############# - "batch_size": 360 * 16000, + "batch_size": 180 * 16000, "max_seq_length": {"audio_features": 35 * 16000}, "accum_grad_multiple_step": 1, - "torch_amp_options": {"dtype": "bfloat16"}, } train_args = { - "config": train_config_24gbgpu_amp, - "network_module": network_module, - "net_args": {"model_config_dict": asdict(model_config_drop_03)}, + "config": train_config, + "network_module": branchformer_module, + "net_args": {"model_config_dict": asdict(model_config)}, "debug": False, - "use_speed_perturbation": True } results = {} - training_name = prefix_name + "/" + network_module + "_384dim_sub4_24gbgpu_50eps_amp_longer" - train_job = training(training_name, train_data, train_args, num_epochs=450, **default_returnn) - train_job.rqmt["gpu_mem"] = 24 + training_name = prefix_name + "/" + branchformer_module + "_384dim_sub4_50eps" + train_job = training(training_name, train_data, train_args, num_epochs=250, **default_returnn) asr_model = prepare_asr_model( - training_name, train_job, train_args, with_prior=True, datasets=train_data, get_specific_checkpoint=450 + training_name, train_job, train_args, with_prior=True, datasets=train_data, get_specific_checkpoint=250 ) + lm_scales = [2.0, 2.2, 2.4, 2.6, 2.8] + prior_scales = [0.7, 0.9] res, _ = tune_and_evaluate_helper( - training_name, asr_model, default_decoder_config, lm_scales=[2.0, 2.2, 2.4, 2.6, 2.8], prior_scales=[0.5, 0.7] + training_name, asr_model, default_decoder_config, lm_scales=lm_scales, + prior_scales=prior_scales, dev_dataset_tuples=dev_dataset_tuples ) results.update(res) asr_model_best4 = prepare_asr_model( - training_name + "/best4", train_job, train_args, with_prior=True, datasets=train_data, get_best_averaged_checkpoint=(4, "dev_loss_ctc") + training_name + "/best4", train_job, train_args, with_prior=True, datasets=train_data, + get_best_averaged_checkpoint=(4, "dev_loss_ctc") ) - res, _ = tune_and_evaluate_helper(training_name + "/best4", asr_model_best4, default_decoder_config, lm_scales=[2.3, 2.5, 2.7], prior_scales=[0.5, 0.7]) + res, _ = tune_and_evaluate_helper(training_name + "/best4", asr_model_best4, default_decoder_config, + lm_scales=lm_scales, prior_scales=prior_scales, dev_dataset_tuples=dev_dataset_tuples) results.update(res) asr_model_best = prepare_asr_model( training_name + "/best", train_job, train_args, with_prior=True, datasets=train_data, get_best_averaged_checkpoint=(1, "dev_loss_ctc") ) res, _ = tune_and_evaluate_helper(training_name + "/best", asr_model_best, default_decoder_config, - lm_scales=[2.3, 2.5, 2.7], prior_scales=[0.5, 0.7]) + lm_scales=lm_scales, prior_scales=prior_scales, dev_dataset_tuples=dev_dataset_tuples) results.update(res) - generate_report(results=results, exp_name=training_name) + generate_report(results=results, exp_name=training_name) # TODO current best with 6.99 del results - - network_module_conv_first = "ctc.conformer_1023.i6modelsV1_VGG4LayerActFrontendV1_v6_conv_first" - train_args = { - "config": train_config_24gbgpu_amp, - "network_module": network_module_conv_first, - "net_args": {"model_config_dict": asdict(model_config)}, - "debug": False, - } - results = {} - training_name = prefix_name + "/" + network_module_conv_first + "_384dim_sub4_24gbgpu_50eps_conv_first_amp" - train_job = training(training_name, train_data, train_args, num_epochs=250, **default_returnn) - train_job.rqmt["gpu_mem"] = 24 - asr_model = prepare_asr_model( - training_name, train_job, train_args, with_prior=True, datasets=train_data, get_specific_checkpoint=250 - ) - res, _ = tune_and_evaluate_helper( - training_name, asr_model, default_decoder_config, lm_scales=[1.8, 2.0, 2.2, 2.4, 2.6, 2.8], - prior_scales=[0.5, 0.7] + unimod_module = "ctc.conformer_1023.conformer_v1_uni_aggr_v1" + from ...pytorch_networks.ctc.conformer_1023.conformer_v1_uni_aggr_cfg_v1 import ModelConfig as UniAggrConfig + uni_aggr_model_config = UniAggrConfig( + feature_extraction_config=fe_config, + frontend_config=frontend_config, + specaug_config=specaug_config, + label_target_size=vocab_size_without_blank, + conformer_size=384, + num_layers=12, + num_heads=4, + ff_dim=1536, + att_weights_dropout=0.2, + conv_dropout=0.2, + ff_dropout=0.2, + mhsa_dropout=0.2, + conv_kernel_size=31, + final_dropout=0.2, + specauc_start_epoch=1, + aggr_layer=9, ) - results.update(res) - generate_report(results=results, exp_name=training_name) - del results - - # E-Branchformer - branchformer_module = "ctc.conformer_1023.i6models_ebranchformer_v1" train_config = { "optimizer": {"class": "adamw", "epsilon": 1e-16, "weight_decay": 1e-3}, "learning_rates": list(np.linspace(7e-6, 5e-4, 110)) @@ -549,23 +457,24 @@ def tune_and_evaluate_helper( "max_seq_length": {"audio_features": 35 * 16000}, "accum_grad_multiple_step": 1, } + # Unimodal Aggregation train_args = { "config": train_config, - "network_module": branchformer_module, - "net_args": {"model_config_dict": asdict(model_config)}, + "network_module": unimod_module, + "net_args": {"model_config_dict": asdict(uni_aggr_model_config)}, "debug": False, } results = {} - training_name = prefix_name + "/" + branchformer_module + "_384dim_sub4_50eps" + training_name = prefix_name + "/" + unimod_module + "_384dim_sub4_50eps" train_job = training(training_name, train_data, train_args, num_epochs=250, **default_returnn) asr_model = prepare_asr_model( - training_name, train_job, train_args, with_prior=True, datasets=train_data, get_specific_checkpoint=250 + training_name, train_job, train_args, with_prior=True, datasets=train_data, get_specific_checkpoint=111 ) lm_scales = [2.0, 2.2, 2.4, 2.6, 2.8] prior_scales = [0.7, 0.9] res, _ = tune_and_evaluate_helper( training_name, asr_model, default_decoder_config, lm_scales=lm_scales, - prior_scales=prior_scales + prior_scales=prior_scales, dev_dataset_tuples=dev_dataset_tuples ) results.update(res) asr_model_best4 = prepare_asr_model( @@ -573,14 +482,14 @@ def tune_and_evaluate_helper( get_best_averaged_checkpoint=(4, "dev_loss_ctc") ) res, _ = tune_and_evaluate_helper(training_name + "/best4", asr_model_best4, default_decoder_config, - lm_scales=lm_scales, prior_scales=prior_scales) + lm_scales=lm_scales, prior_scales=prior_scales, dev_dataset_tuples=dev_dataset_tuples) results.update(res) asr_model_best = prepare_asr_model( training_name + "/best", train_job, train_args, with_prior=True, datasets=train_data, get_best_averaged_checkpoint=(1, "dev_loss_ctc") ) res, _ = tune_and_evaluate_helper(training_name + "/best", asr_model_best, default_decoder_config, - lm_scales=lm_scales, prior_scales=prior_scales) + lm_scales=lm_scales, prior_scales=prior_scales, dev_dataset_tuples=dev_dataset_tuples) results.update(res) - generate_report(results=results, exp_name=training_name) # TODO current best with 7.083 - del results \ No newline at end of file + generate_report(results=results, exp_name=training_name) + del results diff --git a/users/hilmes/experiments/tedlium2/standalone/experiments/ctc_phon/tune_eval.py b/users/hilmes/experiments/tedlium2/standalone/experiments/ctc_phon/tune_eval.py new file mode 100644 index 000000000..520ca392c --- /dev/null +++ b/users/hilmes/experiments/tedlium2/standalone/experiments/ctc_phon/tune_eval.py @@ -0,0 +1,135 @@ +from ...default_tools import RETURNN_EXE, QUANT_RETURNN, MINI_RETURNN_ROOT +from ...pipeline import search, ASRModel, quantize_static +from ...pytorch_networks.ctc.decoder.flashlight_ctc_v1 import DecoderConfig +from typing import List, Optional, Dict, Any +from ...data.common import TrainingDatasets +from dataclasses import dataclass, asdict +from ...config import get_static_quant_config +import copy +from i6_core.tools.parameter_tuning import GetOptimalParametersAsVariableJob + +@dataclass +class QuantArgs: + sample_ls: List[int] + quant_config_dict: Dict[str, Any] + decoder: str + num_iterations: int + datasets: TrainingDatasets + network_module: str + filter_args: Optional[Dict[str, Any]] = None + +default_returnn = { + "returnn_exe": RETURNN_EXE, + "returnn_root": MINI_RETURNN_ROOT, +} + +def tune_and_evaluate_helper( + training_name: str, + asr_model: ASRModel, + base_decoder_config: DecoderConfig, + lm_scales: List[float], + prior_scales: List[float], + dev_dataset_tuples: Dict[str, Any], + quant_str: Optional[str] = None, + test_dataset_tuples: Optional[Dict[str, Any]] = None, + quant_args: Optional[QuantArgs] = None, +): + """ + Example helper to execute tuning over lm_scales and prior scales. + With the best values runs test-clean and test-other. + + This is just a reference helper and can (should) be freely changed, copied, modified etc... + + :param training_name: for alias and output names + :param asr_model: ASR model to use + :param base_decoder_config: any decoder config dataclass + :param lm_scales: lm scales for tuning + :param prior_scales: prior scales for tuning, same length as lm scales + """ + tune_parameters = [] + tune_values = [] + results = {} + for lm_weight in lm_scales: + for prior_scale in prior_scales: + decoder_config = copy.deepcopy(base_decoder_config) + decoder_config.lm_weight = lm_weight + decoder_config.prior_scale = prior_scale + search_name = training_name + "/search_lm%.1f_prior%.1f" % (lm_weight, prior_scale) + search_jobs, wers = search( + search_name, + forward_config={}, + asr_model=asr_model, + decoder_module="ctc.decoder.flashlight_ctc_v1", + decoder_args={"config": asdict(decoder_config)}, + test_dataset_tuples=dev_dataset_tuples, + **default_returnn, + ) + tune_parameters.append((lm_weight, prior_scale)) + tune_values.append((wers[search_name + "/dev"])) + results.update(wers) + if quant_args is not None: + assert quant_str is not None, "You want your quant to have a name" + for num_samples in quant_args.sample_ls: + for seed in range(quant_args.num_iterations): + it_name = training_name + quant_str + f"/quantize_static/samples_{num_samples}/seed_{seed}" + quant_config = get_static_quant_config( + training_datasets=quant_args.datasets, + network_module=quant_args.network_module, + net_args=asr_model.net_args, + quant_args=quant_args.quant_config_dict, + config={}, + num_samples=num_samples, + dataset_seed=seed, + debug=False, + dataset_filter_args=quant_args.filter_args + ) + quant_chkpt = quantize_static( + prefix_name=it_name, + returnn_config=quant_config, + checkpoint=asr_model.checkpoint, + returnn_exe=RETURNN_EXE, + returnn_root=QUANT_RETURNN, + ) + quant_model = ASRModel( + checkpoint=quant_chkpt, + net_args=asr_model.net_args | quant_args.quant_config_dict, + network_module=quant_args.network_module, + prior_file=asr_model.prior_file, + prefix_name=it_name + ) + for lm_weight in lm_scales: + for prior_scale in prior_scales: + decoder_config = copy.deepcopy(base_decoder_config) + decoder_config.lm_weight = lm_weight + decoder_config.prior_scale = prior_scale + search_name = it_name + "/search_lm%.1f_prior%.1f" % (lm_weight, prior_scale) + search_jobs, wers = search( + search_name, + forward_config={}, + asr_model=quant_model, + decoder_module=quant_args.decoder, + decoder_args={"config": asdict(decoder_config)}, + test_dataset_tuples=dev_dataset_tuples, + **default_returnn, + ) + results.update(wers) + pick_optimal_params_job = GetOptimalParametersAsVariableJob( + parameters=tune_parameters, values=tune_values, mode="minimize" + ) + pick_optimal_params_job.add_alias(training_name + f"/pick_best_dev") + if test_dataset_tuples is not None: + for key, tune_values in [("test", tune_values)]: + decoder_config = copy.deepcopy(base_decoder_config) + decoder_config.lm_weight = pick_optimal_params_job.out_optimal_parameters[0] + decoder_config.prior_scale = pick_optimal_params_job.out_optimal_parameters[1] + search_jobs, wers = search( + training_name, + forward_config={}, + asr_model=asr_model, + decoder_module="ctc.decoder.flashlight_ctc_v1", + decoder_args={"config": asdict(decoder_config)}, + test_dataset_tuples={key: test_dataset_tuples[key]}, + **default_returnn, + ) + results.update(wers) + return results, pick_optimal_params_job diff --git a/users/hilmes/experiments/tedlium2/standalone/pytorch_networks/ctc/conformer_1023/conformer_v1_uni_aggr_cfg_v1.py b/users/hilmes/experiments/tedlium2/standalone/pytorch_networks/ctc/conformer_1023/conformer_v1_uni_aggr_cfg_v1.py new file mode 100644 index 000000000..56071ed65 --- /dev/null +++ b/users/hilmes/experiments/tedlium2/standalone/pytorch_networks/ctc/conformer_1023/conformer_v1_uni_aggr_cfg_v1.py @@ -0,0 +1,85 @@ +""" +Config for the base CTC models v4, including specaug start time +""" + +from dataclasses import dataclass + +import torch +from torch import nn +from typing import Callable, Optional, Type, Union + +from i6_models.assemblies.conformer.conformer_v1 import ConformerBlockV1Config, ConformerBlockV1 +from i6_models.parts.frontend.vgg_act import VGG4LayerActFrontendV1Config +from i6_models.config import ModuleFactoryV1, ModelConfiguration +from i6_models.primitives.feature_extraction import LogMelFeatureExtractionV1Config + + +@dataclass(kw_only=True) +class VGG4LayerActFrontendV1Config_mod(VGG4LayerActFrontendV1Config): + activation_str: str = "" + activation: Optional[Union[nn.Module, Callable[[torch.Tensor], torch.Tensor]]] = None + + @classmethod + def from_dict(cls, d): + d = d.copy() + activation_str = d.pop("activation_str") + if activation_str == "ReLU": + from torch.nn import ReLU + + activation = ReLU() + else: + assert False, "Unsupported activation %s" % d["activation_str"] + d["activation"] = activation + return VGG4LayerActFrontendV1Config(**d) + + +@dataclass +class ConformerEncoderV1Config(ModelConfiguration): + """ + Attributes: + num_layers: Number of conformer layers in the conformer encoder + frontend: A pair of ConformerFrontend and corresponding config + block_cfg: Configuration for ConformerBlockV1 + """ + + num_layers: int + + # nested configurations + frontend: ModuleFactoryV1 + block_cfg: ConformerBlockV1Config + + +@dataclass +class SpecaugConfig(ModelConfiguration): + repeat_per_n_frames: int + max_dim_time: int + num_repeat_feat: int + max_dim_feat: int + + +@dataclass +class ModelConfig: + feature_extraction_config: LogMelFeatureExtractionV1Config + frontend_config: VGG4LayerActFrontendV1Config + specaug_config: SpecaugConfig + specauc_start_epoch: int + label_target_size: int + conformer_size: int + num_layers: int + num_heads: int + ff_dim: int + att_weights_dropout: float + conv_dropout: float + ff_dropout: float + mhsa_dropout: float + conv_kernel_size: int + final_dropout: float + aggr_layer: int + + @classmethod + def from_dict(cls, d): + d = d.copy() + d["feature_extraction_config"] = LogMelFeatureExtractionV1Config(**d["feature_extraction_config"]) + d["frontend_config"] = VGG4LayerActFrontendV1Config_mod.from_dict(d["frontend_config"]) + d["specaug_config"] = SpecaugConfig(**d["specaug_config"]) + return ModelConfig(**d) diff --git a/users/hilmes/experiments/tedlium2/standalone/pytorch_networks/ctc/conformer_1023/conformer_v1_uni_aggr_v1.py b/users/hilmes/experiments/tedlium2/standalone/pytorch_networks/ctc/conformer_1023/conformer_v1_uni_aggr_v1.py new file mode 100644 index 000000000..a73f38b71 --- /dev/null +++ b/users/hilmes/experiments/tedlium2/standalone/pytorch_networks/ctc/conformer_1023/conformer_v1_uni_aggr_v1.py @@ -0,0 +1,278 @@ +""" +Like v2, but with i6_models specaugment (v3) +and now controllable start time for when specaugment is applied (v4) +and with the proper feature extraction from i6-models +""" + +import numpy as np +import torch +from typing import Tuple, Union, Callable +import torch.functional as F +from torch import nn +from dataclasses import dataclass + +from i6_models.parts.conformer.norm import LayerNormNC +from i6_models.assemblies.conformer.conformer_v1 import ConformerBlockV1Config, ConformerBlockV1 +from i6_models.config import ModuleFactoryV1, ModelConfiguration +from i6_models.parts.frontend.vgg_act import VGG4LayerActFrontendV1 + +from i6_models.parts.conformer.convolution import ConformerConvolutionV1Config +from i6_models.parts.conformer.feedforward import ConformerPositionwiseFeedForwardV1Config +from i6_models.parts.conformer.mhsa import ConformerMHSAV1Config +from i6_models.primitives.specaugment import specaugment_v1_by_length +from i6_models.primitives.feature_extraction import LogMelFeatureExtractionV1 + +from returnn.torch.context import get_run_ctx + +from .conformer_v1_uni_aggr_cfg_v1 import ModelConfig + + +def mask_tensor(tensor: torch.Tensor, seq_len: torch.Tensor) -> torch.Tensor: + """ + mask a tensor with a "positive" mask (boolean true means position is used) + + This function is traceable. + + :param tensor: [B,T,....] + :param seq_len: [B] + :return: [B,T] + """ + seq_len = seq_len.to(device=tensor.device) + r = torch.arange(tensor.shape[1], device=tensor.device) # [T] + seq_mask = torch.less(r[None, :], seq_len[:, None]) # broadcast to [B,T] + return seq_mask + + +@dataclass +class ConformerAggrEncoderV1Config(ModelConfiguration): + """ + Attributes: + num_layers: Number of conformer layers in the conformer encoder + frontend: A pair of ConformerFrontend and corresponding config + block_cfg: Configuration for ConformerBlockV1 + """ + + num_layers: int + aggr_layer: int + + # nested configurations + frontend: ModuleFactoryV1 + block_cfg: ConformerBlockV1Config + +class ConformerAggrEncoderV1(nn.Module): + """ + Implementation of the convolution-augmented Transformer (short Conformer), as in the original publication. + The model consists of a frontend and a stack of N conformer blocks. + C.f. https://arxiv.org/pdf/2005.08100.pdf + """ + + def __init__(self, cfg: ConformerAggrEncoderV1Config): + """ + :param cfg: conformer encoder configuration with subunits for frontend and conformer blocks + """ + super().__init__() + + self.frontend = cfg.frontend() + self.module_list = torch.nn.ModuleList([ConformerBlockV1(cfg.block_cfg) for _ in range(cfg.num_layers)]) + self.aggr_layer = cfg.aggr_layer + self.aggr_lin = nn.Linear(cfg.block_cfg.ff_cfg.input_dim, 1) + + def forward(self, data_tensor: torch.Tensor, sequence_mask: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]: + """ + :param data_tensor: input tensor of shape [B, T', F] + :param sequence_mask: mask tensor where 1 defines positions within the sequence and 0 outside, shape: [B, T'] + :return: (output, out_seq_mask) + where output is torch.Tensor of shape [B, T, F'], + out_seq_mask is a torch.Tensor of shape [B, T] + + F: input feature dim, F': internal and output feature dim + T': data time dim, T: down-sampled time dim (internal time dim) + """ + x, sequence_mask = self.frontend(data_tensor, sequence_mask) # [B, T, F'] + for i, module in enumerate(self.module_list): + if i == self.aggr_layer: + lengths = torch.sum(sequence_mask, dim=1) + # from https://github.com/Audio-WestlakeU/UMA-ASR/blob/main/espnet2/asr/uma.py + batch, length, _ = x.size() + weights = self.aggr_lin(x) # [B, T, 1] + weights = torch.sigmoid(weights) + scalar_before = weights[:, :-1, :].detach() # (#batch, L-1, 1) + scalar_after = weights[:, 1:, :].detach() # (#batch, L-1, 1) + scalar_before = torch.nn.functional.pad(scalar_before, (0, 0, 1, 0)) # (#batch, L, 1) + scalar_after = torch.nn.functional.pad(scalar_after, (0, 0, 0, 1)) # (#batch, L, 1) + mask = (weights.lt(scalar_before)) & (weights.lt(scalar_after)) # bool tensor (#batch, L, 1) + mask = mask.reshape(weights.shape[0], -1) # bool tensor (#batch, L) + mask[:, 0] = True + batch_index = mask.nonzero()[:, 0] # (k,1); [0,0,0,...,1,1,...,2,2,...,#batch-1,...] + valley_index_start = mask.nonzero()[:, 1] # (k,1); [0,3,7,...,0,2,...,0,4,...,0,...] + mask[:, 0] = False + mask[:, -1] = True + valley_index_end = mask.nonzero()[:, 1] + 2 + # (k,1); [5,9,...,4,...,6,...] + valley_index_end = torch.where(valley_index_end > (length) * torch.ones_like(valley_index_end), + (length) * torch.ones_like(valley_index_end), valley_index_end) + _, counts = torch.unique(batch_index, + return_counts=True) # (#batch, 1); the number of valleys in each sample + max_counts = (torch.max(counts)).item() + utri_mat1 = torch.tril(torch.ones(max_counts + 1, max_counts), -1).to(x.device) + batch_index_mask = utri_mat1[counts] + batch_index_mask = batch_index_mask.reshape(-1, 1) + batch_index_mask = batch_index_mask.nonzero()[:, 0] + valleys = torch.zeros(batch * max_counts, 2).type_as(valley_index_start) + valleys[batch_index_mask] = torch.cat((valley_index_start.unsqueeze(1), valley_index_end.unsqueeze(1)), + 1) + utri_mat = torch.tril(torch.ones(length + 1, length), -1).to(x.device) + output_mask = (utri_mat[valleys[:, 1]] - utri_mat[valleys[:, 0]]).reshape(batch, max_counts, length) + output_mask = output_mask.detach() + alpha_h = torch.mul(weights, x) + x = torch.bmm(output_mask, alpha_h) / torch.bmm(output_mask, weights).clamp_(1e-6) + new_lengths = (lengths / lengths[0] * x.shape[1]).type_as(lengths) + sequence_mask = mask_tensor(x, new_lengths) + + x = module(x, sequence_mask) # [B, T, F'] + + return x, sequence_mask + + +class Model(torch.nn.Module): + def __init__(self, model_config_dict, **kwargs): + super().__init__() + self.cfg = ModelConfig.from_dict(model_config_dict) + frontend_config = self.cfg.frontend_config + conformer_size = self.cfg.conformer_size + conformer_config = ConformerAggrEncoderV1Config( + num_layers=self.cfg.num_layers, + frontend=ModuleFactoryV1(module_class=VGG4LayerActFrontendV1, cfg=frontend_config), + block_cfg=ConformerBlockV1Config( + ff_cfg=ConformerPositionwiseFeedForwardV1Config( + input_dim=conformer_size, + hidden_dim=self.cfg.ff_dim, + dropout=self.cfg.ff_dropout, + activation=nn.functional.silu, + ), + mhsa_cfg=ConformerMHSAV1Config( + input_dim=conformer_size, + num_att_heads=self.cfg.num_heads, + att_weights_dropout=self.cfg.att_weights_dropout, + dropout=self.cfg.mhsa_dropout, + ), + conv_cfg=ConformerConvolutionV1Config( + channels=conformer_size, + kernel_size=self.cfg.conv_kernel_size, + dropout=self.cfg.conv_dropout, + activation=nn.functional.silu, + norm=LayerNormNC(conformer_size), + ), + ), + aggr_layer=self.cfg.aggr_layer, + ) + + self.feature_extraction = LogMelFeatureExtractionV1(cfg=self.cfg.feature_extraction_config) + self.conformer = ConformerAggrEncoderV1(cfg=conformer_config) + self.final_linear = nn.Linear(conformer_size, self.cfg.label_target_size + 1) # + CTC blank + self.final_dropout = nn.Dropout(p=self.cfg.final_dropout) + self.specaug_start_epoch = self.cfg.specauc_start_epoch + + # No particular weight init! + + def forward( + self, + raw_audio: torch.Tensor, + raw_audio_len: torch.Tensor, + ): + """ + :param raw_audio: Audio samples as [B, T, 1] + :param raw_audio_len: length of T as [B] + :return: logprobs [B, T, #labels + blank] + """ + + squeezed_features = torch.squeeze(raw_audio, dim=-1) + with torch.no_grad(): + audio_features, audio_features_len = self.feature_extraction(squeezed_features, raw_audio_len) + + run_ctx = get_run_ctx() + if self.training and run_ctx.epoch >= self.specaug_start_epoch: + audio_features_masked_2 = specaugment_v1_by_length( + audio_features, + time_min_num_masks=2, # TODO: make configurable + time_max_mask_per_n_frames=self.cfg.specaug_config.repeat_per_n_frames, + time_mask_max_size=self.cfg.specaug_config.max_dim_time, + freq_min_num_masks=2, + freq_mask_max_size=self.cfg.specaug_config.max_dim_feat, + freq_max_num_masks=self.cfg.specaug_config.num_repeat_feat, + ) + else: + audio_features_masked_2 = audio_features + + conformer_in = audio_features_masked_2 + # create the mask for the conformer input + mask = mask_tensor(conformer_in, audio_features_len) + + conformer_out, out_mask = self.conformer(conformer_in, mask) + conformer_out = self.final_dropout(conformer_out) + logits = self.final_linear(conformer_out) + + log_probs = torch.log_softmax(logits, dim=2) + + return log_probs, torch.sum(out_mask, dim=1) + + +def train_step(*, model: Model, data, run_ctx, **kwargs): + + raw_audio = data["raw_audio"] # [B, T', F] + raw_audio_len = data["raw_audio:size1"].to("cpu") # [B] + + labels = data["labels"] # [B, N] (sparse) + labels_len = data["labels:size1"] # [B, N] + + logprobs, audio_features_len = model( + raw_audio=raw_audio, + raw_audio_len=raw_audio_len, + ) + transposed_logprobs = torch.permute(logprobs, (1, 0, 2)) # CTC needs [T, B, F] + ctc_loss = nn.functional.ctc_loss( + transposed_logprobs, + labels, + input_lengths=audio_features_len, + target_lengths=labels_len, + blank=model.cfg.label_target_size, + reduction="sum", + zero_infinity=True, + ) + num_phonemes = torch.sum(labels_len) + run_ctx.mark_as_loss(name="ctc", loss=ctc_loss, inv_norm_factor=num_phonemes) + + +def prior_init_hook(run_ctx, **kwargs): + # we are storing durations, but call it output.hdf to match + # the default output of the ReturnnForwardJob + run_ctx.sum_probs = None + run_ctx.sum_frames = 0 + + +def prior_finish_hook(run_ctx, **kwargs): + all_frames = run_ctx.sum_frames.detach().cpu().numpy() + all_probs = run_ctx.sum_probs.detach().cpu().numpy() + average_probs = all_probs / all_frames + log_average_probs = np.log(average_probs) + print("Prior sum in std-space (should be close to 1.0):", np.sum(average_probs)) + with open("prior.txt", "w") as f: + np.savetxt(f, log_average_probs, delimiter=" ") + print("Saved prior in prior.txt in +log space.") + + +def prior_step(*, model: Model, data, run_ctx, **kwargs): + raw_audio = data["raw_audio"] # [B, T', F] + raw_audio_len = data["raw_audio:size1"] # [B] + + logprobs, audio_features_len = model( + raw_audio=raw_audio, + raw_audio_len=raw_audio_len, + ) + + probs = torch.exp(logprobs) + run_ctx.sum_frames = run_ctx.sum_frames + torch.sum(audio_features_len) + if run_ctx.sum_probs is None: + run_ctx.sum_probs = torch.sum(probs, dim=(0, 1)) + else: + run_ctx.sum_probs += torch.sum(probs, dim=(0, 1)) diff --git a/users/hilmes/experiments/tedlium2/standalone/pytorch_networks/ctc/conformer_1023/quant/baseline_quant_v1.py b/users/hilmes/experiments/tedlium2/standalone/pytorch_networks/ctc/conformer_1023/quant/baseline_quant_v1.py index f5086205f..c723c51e3 100644 --- a/users/hilmes/experiments/tedlium2/standalone/pytorch_networks/ctc/conformer_1023/quant/baseline_quant_v1.py +++ b/users/hilmes/experiments/tedlium2/standalone/pytorch_networks/ctc/conformer_1023/quant/baseline_quant_v1.py @@ -490,17 +490,18 @@ def static_quant_init_hook(run_ctx, **kwargs): run_ctx.apply_quant = False run_ctx.tag_file = open("seq_tags.txt", "wt") - def static_quant_step(*, model: Model, data, run_ctx, **kwargs): raw_audio = data["raw_audio"] # [B, T', F] raw_audio_len = data["raw_audio:size1"] # [B] assert not model.training + assert model.eval() + model.eval() _, audio_features_len = model( raw_audio=raw_audio, raw_audio_len=raw_audio_len, ) - for tag, feat_len, raw_len in zip(data["seq_tag"], audio_features_len, raw_audio_len): + for tag, feat_len, raw_len in zip(data["seq_tag"], audio_features_len, raw_audio_len): run_ctx.tag_file.write(tag + f" len: {feat_len} raw_len: {raw_len}\n") def static_quant_finish_hook(run_ctx, **kwargs): diff --git a/users/hilmes/modules/onnx_precomputed_hybrid_system.py b/users/hilmes/modules/onnx_precomputed_hybrid_system.py index 0ecdfbb95..5edba5167 100644 --- a/users/hilmes/modules/onnx_precomputed_hybrid_system.py +++ b/users/hilmes/modules/onnx_precomputed_hybrid_system.py @@ -42,6 +42,7 @@ def calcluate_nn_prior(self, returnn_config, epoch, epoch_num, name, checkpoint, del prior_config.config["chunking"] if "torch_amp" in prior_config.config.keys(): del prior_config.config['torch_amp'] + prior_config.config["extern_data"]["data_raw"] = {"dim": 1, "shape": (None, 1), "available_for_inference": True} from i6_core.tools.git import CloneGitRepositoryJob # if "align" not in prior_config.config["train"]["datasets"]: returnn_root = CloneGitRepositoryJob( @@ -163,9 +164,9 @@ def nn_recognition( onnx_job.add_alias(f"export_onnx/{name}/epoch_{epoch_str}") onnx_job.set_keep_value(5) onnx_model = onnx_job.out_onnx_model - io_map = {"features": "data", "output": "log_probs"} + io_map = {"features": "data_raw", "output": "log_probs"} if needs_features_size: - io_map["features-size"] = "data:size1" + io_map["features-size"] = "data_raw:size1" if nn_prior or acoustic_mixture_path is None: prior_file, prior_config = self.calcluate_nn_prior( @@ -178,9 +179,13 @@ def nn_recognition( ) # This can't be acoustic_mixture_path because python hands in the object itself, not a copy thus # one would override the old mixture_path (if there is any) for all other exps + if "data_raw" in returnn_config.config['extern_data']: + features = returnn_config.config['extern_data']['data_raw']['dim'] + else: + features = returnn_config.config['extern_data']['data']['dim'] tmp_acoustic_mixture_path = CreateDummyMixturesJob( num_mixtures=returnn_config.config['extern_data']['classes']['dim'], - num_features=returnn_config.config['extern_data']['data']['dim']).out_mixtures + num_features=features).out_mixtures lmgc_scorer = rasr.GMMFeatureScorer(acoustic_mixture_path) scorer = rasr.PrecomputedHybridFeatureScorer( prior_mixtures=tmp_acoustic_mixture_path, diff --git a/users/hilmes/modules/pytorch_onnx_hybrid_system.py b/users/hilmes/modules/pytorch_onnx_hybrid_system.py index 20e211255..2bfee277e 100644 --- a/users/hilmes/modules/pytorch_onnx_hybrid_system.py +++ b/users/hilmes/modules/pytorch_onnx_hybrid_system.py @@ -29,7 +29,7 @@ from i6_experiments.users.hilmes.experiments.tedlium2.asr_2023.hybrid.torch_baselines.pytorch_networks.prior.forward import \ ReturnnForwardComputePriorJob from i6_experiments.users.hilmes.tools.onnx import ExportPyTorchModelToOnnxJob - +from i6_core.tools.git import CloneGitRepositoryJob def get_quant_str( quant_mode: CalibrationMethod, @@ -88,6 +88,8 @@ def get_quant_str( mode_str_tmp += f"_single_tag" if "unique_tags" in filter_opts: mode_str_tmp += f"_unique_tags" + if "range_len" in filter_opts: + mode_str_tmp += f"_range_len_{filter_opts['range_len'][0]}_{filter_opts['range_len'][1]}" return mode_str_tmp @@ -144,7 +146,6 @@ def calcluate_nn_prior(self, returnn_config, epoch, epoch_num, name, checkpoint, prior_config.config["load_epoch"] = epoch_num if "chunking" in prior_config.config.keys(): del prior_config.config["chunking"] - from i6_core.tools.git import CloneGitRepositoryJob if any(x in name for x in ["distill_whisper"]): returnn_root = CloneGitRepositoryJob( "https://github.com/rwth-i6/returnn", @@ -227,7 +228,6 @@ def nn_recognition( epoch_num = best_checkpoint_job.out_epoch elif epoch == "avrg": assert train_job is not None, "train_job needed to average checkpoints" - from i6_core.tools.git import CloneGitRepositoryJob chkpts = [] for x in [0, 1, 2, 3]: best_job = GetBestPtCheckpointJob(train_job.out_model_dir, train_job.out_learning_rates, @@ -269,7 +269,6 @@ def nn_recognition( num_mixtures=returnn_config.config['extern_data']['classes']['dim'], num_features=returnn_config.config['extern_data']['data']['dim']).out_mixtures lmgc_scorer = rasr.GMMFeatureScorer(acoustic_mixture_path) - onnx_job = ExportPyTorchModelToOnnxJob( pytorch_checkpoint=checkpoint, returnn_config=returnn_config, @@ -299,6 +298,7 @@ def nn_recognition( final_skip_ls: Optional[Tuple[List[int], List[int]]] = tmp_kwargs.pop("final_skip_ls", None) smooth_ls = tmp_kwargs.pop("smooth_ls", []) quant_filter_opts = tmp_kwargs.pop("quant_filter_opts", [None]) + loss_table_args = tmp_kwargs.pop("loss_table_args", None) for data_num in data_num_ls: for quant_mode, average, sym, activation_type, weight_type, quant_format, quant_ops, percentile, num_bins, filter_opts in itertools.product(quant_modes, avg_modes, sym_modes, activation_type_ls, weight_type_ls, quant_format_ls, quant_ops_ls, percentile_ls, num_bin_ls, quant_filter_opts): if not quant_mode == CalibrationMethod.MinMax and "speed" in name: @@ -351,7 +351,7 @@ def nn_recognition( quant_job.add_alias("quantize_static/" + name + "/" + mode_str + "/epoch" + epoch_str + data_str) quant_job.set_keep_value(5) quant_model = quant_job.out_model - if data_num is None: + if data_num is None or "range_len_" in mode_str: self.jobs[recognition_corpus_key][f"quantize_static/" + name + "/" + mode_str + "/epoch" + epoch_str] = quant_job scorer = OnnxFeatureScorer( mixtures=acoustic_mixture_path, @@ -484,9 +484,138 @@ def nn_recognition( lmgc_scorer=lmgc_scorer, **tmp_kwargs, ) + # calculate based on loss + if epoch_str == "250": + from i6_core.returnn.forward import ReturnnForwardJobV2 + from i6_core.returnn.config import ReturnnConfig + loss_config: ReturnnConfig = copy.deepcopy(prior_config) + serializer_objects = copy.deepcopy(loss_config.python_epilog[0].serializer_objects)[:-3] + from i6_experiments.common.setups.serialization import Import, ExplicitHash, ExternalImport + package = "i6_experiments.users.hilmes.experiments.tedlium2.asr_2023.hybrid.torch_baselines" + prior_computation = Import(package + ".pytorch_networks.prior.basic.loss_forward_step", + import_as="forward_step") + serializer_objects.append(prior_computation) + prior_computation = Import( + package + ".pytorch_networks.prior.prior_callback.PrintLossCallback", + import_as="forward_callback" + ) + serializer_objects.append(prior_computation) + models_commit = "75e03f37ac74d3d0c7358d29bb9b71dcec1bf120" + i6_models_repo = CloneGitRepositoryJob( + url="https://github.com/rwth-i6/i6_models", + commit=models_commit, + checkout_folder_name="i6_models", + branch="bene_conf_enc" if models_commit == "75e03f37ac74d3d0c7358d29bb9b71dcec1bf120" else None, + ).out_repository + if models_commit == "75e03f37ac74d3d0c7358d29bb9b71dcec1bf120": + i6_models_repo.hash_overwrite = "TEDLIUM2_DEFAULT_I6_MODELS" + i6_models = ExternalImport(import_path=i6_models_repo) + serializer_objects.insert(0, i6_models) + loss_config.python_epilog[0].serializer_objects = serializer_objects + loss_config.config["max_seqs"] = 1 + loss_config.config["forward_data"] = "train" + loss_config.config["model_outputs"] = {"ce_score": {"dim": 1, "shape": (1,)}} + loss_config.config["train"]["datasets"]["align"]["partition_epoch"] = 1 + #if "min_seq_length" in loss_config.config: + # del loss_config.config["min_seq_length"] + calculate_loss_job = ReturnnForwardJobV2( + model_checkpoint=checkpoint, + returnn_config=loss_config, + log_verbosity=5, + mem_rqmt=16, + time_rqmt=2 if not "whisper" in name else 4, + device="gpu", + cpu_rqmt=2, + returnn_python_exe=self.returnn_python_exe, + returnn_root=self.returnn_root, + output_files=["loss_table"] + ) + calculate_loss_job.add_alias("calulate_loss/" + name + "/epoch_" + epoch_str) + tk.register_output("calculate_loss/" + name + "/epoch_" + epoch_str, + calculate_loss_job.out_files["loss_table"]) + self.jobs[recognition_corpus_key][ + f"calculate_loss/" + name + "/epoch_" + epoch_str] = calculate_loss_job + if loss_table_args is not None: + for args in loss_table_args: + mode_str = get_quant_str( + quant_mode=quant_mode, + average=average, + sym=sym, + activation_type=activation_type, + weight_type=weight_type, + quant_format=quant_format, + quant_ops=quant_ops, + percentile=percentile, + num_bins=num_bins, + random_seed=0, + filter_opts=filter_opts, + ) + string = "" + for arg in args: + string += f"_{arg}" + mode_str += f"_loss_table{string}" + quant_job = ModelQuantizeStaticJob( + model=onnx_model, + dataset=prior_config.config["train"]["datasets"]["feat"], + num_seqs=data_num, + num_parallel_seqs=num_parallel_seqs, + calibrate_method=quant_mode, + moving_average=average, + symmetric=sym, + weight_type=weight_type, + activation_type=activation_type, + quant_format=quant_format, + ops_to_quant=quant_ops, + num_bins=num_bins, + percentile=percentile, + random_seed=random_seed, + filter_opts=filter_opts, + loss_table=(calculate_loss_job.out_files["loss_table"], args) + ) + if data_num is None: + data_str = "" + else: + data_str = "-" + str(data_num) + quant_job.add_alias("quantize_static/" + name + "/" + mode_str + "/epoch" + epoch_str + data_str) + quant_job.set_keep_value(5) + quant_model = quant_job.out_model + self.jobs[recognition_corpus_key][f"quantize_static/" + name + "/" + mode_str + "/epoch" + epoch_str + data_str] = quant_job + scorer = OnnxFeatureScorer( + mixtures=acoustic_mixture_path, + model=quant_model, + priori_scale=prior, + io_map=io_map, + inter_op_threads=tmp_kwargs.get("cpu", 1), + intra_op_threads=tmp_kwargs.get("cpu", 1), + prior_file=prior_file + ) + + self.feature_scorers[recognition_corpus_key][f"pre-nn-{name}-{prior:02.2f}-{mode_str}{data_str}"] = scorer + self.feature_flows[recognition_corpus_key][f"{feature_flow_key}-onnx-{epoch_str}-{mode_str}{data_str}"] = feature_flow + + recog_name = f"e{epoch_str}-prior{prior:02.2f}-ps{pron:02.2f}-lm{lm:02.2f}-{mode_str}{data_str}" + recog_func( + name=f"{name}-{recognition_corpus_key}-{recog_name}", + prefix=f"nn_recog/{name}/", + corpus=recognition_corpus_key, + flow=feature_flow, + feature_scorer=scorer, + pronunciation_scale=pron, + lm_scale=lm, + search_parameters=search_parameters, + lattice_to_ctm_kwargs=lattice_to_ctm_kwargs, + parallelize_conversion=parallelize_conversion, + rtf=rtf, + mem=mem, + lmgc_alias=f"lmgc/{name}/{recognition_corpus_key}-{recog_name}", + lmgc_scorer=lmgc_scorer, + **tmp_kwargs, + ) + if "quant" in name and not "rtf" in name: continue + scorer = OnnxFeatureScorer( mixtures=acoustic_mixture_path, model=onnx_model, diff --git a/users/hilmes/tools/onnx.py b/users/hilmes/tools/onnx.py index acabfcfc0..2916cba00 100644 --- a/users/hilmes/tools/onnx.py +++ b/users/hilmes/tools/onnx.py @@ -90,6 +90,7 @@ class ModelQuantizeStaticJob(Job): "num_bins": None, "random_seed": 0, "filter_opts": None, + "loss_table": None } def __init__(self, @@ -111,6 +112,7 @@ def __init__(self, num_bins: Optional[int] = None, random_seed: int = 0, filter_opts: Optional[Dict[str, Any]] = None, + loss_table: Optional[Tuple[tk.Path, Any]] = None, # Path to loss table + args ): """ :param model: @@ -128,6 +130,7 @@ def __init__(self, self.quant_format = quant_format self.weight_type = weight_type self.filter_opts = filter_opts + self.loss_table = loss_table self.out_model = self.output_path("model.onnx") if num_seqs is None: @@ -150,12 +153,16 @@ def __init__(self, time = 4 else: time = 1 + # cpu slow bandaid + if time >= 1: + time += 5 if not calibrate_method == CalibrationMethod.MinMax: time *= 2 if self.filter_opts is not None and "single_tag" in self.filter_opts: time += 1 - self.rqmt = {"cpu": 8 if num_seqs is not None and num_seqs > 100 else 4, "mem": 16.0 if calibrate_method == CalibrationMethod.MinMax else 64, "time": time} + + self.rqmt = {"cpu": 8 if num_seqs is not None and num_seqs > 100 else 4, "mem": 16.0 if calibrate_method == CalibrationMethod.MinMax else 100, "time": time} self.calibration_method = calibrate_method self.percentile = percentile self.num_bins = num_bins @@ -197,6 +204,15 @@ def run(self): seed = self.random_seed import random random.seed(seed) + loss_table = None + if self.loss_table is not None: + loss_table = [] + with open(self.loss_table[0], "rt") as f: + for line in f: + loss_table.append(line.split(" ")) # (Tag, loss) + if "reverse" in self.loss_table[1]: + loss_table.reverse() + class DummyDataReader(CalibrationDataReader): def __init__(self, @@ -204,15 +220,17 @@ def __init__(self, data: Union[Dataset, MetaDataset], max_seqs: int, final_skip: Optional[Tuple[int, int]] = (None, None), filter_opts: Optional[Dict[str, Any]] = None, - open_budget: Optional[Tuple[int, float]] = (None, None), + open_budget: Tuple[Optional[int], Optional[float]] = (None, None), + loss_table: Optional[List[Tuple[str, str]]] = None + ): self.max_seqs = max_seqs self.data = data self.counter: int = 0 sess_option = SessionOptions() - logging.info(f"Data Loading {os.getenv('SLURM_CPUS_PER_TASK')}") - sess_option.intra_op_num_threads = int(os.getenv('SLURM_CPUS_PER_TASK')) + logging.info(f"Data Loading {os.getenv('SLURM_CPUS_PER_TASK', 4)}") + sess_option.intra_op_num_threads = int(os.getenv('SLURM_CPUS_PER_TASK', 4)) session = InferenceSession(model_str, sess_option) self.input_name_1 = session.get_inputs()[0].name inputs = [] @@ -228,6 +246,7 @@ def __init__(self, self.visited_seqs = set() self.open_budget = open_budget[0] self.budget_thresh = None if open_budget[0] is None else open_budget[0] * open_budget[1] + self.loss_table = loss_table def compare_budget(self): if self.budget_thresh is None or self.open_budget is None: @@ -239,7 +258,7 @@ def get_next(self): key = "data" if "data" in self.data.get_data_keys() else "raw_audio" # hack to make it compatible with both setups for now seq_number = None if not self.data.is_less_than_num_seqs(self.counter) or self.counter >= self.max_seqs or self.compare_budget(): - if not self.data.is_less_than_num_seqs(self.counter): + if self.data.is_less_than_num_seqs(self.counter) and self.final_skip_step is None: logging.info(f"Finished after {self.counter} sequences") return None elif self.final_skip_step is not None and self.counter < self.max_seqs + self.final_skip_step * self.final_skip_count: @@ -254,15 +273,46 @@ def get_next(self): else: logging.info("Seen all sequences in dataset") return None + if self.loss_table is not None: + seq_number = self.counter + name = self.loss_table[seq_number][0] + real_seq_number = self.data.get_all_tags().index(name) + while real_seq_number in self.seen_seqs or not self.check_filter(real_seq_number): + seq_number += 1 + name = self.loss_table[seq_number][0] + real_seq_number = self.data.get_all_tags().index(name) + assert self.loss_table[seq_number][0] == self.data.get_tag(real_seq_number), (self.loss_table[seq_number][0], self.data.get_tag(real_seq_number)) + logging.info(f"Position {seq_number} is real {real_seq_number} with Tag {self.data.get_tag(real_seq_number)} matching {self.loss_table[seq_number]}") + self.visited_seqs.add(real_seq_number) + if self.open_budget is not None and self.open_budget == 0: + assert False, "This path should not be reached" + logging.info("Budget Full") + return None + if len(self.visited_seqs) == self.data.num_seqs: + self.visited_seqs = set() + self.open_budget += 1 + seq_number = seq_number + seq_number = real_seq_number if seq_number is None: while not seq_number or seq_number in self.seen_seqs or not self.check_filter(seq_number): seq_number = random.randint(0, self.data.num_seqs - 1) - self.visited_seqs.add(seq_number) - assert len(self.visited_seqs) <= self.data.num_seqs, "Visited all sequences" - if len(self.visited_seqs) == self.data.num_seqs and any(x in self.filter_opts for x in ["single_tag", "unique_tags"]): - logging.warning("All seqs seen, still not all num seqs reached") + self.visited_seqs.add(seq_number) # +2 because seen seqs has not been updated + logging.info(f"{len(self.visited_seqs)} {self.data.num_seqs} {len(self.seen_seqs)}") + logging.info(f"{seq_number}, {seq_number in self.seen_seqs} {not self.check_filter(seq_number)}") + logging.info(f"{len(self.visited_seqs) == self.data.num_seqs} {len(self.seen_seqs)+2 == self.data.num_seqs} {len(self.seen_seqs)+1 == self.data.num_seqs}") + if len(self.visited_seqs) == self.data.num_seqs and (len(self.seen_seqs)+2 == self.data.num_seqs or len(self.seen_seqs)+1 == self.data.num_seqs): return None + if len(self.visited_seqs) == self.data.num_seqs and not (len(self.seen_seqs)+2 == self.data.num_seqs or len(self.seen_seqs)+1 == self.data.num_seqs) and any(x in self.filter_opts for x in ["single_tag", "unique_tags"]): + return None + if self.open_budget is not None and self.open_budget == 0: + logging.info("Budget Full") + return None + if len(self.visited_seqs) == self.data.num_seqs and not (len(self.seen_seqs)+2 == self.data.num_seqs or len(self.seen_seqs)+1 == self.data.num_seqs): + self.visited_seqs = set() + self.open_budget += 1 + #assert len(self.visited_seqs) < self.data.num_seqs, "Visited all sequences" self.seen_seqs.append(seq_number) + logging.info(len(self.seen_seqs)) self.data.load_seqs(seq_number, seq_number+1) data: np.ndarray = self.data.get_data(seq_number, key) seq_len: np.ndarray = self.data.get_seq_length(seq_number)[key] @@ -286,15 +336,26 @@ def check_filter(self, seq_number) -> bool: if name == "max_seq_len": seq_len = self.data.get_seq_length(seq_number)["data" if "data" in self.data.get_data_keys() else "raw_audio"] if seq_len > value: - logging.info( + logging.warning( f"FILTER: Seq {self.data.get_tag(seq_number)} has length {seq_len} longer than {value}") return False elif name == "min_seq_len": seq_len = self.data.get_seq_length(seq_number)[ "data" if "data" in self.data.get_data_keys() else "raw_audio"] if seq_len < value: + logging.warning( + f"FILTER: Seq {self.data.get_tag(seq_number)}has length {seq_len} shorter than {value}") + return False + elif name == "range_len": + seq_len = self.data.get_seq_length(seq_number)[ + "data" if "data" in self.data.get_data_keys() else "raw_audio"] + if seq_len > value[0] and seq_len < value[1]: logging.info( f"FILTER: Seq {self.data.get_tag(seq_number)}has length {seq_len} shorter than {value}") + return True + else: + logging.warning( + f"FILTER: Seq {self.data.get_tag(seq_number)}has length {seq_len} not in range {value}") return False elif name == "partition": seq_len = self.data.get_seq_length(seq_number)[ @@ -306,16 +367,20 @@ def check_filter(self, seq_number) -> bool: value.remove((lower, upper)) logging.info(value) return True - logging.info( + logging.warning( f"FILTER: {self.data.get_tag(seq_number)} of length {seq_len} not matching {value}") return False elif name == "budget": seq_len = self.data.get_seq_length(seq_number)[ "data" if "data" in self.data.get_data_keys() else "raw_audio"] - if seq_len < self.open_budget: + if seq_len <= self.open_budget: logging.info(f"FILTER: Seq with len {seq_len} within budget {self.open_budget}") self.open_budget -= seq_len + self.visited_seqs = set() return True + else: + pass + #logging.warning(f"FILTER: Seq with len {seq_len} NOT in budget {self.open_budget}") return False elif name == "unique_tags": seq_tag = self.data.get_tag(seq_number) @@ -334,16 +399,24 @@ def check_filter(self, seq_number) -> bool: else: raise NotImplementedError if self.open_budget is not None: + assert False seq_len = self.data.get_seq_length(seq_number)[ "data" if "data" in self.data.get_data_keys() else "raw_audio"] if seq_len < self.open_budget: logging.info(f"FILTER: Seq with len {seq_len} within budget {self.open_budget}") self.open_budget -= seq_len return True + else: + logging.warning(f"FILTER: Seq with len {seq_len} NOT in budget {self.open_budget}") return False return True self.dataset = self.convert_to_str(self.dataset) + if loss_table is not None: + with open("segments", "wt") as f: + for tag, loss in loss_table[:self.num_seqs]: + f.write(f"{tag}\n") + #self.dataset["seq_list_filter_file"] = "segments" dataset: Dataset = init_dataset(self.dataset) dataset.init_seq_order(1) @@ -353,7 +426,8 @@ def check_filter(self, seq_number) -> bool: max_seqs=self.num_seqs, final_skip=self.final_skip, filter_opts=self.filter_opts, - open_budget=self.budget + open_budget=self.budget, + loss_table=loss_table, ) quant_options = { "CalibMaxIntermediateOutputs": self.num_parallel_seqs, From 739d46ddd464bb032164c7b3522d7e44f3670424 Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Tue, 28 May 2024 09:11:29 +0200 Subject: [PATCH 068/227] cleanup --- .../exp2024_04_23_baselines/ctc.py | 19 ++----------------- 1 file changed, 2 insertions(+), 17 deletions(-) diff --git a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py index 4403ca6a0..d295ba6e4 100644 --- a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py +++ b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py @@ -97,23 +97,8 @@ def py(): train_vocab_opts={"other_opts": {"enable_sampling": True, "alpha": alpha}}, ) - for alpha in [ - # 0.3, # very bad? - 0.7, - ]: - train_exp( - "v6-bhv20-11gb-f32-bs15k-accgrad1-mgpu4-pavg100-wd1e_2-lrlin1e_5_295k-speedpertV2-spm_bpe10k" - f"-spmSample{str(alpha).replace('.', '')}", - config_11gb_v6_f32_accgrad1_mgpu4_pavg100_wd1e_4, - config_updates={ - **_get_cfg_lrlin_oclr_by_bs_nep(15_000, 500), - "optimizer.weight_decay": 1e-2, - "__train_audio_preprocess": speed_pert_librosa_config, - "speed_pert_discrete_values": [0.7, 0.8, 0.9, 1.0, 1.1], - }, - vocab="spm_bpe10k", - train_vocab_opts={"other_opts": {"enable_sampling": True, "alpha": alpha}}, - ) + # v6-bhv20-11gb-f32-bs15k-accgrad1-mgpu4-pavg100-wd1e_2-lrlin1e_5_295k-speedpertV2 + # with spm_bpe10k and enable_sampling, alpha in {0.3, 0.7} was both very bad (90% WER). # noinspection PyShadowingNames From 0f6e5948a894ac1dd89f57057b48964cfe8cbcf7 Mon Sep 17 00:00:00 2001 From: "luca.gaudino" Date: Tue, 28 May 2024 16:51:00 +0200 Subject: [PATCH 069/227] updates and fix mel norm + zoneout --- .../conformer_import_moh_att_2023_06_30.py | 178 +++++++++-------- .../conformer_import_moh_att_train.py | 4 +- .../model_recogs/model_recog.py | 1 + .../tedlium2/_import_model.py | 24 ++- .../conformer_import_moh_att_2023_10_19.py | 58 +++--- .../conformer_import_moh_att_train.py | 80 +++++--- .../librispeech_960/conformer_ctc_train.py | 33 ++- .../tedlium2/conformer_ctc_train.py | 188 ++++++++++++++---- .../rf/conformer_ctc/model_conformer_ctc.py | 3 +- users/gaudino/recog.py | 2 + 10 files changed, 384 insertions(+), 187 deletions(-) diff --git a/users/gaudino/experiments/rf_conformer_att_2023/librispeech_960/conformer_import_moh_att_2023_06_30.py b/users/gaudino/experiments/rf_conformer_att_2023/librispeech_960/conformer_import_moh_att_2023_06_30.py index 8aea3533c..611d6c876 100644 --- a/users/gaudino/experiments/rf_conformer_att_2023/librispeech_960/conformer_import_moh_att_2023_06_30.py +++ b/users/gaudino/experiments/rf_conformer_att_2023/librispeech_960/conformer_import_moh_att_2023_06_30.py @@ -84,6 +84,9 @@ def sis_run_with_prefix(prefix_name: str = None): task = get_librispeech_task_bpe10k_raw(with_eos_postfix=True) + bsf = 10 + prefix_name = prefix_name + f"/bsf{bsf}" + ### Experiments without LM and with LSTM LM new_chkpt_path = tk.Path( @@ -100,11 +103,11 @@ def sis_run_with_prefix(prefix_name: str = None): # att only for beam_size in [12, 18]: - recog_name = f"/bsf10/att_beam{beam_size}" + recog_name = f"/att_beam{beam_size}" name = prefix_name + recog_name search_args = { "beam_size": beam_size, - "bsf": 10, + "bsf": bsf, } res, _ = recog_model( @@ -122,14 +125,15 @@ def sis_run_with_prefix(prefix_name: str = None): ) # att + lstm lm TODO: debug difference - for scales, beam_size in product([(1.0, 0.3), (1.0, 0.33), (1.0, 0.27)], [12, 32]): + for scales, beam_size in product([(1.0, 0.3), (1.0, 0.33), (1.0, 0.27)], []): att_scale, lm_scale = scales - recog_name = f"/bsf10/opls_att{att_scale}_lstm_lm{lm_scale}_beam{beam_size}" + recog_name = f"/opls_att{att_scale}_lstm_lm{lm_scale}_beam{beam_size}" name = prefix_name + recog_name search_args = { "beam_size": beam_size, "add_lstm_lm": True, "lm_scale": lm_scale, + "bsf": bsf, } res, _ = recog_model( task, @@ -150,7 +154,7 @@ def sis_run_with_prefix(prefix_name: str = None): for prior_scale, beam_size in product([0.0], []): name = ( prefix_name - + f"/bsf10/ctc_prefix_fix" + + f"/ctc_prefix_fix" + (f"_prior{prior_scale}" if prior_scale != 0.0 else "") + f"_beam{beam_size}" ) @@ -160,7 +164,7 @@ def sis_run_with_prefix(prefix_name: str = None): "use_ctc": True, "ctc_scale": 1.0, "ctc_state_fix": True, - "bsf": 10, + "bsf": bsf, "prior_corr": prior_scale != 0.0, "ctc_prior_file": "/work/asr3/zeineldeen/hiwis/luca.gaudino/setups-data/2023-02-22--conformer-swb/work/i6_core/returnn/extract_prior/ReturnnComputePriorJobV2.ZeflcEHlQTjn/output/prior.txt", "prior_scale": prior_scale, @@ -179,38 +183,33 @@ def sis_run_with_prefix(prefix_name: str = None): res.output, ) - # att + espnet ctc prefix scorer + lstm lm - for scales, prior_scale, lm_scale, beam_size in product( - [(0.8, 0.2), (0.85, 0.15)], - [0.0], - [0.4, 0.45, 0.5, 0.55, 0.6, 0.65], - [12, 32], - ): + # att + espnet ctc prefix + # beam 32: {"dev-clean": 2.14, "dev-other": 5.21, "test-clean": 2.43, "test-other": 5.57} + for scales, prior_scale, beam_size in product([(0.7, 0.3)], [0.1], []): att_scale, ctc_scale = scales - recog_name = ( - f"/bsf10/opls_att{att_scale}_ctc{ctc_scale}_fix" - + (f"_prior{prior_scale}" if prior_scale > 0.0 else "") - + f"_lstm_lm{lm_scale}_beam{beam_size}" + + name = ( + prefix_name + + f"/opls_att{att_scale}_ctc{ctc_scale}_fix" + + (f"_prior{prior_scale}" if prior_scale != 0.0 else "") + + f"_beam{beam_size}" ) - name = prefix_name + recog_name search_args = { "beam_size": beam_size, - "add_lstm_lm": True, - "lm_scale": lm_scale, "att_scale": att_scale, - "ctc_scale": ctc_scale, "use_ctc": True, - "bsf": 10, - "prior_corr": prior_scale > 0.0, + "ctc_scale": ctc_scale, + "ctc_state_fix": True, + "bsf": bsf, + "prior_corr": prior_scale != 0.0, "ctc_prior_file": "/work/asr3/zeineldeen/hiwis/luca.gaudino/setups-data/2023-02-22--conformer-swb/work/i6_core/returnn/extract_prior/ReturnnComputePriorJobV2.ZeflcEHlQTjn/output/prior.txt", "prior_scale": prior_scale, - "ctc_state_fix": True, } res, _ = recog_model( task, model_with_checkpoint, model_recog, - dev_sets=["dev-other"], + dev_sets=None, model_args=model_args, search_args=search_args, prefix_name=name, @@ -220,33 +219,68 @@ def sis_run_with_prefix(prefix_name: str = None): res.output, ) - # att + espnet ctc prefix - # beam 32: {"dev-clean": 2.14, "dev-other": 5.21, "test-clean": 2.43, "test-other": 5.57} - for scales, prior_scale, beam_size in product([(0.7, 0.3)], [0.1], []): - att_scale, ctc_scale = scales - + # ctc only decoding + # prior 0.0: {"dev-clean": 2.85, "dev-other": 6.68, "test-clean": 3.09, "test-other": 7.0} + for prior_scale in []: + search_args = { + "bsf": bsf, + "prior_corr": prior_scale > 0.0, + "ctc_prior_file": "/work/asr3/zeineldeen/hiwis/luca.gaudino/setups-data/2023-02-22--conformer-swb/work/i6_core/returnn/extract_prior/ReturnnComputePriorJobV2.ZeflcEHlQTjn/output/prior.txt", + "prior_scale": prior_scale, + } name = ( prefix_name - + f"/bsf10/opls_att{att_scale}_ctc{ctc_scale}_fix" - + (f"_prior{prior_scale}" if prior_scale != 0.0 else "") - + f"_beam{beam_size}" + + f"/ctc_greedy" + + (f"_prior{prior_scale}" if prior_scale > 0.0 else "") + ) + res, _ = recog_model( + task, + model_with_checkpoint, + model_recog_ctc, + dev_sets=None, + model_args=model_args, + search_args=search_args, + prefix_name=name, ) + tk.register_output( + name + f"/recog_results", + res.output, + ) + + # ------------------ with LSTM LM ------------------------ + + # att + espnet ctc prefix scorer + lstm lm + for scales, prior_scale, lm_scale, beam_size in product( + [(0.8, 0.2), (0.85, 0.15)], + [0.0], + [0.4, 0.45, 0.5, 0.55, 0.6, 0.65], + [], + ): + att_scale, ctc_scale = scales + recog_name = ( + f"/opls_att{att_scale}_ctc{ctc_scale}_fix" + + (f"_prior{prior_scale}" if prior_scale > 0.0 else "") + + f"_lstm_lm{lm_scale}_beam{beam_size}" + ) + name = prefix_name + recog_name search_args = { "beam_size": beam_size, + "add_lstm_lm": True, + "lm_scale": lm_scale, "att_scale": att_scale, - "use_ctc": True, "ctc_scale": ctc_scale, - "ctc_state_fix": True, - "bsf": 10, - "prior_corr": prior_scale != 0.0, + "use_ctc": True, + "bsf": bsf, + "prior_corr": prior_scale > 0.0, "ctc_prior_file": "/work/asr3/zeineldeen/hiwis/luca.gaudino/setups-data/2023-02-22--conformer-swb/work/i6_core/returnn/extract_prior/ReturnnComputePriorJobV2.ZeflcEHlQTjn/output/prior.txt", "prior_scale": prior_scale, + "ctc_state_fix": True, } res, _ = recog_model( task, model_with_checkpoint, model_recog, - dev_sets=None, + dev_sets=["dev-other"], model_args=model_args, search_args=search_args, prefix_name=name, @@ -256,6 +290,8 @@ def sis_run_with_prefix(prefix_name: str = None): res.output, ) + # ------------ Search Errors ------------ + # check for search errors for scales in [(0.7, 0.3)]: for beam_size in []: @@ -309,40 +345,12 @@ def sis_run_with_prefix(prefix_name: str = None): res, ) - # ctc only decoding - # prior 0.0: {"dev-clean": 2.85, "dev-other": 6.68, "test-clean": 3.09, "test-other": 7.0} - for prior_scale in []: - search_args = { - "bsf": 10, - "prior_corr": prior_scale > 0.0, - "ctc_prior_file": "/work/asr3/zeineldeen/hiwis/luca.gaudino/setups-data/2023-02-22--conformer-swb/work/i6_core/returnn/extract_prior/ReturnnComputePriorJobV2.ZeflcEHlQTjn/output/prior.txt", - "prior_scale": prior_scale, - } - name = ( - prefix_name - + f"/bsf10/ctc_greedy" - + (f"_prior{prior_scale}" if prior_scale > 0.0 else "") - ) - res, _ = recog_model( - task, - model_with_checkpoint, - model_recog_ctc, - dev_sets=None, - model_args=model_args, - search_args=search_args, - prefix_name=name, - ) - tk.register_output( - name + f"/recog_results", - res.output, - ) - # opts att + ctc TODO: fix bugs for scales, blank_scale, beam_size in product([(0.65, 0.35)], [2.0], []): att_scale, ctc_scale = scales name = ( prefix_name - + f"/bsf20/opts_att{att_scale}_ctc{ctc_scale}" + + f"/opts_att{att_scale}_ctc{ctc_scale}" + (f"_blank{blank_scale}" if blank_scale != 0.0 else "") + f"_beam{beam_size}" ) @@ -351,7 +359,7 @@ def sis_run_with_prefix(prefix_name: str = None): "att_scale": att_scale, "ctc_scale": ctc_scale, "blank_scale": blank_scale, - "bsf": 20, + "bsf": bsf, } # @@ -400,7 +408,7 @@ def sis_run_with_prefix(prefix_name: str = None): res, ) - ### Experiments with transformer LM + # ------------------ with Trafo LM ------------------------ model_w_trafo_lm_ckpt_path = tk.Path( _torch_ckpt_filename_w_trafo_lm, hash_overwrite="torch_ckpt_w_trafo_lm" @@ -411,14 +419,20 @@ def sis_run_with_prefix(prefix_name: str = None): ) model_args = { - "add_trafo_lm": True, - "trafo_lm_args": { + "external_language_model": { + "class": "Trafo_LM_Model", "num_layers": 24, "layer_out_dim": 1024, "att_num_heads": 8, "use_pos_enc": True, "ff_activation": "relu", }, + "preload_from_files": { + "01_trafo_lm": { + "prefix": "language_model.", + "filename": "/work/asr3/zeineldeen/hiwis/luca.gaudino/setups-data/2023-08-10--rf-librispeech/work/i6_experiments/users/gaudino/returnn/convert_ckpt_rf/librispeech/trafo_lm_only_24_02_06/network.023.pt", + } + }, } # opts ctc + trafo lm TODO: fix bugs @@ -426,7 +440,7 @@ def sis_run_with_prefix(prefix_name: str = None): ctc_scale, lm_scale = scales name = ( prefix_name - + f"/bsf20/opts_ctc{ctc_scale}_trafo_lm{lm_scale}" + + f"/opts_ctc{ctc_scale}_trafo_lm{lm_scale}" + f"_beam{beam_size}" ) search_args = { @@ -437,7 +451,7 @@ def sis_run_with_prefix(prefix_name: str = None): # "remove_trafo_lm_eos": True, # "add_eos_to_end": True, "lm_scale": lm_scale, - "bsf": 20, + "bsf": bsf, } recog_res, recog_out = recog_model( @@ -456,14 +470,14 @@ def sis_run_with_prefix(prefix_name: str = None): # att + trafo lm # beam 32: {"dev-clean": 1.91, "dev-other": 4.14, "test-clean": 2.2, "test-other": 4.6} - for lm_scale, beam_size in product([0.42], [40, 48 ,60 ,64, 70]): - recog_name = f"/bsf10/att_trafo_lm{lm_scale}_beam{beam_size}" + for lm_scale, beam_size in product([0.42], [32, 40]): + recog_name = f"/att_trafo_lm{lm_scale}_beam{beam_size}" name = prefix_name + recog_name search_args = { "beam_size": beam_size, "add_trafo_lm": True, "lm_scale": lm_scale, - "bsf": 10, + "bsf": bsf, } res, _ = recog_model( task, @@ -485,7 +499,7 @@ def sis_run_with_prefix(prefix_name: str = None): [1.0], [0.0], [0.65], [] ): recog_name = ( - f"/bsf10/opls_ctc{ctc_scale}_fix" + f"/opls_ctc{ctc_scale}_fix" + (f"_prior{prior_scale}" if prior_scale > 0.0 else "") + f"_trafo_lm{lm_scale}_beam{beam_size}" ) @@ -497,11 +511,10 @@ def sis_run_with_prefix(prefix_name: str = None): "att_scale": 0.0, "ctc_scale": ctc_scale, "use_ctc": True, - "bsf": 10, + "bsf": bsf, "prior_corr": prior_scale > 0.0, "ctc_prior_file": "/work/asr3/zeineldeen/hiwis/luca.gaudino/setups-data/2023-02-22--conformer-swb/work/i6_core/returnn/extract_prior/ReturnnComputePriorJobV2.ZeflcEHlQTjn/output/prior.txt", "prior_scale": prior_scale, - "ctc_state_fix": True, } res, _ = recog_model( task, @@ -524,7 +537,7 @@ def sis_run_with_prefix(prefix_name: str = None): ): att_scale, ctc_scale = scales recog_name = ( - f"/bsf10/opls_att{att_scale}_ctc{ctc_scale}_fix" + f"/opls_att{att_scale}_ctc{ctc_scale}_fix" + (f"_prior{prior_scale}" if prior_scale > 0.0 else "") + f"_trafo_lm{lm_scale}_beam{beam_size}_cpu" ) @@ -536,11 +549,10 @@ def sis_run_with_prefix(prefix_name: str = None): "att_scale": att_scale, "ctc_scale": ctc_scale, "use_ctc": True, - "bsf": 10, + "bsf": bsf, "prior_corr": prior_scale > 0.0, "ctc_prior_file": "/work/asr3/zeineldeen/hiwis/luca.gaudino/setups-data/2023-02-22--conformer-swb/work/i6_core/returnn/extract_prior/ReturnnComputePriorJobV2.ZeflcEHlQTjn/output/prior.txt", "prior_scale": prior_scale, - "ctc_state_fix": True, } res, _ = recog_model( task, @@ -799,7 +811,7 @@ def __init__( self.mel_normalization = model_args.get("mel_normalization", False) self.no_ctc = model_args.get("no_ctc", False) self.enc_layer_w_ctc = model_args.get("enc_layer_w_ctc", None) - self.s_use_zoneout_output = model_args.get("s_use_zoneout_output", True) + self.s_use_zoneout_output = model_args.get("s_use_zoneout_output", False) self.encoder = ConformerEncoder( in_dim, diff --git a/users/gaudino/experiments/rf_conformer_att_2023/librispeech_960/conformer_import_moh_att_train.py b/users/gaudino/experiments/rf_conformer_att_2023/librispeech_960/conformer_import_moh_att_train.py index 85c0a7435..79cb8641f 100644 --- a/users/gaudino/experiments/rf_conformer_att_2023/librispeech_960/conformer_import_moh_att_train.py +++ b/users/gaudino/experiments/rf_conformer_att_2023/librispeech_960/conformer_import_moh_att_train.py @@ -1302,9 +1302,7 @@ def __init__( Dim(name="lstm", dimension=1024), zoneout_factor_cell=0.15, zoneout_factor_output=0.05, - # TODO: was this a bug? - use_zoneout_output=True, - # use_zoneout_output=False, # like RETURNN/TF ZoneoutLSTM old default + use_zoneout_output=False, # like RETURNN/TF ZoneoutLSTM old default # parts_order="icfo", # like RETURNN/TF ZoneoutLSTM # parts_order="ifco", parts_order="jifo", # NativeLSTM (the code above converts it...) diff --git a/users/gaudino/experiments/rf_conformer_att_2023/librispeech_960/model_recogs/model_recog.py b/users/gaudino/experiments/rf_conformer_att_2023/librispeech_960/model_recogs/model_recog.py index 2d19622f4..5c16781ef 100644 --- a/users/gaudino/experiments/rf_conformer_att_2023/librispeech_960/model_recogs/model_recog.py +++ b/users/gaudino/experiments/rf_conformer_att_2023/librispeech_960/model_recogs/model_recog.py @@ -174,6 +174,7 @@ def model_recog( ) if model.search_args.get("ilm_scale", 0.0) > 0: + # breakpoint() ilm_out = model.ilm(input_embed, state=ilm_state, spatial_dim=single_step_dim) ilm_state = ilm_out["state"] ilm_log_prob = rf.log_softmax(ilm_out["output"], axis=model.target_dim) diff --git a/users/gaudino/experiments/rf_conformer_att_2023/tedlium2/_import_model.py b/users/gaudino/experiments/rf_conformer_att_2023/tedlium2/_import_model.py index 5971097fa..c2a7de778 100644 --- a/users/gaudino/experiments/rf_conformer_att_2023/tedlium2/_import_model.py +++ b/users/gaudino/experiments/rf_conformer_att_2023/tedlium2/_import_model.py @@ -18,6 +18,8 @@ MakeModel, ) +from i6_experiments.users.gaudino.models.asr.rf.conformer_ctc.model_conformer_ctc import MakeModel as MakeModelCTC + from i6_experiments.users.gaudino.models.asr.rf.nn_lm.lm_import_2023_11_09 import ( MakeModel as MakeModelLM, ) @@ -88,9 +90,14 @@ def convert_checkpoint( print() + ctc_only = model_args.get("ctc_only", False) + print("Creating model...") rf.select_backend_torch() - model = MakeModel(80, 1_057, model_args=model_args)() + if ctc_only: + model = MakeModelCTC(80, 1_057)() + else: + model = MakeModel(80, 1_057, model_args=model_args)() print("Created model:", model) print("Model parameters:") for name, param in model.named_parameters(): @@ -103,7 +110,8 @@ def convert_checkpoint( print("Create ParamMapping...") param_mapping = {} _add_params_conformer(param_mapping, prefix="") - _add_params_att_decoder(param_mapping) + if not ctc_only: + _add_params_att_decoder(param_mapping) _add_params_trafo_lm(param_mapping) # if model_args.get("encoder_ctc", False): # _add_params_conformer(param_mapping, prefix="sep_enc_ctc_") @@ -161,7 +169,6 @@ def convert_checkpoint( os.symlink(os.path.basename(meta_filename), symlink_filename_2) # assert os.path.exists(self.out_checkpoint.get_path()) - def convert_lm(ckpt_path_lm, out_dir, model_target_dim, model_args): from tensorflow.python.training.py_checkpoint_reader import CheckpointReader from returnn.torch.frontend.bridge import rf_module_to_pt_module @@ -326,8 +333,10 @@ def _add_params_conformer(param_mapping: Dict[str, str], prefix: str): param_mapping.update( { prefix + "encoder.input_projection.weight": "source_linear/W", - prefix + "ctc.weight": "ctc/W", - prefix + "ctc.bias": "ctc/b", + # prefix + "ctc.weight": "ctc/W", + # prefix + "ctc.bias": "ctc/b", + prefix + "enc_aux_logits_12.weight": "ctc/W", + prefix + "enc_aux_logits_12.bias": "ctc/b", } ) # conformer @@ -598,7 +607,7 @@ def map_param_func_mini_att_ilm( def import_models(): # for model_name, sep_enc in product(list(models.keys())[-1:], [True, False]): - model_list = ["model_baseline"] + model_list = ["model_ctc_only"] # model_list = ["model_ctc0.9_att0.1", "model_ctc0.8_att0.2", "model_ctc0.7_att0.3", "model_ctc0.6_att0.4", "model_ctc0.5_att0.5", "model_ctc0.4_att0.6"] for model_name, sep_enc, add_trafo_lm in product(model_list, [False], [False]): model_args = { @@ -606,6 +615,7 @@ def import_models(): "add_trafo_lm": add_trafo_lm, "encoder_ctc": sep_enc, "no_ctc": models[model_name].get("no_ctc", False), + "ctc_only": models[model_name].get("ctc_only", False), } print( @@ -615,7 +625,7 @@ def import_models(): + " ..." ) out_dir = "/work/asr3/zeineldeen/hiwis/luca.gaudino/setups-data/2023-08-10--rf-librispeech/work/i6_experiments/users/gaudino/returnn/convert_ckpt_rf/tedlium2/without_lm/" - out_dir_postfix = model_name + ("__ctc_only" if sep_enc else "") + ("__trafo_lm" if add_trafo_lm else "") + "_24_05_22" + out_dir_postfix = model_name + ("__ctc_only" if sep_enc else "") + ("__trafo_lm" if add_trafo_lm else "") + "_rf_compatible" ckpt_path = models[model_name]["ckpt"].ckpt_path diff --git a/users/gaudino/experiments/rf_conformer_att_2023/tedlium2/conformer_import_moh_att_2023_10_19.py b/users/gaudino/experiments/rf_conformer_att_2023/tedlium2/conformer_import_moh_att_2023_10_19.py index f1ca364cf..e653183c9 100644 --- a/users/gaudino/experiments/rf_conformer_att_2023/tedlium2/conformer_import_moh_att_2023_10_19.py +++ b/users/gaudino/experiments/rf_conformer_att_2023/tedlium2/conformer_import_moh_att_2023_10_19.py @@ -92,6 +92,7 @@ def sis_run_with_prefix(prefix_name: str = None): model_args = { "target_embed_dim": 256, "mel_normalization": True, + "s_use_zoneout_output": True, "no_ctc": models[model_name].get("no_ctc", False), "enc_layer_w_ctc": models[model_name].get("enc_layer_w_ctc", None), } @@ -108,6 +109,7 @@ def sis_run_with_prefix(prefix_name: str = None): bsf = 10 prefix_name_single_seq = prefix_name + f"/single_seq" + prefix_name_bsf32 = prefix_name + f"/bsf32" prefix_name = prefix_name + f"/bsf{bsf}" + "_fix_zoneout_output" ### Single model experiments @@ -288,8 +290,8 @@ def sis_run_with_prefix(prefix_name: str = None): opls_model_names = { # -------- tuning done ---------- "model_baseline":{ - "scales": [(0.7, 0.3, 0.7, 0.4), (0.7, 0.3, 0.7, 0.5)], - "scales_w_fix": [], + "scales": [(0.7, 0.3, 0.7, 0.4), (0.7, 0.3, 0.7, 0.5), (0.8, 0.2, 0.75, 0.4), (0.8, 0.2, 0.75, 0.5)], + "scales_w_fix": [(0.8, 0.2, 0.75, 0.4)], }, # "model_ctc0.43_att1.0": { # "scales": [(0.8,0.2, 0.6), (0.8, 0.2, 0.7), (0.8, 0.2, 0.9)], @@ -359,9 +361,8 @@ def sis_run_with_prefix(prefix_name: str = None): for model_name in ["model_baseline"]: # for model_name in opls_model_names: # for scales, beam_size in product(opls_model_names[model_name]["scales"], [12]): - for scales, beam_size in product([(0.6, 0.4), (0.65, 0.35), (0.7, 0.3), (0.75, 0.25), (0.8, 0.2)], [12]): + for scales, prior_scale, beam_size in product([(0.8, 0.2)], [0.75], []): #12 att_scale, ctc_scale, = scales - prior_scale = 0.0 search_args = { "beam_size": beam_size, @@ -388,7 +389,7 @@ def sis_run_with_prefix(prefix_name: str = None): task, models_with_pt_ckpt[model_name]["ckpt"], model_recog, - dev_sets=["dev"], # set to None for all + dev_sets=["dev", "test"], # set to None for all model_args=models_with_pt_ckpt[model_name]["model_args"], search_args=search_args, prefix_name=name, @@ -408,7 +409,7 @@ def sis_run_with_prefix(prefix_name: str = None): # ctc beam search espnet for model_name in ctc_beam_search_model_names: for scales, beam_size in product( - ctc_beam_search_model_names[model_name]["scales"], [32] # 32 + ctc_beam_search_model_names[model_name]["scales"], [] # 32 ): att_scale, ctc_scale, prior_scale = scales @@ -461,18 +462,13 @@ def sis_run_with_prefix(prefix_name: str = None): "class": "Trafo_LM_Model", }, "mel_normalization": True, + "s_use_zoneout_output": True, "no_ctc": models[model_name].get("no_ctc", False), "enc_layer_w_ctc": models[model_name].get("enc_layer_w_ctc", None), } models_with_pt_ckpt[model_name]["model_args"] = copy.deepcopy(model_args) - # att + trafo lm + ilm correction - for model_name, lm_scale, ilm_scale, beam_size in product( - # ["model_baseline", "model_ctc0.5_att0.5"], [0.36] ,[0.28], [12] - ["model_baseline"], [0.3, 0.34, 0.36, 0.4] ,[0.28], [12] - ): - ilm_model_args = copy.deepcopy(models_with_pt_ckpt[model_name]["model_args"]) - ilm_model_args["preload_from_files"] = { + preload_from_files_ilm = { "01_mini_att_ilm": { "prefix": "ilm.", "filename": "/work/asr3/zeineldeen/hiwis/luca.gaudino/setups-data/2023-08-10--rf-librispeech/work/i6_experiments/users/gaudino/returnn/convert_ckpt_rf/tedlium2/mini_att_ilm_24_04_21/average.pt", @@ -483,8 +479,16 @@ def sis_run_with_prefix(prefix_name: str = None): } } + # att + trafo lm + ilm correction + for model_name, lm_scale, ilm_scale, beam_size in product( + # ["model_baseline", "model_ctc0.5_att0.5"], [0.36] ,[0.28], [12] + ["model_baseline"], [0.36], [0.28], [] #12 + ): + ilm_model_args = copy.deepcopy(models_with_pt_ckpt[model_name]["model_args"]) + ilm_model_args["preload_from_files"] = preload_from_files_ilm + name = ( - prefix_name + prefix_name_bsf32 + "/" + model_name + f"/att_trafolm{lm_scale}_ilm{ilm_scale}" @@ -495,7 +499,7 @@ def sis_run_with_prefix(prefix_name: str = None): "att_scale": 1.0, "ilm_scale": ilm_scale, "lm_scale": lm_scale, - "bsf": bsf, + "bsf": 32, "use_first_lm": True, "use_zoneout_output": True, } @@ -514,9 +518,14 @@ def sis_run_with_prefix(prefix_name: str = None): ) # opls att + ctc + trafo lm + ilm - for model_name, beam_size, ilm_scale in product(["model_baseline"], [12], [0.1, 0.2, 0.25, 0.3, 0.4]): - for scales in opls_model_names[model_name]["scales"]: - att_scale, ctc_scale, prior_scale, lm_scale = scales + # 5.78 with att 0.7, ctc 0.3, prior 0.7, trafo 0.6, ilm 0.45 + for model_name, beam_size, lm_scale in product(["model_baseline"], [12], [0.6, 0.62, 0.64, 0.66, 0.68, 0.7]): + for scales in [(0.7, 0.3, 0.7, 0.45)]: + att_scale, ctc_scale, prior_scale, ilm_scale = scales + + ilm_model_args = copy.deepcopy(models_with_pt_ckpt[model_name]["model_args"]) + ilm_model_args["preload_from_files"] = preload_from_files_ilm + name = ( prefix_name + "/" @@ -531,6 +540,7 @@ def sis_run_with_prefix(prefix_name: str = None): "ctc_scale": ctc_scale, "use_ctc": True, "add_trafo_lm": True, + "ilm_scale": ilm_scale, "lm_scale": lm_scale, "bsf": bsf, "prior_corr": True if prior_scale > 0 else False, @@ -542,8 +552,8 @@ def sis_run_with_prefix(prefix_name: str = None): task, models_with_pt_ckpt[model_name]["ckpt"], model_recog, - dev_sets=["dev", "test"], - model_args=models_with_pt_ckpt[model_name]["model_args"], + dev_sets=["dev"], + model_args=ilm_model_args, search_args=search_args, prefix_name=name, ) @@ -567,6 +577,7 @@ def sis_run_with_prefix(prefix_name: str = None): } }, "mel_normalization": True, + "s_use_zoneout_output": True, "no_ctc": models[model_name].get("no_ctc", False), "enc_layer_w_ctc": models[model_name].get("enc_layer_w_ctc", None), } @@ -574,7 +585,7 @@ def sis_run_with_prefix(prefix_name: str = None): # att + trafo lm for model_name, lm_scale, beam_size in product( - ["model_baseline"], [0.13, 0.15, 0.18, 0.2], [12] + ["model_baseline"], [0.18], [] #12 ): lm_model_args = copy.deepcopy(models_with_pt_ckpt[model_name]["model_args"]) name = ( @@ -608,7 +619,8 @@ def sis_run_with_prefix(prefix_name: str = None): ) # att + ctc + trafo lm opls - for model_name, beam_size in product(opls_model_names.keys(), []): + for model_name, beam_size in product(["model_baseline"], []): # 12 + # for model_name, beam_size in product(opls_model_names.keys(), []): for scales in opls_model_names[model_name]["scales"]: att_scale, ctc_scale, prior_scale, lm_scale = scales name = ( @@ -636,7 +648,7 @@ def sis_run_with_prefix(prefix_name: str = None): task, models_with_pt_ckpt[model_name]["ckpt"], model_recog, - dev_sets=["dev", "test"], + dev_sets=["dev"], model_args=models_with_pt_ckpt[model_name]["model_args"], search_args=search_args, prefix_name=name, diff --git a/users/gaudino/experiments/rf_conformer_att_2023/tedlium2/conformer_import_moh_att_train.py b/users/gaudino/experiments/rf_conformer_att_2023/tedlium2/conformer_import_moh_att_train.py index fe0451e21..f405cd911 100644 --- a/users/gaudino/experiments/rf_conformer_att_2023/tedlium2/conformer_import_moh_att_train.py +++ b/users/gaudino/experiments/rf_conformer_att_2023/tedlium2/conformer_import_moh_att_train.py @@ -105,20 +105,20 @@ def sis_run_with_prefix(prefix_name: Optional[str] = None): # train_exp("base-11gb", config_11gb, gpu_mem=11) # train_exp("base-11gb-v1", my_config_11gb, num_epochs=400, gpu_mem=11) - train_exp( # dev 8.77 test 8.26 - "base-11gb-v3-lrlin1e_5_600k_aux4_8", - my_config_11gb, - config_updates={ - "learning_rate": 1.0, - "dynamic_learning_rate": dyn_lr_piecewise_linear, - # total steps after 2000 epochs: 982.312 - "learning_rate_piecewise_steps": [600_000, 900_000, 982_000], - "learning_rate_piecewise_values": [1e-5, 1e-3, 1e-5, 1e-6], - "aux_loss_layers": [4,8], - }, - num_epochs=400, - gpu_mem=11, - ) + # train_exp( # dev 8.77 test 8.26 + # "base-11gb-v3-lrlin1e_5_600k_aux4_8", + # my_config_11gb, + # config_updates={ + # "learning_rate": 1.0, + # "dynamic_learning_rate": dyn_lr_piecewise_linear, + # # total steps after 2000 epochs: 982.312 + # "learning_rate_piecewise_steps": [600_000, 900_000, 982_000], + # "learning_rate_piecewise_values": [1e-5, 1e-3, 1e-5, 1e-6], + # "aux_loss_layers": [4,8], + # }, + # num_epochs=400, + # gpu_mem=11, + # ) # train_exp( # aux 12: does not converge # "base-11gb-v3-lrlin1e_5_261k", @@ -133,8 +133,22 @@ def sis_run_with_prefix(prefix_name: Optional[str] = None): # gpu_mem=11, # ) - train_exp( # dev 7.89 test 7.3 - "base-11gb-v3-lrlin1e_5_261k_aux4_8", + # train_exp( # dev 7.89 test 7.3 + # "base-11gb-v3-lrlin1e_5_261k_aux4_8", + # my_config_11gb, + # config_updates={ + # "learning_rate": 1.0, + # "dynamic_learning_rate": dyn_lr_piecewise_linear, + # "learning_rate_piecewise_steps": [261_000, 522_000, 580_000], # 45% 45 % 10% + # "learning_rate_piecewise_values": [1e-5, 1e-3, 1e-5, 1e-6], + # "aux_loss_layers": [4, 8], + # }, + # num_epochs=400, + # gpu_mem=11, + # ) + + train_exp( # + "base-11gb-v3-lrlin1e_5_261k_aux4_8_zoneout_fix", my_config_11gb, config_updates={ "learning_rate": 1.0, @@ -142,12 +156,13 @@ def sis_run_with_prefix(prefix_name: Optional[str] = None): "learning_rate_piecewise_steps": [261_000, 522_000, 580_000], # 45% 45 % 10% "learning_rate_piecewise_values": [1e-5, 1e-3, 1e-5, 1e-6], "aux_loss_layers": [4, 8], + "s_use_zoneout_output": True, }, num_epochs=400, gpu_mem=11, ) - train_exp( # + train_exp( # dev 7.59 test 7.13 "base-11gb-v3-lrlin1e_5_261k_aux4_8_12", my_config_11gb, config_updates={ @@ -175,21 +190,21 @@ def sis_run_with_prefix(prefix_name: Optional[str] = None): # gpu_mem=11, # ) - model = train_exp( # with aux 4 8: dev 9.92 test 8.96 - wrong steps!!! - "base-24gb-v6-lrlin1e_5_261k", - config_24gb_v6, - config_updates={ - "learning_rate": 1.0, - "dynamic_learning_rate": dyn_lr_piecewise_linear, - "learning_rate_piecewise_steps": [261_000, 522_000, 580_000], - "learning_rate_piecewise_values": [1e-5, 1e-3, 1e-5, 1e-6], - }, - num_epochs=400, - ) + # model = train_exp( # with aux 4 8: dev 9.92 test 8.96 - wrong steps!!! + # "base-24gb-v6-lrlin1e_5_261k", + # config_24gb_v6, + # config_updates={ + # "learning_rate": 1.0, + # "dynamic_learning_rate": dyn_lr_piecewise_linear, + # "learning_rate_piecewise_steps": [261_000, 522_000, 580_000], + # "learning_rate_piecewise_values": [1e-5, 1e-3, 1e-5, 1e-6], + # }, + # num_epochs=400, + # ) model = train_exp( # - "base-24gb-v6-lrlin1e_5_85k", + "base-24gb-v6-lrlin1e_5_85k_zoneout_fix", config_24gb_v6, config_updates={ "learning_rate": 1.0, @@ -197,6 +212,7 @@ def sis_run_with_prefix(prefix_name: Optional[str] = None): # total steps after 400 epochs: 189.995 "learning_rate_piecewise_steps": [85_500, 171_000, 190_000], "learning_rate_piecewise_values": [1e-5, 1e-3, 1e-5, 1e-6], + "s_use_zoneout_output": True, }, num_epochs=400, ) @@ -1365,7 +1381,6 @@ def __init__( enc_att_dropout: float = 0.1, l2: float = 0.0001, language_model: Optional[RFModelWithMakeLabelScorer] = None, - mel_normalization: bool = True, ): super(Model, self).__init__() @@ -1373,7 +1388,7 @@ def __init__( config = get_global_config(return_empty_if_none=True) - self.mel_normalization = mel_normalization + self.mel_normalization = config.typed_value("mel_normalization", True) self.in_dim = in_dim self.encoder = ConformerEncoder( @@ -1432,7 +1447,8 @@ def __init__( Dim(name="lstm", dimension=1024), zoneout_factor_cell=0.15, zoneout_factor_output=0.05, - use_zoneout_output=False, # like RETURNN/TF ZoneoutLSTM old default + use_zoneout_output=config.typed_value("s_use_zoneout_output", False), # TODO: run exps with this fixed + # use_zoneout_output=False, # like RETURNN/TF ZoneoutLSTM old default # parts_order="icfo", # like RETURNN/TF ZoneoutLSTM # parts_order="ifco", parts_order="jifo", # NativeLSTM (the code above converts it...) diff --git a/users/gaudino/experiments/rf_conformer_rnnt_2024/librispeech_960/conformer_ctc_train.py b/users/gaudino/experiments/rf_conformer_rnnt_2024/librispeech_960/conformer_ctc_train.py index 25d1a4bb4..4b08a9e96 100644 --- a/users/gaudino/experiments/rf_conformer_rnnt_2024/librispeech_960/conformer_ctc_train.py +++ b/users/gaudino/experiments/rf_conformer_rnnt_2024/librispeech_960/conformer_ctc_train.py @@ -119,7 +119,7 @@ def sis_run_with_prefix(prefix_name: Optional[str] = None): # }, # ) - train_exp( # + train_exp( # dev-other 9.01 "base-24gb-lrlin1e_5_600k_ctc_only", config_24gb_v6, config_updates={ @@ -132,7 +132,7 @@ def sis_run_with_prefix(prefix_name: Optional[str] = None): }, ) - train_exp( # + train_exp( # dev-other 6.93 "base-24gb-lrlin1e_5_600k_ctc_only_aux4_8", config_24gb_v6, config_updates={ @@ -144,6 +144,35 @@ def sis_run_with_prefix(prefix_name: Optional[str] = None): }, ) + + # without mel normalization + train_exp( # dev-other + "base-24gb-lrlin1e_5_600k_ctc_only_no_mel_norm", + config_24gb_v6, + config_updates={ + "learning_rate": 1.0, + "dynamic_learning_rate": dyn_lr_piecewise_linear, + # total steps after 2000 epochs: 982.312 + "learning_rate_piecewise_steps": [600_000, 900_000, 982_000], + "learning_rate_piecewise_values": [1e-5, 1e-3, 1e-5, 1e-6], + "aux_loss_layers":[], + "mel_normalization_ted2": False, + }, + ) + + train_exp( # dev-other + "base-24gb-lrlin1e_5_600k_ctc_only_aux4_8_no_mel_norm", + config_24gb_v6, + config_updates={ + "learning_rate": 1.0, + "dynamic_learning_rate": dyn_lr_piecewise_linear, + # total steps after 2000 epochs: 982.312 + "learning_rate_piecewise_steps": [600_000, 900_000, 982_000], + "learning_rate_piecewise_values": [1e-5, 1e-3, 1e-5, 1e-6], + "mel_normalization_ted2": False, + }, + ) + _sis_prefix: Optional[str] = None diff --git a/users/gaudino/experiments/rf_conformer_rnnt_2024/tedlium2/conformer_ctc_train.py b/users/gaudino/experiments/rf_conformer_rnnt_2024/tedlium2/conformer_ctc_train.py index 900926eae..74628b703 100644 --- a/users/gaudino/experiments/rf_conformer_rnnt_2024/tedlium2/conformer_ctc_train.py +++ b/users/gaudino/experiments/rf_conformer_rnnt_2024/tedlium2/conformer_ctc_train.py @@ -11,6 +11,7 @@ import hashlib import contextlib import functools +from sisyphus import tk from returnn.tensor import Tensor, Dim, single_step_dim import returnn.frontend as rf @@ -30,10 +31,11 @@ if TYPE_CHECKING: from i6_experiments.users.gaudino.model_interfaces import ModelDef, RecogDef, TrainDef - from i6_experiments.users.gaudino.model_with_checkpoints import ( - ModelWithCheckpoints, - ModelWithCheckpoint, - ) + +from i6_experiments.users.gaudino.model_with_checkpoints import ( + ModelWithCheckpoints, + ModelWithCheckpoint, +) from i6_experiments.users.gaudino.models.asr.rf.conformer_ctc.model_conformer_ctc import from_scratch_model_def, from_scratch_training from i6_experiments.users.gaudino.models.asr.rf.conformer_ctc.model_recog_ctc_greedy import model_recog @@ -45,6 +47,9 @@ def sis_run_with_prefix(prefix_name: Optional[str] = None): """run the exp""" + + from i6_core.returnn.training import PtCheckpoint + _sis_setup_global_prefix(prefix_name) # Moh: dev-clean 2.27, dev-other 5.39, test-clean 2.41, test-other 5.51 @@ -167,54 +172,167 @@ def sis_run_with_prefix(prefix_name: Optional[str] = None): # gpu_mem=11, # ) - train_exp( - "from-scratch-24gb_lrmaxs85k_lrmin1e-5_lrmax1e-3", - ctc_train_24gb_config, + # train_exp( # does not converge + # "from-scratch-24gb_lrmaxs85k_lrmin1e-5_lrmax1e-3", + # ctc_train_24gb_config, + # config_updates={ + # "learning_rate": 1.0, + # "dynamic_learning_rate": dyn_lr_piecewise_linear, + # # total steps after 400 epochs: + # "learning_rate_piecewise_steps": [85_500, 171_000, 190_000], # 45% 45 % 10% + # "learning_rate_piecewise_values": [1e-5, 1e-3, 1e-5, 1e-6], + # "aux_loss_layers": [], + # }, + # num_epochs=400, + # ) + # + # train_exp( # does not converge + # "from-scratch-24gb_lrmaxs85k_lrmin8e-5_lrmax8e-4", + # ctc_train_24gb_config, + # config_updates={ + # "learning_rate": 1.0, + # "dynamic_learning_rate": dyn_lr_piecewise_linear, + # # total steps after 400 epochs: + # "learning_rate_piecewise_steps": [85_500, 171_000, 190_000], # 45% 45 % 10% + # "learning_rate_piecewise_values": [8e-5, 8e-4, 8e-5, 1e-6], + # "aux_loss_layers": [], + # }, + # num_epochs=400, + # ) + + # init from tf ctc only model + _torch_ckpt_dir_path = "/work/asr3/zeineldeen/hiwis/luca.gaudino/setups-data/2023-08-10--rf-librispeech/work/i6_experiments/users/gaudino/returnn/convert_ckpt_rf/tedlium2/without_lm/" + + model_args = { + "mel_normalization": True, + } + new_ckpt_path = tk.Path( + _torch_ckpt_dir_path + "model_ctc_only_rf_compatible" + "/average.pt", + hash_overwrite= "model_ctc_only_rf_compatible" + "_torch_ckpt", + ) + new_ckpt = PtCheckpoint(new_ckpt_path) + + + # recog ctc only model + _recog( + "model_recogs/model_ctc_only_rf_compatible/ctc_greedy/recog_results", + ModelWithCheckpoint( + definition=from_scratch_model_def, checkpoint=new_ckpt + ), + model_recog, + ) + + # train_exp( # does not improve, different wer from the beginning + # "init_from_tf_lin132k_lrmax8e-4_25eps", + # ctc_train_config, + # config_updates={ + # "learning_rate": 1.0, + # "dynamic_learning_rate": dyn_lr_piecewise_linear, + # # total steps after 2000 epochs: 982.312 + # # total steps after 400 epochs: + # "learning_rate_piecewise_steps": [66_000, 132_000, 145_000], # 45% 45 % 10% + # # "learning_rate_piecewise_steps": [600_000, 900_000, 982_000], # 45% 45 % 10% + # "learning_rate_piecewise_values": [8e-5, 8e-4, 8e-5, 1e-6], + # "aux_loss_layers": [], + # "preload_from_files": { + # "encoder": { + # "filename": _torch_ckpt_dir_path + "model_ctc_only_rf_compatible" + "/average.pt", + # "ignore_missing": True, + # "init_for_train": True, + # }, + # }, + # }, + # num_epochs=100, + # gpu_mem=11, + # ) + + train_exp( # + "from-scratch-11gb_lrmaxs522k_lrmin8e-5_lrmax8e-4_aux4_8_adjSpec", + ctc_train_config, config_updates={ "learning_rate": 1.0, "dynamic_learning_rate": dyn_lr_piecewise_linear, - # total steps after 400 epochs: - "learning_rate_piecewise_steps": [85_500, 171_000, 190_000], # 45% 45 % 10% - "learning_rate_piecewise_values": [1e-5, 1e-3, 1e-5, 1e-6], - "aux_loss_layers": [], - }, + # total steps after 2000 epochs: 982.312 + "learning_rate_piecewise_steps": [261_000, 522_000, 580_000], # 45% 45 % 10% + "learning_rate_piecewise_values": [8e-5, 8e-4, 8e-5, 1e-6], + "aux_loss_layers": [4, 8], + "specaugment_steps": (5_900, 18_000, 36_000), + }, num_epochs=400, + gpu_mem=11, ) - train_exp( - "from-scratch-24gb_lrmaxs85k_lrmin8e-5_lrmax8e-4", - ctc_train_24gb_config, + train_exp( # + "from-scratch-11gb_lrmaxs522k_lrmin1e-5_lrmax1e-3_aux4_8_adjSpec", + ctc_train_config, config_updates={ "learning_rate": 1.0, "dynamic_learning_rate": dyn_lr_piecewise_linear, - # total steps after 400 epochs: - "learning_rate_piecewise_steps": [85_500, 171_000, 190_000], # 45% 45 % 10% - "learning_rate_piecewise_values": [8e-5, 8e-4, 8e-5, 1e-6], - "aux_loss_layers": [], - }, + # total steps after 2000 epochs: 982.312 + "learning_rate_piecewise_steps": [261_000, 522_000, 580_000], # 45% 45 % 10% + "learning_rate_piecewise_values": [1e-5, 1e-3, 1e-5, 1e-6], + "aux_loss_layers": [4, 8], + "specaugment_steps": (5_900, 18_000, 36_000), + }, num_epochs=400, + gpu_mem=11, ) - # init for tf ctc only model - train_exp( # does not converge - "from-scratch-11gb_lrmaxs522k_lrmin8e-5_lrmax8e-4", + # TODO: try with pretrain + + train_exp( # + "from-scratch-11gb_pre3_lrmaxs522k_lrmin1e-5_lrmax1e-3_aux4_8_adjSpec", ctc_train_config, config_updates={ "learning_rate": 1.0, "dynamic_learning_rate": dyn_lr_piecewise_linear, # total steps after 2000 epochs: 982.312 - # total steps after 400 epochs: - "learning_rate_piecewise_steps": [66_000, 132_000, 145_000], # 45% 45 % 10% - # "learning_rate_piecewise_steps": [600_000, 900_000, 982_000], # 45% 45 % 10% - "learning_rate_piecewise_values": [8e-5, 8e-4, 8e-5, 1e-6], - "aux_loss_layers": [], - "preload_from_files": { - "filename": "", - "ignore_missing": True, - "init_for_train": True, + "learning_rate_piecewise_steps": [261_000, 522_000, 580_000], # 45% 45 % 10% + "learning_rate_piecewise_values": [1e-5, 1e-3, 1e-5, 1e-6], + "aux_loss_layers": [4, 8], + "specaugment_steps": (5_900, 18_000, 36_000), + "pretrain_opts": { # pretrain + "steps": [ + (8 * 500, {"num_layers": 2}), + (4 * 500, {"num_layers": 4}), + (4 * 500, {"num_layers": 8}), + ] }, - }, - num_epochs=100, + }, + num_epochs=400, + gpu_mem=11, + ) + + # TODO: try with epoch base lr schedule + ep = 400 + lr = 8e-4 + cyc_ep = int(0.45 * ep) + + train_exp( # + "from-scratch-11gb_ep_based_lr_aux4_8", + ctc_train_config, + config_updates={ + "learning_rate": 1.0, + # "dynamic_learning_rate": dyn_lr_piecewise_linear, + # total steps after 2000 epochs: 982.312 + # "learning_rate_piecewise_steps": [261_000, 522_000, 580_000], # 45% 45 % 10% + # "learning_rate_piecewise_values": [1e-5, 1e-3, 1e-5, 1e-6], + "aux_loss_layers": [4, 8], + # "specaugment_steps": (5_900, 18_000, 36_000), + # "pretrain_opts": { # pretrain + # "steps": [ + # (8 * 500, {"num_layers": 2}), + # (4 * 500, {"num_layers": 4}), + # (4 * 500, {"num_layers": 8}), + # ] + # }, + "learning_rates": ( + list(numpy.linspace(lr / 10, lr, cyc_ep)) + + list(numpy.linspace(lr, lr / 10, cyc_ep)) + + list(numpy.linspace(lr / 10, 1e-6, ep - 2 * cyc_ep)) + ) + }, + num_epochs=400, gpu_mem=11, ) @@ -242,7 +360,7 @@ def _recog( dev_sets: Optional[Collection[str]] = None, ): from sisyphus import tk - from i6_experiments.users.zeyer.recog import recog_model + from i6_experiments.users.gaudino.recog_2 import recog_model if recog_def is None: recog_def = model_recog diff --git a/users/gaudino/models/asr/rf/conformer_ctc/model_conformer_ctc.py b/users/gaudino/models/asr/rf/conformer_ctc/model_conformer_ctc.py index 463d65487..21b5fac95 100644 --- a/users/gaudino/models/asr/rf/conformer_ctc/model_conformer_ctc.py +++ b/users/gaudino/models/asr/rf/conformer_ctc/model_conformer_ctc.py @@ -141,7 +141,6 @@ def __init__( enc_att_dropout: float = 0.1, l2: float = 0.0001, language_model: Optional[RFModelWithMakeLabelScorer] = None, - mel_normalization: bool = True, joiner_dim: int = 640, ): super(Model, self).__init__() @@ -150,7 +149,7 @@ def __init__( config = get_global_config(return_empty_if_none=True) - self.mel_normalization = mel_normalization + self.mel_normalization = config.typed_value("mel_normalization_ted2", True) self.in_dim = in_dim self.encoder = ConformerEncoder( diff --git a/users/gaudino/recog.py b/users/gaudino/recog.py index ecd02a31e..9dd10c3a4 100644 --- a/users/gaudino/recog.py +++ b/users/gaudino/recog.py @@ -4,6 +4,7 @@ from __future__ import annotations +import copy import os from typing import TYPE_CHECKING, Optional, Union, Any, Dict, Sequence, Collection, Iterator, Callable @@ -314,6 +315,7 @@ def search_config_v2( extern_data_raw = instanciate_delayed(extern_data_raw) if model_args.get("preload_from_files", None): + model_args = copy.deepcopy(model_args) preload_from_files = model_args.pop("preload_from_files") returnn_recog_config_dict["preload_from_files"] = preload_from_files From 1c4de76e104f602108512fd4ab58b56af8a79f7e Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Tue, 28 May 2024 12:01:14 -0400 Subject: [PATCH 070/227] update conf v2 --- users/zeineldeen/models/asr/encoder/conformer_encoder_v2.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/users/zeineldeen/models/asr/encoder/conformer_encoder_v2.py b/users/zeineldeen/models/asr/encoder/conformer_encoder_v2.py index fa8e11f26..10240b0a4 100644 --- a/users/zeineldeen/models/asr/encoder/conformer_encoder_v2.py +++ b/users/zeineldeen/models/asr/encoder/conformer_encoder_v2.py @@ -87,6 +87,7 @@ def __init__( mhsa_weight_dropout=None, conv_weight_dropout=None, frontend_conv_weight_dropout=None, + ctc_weight_dropout=None, memory_variant_opts: Optional[ConformerMemoryVariantOpts] = None, ): """ @@ -232,6 +233,7 @@ def __init__( self.conv_weight_drop = conv_weight_dropout self.mhsa_weight_drop = mhsa_weight_dropout self.frontend_conv_weight_drop = frontend_conv_weight_dropout + self.ctc_weight_drop = ctc_weight_dropout self.memory_variant_opts = memory_variant_opts if self.memory_variant_opts: @@ -1083,7 +1085,7 @@ def _create_conformer_block(self, i, source): mhsa_input = conv_module1 mhsa = self._create_mhsa_module(prefix_name, mhsa_input, i) mhsa = self.network.add_combine_layer( - "{}_res".format(prefix_name), kind="add", source=[mhsa, mhsa_input], n_out=self.enc_value_dim + "{}_self_att_res".format(prefix_name), kind="add", source=[mhsa, mhsa_input], n_out=self.enc_value_dim ) conv_module = self._create_convolution_module(prefix_name, mhsa, i, half_step=self.sandwich_conv) @@ -1254,7 +1256,7 @@ def _create_all_network_parts(self): loss="ctc", dropout=self.ctc_dropout, loss_opts=default_ctc_loss_opts, - param_dropout=self.ff_weight_drop, + param_dropout=self.ctc_weight_drop, param_dropout_min_ndim=2, param_variational_noise=self.ff_weight_noise, ) From ef244fffa290301fb0cf046a5fc8b987a84ffadb Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Tue, 28 May 2024 12:01:45 -0400 Subject: [PATCH 071/227] more --- users/zeineldeen/data_aug/speed_perturbation_generic.py | 8 +++----- .../librispeech_960/attention_asr_config.py | 1 + 2 files changed, 4 insertions(+), 5 deletions(-) diff --git a/users/zeineldeen/data_aug/speed_perturbation_generic.py b/users/zeineldeen/data_aug/speed_perturbation_generic.py index 7b5260942..7670427ae 100644 --- a/users/zeineldeen/data_aug/speed_perturbation_generic.py +++ b/users/zeineldeen/data_aug/speed_perturbation_generic.py @@ -8,13 +8,11 @@ def speed_pert(audio, sample_rate, random_state, min_factor={min_factor}, max_fa """ speed_pert_v2 = """ -def speed_pert(audio, sample_rate={sample_rate}, min_factor={min_factor}, max_factor={max_factor}, step={step}): +def speed_pert(audio, sample_rate={sample_rate}, min_factor={min_factor}, max_factor={max_factor}, step={step}, random_state=numpy.random.RandomState(1)): import librosa - import numpy - - random_state = np.random.RandomState(1) + new_sample_rate = int(sample_rate * (1 + random_state.randint(min_factor, max_factor) * step)) if new_sample_rate != sample_rate: - audio = librosa.core.resample(audio, sample_rate, new_sample_rate, res_type="kaiser_fast") + audio = librosa.resample(audio, orig_sr=sample_rate, target_sr=new_sample_rate, res_type="kaiser_fast", axis=0) return audio """ diff --git a/users/zeineldeen/experiments/conformer_att_2022/librispeech_960/attention_asr_config.py b/users/zeineldeen/experiments/conformer_att_2022/librispeech_960/attention_asr_config.py index 0630cbd43..d16556709 100644 --- a/users/zeineldeen/experiments/conformer_att_2022/librispeech_960/attention_asr_config.py +++ b/users/zeineldeen/experiments/conformer_att_2022/librispeech_960/attention_asr_config.py @@ -686,6 +686,7 @@ def create_config( assert "sample_rate" in speed_pert_version speed_pert_generic_str = data_aug.speed_pert_generic_v2 assert isinstance(speed_pert_generic_str, str) + python_prolog += ["import numpy\n\n"] python_prolog += [speed_pert_generic_str.format(**speed_pert_version)] else: raise ValueError("Invalid speed_pert_version") From 755dc073347f652e1cd78236d1458175e2cf59c3 Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Wed, 29 May 2024 17:41:21 +0000 Subject: [PATCH 072/227] update --- .../librispeech_960/additional_config.py | 25 ++++++++++--------- 1 file changed, 13 insertions(+), 12 deletions(-) diff --git a/users/zeineldeen/experiments/conformer_att_2022/librispeech_960/additional_config.py b/users/zeineldeen/experiments/conformer_att_2022/librispeech_960/additional_config.py index c3fc2ecdb..1dbe0a6a7 100644 --- a/users/zeineldeen/experiments/conformer_att_2022/librispeech_960/additional_config.py +++ b/users/zeineldeen/experiments/conformer_att_2022/librispeech_960/additional_config.py @@ -4,19 +4,20 @@ def get_lm_opts(): transf_lm_net = TransformerLM( - source='prev:output', num_layers=24, vocab_size=2051, use_as_ext_lm=True, prefix_name='lm_') + source="prev:output", num_layers=24, vocab_size=2051, use_as_ext_lm=True, prefix_name="lm_" + ) transf_lm_net.create_network() transf_lm_opts = { - 'lm_subnet': transf_lm_net.network.get_net(), - 'lm_output_prob_name': 'lm_output', - 'is_recurrent': True, - 'preload_from_files': { - 'lm_model': { - 'filename': '/work/asr4/zeineldeen/setups-data/librispeech/2021-02-21--lm-bpe/dependencies/lm_models/transf/epoch.017', - 'prefix': 'lm_' + "lm_subnet": transf_lm_net.network.get_net(), + "lm_output_prob_name": "lm_output", + "is_recurrent": True, + "preload_from_files": { + "lm_model": { + "filename": "/work/asr4/zeineldeen/setups-data/librispeech/2021-02-21--lm-bpe/dependencies/lm_models/transf/epoch.017", + "prefix": "lm_", } }, - 'name': 'trafo', + "name": "trafo", } return transf_lm_opts @@ -25,7 +26,7 @@ def get_lm_opts(): fairseq_mhsa_init = "variance_scaling_initializer(mode='fan_avg', distribution='uniform', scale=0.5)" # limit = sqrt(6 * 0.5 / (fan_in + fan_out)) = sqrt(3 / (fan_in + fan_out)) -def apply_fairseq_init_to_conformer(conformer_args: [ConformerEncoderArgs,ConformerDecoderArgs]): +def apply_fairseq_init_to_conformer(conformer_args: [ConformerEncoderArgs, ConformerDecoderArgs]): # fairseq init conformer_args.ff_init = fairseq_ff_init conformer_args.mhsa_init = fairseq_mhsa_init @@ -40,10 +41,10 @@ def apply_fairseq_init_to_transformer_decoder(transformer_dec_args: TransformerD transformer_dec_args.mhsa_out_init = fairseq_ff_init -def reset_params_init(args: [ConformerEncoderArgs,TransformerDecoderArgs]): +def reset_params_init(args: [ConformerEncoderArgs, TransformerDecoderArgs]): # reset parameters init args.ff_init = None args.mhsa_init = None args.mhsa_out_init = None if isinstance(args, ConformerEncoderArgs): - args.conv_module_init = None \ No newline at end of file + args.conv_module_init = None From dfe142f2a38fcc45a9cddf4dab0a9351f5f886aa Mon Sep 17 00:00:00 2001 From: Simon Berger Date: Thu, 30 May 2024 10:54:51 +0200 Subject: [PATCH 073/227] Update users/berger --- .../20230210_baselines/__init__.py | 2 + .../config_02b_transducer_rasr_features.py | 18 +++++--- ..._02f_transducer_rasr_features_am_scales.py | 10 +---- ...nfig_03a_transducer_fullsum_raw_samples.py | 1 + ...ig_03b_transducer_fullsum_rasr_features.py | 42 ++++++++--------- users/berger/network/helpers/rnnt_loss.py | 45 ++++++++++++++++++- .../network/models/context_1_transducer.py | 2 + .../context_1_transducer_raw_samples.py | 2 + 8 files changed, 86 insertions(+), 36 deletions(-) diff --git a/users/berger/configs/librispeech/20230210_baselines/__init__.py b/users/berger/configs/librispeech/20230210_baselines/__init__.py index 1bfefd2ef..bcb63868b 100644 --- a/users/berger/configs/librispeech/20230210_baselines/__init__.py +++ b/users/berger/configs/librispeech/20230210_baselines/__init__.py @@ -15,6 +15,7 @@ from .config_02c_transducer_rasr_features_wei_lex import py as py_02c from .config_02e_transducer_rasr_features_tinaconf import py as py_02e from .config_02e_transducer_rasr_features_tinaconf_rtf import py as py_02e_rtf +from .config_02f_transducer_rasr_features_am_scales import py as py_02f from .config_03a_transducer_fullsum_raw_samples import py as py_03a from .config_03b_transducer_fullsum_rasr_features import py as py_03b from .config_03c_transducer_fullsum_rasr_features_wei_lex import py as py_03c @@ -37,6 +38,7 @@ def main() -> SummaryReport: sub_reports.append(copy.deepcopy(py_02c()[0])) sub_reports.append(copy.deepcopy(py_02e())) sub_reports.append(copy.deepcopy(py_02e_rtf())) + sub_reports.append(copy.deepcopy(py_02f())) sub_reports.append(copy.deepcopy(py_03a())) sub_reports.append(copy.deepcopy(py_03b())) sub_reports.append(copy.deepcopy(py_03c())) diff --git a/users/berger/configs/librispeech/20230210_baselines/config_02b_transducer_rasr_features.py b/users/berger/configs/librispeech/20230210_baselines/config_02b_transducer_rasr_features.py index 3953a13fa..9970ae508 100644 --- a/users/berger/configs/librispeech/20230210_baselines/config_02b_transducer_rasr_features.py +++ b/users/berger/configs/librispeech/20230210_baselines/config_02b_transducer_rasr_features.py @@ -66,10 +66,7 @@ def generate_returnn_config( } if train: - ( - network_dict, - extra_python, - ) = transducer_model.make_context_1_conformer_transducer( + (network_dict, extra_python,) = transducer_model.make_context_1_conformer_transducer( num_outputs=num_classes, specaug_args=specaug_args, conformer_args={ @@ -402,8 +399,15 @@ def run_exp( { "epochs": [382], "lm_scales": [0.8], + "mem": 8, } ) + system.run_recog_step_for_corpora( + exp_names=[f"Conformer_Transducer_Viterbi_specaug-v2_{name_suffix}"], + corpora=["dev-clean_4gram", "dev-other_4gram", "test-clean_4gram", "test-other_4gram"], + recog_exp_names=["recog_ilm-0.3"], + **recog_args, + ) recog_args["search_parameters"].update( { "label-pruning": 11.0, @@ -473,7 +477,11 @@ def run_exp( **recog_args, ) - train_job = system.get_train_job(f"Conformer_Transducer_Viterbi_lr-0.0008_{name_suffix}") + if "blstm" in name_suffix: + train_job = system.get_train_job(f"Conformer_Transducer_Viterbi_specaug-v2_{name_suffix}") + else: + train_job = system.get_train_job(f"Conformer_Transducer_Viterbi_lr-0.0008_{name_suffix}") + model = train_job.out_checkpoints[400] assert isinstance(model, Checkpoint) diff --git a/users/berger/configs/librispeech/20230210_baselines/config_02f_transducer_rasr_features_am_scales.py b/users/berger/configs/librispeech/20230210_baselines/config_02f_transducer_rasr_features_am_scales.py index 320f83114..4f66ded44 100644 --- a/users/berger/configs/librispeech/20230210_baselines/config_02f_transducer_rasr_features_am_scales.py +++ b/users/berger/configs/librispeech/20230210_baselines/config_02f_transducer_rasr_features_am_scales.py @@ -65,10 +65,7 @@ def generate_returnn_config( } if train: - ( - network_dict, - extra_python, - ) = transducer_model.make_context_1_conformer_transducer( + (network_dict, extra_python,) = transducer_model.make_context_1_conformer_transducer( num_outputs=num_classes, specaug_args=specaug_args, conformer_args={ @@ -102,10 +99,7 @@ def generate_returnn_config( specaug_v2=specaug_v2, ) else: - ( - network_dict, - extra_python, - ) = transducer_model.make_context_1_conformer_transducer_recog( + (network_dict, extra_python,) = transducer_model.make_context_1_conformer_transducer_recog( num_outputs=num_classes, conformer_args={ "num_blocks": 12, diff --git a/users/berger/configs/librispeech/20230210_baselines/config_03a_transducer_fullsum_raw_samples.py b/users/berger/configs/librispeech/20230210_baselines/config_03a_transducer_fullsum_raw_samples.py index 2ee08d156..8a89118c7 100644 --- a/users/berger/configs/librispeech/20230210_baselines/config_03a_transducer_fullsum_raw_samples.py +++ b/users/berger/configs/librispeech/20230210_baselines/config_03a_transducer_fullsum_raw_samples.py @@ -83,6 +83,7 @@ def generate_returnn_config( "activation": "tanh", }, }, + fullsum_v2=True, ) else: (network_dict, extra_python,) = transducer_model.make_context_1_conformer_transducer_recog( diff --git a/users/berger/configs/librispeech/20230210_baselines/config_03b_transducer_fullsum_rasr_features.py b/users/berger/configs/librispeech/20230210_baselines/config_03b_transducer_fullsum_rasr_features.py index 496d6fd5b..f0cf7ca0d 100644 --- a/users/berger/configs/librispeech/20230210_baselines/config_03b_transducer_fullsum_rasr_features.py +++ b/users/berger/configs/librispeech/20230210_baselines/config_03b_transducer_fullsum_rasr_features.py @@ -49,10 +49,7 @@ def generate_returnn_config( **kwargs, ) -> ReturnnConfig: if train: - ( - network_dict, - extra_python, - ) = transducer_model.make_context_1_conformer_transducer_fullsum( + (network_dict, extra_python,) = transducer_model.make_context_1_conformer_transducer_fullsum( num_outputs=num_classes, specaug_args={ "max_time_num": 1, @@ -84,12 +81,10 @@ def generate_returnn_config( "activation": "tanh", }, }, + fullsum_v2=True, ) else: - ( - network_dict, - extra_python, - ) = transducer_model.make_context_1_conformer_transducer_recog( + (network_dict, extra_python,) = transducer_model.make_context_1_conformer_transducer_recog( num_outputs=num_classes, conformer_args={ "num_blocks": 12, @@ -279,27 +274,32 @@ def run_exp(alignments: Dict[str, AlignmentData], viterbi_model_checkpoint: Chec recog_args["search_parameters"].update( { - # "separate-lookahead-lm": True, + "separate-lookahead-lm": True, "label-full-sum": False, "label-pruning": 16.2, } ) - recog_args["lookahead_options"].update({"lm_lookahead_scale": 0.45}) recog_args["use_gpu"] = True recog_args["rtf"] = 100 recog_args["mem"] = 24 - system.run_recog_step_for_corpora( - recog_descriptor="fs", - recog_exp_names={"Conformer_Transducer_Fullsum_lr-0.0001_bs-9000": ["recog_ilm-0.2"]}, - corpora=[ - # "dev-clean_kazuki_transformer", - "dev-other_kazuki_transformer", - # "test-clean_kazuki_transformer", - # "test-other_kazuki_transformer", - ], - **recog_args, - ) + # recog_args["lm_scales"] = [0.8, 0.9] + # for lm_lookahead_scale in [0.3, 0.4, 0.45, 0.5, 0.6]: + recog_args["lm_scales"] = [0.9] + for lm_lookahead_scale in [0.3, 0.4, 0.45, 0.5, 0.6]: + recog_args["lookahead_options"].update({"lm_lookahead_scale": lm_lookahead_scale}) + + system.run_recog_step_for_corpora( + recog_descriptor=f"fs_lookahead-{lm_lookahead_scale}", + recog_exp_names={"Conformer_Transducer_Fullsum_lr-0.0001_bs-9000": ["recog_ilm-0.2", "recog_ilm-0.3"]}, + corpora=[ + "dev-clean_kazuki_transformer", + "dev-other_kazuki_transformer", + "test-clean_kazuki_transformer", + "test-other_kazuki_transformer", + ], + **recog_args, + ) assert system.summary_report return system.summary_report diff --git a/users/berger/network/helpers/rnnt_loss.py b/users/berger/network/helpers/rnnt_loss.py index 0edb8f719..613041026 100644 --- a/users/berger/network/helpers/rnnt_loss.py +++ b/users/berger/network/helpers/rnnt_loss.py @@ -1,3 +1,7 @@ +from sisyphus.delayed_ops import DelayedFormat +from i6_core.tools.git import CloneGitRepositoryJob + + def rnnt_loss(sources, blank_label=0): from returnn.extern.WarpRna import rna_loss @@ -61,6 +65,24 @@ def rnnt_loss_compressed(sources, blank_label=0): return loss +def rnnt_loss_compressed_v2(sources, blank_label: int = 0): + from tensorflow_binding.returnn_tf_op import monotonic_rnnt_loss + + logits = sources(0, as_data=True, auto_convert=False) + targets = sources(1, as_data=True, auto_convert=False) + encoder = sources(2, as_data=True, auto_convert=False) + + loss = monotonic_rnnt_loss( + logits.placeholder, + targets.get_placeholder_as_batch_major(), + encoder.get_sequence_lengths(), + targets.get_sequence_lengths(), + blank_label=blank_label, + ) + loss.set_shape((None,)) + return loss + + def add_rnnt_loss_compressed( network: dict, encoder: str, @@ -68,6 +90,7 @@ def add_rnnt_loss_compressed( targets: str, num_classes: int, blank_index: int = 0, + loss_v2: bool = False, ): network["output"] = { "class": "linear", @@ -86,7 +109,25 @@ def add_rnnt_loss_compressed( "from": ["output", targets, encoder], "loss": "as_is", "out_type": {"batch_dim_axis": 0, "time_dim_axis": None, "shape": ()}, - "eval": f'self.network.get_config().typed_value("rnnt_loss_compressed")(source, {blank_index})', } - return [rnnt_loss_compressed] + if loss_v2: + network["rnnt_loss"][ + "eval" + ] = f'self.network.get_config().typed_value("rnnt_loss_compressed_v2")(source, {blank_index})' + else: + network["rnnt_loss"][ + "eval" + ] = f'self.network.get_config().typed_value("rnnt_loss_compressed")(source, {blank_index})' + + if loss_v2: + repo = CloneGitRepositoryJob( + "https://github.com/SimBe195/monotonic-rnnt.git", checkout_folder_name="monotonic-rnnt" + ).out_repository + return [ + "import sys", + DelayedFormat('sys.path.append("{}")', repo), + rnnt_loss_compressed_v2, + ] + else: + return [rnnt_loss_compressed] diff --git a/users/berger/network/models/context_1_transducer.py b/users/berger/network/models/context_1_transducer.py index 38cd61d42..603b0be38 100644 --- a/users/berger/network/models/context_1_transducer.py +++ b/users/berger/network/models/context_1_transducer.py @@ -119,6 +119,7 @@ def make_context_1_conformer_transducer_fullsum( conformer_args: Dict = {}, decoder_args: Dict = {}, specaug_v2: bool = False, + fullsum_v2: bool = False, ) -> Tuple[Dict, List]: network = {} python_code = [] @@ -172,6 +173,7 @@ def make_context_1_conformer_transducer_fullsum( targets=f"base:base:{context_labels}", num_classes=num_outputs, blank_index=blank_index, + loss_v2=fullsum_v2, ) else: python_code += add_rnnt_loss( diff --git a/users/berger/network/models/context_1_transducer_raw_samples.py b/users/berger/network/models/context_1_transducer_raw_samples.py index 289cc1881..56ccea00a 100644 --- a/users/berger/network/models/context_1_transducer_raw_samples.py +++ b/users/berger/network/models/context_1_transducer_raw_samples.py @@ -112,6 +112,7 @@ def make_context_1_conformer_transducer_fullsum( vgg_args: Dict = {}, conformer_args: Dict = {}, decoder_args: Dict = {}, + fullsum_v2: bool = False, ) -> Tuple[Dict, List]: network = {} python_code = [] @@ -159,6 +160,7 @@ def make_context_1_conformer_transducer_fullsum( targets=f"base:base:{context_labels}", num_classes=num_outputs, blank_index=blank_index, + loss_v2=fullsum_v2, ) else: python_code += add_rnnt_loss( From 99647dff0ea1f952f6169ab8881da376f2379a8f Mon Sep 17 00:00:00 2001 From: "luca.gaudino" Date: Fri, 31 May 2024 11:16:26 +0200 Subject: [PATCH 074/227] fixes and update --- .../conformer_import_moh_att_2023_06_30.py | 171 ++++++++++++--- .../model_recogs/model_recog.py | 5 +- .../tedlium2/_import_model.py | 12 +- .../conformer_import_moh_att_2023_10_19.py | 10 +- .../tedlium2/conformer_ctc_train.py | 205 +++++++++++++----- .../tedlium2/conformer_rnnt_train.py | 20 +- .../models/asr/rf/ilm_import_2024_04_17.py | 6 +- 7 files changed, 333 insertions(+), 96 deletions(-) diff --git a/users/gaudino/experiments/rf_conformer_att_2023/librispeech_960/conformer_import_moh_att_2023_06_30.py b/users/gaudino/experiments/rf_conformer_att_2023/librispeech_960/conformer_import_moh_att_2023_06_30.py index 611d6c876..ab9778259 100644 --- a/users/gaudino/experiments/rf_conformer_att_2023/librispeech_960/conformer_import_moh_att_2023_06_30.py +++ b/users/gaudino/experiments/rf_conformer_att_2023/librispeech_960/conformer_import_moh_att_2023_06_30.py @@ -60,6 +60,7 @@ _returnn_tf_ckpt_filename = "i6_core/returnn/training/AverageTFCheckpointsJob.BxqgICRSGkgb/output/model/average.index" _torch_ckpt_filename_w_lstm_lm = "/work/asr3/zeineldeen/hiwis/luca.gaudino/setups-data/2023-08-10--rf-librispeech/work/i6_experiments/users/gaudino/returnn/convert_ckpt_rf/full_w_lm_import_2023_10_18/average.pt" _torch_ckpt_filename_w_trafo_lm = "/work/asr3/zeineldeen/hiwis/luca.gaudino/setups-data/2023-08-10--rf-librispeech/work/i6_experiments/users/gaudino/returnn/convert_ckpt_rf/librispeech/full_w_trafo_lm_import_2024_02_05/average.pt" +_torch_ckpt_filename_base_model = "/work/asr3/zeineldeen/hiwis/luca.gaudino/setups-data/2023-08-10--rf-librispeech/work/i6_experiments/users/gaudino/returnn/convert_ckpt_rf/librispeech/base_model/average.pt" # The model gets raw features (16khz) and does feature extraction internally. _log_mel_feature_dim = 80 @@ -124,31 +125,6 @@ def sis_run_with_prefix(prefix_name: str = None): res.output, ) - # att + lstm lm TODO: debug difference - for scales, beam_size in product([(1.0, 0.3), (1.0, 0.33), (1.0, 0.27)], []): - att_scale, lm_scale = scales - recog_name = f"/opls_att{att_scale}_lstm_lm{lm_scale}_beam{beam_size}" - name = prefix_name + recog_name - search_args = { - "beam_size": beam_size, - "add_lstm_lm": True, - "lm_scale": lm_scale, - "bsf": bsf, - } - res, _ = recog_model( - task, - model_with_checkpoint, - model_recog, - dev_sets=["dev-other"], - model_args=model_args, - search_args=search_args, - prefix_name=name, - ) - tk.register_output( - name + f"/recog_results", - res.output, - ) - # espnet ctc prefix decoder # beam 12/32: {"dev-clean": 2.83, "dev-other": 6.69, "test-clean": 3.07, "test-other": 7.02} for prior_scale, beam_size in product([0.0], []): @@ -249,6 +225,31 @@ def sis_run_with_prefix(prefix_name: str = None): # ------------------ with LSTM LM ------------------------ + # att + lstm lm TODO: debug difference + for scales, beam_size in product([(1.0, 0.3), (1.0, 0.33), (1.0, 0.27)], []): + att_scale, lm_scale = scales + recog_name = f"/opls_att{att_scale}_lstm_lm{lm_scale}_beam{beam_size}" + name = prefix_name + recog_name + search_args = { + "beam_size": beam_size, + "add_lstm_lm": True, + "lm_scale": lm_scale, + "bsf": bsf, + } + res, _ = recog_model( + task, + model_with_checkpoint, + model_recog, + dev_sets=["dev-other"], + model_args=model_args, + search_args=search_args, + prefix_name=name, + ) + tk.register_output( + name + f"/recog_results", + res.output, + ) + # att + espnet ctc prefix scorer + lstm lm for scales, prior_scale, lm_scale, beam_size in product( [(0.8, 0.2), (0.85, 0.15)], @@ -410,12 +411,20 @@ def sis_run_with_prefix(prefix_name: str = None): # ------------------ with Trafo LM ------------------------ - model_w_trafo_lm_ckpt_path = tk.Path( - _torch_ckpt_filename_w_trafo_lm, hash_overwrite="torch_ckpt_w_trafo_lm" + # model_w_trafo_lm_ckpt_path = tk.Path( + # _torch_ckpt_filename_w_trafo_lm, hash_overwrite="torch_ckpt_w_trafo_lm" + # ) + # model_w_trafo_lm_ckpt = PtCheckpoint(model_w_trafo_lm_ckpt_path) + # model_with_checkpoint = ModelWithCheckpoint( + # definition=from_scratch_model_def, checkpoint=model_w_trafo_lm_ckpt + # ) + # + model_ckpt_path = tk.Path( + _torch_ckpt_filename_base_model, hash_overwrite="torch_ckpt_base_model" ) - model_w_trafo_lm_ckpt = PtCheckpoint(model_w_trafo_lm_ckpt_path) + model_ckpt = PtCheckpoint(model_ckpt_path) model_with_checkpoint = ModelWithCheckpoint( - definition=from_scratch_model_def, checkpoint=model_w_trafo_lm_ckpt + definition=from_scratch_model_def, checkpoint=model_ckpt ) model_args = { @@ -435,6 +444,8 @@ def sis_run_with_prefix(prefix_name: str = None): }, } + # ilm ckpt torch: /work/asr3/zeineldeen/hiwis/luca.gaudino/setups-data/2023-08-10--rf-librispeech/work/i6_experiments/users/gaudino/returnn/convert_ckpt_rf/librispeech/mini_att_ilm_24_05_28/average.pt + # opts ctc + trafo lm TODO: fix bugs for scales, beam_size in product([(1.0, 0.5)], []): ctc_scale, lm_scale = scales @@ -470,7 +481,7 @@ def sis_run_with_prefix(prefix_name: str = None): # att + trafo lm # beam 32: {"dev-clean": 1.91, "dev-other": 4.14, "test-clean": 2.2, "test-other": 4.6} - for lm_scale, beam_size in product([0.42], [32, 40]): + for lm_scale, beam_size in product([0.42], [32]): recog_name = f"/att_trafo_lm{lm_scale}_beam{beam_size}" name = prefix_name + recog_name search_args = { @@ -570,6 +581,106 @@ def sis_run_with_prefix(prefix_name: str = None): res.output, ) + # ------------------ with MiniAtt ILM ------------------------ + + model_args = { + "external_language_model": { + "class": "Trafo_LM_Model", + "num_layers": 24, + "layer_out_dim": 1024, + "att_num_heads": 8, + "use_pos_enc": True, + "ff_activation": "relu", + }, + "internal_language_model": { + "class": "MiniAtt_ILM_Model", + "s_use_zoneout_output": False, + }, + "preload_from_files": { + "01_trafo_lm": { + "prefix": "language_model.", + "filename": "/work/asr3/zeineldeen/hiwis/luca.gaudino/setups-data/2023-08-10--rf-librispeech/work/i6_experiments/users/gaudino/returnn/convert_ckpt_rf/librispeech/trafo_lm_only_24_02_06/network.023.pt", + }, + "01_mini_att_ilm": { + "prefix": "ilm.", + "filename": "/work/asr3/zeineldeen/hiwis/luca.gaudino/setups-data/2023-08-10--rf-librispeech/work/i6_experiments/users/gaudino/returnn/convert_ckpt_rf/librispeech/mini_att_ilm_24_05_28/average.pt", + }, + }, + } + + # ilm ckpt torch: /work/asr3/zeineldeen/hiwis/luca.gaudino/setups-data/2023-08-10--rf-librispeech/work/i6_experiments/users/gaudino/returnn/convert_ckpt_rf/librispeech/mini_att_ilm_24_05_28/average.pt + + # att + trafo lm + ilm + # + for lm_scale, ilm_scale, beam_size in product([0.54], [0.4], [32, 64]): + recog_name = f"/att_trafolm{lm_scale}_ilm{ilm_scale}_beam{beam_size}_ffix" + name = prefix_name + recog_name + search_args = { + "beam_size": beam_size, + "add_trafo_lm": True, + "lm_scale": lm_scale, + "ilm_scale": ilm_scale, + "bsf": bsf, + "use_lm_first_label": True, + } + res, _ = recog_model( + task, + model_with_checkpoint, + model_recog, + dev_sets=["dev-other"], + model_args=model_args, + search_args=search_args, + prefix_name=name, + ) + tk.register_output( + name + f"/recog_results", + res.output, + ) + + # opls att + ctc + trafo lm + ilm + for scales, prior_scale, lm_scale, ilm_scale, beam_size in product( + [(0.85, 0.15)], [0.0], [0.5], [0.3, 0.35, 0.4, 0.45], [12, 32] + ): + att_scale, ctc_scale = scales + recog_name = ( + f"/opls_att{att_scale}_ctc{ctc_scale}" + + (f"_prior{prior_scale}" if prior_scale > 0.0 else "") + + f"_trafo_lm{lm_scale}" + + f"_ilm{ilm_scale}" + + f"_beam{beam_size}_ffix" + ) + name = prefix_name + recog_name + search_args = { + "beam_size": beam_size, + "add_trafo_lm": True, + "lm_scale": lm_scale, + "att_scale": att_scale, + "ctc_scale": ctc_scale, + "ilm_scale": ilm_scale, + "use_ctc": True, + "bsf": bsf, + "prior_corr": prior_scale > 0.0, + "ctc_prior_file": "/work/asr3/zeineldeen/hiwis/luca.gaudino/setups-data/2023-02-22--conformer-swb/work/i6_core/returnn/extract_prior/ReturnnComputePriorJobV2.ZeflcEHlQTjn/output/prior.txt", + "prior_scale": prior_scale, + "use_lm_first_label": True, + } + res, _ = recog_model( + task, + model_with_checkpoint, + model_recog, + dev_sets=["dev-other"], + model_args=model_args, + search_args=search_args, + prefix_name=name, + # device="cpu", + # search_mem_rqmt=15, + ) + tk.register_output( + name + f"/recog_results", + res.output, + ) + + py = sis_run_with_prefix # if run directly via `sis m ...` diff --git a/users/gaudino/experiments/rf_conformer_att_2023/librispeech_960/model_recogs/model_recog.py b/users/gaudino/experiments/rf_conformer_att_2023/librispeech_960/model_recogs/model_recog.py index 5c16781ef..ed496388c 100644 --- a/users/gaudino/experiments/rf_conformer_att_2023/librispeech_960/model_recogs/model_recog.py +++ b/users/gaudino/experiments/rf_conformer_att_2023/librispeech_960/model_recogs/model_recog.py @@ -166,15 +166,12 @@ def model_recog( lm_state = lm_out["state"] lm_log_prob = rf.log_softmax(lm_out["output"], axis=model.target_dim) - - - if not model.search_args.get("use_lm_first_label", False) and i > 0: + if model.search_args.get("use_lm_first_label", True) or i > 0: label_log_prob = ( label_log_prob + model.search_args["lm_scale"] * lm_log_prob ) if model.search_args.get("ilm_scale", 0.0) > 0: - # breakpoint() ilm_out = model.ilm(input_embed, state=ilm_state, spatial_dim=single_step_dim) ilm_state = ilm_out["state"] ilm_log_prob = rf.log_softmax(ilm_out["output"], axis=model.target_dim) diff --git a/users/gaudino/experiments/rf_conformer_att_2023/tedlium2/_import_model.py b/users/gaudino/experiments/rf_conformer_att_2023/tedlium2/_import_model.py index c2a7de778..2d63bc745 100644 --- a/users/gaudino/experiments/rf_conformer_att_2023/tedlium2/_import_model.py +++ b/users/gaudino/experiments/rf_conformer_att_2023/tedlium2/_import_model.py @@ -657,12 +657,13 @@ def import_models(): if __name__ == "__main__": - import_models() + # import_models() # convert_lm( # _ted2_lm_ckpt_filename, # "/work/asr3/zeineldeen/hiwis/luca.gaudino/setups-data/2023-08-10--rf-librispeech/work/i6_experiments/users/gaudino/returnn/convert_ckpt_rf/tedlium2/trafo_lm_only_24_02_05", # 1057, # ) + # Ted2 ILM # convert_mini_att_ilm( # ckpt_path_prior="/u/zeineldeen/setups/ubuntu_22_setups/2023-04-17--conformer-att/work/i6_core/returnn/training/AverageTFCheckpointsJob.yB4JK4GDCxWG/output/model/average", # ckpt_path_mini_att="/u/zeineldeen/setups/ubuntu_22_setups/2023-04-17--conformer-att/work/i6_core/returnn/training/GetBestTFCheckpointJob.70hGEsLQ6ynw/output/model/checkpoint", @@ -670,3 +671,12 @@ def import_models(): # model_target_dim=1057, # out_dir="/work/asr3/zeineldeen/hiwis/luca.gaudino/setups-data/2023-08-10--rf-librispeech/work/i6_experiments/users/gaudino/returnn/convert_ckpt_rf/tedlium2/mini_att_ilm_24_04_21", # ) + + # ls960 ILM + convert_mini_att_ilm( + ckpt_path_prior="/u/zeineldeen/setups/ubuntu_22_setups/2023-04-17--conformer-att/work/i6_core/returnn/training/AverageTFCheckpointsJob.BxqgICRSGkgb/output/model/average", + ckpt_path_mini_att="/u/zeineldeen/setups/ubuntu_22_setups/2023-04-17--conformer-att/work/i6_core/returnn/training/GetBestTFCheckpointJob.JLwxrydala1K/output/model/checkpoint", + model_in_dim=640, + model_target_dim=10025, + out_dir="/work/asr3/zeineldeen/hiwis/luca.gaudino/setups-data/2023-08-10--rf-librispeech/work/i6_experiments/users/gaudino/returnn/convert_ckpt_rf/librispeech/mini_att_ilm_24_05_28", + ) diff --git a/users/gaudino/experiments/rf_conformer_att_2023/tedlium2/conformer_import_moh_att_2023_10_19.py b/users/gaudino/experiments/rf_conformer_att_2023/tedlium2/conformer_import_moh_att_2023_10_19.py index e653183c9..d89d6fbf1 100644 --- a/users/gaudino/experiments/rf_conformer_att_2023/tedlium2/conformer_import_moh_att_2023_10_19.py +++ b/users/gaudino/experiments/rf_conformer_att_2023/tedlium2/conformer_import_moh_att_2023_10_19.py @@ -518,10 +518,10 @@ def sis_run_with_prefix(prefix_name: str = None): ) # opls att + ctc + trafo lm + ilm - # 5.78 with att 0.7, ctc 0.3, prior 0.7, trafo 0.6, ilm 0.45 - for model_name, beam_size, lm_scale in product(["model_baseline"], [12], [0.6, 0.62, 0.64, 0.66, 0.68, 0.7]): - for scales in [(0.7, 0.3, 0.7, 0.45)]: - att_scale, ctc_scale, prior_scale, ilm_scale = scales + # 5.74 with att 0.7, ctc 0.3, prior 0.7, trafo 0.6, ilm 0.45 + for model_name, beam_size in product(["model_baseline"], [12, 24]): + for scales in [(0.7, 0.3, 0.7, 0.6, 0.45)]: + att_scale, ctc_scale, prior_scale, lm_scale, ilm_scale = scales ilm_model_args = copy.deepcopy(models_with_pt_ckpt[model_name]["model_args"]) ilm_model_args["preload_from_files"] = preload_from_files_ilm @@ -552,7 +552,7 @@ def sis_run_with_prefix(prefix_name: str = None): task, models_with_pt_ckpt[model_name]["ckpt"], model_recog, - dev_sets=["dev"], + dev_sets=["dev", "test"], model_args=ilm_model_args, search_args=search_args, prefix_name=name, diff --git a/users/gaudino/experiments/rf_conformer_rnnt_2024/tedlium2/conformer_ctc_train.py b/users/gaudino/experiments/rf_conformer_rnnt_2024/tedlium2/conformer_ctc_train.py index 74628b703..3fd2c0362 100644 --- a/users/gaudino/experiments/rf_conformer_rnnt_2024/tedlium2/conformer_ctc_train.py +++ b/users/gaudino/experiments/rf_conformer_rnnt_2024/tedlium2/conformer_ctc_train.py @@ -70,6 +70,7 @@ def sis_run_with_prefix(prefix_name: Optional[str] = None): "weight_decay": 1e-6, }, # accum_grad_multiple_step=4, + accum_grad_multiple_step=2, # gradient_noise=0.0, learning_rate=2.5e-3, dynamic_learning_rate=dyn_lr_lin_warmup_invsqrt_decay, @@ -77,7 +78,6 @@ def sis_run_with_prefix(prefix_name: Optional[str] = None): learning_rate_invsqrt_norm=40_000, max_seq_length_default_target=None, gradient_clip_global_norm=5.0, - accum_grad_multiple_step=2, aux_loss_layers=[4,8], # rnnt_loss=False, ) @@ -246,24 +246,154 @@ def sis_run_with_prefix(prefix_name: Optional[str] = None): # gpu_mem=11, # ) - train_exp( # - "from-scratch-11gb_lrmaxs522k_lrmin8e-5_lrmax8e-4_aux4_8_adjSpec", + # train_exp( # does not converge + # "from-scratch-11gb_lrmaxs522k_lrmin8e-5_lrmax8e-4_aux4_8_adjSpec", + # ctc_train_config, + # config_updates={ + # "learning_rate": 1.0, + # "dynamic_learning_rate": dyn_lr_piecewise_linear, + # # total steps after 2000 epochs: 982.312 + # "learning_rate_piecewise_steps": [261_000, 522_000, 580_000], # 45% 45 % 10% + # "learning_rate_piecewise_values": [8e-5, 8e-4, 8e-5, 1e-6], + # "aux_loss_layers": [4, 8], + # "specaugment_steps": (5_900, 18_000, 36_000), + # }, + # num_epochs=400, + # gpu_mem=11, + # ) + # + # train_exp( # does not converge + # "from-scratch-11gb_lrmaxs522k_lrmin1e-5_lrmax1e-3_aux4_8_adjSpec", + # ctc_train_config, + # config_updates={ + # "learning_rate": 1.0, + # "dynamic_learning_rate": dyn_lr_piecewise_linear, + # # total steps after 2000 epochs: 982.312 + # "learning_rate_piecewise_steps": [261_000, 522_000, 580_000], # 45% 45 % 10% + # "learning_rate_piecewise_values": [1e-5, 1e-3, 1e-5, 1e-6], + # "aux_loss_layers": [4, 8], + # "specaugment_steps": (5_900, 18_000, 36_000), + # }, + # num_epochs=400, + # gpu_mem=11, + # ) + + # train_exp( # does not converge + # "from-scratch-11gb_lrmaxs522k_lrmin8e-5_lrmax8e-4_aux4_8_adjSpec2", + # ctc_train_config, + # config_updates={ + # "learning_rate": 1.0, + # "dynamic_learning_rate": dyn_lr_piecewise_linear, + # # total steps after 2000 epochs: 982.312 + # "learning_rate_piecewise_steps": [261_000, 522_000, 580_000], # 45% 45 % 10% + # "learning_rate_piecewise_values": [8e-5, 8e-4, 8e-5, 1e-6], + # "aux_loss_layers": [4, 8], + # "specaugment_steps": (25_000, 50_000, 100_000), + # }, + # config_deletes=["learning_rate_warmup_steps", "learning_rate_invsqrt_norm"], + # num_epochs=400, + # gpu_mem=11, + # ) + # + # train_exp( # does not converge + # "from-scratch-11gb_lrmaxs522k_lrmin1e-5_lrmax1e-3_aux4_8_adjSpec2", + # ctc_train_config, + # config_updates={ + # "learning_rate": 1.0, + # "dynamic_learning_rate": dyn_lr_piecewise_linear, + # # total steps after 2000 epochs: 982.312 + # "learning_rate_piecewise_steps": [261_000, 522_000, 580_000], # 45% 45 % 10% + # "learning_rate_piecewise_values": [1e-5, 1e-3, 1e-5, 1e-6], + # "aux_loss_layers": [4, 8], + # "specaugment_steps": (25_000, 50_000, 100_000), + # }, + # config_deletes=["learning_rate_warmup_steps", "learning_rate_invsqrt_norm"], + # num_epochs=400, + # gpu_mem=11, + # ) + + # TODO: try with pretrain + + # train_exp( # does not converge + # "from-scratch-11gb_pre3_lrmaxs522k_lrmin1e-5_lrmax1e-3_aux4_8_adjSpec", + # ctc_train_config, + # config_updates={ + # "learning_rate": 1.0, + # "dynamic_learning_rate": dyn_lr_piecewise_linear, + # # total steps after 2000 epochs: 982.312 + # "learning_rate_piecewise_steps": [261_000, 522_000, 580_000], # 45% 45 % 10% + # "learning_rate_piecewise_values": [1e-5, 1e-3, 1e-5, 1e-6], + # "aux_loss_layers": [4, 8], + # "specaugment_steps": (5_900, 18_000, 36_000), + # "pretrain_opts": { # pretrain + # "steps": [ + # (8 * 500, {"num_layers": 2}), + # (4 * 500, {"num_layers": 4}), + # (4 * 500, {"num_layers": 8}), + # ] + # }, + # }, + # num_epochs=400, + # gpu_mem=11, + # ) + + # TODO: try with epoch base lr schedule + ep = 400 + lr = 8e-4 + cyc_ep = int(0.45 * ep) + + # train_exp( # does not converge + # "from-scratch-11gb_ep_based_lr_aux4_8", + # ctc_train_config, + # config_updates={ + # "learning_rate": 1.0, + # "dynamic_learning_rate": None, + # # total steps after 2000 epochs: 982.312 + # # "learning_rate_piecewise_steps": [261_000, 522_000, 580_000], # 45% 45 % 10% + # # "learning_rate_piecewise_values": [1e-5, 1e-3, 1e-5, 1e-6], + # "aux_loss_layers": [4, 8], + # # "specaugment_steps": (5_900, 18_000, 36_000), + # # "pretrain_opts": { # pretrain + # # "steps": [ + # # (8 * 500, {"num_layers": 2}), + # # (4 * 500, {"num_layers": 4}), + # # (4 * 500, {"num_layers": 8}), + # # ] + # # }, + # "learning_rates": ( + # list(np.linspace(lr / 10, lr, cyc_ep)) + # + list(np.linspace(lr, lr / 10, cyc_ep)) + # + list(np.linspace(lr / 10, 1e-6, ep - 2 * cyc_ep)) + # ) + # }, + # num_epochs=400, + # gpu_mem=11, + # ) + + train_exp( + "from-scratch-11gb_lrmin1e-5_lrmax1e-3_aux4_8_adjSpec6k_noCurrL", ctc_train_config, config_updates={ "learning_rate": 1.0, "dynamic_learning_rate": dyn_lr_piecewise_linear, # total steps after 2000 epochs: 982.312 "learning_rate_piecewise_steps": [261_000, 522_000, 580_000], # 45% 45 % 10% - "learning_rate_piecewise_values": [8e-5, 8e-4, 8e-5, 1e-6], + "learning_rate_piecewise_values": [1e-5, 1e-3, 1e-5, 1e-6], "aux_loss_layers": [4, 8], "specaugment_steps": (5_900, 18_000, 36_000), + "epoch_wise_filter": { + # (1, 5): {"max_mean_len": 1000}, # better? + # older settings: + # (1, 5): {"max_mean_len": 200}, + # (6, 10): {"max_mean_len": 500}, + }, }, num_epochs=400, gpu_mem=11, ) - train_exp( # - "from-scratch-11gb_lrmaxs522k_lrmin1e-5_lrmax1e-3_aux4_8_adjSpec", + train_exp( + "from-scratch-11gb_lrmin1e-5_lrmax1e-3_aux4_8_adjSpec6k_adjCurrL", ctc_train_config, config_updates={ "learning_rate": 1.0, @@ -273,15 +403,21 @@ def sis_run_with_prefix(prefix_name: Optional[str] = None): "learning_rate_piecewise_values": [1e-5, 1e-3, 1e-5, 1e-6], "aux_loss_layers": [4, 8], "specaugment_steps": (5_900, 18_000, 36_000), + "epoch_wise_filter": { + # (1, 5): {"max_mean_len": 1000}, # better? + # older settings: + # (1, 5): {"max_mean_len": 200}, + # (6, 10): {"max_mean_len": 500}, + (1,2): {"max_mean_len": 400}, + (2,4): {"max_mean_len": 800}, + }, }, num_epochs=400, gpu_mem=11, ) - # TODO: try with pretrain - - train_exp( # - "from-scratch-11gb_pre3_lrmaxs522k_lrmin1e-5_lrmax1e-3_aux4_8_adjSpec", + train_exp( + "from-scratch-11gb_lrmin1e-5_lrmax1e-3_aux4_8_adjSpec6k_accumGrad4", ctc_train_config, config_updates={ "learning_rate": 1.0, @@ -291,47 +427,9 @@ def sis_run_with_prefix(prefix_name: Optional[str] = None): "learning_rate_piecewise_values": [1e-5, 1e-3, 1e-5, 1e-6], "aux_loss_layers": [4, 8], "specaugment_steps": (5_900, 18_000, 36_000), - "pretrain_opts": { # pretrain - "steps": [ - (8 * 500, {"num_layers": 2}), - (4 * 500, {"num_layers": 4}), - (4 * 500, {"num_layers": 8}), - ] - }, - }, - num_epochs=400, - gpu_mem=11, - ) - - # TODO: try with epoch base lr schedule - ep = 400 - lr = 8e-4 - cyc_ep = int(0.45 * ep) - - train_exp( # - "from-scratch-11gb_ep_based_lr_aux4_8", - ctc_train_config, - config_updates={ - "learning_rate": 1.0, - # "dynamic_learning_rate": dyn_lr_piecewise_linear, - # total steps after 2000 epochs: 982.312 - # "learning_rate_piecewise_steps": [261_000, 522_000, 580_000], # 45% 45 % 10% - # "learning_rate_piecewise_values": [1e-5, 1e-3, 1e-5, 1e-6], - "aux_loss_layers": [4, 8], - # "specaugment_steps": (5_900, 18_000, 36_000), - # "pretrain_opts": { # pretrain - # "steps": [ - # (8 * 500, {"num_layers": 2}), - # (4 * 500, {"num_layers": 4}), - # (4 * 500, {"num_layers": 8}), - # ] - # }, - "learning_rates": ( - list(numpy.linspace(lr / 10, lr, cyc_ep)) - + list(numpy.linspace(lr, lr / 10, cyc_ep)) - + list(numpy.linspace(lr / 10, 1e-6, ep - 2 * cyc_ep)) - ) + "accum_grad_multiple_step": 4, }, + config_deletes=["learning_rate_warmup_steps", "learning_rate_invsqrt_norm"], num_epochs=400, gpu_mem=11, ) @@ -405,7 +503,8 @@ def train_exp( _sis_setup_global_prefix() prefix = _sis_prefix + "/" + name - task = _get_ted2_task() + epoch_wise_filter = config.pop("epoch_wise_filter", None) + task = _get_ted2_task(epoch_wise_filter=epoch_wise_filter) config = config.copy() config = dict_update_deep(config, config_updates, config_deletes) if "__num_epochs" in config: @@ -506,7 +605,7 @@ def _get_ls_task(): return _ls_task -def _get_ted2_task(): +def _get_ted2_task(epoch_wise_filter=None): global _ted2_task if _ted2_task: return _ted2_task @@ -515,7 +614,7 @@ def _get_ted2_task(): get_tedlium2_task_bpe1k_raw, ) - _ted2_task = get_tedlium2_task_bpe1k_raw(with_eos_postfix=True, train_epoch_wise_filter=None) + _ted2_task = get_tedlium2_task_bpe1k_raw(with_eos_postfix=True, train_epoch_wise_filter=epoch_wise_filter) return _ted2_task diff --git a/users/gaudino/experiments/rf_conformer_rnnt_2024/tedlium2/conformer_rnnt_train.py b/users/gaudino/experiments/rf_conformer_rnnt_2024/tedlium2/conformer_rnnt_train.py index 9718aed90..beae49311 100644 --- a/users/gaudino/experiments/rf_conformer_rnnt_2024/tedlium2/conformer_rnnt_train.py +++ b/users/gaudino/experiments/rf_conformer_rnnt_2024/tedlium2/conformer_rnnt_train.py @@ -79,7 +79,7 @@ def sis_run_with_prefix(prefix_name: Optional[str] = None): # train_exp("base-11gb", config_11gb, gpu_mem=11) # train_exp("base-11gb-v1", my_config_11gb, num_epochs=400, gpu_mem=11) - train_exp( + train_exp( # "from-scratch-11gb", rnnt_train_config, config_updates={ @@ -91,6 +91,24 @@ def sis_run_with_prefix(prefix_name: Optional[str] = None): "learning_rate_piecewise_steps": [261_000, 522_000, 580_000], # 45% 45 % 10% "learning_rate_piecewise_values": [1e-5, 1e-3, 1e-5, 1e-6], }, + config_deletes=["learning_rate_warmup_steps", "learning_rate_invsqrt_norm"], + num_epochs=400, + gpu_mem=11, + ) + + train_exp( # does not converge + "from-scratch-11gb", + rnnt_train_config, + config_updates={ + "learning_rate": 1.0, + "dynamic_learning_rate": dyn_lr_piecewise_linear, + # total steps after 2000 epochs: 982.312 + # "learning_rate_piecewise_steps": [600_000, 900_000, 982_000], + # "learning_rate_piecewise_values": [1e-5, 1e-3, 1e-5, 1e-6], + "learning_rate_piecewise_steps": [261_000, 522_000, 580_000], # 45% 45 % 10% + "learning_rate_piecewise_values": [1e-5, 1e-3, 1e-5, 1e-6], + }, + config_deletes=["learning_rate_warmup_steps", "learning_rate_invsqrt_norm"], num_epochs=400, gpu_mem=24, ) diff --git a/users/gaudino/models/asr/rf/ilm_import_2024_04_17.py b/users/gaudino/models/asr/rf/ilm_import_2024_04_17.py index e7f671c18..adc3c60c2 100644 --- a/users/gaudino/models/asr/rf/ilm_import_2024_04_17.py +++ b/users/gaudino/models/asr/rf/ilm_import_2024_04_17.py @@ -25,6 +25,7 @@ def __init__( mini_att_lstm_dim: int = 50, mini_att_out_dim: int = 512, prior_dim: int = 1024, + s_use_zoneout_output: bool = True, # for ted2, for ls960 set to false # layer_out_dim: int = 768, # default values for ted2 trafo lm # layer_ff_dim: int = 4096, # embed_dim: int = 128, @@ -49,13 +50,14 @@ def __init__( self.mini_att_lstm_dim, self.mini_att_out_dim, with_bias=True ) + self.s_use_zoneout_output = s_use_zoneout_output + self.prior_s = rf.ZoneoutLSTM( in_dim + self.mini_att_out_dim, self.prior_dim, zoneout_factor_cell=0.15, zoneout_factor_output=0.05, - # use_zoneout_output=False, # like RETURNN/TF ZoneoutLSTM old default - use_zoneout_output=True, + use_zoneout_output=self.s_use_zoneout_output, # parts_order="icfo", # like RETURNN/TF ZoneoutLSTM # parts_order="ifco", parts_order="jifo", # NativeLSTM (the code above converts it...) From 6bd01c34aea62eb44113a061afa268284aee9692 Mon Sep 17 00:00:00 2001 From: "luca.gaudino" Date: Fri, 31 May 2024 11:17:59 +0200 Subject: [PATCH 075/227] add CTC gauss weights --- .../tedlium2/attention_asr_config.py | 17 +- .../tedlium2/configs/ted2_att_baseline.py | 92 ++++- .../gaudino/models/asr/decoder/ctc_decoder.py | 12 + .../models/asr/encoder/conformer_encoder.py | 385 ++++++++++++++---- 4 files changed, 423 insertions(+), 83 deletions(-) diff --git a/users/gaudino/experiments/conformer_att_2023/tedlium2/attention_asr_config.py b/users/gaudino/experiments/conformer_att_2023/tedlium2/attention_asr_config.py index 1321f7cc5..5abb616b6 100644 --- a/users/gaudino/experiments/conformer_att_2023/tedlium2/attention_asr_config.py +++ b/users/gaudino/experiments/conformer_att_2023/tedlium2/attention_asr_config.py @@ -412,6 +412,10 @@ class ConformerEncoderArgs(EncoderArgs): ctc_self_align_scale: float = 0.5 ctc_dropout: float = 0.0 enc_layer_w_ctc: Optional[int] = None + ctc_att_weights_gauss: bool = False + ctc_att_weights_gauss_stddev: float = 1.0 + ctc_att_weights_gauss_window: int = 5 + ctc_att_weights_use_enc: bool = True # param init ff_init: Optional[str] = None @@ -615,6 +619,10 @@ class CTCDecoderArgs(DecoderArgs): renorm_after_remove_blank: bool = True recombine: bool = False max_approx: bool = False + train: bool = False + + # not used + coverage_scale: bool = False def create_config( @@ -813,10 +821,11 @@ def create_config( elif isinstance(decoder_args, CTCDecoderArgs): decoder_type = CTCDecoder dec_type = "ctc" - exp_config["extern_data"]["bpe_labels_w_blank"] = copy.deepcopy( - exp_config["extern_data"]["bpe_labels"] - ) - exp_config["extern_data"]["bpe_labels_w_blank"]["dim"] += 1 + if not decoder_args.train: + exp_config["extern_data"]["bpe_labels_w_blank"] = copy.deepcopy( + exp_config["extern_data"]["bpe_labels"] + ) + exp_config["extern_data"]["bpe_labels_w_blank"]["dim"] += 1 else: assert False, "invalid decoder_args type" diff --git a/users/gaudino/experiments/conformer_att_2023/tedlium2/configs/ted2_att_baseline.py b/users/gaudino/experiments/conformer_att_2023/tedlium2/configs/ted2_att_baseline.py index eecc1e543..60c2d1423 100644 --- a/users/gaudino/experiments/conformer_att_2023/tedlium2/configs/ted2_att_baseline.py +++ b/users/gaudino/experiments/conformer_att_2023/tedlium2/configs/ted2_att_baseline.py @@ -1104,10 +1104,100 @@ def get_base_v1_args(lr, ep, enc_drop=0.1, pretrain_reps=3, use_legacy_stats=Tru ) ) prior_file_ctc_only = compute_ctc_prior( - only_ctc_name + "default_last", prior_args, last_checkpoint, bpe_size=BPE_1K + only_ctc_name + "/default_last", prior_args, last_checkpoint, bpe_size=BPE_1K ) # best checkpoint path "/u/zeineldeen/setups/ubuntu_22_setups/2023-04-17--conformer-att/work/i6_core/returnn/training/ReturnnTrainingJob.9o6iL7eblZwa/output/models/epoch.400" + # train only CTC no pretrain + no_pre_args = copy.deepcopy(args) + no_pre_args["decoder_args"] = CTCDecoderArgs(train=True) + no_pre_args["with_pretrain"] = False + only_ctc_name = f"base_bpe1000_peakLR{lr}_ep{ep}_globalNorm_epochOCLR_fixZoneout_encDrop{enc_drop}_woDepthConvPre_weightDrop0.1_decAttDrop0.0_embedDim256_numBlocks12_onlyCTC" + + # _, train_data = run_exp( + # only_ctc_name, + # no_pre_args, + # num_epochs=ep, + # epoch_wise_filter=None, + # bpe_size=BPE_1K, + # partition_epoch=4, + # search_args={ "decoder_args": CTCDecoderArgs(), **no_pre_args}, + # ) + + + # train only CTC with guassian "att weights" + + only_ctc_args = copy.deepcopy(args) + only_ctc_args["decoder_args"].ce_loss_scale = 0.0 + only_ctc_args["encoder_args"].ctc_att_weights_gauss = True + only_ctc_args["encoder_args"].ctc_att_weights_gauss_stddev = 1.0 + only_ctc_args["encoder_args"].ctc_att_weights_gauss_window = 5 + + only_ctc_args2 = copy.deepcopy(only_ctc_args) + + for use_enc in [False, True]: + only_ctc_args["encoder_args"].ctc_att_weights_use_enc = use_enc + only_ctc_name = name + "_onlyCTC_gaussWeights" + ("_no_enc" if not use_enc else "") + + if(use_enc): + only_ctc_args["gradient_clip_global_norm"] = 5.0 + only_ctc_name += "_gradClip5.0" + + _, train_data = run_exp( + only_ctc_name, + only_ctc_args, + num_epochs=ep, + epoch_wise_filter=None, + bpe_size=BPE_1K, + partition_epoch=4, + search_args={"ctc_decode": True, "ctc_blank_idx": 1057, **only_ctc_args}, + ) + + only_ctc_args["decoder_args"] = CTCDecoderArgs() + + last_checkpoint = Checkpoint( + tk.Path( + "/work/asr3/zeineldeen/hiwis/luca.gaudino/setups-data/2023-10-15--conformer-no-app/work/i6_core/returnn/training/ReturnnTrainingJob.4dFO6QJQ4h7x/output/models/epoch.400.index" + ) + ) + prior_file_ctc_only = compute_ctc_prior( + name + "_onlyCTC_gaussWeights" + "_gradClip5.0" + "/default_last", only_ctc_args, last_checkpoint, bpe_size=BPE_1K + ) + + only_ctc_args.pop("gradient_clip_global_norm") + only_ctc_args["encoder_args"].ctc_att_weights_use_enc = False + + last_checkpoint = Checkpoint( + tk.Path( + "/work/asr3/zeineldeen/hiwis/luca.gaudino/setups-data/2023-10-15--conformer-no-app/work/i6_core/returnn/training/ReturnnTrainingJob.4v01A22bWufz/output/models/epoch.400.index" + ) + ) + prior_file_ctc_only = compute_ctc_prior( + name + "_onlyCTC_gaussWeights" + "_no_enc" + "/default_last", only_ctc_args, last_checkpoint, bpe_size=BPE_1K + ) + + + + + for use_enc, std, window in product([], [0.5, 1.0, 2.0], [3, 5, 10]): + only_ctc_args = copy.deepcopy(only_ctc_args2) + only_ctc_args["encoder_args"].ctc_att_weights_gauss_stddev = std + only_ctc_args["encoder_args"].ctc_att_weights_gauss_window = window + only_ctc_args["encoder_args"].ctc_att_weights_use_enc = use_enc + only_ctc_args["gradient_clip_global_norm"] = 5.0 + + only_ctc_name = name + f"_onlyCTC_gaussWeights_std{std}_window{window}" + ("_no_enc" if not use_enc else "") + + _, train_data = run_exp( + only_ctc_name, + only_ctc_args, + num_epochs=ep, + epoch_wise_filter=None, + bpe_size=BPE_1K, + partition_epoch=4, + search_args={"ctc_decode": True, "ctc_blank_idx": 1057, **only_ctc_args}, + ) + # train scale CTC scale_ctc_name = name + "_ctcScale0.3" scale_ctc_args = copy.deepcopy(args) diff --git a/users/gaudino/models/asr/decoder/ctc_decoder.py b/users/gaudino/models/asr/decoder/ctc_decoder.py index ef64002e7..58caa11c3 100644 --- a/users/gaudino/models/asr/decoder/ctc_decoder.py +++ b/users/gaudino/models/asr/decoder/ctc_decoder.py @@ -303,6 +303,11 @@ def __init__( renorm_after_remove_blank=True, recombine=False, max_approx=False, + train = False, + + # not used + coverage_scale=False, + ): """ :param base_model: base/encoder model instance @@ -430,6 +435,8 @@ def __init__( self.dec_output = None self.output_prob = None + self.train = train + def get_python_prolog(self): """Called in attention_asr_config to add ctc decoder specific python code to the config.""" python_prolog = [] @@ -1570,6 +1577,11 @@ def add_blank_collapse(self): self.ctc_source = "blank_collapse_apply" def create_network(self): + + if self.train: + self.decision_layer_name = "dummy" + return + self.decision_layer_name = "out_best_wo_blank" # modify ctc source diff --git a/users/gaudino/models/asr/encoder/conformer_encoder.py b/users/gaudino/models/asr/encoder/conformer_encoder.py index 4cc13678f..c9617a093 100644 --- a/users/gaudino/models/asr/encoder/conformer_encoder.py +++ b/users/gaudino/models/asr/encoder/conformer_encoder.py @@ -16,6 +16,8 @@ from i6_core.returnn.config import CodeWrapper +import numpy as np + class ConformerEncoder: """ @@ -56,9 +58,11 @@ def __init__( ctc_opts=None, ctc_self_align_delay: Optional[int] = None, ctc_self_align_scale: float = 0.5, - enc_layer_w_ctc: Optional[int] = None, - + ctc_att_weights_gauss=False, + ctc_att_weights_gauss_stddev=1.0, + ctc_att_weights_gauss_window=5, + ctc_att_weights_use_enc=True, subsample=None, start_conv_init=None, conv_module_init=None, @@ -89,7 +93,6 @@ def __init__( mhsa_weight_dropout=None, conv_weight_dropout=None, memory_variant_opts: Optional[ConformerMemoryVariantOpts] = None, - conv_use_time_mask=False, ): """ @@ -168,7 +171,9 @@ def __init__( bn_momentum = batch_norm_opts.pop("momentum", 0.1) bn_eps = batch_norm_opts.pop("epsilon", 1e-3) - bn_update_sample_only_in_train = batch_norm_opts.pop("update_sample_only_in_training", True) + bn_update_sample_only_in_train = batch_norm_opts.pop( + "update_sample_only_in_training", True + ) bn_delay_sample_update = batch_norm_opts.pop("delay_sample_update", True) self.batch_norm_opts = { "momentum": bn_momentum, @@ -190,6 +195,10 @@ def __init__( self.ctc_self_align_scale = ctc_self_align_scale self.enc_layer_w_ctc = enc_layer_w_ctc + self.ctc_att_weights_gauss = ctc_att_weights_gauss + self.ctc_att_weights_gauss_stddev = ctc_att_weights_gauss_stddev + self.ctc_att_weights_gauss_window = ctc_att_weights_gauss_window + self.ctc_att_weights_use_enc = ctc_att_weights_use_enc self.start_conv_init = start_conv_init self.conv_module_init = conv_module_init @@ -223,7 +232,9 @@ def __init__( self.use_sqrd_relu = use_sqrd_relu self.use_causal_layers = use_causal_layers - self.use_causal_conv = use_causal_conv if use_causal_conv is not None else self.use_causal_layers + self.use_causal_conv = ( + use_causal_conv if use_causal_conv is not None else self.use_causal_layers + ) self.conv_alternative_name = conv_alternative_name self.fix_merge_dims = fix_merge_dims @@ -245,13 +256,19 @@ def __init__( if self.memory_variant_opts: self.concat_window_dim = SpatialDim("concat-window") # W*N self.enc_att_num_heads_dim = SpatialDim("enc-att-num-heads", att_num_heads) - self.enc_per_head_dim = FeatureDim("enc-dim-per-head", self.enc_key_per_head_dim) + self.enc_per_head_dim = FeatureDim( + "enc-dim-per-head", self.enc_key_per_head_dim + ) if self.memory_variant_opts.conv_cache_size: self.conv_cache_concat_dim = SpatialDim("conv-cache-concat") if self.memory_variant_opts.use_emformer_mem: - self.emformer_mem_bank_dim = SpatialDim("emformer-mem-bank") # M, the same as C but different tag + self.emformer_mem_bank_dim = SpatialDim( + "emformer-mem-bank" + ) # M, the same as C but different tag self.emformer_ext_query_dim = SpatialDim("emformer-ext-query") # W+1 - self.concat_window_with_mem_dim = SpatialDim("concat-window-with-mem") # W*N+M + self.concat_window_with_mem_dim = SpatialDim( + "concat-window-with-mem" + ) # W*N+M self.conv_use_time_mask = conv_use_time_mask @@ -282,7 +299,9 @@ def _create_ff_module(self, prefix_name, i, source, layer_index): ) if self.use_sqrd_relu: - swish_act = self.network.add_activation_layer("{}_relu".format(prefix_name), ff1, activation="relu") + swish_act = self.network.add_activation_layer( + "{}_relu".format(prefix_name), ff1, activation="relu" + ) swish_act = self.network.add_eval_layer( "{}_square_relu".format(prefix_name), swish_act, eval="source(0) ** 2" ) @@ -291,7 +310,9 @@ def _create_ff_module(self, prefix_name, i, source, layer_index): "{}_swish".format(prefix_name), ff1, activation=self.activation ) - drop1 = self.network.add_dropout_layer("{}_drop1".format(prefix_name), swish_act, dropout=self.dropout) + drop1 = self.network.add_dropout_layer( + "{}_drop1".format(prefix_name), swish_act, dropout=self.dropout + ) ff2 = self.network.add_linear_layer( "{}_ff2".format(prefix_name), @@ -303,19 +324,28 @@ def _create_ff_module(self, prefix_name, i, source, layer_index): param_dropout=self.ff_weight_drop, ) - drop2 = self.network.add_dropout_layer("{}_drop2".format(prefix_name), ff2, dropout=self.dropout) + drop2 = self.network.add_dropout_layer( + "{}_drop2".format(prefix_name), ff2, dropout=self.dropout + ) - half_step_ff = self.network.add_eval_layer("{}_half_step".format(prefix_name), drop2, eval="0.5 * source(0)") + half_step_ff = self.network.add_eval_layer( + "{}_half_step".format(prefix_name), drop2, eval="0.5 * source(0)" + ) res_inputs = [half_step_ff, source] ff_module_res = self.network.add_combine_layer( - "{}_res".format(prefix_name), kind="add", source=res_inputs, n_out=self.enc_key_dim + "{}_res".format(prefix_name), + kind="add", + source=res_inputs, + n_out=self.enc_key_dim, ) return ff_module_res - def _get_mem_chunks(self, prefix_name: str, input_layer: str, mem_size: int) -> List[Tuple[str, Union[str, Dim]]]: + def _get_mem_chunks( + self, prefix_name: str, input_layer: str, mem_size: int + ) -> List[Tuple[str, Union[str, Dim]]]: """ :param name: layer prefix name :param input_layer: name of input layer to shift of shape [B*C, W, D] @@ -340,14 +370,16 @@ def _get_mem_chunks(self, prefix_name: str, input_layer: str, mem_size: int) -> ) # [B, C, W, D] # Merge batch and chunk dim again. chunk_shifted = self.network.add_generic_layer( - f"{prefix_name}_chunk_shifted_" + (f"_{mem_idx}" if mem_idx > 0 else ""), + f"{prefix_name}_chunk_shifted_" + + (f"_{mem_idx}" if mem_idx > 0 else ""), cls="merge_dims", source=chunk_shifted, axes=("B", self.memory_variant_opts.chunked_time_dim), ) # [B*C, W, D] # Make sure the time_dim_axis (T) is set to the correct dim (W). chunk_shifted = self.network.add_generic_layer( - f"{prefix_name}_chunk_shifted__" + (f"_{mem_idx}" if mem_idx > 0 else ""), + f"{prefix_name}_chunk_shifted__" + + (f"_{mem_idx}" if mem_idx > 0 else ""), cls="reinterpret_data", source=chunk_shifted, set_axes={"T": "spatial"}, @@ -356,12 +388,15 @@ def _get_mem_chunks(self, prefix_name: str, input_layer: str, mem_size: int) -> if self.memory_variant_opts.mem_slice_start is not None: assert self.memory_variant_opts.mem_slice_size is not None chunk_shifted = self.network.add_generic_layer( - f"{prefix_name}_chunk_shifted__" + (f"_{mem_idx}" if mem_idx > 0 else "") + "_sliced", + f"{prefix_name}_chunk_shifted__" + + (f"_{mem_idx}" if mem_idx > 0 else "") + + "_sliced", cls="slice", source=chunk_shifted, axis="T", slice_start=self.memory_variant_opts.mem_slice_start, - slice_end=self.memory_variant_opts.mem_slice_start + self.memory_variant_opts.mem_slice_size, + slice_end=self.memory_variant_opts.mem_slice_start + + self.memory_variant_opts.mem_slice_size, ) mem_chunks.append((chunk_shifted, "T")) @@ -371,7 +406,12 @@ def _get_mem_chunks(self, prefix_name: str, input_layer: str, mem_size: int) -> return mem_chunks def _self_att_v2( - self, prefix_name: str, *, input_layer: str, concat_prev_chunks_inputs: str, layer_index: int + self, + prefix_name: str, + *, + input_layer: str, + concat_prev_chunks_inputs: str, + layer_index: int, ) -> str: """ Self-Attention implementation via RETURNN layers instead of using RETURNN SelfAttentionLayer @@ -382,12 +422,16 @@ def _self_att_v2( """ if self.memory_variant_opts.use_cached_prev_kv: - assert concat_prev_chunks_inputs is None, "Should use cached keys and values instead." + assert ( + concat_prev_chunks_inputs is None + ), "Should use cached keys and values instead." K = self.network.add_generic_layer( f"{prefix_name}_ln_K", cls="linear", - source=input_layer if self.memory_variant_opts.use_cached_prev_kv else concat_prev_chunks_inputs, + source=input_layer + if self.memory_variant_opts.use_cached_prev_kv + else concat_prev_chunks_inputs, n_out=self.enc_key_dim, forward_weights_init=self.mhsa_init, with_bias=False, @@ -397,7 +441,9 @@ def _self_att_v2( V = self.network.add_generic_layer( f"{prefix_name}_ln_V", cls="linear", - source=input_layer if self.memory_variant_opts.use_cached_prev_kv else concat_prev_chunks_inputs, + source=input_layer + if self.memory_variant_opts.use_cached_prev_kv + else concat_prev_chunks_inputs, n_out=self.enc_value_dim, forward_weights_init=self.mhsa_init, with_bias=False, @@ -415,7 +461,9 @@ def _self_att_v2( # C is approx 15-20. # Then we can concat it to K and V. # Note on prefix_name: The outer _create_mhsa_module adds the additional "_self_att" prefix. - mem_bank = self._block_prefix_name(layer_index - 1) + "_self_att_emformer_mem" # [B*C, D] + mem_bank = ( + self._block_prefix_name(layer_index - 1) + "_self_att_emformer_mem" + ) # [B*C, D] # Same projection which is usually applied to get back to the residual stream. mem_bank = self.network.add_generic_layer( @@ -424,7 +472,8 @@ def _self_att_v2( source=mem_bank, n_out=self.enc_key_dim, with_bias=False, - reuse_params=self._block_prefix_name(layer_index - 1) + "_self_att_linear", + reuse_params=self._block_prefix_name(layer_index - 1) + + "_self_att_linear", param_dropout=self.mhsa_weight_drop, ) # [B*C, D] mem_bank = self.network.add_dropout_layer( @@ -433,7 +482,10 @@ def _self_att_v2( if self.memory_variant_opts.apply_tanh_on_emformer_mem: mem_bank = self.network.add_generic_layer( - f"{prefix_name}_emformer_mem_tanh", cls="activation", source=mem_bank, activation="tanh" + f"{prefix_name}_emformer_mem_tanh", + cls="activation", + source=mem_bank, + activation="tanh", ) else: mem_bank = self.network.add_generic_layer( @@ -453,7 +505,12 @@ def _self_att_v2( f"{prefix_name}_emformer_mem_set_new_dim", cls="reinterpret_data", source=mem_bank, - set_dim_tags=[(self.memory_variant_opts.chunked_time_dim, self.emformer_mem_bank_dim)], + set_dim_tags=[ + ( + self.memory_variant_opts.chunked_time_dim, + self.emformer_mem_bank_dim, + ) + ], ) # [B, M, D] mem_bank_K = self.network.add_generic_layer( @@ -503,11 +560,15 @@ def _self_att_v2( else: mem_bank_K, mem_bank_V = None, None - kv_dim = self.concat_window_with_mem_dim if mem_bank_K else self.concat_window_dim # W*N [+M] + kv_dim = ( + self.concat_window_with_mem_dim if mem_bank_K else self.concat_window_dim + ) # W*N [+M] if self.memory_variant_opts.use_cached_prev_kv or mem_bank_K: # concat previous cached keys and values - concat_keys = self._get_mem_chunks(f"{prefix_name}_ln_K_", K, self.memory_variant_opts.mem_size) + concat_keys = self._get_mem_chunks( + f"{prefix_name}_ln_K_", K, self.memory_variant_opts.mem_size + ) concat_keys.append((K, "T")) if mem_bank_K: concat_keys.append((mem_bank_K, self.emformer_mem_bank_dim)) @@ -528,7 +589,9 @@ def _self_att_v2( ) # [B*C, W*N, H, D/H] if self.memory_variant_opts.use_cached_prev_kv or mem_bank_V: - concat_values = self._get_mem_chunks(f"{prefix_name}_ln_V_", V, self.memory_variant_opts.mem_size) + concat_values = self._get_mem_chunks( + f"{prefix_name}_ln_V_", V, self.memory_variant_opts.mem_size + ) concat_values.append((V, "T")) if mem_bank_V: concat_values.append((mem_bank_V, self.emformer_mem_bank_dim)) @@ -608,7 +671,10 @@ def _self_att_v2( dtype="float32", ) # [1] Q_energy_factor = self.network.add_generic_layer( - f"{prefix_name}_Q_energy_factor", cls="eval", source=dim_per_head_const, eval="source(0) ** -0.5" + f"{prefix_name}_Q_energy_factor", + cls="eval", + source=dim_per_head_const, + eval="source(0) ** -0.5", ) # [1] Q_H = self.network.add_generic_layer( f"{prefix_name}_ln_Q_H", @@ -642,14 +708,18 @@ def _self_att_v2( clipping=self.rel_pos_clipping, query_spatial_dim=query_dim, # W+1 or W key_value_spatial_dim=kv_dim, # W*N [+M] - query_offset=self.memory_variant_opts.chunk_size * self.memory_variant_opts.mem_size, + query_offset=self.memory_variant_opts.chunk_size + * self.memory_variant_opts.mem_size, ) # [queries (W [+1]), kvs (W*N [+M]), D/H] if self.memory_variant_opts.use_emformer_mem: # -> have summary, i.e. [W+1] mask_query = "emformer_mask_query_dim" if mask_query not in self.network: range_in_query_dim = self.network.add_generic_layer( - "emformer_range_query_dim", cls="range_in_axis", source=Q, axis=self.emformer_ext_query_dim + "emformer_range_query_dim", + cls="range_in_axis", + source=Q, + axis=self.emformer_ext_query_dim, ) # [W+1] mask_query = self.network.add_eval_layer( mask_query, @@ -669,9 +739,14 @@ def _self_att_v2( range_in_kv_dim = self.network.add_generic_layer( "emformer_range_kv_dim", cls="range_in_axis", source=K, axis=kv_dim ) # [W*N + M] - kv_dim_len = self.network.add_generic_layer("kv_dim_len", cls="length", source=K, axis=kv_dim) + kv_dim_len = self.network.add_generic_layer( + "kv_dim_len", cls="length", source=K, axis=kv_dim + ) mem_len = self.network.add_generic_layer( - "mem_len", cls="length", source=mem_bank_K, axis=self.emformer_mem_bank_dim + "mem_len", + cls="length", + source=mem_bank_K, + axis=self.emformer_mem_bank_dim, ) mask_kv = self.network.add_eval_layer( mask_kv, @@ -751,7 +826,10 @@ def _self_att_v2( # TODO: is this safe? find a better way set_axes={ "T": f"dim:" - + str(self.memory_variant_opts.chunk_size + (1 if self.memory_variant_opts.use_emformer_mem else 0)) + + str( + self.memory_variant_opts.chunk_size + + (1 if self.memory_variant_opts.use_emformer_mem else 0) + ) }, ) # [B*C, W [+1], D] @@ -805,7 +883,9 @@ def _create_mhsa_module(self, prefix_name, source, layer_index): if self.memory_variant_opts.use_cached_prev_kv is False: # shifted inputs + current chunk ln_concat_chunks = self._get_mem_chunks( - prefix_name=f"{prefix_name}_ln", input_layer=ln, mem_size=self.memory_variant_opts.mem_size + prefix_name=f"{prefix_name}_ln", + input_layer=ln, + mem_size=self.memory_variant_opts.mem_size, ) ln_concat_chunks += [(ln, "T")] ln_ = self.network.add_generic_layer( @@ -818,7 +898,9 @@ def _create_mhsa_module(self, prefix_name, source, layer_index): ln_ = None if self.memory_variant_opts.self_att_version == 0: - assert self.memory_variant_opts.use_cached_prev_kv is False, "Not implemented." + assert ( + self.memory_variant_opts.use_cached_prev_kv is False + ), "Not implemented." # this implementation is not efficient. ln_rel_pos_enc = self.network.add_relative_pos_encoding_layer( f"{prefix_name}_ln_rel_pos_enc", @@ -839,7 +921,9 @@ def _create_mhsa_module(self, prefix_name, source, layer_index): key_shift=ln_rel_pos_enc if ln_rel_pos_enc is not None else None, l2=self.self_att_l2, attention_left_only=self.use_causal_layers, - param_variational_noise=self.weight_noise if "mhsa" in self.weight_noise_layers else None, + param_variational_noise=self.weight_noise + if "mhsa" in self.weight_noise_layers + else None, param_dropout=self.mhsa_weight_drop, ) # [B*C, W*N, D] mhsa_splits = self.network.add_generic_layer( @@ -865,7 +949,10 @@ def _create_mhsa_module(self, prefix_name, source, layer_index): # - ln_ contains the cached keys and values only # - project only current chunk mhsa = self._self_att_v2( - prefix_name, input_layer=ln, concat_prev_chunks_inputs=ln_, layer_index=layer_index + prefix_name, + input_layer=ln, + concat_prev_chunks_inputs=ln_, + layer_index=layer_index, ) else: mhsa = self.network.add_self_att_layer( @@ -879,7 +966,9 @@ def _create_mhsa_module(self, prefix_name, source, layer_index): key_shift=ln_rel_pos_enc if ln_rel_pos_enc is not None else None, l2=self.self_att_l2, attention_left_only=self.use_causal_layers, - param_variational_noise=self.weight_noise if "mhsa" in self.weight_noise_layers else None, + param_variational_noise=self.weight_noise + if "mhsa" in self.weight_noise_layers + else None, param_dropout=self.mhsa_weight_drop, ) @@ -893,16 +982,23 @@ def _create_mhsa_module(self, prefix_name, source, layer_index): param_dropout=self.mhsa_weight_drop, ) - drop = self.network.add_dropout_layer("{}_dropout".format(prefix_name), mhsa_linear, dropout=self.dropout) + drop = self.network.add_dropout_layer( + "{}_dropout".format(prefix_name), mhsa_linear, dropout=self.dropout + ) res_inputs = [drop, source] mhsa_res = self.network.add_combine_layer( - "{}_res".format(prefix_name), kind="add", source=res_inputs, n_out=self.enc_value_dim + "{}_res".format(prefix_name), + kind="add", + source=res_inputs, + n_out=self.enc_value_dim, ) return mhsa_res - def _create_convolution_module(self, prefix_name, source, layer_index, half_step=False): + def _create_convolution_module( + self, prefix_name, source, layer_index, half_step=False + ): """ Add Convolution Module: LN + point-wise-conv + GLU + depth-wise-conv + BN + Swish + point-wise-conv + Dropout @@ -928,9 +1024,14 @@ def _create_convolution_module(self, prefix_name, source, layer_index, half_step param_dropout=self.conv_weight_drop, ) - glu_act = self.network.add_gating_layer("{}_glu".format(prefix_name), pointwise_conv1) + glu_act = self.network.add_gating_layer( + "{}_glu".format(prefix_name), pointwise_conv1 + ) - if self.memory_variant_opts is not None and self.memory_variant_opts.conv_cache_size: + if ( + self.memory_variant_opts is not None + and self.memory_variant_opts.conv_cache_size + ): mem_chunks = self._get_mem_chunks( prefix_name=f"{prefix_name}_glu_act", input_layer=glu_act, @@ -957,7 +1058,6 @@ def _create_convolution_module(self, prefix_name, source, layer_index, half_step padding=(self.conv_kernel_size - 1, 0), ) - depthwise_conv = self.network.add_conv_layer( prefix_name + "_" + (self.conv_alternative_name or "depthwise_conv2"), depthwise_conv_input_padded, @@ -990,26 +1090,36 @@ def _create_convolution_module(self, prefix_name, source, layer_index, half_step **conv_extra_kwargs, ) - if self.memory_variant_opts is not None and self.memory_variant_opts.conv_cache_size: + if ( + self.memory_variant_opts is not None + and self.memory_variant_opts.conv_cache_size + ): # we apply convolution over the concatenated chunks but we only need the output of the current # chunk, thus, we need to slice from [B*C, W*N, D] to [B*C, W, D] - assert self.memory_variant_opts.mem_slice_size, "mem_slice_size must be set." + assert ( + self.memory_variant_opts.mem_slice_size + ), "mem_slice_size must be set." depthwise_conv = self.network.add_generic_layer( f"{prefix_name}_depthwise_conv_slice", cls="slice", source=depthwise_conv, axis="T", - slice_start=self.memory_variant_opts.mem_slice_size * self.memory_variant_opts.conv_cache_size, + slice_start=self.memory_variant_opts.mem_slice_size + * self.memory_variant_opts.conv_cache_size, ) if self.use_ln: - bn = self.network.add_layer_norm_layer("{}_layer_norm".format(prefix_name), depthwise_conv) + bn = self.network.add_layer_norm_layer( + "{}_layer_norm".format(prefix_name), depthwise_conv + ) else: bn = self.network.add_batch_norm_layer( "{}_bn".format(prefix_name), depthwise_conv, opts=self.batch_norm_opts ) - swish_act = self.network.add_activation_layer("{}_swish".format(prefix_name), bn, activation="swish") + swish_act = self.network.add_activation_layer( + "{}_swish".format(prefix_name), bn, activation="swish" + ) pointwise_conv2 = self.network.add_linear_layer( "{}_pointwise_conv2".format(prefix_name), @@ -1022,22 +1132,32 @@ def _create_convolution_module(self, prefix_name, source, layer_index, half_step param_dropout=self.conv_weight_drop, ) - drop = self.network.add_dropout_layer("{}_drop".format(prefix_name), pointwise_conv2, dropout=self.dropout) + drop = self.network.add_dropout_layer( + "{}_drop".format(prefix_name), pointwise_conv2, dropout=self.dropout + ) if half_step: - drop = self.network.add_eval_layer("{}_half_step".format(prefix_name), drop, eval="0.5 * source(0)") + drop = self.network.add_eval_layer( + "{}_half_step".format(prefix_name), drop, eval="0.5 * source(0)" + ) res_inputs = [drop, source] res = self.network.add_combine_layer( - "{}_res".format(prefix_name), kind="add", source=res_inputs, n_out=self.enc_key_dim + "{}_res".format(prefix_name), + kind="add", + source=res_inputs, + n_out=self.enc_key_dim, ) return res def _block_prefix_name(self, layer_index: int) -> str: assert layer_index >= 1 if self.add_to_prefix_name: - prefix_name = "conformer_block_%s_%02i" % (self.add_to_prefix_name, layer_index) + prefix_name = "conformer_block_%s_%02i" % ( + self.add_to_prefix_name, + layer_index, + ) else: prefix_name = "conformer_block_%02i" % layer_index return prefix_name @@ -1074,7 +1194,9 @@ def _create_conformer_block(self, i, source): mhsa_input = conv_module1 mhsa = self._create_mhsa_module(prefix_name, mhsa_input, i) - conv_module = self._create_convolution_module(prefix_name, mhsa, i, half_step=self.sandwich_conv) + conv_module = self._create_convolution_module( + prefix_name, mhsa, i, half_step=self.sandwich_conv + ) ff_module2_input = conv_module ff_module2 = self._create_ff_module(prefix_name, 2, ff_module2_input, i) @@ -1085,7 +1207,9 @@ def _create_conformer_block(self, i, source): assert 0 <= i - 1 < len(self.subsample) subsample_factor = self.subsample_list[i - 1] if subsample_factor > 1: - res = self.network.add_pool_layer(res + "_pool{}".format(i), res, pool_size=(subsample_factor,)) + res = self.network.add_pool_layer( + res + "_pool{}".format(i), res, pool_size=(subsample_factor,) + ) res = self.network.add_copy_layer(prefix_name, res) return res @@ -1150,7 +1274,9 @@ def _create_all_network_parts(self): activation=self.input_layer_conv_act, init=self.start_conv_init, merge_out=False, - param_variational_noise=self.weight_noise if "frontend_conv" in self.weight_noise_layers else None, + param_variational_noise=self.weight_noise + if "frontend_conv" in self.weight_noise_layers + else None, ) subsampled_input = self.network.add_conv_block( @@ -1164,7 +1290,9 @@ def _create_all_network_parts(self): split_input=False, prefix_name="subsample_", merge_out_fixed=self.fix_merge_dims, - param_variational_noise=self.weight_noise if "frontend_conv" in self.weight_noise_layers else None, + param_variational_noise=self.weight_noise + if "frontend_conv" in self.weight_noise_layers + else None, ) elif self.input_layer == "conv-6": extra_conv_opts = {} @@ -1178,7 +1306,9 @@ def _create_all_network_parts(self): activation=self.input_layer_conv_act, init=self.start_conv_init, merge_out=False, - param_variational_noise=self.weight_noise if "frontend_conv" in self.weight_noise_layers else None, + param_variational_noise=self.weight_noise + if "frontend_conv" in self.weight_noise_layers + else None, extra_conv_opts=extra_conv_opts, ) @@ -1193,7 +1323,9 @@ def _create_all_network_parts(self): split_input=False, prefix_name="subsample_", merge_out_fixed=self.fix_merge_dims, - param_variational_noise=self.weight_noise if "frontend_conv" in self.weight_noise_layers else None, + param_variational_noise=self.weight_noise + if "frontend_conv" in self.weight_noise_layers + else None, extra_conv_opts=extra_conv_opts, ) @@ -1209,29 +1341,95 @@ def _create_all_network_parts(self): ) if self.add_abs_pos_enc_to_input: - source_linear = self.network.add_pos_encoding_layer("input_abs_pos_enc", source_linear, add_to_input=True) + source_linear = self.network.add_pos_encoding_layer( + "input_abs_pos_enc", source_linear, add_to_input=True + ) if self.dropout_in: - source_linear = self.network.add_dropout_layer("source_dropout", source_linear, dropout=self.dropout_in) + source_linear = self.network.add_dropout_layer( + "source_dropout", source_linear, dropout=self.dropout_in + ) conformer_block_src = source_linear for i in range(1, self.num_blocks + 1): conformer_block_src = self._create_conformer_block(i, conformer_block_src) - encoder = self.network.add_copy_layer(self.output_layer_name, conformer_block_src) + encoder = self.network.add_copy_layer( + self.output_layer_name, conformer_block_src + ) if self.with_ctc: default_ctc_loss_opts = {"beam_width": 1} if self.native_ctc: default_ctc_loss_opts["use_native"] = True else: - self.ctc_opts.update({"ignore_longer_outputs_than_inputs": True}) # always enable + self.ctc_opts.update( + {"ignore_longer_outputs_than_inputs": True} + ) # always enable if self.ctc_opts: default_ctc_loss_opts["ctc_opts"] = self.ctc_opts - if self.enc_layer_w_ctc is not None and self.enc_layer_w_ctc <= self.num_blocks: + if ( + self.enc_layer_w_ctc is not None + and self.enc_layer_w_ctc <= self.num_blocks + ): encoder = f"conformer_block_{self.enc_layer_w_ctc:02d}" + if self.ctc_att_weights_gauss: + + window_size = self.ctc_att_weights_gauss_window + gaussian_weights = [np.exp(-0.5 * ((i - window_size // 2) / self.ctc_att_weights_gauss_stddev) ** 2) for i in range(window_size)] + # normalize + gaussian_weights = list(np.array(gaussian_weights) / np.sum(gaussian_weights)) + + # gaussian_weights_code = "np.array(%r, dtype=np.float32)" % gaussian_weights + # gaussian_weights_value = CodeWrapper(gaussian_weights_code) + + gaussian_weights_value = CodeWrapper( + f"eval(\"exec('import numpy') or numpy.array({gaussian_weights}, dtype=numpy.float32)\")" + ) + + self.network.update( + { + # encoder [B,T,D] + "enc_win": {"class": "window", "from": encoder, "window_size": window_size}, # [B,T,W,D] + "gaussian_weights_1": { + "class": "constant", + "value": gaussian_weights_value, + "dtype": "float32", + }, + "enc_weighted_with_gaussian": { + "class": "combine", + "kind": "mul", + "from": ["enc_win", "gaussian_weights_1"], + }, + "enc_attention": { + "class": "eval", + "eval": "tf.reduce_sum(source(0, auto_convert=False), axis=-2)", + "from": "enc_weighted_with_gaussian", + "out_type": {"shape": (None, self.enc_key_dim), "dtype": "float32"}, + }, + # "enc_attention": { + # "class": "reduce", + # "mode": "sum", + # "from": "enc_weighted_with_gaussian", + # "axes": ["enc_win:window"], + # }, + "enc_with_attention": { + "class": "concat", + "from": [ + (encoder, "f"), + ("enc_attention", "f"), + ], + }, + } + ) + + if self.ctc_att_weights_use_enc: + encoder = "enc_with_attention" + else: + encoder = "enc_attention" + self.network.add_softmax_layer( "ctc", encoder, @@ -1243,13 +1441,21 @@ def _create_all_network_parts(self): ) if self.ctc_loss_scale or self.ctc_self_align_delay: self.network["ctc"]["loss_scale"] = (self.ctc_loss_scale or 1.0) * ( - (1.0 - self.ctc_self_align_scale) if self.ctc_self_align_delay else 1.0 + (1.0 - self.ctc_self_align_scale) + if self.ctc_self_align_delay + else 1.0 ) if self.ctc_self_align_delay: # http://arxiv.org/abs/2105.05005 - assert self.ctc_self_align_delay > 0 # not implemented otherwise, but also not sure if meaningful - self.network["ctc_log_prob"] = {"class": "activation", "from": "ctc", "activation": "safe_log"} + assert ( + self.ctc_self_align_delay > 0 + ) # not implemented otherwise, but also not sure if meaningful + self.network["ctc_log_prob"] = { + "class": "activation", + "from": "ctc", + "activation": "safe_log", + } # Cut off first N frames. self.network[f"ctc_log_prob_slice{self.ctc_self_align_delay}"] = { "class": "slice", @@ -1258,7 +1464,9 @@ def _create_all_network_parts(self): "slice_start": self.ctc_self_align_delay, } # Forced alignment using that. - self.network[f"ctc_forced_alignment_slice{self.ctc_self_align_delay}"] = { + self.network[ + f"ctc_forced_alignment_slice{self.ctc_self_align_delay}" + ] = { "class": "forced_align", "align_target": f"data:{self.target}", "topology": "ctc", @@ -1272,7 +1480,9 @@ def _create_all_network_parts(self): "axis": "sparse_dim", "sparse": True, } - self.network[f"ctc_forced_alignment_shift{self.ctc_self_align_delay}"] = { + self.network[ + f"ctc_forced_alignment_shift{self.ctc_self_align_delay}" + ] = { "class": "postfix_in_time", "from": f"ctc_forced_alignment_slice{self.ctc_self_align_delay}", "postfix": "_blank_idx", @@ -1283,7 +1493,8 @@ def _create_all_network_parts(self): "class": "copy", "from": "ctc", "loss": "ce", - "loss_scale": (self.ctc_loss_scale or 1.0) * self.ctc_self_align_scale, + "loss_scale": (self.ctc_loss_scale or 1.0) + * self.ctc_self_align_scale, "target": f"layer:ctc_forced_alignment_shift{self.ctc_self_align_delay}", } @@ -1292,13 +1503,19 @@ def _create_all_network_parts(self): def _create_conformer_blocks(self, input): if self.proj_input: conformer_block_src = self.network.add_linear_layer( - "encoder_proj", input, n_out=self.enc_key_dim, activation=None, with_bias=False + "encoder_proj", + input, + n_out=self.enc_key_dim, + activation=None, + with_bias=False, ) else: conformer_block_src = input for i in range(1, self.num_blocks + 1): conformer_block_src = self._create_conformer_block(i, conformer_block_src) - encoder = self.network.add_copy_layer(self.output_layer_name, conformer_block_src) + encoder = self.network.add_copy_layer( + self.output_layer_name, conformer_block_src + ) return encoder def create_network(self): @@ -1344,7 +1561,9 @@ def _energy_mask_emformer_mem( chunk_size_dim # unused # noqa - energy_data: Tensor = source(0, as_data=True) # [B*C, H, W*N+M, W+1], M=C, dims not necessarily that order + energy_data: Tensor = source( + 0, as_data=True + ) # [B*C, H, W*N+M, W+1], M=C, dims not necessarily that order assert len(energy_data.batch.virtual_dims) == 2 batch_virtual_dim0, batch_virtual_dim1 = energy_data.batch.virtual_dims @@ -1361,8 +1580,16 @@ def _energy_mask_emformer_mem( continue energy_dims.append(d) energy_shape.append(d.get_dim_value()) - energy: tf.Tensor = tf.reshape(energy_data.raw_tensor, energy_shape) # [B, C, H, W*N [+M], W+1] - assert set(energy_dims) == {batch_dim, chunked_time_dim, att_num_heads_dim, query_dim, kv_dim} + energy: tf.Tensor = tf.reshape( + energy_data.raw_tensor, energy_shape + ) # [B, C, H, W*N [+M], W+1] + assert set(energy_dims) == { + batch_dim, + chunked_time_dim, + att_num_heads_dim, + query_dim, + kv_dim, + } assert len(energy_dims) == len(energy_shape) == energy.shape.rank == 5 def _bc_shape(d_: Dim): @@ -1391,7 +1618,9 @@ def _bc_shape(d_: Dim): mask = mask0 & mask1 # [..C.., ..W+1.., ..W*N+M..] energy = tf.where(mask, energy, neg_inf) - energy = tf.reshape(energy, [d.get_dim_value() for d in energy_data.dims]) # [B*C, H, W*N+M, W+1] + energy = tf.reshape( + energy, [d.get_dim_value() for d in energy_data.dims] + ) # [B*C, H, W*N+M, W+1] if numpy.isinf(neg_inf): self.allow_inf_in_output = True return energy From c4ebf74cdb711e183378635c7c10d21e61c1fb72 Mon Sep 17 00:00:00 2001 From: "luca.gaudino" Date: Fri, 31 May 2024 12:11:20 +0200 Subject: [PATCH 076/227] convert ls960 LSTM LM to rf --- .../tedlium2/_import_model.py | 143 +++++++++++++++++- 1 file changed, 136 insertions(+), 7 deletions(-) diff --git a/users/gaudino/experiments/rf_conformer_att_2023/tedlium2/_import_model.py b/users/gaudino/experiments/rf_conformer_att_2023/tedlium2/_import_model.py index 2d63bc745..8bace5db2 100644 --- a/users/gaudino/experiments/rf_conformer_att_2023/tedlium2/_import_model.py +++ b/users/gaudino/experiments/rf_conformer_att_2023/tedlium2/_import_model.py @@ -24,6 +24,10 @@ MakeModel as MakeModelLM, ) +from i6_experiments.users.gaudino.models.asr.rf.nn_lm.lm_import_2023_09_03 import ( + MakeModel as MakeModelLSTMLM, +) + from i6_experiments.users.gaudino.models.asr.rf.ilm_import_2024_04_17 import ( MakeModel as MakeModelILM, ) @@ -32,7 +36,7 @@ from itertools import product - +_lstm_lm_path = "/work/asr3/irie/experiments/lm/librispeech/2018-03-05--lmbpe-zeyer/data-train/re_i128_m2048_m2048_m2048_m2048.sgd_b32_lr0_cl2.newbobabs.d0.0.1350/bk-net-model/network.035" _returnn_tf_ckpt_filename = "/work/asr4/zeineldeen/setups-data/ubuntu_22_setups/2023-04-17--conformer-att/work/i6_core/returnn/training/AverageTFCheckpointsJob.yB4JK4GDCxWG/output/model/average" _ted2_lm_ckpt_filename = "/work/asr4/michel/setups-data/language_modelling/tedlium/neurallm/trafo_kazuki19/net-model/network.020" @@ -210,6 +214,47 @@ def convert_lm(ckpt_path_lm, out_dir, model_target_dim, model_args): {"model": pt_model.state_dict(), "epoch": epoch, "step": step}, filename ) +def convert_lstm_lm(ckpt_path_lm, out_dir, model_target_dim): + from tensorflow.python.training.py_checkpoint_reader import CheckpointReader + from returnn.torch.frontend.bridge import rf_module_to_pt_module + + print("Loading checkpoint...") + reader_lm = CheckpointReader(ckpt_path_lm) + + print("Creating model...") + rf.select_backend_torch() + model = MakeModelLSTMLM(model_target_dim, model_target_dim)() + + print("Create ParamMapping...") + param_mapping = {} + _add_params_lstm_lm(param_mapping) + + print("Mapping parameters...") + for name, param in model.named_parameters(): + assert isinstance(name, str) + assert isinstance(param, rf.Parameter) + value = map_param_func_lstm(reader_lm, name, param, param_mapping) + + assert isinstance(value, numpy.ndarray) + # noinspection PyProtectedMember + param._raw_backend.set_parameter_initial_value(param, value) + + epoch = 1 + step = 0 + + print("Converting rf module to pt module...") + ckpt_name = os.path.basename(ckpt_path_lm) + pt_model = rf_module_to_pt_module(model) + + save_model = True + if save_model: + os.makedirs(out_dir, exist_ok=True) + filename = out_dir + "/" + ckpt_name + ".pt" + print(f"Saving PyTorch model checkpoint: {filename}") + torch.save( + {"model": pt_model.state_dict(), "epoch": epoch, "step": step}, filename + ) + def convert_mini_att_ilm(ckpt_path_mini_att, ckpt_path_prior, model_in_dim, model_target_dim, out_dir): from tensorflow.python.training.py_checkpoint_reader import CheckpointReader from returnn.torch.frontend.bridge import rf_module_to_pt_module @@ -298,6 +343,26 @@ def _add_params_trafo_lm(param_mapping: Dict[str, str]): } ) +def _add_params_lstm_lm(param_mapping: Dict[str, str]): + # add params of lstm lm + for layer_idx in range(4): + param_mapping.update( + { + f"lstm_{layer_idx}.ff_weight": f"lstm{layer_idx}/rec/W", + f"lstm_{layer_idx}.rec_weight": f"lstm{layer_idx}/rec/W_re", + f"lstm_{layer_idx}.bias": f"lstm{layer_idx}/rec/b", + } + ) + + param_mapping.update( + { + "input.weight": "input/W", + "input_bias": "input/b", + "output.weight": "output/W", + "output.bias": "output/b", + } + ) + def _add_params_mini_att_ilm(param_mapping: Dict[str, str]): # rf -> tf param_mapping.update( @@ -532,6 +597,62 @@ def map_param_func_trafo_lm( raise NotImplementedError(f"cannot map {name!r} {var}") +def map_param_func_lstm(reader, name: str, var: rf.Parameter, param_mapping: Dict[str, str]) -> numpy.ndarray: + """map params, TF to RF""" + from tensorflow.python.training.py_checkpoint_reader import CheckpointReader + from i6_experiments.users.gaudino.convert import ( + convert_params, + ) + from i6_experiments.users.zeyer.returnn.convert.params import ( + tf_to_rf_np as convert_params_tf_to_rf_np, + ) + + assert isinstance(reader, CheckpointReader) + assert isinstance(var, rf.Parameter) + + tf_var_name = name.replace(".", "/") + if reader.has_tensor(tf_var_name): + return reader.get_tensor(tf_var_name) + + if name in param_mapping: + var_name = param_mapping[name] + assert reader.has_tensor(var_name) + value = reader.get_tensor(var_name) + assert isinstance(value, numpy.ndarray) + + if name.endswith(".ff_weight"): + print("Old ff:", value[0][0], value[0][2048], value[0][4096], value[0][6144]) + value = convert_params.convert_tf_lstm_to_torch_lstm_ff(value) + print("Convert ff:", value[0][0], value[2048][0], value[4096][0], value[6144][0]) + + if name.endswith(".rec_weight"): + print("Old rec:", value[0][0], value[0][2048], value[0][4096], value[0][6144]) + value = convert_params.convert_tf_lstm_to_torch_lstm_rec(value) + print("Convert rec:", value[0][0], value[2048][0], value[4096][0], value[6144][0]) + + + if "lstm" in name and name.endswith(".bias"): + print("Old bias:", value[0], value[2048], value[4096], value[6144]) + value = convert_params.convert_tf_lstm_to_torch_lstm_bias( + value + ) + print("Convert bias:", value[0], value[2048], value[4096], value[6144]) + + + if (name == "output.weight"): + # value = convert_params_np.convert_tf_lstm_to_native_lstm_ff(value) + value = value.transpose() + + assert ( + value.shape == var.batch_shape + ), f"new param {name} {var.batch_shape} vs ckpt param {var_name} {value.shape}" + assert ( + value.dtype.name == var.dtype + ), f"new param {name} {var.dtype} vs ckpt param {var_name} {value.dtype}" + return value + + raise NotImplementedError(f"cannot map {name!r} {var}") + def map_param_func_mini_att_ilm( reader, name: str, var: rf.Parameter, param_mapping: Dict[str, str] ) -> numpy.ndarray: @@ -673,10 +794,18 @@ def import_models(): # ) # ls960 ILM - convert_mini_att_ilm( - ckpt_path_prior="/u/zeineldeen/setups/ubuntu_22_setups/2023-04-17--conformer-att/work/i6_core/returnn/training/AverageTFCheckpointsJob.BxqgICRSGkgb/output/model/average", - ckpt_path_mini_att="/u/zeineldeen/setups/ubuntu_22_setups/2023-04-17--conformer-att/work/i6_core/returnn/training/GetBestTFCheckpointJob.JLwxrydala1K/output/model/checkpoint", - model_in_dim=640, - model_target_dim=10025, - out_dir="/work/asr3/zeineldeen/hiwis/luca.gaudino/setups-data/2023-08-10--rf-librispeech/work/i6_experiments/users/gaudino/returnn/convert_ckpt_rf/librispeech/mini_att_ilm_24_05_28", + # convert_mini_att_ilm( + # ckpt_path_prior="/u/zeineldeen/setups/ubuntu_22_setups/2023-04-17--conformer-att/work/i6_core/returnn/training/AverageTFCheckpointsJob.BxqgICRSGkgb/output/model/average", + # ckpt_path_mini_att="/u/zeineldeen/setups/ubuntu_22_setups/2023-04-17--conformer-att/work/i6_core/returnn/training/GetBestTFCheckpointJob.JLwxrydala1K/output/model/checkpoint", + # model_in_dim=640, + # model_target_dim=10025, + # out_dir="/work/asr3/zeineldeen/hiwis/luca.gaudino/setups-data/2023-08-10--rf-librispeech/work/i6_experiments/users/gaudino/returnn/convert_ckpt_rf/librispeech/mini_att_ilm_24_05_28", + # ) + + # ls960 LSTM LM + convert_lstm_lm( + _lstm_lm_path, + "/work/asr3/zeineldeen/hiwis/luca.gaudino/setups-data/2023-08-10--rf-librispeech/work/i6_experiments/users/gaudino/returnn/convert_ckpt_rf/librispeech/lstm_lm_only_24_05_31", + 10025, ) + From 3f38be97cf4682c38d482f819f29344de4be1107 Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Fri, 31 May 2024 11:03:58 -0400 Subject: [PATCH 077/227] fix --- users/zeineldeen/data_aug/speed_perturbation_generic.py | 1 + 1 file changed, 1 insertion(+) diff --git a/users/zeineldeen/data_aug/speed_perturbation_generic.py b/users/zeineldeen/data_aug/speed_perturbation_generic.py index 7670427ae..97dcb3c50 100644 --- a/users/zeineldeen/data_aug/speed_perturbation_generic.py +++ b/users/zeineldeen/data_aug/speed_perturbation_generic.py @@ -8,6 +8,7 @@ def speed_pert(audio, sample_rate, random_state, min_factor={min_factor}, max_fa """ speed_pert_v2 = """ +import numpy def speed_pert(audio, sample_rate={sample_rate}, min_factor={min_factor}, max_factor={max_factor}, step={step}, random_state=numpy.random.RandomState(1)): import librosa From 2e333edb12a1cb2bdcb80bead30097dabba27a06 Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Fri, 31 May 2024 11:04:30 -0400 Subject: [PATCH 078/227] fix --- .../conformer_att_2022/librispeech_960/attention_asr_config.py | 1 - 1 file changed, 1 deletion(-) diff --git a/users/zeineldeen/experiments/conformer_att_2022/librispeech_960/attention_asr_config.py b/users/zeineldeen/experiments/conformer_att_2022/librispeech_960/attention_asr_config.py index d16556709..0630cbd43 100644 --- a/users/zeineldeen/experiments/conformer_att_2022/librispeech_960/attention_asr_config.py +++ b/users/zeineldeen/experiments/conformer_att_2022/librispeech_960/attention_asr_config.py @@ -686,7 +686,6 @@ def create_config( assert "sample_rate" in speed_pert_version speed_pert_generic_str = data_aug.speed_pert_generic_v2 assert isinstance(speed_pert_generic_str, str) - python_prolog += ["import numpy\n\n"] python_prolog += [speed_pert_generic_str.format(**speed_pert_version)] else: raise ValueError("Invalid speed_pert_version") From 455fc74d6c7fa317965446ea1a8573dcecbaccca Mon Sep 17 00:00:00 2001 From: mmz33 Date: Fri, 31 May 2024 11:17:11 -0400 Subject: [PATCH 079/227] fix --- users/zeineldeen/data_aug/speed_perturbation_generic.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/users/zeineldeen/data_aug/speed_perturbation_generic.py b/users/zeineldeen/data_aug/speed_perturbation_generic.py index 97dcb3c50..452df93ee 100644 --- a/users/zeineldeen/data_aug/speed_perturbation_generic.py +++ b/users/zeineldeen/data_aug/speed_perturbation_generic.py @@ -11,7 +11,7 @@ def speed_pert(audio, sample_rate, random_state, min_factor={min_factor}, max_fa import numpy def speed_pert(audio, sample_rate={sample_rate}, min_factor={min_factor}, max_factor={max_factor}, step={step}, random_state=numpy.random.RandomState(1)): import librosa - + new_sample_rate = int(sample_rate * (1 + random_state.randint(min_factor, max_factor) * step)) if new_sample_rate != sample_rate: audio = librosa.resample(audio, orig_sr=sample_rate, target_sr=new_sample_rate, res_type="kaiser_fast", axis=0) From e8460cfa9a72585802cfcbec10c0282edda217aa Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Fri, 31 May 2024 10:40:56 +0200 Subject: [PATCH 080/227] more --- users/zeyer/experiments/exp2024_04_23_baselines/aed.py | 6 +++--- users/zeyer/experiments/exp2024_04_23_baselines/ctc.py | 6 +++--- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/users/zeyer/experiments/exp2024_04_23_baselines/aed.py b/users/zeyer/experiments/exp2024_04_23_baselines/aed.py index 115e4f2c9..59572b25a 100644 --- a/users/zeyer/experiments/exp2024_04_23_baselines/aed.py +++ b/users/zeyer/experiments/exp2024_04_23_baselines/aed.py @@ -71,7 +71,7 @@ def py(): for vocab in [ "bpe10k", # 5.32 "spm10k", # 5.16 - "spm_bpe10k", + "spm_bpe10k", # 5.21 ]: train_exp( # 5.16 f"v6-bhv20-11gb-f32-bs15k-accgrad1-mgpu4-pavg100-wd1e_2-lrlin1e_5_295k-speedpertV2-{vocab}", @@ -93,9 +93,9 @@ def py(): 0.5, # 5.13 0.6, # 5.13 0.7, # 4.98 (!!) - 0.8, + 0.8, # 5.14 0.9, # 5.18 - 1.0, # sanity check + 1.0, # 5.35. sanity check, should be like baseline (5.16), could be attributed to randomness? ]: train_exp( f"v6-bhv20-11gb-f32-bs15k-accgrad1-mgpu4-pavg100-wd1e_2-lrlin1e_5_295k-speedpertV2-spm10k" diff --git a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py index d295ba6e4..c2b4f3faa 100644 --- a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py +++ b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py @@ -47,7 +47,7 @@ def py(): }, ) - train_exp( + train_exp( # 8.79 f"v6-bhv20-11gb-f32-bs15k-accgrad1-mgpu4-pavg100-wd1e_4-lrlin1e_5_295k-speedpertV2-bpe10k", config_11gb_v6_f32_accgrad1_mgpu4_pavg100_wd1e_4, config_updates={ @@ -63,7 +63,7 @@ def py(): "spm10k", # 8.12 "spm_bpe10k", # 7.97 "spm4k", # 9.86 - "spm1k", + "spm1k", # 12.72 "spm_bpe1k", # 11.76 ]: train_exp( # 8.23 @@ -80,7 +80,7 @@ def py(): for alpha in [ 0.3, # 7.88 - 0.5, + 0.5, # 7.13 0.7, # 6.99 ]: train_exp( From ba8163bf89a9c94c1cd8bd1af3777c12ac6d4f26 Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Sat, 1 Jun 2024 12:14:11 +0200 Subject: [PATCH 081/227] more --- .../exp2024_04_23_baselines/ctc.py | 34 +++++++++++++++++++ 1 file changed, 34 insertions(+) diff --git a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py index c2b4f3faa..50f4a4148 100644 --- a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py +++ b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py @@ -30,7 +30,41 @@ def py(): + """Sisyphus entry point""" + """ + Luca: + + CTC, greedy decoding ohne lm. + Habe eigentlich nicht wirklich was gemacht. Ist genau dein setup ohne die attention. + Model definition: i6_experiments/users/gaudino/models/asr/rf/conformer_ctc/model_conformer_ctc.py + Decoding: i6_experiments/users/gaudino/models/asr/rf/conformer_ctc/model_recog_ctc_greedy.py + Sis config: i6_experiments/users/gaudino/experiments/rf_conformer_rnnt_2024/librispeech_960/conformer_ctc_train.py + Experiment name: base-24gb-lrlin1e_5_600k_ctc_only_aux4_8 + Sis work dir: /u/luca.gaudino/setups/2023-08-10--rf-librispeech/alias/librispeech_960_exp2024_05_13_rf/conformer_ctc_train/base-24gb-lrlin1e_5_600k_ctc_only_aux4_8/train + Bekomme: {"dev-clean": 3.08, "dev-other": 6.93, "test-clean": 3.24, "test-other": 7.18} + + No diffs: + - Same oggzip files + - Same BPE vocab + Diffs: + - Luca has "seq_postfix": [0]? + - Luca uses single 24GB GPU, bfloat16 AMP + - Luca uses larger batch 2_400_000 -> 6_400_000, grad accum 1 -> 2 + - Luca uses wd 1e-06 + - Luca uses older behavior_version 21 -> 16. + """ + train_exp( + f"v6-bhv20-11gb-f32-bs15k-accgrad5-mgpu4-pavg100-wd1e_5-lrlin1e_5_295k-bpe10k", + config_11gb_v6_f32_accgrad1_mgpu4_pavg100_wd1e_4, + config_updates={ + **_get_cfg_lrlin_oclr_by_bs_nep(15_000, 500), + "accum_grad_multiple_step": 5, + "optimizer.weight_decay": 1e-5, + }, + ) + + train_exp( # 9.24 f"v6-bhv20-11gb-f32-bs15k-accgrad1-mgpu4-pavg100-wd1e_4-lrlin1e_5_295k-bpe10k", config_11gb_v6_f32_accgrad1_mgpu4_pavg100_wd1e_4, config_updates={ From c2c44ab3214d5cfa01d694e30feeef5cf801ae1f Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Sat, 1 Jun 2024 12:26:02 +0200 Subject: [PATCH 082/227] use_eos_postfix --- .../exp2024_04_23_baselines/ctc.py | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) diff --git a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py index 50f4a4148..b75c73519 100644 --- a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py +++ b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py @@ -134,6 +134,20 @@ def py(): # v6-bhv20-11gb-f32-bs15k-accgrad1-mgpu4-pavg100-wd1e_2-lrlin1e_5_295k-speedpertV2 # with spm_bpe10k and enable_sampling, alpha in {0.3, 0.7} was both very bad (90% WER). + train_exp( + "v6-bhv20-11gb-f32-bs15k-accgrad1-mgpu4-pavg100-wd1e_2-lrlin1e_5_295k-speedpertV2-spm10k-eos-spmSample07", + config_11gb_v6_f32_accgrad1_mgpu4_pavg100_wd1e_4, + config_updates={ + **_get_cfg_lrlin_oclr_by_bs_nep(15_000, 500), + "optimizer.weight_decay": 1e-2, + "__train_audio_preprocess": speed_pert_librosa_config, + "speed_pert_discrete_values": [0.7, 0.8, 0.9, 1.0, 1.1], + "use_eos_postfix": True, + }, + vocab="spm10k", + train_vocab_opts={"other_opts": {"enable_sampling": True, "alpha": 0.7}}, + ) + # noinspection PyShadowingNames def train_exp( @@ -296,6 +310,11 @@ def ctc_training(*, model: Model, data: rf.Tensor, data_spatial_dim: Dim, target data = rf.squeeze(data, axis=data.feature_dim) assert not data.feature_dim # raw audio + if config.bool("use_eos_postfix", False): + targets, (targets_spatial_dim,) = rf.pad( + targets, axes=[targets_spatial_dim], padding=[(0, 1)], value=model.eos_idx + ) + collected_outputs = {} logits, enc_spatial_dim = model(data, in_spatial_dim=data_spatial_dim, collected_outputs=collected_outputs) if aux_loss_layers: From 28e052c60c8802ebbafe26729d0dd7b8ff67c262 Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Sun, 2 Jun 2024 01:57:21 +0200 Subject: [PATCH 083/227] fix CTC with EOS recog scoring --- .../experiments/exp2024_04_23_baselines/ctc.py | 16 +++++++++++++++- users/zeyer/recog.py | 10 +++++++++- 2 files changed, 24 insertions(+), 2 deletions(-) diff --git a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py index b75c73519..d187ba7bf 100644 --- a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py +++ b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py @@ -23,6 +23,7 @@ if TYPE_CHECKING: from i6_experiments.users.zeyer.model_with_checkpoints import ModelWithCheckpoints, ModelWithCheckpoint from i6_experiments.users.zeyer.datasets.task import Task + from i6_experiments.users.zeyer.datasets.score_results import RecogOutput # The model gets raw features (16khz) and does feature extraction internally. @@ -211,11 +212,24 @@ def train_exp( distributed_launch_cmd="torchrun" if num_processes else None, time_rqmt=time_rqmt, ) - recog_training_exp(prefix, task, model_with_checkpoint, recog_def=model_recog) + + recog_post_proc_funcs = [] + if config.get("use_eos_postfix", False): + recog_post_proc_funcs.append(_remove_eos_label) + recog_training_exp( + prefix, task, model_with_checkpoint, recog_def=model_recog, recog_post_proc_funcs=recog_post_proc_funcs + ) return model_with_checkpoint +def _remove_eos_label(res: RecogOutput) -> RecogOutput: + from i6_experiments.users.zeyer.datasets.score_results import RecogOutput + from i6_core.returnn.search import SearchRemoveLabelJob + + return RecogOutput(SearchRemoveLabelJob(res.output, remove_label="", output_gzip=True).out_search_results) + + _sis_prefix: Optional[str] = None diff --git a/users/zeyer/recog.py b/users/zeyer/recog.py index 6f4ee8d81..ae83407ee 100644 --- a/users/zeyer/recog.py +++ b/users/zeyer/recog.py @@ -39,6 +39,7 @@ def recog_training_exp( *, search_config: Dict[str, Any] = None, search_post_config: Optional[Dict[str, Any]] = None, + recog_post_proc_funcs: Sequence[Callable[[RecogOutput], RecogOutput]] = (), search_mem_rqmt: Union[int, float] = 6, exclude_epochs: Collection[int] = (), model_avg: bool = False, @@ -51,6 +52,7 @@ def recog_training_exp( recog_def, search_config=search_config, search_post_config=search_post_config, + recog_post_proc_funcs=recog_post_proc_funcs, search_mem_rqmt=search_mem_rqmt, ) summarize_job = GetBestRecogTrainExp( @@ -79,6 +81,7 @@ def __init__( *, search_config: Optional[Dict[str, Any]] = None, search_post_config: Optional[Dict[str, Any]] = None, + recog_post_proc_funcs: Sequence[Callable[[RecogOutput], RecogOutput]] = (), search_mem_rqmt: Union[int, float] = 6, ): # Note: When something is added here, remember to handle it in _sis_hash. @@ -88,6 +91,7 @@ def __init__( self.recog_def = recog_def self.search_config = search_config self.search_post_config = search_post_config + self.recog_post_proc_funcs = recog_post_proc_funcs self.search_mem_rqmt = search_mem_rqmt def __call__(self, epoch_or_ckpt: Union[int, PtCheckpoint]) -> ScoreResultCollection: @@ -103,6 +107,7 @@ def __call__(self, epoch_or_ckpt: Union[int, PtCheckpoint]) -> ScoreResultCollec self.recog_def, config=self.search_config, search_post_config=self.search_post_config, + recog_post_proc_funcs=self.recog_post_proc_funcs, search_mem_rqmt=self.search_mem_rqmt, ) if isinstance(epoch_or_ckpt, int): @@ -119,6 +124,8 @@ def _sis_hash(self) -> bytes: del d["search_mem_rqmt"] if not self.search_config: del d["search_config"] # compat + if not self.recog_post_proc_funcs: + del d["recog_post_proc_funcs"] # compat # Not the whole task object is relevant but only some minimal parts. task = d.pop("task") assert isinstance(task, Task) @@ -135,6 +142,7 @@ def recog_model( *, config: Optional[Dict[str, Any]] = None, search_post_config: Optional[Dict[str, Any]] = None, + recog_post_proc_funcs: Sequence[Callable[[RecogOutput], RecogOutput]] = (), search_mem_rqmt: Union[int, float] = 6, search_rqmt: Optional[Dict[str, Any]] = None, dev_sets: Optional[Collection[str]] = None, @@ -157,7 +165,7 @@ def recog_model( search_mem_rqmt=search_mem_rqmt, search_rqmt=search_rqmt, search_alias_name=f"{name}/search/{dataset_name}" if name else None, - recog_post_proc_funcs=task.recog_post_proc_funcs, + recog_post_proc_funcs=list(recog_post_proc_funcs) + list(task.recog_post_proc_funcs), ) score_out = task.score_recog_output_func(dataset, recog_out) outputs[dataset_name] = score_out From b1077e9f967cfab36712cfd7e2f1a93fa253cce8 Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Sun, 2 Jun 2024 02:31:59 +0200 Subject: [PATCH 084/227] ctc eos fix more --- users/zeyer/experiments/exp2024_04_23_baselines/ctc.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py index d187ba7bf..265ed9c17 100644 --- a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py +++ b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py @@ -215,7 +215,7 @@ def train_exp( recog_post_proc_funcs = [] if config.get("use_eos_postfix", False): - recog_post_proc_funcs.append(_remove_eos_label) + recog_post_proc_funcs.append(_remove_eos_label_v2) recog_training_exp( prefix, task, model_with_checkpoint, recog_def=model_recog, recog_post_proc_funcs=recog_post_proc_funcs ) @@ -223,11 +223,11 @@ def train_exp( return model_with_checkpoint -def _remove_eos_label(res: RecogOutput) -> RecogOutput: +def _remove_eos_label_v2(res: RecogOutput) -> RecogOutput: from i6_experiments.users.zeyer.datasets.score_results import RecogOutput from i6_core.returnn.search import SearchRemoveLabelJob - return RecogOutput(SearchRemoveLabelJob(res.output, remove_label="", output_gzip=True).out_search_results) + return RecogOutput(SearchRemoveLabelJob(res.output, remove_label="", output_gzip=True).out_search_results) _sis_prefix: Optional[str] = None From b2349a2238d5f891340c698093c71130b645868a Mon Sep 17 00:00:00 2001 From: "luca.gaudino" Date: Mon, 3 Jun 2024 12:11:43 +0200 Subject: [PATCH 085/227] update --- .../librispeech_960/configs/ctc_att_search.py | 52 +++++++++++++++---- .../configs/ctc_att_search_w_recombine.py | 14 +++-- 2 files changed, 48 insertions(+), 18 deletions(-) diff --git a/users/gaudino/experiments/conformer_att_2023/librispeech_960/configs/ctc_att_search.py b/users/gaudino/experiments/conformer_att_2023/librispeech_960/configs/ctc_att_search.py index ac85a50ee..6279e386b 100644 --- a/users/gaudino/experiments/conformer_att_2023/librispeech_960/configs/ctc_att_search.py +++ b/users/gaudino/experiments/conformer_att_2023/librispeech_960/configs/ctc_att_search.py @@ -366,6 +366,8 @@ def run_lm_fusion( test_dataset_tuples = get_test_dataset_tuples(bpe_size=bpe_size) + use_sclite = kwargs.get("use_sclite", False) + run_single_search( exp_name=name, train_data=train_data, @@ -380,6 +382,8 @@ def run_lm_fusion( att_scale=kwargs.get("att_scale", 1.0), ctc_scale=kwargs.get("ctc_scale", 1.0), ctc_prior_scale=kwargs.get("ctc_prior_scale", None), + use_sclite=use_sclite, + ) def run_decoding( @@ -883,7 +887,8 @@ def train_mini_self_att( ) prior_args = copy.deepcopy(retrain_args) - prior_args["decoder_args"] = CTCDecoderArgs(hash_override_version=1) + # prior_args["decoder_args"] = CTCDecoderArgs(hash_override_version=1) + prior_args["decoder_args"] = CTCDecoderArgs() prior_file = compute_ctc_prior( name + f"_retrain1_const20_linDecay580_{1e-4}", prior_args, @@ -969,7 +974,7 @@ def train_mini_self_att( ) # two pass rescoring att,ctc - for beam_size in [12]: + for beam_size in []: #12 for ctc_scale in [0.01]: att_scale = 1.0 run_decoding( @@ -991,7 +996,7 @@ def train_mini_self_att( ) # optsnr att + ctc - for beam_size, scales, prior_scale in product([32], [(0.65, 0.35)], [0.0, 0.3]): + for beam_size, scales, prior_scale in product([], [(0.65, 0.35)], [0.0, 0.3]): # 32 search_args = copy.deepcopy(oclr_args) search_args["beam_size"] = beam_size search_args["ctc_log_prior_file"] = new_prior_file @@ -1062,7 +1067,7 @@ def train_mini_self_att( # att + lstm lm - for beam_size in [24]: + for beam_size in []: # 24 for lm_scale in [0.33]: att_scale = 1.0 run_lm_fusion( @@ -1086,7 +1091,7 @@ def train_mini_self_att( # ctc + lstm lm for beam_size, scales, prior_scale in product( - [55], [(1.0, 0.5)], [0.0, 0.3] + [], [(1.0, 0.5)], [0.0, 0.3] # 55 ): search_args = copy.deepcopy(oclr_args) search_args["beam_size"] = beam_size @@ -1125,7 +1130,7 @@ def train_mini_self_att( ) # two pass rescoring att + lstm lm, ctc - for beam_size in [12]: + for beam_size in []: # 12 for ctc_scale in [0.003]: for lm_scale in [0.4]: # for lm_scale in [0.28, 0.3, 0.32, 0.35, 0.38, 0.4, 0.42]: @@ -1155,7 +1160,7 @@ def train_mini_self_att( ) # optsnr att + ctc w prior + lstm lm - for beam_size, scales in product([48], [(0.7, 0.3, 0.6, 0.3)]): # 48 + for beam_size, scales in product([], [(0.7, 0.3, 0.6, 0.3)]): # 48 search_args = copy.deepcopy(oclr_args) search_args["ctc_log_prior_file"] = new_prior_file # ] = "/u/luca.gaudino/debug/ctc/prior.txt" @@ -1196,7 +1201,7 @@ def train_mini_self_att( # --------------------------- Trafo LM --------------------------- # # att + trafo lm - for beam_size in [12, 32]: + for beam_size in []: # 12, 32 lm_scale = 0.42 run_lm_fusion( args=oclr_args, @@ -1219,7 +1224,7 @@ def train_mini_self_att( # ctc + trafo lm for beam_size, scales, prior_scale in product( - [32], [(1, 0.55)], [0.4] + [], [(1, 0.55)], [0.4] # 32 ): search_args = copy.deepcopy(oclr_args) search_args["beam_size"] = beam_size @@ -1262,7 +1267,7 @@ def train_mini_self_att( # optsnr att + ctc + trafo lm for beam_size, scales, lm_scale, prior_scale in product( - [12, 32], + [], # 12 , 32 [ (0.8, 0.2) ], @@ -1316,3 +1321,30 @@ def train_mini_self_att( use_sclite=True, time_rqmt=time_rqmt, ) + + # --------- With ILM -------------------------------- + + # att + trafo lm + for beam_size, ilm_scale in product([32], [0.4]): + lm_scale = 0.54 + run_lm_fusion( + args=oclr_args, + lm_type="trafo", + exp_name=(f"bsf{bsf}/" if bsf > 0 else "") + f"att_trafolm{lm_scale}_ilm{ilm_scale}_beam{beam_size}", + train_data=train_data, + train_job=train_j, + feature_net=log10_net_10ms, + epoch=train_job_avg_ckpt[ + f"base_conf_12l_lstm_1l_conv6_OCLR_sqrdReLU_cyc915_ep2035_peak0.0009_retrain1_const20_linDecay580_{1e-4}" + ], + ckpt_name="avg", + lm_scales=[lm_scale], + beam_size=beam_size, + bpe_size=BPE_10K, + test_set_names=["dev-clean", "dev-other", "test-clean", "test-other"], + use_sclite=True, + bsf=bsf, + prior_type="mini_lstm", + prior_scales=[ilm_scale], + mini_lstm_ckpt="/u/zeineldeen/setups/ubuntu_22_setups/2023-04-17--conformer-att/work/i6_core/returnn/training/GetBestTFCheckpointJob.JLwxrydala1K/output/model/checkpoint", + ) diff --git a/users/gaudino/experiments/conformer_att_2023/librispeech_960/configs/ctc_att_search_w_recombine.py b/users/gaudino/experiments/conformer_att_2023/librispeech_960/configs/ctc_att_search_w_recombine.py index 3ed600a57..4e997847f 100644 --- a/users/gaudino/experiments/conformer_att_2023/librispeech_960/configs/ctc_att_search_w_recombine.py +++ b/users/gaudino/experiments/conformer_att_2023/librispeech_960/configs/ctc_att_search_w_recombine.py @@ -600,13 +600,12 @@ def run_exp( # --------------------------- With Lstm LM --------------------------- # # optsr max ctc w prior + lstm lm - for lm_scale, beam_size in product([0.3, 0.4, 0.5, 0.6], [12]): + for lm_scale, prior_scale, beam_size in product([0.6], [0.3], [32]): search_args = copy.deepcopy(oclr_args) search_args["beam_size"] = beam_size search_args["ctc_log_prior_file"] = new_prior_file ctc_scale = 1.0 label_scale = 1.0 - prior_scale = 0.0 ext_lm_opts = lstm_lm_opts_map[BPE_10K] @@ -651,7 +650,7 @@ def run_exp( search_args=search_args, feature_extraction_net=log10_net_10ms, bpe_size=BPE_10K, - test_sets=["dev-other"], + test_sets=["dev-clean", "dev-other", "test-clean", "test-other"], # test_sets=["dev-other"], remove_label={ "", @@ -664,13 +663,12 @@ def run_exp( # --------------------------- With Trafo LM --------------------------- # # optsr max ctc w prior + trafo lm - for lm_scale, beam_size in product([0.5, 0.6, 0.65, 0.7], [12]): + for lm_scale, prior_scale, beam_size in product([0.65], [0.3, 0.35], [32]): search_args = copy.deepcopy(oclr_args) search_args["beam_size"] = beam_size search_args["ctc_log_prior_file"] = new_prior_file ctc_scale = 1.0 label_scale = 1.0 - prior_scale = 0.0 ext_lm_opts = trafo_lm_opts_map[BPE_10K] @@ -715,7 +713,7 @@ def run_exp( search_args=search_args, feature_extraction_net=log10_net_10ms, bpe_size=BPE_10K, - test_sets=["dev-other"], + test_sets=["dev-clean", "dev-other", "test-clean", "test-other"], # test_sets=["dev-other"], remove_label={ "", @@ -726,11 +724,11 @@ def run_exp( ) # optsr max att + ctc w prior + trafo lm - for scales, lm_scale, beam_size in product([(0.65, 0.35, 0.0)], [0.45, 0.5, 0.55], [12]): + for scales, lm_scale, prior_scale, beam_size in product([(0.6, 0.4)], [0.6, 0.64, 0.68, 0.7], [0.15, 0.3, 0.45], [32]): search_args = copy.deepcopy(oclr_args) search_args["beam_size"] = beam_size search_args["ctc_log_prior_file"] = new_prior_file - att_scale, ctc_scale, prior_scale = scales + att_scale, ctc_scale = scales label_scale = 1.0 ext_lm_opts = trafo_lm_opts_map[BPE_10K] From f0f8b91aaad595e82368051f1631b88a3bcc3395 Mon Sep 17 00:00:00 2001 From: Lukas Rilling Date: Mon, 3 Jun 2024 13:53:41 +0200 Subject: [PATCH 086/227] Update Glow-TTS-ASR --- .../evaluation/forward_comparison.ipynb | 308 +++- users/rilling/evaluation/swer_eval.ipynb | 1479 +++++++++++------ users/rilling/evaluation/wer_eval.ipynb | 11 +- .../librispeech_glow_asr/experiments.py | 2 +- .../glowTTS/experiments.py | 2 +- .../glowTTS/gt_extraction.py | 2 +- .../librispeech_joint_training/experiments.py | 98 ++ .../glowTTS_ASR_conformer_two_forward_pass.py | 1 - .../shared/eval_invertibility.py | 17 +- .../training_comparison.ipynb | 78 +- .../exp_tts/experiments.py | 2 +- 11 files changed, 1349 insertions(+), 651 deletions(-) diff --git a/users/rilling/evaluation/forward_comparison.ipynb b/users/rilling/evaluation/forward_comparison.ipynb index c22bf1a9e..1a9e6570f 100644 --- a/users/rilling/evaluation/forward_comparison.ipynb +++ b/users/rilling/evaluation/forward_comparison.ipynb @@ -3,13 +3,15 @@ { "cell_type": "code", "execution_count": 2, - "metadata": {}, + "metadata": { + "metadata": {} + }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_503671/2049839218.py:8: DeprecationWarning: Importing display from IPython.core.display is deprecated since IPython 7.14, please import from IPython display\n", + "/var/tmp/ipykernel_4059881/2049839218.py:8: DeprecationWarning: Importing display from IPython.core.display is deprecated since IPython 7.14, please import from IPython display\n", " from IPython.core.display import display\n" ] } @@ -33,22 +35,24 @@ }, { "cell_type": "code", - "execution_count": 8, - "metadata": {}, + "execution_count": 3, + "metadata": { + "metadata": {} + }, "outputs": [ { "data": { "text/plain": [ - "{'/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/400ep/dec_drop_0.05/tts_eval_gl/test-clean/forward/output/audio_files/': '/glowTTS_x_vector_v2/enc768/400ep/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/200ep/dec_drop_0.05/tts_eval_gl/test-clean/forward/output/audio_files/': '/glowTTS_x_vector_v2/enc768/200ep/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/100ep/dec_drop_0.05/tts_eval_gl/test-clean/forward/output/audio_files/': '/glowTTS_x_vector_v2/enc768/100ep/',\n", + "{'/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/100ep/dec_drop_0.05/tts_eval_gl/test-clean/forward/output/audio_files/': '/glowTTS_x_vector_v2/enc768/100ep/',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/200ep_long_cooldown/dec_drop_0.05/tts_eval_gl/test-clean/forward/output/audio_files/': '/glowTTS_x_vector_v2/enc768/200ep_long_cooldown/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/100ep/dec_drop_0.05/tts_eval_gl/test-clean/forward/output/audio_files/': '/glowTTS/enc768/100ep/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/400ep/dec_drop_0.05/tts_eval_gl/test-clean/forward/output/audio_files/': '/glowTTS_x_vector_v2/enc768/400ep/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/200ep/dec_drop_0.05/tts_eval_gl/test-clean/forward/output/audio_files/': '/glowTTS_x_vector_v2/enc768/200ep/',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/200ep/dec_drop_0.05/tts_eval_gl/test-clean/forward/output/audio_files/': '/glowTTS/enc768/200ep/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/100ep/dec_drop_0.05/tts_eval_gl/test-clean/forward/output/audio_files/': '/glowTTS/enc768/100ep/',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/400ep/grad_clip_10/dec_drop_0.05/tts_eval_gl/test-clean/forward/output/audio_files/': '/glowTTS/enc768/400ep/grad_clip_10/'}" ] }, - "execution_count": 8, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } @@ -86,16 +90,18 @@ }, { "cell_type": "code", - "execution_count": 11, - "metadata": {}, + "execution_count": 141, + "metadata": { + "metadata": {} + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/400ep/dec_drop_0.05/tts_eval_gl/test-clean/forward/output/audio_files/test-clean_121-127105-0010_121-127105-0010.ogg\n", - "/glowTTS_x_vector_v2/enc768/400ep/\n", - "AutoMOS: 3.3250440482638384\n", + "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/100ep/dec_drop_0.05/tts_eval_gl/test-clean/forward/output/audio_files/test-clean_1188-133604-0023_1188-133604-0023.ogg\n", + "/glowTTS_x_vector_v2/enc768/100ep/\n", + "AutoMOS: 3.181718836146358\n", "\n" ] }, @@ -104,7 +110,7 @@ "text/html": [ "\n", " \n", " " @@ -120,9 +126,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/200ep/dec_drop_0.05/tts_eval_gl/test-clean/forward/output/audio_files/test-clean_121-127105-0010_121-127105-0010.ogg\n", - "/glowTTS_x_vector_v2/enc768/200ep/\n", - "AutoMOS: 3.2574123507855752\n", + "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/200ep_long_cooldown/dec_drop_0.05/tts_eval_gl/test-clean/forward/output/audio_files/test-clean_1188-133604-0023_1188-133604-0023.ogg\n", + "/glowTTS_x_vector_v2/enc768/200ep_long_cooldown/\n", + "AutoMOS: 3.212764627153152\n", "\n" ] }, @@ -131,7 +137,7 @@ "text/html": [ "\n", " \n", " " @@ -147,9 +153,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/100ep/dec_drop_0.05/tts_eval_gl/test-clean/forward/output/audio_files/test-clean_121-127105-0010_121-127105-0010.ogg\n", - "/glowTTS_x_vector_v2/enc768/100ep/\n", - "AutoMOS: 3.181718836146358\n", + "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/400ep/dec_drop_0.05/tts_eval_gl/test-clean/forward/output/audio_files/test-clean_1188-133604-0023_1188-133604-0023.ogg\n", + "/glowTTS_x_vector_v2/enc768/400ep/\n", + "AutoMOS: 3.300797877637179\n", "\n" ] }, @@ -158,7 +164,7 @@ "text/html": [ "\n", " \n", " " @@ -174,9 +180,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/200ep_long_cooldown/dec_drop_0.05/tts_eval_gl/test-clean/forward/output/audio_files/test-clean_121-127105-0010_121-127105-0010.ogg\n", - "/glowTTS_x_vector_v2/enc768/200ep_long_cooldown/\n", - "AutoMOS: 3.212764627153152\n", + "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/200ep/dec_drop_0.05/tts_eval_gl/test-clean/forward/output/audio_files/test-clean_1188-133604-0023_1188-133604-0023.ogg\n", + "/glowTTS_x_vector_v2/enc768/200ep/\n", + "AutoMOS: 3.2574123507855752\n", "\n" ] }, @@ -185,7 +191,7 @@ "text/html": [ "\n", " \n", " " @@ -201,9 +207,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/100ep/dec_drop_0.05/tts_eval_gl/test-clean/forward/output/audio_files/test-clean_121-127105-0010_121-127105-0010.ogg\n", - "/glowTTS/enc768/100ep/\n", - "AutoMOS: 3.302589650658008\n", + "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/200ep/dec_drop_0.05/tts_eval_gl/test-clean/forward/output/audio_files/test-clean_1188-133604-0023_1188-133604-0023.ogg\n", + "/glowTTS/enc768/200ep/\n", + "AutoMOS: 3.3596264232244146\n", "\n" ] }, @@ -212,7 +218,7 @@ "text/html": [ "\n", " \n", " " @@ -228,9 +234,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/200ep/dec_drop_0.05/tts_eval_gl/test-clean/forward/output/audio_files/test-clean_121-127105-0010_121-127105-0010.ogg\n", - "/glowTTS/enc768/200ep/\n", - "AutoMOS: 3.3596264232244146\n", + "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/100ep/dec_drop_0.05/tts_eval_gl/test-clean/forward/output/audio_files/test-clean_1188-133604-0023_1188-133604-0023.ogg\n", + "/glowTTS/enc768/100ep/\n", + "AutoMOS: 3.302589650658008\n", "\n" ] }, @@ -239,7 +245,7 @@ "text/html": [ "\n", " \n", " " @@ -255,9 +261,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/400ep/grad_clip_10/dec_drop_0.05/tts_eval_gl/test-clean/forward/output/audio_files/test-clean_121-127105-0010_121-127105-0010.ogg\n", + "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/400ep/grad_clip_10/dec_drop_0.05/tts_eval_gl/test-clean/forward/output/audio_files/test-clean_1188-133604-0023_1188-133604-0023.ogg\n", "/glowTTS/enc768/400ep/grad_clip_10/\n", - "AutoMOS: 3.2932603021495437\n", + "AutoMOS: 3.351169210956677\n", "\n" ] }, @@ -266,7 +272,7 @@ "text/html": [ "\n", " \n", " " @@ -280,7 +286,7 @@ } ], "source": [ - "sequence_index = 10\n", + "sequence_index = 102\n", "sequence_name = sequence_names[sequence_index]\n", "\n", "for folder, name in files.items():\n", @@ -296,10 +302,228 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, + "execution_count": 150, + "metadata": { + "metadata": {} + }, + "outputs": [], + "source": [ + "from i6_experiments.users.rilling.experiments.librispeech.librispeech_glowtts.pytorch_networks.feature_extraction import DbMelFeatureExtraction, DbMelFeatureExtractionConfig\n", + "\n", + "fe_config = DbMelFeatureExtractionConfig.from_dict({\n", + " \"sample_rate\": 16000,\n", + " \"win_size\": 0.05,\n", + " \"hop_size\": 0.0125,\n", + " \"f_min\": 60,\n", + " \"f_max\": 7600,\n", + " \"min_amp\": 1e-10,\n", + " \"num_filters\": 80,\n", + " \"center\": True,\n", + " \"norm\": (-83.20164937973021, 34.14062855722116),\n", + " })\n", + "\n", + "fe = DbMelFeatureExtraction(fe_config)" + ] + }, + { + "cell_type": "code", + "execution_count": 151, + "metadata": { + "metadata": {} + }, + "outputs": [], + "source": [ + "import torchaudio" + ] + }, + { + "cell_type": "code", + "execution_count": 152, + "metadata": { + "metadata": {} + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(tensor([[-0.0029, -0.0012, -0.0003, ..., 0.0098, -0.0023, -0.0016]]), 16000)" + ] + }, + "execution_count": 152, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "for folder, name in files.items():\n", + " path = folder + sequence_name\n", + " break\n", + "test = torchaudio.load(path)\n", + "test" + ] + }, + { + "cell_type": "code", + "execution_count": 234, + "metadata": { + "metadata": {} + }, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor(1, dtype=torch.int32)" + ] + }, + "execution_count": 234, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "spec, len = fe(test[0], test[0].shape[0])\n", + "len" + ] + }, + { + "cell_type": "code", + "execution_count": 247, + "metadata": { + "metadata": {} + }, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([1376, 80])" + ] + }, + "execution_count": 247, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "spec[0].shape" + ] + }, + { + "cell_type": "code", + "execution_count": 298, + "metadata": { + "metadata": {} + }, + "outputs": [], + "source": [ + "from torchaudio.functional import mask_along_axis\n", + "import copy\n", + "\n", + "def apply_spec_aug(input, num_repeat_time, max_dim_time, num_repeat_feat, max_dim_feat):\n", + " \"\"\"\n", + " :param Tensor input: the input audio features (B,T,F)\n", + " :param int num_repeat_time: number of repetitions to apply time mask\n", + " :param int max_dim_time: number of columns to be masked on time dimension will be uniformly sampled from [0, mask_param]\n", + " :param int num_repeat_feat: number of repetitions to apply feature mask\n", + " :param int max_dim_feat: number of columns to be masked on feature dimension will be uniformly sampled from [0, mask_param]\n", + " \"\"\"\n", + " for _ in range(num_repeat_time):\n", + " input = mask_along_axis(input, mask_param=max_dim_time, mask_value=0.0, axis=1)\n", + "\n", + " out1 = copy.deepcopy(input)\n", + " for _ in range(num_repeat_feat):\n", + " input = mask_along_axis(input, mask_param=max_dim_feat, mask_value=0.0, axis=2)\n", + " return input, out1" + ] + }, + { + "cell_type": "code", + "execution_count": 299, + "metadata": { + "metadata": {} + }, + "outputs": [], + "source": [ + "def plot_spec(ax, s):\n", + " shape = s.shape\n", + " x = np.arange(0, shape[0]+1)\n", + " y = np.arange(0, shape[1]+1)\n", + "\n", + " s2 = s.transpose(0,1)\n", + " ax.pcolormesh(s2)" + ] + }, + { + "cell_type": "code", + "execution_count": 316, + "metadata": { + "metadata": {} + }, + "outputs": [], + "source": [ + "augment_spec, midstep = apply_spec_aug(spec, 20, 20, 5, 8)" + ] + }, + { + "cell_type": "code", + "execution_count": 317, + "metadata": { + "metadata": {} + }, "outputs": [], - "source": [] + "source": [ + "import matplotlib.pyplot as plt\n", + "import librosa\n", + "\n", + "%matplotlib widget\n" + ] + }, + { + "cell_type": "code", + "execution_count": 320, + "metadata": { + "metadata": {} + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/tmp/ipykernel_4059881/4065018720.py:1: RuntimeWarning: More than 20 figures have been opened. Figures created through the pyplot interface (`matplotlib.pyplot.figure`) are retained until explicitly closed and may consume too much memory. (To control this warning, see the rcParam `figure.max_open_warning`). Consider using `matplotlib.pyplot.close()`.\n", + " fig, ax = plt.subplots(1, 3)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "397f69e5a0c74ecc9ee95ca648376b45", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(1, 3)\n", + "plot_spec(ax[0], spec[0, :400])\n", + "plot_spec(ax[1], midstep[0, :400])\n", + "plot_spec(ax[2], augment_spec[0, :400])" + ] } ], "metadata": { diff --git a/users/rilling/evaluation/swer_eval.ipynb b/users/rilling/evaluation/swer_eval.ipynb index 1e207a807..fe7eaf1e2 100644 --- a/users/rilling/evaluation/swer_eval.ipynb +++ b/users/rilling/evaluation/swer_eval.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -20,108 +20,154 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "['/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_100ep_pe1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_two_forward_pass/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_x_vector_v2/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_100ep_pe1_radam1e-9/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_100ep_pe1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_ASR_conformer_two_forward_pass/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_x_vector/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_ASR_conformer_x_vector/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + "['/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_ctc_scale_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_ctc_scale_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_ctc_scale_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_blstm_x_vector/tuning/lm_4.5/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_blstm_x_vector/tuning/lm_3.0/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_blstm_x_vector/tuning/lm_2.0/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_blstm_x_vector/tuning/lm_3.5/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_blstm_x_vector/tuning/lm_2.5/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_blstm_x_vector/tuning/lm_4.0/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_blstm_x_vector/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_ctc_scale_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_blstm_x_vector_specaug/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_0.1/tuned/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_0.1/tuning/lm_3.5_ps_0.5/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_0.1/tuning/lm_3.0_ps_0.3/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_0.1/tuning/lm_3.5_ps_0/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_0.1/tuning/lm_4.5_ps_0.5/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_0.1/tuning/lm_4.0_ps_0.3/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_0.1/tuning/lm_2.0_ps_0.3/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_0.1/tuning/lm_3.0_ps_0/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_0.1/tuning/lm_2.5_ps_0.5/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_0.1/tuning/lm_3.5_ps_0.3/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_0.1/tuning/lm_2.0_ps_0/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_0.1/tuning/lm_4.5_ps_0/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_0.1/tuning/lm_3.0_ps_0.5/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_0.1/tuning/lm_4.5_ps_0.3/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_0.1/tuning/lm_4.0_ps_0.5/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_0.1/tuning/lm_2.0_ps_0.5/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_0.1/tuning/lm_2.5_ps_0.3/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_0.1/tuning/lm_4.0_ps_0/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_0.1/tuning/lm_2.5_ps_0/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/400ep/gin512/dec_drop_0.05/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/400ep/dec_drop_0.05/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/200ep/dec_drop_0.0/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/200ep/dec_drop_0.05/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/100ep/dec_drop_0.05/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/200ep_long_cooldown/dec_drop_0.0/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/200ep_long_cooldown/dec_drop_0.05/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc192/200ep/dec_drop_0.05/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc192/200ep/dec_drop_0.0/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc192/200ep/dec_drop_0.05_epsilon_1e-8/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_1.0/tuning/lm_3.5_ps_0/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_1.0/tuning/lm_3.0_ps_0.5/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_1.0/tuning/lm_3.5_ps_0.3/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_1.0/tuning/lm_4.0_ps_0.5/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_1.0/tuning/lm_4.5_ps_0.3/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_1.0/tuning/lm_2.5_ps_0.3/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_1.0/tuning/lm_2.0_ps_0.5/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_1.0/tuning/lm_3.0_ps_0/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_1.0/tuning/lm_3.0_ps_0.3/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_1.0/tuning/lm_3.5_ps_0.5/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_1.0/tuning/lm_2.0_ps_0/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_1.0/tuning/lm_4.0_ps_0.3/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_1.0/tuning/lm_4.5_ps_0/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_1.0/tuning/lm_4.5_ps_0.5/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_1.0/tuning/lm_4.0_ps_0/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_1.0/tuning/lm_2.5_ps_0.5/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_1.0/tuning/lm_2.0_ps_0.3/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_1.0/tuning/lm_2.5_ps_0/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_1.0/tuned/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_1.0/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_100ep_pe1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_100ep_pe1_radam1e-9/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_x_vector/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_100ep_pe1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_x_vector_v2/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2_multiscale/enc768/200ep/dec_drop_0.05/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2_conformer_coupling/enc768/200ep/dec_drop_0.05/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2_logdist_loss/ed_scale_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_batch_norm/enc768/200ep/dec_drop_0.05/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector/enc768/100ep/dec_drop_0.05/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc192/100ep/dec_drop_0.05/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc192/200ep/dec_drop_0.05/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc192/200ep/dec_drop_0.05_epsilon_1e-8/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc192/200ep/dec_drop_0.0/grad_clip_10/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc192/100ep/dec_drop_0.05/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/400ep/grad_clip_10/dec_drop_0.05/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/400ep/gin512/grad_clip_10/dec_drop_0.05/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/200ep/dec_drop_0.0/epsilon_1e-8/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/200ep/dec_drop_0.0/grad_clip_10/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/200ep/dec_drop_0.05_epsilon_1e-8/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/200ep/dec_drop_0.05/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc192/400ep/grad_clip_10/dec_drop_0.05/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/100ep/dec_drop_0.00/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/100ep/dec_drop_0.05/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2_logdist_loss/ed_scale_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2_logdist_loss_grad_clip_10/ed_scale_1.0/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/200ep/dec_drop_0.05/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/200ep/dec_drop_0.0/grad_clip_10/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/200ep/dec_drop_0.0/epsilon_1e-8/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/200ep/dec_drop_0.05_epsilon_1e-8/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/400ep/gin512/grad_clip_10/dec_drop_0.05/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/400ep/grad_clip_10/dec_drop_0.05/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/200ep/dec_drop_0.0/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/200ep/dec_drop_0.05/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/400ep/gin512/dec_drop_0.05/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/400ep/dec_drop_0.05/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/200ep_long_cooldown/dec_drop_0.05/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/200ep_long_cooldown/dec_drop_0.0/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/100ep/dec_drop_0.05/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc192/200ep/dec_drop_0.0/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc192/200ep/dec_drop_0.05/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2_logdist_loss_grad_clip_10/ed_scale_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_simple_encoder/12cb/200ep/dec_drop_0.05/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2_logdist_loss_grad_clip_10/ed_scale_1.0/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_simple_encoder/20cb/200ep/dec_drop_0.05/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2_conformer_coupling/enc768/200ep/dec_drop_0.05/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2_multiscale/enc768/200ep/dec_drop_0.05/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_batch_norm/enc768/200ep/dec_drop_0.05/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector/enc768/100ep/dec_drop_0.05/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/specaug/ce_ls_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/specaug/ce_ls_1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/200ep/basic_init/no_specaug/tts_target_size/ce_ls_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/200ep/tts_pretrained/no_specaug/tts_target_size/ce_ls_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/no_specaug/ce_ls_1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/no_specaug/ce_ls_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_cnn_x_vector/tts_pretrained/no_specaug/tts_target_size/ce_ls_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_cnn_x_vector/basic_init/no_specaug/tts_target_size/ce_ls_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/mean_only/200ep/basic_init/no_specaug/tts_target_size/ce_ls_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/200ep/tts_pretrained/no_specaug/tts_target_size/ce_ls_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/no_specaug/tts_target_size/ce_ls_1.0/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/no_specaug/tts_target_size/ce_ls_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector_v2/tts_pretrained/ce_ls_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector_v2/tts_pretrained/ce_ls_0.01/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector_v2/basic_init/ce_ls_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector_v2/basic_init/ce_ls_0.01/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector_v2/200ep/tts_pretrained/ce_ls_1.0/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/glowTTS_simple_encoder/12cb/200ep/dec_drop_0.05/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector_v2/200ep/tts_pretrained/ce_ls_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/ce_ls_1.0/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector_v2/200ep/tts_pretrained/ce_ls_1.0/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/ce_ls_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector/200ep/basic_init/ce_ls_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/ce_ls_1.0/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector_v2/tts_pretrained/ce_ls_0.01/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector_v2/tts_pretrained/ce_ls_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector_v2/basic_init/ce_ls_0.01/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector_v2/basic_init/ce_ls_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector/200ep/tts_pretrained/ce_ls_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector/200ep/basic_init/ce_ls_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector/tts_pretrained/ce_ls_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector/basic_init/ce_ls_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS/enc256/not_silence_preprocessed/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS/enc768/with_sigma/not_silence_preprocessed/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS/enc768/with_sigma/silence_preprocessed/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS/enc768/mean_only/silence_preprocessed/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS/enc768/mean_only/not_silence_preprocessed/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS/enc192/100ep/not_silence_preprocessed/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS/enc192/100ep/silence_preprocessed/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_cnn_x_vector/tts_pretrained/no_specaug/tts_target_size/ce_ls_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_cnn_x_vector/basic_init/no_specaug/tts_target_size/ce_ls_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/mean_only/200ep/basic_init/no_specaug/tts_target_size/ce_ls_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/200ep/tts_pretrained/no_specaug/tts_target_size/ce_ls_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/no_specaug/tts_target_size/ce_ls_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/no_specaug/tts_target_size/ce_ls_1.0/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/200ep/basic_init/no_specaug/tts_target_size/ce_ls_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/200ep/tts_pretrained/no_specaug/tts_target_size/ce_ls_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/no_specaug/ce_ls_1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/no_specaug/ce_ls_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/specaug/ce_ls_1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/specaug/ce_ls_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS_simple_encoder/silence_preprocessed/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS/enc192/200ep/long_cooldown/not_silence_preprocessed/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS/enc192/200ep/long_cooldown/silence_preprocessed/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS_simple_encoder/silence_preprocessed/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS_ddi_actnorm/enc192/100ep/not_silence_preprocessed/LR_scheduled/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS/enc192/100ep/not_silence_preprocessed/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS/enc192/100ep/silence_preprocessed/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS/enc768/mean_only/not_silence_preprocessed/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS/enc768/mean_only/silence_preprocessed/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS/enc768/with_sigma/silence_preprocessed/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS/enc768/with_sigma/not_silence_preprocessed/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS/enc256/not_silence_preprocessed/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS_nar_taco_encoder/silence_preprocessed/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS_nar_taco_encoder/not_silence_preprocessed/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS_nar_taco_encoder_no_blstm/silence_preprocessed/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS_x_vector/enc768/100ep/not_silence_preprocessed/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS_x_vector/enc192/100ep/not_silence_preprocessed/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS_nar_taco_encoder/not_silence_preprocessed/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS_nar_taco_encoder/silence_preprocessed/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS_nar_taco_encoder_no_blstm/silence_preprocessed/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer']" + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS_ddi_actnorm/enc192/100ep/not_silence_preprocessed/LR_scheduled/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer']" ] }, - "execution_count": 2, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } @@ -142,7 +188,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -155,10 +201,10 @@ { "data": { "text/plain": [ - "'100'" + "'250'" ] }, - "execution_count": 3, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -180,16 +226,16 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "(93, 93, 93, 93, 93, 93, 93, 93)" + "(139, 139, 139, 139, 139, 139, 139, 139)" ] }, - "execution_count": 4, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -228,7 +274,7 @@ " else:\n", " nisqa_confidence.append(None)\n", "\n", - " folders = [\"librispeech_glow_asr\", \"joint_training/default\", \"joint_training/conformer_coupling\", \"joint_training/given_alignments\", \"tts_architecture\"]\n", + " folders = [\"ASR_only\", \"joint_training/default\", \"joint_training/conformer_coupling\", \"joint_training/given_alignments\", \"TTS_only/v1\", \"TTS_only/v2\"]\n", " found = False\n", " for folder in folders:\n", " if folder in f:\n", @@ -306,7 +352,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -357,23 +403,23 @@ " \n", " \n", " \n", - " joint_training/conformer_coupling\n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_100ep_pe1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer\n", - " 12.4\n", - " 2.936271\n", - " NaN\n", - " 100\n", + " joint_training/default\n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_ctc_scale_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer\n", + " 13.3\n", + " 3.123151\n", + " 0.019940\n", + " 250\n", " 0.05\n", " False\n", " 768\n", - " [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05]\n", + " [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08]\n", " {'class': 'adam', 'epsilon': 1e-08}\n", " \n", " \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_two_forward_pass/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer\n", - " 20.9\n", - " 2.449569\n", - " NaN\n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer\n", + " 9.5\n", + " 2.746789\n", + " 0.021347\n", " 250\n", " 0.05\n", " False\n", @@ -382,10 +428,10 @@ " {'class': 'adam', 'epsilon': 1e-08}\n", " \n", " \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_x_vector_v2/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer\n", - " 5.2\n", - " 2.136262\n", - " NaN\n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer\n", + " 11.2\n", + " 3.176109\n", + " 0.023388\n", " 250\n", " 0.05\n", " False\n", @@ -394,27 +440,27 @@ " {'class': 'adam', 'epsilon': 1e-08}\n", " \n", " \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_100ep_pe1_radam1e-9/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer\n", - " 14.7\n", - " 2.588368\n", - " NaN\n", - " 100\n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_blstm_x_vector/tuning/lm_4.5/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer\n", + " 16.0\n", + " 3.109557\n", + " 0.021113\n", + " 250\n", " 0.05\n", " False\n", " 768\n", - " [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05]\n", - " {'class': 'radam', 'epsilon': 1e-09}\n", + " [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08]\n", + " {'class': 'adam', 'epsilon': 1e-08}\n", " \n", " \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_100ep_pe1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer\n", - " 14.4\n", - " 2.718031\n", - " NaN\n", - " 100\n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_blstm_x_vector/tuning/lm_3.0/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer\n", + " 16.0\n", + " 3.109557\n", + " 0.021113\n", + " 250\n", " 0.05\n", " False\n", " 768\n", - " [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05]\n", + " [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08]\n", " {'class': 'adam', 'epsilon': 1e-08}\n", " \n", " \n", @@ -432,6 +478,30 @@ " \n", " \n", " tts_architecture\n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS_nar_taco_encoder/not_silence_preprocessed/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer\n", + " 25.2\n", + " 3.463099\n", + " NaN\n", + " 200\n", + " 0.00\n", + " -\n", + " -\n", + " [0: 1e-05, 49: 0.0005, 50: 0.0005, 200: 1e-05]\n", + " {'class': 'adam', 'epsilon': 1e-09}\n", + " \n", + " \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS_nar_taco_encoder_no_blstm/silence_preprocessed/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer\n", + " 105.6\n", + " 3.165388\n", + " NaN\n", + " 100\n", + " 0.00\n", + " -\n", + " -\n", + " [0: 0.0001, 49: 0.0005, 50: 0.0001, 100: 1e-06]\n", + " {'class': 'radam', 'epsilon': 1e-09}\n", + " \n", + " \n", " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS_x_vector/enc768/100ep/not_silence_preprocessed/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer\n", " 20.9\n", " 3.312732\n", @@ -456,177 +526,153 @@ " {'class': 'adam', 'epsilon': 1e-09}\n", " \n", " \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS_nar_taco_encoder/not_silence_preprocessed/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer\n", - " 25.2\n", - " 3.463099\n", - " NaN\n", - " 200\n", - " 0.00\n", - " -\n", - " -\n", - " [0: 1e-05, 49: 0.0005, 50: 0.0005, 200: 1e-05]\n", - " {'class': 'adam', 'epsilon': 1e-09}\n", - " \n", - " \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS_nar_taco_encoder/silence_preprocessed/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer\n", - " 25.9\n", - " 3.391651\n", - " NaN\n", - " 200\n", - " 0.00\n", - " -\n", - " -\n", - " [0: 1e-05, 49: 0.0005, 50: 0.0005, 200: 1e-05]\n", - " {'class': 'adam', 'epsilon': 1e-09}\n", - " \n", - " \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS_nar_taco_encoder_no_blstm/silence_preprocessed/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer\n", - " 105.6\n", - " 3.165388\n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS_ddi_actnorm/enc192/100ep/not_silence_preprocessed/LR_scheduled/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer\n", + " 100.0\n", + " 3.115826\n", " NaN\n", " 100\n", " 0.00\n", - " -\n", - " -\n", - " [0: 0.0001, 49: 0.0005, 50: 0.0001, 100: 1e-06]\n", - " {'class': 'radam', 'epsilon': 1e-09}\n", + " False\n", + " 192\n", + " [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05]\n", + " {'class': 'adam', 'epsilon': 1e-09}\n", " \n", " \n", "\n", - "

93 rows × 9 columns

\n", + "

139 rows × 9 columns

\n", "" ], "text/plain": [ - " sWER \\\n", - "Group Experiment \n", - "joint_training/conformer_coupling /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 12.4 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 20.9 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 5.2 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 14.7 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 14.4 \n", - "... ... \n", - "tts_architecture /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 20.9 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 95.4 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 25.2 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 25.9 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 105.6 \n", + " sWER \\\n", + "Group Experiment \n", + "joint_training/default /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 13.3 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 9.5 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 11.2 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 16.0 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 16.0 \n", + "... ... \n", + "tts_architecture /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 25.2 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 105.6 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 20.9 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 95.4 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 100.0 \n", "\n", - " autoMOS \\\n", - "Group Experiment \n", - "joint_training/conformer_coupling /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 2.936271 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 2.449569 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 2.136262 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 2.588368 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 2.718031 \n", - "... ... \n", - "tts_architecture /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 3.312732 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 2.633865 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 3.463099 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 3.391651 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 3.165388 \n", + " autoMOS \\\n", + "Group Experiment \n", + "joint_training/default /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 3.123151 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 2.746789 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 3.176109 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 3.109557 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 3.109557 \n", + "... ... \n", + "tts_architecture /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 3.463099 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 3.165388 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 3.312732 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 2.633865 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 3.115826 \n", "\n", - " autoMOS confidence \\\n", - "Group Experiment \n", - "joint_training/conformer_coupling /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... NaN \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... NaN \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... NaN \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... NaN \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... NaN \n", - "... ... \n", - "tts_architecture /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... NaN \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... NaN \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... NaN \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... NaN \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... NaN \n", + " autoMOS confidence \\\n", + "Group Experiment \n", + "joint_training/default /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.019940 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.021347 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.023388 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.021113 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.021113 \n", + "... ... \n", + "tts_architecture /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... NaN \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... NaN \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... NaN \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... NaN \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... NaN \n", "\n", - " num_epochs \\\n", - "Group Experiment \n", - "joint_training/conformer_coupling /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 100 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 250 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 250 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 100 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 100 \n", - "... ... \n", - "tts_architecture /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 100 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 100 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 200 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 200 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 100 \n", + " num_epochs \\\n", + "Group Experiment \n", + "joint_training/default /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 250 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 250 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 250 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 250 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 250 \n", + "... ... \n", + "tts_architecture /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 200 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 100 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 100 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 100 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 100 \n", "\n", - " decoder dropout \\\n", - "Group Experiment \n", - "joint_training/conformer_coupling /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.05 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.05 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.05 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.05 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.05 \n", - "... ... \n", - "tts_architecture /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.00 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.00 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.00 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.00 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.00 \n", + " decoder dropout \\\n", + "Group Experiment \n", + "joint_training/default /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.05 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.05 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.05 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.05 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.05 \n", + "... ... \n", + "tts_architecture /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.00 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.00 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.00 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.00 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.00 \n", "\n", - " mean only \\\n", - "Group Experiment \n", - "joint_training/conformer_coupling /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False \n", - "... ... \n", - "tts_architecture /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... - \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... - \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... - \n", + " mean only \\\n", + "Group Experiment \n", + "joint_training/default /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False \n", + "... ... \n", + "tts_architecture /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... - \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... - \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False \n", "\n", - " encoder channels \\\n", - "Group Experiment \n", - "joint_training/conformer_coupling /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 768 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 768 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 768 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 768 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 768 \n", - "... ... \n", - "tts_architecture /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 768 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 192 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... - \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... - \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... - \n", + " encoder channels \\\n", + "Group Experiment \n", + "joint_training/default /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 768 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 768 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 768 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 768 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 768 \n", + "... ... \n", + "tts_architecture /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... - \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... - \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 768 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 192 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 192 \n", "\n", - " LR \\\n", - "Group Experiment \n", - "joint_training/conformer_coupling /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] \n", - "... ... \n", - "tts_architecture /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... [0: 1e-05, 49: 0.0005, 50: 0.0005, 200: 1e-05] \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... [0: 1e-05, 49: 0.0005, 50: 0.0005, 200: 1e-05] \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... [0: 0.0001, 49: 0.0005, 50: 0.0001, 100: 1e-06] \n", + " LR \\\n", + "Group Experiment \n", + "joint_training/default /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] \n", + "... ... \n", + "tts_architecture /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... [0: 1e-05, 49: 0.0005, 50: 0.0005, 200: 1e-05] \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... [0: 0.0001, 49: 0.0005, 50: 0.0001, 100: 1e-06] \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] \n", "\n", - " Optimizer \n", - "Group Experiment \n", - "joint_training/conformer_coupling /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... {'class': 'adam', 'epsilon': 1e-08} \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... {'class': 'adam', 'epsilon': 1e-08} \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... {'class': 'adam', 'epsilon': 1e-08} \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... {'class': 'radam', 'epsilon': 1e-09} \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... {'class': 'adam', 'epsilon': 1e-08} \n", - "... ... \n", - "tts_architecture /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... {'class': 'adam', 'epsilon': 1e-09} \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... {'class': 'adam', 'epsilon': 1e-09} \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... {'class': 'adam', 'epsilon': 1e-09} \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... {'class': 'adam', 'epsilon': 1e-09} \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... {'class': 'radam', 'epsilon': 1e-09} \n", + " Optimizer \n", + "Group Experiment \n", + "joint_training/default /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... {'class': 'adam', 'epsilon': 1e-08} \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... {'class': 'adam', 'epsilon': 1e-08} \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... {'class': 'adam', 'epsilon': 1e-08} \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... {'class': 'adam', 'epsilon': 1e-08} \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... {'class': 'adam', 'epsilon': 1e-08} \n", + "... ... \n", + "tts_architecture /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... {'class': 'adam', 'epsilon': 1e-09} \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... {'class': 'radam', 'epsilon': 1e-09} \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... {'class': 'adam', 'epsilon': 1e-09} \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... {'class': 'adam', 'epsilon': 1e-09} \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... {'class': 'adam', 'epsilon': 1e-09} \n", "\n", - "[93 rows x 9 columns]" + "[139 rows x 9 columns]" ] }, - "execution_count": 5, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -643,7 +689,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 12, "metadata": {}, "outputs": [ { @@ -708,236 +754,236 @@ " \n", " \n", " \n", - " joint_training/conformer_coupling\n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_100ep_pe1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer\n", - " 12.4\n", - " 2.936271\n", - " NaN\n", - " 100\n", + " joint_training/default\n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_ctc_scale_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer\n", + " 13.3\n", + " 3.123151\n", + " 0.019940\n", + " 250\n", " 0.05\n", " False\n", " 768\n", - " [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05]\n", + " [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08]\n", " {'class': 'adam', 'epsilon': 1e-08}\n", - " -0.826781\n", - " -0.846025\n", - " None\n", - " 0.382039\n", - " 0.353906\n", - " None\n", - " False\n", + " -0.753013\n", + " -0.694853\n", + " -0.771774\n", + " 0.417359\n", + " 0.565613\n", + " 0.399888\n", + " True\n", " \n", " \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_two_forward_pass/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer\n", - " 20.9\n", - " 2.449569\n", - " NaN\n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer\n", + " 9.5\n", + " 2.746789\n", + " 0.021347\n", " 250\n", " 0.05\n", " False\n", " 768\n", " [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08]\n", " {'class': 'adam', 'epsilon': 1e-08}\n", - " False\n", - " False\n", - " False\n", - " False\n", - " False\n", - " False\n", - " False\n", + " -0.610471\n", + " -0.555647\n", + " -0.629746\n", + " 0.416831\n", + " 0.583815\n", + " 0.403638\n", + " True\n", " \n", " \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_x_vector_v2/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer\n", - " 5.2\n", - " 2.136262\n", - " NaN\n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer\n", + " 11.2\n", + " 3.176109\n", + " 0.023388\n", " 250\n", " 0.05\n", " False\n", " 768\n", " [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08]\n", " {'class': 'adam', 'epsilon': 1e-08}\n", - " False\n", - " False\n", - " False\n", - " False\n", - " False\n", - " False\n", - " False\n", + " -0.758909\n", + " -0.694360\n", + " -0.778751\n", + " 0.400894\n", + " 0.555330\n", + " 0.379635\n", + " True\n", " \n", " \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_100ep_pe1_radam1e-9/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer\n", - " 14.7\n", - " 2.588368\n", - " NaN\n", - " 100\n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_blstm_x_vector/tuning/lm_4.5/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer\n", + " 16.0\n", + " 3.109557\n", + " 0.021113\n", + " 250\n", " 0.05\n", " False\n", " 768\n", - " [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05]\n", - " {'class': 'radam', 'epsilon': 1e-09}\n", - " -0.82573\n", - " -0.844433\n", - " None\n", - " 0.384814\n", - " 0.355806\n", - " None\n", - " False\n", + " [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08]\n", + " {'class': 'adam', 'epsilon': 1e-08}\n", + " -0.676933\n", + " -0.621956\n", + " -0.692515\n", + " 0.328548\n", + " 0.477463\n", + " 0.302857\n", + " True\n", " \n", " \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/conformer_coupling/raw_audio/ddi/glowTTS_100ep_pe1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer\n", - " 14.4\n", - " 2.718031\n", - " NaN\n", - " 100\n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_blstm_x_vector/tuning/lm_3.0/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer\n", + " 16.0\n", + " 3.109557\n", + " 0.021113\n", + " 250\n", " 0.05\n", " False\n", " 768\n", - " [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05]\n", + " [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08]\n", " {'class': 'adam', 'epsilon': 1e-08}\n", - " -0.825686\n", - " -0.844577\n", - " None\n", - " 0.389056\n", - " 0.360854\n", - " None\n", - " False\n", + " -0.676933\n", + " -0.621956\n", + " -0.692515\n", + " 0.328548\n", + " 0.477463\n", + " 0.302857\n", + " True\n", " \n", " \n", "\n", "" ], "text/plain": [ - " sWER \\\n", - "Group Experiment \n", - "joint_training/conformer_coupling /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 12.4 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 20.9 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 5.2 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 14.7 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 14.4 \n", + " sWER \\\n", + "Group Experiment \n", + "joint_training/default /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 13.3 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 9.5 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 11.2 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 16.0 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 16.0 \n", "\n", - " autoMOS \\\n", - "Group Experiment \n", - "joint_training/conformer_coupling /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 2.936271 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 2.449569 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 2.136262 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 2.588368 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 2.718031 \n", + " autoMOS \\\n", + "Group Experiment \n", + "joint_training/default /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 3.123151 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 2.746789 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 3.176109 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 3.109557 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 3.109557 \n", "\n", - " autoMOS confidence \\\n", - "Group Experiment \n", - "joint_training/conformer_coupling /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... NaN \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... NaN \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... NaN \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... NaN \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... NaN \n", + " autoMOS confidence \\\n", + "Group Experiment \n", + "joint_training/default /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.019940 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.021347 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.023388 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.021113 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.021113 \n", "\n", - " num_epochs \\\n", - "Group Experiment \n", - "joint_training/conformer_coupling /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 100 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 250 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 250 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 100 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 100 \n", + " num_epochs \\\n", + "Group Experiment \n", + "joint_training/default /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 250 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 250 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 250 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 250 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 250 \n", "\n", - " decoder dropout \\\n", - "Group Experiment \n", - "joint_training/conformer_coupling /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.05 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.05 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.05 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.05 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.05 \n", + " decoder dropout \\\n", + "Group Experiment \n", + "joint_training/default /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.05 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.05 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.05 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.05 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.05 \n", "\n", - " mean only \\\n", - "Group Experiment \n", - "joint_training/conformer_coupling /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False \n", + " mean only \\\n", + "Group Experiment \n", + "joint_training/default /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False \n", "\n", - " encoder channels \\\n", - "Group Experiment \n", - "joint_training/conformer_coupling /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 768 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 768 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 768 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 768 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 768 \n", + " encoder channels \\\n", + "Group Experiment \n", + "joint_training/default /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 768 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 768 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 768 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 768 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 768 \n", "\n", - " LR \\\n", - "Group Experiment \n", - "joint_training/conformer_coupling /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] \n", + " LR \\\n", + "Group Experiment \n", + "joint_training/default /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] \n", "\n", - " Optimizer \\\n", - "Group Experiment \n", - "joint_training/conformer_coupling /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... {'class': 'adam', 'epsilon': 1e-08} \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... {'class': 'adam', 'epsilon': 1e-08} \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... {'class': 'adam', 'epsilon': 1e-08} \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... {'class': 'radam', 'epsilon': 1e-09} \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... {'class': 'adam', 'epsilon': 1e-08} \n", + " Optimizer \\\n", + "Group Experiment \n", + "joint_training/default /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... {'class': 'adam', 'epsilon': 1e-08} \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... {'class': 'adam', 'epsilon': 1e-08} \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... {'class': 'adam', 'epsilon': 1e-08} \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... {'class': 'adam', 'epsilon': 1e-08} \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... {'class': 'adam', 'epsilon': 1e-08} \n", "\n", - " MLE \\\n", - "Group Experiment \n", - "joint_training/conformer_coupling /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.826781 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.82573 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.825686 \n", + " MLE \\\n", + "Group Experiment \n", + "joint_training/default /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.753013 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.610471 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.758909 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.676933 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.676933 \n", "\n", - " dev MLE \\\n", - "Group Experiment \n", - "joint_training/conformer_coupling /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.846025 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.844433 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.844577 \n", + " dev MLE \\\n", + "Group Experiment \n", + "joint_training/default /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.694853 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.555647 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.694360 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.621956 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.621956 \n", "\n", - " devtrain MLE \\\n", - "Group Experiment \n", - "joint_training/conformer_coupling /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... None \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... None \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... None \n", + " devtrain MLE \\\n", + "Group Experiment \n", + "joint_training/default /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.771774 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.629746 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.778751 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.692515 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.692515 \n", "\n", - " DP loss \\\n", - "Group Experiment \n", - "joint_training/conformer_coupling /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.382039 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.384814 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.389056 \n", + " DP loss \\\n", + "Group Experiment \n", + "joint_training/default /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.417359 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.416831 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.400894 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.328548 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.328548 \n", "\n", - " DP dev loss \\\n", - "Group Experiment \n", - "joint_training/conformer_coupling /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.353906 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.355806 \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.360854 \n", + " DP dev loss \\\n", + "Group Experiment \n", + "joint_training/default /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.565613 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.583815 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.555330 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.477463 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.477463 \n", "\n", - " DP devtrain loss \\\n", - "Group Experiment \n", - "joint_training/conformer_coupling /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... None \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... None \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... None \n", + " DP devtrain loss \\\n", + "Group Experiment \n", + "joint_training/default /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.399888 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.403638 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.379635 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.302857 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.302857 \n", "\n", - " Joint \n", - "Group Experiment \n", - "joint_training/conformer_coupling /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False \n", - " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False " + " Joint \n", + "Group Experiment \n", + "joint_training/default /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... True \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... True \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... True \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... True \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... True " ] }, - "execution_count": 13, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } @@ -999,6 +1045,311 @@ "df.head(5)" ] }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
sWERautoMOSautoMOS confidencenum_epochsdecoder dropoutmean onlyencoder channelsLROptimizerMLEdev MLEdevtrain MLEDP lossDP dev lossDP devtrain lossJoint
GroupExperiment
joint_training/default/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_ctc_scale_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer13.33.1231510.0199402500.05False768[0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08]{'class': 'adam', 'epsilon': 1e-08}-0.753013-0.694853-0.7717740.4173590.5656130.399888True
/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer9.52.7467890.0213472500.05False768[0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08]{'class': 'adam', 'epsilon': 1e-08}-0.610471-0.555647-0.6297460.4168310.5838150.403638True
/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer11.23.1761090.0233882500.05False768[0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08]{'class': 'adam', 'epsilon': 1e-08}-0.758909-0.694360-0.7787510.4008940.5553300.379635True
/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_blstm_x_vector/tuning/lm_4.5/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer16.03.1095570.0211132500.05False768[0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08]{'class': 'adam', 'epsilon': 1e-08}-0.676933-0.621956-0.6925150.3285480.4774630.302857True
/u/lukas.rilling/experiments/glow_tts_asr_v2/output/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_blstm_x_vector/tuning/lm_3.0/tts_eval_gl/test-clean/swer/ls960eow_phon_ctc_50eps_fastsearch/sclite/wer16.03.1095570.0211132500.05False768[0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08]{'class': 'adam', 'epsilon': 1e-08}-0.676933-0.621956-0.6925150.3285480.4774630.302857True
\n", + "
" + ], + "text/plain": [ + " sWER \\\n", + "Group Experiment \n", + "joint_training/default /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 13.3 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 9.5 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 11.2 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 16.0 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 16.0 \n", + "\n", + " autoMOS \\\n", + "Group Experiment \n", + "joint_training/default /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 3.123151 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 2.746789 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 3.176109 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 3.109557 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 3.109557 \n", + "\n", + " autoMOS confidence \\\n", + "Group Experiment \n", + "joint_training/default /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.019940 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.021347 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.023388 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.021113 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.021113 \n", + "\n", + " num_epochs \\\n", + "Group Experiment \n", + "joint_training/default /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 250 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 250 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 250 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 250 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 250 \n", + "\n", + " decoder dropout \\\n", + "Group Experiment \n", + "joint_training/default /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.05 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.05 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.05 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.05 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.05 \n", + "\n", + " mean only \\\n", + "Group Experiment \n", + "joint_training/default /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... False \n", + "\n", + " encoder channels \\\n", + "Group Experiment \n", + "joint_training/default /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 768 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 768 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 768 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 768 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 768 \n", + "\n", + " LR \\\n", + "Group Experiment \n", + "joint_training/default /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] \n", + "\n", + " Optimizer \\\n", + "Group Experiment \n", + "joint_training/default /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... {'class': 'adam', 'epsilon': 1e-08} \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... {'class': 'adam', 'epsilon': 1e-08} \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... {'class': 'adam', 'epsilon': 1e-08} \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... {'class': 'adam', 'epsilon': 1e-08} \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... {'class': 'adam', 'epsilon': 1e-08} \n", + "\n", + " MLE \\\n", + "Group Experiment \n", + "joint_training/default /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.753013 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.610471 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.758909 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.676933 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.676933 \n", + "\n", + " dev MLE \\\n", + "Group Experiment \n", + "joint_training/default /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.694853 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.555647 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.694360 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.621956 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.621956 \n", + "\n", + " devtrain MLE \\\n", + "Group Experiment \n", + "joint_training/default /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.771774 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.629746 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.778751 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.692515 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... -0.692515 \n", + "\n", + " DP loss \\\n", + "Group Experiment \n", + "joint_training/default /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.417359 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.416831 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.400894 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.328548 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.328548 \n", + "\n", + " DP dev loss \\\n", + "Group Experiment \n", + "joint_training/default /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.565613 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.583815 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.555330 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.477463 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.477463 \n", + "\n", + " DP devtrain loss \\\n", + "Group Experiment \n", + "joint_training/default /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.399888 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.403638 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.379635 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.302857 \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... 0.302857 \n", + "\n", + " Joint \n", + "Group Experiment \n", + "joint_training/default /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... True \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... True \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... True \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... True \n", + " /u/lukas.rilling/experiments/glow_tts_asr_v2/ou... True " + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df[df[\"Joint\"]].head(5)" + ] + }, { "cell_type": "code", "execution_count": 14, @@ -1020,62 +1371,60 @@ "name": "stdout", "output_type": "stream", "text": [ - "| | Group | Experiment | sWER | autoMOS | autoMOS confidence | num_epochs | decoder dropout | mean only | encoder channels | LR | Optimizer | MLE | dev MLE | devtrain MLE | DP loss | DP dev loss | DP devtrain loss | Joint |\n", - "|---:|:----------------------------------|:------------------------------------------------------------------------------------------------------------------------|-------:|----------:|---------------------:|-------------:|------------------:|:------------|:-------------------|:-------------------------------------------------|:-------------------------------------|----------:|----------:|---------------:|----------:|--------------:|-------------------:|:--------|\n", - "| 0 | joint_training/conformer_coupling | joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_100ep_pe1/ | 12.4 | 2.94 | nan | 100 | 0.05 | False | 768 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'adam', 'epsilon': 1e-08} | -0.826781 | -0.846025 | | 0.382039 | 0.353906 | | False |\n", - "| 1 | joint_training/conformer_coupling | joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_two_forward_pass/ | 20.9 | 2.45 | nan | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | 0 | 0 | 0 | 0 | 0 | 0 | False |\n", - "| 2 | joint_training/conformer_coupling | joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_x_vector_v2/ | 5.2 | 2.14 | nan | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | 0 | 0 | 0 | 0 | 0 | 0 | False |\n", - "| 3 | joint_training/conformer_coupling | joint_training/conformer_coupling/raw_audio/ddi/glowTTS_100ep_pe1_radam1e-9/ | 14.7 | 2.59 | nan | 100 | 0.05 | False | 768 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.82573 | -0.844433 | | 0.384814 | 0.355806 | | False |\n", - "| 4 | joint_training/conformer_coupling | joint_training/conformer_coupling/raw_audio/ddi/glowTTS_100ep_pe1/ | 14.4 | 2.72 | nan | 100 | 0.05 | False | 768 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'adam', 'epsilon': 1e-08} | -0.825686 | -0.844577 | | 0.389056 | 0.360854 | | False |\n", - "| 5 | joint_training/conformer_coupling | joint_training/conformer_coupling/raw_audio/ddi/glowTTS/ | 97.7 | 1.61 | nan | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.824271 | -0.830326 | | 0.964433 | 0.725438 | | False |\n", - "| 7 | joint_training/conformer_coupling | joint_training/conformer_coupling/raw_audio/ddi/glowTTS_x_vector/ | 99.5 | 1.93 | nan | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.809305 | -0.755239 | -0.813211 | 1.00198 | 1.07779 | 1.04241 | False |\n", - "| 8 | joint_training/conformer_coupling | joint_training/conformer_coupling/raw_audio/ddi/glowTTS_ASR_conformer_x_vector/ | 5.2 | 2.14 | nan | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | 0 | 0 | 0 | 0 | 0 | 0 | False |\n", - "| 23 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/400ep/gin512/dec_drop_0.05/ | 12.9 | 3.33 | 0.02 | 400 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 400: 1e-06] | {'class': 'radam', 'epsilon': 1e-09} | -0.822881 | -0.834023 | -0.844881 | 0.376549 | 0.455059 | 0.340289 | False |\n", - "| 24 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/400ep/dec_drop_0.05/ | 12.9 | 3.33 | 0.02 | 400 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 400: 1e-06] | {'class': 'radam', 'epsilon': 1e-09} | 0 | 0 | 0 | 0 | 0 | 0 | False |\n", - "| 25 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/200ep/dec_drop_0.0/ | 96.2 | 2.29 | nan | 200 | 0 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.813627 | -0.797961 | -0.803228 | 0.975631 | 0.866819 | 0.882062 | False |\n", - "| 26 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/200ep/dec_drop_0.05/ | 14.6 | 3.26 | 0.02 | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.809709 | -0.82178 | -0.830623 | 0.390625 | 0.4432 | 0.357604 | False |\n", - "| 27 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/100ep/dec_drop_0.05/ | 16.3 | 3.18 | 0.02 | 100 | 0.05 | False | 768 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.795013 | -0.809868 | -0.816514 | 0.408781 | 0.440684 | 0.381301 | False |\n", - "| 28 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/200ep_long_cooldown/dec_drop_0.0/ | 16.7 | 3.32 | nan | 200 | 0 | False | 768 | [0: 1e-06, 49: 0.0005, 50: 0.0005, 200: 1e-06] | {'class': 'radam', 'epsilon': 1e-09} | -0.846667 | -0.76151 | -0.845555 | 0.409992 | 0.468342 | 0.378645 | False |\n", - "| 29 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/200ep_long_cooldown/dec_drop_0.05/ | 15.6 | 3.21 | nan | 200 | 0.05 | False | 768 | [0: 1e-06, 49: 0.0005, 50: 0.0005, 200: 1e-06] | {'class': 'radam', 'epsilon': 1e-09} | -0.80793 | -0.820998 | -0.829611 | 0.394024 | 0.448099 | 0.360531 | False |\n", - "| 30 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc192/200ep/dec_drop_0.05/ | 13.3 | 3.3 | nan | 200 | 0.05 | False | 192 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.811426 | -0.824218 | -0.832125 | 0.375146 | 0.412309 | 0.342878 | False |\n", - "| 31 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc192/200ep/dec_drop_0.0/ | 95.4 | 2.41 | nan | 200 | 0 | False | 192 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.841694 | -0.819818 | -0.83016 | 0.965626 | 1.15174 | 1.18063 | False |\n", - "| 32 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc192/200ep/dec_drop_0.05_epsilon_1e-8/ | 96.7 | 2.27 | nan | 200 | 0.05 | False | 192 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-08} | -0.808277 | -0.817505 | -0.821914 | 0.982278 | 0.814173 | 0.826286 | False |\n", - "| 33 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc192/200ep/dec_drop_0.05/ | 98.8 | 1.88 | nan | 200 | 0.05 | False | 192 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.809477 | -0.815064 | -0.819234 | 0.989373 | 0.615026 | 0.622701 | False |\n", - "| 34 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc192/200ep/dec_drop_0.0/grad_clip_10/ | 12.8 | 3.34 | nan | 200 | 0 | False | 192 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.852834 | -0.773976 | -0.851532 | 0.392373 | 0.431975 | 0.362269 | False |\n", - "| 35 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc192/100ep/dec_drop_0.05/ | 98.1 | 1.52 | nan | 100 | 0.05 | False | 192 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.797353 | -0.804897 | -0.808365 | 0.989832 | 0.777391 | 0.784409 | False |\n", - "| 36 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/400ep/grad_clip_10/dec_drop_0.05/ | 14.4 | 3.29 | 0.02 | 400 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 400: 1e-06] | {'class': 'radam', 'epsilon': 1e-09} | 0 | 0 | 0 | 0 | 0 | 0 | False |\n", - "| 37 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/400ep/gin512/grad_clip_10/dec_drop_0.05/ | 14.4 | 3.29 | 0.02 | 400 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 400: 1e-06] | {'class': 'radam', 'epsilon': 1e-09} | -0.824197 | -0.835761 | -0.846551 | 0.372315 | 0.440626 | 0.33371 | False |\n", - "| 38 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/200ep/dec_drop_0.0/epsilon_1e-8/ | 95.9 | 3.06 | nan | 200 | 0 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-08} | -0.82712 | -0.750288 | -0.813842 | 0.979225 | 0.454561 | 0.462357 | False |\n", - "| 39 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/200ep/dec_drop_0.0/grad_clip_10/ | 14.5 | 3.31 | nan | 200 | 0 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.850649 | -0.838267 | -0.849902 | 0.396277 | 0.445801 | 0.364157 | False |\n", - "| 40 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/200ep/dec_drop_0.05_epsilon_1e-8/ | 15.7 | 3.35 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-08} | -0.811807 | -0.826657 | -0.834532 | 0.386067 | 0.438248 | 0.351594 | False |\n", - "| 41 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/200ep/dec_drop_0.05/ | 15.1 | 3.36 | 0.02 | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.812429 | -0.827038 | -0.834987 | 0.387377 | 0.441218 | 0.352695 | False |\n", - "| 42 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/100ep/dec_drop_0.00/ | 16.3 | 3.27 | nan | 100 | 0 | False | 768 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.831177 | -0.821651 | -0.830556 | 0.409946 | 0.437995 | 0.384226 | False |\n", - "| 43 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/100ep/dec_drop_0.05/ | 17.2 | 3.3 | nan | 100 | 0.05 | False | 768 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.798251 | -0.814911 | -0.821276 | 0.397457 | 0.432689 | 0.367326 | False |\n", - "| 44 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2_logdist_loss/ed_scale_0.1/ | 95.8 | 3.09 | nan | 200 | 0.05 | False | 192 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.782615 | -0.779794 | -0.782747 | 1.08489 | 2.0684 | 2.07562 | False |\n", - "| 45 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2_logdist_loss_grad_clip_10/ed_scale_1.0/ | 98.8 | 2.27 | nan | 200 | 0.05 | False | 192 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.743438 | -0.756143 | -0.757724 | 1.13249 | 1.54302 | 1.5535 | False |\n", - "| 46 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2_logdist_loss_grad_clip_10/ed_scale_0.1/ | 95.7 | 3.21 | nan | 200 | 0.05 | False | 192 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.798058 | -0.786642 | -0.791474 | 1.07707 | 1.81449 | 1.83075 | False |\n", - "| 47 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_simple_encoder/12cb/200ep/dec_drop_0.05/ | 70.3 | 3.47 | nan | 200 | 0.05 | False | - | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.80368 | -0.821293 | -0.825658 | 0.428016 | 0.498157 | 0.402439 | False |\n", - "| 48 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_simple_encoder/20cb/200ep/dec_drop_0.05/ | 57.3 | 3.46 | nan | 200 | 0.05 | False | - | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.834191 | -0.847676 | -0.856235 | 0.402502 | 0.472223 | 0.376431 | False |\n", - "| 49 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2_conformer_coupling/enc768/200ep/dec_drop_0.05/ | 9.6 | 1.79 | 0.03 | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.842848 | -0.852489 | -0.860671 | 0.370438 | 0.41724 | 0.344025 | False |\n", - "| 50 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2_multiscale/enc768/200ep/dec_drop_0.05/ | 100 | 1.25 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.785697 | -0.800581 | -0.807986 | 0.533892 | 0.569833 | 0.522571 | False |\n", - "| 51 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_batch_norm/enc768/200ep/dec_drop_0.05/ | 15.1 | 3.4 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.80533 | -0.817184 | -0.826384 | 0.389733 | 0.44642 | 0.357169 | False |\n", - "| 52 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector/enc768/100ep/dec_drop_0.05/ | 97.9 | 1.51 | nan | 100 | 0.05 | False | 768 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.781911 | -0.787168 | -0.790923 | 0.991812 | 1.38362 | 1.38305 | False |\n", - "| 77 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS/enc256/not_silence_preprocessed/ | 97.9 | 1.69 | nan | 200 | 0 | False | 256 | [0: 5e-05, 49: 0.0005, 50: 0.0005, 200: 1e-06] | {'class': 'adam', 'epsilon': 1e-09} | -0.851128 | -0.54391 | | 0.962189 | 0.501158 | | False |\n", - "| 78 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS/enc768/with_sigma/not_silence_preprocessed/ | 15.7 | 3.35 | nan | 200 | 0 | False | 768 | [0: 5e-05, 49: 0.0005, 50: 0.0005, 200: 1e-06] | {'class': 'adam', 'epsilon': 1e-09} | -0.851343 | -0.833649 | | 0.401905 | 0.450686 | | False |\n", - "| 79 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS/enc768/with_sigma/silence_preprocessed/ | 15.3 | 3.4 | nan | 200 | 0 | False | 768 | [0: 5e-05, 49: 0.0005, 50: 0.0005, 200: 1e-06] | {'class': 'adam', 'epsilon': 1e-09} | -0.736796 | -0.463881 | | 0.371603 | 0.409141 | | False |\n", - "| 80 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS/enc768/mean_only/silence_preprocessed/ | 16.9 | 3.52 | nan | 200 | 0 | True | 768 | [0: 5e-05, 49: 0.0005, 50: 0.0005, 200: 1e-06] | {'class': 'adam', 'epsilon': 1e-09} | -0.735579 | -0.714157 | | 0.366752 | 0.410529 | | False |\n", - "| 81 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS/enc768/mean_only/not_silence_preprocessed/ | 15.5 | 3.47 | nan | 200 | 0 | True | 768 | [0: 5e-05, 49: 0.0005, 50: 0.0005, 200: 1e-06] | {'class': 'adam', 'epsilon': 1e-09} | -0.85035 | -0.763903 | | 0.395024 | 0.448581 | | False |\n", - "| 82 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS/enc192/100ep/not_silence_preprocessed/ | 14.3 | 3.31 | nan | 100 | 0 | False | 192 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'adam', 'epsilon': 1e-09} | -0.8365 | -0.770533 | | 0.406652 | 0.423657 | | False |\n", - "| 83 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS/enc192/100ep/silence_preprocessed/ | 13.5 | 3.3 | nan | 100 | 0 | False | 192 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'adam', 'epsilon': 1e-09} | -0.819508 | -0.80574 | | 0.373986 | 0.385518 | | False |\n", - "| 84 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS/enc192/200ep/long_cooldown/not_silence_preprocessed/ | 14.7 | 3.29 | nan | 200 | 0 | False | 192 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 200: 1e-07] | {'class': 'adam', 'epsilon': 1e-08} | -0.839926 | -0.694879 | | 0.411271 | 0.432932 | | False |\n", - "| 85 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS/enc192/200ep/long_cooldown/silence_preprocessed/ | 13.5 | 3.28 | nan | 200 | 0 | False | 192 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 200: 1e-07] | {'class': 'adam', 'epsilon': 1e-08} | -0.82215 | -0.807288 | | 0.377117 | 0.390598 | | False |\n", - "| 86 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS_simple_encoder/silence_preprocessed/ | 56.4 | 3.33 | nan | 100 | 0 | - | - | [0: 0.0001, 49: 0.0005, 50: 0.0005, 100: 1e-06] | {'class': 'radam', 'epsilon': 1e-09} | -0.842638 | -0.822322 | | 0.384891 | 0.428803 | | False |\n", - "| 87 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS_ddi_actnorm/enc192/100ep/not_silence_preprocessed/LR_scheduled/ | 100 | 3.12 | nan | 100 | 0 | False | 192 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'adam', 'epsilon': 1e-09} | -0.837399 | -0.801737 | | 0.42113 | 0.441682 | | False |\n", - "| 88 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS_x_vector/enc768/100ep/not_silence_preprocessed/ | 20.9 | 3.31 | nan | 100 | 0 | False | 768 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'adam', 'epsilon': 1e-09} | -0.810979 | -0.801251 | | 0.459904 | 0.467786 | | False |\n", - "| 89 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS_x_vector/enc192/100ep/not_silence_preprocessed/ | 95.4 | 2.63 | nan | 100 | 0 | False | 192 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'adam', 'epsilon': 1e-09} | -0.805523 | -0.788462 | | 0.972006 | 1.27149 | | False |\n", - "| 90 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS_nar_taco_encoder/not_silence_preprocessed/ | 25.2 | 3.46 | nan | 200 | 0 | - | - | [0: 1e-05, 49: 0.0005, 50: 0.0005, 200: 1e-05] | {'class': 'adam', 'epsilon': 1e-09} | -0.844504 | -0.70768 | | 0.411171 | 0.455673 | | False |\n", - "| 91 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS_nar_taco_encoder/silence_preprocessed/ | 25.9 | 3.39 | nan | 200 | 0 | - | - | [0: 1e-05, 49: 0.0005, 50: 0.0005, 200: 1e-05] | {'class': 'adam', 'epsilon': 1e-09} | -0.829622 | -0.813688 | | 0.386848 | 0.423963 | | False |\n", - "| 92 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS_nar_taco_encoder_no_blstm/silence_preprocessed/ | 105.6 | 3.17 | nan | 100 | 0 | - | - | [0: 0.0001, 49: 0.0005, 50: 0.0001, 100: 1e-06] | {'class': 'radam', 'epsilon': 1e-09} | -0.799977 | -0.788486 | | 0.8847 | 0.873624 | | False |\n" + "| | Group | Experiment | sWER | autoMOS | autoMOS confidence | num_epochs | decoder dropout | mean only | encoder channels | LR | Optimizer | MLE | dev MLE | devtrain MLE | DP loss | DP dev loss | DP devtrain loss | Joint |\n", + "|----:|:----------------------------------|:------------------------------------------------------------------------------------------------------------------------|-------:|----------:|---------------------:|-------------:|------------------:|:------------|:-------------------|:-------------------------------------------------|:-------------------------------------|------:|----------:|---------------:|----------:|--------------:|-------------------:|:--------|\n", + "| 62 | joint_training/conformer_coupling | joint_training/conformer_coupling/raw_audio/ddi/glowTTS_100ep_pe1/ | 14.4 | 2.72 | nan | 100 | 0.05 | False | 768 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'adam', 'epsilon': 1e-08} | -0.83 | -0.84 | nan | 0.39 | 0.36 | nan | False |\n", + "| 63 | joint_training/conformer_coupling | joint_training/conformer_coupling/raw_audio/ddi/glowTTS/ | 97.7 | 1.61 | nan | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.82 | -0.83 | nan | 0.96 | 0.73 | nan | False |\n", + "| 64 | joint_training/conformer_coupling | joint_training/conformer_coupling/raw_audio/ddi/glowTTS_100ep_pe1_radam1e-9/ | 14.7 | 2.59 | nan | 100 | 0.05 | False | 768 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.83 | -0.84 | nan | 0.38 | 0.36 | nan | False |\n", + "| 65 | joint_training/conformer_coupling | joint_training/conformer_coupling/raw_audio/ddi/glowTTS_x_vector/ | 99.5 | 1.93 | nan | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.81 | -0.76 | -0.81 | 1 | 1.08 | 1.04 | False |\n", + "| 66 | joint_training/conformer_coupling | joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_100ep_pe1/ | 12.4 | 2.94 | nan | 100 | 0.05 | False | 768 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'adam', 'epsilon': 1e-08} | -0.83 | -0.85 | nan | 0.38 | 0.35 | nan | False |\n", + "| 68 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2_multiscale/enc768/200ep/dec_drop_0.05/ | 100 | 1.25 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.79 | -0.8 | -0.81 | 0.53 | 0.57 | 0.52 | False |\n", + "| 69 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2_conformer_coupling/enc768/200ep/dec_drop_0.05/ | 9.6 | 1.79 | 0.03 | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.84 | -0.85 | -0.86 | 0.37 | 0.42 | 0.34 | False |\n", + "| 70 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2_logdist_loss/ed_scale_0.1/ | 95.8 | 3.09 | nan | 200 | 0.05 | False | 192 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.78 | -0.78 | -0.78 | 1.08 | 2.07 | 2.08 | False |\n", + "| 71 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_batch_norm/enc768/200ep/dec_drop_0.05/ | 15.1 | 3.4 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.81 | -0.82 | -0.83 | 0.39 | 0.45 | 0.36 | False |\n", + "| 72 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector/enc768/100ep/dec_drop_0.05/ | 97.9 | 1.51 | nan | 100 | 0.05 | False | 768 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.78 | -0.79 | -0.79 | 0.99 | 1.38 | 1.38 | False |\n", + "| 73 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc192/100ep/dec_drop_0.05/ | 98.1 | 1.52 | nan | 100 | 0.05 | False | 192 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.8 | -0.8 | -0.81 | 0.99 | 0.78 | 0.78 | False |\n", + "| 74 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc192/200ep/dec_drop_0.05/ | 98.8 | 1.88 | nan | 200 | 0.05 | False | 192 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.81 | -0.82 | -0.82 | 0.99 | 0.62 | 0.62 | False |\n", + "| 75 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc192/200ep/dec_drop_0.05_epsilon_1e-8/ | 96.7 | 2.27 | nan | 200 | 0.05 | False | 192 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-08} | -0.81 | -0.82 | -0.82 | 0.98 | 0.81 | 0.83 | False |\n", + "| 76 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc192/200ep/dec_drop_0.0/grad_clip_10/ | 12.8 | 3.34 | nan | 200 | 0 | False | 192 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.85 | -0.77 | -0.85 | 0.39 | 0.43 | 0.36 | False |\n", + "| 77 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc192/400ep/grad_clip_10/dec_drop_0.05/ | 11.7 | 3.47 | nan | 400 | 0.05 | False | 192 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 400: 1e-06] | {'class': 'radam', 'epsilon': 1e-09} | -0.82 | -0.84 | -0.85 | 0.37 | 0.42 | 0.33 | False |\n", + "| 78 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/100ep/dec_drop_0.00/ | 16.3 | 3.27 | nan | 100 | 0 | False | 768 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.83 | -0.82 | -0.83 | 0.41 | 0.44 | 0.38 | False |\n", + "| 79 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/100ep/dec_drop_0.05/ | 17.2 | 3.3 | nan | 100 | 0.05 | False | 768 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.8 | -0.81 | -0.82 | 0.4 | 0.43 | 0.37 | False |\n", + "| 80 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/200ep/dec_drop_0.05/ | 15.1 | 3.36 | 0.02 | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.81 | -0.83 | -0.83 | 0.39 | 0.44 | 0.35 | False |\n", + "| 81 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/200ep/dec_drop_0.0/grad_clip_10/ | 14.5 | 3.31 | nan | 200 | 0 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.85 | -0.84 | -0.85 | 0.4 | 0.45 | 0.36 | False |\n", + "| 82 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/200ep/dec_drop_0.0/epsilon_1e-8/ | 95.9 | 3.06 | nan | 200 | 0 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-08} | -0.83 | -0.75 | -0.81 | 0.98 | 0.45 | 0.46 | False |\n", + "| 83 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/200ep/dec_drop_0.05_epsilon_1e-8/ | 15.7 | 3.35 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-08} | -0.81 | -0.83 | -0.83 | 0.39 | 0.44 | 0.35 | False |\n", + "| 84 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/400ep/gin512/grad_clip_10/dec_drop_0.05/ | 14.4 | 3.29 | 0.02 | 400 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 400: 1e-06] | {'class': 'radam', 'epsilon': 1e-09} | -0.82 | -0.84 | -0.85 | 0.37 | 0.44 | 0.33 | False |\n", + "| 85 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS/enc768/400ep/grad_clip_10/dec_drop_0.05/ | 13.3 | 3.35 | 0.02 | 400 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 400: 1e-06] | {'class': 'radam', 'epsilon': 1e-09} | -0.82 | -0.84 | -0.85 | 0.37 | 0.44 | 0.33 | False |\n", + "| 86 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/200ep/dec_drop_0.0/ | 96.2 | 2.29 | nan | 200 | 0 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.81 | -0.8 | -0.8 | 0.98 | 0.87 | 0.88 | False |\n", + "| 87 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/200ep/dec_drop_0.05/ | 14.6 | 3.26 | 0.02 | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.81 | -0.82 | -0.83 | 0.39 | 0.44 | 0.36 | False |\n", + "| 88 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/400ep/gin512/dec_drop_0.05/ | 12.9 | 3.33 | 0.02 | 400 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 400: 1e-06] | {'class': 'radam', 'epsilon': 1e-09} | -0.82 | -0.83 | -0.84 | 0.38 | 0.46 | 0.34 | False |\n", + "| 89 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/400ep/dec_drop_0.05/ | 13.1 | 3.3 | 0.02 | 400 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 400: 1e-06] | {'class': 'radam', 'epsilon': 1e-09} | -0.82 | -0.83 | -0.84 | 0.38 | 0.46 | 0.34 | False |\n", + "| 90 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/200ep_long_cooldown/dec_drop_0.05/ | 15.6 | 3.21 | nan | 200 | 0.05 | False | 768 | [0: 1e-06, 49: 0.0005, 50: 0.0005, 200: 1e-06] | {'class': 'radam', 'epsilon': 1e-09} | -0.81 | -0.82 | -0.83 | 0.39 | 0.45 | 0.36 | False |\n", + "| 91 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/200ep_long_cooldown/dec_drop_0.0/ | 16.7 | 3.32 | nan | 200 | 0 | False | 768 | [0: 1e-06, 49: 0.0005, 50: 0.0005, 200: 1e-06] | {'class': 'radam', 'epsilon': 1e-09} | -0.85 | -0.76 | -0.85 | 0.41 | 0.47 | 0.38 | False |\n", + "| 92 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc768/100ep/dec_drop_0.05/ | 16.3 | 3.18 | 0.02 | 100 | 0.05 | False | 768 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.8 | -0.81 | -0.82 | 0.41 | 0.44 | 0.38 | False |\n", + "| 93 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc192/200ep/dec_drop_0.0/ | 95.4 | 2.41 | nan | 200 | 0 | False | 192 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.84 | -0.82 | -0.83 | 0.97 | 1.15 | 1.18 | False |\n", + "| 94 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2/enc192/200ep/dec_drop_0.05/ | 13.3 | 3.3 | nan | 200 | 0.05 | False | 192 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.81 | -0.82 | -0.83 | 0.38 | 0.41 | 0.34 | False |\n", + "| 95 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2_logdist_loss_grad_clip_10/ed_scale_0.1/ | 95.7 | 3.21 | nan | 200 | 0.05 | False | 192 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.8 | -0.79 | -0.79 | 1.08 | 1.81 | 1.83 | False |\n", + "| 96 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_x_vector_v2_logdist_loss_grad_clip_10/ed_scale_1.0/ | 98.8 | 2.27 | nan | 200 | 0.05 | False | 192 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.74 | -0.76 | -0.76 | 1.13 | 1.54 | 1.55 | False |\n", + "| 97 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_simple_encoder/20cb/200ep/dec_drop_0.05/ | 57.3 | 3.46 | nan | 200 | 0.05 | False | - | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.83 | -0.85 | -0.86 | 0.4 | 0.47 | 0.38 | False |\n", + "| 98 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/TTS_models/glowTTS_simple_encoder/12cb/200ep/dec_drop_0.05/ | 70.3 | 3.47 | nan | 200 | 0.05 | False | - | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.8 | -0.82 | -0.83 | 0.43 | 0.5 | 0.4 | False |\n", + "| 123 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS_simple_encoder/silence_preprocessed/ | 56.4 | 3.33 | nan | 100 | 0 | - | - | [0: 0.0001, 49: 0.0005, 50: 0.0005, 100: 1e-06] | {'class': 'radam', 'epsilon': 1e-09} | -0.84 | -0.82 | nan | 0.38 | 0.43 | nan | False |\n", + "| 124 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS/enc192/200ep/long_cooldown/not_silence_preprocessed/ | 14.7 | 3.29 | nan | 200 | 0 | False | 192 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 200: 1e-07] | {'class': 'adam', 'epsilon': 1e-08} | -0.84 | -0.69 | nan | 0.41 | 0.43 | nan | False |\n", + "| 125 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS/enc192/200ep/long_cooldown/silence_preprocessed/ | 13.5 | 3.28 | nan | 200 | 0 | False | 192 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 200: 1e-07] | {'class': 'adam', 'epsilon': 1e-08} | -0.82 | -0.81 | nan | 0.38 | 0.39 | nan | False |\n", + "| 126 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS/enc192/100ep/not_silence_preprocessed/ | 14.3 | 3.31 | nan | 100 | 0 | False | 192 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'adam', 'epsilon': 1e-09} | -0.84 | -0.77 | nan | 0.41 | 0.42 | nan | False |\n", + "| 127 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS/enc192/100ep/silence_preprocessed/ | 13.5 | 3.3 | nan | 100 | 0 | False | 192 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'adam', 'epsilon': 1e-09} | -0.82 | -0.81 | nan | 0.37 | 0.39 | nan | False |\n", + "| 128 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS/enc768/mean_only/not_silence_preprocessed/ | 15.5 | 3.47 | nan | 200 | 0 | True | 768 | [0: 5e-05, 49: 0.0005, 50: 0.0005, 200: 1e-06] | {'class': 'adam', 'epsilon': 1e-09} | -0.85 | -0.76 | nan | 0.4 | 0.45 | nan | False |\n", + "| 129 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS/enc768/mean_only/silence_preprocessed/ | 16.9 | 3.52 | nan | 200 | 0 | True | 768 | [0: 5e-05, 49: 0.0005, 50: 0.0005, 200: 1e-06] | {'class': 'adam', 'epsilon': 1e-09} | -0.74 | -0.71 | nan | 0.37 | 0.41 | nan | False |\n", + "| 130 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS/enc768/with_sigma/silence_preprocessed/ | 15.3 | 3.4 | nan | 200 | 0 | False | 768 | [0: 5e-05, 49: 0.0005, 50: 0.0005, 200: 1e-06] | {'class': 'adam', 'epsilon': 1e-09} | -0.74 | -0.46 | nan | 0.37 | 0.41 | nan | False |\n", + "| 131 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS/enc768/with_sigma/not_silence_preprocessed/ | 15.7 | 3.35 | nan | 200 | 0 | False | 768 | [0: 5e-05, 49: 0.0005, 50: 0.0005, 200: 1e-06] | {'class': 'adam', 'epsilon': 1e-09} | -0.85 | -0.83 | nan | 0.4 | 0.45 | nan | False |\n", + "| 132 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS/enc256/not_silence_preprocessed/ | 97.9 | 1.69 | nan | 200 | 0 | False | 256 | [0: 5e-05, 49: 0.0005, 50: 0.0005, 200: 1e-06] | {'class': 'adam', 'epsilon': 1e-09} | -0.85 | -0.54 | nan | 0.96 | 0.5 | nan | False |\n", + "| 133 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS_nar_taco_encoder/silence_preprocessed/ | 25.9 | 3.39 | nan | 200 | 0 | - | - | [0: 1e-05, 49: 0.0005, 50: 0.0005, 200: 1e-05] | {'class': 'adam', 'epsilon': 1e-09} | -0.83 | -0.81 | nan | 0.39 | 0.42 | nan | False |\n", + "| 134 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS_nar_taco_encoder/not_silence_preprocessed/ | 25.2 | 3.46 | nan | 200 | 0 | - | - | [0: 1e-05, 49: 0.0005, 50: 0.0005, 200: 1e-05] | {'class': 'adam', 'epsilon': 1e-09} | -0.84 | -0.71 | nan | 0.41 | 0.46 | nan | False |\n", + "| 135 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS_nar_taco_encoder_no_blstm/silence_preprocessed/ | 105.6 | 3.17 | nan | 100 | 0 | - | - | [0: 0.0001, 49: 0.0005, 50: 0.0001, 100: 1e-06] | {'class': 'radam', 'epsilon': 1e-09} | -0.8 | -0.79 | nan | 0.88 | 0.87 | nan | False |\n", + "| 136 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS_x_vector/enc768/100ep/not_silence_preprocessed/ | 20.9 | 3.31 | nan | 100 | 0 | False | 768 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'adam', 'epsilon': 1e-09} | -0.81 | -0.8 | nan | 0.46 | 0.47 | nan | False |\n", + "| 137 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS_x_vector/enc192/100ep/not_silence_preprocessed/ | 95.4 | 2.63 | nan | 100 | 0 | False | 192 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'adam', 'epsilon': 1e-09} | -0.81 | -0.79 | nan | 0.97 | 1.27 | nan | False |\n", + "| 138 | tts_architecture | tts_architecture/glow_tts/raw_audio/glowTTS_ddi_actnorm/enc192/100ep/not_silence_preprocessed/LR_scheduled/ | 100 | 3.12 | nan | 100 | 0 | False | 192 | [0: 1e-05, 49: 0.0005, 50: 0.0005, 100: 1e-05] | {'class': 'adam', 'epsilon': 1e-09} | -0.84 | -0.8 | nan | 0.42 | 0.44 | nan | False |\n" ] } ], @@ -1092,47 +1441,95 @@ "name": "stdout", "output_type": "stream", "text": [ - "| | Group | Experiment | sWER | autoMOS | autoMOS confidence | num_epochs | decoder dropout | mean only | encoder channels | LR | Optimizer | MLE | dev MLE | devtrain MLE | DP loss | DP dev loss | DP devtrain loss | Joint |\n", - "|---:|:----------------------------------|:----------------------------------------------------------------------------------------------------------------------------------------------------|-------:|----------:|---------------------:|-------------:|------------------:|:------------|-------------------:|:-------------------------------------------------|:-------------------------------------|----------:|----------:|---------------:|----------:|--------------:|-------------------:|:--------|\n", - "| 6 | joint_training/conformer_coupling | joint_training/conformer_coupling/raw_audio/ddi/glowTTS_ASR_conformer_two_forward_pass/ | 95.7 | 1.82 | nan | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.657168 | | -0.670671 | 1.0046 | | 2.09134 | True |\n", - "| 9 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1/ | 4.6 | 3.11 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.74139 | -0.690156 | -0.759844 | 0.346902 | 0.481245 | 0.329289 | True |\n", - "| 10 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass/ | 9.5 | 2.75 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.610471 | -0.555647 | -0.629746 | 0.416831 | 0.583815 | 0.403638 | True |\n", - "| 11 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/ | 11.2 | 3.18 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.758909 | -0.69436 | -0.778751 | 0.400894 | 0.55533 | 0.379635 | True |\n", - "| 12 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_ctc_scale_0.1/ | 13.3 | 3.12 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.753013 | -0.694853 | -0.771774 | 0.417359 | 0.565613 | 0.399888 | True |\n", - "| 13 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment/ | 5.2 | 2.3 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.506816 | -0.458788 | -0.521236 | 0.245737 | 0.346906 | 0.225934 | True |\n", - "| 14 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/ | 9.9 | 2.64 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.621646 | -0.565345 | -0.641523 | 0.402243 | 0.552866 | 0.379653 | True |\n", - "| 15 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/ | 7.9 | 3.19 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.754171 | -0.704233 | -0.772961 | 0.369618 | 0.50542 | 0.346386 | True |\n", - "| 16 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/ | 6.7 | 2.48 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.577228 | -0.531676 | -0.591349 | 0.349734 | 0.46387 | 0.326762 | True |\n", - "| 17 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_ctc_scale_0.1/ | 7.6 | 3.15 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.750811 | -0.700515 | -0.769183 | 0.380467 | 0.502884 | 0.36247 | True |\n", - "| 18 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/ | 4.4 | 3.2 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.745622 | -0.693835 | -0.764738 | 0.330255 | 0.457476 | 0.306534 | True |\n", - "| 19 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/ | 14.8 | 2.61 | 0.03 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.679734 | | -0.699266 | 0.399065 | | 0.370426 | True |\n", - "| 20 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/ | 6 | 2.32 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.520932 | -0.470559 | -0.535346 | 0.229065 | 0.345538 | 0.203592 | True |\n", - "| 21 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/ | 15.2 | 3.16 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.784652 | | -0.805268 | 0.383526 | | 0.355401 | True |\n", - "| 22 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector/ | 98 | 1.58 | 0.01 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.552728 | -0.497187 | -0.548408 | 1.01904 | 0.823625 | 0.701494 | True |\n", - "| 53 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/specaug/ce_ls_0.1/ | 25.2 | 3.11 | nan | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.802836 | -0.81678 | -0.823897 | 0.434087 | 0.464465 | 0.407059 | True |\n", - "| 54 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/specaug/ce_ls_1/ | 88.5 | 1.87 | nan | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.72108 | -0.734634 | -0.74084 | 0.747725 | 0.789389 | 0.691204 | True |\n", - "| 55 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/200ep/basic_init/no_specaug/tts_target_size/ce_ls_0.1/ | 98.1 | 1.82 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.785492 | -0.790627 | -0.79625 | 0.890597 | 0.574966 | 0.575373 | True |\n", - "| 56 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/200ep/tts_pretrained/no_specaug/tts_target_size/ce_ls_0.1/ | 32.9 | 2.77 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.803716 | -0.816318 | -0.825113 | 0.439343 | 0.490279 | 0.409061 | True |\n", - "| 57 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/no_specaug/ce_ls_1/ | 83.9 | 1.92 | nan | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.690569 | -0.702706 | -0.708801 | 0.760198 | 0.943391 | 0.716967 | True |\n", - "| 58 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/no_specaug/ce_ls_0.1/ | 41.9 | 2.75 | nan | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.794999 | -0.80951 | -0.816001 | 0.505974 | 0.538897 | 0.493393 | True |\n", - "| 59 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_cnn_x_vector/tts_pretrained/no_specaug/tts_target_size/ce_ls_0.1/ | 14.1 | 3.2 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.793062 | -0.805013 | -0.81407 | 0.39621 | 0.451179 | 0.36325 | True |\n", - "| 60 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_cnn_x_vector/basic_init/no_specaug/tts_target_size/ce_ls_0.1/ | 23.3 | 3.13 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.77557 | -0.785888 | -0.794856 | 0.432057 | 0.483314 | 0.399083 | True |\n", - "| 61 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/mean_only/200ep/basic_init/no_specaug/tts_target_size/ce_ls_0.1/ | 96.4 | 2.37 | nan | 200 | 0.05 | True | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.803728 | -0.802102 | -0.808006 | 0.932394 | 0.721534 | 0.725609 | True |\n", - "| 62 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/200ep/tts_pretrained/no_specaug/tts_target_size/ce_ls_0.1/ | 91.7 | 2.66 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.805783 | -0.821988 | -0.827055 | 0.625962 | 0.62989 | 0.592278 | True |\n", - "| 63 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/no_specaug/tts_target_size/ce_ls_1.0/ | 97.2 | 2.12 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.801181 | -0.803144 | -0.808404 | 0.834689 | 0.611662 | 0.619833 | True |\n", - "| 64 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/no_specaug/tts_target_size/ce_ls_0.1/ | 99.9 | 1.56 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.799504 | -0.772613 | -0.798104 | 0.818331 | 0.531823 | 0.536853 | True |\n", - "| 65 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector_v2/tts_pretrained/ce_ls_0.1/ | 99.7 | 1.83 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.790621 | -0.805995 | -0.811551 | 0.0523576 | 0.0489216 | 0.0415039 | True |\n", - "| 66 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector_v2/tts_pretrained/ce_ls_0.01/ | 97.2 | 1.97 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.797074 | -0.812303 | -0.818065 | 0.0631472 | 0.0577708 | 0.0508676 | True |\n", - "| 67 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector_v2/basic_init/ce_ls_0.1/ | 99.1 | 1.64 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.782616 | -0.797878 | -0.803697 | 0.0519058 | 0.0493118 | 0.0413708 | True |\n", - "| 68 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector_v2/basic_init/ce_ls_0.01/ | 98.2 | 2.18 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.787278 | -0.802672 | -0.808277 | 0.0638544 | 0.0582362 | 0.0520775 | True |\n", - "| 69 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector_v2/200ep/tts_pretrained/ce_ls_1.0/ | 100 | 1.97 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.72889 | -0.745734 | -0.75171 | 0.075977 | 0.0820037 | 0.0666421 | True |\n", - "| 70 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector_v2/200ep/tts_pretrained/ce_ls_0.1/ | 100 | 1.98 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.760167 | -0.775606 | -0.781364 | 0.075069 | 0.0806164 | 0.0651269 | True |\n", - "| 71 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/ce_ls_1.0/ | 100 | 1.98 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.729906 | -0.74441 | -0.750384 | 0.0698329 | 0.0841703 | 0.0607633 | True |\n", - "| 72 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/ce_ls_0.1/ | 100 | 1.98 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.757141 | -0.771994 | -0.778037 | 0.071102 | 0.0818373 | 0.0614895 | True |\n", - "| 73 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector/200ep/basic_init/ce_ls_0.1/ | 97.9 | 1.78 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.779347 | -0.79411 | -0.800602 | 0.255822 | 0.238816 | 0.246318 | True |\n", - "| 74 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector/200ep/tts_pretrained/ce_ls_0.1/ | 95.4 | 2.53 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.792338 | -0.806682 | -0.812767 | 0.247139 | 0.215995 | 0.232498 | True |\n", - "| 75 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector/tts_pretrained/ce_ls_0.1/ | 95.2 | 2.18 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.775121 | -0.788423 | -0.794789 | 0.263264 | 0.235715 | 0.253516 | True |\n", - "| 76 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector/basic_init/ce_ls_0.1/ | 96.1 | 2.35 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.76667 | -0.781423 | -0.785757 | 0.265068 | 0.264766 | 0.261945 | True |\n" + "| | Group | Experiment | sWER | autoMOS | autoMOS confidence | num_epochs | decoder dropout | mean only | encoder channels | LR | Optimizer | MLE | dev MLE | devtrain MLE | DP loss | DP dev loss | DP devtrain loss | Joint |\n", + "|----:|:----------------------------------|:----------------------------------------------------------------------------------------------------------------------------------------------------|-------:|----------:|---------------------:|-------------:|------------------:|:------------|-------------------:|:-------------------------------------------------|:-------------------------------------|------:|----------:|---------------:|----------:|--------------:|-------------------:|:--------|\n", + "| 0 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_ctc_scale_0.1/ | 13.3 | 3.12 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.75 | -0.69 | -0.77 | 0.42 | 0.57 | 0.4 | True |\n", + "| 1 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass/ | 9.5 | 2.75 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.61 | -0.56 | -0.63 | 0.42 | 0.58 | 0.4 | True |\n", + "| 2 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2_ctc_scale_0.1/ | 11.2 | 3.18 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.76 | -0.69 | -0.78 | 0.4 | 0.56 | 0.38 | True |\n", + "| 3 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_blstm_x_vector/tuning/lm_4.5/ | 16 | 3.11 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.68 | -0.62 | -0.69 | 0.33 | 0.48 | 0.3 | True |\n", + "| 4 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_blstm_x_vector/tuning/lm_3.0/ | 16 | 3.11 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.68 | -0.62 | -0.69 | 0.33 | 0.48 | 0.3 | True |\n", + "| 5 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_blstm_x_vector/tuning/lm_2.0/ | 16 | 3.11 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.68 | -0.62 | -0.69 | 0.33 | 0.48 | 0.3 | True |\n", + "| 6 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_blstm_x_vector/tuning/lm_3.5/ | 16 | 3.11 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.68 | -0.62 | -0.69 | 0.33 | 0.48 | 0.3 | True |\n", + "| 7 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_blstm_x_vector/tuning/lm_2.5/ | 16 | 3.11 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.68 | -0.62 | -0.69 | 0.33 | 0.48 | 0.3 | True |\n", + "| 8 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_blstm_x_vector/tuning/lm_4.0/ | 16 | 3.11 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.68 | -0.62 | -0.69 | 0.33 | 0.48 | 0.3 | True |\n", + "| 9 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_blstm_x_vector/ | 16 | 3.11 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.68 | -0.62 | -0.69 | 0.33 | 0.48 | 0.3 | True |\n", + "| 10 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment_ctc_scale_0.1/ | 4.6 | 3.11 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.74 | -0.69 | -0.76 | 0.35 | 0.48 | 0.33 | True |\n", + "| 11 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/ | 4.4 | 3.2 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.75 | -0.69 | -0.76 | 0.33 | 0.46 | 0.31 | True |\n", + "| 12 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/ | 14.8 | 2.61 | 0.03 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.68 | nan | -0.7 | 0.4 | nan | 0.37 | True |\n", + "| 13 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_two_forward_pass_v2/ | 9.9 | 2.64 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.62 | -0.57 | -0.64 | 0.4 | 0.55 | 0.38 | True |\n", + "| 14 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_ctc_scale_0.1/ | 7.6 | 3.15 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.75 | -0.7 | -0.77 | 0.38 | 0.5 | 0.36 | True |\n", + "| 15 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/ | 6.7 | 2.48 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.58 | -0.53 | -0.59 | 0.35 | 0.46 | 0.33 | True |\n", + "| 16 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_blstm_x_vector_specaug/ | 6.3 | 3.01 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.62 | -0.56 | -0.64 | 0.23 | 0.38 | 0.2 | True |\n", + "| 17 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_0.1/ | 16.1 | 3.22 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.79 | nan | -0.81 | 0.39 | nan | 0.37 | True |\n", + "| 18 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_0.1/tuned/ | 16.1 | 3.22 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.79 | nan | -0.81 | 0.39 | nan | 0.37 | True |\n", + "| 19 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_0.1/tuning/lm_3.5_ps_0.5/ | 16.1 | 3.22 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.79 | nan | -0.81 | 0.39 | nan | 0.37 | True |\n", + "| 20 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_0.1/tuning/lm_3.0_ps_0.3/ | 16.1 | 3.22 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.79 | nan | -0.81 | 0.39 | nan | 0.37 | True |\n", + "| 21 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_0.1/tuning/lm_3.5_ps_0/ | 16.1 | 3.22 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.79 | nan | -0.81 | 0.39 | nan | 0.37 | True |\n", + "| 22 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_0.1/tuning/lm_4.5_ps_0.5/ | 16.1 | 3.22 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.79 | nan | -0.81 | 0.39 | nan | 0.37 | True |\n", + "| 23 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_0.1/tuning/lm_4.0_ps_0.3/ | 16.1 | 3.22 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.79 | nan | -0.81 | 0.39 | nan | 0.37 | True |\n", + "| 24 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_0.1/tuning/lm_2.0_ps_0.3/ | 16.1 | 3.22 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.79 | nan | -0.81 | 0.39 | nan | 0.37 | True |\n", + "| 25 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_0.1/tuning/lm_3.0_ps_0/ | 16.1 | 3.22 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.79 | nan | -0.81 | 0.39 | nan | 0.37 | True |\n", + "| 26 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_0.1/tuning/lm_2.5_ps_0.5/ | 16.1 | 3.22 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.79 | nan | -0.81 | 0.39 | nan | 0.37 | True |\n", + "| 27 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_0.1/tuning/lm_3.5_ps_0.3/ | 16.1 | 3.22 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.79 | nan | -0.81 | 0.39 | nan | 0.37 | True |\n", + "| 28 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_0.1/tuning/lm_2.0_ps_0/ | 16.1 | 3.22 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.79 | nan | -0.81 | 0.39 | nan | 0.37 | True |\n", + "| 29 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_0.1/tuning/lm_4.5_ps_0/ | 16.1 | 3.22 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.79 | nan | -0.81 | 0.39 | nan | 0.37 | True |\n", + "| 30 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_0.1/tuning/lm_3.0_ps_0.5/ | 16.1 | 3.22 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.79 | nan | -0.81 | 0.39 | nan | 0.37 | True |\n", + "| 31 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_0.1/tuning/lm_4.5_ps_0.3/ | 16.1 | 3.22 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.79 | nan | -0.81 | 0.39 | nan | 0.37 | True |\n", + "| 32 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_0.1/tuning/lm_4.0_ps_0.5/ | 16.1 | 3.22 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.79 | nan | -0.81 | 0.39 | nan | 0.37 | True |\n", + "| 33 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_0.1/tuning/lm_2.0_ps_0.5/ | 16.1 | 3.22 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.79 | nan | -0.81 | 0.39 | nan | 0.37 | True |\n", + "| 34 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_0.1/tuning/lm_2.5_ps_0.3/ | 16.1 | 3.22 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.79 | nan | -0.81 | 0.39 | nan | 0.37 | True |\n", + "| 35 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_0.1/tuning/lm_4.0_ps_0/ | 16.1 | 3.22 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.79 | nan | -0.81 | 0.39 | nan | 0.37 | True |\n", + "| 36 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_0.1/tuning/lm_2.5_ps_0/ | 16.1 | 3.22 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.79 | nan | -0.81 | 0.39 | nan | 0.37 | True |\n", + "| 37 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/ | 15.2 | 3.16 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.78 | nan | -0.81 | 0.38 | nan | 0.36 | True |\n", + "| 38 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/ | 7.9 | 3.19 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.75 | -0.7 | -0.77 | 0.37 | 0.51 | 0.35 | True |\n", + "| 39 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector/ | 98 | 1.58 | 0.01 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.55 | -0.5 | -0.55 | 1.02 | 0.82 | 0.7 | True |\n", + "| 40 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment/ | 6 | 2.32 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.52 | -0.47 | -0.54 | 0.23 | 0.35 | 0.2 | True |\n", + "| 41 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_1.0/tuning/lm_3.5_ps_0/ | 15.8 | 3.01 | 0.03 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.74 | nan | -0.76 | 0.39 | nan | 0.36 | True |\n", + "| 42 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_1.0/tuning/lm_3.0_ps_0.5/ | 15.8 | 3.01 | 0.03 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.74 | nan | -0.76 | 0.39 | nan | 0.36 | True |\n", + "| 43 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_1.0/tuning/lm_3.5_ps_0.3/ | 15.8 | 3.01 | 0.03 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.74 | nan | -0.76 | 0.39 | nan | 0.36 | True |\n", + "| 44 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_1.0/tuning/lm_4.0_ps_0.5/ | 15.8 | 3.01 | 0.03 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.74 | nan | -0.76 | 0.39 | nan | 0.36 | True |\n", + "| 45 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_1.0/tuning/lm_4.5_ps_0.3/ | 15.8 | 3.01 | 0.03 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.74 | nan | -0.76 | 0.39 | nan | 0.36 | True |\n", + "| 46 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_1.0/tuning/lm_2.5_ps_0.3/ | 15.8 | 3.01 | 0.03 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.74 | nan | -0.76 | 0.39 | nan | 0.36 | True |\n", + "| 47 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_1.0/tuning/lm_2.0_ps_0.5/ | 15.8 | 3.01 | 0.03 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.74 | nan | -0.76 | 0.39 | nan | 0.36 | True |\n", + "| 48 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_1.0/tuning/lm_3.0_ps_0/ | 15.8 | 3.01 | 0.03 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.74 | nan | -0.76 | 0.39 | nan | 0.36 | True |\n", + "| 49 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_1.0/tuning/lm_3.0_ps_0.3/ | 15.8 | 3.01 | 0.03 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.74 | nan | -0.76 | 0.39 | nan | 0.36 | True |\n", + "| 50 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_1.0/tuning/lm_3.5_ps_0.5/ | 15.8 | 3.01 | 0.03 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.74 | nan | -0.76 | 0.39 | nan | 0.36 | True |\n", + "| 51 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_1.0/tuning/lm_2.0_ps_0/ | 15.8 | 3.01 | 0.03 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.74 | nan | -0.76 | 0.39 | nan | 0.36 | True |\n", + "| 52 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_1.0/tuning/lm_4.0_ps_0.3/ | 15.8 | 3.01 | 0.03 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.74 | nan | -0.76 | 0.39 | nan | 0.36 | True |\n", + "| 53 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_1.0/tuning/lm_4.5_ps_0/ | 15.8 | 3.01 | 0.03 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.74 | nan | -0.76 | 0.39 | nan | 0.36 | True |\n", + "| 54 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_1.0/tuning/lm_4.5_ps_0.5/ | 15.8 | 3.01 | 0.03 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.74 | nan | -0.76 | 0.39 | nan | 0.36 | True |\n", + "| 55 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_1.0/tuning/lm_4.0_ps_0/ | 15.8 | 3.01 | 0.03 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.74 | nan | -0.76 | 0.39 | nan | 0.36 | True |\n", + "| 56 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_1.0/tuning/lm_2.5_ps_0.5/ | 15.8 | 3.01 | 0.03 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.74 | nan | -0.76 | 0.39 | nan | 0.36 | True |\n", + "| 57 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_1.0/tuning/lm_2.0_ps_0.3/ | 15.8 | 3.01 | 0.03 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.74 | nan | -0.76 | 0.39 | nan | 0.36 | True |\n", + "| 58 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_1.0/tuning/lm_2.5_ps_0/ | 15.8 | 3.01 | 0.03 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.74 | nan | -0.76 | 0.39 | nan | 0.36 | True |\n", + "| 59 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_1.0/tuned/ | 15.8 | 3.01 | 0.03 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.74 | nan | -0.76 | 0.39 | nan | 0.36 | True |\n", + "| 60 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_1.0/ | 15.8 | 3.01 | 0.03 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.74 | nan | -0.76 | 0.39 | nan | 0.36 | True |\n", + "| 61 | joint_training/default | joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_spec_augment/ | 5.2 | 2.3 | 0.02 | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.51 | -0.46 | -0.52 | 0.25 | 0.35 | 0.23 | True |\n", + "| 67 | joint_training/conformer_coupling | joint_training/conformer_coupling/raw_audio/no_ddi/glowTTS_ASR_conformer_x_vector_v2/ | 4.2 | 2.05 | nan | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.79 | -0.74 | -0.8 | 0.33 | 0.46 | 0.31 | True |\n", + "| 99 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector_v2/200ep/tts_pretrained/ce_ls_0.1/ | 100 | 1.98 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.76 | -0.78 | -0.78 | 0.08 | 0.08 | 0.07 | True |\n", + "| 100 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector_v2/200ep/tts_pretrained/ce_ls_1.0/ | 100 | 1.97 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.73 | -0.75 | -0.75 | 0.08 | 0.08 | 0.07 | True |\n", + "| 101 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/ce_ls_0.1/ | 100 | 1.98 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.76 | -0.77 | -0.78 | 0.07 | 0.08 | 0.06 | True |\n", + "| 102 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/ce_ls_1.0/ | 100 | 1.98 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.73 | -0.74 | -0.75 | 0.07 | 0.08 | 0.06 | True |\n", + "| 103 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector_v2/tts_pretrained/ce_ls_0.01/ | 97.2 | 1.97 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.8 | -0.81 | -0.82 | 0.06 | 0.06 | 0.05 | True |\n", + "| 104 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector_v2/tts_pretrained/ce_ls_0.1/ | 99.7 | 1.83 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.79 | -0.81 | -0.81 | 0.05 | 0.05 | 0.04 | True |\n", + "| 105 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector_v2/basic_init/ce_ls_0.01/ | 98.2 | 2.18 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.79 | -0.8 | -0.81 | 0.06 | 0.06 | 0.05 | True |\n", + "| 106 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector_v2/basic_init/ce_ls_0.1/ | 99.1 | 1.64 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.78 | -0.8 | -0.8 | 0.05 | 0.05 | 0.04 | True |\n", + "| 107 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector/200ep/tts_pretrained/ce_ls_0.1/ | 95.4 | 2.53 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.79 | -0.81 | -0.81 | 0.25 | 0.22 | 0.23 | True |\n", + "| 108 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_ffn_x_vector/200ep/basic_init/ce_ls_0.1/ | 97.9 | 1.78 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.78 | -0.79 | -0.8 | 0.26 | 0.24 | 0.25 | True |\n", + "| 109 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector/tts_pretrained/ce_ls_0.1/ | 95.2 | 2.18 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.78 | -0.79 | -0.79 | 0.26 | 0.24 | 0.25 | True |\n", + "| 110 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/flow_given_alignment/ga_glowTTS_ASR_cnn_x_vector/basic_init/ce_ls_0.1/ | 96.1 | 2.35 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.77 | -0.78 | -0.79 | 0.27 | 0.26 | 0.26 | True |\n", + "| 111 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_cnn_x_vector/tts_pretrained/no_specaug/tts_target_size/ce_ls_0.1/ | 14.1 | 3.2 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.79 | -0.81 | -0.81 | 0.4 | 0.45 | 0.36 | True |\n", + "| 112 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_cnn_x_vector/basic_init/no_specaug/tts_target_size/ce_ls_0.1/ | 23.3 | 3.13 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.78 | -0.79 | -0.79 | 0.43 | 0.48 | 0.4 | True |\n", + "| 113 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/mean_only/200ep/basic_init/no_specaug/tts_target_size/ce_ls_0.1/ | 96.4 | 2.37 | nan | 200 | 0.05 | True | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.8 | -0.8 | -0.81 | 0.93 | 0.72 | 0.73 | True |\n", + "| 114 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/200ep/tts_pretrained/no_specaug/tts_target_size/ce_ls_0.1/ | 91.7 | 2.66 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.81 | -0.82 | -0.83 | 0.63 | 0.63 | 0.59 | True |\n", + "| 115 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/no_specaug/tts_target_size/ce_ls_0.1/ | 99.9 | 1.56 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.8 | -0.77 | -0.8 | 0.82 | 0.53 | 0.54 | True |\n", + "| 116 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector_v2/200ep/basic_init/no_specaug/tts_target_size/ce_ls_1.0/ | 97.2 | 2.12 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.8 | -0.8 | -0.81 | 0.83 | 0.61 | 0.62 | True |\n", + "| 117 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/200ep/basic_init/no_specaug/tts_target_size/ce_ls_0.1/ | 98.1 | 1.82 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.79 | -0.79 | -0.8 | 0.89 | 0.57 | 0.58 | True |\n", + "| 118 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/200ep/tts_pretrained/no_specaug/tts_target_size/ce_ls_0.1/ | 32.9 | 2.77 | nan | 200 | 0.05 | False | 768 | [0: 1e-05, 99: 0.0005, 100: 0.0005, 200: 1e-05] | {'class': 'radam', 'epsilon': 1e-09} | -0.8 | -0.82 | -0.83 | 0.44 | 0.49 | 0.41 | True |\n", + "| 119 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/no_specaug/ce_ls_1/ | 83.9 | 1.92 | nan | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.69 | -0.7 | -0.71 | 0.76 | 0.94 | 0.72 | True |\n", + "| 120 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/no_specaug/ce_ls_0.1/ | 41.9 | 2.75 | nan | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.79 | -0.81 | -0.82 | 0.51 | 0.54 | 0.49 | True |\n", + "| 121 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/specaug/ce_ls_1/ | 88.5 | 1.87 | nan | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.72 | -0.73 | -0.74 | 0.75 | 0.79 | 0.69 | True |\n", + "| 122 | joint_training/given_alignments | joint_training/given_alignments/raw_audio/joint_models/glowTTS_ASR_ffn_x_vector/specaug/ce_ls_0.1/ | 25.2 | 3.11 | nan | 250 | 0.05 | False | 768 | [0: 7e-06, 109: 0.0007, 110: 0.0007, 250: 1e-08] | {'class': 'adam', 'epsilon': 1e-08} | -0.8 | -0.82 | -0.82 | 0.43 | 0.46 | 0.41 | True |\n" ] } ], @@ -1157,7 +1554,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1187,7 +1584,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1217,7 +1614,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1247,7 +1644,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1277,7 +1674,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] diff --git a/users/rilling/evaluation/wer_eval.ipynb b/users/rilling/evaluation/wer_eval.ipynb index ebc9639f8..69804a5a4 100644 --- a/users/rilling/evaluation/wer_eval.ipynb +++ b/users/rilling/evaluation/wer_eval.ipynb @@ -1062,7 +1062,7 @@ " with open(f, \"r\") as ff:\n", " wers.append(float(ff.readline().replace(\"\\n\", \"\")))\n", " folders = [\n", - " \"librispeech_glow_asr\",\n", + " \"ASR_only\",\n", " \"joint_training/default\",\n", " \"joint_training/conformer_coupling\",\n", " \"joint_training/given_alignments\",\n", @@ -2283,6 +2283,7 @@ "source": [ "ctc_scores = []\n", "ctc_dev_scores = []\n", + "ctc_devtrain_scores = []\n", "overfitting = []\n", "mle_scores = []\n", "dp_scores = []\n", @@ -2299,6 +2300,7 @@ " finished.append(False)\n", " ctc_scores.append(np.nan)\n", " ctc_dev_scores.append(np.nan)\n", + " ctc_devtrain_scores.append(np.nan)\n", " mle_scores.append(np.nan)\n", " dp_scores.append(np.nan)\n", " overfitting.append(np.nan)\n", @@ -2307,7 +2309,12 @@ " finished.append(True)\n", " ctc_scores.append(last_epoch_data[\"error\"][\"ctc\"])\n", " ctc_dev_scores.append(last_epoch_data[\"error\"][\"dev_loss_ctc\"])\n", - " overfitting.append(ctc_dev_scores[-1] / ctc_scores[-1])\n", + " if \"devtrain_loss_ctc\" in last_epoch_data[\"error\"]:\n", + " ctc_devtrain_scores.append(last_epoch_data[\"error\"][\"devtrain_loss_ctc\"])\n", + " overfitting.append(ctc_dev_scores[-1] / ctc_scores[-1])\n", + " else:\n", + " ctc_devtrain_scores.append(np.nan)\n", + " overfitting.append(np.nan)\n", "\n", " if \"mle\" in last_epoch_data[\"error\"]:\n", " breakpoint()\n", diff --git a/users/rilling/experiments/librispeech/librispeech_glow_asr/experiments.py b/users/rilling/experiments/librispeech/librispeech_glow_asr/experiments.py index 90c4d0fbd..a5777f2e4 100644 --- a/users/rilling/experiments/librispeech/librispeech_glow_asr/experiments.py +++ b/users/rilling/experiments/librispeech/librispeech_glow_asr/experiments.py @@ -37,7 +37,7 @@ def glowASR(TTS_experiments: dict): :param dict TTS_experiments: Dictionary containing the TTS-only experiments from ../librispeech_glowtts to import Glow-TTS decoder parameters """ - prefix_name = "experiments/librispeech/librispeech_glow_asr/pytorch/" + prefix_name = "experiments/librispeech/ASR_only/raw_audio/" train_settings = TrainingDatasetSettings( custom_processing_function=None, partition_epoch=3, epoch_wise_filters=[], seq_ordering="laplace:.1000" diff --git a/users/rilling/experiments/librispeech/librispeech_glowtts/glowTTS/experiments.py b/users/rilling/experiments/librispeech/librispeech_glowtts/glowTTS/experiments.py index 56164bf9f..9827b994f 100644 --- a/users/rilling/experiments/librispeech/librispeech_glowtts/glowTTS/experiments.py +++ b/users/rilling/experiments/librispeech/librispeech_glowtts/glowTTS/experiments.py @@ -29,7 +29,7 @@ def get_pytorch_glowTTS(x_vector_exp: dict, gl_checkpoint: dict): :return dict: Dictionary containing the experiment dictionaries to import attributes of experiment jobs in other experiment folders (should be done using storage) """ - prefix = "experiments/librispeech/tts_architecture/glow_tts/raw_audio/" + prefix = "experiments/librispeech/TTS_only/v1/raw_audio/" experiments = {} def run_exp( diff --git a/users/rilling/experiments/librispeech/librispeech_glowtts/glowTTS/gt_extraction.py b/users/rilling/experiments/librispeech/librispeech_glowtts/glowTTS/gt_extraction.py index d63eda851..03367cd63 100644 --- a/users/rilling/experiments/librispeech/librispeech_glowtts/glowTTS/gt_extraction.py +++ b/users/rilling/experiments/librispeech/librispeech_glowtts/glowTTS/gt_extraction.py @@ -21,7 +21,7 @@ def get_ground_truth_audio_and_spectrograms(): :return: durations_hdf """ - prefix = "experiments/librispeech/tts_architecture/glow_tts/ground_truth/" + prefix = "experiments/librispeech/ground_truth/" def run_exp(name, args, dataset): forward_config = get_forward_config( diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training/experiments.py b/users/rilling/experiments/librispeech/librispeech_joint_training/experiments.py index dd1ecffe2..6d620552e 100644 --- a/users/rilling/experiments/librispeech/librispeech_joint_training/experiments.py +++ b/users/rilling/experiments/librispeech/librispeech_joint_training/experiments.py @@ -1727,6 +1727,104 @@ def run_exp( search_args=default_search_args, tts_forward=False, ) + + #=================== 200EP training ================================= + model_config_specaug = copy.deepcopy(model_config) + model_config_specaug.specaug_config = specaug_config + train_args_200ep = { + "net_args": {"fe_config": asdict(fe_config), "model_config": asdict(model_config_specaug)}, + "network_module": net_module, + "debug": True, + "config": { + "optimizer": {"class": "adam", "epsilon": 1e-8}, + "learning_rates": list(np.linspace(7e-6, 7e-4, 88)) + + list(np.linspace(7e-4, 7e-5, 88)) + + list(np.linspace(7e-5, 1e-8, 24)), + "batch_size": 300 * 16000, + "max_seq_length": {"audio_features": 25 * 16000}, + "max_seqs": 60, + }, + } + + train_args_200ep["config"]["preload_from_files"] = { + "x_vector_model": { + "filename": x_vect_train_job.out_checkpoints[x_vect_train_job.returnn_config.get("num_epochs", 100)], + "init_for_train": True, + "prefix": "x_vector.", + "ignore_missing": True, + } + } + + net_module = "glowTTS_ASR_conformer_x_vector_v2" + train_args_200ep["network_module"] = net_module + + exp_dict = run_exp( + net_module + "_200ep_spec_augment_ctc_scale_0.1", + train_args_200ep, + training_datasets_pe1, + asr_test_datasets, + 200, + training_args={"ctc_scale": 0.1}, + forward_args=forward_args, + search_args=default_search_args, + eval_tts=True, + tts_eval_datasets=tts_forward_datasets_xvectors, + eval_invertibility=True, + ) + + net_module = "glowTTS_ASR_conformer_two_forward_pass" + train_args_200ep_two_forward = copy.deepcopy(train_args_200ep) + del train_args_200ep_two_forward["config"]["preload_from_files"] + train_args_200ep_two_forward["network_module"] = net_module + + exp_dict = run_exp( + net_module + "_200ep_ctc_scale_0.1", + train_args_200ep_two_forward, + training_datasets_pe1, + asr_test_datasets, + 200, + training_args={"ctc_scale": 0.1}, + forward_args=forward_args, + search_args=default_search_args, + eval_tts=True, + tts_eval_datasets=tts_forward_datasets, + eval_invertibility=True, + ) + + for lm in [2.0, 2.5, 3.0, 3.5, 4.0, 4.5]: + for ps in [0, 0.3, 0.5]: + additional_search_args = {"lm_weight": lm, "prior_scale": ps} + suffix = f"/tuning/lm_{lm}_ps_{ps}" + + exp_dict = run_exp( + train_args_200ep["network_module"] + "_200ep_spec_augment_ctc_scale_0.1" + suffix, + train_args_200ep, + training_datasets_pe1, + asr_test_datasets, + 200, + training_args={"ctc_scale": 0.1}, + forward_args=forward_args, + search_args={**default_search_args, **additional_search_args}, + eval_tts=True, + tts_eval_datasets=tts_forward_datasets_xvectors, + ) + breakpoint() + + exp_dict = run_exp( + train_args_200ep_two_forward["network_module"] + "_200ep_ctc_scale_0.1" + suffix, + train_args_200ep_two_forward, + training_datasets_pe1, + asr_test_datasets, + 200, + training_args={"ctc_scale": 0.1}, + forward_args=forward_args, + search_args={**default_search_args, **additional_search_args}, + eval_tts=True, + tts_eval_datasets=tts_forward_datasets, + eval_invertibility=True, + with_prior=True, + ) + # ================== BLSTM ================= model_config_blstm = ModelConfigV2( specaug_config=None, diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/glowTTS_ASR_conformer_two_forward_pass.py b/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/glowTTS_ASR_conformer_two_forward_pass.py index c9b6ec80b..622fc9883 100644 --- a/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/glowTTS_ASR_conformer_two_forward_pass.py +++ b/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/glowTTS_ASR_conformer_two_forward_pass.py @@ -520,7 +520,6 @@ def train_step(*, model: Model, data, run_ctx, **kwargs): ) num_phonemes = torch.sum(phonemes_eow_len) - breakpoint() if "ctc_scale" in kwargs: ctc_scale = kwargs["ctc_scale"] else: diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/shared/eval_invertibility.py b/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/shared/eval_invertibility.py index 7dcde6680..7eafca4d7 100644 --- a/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/shared/eval_invertibility.py +++ b/users/rilling/experiments/librispeech/librispeech_joint_training/pytorch_networks/shared/eval_invertibility.py @@ -111,26 +111,11 @@ def forward_step_asr_invertibility(*, model, data, run_ctx, **kwargs): phonemes = data["phonemes"] phonemes_len = data["phonemes:size1"] - if "xvectors" in data: - g = data["xvectors"] - elif "speaker_labels" in data: - g = data["speaker_labels"] - else: - raise Exception("Missing speaker embedding!") - squeezed_audio = torch.squeeze(raw_audio) y, y_lengths = model.feature_extraction(squeezed_audio, raw_audio_len) # [B, T, F] y = y.transpose(1, 2) # [B, F, T] - if hasattr(model, "x_vector"): - _, _, g = model.x_vector(y, y_lengths) - - if hasattr(model, "x_vector_bottleneck"): - g = model.x_vector_bottleneck(g) - elif hasattr(model, "emb_g"): - g = torch.nn.functional.normalize(model.emb_g(g.squeeze(-1))).unsqueeze(-1) - else: - g = None + g = None y_max_length = y.size(2) diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training/training_comparison.ipynb b/users/rilling/experiments/librispeech/librispeech_joint_training/training_comparison.ipynb index 56937615a..ce73c9e82 100644 --- a/users/rilling/experiments/librispeech/librispeech_joint_training/training_comparison.ipynb +++ b/users/rilling/experiments/librispeech/librispeech_joint_training/training_comparison.ipynb @@ -2,18 +2,9 @@ "cells": [ { "cell_type": "code", - "execution_count": 15, + "execution_count": 1, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The autoreload extension is already loaded. To reload it, use:\n", - " %reload_ext autoreload\n" - ] - } - ], + "outputs": [], "source": [ "import sys\n", "sys.path.append(\"/u/lukas.rilling/dev/\")\n", @@ -32,29 +23,30 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 2, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{'/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/training': '/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_ctc_scale_1.0/training': '/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_ctc_scale_1.0/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_1.0/training': '/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_1.0/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ddi_actnorm/training': '/glowTTS_ASR_conformer_two_forward_pass_ddi_actnorm/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_200ep_ctc_scale_0.1/training': '/glowTTS_ASR_conformer_two_forward_pass_200ep_ctc_scale_0.1/',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_ctc_scale_0.1/training': '/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_ctc_scale_0.1/',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_0.1/training': '/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_0.1/',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/training': '/glowTTS_ASR_conformer_two_forward_pass/'}" + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/training': '/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_200ep_spec_augment_ctc_scale_0.1/training': '/glowTTS_ASR_conformer_x_vector_v2_200ep_spec_augment_ctc_scale_0.1/',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/training': '/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/'}" ] }, - "execution_count": 16, + "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "globs = [\n", - " \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass*/training\",\n", + " \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass*_ctc_scale_0.1/training\",\n", + " \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2*_ctc_scale_0.1/training\",\n", " # \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_ctc_scale_1.0/training\",\n", " # \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2/training\",\n", " # \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_blstm_x_vector*/training\",\n", @@ -88,26 +80,26 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/training',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_ctc_scale_1.0/training',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_1.0/training',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ddi_actnorm/training',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_200ep_ctc_scale_0.1/training',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_ctc_scale_0.1/training',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_0.1/training',\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/training',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/training',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_200ep_spec_augment_ctc_scale_0.1/training',\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/training',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS/enc192/100ep/not_silence_preprocessed/training',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS_x_vector/enc768/100ep/not_silence_preprocessed/training',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/weak_baseline/training',\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/training']" ] }, - "execution_count": 17, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } @@ -147,23 +139,21 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{'/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS/enc192/100ep/not_silence_preprocessed/training': 1,\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS_x_vector_v3_norm_xvector/enc768/100ep/not_silence_preprocessed/training': 1,\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS_x_vector/enc768/100ep/not_silence_preprocessed/training': 1,\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS_x_vector_v3/enc768/100ep/not_silence_preprocessed/training': 1,\n", + "{'/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_x_vector_pe1/training': 1,\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_x_vector_pe1_radam/training': 1,\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_x_vector_pe1/training': 1,\n", " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_x_vector_pe1_radam_no_dec_dropout/training': 1,\n", - " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS/training': 1}" + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS/training': 1,\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_200ep_ctc_scale_0.1/training': 1,\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_200ep_spec_augment_ctc_scale_0.1/training': 1}" ] }, - "execution_count": 18, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -174,6 +164,8 @@ " \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS_x_vector*/enc768/100ep/not_silence_preprocessed/training\": 1, \n", " \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_x_vector_pe*/training\": 1,\n", " \"/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS/training\": 1,\n", + " '/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer*200ep*_ctc_scale_0.1/training': 1,\n", + "\n", "\n", "}\n", "\n", @@ -188,7 +180,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -196,16 +188,12 @@ "output_type": "stream", "text": [ "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ctc_scale_0.1/training: 3\n", - "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_ctc_scale_1.0/training: 3\n", - "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_1.0/training: 3\n", - "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_ddi_actnorm/training: 3\n", + "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_200ep_ctc_scale_0.1/training: 1\n", "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_ctc_scale_0.1/training: 3\n", "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass_strong_conformer_weak_specaug_ctc_scale_0.1/training: 3\n", - "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_two_forward_pass/training: 3\n", - "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS/enc192/100ep/not_silence_preprocessed/training: 1\n", - "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/tts_architecture/glow_tts/raw_audio/glowTTS_x_vector/enc768/100ep/not_silence_preprocessed/training: 1\n", - "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/weak_baseline/training: 3\n", - "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/librispeech_glow_asr/pytorch/conformer/asr_dataset/spec_augment/no_glow/training: 3\n", + "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_ctc_scale_0.1/training: 3\n", + "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_200ep_spec_augment_ctc_scale_0.1/training: 1\n", + "/u/lukas.rilling/experiments/glow_tts_asr_v2/alias/experiments/librispeech/joint_training/default/raw_audio/glowTTS_ASR_conformer_x_vector_v2_spec_augment_ctc_scale_0.1/training: 3\n", "Large Font: False\n", "Setup Interactive Legend\n", "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous view', 'arrow-left', 'back'), ('Forward', 'Forward to next view', 'arrow-right', 'forward'), ('Pan', 'Left button pans, Right button zooms\\nx/y fixes axis, CTRL fixes aspect', 'arrows', 'pan'), ('Zoom', 'Zoom to rectangle\\nx/y fixes axis', 'square-o', 'zoom'), ('Download', 'Download plot', 'floppy-o', 'save_figure')]))\n" @@ -214,18 +202,18 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "79c0076f856b4e01889533746fe74923", + "model_id": "f96371033c3046fcb1d49e08b1b32573", "version_major": 2, "version_minor": 0 }, - "image/png": "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", + "image/png": "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", "text/html": [ "\n", "
\n", "
\n", " Figure\n", "
\n", - " \n", + " \n", "
\n", " " ], @@ -287,7 +275,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.12" + "version": "3.10.13" } }, "nbformat": 4, diff --git a/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/exp_tts/experiments.py b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/exp_tts/experiments.py index 72af00dba..b4b595bca 100644 --- a/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/exp_tts/experiments.py +++ b/users/rilling/experiments/librispeech/librispeech_joint_training_given_alignments/exp_tts/experiments.py @@ -43,7 +43,7 @@ def get_glow_tts(x_vector_exp, joint_exps, tts_exps, gl_checkpoint): but in a cleaner setup similar to the setup used for joint training and joint training with external alignments """ - prefix = "experiments/librispeech/joint_training/given_alignments/raw_audio/TTS_models/" + prefix = "experiments/librispeech/TTS_only/v2/raw_audio/" def run_exp( name, From da239e06896b34fb5b7367da6e1d1d2328ae610b Mon Sep 17 00:00:00 2001 From: Benedikt Hilmes Date: Mon, 3 Jun 2024 22:18:21 +0200 Subject: [PATCH 087/227] updates quant --- .../hybrid/torch_baselines/torch_args.py | 43 +- .../tedlium2/standalone/data/common.py | 30 ++ .../tedlium2/standalone/default_tools.py | 2 +- .../experiments/ctc_phon/baseline.py | 252 +++++---- .../experiments/ctc_phon/tune_eval.py | 14 +- .../experiments/ctc_phon/uni_mod_aggr_v1.py | 253 +++++++++ ...elsV2_VGG4LayerActFrontendV1_auxloss_v1.py | 197 +++++++ ...2_VGG4LayerActFrontendV1_auxloss_v1_cfg.py | 90 ++++ .../conformer_1023/quant/baseline_quant_v2.py | 507 ++++++++++++++++++ .../quant/baseline_quant_v2_modules.py | 358 +++++++++++++ .../experiments/tedlium2/standalone/report.py | 50 +- 11 files changed, 1672 insertions(+), 124 deletions(-) create mode 100644 users/hilmes/experiments/tedlium2/standalone/experiments/ctc_phon/uni_mod_aggr_v1.py create mode 100644 users/hilmes/experiments/tedlium2/standalone/pytorch_networks/ctc/conformer_0106/i6modelsV2_VGG4LayerActFrontendV1_auxloss_v1.py create mode 100644 users/hilmes/experiments/tedlium2/standalone/pytorch_networks/ctc/conformer_0106/i6modelsV2_VGG4LayerActFrontendV1_auxloss_v1_cfg.py create mode 100644 users/hilmes/experiments/tedlium2/standalone/pytorch_networks/ctc/conformer_1023/quant/baseline_quant_v2.py create mode 100644 users/hilmes/experiments/tedlium2/standalone/pytorch_networks/ctc/conformer_1023/quant/baseline_quant_v2_modules.py diff --git a/users/hilmes/experiments/tedlium2/asr_2023/hybrid/torch_baselines/torch_args.py b/users/hilmes/experiments/tedlium2/asr_2023/hybrid/torch_baselines/torch_args.py index fcb8a5f70..d0d38ef09 100644 --- a/users/hilmes/experiments/tedlium2/asr_2023/hybrid/torch_baselines/torch_args.py +++ b/users/hilmes/experiments/tedlium2/asr_2023/hybrid/torch_baselines/torch_args.py @@ -146,6 +146,47 @@ def get_nn_args(num_outputs: int = 9001, num_epochs: int = 250, debug=False, **n "torch_jj_config2", ], }, + "quant-paper": { + "epochs": evaluation_epochs, + "feature_flow_key": "fb", + "prior_scales": [0.9], + "pronunciation_scales": [0.0], + "lm_scales": [10.0], + "lm_lookahead": True, + "lookahead_options": None, + "create_lattice": True, + "eval_single_best": True, + "eval_best_in_lattice": True, + "search_parameters": { + "beam-pruning": 15.0, + "beam-pruning-limit": 10000, + "word-end-pruning": 0.5, + "word-end-pruning-limit": 15000, + }, + "lattice_to_ctm_kwargs": { + "fill_empty_segments": True, + "best_path_algo": "bellman-ford", + }, + "optimize_am_lm_scale": True, + "rtf": 50, + "mem": 7, + "lmgc_mem": 16, + "cpu": 2, + "parallelize_conversion": True, + "needs_features_size": True, + # "quantize": [10, 15, 25, 100, 250, 500, 750, 1000, 2500, 5000], + "quantize": [100], + "random_seed_draws": 100, + "quant_modes": [CalibrationMethod.MinMax, CalibrationMethod.Percentile], + "quant_ops": [["Conv", "MatMul"]], + "quant_sym_modes": [False], + "quant_avg_modes": [False], + "quant_percentiles": [99.999], + "quant_num_bin_ls": [2048], + "training_whitelist": [ + "torch_jj_config2", + ], + }, # "quant-base": { # "epochs": evaluation_epochs, # "feature_flow_key": "fb", @@ -743,7 +784,7 @@ def get_nn_args(num_outputs: int = 9001, num_epochs: int = 250, debug=False, **n # recognition_args.update(speed) test_recognition_args = { "dev": {}, - "quant-base": {} + "quant-paper": {} } nn_args = HybridArgs( diff --git a/users/hilmes/experiments/tedlium2/standalone/data/common.py b/users/hilmes/experiments/tedlium2/standalone/data/common.py index f16454a37..c1421930a 100644 --- a/users/hilmes/experiments/tedlium2/standalone/data/common.py +++ b/users/hilmes/experiments/tedlium2/standalone/data/common.py @@ -198,3 +198,33 @@ def build_test_dataset( ) return test_dataset, bliss_dict[dataset_key] + + +def build_st_test_dataset( + corpus_path: tk.Path, + settings: DatasetSettings, +) -> Tuple[Dataset, tk.Path]: + """ + Create ASR test set that only contains the audio stream + + :param corpus_path: + :param settings: settings object for the RETURNN data pipeline + :return: tuple of the test dataset and a path to the corresponding bliss corpus file + """ + from i6_core.returnn.oggzip import BlissToOggZipJob + + ogg_zip = BlissToOggZipJob(bliss_corpus=corpus_path, returnn_root=MINI_RETURNN_ROOT, returnn_python_exe=RETURNN_EXE) + + + audio_datastream = get_audio_raw_datastream(settings.preemphasis, settings.peak_normalization) + + data_map = {"raw_audio": ("zip_dataset", "data")} + + test_zip_dataset = OggZipDataset( + files=[ogg_zip.out_ogg_zip], audio_options=audio_datastream.as_returnn_audio_opts(), seq_ordering="sorted_reverse" + ) + test_dataset = MetaDataset( + data_map=data_map, datasets={"zip_dataset": test_zip_dataset}, seq_order_control_dataset="zip_dataset" + ) + + return test_dataset, corpus_path diff --git a/users/hilmes/experiments/tedlium2/standalone/default_tools.py b/users/hilmes/experiments/tedlium2/standalone/default_tools.py index 8c1b48070..42549a8fe 100644 --- a/users/hilmes/experiments/tedlium2/standalone/default_tools.py +++ b/users/hilmes/experiments/tedlium2/standalone/default_tools.py @@ -19,7 +19,7 @@ I6_MODELS_REPO_PATH = CloneGitRepositoryJob( url="https://github.com/rwth-i6/i6_models", - commit="3c9173691521778b1e8b4070c172cbe929e4826b", + commit="645d4e1a00349ed46593ab2c82dc373db353c33f", checkout_folder_name="i6_models", ).out_repository.copy() I6_MODELS_REPO_PATH.hash_overwrite = "TEDLIUM_STANDALONE_DEFAULT_I6_MODELS" diff --git a/users/hilmes/experiments/tedlium2/standalone/experiments/ctc_phon/baseline.py b/users/hilmes/experiments/tedlium2/standalone/experiments/ctc_phon/baseline.py index 77e80e7b9..ea21e48f8 100644 --- a/users/hilmes/experiments/tedlium2/standalone/experiments/ctc_phon/baseline.py +++ b/users/hilmes/experiments/tedlium2/standalone/experiments/ctc_phon/baseline.py @@ -1,10 +1,11 @@ from dataclasses import asdict import numpy as np from typing import cast +from sisyphus import tk from i6_experiments.common.setups.returnn.datastreams.vocabulary import LabelDatastream from .tune_eval import QuantArgs -from ...data.common import DatasetSettings, build_test_dataset +from ...data.common import DatasetSettings, build_test_dataset, build_st_test_dataset from ...data.phon import build_eow_phon_training_datasets, get_text_lexicon from ...default_tools import RETURNN_EXE, MINI_RETURNN_ROOT from ...lm import get_4gram_binary_lm @@ -40,9 +41,18 @@ def eow_phon_ted_1023_base(quant=False): ) test_dataset_tuples = {} - for testset in ["test"]: - test_dataset_tuples[testset] = build_test_dataset( - dataset_key=testset, + # for testset in ["test"]: + # test_dataset_tuples[testset] = build_test_dataset( + # dataset_key=testset, + # settings=train_settings, + # ) + for path in [ + "/work/smt3/bahar/expriments/st/iwslt2018/iwslt2018/iwslt/sets/iwslt.dev2010.xml.gz", + "/work/smt3/bahar/expriments/st/iwslt2018/iwslt2018/iwslt/sets/iwslt.tst2015.xml.gz", + "/work/smt3/bahar/expriments/st/iwslt2018/iwslt2018/iwslt/sets/iwslt.tst2014.xml.gz", + ]: + test_dataset_tuples[path.split("/")[-1].split(".")[1]] = build_st_test_dataset( + corpus_path=tk.Path(path), settings=train_settings, ) @@ -208,7 +218,51 @@ def eow_phon_ted_1023_base(quant=False): from ...pytorch_networks.ctc.conformer_1023.quant.baseline_quant_v1_cfg import QuantModelConfigV1 num_iterations = 100 # what if we give more information to the activation instead? - for activation_bit in [8, 7, 6, 5, 4, 3, 2, 1]: + if False: + for activation_bit in [8, 7, 6, 5, 4, 3, 2, 1]: + for weight_bit in [8, 7, 6, 5, 4, 3, 2, 1]: + results = {} + model_config_quant_v1 = QuantModelConfigV1( + weight_quant_dtype="qint8", + weight_quant_method="per_tensor", + activation_quant_dtype="qint8", + activation_quant_method="per_tensor", + dot_quant_dtype="qint8", + dot_quant_method="per_tensor", + Av_quant_dtype="qint8", + Av_quant_method="per_tensor", + moving_average=0.01, + weight_bit_prec=weight_bit, + activation_bit_prec=activation_bit, + linear_quant_output=False, + ) + quant_args = QuantArgs( + sample_ls=[10] if weight_bit < 8 or activation_bit < 8 else [10, 100, 1000, 10000], + quant_config_dict={"quant_config_dict": asdict(model_config_quant_v1)}, + decoder="ctc.decoder.flashlight_quant_stat_phoneme_ctc", + num_iterations=num_iterations, + datasets=train_data, + network_module="ctc.conformer_1023.quant.baseline_quant_v1", + ) + quant_str = f"_weight_{weight_bit}_act_{activation_bit}" + asr_model = prepare_asr_model( + training_name+quant_str, + train_job, + train_args, + with_prior=True, + datasets=train_data, + get_specific_checkpoint=250, + ) + res, _ = tune_and_evaluate_helper( # only take best for now, since otherwise too many searches + training_name, asr_model, default_decoder_config, lm_scales=[2.8], + prior_scales=[0.7], quant_args=quant_args, quant_str=quant_str, + dev_dataset_tuples=dev_dataset_tuples, + ) + results.update(res) + generate_report(results=results, exp_name=training_name + quant_str) + del results + transcribers = [(8, 8)] + for activation_bit in [8]: for weight_bit in [8, 7, 6, 5, 4, 3, 2, 1]: results = {} model_config_quant_v1 = QuantModelConfigV1( @@ -231,9 +285,9 @@ def eow_phon_ted_1023_base(quant=False): decoder="ctc.decoder.flashlight_quant_stat_phoneme_ctc", num_iterations=num_iterations, datasets=train_data, - network_module="ctc.conformer_1023.quant.baseline_quant_v1", + network_module="ctc.conformer_1023.quant.baseline_quant_v2", ) - quant_str = f"_weight_{weight_bit}_act_{activation_bit}" + quant_str = f"_v2_weight_{weight_bit}_act_{activation_bit}" asr_model = prepare_asr_model( training_name+quant_str, train_job, @@ -246,19 +300,65 @@ def eow_phon_ted_1023_base(quant=False): training_name, asr_model, default_decoder_config, lm_scales=[2.8], prior_scales=[0.7], quant_args=quant_args, quant_str=quant_str, dev_dataset_tuples=dev_dataset_tuples, + test_dataset_tuples=test_dataset_tuples if (activation_bit, weight_bit) in transcribers else None ) results.update(res) generate_report(results=results, exp_name=training_name + quant_str) del results num_iterations = 250 - for filter in [ - ({"unique_tags": 0.0}, "unique"), - ({"single_tag": 0.0}, "single"), - ({"max_dur": 1.0}, "max_dur_1"), - ({"min_dur": 15.0}, "min_dur_15") - ]: + if False: + for filter in [ + ({"unique_tags": 0.0}, "unique"), + ({"single_tag": 0.0}, "single"), + ({"max_dur": 1.0}, "max_dur_1"), + ({"min_dur": 15.0}, "min_dur_15") + ]: + for activation_bit in [8]: + for weight_bit in [8]: + results = {} + model_config_quant_v1 = QuantModelConfigV1( + weight_quant_dtype="qint8", + weight_quant_method="per_tensor", + activation_quant_dtype="qint8", + activation_quant_method="per_tensor", + dot_quant_dtype="qint8", + dot_quant_method="per_tensor", + Av_quant_dtype="qint8", + Av_quant_method="per_tensor", + moving_average=0.01, + weight_bit_prec=weight_bit, + activation_bit_prec=activation_bit, + linear_quant_output=False, + ) + quant_args = QuantArgs( + sample_ls=[1], #§, 10, 25, 5], + quant_config_dict={"quant_config_dict": asdict(model_config_quant_v1)}, + decoder="ctc.decoder.flashlight_quant_stat_phoneme_ctc", + num_iterations=num_iterations, + datasets=train_data, + network_module="ctc.conformer_1023.quant.baseline_quant_v1", + filter_args=filter[0], + ) + quant_str = f"_weight_{weight_bit}_act_{activation_bit}_{filter[1]}" + asr_model = prepare_asr_model( + training_name+quant_str, + train_job, + train_args, + with_prior=True, + datasets=train_data, + get_specific_checkpoint=250, + ) + res, _ = tune_and_evaluate_helper( # only take best for now, since otherwise too many searches + training_name, asr_model, default_decoder_config, lm_scales=[2.8], + prior_scales=[0.7], quant_args=quant_args, quant_str=quant_str, dev_dataset_tuples=dev_dataset_tuples + ) + results.update(res) + generate_report(results=results, exp_name=training_name + quant_str) + del results + + num_iterations = 100 for activation_bit in [8]: - for weight_bit in [8]: + for weight_bit in [8, 7, 6, 5, 4, 3, 2, 1]: results = {} model_config_quant_v1 = QuantModelConfigV1( weight_quant_dtype="qint8", @@ -272,18 +372,54 @@ def eow_phon_ted_1023_base(quant=False): moving_average=0.01, weight_bit_prec=weight_bit, activation_bit_prec=activation_bit, + linear_quant_output=True, + ) + quant_args = QuantArgs( + sample_ls=[10] if weight_bit < 8 or activation_bit < 8 else [10, 100, 1000, 10000], + quant_config_dict={"quant_config_dict": asdict(model_config_quant_v1)}, + decoder="ctc.decoder.flashlight_quant_stat_phoneme_ctc", + num_iterations=num_iterations, + datasets=train_data, + network_module="ctc.conformer_1023.quant.baseline_quant_v1", + ) + quant_str = f"_weight_{weight_bit}_act_{activation_bit}_qlin" + asr_model = prepare_asr_model( + training_name+quant_str, train_job, train_args, with_prior=True, datasets=train_data, get_specific_checkpoint=250 + ) + res, _ = tune_and_evaluate_helper( # only take best for now, since otherwise too many searches + training_name, asr_model, default_decoder_config, lm_scales=[2.8], + prior_scales=[0.7], quant_args=quant_args, quant_str=quant_str, dev_dataset_tuples=dev_dataset_tuples + ) + results.update(res) + generate_report(results=results, exp_name=training_name+quant_str) + del results + + for activation_bit in [8]: + for weight_bit in [8]: + results = {} + model_config_quant_v1 = QuantModelConfigV1( + weight_quant_dtype="qint8", + weight_quant_method="per_tensor", + activation_quant_dtype="qint8", + activation_quant_method="per_tensor", + dot_quant_dtype="qint8", + dot_quant_method="per_tensor", + Av_quant_dtype="qint8", + Av_quant_method="per_tensor", + moving_average=None, + weight_bit_prec=weight_bit, + activation_bit_prec=activation_bit, linear_quant_output=False, ) quant_args = QuantArgs( - sample_ls=[1], #§, 10, 25, 5], + sample_ls=[10] if weight_bit < 8 or activation_bit < 8 else [10, 100, 1000, 10000], quant_config_dict={"quant_config_dict": asdict(model_config_quant_v1)}, decoder="ctc.decoder.flashlight_quant_stat_phoneme_ctc", num_iterations=num_iterations, datasets=train_data, network_module="ctc.conformer_1023.quant.baseline_quant_v1", - filter_args=filter[0], ) - quant_str = f"_weight_{weight_bit}_act_{activation_bit}_{filter[1]}" + quant_str = f"_weight_{weight_bit}_act_{activation_bit}_no_avg" asr_model = prepare_asr_model( training_name+quant_str, train_job, @@ -294,92 +430,12 @@ def eow_phon_ted_1023_base(quant=False): ) res, _ = tune_and_evaluate_helper( # only take best for now, since otherwise too many searches training_name, asr_model, default_decoder_config, lm_scales=[2.8], - prior_scales=[0.7], quant_args=quant_args, quant_str=quant_str, dev_dataset_tuples=dev_dataset_tuples + prior_scales=[0.7], quant_args=quant_args, quant_str=quant_str, dev_dataset_tuples=dev_dataset_tuples, ) results.update(res) generate_report(results=results, exp_name=training_name + quant_str) del results - num_iterations = 100 - for activation_bit in [8]: - for weight_bit in [8, 7, 6, 5, 4, 3, 2, 1]: - results = {} - model_config_quant_v1 = QuantModelConfigV1( - weight_quant_dtype="qint8", - weight_quant_method="per_tensor", - activation_quant_dtype="qint8", - activation_quant_method="per_tensor", - dot_quant_dtype="qint8", - dot_quant_method="per_tensor", - Av_quant_dtype="qint8", - Av_quant_method="per_tensor", - moving_average=0.01, - weight_bit_prec=weight_bit, - activation_bit_prec=activation_bit, - linear_quant_output=True, - ) - quant_args = QuantArgs( - sample_ls=[10] if weight_bit < 8 or activation_bit < 8 else [10, 100, 1000, 10000], - quant_config_dict={"quant_config_dict": asdict(model_config_quant_v1)}, - decoder="ctc.decoder.flashlight_quant_stat_phoneme_ctc", - num_iterations=num_iterations, - datasets=train_data, - network_module="ctc.conformer_1023.quant.baseline_quant_v1", - ) - quant_str = f"_weight_{weight_bit}_act_{activation_bit}_qlin" - asr_model = prepare_asr_model( - training_name+quant_str, train_job, train_args, with_prior=True, datasets=train_data, get_specific_checkpoint=250 - ) - res, _ = tune_and_evaluate_helper( # only take best for now, since otherwise too many searches - training_name, asr_model, default_decoder_config, lm_scales=[2.8], - prior_scales=[0.7], quant_args=quant_args, quant_str=quant_str, dev_dataset_tuples=dev_dataset_tuples - ) - results.update(res) - generate_report(results=results, exp_name=training_name+quant_str) - del results - - for activation_bit in [8]: - for weight_bit in [8]: - results = {} - model_config_quant_v1 = QuantModelConfigV1( - weight_quant_dtype="qint8", - weight_quant_method="per_tensor", - activation_quant_dtype="qint8", - activation_quant_method="per_tensor", - dot_quant_dtype="qint8", - dot_quant_method="per_tensor", - Av_quant_dtype="qint8", - Av_quant_method="per_tensor", - moving_average=None, - weight_bit_prec=weight_bit, - activation_bit_prec=activation_bit, - linear_quant_output=False, - ) - quant_args = QuantArgs( - sample_ls=[10] if weight_bit < 8 or activation_bit < 8 else [10, 100, 1000, 10000], - quant_config_dict={"quant_config_dict": asdict(model_config_quant_v1)}, - decoder="ctc.decoder.flashlight_quant_stat_phoneme_ctc", - num_iterations=num_iterations, - datasets=train_data, - network_module="ctc.conformer_1023.quant.baseline_quant_v1", - ) - quant_str = f"_weight_{weight_bit}_act_{activation_bit}_no_avg" - asr_model = prepare_asr_model( - training_name+quant_str, - train_job, - train_args, - with_prior=True, - datasets=train_data, - get_specific_checkpoint=250, - ) - res, _ = tune_and_evaluate_helper( # only take best for now, since otherwise too many searches - training_name, asr_model, default_decoder_config, lm_scales=[2.8], - prior_scales=[0.7], quant_args=quant_args, quant_str=quant_str, dev_dataset_tuples=dev_dataset_tuples, - ) - results.update(res) - generate_report(results=results, exp_name=training_name + quant_str) - del results - # E-Branchformer branchformer_module = "ctc.conformer_1023.i6models_ebranchformer_v1" train_config = { diff --git a/users/hilmes/experiments/tedlium2/standalone/experiments/ctc_phon/tune_eval.py b/users/hilmes/experiments/tedlium2/standalone/experiments/ctc_phon/tune_eval.py index 520ca392c..05f208c4c 100644 --- a/users/hilmes/experiments/tedlium2/standalone/experiments/ctc_phon/tune_eval.py +++ b/users/hilmes/experiments/tedlium2/standalone/experiments/ctc_phon/tune_eval.py @@ -113,11 +113,23 @@ def tune_and_evaluate_helper( **default_returnn, ) results.update(wers) + if test_dataset_tuples is not None and seed in [0]: + decoder_config = copy.deepcopy(base_decoder_config) + search_jobs, wers = search( + search_name, + forward_config={}, + asr_model=quant_model, + decoder_module=quant_args.decoder, + decoder_args={"config": asdict(decoder_config)}, + test_dataset_tuples=test_dataset_tuples, + **default_returnn, + ) + #results.update(wers) pick_optimal_params_job = GetOptimalParametersAsVariableJob( parameters=tune_parameters, values=tune_values, mode="minimize" ) pick_optimal_params_job.add_alias(training_name + f"/pick_best_dev") - if test_dataset_tuples is not None: + if test_dataset_tuples is not None and False: for key, tune_values in [("test", tune_values)]: decoder_config = copy.deepcopy(base_decoder_config) decoder_config.lm_weight = pick_optimal_params_job.out_optimal_parameters[0] diff --git a/users/hilmes/experiments/tedlium2/standalone/experiments/ctc_phon/uni_mod_aggr_v1.py b/users/hilmes/experiments/tedlium2/standalone/experiments/ctc_phon/uni_mod_aggr_v1.py new file mode 100644 index 000000000..0e1a893c2 --- /dev/null +++ b/users/hilmes/experiments/tedlium2/standalone/experiments/ctc_phon/uni_mod_aggr_v1.py @@ -0,0 +1,253 @@ +from dataclasses import asdict +import numpy as np +from typing import cast +import copy + +from i6_experiments.common.setups.returnn.datastreams.vocabulary import LabelDatastream + +from ...data.common import DatasetSettings, build_test_dataset +from ...data.phon import build_eow_phon_training_datasets, get_text_lexicon +from ...default_tools import RETURNN_EXE, MINI_RETURNN_ROOT +from ...lm import get_4gram_binary_lm +from ...pipeline import training, prepare_asr_model +from ...report import generate_report +from .tune_eval import tune_and_evaluate_helper + + + +def eow_phon_ted_0106_unimod(): + prefix_name = "experiments/tedlium2/ctc_rnnt_standalone_2024/ctc_eow_phon_unimod" + + train_settings = DatasetSettings( + preemphasis=0.97, # TODO: Check if this is really useful + peak_normalization=True, # TODO: Also check if really useful, older Attention setups did not have that + # training + train_partition_epoch=5, + train_seq_ordering="laplace:.1000", + ) + + # build the training datasets object containing train, cv, dev-train and the extern_data dict + train_data = build_eow_phon_training_datasets( + prefix=prefix_name, + settings=train_settings, + ) + label_datastream = cast(LabelDatastream, train_data.datastreams["labels"]) + vocab_size_without_blank = label_datastream.vocab_size + + dev_dataset_tuples = {} + for testset in ["dev"]: + dev_dataset_tuples[testset] = build_test_dataset( + dataset_key=testset, + settings=train_settings, + ) + + test_dataset_tuples = {} + for testset in ["test"]: + test_dataset_tuples[testset] = build_test_dataset( + dataset_key=testset, + settings=train_settings, + ) + + arpa_4gram_lm = get_4gram_binary_lm(prefix_name=prefix_name) + + default_returnn = { + "returnn_exe": RETURNN_EXE, + "returnn_root": MINI_RETURNN_ROOT, + } + + from ...pytorch_networks.ctc.decoder.flashlight_ctc_v1 import DecoderConfig + + default_decoder_config = DecoderConfig( + lexicon=get_text_lexicon(), + returnn_vocab=label_datastream.vocab, + beam_size=1024, + beam_size_token=12, # makes it much faster + arpa_lm=arpa_4gram_lm, + beam_threshold=14, + ) + + from ...pytorch_networks.ctc.conformer_0106.i6modelsV2_VGG4LayerActFrontendV1_auxloss_v1_cfg import ( + SpecaugConfig, + VGG4LayerActFrontendV1Config_mod, + ModelConfig, + LogMelFeatureExtractionV1Config, + ) + + fe_config = LogMelFeatureExtractionV1Config( + sample_rate=16000, + win_size=0.025, + hop_size=0.01, + f_min=60, + f_max=7600, + min_amp=1e-10, + num_filters=80, + center=False, + ) + specaug_config = SpecaugConfig( + repeat_per_n_frames=25, + max_dim_time=20, + max_dim_feat=8, # Jingjing style + num_repeat_feat=5, + ) + frontend_config = VGG4LayerActFrontendV1Config_mod( + in_features=80, + conv1_channels=32, + conv2_channels=64, + conv3_channels=64, + conv4_channels=32, + conv_kernel_size=(3, 3), + conv_padding=None, + pool1_kernel_size=(2, 1), + pool1_stride=(2, 1), + pool1_padding=None, + pool2_kernel_size=(2, 1), + pool2_stride=(2, 1), + pool2_padding=None, + activation_str="ReLU", + out_features=384, + activation=None, + ) + + model_config = ModelConfig( + feature_extraction_config=fe_config, + frontend_config=frontend_config, + specaug_config=specaug_config, + label_target_size=vocab_size_without_blank, + conformer_size=384, + num_layers=12, + num_heads=4, + ff_dim=1536, + att_weights_dropout=0.2, + conv_dropout=0.2, + ff_dropout=0.2, + mhsa_dropout=0.2, + conv_kernel_size=31, + final_dropout=0.2, + specauc_start_epoch=1, + module_list=["ff", "conv", "mhsa", "ff"], + module_scales=[0.5, 1.0, 1.0, 0.5], + aux_ctc_loss_layers=[3, 7, 11], # 4, 8, 12 when counting from 1 + aux_ctc_loss_scales=[0.3, 0.3, 1.0], + ) + model_config_decoding = copy.deepcopy(model_config) + model_config_decoding.aux_ctc_loss_scales = [0.0, 0.0, 1.0] # for decoding use result only of last layer + + network_module = "ctc.conformer_0106.i6modelsV2_VGG4LayerActFrontendV1_auxloss_v1" + + train_config = { + "optimizer": {"class": "adamw", "epsilon": 1e-16, "weight_decay": 1e-3}, + "learning_rates": list(np.linspace(7e-6, 5e-4, 110)) + + list(np.linspace(5e-4, 5e-5, 110)) + + list(np.linspace(5e-5, 1e-7, 30)), + ############# + "batch_size": 180 * 16000, + "max_seq_length": {"audio_features": 35 * 16000}, + "accum_grad_multiple_step": 1, + } + train_args = { + "config": train_config, + "network_module": network_module, + "net_args": {"model_config_dict": asdict(model_config)}, + "debug": False, + } + train_args_decoding = copy.deepcopy(train_args) + train_args_decoding["net_args"] = {"model_config_dict": asdict(model_config_decoding)} + + results = {} + training_name = prefix_name + "/" + network_module + "_384dim_sub4_50eps" + train_job = training(training_name, train_data, train_args, num_epochs=250, **default_returnn) + asr_model = prepare_asr_model( + training_name, train_job, train_args_decoding, with_prior=True, datasets=train_data, get_specific_checkpoint=250 + ) + lm_scales = [2.0, 2.2, 2.4, 2.6, 2.8] + prior_scales = [0.7, 0.9] + res, _ = tune_and_evaluate_helper( + training_name, asr_model, default_decoder_config, lm_scales=lm_scales, + prior_scales=prior_scales, dev_dataset_tuples=dev_dataset_tuples + ) + results.update(res) + asr_model_best4 = prepare_asr_model( + training_name + "/best4", train_job, train_args, with_prior=True, datasets=train_data, + get_best_averaged_checkpoint=(4, "dev_loss_ctc") + ) + res, _ = tune_and_evaluate_helper(training_name + "/best4", asr_model_best4, default_decoder_config, + lm_scales=lm_scales, prior_scales=prior_scales, dev_dataset_tuples=dev_dataset_tuples) + results.update(res) + asr_model_best = prepare_asr_model( + training_name + "/best", train_job, train_args, with_prior=True, datasets=train_data, + get_best_averaged_checkpoint=(1, "dev_loss_ctc") + ) + res, _ = tune_and_evaluate_helper(training_name + "/best", asr_model_best, default_decoder_config, + lm_scales=lm_scales, prior_scales=prior_scales, dev_dataset_tuples=dev_dataset_tuples) + results.update(res) + generate_report(results=results, exp_name=training_name) + del results + + return + # TODO + unimod_module = "ctc.conformer_1023.conformer_v1_uni_aggr_v1" + from ...pytorch_networks.ctc.conformer_1023.conformer_v1_uni_aggr_cfg_v1 import ModelConfig as UniAggrConfig + uni_aggr_model_config = UniAggrConfig( + feature_extraction_config=fe_config, + frontend_config=frontend_config, + specaug_config=specaug_config, + label_target_size=vocab_size_without_blank, + conformer_size=384, + num_layers=12, + num_heads=4, + ff_dim=1536, + att_weights_dropout=0.2, + conv_dropout=0.2, + ff_dropout=0.2, + mhsa_dropout=0.2, + conv_kernel_size=31, + final_dropout=0.2, + specauc_start_epoch=1, + aggr_layer=9, + ) + train_config = { + "optimizer": {"class": "adamw", "epsilon": 1e-16, "weight_decay": 1e-3}, + "learning_rates": list(np.linspace(7e-6, 5e-4, 110)) + + list(np.linspace(5e-4, 5e-5, 110)) + + list(np.linspace(5e-5, 1e-7, 30)), + ############# + "batch_size": 180 * 16000, + "max_seq_length": {"audio_features": 35 * 16000}, + "accum_grad_multiple_step": 1, + } + # Unimodal Aggregation + train_args = { + "config": train_config, + "network_module": unimod_module, + "net_args": {"model_config_dict": asdict(uni_aggr_model_config)}, + "debug": False, + } + results = {} + training_name = prefix_name + "/" + unimod_module + "_384dim_sub4_50eps" + train_job = training(training_name, train_data, train_args, num_epochs=250, **default_returnn) + asr_model = prepare_asr_model( + training_name, train_job, train_args, with_prior=True, datasets=train_data, get_specific_checkpoint=111 + ) + lm_scales = [2.0, 2.2, 2.4, 2.6, 2.8] + prior_scales = [0.7, 0.9] + res, _ = tune_and_evaluate_helper( + training_name, asr_model, default_decoder_config, lm_scales=lm_scales, + prior_scales=prior_scales + ) + results.update(res) + asr_model_best4 = prepare_asr_model( + training_name + "/best4", train_job, train_args, with_prior=True, datasets=train_data, + get_best_averaged_checkpoint=(4, "dev_loss_ctc") + ) + res, _ = tune_and_evaluate_helper(training_name + "/best4", asr_model_best4, default_decoder_config, + lm_scales=lm_scales, prior_scales=prior_scales) + results.update(res) + asr_model_best = prepare_asr_model( + training_name + "/best", train_job, train_args, with_prior=True, datasets=train_data, + get_best_averaged_checkpoint=(1, "dev_loss_ctc") + ) + res, _ = tune_and_evaluate_helper(training_name + "/best", asr_model_best, default_decoder_config, + lm_scales=lm_scales, prior_scales=prior_scales) + results.update(res) + generate_report(results=results, exp_name=training_name) + del results diff --git a/users/hilmes/experiments/tedlium2/standalone/pytorch_networks/ctc/conformer_0106/i6modelsV2_VGG4LayerActFrontendV1_auxloss_v1.py b/users/hilmes/experiments/tedlium2/standalone/pytorch_networks/ctc/conformer_0106/i6modelsV2_VGG4LayerActFrontendV1_auxloss_v1.py new file mode 100644 index 000000000..31c7f48ad --- /dev/null +++ b/users/hilmes/experiments/tedlium2/standalone/pytorch_networks/ctc/conformer_0106/i6modelsV2_VGG4LayerActFrontendV1_auxloss_v1.py @@ -0,0 +1,197 @@ +""" +Like v2, but with i6_models specaugment (v3) +and now controllable start time for when specaugment is applied (v4) +and with the proper feature extraction from i6-models +""" + +import numpy as np +import torch +from torch import nn + +from i6_models.parts.conformer.norm import LayerNormNC +from i6_models.assemblies.conformer.conformer_v2 import ConformerEncoderV2, ConformerEncoderV2Config, ConformerBlockV2Config +from i6_models.config import ModuleFactoryV1 +from i6_models.parts.frontend.vgg_act import VGG4LayerActFrontendV1 + +from i6_models.parts.conformer.convolution import ConformerConvolutionV1Config +from i6_models.parts.conformer.feedforward import ConformerPositionwiseFeedForwardV1Config +from i6_models.parts.conformer.mhsa import ConformerMHSAV1Config +from i6_models.primitives.specaugment import specaugment_v1_by_length +from i6_models.primitives.feature_extraction import LogMelFeatureExtractionV1 + +from returnn.torch.context import get_run_ctx + +from .i6modelsV2_VGG4LayerActFrontendV1_auxloss_v1_cfg import ModelConfig + + +def mask_tensor(tensor: torch.Tensor, seq_len: torch.Tensor) -> torch.Tensor: + """ + mask a tensor with a "positive" mask (boolean true means position is used) + + This function is traceable. + + :param tensor: [B,T,....] + :param seq_len: [B] + :return: [B,T] + """ + seq_len = seq_len.to(device=tensor.device) + r = torch.arange(tensor.shape[1], device=tensor.device) # [T] + seq_mask = torch.less(r[None, :], seq_len[:, None]) # broadcast to [B,T] + return seq_mask + + +class Model(torch.nn.Module): + def __init__(self, model_config_dict, **kwargs): + super().__init__() + self.cfg = ModelConfig.from_dict(model_config_dict) + frontend_config = self.cfg.frontend_config + conformer_size = self.cfg.conformer_size + conformer_config = ConformerEncoderV2Config( + num_layers=self.cfg.num_layers, + frontend=ModuleFactoryV1(module_class=VGG4LayerActFrontendV1, cfg=frontend_config), + block_cfg=ConformerBlockV2Config( + ff_cfg=ConformerPositionwiseFeedForwardV1Config( + input_dim=conformer_size, + hidden_dim=self.cfg.ff_dim, + dropout=self.cfg.ff_dropout, + activation=nn.functional.silu, + ), + mhsa_cfg=ConformerMHSAV1Config( + input_dim=conformer_size, + num_att_heads=self.cfg.num_heads, + att_weights_dropout=self.cfg.att_weights_dropout, + dropout=self.cfg.mhsa_dropout, + ), + conv_cfg=ConformerConvolutionV1Config( + channels=conformer_size, kernel_size=self.cfg.conv_kernel_size, dropout=self.cfg.conv_dropout, activation=nn.functional.silu, + norm=LayerNormNC(conformer_size) + ), + modules=self.cfg.module_list, + scales=self.cfg.module_scales, + ), + ) + + self.feature_extraction = LogMelFeatureExtractionV1(cfg=self.cfg.feature_extraction_config) + self.conformer = ConformerEncoderV2(cfg=conformer_config) + self.num_output_linears = 1 if self.cfg.aux_ctc_loss_layers is None else len(self.cfg.aux_ctc_loss_layers) + self.output_linears = nn.ModuleList([ + nn.Linear(conformer_size, self.cfg.label_target_size + 1) # + CTC blank + for _ in range(self.num_output_linears) + ]) + self.output_dropout = nn.Dropout(p=self.cfg.final_dropout) + self.specaug_start_epoch = self.cfg.specauc_start_epoch + + # No particular weight init! + + def forward( + self, + raw_audio: torch.Tensor, + raw_audio_len: torch.Tensor, + ): + """ + :param raw_audio: Audio samples as [B, T, 1] + :param raw_audio_len: length of T as [B] + :return: list of logprobs [B, T, #labels + blank], mask [B, T] + """ + + squeezed_features = torch.squeeze(raw_audio, dim=-1) + with torch.no_grad(): + audio_features, audio_features_len = self.feature_extraction(squeezed_features, raw_audio_len) + + run_ctx = get_run_ctx() + if self.training and run_ctx.epoch >= self.specaug_start_epoch: + audio_features_masked_2 = specaugment_v1_by_length( + audio_features, + time_min_num_masks=2, # TODO: make configurable + time_max_mask_per_n_frames=self.cfg.specaug_config.repeat_per_n_frames, + time_mask_max_size=self.cfg.specaug_config.max_dim_time, + freq_min_num_masks=2, + freq_mask_max_size=self.cfg.specaug_config.max_dim_feat, + freq_max_num_masks=self.cfg.specaug_config.num_repeat_feat, + ) + else: + audio_features_masked_2 = audio_features + + conformer_in = audio_features_masked_2 + # create the mask for the conformer input + mask = mask_tensor(conformer_in, audio_features_len) + + + return_layers = self.cfg.aux_ctc_loss_layers or [self.cfg.num_layers - 1] + print(return_layers) + conformer_out_layers, out_mask = self.conformer(conformer_in, mask, return_layers=return_layers) + log_probs_list = [] + for i, (out_layer, scale) in enumerate(zip(conformer_out_layers, self.cfg.aux_ctc_loss_scales)): + if scale == 0.0: + continue + conformer_out = self.output_dropout(out_layer) + logits = self.output_linears[i](conformer_out) + log_probs = torch.log_softmax(logits, dim=2) + log_probs_list.append(log_probs) + + if len(log_probs_list) == 1: + log_probs_list = log_probs_list[0] + + return log_probs_list, torch.sum(out_mask, dim=1) + + +def train_step(*, model: Model, data, run_ctx, **kwargs): + + raw_audio = data["raw_audio"] # [B, T', F] + raw_audio_len = data["raw_audio:size1"].to("cpu") # [B] + + labels = data["labels"] # [B, N] (sparse) + labels_len = data["labels:size1"] # [B, N] + + logprobs_list, audio_features_len = model( + raw_audio=raw_audio, + raw_audio_len=raw_audio_len, + ) + for logprobs, layer_index, scale in zip(logprobs_list, model.cfg.aux_ctc_loss_layers, model.cfg.aux_ctc_loss_scales): + transposed_logprobs = torch.permute(logprobs, (1, 0, 2)) # CTC needs [T, B, F] + ctc_loss = nn.functional.ctc_loss( + transposed_logprobs, + labels, + input_lengths=audio_features_len, + target_lengths=labels_len, + blank=model.cfg.label_target_size, + reduction="sum", + zero_infinity=True, + ) + num_phonemes = torch.sum(labels_len) + run_ctx.mark_as_loss(name=f"ctc_loss_layer{layer_index + 1}", loss=ctc_loss, scale=scale, inv_norm_factor=num_phonemes) + + +def prior_init_hook(run_ctx, **kwargs): + # we are storing durations, but call it output.hdf to match + # the default output of the ReturnnForwardJob + run_ctx.sum_probs = None + run_ctx.sum_frames = 0 + + +def prior_finish_hook(run_ctx, **kwargs): + all_frames = run_ctx.sum_frames.detach().cpu().numpy() + all_probs = run_ctx.sum_probs.detach().cpu().numpy() + average_probs = all_probs / all_frames + log_average_probs = np.log(average_probs) + print("Prior sum in std-space (should be close to 1.0):", np.sum(average_probs)) + with open("prior.txt", 'w') as f: + np.savetxt(f, log_average_probs, delimiter=' ') + print("Saved prior in prior.txt in +log space.") + + +def prior_step(*, model: Model, data, run_ctx, **kwargs): + raw_audio = data["raw_audio"] # [B, T', F] + raw_audio_len = data["raw_audio:size1"] # [B] + + logprobs, audio_features_len = model( + raw_audio=raw_audio, + raw_audio_len=raw_audio_len, + ) + + probs = torch.exp(logprobs) + run_ctx.sum_frames = run_ctx.sum_frames + torch.sum(audio_features_len) + if run_ctx.sum_probs is None: + run_ctx.sum_probs = torch.sum(probs, dim=(0, 1)) + else: + run_ctx.sum_probs += torch.sum(probs, dim=(0, 1)) diff --git a/users/hilmes/experiments/tedlium2/standalone/pytorch_networks/ctc/conformer_0106/i6modelsV2_VGG4LayerActFrontendV1_auxloss_v1_cfg.py b/users/hilmes/experiments/tedlium2/standalone/pytorch_networks/ctc/conformer_0106/i6modelsV2_VGG4LayerActFrontendV1_auxloss_v1_cfg.py new file mode 100644 index 000000000..fdd006b90 --- /dev/null +++ b/users/hilmes/experiments/tedlium2/standalone/pytorch_networks/ctc/conformer_0106/i6modelsV2_VGG4LayerActFrontendV1_auxloss_v1_cfg.py @@ -0,0 +1,90 @@ +""" +Config for the base CTC model with aux loss and ordering +""" + +from dataclasses import dataclass + +import torch +from torch import nn +from typing import Callable, List, Optional, Type, Union + +from i6_models.assemblies.conformer.conformer_v2 import ConformerBlockV2Config, ConformerBlockV2 +from i6_models.parts.frontend.vgg_act import VGG4LayerActFrontendV1Config +from i6_models.config import ModuleFactoryV1, ModelConfiguration +from i6_models.primitives.feature_extraction import LogMelFeatureExtractionV1Config + + +@dataclass(kw_only=True) +class VGG4LayerActFrontendV1Config_mod(VGG4LayerActFrontendV1Config): + activation_str: str = "" + activation: Optional[Union[nn.Module, Callable[[torch.Tensor], torch.Tensor]]] = None + + @classmethod + def from_dict(cls, d): + d = d.copy() + activation_str = d.pop("activation_str") + if activation_str == "ReLU": + from torch.nn import ReLU + activation = ReLU() + else: + assert False, "Unsupported activation %s" % d["activation_str"] + d["activation"] = activation + return VGG4LayerActFrontendV1Config(**d) + + +@dataclass +class ConformerEncoderV2Config(ModelConfiguration): + """ + Attributes: + num_layers: Number of conformer layers in the conformer encoder + frontend: A pair of ConformerFrontend and corresponding config + block_cfg: Configuration for ConformerBlockV1 + """ + + num_layers: int + + # nested configurations + frontend: ModuleFactoryV1 + block_cfg: ConformerBlockV2Config + + +@dataclass +class SpecaugConfig(ModelConfiguration): + repeat_per_n_frames: int + max_dim_time: int + num_repeat_feat: int + max_dim_feat: int + + + +@dataclass +class ModelConfig(): + feature_extraction_config: LogMelFeatureExtractionV1Config + frontend_config: VGG4LayerActFrontendV1Config + specaug_config: SpecaugConfig + specauc_start_epoch: int + label_target_size: int + conformer_size: int + num_layers: int + num_heads: int + ff_dim: int + att_weights_dropout: float + conv_dropout: float + ff_dropout: float + mhsa_dropout: float + conv_kernel_size: int + final_dropout: float + module_list: List[str] + module_scales: List[float] + aux_ctc_loss_layers: Optional[List[int]] + aux_ctc_loss_scales: Optional[List[float]] + + @classmethod + def from_dict(cls, d): + d = d.copy() + d["feature_extraction_config"] = LogMelFeatureExtractionV1Config(**d["feature_extraction_config"]) + d["frontend_config"] = VGG4LayerActFrontendV1Config_mod.from_dict(d["frontend_config"]) + d["specaug_config"] = SpecaugConfig(**d["specaug_config"]) + return ModelConfig(**d) + + diff --git a/users/hilmes/experiments/tedlium2/standalone/pytorch_networks/ctc/conformer_1023/quant/baseline_quant_v2.py b/users/hilmes/experiments/tedlium2/standalone/pytorch_networks/ctc/conformer_1023/quant/baseline_quant_v2.py new file mode 100644 index 000000000..e742bbb09 --- /dev/null +++ b/users/hilmes/experiments/tedlium2/standalone/pytorch_networks/ctc/conformer_1023/quant/baseline_quant_v2.py @@ -0,0 +1,507 @@ +""" +Uses the MHSA fix from v2 modules +""" +import math + +import numpy as np +import torch +from torch import nn +import copy +from typing import Tuple + +from i6_models.parts.conformer.norm import LayerNormNC +from i6_models.assemblies.conformer.conformer_v1 import ConformerEncoderV1Config +from i6_models.assemblies.conformer.conformer_v1 import ConformerBlockV1Config, ConformerEncoderV1 +from i6_models.config import ModuleFactoryV1 +from i6_models.parts.frontend.vgg_act import VGG4LayerActFrontendV1 +from i6_models.util import compat + +from i6_models.parts.conformer.convolution import ConformerConvolutionV1Config +from i6_models.parts.conformer.feedforward import ConformerPositionwiseFeedForwardV1Config +from i6_models.parts.conformer.mhsa import ConformerMHSAV1Config +from i6_models.primitives.specaugment import specaugment_v1_by_length +from i6_models.primitives.feature_extraction import LogMelFeatureExtractionV1, LogMelFeatureExtractionV1Config + +from returnn.torch.context import get_run_ctx + +from .baseline_quant_v1_cfg import QuantModelTrainConfigV1, QuantModelConfigV1, ConformerPositionwiseFeedForwardQuantV1Config, QuantizedMultiheadAttentionV1Config, ConformerConvolutionQuantV1Config, ConformerBlockQuantV1Config, ConformerEncoderQuantV1Config +from .baseline_quant_v2_modules import LinearQuant, QuantizedMultiheadAttention + +class ConformerPositionwiseFeedForwardQuant(nn.Module): + """ + Conformer feedforward module + """ + + def __init__(self, cfg: ConformerPositionwiseFeedForwardQuantV1Config): + super().__init__() + + self.layer_norm = nn.LayerNorm(cfg.input_dim) + self.linear_ff = LinearQuant( + in_features=cfg.input_dim, + out_features=cfg.hidden_dim, + weight_bit_prec=cfg.weight_bit_prec, + weight_quant_dtype=cfg.weight_quant_dtype, + weight_quant_method=cfg.weight_quant_method, + activation_bit_prec=cfg.activation_bit_prec, + activation_quant_dtype=cfg.activation_quant_dtype, + activation_quant_method=cfg.activation_quant_method, + moving_average=cfg.moving_average, + bias=True, + quant_output=cfg.linear_quant_output + ) + self.activation = cfg.activation + self.linear_out = LinearQuant( + in_features=cfg.hidden_dim, + out_features=cfg.input_dim, + weight_bit_prec=cfg.weight_bit_prec, + weight_quant_dtype=cfg.weight_quant_dtype, + weight_quant_method=cfg.weight_quant_method, + activation_bit_prec=cfg.activation_bit_prec, + activation_quant_dtype=cfg.activation_quant_dtype, + activation_quant_method=cfg.activation_quant_method, + moving_average=cfg.moving_average, + bias=True, + quant_output=cfg.linear_quant_output + ) + self.dropout = cfg.dropout + + def forward(self, tensor: torch.Tensor) -> torch.Tensor: + """ + :param tensor: shape [B,T,F], F=input_dim + :return: shape [B,T,F], F=input_dim + """ + tensor = self.layer_norm(tensor) + tensor = self.linear_ff(tensor) # [B,T,F] + tensor = self.activation(tensor) # [B,T,F] + tensor = nn.functional.dropout(tensor, p=self.dropout, training=self.training) # [B,T,F] + tensor = self.linear_out(tensor) # [B,T,F] + tensor = nn.functional.dropout(tensor, p=self.dropout, training=self.training) # [B,T,F] + return tensor + +class ConformerMHSAQuant(torch.nn.Module): + """ + Conformer multi-headed self-attention module + """ + + def __init__(self, cfg: QuantizedMultiheadAttentionV1Config): + + super().__init__() + + self.layernorm = torch.nn.LayerNorm(cfg.input_dim) + self.mhsa = QuantizedMultiheadAttention(cfg=cfg) + self.dropout = cfg.dropout + + def forward(self, input_tensor: torch.Tensor, sequence_mask: torch.Tensor) -> torch.Tensor: + """ + Apply layer norm and multi-head self attention and dropout + + :param input_tensor: Input to the self attention of shape (B, T, F) + :param sequence_mask: bool mask of shape (B, T), True signals within sequence, False outside, will be inverted + which will be applied/added to dot product, used to mask padded key positions out + """ + inv_sequence_mask = compat.logical_not(sequence_mask) + output_tensor = self.layernorm(input_tensor) # [B,T,F] + + output_tensor, _ = self.mhsa( + output_tensor, output_tensor, output_tensor, mask=inv_sequence_mask + ) # [B,T,F] + output_tensor = torch.nn.functional.dropout(output_tensor, p=self.dropout, training=self.training) # [B,T,F] + + return output_tensor + + +class ConformerConvolutionQuant(nn.Module): + """ + Conformer convolution module. + see also: https://github.com/espnet/espnet/blob/713e784c0815ebba2053131307db5f00af5159ea/espnet/nets/pytorch_backend/conformer/convolution.py#L13 + + Uses explicit padding for ONNX exportability, see: + https://github.com/pytorch/pytorch/issues/68880 + """ + + def __init__(self, model_cfg: ConformerConvolutionQuantV1Config): + """ + :param model_cfg: model configuration for this module + """ + super().__init__() + model_cfg.check_valid() + self.pointwise_conv1 = LinearQuant( + in_features=model_cfg.channels, + out_features=2 * model_cfg.channels, + weight_bit_prec=model_cfg.weight_bit_prec, + weight_quant_dtype=model_cfg.weight_quant_dtype, + weight_quant_method=model_cfg.weight_quant_method, + activation_bit_prec=model_cfg.activation_bit_prec, + activation_quant_dtype=model_cfg.activation_quant_dtype, + activation_quant_method=model_cfg.activation_quant_method, + moving_average=model_cfg.moving_average, + bias=True, + quant_output=model_cfg.linear_quant_output, + ) + # TODO: Quantize this + self.depthwise_conv = nn.Conv1d( + in_channels=model_cfg.channels, + out_channels=model_cfg.channels, + kernel_size=model_cfg.kernel_size, + padding=(model_cfg.kernel_size - 1) // 2, + groups=model_cfg.channels, + ) + self.pointwise_conv2 = LinearQuant( + in_features=model_cfg.channels, + out_features=model_cfg.channels, + weight_bit_prec=model_cfg.weight_bit_prec, + weight_quant_dtype=model_cfg.weight_quant_dtype, + weight_quant_method=model_cfg.weight_quant_method, + activation_bit_prec=model_cfg.activation_bit_prec, + activation_quant_dtype=model_cfg.activation_quant_dtype, + activation_quant_method=model_cfg.activation_quant_method, + moving_average=model_cfg.moving_average, + bias=True, + quant_output=model_cfg.linear_quant_output, + ) + self.layer_norm = nn.LayerNorm(model_cfg.channels) + self.norm = copy.deepcopy(model_cfg.norm) + self.dropout = nn.Dropout(model_cfg.dropout) + self.activation = model_cfg.activation + + def forward(self, tensor: torch.Tensor) -> torch.Tensor: + """ + :param tensor: input tensor of shape [B,T,F] + :return: torch.Tensor of shape [B,T,F] + """ + tensor = self.layer_norm(tensor) + tensor = self.pointwise_conv1(tensor) # [B,T,2F] + tensor = nn.functional.glu(tensor, dim=-1) # [B,T,F] + + # conv layers expect shape [B,F,T] so we have to transpose here + tensor = tensor.transpose(1, 2) # [B,F,T] + tensor = self.depthwise_conv(tensor) + + tensor = self.norm(tensor) + tensor = tensor.transpose(1, 2) # transpose back to [B,T,F] + + tensor = self.activation(tensor) + tensor = self.pointwise_conv2(tensor) + + return self.dropout(tensor) + + +class ConformerBlockQuant(nn.Module): + """ + Conformer block module + """ + + def __init__(self, cfg: ConformerBlockQuantV1Config): + """ + :param cfg: conformer block configuration with subunits for the different conformer parts + """ + super().__init__() + self.ff1 = ConformerPositionwiseFeedForwardQuant(cfg=cfg.ff_cfg) + self.mhsa = ConformerMHSAQuant(cfg=cfg.mhsa_cfg) + self.conv = ConformerConvolutionQuant(model_cfg=cfg.conv_cfg) + self.ff2 = ConformerPositionwiseFeedForwardQuant(cfg=cfg.ff_cfg) + self.final_layer_norm = torch.nn.LayerNorm(cfg.ff_cfg.input_dim) + + def forward(self, x: torch.Tensor, /, sequence_mask: torch.Tensor) -> torch.Tensor: + """ + :param x: input tensor of shape [B, T, F] + :param sequence_mask: mask tensor where 0 defines positions within the sequence and 1 outside, shape: [B, T] + :return: torch.Tensor of shape [B, T, F] + """ + x = 0.5 * self.ff1(x) + x # [B, T, F] + x = self.mhsa(x, sequence_mask) + x # [B, T, F] + x = self.conv(x) + x # [B, T, F] + x = 0.5 * self.ff2(x) + x # [B, T, F] + x = self.final_layer_norm(x) # [B, T, F] + return x + + +class ConformerEncoderQuant(nn.Module): + """ + TODO + Implementation of the convolution-augmented Transformer (short Conformer), as in the original publication. + The model consists of a frontend and a stack of N conformer blocks. + C.f. https://arxiv.org/pdf/2005.08100.pdf + """ + + def __init__(self, cfg: ConformerEncoderQuantV1Config): + """ + :param cfg: conformer encoder configuration with subunits for frontend and conformer blocks + """ + super().__init__() + + self.frontend = cfg.frontend() + self.module_list = torch.nn.ModuleList([ConformerBlockQuant(cfg.block_cfg) for _ in range(cfg.num_layers)]) + + def forward(self, data_tensor: torch.Tensor, sequence_mask: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]: + """ + :param data_tensor: input tensor of shape [B, T', F] + :param sequence_mask: mask tensor where 0 defines positions within the sequence and 1 outside, shape: [B, T'] + :return: (output, out_seq_mask) + where output is torch.Tensor of shape [B, T, F'], + out_seq_mask is a torch.Tensor of shape [B, T] + + F: input feature dim, F': internal and output feature dim + T': data time dim, T: down-sampled time dim (internal time dim) + """ + x, sequence_mask = self.frontend(data_tensor, sequence_mask) # [B, T, F'] + for module in self.module_list: + x = module(x, sequence_mask) # [B, T, F'] + + return x, sequence_mask + + +def mask_tensor(tensor: torch.Tensor, seq_len: torch.Tensor) -> torch.Tensor: + """ + mask a tensor with a "positive" mask (boolean true means position is used) + + This function is traceable. + + :param tensor: [B,T,....] + :param seq_len: [B] + :return: [B,T] + """ + seq_len = seq_len.to(device=tensor.device) + r = torch.arange(tensor.shape[1], device=tensor.device) # [T] + seq_mask = torch.less(r[None, :], seq_len[:, None]) # broadcast to [B,T] + return seq_mask + + +class Model(torch.nn.Module): + def __init__(self, model_config_dict, quant_config_dict=None, **kwargs): + epoch = kwargs.pop("epoch") + step = kwargs.pop("step") + if len(kwargs) >= 2: + assert False, f"You did not use all kwargs: {kwargs}" + elif len(kwargs) == 1: + assert "random" in list(kwargs.keys())[0], "This must only be RETURNN random arg" + + super().__init__() + self.train_config = QuantModelTrainConfigV1.from_dict(model_config_dict) + fe_config = self.train_config.feature_extraction_config + frontend_config = self.train_config.frontend_config + conformer_size = self.train_config.conformer_size + self.feature_extraction = LogMelFeatureExtractionV1(cfg=fe_config) + if quant_config_dict: + print("Using Quantizable Model") + self.cfg = QuantModelConfigV1.from_dict(quant_config_dict) + conformer_config = ConformerEncoderQuantV1Config( + num_layers=self.train_config.num_layers, + frontend=ModuleFactoryV1(module_class=VGG4LayerActFrontendV1, cfg=frontend_config), + block_cfg=ConformerBlockQuantV1Config( + ff_cfg=ConformerPositionwiseFeedForwardQuantV1Config( + input_dim=conformer_size, + hidden_dim=self.train_config.ff_dim, + dropout=self.train_config.ff_dropout, + activation=nn.functional.silu, + weight_quant_dtype=self.cfg.weight_quant_dtype, + weight_quant_method=self.cfg.weight_quant_method, + activation_quant_dtype=self.cfg.activation_quant_dtype, + activation_quant_method=self.cfg.activation_quant_method, + moving_average=self.cfg.moving_average, + weight_bit_prec=self.cfg.weight_bit_prec, + activation_bit_prec=self.cfg.activation_bit_prec, + linear_quant_output=self.cfg.linear_quant_output + ), + mhsa_cfg=QuantizedMultiheadAttentionV1Config( + input_dim=conformer_size, + num_att_heads=self.train_config.num_heads, + att_weights_dropout=self.train_config.att_weights_dropout, + dropout=self.train_config.mhsa_dropout, + weight_quant_dtype=self.cfg.weight_quant_dtype, + weight_quant_method=self.cfg.weight_quant_method, + activation_quant_dtype=self.cfg.activation_quant_dtype, + activation_quant_method=self.cfg.activation_quant_method, + activation_bit_prec=self.cfg.activation_bit_prec, + dot_quant_dtype=self.cfg.dot_quant_dtype, + dot_quant_method=self.cfg.dot_quant_method, + Av_quant_dtype=self.cfg.Av_quant_dtype, + Av_quant_method=self.cfg.Av_quant_method, + bit_prec_W_q=self.cfg.weight_bit_prec, + bit_prec_W_k=self.cfg.weight_bit_prec, + bit_prec_W_v=self.cfg.weight_bit_prec, + bit_prec_dot=self.cfg.weight_bit_prec, + bit_prec_A_v=self.cfg.weight_bit_prec, + bit_prec_W_o=self.cfg.weight_bit_prec, + moving_average=self.cfg.moving_average, + linear_quant_output=self.cfg.linear_quant_output, + ), + conv_cfg=ConformerConvolutionQuantV1Config( + channels=conformer_size, + kernel_size=self.train_config.conv_kernel_size, + dropout=self.train_config.conv_dropout, + activation=nn.functional.silu, + norm=LayerNormNC(conformer_size), + weight_bit_prec=self.cfg.weight_bit_prec, + weight_quant_dtype=self.cfg.weight_quant_dtype, + weight_quant_method=self.cfg.weight_quant_method, + activation_bit_prec=self.cfg.activation_bit_prec, + activation_quant_dtype=self.cfg.activation_quant_dtype, + activation_quant_method=self.cfg.activation_quant_method, + moving_average=self.cfg.moving_average, + linear_quant_output=self.cfg.linear_quant_output, + ), + ), + ) + self.conformer = ConformerEncoderQuant(cfg=conformer_config) + else: + conformer_config = ConformerEncoderV1Config( + num_layers=self.train_config.num_layers, + frontend=ModuleFactoryV1(module_class=VGG4LayerActFrontendV1, cfg=frontend_config), + block_cfg=ConformerBlockV1Config( + ff_cfg=ConformerPositionwiseFeedForwardV1Config( + input_dim=conformer_size, + hidden_dim=self.train_config.ff_dim, + dropout=self.train_config.ff_dropout, + activation=nn.functional.silu, + ), + mhsa_cfg=ConformerMHSAV1Config( + input_dim=conformer_size, + num_att_heads=self.train_config.num_heads, + att_weights_dropout=self.train_config.att_weights_dropout, + dropout=self.train_config.mhsa_dropout, + ), + conv_cfg=ConformerConvolutionV1Config( + channels=conformer_size, + kernel_size=self.train_config.conv_kernel_size, + dropout=self.train_config.conv_dropout, + activation=nn.functional.silu, + norm=LayerNormNC(conformer_size), + ), + ), + ) + self.conformer = ConformerEncoderV1(cfg=conformer_config) + + + self.final_linear = nn.Linear(conformer_size, self.train_config.label_target_size + 1) # + CTC blank TODO: do we quant here too? + self.final_dropout = nn.Dropout(p=self.train_config.final_dropout) + self.specaug_start_epoch = self.train_config.specauc_start_epoch + + # No particular weight init! + + def forward( + self, + raw_audio: torch.Tensor, + raw_audio_len: torch.Tensor, + ): + """ + :param raw_audio: Audio samples as [B, T, 1] + :param raw_audio_len: length of T as [B] + :return: logprobs [B, T, #labels + blank] + """ + + squeezed_features = torch.squeeze(raw_audio, dim=-1) + with torch.no_grad(): + audio_features, audio_features_len = self.feature_extraction(squeezed_features, raw_audio_len) + + run_ctx = get_run_ctx() + if self.training and run_ctx.epoch >= self.specaug_start_epoch: + audio_features_masked_2 = specaugment_v1_by_length( + audio_features, + time_min_num_masks=2, + time_max_mask_per_n_frames=self.train_config.specaug_config.repeat_per_n_frames, + time_mask_max_size=self.train_config.specaug_config.max_dim_time, + freq_min_num_masks=2, + freq_mask_max_size=self.train_config.specaug_config.max_dim_feat, + freq_max_num_masks=self.train_config.specaug_config.num_repeat_feat, + ) + else: + audio_features_masked_2 = audio_features + + conformer_in = audio_features_masked_2 + # create the mask for the conformer input + mask = mask_tensor(conformer_in, audio_features_len) + + conformer_out, out_mask = self.conformer(conformer_in, mask) + conformer_out = self.final_dropout(conformer_out) + logits = self.final_linear(conformer_out) + + log_probs = torch.log_softmax(logits, dim=2) + + return log_probs, torch.sum(out_mask, dim=1) + + +def train_step(*, model: Model, data, run_ctx, **kwargs): + + raw_audio = data["raw_audio"] # [B, T', F] + raw_audio_len = data["raw_audio:size1"].to("cpu") # [B] + + labels = data["labels"] # [B, N] (sparse) + labels_len = data["labels:size1"] # [B, N] + + logprobs, audio_features_len = model( + raw_audio=raw_audio, + raw_audio_len=raw_audio_len, + ) + transposed_logprobs = torch.permute(logprobs, (1, 0, 2)) # CTC needs [T, B, F] + ctc_loss = nn.functional.ctc_loss( + transposed_logprobs, + labels, + input_lengths=audio_features_len, + target_lengths=labels_len, + blank=model.train_config.label_target_size, + reduction="sum", + zero_infinity=True, + ) + num_phonemes = torch.sum(labels_len) + run_ctx.mark_as_loss(name="ctc", loss=ctc_loss, inv_norm_factor=num_phonemes) + + +def prior_init_hook(run_ctx, **kwargs): + # we are storing durations, but call it output.hdf to match + # the default output of the ReturnnForwardJob + run_ctx.sum_probs = None + run_ctx.sum_frames = 0 + + +def prior_finish_hook(run_ctx, **kwargs): + all_frames = run_ctx.sum_frames.detach().cpu().numpy() + all_probs = run_ctx.sum_probs.detach().cpu().numpy() + average_probs = all_probs / all_frames + log_average_probs = np.log(average_probs) + print("Prior sum in std-space (should be close to 1.0):", np.sum(average_probs)) + with open("prior.txt", "w") as f: + np.savetxt(f, log_average_probs, delimiter=" ") + print("Saved prior in prior.txt in +log space.") + + +def prior_step(*, model: Model, data, run_ctx, **kwargs): + raw_audio = data["raw_audio"] # [B, T', F] + raw_audio_len = data["raw_audio:size1"] # [B] + + logprobs, audio_features_len = model( + raw_audio=raw_audio, + raw_audio_len=raw_audio_len, + ) + + probs = torch.exp(logprobs) + run_ctx.sum_frames = run_ctx.sum_frames + torch.sum(audio_features_len) + if run_ctx.sum_probs is None: + run_ctx.sum_probs = torch.sum(probs, dim=(0, 1)) + else: + run_ctx.sum_probs += torch.sum(probs, dim=(0, 1)) + + +def static_quant_init_hook(run_ctx, **kwargs): + # These flags are not required for quant, only later for forward + run_ctx.iterative_quant = False + run_ctx.apply_quant = False + run_ctx.tag_file = open("seq_tags.txt", "wt") + +def static_quant_step(*, model: Model, data, run_ctx, **kwargs): + + raw_audio = data["raw_audio"] # [B, T', F] + raw_audio_len = data["raw_audio:size1"] # [B] + assert not model.training + assert model.eval() + model.eval() + _, audio_features_len = model( + raw_audio=raw_audio, + raw_audio_len=raw_audio_len, + ) + for tag, feat_len, raw_len in zip(data["seq_tag"], audio_features_len, raw_audio_len): + run_ctx.tag_file.write(tag + f" len: {feat_len} raw_len: {raw_len}\n") + +def static_quant_finish_hook(run_ctx, **kwargs): + run_ctx.tag_file.close() + torch.save({"model": run_ctx.engine._model.state_dict(), "epoch": 250, "step": run_ctx.engine._train_step}, "model.pt") diff --git a/users/hilmes/experiments/tedlium2/standalone/pytorch_networks/ctc/conformer_1023/quant/baseline_quant_v2_modules.py b/users/hilmes/experiments/tedlium2/standalone/pytorch_networks/ctc/conformer_1023/quant/baseline_quant_v2_modules.py new file mode 100644 index 000000000..d603e3696 --- /dev/null +++ b/users/hilmes/experiments/tedlium2/standalone/pytorch_networks/ctc/conformer_1023/quant/baseline_quant_v2_modules.py @@ -0,0 +1,358 @@ +""" +Fixes mhsa norm +""" +import copy + +import torch +from torch import nn +import torch.ao.quantization as torch_quant +import torch.nn.functional as F +from typing import Optional +from .baseline_quant_v1_cfg import QuantizedMultiheadAttentionV1Config +import math +from returnn.torch.context import get_run_ctx +from torch.ao.quantization.utils import check_min_max_valid + +def get_quantization_range_from_bit_precision(bits, dtype): + + if dtype == torch.qint8: + quant_min = -(2**(bits-1)) + quant_max = (2**(bits-1))-1 + + elif dtype == torch.quint8: + quant_min = 0 + quant_max = (2**bits)-1 + + else: + raise ValueError(f'Unrecognized dtype {dtype}') + + return quant_min, quant_max + + +class WeightQuantizer(nn.Module): + def __init__(self, bit_precision: int, dtype: torch.dtype, method: str, reduce_range: bool = False): + super().__init__() + + self.quant_min, self.quant_max = get_quantization_range_from_bit_precision(bit_precision, dtype) + self.dtype = dtype + self.reduce_range = reduce_range + self.quant_fn, self.observer = None, None + self.quant_fn, self.observer = self.__get_quant_fn_and_observer_for_method(method) + self.scale = None + self.zero_point = None + + def __get_quant_fn_and_observer_for_method(self, method): + if self.quant_fn is not None and self.observer is not None: + return self.quant_fn, self.observer + if method == 'per_tensor': + quant_fn = torch.fake_quantize_per_tensor_affine + observer = torch_quant.observer.MinMaxObserver( + quant_min=self.quant_min, + quant_max=self.quant_max, + dtype=self.dtype, + reduce_range=self.reduce_range + ) + else: + raise ValueError(f'Unknown quantization method: {method}!') + + return quant_fn, observer + + def forward(self, tensor: torch.Tensor): + if self.training: + # This module does not do anything in training + return tensor + if not get_run_ctx().apply_quant: + tensor = self.observer(tensor) + if get_run_ctx().iterative_quant or get_run_ctx().apply_quant: + # und nicht erst ganz am Ende. Heißt jeder Batch wird iterativ quantisiert + self.set_scale_and_zp() + assert self.scale is not None and self.zero_point is not None + tensor = self.quant_fn(tensor, self.scale, self.zero_point, self.quant_min, self.quant_max) + return tensor + + def set_scale_and_zp(self): + assert self.observer is not None + assert check_min_max_valid(self.observer.min_val, self.observer.max_val), "Need to init observer first" + self.scale, self.zero_point = self.observer.calculate_qparams() + + +class ActivationQuantizer(nn.Module): + + def __init__( + self, + bit_precision: int, + dtype: torch.dtype, + method: str, + channel_axis: Optional[int], + moving_avrg: Optional[float], # default if enabled should be 0.01, if set enables moving average + reduce_range: bool = False, + ): + super().__init__() + self.quant_min, self.quant_max = get_quantization_range_from_bit_precision(bit_precision, dtype) + self.dtype = dtype + self.channel_axis = channel_axis + self.moving_avrg = moving_avrg + self.reduce_range = reduce_range + self.quant_fn, self.observer, self.base_observer_args = None, None, None + self.quant_fn, self.observer, self.base_observer_args = self.__get_quant_fn_and_observer_for_method(method) + self.zero_point = None + self.scale = None + + def __get_quant_fn_and_observer_for_method(self, method): + if all(x is not None for x in [self.quant_fn, self.base_observer_args, self.observer]): + return self.quant_fn, self.base_observer_args, self.observer + if method == 'per_tensor': + quant_fn = torch.fake_quantize_per_tensor_affine + base_observer_args = [self.quant_min, self.quant_max] + if self.moving_avrg: + observer = torch_quant.observer.MovingAverageMinMaxObserver( + averaging_constant=self.moving_avrg, + quant_min=self.quant_min, + quant_max=self.quant_max, + dtype=self.dtype, + reduce_range=self.reduce_range + ) + else: + observer = torch_quant.observer.MinMaxObserver( + quant_min=self.quant_min, + quant_max=self.quant_max, + dtype=self.dtype, + reduce_range=self.reduce_range + ) + elif method == 'per_channel': + quant_fn = torch.fake_quantize_per_channel_affine + base_observer_args = [self.channel_axis, self.quant_min, self.quant_max] + assert self.channel_axis is not None + if self.moving_avrg: + observer = torch_quant.observer.MovingAveragePerChannelMinMaxObserver( + averaging_constant=self.moving_avrg, + quant_min=self.quant_min, + quant_max=self.quant_max, + dtype=self.dtype, + ch_axis=self.channel_axis, + reduce_range=self.reduce_range + ) + else: + observer = torch_quant.observer.PerChannelMinMaxObserver( + quant_min=self.quant_min, + quant_max=self.quant_max, + dtype=self.dtype, + reduce_range=self.reduce_range, + ch_axis=self.channel_axis + ) + else: + raise ValueError(f'Unknown quantization method: {method}!') + + return quant_fn, observer, base_observer_args + + + def forward(self, tensor: torch.Tensor): + if self.training: + # This module does not do anything in training + return tensor + # self.observer.reset_min_max_vals() + if get_run_ctx().apply_quant is not True: + tensor = self.observer(tensor) + if get_run_ctx().iterative_quant is True or get_run_ctx().apply_quant is True: + self.set_scale_and_zp() + assert self.scale is not None and self.zero_point is not None, "Need to calibrate before applying quant, disable apply_calibration" + old_tensor = copy.deepcopy(tensor) + tensor = self.quant_fn(tensor, self.scale, self.zero_point, self.quant_min, self.quant_max) + # This 0 case should only happen when the model is broken anyways like for 4 bit + # TODO it seems for linear out this might be the case + #assert not torch.equal(old_tensor, tensor) or torch.sum(old_tensor) == torch.sum(tensor) == 0, (tensor[0,0,0], old_tensor[0 , 0 ,0], self.scale, self.zero_point, self.quant_min, self.quant_max) + return tensor + + def set_scale_and_zp(self): + assert self.observer is not None + assert check_min_max_valid(self.observer.min_val, self.observer.max_val), "Need to init observer first" + self.scale, self.zero_point = self.observer.calculate_qparams() + + +class LinearQuant(nn.Module): + + def __init__( + self, + in_features: int, + out_features: int, + weight_bit_prec: int, + weight_quant_dtype: torch.dtype, + weight_quant_method: str, + activation_bit_prec: int, + activation_quant_dtype: torch.dtype, + activation_quant_method: str, + moving_average: Optional[float], # default if enabled should be 0.01, if set enables moving average + bias: bool, + quant_output: bool + ): + super().__init__() + self.weight = nn.Parameter(torch.empty((out_features, in_features)), requires_grad=True) + if bias: + self.bias = nn.Parameter(torch.empty((out_features,)), requires_grad=True) + + self.weight_bit_prec = weight_bit_prec + self.weight_quant_dtype = weight_quant_dtype + self.weight_quant_method = weight_quant_method + self.weight_quantizer = WeightQuantizer( + bit_precision=self.weight_bit_prec, + dtype=self.weight_quant_dtype, + method=self.weight_quant_method + ) + + self.activation_bit_prec = activation_bit_prec + self.activation_quant_dtype = activation_quant_dtype + self.activation_quant_method = activation_quant_method + self.activation_quantizer = ActivationQuantizer( + bit_precision=self.activation_bit_prec, + dtype=self.activation_quant_dtype, + method=self.activation_quant_method, + channel_axis=2, + moving_avrg=moving_average) + + self.quant_output = quant_output + if self.quant_output: + self.output_quantizer = ActivationQuantizer( + bit_precision=self.activation_bit_prec, + dtype=self.activation_quant_dtype, + method=self.activation_quant_method, + channel_axis=2, + moving_avrg=moving_average + ) + + def forward(self, tensor: torch.Tensor): + lin = F.linear(self.activation_quantizer(tensor), self.weight_quantizer(self.weight), self.bias) + if self.quant_output: + return self.output_quantizer(lin) + else: + return lin + +class QuantizedMultiheadAttention(nn.Module): + def __init__( + self, + cfg: QuantizedMultiheadAttentionV1Config + ): + super().__init__() + self.cfg = cfg + self.num_att_heads = cfg.num_att_heads + self.input_dim = cfg.input_dim + self.dim_heads = self.input_dim // self.num_att_heads + + self.bit_prec_dot = cfg.bit_prec_dot + self.bit_prec_Av = cfg.bit_prec_A_v + self.weight_quant_dtype = cfg.weight_quant_dtype + self.weight_quant_method = cfg.weight_quant_method + self.activation_quant_dtype = cfg.activation_quant_dtype + self.activation_quant_method = cfg.activation_quant_method + self.dot_quant_dtype = cfg.dot_quant_dtype + self.dot_quant_method = cfg.dot_quant_method + self.Av_quant_dtype = cfg.Av_quant_dtype + self.Av_quant_method = cfg.Av_quant_method + self.linear_quant_output = cfg.linear_quant_output + + self.out_proj = self._create_linear_layer( + weight_bits=cfg.bit_prec_W_o, + act_bits=cfg.activation_bit_prec, + ) + + # For some reason pytorch saves the in_proj_weight and bias in this format not with . so we need to adjust + self.in_proj = self._create_linear_layer( + weight_bits=cfg.bit_prec_W_q, + act_bits=cfg.activation_bit_prec, + output_dim=3 * self.input_dim + ) + self.register_parameter("in_proj_weight", self.in_proj.weight) + self.register_parameter("in_proj_bias", self.in_proj.bias) + + if self.bit_prec_dot < 16: + self.q_quantizer = ActivationQuantizer( + self.bit_prec_dot, + self.dot_quant_dtype, + self.dot_quant_method, + channel_axis=None if self.dot_quant_method == "per_tensor" else 3, + moving_avrg=cfg.moving_average + ) + self.k_quantizer = ActivationQuantizer( + self.bit_prec_dot, + self.dot_quant_dtype, + self.dot_quant_method, + channel_axis=None if self.dot_quant_method == "per_tensor" else 2, + moving_avrg=cfg.moving_average + ) + + if self.bit_prec_Av < 16: + self.a_quantizer = WeightQuantizer( + self.bit_prec_Av, + self.Av_quant_dtype, + self.Av_quant_method + ) + self.v_quantizer = ActivationQuantizer( + self.bit_prec_Av, + self.Av_quant_dtype, + self.Av_quant_method, + moving_avrg=cfg.moving_average, + channel_axis=None if self.dot_quant_method == "per_tensor" else NotImplementedError, + ) + self.norm = math.sqrt(self.dim_heads) + self.softmax = nn.Softmax(-1) + self.dropout = nn.Dropout(cfg.att_weights_dropout) + + def _create_linear_layer(self, weight_bits, act_bits, output_dim=None): + return LinearQuant( + in_features=self.input_dim, + out_features=output_dim or self.input_dim, + weight_bit_prec=weight_bits, + weight_quant_dtype=self.weight_quant_dtype, + weight_quant_method=self.weight_quant_method, + activation_bit_prec=act_bits, + activation_quant_dtype=self.activation_quant_dtype, + activation_quant_method=self.activation_quant_method, + moving_average=self.cfg.moving_average, + bias=True, + quant_output=self.linear_quant_output + ) + + def forward(self, query: torch.Tensor, key: torch.Tensor, value: torch.Tensor, mask: Optional[torch.Tensor] = None): + + batch_dim = query.shape[0] + + #query = self.W_q(query) + #key = self.W_k(key) + #value = self.W_v(value) + assert query is value is key, "currently only this case is implemented" + + x = self.in_proj(query) + hidden_dim = query.size(-1) + query, key, value = x.unflatten(-1, (3, hidden_dim)).unsqueeze(0).transpose(0, -2).squeeze(-2).contiguous() + + query = query.view(batch_dim, -1, self.num_att_heads, self.dim_heads) # [B, T, D//H, D'] + key = key.view(batch_dim, -1, self.num_att_heads, self.dim_heads) # [B, T, D//H, D'] + value = value.view(batch_dim, -1, self.num_att_heads, self.dim_heads) # [B, T, D//H, D'] + + query = torch.transpose(query, 1, 2) # [B, D//H, T, D'] + key = torch.transpose(key, 1, 2) # [B, D//H, T, D'] + value = torch.transpose(value, 1, 2) # [B, D//H, T, D'] + + key = torch.transpose(key, -2, -1) # [B, D//H, D', T] + + if self.bit_prec_dot < 16: + query = self.q_quantizer(query) + key = self.k_quantizer(key) + + dot = torch.matmul(query, key) # [B, D//H, T, T] + dot = dot / self.norm + if mask is not None: + mask = mask.view(batch_dim, 1, 1, mask.size(1)) + dot = dot.masked_fill(mask, -float('inf')) + alpha = self.softmax(dot) + alpha = self.dropout(alpha) + + if self.bit_prec_Av < 16: + alpha = self.a_quantizer(alpha) + value = self.v_quantizer(value) + + att_out = torch.matmul(alpha, value) # [B, D//H, T, D'] + att_out = torch.transpose(att_out, 1, 2) # [B, D//H, T, D'] + att_out = att_out.reshape(batch_dim, -1, self.input_dim) # [B, T, D] + att_out = self.out_proj(att_out) + + return att_out, alpha diff --git a/users/hilmes/experiments/tedlium2/standalone/report.py b/users/hilmes/experiments/tedlium2/standalone/report.py index e8df79852..917bceb58 100644 --- a/users/hilmes/experiments/tedlium2/standalone/report.py +++ b/users/hilmes/experiments/tedlium2/standalone/report.py @@ -8,7 +8,7 @@ def calc_stat(ls): max = np.max([float(x[1]) for x in ls]) median = np.median([float(x[1]) for x in ls]) std = np.std([float(x[1]) for x in ls]) - ex_str = f"Avrg: {avrg}, Min {min}, Max {max}, Median {median}, Std {std}, ({avrg},{min},{max},{median},{std})" + ex_str = f"Avrg: {avrg}, Min {min}, Max {max}, Median {median}, Std {std}, ({avrg},{min},{max},{median},{std}) Num Values: {len(ls)}" return ex_str def baseline_report_format(report: _Report_Type) -> str: @@ -18,34 +18,38 @@ def baseline_report_format(report: _Report_Type) -> str: :return: """ extra_ls = ["quantize_static"] + sets = set() + for recog in report: + sets.add(recog.split("/")[-1]) out = [(" ".join(recog.split("/")[3:]), str(report[recog])) for recog in report if not any(extra in recog for extra in extra_ls)] out = sorted(out, key=lambda x: float(x[1])) best_ls = [out[0]] - for extra in extra_ls: - if extra == "quantize_static": - tmp = {recog: report[recog] for recog in report if extra in recog} - iters = set() - for recog in tmp: - x = recog.split("/") - for sub in x: - if "samples" in sub: - iters.add(sub[len("samples_"):]) - for samples in iters: - out2 = [(" ".join(recog.split("/")[3:]), str(report[recog])) for recog in report if f"samples_{samples}/" in recog] + for dataset in sets: + for extra in extra_ls: + if extra == "quantize_static": + tmp = {recog: report[recog] for recog in report if extra in recog and dataset in recog} + iters = set() + for recog in tmp: + x = recog.split("/") + for sub in x: + if "samples" in sub: + iters.add(sub[len("samples_"):]) + for samples in iters: + out2 = [(" ".join(recog.split("/")[3:]), str(report[recog])) for recog in report if f"samples_{samples}/" in recog and dataset in recog] + out2 = sorted(out2, key=lambda x: float(x[1])) + if len(out2) > 0: + ex_str = calc_stat(out2) + out.append((dataset + " " + extra + f"_samples_{samples}", ex_str)) + out.extend(out2[:3]) + out.extend(out2[-3:]) + best_ls.append(out2[0]) + else: + out2 = [(" ".join(recog.split("/")[3:]), str(report[recog])) for recog in report if extra in recog and dataset in recog] out2 = sorted(out2, key=lambda x: float(x[1])) if len(out2) > 0: - ex_str = calc_stat(out2) - out.append((extra + f"_samples_{samples}", ex_str)) - out.extend(out2[:3]) - out.extend(out2[-3:]) + out.append((dataset + " " + extra, "")) + out.extend(out2) best_ls.append(out2[0]) - else: - out2 = [(" ".join(recog.split("/")[3:]), str(report[recog])) for recog in report if extra in recog] - out2 = sorted(out2, key=lambda x: float(x[1])) - if len(out2) > 0: - out.append((extra, "")) - out.extend(out2) - best_ls.append(out2[0]) best_ls = sorted(best_ls, key=lambda x: float(x[1])) best_ls += [("Base Results", "")] out = best_ls + out From 045aa35a47d4b69edc20860d3fdb5041fe3472bb Mon Sep 17 00:00:00 2001 From: marvin84 Date: Tue, 4 Jun 2024 14:07:49 +0200 Subject: [PATCH 088/227] added factored bw --- common/datasets/tedlium2_v2/corpus.py | 136 +++++++ common/datasets/tedlium2_v2/download.py | 48 +++ common/datasets/tedlium2_v2/export.py | 96 +++++ common/datasets/tedlium2_v2/lexicon.py | 171 ++++++++ common/datasets/tedlium2_v2/textual_data.py | 39 ++ common/datasets/tedlium2_v2/vocab.py | 51 +++ .../configs/LFR_factored/baseline/config.py | 9 + .../common/BASE_factored_hybrid_system.py | 2 +- .../common/TF_factored_hybrid_system.py | 42 +- .../decoder/BASE_factored_hybrid_search.py | 20 +- users/raissi/setups/common/decoder/config.py | 6 + .../setups/common/helpers/network/augment.py | 200 +++++++++- .../setups/common/helpers/priors/__init__.py | 2 +- .../priors/estimate_povey_like_prior_fh.py | 372 +++++++++++------- .../helpers/priors/factored_estimation.py | 249 +++++++----- .../common/helpers/priors/transcription.py | 108 +++-- .../setups/common/helpers/priors/util.py | 13 +- users/raissi/setups/common/util/tdp.py | 4 +- .../decoder/LBS_factored_hybrid_search.py | 61 ++- .../setups/librispeech/helpers/__init__.py | 0 .../librispeech/helpers/priors/__init__.py | 0 .../helpers/priors/transcription.py | 56 +++ users/raissi/utils/default_tools.py | 1 + 23 files changed, 1385 insertions(+), 301 deletions(-) create mode 100644 common/datasets/tedlium2_v2/corpus.py create mode 100644 common/datasets/tedlium2_v2/download.py create mode 100644 common/datasets/tedlium2_v2/export.py create mode 100644 common/datasets/tedlium2_v2/lexicon.py create mode 100644 common/datasets/tedlium2_v2/textual_data.py create mode 100644 common/datasets/tedlium2_v2/vocab.py create mode 100644 users/raissi/setups/librispeech/helpers/__init__.py create mode 100644 users/raissi/setups/librispeech/helpers/priors/__init__.py create mode 100644 users/raissi/setups/librispeech/helpers/priors/transcription.py diff --git a/common/datasets/tedlium2_v2/corpus.py b/common/datasets/tedlium2_v2/corpus.py new file mode 100644 index 000000000..f74a7acbf --- /dev/null +++ b/common/datasets/tedlium2_v2/corpus.py @@ -0,0 +1,136 @@ +import os +from functools import lru_cache +from typing import Dict, Optional, Any + +from sisyphus import tk + +from i6_core.audio.encoding import BlissChangeEncodingJob + +from i6_core.meta import CorpusObject + +from ..tedlium2.constants import DURATIONS +from .download import download_data_dict + + +@lru_cache() +def get_bliss_corpus_dict(audio_format: str = "wav", output_prefix: str = "datasets") -> Dict[str, tk.Path]: + """ + creates a dictionary of all corpora in the TedLiumV2 dataset in the bliss xml format + + :param audio_format: options: wav, ogg, flac, sph, nist. nist (NIST sphere format) and sph are the same. + :param output_prefix: + :return: + """ + assert audio_format in ["flac", "ogg", "wav", "sph", "nist"] + + output_prefix = os.path.join(output_prefix, "Ted-Lium-2") + + bliss_corpus_dict = download_data_dict(output_prefix=output_prefix).bliss_nist + + audio_format_options = { + "wav": { + "output_format": "wav", + "codec": "pcm_s16le", + }, + "ogg": {"output_format": "ogg", "codec": "libvorbis"}, + "flac": {"output_format": "flac", "codec": "flac"}, + } + + converted_bliss_corpus_dict = {} + if audio_format not in ["sph", "nist"]: + for corpus_name, sph_corpus in bliss_corpus_dict.items(): + bliss_change_encoding_job = BlissChangeEncodingJob( + corpus_file=sph_corpus, + sample_rate=16000, + recover_duration=False, + **audio_format_options[audio_format], + ) + bliss_change_encoding_job.add_alias( + os.path.join( + output_prefix, + "%s_conversion" % audio_format, + corpus_name, + ) + ) + converted_bliss_corpus_dict[corpus_name] = bliss_change_encoding_job.out_corpus + else: + converted_bliss_corpus_dict = bliss_corpus_dict + + return converted_bliss_corpus_dict + + +@lru_cache() +def get_corpus_object_dict(audio_format: str = "flac", output_prefix: str = "datasets") -> Dict[str, CorpusObject]: + """ + creates a dict of all corpora in the TedLiumV2 dataset as a `meta.CorpusObject` + + :param audio_format: options: wav, ogg, flac, sph, nist. nist (NIST sphere format) and sph are the same. + :param output_prefix: + :return: + """ + bliss_corpus_dict = get_bliss_corpus_dict(audio_format=audio_format, output_prefix=output_prefix) + + corpus_object_dict = {} + + for corpus_name, bliss_corpus in bliss_corpus_dict.items(): + corpus_object = CorpusObject() + corpus_object.corpus_file = bliss_corpus + corpus_object.audio_format = audio_format + corpus_object.audio_dir = None + corpus_object.duration = DURATIONS[corpus_name] + + corpus_object_dict[corpus_name] = corpus_object + + return corpus_object_dict + + +@lru_cache() +def get_stm_dict(output_prefix: str = "datasets") -> Dict[str, tk.Path]: + """ + fetches the STM files for TedLiumV2 dataset + + :param output_prefix: + :return: + """ + return download_data_dict(output_prefix=output_prefix).stm + + +def get_ogg_zip_dict( + subdir_prefix: str = "datasets", + returnn_python_exe: Optional[tk.Path] = None, + returnn_root: Optional[tk.Path] = None, + bliss_to_ogg_job_rqmt: Optional[Dict[str, Any]] = None, + extra_args: Optional[Dict[str, Dict[str, Any]]] = None, +) -> Dict[str, tk.Path]: + """ + Get a dictionary containing the paths to the ogg_zip for each corpus part. + + No outputs will be registered. + + :param subdir_prefix: dir name prefix for aliases and outputs + :param returnn_python_exe: path to returnn python executable + :param returnn_root: python to returnn root + :param bliss_to_ogg_job_rqmt: rqmt for bliss to ogg job + :param extra_args: extra args for each dataset for bliss to ogg job + :return: dictionary with ogg zip paths for each corpus (train, dev, test) + """ + from i6_core.returnn.oggzip import BlissToOggZipJob + + ogg_zip_dict = {} + bliss_corpus_dict = get_bliss_corpus_dict(audio_format="wav", output_prefix=subdir_prefix) + if extra_args is None: + extra_args = {} + for name, bliss_corpus in bliss_corpus_dict.items(): + ogg_zip_job = BlissToOggZipJob( + bliss_corpus, + no_conversion=False, # cannot be used for corpus with multiple segments per recording + returnn_python_exe=returnn_python_exe, + returnn_root=returnn_root, + **extra_args.get(name, {}), + ) + if bliss_to_ogg_job_rqmt: + ogg_zip_job.rqmt = bliss_to_ogg_job_rqmt + ogg_zip_job.add_alias(os.path.join(subdir_prefix, "Ted-Lium-2", "%s_ogg_zip_job" % name)) + ogg_zip_dict[name] = ogg_zip_job.out_ogg_zip + + return ogg_zip_dict diff --git a/common/datasets/tedlium2_v2/download.py b/common/datasets/tedlium2_v2/download.py new file mode 100644 index 000000000..948224ae7 --- /dev/null +++ b/common/datasets/tedlium2_v2/download.py @@ -0,0 +1,48 @@ +import os +from dataclasses import dataclass +from functools import lru_cache +from typing import Any, Dict + +from sisyphus import tk + +from i6_core.datasets.tedlium2 import ( + DownloadTEDLIUM2CorpusJob, + CreateTEDLIUM2BlissCorpusJobV2, +) + + +@dataclass(frozen=True) +class TedLium2Data: + """Class for storing the TedLium2 data""" + + data_dir: Dict[str, tk.Path] + lm_dir: tk.Path + vocab: tk.Path + bliss_nist: Dict[str, tk.Path] + stm: Dict[str, tk.Path] + + +@lru_cache() +def download_data_dict(output_prefix: str = "datasets") -> TedLium2Data: + """ + downloads the TedLiumV2 dataset and performs the initial data processing steps + Uses the fixed job CreateTEDLIUM2BlissCorpusJobV2 from: https://github.com/rwth-i6/i6_core/pull/490 + + :param output_prefix: + :return: + """ + download_tedlium2_job = DownloadTEDLIUM2CorpusJob() + download_tedlium2_job.add_alias(os.path.join(output_prefix, "download", "raw_corpus_job")) + + bliss_corpus_tedlium2_job = CreateTEDLIUM2BlissCorpusJobV2(download_tedlium2_job.out_corpus_folders) + bliss_corpus_tedlium2_job.add_alias(os.path.join(output_prefix, "create_bliss", "bliss_corpus_job")) + + tl2_data = TedLium2Data( + data_dir=download_tedlium2_job.out_corpus_folders, + lm_dir=download_tedlium2_job.out_lm_folder, + vocab=download_tedlium2_job.out_vocab_dict, + bliss_nist=bliss_corpus_tedlium2_job.out_corpus_files, + stm=bliss_corpus_tedlium2_job.out_stm_files, + ) + + return tl2_data diff --git a/common/datasets/tedlium2_v2/export.py b/common/datasets/tedlium2_v2/export.py new file mode 100644 index 000000000..1919fa8c0 --- /dev/null +++ b/common/datasets/tedlium2_v2/export.py @@ -0,0 +1,96 @@ +import os + +from sisyphus import tk + +from .corpus import get_bliss_corpus_dict, get_stm_dict +from .lexicon import get_bliss_lexicon, get_g2p_augmented_bliss_lexicon +from .textual_data import get_text_data_dict + +TEDLIUM_PREFIX = "Ted-Lium-2" + + +def _export_datasets(output_prefix: str = "datasets"): + """ + exports all datasets for TedLiumV2 with all available audio formats + + :param output_prefix: + :return: + """ + for audio_format in ["flac", "ogg", "wav", "nist", "sph"]: + bliss_corpus_dict = get_bliss_corpus_dict(audio_format=audio_format, output_prefix=output_prefix) + for name, bliss_corpus in bliss_corpus_dict.items(): + tk.register_output( + os.path.join( + output_prefix, + TEDLIUM_PREFIX, + "corpus", + f"{name}-{audio_format}.xml.gz", + ), + bliss_corpus, + ) + + +def _export_stms(output_prefix: str = "datasets"): + """ + exports all STMs for TedLiumV2 + + :param output_prefix: + :return: + """ + stm_dict = get_stm_dict(output_prefix=output_prefix) + for name, stm_file in stm_dict.items(): + tk.register_output( + os.path.join( + output_prefix, + TEDLIUM_PREFIX, + "stm", + f"{name}.txt", + ), + stm_file, + ) + + +def _export_text_data(output_prefix: str = "datasets"): + """ + exports all the textual data for TedLiumV2 dataset + + :param output_prefix: + :return: + """ + txt_data_dict = get_text_data_dict(output_prefix=output_prefix) + for k, v in txt_data_dict.items(): + tk.register_output(os.path.join(output_prefix, TEDLIUM_PREFIX, "text_data", f"{k}.gz"), v) + + +def _export_lexicon(output_prefix: str = "datasets"): + """ + exports the lexicon for TedLiumV2 + + :param output_prefix: + :return: + """ + lexicon_output_prefix = os.path.join(output_prefix, TEDLIUM_PREFIX, "lexicon") + + bliss_lexicon = get_bliss_lexicon(output_prefix=output_prefix) + tk.register_output(os.path.join(lexicon_output_prefix, "tedlium2.lexicon.xml.gz"), bliss_lexicon) + + g2p_bliss_lexicon = get_g2p_augmented_bliss_lexicon( + add_unknown_phoneme_and_mapping=False, output_prefix=output_prefix + ) + tk.register_output( + os.path.join(lexicon_output_prefix, "tedlium2.lexicon_with_g2p.xml.gz"), + g2p_bliss_lexicon, + ) + + +def export_all(output_prefix: str = "datasets"): + """ + exports everything for TedLiumV2 + + :param output_prefix: + :return: + """ + _export_datasets(output_prefix=output_prefix) + _export_stms(output_prefix=output_prefix) + _export_text_data(output_prefix=output_prefix) + _export_lexicon(output_prefix=output_prefix) diff --git a/common/datasets/tedlium2_v2/lexicon.py b/common/datasets/tedlium2_v2/lexicon.py new file mode 100644 index 000000000..4d8366155 --- /dev/null +++ b/common/datasets/tedlium2_v2/lexicon.py @@ -0,0 +1,171 @@ +import os +from functools import lru_cache +from sisyphus import tk + +from i6_core.lexicon import LexiconFromTextFileJob +from i6_core.lexicon.modification import WriteLexiconJob, MergeLexiconJob +from i6_core.lib import lexicon +from i6_experiments.common.helpers.g2p import G2PBasedOovAugmenter + +from ..tedlium2.constants import SILENCE_PHONEME, UNKNOWN_PHONEME +from .corpus import get_bliss_corpus_dict +from .download import download_data_dict + + +@lru_cache() +def _get_special_lemma_lexicon( + add_unknown_phoneme_and_mapping: bool = False, + add_silence: bool = True, +) -> lexicon.Lexicon: + """ + creates the special lemma used in RASR + + :param add_unknown_phoneme_and_mapping: adds [unknown] as label with [UNK] as phoneme and as LM token + :param add_silence: adds [silence] label with [SILENCE] phoneme, + use False for CTC/RNN-T setups without silence modelling. + :return: + """ + lex = lexicon.Lexicon() + if add_silence: + lex.add_lemma( + lexicon.Lemma( + orth=["[silence]", ""], + phon=[SILENCE_PHONEME], + synt=[], + special="silence", + eval=[[]], + ) + ) + if add_unknown_phoneme_and_mapping: + lex.add_lemma( + lexicon.Lemma( + orth=["[unknown]"], + phon=[UNKNOWN_PHONEME], + synt=[""], + special="unknown", + eval=[[]], + ) + ) + else: + lex.add_lemma( + lexicon.Lemma( + orth=["[unknown]"], + synt=[""], + special="unknown", + eval=[[]], + ) + ) + + lex.add_lemma( + lexicon.Lemma( + orth=["[sentence-begin]"], + synt=[""], + special="sentence-begin", + eval=[[]], + ) + ) + lex.add_lemma( + lexicon.Lemma( + orth=["[sentence-end]"], + synt=[""], + special="sentence-end", + eval=[[]], + ) + ) + if add_silence: + lex.add_phoneme(SILENCE_PHONEME, variation="none") + if add_unknown_phoneme_and_mapping: + lex.add_phoneme(UNKNOWN_PHONEME, variation="none") + + return lex + + +@lru_cache() +def _get_raw_bliss_lexicon( + output_prefix: str, +) -> tk.Path: + """ + downloads the vocabulary file from the TedLiumV2 dataset and creates a bliss lexicon + + :param output_prefix: + :return: + """ + vocab = download_data_dict(output_prefix=output_prefix).vocab + + convert_lexicon_job = LexiconFromTextFileJob( + text_file=vocab, + compressed=True, + ) + convert_lexicon_job.add_alias(os.path.join(output_prefix, "convert_text_to_bliss_lexicon_job")) + + return convert_lexicon_job.out_bliss_lexicon + + +@lru_cache() +def get_bliss_lexicon( + add_unknown_phoneme_and_mapping: bool = True, + add_silence: bool = True, + output_prefix: str = "datasets", +) -> tk.Path: + """ + merges the lexicon with special RASR tokens with the lexicon created from the downloaded TedLiumV2 vocabulary + + :param add_unknown_phoneme_and_mapping: add an unknown phoneme and mapping unknown phoneme:lemma + :param add_silence: include silence lemma and phoneme + :param output_prefix: + :return: + """ + static_lexicon = _get_special_lemma_lexicon(add_unknown_phoneme_and_mapping, add_silence) + static_lexicon_job = WriteLexiconJob(static_lexicon, sort_phonemes=True, sort_lemmata=False) + static_lexicon_job.add_alias(os.path.join(output_prefix, "static_lexicon_job")) + + raw_tedlium2_lexicon = _get_raw_bliss_lexicon(output_prefix=output_prefix) + + merge_lexicon_job = MergeLexiconJob( + bliss_lexica=[ + static_lexicon_job.out_bliss_lexicon, + raw_tedlium2_lexicon, + ], + sort_phonemes=True, + sort_lemmata=True, + compressed=True, + ) + merge_lexicon_job.add_alias(os.path.join(output_prefix, "merge_lexicon_job")) + + return merge_lexicon_job.out_bliss_lexicon + + +@lru_cache() +def get_g2p_augmented_bliss_lexicon( + add_unknown_phoneme_and_mapping: bool = False, + add_silence: bool = True, + audio_format: str = "wav", + output_prefix: str = "datasets", +) -> tk.Path: + """ + augment the kernel lexicon with unknown words from the training corpus + + :param add_unknown_phoneme_and_mapping: add an unknown phoneme and mapping unknown phoneme:lemma + :param add_silence: include silence lemma and phoneme + :param audio_format: options: wav, ogg, flac, sph, nist. nist (NIST sphere format) and sph are the same. + :param output_prefix: + :return: + """ + original_bliss_lexicon = get_bliss_lexicon( + add_unknown_phoneme_and_mapping, add_silence=add_silence, output_prefix=output_prefix + ) + corpus_name = "train" + bliss_corpus = get_bliss_corpus_dict(audio_format=audio_format, output_prefix=output_prefix)[corpus_name] + + g2p_augmenter = G2PBasedOovAugmenter( + original_bliss_lexicon=original_bliss_lexicon, + train_lexicon=original_bliss_lexicon, + ) + augmented_bliss_lexicon = g2p_augmenter.get_g2p_augmented_bliss_lexicon( + bliss_corpus=bliss_corpus, + corpus_name=corpus_name, + alias_path=os.path.join(output_prefix, "g2p"), + casing="lower", + ) + + return augmented_bliss_lexicon diff --git a/common/datasets/tedlium2_v2/textual_data.py b/common/datasets/tedlium2_v2/textual_data.py new file mode 100644 index 000000000..553489a0d --- /dev/null +++ b/common/datasets/tedlium2_v2/textual_data.py @@ -0,0 +1,39 @@ +from functools import lru_cache +from typing import Dict + +from sisyphus import tk + +from i6_core.corpus import CorpusToTxtJob +from i6_core.text import ConcatenateJob + +from i6_experiments.common.datasets.tedlium2.corpus_v2 import get_bliss_corpus_dict + +from .download import download_data_dict + + +@lru_cache() +def get_text_data_dict(output_prefix: str = "datasets") -> Dict[str, tk.Path]: + """ + gather all the textual data provided within the TedLiumV2 dataset + + :param output_prefix: + :return: + """ + lm_dir = download_data_dict(output_prefix=output_prefix).lm_dir + + text_corpora = [ + "commoncrawl-9pc", + "europarl-v7-6pc", + "giga-fren-4pc", + "news-18pc", + "news-commentary-v8-9pc", + "yandex-1m-31pc", + ] + + txt_dict = {name: lm_dir.join_right("%s.en.gz" % name) for name in text_corpora} + txt_dict["audio-transcriptions"] = CorpusToTxtJob( + get_bliss_corpus_dict(audio_format="wav", output_prefix="corpora")["train"] + ).out_txt + txt_dict["background-data"] = ConcatenateJob(list(txt_dict.values())).out + + return txt_dict diff --git a/common/datasets/tedlium2_v2/vocab.py b/common/datasets/tedlium2_v2/vocab.py new file mode 100644 index 000000000..14d4455f5 --- /dev/null +++ b/common/datasets/tedlium2_v2/vocab.py @@ -0,0 +1,51 @@ +from i6_experiments.common.helpers.text_labels.subword_nmt_bpe import ( + get_returnn_subword_nmt, + get_bpe_settings, + BPESettings, +) +from .corpus import get_bliss_corpus_dict + + +def get_subword_nmt_bpe(bpe_size: int, unk_label: str = "", subdir_prefix: str = "") -> BPESettings: + """ + Get the BPE tokens via the Returnn subword-nmt for a Tedlium2 setup. + + :param bpe_size: the number of BPE merge operations. This is NOT the resulting vocab size! + :param unk_label: unknown label symbol + :param subdir_prefix: dir name prefix for aliases and outputs + """ + subword_nmt_repo = get_returnn_subword_nmt(output_prefix=subdir_prefix) + train_corpus = get_bliss_corpus_dict()["train"] + bpe_settings = get_bpe_settings( + train_corpus, + bpe_size=bpe_size, + unk_label=unk_label, + output_prefix=subdir_prefix, + subword_nmt_repo_path=subword_nmt_repo, + ) + return bpe_settings + + +def get_subword_nmt_bpe_v2(bpe_size: int, unk_label: str = "", subdir_prefix: str = "") -> BPESettings: + """ + Get the BPE tokens via the Returnn subword-nmt for a Tedlium2 setup. + + V2: Uses subword-nmt version corrected for Apptainer related bug, adds hash overwrite for repo + + :param bpe_size: the number of BPE merge operations. This is NOT the resulting vocab size! + :param unk_label: unknown label symbol + :param subdir_prefix: dir name prefix for aliases and outputs + """ + subword_nmt_repo = get_returnn_subword_nmt( + commit_hash="5015a45e28a958f800ef1c50e7880c0c9ef414cf", output_prefix=subdir_prefix + ) + subword_nmt_repo.hash_overwrite = "I6_SUBWORD_NMT_V2" + train_corpus = get_bliss_corpus_dict()["train"] + bpe_settings = get_bpe_settings( + train_corpus, + bpe_size=bpe_size, + unk_label=unk_label, + output_prefix=subdir_prefix, + subword_nmt_repo_path=subword_nmt_repo, + ) + return bpe_settings diff --git a/users/raissi/experiments/librispeech/configs/LFR_factored/baseline/config.py b/users/raissi/experiments/librispeech/configs/LFR_factored/baseline/config.py index 545954399..5eb18de33 100644 --- a/users/raissi/experiments/librispeech/configs/LFR_factored/baseline/config.py +++ b/users/raissi/experiments/librispeech/configs/LFR_factored/baseline/config.py @@ -79,6 +79,15 @@ out_joint_diphone="output/output_batch_major", ) +CONF_FH_TRIPHONE_FS_DECODING_TENSOR_CONFIG_V2 = dataclasses.replace( + DecodingTensorMap.default(), + in_encoder_output="conformer_12_output/add", + out_encoder_output="encoder__output/output_batch_major", + out_right_context="right__output/output_batch_major", + out_left_context="left__output/output_batch_major", + out_center_state="center__output/output_batch_major", + out_joint_diphone="output/output_batch_major", +) BLSTM_FH_DECODING_TENSOR_CONFIG = dataclasses.replace( CONF_FH_DECODING_TENSOR_CONFIG, diff --git a/users/raissi/setups/common/BASE_factored_hybrid_system.py b/users/raissi/setups/common/BASE_factored_hybrid_system.py index 1ec82b301..a82d23919 100644 --- a/users/raissi/setups/common/BASE_factored_hybrid_system.py +++ b/users/raissi/setups/common/BASE_factored_hybrid_system.py @@ -530,7 +530,7 @@ def _set_native_lstm_path(self, search_numpy_blas=True, blas_lib=None): self.native_lstm2_path = compile_native_op_job.out_op def set_local_flf_tool_for_decoding(self, path): - self.csp["base"].flf_tool_exe = path + self.crp["base"].flf_tool_exe = path # --------------------- Init procedure ----------------- def set_initial_nn_args(self, initial_nn_args): diff --git a/users/raissi/setups/common/TF_factored_hybrid_system.py b/users/raissi/setups/common/TF_factored_hybrid_system.py index b758c266f..81eb0b02a 100644 --- a/users/raissi/setups/common/TF_factored_hybrid_system.py +++ b/users/raissi/setups/common/TF_factored_hybrid_system.py @@ -47,6 +47,8 @@ import i6_experiments.users.raissi.setups.common.helpers.train as train_helpers import i6_experiments.users.raissi.setups.common.helpers.decode as decode_helpers +from i6_experiments.users.raissi.setups.common.helpers.priors.factored_estimation import get_triphone_priors +from i6_experiments.users.raissi.setups.common.helpers.priors.util import PartitionDataSetup # user based modules from i6_experiments.users.raissi.setups.common.data.backend import BackendInfo @@ -74,7 +76,7 @@ from i6_experiments.users.raissi.setups.common.data.backend import Backend, BackendInfo - +from i6_experiments.users.raissi.setups.common.decoder.BASE_factored_hybrid_search import DecodingTensorMap from i6_experiments.users.raissi.setups.common.decoder.config import ( PriorInfo, PriorConfig, @@ -160,9 +162,6 @@ def get_model_checkpoint(self, model_job, epoch): def get_model_path(self, model_job, epoch): return model_job.out_checkpoints[epoch].ckpt_path - def set_local_flf_tool_for_decoding(self, path=None): - self.csp["base"].flf_tool_exe = path - # -------------------------------------------- Training -------------------------------------------------------- # -------------encoder architectures ------------------------------- @@ -279,7 +278,7 @@ def get_conformer_network_zhou_variant( network["classes_"]["from"] = "slice_classes" else: - network=encoder_net + network = encoder_net return network @@ -736,9 +735,38 @@ def set_diphone_priors_returnn_rasr( self.experiments[key]["priors"] = p_info - - def set_triphone_priors_factored(self): + def set_triphone_priors_factored( + self, + key: str, + epoch: int, + tensor_map: DecodingTensorMap, + partition_data_setup: PartitionDataSetup = None, + model_path: tk.Path = None, + ): self.create_hdf() + if self.experiments[key]["graph"].get("inference", None) is None: + self.set_graph_for_experiment(key) + if partition_data_setup is None: + partition_data_setup = PartitionDataSetup() + + if model_path is None: + model_path = DelayedFormat(self.get_model_path(model_job=self.experiments[key]["train_job"], epoch=epoch)) + triphone_priors = get_triphone_priors( + name=f"{self.experiments[key]['name']}/e{epoch}", + graph_path=self.experiments[key]["graph"]["inference"], + model_path=model_path, + data_paths=self.hdfs[self.train_key], + tensor_map=tensor_map, + partition_data_setup=partition_data_setup, + label_info=self.label_info, + ) + + p_info = PriorInfo( + center_state_prior=PriorConfig(file=triphone_priors[1], scale=0.0), + left_context_prior=PriorConfig(file=triphone_priors[2], scale=0.0), + right_context_prior=PriorConfig(file=triphone_priors[0], scale=0.0), + ) + self.experiments[key]["priors"] = p_info def set_triphone_priors_returnn_rasr( self, diff --git a/users/raissi/setups/common/decoder/BASE_factored_hybrid_search.py b/users/raissi/setups/common/decoder/BASE_factored_hybrid_search.py index d0ed08923..c27141a02 100644 --- a/users/raissi/setups/common/decoder/BASE_factored_hybrid_search.py +++ b/users/raissi/setups/common/decoder/BASE_factored_hybrid_search.py @@ -671,8 +671,11 @@ def recognize( if search_parameters.tdp_scale is not None: if name_override is None: name += f"-tdpScale-{search_parameters.tdp_scale}" - name += f"-spTdp-{format_tdp(search_parameters.tdp_speech)}" name += f"-silTdp-{format_tdp(search_parameters.tdp_silence)}" + if search_parameters.tdp_nonword is not None: + name += f"-nwTdp-{format_tdp(search_parameters.tdp_nonword)}" + name += f"-spTdp-{format_tdp(search_parameters.tdp_speech)}" + if self.feature_scorer_type.is_factored(): if search_parameters.transition_scales is not None: @@ -758,6 +761,12 @@ def recognize( adv_search_extra_config = ( copy.deepcopy(adv_search_extra_config) if adv_search_extra_config is not None else rasr.RasrConfig() ) + + if search_parameters.word_recombination_limit is not None: + adv_search_extra_config.flf_lattice_tool.network.recognizer.recognizer.reduce_context_word_recombination = True + adv_search_extra_config.flf_lattice_tool.network.recognizer.recognizer.reduce_context_word_recombination_limit = search_parameters.word_recombination_limit + name += f"recombLim{search_parameters.word_recombination_limit}" + if search_parameters.altas is not None: adv_search_extra_config.flf_lattice_tool.network.recognizer.recognizer.acoustic_lookahead_temporal_approximation_scale = ( search_parameters.altas @@ -907,7 +916,7 @@ def recognize( if add_sis_alias_and_output: tk.register_output(f"{pre_path}/{name}.wer", scorer.out_report_dir) - if opt_lm_am and search_parameters.altas is None: + if opt_lm_am and (search_parameters.altas is None or search_parameters.altas < 3.0): assert search_parameters.beam >= 15.0 if pron_scale is not None: if isinstance(pron_scale, DelayedBase) and pron_scale.is_set(): @@ -1311,14 +1320,16 @@ def push_delayed_tuple( best_priors = best_overall_n.out_argmin[0] best_tdp_scale = best_overall_n.out_argmin[1] best_tdp_sil = best_overall_n.out_argmin[2] - best_tdp_sp = best_overall_n.out_argmin[3] + best_tdp_nw = best_overall_n.out_argmin[3] + best_tdp_sp = best_overall_n.out_argmin[4] if use_pron: - best_pron = best_overall_n.out_argmin[4] + best_pron = best_overall_n.out_argmin[5] base_cfg = dataclasses.replace( search_parameters, tdp_scale=best_tdp_scale, tdp_silence=push_delayed_tuple(best_tdp_sil), + tdp_nonword=push_delayed_tuple(best_tdp_nw), tdp_speech=push_delayed_tuple(best_tdp_sp), pron_scale=best_pron, ) @@ -1327,6 +1338,7 @@ def push_delayed_tuple( search_parameters, tdp_scale=best_tdp_scale, tdp_silence=push_delayed_tuple(best_tdp_sil), + tdp_nonword=push_delayed_tuple(best_tdp_nw), tdp_speech=push_delayed_tuple(best_tdp_sp), ) diff --git a/users/raissi/setups/common/decoder/config.py b/users/raissi/setups/common/decoder/config.py index 455f023cf..1d5788bf5 100644 --- a/users/raissi/setups/common/decoder/config.py +++ b/users/raissi/setups/common/decoder/config.py @@ -157,6 +157,7 @@ class SearchParameters: altas: Optional[float] = None lm_lookahead_scale: Optional[float] = None lm_lookahead_history_limit: Int = 1 + word_recombination_limit: Optional[Int] = None posterior_scales: Optional[PosteriorScales] = None silence_penalties: Optional[Tuple[Float, Float]] = None # loop, fwd state_dependent_tdps: Optional[Union[str, tk.Path]] = None @@ -189,6 +190,11 @@ def with_lm_lookahead_scale(self, scale: Float) -> "SearchParameters": def with_lm_lookahead_history_limit(self, history_limit: Int) -> "SearchParameters": return dataclasses.replace(self, lm_lookahead_history_limit=history_limit) + def with_word_recombination_limit(self, word_recombination_limit: Int) -> "SearchParameters": + return dataclasses.replace(self, word_recombination_limit=word_recombination_limit) + + + def with_prior_scale( self, center: Optional[Float] = None, diff --git a/users/raissi/setups/common/helpers/network/augment.py b/users/raissi/setups/common/helpers/network/augment.py index 71a639926..5613a379f 100644 --- a/users/raissi/setups/common/helpers/network/augment.py +++ b/users/raissi/setups/common/helpers/network/augment.py @@ -29,11 +29,29 @@ class LogLinearScales: label_posterior_scale: float transition_scale: float + context_label_posterior_scale: float = 1.0 label_prior_scale: Optional[float] = None @classmethod def default(cls) -> "LogLinearScales": - return cls(label_posterior_scale=0.3, label_prior_scale=None, transition_scale=0.3) + return cls(label_posterior_scale=0.3, transition_scale=0.3, label_prior_scale=None, context_label_posterior_scale=1.0) + +@dataclass(frozen=True, eq=True) +class LossScales: + center_scale:int = 1.0 + right_scale: int = 1.0 + left_scale: int = 1.0 + + def get_scale(self, label_name: str): + if 'center' in label_name: + return self.center_scale + elif 'right' in label_name: + return self.right_scale + elif 'left' in label_name: + return self.left_scale + else: + raise NotImplemented("Not recognized label name for output loss scale") + Layer = Dict[str, Any] @@ -889,3 +907,183 @@ def add_fast_bw_layer_to_returnn_config( # ToDo: handel the import model part return returnn_config + +def add_fast_bw_factored_layer_to_network( + crp: rasr.CommonRasrParameters, + network: Network, + log_linear_scales: LogLinearScales, + loss_scales: LossScales, + label_info: LabelInfo, + reference_layers: [str] = ["left-output", "center-output" "right-output"], + label_prior_type: Optional[PriorType] = None, + label_prior: Optional[returnn.CodeWrapper] = None, + label_prior_estimation_axes: str = None, + extra_rasr_config: Optional[rasr.RasrConfig] = None, + extra_rasr_post_config: Optional[rasr.RasrConfig] = None, +) -> Network: + + crp = correct_rasr_FSA_bug(crp) + + if label_prior_type is not None: + assert log_linear_scales.label_prior_scale is not None, "If you plan to use the prior, please set the scale for it" + if label_prior_type == PriorType.TRANSCRIPT: + assert label_prior is not None, "You forgot to set the label prior file" + + inputs = [] + for reference_layer in reference_layers: + for attribute in ["loss", "loss_opts", "target"]: + if reference_layer in network: + network[reference_layer].pop(attribute, None) + + out_denot = reference_layer.split("-")[0] + am_scale = log_linear_scales.label_posterior_scale if "center" in reference_layer else log_linear_scales.context_label_posterior_scale + # prior calculation + if label_prior_type is not None: + prior_name = ("_").join(["label_prior", out_denot]) + comb_name = ("_").join(["comb-prior", out_denot]) + prior_eval_string = "(safe_log(source(1)) * prior_scale)" + inputs.append(comb_name) + if label_prior_type == PriorType.TRANSCRIPT: + network[prior_name] = {"class": "constant", "dtype": "float32", "value": label_prior} + elif label_prior_type == PriorType.AVERAGE: + network[prior_name] = { + "class": "accumulate_mean", + "exp_average": 0.001, + "from": reference_layer, + "is_prob_distribution": True, + } + elif label_prior_type == PriorType.ONTHEFLY: + assert label_prior_estimation_axes is not None, "You forgot to set one which axis you want to average the prior, eg. bt" + network[prior_name] = { + "class": "reduce", + "mode": "mean", + "from": reference_layer, + "axis": label_prior_estimation_axes, + } + prior_eval_string = "tf.stop_gradient((safe_log(source(1)) * prior_scale))" + else: + raise NotImplementedError("Unknown PriorType") + + network[comb_name] = { + "class": "combine", + "kind": "eval", + "eval": f"am_scale*(safe_log(source(0)) - {prior_eval_string})", + "eval_locals": { + "am_scale": am_scale, + "prior_scale": log_linear_scales.label_prior_scale, + }, + "from": [reference_layer, prior_name], + } + + else: + comb_name = ("_").join(["multiply-scale", out_denot]) + inputs.append(comb_name) + network[comb_name] = { + "class": "combine", + "kind": "eval", + "eval": "am_scale*(safe_log(source(0)))", + "eval_locals": {"am_scale": am_scale}, + "from": [reference_layer], + } + + bw_out = ("_").join(["output-bw", out_denot]) + network[bw_out] = { + "class": "copy", + "from": reference_layer, + "loss": "via_layer", + "loss_opts": { + "align_layer": ("/").join(["fast_bw", out_denot]), + "loss_wrt_to_act_in": "softmax", + }, + "loss_scale": loss_scales.get_scale(reference_layer), + } + + network["fast_bw"] = { + "class": "fast_bw_factored", + "align_target": "hmm-monophone", + "hmm_opts": {"num_contexts": label_info.n_contexts}, + "from": inputs, + "tdp_scale": log_linear_scales.transition_scale, + "n_out": label_info.n_contexts*2 + label_info.get_n_state_classes() + } + + # Create additional Rasr config file for the automaton + mapping = { + "corpus": "neural-network-trainer.corpus", + "lexicon": ["neural-network-trainer.alignment-fsa-exporter.model-combination.lexicon"], + "acoustic_model": ["neural-network-trainer.alignment-fsa-exporter.model-combination.acoustic-model"], + } + config, post_config = rasr.build_config_from_mapping(crp, mapping) + post_config["*"].output_channel.file = "fastbw.log" + + # Define action + config.neural_network_trainer.action = "python-control" + # neural_network_trainer.alignment_fsa_exporter.allophone_state_graph_builder + config.neural_network_trainer.alignment_fsa_exporter.allophone_state_graph_builder.orthographic_parser.allow_for_silence_repetitions = ( + False + ) + config.neural_network_trainer.alignment_fsa_exporter.allophone_state_graph_builder.orthographic_parser.normalize_lemma_sequence_scores = ( + False + ) + # neural_network_trainer.alignment_fsa_exporter + config.neural_network_trainer.alignment_fsa_exporter.model_combination.acoustic_model.fix_allophone_context_at_word_boundaries = ( + True + ) + config.neural_network_trainer.alignment_fsa_exporter.model_combination.acoustic_model.transducer_builder_filter_out_invalid_allophones = ( + True + ) + + # additional config + config._update(extra_rasr_config) + post_config._update(extra_rasr_post_config) + + automaton_config = rasr.WriteRasrConfigJob(config, post_config).out_config + tk.register_output("train/bw.config", automaton_config) + + network["fast_bw"]["sprint_opts"] = { + "sprintExecPath": rasr.RasrCommand.select_exe(crp.nn_trainer_exe, "nn-trainer"), + "sprintConfigStr": DelayedFormat("--config={}", automaton_config), + "sprintControlConfig": {"verbose": True}, + "usePythonSegmentOrder": False, + "numInstances": 1, + } + + return network + + +def add_fast_bw_factored_layer_to_returnn_config( + crp: rasr.CommonRasrParameters, + returnn_config: returnn.ReturnnConfig, + log_linear_scales: LogLinearScales, + loss_scales: LossScales, + label_info: LabelInfo, + import_model: [tk.Path, str] = None, + reference_layers: [str] = ["left-output", "center-output", "right-output"], + label_prior_type: Optional[PriorType] = None, + label_prior: Optional[returnn.CodeWrapper] = None, + label_prior_estimation_axes: str = None, + extra_rasr_config: Optional[rasr.RasrConfig] = None, + extra_rasr_post_config: Optional[rasr.RasrConfig] = None, +) -> returnn.ReturnnConfig: + + returnn_config.config["network"] = add_fast_bw_factored_layer_to_network( + crp=crp, + network=returnn_config.config["network"], + log_linear_scales=log_linear_scales, + loss_scales=loss_scales, + label_info=label_info, + reference_layers=reference_layers, + label_prior_type=label_prior_type, + label_prior=label_prior, + label_prior_estimation_axes=label_prior_estimation_axes, + extra_rasr_config=extra_rasr_config, + extra_rasr_post_config=extra_rasr_post_config, + ) + + if "chunking" in returnn_config.config: + del returnn_config.config["chunking"] + if "pretrain" in returnn_config.config and import_model is not None: + del returnn_config.config["pretrain"] + + return returnn_config + diff --git a/users/raissi/setups/common/helpers/priors/__init__.py b/users/raissi/setups/common/helpers/priors/__init__.py index 26b313536..cb3f4df67 100644 --- a/users/raissi/setups/common/helpers/priors/__init__.py +++ b/users/raissi/setups/common/helpers/priors/__init__.py @@ -7,5 +7,5 @@ from .flat import CreateFlatPriorsJob from .smoothen import smoothen_priors, SmoothenPriorsJob from .scale import scale_priors, ScalePriorsJob -from .transcription import get_mono_transcription_priors +from .transcription import get_prior_from_transcription from .tri_join import JoinRightContextPriorsJob, ReshapeCenterStatePriorsJob diff --git a/users/raissi/setups/common/helpers/priors/estimate_povey_like_prior_fh.py b/users/raissi/setups/common/helpers/priors/estimate_povey_like_prior_fh.py index 986ffa287..1cae2bc1b 100644 --- a/users/raissi/setups/common/helpers/priors/estimate_povey_like_prior_fh.py +++ b/users/raissi/setups/common/helpers/priors/estimate_povey_like_prior_fh.py @@ -2,9 +2,10 @@ import h5py +import logging import numpy as np import math -import tensorflow as tf +from typing import List, Optional, Union from IPython import embed @@ -14,11 +15,11 @@ import pickle from sisyphus import * - -from i6_core.lib.rasr_cache import FileArchive +from sisyphus.delayed_ops import DelayedFormat Path = setup_path(__package__) +from i6_core.lib.rasr_cache import FileArchive from i6_experiments.users.raissi.setups.common.data.factored_label import LabelInfo from i6_experiments.users.raissi.setups.common.decoder.BASE_factored_hybrid_search import DecodingTensorMap @@ -26,9 +27,10 @@ initialize_dicts, initialize_dicts_with_zeros, get_batch_from_segments, - ) +from i6_experiments.users.raissi.setups.common.util.cache_manager import cache_file + ################################### # Triphone ################################### @@ -36,7 +38,7 @@ class EstimateFactoredTriphonePriorsJob(Job): def __init__( self, graph_path: Path, - model_path: Path, + model_path: DelayedFormat, tensor_map: Optional[Union[dict, DecodingTensorMap]], data_paths: [Path], data_indices: [int], @@ -44,10 +46,10 @@ def __init__( end_ind_segment: int, label_info: LabelInfo, tf_library_path: str = None, - n_batch=15000, + n_batch=10000, cpu=2, gpu=1, - mem=4, + mem=32, time=1, ): self.graph_path = graph_path @@ -56,10 +58,12 @@ def __init__( self.data_indices = data_indices self.segment_slice = (start_ind_segment, end_ind_segment) self.tf_library_path = tf_library_path - self.triphone_means, self.diphone_means = initialize_dicts_with_zeros(label_info.n_contexts, label_info.get_n_state_classes()) + self.triphone_means, self.diphone_means = initialize_dicts_with_zeros( + label_info.n_contexts, label_info.get_n_state_classes() + ) self.context_means = np.zeros(label_info.n_contexts) self.num_segments = [ - self.output_path("segmentLength.%d.%d-%d" % (index, start_ind_segment, end_ind_segment), cached=False) + self.output_path("segment_length.%d.%d-%d" % (index, start_ind_segment, end_ind_segment), cached=False) for index in self.data_indices ] self.triphone_files = [ @@ -70,7 +74,7 @@ def __init__( self.output_path("diphone_means.%d.%d-%d" % (index, start_ind_segment, end_ind_segment), cached=False) for index in self.data_indices ] - self.context_means = [ + self.context_files = [ self.output_path("context_means.%d.%d-%d" % (index, start_ind_segment, end_ind_segment), cached=False) for index in self.data_indices ] @@ -84,10 +88,14 @@ def tasks(self): yield Task("run", resume="run", rqmt=self.rqmt, args=range(1, (len(self.data_indices) + 1))) def get_dense_label(self, left_context, center_state, right_context=0): - return (((center_state * self.label_info.n_contexts) + left_context) * self.label_info.n_contexts) + right_context + return ( + ((center_state * self.label_info.n_contexts) + left_context) * self.label_info.n_contexts + ) + right_context def get_segment_features_from_hdf(self, dataIndex): - hf = h5py.File(self.data_paths[dataIndex].get_path()) + logging.info(f"processing {self.data_paths[dataIndex]}") + file_path = self.data_paths[dataIndex] + hf = h5py.File(file_path) segment_names = list(hf["streams"]["features"]["data"]) segments = [] for name in segment_names: @@ -96,28 +104,35 @@ def get_segment_features_from_hdf(self, dataIndex): def get_encoder_output(self, session, feature_vector): return session.run( - [self.tensor_map.out_encoder_output], + [f"{self.tensor_map.out_encoder_output}:0"], feed_dict={ - self.tensor_map.in_data: feature_vector.reshape(1, feature_vector.shape[0], feature_vector.shape[1]), - self.tensor_map.in_seq_length: [feature_vector.shape[0]], + f"{self.tensor_map.in_data}:0": feature_vector.reshape( + 1, feature_vector.shape[0], feature_vector.shape[1] + ), + f"{self.tensor_map.in_seq_length}:0": [feature_vector.shape[0]], }, ) def get_posteriors_given_encoder_output(self, session, feature_vector, class_label_vector): feature_in = ( feature_vector.reshape(feature_vector.shape[1], 1, feature_vector.shape[2]) - if "fwd" in self.tensor_map.in_encoder_output + if "fwd" in tensor_map.in_encoder_output else feature_vector ) return session.run( - [self.tensor_map.out_left_context, self.tensor_map.out_center_state, self.tensor_map.out_right_context], + [ + f"{self.tensor_map.out_left_context}:0", + f"{self.tensor_map.out_center_state}:0", + f"{self.tensor_map.out_right_context}:0", + ], feed_dict={ - self.tensor_map.in_encoder_output: feature_in, - self.tensor_map.in_seq_length: [[class_label_vector] * feature_vector.shape[1]], + f"{self.tensor_map.in_encoder_output}:0": feature_in, + f"{self.tensor_map.in_classes}:0": [[class_label_vector] * feature_vector.shape[1]], }, ) - def calculateMeanPosteriors(self, session, task_id): + def calculate_mean_posteriors(self, session, task_id): + logging.info(f"starting with {task_id}") sample_count = 0 segments = self.get_segment_features_from_hdf(self.data_indices[task_id - 1]) @@ -127,21 +142,21 @@ def calculateMeanPosteriors(self, session, task_id): if len(batch) == 0: break encoder_output = self.get_encoder_output(session, batch) - for pastContextId in range(self.label_info.n_contexts): - for currentState in range(self.label_info.get_n_state_classes()): - denselabel = self.get_dense_label(left_context=pastContextId, center_state=currentState) + for left_context in range(self.label_info.n_contexts): + for center_state in range(self.label_info.get_n_state_classes()): + denselabel = self.get_dense_label(left_context=left_context, center_state=center_state) p = self.get_posteriors_given_encoder_output(session, encoder_output[0], denselabel) # triphone is calculates for each center and left context - tri = (sample_count * self.triphone_means[pastContextId][currentState]) + ( + tri = (sample_count * self.triphone_means[left_context][center_state]) + ( b_size * np.mean(p[0][0], axis=0) ) - self.triphone_means[pastContextId][currentState] = np.divide(tri, denom) + self.triphone_means[left_context][center_state] = np.divide(tri, denom) # diphone is calculated for each context with centerstate 0 - if not currentState: - di = (sample_count * self.diphone_means[pastContextId]) + (b_size * np.mean(p[1][0], axis=0)) - self.diphone_means[pastContextId] = np.divide(di, denom) + if not center_state: + di = (sample_count * self.diphone_means[left_context]) + (b_size * np.mean(p[1][0], axis=0)) + self.diphone_means[left_context] = np.divide(di, denom) # context is not label dependent - if not pastContextId: + if not left_context: ctx = (sample_count * self.context_means) + (b_size * np.mean(p[2][0], axis=0)) self.context_means = np.divide(ctx, denom) sample_count += b_size @@ -149,7 +164,8 @@ def calculateMeanPosteriors(self, session, task_id): with open(self.num_segments[task_id - 1].get_path(), "wb") as fp: pickle.dump(sample_count, fp, protocol=pickle.HIGHEST_PROTOCOL) - def dumpMeans(self, task_id): + def dump_means(self, task_id): + logging.info(f"dumping means") with open(self.triphone_files[task_id - 1].get_path(), "wb") as f1: pickle.dump(self.triphone_means, f1, protocol=pickle.HIGHEST_PROTOCOL) with open(self.diphone_files[task_id - 1].get_path(), "wb") as f2: @@ -158,25 +174,104 @@ def dumpMeans(self, task_id): pickle.dump(self.context_means, f3, protocol=pickle.HIGHEST_PROTOCOL) def run(self, task_id): - tf.load_op_library(self.tf_library_path) + import tensorflow as tf + if self.tf_library_path is not None: + tf.load_op_library(self.tf_library_path) mg = tf.compat.v1.MetaGraphDef() mg.ParseFromString(open(self.graph_path.get_path(), "rb").read()) - tf.compat.v1.import_graph_def(mg.graph_def, name="") + tf.import_graph_def(mg.graph_def, name="") # session s = tf.compat.v1.Session() - returnValue = s.run(["save/restore_all"], feed_dict={"save/Const:0": self.model.get_path()}) + returnValue = s.run(["save/restore_all"], feed_dict={"save/Const:0": self.model_path.get()}) + + self.calculate_mean_posteriors(s, task_id) + self.dump_means(task_id) + + +class CombineMeansForTriphoneForward(Job): + def __init__( + self, + triphone_files: List[Path], + diphone_files: List[Path], + context_files: List[Path], + num_segment_files: List[Path], + label_info: LabelInfo, + ): + self.triphone_files = triphone_files + self.diphone_files = diphone_files + self.context_files = context_files + self.num_segment_files = num_segment_files + self.label_info = label_info + self.num_segments = [] + self.triphone_means, self.diphoneMeans = initialize_dicts( + n_contexts=label_info.n_contexts, n_state_classes=label_info.get_n_state_classes() + ) + self.context_means = [] + self.num_segments_out = self.output_path("segment_length", cached=False) + self.triphone_files_out = self.output_path("triphone_means", cached=False) + self.diphone_files_out = self.output_path("diphoneMeans", cached=False) + self.context_files_out = self.output_path("context_means", cached=False) + self.rqmt = {"cpu": 1, "mem": 1, "time": 0.5} - self.calculateMeanPosteriors(s, task_id) - self.dumpMeans(task_id) + def tasks(self): + yield Task("run", resume="run", rqmt=self.rqmt) + + def read_num_segments(self): + for filename in self.num_segment_files: + with open(tk.uncached_path(filename), "rb") as f: + self.num_segments.append(pickle.load(f)) + + def calculate_weighted_averages(self): + coeffs = [self.num_segments[i] / np.sum(self.num_segments) for i in range(len(self.num_segment_files))] + for filename in self.triphone_files: + with open(tk.uncached_path(filename), "rb") as f: + triphoneDict = pickle.load(f) + for i in range(self.nContexts): + for j in range(self.nStates): + self.triphone_means[i][j].append( + np.dot(coeffs[self.triphone_files.index(filename)], triphoneDict[i][j]) + ) + for filename in self.diphone_files: + with open(tk.uncached_path(filename), "rb") as f: + diphoneDict = pickle.load(f) + for i in range(self.nContexts): + self.diphoneMeans[i].append(np.dot(coeffs[self.diphone_files.index(filename)], diphoneDict[i])) + for filename in self.context_files: + with open(tk.uncached_path(filename), "rb") as f: + means = pickle.load(f) + self.context_means.append(np.dot(coeffs[self.context_files.index(filename)], means)) + for i in range(self.nContexts): + self.diphoneMeans[i] = np.sum(self.diphoneMeans[i], axis=0) + for j in range(self.nStates): + self.triphone_means[i][j] = np.sum(self.triphone_means[i][j], axis=0) + self.context_means = np.sum(self.context_means, axis=0) + + def dump_means(self): + with open(tk.uncached_path(self.triphone_files_out), "wb") as f1: + pickle.dump(self.triphone_means, f1, protocol=pickle.HIGHEST_PROTOCOL) + with open(tk.uncached_path(self.diphone_files_out), "wb") as f2: + pickle.dump(self.diphoneMeans, f2, protocol=pickle.HIGHEST_PROTOCOL) + with open(tk.uncached_path(self.context_files_out), "wb") as f3: + pickle.dump(self.context_means, f3, protocol=pickle.HIGHEST_PROTOCOL) + sumSegNums = np.sum(self.num_segments) + with open(tk.uncached_path(self.num_segments_out), "wb") as f4: + pickle.dump(sumSegNums, f4, protocol=pickle.HIGHEST_PROTOCOL) + + def run(self): + self.read_num_segments() + self.calculate_weighted_averages() + self.dump_means() class DumpXmlForTriphoneForwardJob(Job): - def __init__(self, - triphone_files: List, - diphone_files: List, - context_files: List, - num_segment_files: List, - label_info: LabelInfo): + def __init__( + self, + triphone_files: List, + diphone_files: List, + context_files: List, + num_segment_files: List, + label_info: LabelInfo, + ): self.triphone_files = triphone_files self.diphone_files = diphone_files self.context_files = context_files @@ -184,9 +279,9 @@ def __init__(self, self.label_info = label_info self.num_segments = [] self.triphone_means, self.diphone_means = initialize_dicts( - n_contexts=n_contexts, n_state_classes=n_state_classes + n_contexts=label_info.n_contexts, n_state_classes=label_info.get_n_state_classes() ) - self.contextMeans = [] + self.context_means = [] self.triphone_xml = self.output_path("triphone_scores.xml", cached=False) self.diphone_xml = self.output_path("diphone_scores.xml", cached=False) self.context_xml = self.output_path("context_scores.xml", cached=False) @@ -195,95 +290,93 @@ def __init__(self, def tasks(self): yield Task("run", resume="run", rqmt=self.rqmt) - def readnum_segments(self): + def read_num_segments(self): for filename in self.num_segment_files: with open(filename.get_path(), "rb") as f: self.num_segments.append(pickle.load(f)) - def calculateWeightedAverages(self): + def calculate_weighted_averages(self): coeffs = [self.num_segments[i] / np.sum(self.num_segments) for i in range(len(self.num_segment_files))] for filename in self.triphone_files: with open(filename.get_path(), "rb") as f: triphoneDict = pickle.load(f) - for i in range(self.n_contexts): - for j in range(self.n_state_classes): + for i in range(self.label_info.n_contexts): + for j in range(self.label_info.get_n_state_classes()): self.triphone_means[i][j].append( np.dot(coeffs[self.triphone_files.index(filename)], triphoneDict[i][j]) ) for filename in self.diphone_files: with open(filename.get_path(), "rb") as f: - diphoneDict = pickle.load(f) - for i in range(self.n_contexts): - self.diphone_means[i].append(np.dot(coeffs[self.diphone_files.index(filename)], diphoneDict[i])) + diphone_dict = pickle.load(f) + for i in range(self.label_info.n_contexts): + self.diphone_means[i].append(np.dot(coeffs[self.diphone_files.index(filename)], diphone_dict[i])) for filename in self.context_files: with open(filename.get_path(), "rb") as f: means = pickle.load(f) - self.contextMeans.append(np.dot(coeffs[self.context_files.index(filename)], means)) - for i in range(self.n_contexts): + self.context_means.append(np.dot(coeffs[self.context_files.index(filename)], means)) + for i in range(self.label_info.n_contexts): self.diphone_means[i] = np.sum(self.diphone_means[i], axis=0) - for j in range(self.n_state_classes): + for j in range(self.label_info.get_n_state_classes()): self.triphone_means[i][j] = np.sum(self.triphone_means[i][j], axis=0) - self.contextMeans = np.sum(self.contextMeans, axis=0) + self.context_means = np.sum(self.context_means, axis=0) - def dumpXml(self): - for pastId in range(self.n_contexts): - for currentstateId in range(self.n_state_classes): - for i, s in enumerate(self.triphone_means[pastId][currentstateId]): + def dump_xml(self): + for context_id in range(self.label_info.n_contexts): + for center_stateId in range(self.label_info.get_n_state_classes()): + for i, s in enumerate(self.triphone_means[context_id][center_stateId]): if s == 0: - self.triphone_means[pastId][currentstateId][i] += 1e-5 + self.triphone_means[context_id][center_stateId][i] += 1e-5 with open(self.triphone_xml.get_path(), "wt") as f: f.write( '\n\n' - % (self.n_contexts * self.n_state_classes, self.n_contexts) + % (self.label_info.n_contexts * self.label_info.get_n_state_classes(), self.label_info.n_contexts) ) - for pastId in range(self.n_contexts): - for currentstateId in range(self.n_state_classes): - for i, s in enumerate(self.triphone_means[pastId][currentstateId]): + for context_id in range(self.label_info.n_contexts): + for center_stateId in range(self.label_info.get_n_state_classes()): + for i, s in enumerate(self.triphone_means[context_id][center_stateId]): if s == 0: - self.triphone_means[pastId][currentstateId][i] += 1e-5 - f.write(" ".join("%.20e" % math.log(s) for s in self.triphone_means[pastId][currentstateId]) + "\n") + self.triphone_means[context_id][center_stateId][i] += 1e-5 + f.write(" ".join("%.20e" % math.log(s) for s in self.triphone_means[context_id][center_stateId]) + "\n") f.write("") with open(self.diphone_xml.get_path(), "wt") as f: f.write( '\n\n' - % (self.n_contexts, self.n_state_classes) + % (self.label_info.n_contexts, self.label_info.get_n_state_classes()) ) - for pastId in range(self.n_contexts): - for i, c in enumerate(self.diphone_means[pastId]): + for context_id in range(self.label_info.n_contexts): + for i, c in enumerate(self.diphone_means[context_id]): if c == 0: - self.diphone_means[pastId][i] += 1e-5 - f.write(" ".join("%.20e" % math.log(s) for s in self.diphone_means[pastId]) + "\n") + self.diphone_means[context_id][i] += 1e-5 + f.write(" ".join("%.20e" % math.log(s) for s in self.diphone_means[context_id]) + "\n") f.write("") with open(self.context_xml.get_path(), "wt") as f: - f.write('\n\n' % (self.n_contexts)) - f.write(" ".join("%.20e" % math.log(s) for s in np.nditer(self.contextMeans)) + "\n") + f.write('\n\n' % (self.label_info.n_contexts)) + f.write(" ".join("%.20e" % math.log(s) for s in np.nditer(self.context_means)) + "\n") f.write("") def run(self): - self.readnum_segments() - print("number of segments read") - self.calculateWeightedAverages() - self.dumpXml() - - + self.read_num_segments() + logging.info("number of segments read") + self.calculate_weighted_averages() + self.dump_xml() +# needs refactoring class EstimateRasrDiphoneAndContextPriors(Job): def __init__( self, graph_path: Path, - model_path: Path, + model_path: DelayedFormat, tensor_map: Optional[Union[dict, DecodingTensorMap]], data_paths: [Path], data_indices: [int], label_info: LabelInfo, tf_library_path: str = None, - n_batch=15000, + n_batch=12000, cpu=2, gpu=1, mem=4, time=1, - ): self.graph_path = graph_path self.model_path = model_path @@ -291,11 +384,13 @@ def __init__( self.data_paths = data_paths self.data_indices = data_indices self.tf_library_path = tf_library_path - self.diphoneMeans = dict(zip(range(label_info.n_contexts), [np.zeros(nStateClasses) for _ in range(label_info.n_contexts)])) - self.contextMeans = np.zeros(label_info.n_contexts) + self.diphoneMeans = dict( + zip(range(label_info.n_contexts), [np.zeros(nStateClasses) for _ in range(label_info.n_contexts)]) + ) + self.context_means = np.zeros(label_info.n_contexts) self.num_segments = [self.output_path("segmentLength.%d" % index, cached=False) for index in self.data_indices] - self.diphoneFiles = [self.output_path("diphoneMeans.%d" % index, cached=False) for index in self.data_indices] - self.contextFiles = [self.output_path("contextMeans.%d" % index, cached=False) for index in self.data_indices] + self.diphone_files = [self.output_path("diphoneMeans.%d" % index, cached=False) for index in self.data_indices] + self.context_files = [self.output_path("context_means.%d" % index, cached=False) for index in self.data_indices] self.n_batch = n_batch if not gpu: @@ -307,7 +402,6 @@ def tasks(self): def get_segment_features_from_hdf(self, dataIndex): hf = h5py.File(tk.uncached_path(self.data_paths[dataIndex])) - print(self.data_paths[dataIndex]) segmentNames = list(hf["streams"]["features"]["data"]) segments = [] for name in segmentNames: @@ -340,9 +434,12 @@ def getPosteriorsOfBothOutputsWithEncoded(self, session, feature_vector, class_l ) def get_dense_label(self, left_context, center_state, right_context=0): - return (((center_state * self.label_info.n_contexts) + left_context) * self.label_info.n_contexts) + right_context + return ( + ((center_state * self.label_info.n_contexts) + left_context) * self.label_info.n_contexts + ) + right_context - def calculateMeanPosteriors(self, session, task_id): + def calculate_mean_posteriors(self, session, task_id): + logging.info(f"starting with {task_id}") sample_count = 0 segments = self.get_segment_features_from_hdf(self.data_indices[task_id - 1]) @@ -353,49 +450,52 @@ def calculateMeanPosteriors(self, session, task_id): break encoder_output = self.get_encoder_output(session, batch) - for pastContextId in range(self.label_info.n_contexts): + for left_context in range(self.label_info.n_contexts): p = self.getPosteriorsOfBothOutputsWithEncoded( - session, encoder_output[0], self.get_dense_label(pastContextId) + session, encoder_output[0], self.get_dense_label(left_context) ) - di = (sample_count * self.diphoneMeans[pastContextId]) + (b_size * np.mean(p[0][0], axis=0)) - self.diphoneMeans[pastContextId] = np.divide(di, denom) + di = (sample_count * self.diphoneMeans[left_context]) + (b_size * np.mean(p[0][0], axis=0)) + self.diphoneMeans[left_context] = np.divide(di, denom) # context is not label dependent - if not pastContextId: - ctx = (sample_count * self.contextMeans) + (b_size * np.mean(p[1][0], axis=0)) - self.contextMeans = np.divide(ctx, denom) + if not left_context: + ctx = (sample_count * self.context_means) + (b_size * np.mean(p[1][0], axis=0)) + self.context_means = np.divide(ctx, denom) sample_count += b_size with open(tk.uncached_path(self.num_segments[task_id - 1]), "wb") as fp: pickle.dump(sample_count, fp, protocol=pickle.HIGHEST_PROTOCOL) - def dumpMeans(self, task_id): - with open(tk.uncached_path(self.diphoneFiles[task_id - 1]), "wb") as fp: + def dump_means(self, task_id): + with open(tk.uncached_path(self.diphone_files[task_id - 1]), "wb") as fp: pickle.dump(self.diphoneMeans, fp, protocol=pickle.HIGHEST_PROTOCOL) - with open(tk.uncached_path(self.contextFiles[task_id - 1]), "wb") as fp: - pickle.dump(self.contextMeans, fp, protocol=pickle.HIGHEST_PROTOCOL) + with open(tk.uncached_path(self.context_files[task_id - 1]), "wb") as fp: + pickle.dump(self.context_means, fp, protocol=pickle.HIGHEST_PROTOCOL) def run(self, task_id): - tf.load_op_library(self.tf_library_path) + import tensorflow as tf + if self.tf_library_path is not None: + tf.load_op_library(self.tf_library_path) mg = tf.MetaGraphDef() mg.ParseFromString(open(self.graph_path.get_path(), "rb").read()) tf.import_graph_def(mg.graph_def, name="") # session s = tf.Session() - returnValue = s.run(["save/restore_all"], feed_dict={"save/Const:0": self.model_path.get_path()}) + returnValue = s.run(["save/restore_all"], feed_dict={"save/Const:0": self.model_path.get()}) - self.calculateMeanPosteriors(s, task_id) - self.dumpMeans(task_id) + self.calculate_mean_posteriors(s, task_id) + self.dump_means(task_id) -# you can use DumpXmlForDiphone and have an attribute called isSprint, with which you call your additional function. +# needs refactoring +# you can use dump_xmlForDiphone and have an attribute called isSprint, with which you call your additional function. # Generally think to merge all functions -class DumpXmlRasrForDiphone(Job): +class dump_xmlRasrForDiphone(Job): def __init__( self, - diphoneFiles, - contextFiles, - numSegmentFiles, + diphone_files, + context_files, + num_segment_files, nContexts, nStateClasses, adjustSilence=True, @@ -404,12 +504,12 @@ def __init__( nonWordIndices=None, ): - self.diphoneFiles = diphoneFiles - self.contextFiles = contextFiles - self.numSegmentFiles = numSegmentFiles + self.diphone_files = diphone_files + self.context_files = context_files + self.num_segment_files = num_segment_files self.num_segments = [] self.diphoneMeans = dict(zip(range(nContexts), [[] for _ in range(nContexts)])) - self.contextMeans = [] + self.context_means = [] self.diphoneXml = self.output_path("diphoneScores.xml", cached=False) self.contextXml = self.output_path("contextScores.xml", cached=False) self.nContexts = nContexts @@ -423,30 +523,30 @@ def __init__( def tasks(self): yield Task("run", resume="run", rqmt=self.rqmt) - def readnum_segments(self): - for filename in self.numSegmentFiles: + def read_num_segments(self): + for filename in self.num_segment_files: with open(tk.uncached_path(filename), "rb") as f: self.num_segments.append(pickle.load(f)) - def calculateWeightedAverages(self): - coeffs = [self.num_segments[i] / np.sum(self.num_segments) for i in range(len(self.numSegmentFiles))] - for filename in self.diphoneFiles: + def calculate_weighted_averages(self): + coeffs = [self.num_segments[i] / np.sum(self.num_segments) for i in range(len(self.num_segment_files))] + for filename in self.diphone_files: with open(tk.uncached_path(filename), "rb") as f: - diphoneDict = pickle.load(f) + diphone_dict = pickle.load(f) for i in range(self.label_info.n_contexts): - self.diphoneMeans[i].append(np.dot(coeffs[self.diphoneFiles.index(filename)], diphoneDict[i])) - for filename in self.contextFiles: + self.diphoneMeans[i].append(np.dot(coeffs[self.diphone_files.index(filename)], diphone_dict[i])) + for filename in self.context_files: with open(tk.uncached_path(filename), "rb") as f: means = pickle.load(f) - self.contextMeans.append(np.dot(coeffs[self.contextFiles.index(filename)], means)) + self.context_means.append(np.dot(coeffs[self.context_files.index(filename)], means)) for i in range(self.label_info.n_contexts): self.diphoneMeans[i] = np.sum(self.diphoneMeans[i], axis=0) - self.contextMeans = np.sum(self.contextMeans, axis=0) + self.context_means = np.sum(self.context_means, axis=0) def setSilenceAndNonWordValues(self): # context vectors - sil = sum([self.contextMeans[i] for i in self.silBoundaryIndices]) - noise = sum([self.contextMeans[i] for i in self.nonWordIndices]) + sil = sum([self.context_means[i] for i in self.silBoundaryIndices]) + noise = sum([self.context_means[i] for i in self.nonWordIndices]) # center given context vectors meansListSil = [self.diphoneMeans[i] for i in self.silBoundaryIndices] @@ -455,24 +555,24 @@ def setSilenceAndNonWordValues(self): dpNoise = [sum(x) for x in zip(*meansListNonword)] for i in self.silBoundaryIndices: - self.contextMeans[i] = sil + self.context_means[i] = sil self.diphoneMeans[i] = dpSil for i in self.nonWordIndices: - self.contextMeans[i] = noise + self.context_means[i] = noise self.diphoneMeans[i] = dpNoise def setSilenceValues(self): - sil = sum([self.contextMeans[i] for i in self.silBoundaryIndices]) + sil = sum([self.context_means[i] for i in self.silBoundaryIndices]) # center given context vectors meansListSil = [self.diphoneMeans[i] for i in self.silBoundaryIndices] dpSil = [np.sum(x) for x in zip(*meansListSil)] for i in self.silBoundaryIndices: - self.contextMeans[i] = sil + self.context_means[i] = sil self.diphoneMeans[i] = dpSil - def dumpXml(self): + def dump_xml(self): perturbation = 1e-8 with open(tk.uncached_path(self.diphoneXml), "wt") as f: f.write( @@ -484,25 +584,25 @@ def dumpXml(self): f.write(" ".join("%.20e" % math.log(s) for s in self.diphoneMeans[i]) + "\n") f.write("") with open(tk.uncached_path(self.contextXml), "wt") as f: - self.contextMeans[self.contextMeans == 0] = perturbation + self.context_means[self.context_means == 0] = perturbation f.write('\n\n' % (self.label_info.n_contexts)) - f.write(" ".join("%.20e" % math.log(s) for s in np.nditer(self.contextMeans)) + "\n") + f.write(" ".join("%.20e" % math.log(s) for s in np.nditer(self.context_means)) + "\n") f.write("") def dumpPickle(self): with open("/u/raissi/experiments/notebooks/diphones.pickle", "wb") as fp: pickle.dump(self.diphoneMeans, fp, protocol=pickle.HIGHEST_PROTOCOL) with open("/u/raissi/experiments/notebooks/context.pickle", "wb") as fp: - pickle.dump(self.contextMeans, fp, protocol=pickle.HIGHEST_PROTOCOL) + pickle.dump(self.context_means, fp, protocol=pickle.HIGHEST_PROTOCOL) def run(self): - self.readnum_segments() - self.calculateWeightedAverages() + self.read_num_segments() + self.calculate_weighted_averages() if self.adjustSilence: if self.adjustNonWord: self.setSilenceAndNonWordValues() else: self.setSilenceValues() - self.dumpXml() - self.dumpPickle() \ No newline at end of file + self.dump_xml() + self.dumpPickle() diff --git a/users/raissi/setups/common/helpers/priors/factored_estimation.py b/users/raissi/setups/common/helpers/priors/factored_estimation.py index d177daa2d..b7036b83f 100644 --- a/users/raissi/setups/common/helpers/priors/factored_estimation.py +++ b/users/raissi/setups/common/helpers/priors/factored_estimation.py @@ -1,32 +1,153 @@ - -def get_diphone_priors(graphPath, model, dataPaths, datasetIndices, - nStateClasses=141, nContexts=47, gpu=1, time=20, isSilMapped=True, name=None, nBatch=10000, tf_library=None, tm=None): +import numpy as np +from typing import List + +from sisyphus import * + + +from i6_experiments.users.raissi.setups.common.data.factored_label import LabelInfo +from i6_experiments.users.raissi.setups.common.decoder.BASE_factored_hybrid_search import DecodingTensorMap +from i6_experiments.users.raissi.setups.common.helpers.priors.estimate_povey_like_prior_fh import ( + EstimateFactoredTriphonePriorsJob, + CombineMeansForTriphoneForward, + DumpXmlForTriphoneForwardJob, +) + +from i6_experiments.users.raissi.setups.common.helpers.priors.util import PartitionDataSetup + +Path = setup_path(__package__) +RANDOM_SEED = 42 + + +def get_triphone_priors( + name: str, + graph_path: Path, + model_path: Path, + data_paths: List[Path], + label_info: LabelInfo, + tensor_map: DecodingTensorMap, + partition_data_setup: PartitionDataSetup, + tf_library=None, + n_batch=10000, + cpu: int = 2, + gpu: int = 1, + time: int = 1, +): + + triphone_files = [] + diphone_files = [] + context_files = [] + num_segments = [] + + np.random.seed(RANDOM_SEED) + for i in np.random.choice(range(len(data_paths)//partition_data_setup.data_offset), partition_data_setup.n_data_indices, replace=False): + start_ind = i * partition_data_setup.data_offset + end_ind = (i + 1) * partition_data_setup.data_offset + for j in range(partition_data_setup.n_segment_indices): + start_ind_seg = j * partition_data_setup.segment_offset + end_ind_seg = (j + 1) * partition_data_setup.segment_offset + # if end_ind_seg > 1248: end_ind_seg = 1248 + data_indices = list(range(start_ind, end_ind)) + estimateJob = EstimateFactoredTriphonePriorsJob( + graph_path=graph_path, + model_path=model_path, + tensor_map=tensor_map, + data_paths=data_paths, + data_indices=data_indices, + start_ind_segment=start_ind_seg, + end_ind_segment=end_ind_seg, + label_info=label_info, + tf_library_path=tf_library, + n_batch=n_batch, + cpu=cpu, + gpu=gpu, + time=time, + ) + if name is not None: + estimateJob.add_alias(f"priors/{name}-{data_indices}_{start_ind_seg}") + triphone_files.extend(estimateJob.triphone_files) + diphone_files.extend(estimateJob.diphone_files) + context_files.extend(estimateJob.context_files) + num_segments.extend(estimateJob.num_segments) + + comb_jobs = [] + for spliter in range(0, len(triphone_files), partition_data_setup.split_step): + start = spliter + end = min(spliter + partition_data_setup.split_step, len(triphone_files)) + comb_jobs.append( + CombineMeansForTriphoneForward( + triphone_files=triphone_files[start:end], + diphone_files=diphone_files[start:end], + context_files=context_files[start:end], + num_segment_files=num_segments[start:end], + label_info=label_info, + ) + ) + + comb_triphone_files = [c.triphone_files_out for c in comb_jobs] + comb_diphone_files = [c.diphone_files_out for c in comb_jobs] + comb_context_files = [c.context_files_out for c in comb_jobs] + comb_num_segs = [c.num_segments_out for c in comb_jobs] + xmlJob = DumpXmlForTriphoneForwardJob( + triphone_files=comb_triphone_files, + diphone_files=comb_diphone_files, + context_files=comb_context_files, + num_segment_files=comb_num_segs, + label_info=label_info + ) + + prior_files_triphone = [xmlJob.triphone_xml, xmlJob.diphone_xml, xmlJob.context_xml] + xml_name = f"priors/{name}" + tk.register_output(xml_name, prior_files_triphone[0]) + + return prior_files_triphone + + +# needs refactoring +def get_diphone_priors( + graph_path, + model_path, + data_paths, + data_indices, + nStateClasses=141, + nContexts=47, + gpu=1, + time=20, + isSilMapped=True, + name=None, + n_batch=10000, + tf_library=None, + tensor_map=None, +): if tf_library is None: tf_library = libraryPath - if tm is None: - tm = defaultTfMap - - estimateJob = EstimateSprintDiphoneAndContextPriors(graphPath, - model, - dataPaths, - datasetIndices, - tf_library, - nContexts=nContexts, - nStateClasses=nStateClasses, - gpu=gpu, - time=time, - tensorMap=tm, - nBatch=nBatch ,) + if tensor_map is None: + tensor_map = defaultTfMap + + estimateJob = EstimateSprintDiphoneAndContextPriors( + graph_path, + model_path, + data_paths, + data_indices, + tf_library, + nContexts=nContexts, + nStateClasses=nStateClasses, + gpu=gpu, + time=time, + tensorMap=tensor_map, + n_batch=n_batch, + ) if name is not None: estimateJob.add_alias(f"priors/{name}") - xmlJob = DumpXmlSprintForDiphone(estimateJob.diphoneFiles, - estimateJob.contextFiles, - estimateJob.numSegments, - nContexts=nContexts, - nStateClasses=nStateClasses, - adjustSilence=isSilMapped) + xmlJob = DumpXmlSprintForDiphone( + estimateJob.diphone_files, + estimateJob.context_files, + estimateJob.num_segments, + nContexts=nContexts, + nStateClasses=nStateClasses, + adjustSilence=isSilMapped, + ) priorFiles = [xmlJob.diphoneXml, xmlJob.contextXml] @@ -34,85 +155,3 @@ def get_diphone_priors(graphPath, model, dataPaths, datasetIndices, tk.register_output(xmlName, priorFiles[0]) return priorFiles - - - -def get_triphone_priors(graphPath, model, dataPaths, nStateClasses=282, nContexts=47, nPhones=47, nStates=3, - cpu=2, gpu=1, time=1, nBatch=18000, dNum=3, sNum=20, step=200, dataOffset=10, segmentOffset=10, - name=None, tf_library=None, tm=None, isMulti=False): - if tf_library is None: - tf_library = libraryPath - if tm is None: - tm = defaultTfMap - - triphoneFiles = [] - diphoneFiles = [] - contextFiles = [] - numSegments = [] - - - for i in range(2, dNum + 2): - startInd = i * dataOffset - endInd = (i + 1) * dataOffset - for j in range(sNum): - startSegInd = j * segmentOffset - endSegInd = (j + 1) * segmentOffset - if endSegInd > 1248: endSegInd = 1248 - - datasetIndices = list(range(startInd, endInd)) - estimateJob = EstimateSprintTriphonePriorsForward(graphPath, - model, - dataPaths, - datasetIndices, - startSegInd, endSegInd, - tf_library, - nContexts=nContexts, - nStateClasses=nStateClasses, - nStates=nStates, - nPhones=nPhones, - nBatch=nBatch, - cpu=cpu, - gpu=gpu, - time=time, - tensorMap=tm, - isMultiEncoder=isMulti) - if name is not None: - estimateJob.add_alias(f"priors/{name}-startind{startSegInd}") - triphoneFiles.extend(estimateJob.triphoneFiles) - diphoneFiles.extend(estimateJob.diphoneFiles) - contextFiles.extend(estimateJob.contextFiles) - numSegments.extend(estimateJob.numSegments) - - - - comJobs = [] - for spliter in range(0, len(triphoneFiles), step): - start = spliter - end = spliter + step - if end > len(triphoneFiles): - end = triphoneFiles - comJobs.append(CombineMeansForTriphoneForward(triphoneFiles[start:end], - diphoneFiles[start:end], - contextFiles[start:end], - numSegments[start:end], - nContexts=nContexts, - nStates=nStateClasses, - )) - - combTriphoneFiles = [c.triphoneFilesOut for c in comJobs] - combDiphoneFiles = [c.diphoneFilesOut for c in comJobs] - combContextFiles = [c.contextFilesOut for c in comJobs] - combNumSegs = [c.numSegmentsOut for c in comJobs] - xmlJob = DumpXmlForTriphoneForward(combTriphoneFiles, - combDiphoneFiles, - combContextFiles, - combNumSegs, - nContexts=nContexts, - nStates=nStateClasses) - - priorFilesTriphone = [xmlJob.triphoneXml, xmlJob.diphoneXml, xmlJob.contextXml] - xmlName = f"priors/{name}" - tk.register_output(xmlName, priorFilesTriphone[0]) - - - return priorFilesTriphone \ No newline at end of file diff --git a/users/raissi/setups/common/helpers/priors/transcription.py b/users/raissi/setups/common/helpers/priors/transcription.py index 8bb8c01b7..f8879ada1 100644 --- a/users/raissi/setups/common/helpers/priors/transcription.py +++ b/users/raissi/setups/common/helpers/priors/transcription.py @@ -1,56 +1,82 @@ -__all__ = ["get_mono_transcription_priors"] +from sisyphus import * +from sisyphus.tools import try_get -import numpy as np -from typing import Iterator, List -import pickle +import os -from sisyphus import Job, Task +from i6_core.corpus.transform import ApplyLexiconToCorpusJob +from i6_core.lexicon.allophones import DumpStateTyingJob +from i6_core.lexicon.modification import AddEowPhonemesToLexiconJob -from i6_experiments.users.raissi.setups.common.decoder.config import PriorInfo, PriorConfig -from i6_experiments.users.raissi.setups.common.helpers.priors.util import write_prior_xml +from i6_experiments.users.mann.experimental.statistics import AllophoneCounts +from i6_experiments.users.mann.setups.prior import PriorFromTranscriptionCounts -pickles = { - ( - 1, - False, - ): "/work/asr4/raissi/setups/librispeech/960-ls/dependencies/priors/daniel/monostate/monostate.pickle", - ( - 1, - True, - ): "/work/asr4/raissi/setups/librispeech/960-ls/dependencies/priors/daniel/monostate/monostate.we.pickle", - ( - 3, - False, - ): "/work/asr4/raissi/setups/librispeech/960-ls/dependencies/priors/daniel/threepartite/threepartite.pickle", - ( - 3, - True, - ): "/work/asr4/raissi/setups/librispeech/960-ls/dependencies/priors/daniel/threepartite/threepartite.we.pickle", -} +def output(name, value): + opath = os.path.join(fname, name) + if isinstance(value, dict): + tk.register_report(opath, DescValueReport(value)) + return + tk.register_report(opath, SimpleValueReport(value)) -class LoadTranscriptionPriorsJob(Job): - def __init__(self, n: int, eow: bool): - assert n in [1, 3] +from sisyphus.delayed_ops import DelayedBase - self.n = n - self.eow = eow +class DelayedGetDefault(DelayedBase): + def __init__(self, a, b, default=None): + super().__init__(a, b) + self.default = default - self.out_priors = self.output_path("priors.xml") + def get(self): + try: + return try_get(self.a)[try_get(self.b)] + except KeyError: + return self.default - def tasks(self) -> Iterator[Task]: - yield Task("run", mini_task=True) - def run(self): - file = pickles[(self.n, self.eow)] +def get_prior_from_transcription( + crp, + total_frames, + average_phoneme_frames, + epsilon=1e-12, + lemma_end_probability=0.0, - with open(file, "rb") as f: - priors: List[float] = pickle.load(f) +): - write_prior_xml(log_priors=np.log(priors), path=self.out_priors) + lexicon_w_we = AddEowPhonemesToLexiconJob( + crp.lexicon_config.file, + boundary_marker=" #", # the prepended space is important + ) + corpus = crp.corpus_config.file + if not isinstance(crp.corpus_config.file, tk.Path): + corpus = tk.Path(crp.corpus_config.file) -def get_mono_transcription_priors(states_per_phone: int, with_word_end: bool) -> PriorInfo: - load_j = LoadTranscriptionPriorsJob(states_per_phone, with_word_end) - return PriorInfo(center_state_prior=PriorConfig(file=load_j.out_priors, scale=0.0)) + + transcribe_job = ApplyLexiconToCorpusJob( + corpus, + lexicon_w_we.out_lexicon, + ) + + count_phonemes = AllophoneCounts( + transcribe_job.out_corpus, + lemma_end_probability=lemma_end_probability, + ) + + state_tying_file = DumpStateTyingJob(crp).out_state_tying + + + + prior_job = PriorFromTranscriptionCounts( + allophone_counts=count_phonemes.counts, + total_count=count_phonemes.total, + state_tying=state_tying_file, + average_phoneme_frames=average_phoneme_frames, + num_frames=total_frames, + eps=epsilon, + ) + + return { + "txt": prior_job.out_prior_txt_file, + "xml": prior_job.out_prior_xml_file, + "png": prior_job.out_prior_png_file + } \ No newline at end of file diff --git a/users/raissi/setups/common/helpers/priors/util.py b/users/raissi/setups/common/helpers/priors/util.py index 77f6f6e33..c90fb2339 100644 --- a/users/raissi/setups/common/helpers/priors/util.py +++ b/users/raissi/setups/common/helpers/priors/util.py @@ -2,12 +2,21 @@ from dataclasses import dataclass import numpy as np -from typing import List, Tuple, Union +from typing import List, Tuple, Union import xml.etree.ElementTree as ET from sisyphus import Path +@dataclass(frozen=True, eq=True) +class PartitionDataSetup: + n_segment_indices: int = 20 + n_data_indices: int = 3 + segment_offset: int = 10 + data_offset: int = 10 + split_step: int = 200 + + @dataclass(frozen=True, eq=True) class ParsedPriors: priors_log: List[float] @@ -81,4 +90,4 @@ def get_batch_from_segments(segments: List, batchSize=10000): yield segments[index * batchSize : (index + 1) * batchSize] index += 1 except IndexError: - index = 0 \ No newline at end of file + index = 0 diff --git a/users/raissi/setups/common/util/tdp.py b/users/raissi/setups/common/util/tdp.py index 5833c99d2..7fc7cc4c5 100644 --- a/users/raissi/setups/common/util/tdp.py +++ b/users/raissi/setups/common/util/tdp.py @@ -3,7 +3,7 @@ from typing import Union, Tuple from sisyphus import tk -from sisyphus.delayed_ops import DelayedBase +from sisyphus.delayed_ops import DelayedBase, DelayedGetItem from i6_experiments.common.setups.rasr.config.am_config import Tdp from i6_experiments.users.raissi.setups.common.data.typings import TDP @@ -14,6 +14,8 @@ def to_tdp(tdp_tuple: Tuple[TDP, TDP, TDP, TDP]) -> Tdp: def format_tdp_val(val) -> str: + if isinstance(val, DelayedGetItem): + val = val.get() return "inf" if val == "infinity" else f"{val}" diff --git a/users/raissi/setups/librispeech/decoder/LBS_factored_hybrid_search.py b/users/raissi/setups/librispeech/decoder/LBS_factored_hybrid_search.py index 2bca15a42..736be9b91 100644 --- a/users/raissi/setups/librispeech/decoder/LBS_factored_hybrid_search.py +++ b/users/raissi/setups/librispeech/decoder/LBS_factored_hybrid_search.py @@ -97,6 +97,7 @@ def __init__( lm_gc_simple_hash=lm_gc_simple_hash, gpu=gpu, ) + self.trafo_lm_config = self.get_eugen_trafo_with_quant_and_compress_config() def get_ls_kazuki_lstm_lm_config( self, @@ -115,7 +116,7 @@ def get_ls_kazuki_lstm_lm_config( state_manager="lstm", ).get() - def get_eugen_trafo_config( + def get_eugen_trafo_with_quant_and_compress_config( self, min_batch_size: int = 0, opt_batch_size: int = 64, @@ -229,6 +230,62 @@ def get_eugen_trafo_config( return trafo_config + def get_eugen_trafo_config( + self, + min_batch_size: int = 0, + opt_batch_size: int = 64, + max_batch_size: int = 64, + scale: Optional[float] = None, + ) -> rasr.RasrConfig: + # assert self.library_path is not None + + + trafo_config = rasr.RasrConfig() + + trafo_config.min_batch_size = min_batch_size + trafo_config.opt_batch_size = opt_batch_size + trafo_config.max_batch_size = max_batch_size + trafo_config.allow_reduced_history = True + if scale is not None: + trafo_config.scale = scale + trafo_config.type = "tfrnn" + trafo_config.vocab_file = tk.Path("/work/asr3/raissi/shared_workspaces/gunz/dependencies/ls-eugen-trafo-lm/vocabulary", cached=True) + trafo_config.transform_output_negate = True + trafo_config.vocab_unknown_word = "" + + trafo_config.input_map.info_0.param_name = "word" + trafo_config.input_map.info_0.tensor_name = "extern_data/placeholders/delayed/delayed" + trafo_config.input_map.info_0.seq_length_tensor_name = "extern_data/placeholders/delayed/delayed_dim0_size" + + trafo_config.input_map.info_1.param_name = "state-lengths" + trafo_config.input_map.info_1.tensor_name = "output/rec/dec_0_self_att_att/state_lengths" + + trafo_config.loader.type = "meta" + trafo_config.loader.meta_graph_file = ( + "/work/asr4/raissi/setups/librispeech/960-ls/dependencies/trafo-lm_eugen/integrated_fixup_graph_no_cp_no_quant.meta" + ) + model_path = "/work/asr3/raissi/shared_workspaces/gunz/dependencies/ls-eugen-trafo-lm/epoch.030" + trafo_config.loader.saved_model_file = rasr.StringWrapper(model_path, f"{model_path}.index") + trafo_config.loader.required_libraries = self.library_path + + trafo_config.output_map.info_0.param_name = "softmax" + trafo_config.output_map.info_0.tensor_name = "output/rec/decoder/add" + + trafo_config.output_map.info_1.param_name = "weights" + trafo_config.output_map.info_1.tensor_name = "output/rec/output/W/read" + + trafo_config.output_map.info_2.param_name = "bias" + trafo_config.output_map.info_2.tensor_name = "output/rec/output/b/read" + + + trafo_config.state_manager.cache_prefix = True + trafo_config.state_manager.min_batch_size = min_batch_size + trafo_config.state_manager.min_common_prefix_length = 0 + trafo_config.state_manager.type = "transformer" + trafo_config.softmax_adapter.type = "blas-nce" + + return trafo_config + def recognize_ls_trafo_lm( self, *, @@ -265,7 +322,7 @@ def recognize_ls_trafo_lm( is_nn_lm=True, keep_value=keep_value, label_info=label_info, - lm_config=self.get_eugen_trafo_config(), + lm_config=self.trafo_lm_config, name_override=name_override, name_prefix=name_prefix, num_encoder_output=num_encoder_output, diff --git a/users/raissi/setups/librispeech/helpers/__init__.py b/users/raissi/setups/librispeech/helpers/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/users/raissi/setups/librispeech/helpers/priors/__init__.py b/users/raissi/setups/librispeech/helpers/priors/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/users/raissi/setups/librispeech/helpers/priors/transcription.py b/users/raissi/setups/librispeech/helpers/priors/transcription.py new file mode 100644 index 000000000..81ea888e3 --- /dev/null +++ b/users/raissi/setups/librispeech/helpers/priors/transcription.py @@ -0,0 +1,56 @@ +__all__ = ["get_mono_transcription_priors"] + +import numpy as np +from typing import Iterator, List +import pickle + +from sisyphus import Job, Task + +from i6_experiments.users.raissi.setups.common.decoder.config import PriorInfo, PriorConfig +from i6_experiments.users.raissi.setups.common.helpers.priors.util import write_prior_xml + + +pickles = { + ( + 1, + False, + ): "/work/asr4/raissi/setups/librispeech/960-ls/dependencies/priors/daniel/monostate/monostate.pickle", + ( + 1, + True, + ): "/work/asr4/raissi/setups/librispeech/960-ls/dependencies/priors/daniel/monostate/monostate.we.pickle", + ( + 3, + False, + ): "/work/asr4/raissi/setups/librispeech/960-ls/dependencies/priors/daniel/threepartite/threepartite.pickle", + ( + 3, + True, + ): "/work/asr4/raissi/setups/librispeech/960-ls/dependencies/priors/daniel/threepartite/threepartite.we.pickle", +} + + +class LoadTranscriptionPriorsJob(Job): + def __init__(self, n: int, eow: bool): + assert n in [1, 3] + + self.n = n + self.eow = eow + + self.out_priors = self.output_path("priors.xml") + + def tasks(self) -> Iterator[Task]: + yield Task("run", mini_task=True) + + def run(self): + file = pickles[(self.n, self.eow)] + + with open(file, "rb") as f: + priors: List[float] = pickle.load(f) + + write_prior_xml(log_priors=np.log(priors), path=self.out_priors) + + +def get_mono_transcription_priors(states_per_phone: int, with_word_end: bool) -> PriorInfo: + load_j = LoadTranscriptionPriorsJob(states_per_phone, with_word_end) + return PriorInfo(center_state_prior=PriorConfig(file=load_j.out_priors, scale=0.0)) \ No newline at end of file diff --git a/users/raissi/utils/default_tools.py b/users/raissi/utils/default_tools.py index 47d9ee5b3..baef3b003 100644 --- a/users/raissi/utils/default_tools.py +++ b/users/raissi/utils/default_tools.py @@ -93,6 +93,7 @@ def get_rasr_binary_path(rasr_path): hash_overwrite="CONFORMER_RETURNN_Len_FIX", ) RETURNN_ROOT_TORCH = tk.Path("/work/tools/users/raissi/returnn_versions/torch", hash_overwrite="TORCH_RETURNN_ROOT") +RETURNN_ROOT_BW_FACTORED = tk.Path("/work/tools/users/raissi/returnn_versions/bw-factored", hash_overwrite="BW_RETURNN_ROOT") SCTK_BINARY_PATH = compile_sctk(branch="v2.4.12") # use last published version SCTK_BINARY_PATH.hash_overwrite = "DEFAULT_SCTK_BINARY_PATH" From d45e75c91a171b8d4e5459223d31b6bd578821ac Mon Sep 17 00:00:00 2001 From: marvin84 Date: Tue, 4 Jun 2024 14:09:50 +0200 Subject: [PATCH 089/227] deleted wrong stashed --- common/datasets/tedlium2_v2/corpus.py | 136 ---------------- common/datasets/tedlium2_v2/download.py | 48 ------ common/datasets/tedlium2_v2/export.py | 96 ----------- common/datasets/tedlium2_v2/lexicon.py | 171 -------------------- common/datasets/tedlium2_v2/textual_data.py | 39 ----- common/datasets/tedlium2_v2/vocab.py | 51 ------ 6 files changed, 541 deletions(-) delete mode 100644 common/datasets/tedlium2_v2/corpus.py delete mode 100644 common/datasets/tedlium2_v2/download.py delete mode 100644 common/datasets/tedlium2_v2/export.py delete mode 100644 common/datasets/tedlium2_v2/lexicon.py delete mode 100644 common/datasets/tedlium2_v2/textual_data.py delete mode 100644 common/datasets/tedlium2_v2/vocab.py diff --git a/common/datasets/tedlium2_v2/corpus.py b/common/datasets/tedlium2_v2/corpus.py deleted file mode 100644 index f74a7acbf..000000000 --- a/common/datasets/tedlium2_v2/corpus.py +++ /dev/null @@ -1,136 +0,0 @@ -import os -from functools import lru_cache -from typing import Dict, Optional, Any - -from sisyphus import tk - -from i6_core.audio.encoding import BlissChangeEncodingJob - -from i6_core.meta import CorpusObject - -from ..tedlium2.constants import DURATIONS -from .download import download_data_dict - - -@lru_cache() -def get_bliss_corpus_dict(audio_format: str = "wav", output_prefix: str = "datasets") -> Dict[str, tk.Path]: - """ - creates a dictionary of all corpora in the TedLiumV2 dataset in the bliss xml format - - :param audio_format: options: wav, ogg, flac, sph, nist. nist (NIST sphere format) and sph are the same. - :param output_prefix: - :return: - """ - assert audio_format in ["flac", "ogg", "wav", "sph", "nist"] - - output_prefix = os.path.join(output_prefix, "Ted-Lium-2") - - bliss_corpus_dict = download_data_dict(output_prefix=output_prefix).bliss_nist - - audio_format_options = { - "wav": { - "output_format": "wav", - "codec": "pcm_s16le", - }, - "ogg": {"output_format": "ogg", "codec": "libvorbis"}, - "flac": {"output_format": "flac", "codec": "flac"}, - } - - converted_bliss_corpus_dict = {} - if audio_format not in ["sph", "nist"]: - for corpus_name, sph_corpus in bliss_corpus_dict.items(): - bliss_change_encoding_job = BlissChangeEncodingJob( - corpus_file=sph_corpus, - sample_rate=16000, - recover_duration=False, - **audio_format_options[audio_format], - ) - bliss_change_encoding_job.add_alias( - os.path.join( - output_prefix, - "%s_conversion" % audio_format, - corpus_name, - ) - ) - converted_bliss_corpus_dict[corpus_name] = bliss_change_encoding_job.out_corpus - else: - converted_bliss_corpus_dict = bliss_corpus_dict - - return converted_bliss_corpus_dict - - -@lru_cache() -def get_corpus_object_dict(audio_format: str = "flac", output_prefix: str = "datasets") -> Dict[str, CorpusObject]: - """ - creates a dict of all corpora in the TedLiumV2 dataset as a `meta.CorpusObject` - - :param audio_format: options: wav, ogg, flac, sph, nist. nist (NIST sphere format) and sph are the same. - :param output_prefix: - :return: - """ - bliss_corpus_dict = get_bliss_corpus_dict(audio_format=audio_format, output_prefix=output_prefix) - - corpus_object_dict = {} - - for corpus_name, bliss_corpus in bliss_corpus_dict.items(): - corpus_object = CorpusObject() - corpus_object.corpus_file = bliss_corpus - corpus_object.audio_format = audio_format - corpus_object.audio_dir = None - corpus_object.duration = DURATIONS[corpus_name] - - corpus_object_dict[corpus_name] = corpus_object - - return corpus_object_dict - - -@lru_cache() -def get_stm_dict(output_prefix: str = "datasets") -> Dict[str, tk.Path]: - """ - fetches the STM files for TedLiumV2 dataset - - :param output_prefix: - :return: - """ - return download_data_dict(output_prefix=output_prefix).stm - - -def get_ogg_zip_dict( - subdir_prefix: str = "datasets", - returnn_python_exe: Optional[tk.Path] = None, - returnn_root: Optional[tk.Path] = None, - bliss_to_ogg_job_rqmt: Optional[Dict[str, Any]] = None, - extra_args: Optional[Dict[str, Dict[str, Any]]] = None, -) -> Dict[str, tk.Path]: - """ - Get a dictionary containing the paths to the ogg_zip for each corpus part. - - No outputs will be registered. - - :param subdir_prefix: dir name prefix for aliases and outputs - :param returnn_python_exe: path to returnn python executable - :param returnn_root: python to returnn root - :param bliss_to_ogg_job_rqmt: rqmt for bliss to ogg job - :param extra_args: extra args for each dataset for bliss to ogg job - :return: dictionary with ogg zip paths for each corpus (train, dev, test) - """ - from i6_core.returnn.oggzip import BlissToOggZipJob - - ogg_zip_dict = {} - bliss_corpus_dict = get_bliss_corpus_dict(audio_format="wav", output_prefix=subdir_prefix) - if extra_args is None: - extra_args = {} - for name, bliss_corpus in bliss_corpus_dict.items(): - ogg_zip_job = BlissToOggZipJob( - bliss_corpus, - no_conversion=False, # cannot be used for corpus with multiple segments per recording - returnn_python_exe=returnn_python_exe, - returnn_root=returnn_root, - **extra_args.get(name, {}), - ) - if bliss_to_ogg_job_rqmt: - ogg_zip_job.rqmt = bliss_to_ogg_job_rqmt - ogg_zip_job.add_alias(os.path.join(subdir_prefix, "Ted-Lium-2", "%s_ogg_zip_job" % name)) - ogg_zip_dict[name] = ogg_zip_job.out_ogg_zip - - return ogg_zip_dict diff --git a/common/datasets/tedlium2_v2/download.py b/common/datasets/tedlium2_v2/download.py deleted file mode 100644 index 948224ae7..000000000 --- a/common/datasets/tedlium2_v2/download.py +++ /dev/null @@ -1,48 +0,0 @@ -import os -from dataclasses import dataclass -from functools import lru_cache -from typing import Any, Dict - -from sisyphus import tk - -from i6_core.datasets.tedlium2 import ( - DownloadTEDLIUM2CorpusJob, - CreateTEDLIUM2BlissCorpusJobV2, -) - - -@dataclass(frozen=True) -class TedLium2Data: - """Class for storing the TedLium2 data""" - - data_dir: Dict[str, tk.Path] - lm_dir: tk.Path - vocab: tk.Path - bliss_nist: Dict[str, tk.Path] - stm: Dict[str, tk.Path] - - -@lru_cache() -def download_data_dict(output_prefix: str = "datasets") -> TedLium2Data: - """ - downloads the TedLiumV2 dataset and performs the initial data processing steps - Uses the fixed job CreateTEDLIUM2BlissCorpusJobV2 from: https://github.com/rwth-i6/i6_core/pull/490 - - :param output_prefix: - :return: - """ - download_tedlium2_job = DownloadTEDLIUM2CorpusJob() - download_tedlium2_job.add_alias(os.path.join(output_prefix, "download", "raw_corpus_job")) - - bliss_corpus_tedlium2_job = CreateTEDLIUM2BlissCorpusJobV2(download_tedlium2_job.out_corpus_folders) - bliss_corpus_tedlium2_job.add_alias(os.path.join(output_prefix, "create_bliss", "bliss_corpus_job")) - - tl2_data = TedLium2Data( - data_dir=download_tedlium2_job.out_corpus_folders, - lm_dir=download_tedlium2_job.out_lm_folder, - vocab=download_tedlium2_job.out_vocab_dict, - bliss_nist=bliss_corpus_tedlium2_job.out_corpus_files, - stm=bliss_corpus_tedlium2_job.out_stm_files, - ) - - return tl2_data diff --git a/common/datasets/tedlium2_v2/export.py b/common/datasets/tedlium2_v2/export.py deleted file mode 100644 index 1919fa8c0..000000000 --- a/common/datasets/tedlium2_v2/export.py +++ /dev/null @@ -1,96 +0,0 @@ -import os - -from sisyphus import tk - -from .corpus import get_bliss_corpus_dict, get_stm_dict -from .lexicon import get_bliss_lexicon, get_g2p_augmented_bliss_lexicon -from .textual_data import get_text_data_dict - -TEDLIUM_PREFIX = "Ted-Lium-2" - - -def _export_datasets(output_prefix: str = "datasets"): - """ - exports all datasets for TedLiumV2 with all available audio formats - - :param output_prefix: - :return: - """ - for audio_format in ["flac", "ogg", "wav", "nist", "sph"]: - bliss_corpus_dict = get_bliss_corpus_dict(audio_format=audio_format, output_prefix=output_prefix) - for name, bliss_corpus in bliss_corpus_dict.items(): - tk.register_output( - os.path.join( - output_prefix, - TEDLIUM_PREFIX, - "corpus", - f"{name}-{audio_format}.xml.gz", - ), - bliss_corpus, - ) - - -def _export_stms(output_prefix: str = "datasets"): - """ - exports all STMs for TedLiumV2 - - :param output_prefix: - :return: - """ - stm_dict = get_stm_dict(output_prefix=output_prefix) - for name, stm_file in stm_dict.items(): - tk.register_output( - os.path.join( - output_prefix, - TEDLIUM_PREFIX, - "stm", - f"{name}.txt", - ), - stm_file, - ) - - -def _export_text_data(output_prefix: str = "datasets"): - """ - exports all the textual data for TedLiumV2 dataset - - :param output_prefix: - :return: - """ - txt_data_dict = get_text_data_dict(output_prefix=output_prefix) - for k, v in txt_data_dict.items(): - tk.register_output(os.path.join(output_prefix, TEDLIUM_PREFIX, "text_data", f"{k}.gz"), v) - - -def _export_lexicon(output_prefix: str = "datasets"): - """ - exports the lexicon for TedLiumV2 - - :param output_prefix: - :return: - """ - lexicon_output_prefix = os.path.join(output_prefix, TEDLIUM_PREFIX, "lexicon") - - bliss_lexicon = get_bliss_lexicon(output_prefix=output_prefix) - tk.register_output(os.path.join(lexicon_output_prefix, "tedlium2.lexicon.xml.gz"), bliss_lexicon) - - g2p_bliss_lexicon = get_g2p_augmented_bliss_lexicon( - add_unknown_phoneme_and_mapping=False, output_prefix=output_prefix - ) - tk.register_output( - os.path.join(lexicon_output_prefix, "tedlium2.lexicon_with_g2p.xml.gz"), - g2p_bliss_lexicon, - ) - - -def export_all(output_prefix: str = "datasets"): - """ - exports everything for TedLiumV2 - - :param output_prefix: - :return: - """ - _export_datasets(output_prefix=output_prefix) - _export_stms(output_prefix=output_prefix) - _export_text_data(output_prefix=output_prefix) - _export_lexicon(output_prefix=output_prefix) diff --git a/common/datasets/tedlium2_v2/lexicon.py b/common/datasets/tedlium2_v2/lexicon.py deleted file mode 100644 index 4d8366155..000000000 --- a/common/datasets/tedlium2_v2/lexicon.py +++ /dev/null @@ -1,171 +0,0 @@ -import os -from functools import lru_cache -from sisyphus import tk - -from i6_core.lexicon import LexiconFromTextFileJob -from i6_core.lexicon.modification import WriteLexiconJob, MergeLexiconJob -from i6_core.lib import lexicon -from i6_experiments.common.helpers.g2p import G2PBasedOovAugmenter - -from ..tedlium2.constants import SILENCE_PHONEME, UNKNOWN_PHONEME -from .corpus import get_bliss_corpus_dict -from .download import download_data_dict - - -@lru_cache() -def _get_special_lemma_lexicon( - add_unknown_phoneme_and_mapping: bool = False, - add_silence: bool = True, -) -> lexicon.Lexicon: - """ - creates the special lemma used in RASR - - :param add_unknown_phoneme_and_mapping: adds [unknown] as label with [UNK] as phoneme and as LM token - :param add_silence: adds [silence] label with [SILENCE] phoneme, - use False for CTC/RNN-T setups without silence modelling. - :return: - """ - lex = lexicon.Lexicon() - if add_silence: - lex.add_lemma( - lexicon.Lemma( - orth=["[silence]", ""], - phon=[SILENCE_PHONEME], - synt=[], - special="silence", - eval=[[]], - ) - ) - if add_unknown_phoneme_and_mapping: - lex.add_lemma( - lexicon.Lemma( - orth=["[unknown]"], - phon=[UNKNOWN_PHONEME], - synt=[""], - special="unknown", - eval=[[]], - ) - ) - else: - lex.add_lemma( - lexicon.Lemma( - orth=["[unknown]"], - synt=[""], - special="unknown", - eval=[[]], - ) - ) - - lex.add_lemma( - lexicon.Lemma( - orth=["[sentence-begin]"], - synt=[""], - special="sentence-begin", - eval=[[]], - ) - ) - lex.add_lemma( - lexicon.Lemma( - orth=["[sentence-end]"], - synt=[""], - special="sentence-end", - eval=[[]], - ) - ) - if add_silence: - lex.add_phoneme(SILENCE_PHONEME, variation="none") - if add_unknown_phoneme_and_mapping: - lex.add_phoneme(UNKNOWN_PHONEME, variation="none") - - return lex - - -@lru_cache() -def _get_raw_bliss_lexicon( - output_prefix: str, -) -> tk.Path: - """ - downloads the vocabulary file from the TedLiumV2 dataset and creates a bliss lexicon - - :param output_prefix: - :return: - """ - vocab = download_data_dict(output_prefix=output_prefix).vocab - - convert_lexicon_job = LexiconFromTextFileJob( - text_file=vocab, - compressed=True, - ) - convert_lexicon_job.add_alias(os.path.join(output_prefix, "convert_text_to_bliss_lexicon_job")) - - return convert_lexicon_job.out_bliss_lexicon - - -@lru_cache() -def get_bliss_lexicon( - add_unknown_phoneme_and_mapping: bool = True, - add_silence: bool = True, - output_prefix: str = "datasets", -) -> tk.Path: - """ - merges the lexicon with special RASR tokens with the lexicon created from the downloaded TedLiumV2 vocabulary - - :param add_unknown_phoneme_and_mapping: add an unknown phoneme and mapping unknown phoneme:lemma - :param add_silence: include silence lemma and phoneme - :param output_prefix: - :return: - """ - static_lexicon = _get_special_lemma_lexicon(add_unknown_phoneme_and_mapping, add_silence) - static_lexicon_job = WriteLexiconJob(static_lexicon, sort_phonemes=True, sort_lemmata=False) - static_lexicon_job.add_alias(os.path.join(output_prefix, "static_lexicon_job")) - - raw_tedlium2_lexicon = _get_raw_bliss_lexicon(output_prefix=output_prefix) - - merge_lexicon_job = MergeLexiconJob( - bliss_lexica=[ - static_lexicon_job.out_bliss_lexicon, - raw_tedlium2_lexicon, - ], - sort_phonemes=True, - sort_lemmata=True, - compressed=True, - ) - merge_lexicon_job.add_alias(os.path.join(output_prefix, "merge_lexicon_job")) - - return merge_lexicon_job.out_bliss_lexicon - - -@lru_cache() -def get_g2p_augmented_bliss_lexicon( - add_unknown_phoneme_and_mapping: bool = False, - add_silence: bool = True, - audio_format: str = "wav", - output_prefix: str = "datasets", -) -> tk.Path: - """ - augment the kernel lexicon with unknown words from the training corpus - - :param add_unknown_phoneme_and_mapping: add an unknown phoneme and mapping unknown phoneme:lemma - :param add_silence: include silence lemma and phoneme - :param audio_format: options: wav, ogg, flac, sph, nist. nist (NIST sphere format) and sph are the same. - :param output_prefix: - :return: - """ - original_bliss_lexicon = get_bliss_lexicon( - add_unknown_phoneme_and_mapping, add_silence=add_silence, output_prefix=output_prefix - ) - corpus_name = "train" - bliss_corpus = get_bliss_corpus_dict(audio_format=audio_format, output_prefix=output_prefix)[corpus_name] - - g2p_augmenter = G2PBasedOovAugmenter( - original_bliss_lexicon=original_bliss_lexicon, - train_lexicon=original_bliss_lexicon, - ) - augmented_bliss_lexicon = g2p_augmenter.get_g2p_augmented_bliss_lexicon( - bliss_corpus=bliss_corpus, - corpus_name=corpus_name, - alias_path=os.path.join(output_prefix, "g2p"), - casing="lower", - ) - - return augmented_bliss_lexicon diff --git a/common/datasets/tedlium2_v2/textual_data.py b/common/datasets/tedlium2_v2/textual_data.py deleted file mode 100644 index 553489a0d..000000000 --- a/common/datasets/tedlium2_v2/textual_data.py +++ /dev/null @@ -1,39 +0,0 @@ -from functools import lru_cache -from typing import Dict - -from sisyphus import tk - -from i6_core.corpus import CorpusToTxtJob -from i6_core.text import ConcatenateJob - -from i6_experiments.common.datasets.tedlium2.corpus_v2 import get_bliss_corpus_dict - -from .download import download_data_dict - - -@lru_cache() -def get_text_data_dict(output_prefix: str = "datasets") -> Dict[str, tk.Path]: - """ - gather all the textual data provided within the TedLiumV2 dataset - - :param output_prefix: - :return: - """ - lm_dir = download_data_dict(output_prefix=output_prefix).lm_dir - - text_corpora = [ - "commoncrawl-9pc", - "europarl-v7-6pc", - "giga-fren-4pc", - "news-18pc", - "news-commentary-v8-9pc", - "yandex-1m-31pc", - ] - - txt_dict = {name: lm_dir.join_right("%s.en.gz" % name) for name in text_corpora} - txt_dict["audio-transcriptions"] = CorpusToTxtJob( - get_bliss_corpus_dict(audio_format="wav", output_prefix="corpora")["train"] - ).out_txt - txt_dict["background-data"] = ConcatenateJob(list(txt_dict.values())).out - - return txt_dict diff --git a/common/datasets/tedlium2_v2/vocab.py b/common/datasets/tedlium2_v2/vocab.py deleted file mode 100644 index 14d4455f5..000000000 --- a/common/datasets/tedlium2_v2/vocab.py +++ /dev/null @@ -1,51 +0,0 @@ -from i6_experiments.common.helpers.text_labels.subword_nmt_bpe import ( - get_returnn_subword_nmt, - get_bpe_settings, - BPESettings, -) -from .corpus import get_bliss_corpus_dict - - -def get_subword_nmt_bpe(bpe_size: int, unk_label: str = "", subdir_prefix: str = "") -> BPESettings: - """ - Get the BPE tokens via the Returnn subword-nmt for a Tedlium2 setup. - - :param bpe_size: the number of BPE merge operations. This is NOT the resulting vocab size! - :param unk_label: unknown label symbol - :param subdir_prefix: dir name prefix for aliases and outputs - """ - subword_nmt_repo = get_returnn_subword_nmt(output_prefix=subdir_prefix) - train_corpus = get_bliss_corpus_dict()["train"] - bpe_settings = get_bpe_settings( - train_corpus, - bpe_size=bpe_size, - unk_label=unk_label, - output_prefix=subdir_prefix, - subword_nmt_repo_path=subword_nmt_repo, - ) - return bpe_settings - - -def get_subword_nmt_bpe_v2(bpe_size: int, unk_label: str = "", subdir_prefix: str = "") -> BPESettings: - """ - Get the BPE tokens via the Returnn subword-nmt for a Tedlium2 setup. - - V2: Uses subword-nmt version corrected for Apptainer related bug, adds hash overwrite for repo - - :param bpe_size: the number of BPE merge operations. This is NOT the resulting vocab size! - :param unk_label: unknown label symbol - :param subdir_prefix: dir name prefix for aliases and outputs - """ - subword_nmt_repo = get_returnn_subword_nmt( - commit_hash="5015a45e28a958f800ef1c50e7880c0c9ef414cf", output_prefix=subdir_prefix - ) - subword_nmt_repo.hash_overwrite = "I6_SUBWORD_NMT_V2" - train_corpus = get_bliss_corpus_dict()["train"] - bpe_settings = get_bpe_settings( - train_corpus, - bpe_size=bpe_size, - unk_label=unk_label, - output_prefix=subdir_prefix, - subword_nmt_repo_path=subword_nmt_repo, - ) - return bpe_settings From ae73db3f6e2fa37165aa738c5b5fa3e013fcaab6 Mon Sep 17 00:00:00 2001 From: "luca.gaudino" Date: Tue, 4 Jun 2024 15:50:57 +0200 Subject: [PATCH 090/227] update trainings and initial rnnt decoder rf --- .../conformer_import_moh_att_2023_06_30.py | 4 +- .../conformer_import_moh_att_train.py | 14 +- .../conformer_import_moh_att_2023_10_19.py | 8 +- .../conformer_import_moh_att_train.py | 4 +- .../librispeech_960/conformer_ctc_train.py | 2 +- .../tedlium2/conformer_ctc_train.py | 205 ++- .../tedlium2/conformer_rnnt_train.py | 55 +- .../rf/conformer_ctc/model_conformer_ctc.py | 16 +- .../asr/rf/conformer_rnnt/model_recog_rnnt.py | 1130 ++++++++--------- 9 files changed, 770 insertions(+), 668 deletions(-) diff --git a/users/gaudino/experiments/rf_conformer_att_2023/librispeech_960/conformer_import_moh_att_2023_06_30.py b/users/gaudino/experiments/rf_conformer_att_2023/librispeech_960/conformer_import_moh_att_2023_06_30.py index ab9778259..52193c721 100644 --- a/users/gaudino/experiments/rf_conformer_att_2023/librispeech_960/conformer_import_moh_att_2023_06_30.py +++ b/users/gaudino/experiments/rf_conformer_att_2023/librispeech_960/conformer_import_moh_att_2023_06_30.py @@ -639,7 +639,7 @@ def sis_run_with_prefix(prefix_name: str = None): # opls att + ctc + trafo lm + ilm for scales, prior_scale, lm_scale, ilm_scale, beam_size in product( - [(0.85, 0.15)], [0.0], [0.5], [0.3, 0.35, 0.4, 0.45], [12, 32] + [(0.8, 0.2)], [0.05, 0.03, 0.04, 0.06, 0.07], [0.65], [0.4], [32] ): att_scale, ctc_scale = scales recog_name = ( @@ -668,7 +668,7 @@ def sis_run_with_prefix(prefix_name: str = None): task, model_with_checkpoint, model_recog, - dev_sets=["dev-other"], + dev_sets=["dev-clean", "dev-other"], model_args=model_args, search_args=search_args, prefix_name=name, diff --git a/users/gaudino/experiments/rf_conformer_att_2023/librispeech_960/conformer_import_moh_att_train.py b/users/gaudino/experiments/rf_conformer_att_2023/librispeech_960/conformer_import_moh_att_train.py index 79cb8641f..5bdc5eff2 100644 --- a/users/gaudino/experiments/rf_conformer_att_2023/librispeech_960/conformer_import_moh_att_train.py +++ b/users/gaudino/experiments/rf_conformer_att_2023/librispeech_960/conformer_import_moh_att_train.py @@ -102,7 +102,7 @@ def sis_run_with_prefix(prefix_name: Optional[str] = None): # RF recog: {"dev-clean": 2.25, "dev-other": 5.34, "test-clean": 2.42, "test-other": 5.56} # _recog_imported() - train_exp("from-scratch-train", config_11gb, gpu_mem=11) + # train_exp("from-scratch-train", config_11gb, gpu_mem=11) # train_exp( # dev-other 7.6 # "base-24gb-bs30k-f32", @@ -334,6 +334,18 @@ def sis_run_with_prefix(prefix_name: Optional[str] = None): "learning_rate_piecewise_values": [1e-5, 1e-3, 1e-5, 1e-6], }, ) + model = train_exp( + "base-24gb-v6-lrlin1e_5_600k_noCTC", + config_24gb_v6, + config_updates={ + "learning_rate": 1.0, + "dynamic_learning_rate": dyn_lr_piecewise_linear, + # total steps after 2000 epochs: 982.312 + "learning_rate_piecewise_steps": [600_000, 900_000, 982_000], + "learning_rate_piecewise_values": [1e-5, 1e-3, 1e-5, 1e-6], + "aux_loss_layers": [], + }, + ) # All beam search experiments using model_recog_pure_torch, beam_search_sep_ended_keep_v6. # for name, recog_config in { # "beam12-batch200-lenReward01": { diff --git a/users/gaudino/experiments/rf_conformer_att_2023/tedlium2/conformer_import_moh_att_2023_10_19.py b/users/gaudino/experiments/rf_conformer_att_2023/tedlium2/conformer_import_moh_att_2023_10_19.py index d89d6fbf1..19b1bb220 100644 --- a/users/gaudino/experiments/rf_conformer_att_2023/tedlium2/conformer_import_moh_att_2023_10_19.py +++ b/users/gaudino/experiments/rf_conformer_att_2023/tedlium2/conformer_import_moh_att_2023_10_19.py @@ -482,7 +482,7 @@ def sis_run_with_prefix(prefix_name: str = None): # att + trafo lm + ilm correction for model_name, lm_scale, ilm_scale, beam_size in product( # ["model_baseline", "model_ctc0.5_att0.5"], [0.36] ,[0.28], [12] - ["model_baseline"], [0.36], [0.28], [] #12 + ["model_baseline"], [0.36], [0.28], [12,24] #12 ): ilm_model_args = copy.deepcopy(models_with_pt_ckpt[model_name]["model_args"]) ilm_model_args["preload_from_files"] = preload_from_files_ilm @@ -492,7 +492,7 @@ def sis_run_with_prefix(prefix_name: str = None): + "/" + model_name + f"/att_trafolm{lm_scale}_ilm{ilm_scale}" - + f"_beam{beam_size}" + + f"_beam{beam_size}_fffix" ) search_args = { "beam_size": beam_size, @@ -502,6 +502,7 @@ def sis_run_with_prefix(prefix_name: str = None): "bsf": 32, "use_first_lm": True, "use_zoneout_output": True, + "hash_overwrite": "ffix", } recog_res, recog_out = recog_model( task, @@ -532,7 +533,7 @@ def sis_run_with_prefix(prefix_name: str = None): + model_name + f"/opls_att{att_scale}_ctc{ctc_scale}_trafolm{lm_scale}_ilm{ilm_scale}" + (f"_prior{prior_scale}" if prior_scale > 0 else "") - + f"_beam{beam_size}" + + f"_beam{beam_size}_ffix" ) search_args = { "beam_size": beam_size, @@ -546,6 +547,7 @@ def sis_run_with_prefix(prefix_name: str = None): "prior_corr": True if prior_scale > 0 else False, "prior_scale": prior_scale, "ctc_prior_file": models[model_name]["prior"], + "use_first_lm": True, } recog_res, recog_out = recog_model( diff --git a/users/gaudino/experiments/rf_conformer_att_2023/tedlium2/conformer_import_moh_att_train.py b/users/gaudino/experiments/rf_conformer_att_2023/tedlium2/conformer_import_moh_att_train.py index f405cd911..b96e1f691 100644 --- a/users/gaudino/experiments/rf_conformer_att_2023/tedlium2/conformer_import_moh_att_train.py +++ b/users/gaudino/experiments/rf_conformer_att_2023/tedlium2/conformer_import_moh_att_train.py @@ -147,7 +147,7 @@ def sis_run_with_prefix(prefix_name: Optional[str] = None): # gpu_mem=11, # ) - train_exp( # + train_exp( # dev 7.8 test 7.22 "base-11gb-v3-lrlin1e_5_261k_aux4_8_zoneout_fix", my_config_11gb, config_updates={ @@ -203,7 +203,7 @@ def sis_run_with_prefix(prefix_name: Optional[str] = None): # ) - model = train_exp( # + model = train_exp( # dev 8.53 test 7.7 "base-24gb-v6-lrlin1e_5_85k_zoneout_fix", config_24gb_v6, config_updates={ diff --git a/users/gaudino/experiments/rf_conformer_rnnt_2024/librispeech_960/conformer_ctc_train.py b/users/gaudino/experiments/rf_conformer_rnnt_2024/librispeech_960/conformer_ctc_train.py index 4b08a9e96..53e2e77ee 100644 --- a/users/gaudino/experiments/rf_conformer_rnnt_2024/librispeech_960/conformer_ctc_train.py +++ b/users/gaudino/experiments/rf_conformer_rnnt_2024/librispeech_960/conformer_ctc_train.py @@ -160,7 +160,7 @@ def sis_run_with_prefix(prefix_name: Optional[str] = None): }, ) - train_exp( # dev-other + train_exp( # dev-other 7.17 "base-24gb-lrlin1e_5_600k_ctc_only_aux4_8_no_mel_norm", config_24gb_v6, config_updates={ diff --git a/users/gaudino/experiments/rf_conformer_rnnt_2024/tedlium2/conformer_ctc_train.py b/users/gaudino/experiments/rf_conformer_rnnt_2024/tedlium2/conformer_ctc_train.py index 3fd2c0362..e82d2cef9 100644 --- a/users/gaudino/experiments/rf_conformer_rnnt_2024/tedlium2/conformer_ctc_train.py +++ b/users/gaudino/experiments/rf_conformer_rnnt_2024/tedlium2/conformer_ctc_train.py @@ -370,70 +370,225 @@ def sis_run_with_prefix(prefix_name: Optional[str] = None): # gpu_mem=11, # ) - train_exp( - "from-scratch-11gb_lrmin1e-5_lrmax1e-3_aux4_8_adjSpec6k_noCurrL", + # train_exp( # does not converge + # "from-scratch-11gb_lrmin1e-5_lrmax1e-3_aux4_8_adjSpec6k_noCurrL", + # ctc_train_config, + # config_updates={ + # "learning_rate": 1.0, + # "dynamic_learning_rate": dyn_lr_piecewise_linear, + # # total steps after 2000 epochs: 982.312 + # "learning_rate_piecewise_steps": [261_000, 522_000, 580_000], # 45% 45 % 10% + # "learning_rate_piecewise_values": [1e-5, 1e-3, 1e-5, 1e-6], + # "aux_loss_layers": [4, 8], + # "specaugment_steps": (5_900, 18_000, 36_000), + # "epoch_wise_filter": { + # # (1, 5): {"max_mean_len": 1000}, # better? + # # older settings: + # # (1, 5): {"max_mean_len": 200}, + # # (6, 10): {"max_mean_len": 500}, + # }, + # }, + # num_epochs=400, + # gpu_mem=11, + # ) + + # train_exp( # does not converge + # "from-scratch-11gb_lrmin8e-5_lrmax8e-4_aux4_8_noSpec_noCurrL", + # ctc_train_config, + # config_updates={ + # "learning_rate": 1.0, + # "dynamic_learning_rate": dyn_lr_piecewise_linear, + # # total steps after 2000 epochs: 982.312 + # "learning_rate_piecewise_steps": [261_000, 522_000, 580_000], # 45% 45 % 10% + # "learning_rate_piecewise_values": [8e-5, 8e-4, 8e-5, 1e-6], + # "aux_loss_layers": [4, 8], + # "use_specaugment": False, + # "epoch_wise_filter": { + # # (1, 5): {"max_mean_len": 1000}, # better? + # # older settings: + # # (1, 5): {"max_mean_len": 200}, + # # (6, 10): {"max_mean_len": 500}, + # }, + # }, + # num_epochs=400, + # gpu_mem=11, + # ) + + # train_exp( # does not converge + # "from-scratch-11gb_lrmin1e-5_lrmax1e-3_aux4_8_noSpec_noCurrL", + # ctc_train_config, + # config_updates={ + # "learning_rate": 1.0, + # "dynamic_learning_rate": dyn_lr_piecewise_linear, + # # total steps after 2000 epochs: 982.312 + # "learning_rate_piecewise_steps": [261_000, 522_000, 580_000], # 45% 45 % 10% + # "learning_rate_piecewise_values": [1e-5, 1e-3, 1e-5, 1e-6], + # "aux_loss_layers": [4, 8], + # "use_specaugment": False, + # "epoch_wise_filter": { + # # (1, 5): {"max_mean_len": 1000}, # better? + # # older settings: + # # (1, 5): {"max_mean_len": 200}, + # # (6, 10): {"max_mean_len": 500}, + # }, + # }, + # num_epochs=400, + # gpu_mem=11, + # ) + + # train_exp( # does not converge + # "from-scratch-11gb_lrmin1e-5_lrmax1e-3_aux4_8_noSpec", + # ctc_train_config, + # config_updates={ + # "learning_rate": 1.0, + # "dynamic_learning_rate": dyn_lr_piecewise_linear, + # # total steps after 2000 epochs: 982.312 + # "learning_rate_piecewise_steps": [261_000, 522_000, 580_000], # 45% 45 % 10% + # "learning_rate_piecewise_values": [1e-5, 1e-3, 1e-5, 1e-6], + # "aux_loss_layers": [4, 8], + # "use_specaugment": False, + # }, + # num_epochs=400, + # gpu_mem=11, + # ) + + # train_exp( # does not converge + # "from-scratch-11gb_lrmin1e-5_lrmax1e-3_aux4_8_adjSpec6k_adjCurrL", + # ctc_train_config, + # config_updates={ + # "learning_rate": 1.0, + # "dynamic_learning_rate": dyn_lr_piecewise_linear, + # # total steps after 2000 epochs: 982.312 + # "learning_rate_piecewise_steps": [261_000, 522_000, 580_000], # 45% 45 % 10% + # "learning_rate_piecewise_values": [1e-5, 1e-3, 1e-5, 1e-6], + # "aux_loss_layers": [4, 8], + # "specaugment_steps": (5_900, 18_000, 36_000), + # "epoch_wise_filter": { + # # (1, 5): {"max_mean_len": 1000}, # better? + # # older settings: + # # (1, 5): {"max_mean_len": 200}, + # # (6, 10): {"max_mean_len": 500}, + # (1,2): {"max_mean_len": 400}, + # (2,4): {"max_mean_len": 800}, + # }, + # }, + # num_epochs=400, + # gpu_mem=11, + # ) + + # train_exp( # does not converge + # "from-scratch-11gb_lrmin1e-5_lrmax1e-3_aux4_8_adjSpec6k_accumGrad4", + # ctc_train_config, + # config_updates={ + # "learning_rate": 1.0, + # "dynamic_learning_rate": dyn_lr_piecewise_linear, + # # total steps after 2000 epochs: 982.312 + # "learning_rate_piecewise_steps": [261_000, 522_000, 580_000], # 45% 45 % 10% + # "learning_rate_piecewise_values": [1e-5, 1e-3, 1e-5, 1e-6], + # "aux_loss_layers": [4, 8], + # "specaugment_steps": (5_900, 18_000, 36_000), + # "accum_grad_multiple_step": 4, + # }, + # config_deletes=["learning_rate_warmup_steps", "learning_rate_invsqrt_norm"], + # num_epochs=400, + # gpu_mem=11, + # ) + + # train_exp( # does not converge + # "from-scratch-11gb_lrmax2e-3_aux4_8_adjSpec", + # ctc_train_config, + # config_updates={ + # "learning_rate": 1.0, + # "dynamic_learning_rate": dyn_lr_piecewise_linear, + # # total steps after 2000 epochs: 982.312 + # "learning_rate_piecewise_steps": [261_000, 522_000, 580_000], # 45% 45 % 10% + # "learning_rate_piecewise_values": [2e-4, 2e-3, 2e-4, 1e-6], + # "aux_loss_layers": [4, 8], + # "specaugment_steps": (5_900, 18_000, 36_000), + # }, + # num_epochs=400, + # gpu_mem=11, + # ) + + train_exp( # + "from-scratch-11gb_lrmax8e-4_aux4_8_adjSpec_no_norm_loss", ctc_train_config, config_updates={ "learning_rate": 1.0, "dynamic_learning_rate": dyn_lr_piecewise_linear, # total steps after 2000 epochs: 982.312 "learning_rate_piecewise_steps": [261_000, 522_000, 580_000], # 45% 45 % 10% - "learning_rate_piecewise_values": [1e-5, 1e-3, 1e-5, 1e-6], + "learning_rate_piecewise_values": [8e-5, 8e-4, 8e-5, 1e-6], "aux_loss_layers": [4, 8], "specaugment_steps": (5_900, 18_000, 36_000), - "epoch_wise_filter": { - # (1, 5): {"max_mean_len": 1000}, # better? - # older settings: - # (1, 5): {"max_mean_len": 200}, - # (6, 10): {"max_mean_len": 500}, - }, + "use_normalized_loss": False, }, num_epochs=400, gpu_mem=11, ) - train_exp( - "from-scratch-11gb_lrmin1e-5_lrmax1e-3_aux4_8_adjSpec6k_adjCurrL", + train_exp( # + "from-scratch-11gb_lrmax8e-4_aux4_8_adjSpec_no_norm_loss_no_grad_clip", ctc_train_config, config_updates={ "learning_rate": 1.0, "dynamic_learning_rate": dyn_lr_piecewise_linear, # total steps after 2000 epochs: 982.312 "learning_rate_piecewise_steps": [261_000, 522_000, 580_000], # 45% 45 % 10% - "learning_rate_piecewise_values": [1e-5, 1e-3, 1e-5, 1e-6], + "learning_rate_piecewise_values": [8e-5, 8e-4, 8e-5, 1e-6], "aux_loss_layers": [4, 8], "specaugment_steps": (5_900, 18_000, 36_000), - "epoch_wise_filter": { - # (1, 5): {"max_mean_len": 1000}, # better? - # older settings: - # (1, 5): {"max_mean_len": 200}, - # (6, 10): {"max_mean_len": 500}, - (1,2): {"max_mean_len": 400}, - (2,4): {"max_mean_len": 800}, - }, + "use_normalized_loss": False, }, + config_deletes=["learning_rate_warmup_steps", "learning_rate_invsqrt_norm", "gradient_clip_global_norm"], num_epochs=400, gpu_mem=11, ) - train_exp( - "from-scratch-11gb_lrmin1e-5_lrmax1e-3_aux4_8_adjSpec6k_accumGrad4", + train_exp( # + "from-scratch-11gb_lrmax8e-4_aux4_8_adjSpe_eps2e-8", ctc_train_config, config_updates={ "learning_rate": 1.0, "dynamic_learning_rate": dyn_lr_piecewise_linear, # total steps after 2000 epochs: 982.312 "learning_rate_piecewise_steps": [261_000, 522_000, 580_000], # 45% 45 % 10% - "learning_rate_piecewise_values": [1e-5, 1e-3, 1e-5, 1e-6], + "learning_rate_piecewise_values": [8e-5, 8e-4, 8e-5, 1e-6], "aux_loss_layers": [4, 8], "specaugment_steps": (5_900, 18_000, 36_000), - "accum_grad_multiple_step": 4, + "optimizer": { + "class": "adamw", + "epsilon": 2e-8, + "weight_decay": 1e-6, + }, }, - config_deletes=["learning_rate_warmup_steps", "learning_rate_invsqrt_norm"], num_epochs=400, gpu_mem=11, ) + train_exp( # + "from-scratch-11gb_lrmax8e-4_aux4_8_adjSpe_adam", + ctc_train_config, + config_updates={ + "learning_rate": 1.0, + "dynamic_learning_rate": dyn_lr_piecewise_linear, + # total steps after 2000 epochs: 982.312 + "learning_rate_piecewise_steps": [261_000, 522_000, 580_000], # 45% 45 % 10% + "learning_rate_piecewise_values": [8e-5, 8e-4, 8e-5, 1e-6], + "aux_loss_layers": [4, 8], + "specaugment_steps": (5_900, 18_000, 36_000), + "optimizer": { + "class": "adam", + "epsilon": 1e-8, + "weight_decay": 1e-6, + }, + }, + num_epochs=400, + gpu_mem=11, + ) + + + _sis_prefix: Optional[str] = None diff --git a/users/gaudino/experiments/rf_conformer_rnnt_2024/tedlium2/conformer_rnnt_train.py b/users/gaudino/experiments/rf_conformer_rnnt_2024/tedlium2/conformer_rnnt_train.py index beae49311..4a669a70b 100644 --- a/users/gaudino/experiments/rf_conformer_rnnt_2024/tedlium2/conformer_rnnt_train.py +++ b/users/gaudino/experiments/rf_conformer_rnnt_2024/tedlium2/conformer_rnnt_train.py @@ -56,7 +56,8 @@ def sis_run_with_prefix(prefix_name: Optional[str] = None): batch_size=15_000 * _batch_size_factor, max_seqs=200, # max_seq_length_default_target=75, - specaugment_steps=(10_000, 20_000, 40_000), + # specaugment_steps=(10_000, 20_000, 40_000), + specaugment_steps=(5_900, 18_000, 36_000), # gradient_clip=0, # gradient_clip_global_norm = 1.0 optimizer={ @@ -67,12 +68,12 @@ def sis_run_with_prefix(prefix_name: Optional[str] = None): # accum_grad_multiple_step=4, # gradient_noise=0.0, learning_rate=2.5e-3, - dynamic_learning_rate=dyn_lr_lin_warmup_invsqrt_decay, - learning_rate_warmup_steps=40_000, - learning_rate_invsqrt_norm=40_000, + dynamic_learning_rate=dyn_lr_piecewise_linear, + # learning_rate_piecewise_steps= [261_000, 522_000, 580_000], # 45% 45 % 10% # 11gb + learning_rate_piecewise_steps = [85_500, 171_000, 190_000], # 45% 45 % 10% # 24gb # aux_loss_layers=[4, 8], max_seq_length_default_target=None, - gradient_clip_global_norm=5.0, + # gradient_clip_global_norm=5.0, accum_grad_multiple_step=2, # aux_loss_layers=[12], ) @@ -80,39 +81,33 @@ def sis_run_with_prefix(prefix_name: Optional[str] = None): # train_exp("base-11gb", config_11gb, gpu_mem=11) # train_exp("base-11gb-v1", my_config_11gb, num_epochs=400, gpu_mem=11) train_exp( # - "from-scratch-11gb", + "from-scratch-24gb", rnnt_train_config, config_updates={ "learning_rate": 1.0, - "dynamic_learning_rate": dyn_lr_piecewise_linear, - # total steps after 2000 epochs: 982.312 - # "learning_rate_piecewise_steps": [600_000, 900_000, 982_000], - # "learning_rate_piecewise_values": [1e-5, 1e-3, 1e-5, 1e-6], - "learning_rate_piecewise_steps": [261_000, 522_000, 580_000], # 45% 45 % 10% - "learning_rate_piecewise_values": [1e-5, 1e-3, 1e-5, 1e-6], + "learning_rate_piecewise_values": [8e-5, 8e-4, 8e-5, 1e-6], }, - config_deletes=["learning_rate_warmup_steps", "learning_rate_invsqrt_norm"], - num_epochs=400, - gpu_mem=11, - ) - - train_exp( # does not converge - "from-scratch-11gb", - rnnt_train_config, - config_updates={ - "learning_rate": 1.0, - "dynamic_learning_rate": dyn_lr_piecewise_linear, - # total steps after 2000 epochs: 982.312 - # "learning_rate_piecewise_steps": [600_000, 900_000, 982_000], - # "learning_rate_piecewise_values": [1e-5, 1e-3, 1e-5, 1e-6], - "learning_rate_piecewise_steps": [261_000, 522_000, 580_000], # 45% 45 % 10% - "learning_rate_piecewise_values": [1e-5, 1e-3, 1e-5, 1e-6], - }, - config_deletes=["learning_rate_warmup_steps", "learning_rate_invsqrt_norm"], num_epochs=400, gpu_mem=24, ) + # train_exp( # does not converge (wrong steps + more mistakes) + # "from-scratch-11gb", + # rnnt_train_config, + # config_updates={ + # "learning_rate": 1.0, + # "dynamic_learning_rate": dyn_lr_piecewise_linear, + # # total steps after 2000 epochs: 982.312 + # # "learning_rate_piecewise_steps": [600_000, 900_000, 982_000], + # # "learning_rate_piecewise_values": [1e-5, 1e-3, 1e-5, 1e-6], + # "learning_rate_piecewise_steps": [261_000, 522_000, 580_000], # 45% 45 % 10% + # "learning_rate_piecewise_values": [1e-5, 1e-3, 1e-5, 1e-6], + # }, + # config_deletes=["learning_rate_warmup_steps", "learning_rate_invsqrt_norm"], + # num_epochs=400, + # gpu_mem=24, + # ) + _sis_prefix: Optional[str] = None diff --git a/users/gaudino/models/asr/rf/conformer_ctc/model_conformer_ctc.py b/users/gaudino/models/asr/rf/conformer_ctc/model_conformer_ctc.py index 21b5fac95..f32fc88dd 100644 --- a/users/gaudino/models/asr/rf/conformer_ctc/model_conformer_ctc.py +++ b/users/gaudino/models/asr/rf/conformer_ctc/model_conformer_ctc.py @@ -150,6 +150,7 @@ def __init__( config = get_global_config(return_empty_if_none=True) self.mel_normalization = config.typed_value("mel_normalization_ted2", True) + self.use_specaugment = config.typed_value("use_specaugment", True) self.in_dim = in_dim self.encoder = ConformerEncoder( @@ -288,13 +289,14 @@ def encode( if self._mixup: source = self._mixup(source, spatial_dim=in_spatial_dim) - # SpecAugment - source = rf.audio.specaugment( - source, - spatial_dim=in_spatial_dim, - feature_dim=self.in_dim, - **self._specaugment_opts, - ) + if self.use_specaugment: + # SpecAugment + source = rf.audio.specaugment( + source, + spatial_dim=in_spatial_dim, + feature_dim=self.in_dim, + **self._specaugment_opts, + ) # Encoder including convolutional frontend with _opt_apply_pretrain_to_encoder( self.encoder, collected_outputs, self._pretrain_opts diff --git a/users/gaudino/models/asr/rf/conformer_rnnt/model_recog_rnnt.py b/users/gaudino/models/asr/rf/conformer_rnnt/model_recog_rnnt.py index afd6c3eb8..5525e4369 100644 --- a/users/gaudino/models/asr/rf/conformer_rnnt/model_recog_rnnt.py +++ b/users/gaudino/models/asr/rf/conformer_rnnt/model_recog_rnnt.py @@ -24,6 +24,74 @@ from i6_experiments.users.gaudino.experiments.rf_conformer_att_2023.librispeech_960.trafo_lm import trafo_lm_kazuki_import + +Hypothesis = Tuple[List[int], Tensor, rf.State, float] +Hypothesis.__doc__ = """Hypothesis generated by RNN-T beam search decoder, + represented as tuple of (tokens, prediction network output, prediction network state, score). + """ + + +def _get_hypo_tokens(hypo: Hypothesis) -> List[int]: + return hypo[0] + + +def _get_hypo_predictor_out(hypo: Hypothesis) -> torch.Tensor: + return hypo[1] + + +def _get_hypo_state(hypo: Hypothesis) -> List[List[torch.Tensor]]: + return hypo[2] + + +def _get_hypo_score(hypo: Hypothesis) -> float: + return hypo[3] + + +def _get_hypo_key(hypo: Hypothesis) -> str: + return str(hypo[0]) + + +def _batch_state(hypos: List[Hypothesis]) -> List[List[torch.Tensor]]: # TODO + states: List[List[torch.Tensor]] = [] + for i in range(len(_get_hypo_state(hypos[0]))): + batched_state_components: List[torch.Tensor] = [] + for j in range(len(_get_hypo_state(hypos[0])[i])): + batched_state_components.append(torch.cat([_get_hypo_state(hypo)[i][j] for hypo in hypos])) + states.append(batched_state_components) + return states + + +def _slice_state(states: List[List[torch.Tensor]], idx: int, device: torch.device) -> List[List[torch.Tensor]]: # TODO + idx_tensor = torch.tensor([idx], device=device) + return [[state.index_select(0, idx_tensor) for state in state_tuple] for state_tuple in states] + + +def _default_hypo_sort_key(hypo: Hypothesis) -> float: + return _get_hypo_score(hypo) / (len(_get_hypo_tokens(hypo)) + 1) # is this doing length normalization ? + + +def _compute_updated_scores( + hypos: List[Hypothesis], + next_token_probs: Tensor, + beam_width: int, +) -> Tuple[Tensor, Tensor, Tensor]: # TODO + hypo_scores = torch.tensor([_get_hypo_score(h) for h in hypos]).unsqueeze(1) + nonblank_scores = hypo_scores + next_token_probs[:, :-1] # [beam_width, num_tokens - 1] + nonblank_nbest_scores, nonblank_nbest_idx = nonblank_scores.reshape(-1).topk(beam_width) + nonblank_nbest_hypo_idx = nonblank_nbest_idx.div(nonblank_scores.shape[1], rounding_mode="trunc") + nonblank_nbest_token = nonblank_nbest_idx % nonblank_scores.shape[1] + return nonblank_nbest_scores, nonblank_nbest_hypo_idx, nonblank_nbest_token + + +def _remove_hypo(hypo: Hypothesis, hypo_list: List[Hypothesis]) -> None: # TODO + for i, elem in enumerate(hypo_list): + if _get_hypo_key(hypo) == _get_hypo_key(elem): + del hypo_list[i] + break + + + + def model_recog( *, model: Model, @@ -70,6 +138,166 @@ def model_recog( out_seq_len = rf.constant(0, dims=batch_dims_) seq_log_prob = rf.constant(0.0, dims=batch_dims_) + + # TODO implement rnnt search + temperature = 1.0 + step_max_tokens = 100 + + def _init_b_hypos(self, device: torch.device) -> List[Hypothesis]: + token = self.blank + state = None + + one_tensor = torch.tensor([1], device=device) + pred_out, _, pred_state = model.predict(torch.tensor([[token]], device=device), one_tensor, state) + init_hypo = ( + [token], + pred_out[0].detach(), + pred_state, + 0.0, + ) + return [init_hypo] + + def _gen_next_token_probs( + self, enc_out: torch.Tensor, hypos: List[Hypothesis], device: torch.device + ) -> torch.Tensor: + one_tensor = torch.tensor([1], device=device) + predictor_out = torch.stack([_get_hypo_predictor_out(h) for h in hypos], dim=0) + joined_out, _, _ = model.join( + enc_out, + one_tensor, + predictor_out, + torch.tensor([1] * len(hypos), device=device), + ) # [beam_width, 1, 1, num_tokens] + joined_out = torch.nn.functional.log_softmax(joined_out / self.temperature, dim=3) + return joined_out[:, 0, 0] + + def _gen_b_hypos( + self, + b_hypos: List[Hypothesis], + a_hypos: List[Hypothesis], + next_token_probs: torch.Tensor, + key_to_b_hypo: Dict[str, Hypothesis], + ) -> List[Hypothesis]: + for i in range(len(a_hypos)): + h_a = a_hypos[i] + append_blank_score = _get_hypo_score(h_a) + next_token_probs[i, -1] + if _get_hypo_key(h_a) in key_to_b_hypo: + h_b = key_to_b_hypo[_get_hypo_key(h_a)] + _remove_hypo(h_b, b_hypos) + score = float(torch.tensor(_get_hypo_score(h_b)).logaddexp(append_blank_score)) + else: + score = float(append_blank_score) + h_b = ( + _get_hypo_tokens(h_a), + _get_hypo_predictor_out(h_a), + _get_hypo_state(h_a), + score, + ) + b_hypos.append(h_b) + key_to_b_hypo[_get_hypo_key(h_b)] = h_b + _, sorted_idx = torch.tensor([_get_hypo_score(hypo) for hypo in b_hypos]).sort() + return [b_hypos[idx] for idx in sorted_idx] + + def _gen_a_hypos( + self, + a_hypos: List[Hypothesis], + b_hypos: List[Hypothesis], + next_token_probs: torch.Tensor, + t: int, + beam_width: int, + device: torch.device, + ) -> List[Hypothesis]: + ( + nonblank_nbest_scores, + nonblank_nbest_hypo_idx, + nonblank_nbest_token, + ) = _compute_updated_scores(a_hypos, next_token_probs, beam_width) + + if len(b_hypos) < beam_width: + b_nbest_score = -float("inf") + else: + b_nbest_score = _get_hypo_score(b_hypos[-beam_width]) + + base_hypos: List[Hypothesis] = [] + new_tokens: List[int] = [] + new_scores: List[float] = [] + for i in range(beam_width): + score = float(nonblank_nbest_scores[i]) + if score > b_nbest_score: + a_hypo_idx = int(nonblank_nbest_hypo_idx[i]) + base_hypos.append(a_hypos[a_hypo_idx]) + new_tokens.append(int(nonblank_nbest_token[i])) + new_scores.append(score) + + if base_hypos: + new_hypos = self._gen_new_hypos(base_hypos, new_tokens, new_scores, t, device) + else: + new_hypos: List[Hypothesis] = [] + + return new_hypos + + def _gen_new_hypos( + self, + base_hypos: List[Hypothesis], + tokens: List[int], + scores: List[float], + t: int, + device: torch.device, + ) -> List[Hypothesis]: + tgt_tokens = torch.tensor([[token] for token in tokens], device=device) + states = _batch_state(base_hypos) + pred_out, _, pred_states = self.model.predict( + tgt_tokens, + torch.tensor([1] * len(base_hypos), device=device), + states, + ) + new_hypos: List[Hypothesis] = [] + for i, h_a in enumerate(base_hypos): + new_tokens = _get_hypo_tokens(h_a) + [tokens[i]] + new_hypos.append((new_tokens, pred_out[i].detach(), _slice_state(pred_states, i, device), scores[i])) + return new_hypos + + # from _search function + n_time_steps = enc_out.shape[1] + device = enc_out.device + + a_hypos: List[Hypothesis] = [] + b_hypos = self._init_b_hypos(device) if hypo is None else hypo + for t in range(n_time_steps): + a_hypos = b_hypos + b_hypos = torch.jit.annotate(List[Hypothesis], []) + key_to_b_hypo: Dict[str, Hypothesis] = {} + symbols_current_t = 0 + + while a_hypos: + next_token_probs = self._gen_next_token_probs(enc_out[:, t: t + 1], a_hypos, device) + next_token_probs = next_token_probs.cpu() + b_hypos = self._gen_b_hypos(b_hypos, a_hypos, next_token_probs, key_to_b_hypo) + + if symbols_current_t == self.step_max_tokens: + break + + a_hypos = self._gen_a_hypos( + a_hypos, + b_hypos, + next_token_probs, + t, + beam_width, + device, + ) + if a_hypos: + symbols_current_t += 1 + + _, sorted_idx = torch.tensor([self.hypo_sort_key(hyp) for hyp in b_hypos]).topk(beam_width) + b_hypos = [b_hypos[idx] for idx in sorted_idx] + + # return b_hypos + # results is in b_hypoes + # TODO: extract results + + return seq_targets, seq_log_prob, out_spatial_dim, beam_dim + + # old search code i = 0 seq_targets = [] seq_backrefs = [] @@ -90,8 +318,6 @@ def model_recog( # logits = model.decode_logits(input_embed=input_embed, **step_out) label_log_prob = rf.log_softmax(step_out["output"], axis=model.target_dim) - # TODO: implement rnnt search - breakpoint() # Filter out finished beams label_log_prob = rf.where( ended, @@ -166,634 +392,344 @@ def model_recog( model_recog.batch_size_dependent = False -def model_recog_pure_torch( - *, - model: Model, - data: Tensor, - data_spatial_dim: Dim, - targets: Optional[Tensor] = None, - targets_spatial_dim: Optional[Dim] = None, - max_seq_len: Optional[int] = None, -) -> Tuple[Tensor, Tensor, Dict[str, Tensor], Dim, Dim]: - """ - Function is run within RETURNN. +### Copied from torchaudio +# TODO: Adapt to rf +from typing import Callable, Dict, List, Optional, Tuple - Earlier we used the generic beam_search function, - but now we just directly perform the search here, - as this is overall simpler and shorter. +import torch +from torchaudio.models import RNNT - :return: - recog results including beam {batch, beam, out_spatial}, - log probs {batch, beam}, - recog results info: key -> {batch, beam}, - out_spatial_dim, - final beam_dim + +__all__ = ["Hypothesis", "RNNTBeamSearch"] + + +Hypothesis = Tuple[List[int], torch.Tensor, List[List[torch.Tensor]], float] +Hypothesis.__doc__ = """Hypothesis generated by RNN-T beam search decoder, + represented as tuple of (tokens, prediction network output, prediction network state, score). """ - import torch - import time - from i6_experiments.users.zeyer.decoding.beam_search_torch.beam_search_v5 import ( - BeamSearchOptsV5, - beam_search_v5, - ) - from i6_experiments.users.zeyer.decoding.beam_search_torch.beam_search_sep_ended import ( - BeamSearchDynBeamOpts, - beam_search_sep_ended, - ) - from i6_experiments.users.zeyer.decoding.beam_search_torch.beam_search_sep_ended_keep_v6 import ( - BeamSearchSepEndedKeepOpts, - beam_search_sep_ended_keep_v6, - ) - from i6_experiments.users.zeyer.decoding.beam_search_torch.scorers.length_reward import ( - LengthRewardScorer, - ) - from i6_experiments.users.zeyer.decoding.beam_search_torch.scorers.shallow_fusion import ( - ShallowFusedLabelScorers, - ) - from returnn.config import get_global_config - config = get_global_config() - torch.cuda.set_sync_debug_mode( - 1 - ) # debug CUDA sync. does not hurt too much to leave this always in? - start_time = time.perf_counter_ns() +def _get_hypo_tokens(hypo: Hypothesis) -> List[int]: + return hypo[0] - data_concat_zeros = config.float("data_concat_zeros", 0) - if data_concat_zeros: - data_concat_zeros_dim = Dim( - int(data_concat_zeros * _batch_size_factor * 100), name="data_concat_zeros" - ) - data, data_spatial_dim = rf.concat( - (data, data_spatial_dim), - (rf.zeros([data_concat_zeros_dim]), data_concat_zeros_dim), - allow_broadcast=True, - ) - batch_dims = data.remaining_dims((data_spatial_dim, data.feature_dim)) - assert ( - len(batch_dims) == 1 - ), batch_dims # not implemented otherwise, simple to add... - batch_dim = batch_dims[0] - enc, enc_spatial_dim = model.encode(data, in_spatial_dim=data_spatial_dim) - if max_seq_len is None: - max_seq_len = enc_spatial_dim.get_size_tensor() - else: - max_seq_len = rf.convert_to_tensor(max_seq_len, dtype="int32") +def _get_hypo_predictor_out(hypo: Hypothesis) -> torch.Tensor: + return hypo[1] - if data.raw_tensor.device.type == "cuda": - # Just so that timing of encoder is correct. - torch.cuda.synchronize(data.raw_tensor.device) - - enc_end_time = time.perf_counter_ns() - - beam_search_version = config.typed_value("beam_search_version", 1) - beam_search_func = { - 5: beam_search_v5, - "sep_ended": beam_search_sep_ended, - "sep_ended_keep_v6": beam_search_sep_ended_keep_v6, - }[beam_search_version] - if beam_search_version == "sep_ended": - beam_search_opts_cls = BeamSearchDynBeamOpts - elif isinstance(beam_search_version, str) and beam_search_version.startswith( - "sep_ended_keep" - ): - beam_search_opts_cls = BeamSearchSepEndedKeepOpts - elif isinstance(beam_search_version, int) and beam_search_version >= 5: - beam_search_opts_cls = BeamSearchOptsV5 - else: - raise ValueError(f"unexpected {beam_search_version=}") - beam_search_opts = (config.typed_value("beam_search_opts", None) or {}).copy() - if beam_search_opts.get("beam_size") is None: - beam_search_opts["beam_size"] = config.int("beam_size", 12) - if beam_search_opts.get("length_normalization_exponent") is None: - beam_search_opts["length_normalization_exponent"] = config.float( - "length_normalization_exponent", 1.0 - ) - if beam_search_opts.get("length_reward") is None: - beam_search_opts["length_reward"] = config.float("length_reward", 0.0) - extra = {} - out_individual_seq_scores = None - if config.bool("beam_search_collect_individual_seq_scores", False): - out_individual_seq_scores = {} - extra["out_individual_seq_scores"] = out_individual_seq_scores - cheating = config.bool("cheating", False) - if cheating: - assert targets and targets_spatial_dim - extra["cheating_targets"] = targets.copy_compatible_to_dims_raw( - [batch_dim, targets_spatial_dim] - ) - extra[ - "cheating_targets_seq_len" - ] = targets_spatial_dim.dyn_size_ext.copy_compatible_to_dims_raw([batch_dim]) - coverage_scale = beam_search_opts.pop("attention_coverage_scale", 0.0) - coverage_opts = beam_search_opts.pop("attention_coverage_opts", {}) - neg_coverage_scale = beam_search_opts.pop("neg_attention_coverage_scale", 0.0) - neg_coverage_opts = beam_search_opts.pop("neg_attention_coverage_opts", {}) - monotonicity_scale = beam_search_opts.pop("attention_monotonicity_scale", 0.0) - monotonicity_opts = beam_search_opts.pop("attention_monotonicity_opts", {}) - max_seq_len_factor = beam_search_opts.pop("max_seq_len_factor", 1) - if max_seq_len_factor != 1: - max_seq_len = rf.cast(max_seq_len * max_seq_len_factor, max_seq_len.dtype) - label_scorer = ShallowFusedLabelScorers() - if coverage_scale or neg_coverage_scale or cheating: - label_scorer.label_scorers.update( - get_label_scorer_and_coverage_scorer_pure_torch( - model=model, - batch_dim=batch_dim, - enc=enc, - enc_spatial_dim=enc_spatial_dim, - coverage_opts=coverage_opts, - coverage_scale=coverage_scale, - neg_coverage_scale=neg_coverage_scale, - neg_coverage_opts=neg_coverage_opts, - monotonicity_scale=monotonicity_scale, - monotonicity_opts=monotonicity_opts, - always_add_scorers=cheating, - ) - ) - else: - label_scorer.label_scorers["decoder"] = ( - get_label_scorer_pure_torch( - model=model, - batch_dim=batch_dim, - enc=enc, - enc_spatial_dim=enc_spatial_dim, - ), - 1.0, - ) - if isinstance(beam_search_version, str) or beam_search_version >= 5: - len_reward = beam_search_opts.pop("length_reward", 0.0) - if len_reward or cheating: - label_scorer.label_scorers["length_reward"] = ( - LengthRewardScorer(), - len_reward, - ) - if model.language_model: - lm_scale = beam_search_opts.pop("lm_scale") # must be defined with LM - label_scorer.label_scorers["lm"] = ( - model.language_model_make_label_scorer(), - lm_scale, - ) - print("** max seq len:", max_seq_len.raw_tensor) +def _get_hypo_state(hypo: Hypothesis) -> List[List[torch.Tensor]]: + return hypo[2] - # Beam search happening here: - ( - seq_targets, # [Batch,FinalBeam,OutSeqLen] - seq_log_prob, # [Batch,FinalBeam] - out_seq_len, # [Batch,FinalBeam] - ) = beam_search_func( - label_scorer, - batch_size=int(batch_dim.get_dim_value()), - max_seq_len=max_seq_len.copy_compatible_to_dims_raw([batch_dim]), - device=data.raw_tensor.device, - opts=beam_search_opts_cls( - **beam_search_opts, - bos_label=model.bos_idx, - eos_label=model.eos_idx, - num_labels=model.target_dim.dimension, - ), - **extra, - ) - beam_dim = Dim(seq_log_prob.shape[1], name="beam") - out_spatial_dim = Dim( - rf.convert_to_tensor( - out_seq_len, dims=[batch_dim, beam_dim], name="out_spatial" - ) - ) - seq_targets_t = rf.convert_to_tensor( - seq_targets, - dims=[batch_dim, beam_dim, out_spatial_dim], - sparse_dim=model.target_dim, - ) - seq_log_prob_t = rf.convert_to_tensor(seq_log_prob, dims=[batch_dim, beam_dim]) +def _get_hypo_score(hypo: Hypothesis) -> float: + return hypo[3] - search_end_time = time.perf_counter_ns() - data_seq_len_sum = rf.reduce_sum( - data_spatial_dim.dyn_size_ext, axis=data_spatial_dim.dyn_size_ext.dims - ) - data_seq_len_sum_secs = data_seq_len_sum.raw_tensor / _batch_size_factor / 100.0 - data_seq_len_max_seqs = ( - data_spatial_dim.get_dim_value() / _batch_size_factor / 100.0 - ) - out_len_longest_sum = rf.reduce_sum( - rf.reduce_max(out_spatial_dim.dyn_size_ext, axis=beam_dim), axis=batch_dim - ) - print( - "TIMINGS:", - ", ".join( - ( - f"batch size {data.get_batch_dim_tag().get_dim_value()}", - f"data len max {data_spatial_dim.get_dim_value()} ({data_seq_len_max_seqs:.2f} secs)", - f"data len sum {data_seq_len_sum.raw_tensor} ({data_seq_len_sum_secs:.2f} secs)", - f"enc {enc_end_time - start_time} ns", - f"enc len max {enc_spatial_dim.get_dim_value()}", - f"dec {search_end_time - enc_end_time} ns", - f"out len max {out_spatial_dim.get_dim_value()}", - f"out len longest sum {out_len_longest_sum.raw_tensor}", - ) - ), - ) - extra_recog_results = {} - if out_individual_seq_scores: - for k, v in out_individual_seq_scores.items(): - extra_recog_results[f"score:{k}"] = rf.convert_to_tensor( - v.expand(batch_dim.get_dim_value(), beam_dim.get_dim_value()), - dims=[batch_dim, beam_dim], - ) +def _get_hypo_key(hypo: Hypothesis) -> str: + return str(hypo[0]) - return seq_targets_t, seq_log_prob_t, extra_recog_results, out_spatial_dim, beam_dim +def _batch_state(hypos: List[Hypothesis]) -> List[List[torch.Tensor]]: + states: List[List[torch.Tensor]] = [] + for i in range(len(_get_hypo_state(hypos[0]))): + batched_state_components: List[torch.Tensor] = [] + for j in range(len(_get_hypo_state(hypos[0])[i])): + batched_state_components.append(torch.cat([_get_hypo_state(hypo)[i][j] for hypo in hypos])) + states.append(batched_state_components) + return states -def get_label_scorer_pure_torch( - *, - model: Model, - batch_dim: Dim, - enc: Dict[str, Tensor], - enc_spatial_dim: Dim, -): - import torch - import functools - from i6_experiments.users.zeyer.decoding.beam_search_torch.interface import ( - LabelScorerIntf, - StateObjTensorExt, - StateObjIgnored, - ) - class LabelScorer(LabelScorerIntf): - """label scorer""" +def _slice_state(states: List[List[torch.Tensor]], idx: int, device: torch.device) -> List[List[torch.Tensor]]: + idx_tensor = torch.tensor([idx], device=device) + return [[state.index_select(0, idx_tensor) for state in state_tuple] for state_tuple in states] - def get_initial_state(self, *, batch_size: int, device: torch.device) -> Any: - """Initial state.""" - beam_dim = Dim(1, name="initial-beam") - batch_dims_ = [batch_dim, beam_dim] - decoder_state = model.decoder_default_initial_state( - batch_dims=batch_dims_, enc_spatial_dim=enc_spatial_dim - ) - return tree.map_structure( - functools.partial(self._map_tensor_to_raw, beam_dim=beam_dim), - decoder_state, - ) - def max_remaining_seq_score( - self, *, state: Any, max_remaining_steps: torch.Tensor, device: torch.device - ) -> torch.Tensor: - """max remaining""" - return torch.zeros((1, 1), device=device) - - def score_and_update_state( - self, - *, - prev_state: Any, - prev_label: torch.Tensor, - ) -> Tuple[torch.Tensor, Any]: - """update state""" - beam_dim = Dim(prev_label.shape[1], name="beam") - - def _map_raw_to_tensor(v): - if isinstance(v, StateObjTensorExt): - tensor: Tensor = v.extra - tensor = tensor.copy_template_new_dim_tags( - (batch_dim, beam_dim) + tensor.dims[2:], keep_special_axes=True - ) - tensor.raw_tensor = v.tensor - return tensor - elif isinstance(v, StateObjIgnored): - return v.content - else: - raise TypeError( - f"_map_raw_to_tensor: unexpected {v} ({type(v).__name__})" - ) - - input_embed = model.target_embed( - rf.convert_to_tensor( - prev_label, dims=[batch_dim, beam_dim], sparse_dim=model.target_dim - ) - ) - decode_out, decoder_state = model.loop_step( - **enc, - enc_spatial_dim=enc_spatial_dim, - input_embed=input_embed, - state=tree.map_structure(_map_raw_to_tensor, prev_state), - ) - logits = model.decode_logits(input_embed=input_embed, **decode_out) - label_log_prob = rf.log_softmax(logits, axis=model.target_dim) - assert set(label_log_prob.dims) == {batch_dim, beam_dim, model.target_dim} - - return ( - self._map_tensor_to_raw(label_log_prob, beam_dim=beam_dim).tensor, - tree.map_structure( - functools.partial(self._map_tensor_to_raw, beam_dim=beam_dim), - decoder_state, - ), - ) +def _default_hypo_sort_key(hypo: Hypothesis) -> float: + return _get_hypo_score(hypo) / (len(_get_hypo_tokens(hypo)) + 1) - @staticmethod - def _map_tensor_to_raw(v, *, beam_dim: Dim): - if isinstance(v, Tensor): - if beam_dim not in v.dims: - return StateObjIgnored(v) - batch_dims_ = [batch_dim, beam_dim] - v = v.copy_transpose( - batch_dims_ + [dim for dim in v.dims if dim not in batch_dims_] - ) - raw = v.raw_tensor - return StateObjTensorExt(raw, v.copy_template()) - elif isinstance(v, Dim): - return StateObjIgnored(v) - else: - raise TypeError( - f"_map_tensor_to_raw: unexpected {v} ({type(v).__name__})" - ) - return LabelScorer() +def _compute_updated_scores( + hypos: List[Hypothesis], + next_token_probs: torch.Tensor, + beam_width: int, +) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]: + hypo_scores = torch.tensor([_get_hypo_score(h) for h in hypos]).unsqueeze(1) + nonblank_scores = hypo_scores + next_token_probs[:, :-1] # [beam_width, num_tokens - 1] + nonblank_nbest_scores, nonblank_nbest_idx = nonblank_scores.reshape(-1).topk(beam_width) + nonblank_nbest_hypo_idx = nonblank_nbest_idx.div(nonblank_scores.shape[1], rounding_mode="trunc") + nonblank_nbest_token = nonblank_nbest_idx % nonblank_scores.shape[1] + return nonblank_nbest_scores, nonblank_nbest_hypo_idx, nonblank_nbest_token -# RecogDef API -model_recog_pure_torch: RecogDef[Model] -model_recog_pure_torch.output_with_beam = True -model_recog_pure_torch.output_blank_label = None -model_recog_pure_torch.batch_size_dependent = False +def _remove_hypo(hypo: Hypothesis, hypo_list: List[Hypothesis]) -> None: + for i, elem in enumerate(hypo_list): + if _get_hypo_key(hypo) == _get_hypo_key(elem): + del hypo_list[i] + break -def get_label_scorer_and_coverage_scorer_pure_torch( - *, - model: Model, - batch_dim: Dim, - enc: Dict[str, Tensor], - enc_spatial_dim: Dim, - coverage_scale: float = 0.0, - coverage_opts: Optional[Dict[str, Any]] = None, - neg_coverage_scale: float = 0.0, - neg_coverage_opts: Optional[Dict[str, Any]] = None, - monotonicity_scale: float = 0.0, - monotonicity_opts: Optional[Dict[str, Any]] = None, - always_add_scorers: bool = False, -): - import torch - import functools - from returnn.frontend.decoder.transformer import TransformerDecoderLayer - from i6_experiments.users.zeyer.decoding.beam_search_torch.interface import ( - LabelScorerIntf, - StateObjTensorExt, - StateObjIgnored, - ) +class RNNTBeamSearch(torch.nn.Module): + r"""Beam search decoder for RNN-T model. - accum_att_weights = rf.zeros(()) # [Batch,Beam,kv_axis] - att_weights_dec_frame: Tensor # [Batch,Beam,kv_axis] - beam_dim: Dim - - raise NotImplementedError("need more work here") # TODO... - - model_att_reduce_type = coverage_opts.get("model_att_reduce_type", "max") - - def hooked_cross_att( - self: rf.CrossAttention, q: Tensor, k: Tensor, v: Tensor, *, kv_axis: Dim - ) -> Tensor: - """apply attention""" - nonlocal att_weights_dec_frame - # Standard dot attention, inline rf.dot_attention. - q *= self.key_dim_per_head.dimension**-0.5 - energy = rf.matmul(q, k, reduce=self.key_dim_per_head) - att_weights = rf.softmax(energy, axis=kv_axis) - if model_att_reduce_type == "max": - att_weights_dec_frame = rf.maximum( - att_weights_dec_frame, rf.reduce_max(att_weights, axis=self.num_heads) - ) - elif model_att_reduce_type == "avg": - att_weights_dec_frame += rf.reduce_mean( - att_weights, axis=self.num_heads - ) * (1 / len(model.decoder.layers)) + See Also: + * :class:`torchaudio.pipelines.RNNTBundle`: ASR pipeline with pretrained model. + + Args: + model (RNNT): RNN-T model to use. + blank (int): index of blank token in vocabulary. + temperature (float, optional): temperature to apply to joint network output. + Larger values yield more uniform samples. (Default: 1.0) + hypo_sort_key (Callable[[Hypothesis], float] or None, optional): callable that computes a score + for a given hypothesis to rank hypotheses by. If ``None``, defaults to callable that returns + hypothesis score normalized by token sequence length. (Default: None) + step_max_tokens (int, optional): maximum number of tokens to emit per input time step. (Default: 100) + """ + + def __init__( + self, + model: RNNT, + blank: int, + temperature: float = 1.0, + hypo_sort_key: Optional[Callable[[Hypothesis], float]] = None, + step_max_tokens: int = 100, + ) -> None: + super().__init__() + self.model = model + self.blank = blank + self.temperature = temperature + + if hypo_sort_key is None: + self.hypo_sort_key = _default_hypo_sort_key else: - raise ValueError(f"invalid model_att_reduce_type {model_att_reduce_type!r}") - # Masking not needed because softmax should already have masked, - # so we have 0.0 att weights for padded frames. - att = rf.matmul(att_weights, v, reduce=kv_axis, use_mask=False) - if v.feature_dim in att.dims: - att.feature_dim = v.feature_dim - output, _ = rf.merge_dims( - att, - dims=(self.num_heads, self.value_dim_per_head), - out_dim=self.value_dim_total, + self.hypo_sort_key = hypo_sort_key + + self.step_max_tokens = step_max_tokens + + def _init_b_hypos(self, device: torch.device) -> List[Hypothesis]: + token = self.blank + state = None + + one_tensor = torch.tensor([1], device=device) + pred_out, _, pred_state = self.model.predict(torch.tensor([[token]], device=device), one_tensor, state) + init_hypo = ( + [token], + pred_out[0].detach(), + pred_state, + 0.0, ) - if self.proj: - output = self.proj(output) - return output - - for layer in model.decoder.layers: - layer: TransformerDecoderLayer - layer.cross_att.attention = functools.partial( - hooked_cross_att, self=layer.cross_att + return [init_hypo] + + def _gen_next_token_probs( + self, enc_out: torch.Tensor, hypos: List[Hypothesis], device: torch.device + ) -> torch.Tensor: + one_tensor = torch.tensor([1], device=device) + predictor_out = torch.stack([_get_hypo_predictor_out(h) for h in hypos], dim=0) + joined_out, _, _ = self.model.join( + enc_out, + one_tensor, + predictor_out, + torch.tensor([1] * len(hypos), device=device), + ) # [beam_width, 1, 1, num_tokens] + joined_out = torch.nn.functional.log_softmax(joined_out / self.temperature, dim=3) + return joined_out[:, 0, 0] + + def _gen_b_hypos( + self, + b_hypos: List[Hypothesis], + a_hypos: List[Hypothesis], + next_token_probs: torch.Tensor, + key_to_b_hypo: Dict[str, Hypothesis], + ) -> List[Hypothesis]: + for i in range(len(a_hypos)): + h_a = a_hypos[i] + append_blank_score = _get_hypo_score(h_a) + next_token_probs[i, -1] + if _get_hypo_key(h_a) in key_to_b_hypo: + h_b = key_to_b_hypo[_get_hypo_key(h_a)] + _remove_hypo(h_b, b_hypos) + score = float(torch.tensor(_get_hypo_score(h_b)).logaddexp(append_blank_score)) + else: + score = float(append_blank_score) + h_b = ( + _get_hypo_tokens(h_a), + _get_hypo_predictor_out(h_a), + _get_hypo_state(h_a), + score, + ) + b_hypos.append(h_b) + key_to_b_hypo[_get_hypo_key(h_b)] = h_b + _, sorted_idx = torch.tensor([_get_hypo_score(hypo) for hypo in b_hypos]).sort() + return [b_hypos[idx] for idx in sorted_idx] + + def _gen_a_hypos( + self, + a_hypos: List[Hypothesis], + b_hypos: List[Hypothesis], + next_token_probs: torch.Tensor, + t: int, + beam_width: int, + device: torch.device, + ) -> List[Hypothesis]: + ( + nonblank_nbest_scores, + nonblank_nbest_hypo_idx, + nonblank_nbest_token, + ) = _compute_updated_scores(a_hypos, next_token_probs, beam_width) + + if len(b_hypos) < beam_width: + b_nbest_score = -float("inf") + else: + b_nbest_score = _get_hypo_score(b_hypos[-beam_width]) + + base_hypos: List[Hypothesis] = [] + new_tokens: List[int] = [] + new_scores: List[float] = [] + for i in range(beam_width): + score = float(nonblank_nbest_scores[i]) + if score > b_nbest_score: + a_hypo_idx = int(nonblank_nbest_hypo_idx[i]) + base_hypos.append(a_hypos[a_hypo_idx]) + new_tokens.append(int(nonblank_nbest_token[i])) + new_scores.append(score) + + if base_hypos: + new_hypos = self._gen_new_hypos(base_hypos, new_tokens, new_scores, t, device) + else: + new_hypos: List[Hypothesis] = [] + + return new_hypos + + def _gen_new_hypos( + self, + base_hypos: List[Hypothesis], + tokens: List[int], + scores: List[float], + t: int, + device: torch.device, + ) -> List[Hypothesis]: + tgt_tokens = torch.tensor([[token] for token in tokens], device=device) + states = _batch_state(base_hypos) + pred_out, _, pred_states = self.model.predict( + tgt_tokens, + torch.tensor([1] * len(base_hypos), device=device), + states, ) + new_hypos: List[Hypothesis] = [] + for i, h_a in enumerate(base_hypos): + new_tokens = _get_hypo_tokens(h_a) + [tokens[i]] + new_hypos.append((new_tokens, pred_out[i].detach(), _slice_state(pred_states, i, device), scores[i])) + return new_hypos + + def _search( + self, + enc_out: torch.Tensor, + hypo: Optional[List[Hypothesis]], + beam_width: int, + ) -> List[Hypothesis]: + n_time_steps = enc_out.shape[1] + device = enc_out.device + + a_hypos: List[Hypothesis] = [] + b_hypos = self._init_b_hypos(device) if hypo is None else hypo + for t in range(n_time_steps): + a_hypos = b_hypos + b_hypos = torch.jit.annotate(List[Hypothesis], []) + key_to_b_hypo: Dict[str, Hypothesis] = {} + symbols_current_t = 0 + + while a_hypos: + next_token_probs = self._gen_next_token_probs(enc_out[:, t : t + 1], a_hypos, device) + next_token_probs = next_token_probs.cpu() + b_hypos = self._gen_b_hypos(b_hypos, a_hypos, next_token_probs, key_to_b_hypo) + + if symbols_current_t == self.step_max_tokens: + break + + a_hypos = self._gen_a_hypos( + a_hypos, + b_hypos, + next_token_probs, + t, + beam_width, + device, + ) + if a_hypos: + symbols_current_t += 1 - class LabelScorer(LabelScorerIntf): - """label scorer""" + _, sorted_idx = torch.tensor([self.hypo_sort_key(hyp) for hyp in b_hypos]).topk(beam_width) + b_hypos = [b_hypos[idx] for idx in sorted_idx] - def get_initial_state(self, *, batch_size: int, device: torch.device) -> Any: - """Initial state.""" - beam_dim = Dim(1, name="initial-beam") - batch_dims_ = [batch_dim, beam_dim] - decoder_state = model.decoder_default_initial_state( - batch_dims=batch_dims_, enc_spatial_dim=enc_spatial_dim - ) - if coverage_scale or neg_coverage_scale or always_add_scorers: - decoder_state["accum_att_weights"] = rf.zeros(batch_dims_) - return tree.map_structure( - functools.partial(self._map_tensor_to_raw, beam_dim=beam_dim), - decoder_state, - ) + return b_hypos - def max_remaining_seq_score( - self, *, state: Any, max_remaining_steps: torch.Tensor, device: torch.device - ) -> torch.Tensor: - """max remaining""" - return torch.zeros((1, 1), device=device) - - def score_and_update_state( - self, - *, - prev_state: Any, - prev_label: torch.Tensor, - ) -> Tuple[torch.Tensor, Any]: - """update state""" - nonlocal beam_dim - beam_dim = Dim(prev_label.shape[1], name="beam") - - def _map_raw_to_tensor(v): - if isinstance(v, StateObjTensorExt): - tensor: Tensor = v.extra - tensor = tensor.copy_template_new_dim_tags( - (batch_dim, beam_dim) + tensor.dims[2:], keep_special_axes=True - ) - tensor.raw_tensor = v.tensor - return tensor - elif isinstance(v, StateObjIgnored): - return v.content - else: - raise TypeError( - f"_map_raw_to_tensor: unexpected {v} ({type(v).__name__})" - ) - - prev_state = tree.map_structure(_map_raw_to_tensor, prev_state) - - nonlocal accum_att_weights, att_weights_dec_frame - accum_att_weights = prev_state["accum_att_weights"] - att_weights_dec_frame = rf.zeros(()) - logits, decoder_state = model.decoder( - rf.convert_to_tensor( - prev_label, dims=[batch_dim, beam_dim], sparse_dim=model.target_dim - ), - spatial_dim=single_step_dim, - encoder=enc, - state=prev_state, - ) - accum_att_weights += att_weights_dec_frame - if coverage_scale or neg_coverage_scale or always_add_scorers: - decoder_state["accum_att_weights"] = accum_att_weights - label_log_prob = rf.log_softmax(logits, axis=model.target_dim) - assert set(label_log_prob.dims) == {batch_dim, beam_dim, model.target_dim} - - return ( - self._map_tensor_to_raw(label_log_prob, beam_dim=beam_dim).tensor, - tree.map_structure( - functools.partial(self._map_tensor_to_raw, beam_dim=beam_dim), - decoder_state, - ), - ) + def forward(self, input: torch.Tensor, length: torch.Tensor, beam_width: int) -> List[Hypothesis]: + r"""Performs beam search for the given input sequence. - @staticmethod - def _map_tensor_to_raw(v, *, beam_dim: Dim): - if isinstance(v, Tensor): - if beam_dim not in v.dims: - return StateObjIgnored(v) - batch_dims_ = [batch_dim, beam_dim] - v = v.copy_transpose( - batch_dims_ + [dim for dim in v.dims if dim not in batch_dims_] - ) - raw = v.raw_tensor - return StateObjTensorExt(raw, v.copy_template()) - elif isinstance(v, Dim): - return StateObjIgnored(v) - else: - raise TypeError( - f"_map_tensor_to_raw: unexpected {v} ({type(v).__name__})" - ) + T: number of frames; + D: feature dimension of each frame. - class CoverageScorer(LabelScorerIntf): - """coverage + Args: + input (torch.Tensor): sequence of input frames, with shape (T, D) or (1, T, D). + length (torch.Tensor): number of valid frames in input + sequence, with shape () or (1,). + beam_width (int): beam size to use during search. - Google NMT: https://arxiv.org/pdf/1609.08144.pdf - Alternative: https://arxiv.org/abs/1612.02695 - Another alternative: https://arxiv.org/pdf/2105.00982.pdf + Returns: + List[Hypothesis]: top-``beam_width`` hypotheses found by beam search. """ - - def __init__(self, opts: Dict[str, Any]): - self.opts = opts - - def get_initial_state(self, *, batch_size: int, device: torch.device) -> Any: - """Initial state.""" - return {"prev_score": torch.zeros([batch_size, 1], device=device)} - - def score_and_update_state( - self, - *, - prev_state: Any, - prev_label: torch.Tensor, - ) -> Tuple[torch.Tensor, Any]: - """update state""" - prev_label # noqa # unused - # We assume the label scorer has run before us (make sure by right ordering). - accum_att_weights_ = accum_att_weights - assert set(accum_att_weights_.dims) == { - batch_dim, - beam_dim, - enc_spatial_dim, - } - cov_type = self.opts.get("type", "log1p") - if self.opts.get("rescale", False): - accum_att_weights_ /= rf.maximum( - rf.reduce_max(accum_att_weights_, axis=enc_spatial_dim), 1.0 - ) - if ( - cov_type == "log1p" - ): # log1p, to avoid having lots of negative numbers. So this starts more around 0.0. - coverage_score = rf.log1p(rf.minimum(accum_att_weights_, 1.0)) - elif ( - cov_type == "log" - ): # orig Google NMT: https://arxiv.org/pdf/1609.08144.pdf, but clipped - eps = self.opts.get("eps", 0.0) - clip_min = self.opts.get("clip_min", 0.01) - coverage_score = rf.log( - rf.clip_by_value(accum_att_weights_, clip_min, 1.0) + eps - ) - elif cov_type == "indicator": - threshold = self.opts.get("threshold", 0.5) - coverage_score = rf.where(accum_att_weights_ >= threshold, 1.0, 0.0) - elif cov_type == "relu_upper": - threshold = self.opts.get("threshold", 0.5) - coverage_score = rf.where( - accum_att_weights_ >= threshold, accum_att_weights_ - threshold, 0.0 - ) - else: - raise ValueError(f"invalid coverage opts type {cov_type!r}") - coverage_score = rf.reduce_sum(coverage_score, axis=enc_spatial_dim) - coverage_score_raw = coverage_score.copy_compatible_to_dims_raw( - (batch_dim, beam_dim) - ) - state = {"prev_score": coverage_score_raw} - return (coverage_score_raw - prev_state["prev_score"])[:, :, None], state - - class MonotonicityScorer(LabelScorerIntf): - """score monotonicity""" - - def get_initial_state(self, *, batch_size: int, device: torch.device) -> Any: - """Initial state.""" - return {"att_pos": torch.zeros([batch_size, 1], device=device)} - - def score_and_update_state( - self, - *, - prev_state: Any, - prev_label: torch.Tensor, - ) -> Tuple[torch.Tensor, Any]: - """update state""" - prev_label # noqa # unused - # We assume the label scorer has run before us (make sure by right ordering). - assert set(att_weights_dec_frame.dims) == { - batch_dim, - beam_dim, - enc_spatial_dim, - } - att_pos = rf.matmul( - att_weights_dec_frame, - rf.range_over_dim(enc_spatial_dim, dtype=att_weights_dec_frame.dtype), - reduce=enc_spatial_dim, - use_mask=False, # not needed, att weights already 0 outside - ) # [Batch,Beam] - att_pos_raw = att_pos.copy_compatible_to_dims_raw((batch_dim, beam_dim)) - delta_raw = prev_state["att_pos"] - att_pos_raw - threshold = monotonicity_opts.get("threshold", 1.0) - # Penalize when below threshold. The more it is below (or even negative), the more. - score_raw = torch.where( - delta_raw < threshold, delta_raw - threshold, 0.0 - ) # [Batch,Beam] - return score_raw[:, :, None], {"att_pos": att_pos_raw} - - # Note: insertion order matters here, we want that decoder is scored first. - res = {"decoder": (LabelScorer(), 1.0)} - if coverage_scale or always_add_scorers: - res["attention_coverage"] = ( - CoverageScorer(coverage_opts or {}), - coverage_scale, - ) - if neg_coverage_scale or (neg_coverage_opts and always_add_scorers): - # Idea: Too much attention on some frames (e.g. repetitions) is scored negatively. - res["attention_neg_coverage"] = ( - CoverageScorer(neg_coverage_opts or {}), - -neg_coverage_scale, - ) - if monotonicity_scale or always_add_scorers: - res["attention_monotonicity"] = (MonotonicityScorer(), monotonicity_scale) - return res \ No newline at end of file + if input.dim() != 2 and not (input.dim() == 3 and input.shape[0] == 1): + raise ValueError("input must be of shape (T, D) or (1, T, D)") + if input.dim() == 2: + input = input.unsqueeze(0) + + if length.shape != () and length.shape != (1,): + raise ValueError("length must be of shape () or (1,)") + if length.dim() == 0: + length = length.unsqueeze(0) + + enc_out, _ = self.model.transcribe(input, length) + return self._search(enc_out, None, beam_width) + + @torch.jit.export + def infer( + self, + input: torch.Tensor, + length: torch.Tensor, + beam_width: int, + state: Optional[List[List[torch.Tensor]]] = None, + hypothesis: Optional[List[Hypothesis]] = None, + ) -> Tuple[List[Hypothesis], List[List[torch.Tensor]]]: + r"""Performs beam search for the given input sequence in streaming mode. + + T: number of frames; + D: feature dimension of each frame. + + Args: + input (torch.Tensor): sequence of input frames, with shape (T, D) or (1, T, D). + length (torch.Tensor): number of valid frames in input + sequence, with shape () or (1,). + beam_width (int): beam size to use during search. + state (List[List[torch.Tensor]] or None, optional): list of lists of tensors + representing transcription network internal state generated in preceding + invocation. (Default: ``None``) + hypothesis (List[Hypothesis] or None): hypotheses from preceding invocation to seed + search with. (Default: ``None``) + + Returns: + (List[Hypothesis], List[List[torch.Tensor]]): + List[Hypothesis] + top-``beam_width`` hypotheses found by beam search. + List[List[torch.Tensor]] + list of lists of tensors representing transcription network + internal state generated in current invocation. + """ + if input.dim() != 2 and not (input.dim() == 3 and input.shape[0] == 1): + raise ValueError("input must be of shape (T, D) or (1, T, D)") + if input.dim() == 2: + input = input.unsqueeze(0) + + if length.shape != () and length.shape != (1,): + raise ValueError("length must be of shape () or (1,)") + if length.dim() == 0: + length = length.unsqueeze(0) + + enc_out, _, state = self.model.transcribe_streaming(input, length, state) + return self._search(enc_out, hypothesis, beam_width), state From d6c45435fc88761dc09b3770db5760421a16ba55 Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Tue, 4 Jun 2024 23:59:03 +0200 Subject: [PATCH 091/227] feature batch norm --- .../exp2024_04_23_baselines/ctc.py | 20 +++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py index 265ed9c17..1aa784b0a 100644 --- a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py +++ b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py @@ -149,6 +149,20 @@ def py(): train_vocab_opts={"other_opts": {"enable_sampling": True, "alpha": 0.7}}, ) + train_exp( + "v6-bhv20-11gb-f32-bs15k-accgrad1-mgpu4-pavg100-wd1e_2-lrlin1e_5_295k-featBN-speedpertV2-spm10k-spmSample07", + config_11gb_v6_f32_accgrad1_mgpu4_pavg100_wd1e_4, + model_config={"feature_batch_norm": True}, + config_updates={ + **_get_cfg_lrlin_oclr_by_bs_nep(15_000, 500), + "optimizer.weight_decay": 1e-2, + "__train_audio_preprocess": speed_pert_librosa_config, + "speed_pert_discrete_values": [0.7, 0.8, 0.9, 1.0, 1.1], + }, + vocab="spm10k", + train_vocab_opts={"other_opts": {"enable_sampling": True, "alpha": 0.7}}, + ) + # noinspection PyShadowingNames def train_exp( @@ -545,6 +559,10 @@ def __init__( vocab_labels, user_defined_symbols={model_recog.output_blank_label: blank_idx} ) + self.feature_batch_norm = None + if config.bool("feature_batch_norm", False): + self.feature_batch_norm = rf.BatchNorm(self.in_dim, affine=False, use_mask=True) + self._specaugment_opts = { "steps": config.typed_value("specaugment_steps") or (0, 1000, 2000), "max_consecutive_spatial_dims": config.typed_value("specaugment_max_consecutive_spatial_dims") or 20, @@ -574,6 +592,8 @@ def __call__( out_dim=self.in_dim, sampling_rate=16_000, ) + if self.feature_batch_norm: + source = self.feature_batch_norm(source) if self._mixup: source = self._mixup(source, spatial_dim=in_spatial_dim) # SpecAugment From e243cc23d2003c802ba7d244b31cd60ad40a23b4 Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Wed, 5 Jun 2024 21:51:22 +0200 Subject: [PATCH 092/227] feature normalization --- .../experiments/exp2024_04_23_baselines/ctc.py | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py index 1aa784b0a..b254ab994 100644 --- a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py +++ b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py @@ -163,6 +163,20 @@ def py(): train_vocab_opts={"other_opts": {"enable_sampling": True, "alpha": 0.7}}, ) + train_exp( + "v6-bhv20-11gb-f32-bs15k-accgrad1-mgpu4-pavg100-wd1e_2-lrlin1e_5_295k-featNorm-speedpertV2-spm10k-spmSample07", + config_11gb_v6_f32_accgrad1_mgpu4_pavg100_wd1e_4, + model_config={"feature_norm": True}, + config_updates={ + **_get_cfg_lrlin_oclr_by_bs_nep(15_000, 500), + "optimizer.weight_decay": 1e-2, + "__train_audio_preprocess": speed_pert_librosa_config, + "speed_pert_discrete_values": [0.7, 0.8, 0.9, 1.0, 1.1], + }, + vocab="spm10k", + train_vocab_opts={"other_opts": {"enable_sampling": True, "alpha": 0.7}}, + ) + # noinspection PyShadowingNames def train_exp( @@ -562,6 +576,7 @@ def __init__( self.feature_batch_norm = None if config.bool("feature_batch_norm", False): self.feature_batch_norm = rf.BatchNorm(self.in_dim, affine=False, use_mask=True) + self.feature_norm = config.bool("feature_norm", False) self._specaugment_opts = { "steps": config.typed_value("specaugment_steps") or (0, 1000, 2000), @@ -594,6 +609,8 @@ def __call__( ) if self.feature_batch_norm: source = self.feature_batch_norm(source) + if self.feature_norm: + source = rf.normalize(source, axis=in_spatial_dim) if self._mixup: source = self._mixup(source, spatial_dim=in_spatial_dim) # SpecAugment From e93e1719a4e6ea8b19816023ff44ce99449b4f5a Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Wed, 5 Jun 2024 22:08:22 +0200 Subject: [PATCH 093/227] recog fix API doc --- users/zeyer/model_interfaces/recog.py | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/users/zeyer/model_interfaces/recog.py b/users/zeyer/model_interfaces/recog.py index 5847c3076..49a09ff27 100644 --- a/users/zeyer/model_interfaces/recog.py +++ b/users/zeyer/model_interfaces/recog.py @@ -4,7 +4,7 @@ from __future__ import annotations -from typing import TYPE_CHECKING, Optional, Protocol +from typing import TYPE_CHECKING, Optional, Protocol, Tuple if TYPE_CHECKING: from returnn.tensor import Tensor, Dim @@ -24,13 +24,17 @@ def __call__( model: ModelT, data: Tensor, data_spatial_dim: Dim, - ) -> Tensor: + ) -> Tuple[Tensor, Tensor, Dim, Dim]: """ - :return: recog output, including beam or not, depending on output_with_beam + :return: + recog results including beam {batch, beam, out_spatial}, + log probs {batch, beam}, + out_spatial_dim, + final beam_dim """ raise NotImplementedError - output_with_beam: bool = True + output_with_beam: bool = True # False not really supported... output_blank_label: Optional[str] = None # A batched beam search can be dependent on the batch size, From 0804c99f2d46be22e614c3f202da6abefc78ea84 Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Wed, 5 Jun 2024 23:33:24 +0200 Subject: [PATCH 094/227] collect stats, initial code --- users/zeyer/collect_model_dataset_stats.py | 289 +++++++++++++++++++++ users/zeyer/model_interfaces/__init__.py | 1 + users/zeyer/model_interfaces/forward.py | 22 ++ 3 files changed, 312 insertions(+) create mode 100644 users/zeyer/collect_model_dataset_stats.py create mode 100644 users/zeyer/model_interfaces/forward.py diff --git a/users/zeyer/collect_model_dataset_stats.py b/users/zeyer/collect_model_dataset_stats.py new file mode 100644 index 000000000..095bdcca2 --- /dev/null +++ b/users/zeyer/collect_model_dataset_stats.py @@ -0,0 +1,289 @@ +""" +Calculate statistics over any dataset, e.g. feature statistics. +Can also perform any computation on the dataset, e.g. forward pass through a model. +Thus, this can also be used to calculate prior statistics for a model. +""" + +from __future__ import annotations + +from typing import TYPE_CHECKING, Optional, Union, Any, Dict +from dataclasses import dataclass + +from sisyphus import tk +from i6_core.util import instanciate_delayed + +from i6_core.returnn import ReturnnConfig +from i6_core.returnn.forward import ReturnnForwardJobV2 +from returnn_common import nn +from returnn_common.datasets_old_2022_10.interface import DatasetConfig +from i6_experiments.common.setups import serialization +from i6_experiments.users.zeyer.utils.serialization import get_import_py_code + +from i6_experiments.users.zeyer import tools_paths +from i6_experiments.users.zeyer.model_interfaces import ModelDef, ModelDefWithCfg, ForwardDef, serialize_model_def +from i6_experiments.users.zeyer.model_with_checkpoints import ModelWithCheckpoint + +if TYPE_CHECKING: + from returnn.tensor import TensorDict + + +def collect_statistics( + *, + dataset: DatasetConfig, + model: Optional[ModelWithCheckpoint] = None, + forward_def: ForwardDef, + config: Optional[Dict[str, Any]] = None, + forward_post_config: Optional[Dict[str, Any]] = None, + forward_mem_rqmt: Union[int, float] = 6, + forward_rqmt: Optional[Dict[str, Any]] = None, + forward_alias_name: Optional[str] = None, +) -> StatisticsOutput: + """ + recog on the specific dataset + """ + env_updates = None + if (config and config.get("__env_updates")) or (forward_post_config and forward_post_config.get("__env_updates")): + env_updates = (config and config.pop("__env_updates", None)) or ( + forward_post_config and forward_post_config.pop("__env_updates", None) + ) + out_files = { + "mean": _prior_mean_out_filename, + "std_dev": _prior_std_dev_out_filename, + "min": _prior_min_out_filename, + "max": _prior_max_out_filename, + "info": _prior_info_out_filename, + } + forward_job = ReturnnForwardJobV2( + model_checkpoint=model.checkpoint if model else None, + returnn_config=_collect_stats_returnn_forward_config( + dataset, model.definition if model else None, forward_def, config=config, post_config=forward_post_config + ), + output_files=list(out_files.values()), + returnn_python_exe=tools_paths.get_returnn_python_exe(), + returnn_root=tools_paths.get_returnn_root(), + mem_rqmt=forward_mem_rqmt, + ) + if forward_rqmt: + forward_job.rqmt.update(forward_rqmt) + if env_updates: + for k, v in env_updates.items(): + forward_job.set_env(k, v) + if forward_alias_name: + forward_job.add_alias(forward_alias_name) + return StatisticsOutput(**forward_job.out_files) + + +@dataclass +class StatisticsOutput: + """statistics""" + + mean: tk.Path + std_dev: tk.Path + min: tk.Path + max: tk.Path + info: tk.Path + + +_prior_mean_out_filename = "stats.mean.txt" +_prior_std_dev_out_filename = "stats.std_dev.txt" +_prior_min_out_filename = "stats.min.txt" +_prior_max_out_filename = "stats.max.txt" +_prior_info_out_filename = "stats.info.txt" + + +def _returnn_get_forward_callback(): + from returnn.tensor import Tensor, TensorDict + from returnn.forward_iface import ForwardCallbackIface + from returnn.util.basic import Stats + + class _ReturnnCollectStatsForwardCallbackIface(ForwardCallbackIface): + def __init__(self): + self.stats: Optional[Stats] = None + + def init(self, *, model): + self.stats = Stats() + + def process_seq(self, *, seq_tag: str, outputs: TensorDict): + # see _returnn_forward_step + out: Tensor = outputs["output"].copy_with_feature_last() + assert out.batch_ndim == 2 # (time,feature) + self.stats.collect(out.raw_tensor) + + def finish(self): + self.stats.dump("stats") + + return _ReturnnCollectStatsForwardCallbackIface() + + +# Those are applied for both training, recog and potential others. +# The values are only used if they are neither set in config nor post_config already. +# They should also not infer with other things from the epilog. +SharedPostConfig = { + # In case pretraining overwrites some of these, they need a default. + "accum_grad_multiple_step": None, + "use_last_best_model": None, +} + + +def _collect_stats_returnn_forward_config( + dataset: DatasetConfig, + model_def: Union[None, ModelDef, ModelDefWithCfg], + forward_def: ForwardDef, + *, + config: Optional[Dict[str, Any]] = None, + post_config: Optional[Dict[str, Any]] = None, +) -> ReturnnConfig: + """ + Create config for collecting stats. + + TODO should use sth like unhashed_package_root (https://github.com/rwth-i6/i6_experiments/pull/157) + """ + from i6_experiments.common.setups.returnn.serialization import get_serializable_config + + returnn_recog_config_dict = dict( + # dataset + default_input=dataset.get_default_input(), + target=dataset.get_default_target(), # only for get_model with model_def + forward_data=dataset.get_main_dataset(), + ) + if model_def: + returnn_recog_config_dict.update( + dict( + backend=model_def.backend, + behavior_version=model_def.behavior_version, + ) + ) + else: + assert config and config.get("backend") and config.get("behavior_version") + if config: + returnn_recog_config_dict.update(config) + if isinstance(model_def, ModelDefWithCfg): + returnn_recog_config_dict.update(model_def.config) + + extern_data_raw = dataset.get_extern_data() + # The extern_data is anyway not hashed, so we can also instanciate any delayed objects here. + # It's not hashed because we assume that all aspects of the dataset are already covered + # by the datasets itself as part in the config above. + extern_data_raw = instanciate_delayed(extern_data_raw) + + returnn_forward_config = ReturnnConfig( + config=returnn_recog_config_dict, + python_epilog=[ + serialization.Collection( + [ + serialization.NonhashedCode(get_import_py_code()), + serialization.NonhashedCode( + nn.ReturnnConfigSerializer.get_base_extern_data_py_code_str_direct(extern_data_raw) + ), + *( + serialize_model_def(model_def) + if model_def + else [serialization.NonhashedCode("_model_def = None\n")] + ), + serialization.Import(_returnn_get_model, import_as="get_model"), + serialization.Import(forward_def, import_as="_forward_def", ignore_import_as_for_hash=True), + serialization.Import(_returnn_forward_step, import_as="forward_step"), + serialization.Import(_returnn_get_forward_callback, import_as="forward_callback"), + serialization.ExplicitHash( + { + # Increase the version whenever some incompatible change is made in this recog() function, + # which influences the outcome, but would otherwise not influence the hash. + "version": 2, + } + ), + serialization.PythonEnlargeStackWorkaroundNonhashedCode, + serialization.PythonCacheManagerFunctionNonhashedCode, + serialization.PythonModelineNonhashedCode, + ] + ) + ], + post_config=dict( # not hashed + log_batch_size=True, + # debug_add_check_numerics_ops = True + # debug_add_check_numerics_on_output = True + # flat_net_construction=True, + torch_log_memory_usage=True, + watch_memory=True, + use_lovely_tensors=True, + ), + sort_config=False, + ) + + # There might be some further functions in the config, e.g. some dataset postprocessing. + returnn_forward_config = get_serializable_config( + returnn_forward_config, + # The only dim tags we directly have in the config are via extern_data, maybe also model_outputs. + # All other dim tags are inside functions such as get_model or train_step, + # so we do not need to care about them here, only about the serialization of those functions. + # Those dim tags and those functions are already handled above. + serialize_dim_tags=False, + ) + + batch_size_dependent = False + if "__batch_size_dependent" in returnn_forward_config.config: + batch_size_dependent = returnn_forward_config.config.pop("__batch_size_dependent") + if "__batch_size_dependent" in returnn_forward_config.post_config: + batch_size_dependent = returnn_forward_config.post_config.pop("__batch_size_dependent") + for k, v in dict( + batching="sorted", + batch_size=20000 * model_def.batch_size_factor, + max_seqs=200, + ).items(): + if k in returnn_forward_config.config: + v = returnn_forward_config.config.pop(k) + if k in returnn_forward_config.post_config: + v = returnn_forward_config.post_config.pop(k) + (returnn_forward_config.config if batch_size_dependent else returnn_forward_config.post_config)[k] = v + + if post_config: + returnn_forward_config.post_config.update(post_config) + + for k, v in SharedPostConfig.items(): + if k in returnn_forward_config.config or k in returnn_forward_config.post_config: + continue + returnn_forward_config.post_config[k] = v + + return returnn_forward_config + + +def _returnn_get_model(*, epoch: int, **_kwargs_unused): + from returnn.tensor import Tensor + from returnn.config import get_global_config + import returnn.frontend as rf + + config = get_global_config() + model_def = config.typed_value("_model_def") + if model_def is None: + return rf.Module() # empty dummy module + + default_input_key = config.typed_value("default_input") + default_target_key = config.typed_value("target") + extern_data_dict = config.typed_value("extern_data") + data = Tensor(name=default_input_key, **extern_data_dict[default_input_key]) + targets = Tensor(name=default_target_key, **extern_data_dict[default_target_key]) + assert targets.sparse_dim and targets.sparse_dim.vocab, f"no vocab for {targets}" + + model = model_def(epoch=epoch, in_dim=data.feature_dim, target_dim=targets.sparse_dim) + return model + + +def _returnn_forward_step(*, model, extern_data: TensorDict, **_kwargs_unused): + import returnn.frontend as rf + from returnn.tensor import Tensor, Dim, batch_dim + from returnn.config import get_global_config + + if rf.is_executing_eagerly(): + batch_size = int(batch_dim.get_dim_value()) + for batch_idx in range(batch_size): + seq_tag = extern_data["seq_tag"].raw_tensor[batch_idx].item() + print(f"batch {batch_idx+1}/{batch_size} seq_tag: {seq_tag!r}") + + config = get_global_config() + default_input_key = config.typed_value("default_input") + data = extern_data[default_input_key] + data_spatial_dim = data.get_time_dim_tag() + forward_def: ForwardDef = config.typed_value("_forward_def") + out, out_spatial_dim = forward_def(data, in_spatial_dim=data_spatial_dim, model=model) + assert isinstance(out, Tensor) and isinstance(out_spatial_dim, Dim) + assert out.feature_dim # we expect a feature dim + rf.get_run_ctx().mark_as_output(out, "output", dims=[batch_dim, out_spatial_dim, out.feature_dim]) diff --git a/users/zeyer/model_interfaces/__init__.py b/users/zeyer/model_interfaces/__init__.py index cd530259e..2fb721309 100644 --- a/users/zeyer/model_interfaces/__init__.py +++ b/users/zeyer/model_interfaces/__init__.py @@ -6,4 +6,5 @@ from .model import * from .model_with_checkpoints import * from .recog import * +from .forward import * from .training import * diff --git a/users/zeyer/model_interfaces/forward.py b/users/zeyer/model_interfaces/forward.py new file mode 100644 index 000000000..917539137 --- /dev/null +++ b/users/zeyer/model_interfaces/forward.py @@ -0,0 +1,22 @@ +""" +Any forwarding +""" + +from __future__ import annotations + +from typing import TYPE_CHECKING, Protocol, Tuple + +if TYPE_CHECKING: + from returnn.tensor import Tensor, Dim + +from .model import ModelT + + +class ForwardDef(Protocol[ModelT]): + def __call__(self, source: Tensor, /, in_spatial_dim: Dim, model: ModelT) -> Tuple[Tensor, Dim]: + """ + :param source: input tensor + :param in_spatial_dim: input spatial dimension + :param model: + :return: output tensor and output spatial dimension (can be same as in_spatial_dim) + """ From 68479b7991794929f3e72c7fac511231d4d552a6 Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Wed, 5 Jun 2024 23:59:31 +0200 Subject: [PATCH 095/227] librispeech feature stats --- users/zeyer/datasets/librispeech.py | 55 ++++++++++++++++++++++++++++- 1 file changed, 54 insertions(+), 1 deletion(-) diff --git a/users/zeyer/datasets/librispeech.py b/users/zeyer/datasets/librispeech.py index 020e285fe..d511e8ade 100644 --- a/users/zeyer/datasets/librispeech.py +++ b/users/zeyer/datasets/librispeech.py @@ -3,7 +3,7 @@ """ from __future__ import annotations -from typing import Optional, Any, Union, Tuple, Dict +from typing import TYPE_CHECKING, Optional, Any, Union, Tuple, Dict from copy import deepcopy import re from functools import cache @@ -25,6 +25,10 @@ from .utils.bpe import Bpe from .utils.spm import SentencePieceModel +if TYPE_CHECKING: + from returnn.tensor import Tensor, Dim + from i6_experiments.users.zeyer.collect_model_dataset_stats import StatisticsOutput + librispeech_ogg_zip_dict = librispeech.get_ogg_zip_dict() @@ -681,6 +685,55 @@ def _score_recog_out_v2(dataset: DatasetConfig, recog_output: RecogOutput) -> Sc return ScoreResult(dataset_name=corpus_name, main_measure_value=score_job.out_wer, report=score_job.out_report_dir) +def get_librispeech_raw_audio_only(*, main_key: str = "train") -> LibrispeechOggZip: + """librispeech with raw audio""" + return LibrispeechOggZip(audio=_raw_audio_opts, audio_dim=1, main_key=main_key) + + +def get_librispeech_log_mel_stats(dim: int, **kwargs) -> StatisticsOutput: + """ + Get feature stats + + :param dim: feature dim + :param kwargs: all passed to rf.audio.log_mel_filterbank_from_raw. + Default sampling_rate is 16_000, which is exactly also what we have for Librispeech usually. + Note on log_base: Default is 10.0. + Note that in some earlier setups, and also Mohammads original AED setup, + we used log_base=math.exp(2.3026), which is almost 10.0 but not exactly... + """ + from i6_experiments.users.zeyer.collect_model_dataset_stats import collect_statistics + + return collect_statistics( + dataset=get_librispeech_raw_audio_only(), + forward_def=_librispeech_log_mel_stats_returnn_forward, + config={ + "_audio_feature_dim": dim, + "_audio_feature_opts": kwargs, + }, + ) + + +def _librispeech_log_mel_stats_returnn_forward( + source: Tensor, /, in_spatial_dim: Dim, model: Any +) -> Tuple[Tensor, Dim]: + from returnn.config import get_global_config + import returnn.frontend as rf + from returnn.tensor import Dim + + model # noqa # unused + config = get_global_config() + feat_dim = config.int("_audio_feature_dim", -1) + assert feat_dim > 0 + feat_dim = Dim(feat_dim, name="audio", kind=Dim.Types.Feature) + opts = config.typed_value("_audio_feature_opts", None) + assert isinstance(opts, dict) + + source, out_spatial_dim = rf.audio.log_mel_filterbank_from_raw( + source, in_spatial_dim=in_spatial_dim, out_dim=feat_dim, **opts + ) + return source, out_spatial_dim + + def tests(): from sisyphus.hash import sis_hash_helper From b449d148d51a8242a5e7c359b692f713810b4838 Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Thu, 6 Jun 2024 00:10:13 +0200 Subject: [PATCH 096/227] feature global norm --- .../exp2024_04_23_baselines/ctc.py | 24 +++++++++++++++++++ 1 file changed, 24 insertions(+) diff --git a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py index b254ab994..74ec1c794 100644 --- a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py +++ b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py @@ -177,6 +177,23 @@ def py(): train_vocab_opts={"other_opts": {"enable_sampling": True, "alpha": 0.7}}, ) + from i6_experiments.users.zeyer.datasets.librispeech import get_librispeech_log_mel_stats + + feature_stats = get_librispeech_log_mel_stats(_log_mel_feature_dim) + train_exp( + "v6-bhv20-11gb-f32-bs15k-accgrad1-mgpu4-pavg100-wd1e_2-lrlin1e_5_295k-featGN-speedpertV2-spm10k-spmSample07", + config_11gb_v6_f32_accgrad1_mgpu4_pavg100_wd1e_4, + model_config={"feature_stats": {"mean": feature_stats.mean, "std_dev": feature_stats.std_dev}}, + config_updates={ + **_get_cfg_lrlin_oclr_by_bs_nep(15_000, 500), + "optimizer.weight_decay": 1e-2, + "__train_audio_preprocess": speed_pert_librosa_config, + "speed_pert_discrete_values": [0.7, 0.8, 0.9, 1.0, 1.1], + }, + vocab="spm10k", + train_vocab_opts={"other_opts": {"enable_sampling": True, "alpha": 0.7}}, + ) + # noinspection PyShadowingNames def train_exp( @@ -577,6 +594,11 @@ def __init__( if config.bool("feature_batch_norm", False): self.feature_batch_norm = rf.BatchNorm(self.in_dim, affine=False, use_mask=True) self.feature_norm = config.bool("feature_norm", False) + self.feature_stats = None + feature_stats = config.typed_value("feature_stats") + if feature_stats: + assert isinstance(feature_stats, dict) + self.feature_stats = {k: rf.constant(v, dims=[self.in_dim]) for k, v in feature_stats.items()} self._specaugment_opts = { "steps": config.typed_value("specaugment_steps") or (0, 1000, 2000), @@ -611,6 +633,8 @@ def __call__( source = self.feature_batch_norm(source) if self.feature_norm: source = rf.normalize(source, axis=in_spatial_dim) + if self.feature_stats: + source = (source - self.feature_stats["mean"]) / self.feature_stats["std_dev"] if self._mixup: source = self._mixup(source, spatial_dim=in_spatial_dim) # SpecAugment From f140044ecc7e509f2a866fa076d8e33dfed75a1f Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Thu, 6 Jun 2024 00:46:18 +0200 Subject: [PATCH 097/227] small fixes --- users/zeyer/collect_model_dataset_stats.py | 55 ++++++++++++++++++++-- users/zeyer/datasets/librispeech.py | 15 ++---- 2 files changed, 56 insertions(+), 14 deletions(-) diff --git a/users/zeyer/collect_model_dataset_stats.py b/users/zeyer/collect_model_dataset_stats.py index 095bdcca2..c65e13c4a 100644 --- a/users/zeyer/collect_model_dataset_stats.py +++ b/users/zeyer/collect_model_dataset_stats.py @@ -6,7 +6,7 @@ from __future__ import annotations -from typing import TYPE_CHECKING, Optional, Union, Any, Dict +from typing import TYPE_CHECKING, Optional, Union, Any, Dict, Tuple from dataclasses import dataclass from sisyphus import tk @@ -24,7 +24,7 @@ from i6_experiments.users.zeyer.model_with_checkpoints import ModelWithCheckpoint if TYPE_CHECKING: - from returnn.tensor import TensorDict + from returnn.tensor import Tensor, Dim, TensorDict def collect_statistics( @@ -70,7 +70,54 @@ def collect_statistics( forward_job.set_env(k, v) if forward_alias_name: forward_job.add_alias(forward_alias_name) - return StatisticsOutput(**forward_job.out_files) + return StatisticsOutput(**{k: forward_job.out_files[v] for k, v in out_files.items()}) + + +def collect_log_mel_feature_statistics( + *, dataset: DatasetConfig, dim: int, backend: str = "torch", behavior_version: int = 21, **kwargs +): + """ + Get feature stats + + :param dataset: + :param dim: log mel feature dim + :param backend: + :param behavior_version: + :param kwargs: all passed to rf.audio.log_mel_filterbank_from_raw. + Default sampling_rate is 16_000, which is also what we have for Librispeech usually. + Note on log_base: Default is 10.0. + Note that in some earlier setups, and also Mohammads original AED setup, + we used log_base=math.exp(2.3026), which is almost 10.0 but not exactly... + """ + return collect_statistics( + dataset=dataset, + forward_def=_log_mel_stats_returnn_forward, + config={ + "backend": backend, + "behavior_version": behavior_version, + "_audio_feature_dim": dim, + "_audio_feature_opts": kwargs, + }, + ) + + +def _log_mel_stats_returnn_forward(source: Tensor, /, in_spatial_dim: Dim, model: Any) -> Tuple[Tensor, Dim]: + from returnn.config import get_global_config + import returnn.frontend as rf + from returnn.tensor import Dim + + model # noqa # unused + config = get_global_config() + feat_dim = config.int("_audio_feature_dim", -1) + assert feat_dim > 0 + feat_dim = Dim(feat_dim, name="audio", kind=Dim.Types.Feature) + opts = config.typed_value("_audio_feature_opts", None) + assert isinstance(opts, dict) + + source, out_spatial_dim = rf.audio.log_mel_filterbank_from_raw( + source, in_spatial_dim=in_spatial_dim, out_dim=feat_dim, **opts + ) + return source, out_spatial_dim @dataclass @@ -226,7 +273,7 @@ def _collect_stats_returnn_forward_config( batch_size_dependent = returnn_forward_config.post_config.pop("__batch_size_dependent") for k, v in dict( batching="sorted", - batch_size=20000 * model_def.batch_size_factor, + batch_size=(20000 * model_def.batch_size_factor) if model_def else (20000 * 160), max_seqs=200, ).items(): if k in returnn_forward_config.config: diff --git a/users/zeyer/datasets/librispeech.py b/users/zeyer/datasets/librispeech.py index d511e8ade..630fc3fbe 100644 --- a/users/zeyer/datasets/librispeech.py +++ b/users/zeyer/datasets/librispeech.py @@ -340,6 +340,8 @@ def get_dataset(self, key: str, *, training: bool = False, subset: Optional[int] eos_id = vocab.get_eos_idx() assert eos_id is not None, f"{self}: vocab {vocab} does not define EOS" d["targets"]["seq_postfix"] = [eos_id] + else: + d["targets"] = None if training: d["partition_epoch"] = self.train_epoch_split if self.train_epoch_wise_filter is not None: @@ -701,16 +703,9 @@ def get_librispeech_log_mel_stats(dim: int, **kwargs) -> StatisticsOutput: Note that in some earlier setups, and also Mohammads original AED setup, we used log_base=math.exp(2.3026), which is almost 10.0 but not exactly... """ - from i6_experiments.users.zeyer.collect_model_dataset_stats import collect_statistics - - return collect_statistics( - dataset=get_librispeech_raw_audio_only(), - forward_def=_librispeech_log_mel_stats_returnn_forward, - config={ - "_audio_feature_dim": dim, - "_audio_feature_opts": kwargs, - }, - ) + from i6_experiments.users.zeyer.collect_model_dataset_stats import collect_log_mel_feature_statistics + + return collect_log_mel_feature_statistics(dataset=get_librispeech_raw_audio_only(), dim=dim, **kwargs) def _librispeech_log_mel_stats_returnn_forward( From 950e5788b346a9c0b929e0599c1fca0be45b7149 Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Thu, 6 Jun 2024 00:48:07 +0200 Subject: [PATCH 098/227] small fix --- users/zeyer/experiments/exp2024_04_23_baselines/ctc.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py index 74ec1c794..70ed2178f 100644 --- a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py +++ b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py @@ -535,6 +535,7 @@ def __init__( ): super(Model, self).__init__() + import numpy from returnn.config import get_global_config config = get_global_config(return_empty_if_none=True) @@ -598,7 +599,9 @@ def __init__( feature_stats = config.typed_value("feature_stats") if feature_stats: assert isinstance(feature_stats, dict) - self.feature_stats = {k: rf.constant(v, dims=[self.in_dim]) for k, v in feature_stats.items()} + self.feature_stats = { + k: rf.constant(numpy.loadtxt(v), dims=[self.in_dim]) for k, v in feature_stats.items() + } self._specaugment_opts = { "steps": config.typed_value("specaugment_steps") or (0, 1000, 2000), From e666f61e17da159bd0146c3044cf0ae64672c80b Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Thu, 6 Jun 2024 07:22:49 +0200 Subject: [PATCH 099/227] small fix --- users/zeyer/experiments/exp2024_04_23_baselines/ctc.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py index 70ed2178f..8cbc86a79 100644 --- a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py +++ b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py @@ -600,7 +600,7 @@ def __init__( if feature_stats: assert isinstance(feature_stats, dict) self.feature_stats = { - k: rf.constant(numpy.loadtxt(v), dims=[self.in_dim]) for k, v in feature_stats.items() + k: rf.convert_to_tensor(numpy.loadtxt(v), dims=[self.in_dim]) for k, v in feature_stats.items() } self._specaugment_opts = { From e0fc149add997671af4593cab5ffe25d53a344d9 Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Thu, 6 Jun 2024 09:28:54 +0200 Subject: [PATCH 100/227] small fix --- .../experiments/exp2024_04_23_baselines/ctc.py | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-) diff --git a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py index 8cbc86a79..450331bf0 100644 --- a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py +++ b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py @@ -599,9 +599,15 @@ def __init__( feature_stats = config.typed_value("feature_stats") if feature_stats: assert isinstance(feature_stats, dict) - self.feature_stats = { - k: rf.convert_to_tensor(numpy.loadtxt(v), dims=[self.in_dim]) for k, v in feature_stats.items() - } + self.feature_stats = rf.ParameterList( + { + k: rf.Parameter( + rf.convert_to_tensor(numpy.loadtxt(v), dims=[self.in_dim], dtype=rf.get_default_float_dtype()), + auxiliary=True, + ) + for k, v in feature_stats.items() + } + ) self._specaugment_opts = { "steps": config.typed_value("specaugment_steps") or (0, 1000, 2000), @@ -637,7 +643,7 @@ def __call__( if self.feature_norm: source = rf.normalize(source, axis=in_spatial_dim) if self.feature_stats: - source = (source - self.feature_stats["mean"]) / self.feature_stats["std_dev"] + source = (source - self.feature_stats.mean) / self.feature_stats.std_dev if self._mixup: source = self._mixup(source, spatial_dim=in_spatial_dim) # SpecAugment From b7480b8a44d11004587b7da2fbcce5d616874665 Mon Sep 17 00:00:00 2001 From: "luca.gaudino" Date: Thu, 6 Jun 2024 10:07:24 +0200 Subject: [PATCH 101/227] fix feat norm search --- .../conformer_import_moh_att_2023_06_30.py | 2 +- .../librispeech_960/conformer_ctc_train.py | 47 +++++++++++++--- .../tedlium2/conformer_rnnt_train.py | 54 ++++++++++++++----- .../asr/rf/conformer_rnnt/model_recog_rnnt.py | 51 ++++++++++-------- 4 files changed, 111 insertions(+), 43 deletions(-) diff --git a/users/gaudino/experiments/rf_conformer_att_2023/librispeech_960/conformer_import_moh_att_2023_06_30.py b/users/gaudino/experiments/rf_conformer_att_2023/librispeech_960/conformer_import_moh_att_2023_06_30.py index 52193c721..4b0b70543 100644 --- a/users/gaudino/experiments/rf_conformer_att_2023/librispeech_960/conformer_import_moh_att_2023_06_30.py +++ b/users/gaudino/experiments/rf_conformer_att_2023/librispeech_960/conformer_import_moh_att_2023_06_30.py @@ -639,7 +639,7 @@ def sis_run_with_prefix(prefix_name: str = None): # opls att + ctc + trafo lm + ilm for scales, prior_scale, lm_scale, ilm_scale, beam_size in product( - [(0.8, 0.2)], [0.05, 0.03, 0.04, 0.06, 0.07], [0.65], [0.4], [32] + [(0.8, 0.2)], [0.05, 0.07], [0.65], [0.4], [32, 48, 64] ): att_scale, ctc_scale = scales recog_name = ( diff --git a/users/gaudino/experiments/rf_conformer_rnnt_2024/librispeech_960/conformer_ctc_train.py b/users/gaudino/experiments/rf_conformer_rnnt_2024/librispeech_960/conformer_ctc_train.py index 53e2e77ee..66fe36592 100644 --- a/users/gaudino/experiments/rf_conformer_rnnt_2024/librispeech_960/conformer_ctc_train.py +++ b/users/gaudino/experiments/rf_conformer_rnnt_2024/librispeech_960/conformer_ctc_train.py @@ -10,6 +10,7 @@ import hashlib import contextlib import functools +from sisyphus import tk from returnn.tensor import Tensor, Dim, single_step_dim import returnn.frontend as rf @@ -32,10 +33,10 @@ if TYPE_CHECKING: from i6_experiments.users.zeyer.model_interfaces import ModelDef, RecogDef, TrainDef - from i6_experiments.users.zeyer.model_with_checkpoints import ( - ModelWithCheckpoints, - ModelWithCheckpoint, - ) +from i6_experiments.users.zeyer.model_with_checkpoints import ( + ModelWithCheckpoints, + ModelWithCheckpoint, +) # From Mohammad, 2023-06-29 # dev-clean 2.27 @@ -99,6 +100,9 @@ def sis_run_with_prefix(prefix_name: Optional[str] = None): """run the exp""" + + from i6_core.returnn.training import PtCheckpoint + _sis_setup_global_prefix(prefix_name) # Moh: dev-clean 2.27, dev-other 5.39, test-clean 2.41, test-other 5.51 @@ -158,9 +162,12 @@ def sis_run_with_prefix(prefix_name: Optional[str] = None): "aux_loss_layers":[], "mel_normalization_ted2": False, }, + search_config={ + "mel_normalization_ted2": False, + }, ) - train_exp( # dev-other 7.17 + train_exp( # dev-other 6.92 "base-24gb-lrlin1e_5_600k_ctc_only_aux4_8_no_mel_norm", config_24gb_v6, config_updates={ @@ -171,7 +178,34 @@ def sis_run_with_prefix(prefix_name: Optional[str] = None): "learning_rate_piecewise_values": [1e-5, 1e-3, 1e-5, 1e-6], "mel_normalization_ted2": False, }, + search_config = { + "mel_normalization_ted2": False, + }, + ) + + _torch_ckpt_path = "/u/luca.gaudino/setups/2023-08-10--rf-librispeech/work/i6_core/returnn/training/ReturnnTrainingJob.AWwVft0oGy8e/output/models/epoch.1981.pt" + + new_ckpt_path = tk.Path( + _torch_ckpt_path, + hash_overwrite= "ctc" + "_torch_ckpt", ) + new_ckpt = PtCheckpoint(new_ckpt_path) + + recog_config = { + "mel_normalization_ted2": False, + } + + # recog ctc only model + _recog( + "model_recogs/base-24gb-lrlin1e_5_600k_ctc_only_aux4_8_no_mel_norm/ep1981/ctc_greedy/recog_results", + ModelWithCheckpoint( + definition=from_scratch_model_def, checkpoint=new_ckpt + ), + model_recog, + recog_config=recog_config, + ) + + _sis_prefix: Optional[str] = None @@ -227,6 +261,7 @@ def train_exp( fine_tune: Optional[Union[int, List[Tuple[int, Dict[str, Any]]]]] = None, time_rqmt: Optional[int] = None, model_avg: bool = False, + search_config: Optional[Dict[str, Any]] = None, ) -> ModelWithCheckpoints: """ Train experiment @@ -264,7 +299,7 @@ def train_exp( time_rqmt=time_rqmt, ) recog_training_exp( - prefix, task, model_with_checkpoint, recog_def=model_recog, model_avg=model_avg + prefix, task, model_with_checkpoint, recog_def=model_recog, model_avg=model_avg, search_config=search_config ) if fine_tune: diff --git a/users/gaudino/experiments/rf_conformer_rnnt_2024/tedlium2/conformer_rnnt_train.py b/users/gaudino/experiments/rf_conformer_rnnt_2024/tedlium2/conformer_rnnt_train.py index 4a669a70b..d075dec27 100644 --- a/users/gaudino/experiments/rf_conformer_rnnt_2024/tedlium2/conformer_rnnt_train.py +++ b/users/gaudino/experiments/rf_conformer_rnnt_2024/tedlium2/conformer_rnnt_train.py @@ -11,6 +11,7 @@ import hashlib import contextlib import functools +from sisyphus import tk from returnn.tensor import Tensor, Dim, single_step_dim import returnn.frontend as rf @@ -30,10 +31,11 @@ if TYPE_CHECKING: from i6_experiments.users.gaudino.model_interfaces import ModelDef, RecogDef, TrainDef - from i6_experiments.users.gaudino.model_with_checkpoints import ( - ModelWithCheckpoints, - ModelWithCheckpoint, - ) + +from i6_experiments.users.gaudino.model_with_checkpoints import ( + ModelWithCheckpoints, + ModelWithCheckpoint, +) from i6_experiments.users.gaudino.models.asr.rf.conformer_rnnt.model_conformer_rnnt import from_scratch_model_def, from_scratch_training from i6_experiments.users.gaudino.models.asr.rf.conformer_rnnt.model_recog_rnnt import model_recog @@ -45,6 +47,9 @@ def sis_run_with_prefix(prefix_name: Optional[str] = None): """run the exp""" + + from i6_core.returnn.training import PtCheckpoint + _sis_setup_global_prefix(prefix_name) # Moh: dev-clean 2.27, dev-other 5.39, test-clean 2.41, test-other 5.51 @@ -80,15 +85,38 @@ def sis_run_with_prefix(prefix_name: Optional[str] = None): # train_exp("base-11gb", config_11gb, gpu_mem=11) # train_exp("base-11gb-v1", my_config_11gb, num_epochs=400, gpu_mem=11) - train_exp( # - "from-scratch-24gb", - rnnt_train_config, - config_updates={ - "learning_rate": 1.0, - "learning_rate_piecewise_values": [8e-5, 8e-4, 8e-5, 1e-6], - }, - num_epochs=400, - gpu_mem=24, + + # train_exp( # TODO: runs in loss nan + # "from-scratch-24gb", + # rnnt_train_config, + # config_updates={ + # "learning_rate": 1.0, + # "learning_rate_piecewise_values": [8e-5, 8e-4, 8e-5, 1e-6], + # }, + # num_epochs=400, + # gpu_mem=24, + # ) + + _torch_ckpt_path = "/work/asr3/zeineldeen/hiwis/luca.gaudino/setups-data/2023-08-10--rf-librispeech/work/i6_core/returnn/training/ReturnnTrainingJob.J6Uj9xtt1v5J/output/models/epoch.003.pt" + + model_args = { + "mel_normalization": True, + } + new_ckpt_path = tk.Path( + _torch_ckpt_path, + hash_overwrite= "rnnt" + "_torch_ckpt", + ) + new_ckpt = PtCheckpoint(new_ckpt_path) + + + # recog ctc only model + _recog( + "model_recogs/from-scratch-24gb/rnnt_beam_search/recog_results", + ModelWithCheckpoint( + definition=from_scratch_model_def, checkpoint=new_ckpt + ), + model_recog, + dev_sets=["dev"] ) # train_exp( # does not converge (wrong steps + more mistakes) diff --git a/users/gaudino/models/asr/rf/conformer_rnnt/model_recog_rnnt.py b/users/gaudino/models/asr/rf/conformer_rnnt/model_recog_rnnt.py index 5525e4369..e47145a67 100644 --- a/users/gaudino/models/asr/rf/conformer_rnnt/model_recog_rnnt.py +++ b/users/gaudino/models/asr/rf/conformer_rnnt/model_recog_rnnt.py @@ -130,35 +130,39 @@ def model_recog( # Initial state. beam_dim = Dim(1, name="initial-beam") batch_dims_ = [beam_dim] + batch_dims - decoder_state = model.decoder_default_initial_state( - batch_dims=batch_dims_, enc_spatial_dim=enc_spatial_dim - ) + target = rf.constant(model.bos_idx, dims=batch_dims_, sparse_dim=model.target_dim_w_blank) ended = rf.constant(False, dims=batch_dims_) out_seq_len = rf.constant(0, dims=batch_dims_) seq_log_prob = rf.constant(0.0, dims=batch_dims_) + blank_idx = model.target_dim.get_dim_value() + + enc_out = enc_args["enc"] + # TODO implement rnnt search temperature = 1.0 step_max_tokens = 100 - def _init_b_hypos(self, device: torch.device) -> List[Hypothesis]: - token = self.blank - state = None + def _init_b_hypos(device: torch.device) -> List[Hypothesis]: + token = blank_idx + decoder_state = model.decoder_default_initial_state( + batch_dims=batch_dims_, enc_spatial_dim=enc_spatial_dim + ) - one_tensor = torch.tensor([1], device=device) - pred_out, _, pred_state = model.predict(torch.tensor([[token]], device=device), one_tensor, state) + blank_tensor = rf.constant(blank_idx, dims=Dim(1), sparse_dim=model.target_dim_w_blank) + pred_out, _, pred_state = model.predictor(blank_tensor, decoder_state.predictor) init_hypo = ( [token], - pred_out[0].detach(), + pred_out, # pred_out[0].detach(), TODO: what is this doing? pred_state, 0.0, ) return [init_hypo] def _gen_next_token_probs( - self, enc_out: torch.Tensor, hypos: List[Hypothesis], device: torch.device + enc_out: Tensor, hypos: List[Hypothesis], device: torch.device ) -> torch.Tensor: one_tensor = torch.tensor([1], device=device) predictor_out = torch.stack([_get_hypo_predictor_out(h) for h in hypos], dim=0) @@ -168,11 +172,10 @@ def _gen_next_token_probs( predictor_out, torch.tensor([1] * len(hypos), device=device), ) # [beam_width, 1, 1, num_tokens] - joined_out = torch.nn.functional.log_softmax(joined_out / self.temperature, dim=3) + joined_out = torch.nn.functional.log_softmax(joined_out / temperature, dim=3) return joined_out[:, 0, 0] def _gen_b_hypos( - self, b_hypos: List[Hypothesis], a_hypos: List[Hypothesis], next_token_probs: torch.Tensor, @@ -199,7 +202,6 @@ def _gen_b_hypos( return [b_hypos[idx] for idx in sorted_idx] def _gen_a_hypos( - self, a_hypos: List[Hypothesis], b_hypos: List[Hypothesis], next_token_probs: torch.Tensor, @@ -230,14 +232,13 @@ def _gen_a_hypos( new_scores.append(score) if base_hypos: - new_hypos = self._gen_new_hypos(base_hypos, new_tokens, new_scores, t, device) + new_hypos = _gen_new_hypos(base_hypos, new_tokens, new_scores, t, device) else: new_hypos: List[Hypothesis] = [] return new_hypos def _gen_new_hypos( - self, base_hypos: List[Hypothesis], tokens: List[int], scores: List[float], @@ -246,7 +247,7 @@ def _gen_new_hypos( ) -> List[Hypothesis]: tgt_tokens = torch.tensor([[token] for token in tokens], device=device) states = _batch_state(base_hypos) - pred_out, _, pred_states = self.model.predict( + pred_out, _, pred_states = model.predict( tgt_tokens, torch.tensor([1] * len(base_hypos), device=device), states, @@ -257,12 +258,16 @@ def _gen_new_hypos( new_hypos.append((new_tokens, pred_out[i].detach(), _slice_state(pred_states, i, device), scores[i])) return new_hypos + # TODO: call for every seq + # for enc_out in enc_out_batched: + # from _search function - n_time_steps = enc_out.shape[1] + n_time_steps = enc_out.get_dim(1) device = enc_out.device + breakpoint() a_hypos: List[Hypothesis] = [] - b_hypos = self._init_b_hypos(device) if hypo is None else hypo + b_hypos = _init_b_hypos(device) # used for streaming: if hypo is None else hypo for t in range(n_time_steps): a_hypos = b_hypos b_hypos = torch.jit.annotate(List[Hypothesis], []) @@ -270,14 +275,14 @@ def _gen_new_hypos( symbols_current_t = 0 while a_hypos: - next_token_probs = self._gen_next_token_probs(enc_out[:, t: t + 1], a_hypos, device) + next_token_probs = _gen_next_token_probs(enc_out[:, t: t + 1], a_hypos, device) next_token_probs = next_token_probs.cpu() - b_hypos = self._gen_b_hypos(b_hypos, a_hypos, next_token_probs, key_to_b_hypo) + b_hypos = _gen_b_hypos(b_hypos, a_hypos, next_token_probs, key_to_b_hypo) - if symbols_current_t == self.step_max_tokens: + if symbols_current_t == step_max_tokens: break - a_hypos = self._gen_a_hypos( + a_hypos = _gen_a_hypos( a_hypos, b_hypos, next_token_probs, @@ -288,7 +293,7 @@ def _gen_new_hypos( if a_hypos: symbols_current_t += 1 - _, sorted_idx = torch.tensor([self.hypo_sort_key(hyp) for hyp in b_hypos]).topk(beam_width) + _, sorted_idx = torch.tensor([hypo_sort_key(hyp) for hyp in b_hypos]).topk(beam_width) b_hypos = [b_hypos[idx] for idx in sorted_idx] # return b_hypos From 9a965e58bee455fdafb828c95de82267ffab8dee Mon Sep 17 00:00:00 2001 From: schmitt Date: Thu, 6 Jun 2024 10:10:59 +0200 Subject: [PATCH 102/227] update --- .../labels/v2/librispeech/bpe/bpe.py | 11 + .../v2/librispeech/bpe/bpe_alignments.py | 38 +- .../labels/v2/librispeech/bpe/bpe_labels.py | 23 +- .../labels/v2/librispeech/label_singletons.py | 8 +- .../notes/commands | 3 +- .../pipelines/pipeline_ls_conf/alias.py | 2 +- .../global_vs_segmental_2022_23/recog_new.py | 6 + .../returnn/config_builder_rf/base.py | 25 +- .../network_builder_rf/global_/model.py | 20 +- .../global_/model_import.py | 7 + .../network_builder_rf/global_/train.py | 2 +- .../returnn/network_builder_rf/recog.py | 7 +- .../network_builder_rf/segmental/model.py | 34 +- .../segmental/model_new/blank_model/model.py | 70 +- .../segmental/model_new/blank_model/train.py | 133 ++- .../segmental/model_new/label_model/train.py | 824 +++++++++++++++++- .../network_builder_rf/segmental/recog.py | 224 ++--- .../segmental/recombination.py | 204 +++++ .../network_builder_rf/segmental/train.py | 212 +++-- .../network_builder_rf/segmental/utils.py | 6 +- .../center_window_att/baseline_v3/__init__.py | 110 ++- .../center_window_att/baseline_v3/baseline.py | 3 +- .../center_window_att/baseline_v4/__init__.py | 73 +- .../center_window_att/baseline_v4/baseline.py | 2 + .../center_window_att/config_builder.py | 11 +- .../center_window_att/recog.py | 4 +- .../center_window_att/train.py | 195 ++++- .../pipelines/pipeline_ls_conf/checkpoints.py | 21 +- .../global_att/baseline_v1/__init__.py | 37 +- .../pipeline_ls_conf/global_att/train.py | 5 +- .../model_interfaces/training.py | 19 + 31 files changed, 1975 insertions(+), 364 deletions(-) create mode 100644 users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/recombination.py diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/dependencies/labels/v2/librispeech/bpe/bpe.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/dependencies/labels/v2/librispeech/bpe/bpe.py index c16f7037a..fab669018 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/dependencies/labels/v2/librispeech/bpe/bpe.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/dependencies/labels/v2/librispeech/bpe/bpe.py @@ -1,4 +1,5 @@ from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23.dependencies.labels.v2.general import LabelDefinition +from i6_core.text.label.subword_nmt.train import ReturnnTrainBpeJob from typing import Dict from abc import ABC, abstractmethod @@ -14,3 +15,13 @@ def vocab_path(self) -> Path: @property def bpe_codes_path(self) -> Path: return Path("/u/zeineldeen/setups/librispeech/2022-11-28--conformer-att/work/i6_core/text/label/subword_nmt/train/ReturnnTrainBpeJob.vTq56NZ8STWt/output/bpe.codes") + + +class LibrispeechBPE1056(LabelDefinition, ABC): + @property + def vocab_path(self) -> Path: + return Path("/work/asr4/zeineldeen/setups-data/librispeech/2022-11-28--conformer-att/work/i6_core/text/label/subword_nmt/train/ReturnnTrainBpeJob.qhkNn2veTWkV/output/bpe.vocab") + + @property + def bpe_codes_path(self) -> Path: + return Path("/work/asr4/zeineldeen/setups-data/librispeech/2022-11-28--conformer-att/work/i6_core/text/label/subword_nmt/train/ReturnnTrainBpeJob.qhkNn2veTWkV/output/bpe.codes") diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/dependencies/labels/v2/librispeech/bpe/bpe_alignments.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/dependencies/labels/v2/librispeech/bpe/bpe_alignments.py index 87a226bad..5188c6984 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/dependencies/labels/v2/librispeech/bpe/bpe_alignments.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/dependencies/labels/v2/librispeech/bpe/bpe_alignments.py @@ -5,7 +5,7 @@ from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23.dependencies.labels.v2.general import \ SegmentalLabelDefinition from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23.dependencies.labels.v2.librispeech.bpe.bpe import \ - LibrispeechBPE10025 + LibrispeechBPE10025, LibrispeechBPE1056 from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23.dependencies.labels.v2.librispeech.general import \ LibrispeechLabelDefinition from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23.dependencies.general.hyperparameters import \ @@ -151,3 +151,39 @@ def alignment_paths(self) -> Dict[str, Path]: ) for corpus_key, alignment_path in self.librispeech_bpe_10025_ctc_alignment_instance.alignment_paths.items() } return self._alignment_paths + + +class LibrispeechBpe1056Alignment(LibrispeechBPE1056, LibrispeechLabelDefinition, SegmentalLabelDefinition): + """ + This is a forced alignment from the auxiliary CTC model in Mohammad's global AED setup (5.6% WER). + """ + def __init__(self): + super().__init__() + + self._alignment_paths = None + + @property + def model_hyperparameters(self) -> SegmentalModelHyperparameters: + return SegmentalModelHyperparameters( + sos_idx=0, target_num_labels=1056, sil_idx=None, blank_idx=0, target_num_labels_wo_blank=1055) + + @property + def rasr_format_paths(self) -> RasrFormats: + raise NotImplementedError + + @property + def alias(self) -> str: + return "att-transducer-alignment" + + @property + def alignment_paths(self) -> Dict[str, Path]: + if self._alignment_paths is None: + raise ValueError("Alignments first need to be set externally!") + return self._alignment_paths + + @alignment_paths.setter + def alignment_paths(self, value): + assert isinstance(value, dict) + assert self._alignment_paths is None, "Alignment paths are already set!" + assert "train" in value and "cv" in value and "devtrain" in value + self._alignment_paths = value diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/dependencies/labels/v2/librispeech/bpe/bpe_labels.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/dependencies/labels/v2/librispeech/bpe/bpe_labels.py index 0a9495ec1..9ec17fa04 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/dependencies/labels/v2/librispeech/bpe/bpe_labels.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/dependencies/labels/v2/librispeech/bpe/bpe_labels.py @@ -1,4 +1,4 @@ -from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23.dependencies.labels.v2.librispeech.bpe.bpe import LibrispeechBPE10025 +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23.dependencies.labels.v2.librispeech.bpe.bpe import LibrispeechBPE10025, LibrispeechBPE1056 from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23.dependencies.labels.v2.librispeech.general import LibrispeechLabelDefinition from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23.dependencies.labels.v2.general import GlobalLabelDefinition from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23.dependencies.labels.v2.librispeech.phonemes.gmm_alignments import LIBRISPEECH_GMM_ALIGNMENT @@ -16,7 +16,7 @@ class LibrispeechBPE10025Labels(LibrispeechBPE10025, LibrispeechLabelDefinition, GlobalLabelDefinition): """ - These are the BPE labels of the SWB corpus. + These are the BPE labels of the Librispeech corpus. """ def __init__(self): super().__init__() @@ -33,7 +33,7 @@ def model_hyperparameters(self) -> GlobalModelHyperparameters: class LibrispeechBPE10025LabelsWithSilence(LibrispeechBPE10025, LibrispeechLabelDefinition, GlobalLabelDefinition): """ - These are the BPE labels of the SWB corpus. + These are the BPE labels of the Librispeech corpus. """ def __init__(self, librispeech_bpe_10025_labels_instance: LibrispeechBPE10025Labels): super().__init__() @@ -92,3 +92,20 @@ def model_hyperparameters(self) -> GlobalModelHyperparameters: @property def label_paths(self) -> Dict[str, Path]: return self._label_paths + + +class LibrispeechBPE1056Labels(LibrispeechBPE1056, LibrispeechLabelDefinition, GlobalLabelDefinition): + """ + These are the BPE labels of the Librispeech corpus. + """ + def __init__(self): + super().__init__() + + @property + def alias(self) -> str: + return "bpe" + + @property + def model_hyperparameters(self) -> GlobalModelHyperparameters: + return GlobalModelHyperparameters( + sos_idx=0, target_num_labels=1056, sil_idx=None, target_num_labels_wo_blank=1056) diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/dependencies/labels/v2/librispeech/label_singletons.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/dependencies/labels/v2/librispeech/label_singletons.py index a248e57ae..0efb0cc71 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/dependencies/labels/v2/librispeech/label_singletons.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/dependencies/labels/v2/librispeech/label_singletons.py @@ -1,5 +1,9 @@ from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23.dependencies.labels.v2.librispeech.bpe.bpe_labels import LibrispeechBPE10025Labels, LibrispeechBPE10025LabelsWithSilence -from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23.dependencies.labels.v2.librispeech.bpe.bpe_alignments import LibrispeechBpe10025CtcAlignment, LibrispeechBpe10025CtcAlignmentEos +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23.dependencies.labels.v2.librispeech.bpe.bpe_alignments import ( + LibrispeechBpe10025CtcAlignment, + LibrispeechBpe10025CtcAlignmentEos, + LibrispeechBpe1056Alignment, +) from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23.dependencies.corpora.librispeech import LibrispeechCorpora @@ -9,3 +13,5 @@ LibrispeechBPE10025_LABELS_WITH_SILENCE = LibrispeechBPE10025LabelsWithSilence(LibrispeechBPE10025_LABELS) LibrispeechBPE10025_CTC_ALIGNMENT = LibrispeechBpe10025CtcAlignment() LibrispeechBPE10025_CTC_ALIGNMENT_EOS = LibrispeechBpe10025CtcAlignmentEos(LibrispeechBPE10025_CTC_ALIGNMENT) + +LibrispeechBPE1056_ALIGNMENT = LibrispeechBpe1056Alignment() diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/notes/commands b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/notes/commands index 0e7d139c5..ef4fb6c2b 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/notes/commands +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/notes/commands @@ -1,4 +1,5 @@ apptainer shell --nv -B /work/asr4 -B /work/asr3 -B /work/common -B /work/tools -B /u/berger -B /u/zeineldeen -B /u/rossenbach -B /u/beck -B /work/speech/tuske -B /u/zeyer -B /u/schmitt -B /u/atanas.gruev -B /u/zhou /work/asr4/berger/apptainer/images/i6_tensorflow-2.8_onnx-1.15.sif /work/asr4/berger/apptainer/images/i6_torch-2.2_onnx-1.16.sif -export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/lib/python3.8/dist-packages/scipy/.libs \ No newline at end of file +export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/lib/python3.8/dist-packages/scipy/.libs +export NUMBA_CACHE_DIR=/var/tmp/numba_cache_schmitt/ # librosa \ No newline at end of file diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/pipelines/pipeline_ls_conf/alias.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/pipelines/pipeline_ls_conf/alias.py index fca544222..c1f07e2ed 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/pipelines/pipeline_ls_conf/alias.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/pipelines/pipeline_ls_conf/alias.py @@ -2,4 +2,4 @@ from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23.pipelines.pipeline_ls_conf.checkpoints import default_import_model_name -alias = f"{base_alias}/ls_conformer/import_{default_import_model_name}" +alias = f"{base_alias}/ls_conformer" diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/recog_new.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/recog_new.py index a301f504c..5e88e111e 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/recog_new.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/recog_new.py @@ -246,6 +246,12 @@ def __init__( self.search_rqmt = search_rqmt if search_rqmt is not None else {} self.alias += "/returnn_decoding" if search_alias is None else f"/{search_alias}" + + use_recombination = self.recog_opts.get("use_recombination") + if use_recombination is not None: + assert use_recombination in {"sum", "max"} + self.alias += f"_w-{use_recombination}-recomb" + if isinstance(self, ReturnnSegmentalAttDecodingExperiment): length_scale = self.config_builder.variant_params["network"]["length_scale"] if length_scale != 1.0: diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/config_builder_rf/base.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/config_builder_rf/base.py index 20af5a6d8..6130a6092 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/config_builder_rf/base.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/config_builder_rf/base.py @@ -89,9 +89,20 @@ def get_train_config(self, opts: Dict): train_step_func = opts.pop("train_step_func") remaining_opt_keys = [ - "aux_loss_layers", "preload_from_files", "accum_grad_multiple_step", "optimizer", "batching", - "torch_distributed", "pos_emb_dropout", "rf_att_dropout_broadcast", "grad_scaler", "gradient_clip_global_norm", - "spec_augment_steps", "torch_amp" + "aux_loss_layers", + "preload_from_files", + "accum_grad_multiple_step", + "optimizer", + "batching", + "torch_distributed", + "pos_emb_dropout", + "rf_att_dropout_broadcast", + "grad_scaler", + "gradient_clip_global_norm", + # "specaugment_steps", + "torch_amp", + "full_sum_training_beam_size", + # "max_seq_length" ] config_dict.update( {k: opts.pop(k) for k in remaining_opt_keys if k in opts} @@ -220,6 +231,7 @@ def get_lr_settings(self, lr_opts, python_epilog: Optional[List] = None): }) elif lr_opts["type"] == "dyn_lr_piecewise_linear": _lrlin_oclr_steps_by_bs_nep = { + (3, 125): [194_000, 388_000, 430_000], # ~3450steps/ep, 125 eps -> 430k steps in total (8, 125): [139_000, 279_000, 310_000], # ~2485steps/ep, 125 eps -> 310k steps in total (8, 250): [279_000, 558_000, 621_000], # ~2485steps/ep, 250 eps -> 621k steps in total (8, 500): [558_000, 1_117_000, 1_242_000], # ~2485steps/ep, 500 eps -> 1.242k steps in total @@ -288,6 +300,7 @@ def get_train_dataset_dict(self, dataset_opts: Dict): pre_process=CodeWrapper("speed_pert") if dataset_opts.get("use_speed_pert") else None, seq_ordering=self.variant_params["config"]["train_seq_ordering"], epoch_wise_filter=dataset_opts.get("epoch_wise_filter", None), + seq_postfix=dataset_opts.get("seq_postfix", self.variant_params["dependencies"].model_hyperparameters.sos_idx), **self.get_default_dataset_opts("train", dataset_opts) ) else: @@ -307,6 +320,7 @@ def get_cv_dataset_dict(self, dataset_opts: Dict): pre_process=None, seq_ordering="sorted_reverse", epoch_wise_filter=None, + seq_postfix=dataset_opts.get("seq_postfix", self.variant_params["dependencies"].model_hyperparameters.sos_idx), **self.get_default_dataset_opts("cv", dataset_opts) ) else: @@ -326,6 +340,7 @@ def get_devtrain_dataset_dict(self, dataset_opts: Dict): pre_process=None, seq_ordering="sorted_reverse", epoch_wise_filter=None, + seq_postfix=dataset_opts.get("seq_postfix", self.variant_params["dependencies"].model_hyperparameters.sos_idx), **self.get_default_dataset_opts("devtrain", dataset_opts) ) else: @@ -516,4 +531,8 @@ def get_recog_config(self, opts: Dict): "eos_label": self.variant_params["dependencies"].model_hyperparameters.sos_idx, } + use_recombination = opts.get("use_recombination") + if use_recombination is not None: + recog_config.config["use_recombination"] = use_recombination + return recog_config diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/model.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/model.py index ed2961cd8..8af71daf3 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/model.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/model.py @@ -87,12 +87,24 @@ def __init__( class MakeModel: """for import""" - def __init__(self, in_dim: int, target_dim: int, *, eos_label: int = 0, num_enc_layers: int = 12): + def __init__( + self, + in_dim: int, + target_dim: int, + *, + eos_label: int = 0, + num_enc_layers: int = 12, + enc_aux_logits: Sequence[int] = (), + ): self.in_dim = in_dim self.target_dim = target_dim self.eos_label = eos_label self.num_enc_layers = num_enc_layers + # do not set attribute otherwise to keep job hashes + if enc_aux_logits != (): + self.enc_aux_logits = enc_aux_logits + def __call__(self) -> GlobalAttentionModel: from returnn.datasets.util.vocabulary import Vocabulary @@ -102,7 +114,11 @@ def __call__(self) -> GlobalAttentionModel: [str(i) for i in range(target_dim.dimension)], eos_label=self.eos_label ) - return self.make_model(in_dim, target_dim, num_enc_layers=self.num_enc_layers) + extra = {} + if hasattr(self, "enc_aux_logits"): + extra["enc_aux_logits"] = self.enc_aux_logits + + return self.make_model(in_dim, target_dim, num_enc_layers=self.num_enc_layers, **extra) @classmethod def make_model( diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/model_import.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/model_import.py index 041ab883a..8964adc04 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/model_import.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/model_import.py @@ -103,6 +103,13 @@ def _add_params(): _ParamMapping[ f"encoder.layers.{layer_idx}.final_layer_norm.bias" ] = f"conformer_block_{layer_idx + 1:02d}_ln/bias" + # ctc + _ParamMapping[ + f"encoder.enc_aux_logits_{layer_idx}.weight" + ] = f"ctc/W" + _ParamMapping[ + f"encoder.enc_aux_logits_{layer_idx}.bias" + ] = f"ctc/b" _add_params() diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/train.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/train.py index a2a1391d3..b068dc565 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/train.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/train.py @@ -118,7 +118,7 @@ def from_scratch_training( for i, layer_idx in enumerate(aux_loss_layers): if layer_idx > len(model.encoder.layers): continue - linear = getattr(model, f"enc_aux_logits_{layer_idx}") + linear = getattr(model.encoder, f"enc_aux_logits_{layer_idx}") aux_logits = linear(collected_outputs[str(layer_idx - 1)]) aux_loss = rf.ctc_loss( logits=aux_logits, diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/recog.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/recog.py index 37a07cc37..902ee0481 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/recog.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/recog.py @@ -24,8 +24,11 @@ def _returnn_v2_forward_step(*, model, extern_data: TensorDict, **_kwargs_unused default_target_key = config.typed_value("target") targets = extern_data[default_target_key] extra.update(dict(targets=targets, targets_spatial_dim=targets.get_time_dim_tag())) - if config.bool("use_recombination", False): - extra.update(dict(use_recombination=True)) + + use_recombination = config.typed_value("use_recombination", None) + if use_recombination: + extra.update(dict(use_recombination=use_recombination)) + recog_out = recog_def(model=model, data=data, data_spatial_dim=data_spatial_dim, **extra) if len(recog_out) == 5: # recog results including beam {batch, beam, out_spatial}, diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model.py index 55f63067a..7e441184c 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model.py @@ -9,6 +9,8 @@ from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model_new.blank_model.model import ( BlankDecoderV1, BlankDecoderV3, + BlankDecoderV5, + BlankDecoderV6, ) from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model_new.label_model.model import ( SegmentalAttLabelDecoder, SegmentalAttEfficientLabelDecoder @@ -65,7 +67,7 @@ def __init__( l2=l2, ) - assert blank_decoder_version in {1, 3, 4} + assert blank_decoder_version in {1, 3, 4, 5, 6} assert label_decoder_state in {"nb-lstm", "joint-lstm"} if not use_joint_model: assert label_decoder_state == "nb-lstm" @@ -96,13 +98,24 @@ def __init__( align_target_dim=align_target_dim, encoder_out_dim=self.encoder.out_dim, ) - else: + elif blank_decoder_version in {3, 4}: # the logic for blank_decoder_version == 4 is in the train/recog code self.blank_decoder = BlankDecoderV3( length_model_state_dim=length_model_state_dim, label_state_dim=self.label_decoder.get_lstm().out_dim, encoder_out_dim=self.encoder.out_dim, ) + elif blank_decoder_version == 5: + self.blank_decoder = BlankDecoderV5( + label_state_dim=self.label_decoder.get_lstm().out_dim, + encoder_out_dim=self.encoder.out_dim, + ) + else: + self.blank_decoder = BlankDecoderV6( + length_model_state_dim=length_model_state_dim, + label_state_dim=self.label_decoder.get_lstm().out_dim, + encoder_out_dim=self.encoder.out_dim, + ) else: self.blank_decoder = None @@ -287,3 +300,20 @@ def _returnn_v2_get_model(*, epoch: int, **_kwargs_unused): model = model_def( epoch=epoch, in_dim=data.feature_dim, align_target_dim=targets.sparse_dim, target_dim=non_blank_targets.sparse_dim) return model + + +def _returnn_v2_get_model_for_full_sum_training(*, epoch: int, **_kwargs_unused): + from returnn.tensor import Tensor, Dim + from returnn.config import get_global_config + + config = get_global_config() + default_input_key = config.typed_value("default_input") + default_target_key = config.typed_value("target") + extern_data_dict = config.typed_value("extern_data") + data = Tensor(name=default_input_key, **extern_data_dict[default_input_key]) + targets = Tensor(name=default_target_key, **extern_data_dict[default_target_key]) + + model_def = config.typed_value("_model_def") + model = model_def( + epoch=epoch, in_dim=data.feature_dim, align_target_dim=targets.sparse_dim, target_dim=targets.sparse_dim) + return model diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/blank_model/model.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/blank_model/model.py index 746349237..3954b544f 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/blank_model/model.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/blank_model/model.py @@ -11,11 +11,9 @@ class BlankDecoderBase(rf.Module, ABC): - def __init__(self, length_model_state_dim: Dim): + def __init__(self): super(BlankDecoderBase, self).__init__() - self.length_model_state_dim = length_model_state_dim self.emit_prob_dim = Dim(name="emit_prob", dimension=1) - self.emit_prob = rf.Linear(self.length_model_state_dim, self.emit_prob_dim) @property @abstractmethod @@ -55,11 +53,6 @@ def _get_am(enc: rf.Tensor, enc_spatial_dim: Dim, state: rf.State, spatial_dim) return rf.gather(enc, axis=enc_spatial_dim, indices=i, clip_to_valid=clip_to_valid) - def decode_logits(self, *, s_blank: Tensor) -> Tensor: - """logits for the decoder""" - logits = self.emit_prob(s_blank) - return logits - def get_label_decoder_deps(self) -> Optional[List[str]]: return None @@ -72,10 +65,9 @@ def __init__( align_target_dim: Dim, encoder_out_dim: Dim, ): - super(BlankDecoderV1, self).__init__(length_model_state_dim=length_model_state_dim) + super(BlankDecoderV1, self).__init__() self.length_model_state_dim = length_model_state_dim self.length_model_embed_dim = length_model_embed_dim - self.emit_prob_dim = Dim(name="emit_prob", dimension=1) self.target_embed = rf.Embedding(align_target_dim, self.length_model_embed_dim) self.s = rf.LSTM( @@ -125,10 +117,9 @@ def __init__( label_state_dim: Dim, encoder_out_dim: Dim, ): - super(BlankDecoderV2, self).__init__(length_model_state_dim=length_model_state_dim) + super(BlankDecoderV2, self).__init__() self.length_model_state_dim = length_model_state_dim self.length_model_embed_dim = length_model_embed_dim - self.emit_prob_dim = Dim(name="emit_prob", dimension=1) self.target_embed = rf.Embedding(target_dim, self.length_model_embed_dim) self.s = rf.LSTM( @@ -164,6 +155,11 @@ def loop_step( return {"s_blank": s_blank}, state_ + def decode_logits(self, *, s_blank: Tensor) -> Tensor: + """logits for the decoder""" + logits = self.emit_prob(s_blank) + return logits + def get_label_decoder_deps(self) -> Optional[List[str]]: return ["s"] @@ -175,9 +171,8 @@ def __init__( label_state_dim: Dim, encoder_out_dim: Dim, ): - super(BlankDecoderV3, self).__init__(length_model_state_dim=length_model_state_dim) + super(BlankDecoderV3, self).__init__() self.length_model_state_dim = length_model_state_dim - self.emit_prob_dim = Dim(name="emit_prob", dimension=1) self.s = rf.LSTM( encoder_out_dim + label_state_dim, @@ -211,5 +206,52 @@ def loop_step( return {"s_blank": s_blank}, state_ + def decode_logits(self, *, s_blank: Tensor) -> Tensor: + """logits for the decoder""" + logits = self.emit_prob(s_blank) + return logits + + def get_label_decoder_deps(self) -> Optional[List[str]]: + return ["s"] + + +class BlankDecoderV5(BlankDecoderBase): + @property + def _s(self) -> rf.LSTM: + raise NotImplementedError + + def __init__( + self, + label_state_dim: Dim, + encoder_out_dim: Dim, + ): + super(BlankDecoderV5, self).__init__() + + self.emit_prob = rf.Linear(encoder_out_dim + label_state_dim, self.emit_prob_dim) + + def get_label_decoder_deps(self) -> Optional[List[str]]: + return ["s"] + + +class BlankDecoderV6(BlankDecoderBase): + def __init__( + self, + length_model_state_dim: Dim, + label_state_dim: Dim, + encoder_out_dim: Dim, + ): + super(BlankDecoderV6, self).__init__() + self.length_model_state_dim = length_model_state_dim + + self.s = rf.LSTM( + encoder_out_dim, + self.length_model_state_dim, + ) + self.emit_prob = rf.Linear(self.length_model_state_dim + label_state_dim, self.emit_prob_dim) + + @property + def _s(self) -> rf.LSTM: + return self.s + def get_label_decoder_deps(self) -> Optional[List[str]]: return ["s"] diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/blank_model/train.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/blank_model/train.py index 101330b4e..0d961b411 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/blank_model/train.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/blank_model/train.py @@ -3,22 +3,23 @@ from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model_new.blank_model.model import ( BlankDecoderV1, BlankDecoderV3, + BlankDecoderV5, + BlankDecoderV6, BlankDecoderBase ) +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental import utils from returnn.tensor import Dim import returnn.frontend as rf -def decode_logits( +def get_packed_logits_and_emit_ground_truth( *, - model: BlankDecoderBase, - blank_loop_out: Dict, + blank_logits: rf.Tensor, align_targets_spatial_dim: Dim, emit_ground_truth: rf.Tensor, batch_dims: List[Dim] ): - blank_logits = model.decode_logits(**blank_loop_out) blank_logits_packed, pack_dim = rf.pack_padded( blank_logits, dims=batch_dims + [align_targets_spatial_dim], enforce_sorted=False) emit_ground_truth_packed, _ = rf.pack_padded( @@ -77,9 +78,8 @@ def viterbi_training( spatial_dim=align_targets_spatial_dim, ) - blank_logits_packed, pack_dim, emit_ground_truth_packed = decode_logits( - model=model, - blank_loop_out=blank_loop_out, + blank_logits_packed, pack_dim, emit_ground_truth_packed = get_packed_logits_and_emit_ground_truth( + blank_logits=model.decode_logits(**blank_loop_out), align_targets_spatial_dim=align_targets_spatial_dim, emit_ground_truth=emit_ground_truth, batch_dims=batch_dims @@ -112,9 +112,8 @@ def viterbi_training_v3( spatial_dim=label_states_unmasked_spatial_dim, ) - blank_logits_packed, pack_dim, emit_ground_truth_packed = decode_logits( - model=model, - blank_loop_out=blank_loop_out, + blank_logits_packed, pack_dim, emit_ground_truth_packed = get_packed_logits_and_emit_ground_truth( + blank_logits=model.decode_logits(**blank_loop_out), align_targets_spatial_dim=label_states_unmasked_spatial_dim, emit_ground_truth=emit_ground_truth, batch_dims=batch_dims @@ -128,16 +127,126 @@ def viterbi_training_v3( ) -# TODO: implement viterbi_training_v4 def viterbi_training_v4( *, model: BlankDecoderV3, enc_args: Dict, enc_spatial_dim: Dim, + label_states: rf.Tensor, + label_states_spatial_dim: Dim, + non_blank_mask: rf.Tensor, + non_blank_mask_dim: Dim, + non_blank_targets_spatial_dim: Dim, + emit_ground_truth: rf.Tensor, + emit_blank_target_dim: Dim, + batch_dims: List[Dim], +): + enc_spatial_dim.declare_same_as(non_blank_mask_dim) + am, _ = utils.get_masked( + input=enc_args["enc"], + mask=non_blank_mask, + mask_dim=non_blank_mask_dim, + batch_dims=batch_dims, + result_spatial_dim=non_blank_targets_spatial_dim, + ) + + singleton_dim = Dim(name="singleton", dimension=1) + first_enc_frame = rf.gather( + enc_args["enc"], + indices=rf.convert_to_tensor(0, dtype="int32"), + axis=enc_spatial_dim, + ) + first_enc_frame = rf.expand_dim(first_enc_frame, singleton_dim) + am, _ = rf.concat( + (first_enc_frame, singleton_dim), + (am, non_blank_targets_spatial_dim), + out_dim=label_states_spatial_dim + ) + + s, _ = model.s( + rf.concat_features(am, label_states), + state=model.s.default_initial_state(batch_dims=batch_dims), + spatial_dim=label_states_spatial_dim + ) + + s_unmasked = utils.get_unmasked( + s, + input_spatial_dim=label_states_spatial_dim, + mask=non_blank_mask, + mask_spatial_dim=non_blank_mask_dim + ) + + blank_logits_packed, pack_dim, emit_ground_truth_packed = get_packed_logits_and_emit_ground_truth( + blank_logits=model.decode_logits(s_blank=s_unmasked), + align_targets_spatial_dim=enc_spatial_dim, + emit_ground_truth=emit_ground_truth, + batch_dims=batch_dims + ) + + calc_loss( + blank_logits_packed=blank_logits_packed, + emit_ground_truth_packed=emit_ground_truth_packed, + emit_blank_target_dim=emit_blank_target_dim, + pack_dim=pack_dim + ) + + +def viterbi_training_v5( + *, + model: BlankDecoderV5, + enc_args: Dict, + enc_spatial_dim: Dim, + label_states_unmasked: rf.Tensor, + label_states_unmasked_spatial_dim: Dim, + emit_ground_truth: rf.Tensor, + emit_blank_target_dim: Dim, + batch_dims: List[Dim], +): + enc_spatial_dim.declare_same_as(label_states_unmasked_spatial_dim) + blank_logits = model.emit_prob(rf.concat_features(enc_args["enc"], label_states_unmasked)) + blank_logits_packed, pack_dim, emit_ground_truth_packed = get_packed_logits_and_emit_ground_truth( + blank_logits=blank_logits, + align_targets_spatial_dim=enc_spatial_dim, + emit_ground_truth=emit_ground_truth, + batch_dims=batch_dims + ) + + calc_loss( + blank_logits_packed=blank_logits_packed, + emit_ground_truth_packed=emit_ground_truth_packed, + emit_blank_target_dim=emit_blank_target_dim, + pack_dim=pack_dim + ) + + +def viterbi_training_v6( + *, + model: BlankDecoderV6, + enc_args: Dict, + enc_spatial_dim: Dim, label_states_unmasked: rf.Tensor, label_states_unmasked_spatial_dim: Dim, emit_ground_truth: rf.Tensor, emit_blank_target_dim: Dim, batch_dims: List[Dim], ): - pass + enc_spatial_dim.declare_same_as(label_states_unmasked_spatial_dim) + s, _ = model.s( + enc_args["enc"], + state=model.s.default_initial_state(batch_dims=batch_dims,), + spatial_dim=enc_spatial_dim + ) + blank_logits = model.emit_prob(rf.concat_features(s, label_states_unmasked)) + blank_logits_packed, pack_dim, emit_ground_truth_packed = get_packed_logits_and_emit_ground_truth( + blank_logits=blank_logits, + align_targets_spatial_dim=enc_spatial_dim, + emit_ground_truth=emit_ground_truth, + batch_dims=batch_dims + ) + + calc_loss( + blank_logits_packed=blank_logits_packed, + emit_ground_truth_packed=emit_ground_truth_packed, + emit_blank_target_dim=emit_blank_target_dim, + pack_dim=pack_dim + ) diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/label_model/train.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/label_model/train.py index 94468db9a..52fb27d5b 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/label_model/train.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/label_model/train.py @@ -1,6 +1,10 @@ from typing import Optional, Dict, Any, Sequence, Tuple, List +import tree + +import torch from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental import utils +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental import recombination from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model_new.label_model.model import ( SegmentalAttLabelDecoder, SegmentalAttEfficientLabelDecoder @@ -8,6 +12,7 @@ from returnn.tensor import Dim, single_step_dim import returnn.frontend as rf +from returnn.frontend.tensor_array import TensorArray from i6_experiments.users.schmitt.returnn_frontend.model_interfaces.training import TrainDef @@ -104,9 +109,10 @@ def _label_loop_body(xs, state: rf.State): segment_lens=final_state.decoder.segment_lens, state=final_state.decoder, ) + singleton_dim = Dim(name="singleton", dimension=1) return rf.concat( (label_loop_out["s"], non_blank_targets_spatial_dim), - (rf.expand_dim(last_loop_out["s"], single_step_dim), single_step_dim), + (rf.expand_dim(last_loop_out["s"], singleton_dim), singleton_dim), ) return None @@ -187,14 +193,15 @@ def viterbi_training_efficient( targets_spatial_dim.get_size_tensor() - 1, input_embeddings.device), clip_to_valid=True, ) + singleton_dim = Dim(name="singleton", dimension=1) last_lstm_out, _ = model.s_wo_att( last_embedding, state=final_state, - spatial_dim=single_step_dim, + spatial_dim=singleton_dim, ) return rf.concat( (label_lstm_out, targets_spatial_dim), - (rf.expand_dim(last_lstm_out, single_step_dim), single_step_dim), + (rf.expand_dim(last_lstm_out, singleton_dim), singleton_dim), ) return None @@ -205,35 +212,199 @@ def full_sum_training( model: SegmentalAttEfficientLabelDecoder, enc_args: Dict, enc_spatial_dim: Dim, - non_blank_targets: rf.Tensor, + non_blank_targets: rf.Tensor, # [B, S, V] non_blank_targets_spatial_dim: Dim, - segment_starts: rf.Tensor, - segment_lens: rf.Tensor, + segment_starts: rf.Tensor, # [B, T] + segment_lens: rf.Tensor, # [B, T] batch_dims: List[Dim], ) -> Optional[Dict[str, Tuple[rf.Tensor, Dim]]]: - # print("full_sum_training") - # print("model", model) + non_blank_input_embeddings = model.target_embed(non_blank_targets) # [B, S, D] + singleton_dim = Dim(name="singleton", dimension=1) + singleton_zeros = rf.zeros(batch_dims + [singleton_dim, model.target_embed.out_dim]) + non_blank_input_embeddings_shifted, non_blank_targets_spatial_dim_ext = rf.concat( + (singleton_zeros, singleton_dim), + (non_blank_input_embeddings, non_blank_targets_spatial_dim), + allow_broadcast=True + ) # [B, S+1, D] + non_blank_input_embeddings_shifted.feature_dim = non_blank_input_embeddings.feature_dim + + label_lstm_out, _ = model.s_wo_att( + non_blank_input_embeddings_shifted, + state=model.s_wo_att.default_initial_state(batch_dims=batch_dims), + spatial_dim=non_blank_targets_spatial_dim_ext, + ) # [B, S+1, D] - import torch - from torch.profiler import profile, record_function, ProfilerActivity + att = model( + enc=enc_args["enc"], + enc_ctx=enc_args["enc_ctx"], + enc_spatial_dim=enc_spatial_dim, + s=label_lstm_out, + segment_starts=segment_starts, + segment_lens=segment_lens, + ) # [B, S+1, T, D] - with profile(activities=[ProfilerActivity.CPU, ProfilerActivity.CUDA], record_shapes=True, profile_memory=True) as prof: + logits = model.decode_logits( + input_embed=non_blank_input_embeddings_shifted, + att=att, + s=label_lstm_out, + ) # [B, S+1, T, D] - non_blank_input_embeddings = model.target_embed(non_blank_targets) # [B, S, D] - singleton_dim = Dim(name="singleton", dimension=1) - singleton_zeros = rf.zeros(batch_dims + [singleton_dim, model.target_embed.out_dim]) - non_blank_input_embeddings_shifted, non_blank_targets_spatial_dim_ext = rf.concat( - (singleton_zeros, singleton_dim), - (non_blank_input_embeddings, non_blank_targets_spatial_dim), - allow_broadcast=True - ) # [B, S+1, D] - non_blank_input_embeddings_shifted.feature_dim = non_blank_input_embeddings.feature_dim - - label_lstm_out, _ = model.s_wo_att( - non_blank_input_embeddings_shifted, - state=model.s_wo_att.default_initial_state(batch_dims=batch_dims), - spatial_dim=non_blank_targets_spatial_dim_ext, - ) # [B, S+1, D] + + logits_packed, pack_dim = rf.pack_padded( + logits, + dims=batch_dims + [enc_spatial_dim, non_blank_targets_spatial_dim_ext], + enforce_sorted=False + ) # [B * T * (S+1), D] + + from returnn.extern_private.BergerMonotonicRNNT.monotonic_rnnt.pytorch_binding import monotonic_rnnt_loss + + loss = monotonic_rnnt_loss( + acts=logits_packed.raw_tensor, + labels=non_blank_targets.copy_transpose(batch_dims + [non_blank_targets_spatial_dim]).raw_tensor, + input_lengths=rf.copy_to_device(enc_spatial_dim.dyn_size_ext, logits.device).raw_tensor, + label_lengths=rf.copy_to_device(non_blank_targets_spatial_dim.dyn_size_ext, logits.device).raw_tensor.int(), + blank_label=model.blank_idx, + ) + + loss = rf.convert_to_tensor(loss, name="full_sum_loss") + loss.mark_as_loss("full_sum_loss", scale=1.0, use_normalized_loss=True) + + return None + + +def full_sum_training_w_beam( + *, + model: SegmentalAttEfficientLabelDecoder, + enc_args: Dict, + enc_spatial_dim: Dim, + non_blank_targets: rf.Tensor, # [B, S, V] + non_blank_targets_spatial_dim: Dim, + # segment_starts: rf.Tensor, # [B, T] + # segment_lens: rf.Tensor, # [B, T] + batch_dims: List[Dim], + beam_size: int, +) -> Optional[Dict[str, Tuple[rf.Tensor, Dim]]]: + assert len(batch_dims) == 1, "not supported yet" + + non_blank_input_embeddings = model.target_embed(non_blank_targets) # [B, S, D] + non_blank_input_embeddings, non_blank_targets_padded_spatial_dim = rf.pad( + non_blank_input_embeddings, + axes=[non_blank_targets_spatial_dim], + padding=[(1, 0)], + value=0.0, + ) + non_blank_targets_padded_spatial_dim = non_blank_targets_padded_spatial_dim[0] + + # add blank idx on the right + # this way, when the label index for gathering reached the last non-blank index, it will gather blank after that + # which then only allows corresponding hypotheses to be extended by blank + non_blank_targets_padded, _ = rf.pad( + non_blank_targets, + axes=[non_blank_targets_spatial_dim], + padding=[(0, 1)], + value=model.blank_idx, + out_dims=[non_blank_targets_padded_spatial_dim] + ) + + non_blank_targets_padded_sizes = rf.copy_to_device( + non_blank_targets_padded_spatial_dim.dyn_size_ext, non_blank_targets.device + ) + non_blank_targets_spatial_sizes = rf.copy_to_device( + non_blank_targets_spatial_dim.dyn_size_ext, non_blank_targets.device) + enc_spatial_sizes = rf.copy_to_device(enc_spatial_dim.dyn_size_ext, non_blank_targets.device) + + linear_label_positions = enc_spatial_sizes / non_blank_targets_spatial_sizes + linear_label_positions = linear_label_positions * rf.range_over_dim(non_blank_targets_spatial_dim) + # print("linear_label_positions", linear_label_positions.raw_tensor) + # exit() + + # print("non_blank_targets_padded", non_blank_targets_padded.raw_tensor) + + beam_dim = Dim(1, name="initial-beam") + batch_dims_ = [beam_dim] + batch_dims + bos_idx = 0 + seq_log_prob = rf.constant(0.0, dims=batch_dims_) + + max_seq_len = enc_spatial_dim.get_size_tensor() + max_seq_len = rf.reduce_max(max_seq_len, axis=max_seq_len.dims) + + label_lstm_state = model.s_wo_att.default_initial_state(batch_dims=batch_dims_) + target = rf.constant(bos_idx, dims=batch_dims_, sparse_dim=model.target_dim) + # target_non_blank = target.copy() + update_state_mask = rf.convert_to_tensor(target != model.blank_idx) + label_indices = rf.zeros(batch_dims_, dtype="int64") + + # input_embed = rf.zeros( + # batch_dims_ + [model.target_embed.out_dim], + # feature_dim=model.target_embed.out_dim, + # dtype="float32" + # ) + + vocab_range = rf.range_over_dim(model.target_dim) + blank_tensor = rf.convert_to_tensor(model.blank_idx, dtype=vocab_range.dtype) + log_lambda = rf.log(rf.convert_to_tensor(0.004)) * rf.ones([model.target_dim], dtype="float32") + # lambda_ = rf.shift_right(lambda_, axis=model.target_dim, pad_value=0.0) + log_lambda = rf.where( + vocab_range == model.blank_idx, + rf.constant(0.0, dims=[model.target_dim], dtype="float32"), + log_lambda + ) + + old_beam_dim = beam_dim.copy() + backrefs = rf.zeros(batch_dims_, dtype="int32") + + i = 0 + seq_targets = [] + seq_backrefs = [] + while i < max_seq_len.raw_tensor: + if i > 0: + # target_non_blank = rf.where(update_state_mask, target, rf.gather(target_non_blank, indices=backrefs)) + # input_embed = rf.where( + # update_state_mask, + # model.target_embed(target_non_blank), + # rf.gather(input_embed, indices=backrefs) + # ) + prev_label_indices = rf.gather(label_indices, indices=backrefs) + label_indices = rf.where( + update_state_mask, + rf.where( + prev_label_indices == non_blank_targets_padded_sizes - 1, + prev_label_indices, + prev_label_indices + 1 + ), + prev_label_indices + ) + + ground_truth = rf.gather( + non_blank_targets_padded, + indices=label_indices, + axis=non_blank_targets_padded_spatial_dim, + clip_to_valid=True + ) + input_embed = rf.gather( + non_blank_input_embeddings, + indices=label_indices, + axis=non_blank_targets_padded_spatial_dim, + clip_to_valid=True + ) + + label_lstm_out, label_lstm_state_updated = model.s_wo_att( + input_embed, + state=label_lstm_state, + spatial_dim=single_step_dim, + ) + + center_position = rf.minimum( + rf.full(dims=[beam_dim] + batch_dims, fill_value=i, dtype="int32"), + rf.copy_to_device(enc_spatial_dim.get_size_tensor() - 1, label_lstm_out.device) + ) + segment_starts = rf.maximum( + rf.convert_to_tensor(0, dtype="int32"), center_position - model.center_window_size // 2) + segment_ends = rf.minimum( + rf.copy_to_device(enc_spatial_dim.get_size_tensor() - 1, label_lstm_out.device), + center_position + model.center_window_size // 2 + ) + segment_lens = segment_ends - segment_starts + 1 att = model( enc=enc_args["enc"], @@ -243,41 +414,602 @@ def full_sum_training( segment_starts=segment_starts, segment_lens=segment_lens, ) # [B, S+1, T, D] + # print("att", att) logits = model.decode_logits( - input_embed=non_blank_input_embeddings_shifted, + input_embed=input_embed, att=att, s=label_lstm_out, ) # [B, S+1, T, D] + # print("logits", logits) + + label_log_prob = rf.log_softmax(logits, axis=model.target_dim) + + def custom_backward(grad): + grad[:, :, 0] *= 0.001 + return grad + + if rf.get_run_ctx().train_flag: + label_log_prob.raw_tensor.register_hook(custom_backward) + + # log prob needs to correspond to the next non-blank label... + log_prob_mask = vocab_range == ground_truth + rem_frames = enc_spatial_sizes - i + rem_labels = non_blank_targets_spatial_sizes - label_indices + # ... or to blank if there are more frames than labels left + log_prob_mask = rf.logical_or( + log_prob_mask, + rf.logical_and( + vocab_range == blank_tensor, + rem_frames > rem_labels + ) + ) + label_log_prob = rf.where( + log_prob_mask, + label_log_prob, + rf.constant(-float("inf"), dims=batch_dims + [beam_dim, model.target_dim]) + ) - print("logits", logits.raw_tensor.shape) + seq_log_prob = seq_log_prob + label_log_prob # Batch, InBeam, Vocab + old_beam_dim = beam_dim.copy() + seq_log_prob, (backrefs, target), beam_dim = rf.top_k( + seq_log_prob, + k_dim=Dim(beam_size, name=f"dec-step{i}-beam"), + axis=[beam_dim, model.target_dim] + ) # seq_log_prob, backrefs, target: Batch, Beam + seq_targets.append(target) + seq_backrefs.append(backrefs) + + update_state_mask = rf.logical_and( + rf.convert_to_tensor(target != model.blank_idx), + seq_log_prob != rf.convert_to_tensor(-float("inf"), dtype="float32") + ) - logits_packed, pack_dim = rf.pack_padded( - logits, - dims=batch_dims + [enc_spatial_dim, non_blank_targets_spatial_dim_ext], - enforce_sorted=False - ) # [B * T * (S+1), D] + def _get_masked_state(old, new, mask): + old = rf.gather(old, indices=backrefs, axis=old_beam_dim) + new = rf.gather(new, indices=backrefs, axis=old_beam_dim) + return rf.where(mask, new, old) - print("logits_packed", logits_packed.raw_tensor.shape) + label_lstm_state = tree.map_structure( + lambda old_state, new_state: _get_masked_state(old_state, new_state, update_state_mask), + label_lstm_state, label_lstm_state_updated + ) - print(prof.key_averages(group_by_input_shape=True).table(sort_by="self_cuda_memory_usage", row_limit=10)) - exit() + i += 1 + + # # Backtrack via backrefs, resolve beams. + # seq_targets_ = [] + # indices = rf.range_over_dim(beam_dim) # FinalBeam -> FinalBeam + # for backrefs, target in zip(seq_backrefs[::-1], seq_targets[::-1]): + # # indices: FinalBeam -> Beam + # # backrefs: Beam -> PrevBeam + # seq_targets_.insert(0, rf.gather(target, indices=indices)) + # indices = rf.gather(backrefs, indices=indices) # FinalBeam -> PrevBeam + # + # seq_targets__ = TensorArray(seq_targets_[0]) + # for target in seq_targets_: + # seq_targets__ = seq_targets__.push_back(target) + # seq_targets = seq_targets__.stack(axis=enc_spatial_dim) + + # torch.set_printoptions(threshold=10_000) + # print("seq_targets", seq_targets.copy_transpose(batch_dims + [beam_dim, enc_spatial_dim]).raw_tensor[0, 0]) + # print("seq_log_prob", seq_log_prob.raw_tensor[0]) + + # calculate full-sum loss using the log-sum-exp trick + max_log_prob = rf.reduce_max(seq_log_prob, axis=beam_dim) + loss = -1 * (max_log_prob + rf.log(rf.reduce_sum(rf.exp(seq_log_prob - max_log_prob), axis=beam_dim))) + + # loss = -rf.log(rf.reduce_sum(rf.exp(seq_log_prob), axis=beam_dim)) + loss.mark_as_loss("full_sum_loss", scale=1.0, use_normalized_loss=True) - from returnn.extern_private.BergerMonotonicRNNT.monotonic_rnnt.pytorch_binding import monotonic_rnnt_loss + return None - loss = monotonic_rnnt_loss( - acts=logits_packed.raw_tensor, - labels=non_blank_targets.copy_transpose(batch_dims + [non_blank_targets_spatial_dim]).raw_tensor, - input_lengths=rf.copy_to_device(enc_spatial_dim.dyn_size_ext, logits.device).raw_tensor, - label_lengths=rf.copy_to_device(non_blank_targets_spatial_dim.dyn_size_ext, logits.device).raw_tensor.int(), - blank_label=model.blank_idx, + +def full_sum_training_w_beam_eff( + *, + model: SegmentalAttEfficientLabelDecoder, + enc_args: Dict, + enc_spatial_dim: Dim, + non_blank_targets: rf.Tensor, # [B, S, V] + non_blank_targets_spatial_dim: Dim, + segment_starts: rf.Tensor, # [B, T] + segment_lens: rf.Tensor, # [B, T] + batch_dims: List[Dim], + beam_size: int, +) -> Optional[Dict[str, Tuple[rf.Tensor, Dim]]]: + assert len(batch_dims) == 1, "not supported yet" + assert model.blank_idx == 0, "blank idx needs to be zero because of the way the gradient is scaled" + + # ------------------------ init some variables ------------------------ + beam_dim = Dim(1, name="initial-beam") + batch_dims_ = [beam_dim] + batch_dims + bos_idx = 0 + seq_log_prob = rf.constant(0.0, dims=batch_dims_) + max_seq_len = enc_spatial_dim.get_size_tensor() + max_seq_len = rf.reduce_max(max_seq_len, axis=max_seq_len.dims) + label_lstm_state = model.s_wo_att.default_initial_state(batch_dims=batch_dims) + target = rf.constant(bos_idx, dims=batch_dims_, sparse_dim=model.target_dim) + update_state_mask = rf.convert_to_tensor(target != model.blank_idx) + label_indices = rf.zeros(batch_dims_, dtype="int32") + vocab_range = rf.range_over_dim(model.target_dim) + blank_tensor = rf.convert_to_tensor(model.blank_idx, dtype=vocab_range.dtype) + backrefs = rf.zeros(batch_dims_, dtype="int32") + seq_hash = rf.constant(0, dims=batch_dims_, dtype="int64") + + # ------------------------ targets/embeddings ------------------------ + + non_blank_input_embeddings = model.target_embed(non_blank_targets) # [B, S, D] + non_blank_input_embeddings, non_blank_targets_padded_spatial_dim = rf.pad( + non_blank_input_embeddings, + axes=[non_blank_targets_spatial_dim], + padding=[(1, 0)], + value=0.0, + ) # [B, S+1, D] + non_blank_targets_padded_spatial_dim = non_blank_targets_padded_spatial_dim[0] + + # add blank idx on the right + # this way, when the label index for gathering reached the last non-blank index, it will gather blank after that + # which then only allows corresponding hypotheses to be extended by blank + non_blank_targets_padded, _ = rf.pad( + non_blank_targets, + axes=[non_blank_targets_spatial_dim], + padding=[(0, 1)], + value=model.blank_idx, + out_dims=[non_blank_targets_padded_spatial_dim] ) - # print("loss", loss.shape) + # ------------------------ sizes ------------------------ - exit() + non_blank_targets_padded_spatial_sizes = rf.copy_to_device( + non_blank_targets_padded_spatial_dim.dyn_size_ext, non_blank_targets.device + ) + non_blank_targets_spatial_sizes = rf.copy_to_device( + non_blank_targets_spatial_dim.dyn_size_ext, non_blank_targets.device) + max_num_labels = rf.reduce_max( + non_blank_targets_spatial_sizes, axis=non_blank_targets_spatial_sizes.dims + ).raw_tensor.item() + enc_spatial_sizes = rf.copy_to_device(enc_spatial_dim.dyn_size_ext, non_blank_targets.device) + + # ------------------------ compute LSTM sequence ------------------------ + + label_lstm_out_seq, _ = model.s_wo_att( + non_blank_input_embeddings, + state=label_lstm_state, + spatial_dim=non_blank_targets_padded_spatial_dim, + ) - loss = rf.convert_to_tensor(loss, name="full_sum_loss") + # ------------------------ chunk dim ------------------------ + + chunk_size = 20 + chunk_dim = Dim(chunk_size, name="chunk") + chunk_range = rf.expand_dim(rf.range_over_dim(chunk_dim), batch_dims[0]) + + i = 0 + seq_targets = [] + seq_backrefs = [] + while i < max_seq_len.raw_tensor: + # get current number of labels for each hypothesis + if i > 0: + prev_label_indices = rf.gather(label_indices, indices=backrefs) + label_indices = rf.where( + update_state_mask, + rf.where( + prev_label_indices == non_blank_targets_padded_spatial_sizes - 1, + prev_label_indices, + prev_label_indices + 1 + ), + prev_label_indices + ) + + # gather ground truth, input embeddings and LSTM output for current label index + ground_truth = rf.gather( + non_blank_targets_padded, + indices=label_indices, + axis=non_blank_targets_padded_spatial_dim, + clip_to_valid=True + ) + input_embed = rf.gather( + non_blank_input_embeddings, + indices=label_indices, + axis=non_blank_targets_padded_spatial_dim, + clip_to_valid=True + ) + label_lstm_out = rf.gather( + label_lstm_out_seq, + indices=label_indices, + axis=non_blank_targets_padded_spatial_dim, + clip_to_valid=True + ) + + # precompute attention for the current chunk (more efficient than computing it individually for each label index) + if i % chunk_size == 0: + seg_starts = rf.gather( + segment_starts, + indices=chunk_range, + axis=enc_spatial_dim, + clip_to_valid=True + ) + seg_lens = rf.gather( + segment_lens, + indices=chunk_range, + axis=enc_spatial_dim, + clip_to_valid=True + ) + att = model( + enc=enc_args["enc"], + enc_ctx=enc_args["enc_ctx"], + enc_spatial_dim=enc_spatial_dim, + s=label_lstm_out_seq, + segment_starts=seg_starts, + segment_lens=seg_lens, + ) # [B, S+1, T, D] + chunk_range += chunk_size + + # gather attention for the current label index + att_step = rf.gather( + att, + indices=label_indices, + axis=non_blank_targets_padded_spatial_dim, + clip_to_valid=True + ) + att_step = rf.gather( + att_step, + indices=rf.constant(i % chunk_size, dims=batch_dims, device=att_step.device), + axis=chunk_dim, + clip_to_valid=True + ) + + logits = model.decode_logits( + input_embed=input_embed, + att=att_step, + s=label_lstm_out, + ) # [B, S+1, T, D] + + label_log_prob = rf.log_softmax(logits, axis=model.target_dim) + + # alpha = 0. + # label_log_prob = label_log_prob + rf.stop_gradient(label_log_prob * (alpha - 1)) + + # # scale down blank gradient to avoid outputting only blanks in the beginning + # # and then all other labels in the end + # def custom_backward(grad): + # grad[:, :, 0] *= 0.00005 + # return grad + # + # if rf.get_run_ctx().train_flag: + # label_log_prob.raw_tensor.register_hook(custom_backward) + + # mask label log prob in order to only allow hypotheses corresponding to the ground truth: + # log prob needs to correspond to the next non-blank label... + log_prob_mask = vocab_range == ground_truth + rem_frames = enc_spatial_sizes - i + rem_labels = non_blank_targets_spatial_sizes - label_indices + # ... or to blank if there are more frames than labels left + log_prob_mask = rf.logical_or( + log_prob_mask, + rf.logical_and( + vocab_range == blank_tensor, + rem_frames > rem_labels + ) + ) + label_log_prob = rf.where( + log_prob_mask, + label_log_prob, + rf.constant(-1.0e30, dims=batch_dims + [beam_dim, model.target_dim]) + ) + + # recombine hypotheses corresponding to the same node in the lattice (= same hash value -> same label history) + # do this by setting the log prob of all but the best hypothesis to -inf + # and setting the log prob of the best hypothesis to either the max or the sum of the equivalent hypotheses + seq_log_prob = recombination.recombine_seqs(seq_targets, seq_log_prob, seq_hash, beam_dim, batch_dims[0]) + + # set the beam size as low as possible according to the following rules (using recombination): + # 1) in frame i, there are i+1 nodes in the lattice and from each node, we can spawn 2 hypotheses + # 2) if T-i frames remain, only (T-i)*2 hypotheses can survive in order to reach the last node + # 3) in a frame, there are at most S+1 nodes, i.e. (S+1)*2 hypotheses can be spawned (see 1)) + # 4) the beam size should not exceed the given beam size + beam_size_ = min( + min((i + 1) * 2, rf.reduce_max(rem_frames, axis=rem_frames.dims).raw_tensor.item() * 2), + min((max_num_labels + 1) * 2 - 1, beam_size) + ) + + # update sequence log prob and beam indices + seq_log_prob = seq_log_prob + label_log_prob # Batch, InBeam, Vocab + seq_log_prob, (backrefs, target), beam_dim = rf.top_k( + seq_log_prob, + k_dim=Dim(beam_size_, name=f"dec-step{i}-beam"), + axis=[beam_dim, model.target_dim] + ) # seq_log_prob, backrefs, target: Batch, Beam + seq_targets.append(target) + seq_backrefs.append(backrefs) + + seq_hash = recombination.update_seq_hash(seq_hash, target, backrefs, model.blank_idx) + + # mask blank label + update_state_mask = rf.convert_to_tensor(target != model.blank_idx) + + i += 1 + + # last recombination + seq_log_prob = recombination.recombine_seqs(seq_targets, seq_log_prob, seq_hash, beam_dim, batch_dims[0]) + + # # Backtrack via backrefs, resolve beams. + # seq_targets_ = [] + # indices = rf.range_over_dim(beam_dim) # FinalBeam -> FinalBeam + # for backrefs, target in zip(seq_backrefs[::-1], seq_targets[::-1]): + # # indices: FinalBeam -> Beam + # # backrefs: Beam -> PrevBeam + # seq_targets_.insert(0, rf.gather(target, indices=indices)) + # indices = rf.gather(backrefs, indices=indices) # FinalBeam -> PrevBeam + # + # seq_targets__ = TensorArray(seq_targets_[0]) + # for target in seq_targets_: + # seq_targets__ = seq_targets__.push_back(target) + # seq_targets = seq_targets__.stack(axis=enc_spatial_dim) + # + # torch.set_printoptions(threshold=10_000) + # print("seq_targets", seq_targets.copy_transpose(batch_dims + [beam_dim, enc_spatial_dim]).raw_tensor[0, :]) + # print("seq_log_prob", seq_log_prob.raw_tensor[0]) + + # calculate full-sum loss using the log-sum-exp trick + max_log_prob = rf.reduce_max(seq_log_prob, axis=beam_dim) + loss = -1 * (max_log_prob + rf.log(rf.reduce_sum(rf.exp(seq_log_prob - max_log_prob), axis=beam_dim))) + + # loss = -rf.log(rf.reduce_sum(rf.exp(seq_log_prob), axis=beam_dim)) loss.mark_as_loss("full_sum_loss", scale=1.0, use_normalized_loss=True) return None + + +def full_sum_training_w_beam_eff_w_recomb( + *, + model: SegmentalAttEfficientLabelDecoder, + enc_args: Dict, + enc_spatial_dim: Dim, + non_blank_targets: rf.Tensor, # [B, S, V] + non_blank_targets_spatial_dim: Dim, + segment_starts: rf.Tensor, # [B, T] + segment_lens: rf.Tensor, # [B, T] + batch_dims: List[Dim], + beam_size: int, +) -> Optional[Dict[str, Tuple[rf.Tensor, Dim]]]: + assert len(batch_dims) == 1, "not supported yet" + assert model.blank_idx == 0, "blank idx needs to be zero because of the way the gradient is scaled" + + # ------------------------ init some variables ------------------------ + beam_dim = Dim(1, name="initial-beam") + batch_dims_ = [beam_dim] + batch_dims + bos_idx = 0 + seq_log_prob = rf.constant(0.0, dims=batch_dims_) + max_seq_len = enc_spatial_dim.get_size_tensor() + max_seq_len = rf.reduce_max(max_seq_len, axis=max_seq_len.dims) + label_lstm_state = model.s_wo_att.default_initial_state(batch_dims=batch_dims) + target = rf.constant(bos_idx, dims=batch_dims_, sparse_dim=model.target_dim) + vocab_range = rf.range_over_dim(model.target_dim) + blank_tensor = rf.convert_to_tensor(model.blank_idx, dtype=vocab_range.dtype) + backrefs = rf.zeros(batch_dims_, dtype="int32") + + # ------------------------ targets/embeddings ------------------------ + + non_blank_input_embeddings = model.target_embed(non_blank_targets) # [B, S, D] + non_blank_input_embeddings, non_blank_targets_padded_spatial_dim = rf.pad( + non_blank_input_embeddings, + axes=[non_blank_targets_spatial_dim], + padding=[(1, 0)], + value=0.0, + ) # [B, S+1, D] + non_blank_targets_padded_spatial_dim = non_blank_targets_padded_spatial_dim[0] + + # add blank idx on the right + # this way, when the label index for gathering reached the last non-blank index, it will gather blank after that + # which then only allows corresponding hypotheses to be extended by blank + non_blank_targets_padded, _ = rf.pad( + non_blank_targets, + axes=[non_blank_targets_spatial_dim], + padding=[(0, 1)], + value=model.blank_idx, + out_dims=[non_blank_targets_padded_spatial_dim] + ) + + # ------------------------ sizes ------------------------ + + non_blank_targets_padded_spatial_sizes = rf.copy_to_device( + non_blank_targets_padded_spatial_dim.dyn_size_ext, non_blank_targets.device + ) + non_blank_targets_spatial_sizes = rf.copy_to_device( + non_blank_targets_spatial_dim.dyn_size_ext, non_blank_targets.device) + max_num_labels = rf.reduce_max( + non_blank_targets_spatial_sizes, axis=non_blank_targets_spatial_sizes.dims + ).raw_tensor.item() + single_col_dim = Dim(dimension=max_num_labels + 1, name="max-num-labels") + label_indices = rf.zeros(batch_dims_, dtype="int32", sparse_dim=single_col_dim) + + enc_spatial_sizes = rf.copy_to_device(enc_spatial_dim.dyn_size_ext, non_blank_targets.device) + + # ------------------------ compute LSTM sequence ------------------------ + + label_lstm_out_seq, _ = model.s_wo_att( + non_blank_input_embeddings, + state=label_lstm_state, + spatial_dim=non_blank_targets_padded_spatial_dim, + ) + + # ------------------------ chunk dim ------------------------ + + chunk_size = 20 + chunk_dim = Dim(chunk_size, name="chunk") + chunk_range = rf.expand_dim(rf.range_over_dim(chunk_dim), batch_dims[0]) + + i = 0 + seq_targets = [] + seq_backrefs = [] + while i < max_seq_len.raw_tensor: + # get current number of labels for each hypothesis + if i > 0: + prev_label_indices = rf.gather(label_indices, indices=backrefs) + # mask blank label + update_state_mask = rf.convert_to_tensor(target != prev_label_indices) + label_indices = rf.where( + update_state_mask, + rf.where( + prev_label_indices == non_blank_targets_padded_spatial_sizes - 1, + prev_label_indices, + prev_label_indices + 1 + ), + prev_label_indices + ) + + # gather ground truth, input embeddings and LSTM output for current label index + ground_truth = rf.gather( + non_blank_targets_padded, + indices=label_indices, + axis=non_blank_targets_padded_spatial_dim, + clip_to_valid=True + ) + input_embed = rf.gather( + non_blank_input_embeddings, + indices=label_indices, + axis=non_blank_targets_padded_spatial_dim, + clip_to_valid=True + ) + label_lstm_out = rf.gather( + label_lstm_out_seq, + indices=label_indices, + axis=non_blank_targets_padded_spatial_dim, + clip_to_valid=True + ) + + # precompute attention for the current chunk (more efficient than computing it individually for each label index) + if i % chunk_size == 0: + seg_starts = rf.gather( + segment_starts, + indices=chunk_range, + axis=enc_spatial_dim, + clip_to_valid=True + ) + seg_lens = rf.gather( + segment_lens, + indices=chunk_range, + axis=enc_spatial_dim, + clip_to_valid=True + ) + att = model( + enc=enc_args["enc"], + enc_ctx=enc_args["enc_ctx"], + enc_spatial_dim=enc_spatial_dim, + s=label_lstm_out_seq, + segment_starts=seg_starts, + segment_lens=seg_lens, + ) # [B, S+1, T, D] + chunk_range += chunk_size + + # gather attention for the current label index + att_step = rf.gather( + att, + indices=label_indices, + axis=non_blank_targets_padded_spatial_dim, + clip_to_valid=True + ) + att_step = rf.gather( + att_step, + indices=rf.constant(i % chunk_size, dims=batch_dims, device=att_step.device), + axis=chunk_dim, + clip_to_valid=True + ) + + logits = model.decode_logits( + input_embed=input_embed, + att=att_step, + s=label_lstm_out, + ) # [B, S+1, T, D] + + label_log_prob = rf.log_softmax(logits, axis=model.target_dim) + + # mask label log prob in order to only allow hypotheses corresponding to the ground truth: + # log prob needs to correspond to the next non-blank label... + log_prob_mask = vocab_range == ground_truth + rem_frames = enc_spatial_sizes - i + rem_labels = non_blank_targets_spatial_sizes - label_indices + # ... or to blank if there are more frames than labels left + log_prob_mask = rf.logical_or( + log_prob_mask, + rf.logical_and( + vocab_range == blank_tensor, + rem_frames > rem_labels + ) + ) + label_log_prob = rf.where( + log_prob_mask, + label_log_prob, + rf.constant(-1.0e30, dims=batch_dims + [beam_dim, model.target_dim]) + ) + + label_log_prob = rf.where( + rf.convert_to_tensor(i >= rf.copy_to_device(enc_spatial_dim.get_size_tensor(), label_log_prob.device)), + rf.sparse_to_dense( + model.blank_idx, + axis=model.target_dim, + label_value=0.0, + other_value=-1.0e30 + ), + label_log_prob + ) + + seq_log_prob = recombination.recombine_seqs_train( + seq_log_prob=seq_log_prob, + label_log_prob=label_log_prob, + label_indices=label_indices, + ground_truth=ground_truth, + target_dim=model.target_dim, + single_col_dim=single_col_dim, + labels_padded_spatial_sizes=non_blank_targets_padded_spatial_sizes, + beam_dim=beam_dim, + batch_dims=batch_dims, + blank_idx=model.blank_idx, + ) + + beam_size_ = min( + min((i + 2), rf.reduce_max(rem_frames, axis=rem_frames.dims).raw_tensor.item()), + min((max_num_labels + 1), beam_size) + ) + + # update sequence log prob and beam indices + # seq_log_prob = seq_log_prob + label_log_prob # Batch, InBeam, Vocab + seq_log_prob, (backrefs, target), beam_dim = rf.top_k( + seq_log_prob, + k_dim=Dim(beam_size_, name=f"dec-step{i}-beam"), + axis=[beam_dim, single_col_dim] + ) # seq_log_prob, backrefs, target: Batch, Beam + seq_targets.append(target) + seq_backrefs.append(backrefs) + + i += 1 + + # Backtrack via backrefs, resolve beams. + seq_targets_ = [] + indices = rf.range_over_dim(beam_dim) # FinalBeam -> FinalBeam + for backrefs, target in zip(seq_backrefs[::-1], seq_targets[::-1]): + # indices: FinalBeam -> Beam + # backrefs: Beam -> PrevBeam + seq_targets_.insert(0, rf.gather(target, indices=indices)) + indices = rf.gather(backrefs, indices=indices) # FinalBeam -> PrevBeam + + seq_targets__ = TensorArray(seq_targets_[0]) + for target in seq_targets_: + seq_targets__ = seq_targets__.push_back(target) + seq_targets = seq_targets__.stack(axis=enc_spatial_dim) + + torch.set_printoptions(threshold=10_000) + print("seq_targets", seq_targets.copy_transpose(batch_dims + [beam_dim, enc_spatial_dim]).raw_tensor[0, 0]) + + loss = -1 * seq_log_prob + + # loss = -rf.log(rf.reduce_sum(rf.exp(seq_log_prob), axis=beam_dim)) + loss.mark_as_loss("full_sum_loss", scale=1.0, use_normalized_loss=True) + + # print("loss", loss.raw_tensor) + # print("single_col_dim", single_col_dim.dimension) + # exit() + + return None + diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/recog.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/recog.py index cd7886330..53e39d302 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/recog.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/recog.py @@ -8,6 +8,7 @@ from i6_experiments.users.schmitt.returnn_frontend.model_interfaces.recog import RecogDef from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.base import _batch_size_factor from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model import SegmentalAttentionModel +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental import recombination from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.utils import get_masked, get_non_blank_mask from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.beam_search import utils as beam_search_utils from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model_new.blank_model.model import ( @@ -16,82 +17,12 @@ ) -def recombine_seqs( - seq_targets: list, - seq_log_prob: Tensor, - seq_backrefs: list, - seq_hash: Tensor, - beam_dim: Dim, - batch_dim: Dim, - i: int -) -> Tensor: - if len(seq_targets) in (0, 1): - return seq_log_prob - - print("seq_hash: ", seq_hash.raw_tensor) - print("seq_log_prob before: ", seq_log_prob.raw_tensor) - - seq_hash_cpu = rf.copy_to_device(seq_hash.copy_transpose([batch_dim, beam_dim]), device="cpu") - # convert from neg log prob to log prob - seq_log_prob = rf.copy_to_device(seq_log_prob.copy_transpose([batch_dim, beam_dim]), device="cpu") - - for b in range(batch_dim.dyn_size_ext.raw_tensor.item()): - # for each batch dim, we need to find the seqs that have the same hash value - seq_sets = {} - for h in range(beam_dim.dimension): - # hash value of current hypothesis - seq_hash_value = seq_hash_cpu.raw_tensor[b, h].item() - if seq_hash_value not in seq_sets: - seq_sets[seq_hash_value] = [] - # insert hypothesis index into the list of hypotheses with the same hash value - seq_sets[seq_hash_value].append(h) - # for each set of hypotheses with the same hash value, we keep the one with the highest log prob - for seq_set in seq_sets.values(): - if len(seq_set) == 1: - continue - best_score = float("-inf") - best_idx = -1 - for idx in seq_set: - if seq_log_prob.raw_tensor[b, idx] > best_score: - best_score = seq_log_prob.raw_tensor[b, idx] - best_idx = idx - # print("batch: ", b, "seq_set: ", seq_set, "best_idx: ", best_idx, "best_score: ", best_score) - # exit() - for idx in seq_set: - if idx != best_idx: - seq_log_prob.raw_tensor[b, idx] = float("-inf") - else: - seq_log_prob.raw_tensor[b, idx] = best_score - - seq_log_prob = seq_log_prob - print("seq_log_prob after: ", seq_log_prob.raw_tensor) - exit() - - return rf.copy_to_device(seq_log_prob, device="gpu") - - -def update_seq_hash(seq_hash: Tensor, target: Tensor, backrefs: Tensor) -> Tensor: - print("update_seq_hash") - print("old seq_hash", seq_hash.raw_tensor) - print("target", target.raw_tensor) - print("backrefs", backrefs.raw_tensor) - print("\n\n") - - old_seq_hash = rf.gather(seq_hash, indices=backrefs) - seq_hash = rf.where( - target == 10025, - old_seq_hash, - (old_seq_hash * 257 + (target + 1)) % (10 ** 9 + 7) - ) - return seq_hash - - def model_recog( *, model: SegmentalAttentionModel, data: Tensor, data_spatial_dim: Dim, - use_recombination: bool = False, + use_recombination: Optional[str] = None, ) -> Tuple[Tensor, Tensor, Dim, Dim]: """ Function is run within RETURNN. @@ -129,6 +60,27 @@ def model_recog( blank_decoder_state = model.blank_decoder.default_initial_state(batch_dims=batch_dims_) if model.language_model: lm_state = model.language_model.default_initial_state(batch_dims=batch_dims_) + for state in lm_state: + if state == "pos": + # pass + lm_state[state] = rf.zeros(batch_dims_, dtype="int32") + else: + self_att_expand_dim = Dim(rf.zeros(batch_dims_, dtype="int32"), name="self_att_expand_dim_init") + lm_state[state].self_att.accum_axis = self_att_expand_dim + + k_accum = lm_state[state].self_att.k_accum # type: rf.Tensor + k_accum_raw = k_accum.raw_tensor + lm_state[state].self_att.k_accum = k_accum.copy_template_replace_dim_tag( + k_accum.get_axis_from_description("stag:self_att_expand_dim_init"), self_att_expand_dim + ) + lm_state[state].self_att.k_accum.raw_tensor = k_accum_raw + + v_accum = lm_state[state].self_att.v_accum # type: rf.Tensor + v_accum_raw = v_accum.raw_tensor + lm_state[state].self_att.v_accum = v_accum.copy_template_replace_dim_tag( + v_accum.get_axis_from_description("stag:self_att_expand_dim_init"), self_att_expand_dim + ) + lm_state[state].self_att.v_accum.raw_tensor = v_accum_raw bos_idx = 0 @@ -144,6 +96,7 @@ def model_recog( seq_log_prob = rf.constant(0.0, dims=batch_dims_) if use_recombination: assert len(batch_dims) == 1 + assert use_recombination in {"sum", "max"} seq_hash = rf.constant(0, dims=batch_dims_, dtype="int64") input_embed = rf.zeros( @@ -212,7 +165,13 @@ def model_recog( spatial_dim=single_step_dim, state=lm_state, ) - label_log_prob += rf.log_softmax(lm_logits, axis=model.target_dim) + lm_label_log_prob = rf.log_softmax(lm_logits, axis=model.target_dim) + # print(i) + # print("lm_label_log_prob: ", lm_label_log_prob.copy_transpose(batch_dims + [beam_dim, model.target_dim]).raw_tensor[0, :, :6]) + # print() + # if i == 10: + # exit() + label_log_prob += 0.4 * lm_label_log_prob # ------------------- blank step ------------------- @@ -243,12 +202,29 @@ def model_recog( else: output_log_prob = label_log_prob + # for shorter seqs in the batch, set the blank score to zero and the others to ~-inf + output_log_prob = rf.where( + rf.convert_to_tensor(i >= rf.copy_to_device(enc_spatial_dim.get_size_tensor(), data.device)), + rf.sparse_to_dense( + model.blank_idx, + axis=model.target_dim if model.use_joint_model else model.align_target_dim, + label_value=0.0, + other_value=-1.0e30 + ), + output_log_prob + ) + # ------------------- top-k ------------------- if use_recombination: - seq_log_prob = recombine_seqs(seq_targets, seq_log_prob, seq_backrefs, seq_hash, beam_dim, batch_dims[0], i) - if i == 3: - exit() + seq_log_prob = recombination.recombine_seqs( + seq_targets, + seq_log_prob, + seq_hash, + beam_dim, + batch_dims[0], + use_sum=use_recombination == "sum" + ) seq_log_prob = seq_log_prob + output_log_prob # Batch, InBeam, Vocab old_beam_dim = beam_dim.copy() @@ -257,11 +233,12 @@ def model_recog( k_dim=Dim(beam_size, name=f"dec-step{i}-beam"), axis=[beam_dim, model.target_dim if model.use_joint_model else model.align_target_dim] ) # seq_log_prob, backrefs, target: Batch, Beam + # print("seq_log_prob: ", seq_log_prob.raw_tensor) seq_targets.append(target) seq_backrefs.append(backrefs) if use_recombination: - seq_hash = update_seq_hash(seq_hash, target, backrefs) + seq_hash = recombination.update_seq_hash(seq_hash, target, backrefs, model.blank_idx) # mask for updating label-sync states update_state_mask = rf.convert_to_tensor(target != model.blank_idx) @@ -289,33 +266,84 @@ def _get_masked_state(old, new, mask): # ------------------- update external LM state ------------------- if model.language_model: - def _get_masked_state_lm(old: rf.Tensor, new: rf.Tensor, mask: rf.Tensor): - if isinstance(old, Dim): - return new - - def _update(tensor: rf.Tensor): - tensor = tensor.copy_transpose(batch_dims + [old_beam_dim] + tensor.remaining_dims(batch_dims_)) - tensor_raw_tensor = beam_search_utils.batch_gather( - tensor.raw_tensor, - indices=backrefs.copy_transpose(batch_dims + [beam_dim]).raw_tensor + for state in lm_state: + if state == "pos": + lm_state[state] = rf.where( + update_state_mask, + rf.gather(lm_state_updated[state], indices=backrefs), + rf.gather(lm_state[state], indices=backrefs) ) - tensor = tensor.copy_template_replace_dim_tag(1, beam_dim) - tensor.raw_tensor = tensor_raw_tensor - return tensor - - old = _update(old) - new = _update(new) + else: + updated_accum_axis = lm_state_updated[state].self_att.accum_axis - return rf.where(mask, new, old) + updated_self_att_expand_dim_dyn_size_ext = rf.gather(updated_accum_axis.dyn_size_ext, indices=backrefs) + masked_self_att_expand_dim_dyn_size_ext = rf.where( + update_state_mask, + updated_self_att_expand_dim_dyn_size_ext, + updated_self_att_expand_dim_dyn_size_ext - 1 + ) + masked_self_att_expand_dim = Dim(masked_self_att_expand_dim_dyn_size_ext, name="self_att_expand_dim_init") + lm_state[state].self_att.accum_axis = masked_self_att_expand_dim + + def _mask_lm_state(tensor: rf.Tensor): + tensor = rf.gather(tensor, indices=backrefs) + tensor = tensor.copy_transpose( + [updated_accum_axis] + tensor.remaining_dims(updated_accum_axis)) + tensor_raw = tensor.raw_tensor + tensor_raw = tensor_raw[:rf.reduce_max( + masked_self_att_expand_dim_dyn_size_ext, + axis=masked_self_att_expand_dim_dyn_size_ext.dims + ).raw_tensor.item()] + tensor = tensor.copy_template_replace_dim_tag( + tensor.get_axis_from_description(updated_accum_axis), masked_self_att_expand_dim + ) + tensor.raw_tensor = tensor_raw + return tensor + + lm_state[state].self_att.k_accum = _mask_lm_state(lm_state_updated[state].self_att.k_accum) + lm_state[state].self_att.v_accum = _mask_lm_state(lm_state_updated[state].self_att.v_accum) + + # lm_state[state].self_att.k_accum = rf.gather(lm_state_updated[state].self_att.k_accum, indices=backrefs) + # lm_state[state].self_att.k_accum = lm_state[state].self_att.k_accum.copy_transpose( + # [updated_accum_axis] + lm_state[state].self_att.k_accum.remaining_dims(updated_accum_axis)) + # k_accum_raw = lm_state[state].self_att.k_accum.raw_tensor + # k_accum_raw = k_accum_raw[:rf.reduce_max( + # masked_self_att_expand_dim_dyn_size_ext, + # axis=masked_self_att_expand_dim_dyn_size_ext.dims + # ).raw_tensor.item()] + # lm_state[state].self_att.k_accum = lm_state[state].self_att.k_accum.copy_template_replace_dim_tag( + # lm_state[state].self_att.k_accum.get_axis_from_description(updated_accum_axis), masked_self_att_expand_dim + # ) + # lm_state[state].self_att.k_accum.raw_tensor = k_accum_raw + # + # lm_state[state].self_att.v_accum = rf.gather(lm_state_updated[state].self_att.v_accum, indices=backrefs) + # lm_state[state].self_att.v_accum = lm_state[state].self_att.v_accum.copy_transpose( + # [updated_accum_axis] + lm_state[state].self_att.v_accum.remaining_dims(updated_accum_axis)) + # v_accum_raw = lm_state[state].self_att.v_accum.raw_tensor + # v_accum_raw = v_accum_raw[:rf.reduce_max( + # masked_self_att_expand_dim_dyn_size_ext, + # axis=masked_self_att_expand_dim_dyn_size_ext.dims + # ).raw_tensor.item()] + # lm_state[state].self_att.v_accum = lm_state[state].self_att.v_accum.copy_template_replace_dim_tag( + # lm_state[state].self_att.v_accum.get_axis_from_description(updated_accum_axis), masked_self_att_expand_dim + # ) + # lm_state[state].self_att.v_accum.raw_tensor = v_accum_raw - lm_state = tree.map_structure( - lambda old_state, new_state: _get_masked_state_lm(old_state, new_state, update_state_mask), - lm_state, lm_state_updated - ) + i += 1 - exit() + # last recombination + if use_recombination: + seq_log_prob = recombination.recombine_seqs( + seq_targets, + seq_log_prob, + seq_hash, + beam_dim, + batch_dims[0], + use_sum=use_recombination == "sum" + ) - i += 1 + # print("seq_log_prob: ", seq_log_prob.raw_tensor) + # exit() # Backtrack via backrefs, resolve beams. seq_targets_ = [] diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/recombination.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/recombination.py new file mode 100644 index 000000000..b8017325c --- /dev/null +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/recombination.py @@ -0,0 +1,204 @@ +from typing import Optional, Dict, Any, Tuple, Sequence +import tree +import numpy as np +import torch + +from returnn.tensor import Tensor, Dim +import returnn.frontend as rf + + +def recombine_seqs( + seq_targets: list, + seq_log_prob: Tensor, + seq_hash: Tensor, + beam_dim: Dim, + batch_dim: Dim, + use_sum: bool = True, +) -> Tensor: + if len(seq_targets) in (0, 1): + return seq_log_prob + + seq_hash_cpu = rf.copy_to_device(seq_hash.copy_transpose([batch_dim, beam_dim]), device="cpu") + # convert from neg log prob to log prob + seq_log_prob_cpu = rf.copy_to_device(seq_log_prob.copy_transpose([batch_dim, beam_dim]), device="cpu") + + for b in range(batch_dim.dyn_size_ext.raw_tensor.item()): + # for each batch dim, we need to find the seqs that have the same hash value + seq_sets = {} + for h in range(beam_dim.dimension): + # hash value of current hypothesis + seq_hash_value = seq_hash_cpu.raw_tensor[b, h].item() + if seq_hash_value not in seq_sets: + seq_sets[seq_hash_value] = [] + # insert hypothesis index into the list of hypotheses with the same hash value + seq_sets[seq_hash_value].append(h) + # for each set of hypotheses with the same hash value, we keep the one with the highest log prob + for seq_set in seq_sets.values(): + # skip if there is only one hypothesis in the set + if len(seq_set) == 1: + continue + best_score = -1.0e30 + best_idx = -1 + # find the hypothesis with the highest log prob + for idx in seq_set: + if seq_log_prob_cpu.raw_tensor[b, idx] > best_score: + best_score = seq_log_prob_cpu.raw_tensor[b, idx] + best_idx = idx + + if use_sum: + sum_score = torch.zeros(1, device="cpu") + # calculate log of sum of probs via log-sum-exp trick + for idx in seq_set: + sum_score += torch.exp(seq_log_prob_cpu.raw_tensor[b, idx] - best_score) + recomb_score = torch.log(sum_score) + best_score + else: + recomb_score = best_score + + for idx in seq_set: + if idx != best_idx: + seq_log_prob_cpu.raw_tensor[b, idx] = -1.0e30 + else: + seq_log_prob_cpu.raw_tensor[b, idx] = recomb_score + + return rf.copy_to_device(seq_log_prob_cpu, device=seq_log_prob.device) + + +def recombine_seqs_train( + seq_log_prob: Tensor, + label_log_prob: Tensor, + label_indices: Tensor, + ground_truth: Tensor, + labels_padded_spatial_sizes: Tensor, + target_dim: Dim, + single_col_dim: Dim, + beam_dim: Dim, + batch_dims: Sequence[Dim], + blank_idx: int, +) -> Tensor: + # local horizontal scores for each hyp: [B, beam] + horizontal_scores = rf.gather( + label_log_prob, + indices=rf.constant(blank_idx, dtype="int32", dims=batch_dims), + axis=target_dim + ) + + # combined horizontal scores for each hyp: [B, beam] + horizontal_scores = seq_log_prob + horizontal_scores + + # if a hypothesis has score < -1.0e30, it means that it got recombined with another hypothesis in the previous step + # in this case, it has the same label index as the hypothesis it got combined with and therefore, the scatter + # below would result in a horizontal score < -1.0e30, which is wrong. + # therefore, set the label index to S+2 and cut off this score afterwards + label_indices_ext = rf.where( + seq_log_prob <= -1.0e30, + single_col_dim.dimension, + label_indices, + ) + single_col_dim_ext = single_col_dim + 1 + label_indices_ext.sparse_dim = single_col_dim_ext + + # lattice column with horizontal scores: [B, S+2] + # horizontal -> label index stays the same + horizontal_scores = rf.scatter( + horizontal_scores, + indices=label_indices_ext, + indices_dim=beam_dim, + ) + horizontal_scores = horizontal_scores.copy_transpose(batch_dims + [single_col_dim_ext]) + # cut off the last row as mentioned above + horizontal_scores_raw = horizontal_scores.raw_tensor[:, :-1] + # lattice column with horizontal scores: [B, S+1] + horizontal_scores = horizontal_scores.copy_template_replace_dim_tag( + horizontal_scores.get_axis_from_description(single_col_dim_ext), + single_col_dim + ) + horizontal_scores.raw_tensor = horizontal_scores_raw + + # lattice column with horizontal scores for each hyp: [B, beam, S+1] + # each hyp only has one node with score > -1.0e30, which is the node corresponding to the horizontal transition + horizontal_scores = rf.where( + rf.range_over_dim(single_col_dim) == label_indices_ext, + horizontal_scores, + rf.constant(-1.0e30, dims=batch_dims) + ) + + # local diagonal scores for each hyp: [B, beam] + diagonal_scores = rf.gather( + label_log_prob, + indices=ground_truth, + axis=target_dim + ) + + # if the ground truth is blank, it means the hypothesis is already at the top-most row of the lattice + # in this case, set the diagonal score to -1.0e30 + diagonal_scores = rf.where( + ground_truth == blank_idx, + rf.constant(-1.0e30, dims=batch_dims), + diagonal_scores + ) + # combined diagonal scores for each hyp: [B, beam] + diagonal_scores = seq_log_prob + diagonal_scores + + # the updated label indices after diagonal transition: [B, beam] + label_indices_updated = label_indices + 1 + + + # same as with horizontal_scores, see above + label_indices_updated_ext = rf.where( + seq_log_prob <= -1.0e30, + single_col_dim.dimension, + label_indices_updated, + ) + label_indices_updated_ext.sparse_dim = single_col_dim_ext + + # lattice column with diagonal scores: [B, S+2] + # diagonal -> label index is updated + diagonal_scores = rf.scatter( + diagonal_scores, + indices=label_indices_updated_ext, + indices_dim=beam_dim, + ) + diagonal_scores = diagonal_scores.copy_transpose(batch_dims + [single_col_dim_ext]) + # cut off last row, see above + diagonal_scores_raw = diagonal_scores.raw_tensor[:, :-1] + # lattice column with diagonal scores: [B, S+1] + diagonal_scores = diagonal_scores.copy_template_replace_dim_tag( + diagonal_scores.get_axis_from_description(single_col_dim_ext), + single_col_dim + ) + diagonal_scores.raw_tensor = diagonal_scores_raw + + # lattice column with diagonal scores for each hyp: [B, beam, S+1] + # each hyp only has one node with score > -1.0e30, which is the node corresponding to the diagonal transition + diagonal_scores = rf.where( + rf.range_over_dim(single_col_dim) == label_indices_updated_ext, + diagonal_scores, + rf.constant(-1.0e30, dims=batch_dims) + ) + + best_scores = rf.maximum(horizontal_scores, diagonal_scores) + sum_scores = rf.exp(horizontal_scores - best_scores) + rf.exp(diagonal_scores - best_scores) + sum_scores = best_scores + rf.safe_log(sum_scores) + + best_scores = rf.reduce_max(sum_scores, axis=beam_dim) + is_max = sum_scores == best_scores + sum_scores = best_scores + rf.log(rf.reduce_sum(rf.exp(sum_scores - best_scores), axis=beam_dim)) + + sum_scores = rf.expand_dim(sum_scores, beam_dim) + sum_scores = rf.where( + is_max, + sum_scores, + rf.constant(-1.0e30, dims=batch_dims) + ) + + return sum_scores + + +def update_seq_hash(seq_hash: Tensor, target: Tensor, backrefs: Tensor, blank_idx: int) -> Tensor: + old_seq_hash = rf.gather(seq_hash, indices=backrefs) + seq_hash = rf.where( + target == blank_idx, + old_seq_hash, + (old_seq_hash * 257 + (target + 1)) % (10 ** 9 + 7) + ) + return seq_hash diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/train.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/train.py index 082d8525d..bb5c56b40 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/train.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/train.py @@ -1,6 +1,6 @@ import torch -from i6_experiments.users.schmitt.returnn_frontend.model_interfaces.training import FramewiseTrainDef +from i6_experiments.users.schmitt.returnn_frontend.model_interfaces.training import FramewiseTrainDef, FullSumTrainDef from returnn.tensor import TensorDict @@ -16,15 +16,35 @@ from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model_new.label_model.train import ( full_sum_training as label_model_full_sum_training ) +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model_new.label_model.train import ( + full_sum_training_w_beam as label_model_full_sum_training_w_beam +) +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model_new.label_model.train import ( + full_sum_training_w_beam_eff as label_model_full_sum_training_w_beam_eff +) +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model_new.label_model.train import ( + full_sum_training_w_beam_eff_w_recomb as label_model_full_sum_training_w_beam_eff_w_recomb +) from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model_new.blank_model.train import ( viterbi_training as blank_model_viterbi_training ) from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model_new.blank_model.train import ( viterbi_training_v3 as blank_model_viterbi_training_v3 ) +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model_new.blank_model.train import ( + viterbi_training_v4 as blank_model_viterbi_training_v4 +) +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model_new.blank_model.train import ( + viterbi_training_v5 as blank_model_viterbi_training_v5 +) +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model_new.blank_model.train import ( + viterbi_training_v6 as blank_model_viterbi_training_v6 +) from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model_new.blank_model.model import ( BlankDecoderV1, BlankDecoderV3, + BlankDecoderV5, + BlankDecoderV6 ) from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model_new.label_model.model import ( SegmentalAttLabelDecoder, @@ -57,6 +77,26 @@ def _returnn_v2_train_step(*, model, extern_data: TensorDict, **_kwargs_unused): ) +def _returnn_v2_full_sum_train_step(*, model, extern_data: TensorDict, **_kwargs_unused): + from returnn.config import get_global_config + + config = get_global_config() + default_input_key = config.typed_value("default_input") + default_target_key = config.typed_value("target") + data = extern_data[default_input_key] + data_spatial_dim = data.get_time_dim_tag() + targets = extern_data[default_target_key] + targets_spatial_dim = targets.get_time_dim_tag() + train_def: FullSumTrainDef = config.typed_value("_train_def") + train_def( + model=model, + data=data, + data_spatial_dim=data_spatial_dim, + non_blank_targets=targets, + non_blank_targets_spatial_dim=targets_spatial_dim, + ) + + def viterbi_training( *, model: SegmentalAttentionModel, @@ -71,6 +111,8 @@ def viterbi_training( config = get_global_config() # noqa aux_loss_layers = config.typed_value("aux_loss_layers") aux_loss_scales = config.typed_value("aux_loss_scales", ([1.0] * len(aux_loss_layers)) if aux_loss_layers else None) + use_ctc_loss = config.typed_value("use_ctc_loss", True) + generate_ctc_alignments_on_the_fly = config.typed_value("generate_ctc_alignments_on_the_fly", False) force_inefficient_loop = config.typed_value("force_inefficient_loop", False) if data.feature_dim and data.feature_dim.dimension == 1: @@ -94,7 +136,6 @@ def viterbi_training( # TODO: use rf.window() instead segment_starts, segment_lens = utils.get_segment_starts_and_lens( non_blank_mask=rf.sequence_mask(align_targets.dims), # this way, every frame is interpreted as non-blank - align_targets=align_targets, align_targets_spatial_dim=align_targets_spatial_dim, model=model, batch_dims=batch_dims, @@ -118,7 +159,6 @@ def viterbi_training( segment_starts, segment_lens = utils.get_segment_starts_and_lens( non_blank_mask, - align_targets, align_targets_spatial_dim, model, batch_dims, @@ -132,24 +172,46 @@ def viterbi_training( data, in_spatial_dim=data_spatial_dim, collected_outputs=collected_outputs) if aux_loss_layers: - for i, layer_idx in enumerate(aux_loss_layers): - if layer_idx > len(model.encoder.layers): - continue - linear = getattr(model, f"enc_aux_logits_{layer_idx}") - aux_logits = linear(collected_outputs[str(layer_idx - 1)]) - aux_loss = rf.ctc_loss( - logits=aux_logits, - targets=non_blank_targets, - input_spatial_dim=enc_spatial_dim, - targets_spatial_dim=non_blank_targets_spatial_dim, - blank_index=model.blank_idx, - ) - aux_loss.mark_as_loss( - f"ctc_{layer_idx}", - scale=aux_loss_scales[i], - custom_inv_norm_factor=align_targets_spatial_dim.get_size_tensor(), - use_normalized_loss=True, + if use_ctc_loss: + for i, layer_idx in enumerate(aux_loss_layers): + if layer_idx > len(model.encoder.layers): + continue + linear = getattr(model.encoder, f"enc_aux_logits_{layer_idx}") + aux_logits = linear(collected_outputs[str(layer_idx - 1)]) + aux_loss = rf.ctc_loss( + logits=aux_logits, + targets=non_blank_targets, + input_spatial_dim=enc_spatial_dim, + targets_spatial_dim=non_blank_targets_spatial_dim, + blank_index=model.blank_idx, + ) + aux_loss.mark_as_loss( + f"ctc_{layer_idx}", + scale=aux_loss_scales[i], + custom_inv_norm_factor=align_targets_spatial_dim.get_size_tensor(), + use_normalized_loss=True, + ) + elif generate_ctc_alignments_on_the_fly: + assert len(aux_loss_layers) == 1 + assert len(batch_dims) == 1 + assert model.blank_idx == model.target_dim.dimension + print("Generating CTC alignments on the fly") + layer_idx = aux_loss_layers[0] + linear = getattr(model.encoder, f"enc_aux_logits_{layer_idx}") + aux_logits = linear(collected_outputs[str(layer_idx - 1)]) # type: rf.Tensor + print("aux_logits", aux_logits) + + from torchaudio.functional import forced_align + rem_dims = aux_logits.remaining_dims(batch_dims + [enc_spatial_dim]) + ctc_align = forced_align( + log_probs=aux_logits.copy_transpose(batch_dims + [enc_spatial_dim] + rem_dims).raw_tensor, + targets=non_blank_targets.copy_transpose(batch_dims + [non_blank_targets_spatial_dim]).raw_tensor.contiguous(), + input_lengths=enc_spatial_dim.get_size_tensor().raw_tensor, + target_lengths=non_blank_targets_spatial_dim.get_size_tensor().raw_tensor, + blank=model.blank_idx, ) + print("ctc_align", ctc_align.shape) + exit() if model.use_joint_model: @@ -241,8 +303,11 @@ def viterbi_training( emit_blank_target_dim=emit_blank_target_dim, batch_dims=batch_dims, ) - else: - assert isinstance(model.blank_decoder, BlankDecoderV3) and model.blank_decoder_version in (3,) + elif model.blank_decoder_version in (3, 5, 6): + assert isinstance( + model.blank_decoder, BlankDecoderV3) or isinstance( + model.blank_decoder, BlankDecoderV5) or isinstance( + model.blank_decoder, BlankDecoderV6) label_states_unmasked = utils.get_unmasked( input=label_decoder_outputs[0], @@ -250,12 +315,51 @@ def viterbi_training( mask=non_blank_mask, mask_spatial_dim=align_targets_spatial_dim ) - blank_model_viterbi_training_v3( + + if model.blank_decoder_version == 3: + blank_model_viterbi_training_v3( + model=model.blank_decoder, + enc_args=enc_args, + enc_spatial_dim=enc_spatial_dim, + label_states_unmasked=label_states_unmasked, + label_states_unmasked_spatial_dim=align_targets_spatial_dim, + emit_ground_truth=emit_ground_truth, + emit_blank_target_dim=emit_blank_target_dim, + batch_dims=batch_dims, + ) + elif model.blank_decoder_version == 5: + blank_model_viterbi_training_v5( + model=model.blank_decoder, + enc_args=enc_args, + enc_spatial_dim=enc_spatial_dim, + label_states_unmasked=label_states_unmasked, + label_states_unmasked_spatial_dim=align_targets_spatial_dim, + emit_ground_truth=emit_ground_truth, + emit_blank_target_dim=emit_blank_target_dim, + batch_dims=batch_dims, + ) + else: + blank_model_viterbi_training_v6( + model=model.blank_decoder, + enc_args=enc_args, + enc_spatial_dim=enc_spatial_dim, + label_states_unmasked=label_states_unmasked, + label_states_unmasked_spatial_dim=align_targets_spatial_dim, + emit_ground_truth=emit_ground_truth, + emit_blank_target_dim=emit_blank_target_dim, + batch_dims=batch_dims, + ) + else: + assert model.blank_decoder_version == 4 and isinstance(model.blank_decoder, BlankDecoderV3) + blank_model_viterbi_training_v4( model=model.blank_decoder, enc_args=enc_args, enc_spatial_dim=enc_spatial_dim, - label_states_unmasked=label_states_unmasked, - label_states_unmasked_spatial_dim=align_targets_spatial_dim, + label_states=label_decoder_outputs[0], + label_states_spatial_dim=label_decoder_outputs[1], + non_blank_mask=non_blank_mask, + non_blank_mask_dim=align_targets_spatial_dim, + non_blank_targets_spatial_dim=non_blank_targets_spatial_dim, emit_ground_truth=emit_ground_truth, emit_blank_target_dim=emit_blank_target_dim, batch_dims=batch_dims, @@ -270,8 +374,8 @@ def full_sum_training( model: SegmentalAttentionModel, data: rf.Tensor, data_spatial_dim: Dim, - align_targets: rf.Tensor, - align_targets_spatial_dim: Dim + non_blank_targets: rf.Tensor, + non_blank_targets_spatial_dim: Dim ): assert model.use_joint_model assert isinstance(model.label_decoder, SegmentalAttEfficientLabelDecoder) @@ -279,28 +383,18 @@ def full_sum_training( from returnn.config import get_global_config - # torch.cuda.memory._record_memory_history(enabled=True) - config = get_global_config() # noqa aux_loss_layers = config.typed_value("aux_loss_layers") aux_loss_scales = config.typed_value("aux_loss_scales", ([1.0] * len(aux_loss_layers)) if aux_loss_layers else None) + full_sum_training_beam_size = config.int("full_sum_training_beam_size", None) + if data.feature_dim and data.feature_dim.dimension == 1: data = rf.squeeze(data, axis=data.feature_dim) assert not data.feature_dim # raw audio batch_dims = data.remaining_dims(data_spatial_dim) - # set blank indices in alignment to 0 (= EOS index of imported global att model which is not used otherwise) - align_targets.raw_tensor[align_targets.raw_tensor == model.target_dim.dimension] = 0 - align_targets.sparse_dim = model.target_dim - - # get non-blank targets ([B,S]) - non_blank_mask = utils.get_non_blank_mask(align_targets, model.blank_idx) - non_blank_targets, non_blank_targets_spatial_dim = utils.get_masked( - align_targets, non_blank_mask, align_targets_spatial_dim, batch_dims - ) - # ------------------- encoder aux loss ------------------- collected_outputs = {} @@ -323,16 +417,15 @@ def full_sum_training( aux_loss.mark_as_loss( f"ctc_{layer_idx}", scale=aux_loss_scales[i], - custom_inv_norm_factor=align_targets_spatial_dim.get_size_tensor(), + custom_inv_norm_factor=enc_spatial_dim.get_size_tensor(), use_normalized_loss=True, ) # for every frame position, get the corresponding window around it ([B,T,W]) # TODO: use rf.window() instead segment_starts, segment_lens = utils.get_segment_starts_and_lens( - utils.get_non_blank_mask(align_targets, blank_idx=-1), # this way, every frame is interpreted as non-blank - align_targets, - align_targets_spatial_dim, + rf.sequence_mask(batch_dims + [enc_spatial_dim]), # this way, every frame is interpreted as non-blank + enc_spatial_dim, model, batch_dims, enc_spatial_dim @@ -340,16 +433,29 @@ def full_sum_training( # ------------------- joint loop ------------------- - label_model_full_sum_training( - model=model.label_decoder, - enc_args=enc_args, - enc_spatial_dim=enc_spatial_dim, - non_blank_targets=non_blank_targets, - non_blank_targets_spatial_dim=non_blank_targets_spatial_dim, - segment_starts=segment_starts, - segment_lens=segment_lens, - batch_dims=batch_dims, - ) + if full_sum_training_beam_size: + label_model_full_sum_training_w_beam_eff_w_recomb( + model=model.label_decoder, + enc_args=enc_args, + enc_spatial_dim=enc_spatial_dim, + non_blank_targets=non_blank_targets, + non_blank_targets_spatial_dim=non_blank_targets_spatial_dim, + segment_starts=segment_starts, + segment_lens=segment_lens, + batch_dims=batch_dims, + beam_size=full_sum_training_beam_size + ) + else: + label_model_full_sum_training( + model=model.label_decoder, + enc_args=enc_args, + enc_spatial_dim=enc_spatial_dim, + non_blank_targets=non_blank_targets, + non_blank_targets_spatial_dim=non_blank_targets_spatial_dim, + segment_starts=segment_starts, + segment_lens=segment_lens, + batch_dims=batch_dims, + ) full_sum_training: TrainDef[SegmentalAttentionModel] diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/utils.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/utils.py index 18074b34b..73da27aa7 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/utils.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/utils.py @@ -34,11 +34,12 @@ def get_masked( result = rf.scatter( input, indices=idxs, indices_dim=mask_dim, out_dim=result_spatial_dim_temp) # remove accumulated blanks at the last position - result = result.copy_transpose([result_spatial_dim_temp] + batch_dims) + rem_dims = result.remaining_dims([result_spatial_dim_temp] + batch_dims) + result = result.copy_transpose([result_spatial_dim_temp] + batch_dims + rem_dims) result_raw_tensor = result.raw_tensor result = result.copy_template_replace_dim_tag(0, result_spatial_dim) result.raw_tensor = result_raw_tensor[:-1] - result = result.copy_transpose(batch_dims + [result_spatial_dim]) + result = result.copy_transpose(batch_dims + [result_spatial_dim] + rem_dims) return result, result_spatial_dim @@ -67,7 +68,6 @@ def get_unmasked( def get_segment_starts_and_lens( non_blank_mask: Tensor, - align_targets: Tensor, align_targets_spatial_dim: Dim, model: SegmentalAttentionModel, batch_dims: Sequence[Dim], diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v3/__init__.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v3/__init__.py index 21f3ce8fc..8be9edbfb 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v3/__init__.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v3/__init__.py @@ -10,9 +10,8 @@ def run_exps(): - # baseline model for checking consistency of train and recog implementations for model_alias, config_builder in baseline.center_window_att_baseline_rf( - win_size_list=(5,), + win_size_list=(5,), blank_decoder_version=4, ): for train_alias, checkpoint in train.train_center_window_att_viterbi_import_global_tf( alias=model_alias, @@ -26,14 +25,62 @@ def run_exps(): checkpoint=checkpoint, ) + # for model_alias, config_builder in baseline.center_window_att_baseline_rf( + # win_size_list=(5,), blank_decoder_version=5, + # ): + # for train_alias, checkpoint in train.train_center_window_att_viterbi_import_global_tf( + # alias=model_alias, + # config_builder=config_builder, + # n_epochs_list=(10,), + # const_lr_list=(1e-4,), + # ): + # pass + # recog.center_window_returnn_frame_wise_beam_search( + # alias=train_alias, + # config_builder=config_builder, + # checkpoint=checkpoint, + # ) + + # for model_alias, config_builder in baseline.center_window_att_baseline_rf( + # win_size_list=(5,), blank_decoder_version=6, + # ): + # for train_alias, checkpoint in train.train_center_window_att_viterbi_import_global_tf( + # alias=model_alias, + # config_builder=config_builder, + # n_epochs_list=(10,), + # const_lr_list=(1e-4,), + # ): + # pass + # recog.center_window_returnn_frame_wise_beam_search( + # alias=train_alias, + # config_builder=config_builder, + # checkpoint=checkpoint, + # ) + + # for model_alias, config_builder in baseline.center_window_att_baseline_rf( + # win_size_list=(5,) + # ): + # for max_shift, num_iterations in [(1, 1), (2, 1), (1, 2)]: + # for train_alias, checkpoint in train.train_center_window_att_viterbi_import_global_tf( + # alias=model_alias, + # config_builder=config_builder, + # n_epochs_list=(100,), + # const_lr_list=(1e-4,), + # alignment_augmentation_opts={"max_shift": max_shift, "num_iterations": num_iterations}, + # ): + # recog.center_window_returnn_frame_wise_beam_search( + # alias=train_alias, + # config_builder=config_builder, + # checkpoint=checkpoint, + # ) + for model_alias, config_builder in baseline.center_window_att_baseline_rf( - win_size_list=(5, 129), + win_size_list=(5,), ): - for train_alias, checkpoint in train.train_center_window_att_viterbi_import_global_tf( + for train_alias, checkpoint in train.train_center_window_att_viterbi_from_scratch( alias=model_alias, config_builder=config_builder, - n_epochs_list=(100,), - const_lr_list=(1e-4,), + n_epochs_list=(500,), ): recog.center_window_returnn_frame_wise_beam_search( alias=train_alias, @@ -41,8 +88,24 @@ def run_exps(): checkpoint=checkpoint, ) + # for model_alias, config_builder in baseline.center_window_att_baseline_rf( + # win_size_list=(5,), + # ): + # for train_alias, checkpoint in train.train_center_window_att_viterbi_from_scratch( + # alias=model_alias, + # config_builder=config_builder, + # n_epochs_list=(500,), + # use_speed_pert=True, + # ): + # recog.center_window_returnn_frame_wise_beam_search( + # alias=train_alias, + # config_builder=config_builder, + # checkpoint=checkpoint, + # ) + + # ------------------------------------- best models: KEEP! ------------------------------------- for model_alias, config_builder in baseline.center_window_att_baseline_rf( - win_size_list=(5, 129), use_att_ctx_in_state=False, use_weight_feedback=False, + win_size_list=(5, 129), ): for train_alias, checkpoint in train.train_center_window_att_viterbi_import_global_tf( alias=model_alias, @@ -57,32 +120,19 @@ def run_exps(): ) for model_alias, config_builder in baseline.center_window_att_baseline_rf( - win_size_list=(5,) + win_size_list=(5,), ): - for max_shift, num_iterations in [(1, 1), (2, 1), (1, 2)]: - for train_alias, checkpoint in train.train_center_window_att_viterbi_import_global_tf( - alias=model_alias, - config_builder=config_builder, - n_epochs_list=(100,), - const_lr_list=(1e-4,), - alignment_augmentation_opts={"max_shift": max_shift, "num_iterations": num_iterations}, - ): + for train_alias, checkpoint in train.train_center_window_att_viterbi_import_global_tf( + alias=model_alias, + config_builder=config_builder, + n_epochs_list=(100,), + const_lr_list=(1e-4,), + ): + for use_recombination in {"max", "sum"}: recog.center_window_returnn_frame_wise_beam_search( alias=train_alias, config_builder=config_builder, checkpoint=checkpoint, + checkpoint_aliases=("best-4-avg",), + use_recombination=use_recombination, ) - - for model_alias, config_builder in baseline.center_window_att_baseline_rf( - win_size_list=(5,), - ): - for train_alias, checkpoint in train.train_center_window_att_viterbi_from_scratch( - alias=model_alias, - config_builder=config_builder, - n_epochs_list=(500,), - ): - recog.center_window_returnn_frame_wise_beam_search( - alias=train_alias, - config_builder=config_builder, - checkpoint=checkpoint, - ) diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v3/baseline.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v3/baseline.py index d6fff6356..8068a8061 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v3/baseline.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v3/baseline.py @@ -8,12 +8,13 @@ def center_window_att_baseline_rf( win_size_list: Tuple[int, ...] = (5, 129), use_att_ctx_in_state: bool = True, use_weight_feedback: bool = True, + blank_decoder_version: int = 3, ): for win_size in win_size_list: alias, config_builder = get_center_window_att_config_builder_rf( win_size=win_size, use_att_ctx_in_state=use_att_ctx_in_state, - blank_decoder_version=3, + blank_decoder_version=blank_decoder_version, use_joint_model=False, use_weight_feedback=use_weight_feedback, ) diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v4/__init__.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v4/__init__.py index d9f80c03e..478e6957d 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v4/__init__.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v4/__init__.py @@ -13,7 +13,7 @@ def run_exps(): for train_alias, checkpoint in train.train_center_window_att_viterbi_import_global_tf( alias=model_alias, config_builder=config_builder, - n_epochs_list=(100,), + n_epochs_list=(200, 300), ): recog.center_window_returnn_frame_wise_beam_search( alias=train_alias, @@ -27,10 +27,79 @@ def run_exps(): for train_alias, checkpoint in train.train_center_window_att_viterbi_import_global_tf( alias=model_alias, config_builder=config_builder, - n_epochs_list=(100,), + n_epochs_list=(200, 300), ): recog.center_window_returnn_frame_wise_beam_search( alias=train_alias, config_builder=config_builder, checkpoint=checkpoint, ) + + for model_alias, config_builder in baseline.center_window_att_baseline_rf( + win_size_list=(5,), + label_decoder_state="nb-lstm", + use_att_ctx_in_state=False, + use_weight_feedback=False, + bpe_vocab_size=1056, + ): + for train_alias, checkpoint in train.train_center_window_att_full_sum_from_scratch( + alias=model_alias, + config_builder=config_builder, + n_epochs_list=(125,), + use_speed_pert=True, + batch_size=3_000, + time_rqmt=80, + use_mgpu=False, + ): + pass + # recog.center_window_returnn_frame_wise_beam_search( + # alias=train_alias, + # config_builder=config_builder, + # checkpoint=checkpoint, + # ) + + for model_alias, config_builder in baseline.center_window_att_baseline_rf( + win_size_list=(5,), + label_decoder_state="nb-lstm", + use_att_ctx_in_state=False, + use_weight_feedback=False, + bpe_vocab_size=1056, + ): + for train_alias, checkpoint in train.train_center_window_att_full_sum_from_scratch( + alias=model_alias, + config_builder=config_builder, + n_epochs_list=(125,), + use_speed_pert=True, + batch_size=3_000, + time_rqmt=1, + use_mgpu=True, + ): + pass + # recog.center_window_returnn_frame_wise_beam_search( + # alias=train_alias, + # config_builder=config_builder, + # checkpoint=checkpoint, + # ) + + for model_alias, config_builder in baseline.center_window_att_baseline_rf( + win_size_list=(1,), + label_decoder_state="nb-lstm", + use_att_ctx_in_state=False, + use_weight_feedback=False, + ): + for train_alias, checkpoint in train.train_center_window_att_full_sum_from_scratch( + alias=model_alias, + config_builder=config_builder, + n_epochs_list=(125,), + use_speed_pert=True, + batch_size=3_000, + time_rqmt=80, + use_mgpu=False, + beam_size=100 + ): + pass + # recog.center_window_returnn_frame_wise_beam_search( + # alias=train_alias, + # config_builder=config_builder, + # checkpoint=checkpoint, + # ) diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v4/baseline.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v4/baseline.py index 8e5566d4f..5cef2bc0b 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v4/baseline.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v4/baseline.py @@ -9,6 +9,7 @@ def center_window_att_baseline_rf( use_att_ctx_in_state: bool = True, label_decoder_state: str = "nb-lstm", use_weight_feedback: bool = True, + bpe_vocab_size: int = 10025, ): for win_size in win_size_list: alias, config_builder = get_center_window_att_config_builder_rf( @@ -18,6 +19,7 @@ def center_window_att_baseline_rf( use_joint_model=True, label_decoder_state=label_decoder_state, use_weight_feedback=use_weight_feedback, + bpe_vocab_size=bpe_vocab_size, ) alias = f"{base_alias}/baseline_rf/{alias}" yield alias, config_builder diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/config_builder.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/config_builder.py index a4f9b7d68..d43cc8813 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/config_builder.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/config_builder.py @@ -2,6 +2,7 @@ from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23.dependencies.labels.v2.librispeech.label_singletons import ( LibrispeechBPE10025_CTC_ALIGNMENT, + LibrispeechBPE1056_ALIGNMENT, LIBRISPEECH_CORPUS ) from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23.dependencies.general.returnn.exes import RETURNN_EXE_NEW, RETURNN_CURRENT_ROOT @@ -17,9 +18,11 @@ def get_center_window_att_config_builder_rf( use_joint_model: bool, use_weight_feedback: bool = True, label_decoder_state: str = "nb-lstm", + bpe_vocab_size: int = 10025, ) -> Tuple[str, SegmentalAttConfigBuilderRF]: + assert bpe_vocab_size in {10025, 1056} variant_params = { - "dependencies": LibrispeechBPE10025_CTC_ALIGNMENT, + "dependencies": LibrispeechBPE10025_CTC_ALIGNMENT if bpe_vocab_size == 10025 else LibrispeechBPE1056_ALIGNMENT, "dataset": { "feature_type": "raw", "corpus": LIBRISPEECH_CORPUS @@ -45,9 +48,11 @@ def get_center_window_att_config_builder_rf( ) alias = ( + f"bpe-size-{bpe_vocab_size}/" f"win-size-{win_size}/" - f"{'w' if use_weight_feedback else 'wo'}-weight-feedback/" - f"{'w' if use_att_ctx_in_state else 'wo'}-att-ctx-in-state/" + f"{'w' if use_weight_feedback else 'wo'}-wf_" + f"{'w' if use_att_ctx_in_state else 'wo'}-ctx-in-s/" + f"bd-{blank_decoder_version}/" f"{label_decoder_state}" ) diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/recog.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/recog.py index 3d7c75192..dc0ffa994 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/recog.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/recog.py @@ -22,7 +22,8 @@ def center_window_returnn_frame_wise_beam_search( checkpoint_aliases: Tuple[str, ...] = ("last", "best", "best-4-avg"), run_analysis: bool = False, att_weight_seq_tags: Optional[List] = None, - pure_torch: bool = False + pure_torch: bool = False, + use_recombination: Optional[str] = None, ): ilm_opts = {"type": ilm_type} if ilm_type == "mini_att": @@ -46,6 +47,7 @@ def center_window_returnn_frame_wise_beam_search( "recog_def": model_recog_pure_torch if pure_torch else model_recog, "forward_step_func": _returnn_v2_forward_step, "forward_callback": _returnn_v2_get_forward_callback, + "use_recombination": use_recombination, }, search_alias=f'returnn_decoding{"_pure_torch" if pure_torch else ""}' ).run() diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/train.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/train.py index 468a525d2..61e373208 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/train.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/train.py @@ -1,8 +1,15 @@ +import copy from typing import Tuple, Optional, List, Dict, Union, Callable from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.config_builder_rf.base import SegmentalAttConfigBuilderRF from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23.train_new import SegmentalTrainExperiment -from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.train import _returnn_v2_train_step, viterbi_training +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.train import ( + _returnn_v2_train_step, + _returnn_v2_full_sum_train_step, + viterbi_training, + full_sum_training, +) +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model import _returnn_v2_get_model_for_full_sum_training from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.pipelines.pipeline_ls_conf.checkpoints import ( external_checkpoints, default_import_model_name, @@ -15,54 +22,157 @@ def train_center_window_att_viterbi_from_scratch( config_builder: SegmentalAttConfigBuilderRF, n_epochs_list: Tuple[int, ...], time_rqmt: int = 80, + use_speed_pert: bool = False, + batch_size: int = 15_000, + use_mgpu: bool = True, ): - batch_size = 15_000 for n_epochs in n_epochs_list: - alias += "/train_from_scratch/%d-epochs_w-ctc-loss" % (n_epochs,) + alias += f"/viterbi-train_from_scratch/{n_epochs}-epochs_bs-{batch_size}_w-ctc-loss_{'w' if use_speed_pert else 'wo'}-speed-pert" + + train_opts = { + "dataset_opts": { + "use_speed_pert": use_speed_pert, + "epoch_wise_filter": {(1, 5): {"max_mean_len": 1000}} + }, + # "import_model_train_epoch1": None, + "accum_grad_multiple_step": 4, + "pos_emb_dropout": 0.1, + "rf_att_dropout_broadcast": False, + "batch_size": batch_size, + "batching": "laplace:.1000", + "lr_opts": { + "type": "dyn_lr_piecewise_linear", + "batch_size": batch_size, + "num_epochs": n_epochs, + "learning_rate": 1e-3, + }, + "aux_loss_layers": None, + "specaugment_steps": (5_000, 15_000, 25_000), + "grad_scaler": None, + "gradient_clip_global_norm": 5.0, + "optimizer": { + "class": "adamw", + "weight_decay_modules_blacklist": [ + "rf.Embedding", + "rf.LearnedRelativePositionalEncoding", + ], + "epsilon": 1e-16, + "weight_decay": 1e-6, + }, + "train_def": viterbi_training, + "train_step_func": _returnn_v2_train_step, + } + + if use_speed_pert: + train_opts["preload_from_files"] = { + "pretrained_ctc_weights": { + "filename": external_checkpoints[default_import_model_name + "_w_ctc"], + "init_for_train": True, + "ignore_missing": False, + } + } + + train_rqmt = { + "time": time_rqmt, + } + if use_mgpu: + train_rqmt.update({ + "horovod_num_processes": 4, + "distributed_launch_cmd": "torchrun" + }) + train_opts["torch_distributed"] = {} train_exp = SegmentalTrainExperiment( config_builder=config_builder, alias=alias, num_epochs=n_epochs, - train_rqmt={ - "time": time_rqmt, - "horovod_num_processes": 4, - "distributed_launch_cmd": "torchrun" + train_rqmt=train_rqmt, + train_opts=train_opts + ) + checkpoints, model_dir, learning_rates = train_exp.run_train() + + checkpoint = { + "model_dir": model_dir, + "learning_rates": learning_rates, + "key": "dev_loss_non_blank_ce", + "checkpoints": checkpoints, + "n_epochs": n_epochs + } + yield alias, checkpoint + + +def train_center_window_att_full_sum_from_scratch( + alias: str, + config_builder: SegmentalAttConfigBuilderRF, + n_epochs_list: Tuple[int, ...], + time_rqmt: int = 80, + use_speed_pert: bool = False, + batch_size: int = 15_000, + use_mgpu: bool = True, + beam_size: Optional[int] = None, +): + # TODO: do this in a nicer way + config_builder = copy.deepcopy(config_builder) + config_builder.get_model_func = _returnn_v2_get_model_for_full_sum_training + for n_epochs in n_epochs_list: + alias += f"/full-sum-train_from_scratch/{n_epochs}-epochs_bs-{batch_size}_w-ctc-loss_{'w' if use_speed_pert else 'wo'}-speed-pert" + + train_opts = { + "dataset_opts": { + "use_speed_pert": use_speed_pert, + "epoch_wise_filter": {(1, 5): {"max_mean_len": 1000}}, + "hdf_targets": {}, # do not use alignment for full sum training + "seq_postfix": None, }, - train_opts={ - "dataset_opts": { - "use_speed_pert": False, - "epoch_wise_filter": {(1, 5): {"max_mean_len": 1000}} - }, - # "import_model_train_epoch1": None, - "accum_grad_multiple_step": 4, - "torch_distributed": {}, - "pos_emb_dropout": 0.1, - "rf_att_dropout_broadcast": False, + # "import_model_train_epoch1": None, + "accum_grad_multiple_step": 4, + "pos_emb_dropout": 0.1, + "rf_att_dropout_broadcast": False, + "batch_size": batch_size, + "batching": "laplace:.1000", + "lr_opts": { + "type": "dyn_lr_piecewise_linear", "batch_size": batch_size, - "batching": "laplace:.1000", - "lr_opts": { - "type": "dyn_lr_piecewise_linear", - "batch_size": batch_size, - "num_epochs": n_epochs, - "learning_rate": 1e-3, - }, - "aux_loss_layers": None, - "specaugment_steps": (5_000, 15_000, 25_000), - "grad_scaler": None, - "gradient_clip_global_norm": 5.0, - "optimizer": { - "class": "adamw", - "weight_decay_modules_blacklist": [ - "rf.Embedding", - "rf.LearnedRelativePositionalEncoding", - ], - "epsilon": 1e-16, - "weight_decay": 1e-6, - }, - "train_def": viterbi_training, - "train_step_func": _returnn_v2_train_step, - } + "num_epochs": n_epochs, + "learning_rate": 1e-3, + }, + "aux_loss_layers": None, + "specaugment_steps": (5_000, 15_000, 25_000), + "grad_scaler": None, + "gradient_clip_global_norm": 5.0, + "optimizer": { + "class": "adamw", + "weight_decay_modules_blacklist": [ + "rf.Embedding", + "rf.LearnedRelativePositionalEncoding", + ], + "epsilon": 1e-16, + "weight_decay": 1e-6, + }, + # "max_seq_length": {"targets": 75}, + "train_def": full_sum_training, + "train_step_func": _returnn_v2_full_sum_train_step, + } + + if beam_size is not None: + train_opts["full_sum_training_beam_size"] = beam_size + + train_rqmt = { + "time": time_rqmt, + } + if use_mgpu: + train_rqmt.update({ + "horovod_num_processes": 4, + "distributed_launch_cmd": "torchrun" + }) + train_opts["torch_distributed"] = {} + + train_exp = SegmentalTrainExperiment( + config_builder=config_builder, + alias=alias, + num_epochs=n_epochs, + train_rqmt=train_rqmt, + train_opts=train_opts ) checkpoints, model_dir, learning_rates = train_exp.run_train() @@ -83,6 +193,7 @@ def train_center_window_att_viterbi_import_global_tf( const_lr_list: Tuple[float, ...] = (1e-4,), time_rqmt: int = 80, alignment_augmentation_opts: Optional[Dict] = None, + import_model_name: str = default_import_model_name, ): if not config_builder.use_att_ctx_in_state: # only randomly init FF weights, since only the input dim of the lstm layer is different @@ -92,7 +203,7 @@ def train_center_window_att_viterbi_import_global_tf( for n_epochs in n_epochs_list: for const_lr in const_lr_list: - train_alias = alias + f"/train_from_global_att_tf_checkpoint/standard-training/{n_epochs}-epochs_{const_lr}-const-lr_wo-ctc-loss" + train_alias = alias + f"/train_from_{import_model_name}/standard-training/{n_epochs}-epochs_{const_lr}-const-lr_wo-ctc-loss" if alignment_augmentation_opts: opts = alignment_augmentation_opts train_alias += f"_align-aug-{opts['num_iterations']}-iters_{opts['max_shift']}-max-shift" @@ -100,7 +211,7 @@ def train_center_window_att_viterbi_import_global_tf( train_opts = { "preload_from_files": { "pretrained_global_att_params": { - "filename": external_checkpoints[default_import_model_name], + "filename": external_checkpoints[import_model_name], "init_for_train": True, "ignore_missing": True, # because of length model params } diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/checkpoints.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/checkpoints.py index 2b3dc216b..56f161b86 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/checkpoints.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/checkpoints.py @@ -16,19 +16,30 @@ from sisyphus import tk +external_checkpoints = {} -global_att_checkpoint = ConvertTfCheckpointToRfPtJob( +for checkpoint_name, checkpoint in external_checkpoints_tf.items(): + global_att_checkpoint = ConvertTfCheckpointToRfPtJob( + checkpoint=checkpoint, + make_model_func=MakeModelGlobal( + in_dim=80, + target_dim=10025, + ), + map_func=map_param_func_v2_global + ).out_checkpoint + + external_checkpoints[checkpoint_name] = PtCheckpoint(global_att_checkpoint) + +global_att_checkpoint_w_ctc = ConvertTfCheckpointToRfPtJob( checkpoint=external_checkpoints_tf[default_import_model_name], make_model_func=MakeModelGlobal( in_dim=80, target_dim=10025, + enc_aux_logits=(11,) ), map_func=map_param_func_v2_global ).out_checkpoint - -external_checkpoints = { - default_import_model_name: PtCheckpoint(global_att_checkpoint) -} +external_checkpoints[default_import_model_name + "_w_ctc"] = PtCheckpoint(global_att_checkpoint_w_ctc) def get_center_window_baseline_v1_tf_checkpoint(): diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/global_att/baseline_v1/__init__.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/global_att/baseline_v1/__init__.py index 31c6c5bab..c6c6301de 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/global_att/baseline_v1/__init__.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/global_att/baseline_v1/__init__.py @@ -11,7 +11,8 @@ def run_exps(): for use_weight_feedback in (True,): for model_alias, config_builder in baseline.global_att_baseline_rf(use_weight_feedback=use_weight_feedback): for train_alias, checkpoint in ( - (f"{model_alias}/import-global-tf_no-finetuning", external_checkpoints[default_import_model_name]), + (f"{model_alias}/import_{default_import_model_name}", external_checkpoints[default_import_model_name]), + (f"{model_alias}/import_glob.conformer.mohammad.5.4", external_checkpoints["glob.conformer.mohammad.5.4"]), ): recog.global_att_returnn_label_sync_beam_search( alias=train_alias, @@ -31,37 +32,3 @@ def run_exps(): config_builder=config_builder, checkpoint=checkpoint, ) - - for use_weight_feedback in (True,): - for model_alias, config_builder in baseline.global_att_baseline_rf( - use_weight_feedback=use_weight_feedback, - use_att_ctx_in_state=False, - ): - for train_alias, checkpoint in train.train_import_global_tf( - alias=model_alias, - config_builder=config_builder, - n_epochs_list=(100,), - const_lr_list=(1e-4,), - ): - recog.global_att_returnn_label_sync_beam_search( - alias=train_alias, - config_builder=config_builder, - checkpoint=checkpoint, - ) - - for use_weight_feedback in (False,): - for model_alias, config_builder in baseline.global_att_baseline_rf( - use_weight_feedback=use_weight_feedback, - use_att_ctx_in_state=False, - ): - for train_alias, checkpoint in train.train_import_global_tf( - alias=model_alias, - config_builder=config_builder, - n_epochs_list=(300,), - const_lr_list=(1e-4,), - ): - recog.global_att_returnn_label_sync_beam_search( - alias=train_alias, - config_builder=config_builder, - checkpoint=checkpoint, - ) diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/global_att/train.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/global_att/train.py index 6d02cab56..c4c3949b3 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/global_att/train.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/global_att/train.py @@ -58,6 +58,7 @@ def train_import_global_tf( n_epochs_list: Tuple[int, ...], const_lr_list: Tuple[float, ...], time_rqmt: int = 80, + import_model_name: str = default_import_model_name, ): if not config_builder.use_att_ctx_in_state: # only randomly init FF weights, since only the input dim of the lstm layer is different @@ -66,12 +67,12 @@ def train_import_global_tf( custom_missing_load_func = None for n_epochs, const_lr in itertools.product(n_epochs_list, const_lr_list): - train_alias = alias + f"/train_from_global_att_tf_checkpoint/standard-training/{n_epochs}-epochs_{const_lr}-const-lr_wo-ctc-loss" + train_alias = alias + f"/train_from_{import_model_name}/standard-training/{n_epochs}-epochs_{const_lr}-const-lr_wo-ctc-loss" train_opts = { "preload_from_files": { "pretrained_global_att_params": { - "filename": external_checkpoints[default_import_model_name], + "filename": external_checkpoints[import_model_name], "init_for_train": True, } }, diff --git a/users/schmitt/returnn_frontend/model_interfaces/training.py b/users/schmitt/returnn_frontend/model_interfaces/training.py index 6edef2ad1..d834db360 100644 --- a/users/schmitt/returnn_frontend/model_interfaces/training.py +++ b/users/schmitt/returnn_frontend/model_interfaces/training.py @@ -48,3 +48,22 @@ def __call__( raise NotImplementedError learning_rate_control_error_measure: Optional[str] = None + + +class FullSumTrainDef(Protocol[ModelT]): + """ + Defines the losses (mark_as_loss). + """ + + def __call__( + self, + *, + model: ModelT, + data: Tensor, + data_spatial_dim: Dim, + non_blank_targets: Tensor, + non_blank_targets_spatial_dim: Dim, + ): + raise NotImplementedError + + learning_rate_control_error_measure: Optional[str] = None From b76c488cd3c6698361f34367af8092a43c0f8f2b Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Thu, 6 Jun 2024 12:18:11 +0200 Subject: [PATCH 103/227] update --- .../tedlium2/configs/ted2_att_baseline.py | 197 +++++++----------- 1 file changed, 75 insertions(+), 122 deletions(-) diff --git a/users/zeineldeen/experiments/conformer_att_2023/tedlium2/configs/ted2_att_baseline.py b/users/zeineldeen/experiments/conformer_att_2023/tedlium2/configs/ted2_att_baseline.py index 3c9f21f2c..76080e7fd 100644 --- a/users/zeineldeen/experiments/conformer_att_2023/tedlium2/configs/ted2_att_baseline.py +++ b/users/zeineldeen/experiments/conformer_att_2023/tedlium2/configs/ted2_att_baseline.py @@ -1161,68 +1161,19 @@ def get_base_v1_args(lr, ep, enc_drop=0.1, pretrain_reps=3, use_legacy_stats=Tru recog_datasets_tuples = get_test_dataset_tuples(bpe_size=BPE_1K) - # baseline: 7.41/6.85 - # dev_coverage0.03_0.11_max/wer 7.34 - # test_coverage0.03_0.11_max/wer 6.85 - # for test_set in ["test"]: - # for cov_update in ["max"]: - # for cov_scale in [0.03, 0.04]: - # for cov_thre in [0.11, 0.13]: - # search_args = copy.deepcopy(args) - # search_args["decoder_args"].coverage_scale = cov_scale - # search_args["decoder_args"].coverage_threshold = cov_thre - # name_ = f"/average_4/{test_set}_coverage{cov_scale}_{cov_thre}" - # if cov_update == "max": - # name_ += "_max" - # search_args["decoder_args"].coverage_update = "max" - # run_single_search( - # exp_name=name + name_, - # train_data=train_data, - # search_args=search_args, - # checkpoint=train_job_avg_ckpt[name], - # feature_extraction_net=log10_net_10ms, - # recog_dataset=recog_datasets_tuples[test_set][0], - # recog_ref=recog_datasets_tuples[test_set][1], - # recog_bliss=recog_datasets_tuples[test_set][2], - # ) - - # # TODO: only CTC - # only_ctc_args = copy.deepcopy(args) - # only_ctc_args["decoder_args"].ce_loss_scale = 0.0 - # _, train_data = run_exp( - # name + "_onlyCTC", - # only_ctc_args, - # num_epochs=ep, - # epoch_wise_filter=None, - # bpe_size=BPE_1K, - # partition_epoch=4, - # search_args={"ctc_decode": True, "ctc_blank_idx": 1057, **only_ctc_args}, - # avg_key="dev_score_ctc", - # ) - # - # # TODO: scale CTC - # scale_ctc_args = copy.deepcopy(args) - # scale_ctc_args["encoder_args"].ctc_loss_scale = 0.3 / 0.7 # AED scale is 1.0 - # _, train_data = run_exp( - # name + "_ctcScale0.3", - # scale_ctc_args, - # num_epochs=ep, - # epoch_wise_filter=None, - # bpe_size=BPE_1K, - # partition_epoch=4, - # ) - # - # # TODO: grad clip 5 - # grad_clip_args = copy.deepcopy(args) - # grad_clip_args["gradient_clip_global_norm"] = 5 - # _, train_data = run_exp( - # name + "_gradClipNorm5", - # grad_clip_args, - # num_epochs=ep, - # epoch_wise_filter=None, - # bpe_size=BPE_1K, - # partition_epoch=4, - # ) + # TODO: only CTC + only_ctc_args = copy.deepcopy(args) + only_ctc_args["decoder_args"].ce_loss_scale = 0.0 + _, train_data = run_exp( + name + "_onlyCTC", + only_ctc_args, + num_epochs=ep, + epoch_wise_filter=None, + bpe_size=BPE_1K, + partition_epoch=4, + search_args={"ctc_decode": True, "ctc_blank_idx": 1057, **only_ctc_args}, + avg_key="dev_score_ctc", + ) # base_bpe1000_peakLR0.0008_ep400_globalNorm_epochOCLR_pre3_fixZoneout_encDrop0.15_woDepthConvPre_weightDrop0.1_decAttDrop0.0_embedDim256_numBlocks12 # 7.4 6.85 avg @@ -1270,6 +1221,7 @@ def get_base_v1_args(lr, ep, enc_drop=0.1, pretrain_reps=3, use_legacy_stats=Tru if ctc_scale == 0.3: args_ = copy.deepcopy(args) args_["with_pretrain"] = False + reset_params_init(args_["encoder_args"]) specaug_steps = {"step0": 10_000, "step1": 15_000, "step2": 20_000} args_["specaug_str_func_opts"] = { "version": 2, @@ -1280,7 +1232,7 @@ def get_base_v1_args(lr, ep, enc_drop=0.1, pretrain_reps=3, use_legacy_stats=Tru "freq_dim_factor": 5, } run_exp( - exp_name + "_woPretrain", + exp_name + "_woPretrain_defaultInit", args_, num_epochs=ep, epoch_wise_filter=[(1, 2, 400), (3, 4, 800)], @@ -1289,75 +1241,76 @@ def get_base_v1_args(lr, ep, enc_drop=0.1, pretrain_reps=3, use_legacy_stats=Tru ) args_["encoder_args"].with_ctc = False run_exp( - exp_name + "_woPretrain_noCTC", + exp_name + "_woPretrain_noCTC_defaultInit", args_, num_epochs=ep, epoch_wise_filter=[(1, 2, 400), (3, 4, 800)], bpe_size=BPE_1K, partition_epoch=4, + avg_key="dev_score", ) # TODO: multi-gpu # base_bpe1000_peakLR0.0016_ep200_globalNorm_epochOCLR_pre3_fixZoneout_encDrop0.15_woDepthConvPre_weightDrop0.1_decAttDrop0.0_embedDim256_numBlocks12_gradClipNorm5.0_paramSync_step100_accum1_ctcScale0.3_gpu4 # 8.66 7.97 avg - - for num_blocks in [12]: - for ep in [50 * 4]: - for lr in [8e-4, 13e-4, 16e-4]: - for target_embed_dim in [256]: - for att_drop in [0.0]: - for weight_drop in [0.1]: - for enc_drop in [0.15]: - for ctc_scale in [0.3]: - for sync_step in [100]: - for grad_clip in [None, 1.0, 5.0]: - if grad_clip is None and lr != 8e-4: - continue - - base_v1_args, exp_name = get_base_v1_args( - lr, ep, enc_drop=enc_drop, use_legacy_stats=False - ) - - args = copy.deepcopy(base_v1_args) - args["encoder_args"].num_blocks = num_blocks - args["encoder_args"].mhsa_weight_dropout = weight_drop - args["encoder_args"].ff_weight_dropout = weight_drop - args["encoder_args"].conv_weight_dropout = weight_drop - - args["decoder_args"].embed_dim = target_embed_dim - args["decoder_args"].att_dropout = att_drop - - args["horovod_params"] = { - "horovod_reduce_type": "param", - "horovod_param_sync_step": sync_step, - "horovod_dataset_distribution": "random_seed_offset", - } - - args["batch_size"] = 15_000 * 160 - args["pretrain_opts"]["initial_batch_size"] = 15_000 * 160 - args["accum_grad"] = 1 - - exp_name += f"_weightDrop{weight_drop}_decAttDrop{att_drop}_embedDim{target_embed_dim}_numBlocks{num_blocks}" - if grad_clip: - args["gradient_clip_global_norm"] = grad_clip - exp_name += f"_gradClipNorm{grad_clip}" - - exp_name += f"_paramSync_step{sync_step}_accum1" - - if ctc_scale != 1.0: - args["encoder_args"].ctc_loss_scale = ctc_scale - args["decoder_args"].ce_loss_scale = 1.0 - ctc_scale - exp_name += f"_ctcScale{ctc_scale}" - - run_exp( - exp_name + "_gpu4", - args, - num_epochs=ep, - epoch_wise_filter=None, - bpe_size=BPE_1K, - partition_epoch=4 * 4, - horovod_num_processes=4, - ) + # + # for num_blocks in [12]: + # for ep in [50 * 4]: + # for lr in [8e-4, 13e-4, 16e-4]: + # for target_embed_dim in [256]: + # for att_drop in [0.0]: + # for weight_drop in [0.1]: + # for enc_drop in [0.15]: + # for ctc_scale in [0.3]: + # for sync_step in [100]: + # for grad_clip in [None, 1.0, 5.0]: + # if grad_clip is None and lr != 8e-4: + # continue + # + # base_v1_args, exp_name = get_base_v1_args( + # lr, ep, enc_drop=enc_drop, use_legacy_stats=False + # ) + # + # args = copy.deepcopy(base_v1_args) + # args["encoder_args"].num_blocks = num_blocks + # args["encoder_args"].mhsa_weight_dropout = weight_drop + # args["encoder_args"].ff_weight_dropout = weight_drop + # args["encoder_args"].conv_weight_dropout = weight_drop + # + # args["decoder_args"].embed_dim = target_embed_dim + # args["decoder_args"].att_dropout = att_drop + # + # args["horovod_params"] = { + # "horovod_reduce_type": "param", + # "horovod_param_sync_step": sync_step, + # "horovod_dataset_distribution": "random_seed_offset", + # } + # + # args["batch_size"] = 15_000 * 160 + # args["pretrain_opts"]["initial_batch_size"] = 15_000 * 160 + # args["accum_grad"] = 1 + # + # exp_name += f"_weightDrop{weight_drop}_decAttDrop{att_drop}_embedDim{target_embed_dim}_numBlocks{num_blocks}" + # if grad_clip: + # args["gradient_clip_global_norm"] = grad_clip + # exp_name += f"_gradClipNorm{grad_clip}" + # + # exp_name += f"_paramSync_step{sync_step}_accum1" + # + # if ctc_scale != 1.0: + # args["encoder_args"].ctc_loss_scale = ctc_scale + # args["decoder_args"].ce_loss_scale = 1.0 - ctc_scale + # exp_name += f"_ctcScale{ctc_scale}" + # + # run_exp( + # exp_name + "_gpu4", + # args, + # num_epochs=ep, + # epoch_wise_filter=None, + # bpe_size=BPE_1K, + # partition_epoch=4 * 4, + # horovod_num_processes=4, + # ) # # TODO: mixup # for num_blocks in [12]: From f7ca71a0fe4d0b236fe5c6ef042628e1f9a296c3 Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Thu, 6 Jun 2024 12:20:07 +0200 Subject: [PATCH 104/227] update --- .../configs/libri_chunked_aed_variants.py | 1470 +++++++++++++++++ .../configs/ted2_chunked_aed_variants.py | 71 +- 2 files changed, 1508 insertions(+), 33 deletions(-) create mode 100644 users/zeineldeen/experiments/chunkwise_att_2023/librispeech_960/configs/libri_chunked_aed_variants.py diff --git a/users/zeineldeen/experiments/chunkwise_att_2023/librispeech_960/configs/libri_chunked_aed_variants.py b/users/zeineldeen/experiments/chunkwise_att_2023/librispeech_960/configs/libri_chunked_aed_variants.py new file mode 100644 index 000000000..ceddb4d61 --- /dev/null +++ b/users/zeineldeen/experiments/chunkwise_att_2023/librispeech_960/configs/libri_chunked_aed_variants.py @@ -0,0 +1,1470 @@ +""" +based on: +users/zeineldeen/experiments/conformer_att_2022/librispeech_960/configs/baseline_960h_v2.py +""" + +from __future__ import annotations +from typing import Optional, Union, List +import copy +import os + +import numpy, math + +from sisyphus import tk + +from i6_experiments.users.zeineldeen.experiments.chunkwise_att_2023.librispeech_960.chunkwise_attention_asr_config import ( + create_config, + ConformerEncoderArgs, + RNNDecoderArgs, +) + +from i6_experiments.users.zeineldeen.experiments.conformer_att_2022.librispeech_960.additional_config import ( + apply_fairseq_init_to_conformer, +) +from i6_experiments.users.zeineldeen.experiments.chunkwise_att_2023.librispeech_960.data import ( + build_training_datasets, + build_test_dataset, + build_chunkwise_training_datasets, +) +from i6_experiments.users.zeineldeen.experiments.conformer_att_2023.librispeech_960.default_tools import ( + RETURNN_ROOT, + RETURNN_CPU_EXE, +) +from i6_experiments.users.zeineldeen.experiments.conformer_att_2023.tedlium2.default_tools import RETURNN_ROOT_V2 +from i6_experiments.users.zeineldeen.experiments.conformer_att_2022.librispeech_960.feature_extraction_net import ( + log10_net_10ms, +) +from i6_experiments.users.zeineldeen.experiments.conformer_att_2022.librispeech_960.pipeline import ( + training, + search, + get_average_checkpoint, + get_best_checkpoint, + search_single, +) +from i6_experiments.users.zeineldeen.models.lm import generic_lm +from i6_experiments.users.zeineldeen.models.lm.transformer_lm import TransformerLM +from i6_experiments.users.zeineldeen.experiments.conformer_att_2022.librispeech_960 import ( + ilm_helpers, +) +from i6_experiments.users.rossenbach.experiments.librispeech.kazuki_lm.experiment import ( + get_lm, + ZeineldeenLM, +) + +from i6_experiments.users.zeineldeen.experiments.chunkwise_att_2023 import ( + tools_eval_funcs, + tools_eval_funcs_old, +) + +from i6_core.returnn.config import ReturnnConfig +from i6_core.returnn.training import Checkpoint +from i6_core.returnn.forward import ReturnnForwardJob + +train_jobs_map = {} # dict[str, ReturnnTrainJob] +train_job_avg_ckpt = {} +train_job_best_epoch = {} + +BPE_10K = 10000 +BPE_5K = 5000 +BPE_1K = 1000 + +# dev-other: +# Seq-length 'audio_features' Stats: +# 2864 seqs +# Mean: 102995.8959497207 (6.4 sec) +# Std dev: 69081.77143805166 (4.3 sec) +# Min/max: 17040 / 562480 (1.1 / 35.2 sec) +# Seq-length 'bpe_labels' Stats: +# 2864 seqs +# Mean: 21.13966480446923 +# Std dev: 13.536136898032625 +# Min/max: 2 / 110 +# +# test-other: +# Seq-length 'audio_features' Stats: +# 2939 seqs +# Mean: 104686.32936372912 (6.5 sec) +# Std dev: 70821.55181403323 (4.4 sec) +# Min/max: 20000 / 552160 (1.2 / 34.5 sec) +# Seq-length 'bpe_labels' Stats: +# 2939 seqs +# Mean: 21.22796869683565 +# Std dev: 14.559673655773087 +# Min/max: 2 / 137 + + +# --------------------------- LM --------------------------- # + +lstm_10k_lm_opts = { + "lm_subnet": generic_lm.libri_lstm_bpe10k_net, + "lm_model": generic_lm.libri_lstm_bpe10k_model, + "name": "lstm", +} + +lstm_lm_opts_map = { + BPE_10K: lstm_10k_lm_opts, +} + +trafo_lm_net = TransformerLM(source="prev:output", num_layers=24, vocab_size=10025, use_as_ext_lm=True) +trafo_lm_net.create_network() +trafo_10k_lm_opts = { + "lm_subnet": trafo_lm_net.network.get_net(), + "load_on_init_opts": { + "filename": "/work/asr3/irie/experiments/lm/librispeech/2018-03-05--lmbpe-zeyer/data-train/transfo_24_d00.4096_1024.sgd.lr1.8_heads/bk-net-model/network.023", + "params_prefix": "", + "load_if_prefix": "lm_output_masked/", + }, + "name": "trafo", +} + +bpe5k_lm = get_lm("ls960_trafo24_bs3000_5ep_5kbpe") # type: ZeineldeenLM +trafo_5k_lm_opts = { + "lm_subnet": bpe5k_lm.combination_network, + "load_on_init_opts": { + "filename": get_best_checkpoint(bpe5k_lm.train_job, key="dev_score_output/output"), + "params_prefix": "", + "load_if_prefix": "lm_output/", + }, + "name": "trafo", +} + +trafo_lm_opts_map = { + BPE_10K: trafo_10k_lm_opts, + BPE_5K: trafo_5k_lm_opts, +} + + +# ----------------------------------------------------------- # + + +abs_name = os.path.abspath(__file__) +prefix_name = os.path.basename(abs_name)[: -len(".py")] + + +def get_test_dataset_tuples(bpe_size, selected_datasets=None): + test_dataset_tuples = {} + for testset in ["dev-clean", "dev-other", "test-clean", "test-other"]: + if selected_datasets and testset not in selected_datasets: + continue + test_dataset_tuples[testset] = build_test_dataset( + testset, + use_raw_features=True, + bpe_size=bpe_size, + ) + return test_dataset_tuples + + +def run_train( + prefix_name: str, + exp_name: str, + train_args, + train_data, + feature_extraction_net, + num_epochs, + recog_epochs, + time_rqmt=168, + **kwargs, +): + exp_prefix = os.path.join(prefix_name, exp_name) + returnn_config = create_config( + training_datasets=train_data, + **train_args, + feature_extraction_net=feature_extraction_net, + recog_epochs=recog_epochs, + ) + train_job = training( + exp_prefix, + returnn_config, + RETURNN_CPU_EXE, + kwargs.get("returnn_root", RETURNN_ROOT), + num_epochs=num_epochs, + time_rqmt=time_rqmt, + gpu_mem=kwargs.get("gpu_mem", 11), + ) + return train_job + + +def run_single_search( + prefix_name: str, + exp_name: str, + train_data, + search_args, + checkpoint, + feature_extraction_net, + recog_dataset, + recog_ref, + recog_bliss_corpus, + mem_rqmt=8, + time_rqmt=4, + **kwargs, +): + exp_prefix = os.path.join(prefix_name, exp_name) + returnn_search_config = create_config( + training_datasets=train_data, + **search_args, + feature_extraction_net=feature_extraction_net, + is_recog=True, + ) + search_single( + exp_prefix, + returnn_search_config, + checkpoint, + recognition_dataset=recog_dataset, + recognition_reference=recog_ref, + recognition_bliss_corpus=recog_bliss_corpus, + returnn_exe=RETURNN_CPU_EXE, + returnn_root=kwargs.get("returnn_root", RETURNN_ROOT), + mem_rqmt=mem_rqmt, + time_rqmt=time_rqmt, + use_sclite=True, + use_gpu_test=kwargs.get("use_gpu_test", False), + gpu_mem=kwargs.get("gpu_mem", 11), + ) + + +def run_lm_fusion( + lm_type, + prefix_name: str, + exp_name: str, + epoch: Union[str, int], + test_set_names: Union[str, List[str]], + lm_scales, + train_job, + train_data, + feature_net, + bpe_size, + args, + am_scale=1.0, + beam_size=12, + prior_scales=None, + prior_type=None, + mini_lstm_ckpt=None, + length_norm=True, + prior_type_name=None, + coverage_scale=None, + coverage_threshold=None, + lm_desc_suffix="", + **kwargs, +): + assert lm_type in ["lstm", "trafo"], "lm type should be lstm or trafo" + + if isinstance(lm_scales, float): + lm_scales = [lm_scales] + if prior_scales and isinstance(prior_scales, float): + prior_scales = [prior_scales] + if isinstance(test_set_names, str): + test_set_names = [test_set_names] + assert isinstance(test_set_names, list) + + if epoch == "avg": + search_checkpoint = train_job_avg_ckpt[exp_name] + elif epoch == "best": + search_checkpoint = train_job_best_epoch[exp_name] + else: + assert isinstance(epoch, int), "epoch must be either a defined integer or a string in {avg, best}." + search_checkpoint = train_job.out_checkpoints[epoch] + + ext_lm_opts = lstm_lm_opts_map[bpe_size] if lm_type == "lstm" else trafo_lm_opts_map[bpe_size] + + ext_lm_opts["am_scale"] = am_scale + + time_rqmt = 1.0 + + search_args = copy.deepcopy(args) + + if lm_type == "lstm": + if beam_size > 128: + search_args["batch_size"] = 4000 * 160 + + if lm_type == "trafo": + search_args["batch_size"] = 4000 * 160 if beam_size <= 32 else 2000 * 160 + time_rqmt = 2 + if beam_size > 50: + time_rqmt = 3 + + search_args["beam_size"] = beam_size + if kwargs.get("batch_size", None): + search_args["batch_size"] = kwargs["batch_size"] + + if not length_norm: + search_args["decoder_args"].length_normalization = False + + if "decoder_args" in kwargs: + for k, v in kwargs["decoder_args"].items(): + setattr(search_args["decoder_args"], k, v) + + scales = [(e,) for e in lm_scales] + + for test_set in test_set_names: + if prior_scales: + import itertools + + scales = itertools.product(lm_scales, prior_scales) + + for scale in scales: + lm_scale = scale[0] + prior_scale = scale[1] if len(scale) == 2 else None + if prior_scale and prior_scale > lm_scale: + continue + + # External LM opts + ext_lm_opts["lm_scale"] = lm_scale + search_args["ext_lm_opts"] = ext_lm_opts + + # ILM opts + if prior_scale: + ilm_opts = { + "scale": prior_scale, + "type": prior_type, + "ctx_dim": search_args["encoder_args"].enc_key_dim, # this is needed for mini-lstm + } + # this is needed for mini-self-att + if hasattr(search_args["decoder_args"], "num_layers"): + ilm_opts["num_dec_layers"] = search_args["decoder_args"].num_layers + search_args["decoder_args"].create_ilm_decoder = True + search_args["decoder_args"].ilm_type = prior_type + + ilm_opts.update(kwargs.get("ilm_train_opts", {})) # example for FFN, etc + + search_args["prior_lm_opts"] = ilm_opts + search_args["preload_from_files"] = { + "prior_lm": { + "filename": search_checkpoint, # copy ASR decoder to be used as ILM decoder + "prefix": "prior_", + } + } + if prior_type == "mini_lstm" or prior_type == "ffn": + assert mini_lstm_ckpt, "Mini-LSTM checkpoint not set." + search_args["preload_from_files"].update( + { + "mini_lstm": { + "filename": mini_lstm_ckpt, + "prefix": "mini_", + } + } + ) + + if prior_type_name is None: + prior_type_name = prior_type + + lm_desc = "" + + if am_scale: + lm_desc += f"am-scale-{am_scale}-" + + lm_desc += f"lm-scale-{lm_scale}" + if prior_scale: + lm_desc += f"-prior-{prior_scale}-{prior_type_name}" + lm_desc += f"-beam-{beam_size}" + if length_norm is False: + lm_desc += "-woLenNorm" + + if coverage_scale and coverage_threshold: + assert isinstance(search_args["decoder_args"], RNNDecoderArgs) + search_args["decoder_args"].coverage_scale = coverage_scale + search_args["decoder_args"].coverage_threshold = coverage_threshold + lm_desc += f"_coverage-thre{coverage_threshold}-scale{coverage_scale}" + + if lm_desc_suffix: + lm_desc += f"{lm_desc_suffix}" + + name = f"{exp_name}/recog-{lm_type}-lm/ep-{epoch}/{lm_desc}/{test_set}" + + test_dataset_tuples = get_test_dataset_tuples(bpe_size=bpe_size) + + run_single_search( + prefix_name=prefix_name, + exp_name=name, + train_data=train_data, + search_args=search_args, + checkpoint=search_checkpoint, + feature_extraction_net=feature_net, + recog_dataset=test_dataset_tuples[test_set][0], + recog_ref=test_dataset_tuples[test_set][1], + recog_bliss_corpus=test_dataset_tuples[test_set][2], + time_rqmt=kwargs.get("time_rqmt", time_rqmt), + gpu_mem=kwargs.get("gpu_mem", 11), + use_gpu_test=kwargs.get("use_gpu_test", False), + returnn_root=kwargs.get("returnn_root", RETURNN_ROOT), + ) + + +def run_search( + prefix_name: str, + exp_name: str, + train_args, + train_data, + train_job, + feature_extraction_net, + num_epochs, + search_args, + recog_epochs, + bpe_size, + run_all_for_best_last_avg=False, + recog_ext_pipeline=False, + **kwargs, +): + exp_prefix = os.path.join(prefix_name, exp_name) + + search_args = search_args if search_args is not None else copy.deepcopy(train_args) + search_args["search_type"] = None + + returnn_search_config = create_config( + training_datasets=train_data, + **search_args, + feature_extraction_net=feature_extraction_net, + is_recog=True, + recog_ext_pipeline=recog_ext_pipeline, + ) + + num_avg = kwargs.get("num_avg", 4) + averaged_checkpoint = get_average_checkpoint( + train_job, + returnn_exe=RETURNN_CPU_EXE, + returnn_root=kwargs.get("returnn_root", RETURNN_ROOT), + num_average=num_avg, + key=kwargs.get("key", "dev_score_output/output_prob"), + ) + if num_avg == 4: # TODO: just for now to not break hashes + train_job_avg_ckpt[exp_name] = averaged_checkpoint + + best_checkpoint = get_best_checkpoint(train_job, key=kwargs.get("key", "dev_score_output/output_prob")) + train_job_best_epoch[exp_name] = best_checkpoint + + if recog_epochs is None: + default_recog_epochs = [40] + [80 * i for i in range(1, int(num_epochs / 80) + 1)] + if num_epochs % 80 != 0: + default_recog_epochs += [num_epochs] + else: + default_recog_epochs = recog_epochs + + test_dataset_tuples = get_test_dataset_tuples( + bpe_size=bpe_size, selected_datasets=kwargs.get("selected_datasets", None) + ) + + all_test_dataset_tuples = get_test_dataset_tuples(bpe_size=bpe_size) + + remove_label = {"", "", ""} if recog_ext_pipeline else None + + for ep in default_recog_epochs: + search( + exp_prefix + f"/recogs/ep-{ep}", + returnn_search_config, + train_job.out_checkpoints[ep], + test_dataset_tuples, + RETURNN_CPU_EXE, + kwargs.get("returnn_root", RETURNN_ROOT), + use_sclite=kwargs.get("use_sclite", False), + recog_ext_pipeline=recog_ext_pipeline, + remove_label=remove_label, + ) + + search( + exp_prefix + "/default_last", + returnn_search_config, + train_job.out_checkpoints[num_epochs], + all_test_dataset_tuples if run_all_for_best_last_avg else test_dataset_tuples, + RETURNN_CPU_EXE, + kwargs.get("returnn_root", RETURNN_ROOT), + use_sclite=kwargs.get("use_sclite", False), + recog_ext_pipeline=recog_ext_pipeline, + remove_label=remove_label, + ) + + search( + exp_prefix + "/default_best", + returnn_search_config, + best_checkpoint, + all_test_dataset_tuples if run_all_for_best_last_avg else test_dataset_tuples, + RETURNN_CPU_EXE, + kwargs.get("returnn_root", RETURNN_ROOT), + use_sclite=kwargs.get("use_sclite", False), + recog_ext_pipeline=recog_ext_pipeline, + remove_label=remove_label, + ) + + search( + exp_prefix + f"/average_{num_avg}", + returnn_search_config, + averaged_checkpoint, + all_test_dataset_tuples if run_all_for_best_last_avg else test_dataset_tuples, + RETURNN_CPU_EXE, + kwargs.get("returnn_root", RETURNN_ROOT), + use_sclite=kwargs.get("use_sclite", False), + recog_ext_pipeline=recog_ext_pipeline, + remove_label=remove_label, + enable_mail=True, + ) + + +def run_exp( + prefix_name: str, + exp_name: str, + train_args, + feature_extraction_net=log10_net_10ms, + num_epochs=300, + search_args=None, + recog_epochs=None, + bpe_size=10000, + partition_epoch=20, + time_rqmt=168, + train_fixed_alignment=None, + cv_fixed_alignment=None, + recog_ext_pipeline=False, + **kwargs, +): + if train_fixed_alignment: + assert cv_fixed_alignment, "cv alignment is not set." + train_data = build_chunkwise_training_datasets( + train_fixed_alignment=train_fixed_alignment, + cv_fixed_alignment=cv_fixed_alignment, + bpe_size=bpe_size, + use_raw_features=True, + partition_epoch=partition_epoch, + epoch_wise_filter=kwargs.get("epoch_wise_filter", [(1, 5, 1000)]), + link_speed_perturbation=train_args.get("speed_pert", True), + seq_ordering=kwargs.get("seq_ordering", "laplace:.1000"), + ) + else: + train_data = build_training_datasets( + bpe_size=bpe_size, + use_raw_features=True, + partition_epoch=partition_epoch, + epoch_wise_filter=kwargs.get("epoch_wise_filter", [(1, 5, 1000)]), + link_speed_perturbation=train_args.get("speed_pert", True), + seq_ordering=kwargs.get("seq_ordering", "laplace:.1000"), + seq_postfix=kwargs.get("seq_postfix", 0), + ) + + train_job = run_train( + prefix_name, + exp_name, + train_args, + train_data, + feature_extraction_net, + num_epochs, + recog_epochs, + time_rqmt=time_rqmt, + **kwargs, + ) + train_jobs_map[exp_name] = train_job + + run_search( + prefix_name, + exp_name, + train_args, + train_data, + train_job, + feature_extraction_net, + num_epochs, + search_args, + recog_epochs, + bpe_size=bpe_size, + recog_ext_pipeline=recog_ext_pipeline, + **kwargs, + ) + return train_job, train_data + + +def run_forward( + prefix_name: str, + exp_name: str, + train_args, + model_ckpt, + hdf_layers=None, + feature_extraction_net=log10_net_10ms, + bpe_size=10000, + time_rqmt=12, + mem_rqmt=15, + override_returnn_config=None, + seq_postfix=0, + **kwargs, +): + # build train, dev, and devtrain + # - No speed pert + # - Partition epoch 1 + # - No curr. learning + + train_data = build_training_datasets( + bpe_size=bpe_size, + use_raw_features=True, + partition_epoch=1, + epoch_wise_filter=None, + link_speed_perturbation=False, + seq_postfix=seq_postfix, + seq_ordering=kwargs.get("seq_ordering", "laplace:.1000"), + ) + + if train_args.get("dump_alignments_dataset", None): + dump_dataset = train_args["dump_alignments_dataset"] + elif train_args.get("dump_ctc_dataset", None): + dump_dataset = train_args["dump_ctc_dataset"] + else: + raise Exception("No dump dataset specified.") + + assert dump_dataset in ["train", "dev"] + + exp_prefix = os.path.join(prefix_name, exp_name) + + if override_returnn_config: + returnn_config = copy.deepcopy(override_returnn_config) + else: + returnn_config = create_config( + training_datasets=train_data, + **train_args, + feature_extraction_net=feature_extraction_net, + ) + + if isinstance(model_ckpt, str): + model_ckpt_index_path = tk.Path(model_ckpt + ".index") + model_ckpt = Checkpoint(index_path=model_ckpt_index_path) + elif isinstance(model_ckpt, Checkpoint): + pass + else: + raise TypeError(f"model_ckpt must be str or Checkpoint, got {type(model_ckpt)}") + forward_j = ReturnnForwardJob( + model_checkpoint=model_ckpt, + hdf_outputs=hdf_layers, + returnn_config=returnn_config, + returnn_python_exe=RETURNN_CPU_EXE, + returnn_root=RETURNN_ROOT, + time_rqmt=time_rqmt, + mem_rqmt=mem_rqmt, + eval_mode=kwargs.get("do_eval", True), + device=kwargs.get("device", "gpu"), + ) + if kwargs.get("cpu_type", None): + assert "sbatch_args" not in forward_j.rqmt + forward_j.rqmt["cpu_type"] = kwargs["cpu_type"] + + forward_j.add_alias(exp_prefix + "/forward_hdf/" + dump_dataset) + + if hdf_layers is None: + hdf_layers = ["output.hdf"] + + for layer in hdf_layers: + tk.register_output( + os.path.join(exp_prefix, "hdfs", dump_dataset), + forward_j.out_hdf_files[layer], + ) + + return forward_j.out_hdf_files + + +def train_mini_lstm( + prefix_name: str, + exp_name: str, + checkpoint, + args, + num_epochs=20, + lr=8e-4, + time_rqmt=4, + l2=1e-4, + name="mini_lstm", + w_drop=False, + use_dec_state=False, + use_ffn=False, + ffn_opts=None, + train_fixed_alignment=None, + cv_fixed_alignment=None, + **kwargs, +): + if not w_drop: + params_freeze_str = ilm_helpers.get_mini_lstm_params_freeze_str() + else: + if use_ffn: + params_freeze_str = ilm_helpers.get_ffn_params_freeze_str_w_drop(ffn_opts["num_ffn_layers"]) + else: + params_freeze_str = ilm_helpers.get_mini_lstm_params_freeze_str_w_drop() + + mini_lstm_args = copy.deepcopy(args) + mini_lstm_args["batch_size"] = 20000 * 160 + mini_lstm_args["with_pretrain"] = False + mini_lstm_args["lr"] = lr + mini_lstm_args["allow_lr_scheduling"] = False + mini_lstm_args["encoder_args"].with_ctc = False + mini_lstm_args["keep_all_epochs"] = True # keep everything + mini_lstm_args["extra_str"] = params_freeze_str + mini_lstm_args["preload_from_files"] = { + "import": { + "init_for_train": True, + "ignore_missing": True, + "filename": checkpoint, + } + } + mini_lstm_args.update(kwargs) + + exp_prefix = os.path.join(prefix_name, exp_name, name) + if train_fixed_alignment is None: + mini_lstm_train_data = build_training_datasets( + bpe_size=10000, + use_raw_features=True, + epoch_wise_filter=None, + link_speed_perturbation=False, # depends only on text + seq_ordering=kwargs.get("seq_ordering", "laplace:.1000"), + ) + else: + mini_lstm_train_data = build_chunkwise_training_datasets( + train_fixed_alignment=train_fixed_alignment, + cv_fixed_alignment=cv_fixed_alignment, + bpe_size=BPE_10K, + use_raw_features=True, + partition_epoch=20, + epoch_wise_filter=None, + link_speed_perturbation=False, + seq_ordering=kwargs.get("seq_ordering", "laplace:.1000"), + ) + + returnn_config = create_config( + training_datasets=mini_lstm_train_data, + **mini_lstm_args, + feature_extraction_net=log10_net_10ms, + ) + + inp = "s" if use_dec_state else "prev:target_embed" + + if use_ffn: + x = inp + activations = ffn_opts["activations"] + for l in range(ffn_opts["num_ffn_layers"]): + returnn_config.config["network"]["output"]["unit"]["ffn_%02i" % (l + 1)] = { + "class": "linear", + "n_out": ffn_opts["ffn_dims"][l], + "L2": l2, + "from": inp, + "activation": activations[l] if activations and l < len(activations) else None, + } + x = "ffn_%02i" % (l + 1) + + returnn_config.config["network"]["output"]["unit"]["att"] = { + "class": "linear", + "from": x, + "activation": None, + "n_out": mini_lstm_args["encoder_args"].enc_key_dim, + "L2": l2, + } + else: + # Mini-LSTM + FF + + returnn_config.config["network"]["output"]["unit"]["att_lstm"] = { + "class": "rec", + "unit": "nativelstm2", + "from": inp, + "n_out": 50, + } + + returnn_config.config["network"]["output"]["unit"]["att"] = { + "class": "linear", + "from": "att_lstm", + "activation": None, + "n_out": mini_lstm_args["encoder_args"].enc_key_dim, + "L2": l2, + } + + train_job = training( + exp_prefix, + returnn_config, + RETURNN_CPU_EXE, + RETURNN_ROOT, + num_epochs=num_epochs, + time_rqmt=time_rqmt, + ) + return train_job + + +def train_mini_self_att( + prefix_name: str, + exp_name: str, + checkpoint, + args, + num_epochs=20, + lr=8e-4, + time_rqmt=4, + name="mini_self_att", + **kwargs, +): + """ + Same idea as Mini-LSTM but use masked (mini-)self-attention models instead of cross attention. + Note that each layer has its own (mini-)self-attention. + + In the case of transformer decoder, we want to replace cross-attention layers namely: + transformer_decoder_{idx}_att_linear + with masked self-attention models. + """ + + params_freeze_str = ilm_helpers.get_mini_self_att_params_freeze_str_w_drop(args["decoder_args"].num_layers) + + mini_self_att = copy.deepcopy(args) + mini_self_att["batch_size"] = 20000 * 160 # TODO: does this fit now? + mini_self_att["with_pretrain"] = False + mini_self_att["lr"] = lr + mini_self_att["allow_lr_scheduling"] = False + mini_self_att["encoder_args"].with_ctc = False + # mini_self_att['keep_all_epochs'] = True # keep everything + mini_self_att["extra_str"] = params_freeze_str + mini_self_att["preload_from_files"] = { + "import": { + "init_for_train": True, + "ignore_missing": True, + "filename": checkpoint, + } + } + if "decoder_args" in kwargs: + assert isinstance(kwargs["decoder_args"], dict) + for k, v in kwargs["decoder_args"].items(): + setattr(mini_self_att["decoder_args"], k, v) + kwargs.pop("decoder_args") + mini_self_att.update(kwargs) + + exp_prefix = os.path.join(prefix_name, exp_name, name) + mini_self_att_train_data = build_training_datasets( + bpe_size=10000, + use_raw_features=True, + epoch_wise_filter=None, + link_speed_perturbation=False, # depends only on text + seq_ordering=kwargs.get("seq_ordering", "laplace:.1000"), + ) + + # use masked self-att instead of cross-att with layer names having "ilm_" as prefix + mini_self_att["decoder_args"].replace_cross_att_w_masked_self_att = True + + returnn_config = create_config( + training_datasets=mini_self_att_train_data, + **mini_self_att, + feature_extraction_net=log10_net_10ms, + ) + train_job = training( + exp_prefix, + returnn_config, + RETURNN_CPU_EXE, + RETURNN_ROOT, + num_epochs=num_epochs, + time_rqmt=time_rqmt, + ) + return train_job + + +# --------------------------- General Settings --------------------------- # + +conformer_enc_args = ConformerEncoderArgs( + num_blocks=12, + input_layer="conv-6", + att_num_heads=8, + ff_dim=2048, + enc_key_dim=512, + conv_kernel_size=32, + pos_enc="rel", + dropout=0.1, + att_dropout=0.1, + l2=0.0001, + use_sqrd_relu=True, + frontend_conv_l2=0.0001, +) +apply_fairseq_init_to_conformer(conformer_enc_args) +conformer_enc_args.ctc_loss_scale = 1.0 + +rnn_dec_args = RNNDecoderArgs() + +training_args = dict() +training_args["speed_pert"] = True +training_args["with_pretrain"] = False + +lstm_training_args = copy.deepcopy(training_args) +lstm_training_args["batch_size"] = 15000 * 160 # frames * samples per frame + +lstm_dec_exp_args = copy.deepcopy( + { + **lstm_training_args, + "encoder_args": conformer_enc_args, + "decoder_args": rnn_dec_args, + } +) + +# --------------------------- Experiments --------------------------- # + +# Global attention baseline: +# +# dev-clean 2.28 +# dev-other 5.63 +# test-clean 2.48 +# test-other 5.71 + +global_att_best_ckpt = "/work/asr4/zeineldeen/setups-data/librispeech/2022-11-28--conformer-att/models-backup/best_att_100/avg_ckpt/epoch.2029" +global_att_v2 = "/work/asr4/zeineldeen/setups-data/librispeech/2022-11-28--conformer-att/work/i6_core/returnn/training/AverageTFCheckpointsJob.BxqgICRSGkgb/output/model/epoch.570" + +# from Albert: +# with task=“train” and search_type=“end-of-chunk”, it would align on-the-fly +# with task=“eval”, add a hdf-dump-layer, and search_type=“end-of-chunk”, you can dump it +# with task=“train” and search_type default (None), it would train using a fixed alignment + +default_args = copy.deepcopy(lstm_dec_exp_args) +default_args["learning_rates_list"] = list(numpy.linspace(8e-4, 1e-5, 60)) +default_args["retrain_checkpoint"] = global_att_best_ckpt +default_args["chunk_size"] = 20 +default_args["chunk_step"] = 20 * 3 // 4 +default_args["search_type"] = "end-of-chunk" # align on-the-fly + + +def get_ctc_chunksyn_align_config( + dataset_name, + ctc_alignments, + chunk_step, + eoc_idx=0, + hash_full_python_code=False, + ignore_eoc_in_input=False, # workaround for broken CTC/RNA alignments which include EOS (=EOC) +): + from i6_experiments.common.setups.returnn import serialization + + config = ReturnnConfig( + { + "extern_data": { + "bpe_labels": { + "available_for_inference": False, + "dim": 10026, # from CTC so +1 for blank + "shape": (None,), + "sparse": True, + }, + }, + "eval_datasets": { + dataset_name: { + "class": "MetaDataset", + "data_map": {"bpe_labels": ("hdf_dataset", "data")}, + "datasets": { + "hdf_dataset": { + "class": "HDFDataset", + "files": [ctc_alignments], + }, + }, + "seq_order_control_dataset": "hdf_dataset", + }, + }, + "network": { + "chunked_align": { + "class": "eval", + "eval": tools_eval_funcs.get_chunked_align, + "out_type": tools_eval_funcs.get_chunked_align_out_type, + "from": "data:bpe_labels", + "eval_locals": {"chunk_step": chunk_step, "eoc_idx": eoc_idx}, + }, + "output": { + "class": "hdf_dump", + "from": "chunked_align", + "filename": f"alignments-{dataset_name}.hdf", + }, + }, + "batch_size": 5000, + } + ) + config.post_config["use_tensorflow"] = True + if ignore_eoc_in_input: + config.config["network"]["chunked_align"]["eval_locals"].setdefault("ignore_indices", []).append(eoc_idx) + return serialization.get_serializable_config(config, hash_full_python_code=hash_full_python_code) + + +def get_ctc_rna_based_chunk_alignments( + *, + base_model_train_args: Optional[dict] = None, + ctc_dump_exp_name: Optional[str] = None, + fixed_ctc_rna_align_without_eos: bool = True, + ignore_eoc_in_input: bool = False, + chunk_sizes: Optional[List[int]] = None, + chunk_step_factors: Optional[List[Union[int, float]]] = None, + model_ckpt: Optional[Union[str, Checkpoint]] = None, +): + """ + Get CTC/RNA based chunk alignments for train/dev datasets. + """ + # save time-sync -> chunk-sync converted alignments. + ctc_align_wo_speed_pert = { + "train": {}, + "dev": {}, + } + + if model_ckpt is None: + model_ckpt = global_att_best_ckpt + + if fixed_ctc_rna_align_without_eos: + assert not ignore_eoc_in_input # should not be needed then + + if not ctc_dump_exp_name: + ctc_dump_exp_name = "dump_ctc_alignment_wo_speedPert" + if fixed_ctc_rna_align_without_eos: + ctc_dump_exp_name += "_wo_eos" + have_custom_exp_name = False + else: + have_custom_exp_name = True + + for dataset in ["train", "dev"]: + args = copy.deepcopy(base_model_train_args or default_args) + args["dump_ctc_dataset"] = dataset + args["batch_size"] *= 2 + + # CTC alignment with blank. + j = run_forward( + prefix_name=prefix_name, + exp_name=ctc_dump_exp_name, + train_args=args, + model_ckpt=model_ckpt, + hdf_layers=[f"alignments-{dataset}.hdf"], + seq_postfix=None if fixed_ctc_rna_align_without_eos else 0, + ) + + # convert w.r.t different chunk sizes and chunk steps + if not chunk_sizes: + chunk_sizes = [1, 2, 5, 8] + list(range(10, 55, 5)) + [60, 70, 80, 100] + for chunk_size in chunk_sizes: + if not chunk_step_factors: + chunk_step_factors = [1 / 2, 3 / 4, 0.9, 1] # 1 = no overlap + for chunk_step_factor in chunk_step_factors: + chunk_step = max(1, int(chunk_size * chunk_step_factor)) + + if have_custom_exp_name: + ctc_chunk_sync_align_exp_name = f"{ctc_dump_exp_name}_chunk{chunk_size}-{chunk_step}" + else: + ctc_chunk_sync_align_exp_name = f"ctc_chunk_sync_align_wo_speedPert_{chunk_size}-{chunk_step}" + if fixed_ctc_rna_align_without_eos: + ctc_chunk_sync_align_exp_name += "_wo_eos" + + ctc_chunk_sync_align = run_forward( + prefix_name=prefix_name, + exp_name=ctc_chunk_sync_align_exp_name, + train_args=args, + model_ckpt=model_ckpt, + hdf_layers=[f"alignments-{dataset}.hdf"], + override_returnn_config=get_ctc_chunksyn_align_config( + dataset, + ctc_alignments=j[f"alignments-{dataset}.hdf"], + chunk_step=chunk_step, + ignore_eoc_in_input=ignore_eoc_in_input, + ), + device="cpu", + time_rqmt=1.0, + cpu_type="cpu_short", + ) + + ctc_align_wo_speed_pert[dataset][f"{chunk_size}_{chunk_step}"] = ctc_chunk_sync_align[ + f"alignments-{dataset}.hdf" + ] + + return ctc_align_wo_speed_pert + + +def run_chunkwise_train( + total_epochs: List[int], + chunk_sizes: List[Optional[int]], + chunk_step_factors: List[Optional[float]], + enc_stream_type: str = "global", + suffix: str = "", + enable_check_align: bool = True, + on_the_fly_align: bool = False, + with_ctc: bool = False, + ctc_self_align_delay: int = None, + ctc_self_align_delay_scale: float = 0.5, + batch_size: int = 15_000, + accum_grad: int = 2, + time_rqmt: float = 72, + start_lrs: Union[float, List[Optional[float]]] = 1e-4, + decay_pt_factors: Union[float, List[Optional[float]]] = 1 / 3, + min_lr: float = 1e-6, + window_left_padding: Optional[int] = None, + end_slice_size: Optional[int] = None, + end_slice_start: Optional[int] = None, + pos_enc: Optional[str] = "rel", + conf_mem_opts: Optional[dict] = None, + full_sum_approx: bool = False, + retrain_ckpt: Optional[Union[tk.Path, str]] = None, + chunked_decoder: bool = True, + epoch_oclr_lr: Optional[float] = None, + decoder_mask_eoc: Optional[bool] = None, + speed_pert: bool = False, + from_scratch_train: bool = False, + lrs_list: Optional[List[float]] = None, + lr_list_desc: Optional[str] = None, + return_args: bool = False, + **kwargs, +): + if isinstance(start_lrs, float): + start_lrs = [start_lrs] + if isinstance(decay_pt_factors, float): + decay_pt_factors = [decay_pt_factors] + + # train with ctc chunk-sync alignment + ctc_chunksync_align = get_ctc_rna_based_chunk_alignments( + fixed_ctc_rna_align_without_eos=True, + chunk_sizes=chunk_sizes, + chunk_step_factors=chunk_step_factors, + model_ckpt=retrain_ckpt, + ) + + for total_epoch in total_epochs: + for chunk_size in chunk_sizes: + for chunk_step_factor in chunk_step_factors: + for start_lr in start_lrs: + for decay_pt_factor in decay_pt_factors: + train_args = copy.deepcopy(default_args) + train_args["speed_pert"] = speed_pert # no speed pert + train_args["search_type"] = None # fixed alignment + + train_args["max_seq_length"] = None # no filtering! + + train_args["encoder_args"].with_ctc = with_ctc + if ctc_self_align_delay: + assert with_ctc, "need CTC for self-align" + train_args["encoder_args"].ctc_self_align_delay = ctc_self_align_delay + train_args["encoder_args"].ctc_self_align_scale = ctc_self_align_delay_scale + + if enc_stream_type == "causal" or enc_stream_type.startswith("causal-"): + if enc_stream_type == "causal": + train_args["encoder_args"].use_causal_layers = True # causal MHSA and conv + elif enc_stream_type == "causal-mhsa": + train_args["encoder_args"].use_causal_layers = True + train_args["encoder_args"].use_causal_conv = False # causal MHSA only + elif enc_stream_type == "causal-reset-conv": + train_args["encoder_args"].use_causal_layers = True + train_args["encoder_args"].conv_alternative_name = "depthwise_conv2_causal" + train_args.setdefault("retrain_checkpoint_opts", {}).setdefault( + "ignore_params_prefixes", [] + ).extend( + [ + "conformer_block_%02i_conv_mod_depthwise_conv2_causal/" % (i + 1) + for i in range(train_args["encoder_args"].num_blocks) + ] + ) + + train_args["batch_size"] = batch_size * 160 + train_args["accum_grad"] = accum_grad + + train_args["enable_check_align"] = enable_check_align # to not break hashes + + train_args["chunk_size"] = chunk_size + if chunk_size is None: + train_args["chunk_step"] = None + chunk_step = None + else: + chunk_step = max(1, int(chunk_size * chunk_step_factor)) + train_args["chunk_step"] = chunk_step + + if lrs_list is not None: + train_args["learning_rates_list"] = lrs_list + elif epoch_oclr_lr: + assert start_lr is None + cyc_ep = int(0.45 * total_epoch) + train_args["learning_rates_list"] = ( + list(numpy.linspace(epoch_oclr_lr / 10, epoch_oclr_lr, cyc_ep)) + + list(numpy.linspace(epoch_oclr_lr, epoch_oclr_lr / 10, cyc_ep)) + + list(numpy.linspace(epoch_oclr_lr / 10, 1e-6, total_epoch - 2 * cyc_ep)) + ) + else: + decay_pt = int(total_epoch * decay_pt_factor) + train_args["learning_rates_list"] = [start_lr] * decay_pt + list( + numpy.linspace(start_lr, min_lr, total_epoch - decay_pt) + ) + + chunk_level = "input" if enc_stream_type == "chunked" else "encoder" + train_args["chunk_level"] = chunk_level + train_args["eoc_idx"] = 0 + + exp_name = f"{enc_stream_type}_att_chunk" + if chunk_size is not None: + assert chunk_step is not None + exp_name += f"-{chunk_size}_step-{chunk_step}" + else: + exp_name += "-globalAtt" # no chunking + + if start_lr: + exp_name += f"_linDecay{total_epoch}_{start_lr}_decayPt{decay_pt_factor}" + if min_lr != 1e-6: + exp_name += f"_minLR{min_lr}" + elif epoch_oclr_lr: + exp_name += f"_epochOCLR-{epoch_oclr_lr}_ep{total_epoch}" + elif lrs_list: + assert lr_list_desc + exp_name += f"_{lr_list_desc}" + + exp_name += f"_bs{batch_size}_accum{accum_grad}" + + if window_left_padding is not None: + train_args["window_left_padding"] = window_left_padding + exp_name += f"_winLeft{window_left_padding}" + + if end_slice_size is not None: + train_args["end_slice_size"] = end_slice_size + assert end_slice_start is not None, "need end_slice_start" + train_args["end_slice_start"] = end_slice_start + exp_name += f"_endSliceStart{end_slice_start}_endSlice{end_slice_size}" + + if pos_enc is None: + train_args["encoder_args"].pos_enc = pos_enc + exp_name += f"_woPosEnc" + else: + assert pos_enc == "rel" + + if conf_mem_opts is not None: + train_args["conf_mem_opts"] = conf_mem_opts + exp_name += f"_memVariant{conf_mem_opts['self_att_version']}" + mem_size = conf_mem_opts.get("mem_size", 1) + if mem_size > 1: + exp_name += f"_memSize{mem_size}" + if conf_mem_opts.get("mask_paddings", False): + exp_name += f"_memMaskPad" + if conf_mem_opts.get("conv_cache_size", None): + exp_name += f"_convCache{conf_mem_opts['conv_cache_size']}" + if conf_mem_opts.get("use_cached_prev_kv", False): + exp_name += f"_useCachedKV" + if conf_mem_opts.get("mem_slice_start", None) is not None: + assert conf_mem_opts.get("mem_slice_size", None) is not None + exp_name += ( + f"_memSlice{conf_mem_opts['mem_slice_start']}-{conf_mem_opts['mem_slice_size']}" + ) + train_args["recursion_limit"] = 4000 + + if with_ctc: + exp_name += "_withCtc" + + if full_sum_approx: + # NOTE: no need to mask EOC for the decoder since the targets do not contain EOC (just bpe labels) + train_args["decoder_args"].prev_target_embed_direct = True + train_args["decoder_args"].full_sum_simple_approx = True + exp_name += "_fullSumApprox" + + if decoder_mask_eoc: + train_args["decoder_args"].masked_computation_blank_idx = train_args["eoc_idx"] + exp_name += "_maskEOC" + + if retrain_ckpt: + assert suffix, "set suffix for retrain to avoid overwriting" + train_args["retrain_checkpoint"] = retrain_ckpt + + train_args["chunked_decoder"] = chunked_decoder + if not chunked_decoder: + exp_name += "_noChunkedDec" + + if from_scratch_train: + train_args.update(get_base_v1_args(train_args, lr=epoch_oclr_lr, ep=total_epoch)) + train_args["with_pretrain"] = True + train_args["retrain_checkpoint"] = None + exp_name += "_fromScratch" + + if kwargs.get("rel_pos_clipping", None): + train_args["encoder_args"].rel_pos_clipping = kwargs["rel_pos_clipping"] + exp_name += f"_relPosClip{kwargs['rel_pos_clipping']}" + + if kwargs.get("freeze_bn", False): + train_args["freeze_bn"] = True + exp_name += "_freezeBN" + + if kwargs.get("remove_att_ctx_from_dec_state", False): + train_args["remove_att_ctx_from_dec_state"] = True + exp_name += "_woDecAtt" + + if suffix: + exp_name += suffix + + # override + if with_ctc: + search_score_key = "dev_score_output/output_prob" + else: + search_score_key = "dev_score" + + if chunk_size is None or chunked_decoder is False or from_scratch_train: + run_exp( + prefix_name=prefix_name, + exp_name=exp_name, + train_args=train_args, + num_epochs=total_epoch, + epoch_wise_filter=None, + time_rqmt=time_rqmt, + key=search_score_key, + use_sclite=True, + speed_pert=speed_pert, + **kwargs, + ) + elif on_the_fly_align: + train_args["search_type"] = "end-of-chunk" # on-the-fly alignment + run_exp( + prefix_name=prefix_name, + exp_name=exp_name, + train_args=train_args, + num_epochs=total_epoch, + epoch_wise_filter=None, + time_rqmt=time_rqmt, + key=search_score_key, + use_sclite=True, + **kwargs, + ) + else: + if full_sum_approx: + # just use original targets without EOC + train_fixed_alignment = None + cv_fixed_alignment = None + else: + assert ctc_chunksync_align, "Need CTC chunk-sync alignments" + train_fixed_alignment = ctc_chunksync_align["train"][f"{chunk_size}_{chunk_step}"] + cv_fixed_alignment = ctc_chunksync_align["dev"][f"{chunk_size}_{chunk_step}"] + _, train_data = run_exp( + prefix_name=prefix_name, + exp_name=exp_name, + train_args=train_args, + num_epochs=total_epoch, + train_fixed_alignment=train_fixed_alignment, + cv_fixed_alignment=cv_fixed_alignment, + epoch_wise_filter=None, + time_rqmt=time_rqmt, + key=search_score_key, + use_sclite=True, + seq_postfix=None if full_sum_approx else 0, + **kwargs, + ) + + if return_args: + assert len(total_epochs) == 1 + assert len(chunk_sizes) == 1 + assert len(chunk_step_factors) == 1 + assert len(start_lrs) == 1 + assert len(decay_pt_factors) == 1 + + return train_args, exp_name, train_data, train_fixed_alignment, cv_fixed_alignment + + +def _run_exp_full_sum_simple_approx( + *, + enc_stream_type: Optional[str], + chunk_size: int, + chunk_step_factor: float, + total_epochs: int, + with_ctc: bool = False, +): + start_lr = 1e-4 + decay_pt_factor = 1 / 3 + train_args = copy.deepcopy(default_args) + + train_args["speed_pert"] = False # no speed pert + train_args["search_type"] = None + train_args["max_seq_length"] = None # no filtering! + + train_args["encoder_args"].with_ctc = with_ctc + + if enc_stream_type == "causal" or enc_stream_type.startswith("causal-"): + train_args["encoder_args"].use_causal_layers = True + if enc_stream_type == "causal-reset-conv": + train_args["encoder_args"].conv_alternative_name = "depthwise_conv2_causal" + train_args.setdefault("retrain_checkpoint_opts", {}).setdefault("ignore_params_prefixes", []).extend( + [ + "conformer_block_%02i_conv_mod_depthwise_conv2_causal/" % (i + 1) + for i in range(train_args["encoder_args"].num_blocks) + ] + ) + + decay_pt = int(total_epochs * decay_pt_factor) + + train_args["chunk_size"] = chunk_size + + chunk_step = max(1, int(chunk_size * chunk_step_factor)) + train_args["chunk_step"] = chunk_step + + chunk_level = "input" if enc_stream_type == "chunked" else "encoder" + train_args["chunk_level"] = chunk_level + train_args["eoc_idx"] = 0 + train_args["decoder_args"].prev_target_embed_direct = True + train_args["decoder_args"].full_sum_simple_approx = True + + if chunk_level == "input": + # It needs more memory because there are mini batches + # where the chunk size is larger than the sequences, + # thus increasing the overall memory consumption of the whole encoder. + train_args["batch_size"] = int(train_args["batch_size"] * 0.75) + train_args["accum_grad"] = int(train_args.get("accum_grad", 2) * 1.5) + + train_args["learning_rates_list"] = [start_lr] * decay_pt + list( + numpy.linspace(start_lr, 1e-6, total_epochs - decay_pt) + ) + + train_args["enable_check_align"] = False + + train_args["batch_size"] = int(0.75 * train_args["batch_size"]) + train_args["accum_grad"] = int(1.5 * train_args.get("accum_grad", 2)) + + exp_name_parts = [ + "chunk_att_simpleFS", + f"enc-{enc_stream_type}-conf", + f"chunksize-{chunk_size}", + f"chunkstep-{chunk_step}", + f"linDecay{total_epochs}_{start_lr}_decayPt{decay_pt_factor}", + f"ctc{with_ctc}", + ] + + run_exp( + prefix_name=prefix_name, + exp_name="_".join(exp_name_parts), + train_args=train_args, + num_epochs=total_epochs, + epoch_wise_filter=None, + time_rqmt=72, + selected_datasets=["dev-other"], + key="dev_score_output/output_prob" if with_ctc else "dev_score", + use_sclite=True, + ) + + +def py(): + for mask_eoc in [True, False]: + run_chunkwise_train( + enc_stream_type="global", + run_all_for_best_last_avg=True, + enable_check_align=False, + chunk_sizes=[1, 5, 10, 25], + chunk_step_factors=[1], + start_lrs=[2e-4], + decay_pt_factors=[0.25, 1 / 3], + gpu_mem=11, + total_epochs=[10 * 20, 20 * 20], + batch_size=15_000, + accum_grad=2, + time_rqmt=120, + decoder_mask_eoc=mask_eoc, + ) + + # global_att_chunk-1_step-1_linDecay200_0.0002_decayPt0.25_bs15000_accum2 + # 2.37 5.8 2.51 6.03 200 + for mask_eoc in [True, False]: + run_chunkwise_train( + enc_stream_type="global", + run_all_for_best_last_avg=True, + enable_check_align=False, + chunk_sizes=[1, 5, 10, 25], + chunk_step_factors=[1], + start_lrs=[2e-4], + decay_pt_factors=[0.25], + gpu_mem=11, + total_epochs=[20 * 20], + batch_size=15_000, + accum_grad=2, + time_rqmt=120, + decoder_mask_eoc=mask_eoc, + remove_att_ctx_from_dec_state=True + ) + + # TODO: with prev:att, just as-is, no change (done above) + + # TODO: change it to h_t, with att out linear transformation (should then be same kind of embedding, also same dim) + + # TODO: h_t without linear trafo (might be different dim) + + # TODO: no h_t at all (also different dim) + # run_chunkwise_train( + # enc_stream_type="global", + # run_all_for_best_last_avg=True, + # enable_check_align=False, + # chunk_sizes=[1, 20], + # chunk_step_factors=[1], + # start_lrs=[2e-4], + # decay_pt_factors=[0.25], + # gpu_mem=24, + # total_epochs=[300, 400], + # batch_size=30_000, + # accum_grad=1, + # time_rqmt=120, + # decoder_mask_eoc=True, + # remove_att_ctx_from_dec_state=True, + # returnn_root=RETURNN_ROOT_V2, + # ) diff --git a/users/zeineldeen/experiments/chunkwise_att_2023/tedlium2/configs/ted2_chunked_aed_variants.py b/users/zeineldeen/experiments/chunkwise_att_2023/tedlium2/configs/ted2_chunked_aed_variants.py index 91a1ba87b..df2209c86 100644 --- a/users/zeineldeen/experiments/chunkwise_att_2023/tedlium2/configs/ted2_chunked_aed_variants.py +++ b/users/zeineldeen/experiments/chunkwise_att_2023/tedlium2/configs/ted2_chunked_aed_variants.py @@ -1710,16 +1710,33 @@ def py(): decoder_mask_eoc=decoder_mask_eoc, ) - # TODO: mask out EOC symbol + ctx from decoder state + for decoder_mask_eoc in [True, False]: + run_chunkwise_train( + enc_stream_type="global", + run_all_for_best_last_avg=True, + enable_check_align=False, + chunk_sizes=[1, 5, 10, 25], + chunk_step_factors=[1], + start_lrs=[2e-4], + decay_pt_factors=[0.25], + final_lrs=[1e-6], + gpu_mem=11, + total_epochs=[20 * 4, 30 * 4, 40 * 4], + batch_size=15_000, + accum_grad=2, + time_rqmt=120, + decoder_mask_eoc=decoder_mask_eoc, + ) + # TODO: mask out EOC symbol + ctx from decoder state run_chunkwise_train( enc_stream_type="global", run_all_for_best_last_avg=True, enable_check_align=False, - chunk_sizes=[5, 25], + chunk_sizes=[1, 5, 10, 25], chunk_step_factors=[1], start_lrs=[2e-4], - decay_pt_factors=[0.25], + decay_pt_factors=[0.25, 1 / 3], final_lrs=[1e-6], gpu_mem=11, total_epochs=[20 * 4, 40 * 4], @@ -1730,33 +1747,21 @@ def py(): remove_att_ctx_from_dec_state=True, ) - # TODO: large chunks + overlap - # for left_context, center_context, right_context, conv_size, mem_size in [ - # (0, 80, 0, 0, 0), - # ]: - # run_chunkwise_train( - # enc_stream_type="chunked", - # run_all_for_best_last_avg=True, - # enable_check_align=False, - # chunk_sizes=[25], - # chunk_step_factors=[20 / 25], - # start_lrs=[2e-4], - # decay_pt_factors=[1 / 3], - # gpu_mem=24, - # total_epochs=[120], - # batch_size=15_000, - # accum_grad=2, - # time_rqmt=120, - # end_slice_start=left_context, - # end_slice_size=center_context, - # window_left_padding=left_context * 6, - # # conf_mem_opts={ - # # "self_att_version": 1, - # # "mem_size": mem_size, - # # "use_cached_prev_kv": True, - # # "conv_cache_size": conv_size, - # # "mem_slice_start": left_context, - # # "mem_slice_size": 20, - # # }, - # suffix=f"_L{left_context}_C{center_context}_R{right_context}", - # ) + # # TODO: use overlap + # run_chunkwise_train( + # enc_stream_type="global", + # run_all_for_best_last_avg=True, + # enable_check_align=False, + # chunk_sizes=[5, 10, 25], + # chunk_step_factors=[0.5, 0.75], # 50%, 25% overlaps + # start_lrs=[2e-4], + # decay_pt_factors=[0.25, 1 / 3], + # final_lrs=[1e-6], + # gpu_mem=11, + # total_epochs=[20 * 4, 40 * 4], + # batch_size=15_000, + # accum_grad=2, + # time_rqmt=120, + # decoder_mask_eoc=True, + # remove_att_ctx_from_dec_state=True, + # ) From 170f7762a118b91ccb405a79b3d6ffe3f8091382 Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Thu, 6 Jun 2024 10:36:49 +0000 Subject: [PATCH 105/227] add more weight drop to rnn decoder --- .../models/asr/decoder/rnn_decoder.py | 18 ++++++++++++++++-- 1 file changed, 16 insertions(+), 2 deletions(-) diff --git a/users/zeineldeen/models/asr/decoder/rnn_decoder.py b/users/zeineldeen/models/asr/decoder/rnn_decoder.py index b292d2ed8..586a1cdc0 100644 --- a/users/zeineldeen/models/asr/decoder/rnn_decoder.py +++ b/users/zeineldeen/models/asr/decoder/rnn_decoder.py @@ -408,14 +408,28 @@ def create_network(self): ) else: self.base_model.network.add_linear_layer( - "enc_ctx", "encoder", with_bias=True, n_out=self.enc_key_dim, l2=self.base_model.l2 + "enc_ctx", + "encoder", + with_bias=True, + n_out=self.enc_key_dim, + l2=self.base_model.l2, + param_dropout=self.ff_weight_drop, + param_dropout_min_ndim=2, + param_variational_noise=self.ff_weight_noise, ) self.base_model.network.add_split_dim_layer( "enc_value", "encoder", dims=(self.att_num_heads, self.enc_value_dim // self.att_num_heads) ) self.base_model.network.add_linear_layer( - "inv_fertility", "encoder", activation="sigmoid", n_out=self.att_num_heads, with_bias=False + "inv_fertility", + "encoder", + activation="sigmoid", + n_out=self.att_num_heads, + with_bias=False, + param_dropout=self.ff_weight_drop, + param_dropout_min_ndim=2, + param_variational_noise=self.ff_weight_noise, ) decision_layer_name = self.base_model.network.add_decide_layer("decision", self.dec_output, target=self.target) From 734dd697c5a5b1810f1ff07615b15ac31ea8a672 Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Thu, 6 Jun 2024 10:38:48 +0000 Subject: [PATCH 106/227] add chunked rnn decoder --- .../chunkwise_attention_asr_config.py | 2 +- .../models/asr/decoder/chunked_rnn_decoder.py | 1046 +++++++++++++++++ 2 files changed, 1047 insertions(+), 1 deletion(-) create mode 100644 users/zeineldeen/models/asr/decoder/chunked_rnn_decoder.py diff --git a/users/zeineldeen/experiments/chunkwise_att_2023/librispeech_960/chunkwise_attention_asr_config.py b/users/zeineldeen/experiments/chunkwise_att_2023/librispeech_960/chunkwise_attention_asr_config.py index 81cb1b1f7..b611a8f8d 100644 --- a/users/zeineldeen/experiments/chunkwise_att_2023/librispeech_960/chunkwise_attention_asr_config.py +++ b/users/zeineldeen/experiments/chunkwise_att_2023/librispeech_960/chunkwise_attention_asr_config.py @@ -23,7 +23,7 @@ ExternalLMDecoder, ) -from i6_experiments.users.zeyer.experiments.exp2023_02_16_chunked_attention.model import ( +from i6_experiments.users.zeineldeen.models.asr.decoder.chunked_rnn_decoder import ( RNNDecoder as ChunkwiseRNNDecoder, _check_alignment, ) diff --git a/users/zeineldeen/models/asr/decoder/chunked_rnn_decoder.py b/users/zeineldeen/models/asr/decoder/chunked_rnn_decoder.py new file mode 100644 index 000000000..d93edffa4 --- /dev/null +++ b/users/zeineldeen/models/asr/decoder/chunked_rnn_decoder.py @@ -0,0 +1,1046 @@ +""" +Model, based on Mohammads code. +""" + + +from __future__ import annotations +from typing import Optional, Callable +import tensorflow as tf + +from returnn.util.basic import NotSpecified +from returnn.tf.util.data import Data, Dim, SpatialDim, FeatureDim, single_step_dim +from returnn.tf.layers.basic import LayerBase + +from i6_experiments.users.zeineldeen.modules.network import ReturnnNetwork +from i6_experiments.users.zeineldeen.modules.abs_module import AbsModule +from i6_experiments.users.zeineldeen.modules.attention import AdditiveLocAwareness + + +class AttentionMechanism(AbsModule): + """ + Single-head or Multi-head attention mechanism + """ + + def __init__( + self, + enc_key_dim, + att_num_heads, + att_dropout, + l2, + loc_filter_size, + loc_num_channels, + use_weight_feedback, + weight_drop, + weight_noise, + ): + super().__init__() + self.enc_key_dim = enc_key_dim + assert isinstance(att_num_heads, Dim) + self.att_num_heads = att_num_heads + + self.att_dropout = att_dropout + self.l2 = l2 + + self.loc_filter_size = loc_filter_size + self.loc_num_channels = loc_num_channels + + self.select_base_enc: Optional[Callable[[str], str]] = None + self.enc_time_dim = None + + self.use_weight_feedback = use_weight_feedback + + self.weight_drop = weight_drop + self.weight_noise = weight_noise + + def create(self): + out_net = ReturnnNetwork() + + out_net.add_linear_layer( + "s_transformed", + "s", + n_out=self.enc_key_dim, + with_bias=False, + l2=self.l2, + param_dropout=self.weight_drop, + param_dropout_min_ndim=2, + param_variational_noise=self.weight_noise, + ) # project query + + if self.use_weight_feedback: + weight_feedback = AdditiveLocAwareness( + enc_key_dim=self.enc_key_dim, + att_num_heads=self.att_num_heads.dimension, + weight_drop=self.weight_drop, + weight_noise=self.weight_noise, + ) + out_net.update(weight_feedback.create()) # add weight feedback to network + else: + weight_feedback = None + + enc_ctx = "base:enc_ctx" + if self.select_base_enc: + enc_ctx = self.select_base_enc(enc_ctx) + out_net.add_combine_layer( + "energy_in", + [enc_ctx, "s_transformed"] if not weight_feedback else [enc_ctx, weight_feedback.name, "s_transformed"], + kind="add", + n_out=self.enc_key_dim, + ) + + # compute energies + out_net.add_activation_layer("energy_tanh", "energy_in", activation="tanh") + energy = out_net.add_linear_layer( + "energy", + "energy_tanh", + n_out=self.att_num_heads.dimension, + out_dim=self.att_num_heads, + with_bias=False, + l2=self.l2, + param_dropout=self.weight_drop, + param_dropout_min_ndim=2, + param_variational_noise=self.weight_noise, + ) + + att_sm_opts = {} + if self.enc_time_dim: + att_sm_opts["axis"] = self.enc_time_dim + if self.att_dropout: + att_weights0 = out_net.add_softmax_over_spatial_layer("att_weights0", energy, **att_sm_opts) + att_weights = out_net.add_dropout_layer( + "att_weights", + att_weights0, + dropout=self.att_dropout, + dropout_noise_shape={"*": None}, + ) + else: + att_weights = out_net.add_softmax_over_spatial_layer("att_weights", energy, **att_sm_opts) + + enc_value = "base:enc_value" + if self.select_base_enc: + enc_value = self.select_base_enc(enc_value) + if self.enc_time_dim: + att0 = out_net.add_dot_layer( + "att0", + [att_weights, enc_value], + reduce=self.enc_time_dim, + var1="auto", + var2="auto", + ) + else: + att0 = out_net.add_generic_att_layer("att0", weights=att_weights, base=enc_value) + self.name = out_net.add_merge_dims_layer("att", att0, axes="static") + + return out_net.get_net() + + +class RNNDecoder: + """ + Represents RNN LSTM Attention-based decoder + + Related: + * Single headed attention based sequence-to-sequence model for state-of-the-art results on Switchboard + ref: https://arxiv.org/abs/2001.07263 + """ + + def __init__( + self, + base_model, + source=None, + dropout=0.0, + softmax_dropout=0.3, + label_smoothing=0.1, + target="bpe", + beam_size=12, + embed_dim=621, + embed_dropout=0.0, + lstm_num_units=1024, + output_num_units=1024, + enc_key_dim=1024, + l2=None, + att_dropout=None, + rec_weight_dropout=None, + zoneout=False, + ff_init=None, + add_lstm_lm=False, + lstm_lm_dim=1024, + loc_conv_att_filter_size=None, + loc_conv_att_num_channels=None, + reduceout=True, + att_num_heads=1, + embed_weight_init=None, + lstm_weights_init=None, + lstm_lm_proj_dim=1024, + length_normalization=True, + coverage_threshold=None, + coverage_scale=None, + enc_chunks_dim: Optional[Dim] = None, + enc_time_dim: Optional[Dim] = None, + eos_id=0, + search_type: Optional[str] = None, + enable_check_align=True, + masked_computation_blank_idx: Optional[int] = None, + full_sum_simple_approx: bool = False, + prev_target_embed_direct: bool = False, + use_zoneout_output: bool = False, + ff_weight_dropout=None, + ff_weight_noise=None, + ): + """ + :param base_model: base/encoder model instance + :param str|None source: input to decoder subnetwork + :param float softmax_dropout: Dropout applied to the softmax input + :param float label_smoothing: label smoothing value applied to softmax + :param str target: target data key name + :param int beam_size: value of the beam size + :param int embed_dim: target embedding dimension + :param float|None embed_dropout: dropout to be applied on the target embedding + :param int lstm_num_units: the number of hidden units for the decoder LSTM + :param int output_num_units: the number of hidden dimensions for the last layer before softmax + :param int enc_key_dim: the number of hidden dimensions for the encoder key + :param float|None l2: weight decay with l2 norm + :param float|None att_dropout: dropout applied to attention weights + :param float|None rec_weight_dropout: dropout applied to weight paramters + :param bool zoneout: if set, zoneout LSTM cell is used in the decoder instead of nativelstm2 + :param str|None ff_init: feed-forward weights initialization + :param bool add_lstm_lm: add separate LSTM layer that acts as LM-like model + same as here: https://arxiv.org/abs/2001.07263 + :param float lstm_lm_dim: + :param int|None loc_conv_att_filter_size: + :param int|None loc_conv_att_num_channels: + :param bool reduceout: if set to True, maxout layer is used + :param int att_num_heads: number of attention heads + :param enc_chunks_dim: + :param enc_time_dim: + :param int eos_id: end of sentence id. or end-of-chunk if chunking is used + :param search_type: + None -> use RETURNN default handling via search flag (i.e. disabled in training, enabled in search mode). + "end-of-chunk" -> assume given targets without EOC, and search for EOC. + :param enable_check_align: if set, the targets are checked whether M + U = T + :param masked_computation_blank_idx: if set, it uses masked computation for the LSTM/prev:target, + and the mask is for all non-blank indices + :param full_sum_simple_approx: if enabled, it creates a 4D tensor [B, M, U+1, V] via a simple approximation + by only attending to one fixed chunk in M for the whole sequence U+1, and then it uses the RNN-T loss. + The decoder gets only the non-blank labels as input in this case, including BOS (U+1). + This makes only sense in training. Then in recog, you do align-sync search, + and you should set masked_computation_blank_idx to get consistent behavior, + i.e. that blank labels are not used. + :param prev_target_embed_direct: if False, uses "prev:target_embed", + otherwise "prev_target_embed" uses "prev:output". should be like "apply(0)" as initial_output. + """ + + self.base_model = base_model + + self.source = source + + self.dropout = dropout + self.softmax_dropout = softmax_dropout + self.label_smoothing = label_smoothing + + self.enc_key_dim = enc_key_dim + self.enc_value_dim = base_model.enc_value_dim + if isinstance(att_num_heads, int): + att_num_heads = SpatialDim("dec-att-num-heads", att_num_heads) + assert isinstance(att_num_heads, Dim) + self.att_num_heads = att_num_heads + + self.target = target + + self.beam_size = beam_size + + self.embed_dim = embed_dim + self.embed_dropout = embed_dropout + + self.dec_lstm_num_units = lstm_num_units + self.dec_output_num_units = output_num_units + + self.ff_init = ff_init + + self.decision_layer_name = None # this is set in the end-point config + + self.l2 = l2 + self.att_dropout = att_dropout + self.rec_weight_dropout = rec_weight_dropout + self.dec_zoneout = zoneout + + self.ff_weight_drop = ff_weight_dropout + self.ff_weight_noise = ff_weight_noise + + self.add_lstm_lm = add_lstm_lm + self.lstm_lm_dim = lstm_lm_dim + self.lstm_lm_proj_dim = lstm_lm_proj_dim + + self.loc_conv_att_filter_size = loc_conv_att_filter_size + self.loc_conv_att_num_channels = loc_conv_att_num_channels + + self.embed_weight_init = embed_weight_init + self.lstm_weights_init = lstm_weights_init + + self.reduceout = reduceout + + self.length_normalization = length_normalization + self.coverage_threshold = coverage_threshold + self.coverage_scale = coverage_scale + + self.enc_chunks_dim = enc_chunks_dim + self.enc_time_dim = enc_time_dim + self.eos_id = eos_id + self.search_type = search_type + + self.network = ReturnnNetwork() + self.subnet_unit = ReturnnNetwork() + self.dec_output = None + self.output_prob = None + + self.enable_check_align = enable_check_align + self.masked_computation_blank_idx = masked_computation_blank_idx + self.full_sum_simple_approx = full_sum_simple_approx + if full_sum_simple_approx: + assert enc_chunks_dim is not None, "full_sum_simple_approx requires enc_chunks_dim" + self.prev_target_embed_direct = prev_target_embed_direct + + self.use_zoneout_output = use_zoneout_output + + def add_decoder_subnetwork( + self, + subnet_unit: ReturnnNetwork, + target: str = NotSpecified, + search_type: Optional[str] = NotSpecified, + rec_layer_name: Optional[str] = None, + rec_layer_opts: Optional[dict] = None, + ): + if target is NotSpecified: + target = self.target + if search_type is NotSpecified: + search_type = self.search_type + if rec_layer_opts is None: + rec_layer_opts = {} + if not rec_layer_name: + if search_type == "end-of-chunk": + rec_layer_name = "output_align" + rec_layer_opts.setdefault("name_scope", "output/rec") + else: + rec_layer_name = "output" + + if self.full_sum_simple_approx: + pass + elif self.enc_chunks_dim: # use chunking + subnet_unit["new_label_pos"] = { + "class": "eval", + "from": ["output", "prev:new_label_pos"], + "eval": f"tf.where(tf.equal(source(0), {self.eos_id}), source(1), source(1) + 1)", + "out_type": { + "dtype": "int32", + "dim": None, + "sparse_dim": self.enc_chunks_dim, + }, + "initial_output": 0, + } + + subnet_unit["label_pos"] = {"class": "copy", "from": "prev:new_label_pos"} + + subnet_unit["label_pos_reached_end"] = { + "class": "compare", + "from": ["label_pos", "ground_truth_label_seq_len"], + "kind": "greater_equal", + } + + subnet_unit["chunk_idx_reached_last"] = { + "class": "compare", + "from": ["chunk_idx", "last_chunk_idx"], + "kind": "equal", + } + + subnet_unit["chunk_idx_can_be_finished"] = { + "class": "eval", + "from": ["chunk_idx_reached_last", "label_pos_reached_end"], + "eval": "tf.logical_or(tf.logical_and(source(0), source(1)), tf.logical_not(source(0)))", + } + + subnet_unit["ground_truth_label"] = { + "class": "gather", + "from": f"base:data:{target}", + "axis": "T", + "position": "label_pos", + "clip_to_valid": True, + } + + subnet_unit["ground_truth_label_seq_len"] = { + "class": "length", + "from": f"base:data:{target}", + "axis": "T", + } + + subnet_unit["ground_truth_last_label_pos"] = { + "class": "eval", + "from": "ground_truth_label_seq_len", + "eval": "source(0) - 1", + } + + subnet_unit["new_chunk_idx"] = { + "class": "eval", + "from": ["output", "prev:new_chunk_idx"], + "eval": f"tf.where(tf.equal(source(0), {self.eos_id}), source(1) + 1, source(1))", + "out_type": { + "dtype": "int32", + "dim": None, + "sparse_dim": self.enc_chunks_dim, + }, + "initial_output": 0, + } + + subnet_unit["chunk_idx"] = {"class": "copy", "from": "prev:new_chunk_idx"} + + subnet_unit["num_chunks"] = { + "class": "length", + "from": "base:encoder", + "axis": self.enc_chunks_dim, + } + + subnet_unit["last_chunk_idx"] = { + "class": "eval", + "from": "num_chunks", + "eval": "source(0) - 1", + } + + subnet_unit["end"] = { + "class": "compare", + "from": ["new_chunk_idx", "num_chunks"], + "kind": "greater_equal", + } + + else: # no chunking + subnet_unit.add_compare_layer("end", source="output", value=self.eos_id) # sentence end token + + if self.masked_computation_blank_idx is not None: + subnet_unit["masked_comp_mask"] = { + "class": "compare", + "from": "output", + "kind": "not_equal", + "value": self.masked_computation_blank_idx, + "initial_output": True, + } + + prev_output = "prev:output" + if self.full_sum_simple_approx: + assert self.prev_target_embed_direct + assert not self.source + prev_output = "data:source" + + # target embedding + _name = subnet_unit.add_linear_layer( + "prev_target_embed0" if self.prev_target_embed_direct else "target_embed0", + prev_output if self.prev_target_embed_direct else "output", + n_out=self.embed_dim, + with_bias=False, + l2=self.l2, + forward_weights_init=self.embed_weight_init, + initial_output=self.eos_id, + param_dropout=self.ff_weight_drop, + param_dropout_min_ndim=2, + param_variational_noise=self.ff_weight_noise, + ) + if self.masked_computation_blank_idx is not None: + target_embed_layer_dict = subnet_unit[_name] + target_embed_layer_dict = { + "class": "masked_computation", + "unit": target_embed_layer_dict, + "mask": "prev:masked_comp_mask" if self.prev_target_embed_direct else "masked_comp_mask", + "initial_output": self.eos_id, + "from": target_embed_layer_dict["from"], + } + target_embed_layer_dict["unit"]["from"] = "data" + subnet_unit[_name] = target_embed_layer_dict + if self.prev_target_embed_direct: + subnet_unit[_name]["name_scope"] = "target_embed0" # params compatible + + subnet_unit.add_dropout_layer( + "prev_target_embed" if self.prev_target_embed_direct else "target_embed", + _name, + dropout=self.embed_dropout, + dropout_noise_shape={"*": None}, + ) + prev_target_embed = "prev_target_embed" if self.prev_target_embed_direct else "prev:target_embed" + + # attention + att = AttentionMechanism( + enc_key_dim=self.enc_key_dim, + att_num_heads=self.att_num_heads, + att_dropout=self.att_dropout, + l2=self.l2, + loc_filter_size=self.loc_conv_att_filter_size, + loc_num_channels=self.loc_conv_att_num_channels, + use_weight_feedback=not self.enc_chunks_dim, # TODO: allow when chunked + weight_drop=self.ff_weight_drop, + weight_noise=self.ff_weight_noise, + ) + if self.masked_computation_blank_idx is not None: + subnet_unit["prev_att_masked"] = { + "class": "masked_computation", + "mask": "prev:masked_comp_mask", + "unit": {"class": "copy", "from": "data"}, + "from": "prev:att", + } + + if self.enc_chunks_dim: + att.enc_time_dim = self.enc_time_dim + if self.full_sum_simple_approx: + pass + else: + + def _gather_chunk(source: str) -> str: + name = source.replace("base:", "") + subnet_unit[name + "_gather"] = { + "class": "gather", + "from": source, + "position": "chunk_idx", + "axis": self.enc_chunks_dim, + "clip_to_valid": True, + } + subnet_unit[name + "_set_time"] = { + "class": "reinterpret_data", + "from": name + "_gather", + "set_axes": {"T": self.enc_time_dim}, + } + return name + "_set_time" + + assert self.enc_time_dim + att.select_base_enc = _gather_chunk + subnet_unit.update(att.create()) + + # LM-like component same as here https://arxiv.org/pdf/2001.07263.pdf + lstm_lm_component_proj = None + if self.add_lstm_lm: + assert self.masked_computation_blank_idx is None # not implemented... + lstm_lm_component = subnet_unit.add_rec_layer( + "lm_like_s", + prev_target_embed, + n_out=self.lstm_lm_dim, + l2=self.l2, + unit="NativeLSTM2", + rec_weight_dropout=self.rec_weight_dropout, + weights_init=self.lstm_weights_init, + ) + lstm_lm_component_proj = subnet_unit.add_linear_layer( + "lm_like_s_proj", + lstm_lm_component, + n_out=self.lstm_lm_proj_dim, + l2=self.l2, + with_bias=False, + dropout=self.dropout, + param_dropout=self.ff_weight_drop, + param_dropout_min_ndim=2, + param_variational_noise=self.ff_weight_noise, + ) + + lstm_inputs = [] + if lstm_lm_component_proj: + lstm_inputs += [lstm_lm_component_proj] + else: + lstm_inputs += [prev_target_embed] + + if self.masked_computation_blank_idx is not None: + lstm_inputs += ["prev_att_masked"] + else: + lstm_inputs += ["prev:att"] + + if self.add_lstm_lm: + # element-wise addition is applied instead of concat + lstm_inputs = subnet_unit.add_combine_layer( + "add_embed_ctx", lstm_inputs, kind="add", n_out=self.lstm_lm_proj_dim + ) + + # LSTM decoder (or decoder state) + if self.dec_zoneout and not self.full_sum_simple_approx: + # It's bad to use rnn_cell here... Just annoying to keep this just to preserve hash... + zoneout_unit_opts = {"zoneout_factor_cell": 0.15, "zoneout_factor_output": 0.05} + if self.use_zoneout_output: + zoneout_unit_opts["use_zoneout_output"] = True + subnet_unit.add_rnn_cell_layer( + "s", + lstm_inputs, + n_out=self.dec_lstm_num_units, + l2=self.l2, + weights_init=self.lstm_weights_init, + unit="zoneoutlstm", + unit_opts=zoneout_unit_opts, + ) + else: + subnet_unit.add_rec_layer( + "s", + lstm_inputs, + n_out=self.dec_lstm_num_units, + l2=self.l2, + unit="zoneoutlstm" if self.dec_zoneout else "NativeLSTM2", + rec_weight_dropout=self.rec_weight_dropout, + weights_init=self.lstm_weights_init, + ) + if self.dec_zoneout: + subnet_unit["s"].setdefault("unit_opts", {}).update( + {"zoneout_factor_cell": 0.15, "zoneout_factor_output": 0.05} + ) + if self.full_sum_simple_approx: + subnet_unit["s"]["axis"] = single_step_dim + if self.masked_computation_blank_idx is not None: + subnet_unit["_s_input"] = {"class": "copy", "from": lstm_inputs} + layer_dict = subnet_unit["s"] + subnet_unit["s"] = { + "class": "masked_computation", + "unit": layer_dict, + "from": "_s_input", + "mask": "prev:masked_comp_mask", + } + layer_dict["from"] = "data" + + s_name = "s" + if self.add_lstm_lm: + s_name = subnet_unit.add_linear_layer( + "s_proj", + "s", + n_out=self.lstm_lm_proj_dim, + with_bias=False, + dropout=self.dropout, + l2=self.l2, + param_dropout=self.ff_weight_drop, + param_dropout_min_ndim=2, + param_variational_noise=self.ff_weight_noise, + ) + + readout_in_src = subnet_unit.add_combine_layer( + "add_s_att", [s_name, "att"], kind="add", n_out=self.lstm_lm_proj_dim + ) + else: + readout_in_src = [s_name, prev_target_embed, "att"] + + subnet_unit.add_linear_layer( + "readout_in", + readout_in_src, + n_out=self.dec_output_num_units, + l2=self.l2, + param_dropout=self.ff_weight_drop, + param_dropout_min_ndim=2, + param_variational_noise=self.ff_weight_noise, + ) + + if self.reduceout: + subnet_unit.add_reduceout_layer("readout", "readout_in") + else: + subnet_unit.add_copy_layer("readout", "readout_in") + + out_prob_opts = {} + if not search_type and not self.full_sum_simple_approx: + out_prob_opts.update( + dict( + loss="ce", + loss_opts={"label_smoothing": self.label_smoothing}, + ) + ) + + if self.full_sum_simple_approx: + # we only need the logits for full_sum training + self.output_logits = subnet_unit.add_linear_layer( + "output_logits", + "readout", + l2=self.l2, + target=f"layer:base:data:{target}", + dropout=self.softmax_dropout, + name_scope="output_prob", # for ckpt loading + param_dropout=self.ff_weight_drop, + param_dropout_min_ndim=2, + param_variational_noise=self.ff_weight_noise, + ) + # used for recognition + self.output_prob = subnet_unit.add_activation_layer( + "output_prob", + "output_logits", + activation="softmax", + ) + else: + self.output_prob = subnet_unit.add_softmax_layer( + "output_prob", + "readout", + l2=self.l2, + target=f"layer:base:data:{target}" + if (search_type == "end-of-chunk" or self.full_sum_simple_approx) + else target, + dropout=self.softmax_dropout, + **out_prob_opts, + param_dropout=self.ff_weight_drop, + param_dropout_min_ndim=2, + param_variational_noise=self.ff_weight_noise, + ) + + if self.full_sum_simple_approx: + assert self.enc_chunks_dim + subnet_unit["full_sum_simple_approx_loss"] = { + "class": "eval", + "from": ["output_logits", f"base:data:{target}"], + # Pickling/serialization of the func ref should work when this is a global function of this module. + # But depending on your setup, there might anyway not be any serialization. + "eval": _rnnt_full_sum_log_prob_eval_layer_func, + "eval_locals": { + "blank_index": self.eos_id, + "input_spatial_dim": self.enc_chunks_dim, + }, + "out_type": _rnnt_full_sum_log_prob_eval_layer_out, + "loss": "as_is", + } + + if search_type == "end-of-chunk": + subnet_unit["_label_indices"] = { + "class": "range_in_axis", + "from": f"base:data:{target}", + "axis": "sparse_dim", + } + subnet_unit["_label_indices_eq_eoc"] = { + "class": "compare", + "from": "_label_indices", + "value": self.eos_id, + "kind": "equal", + } + subnet_unit["_label_indices_eq_eoc_"] = { + "class": "switch", + "condition": "chunk_idx_can_be_finished", + "true_from": "_label_indices_eq_eoc", + "false_from": False, + } + subnet_unit["_label_indices_eq_true_label"] = { + "class": "compare", + "from": ["_label_indices", "ground_truth_label"], + "kind": "equal", + } + subnet_unit["_label_indices_eq_true_label_"] = { + "class": "switch", + "condition": "label_pos_reached_end", + "true_from": False, + "false_from": "_label_indices_eq_true_label", + } + subnet_unit["eoc_label_mask"] = { + "class": "combine", + "kind": "logical_or", + "from": ["_label_indices_eq_eoc_", "_label_indices_eq_true_label_"], + } + subnet_unit["output_prob_filter_eoc"] = { + "class": "switch", + "condition": "eoc_label_mask", + "true_from": "output_prob", + "false_from": 1e-20, + } + self.output_prob = "output_prob_filter_eoc" + + if self.coverage_scale and self.coverage_threshold: + assert ( + self.att_num_heads.dimension == 1 + ), "Not supported for multi-head attention." # TODO: just average the heads? + accum_w = self.subnet_unit.add_eval_layer( + "accum_w", + source=["prev:att_weights", "att_weights"], + eval="source(0) + source(1)", + ) # [B,enc-T,H=1] + merge_accum_w = self.subnet_unit.add_merge_dims_layer( + "merge_accum_w", accum_w, axes="except_batch" + ) # [B,enc-T] + coverage_mask = self.subnet_unit.add_compare_layer( + "coverage_mask", + merge_accum_w, + kind="greater", + value=self.coverage_threshold, + ) # [B,enc-T] + float_coverage_mask = self.subnet_unit.add_cast_layer( + "float_coverage_mask", coverage_mask, dtype="float32" + ) # [B,enc-T] + accum_coverage = self.subnet_unit.add_reduce_layer( + "accum_coverage", + float_coverage_mask, + mode="sum", + axes=-1, + keep_dims=True, + ) # [B,1] + + self.output_prob = self.subnet_unit.add_eval_layer( + "output_prob_coverage", + source=[self.output_prob, accum_coverage], + eval=f"source(0) * (source(1) ** {self.coverage_scale})", + ) + + if self.full_sum_simple_approx: + subnet_unit.add_copy_layer("output", "data:source") + else: + choice_opts = dict(target=target) + if not self.length_normalization: + choice_opts["length_normalization"] = False + if not search_type: + pass + elif search_type == "end-of-chunk": + choice_opts["search"] = True + choice_opts["target"] = None + else: + raise ValueError(f"Unknown search type: {search_type!r}") + subnet_unit.add_choice_layer( + "output", + self.output_prob, + beam_size=self.beam_size, + initial_output=0, + **choice_opts, + ) + + # recurrent subnetwork + rec_opts = dict(target=target) + if search_type == "end-of-chunk": + # search_flag is False in training, but we anyway want to search, and we don't want the seq len + # from the ground truth labels (without EOC labels), so we must not use the target here. + rec_opts["target"] = None + if self.full_sum_simple_approx: + assert self.prev_target_embed_direct + self.network["_targets_with_bos"] = { + "class": "prefix_in_time", + "from": f"data:{target}", + "prefix": self.eos_id, + } + rec_opts["source"] = "_targets_with_bos" + rec_opts["target"] = None + elif self.source: + rec_opts["source"] = self.source + if self.enc_chunks_dim: + assert self.enc_time_dim and self.enc_time_dim.dimension is not None + rec_opts["include_eos"] = True + # TODO warning this is wrong, needs to be larger, + # but we can't easily change it now because it changes the hash + rec_opts["max_seq_len"] = f"max_len_from('base:encoder') * {self.enc_time_dim.dimension}" + if rec_layer_opts: + rec_opts.update(rec_layer_opts) + dec_output = self.network.add_subnet_rec_layer(rec_layer_name, unit=subnet_unit.get_net(), **rec_opts) + + return dec_output + + def create_network(self): + self.dec_output = self.add_decoder_subnetwork(self.subnet_unit) + target = self.target + if self.search_type == "end-of-chunk": + self.base_model.network["_02_alignment_on_the_fly"] = { + "class": "copy", + "from": "out_best", + "register_as_extern_data": "alignment_on_the_fly", + } + target = "alignment_on_the_fly" + # Add another output layer for potential training. + subnet_unit = ReturnnNetwork() + self.add_decoder_subnetwork(subnet_unit, search_type=None, target=target) + + # Add to Base/Encoder network + + if hasattr(self.base_model, "enc_proj_dim") and self.base_model.enc_proj_dim: + self.base_model.network.add_copy_layer("enc_ctx", "encoder_proj") + self.base_model.network.add_split_dim_layer( + "enc_value", + "encoder_proj", + dims=( + self.att_num_heads, + FeatureDim("val", self.enc_value_dim // self.att_num_heads.dimension), + ), + ) + else: + self.base_model.network.add_linear_layer( + "enc_ctx", + "encoder", + with_bias=True, + n_out=self.enc_key_dim, + l2=self.base_model.l2, + param_dropout=self.ff_weight_drop, + param_dropout_min_ndim=2, + param_variational_noise=self.ff_weight_noise, + ) + self.base_model.network.add_split_dim_layer( + "enc_value", + "encoder", + dims=( + self.att_num_heads, + FeatureDim("val", self.enc_value_dim // self.att_num_heads.dimension), + ), + ) + + if not self.enc_chunks_dim: # use weight feedback + # there was a bug where n_out should be dimension and not the tag + # this does not override the layer to not break hashes of old exps without weight feedback. super annoying + self.base_model.network.add_linear_layer( + "inv_fertility", + "encoder", + activation="sigmoid", + n_out=self.att_num_heads.dimension, + with_bias=False, + param_dropout=self.ff_weight_drop, + param_dropout_min_ndim=2, + param_variational_noise=self.ff_weight_noise, + ) + else: + # this layer is not used anw and kept just to not break hashes + self.base_model.network.add_linear_layer( + "inv_fertility", + "encoder", + activation="sigmoid", + n_out=self.att_num_heads, # Note: this is a bug + with_bias=False, + param_dropout=self.ff_weight_drop, + param_dropout_min_ndim=2, + param_variational_noise=self.ff_weight_noise, + ) + + self.base_model.network["out_best"] = { + "class": "decide", + "from": self.dec_output, + } + + self.base_model.network["enc_seq_len"] = {"class": "length", "from": "encoder"} + self.base_model.network["targets_seq_len"] = { + "class": "length", + "from": f"data:{self.target}", + } + self.base_model.network["out_best_seq_len"] = { + "class": "length", + "from": "out_best", + } + if False: + for name in [ + "enc_seq_len", + "out_best", + "out_best_seq_len", + f"data:{self.target}", + "targets_seq_len", + ]: + name_ = name.replace("data:", "") + self.base_model.network[f"debug_print_{name_}"] = { + "class": "print", + "from": name, + "is_output_layer": True, + } + + # Filter blank / EOS / EOC + if not self.full_sum_simple_approx: + self.base_model.network["out_best_non_blank_mask"] = { + "class": "compare", + "from": "out_best", + "value": self.eos_id, + "kind": "not_equal", + } + + self.base_model.network["out_best_wo_blank"] = { + "class": "masked_computation", + "mask": "out_best_non_blank_mask", + "from": "out_best", + "unit": {"class": "copy"}, + } + self.decision_layer_name = "out_best_wo_blank" + + self.base_model.network["edit_distance"] = { + "class": "copy", + "from": "out_best_wo_blank", + "only_on_search": True, + "loss": "edit_distance", + "target": self.target, + } + + if self.enc_chunks_dim and self.enable_check_align: + self.base_model.network["_check_alignment"] = { + "class": "eval", + "from": "out_best_wo_blank", + "eval": _check_alignment, + "eval_locals": {"target": target}, # with blank + "is_output_layer": True, + } + + return self.dec_output + + +# noinspection PyShadowingNames +def _check_alignment(source, self, target, **_kwargs): + import tensorflow as tf + from returnn.tf.util.data import Data + + out_wo_blank = source(0, as_data=True) + assert isinstance(out_wo_blank, Data) + if not self.network.eval_flag: + # Targets are not available during recognition. + return out_wo_blank.placeholder + out_with_blank = self.network.get_layer(f"data:{target}").output + assert isinstance(out_with_blank, Data) + encoder = self.network.get_layer("encoder").output + assert isinstance(encoder, Data) + num_chunks = encoder.get_sequence_lengths() + num_labels_wo_blank = out_wo_blank.get_sequence_lengths() + num_labels_w_blank = out_with_blank.get_sequence_lengths() + deps = [ + tf.Assert( + tf.reduce_all(tf.equal(num_labels_wo_blank + num_chunks, num_labels_w_blank)), + [ + "num labels wo blank, num chunks, with blank:", + num_labels_wo_blank, + num_chunks, + num_labels_w_blank, + "labels wo blank, with blank:", + out_wo_blank.placeholder, + out_with_blank.placeholder, + ], + summarize=100, + ), + ] + self.network.register_post_control_dependencies(deps) + with tf.control_dependencies(deps): + return tf.identity(out_wo_blank.placeholder) + + +# Taken from returnn_common, adopted. +def _rnnt_full_sum_log_prob_eval_layer_func( + *, + self: LayerBase, + source, + input_spatial_dim: Dim, + blank_index: int, +) -> tf.Tensor: + from returnn.tf.util.data import Data + from returnn.tf.layers.basic import LayerBase + from returnn.extern.HawkAaronWarpTransducer import rnnt_loss + + assert isinstance(self, LayerBase) + logits = source(0, auto_convert=False, as_data=True) + labels = source(1, auto_convert=False, as_data=True) + assert isinstance(logits, Data) and isinstance(labels, Data) + assert labels.batch_ndim == 2 and labels.have_batch_axis() and labels.have_time_axis() + labels_spatial_dim = labels.get_time_dim_tag() + prev_labels_spatial_dim = 1 + labels_spatial_dim + batch_dims = list(self.output.dim_tags) + feat_dim = logits.feature_dim_or_sparse_dim + if blank_index < 0: + blank_index += feat_dim.dimension + assert 0 <= blank_index < feat_dim.dimension + assert labels.sparse_dim.dimension <= feat_dim.dimension + # Move axes into the right order (no-op if they already are). + logits = logits.copy_compatible_to( + Data("logits", dim_tags=batch_dims + [input_spatial_dim, prev_labels_spatial_dim, feat_dim]), + check_dtype=False, + ) + labels = labels.copy_compatible_to( + Data("labels", dim_tags=batch_dims + [labels_spatial_dim], sparse_dim=labels.sparse_dim), check_dtype=False + ) + input_lengths = input_spatial_dim.get_dyn_size_ext_for_batch_ctx( + logits.batch, logits.control_flow_ctx + ).copy_compatible_to(Data("input_lengths", dim_tags=batch_dims), check_dtype=False) + label_lengths = labels_spatial_dim.get_dyn_size_ext_for_batch_ctx( + logits.batch, logits.control_flow_ctx + ).copy_compatible_to(Data("label_lengths", dim_tags=batch_dims), check_dtype=False) + + return rnnt_loss( + acts=logits.placeholder, + labels=labels.placeholder, + input_lengths=input_lengths.placeholder, + label_lengths=label_lengths.placeholder, + blank_label=blank_index, + ) + + +def _rnnt_full_sum_log_prob_eval_layer_out( + *, + name: str, + **_kwargs, +) -> Data: + from returnn.tf.util.data import Data, batch_dim + + return Data("%s_output" % name, dim_tags=[batch_dim]) From 454d2b155374948bfedba232f71c694f0bba3bb7 Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Thu, 6 Jun 2024 10:39:35 +0000 Subject: [PATCH 107/227] update --- users/zeineldeen/models/asr/decoder/chunked_rnn_decoder.py | 1 + 1 file changed, 1 insertion(+) diff --git a/users/zeineldeen/models/asr/decoder/chunked_rnn_decoder.py b/users/zeineldeen/models/asr/decoder/chunked_rnn_decoder.py index d93edffa4..0a10baba6 100644 --- a/users/zeineldeen/models/asr/decoder/chunked_rnn_decoder.py +++ b/users/zeineldeen/models/asr/decoder/chunked_rnn_decoder.py @@ -1,5 +1,6 @@ """ Model, based on Mohammads code. +Starting point here: i6_experiments.users.zeyer.experiments.exp2023_02_16_chunked_attention.model """ From 79e126386d22b168833c2d9bb7cde1a9c0625383 Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Thu, 6 Jun 2024 13:24:24 +0000 Subject: [PATCH 108/227] fix --- .../chunkwise_attention_asr_config.py | 8 ++++++- .../configs/ted2_chunked_aed_variants.py | 22 +++++++++++++++++++ 2 files changed, 29 insertions(+), 1 deletion(-) diff --git a/users/zeineldeen/experiments/chunkwise_att_2023/librispeech_960/chunkwise_attention_asr_config.py b/users/zeineldeen/experiments/chunkwise_att_2023/librispeech_960/chunkwise_attention_asr_config.py index b611a8f8d..cab33c1b0 100644 --- a/users/zeineldeen/experiments/chunkwise_att_2023/librispeech_960/chunkwise_attention_asr_config.py +++ b/users/zeineldeen/experiments/chunkwise_att_2023/librispeech_960/chunkwise_attention_asr_config.py @@ -571,6 +571,9 @@ class RNNDecoderArgs(DecoderArgs): use_zoneout_output: bool = False + ff_weight_dropout: Optional[float] = None + ff_weight_noise: Optional[float] = None + def create_config( training_datasets, @@ -1082,7 +1085,10 @@ def create_config( exp_config["network"]["output"]["unit"].pop("s", None) # change inputs - exp_config["network"]["output"]["unit"]["s_wo_att"]["from"] = "prev:target_embed" # remove prev:att + if decoder_args["full_sum_simple_approx"]: + exp_config["network"]["output"]["unit"]["s_wo_att"]["from"] = "prev_target_embed" + else: + exp_config["network"]["output"]["unit"]["s_wo_att"]["from"] = "prev:target_embed" exp_config["network"]["output"]["unit"]["s_transformed"]["from"] = "s_wo_att" assert exp_config["network"]["output"]["unit"]["readout_in"]["from"][0] == "s" exp_config["network"]["output"]["unit"]["readout_in"]["from"][0] = "s_wo_att" diff --git a/users/zeineldeen/experiments/chunkwise_att_2023/tedlium2/configs/ted2_chunked_aed_variants.py b/users/zeineldeen/experiments/chunkwise_att_2023/tedlium2/configs/ted2_chunked_aed_variants.py index df2209c86..fbb28d0a5 100644 --- a/users/zeineldeen/experiments/chunkwise_att_2023/tedlium2/configs/ted2_chunked_aed_variants.py +++ b/users/zeineldeen/experiments/chunkwise_att_2023/tedlium2/configs/ted2_chunked_aed_variants.py @@ -1747,6 +1747,28 @@ def py(): remove_att_ctx_from_dec_state=True, ) + # TODO: exact full-sum training + run_chunkwise_train( + enc_stream_type="global", + run_all_for_best_last_avg=True, + enable_check_align=False, + chunk_sizes=[25], + chunk_step_factors=[1], + start_lrs=[2e-4], + decay_pt_factors=[0.25, 1 / 3], + final_lrs=[1e-6], + gpu_mem=11, + total_epochs=[20 * 4, 40 * 4], + batch_size=15_000, + accum_grad=2, + time_rqmt=120, + decoder_mask_eoc=False, # there are no blanks in the target seq + remove_att_ctx_from_dec_state=True, # remove att ctx dependency so we can do exact full sum + full_sum_approx=True, + ) + + # TODO: exact full-sum training starting from viterbi-trained model + # # TODO: use overlap # run_chunkwise_train( # enc_stream_type="global", From 58c4d07e991cecd8cf8aef902f19cf29f5711308 Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Thu, 6 Jun 2024 13:53:11 +0000 Subject: [PATCH 109/227] fix --- .../tedlium2/configs/ted2_chunked_aed_variants.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/users/zeineldeen/experiments/chunkwise_att_2023/tedlium2/configs/ted2_chunked_aed_variants.py b/users/zeineldeen/experiments/chunkwise_att_2023/tedlium2/configs/ted2_chunked_aed_variants.py index fbb28d0a5..e0050a9ef 100644 --- a/users/zeineldeen/experiments/chunkwise_att_2023/tedlium2/configs/ted2_chunked_aed_variants.py +++ b/users/zeineldeen/experiments/chunkwise_att_2023/tedlium2/configs/ted2_chunked_aed_variants.py @@ -1759,8 +1759,8 @@ def py(): final_lrs=[1e-6], gpu_mem=11, total_epochs=[20 * 4, 40 * 4], - batch_size=15_000, - accum_grad=2, + batch_size=10_000, + accum_grad=3, time_rqmt=120, decoder_mask_eoc=False, # there are no blanks in the target seq remove_att_ctx_from_dec_state=True, # remove att ctx dependency so we can do exact full sum From 202004d01a0fe8b162ce0bcd7cbff719fbf56bb7 Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Thu, 6 Jun 2024 16:58:14 +0200 Subject: [PATCH 110/227] more --- .../exp2024_04_23_baselines/ctc.py | 24 ++++++++++++------- 1 file changed, 15 insertions(+), 9 deletions(-) diff --git a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py index 450331bf0..76197d180 100644 --- a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py +++ b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py @@ -55,15 +55,21 @@ def py(): - Luca uses older behavior_version 21 -> 16. """ - train_exp( - f"v6-bhv20-11gb-f32-bs15k-accgrad5-mgpu4-pavg100-wd1e_5-lrlin1e_5_295k-bpe10k", - config_11gb_v6_f32_accgrad1_mgpu4_pavg100_wd1e_4, - config_updates={ - **_get_cfg_lrlin_oclr_by_bs_nep(15_000, 500), - "accum_grad_multiple_step": 5, - "optimizer.weight_decay": 1e-5, - }, - ) + for wd in [ + # 1e-5, # 9.9 + 1e-4, + 1e-3, + 1e-2, + ]: + train_exp( + f"v6-bhv20-11gb-f32-bs15k-accgrad5-mgpu4-pavg100-wd{str(wd).replace('-','_')}-lrlin1e_5_295k-bpe10k", + config_11gb_v6_f32_accgrad1_mgpu4_pavg100_wd1e_4, + config_updates={ + **_get_cfg_lrlin_oclr_by_bs_nep(15_000, 500), + "accum_grad_multiple_step": 5, + "optimizer.weight_decay": wd, + }, + ) train_exp( # 9.24 f"v6-bhv20-11gb-f32-bs15k-accgrad1-mgpu4-pavg100-wd1e_4-lrlin1e_5_295k-bpe10k", From cd83e0e9b8a05aa7598b258441a7aefa109d0002 Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Thu, 6 Jun 2024 17:02:55 +0200 Subject: [PATCH 111/227] more --- .../exp2024_04_23_baselines/ctc.py | 48 +++++++------------ 1 file changed, 16 insertions(+), 32 deletions(-) diff --git a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py index 76197d180..d8d936b04 100644 --- a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py +++ b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py @@ -55,38 +55,22 @@ def py(): - Luca uses older behavior_version 21 -> 16. """ - for wd in [ - # 1e-5, # 9.9 - 1e-4, - 1e-3, - 1e-2, - ]: - train_exp( - f"v6-bhv20-11gb-f32-bs15k-accgrad5-mgpu4-pavg100-wd{str(wd).replace('-','_')}-lrlin1e_5_295k-bpe10k", - config_11gb_v6_f32_accgrad1_mgpu4_pavg100_wd1e_4, - config_updates={ - **_get_cfg_lrlin_oclr_by_bs_nep(15_000, 500), - "accum_grad_multiple_step": 5, - "optimizer.weight_decay": wd, - }, - ) - - train_exp( # 9.24 - f"v6-bhv20-11gb-f32-bs15k-accgrad1-mgpu4-pavg100-wd1e_4-lrlin1e_5_295k-bpe10k", - config_11gb_v6_f32_accgrad1_mgpu4_pavg100_wd1e_4, - config_updates={ - **_get_cfg_lrlin_oclr_by_bs_nep(15_000, 500), - }, - ) - - train_exp( - f"v6-bhv20-11gb-f32-bs15k-accgrad1-mgpu4-pavg100-wd1e_2-lrlin1e_5_295k-bpe10k", - config_11gb_v6_f32_accgrad1_mgpu4_pavg100_wd1e_4, - config_updates={ - **_get_cfg_lrlin_oclr_by_bs_nep(15_000, 500), - "optimizer.weight_decay": 1e-2, - }, - ) + for acc in [5, 1]: + for wd in [ + # 1e-5, # accum=5, wd=1e-5: 9.90 + 1e-4, # accum=1, wd=1e-4: 9.24 + 1e-3, + 1e-2, + ]: + train_exp( + f"v6-bhv20-11gb-f32-bs15k-accgrad{acc}-mgpu4-pavg100-wd{str(wd).replace('-','_')}-lrlin1e_5_295k-bpe10k", + config_11gb_v6_f32_accgrad1_mgpu4_pavg100_wd1e_4, + config_updates={ + **_get_cfg_lrlin_oclr_by_bs_nep(15_000, 500), + "accum_grad_multiple_step": acc, + "optimizer.weight_decay": wd, + }, + ) train_exp( # 8.79 f"v6-bhv20-11gb-f32-bs15k-accgrad1-mgpu4-pavg100-wd1e_4-lrlin1e_5_295k-speedpertV2-bpe10k", From 5f620eeb0580d629e99c18a97a234da8d2350ccc Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Thu, 6 Jun 2024 17:18:50 +0200 Subject: [PATCH 112/227] fix name --- users/zeyer/experiments/exp2024_04_23_baselines/ctc.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py index d8d936b04..c749b0941 100644 --- a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py +++ b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py @@ -63,7 +63,9 @@ def py(): 1e-2, ]: train_exp( - f"v6-bhv20-11gb-f32-bs15k-accgrad{acc}-mgpu4-pavg100-wd{str(wd).replace('-','_')}-lrlin1e_5_295k-bpe10k", + f"v6-bhv20-11gb-f32-bs15k-accgrad{acc}" + f"-mgpu4-pavg100-wd{('%.e'%wd).replace('e-0', 'e_')}" + f"-lrlin1e_5_295k-bpe10k", config_11gb_v6_f32_accgrad1_mgpu4_pavg100_wd1e_4, config_updates={ **_get_cfg_lrlin_oclr_by_bs_nep(15_000, 500), From 2f4fa9a6d0ac4d6907f19b0aab100d63c35977e9 Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Thu, 6 Jun 2024 17:20:47 +0200 Subject: [PATCH 113/227] more --- users/zeyer/experiments/exp2024_04_23_baselines/ctc.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py index c749b0941..5a37e66a0 100644 --- a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py +++ b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py @@ -62,6 +62,8 @@ def py(): 1e-3, 1e-2, ]: + if (acc, wd) == (1, 1e-4): + continue # skip for now train_exp( f"v6-bhv20-11gb-f32-bs15k-accgrad{acc}" f"-mgpu4-pavg100-wd{('%.e'%wd).replace('e-0', 'e_')}" From 4e835195605293f5df35047c7c3dced5a77426df Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Thu, 6 Jun 2024 17:24:19 +0200 Subject: [PATCH 114/227] more --- .../exp2024_04_23_baselines/ctc.py | 39 +++++++++---------- 1 file changed, 19 insertions(+), 20 deletions(-) diff --git a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py index 5a37e66a0..e023ae15a 100644 --- a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py +++ b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py @@ -55,26 +55,25 @@ def py(): - Luca uses older behavior_version 21 -> 16. """ - for acc in [5, 1]: - for wd in [ - # 1e-5, # accum=5, wd=1e-5: 9.90 - 1e-4, # accum=1, wd=1e-4: 9.24 - 1e-3, - 1e-2, - ]: - if (acc, wd) == (1, 1e-4): - continue # skip for now - train_exp( - f"v6-bhv20-11gb-f32-bs15k-accgrad{acc}" - f"-mgpu4-pavg100-wd{('%.e'%wd).replace('e-0', 'e_')}" - f"-lrlin1e_5_295k-bpe10k", - config_11gb_v6_f32_accgrad1_mgpu4_pavg100_wd1e_4, - config_updates={ - **_get_cfg_lrlin_oclr_by_bs_nep(15_000, 500), - "accum_grad_multiple_step": acc, - "optimizer.weight_decay": wd, - }, - ) + for acc, wd in [ + # (5, 1e-5), # 9.90 + (5, 1e-3), + (5, 1e-2), + # (1, 1e-4), # 9.24 + (1, 1e-3), + (1, 1e-2), + ]: + train_exp( + f"v6-bhv20-11gb-f32-bs15k-accgrad{acc}" + f"-mgpu4-pavg100-wd{('%.e'%wd).replace('e-0', 'e_')}" + f"-lrlin1e_5_295k-bpe10k", + config_11gb_v6_f32_accgrad1_mgpu4_pavg100_wd1e_4, + config_updates={ + **_get_cfg_lrlin_oclr_by_bs_nep(15_000, 500), + "accum_grad_multiple_step": acc, + "optimizer.weight_decay": wd, + }, + ) train_exp( # 8.79 f"v6-bhv20-11gb-f32-bs15k-accgrad1-mgpu4-pavg100-wd1e_4-lrlin1e_5_295k-speedpertV2-bpe10k", From 8963e44194d790965e06bd8e858fccc096fdb7dc Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Fri, 7 Jun 2024 09:26:54 +0200 Subject: [PATCH 115/227] small fix --- users/zeyer/experiments/exp2024_04_23_baselines/aed.py | 2 +- users/zeyer/experiments/exp2024_04_23_baselines/ctc.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/users/zeyer/experiments/exp2024_04_23_baselines/aed.py b/users/zeyer/experiments/exp2024_04_23_baselines/aed.py index 59572b25a..8099b81df 100644 --- a/users/zeyer/experiments/exp2024_04_23_baselines/aed.py +++ b/users/zeyer/experiments/exp2024_04_23_baselines/aed.py @@ -171,7 +171,7 @@ def train_exp( num_epochs=num_epochs, gpu_mem=gpu_mem, num_processes=num_processes, - distributed_launch_cmd="torchrun" if num_processes else None, + distributed_launch_cmd="torchrun" if num_processes else "mpirun", time_rqmt=time_rqmt, ) recog_training_exp(prefix, task, model_with_checkpoint, recog_def=model_recog) diff --git a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py index e023ae15a..3606c888f 100644 --- a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py +++ b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py @@ -247,7 +247,7 @@ def train_exp( num_epochs=num_epochs, gpu_mem=gpu_mem, num_processes=num_processes, - distributed_launch_cmd="torchrun" if num_processes else None, + distributed_launch_cmd="torchrun" if num_processes else "mpirun", time_rqmt=time_rqmt, ) From f21297dfb634e74f13a33cd150453266dba049de Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Fri, 7 Jun 2024 09:28:13 +0200 Subject: [PATCH 116/227] more --- .../experiments/exp2024_04_23_baselines/ctc.py | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py index 3606c888f..84eaf6a6c 100644 --- a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py +++ b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py @@ -55,6 +55,23 @@ def py(): - Luca uses older behavior_version 21 -> 16. """ + train_exp( + f"v6-bhv21-24gb-bf16-bs40k-accgrad2-wd1e_6-lrlin1e_5_450k-bpe10k", + config_24gb_v6, + config_updates={ + **_get_cfg_lrlin_oclr_by_bs_nep(40_000, 2000), + }, + ) + + train_exp( + f"v6-bhv21-24gb-bf16-bs40k-accgrad2-wd1e_6-lrlin1e_5_600k-bpe10k", + config_24gb_v6, + config_updates={ + **_get_cfg_lrlin_oclr_by_bs_nep(40_000, 2000), + "learning_rate_piecewise_steps": [600_000, 900_000, 982_000], + }, + ) + for acc, wd in [ # (5, 1e-5), # 9.90 (5, 1e-3), From 49438b92fe95093ac8de2facbf1fbef82f124257 Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Fri, 7 Jun 2024 09:35:06 +0200 Subject: [PATCH 117/227] more --- .../experiments/exp2024_04_23_baselines/ctc.py | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py index 84eaf6a6c..257dc1374 100644 --- a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py +++ b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py @@ -123,6 +123,19 @@ def py(): vocab=vocab, ) + train_exp( + f"v6-bhv20-11gb-f32-bs15k-accgrad1-mgpu4-pavg100-wd1e_2-lrlin1e_5_393k-speedpertV2-bpe10k", + config_11gb_v6_f32_accgrad1_mgpu4_pavg100_wd1e_4, + config_updates={ + **_get_cfg_lrlin_oclr_by_bs_nep(15_000, 500), + "learning_rate_piecewise_steps": [393_000, 590_000, 652_000], # total steps after 500 epochs: ~652k + "optimizer.weight_decay": 1e-2, + "__train_audio_preprocess": speed_pert_librosa_config, + "speed_pert_discrete_values": [0.7, 0.8, 0.9, 1.0, 1.1], + }, + vocab="bpe10k", + ) + for alpha in [ 0.3, # 7.88 0.5, # 7.13 From 16b34cc858509637e4a65309db2539225eb5750a Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Fri, 7 Jun 2024 11:26:47 +0200 Subject: [PATCH 118/227] cleanup --- .../exp2024_04_23_baselines/ctc.py | 63 +++++++------------ 1 file changed, 22 insertions(+), 41 deletions(-) diff --git a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py index 257dc1374..9659ffd21 100644 --- a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py +++ b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py @@ -172,50 +172,31 @@ def py(): train_vocab_opts={"other_opts": {"enable_sampling": True, "alpha": 0.7}}, ) - train_exp( - "v6-bhv20-11gb-f32-bs15k-accgrad1-mgpu4-pavg100-wd1e_2-lrlin1e_5_295k-featBN-speedpertV2-spm10k-spmSample07", - config_11gb_v6_f32_accgrad1_mgpu4_pavg100_wd1e_4, - model_config={"feature_batch_norm": True}, - config_updates={ - **_get_cfg_lrlin_oclr_by_bs_nep(15_000, 500), - "optimizer.weight_decay": 1e-2, - "__train_audio_preprocess": speed_pert_librosa_config, - "speed_pert_discrete_values": [0.7, 0.8, 0.9, 1.0, 1.1], - }, - vocab="spm10k", - train_vocab_opts={"other_opts": {"enable_sampling": True, "alpha": 0.7}}, - ) - - train_exp( - "v6-bhv20-11gb-f32-bs15k-accgrad1-mgpu4-pavg100-wd1e_2-lrlin1e_5_295k-featNorm-speedpertV2-spm10k-spmSample07", - config_11gb_v6_f32_accgrad1_mgpu4_pavg100_wd1e_4, - model_config={"feature_norm": True}, - config_updates={ - **_get_cfg_lrlin_oclr_by_bs_nep(15_000, 500), - "optimizer.weight_decay": 1e-2, - "__train_audio_preprocess": speed_pert_librosa_config, - "speed_pert_discrete_values": [0.7, 0.8, 0.9, 1.0, 1.1], - }, - vocab="spm10k", - train_vocab_opts={"other_opts": {"enable_sampling": True, "alpha": 0.7}}, - ) - from i6_experiments.users.zeyer.datasets.librispeech import get_librispeech_log_mel_stats feature_stats = get_librispeech_log_mel_stats(_log_mel_feature_dim) - train_exp( - "v6-bhv20-11gb-f32-bs15k-accgrad1-mgpu4-pavg100-wd1e_2-lrlin1e_5_295k-featGN-speedpertV2-spm10k-spmSample07", - config_11gb_v6_f32_accgrad1_mgpu4_pavg100_wd1e_4, - model_config={"feature_stats": {"mean": feature_stats.mean, "std_dev": feature_stats.std_dev}}, - config_updates={ - **_get_cfg_lrlin_oclr_by_bs_nep(15_000, 500), - "optimizer.weight_decay": 1e-2, - "__train_audio_preprocess": speed_pert_librosa_config, - "speed_pert_discrete_values": [0.7, 0.8, 0.9, 1.0, 1.1], - }, - vocab="spm10k", - train_vocab_opts={"other_opts": {"enable_sampling": True, "alpha": 0.7}}, - ) + + # Test different feature normalization schemes. + for name, model_opts in { + None: None, + "featBN": {"feature_batch_norm": True}, + "featNorm": {"feature_norm": True}, + "featGN": {"feature_stats": {"mean": feature_stats.mean, "std_dev": feature_stats.std_dev}}, + }.items(): + train_exp( + "v6-bhv20-11gb-f32-bs15k-accgrad1-mgpu4-pavg100-wd1e_2-lrlin1e_5_295k-" + f"{(name + '-') if name else ''}speedpertV2-spm10k-spmSample07", + config_11gb_v6_f32_accgrad1_mgpu4_pavg100_wd1e_4, + model_config=model_opts, + config_updates={ + **_get_cfg_lrlin_oclr_by_bs_nep(15_000, 500), + "optimizer.weight_decay": 1e-2, + "__train_audio_preprocess": speed_pert_librosa_config, + "speed_pert_discrete_values": [0.7, 0.8, 0.9, 1.0, 1.1], + }, + vocab="spm10k", + train_vocab_opts={"other_opts": {"enable_sampling": True, "alpha": 0.7}}, + ) # noinspection PyShadowingNames From acdfdf47483f483abb6f6bbce3e4895f9b863260 Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Fri, 7 Jun 2024 11:49:28 +0000 Subject: [PATCH 119/227] fix --- .../librispeech_960/chunkwise_attention_asr_config.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/users/zeineldeen/experiments/chunkwise_att_2023/librispeech_960/chunkwise_attention_asr_config.py b/users/zeineldeen/experiments/chunkwise_att_2023/librispeech_960/chunkwise_attention_asr_config.py index cab33c1b0..bbbac39c1 100644 --- a/users/zeineldeen/experiments/chunkwise_att_2023/librispeech_960/chunkwise_attention_asr_config.py +++ b/users/zeineldeen/experiments/chunkwise_att_2023/librispeech_960/chunkwise_attention_asr_config.py @@ -933,6 +933,8 @@ def create_config( decoder_args = asdict(decoder_args) decoder_args.update({"target": target, "beam_size": beam_size}) + chunked_decoder_trained_with_fs = False + if chunked_decoder: decoder_args["enc_chunks_dim"] = chunked_time_dim decoder_args["enc_time_dim"] = chunk_size_dim @@ -941,6 +943,7 @@ def create_config( decoder_args["enable_check_align"] = enable_check_align # just here to keep some old changes if decoder_args["full_sum_simple_approx"] and is_recog: + chunked_decoder_trained_with_fs = True decoder_args["full_sum_simple_approx"] = False decoder_args["masked_computation_blank_idx"] = eoc_idx elif chunk_size and not dump_ctc_dataset and not dump_ctc and not dump_alignments_dataset: @@ -1085,7 +1088,7 @@ def create_config( exp_config["network"]["output"]["unit"].pop("s", None) # change inputs - if decoder_args["full_sum_simple_approx"]: + if decoder_args["full_sum_simple_approx"] or chunked_decoder_trained_with_fs: exp_config["network"]["output"]["unit"]["s_wo_att"]["from"] = "prev_target_embed" else: exp_config["network"]["output"]["unit"]["s_wo_att"]["from"] = "prev:target_embed" From 50ba89a8b7ac7b3320649e2f84fdaada00d50bcb Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Fri, 7 Jun 2024 11:28:11 +0200 Subject: [PATCH 120/227] comment --- users/zeyer/experiments/exp2024_04_23_baselines/ctc.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py index 9659ffd21..07743cec6 100644 --- a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py +++ b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py @@ -179,9 +179,9 @@ def py(): # Test different feature normalization schemes. for name, model_opts in { None: None, - "featBN": {"feature_batch_norm": True}, - "featNorm": {"feature_norm": True}, - "featGN": {"feature_stats": {"mean": feature_stats.mean, "std_dev": feature_stats.std_dev}}, + "featBN": {"feature_batch_norm": True}, # batch norm + "featNorm": {"feature_norm": True}, # normalize (on sequence level) + "featGN": {"feature_stats": {"mean": feature_stats.mean, "std_dev": feature_stats.std_dev}}, # global norm }.items(): train_exp( "v6-bhv20-11gb-f32-bs15k-accgrad1-mgpu4-pavg100-wd1e_2-lrlin1e_5_295k-" From f34dfdffcb2cad3d4c9bc17496c22c58e6f4d8b7 Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Fri, 7 Jun 2024 12:01:02 +0200 Subject: [PATCH 121/227] more --- .../exp2024_04_23_baselines/ctc.py | 23 +++++++++++++++++++ 1 file changed, 23 insertions(+) diff --git a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py index 07743cec6..e79993e77 100644 --- a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py +++ b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py @@ -140,6 +140,7 @@ def py(): 0.3, # 7.88 0.5, # 7.13 0.7, # 6.99 + 0.8, ]: train_exp( "v6-bhv20-11gb-f32-bs15k-accgrad1-mgpu4-pavg100-wd1e_2-lrlin1e_5_295k-speedpertV2-spm10k" @@ -157,6 +158,28 @@ def py(): # v6-bhv20-11gb-f32-bs15k-accgrad1-mgpu4-pavg100-wd1e_2-lrlin1e_5_295k-speedpertV2 # with spm_bpe10k and enable_sampling, alpha in {0.3, 0.7} was both very bad (90% WER). + # But actually, alpha for BPE has a very different effect, and it causes the seq len to be much longer. + # The higher the alpha, the longer (the reverse as for SPM Unigram). + # See archive/returnn-spm_bpe10-sample.config. + for alpha in [ + 0.005, + 0.01, + # 0.3, # broken + # 0.7, # broken + ]: + train_exp( + "v6-bhv20-11gb-f32-bs15k-accgrad1-mgpu4-pavg100-wd1e_2-lrlin1e_5_295k-speedpertV2-spm_bpe10k" + f"-spmSample{str(alpha).replace('.', '')}", + config_11gb_v6_f32_accgrad1_mgpu4_pavg100_wd1e_4, + config_updates={ + **_get_cfg_lrlin_oclr_by_bs_nep(15_000, 500), + "optimizer.weight_decay": 1e-2, + "__train_audio_preprocess": speed_pert_librosa_config, + "speed_pert_discrete_values": [0.7, 0.8, 0.9, 1.0, 1.1], + }, + vocab="spm_bpe10k", + train_vocab_opts={"other_opts": {"enable_sampling": True, "alpha": alpha}}, + ) train_exp( "v6-bhv20-11gb-f32-bs15k-accgrad1-mgpu4-pavg100-wd1e_2-lrlin1e_5_295k-speedpertV2-spm10k-eos-spmSample07", From 1a640e8b7f66967efda4ce7003237be1701da93b Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Fri, 7 Jun 2024 15:49:57 +0200 Subject: [PATCH 122/227] cleanup --- .../exp2024_04_23_baselines/ctc.py | 49 +++++++------------ 1 file changed, 18 insertions(+), 31 deletions(-) diff --git a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py index e79993e77..a2022eb34 100644 --- a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py +++ b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py @@ -136,14 +136,23 @@ def py(): vocab="bpe10k", ) - for alpha in [ - 0.3, # 7.88 - 0.5, # 7.13 - 0.7, # 6.99 - 0.8, + # Testing different vocabs together with sampling. + for vocab, alpha in [ + # See archive/returnn-spm10-sample.config for playing around with alpha and checking avg seq len. + ("spm10k", 0.3), # 7.88 + ("spm10k", 0.5), # 7.13 + ("spm10k", 0.7), # 6.99 + ("spm10k", 0.8), + # alpha for BPE has a very different effect, and it causes the seq len to be much longer. + # The higher the alpha, the longer (the reverse as for SPM Unigram). + # See archive/returnn-spm_bpe10-sample.config. + ("spm_bpe10k", 0.005), + ("spm_bpe10k", 0.01), + # ("spm_bpe10k", 0.3), # broken + # ("spm_bpe10k", 0.7), # broken ]: train_exp( - "v6-bhv20-11gb-f32-bs15k-accgrad1-mgpu4-pavg100-wd1e_2-lrlin1e_5_295k-speedpertV2-spm10k" + f"v6-bhv20-11gb-f32-bs15k-accgrad1-mgpu4-pavg100-wd1e_2-lrlin1e_5_295k-speedpertV2-{vocab}" f"-spmSample{str(alpha).replace('.', '')}", config_11gb_v6_f32_accgrad1_mgpu4_pavg100_wd1e_4, config_updates={ @@ -152,34 +161,12 @@ def py(): "__train_audio_preprocess": speed_pert_librosa_config, "speed_pert_discrete_values": [0.7, 0.8, 0.9, 1.0, 1.1], }, - vocab="spm10k", + vocab=vocab, train_vocab_opts={"other_opts": {"enable_sampling": True, "alpha": alpha}}, ) - # v6-bhv20-11gb-f32-bs15k-accgrad1-mgpu4-pavg100-wd1e_2-lrlin1e_5_295k-speedpertV2 - # with spm_bpe10k and enable_sampling, alpha in {0.3, 0.7} was both very bad (90% WER). - # But actually, alpha for BPE has a very different effect, and it causes the seq len to be much longer. - # The higher the alpha, the longer (the reverse as for SPM Unigram). - # See archive/returnn-spm_bpe10-sample.config. - for alpha in [ - 0.005, - 0.01, - # 0.3, # broken - # 0.7, # broken - ]: - train_exp( - "v6-bhv20-11gb-f32-bs15k-accgrad1-mgpu4-pavg100-wd1e_2-lrlin1e_5_295k-speedpertV2-spm_bpe10k" - f"-spmSample{str(alpha).replace('.', '')}", - config_11gb_v6_f32_accgrad1_mgpu4_pavg100_wd1e_4, - config_updates={ - **_get_cfg_lrlin_oclr_by_bs_nep(15_000, 500), - "optimizer.weight_decay": 1e-2, - "__train_audio_preprocess": speed_pert_librosa_config, - "speed_pert_discrete_values": [0.7, 0.8, 0.9, 1.0, 1.1], - }, - vocab="spm_bpe10k", - train_vocab_opts={"other_opts": {"enable_sampling": True, "alpha": alpha}}, - ) + # TODO SamplingBytePairEncoding for orig bpe10k, breadth_prob=0.01 + # See archive/returnn-bpe10-sample.config. train_exp( "v6-bhv20-11gb-f32-bs15k-accgrad1-mgpu4-pavg100-wd1e_2-lrlin1e_5_295k-speedpertV2-spm10k-eos-spmSample07", From 1725cded5edf583361132691410700a124a5c4a7 Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Fri, 7 Jun 2024 16:14:43 +0200 Subject: [PATCH 123/227] more --- .../experiments/exp2024_04_23_baselines/ctc.py | 18 ++++++++++++------ 1 file changed, 12 insertions(+), 6 deletions(-) diff --git a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py index a2022eb34..c65c7ffde 100644 --- a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py +++ b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py @@ -143,17 +143,20 @@ def py(): ("spm10k", 0.5), # 7.13 ("spm10k", 0.7), # 6.99 ("spm10k", 0.8), - # alpha for BPE has a very different effect, and it causes the seq len to be much longer. + # alpha for SPM-BPE has a very different effect, and it causes the seq len to be much longer. # The higher the alpha, the longer (the reverse as for SPM Unigram). # See archive/returnn-spm_bpe10-sample.config. ("spm_bpe10k", 0.005), ("spm_bpe10k", 0.01), # ("spm_bpe10k", 0.3), # broken # ("spm_bpe10k", 0.7), # broken + # alpha for BPE is again a bit different, but more similar to SPM-BPE than SPM-Unigram. + # See archive/returnn-bpe10-sample.config. + ("bpe10k", 0.01), ]: train_exp( f"v6-bhv20-11gb-f32-bs15k-accgrad1-mgpu4-pavg100-wd1e_2-lrlin1e_5_295k-speedpertV2-{vocab}" - f"-spmSample{str(alpha).replace('.', '')}", + f"-{'spmSample' if vocab.startswith('spm') else 'bpeSample'}{str(alpha).replace('.', '')}", config_11gb_v6_f32_accgrad1_mgpu4_pavg100_wd1e_4, config_updates={ **_get_cfg_lrlin_oclr_by_bs_nep(15_000, 500), @@ -162,12 +165,15 @@ def py(): "speed_pert_discrete_values": [0.7, 0.8, 0.9, 1.0, 1.1], }, vocab=vocab, - train_vocab_opts={"other_opts": {"enable_sampling": True, "alpha": alpha}}, + train_vocab_opts={ + "other_opts": ( + {"enable_sampling": True, "alpha": alpha} + if vocab.startswith("spm") + else {"class": "SamplingBytePairEncoding", "breadth_prob": alpha} + ) + }, ) - # TODO SamplingBytePairEncoding for orig bpe10k, breadth_prob=0.01 - # See archive/returnn-bpe10-sample.config. - train_exp( "v6-bhv20-11gb-f32-bs15k-accgrad1-mgpu4-pavg100-wd1e_2-lrlin1e_5_295k-speedpertV2-spm10k-eos-spmSample07", config_11gb_v6_f32_accgrad1_mgpu4_pavg100_wd1e_4, From 56543ca18a3a3eb9ae3595716cf00ad6005c9c62 Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Fri, 7 Jun 2024 17:13:41 +0200 Subject: [PATCH 124/227] add canary 1b recog sis prepare config --- .../canary_aed/configs/canary_1b_recog.py | 27 +++++++++++++++++++ 1 file changed, 27 insertions(+) create mode 100644 users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py diff --git a/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py b/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py new file mode 100644 index 000000000..e50468767 --- /dev/null +++ b/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py @@ -0,0 +1,27 @@ +from sisyphus import * + +from i6_core.datasets.huggingface import DownloadAndPrepareHuggingFaceDatasetJob + +test_sets = ["ami", "earnings22", "gigaspeech"] + + +def download_test_datasets(): + # for downloading gigaspeech, a token is required. I login to huggingface and generate a token and then + # run the command `huggingface-cli login` and paste the token + + for test_set in test_sets: + j = DownloadAndPrepareHuggingFaceDatasetJob( + path="open-asr-leaderboard/datasets-test-only", + name=test_set, + split="test", + time_rqmt=24, + mem_rqmt=4, + cpu_rqmt=4, + mini_task=True, + token=True, + ) + tk.register_output(f"datasets/{test_set}", j.out_dir) + + +def py(): + download_test_datasets() From 0beee4cef76badb04aef6a442be94a9a1e774e64 Mon Sep 17 00:00:00 2001 From: Judyxujj Date: Mon, 10 Jun 2024 01:06:53 +0800 Subject: [PATCH 125/227] add config (#223) Co-authored-by: Jingjing Xu --- .../jointly_train_simple_top_k_layerwise.py | 238 ++++++++++++++ .../jointly_train_simple_top_k_layerwise.py | 300 ++++++++++++++++++ 2 files changed, 538 insertions(+) create mode 100644 users/jxu/experiments/ctc/tedlium2/configs/dynamic_encoder_size/simple_topk_refactored/jointly_train_simple_top_k_layerwise.py create mode 100644 users/jxu/experiments/ctc/tedlium2/pytorch_networks/dynamic_encoder_size/simple_topk_refactored/jointly_train_simple_top_k_layerwise.py diff --git a/users/jxu/experiments/ctc/tedlium2/configs/dynamic_encoder_size/simple_topk_refactored/jointly_train_simple_top_k_layerwise.py b/users/jxu/experiments/ctc/tedlium2/configs/dynamic_encoder_size/simple_topk_refactored/jointly_train_simple_top_k_layerwise.py new file mode 100644 index 000000000..4dff7cf8b --- /dev/null +++ b/users/jxu/experiments/ctc/tedlium2/configs/dynamic_encoder_size/simple_topk_refactored/jointly_train_simple_top_k_layerwise.py @@ -0,0 +1,238 @@ +import functools +from typing import Any, Dict, List, Optional, Union +import copy + +import i6_core.returnn as returnn +import i6_experiments.users.jxu.experiments.ctc.tedlium2.configs.configs_helper as configs_helper +from i6_experiments.users.berger.systems.dataclasses import ReturnnConfigs +from i6_experiments.common.setups.returnn_pytorch.serialization import Collection +from i6_experiments.users.berger.systems.dataclasses import ConfigVariant + +# ********** Constant values ********** + +num_outputs = 79 +num_subepochs = 250 + + +# ********** Settings ********** + +def get_returnn_config( + network: Optional[Dict] = None, + *, + target: Optional[str] = "classes", + num_inputs: Optional[int] = None, + num_outputs: Optional[int] = None, + python_prolog: Optional[Union[List, Dict]] = None, + extern_data_config: bool = False, + extra_python: Optional[List] = None, + extra_config: Optional[Dict] = None, + hash_full_python_code: bool = False, + **kwargs, +) -> returnn.ReturnnConfig: + python_prolog = python_prolog or ["import numpy as np"] + extra_python = extra_python or [] + config_dict: dict[str, Any] = {"target": target} + if num_inputs is not None: + config_dict["num_inputs"] = num_inputs + if num_outputs is not None: + config_dict["num_outputs"] = {target: num_outputs} + if extern_data_config: + config_dict.update( + configs_helper.get_extern_data_config(num_inputs=num_inputs, num_outputs=num_outputs, target=target, + **kwargs) + ) + config_dict.update(configs_helper.get_base_config()) + + if network: + config_dict.update({"network:": network}) + + lrate_config = configs_helper.get_oclr_config(**kwargs) + config_dict.update(lrate_config) + + config_dict.update(configs_helper.get_base_regularization_config(**kwargs)) + + if extra_config: + config_dict.update(extra_config) + + post_config_dict = {} + post_config_dict.update(configs_helper.get_base_post_config(**kwargs)) + + return returnn.ReturnnConfig( + config=config_dict, + post_config=post_config_dict, + hash_full_python_code=hash_full_python_code, + python_prolog=python_prolog, + python_epilog=extra_python, + pprint_kwargs={"sort_dicts": False}, + ) + + +def get_serializer(model_config, variant: ConfigVariant, in_dim: int = 1) -> Collection: + from i6_experiments.users.jxu.experiments.ctc.tedlium2.pytorch_networks.dynamic_encoder_size.simple_topk_with_new_i6_models.joint_train_two_model_simple_top_k_modwise import \ + get_train_serializer, get_recog_serializer, get_prior_serializer + if variant == ConfigVariant.TRAIN: + return get_train_serializer(model_config) + if variant == ConfigVariant.PRIOR: + return get_prior_serializer(model_config) + if variant == ConfigVariant.RECOG: + return get_recog_serializer(model_config) + raise NotImplementedError + + +def returnn_config_generator(train_data_config: dict, dev_data_config: dict, peak_lr: float) -> dict: + from i6_experiments.users.jxu.experiments.ctc.tedlium2.pytorch_networks.dynamic_encoder_size.simple_topk_with_new_i6_models.joint_train_two_model_simple_top_k_modwise import \ + get_default_config_v1 as get_train_config + from i6_experiments.users.jxu.experiments.ctc.tedlium2.pytorch_networks.dynamic_encoder_size.simple_topk_with_new_i6_models.joint_train_two_model_simple_top_k_modwise import \ + get_default_config_v1 as get_recog_config + + extra_config = { + "train": train_data_config, + "dev": dev_data_config, + } + recog_extra_config = copy.deepcopy(extra_config) + recog_extra_config["model_outputs"] = {"classes": {"dim": num_outputs}} + + config_partial = functools.partial( + get_returnn_config, + num_epochs=num_subepochs, + num_inputs=50, + num_outputs=num_outputs, + target="targets", + extern_data_config=True, + grad_noise=0.0, + grad_clip=0.0, + cycle_epoch=110, + initial_lr=peak_lr / 100, + peak_lr=peak_lr, + final_lr=1e-08, + batch_size=15000, + extra_config=extra_config, + ) + + def get_returnn_configs(train_config, recog_config): + return ReturnnConfigs( + train_config=config_partial( + extra_python=[get_serializer(train_config, ConfigVariant.TRAIN)], + extra_config=extra_config), + prior_config=config_partial(extra_python=[get_serializer(recog_config, ConfigVariant.PRIOR)], + extra_config=extra_config), + recog_configs={ + "recog": config_partial(extra_python=[get_serializer(recog_config, ConfigVariant.RECOG)], + extra_config=recog_extra_config)}, + ) + + # ----------------------------- gumbel_scale 0.05 gumble_top_k_dropout_0_3 init tau 0.5 k annealing every 20 sub-epoch --------------------------------------- + + experiments = {} + for k_annealing_step in [25]: + for layer_dropout_stage_1, layer_dropout_stage_2 in [(0, 0.3)]: + layer_dropout_kwargs = {"layer_dropout_stage_1": layer_dropout_stage_1, + "layer_dropout_stage_2": layer_dropout_stage_2} + k_anneal_kwargs = {"k_anneal_num_steps_per_iter": 1400 * k_annealing_step, "k_reduction_per_iter": 4} + network_args = {"layer_dropout_kwargs": layer_dropout_kwargs, + "k_anneal_kwargs": k_anneal_kwargs, "num_layers_set": [24, 48], "recog_num_layers": 48} + + train_config = get_train_config(num_inputs=50, num_outputs=num_outputs, + network_args=network_args) + recog_network_args = copy.deepcopy(network_args) + recog_network_args["recog_num_layers"] = 48 + num_recog_mods_48_recog_config = get_recog_config(num_inputs=50, num_outputs=num_outputs, + network_args=recog_network_args) + recog_network_args["recog_num_layers"] = 24 + num_recog_mods_24_recog_config = get_recog_config(num_inputs=50, num_outputs=num_outputs, + network_args=recog_network_args) + + num_recog_mods_48_experiment_name = f"simple_topk_annealing_step_{k_annealing_step}_6_dropout_{layer_dropout_stage_1}_{layer_dropout_stage_2}_recog_num_mods_48_peak_lr_{peak_lr}" + num_recog_mods_48_experiment_name = num_recog_mods_48_experiment_name.replace(".", "_") + experiments[num_recog_mods_48_experiment_name] = get_returnn_configs(train_config, + num_recog_mods_48_recog_config) + + num_recog_mods_24_experiment_name = f"simple_topk_annealing_step_{k_annealing_step}_6_dropout_{layer_dropout_stage_1}_{layer_dropout_stage_2}_recog_num_mods_24_peak_lr_{peak_lr}" + num_recog_mods_24_experiment_name = num_recog_mods_24_experiment_name.replace(".", "_") + experiments[num_recog_mods_24_experiment_name] = get_returnn_configs(train_config, + num_recog_mods_24_recog_config) + + for k_annealing_step, k_reduction_per_iter in [(19, 4)]: + for layer_dropout_stage_1, layer_dropout_stage_2 in [(0, 0.4)]: + layer_dropout_kwargs = {"layer_dropout_stage_1": layer_dropout_stage_1, + "layer_dropout_stage_2": layer_dropout_stage_2} + k_anneal_kwargs = {"k_anneal_num_steps_per_iter": 1400 * k_annealing_step, + "k_reduction_per_iter": k_reduction_per_iter} + network_args = {"layer_dropout_kwargs": layer_dropout_kwargs, + "k_anneal_kwargs": k_anneal_kwargs, "recog_num_layers": 48, "num_layers_set": [16, 32, 48]} + + train_config = get_train_config(num_inputs=50, num_outputs=num_outputs, + network_args=network_args) + recog_network_args = copy.deepcopy(network_args) + recog_network_args["recog_num_layers"] = 48 + num_recog_mods_48_recog_config = get_recog_config(num_inputs=50, num_outputs=num_outputs, + network_args=recog_network_args) + + recog_network_args["recog_num_layers"] = 32 + num_recog_mods_32_recog_config = get_recog_config(num_inputs=50, num_outputs=num_outputs, + network_args=recog_network_args) + + recog_network_args["recog_num_layers"] = 16 + num_recog_mods_16_recog_config = get_recog_config(num_inputs=50, num_outputs=num_outputs, + network_args=recog_network_args) + + num_recog_mods_48_experiment_name = f"three_models_k_annealing_step_{k_annealing_step}_{32 // k_reduction_per_iter}_dropout_{layer_dropout_stage_1}_{layer_dropout_stage_2}_recog_num_mods_48_peak_lr_{peak_lr}" + num_recog_mods_48_experiment_name = num_recog_mods_48_experiment_name.replace(".", "_") + experiments[num_recog_mods_48_experiment_name] = get_returnn_configs(train_config, + num_recog_mods_48_recog_config) + + num_recog_mods_32_experiment_name = f"three_models_k_annealing_step_{k_annealing_step}_{32 // k_reduction_per_iter}_dropout_{layer_dropout_stage_1}_{layer_dropout_stage_2}_recog_num_mods_32_peak_lr_{peak_lr}" + num_recog_mods_32_experiment_name = num_recog_mods_32_experiment_name.replace(".", "_") + experiments[num_recog_mods_32_experiment_name] = get_returnn_configs(train_config, + num_recog_mods_32_recog_config) + + num_recog_mods_16_experiment_name = f"three_models_k_annealing_step_{k_annealing_step}_{32 // k_reduction_per_iter}_dropout_{layer_dropout_stage_1}_{layer_dropout_stage_2}_recog_num_mods_16_peak_lr_{peak_lr}" + num_recog_mods_16_experiment_name = num_recog_mods_16_experiment_name.replace(".", "_") + experiments[num_recog_mods_16_experiment_name] = get_returnn_configs(train_config, + num_recog_mods_16_recog_config) + + + for k_annealing_step, k_reduction_per_iter in [(50, 12), (4.1, 1)]: + for layer_dropout_stage_1, layer_dropout_stage_2 in [(0, 0.3), (0.1, 0.3)]: + layer_dropout_kwargs = {"layer_dropout_stage_1": layer_dropout_stage_1, + "layer_dropout_stage_2": layer_dropout_stage_2} + k_anneal_kwargs = {"k_anneal_num_steps_per_iter": 1400 * k_annealing_step, "k_reduction_per_iter": k_reduction_per_iter} + network_args = {"layer_dropout_kwargs": layer_dropout_kwargs, + "k_anneal_kwargs": k_anneal_kwargs, "recog_num_layers": 48, "num_layers_set": [12, 24, 36, 48]} + + train_config = get_train_config(num_inputs=50, num_outputs=num_outputs, + network_args=network_args) + recog_network_args = copy.deepcopy(network_args) + recog_network_args["recog_num_layers"] = 48 + num_recog_mods_48_recog_config = get_recog_config(num_inputs=50, num_outputs=num_outputs, + network_args=recog_network_args) + + recog_network_args["recog_num_layers"] = 36 + num_recog_mods_36_recog_config = get_recog_config(num_inputs=50, num_outputs=num_outputs, + network_args=recog_network_args) + + recog_network_args["recog_num_layers"] = 24 + num_recog_mods_24_recog_config = get_recog_config(num_inputs=50, num_outputs=num_outputs, + network_args=recog_network_args) + + recog_network_args["recog_num_layers"] = 12 + num_recog_mods_12_recog_config = get_recog_config(num_inputs=50, num_outputs=num_outputs, + network_args=recog_network_args) + + num_recog_mods_48_experiment_name = f"four_models_k_annealing_step_{k_annealing_step}_{36//k_reduction_per_iter}_dropout_{layer_dropout_stage_1}_{layer_dropout_stage_2}_recog_num_mods_48_peak_lr_{peak_lr}" + num_recog_mods_48_experiment_name = num_recog_mods_48_experiment_name.replace(".", "_") + experiments[num_recog_mods_48_experiment_name] = get_returnn_configs(train_config, num_recog_mods_48_recog_config) + + num_recog_mods_36_experiment_name = f"four_models_k_annealing_step_{k_annealing_step}_{36//k_reduction_per_iter}_dropout_{layer_dropout_stage_1}_{layer_dropout_stage_2}_recog_num_mods_36_peak_lr_{peak_lr}" + num_recog_mods_36_experiment_name = num_recog_mods_36_experiment_name.replace(".", "_") + experiments[num_recog_mods_36_experiment_name] = get_returnn_configs(train_config, num_recog_mods_36_recog_config) + + num_recog_mods_24_experiment_name = f"four_models_k_annealing_step_{k_annealing_step}_{36//k_reduction_per_iter}_dropout_{layer_dropout_stage_1}_{layer_dropout_stage_2}_recog_num_mods_24_peak_lr_{peak_lr}" + num_recog_mods_24_experiment_name = num_recog_mods_24_experiment_name.replace(".", "_") + experiments[num_recog_mods_24_experiment_name] = get_returnn_configs(train_config, num_recog_mods_24_recog_config) + + num_recog_mods_12_experiment_name = f"four_models_k_annealing_step_{k_annealing_step}_{36//k_reduction_per_iter}_dropout_{layer_dropout_stage_1}_{layer_dropout_stage_2}_recog_num_mods_12_peak_lr_{peak_lr}" + num_recog_mods_12_experiment_name = num_recog_mods_12_experiment_name.replace(".", "_") + experiments[num_recog_mods_12_experiment_name] = get_returnn_configs(train_config, num_recog_mods_12_recog_config) + + return experiments diff --git a/users/jxu/experiments/ctc/tedlium2/pytorch_networks/dynamic_encoder_size/simple_topk_refactored/jointly_train_simple_top_k_layerwise.py b/users/jxu/experiments/ctc/tedlium2/pytorch_networks/dynamic_encoder_size/simple_topk_refactored/jointly_train_simple_top_k_layerwise.py new file mode 100644 index 000000000..af58af0a4 --- /dev/null +++ b/users/jxu/experiments/ctc/tedlium2/pytorch_networks/dynamic_encoder_size/simple_topk_refactored/jointly_train_simple_top_k_layerwise.py @@ -0,0 +1,300 @@ +from dataclasses import dataclass +from typing import Optional +from collections import OrderedDict + +import torch +from torch import nn +from typing import Tuple +from returnn.tensor.tensor_dict import TensorDict +import returnn.frontend as rf +import numpy as np + +from i6_models.parts.frontend.vgg_act import VGG4LayerActFrontendV1, VGG4LayerActFrontendV1Config +from i6_models.parts.conformer.convolution import ConformerConvolutionV1Config +from i6_models.parts.conformer.norm import LayerNormNC +from i6_models.parts.conformer.mhsa import ConformerMHSAV1Config +from i6_models.parts.conformer.feedforward import ConformerPositionwiseFeedForwardV1Config +from i6_models.assemblies.conformer_with_dynamic_model_size.selection_with_simple_top_k import ( + ConformerBlockConfig, + ConformerEncoderConfig, + ConformerEncoder +) +from i6_models.primitives.specaugment import specaugment_v1_by_length +from i6_models.config import ModelConfiguration, ModuleFactoryV1 + +from i6_experiments.users.berger.pytorch.models.util import lengths_to_padding_mask +from i6_experiments.common.setups.returnn_pytorch.serialization import Collection +from i6_experiments.users.berger.pytorch.serializers.basic import ( + get_basic_pt_network_serializer, +) + +from i6_experiments.common.setups.serialization import Import, CodeFromFunction, NonhashedCode + + +@dataclass +class ConformerCTCConfig(ModelConfiguration): + conformer_cfg: ConformerEncoderConfig + target_size: int + recog_num_layers: int + k_anneal_kwargs: dict + + +class ConformerCTCModel(torch.nn.Module): + def __init__(self, step: int, cfg: ConformerCTCConfig, **kwargs): + super().__init__() + self.conformer = ConformerEncoder(cfg.conformer_cfg) + self.final_linear_list = torch.nn.ModuleList( + [nn.Linear(cfg.conformer_cfg.block_cfg.ff_cfg.input_dim, cfg.target_size) for _ in + range(len(self.conformer.num_layers_set))]) + self.small_model_layers = None + self.recog_num_layers = cfg.recog_num_layers + self.conformer.recog_num_layers = self.recog_num_layers + self.k_anneal_kwargs = cfg.k_anneal_kwargs + self.export_mode = False + + def forward( + self, + audio_features: torch.Tensor, + audio_features_len: Optional[torch.Tensor] = None, + global_train_step: int = 0 + ): + if self.training: + x = specaugment_v1_by_length(audio_features, + time_min_num_masks=2, + time_max_mask_per_n_frames=25, + time_mask_max_size=20, + freq_min_num_masks=2, + freq_mask_max_size=5, + freq_max_num_masks=10) # [B, T, F] + else: + x = audio_features + sequence_mask = lengths_to_padding_mask(audio_features_len) + conformer_out_list, sequence_mask = self.conformer(x, sequence_mask, global_train_step, + self.k_anneal_kwargs) # [B, T, F] + + log_probs_list = [] + for i in range(len(conformer_out_list)): + logits = self.final_linear_list[i](conformer_out_list[i]) # [B, T, F] + log_probs = torch.log_softmax(logits, dim=2) + log_probs_list.append(log_probs) + + if self.training: + return log_probs_list, sequence_mask + + idx = self.conformer.num_layers_set.index(self.recog_num_layers) + return log_probs_list[idx] + +def get_default_config_v1(num_inputs: int, num_outputs: int, network_args: dict) -> ConformerCTCConfig: + dropout = 0.2 if "dropout" not in network_args else network_args["dropout"] + num_att_heads = 6 if "num_att_heads" not in network_args else network_args["num_att_heads"] + att_weights_dropout = 0.1 if "att_weights_dropout" not in network_args else network_args["att_weights_dropout"] + num_layers = 12 if "num_layers" not in network_args else network_args["num_layers"] + kernel_size = 31 if "kernel_size" not in network_args else network_args["kernel_size"] + num_layers_set = network_args["num_layers_set"] + layer_dropout_kwargs = network_args["layer_dropout_kwargs"] + recog_num_layers = network_args["recog_num_layers"] + k_anneal_kwargs = network_args["k_anneal_kwargs"] + + frontend_cfg = VGG4LayerActFrontendV1Config( + in_features=num_inputs, + conv1_channels=32, + conv2_channels=64, + conv3_channels=64, + conv4_channels=32, + conv_kernel_size=(3, 3), + conv_padding=None, + pool1_kernel_size=(2, 1), + pool1_stride=(2, 1), + pool1_padding=None, + pool2_kernel_size=(2, 1), + pool2_stride=(2, 1), + pool2_padding=None, + activation=torch.nn.ReLU(), + out_features=384, + ) + + frontend = ModuleFactoryV1(VGG4LayerActFrontendV1, frontend_cfg) + + ff_cfg = ConformerPositionwiseFeedForwardV1Config( + input_dim=384, + hidden_dim=1536, + dropout=dropout, + activation=torch.nn.SiLU(), + ) + + mhsa_cfg = ConformerMHSAV1Config( + input_dim=384, + num_att_heads=num_att_heads, + att_weights_dropout=att_weights_dropout, + dropout=dropout, + ) + + conv_cfg = ConformerConvolutionV1Config( + channels=384, + kernel_size=kernel_size, + dropout=dropout, + activation=torch.nn.SiLU(), + norm=LayerNormNC(384), + ) + + block_cfg = ConformerBlockConfig( + ff_cfg=ff_cfg, + mhsa_cfg=mhsa_cfg, + conv_cfg=conv_cfg, + layer_dropout=layer_dropout_kwargs["layer_dropout_stage_1"], + modules=["ff", "conv", "mhsa", "ff"], + scales=[0.5, 1.0, 1.0, 0.5] + ) + + + conformer_cfg = ConformerEncoderConfig( + num_layers=num_layers, + frontend=frontend, + block_cfg=block_cfg, + num_layers_set=num_layers_set, + layer_dropout_kwargs=layer_dropout_kwargs + ) + + return ConformerCTCConfig( + conformer_cfg=conformer_cfg, + target_size=num_outputs, + recog_num_layers=recog_num_layers, + k_anneal_kwargs=k_anneal_kwargs + ) + + +def train_step(*, model: torch.nn.Module, extern_data: TensorDict, global_train_step, **kwargs): + audio_features = extern_data["data"].raw_tensor + audio_features_len = extern_data["data"].dims[1].dyn_size_ext.raw_tensor + + targets = extern_data["targets"].raw_tensor.long() + targets_len = extern_data["targets"].dims[1].dyn_size_ext.raw_tensor + + model.train() + + log_probs_list, sequence_mask = model( + audio_features=audio_features, + audio_features_len=audio_features_len.to("cuda"), + global_train_step=global_train_step + ) + sequence_lengths = torch.sum(sequence_mask.type(torch.int32), dim=1) + + k_anneal_num_steps_per_iter = model.k_anneal_kwargs["k_anneal_num_steps_per_iter"] + k_reduction_per_iter = model.k_anneal_kwargs["k_reduction_per_iter"] + k_anneal_num_iters = (4 * len(model.conformer.module_list) - model.conformer.min_k) / k_reduction_per_iter + + loss_layers = model.conformer.num_layers_set + + # stage 1 : jointly train the largest and smallest model + if global_train_step <= k_anneal_num_steps_per_iter * k_anneal_num_iters: + loss_scales = [0.3, 1] + for i in [0, -1]: + log_probs = torch.transpose(log_probs_list[i], 0, 1) # [T, B, F] + loss = torch.nn.functional.ctc_loss( + log_probs=log_probs, + targets=targets, + input_lengths=sequence_lengths, + target_lengths=targets_len, + blank=0, + reduction="sum", + zero_infinity=True, + ) + + loss /= torch.sum(sequence_lengths) + rf.get_run_ctx().mark_as_loss(name=f"CTC_{loss_layers[i]}", loss=loss, scale=loss_scales[i]) + + # stage 2 : jointly train all models efficiently with sandwich rules + else: + if len(model.conformer.num_layers_set) <= 3: + loss_scales = [0.3]*(len(model.conformer.num_layers_set)-1) + [1] + else: + loss_scales = [0.3] + [0]*(len(model.conformer.num_layers_set)-2) + [1] + loss_scales[model.conformer.random_idx] = 0.3 + print(f"random_idx {model.conformer.random_idx}") + + for i in range(len(log_probs_list)): + log_probs = torch.transpose(log_probs_list[i], 0, 1) # [T, B, F] + + loss = torch.nn.functional.ctc_loss( + log_probs=log_probs, + targets=targets, + input_lengths=sequence_lengths, + target_lengths=targets_len, + blank=0, + reduction="sum", + zero_infinity=True, + ) + + loss /= torch.sum(sequence_lengths) + rf.get_run_ctx().mark_as_loss(name=f"CTC_{loss_layers[i]}", loss=loss, scale=loss_scales[i]) + + +def forward_step(*, model: torch.nn.Module, extern_data: TensorDict, **kwargs): + audio_features = extern_data["data"].raw_tensor + audio_features_len = extern_data["data"].dims[1].dyn_size_ext.raw_tensor + log_probs = model( + audio_features=audio_features, + audio_features_len=audio_features_len.to("cuda"), + ) # [B, T, F] + rf.get_run_ctx().mark_as_output(log_probs, name="log_probs") + + +def get_prior_serializer( + model_config: ConformerCTCConfig, +) -> Collection: + pytorch_package = "i6_experiments.users.berger.pytorch" + + return get_basic_pt_network_serializer( + module_import_path=f"{__name__}.{ConformerCTCModel.__name__}", + model_config=model_config, + additional_serializer_objects=[ + Import(f"{__name__}.forward_step"), + Import(f"{pytorch_package}.forward.prior_callback.ComputePriorCallback", import_as="forward_callback"), + ], + ) + + +def export(*, model: torch.nn.Module, model_filename: str): + model.export_mode = True + dummy_data = torch.randn(1, 30, 50, device="cpu") + dummy_data_len = torch.tensor([30], dtype=torch.int32) + torch.onnx.export( + model=model.eval(), + args=(dummy_data, dummy_data_len), + f=model_filename, + verbose=True, + input_names=["data", "data_len"], + output_names=["classes"], + opset_version=17, + dynamic_axes={ + # dict value: manually named axes + "data": {0: "batch", 1: "time"}, + "data_len": {0: "batch"}, + "targets": {0: "batch", 1: "time"}, + }, + ) + + +def get_recog_serializer( + model_config: ConformerCTCConfig, +) -> Collection: + pytorch_package = __package__.rpartition(".")[0] + return get_basic_pt_network_serializer( + module_import_path=f"{__name__}.{ConformerCTCModel.__name__}", + model_config=model_config, + additional_serializer_objects=[ + Import(f"{__name__}.export"), + ], + ) + + +def get_train_serializer( + model_config: ConformerCTCConfig, +) -> Collection: + return get_basic_pt_network_serializer( + module_import_path=f"{__name__}.{ConformerCTCModel.__name__}", + model_config=model_config, + additional_serializer_objects=[ + Import(f"{__name__}.train_step"), + ], + ) From 4cc3c40d0c7e3880c77cacb994f978090a632804 Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Mon, 10 Jun 2024 09:17:26 +0200 Subject: [PATCH 126/227] more --- users/zeyer/experiments/exp2024_04_23_baselines/ctc.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py index c65c7ffde..e4ef939e8 100644 --- a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py +++ b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py @@ -193,8 +193,10 @@ def py(): feature_stats = get_librispeech_log_mel_stats(_log_mel_feature_dim) # Test different feature normalization schemes. + # Note: It seems the diff between dev-other and test-other is less here, probably du to the normalization. for name, model_opts in { - None: None, + None: None, # {"dev-clean": 3.69, "dev-other": 6.99, "test-clean": 3.83, "test-other": 7.32} + # featBN: {"dev-clean": 3.63, "dev-other": 6.96, "test-clean": 3.82, "test-other": 7.15} "featBN": {"feature_batch_norm": True}, # batch norm "featNorm": {"feature_norm": True}, # normalize (on sequence level) "featGN": {"feature_stats": {"mean": feature_stats.mean, "std_dev": feature_stats.std_dev}}, # global norm From 3e688ba34cc734c21553e745c3c3194af61fc1b0 Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Mon, 10 Jun 2024 11:58:42 +0000 Subject: [PATCH 127/227] add nemo model download job --- .../canary_aed/configs/canary_1b_recog.py | 26 ++++++++++++--- .../experiments/canary_aed/nemo/download.py | 33 +++++++++++++++++++ 2 files changed, 54 insertions(+), 5 deletions(-) create mode 100644 users/zeineldeen/experiments/canary_aed/nemo/download.py diff --git a/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py b/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py index e50468767..1ffce34a6 100644 --- a/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py +++ b/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py @@ -1,18 +1,24 @@ +from typing import Dict + from sisyphus import * from i6_core.datasets.huggingface import DownloadAndPrepareHuggingFaceDatasetJob +from i6_experiments.users.zeineldeen.experiments.canary_aed.nemo.download import DownloadNemoModel -test_sets = ["ami", "earnings22", "gigaspeech"] +TEST_DATASETS = ["ami", "earnings22", "gigaspeech"] +MODEL_ID = "nvidia/canary-1b" -def download_test_datasets(): +def download_test_datasets() -> Dict[str, tk.Path]: # for downloading gigaspeech, a token is required. I login to huggingface and generate a token and then # run the command `huggingface-cli login` and paste the token - for test_set in test_sets: + out_dirs = {} + + for test_dataset in TEST_DATASETS: j = DownloadAndPrepareHuggingFaceDatasetJob( path="open-asr-leaderboard/datasets-test-only", - name=test_set, + name=test_dataset, split="test", time_rqmt=24, mem_rqmt=4, @@ -20,8 +26,18 @@ def download_test_datasets(): mini_task=True, token=True, ) - tk.register_output(f"datasets/{test_set}", j.out_dir) + out_dirs[test_dataset] = j.out_dir + tk.register_output(f"datasets/{test_dataset}", j.out_dir) + + return out_dirs + + +def download_canary_1b_model(): + j = DownloadNemoModel(model_id=MODEL_ID, device=-1) + tk.register_output("canary_1b_nemo_model", j.out_model_dir) + return j.out_model_dir def py(): download_test_datasets() + download_canary_1b_model() diff --git a/users/zeineldeen/experiments/canary_aed/nemo/download.py b/users/zeineldeen/experiments/canary_aed/nemo/download.py new file mode 100644 index 000000000..058991135 --- /dev/null +++ b/users/zeineldeen/experiments/canary_aed/nemo/download.py @@ -0,0 +1,33 @@ +from sisyphus import * + +import os + + +class DownloadNemoModel(Job): + def __init__(self, model_id: str, device: int): + self.model_id = model_id + + import torch + + if device >= 0: + self.device = torch.device(f"cuda:{device}") + else: + self.device = torch.device("cpu") + + self.out_model_dir = self.output_path("nemo_model", directory=True) + + def tasks(self): + yield Task("run", mini_task=True) + + def run(self): + # the model by default will be downloaded to huggingface cache + # this can be overridden by setting the HF_HUB_CACHE environment variable: + # https://github.com/huggingface/huggingface_hub/blob/main/src/huggingface_hub/file_download.py#L1171 + # https://github.com/huggingface/huggingface_hub/blob/main/src/huggingface_hub/constants.py#L123 + + for env_var in ["HUGGINGFACE_HUB_CACHE", "HF_HUB_CACHE", "NEMO_CACHE_DIR"]: + os.environ[env_var] = self.out_model_dir.get_path() + + from nemo.collections.asr.models import ASRModel + + ASRModel.from_pretrained(self.model_id, map_location=self.device) From f457f63df93de24dc49f2ac08cf89fc120ff404d Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Mon, 10 Jun 2024 12:33:57 +0000 Subject: [PATCH 128/227] add nemo search job --- .../canary_aed/configs/canary_1b_recog.py | 22 +++++- .../experiments/canary_aed/nemo/search.py | 67 +++++++++++++++++++ 2 files changed, 86 insertions(+), 3 deletions(-) create mode 100644 users/zeineldeen/experiments/canary_aed/nemo/search.py diff --git a/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py b/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py index 1ffce34a6..f0b9570b0 100644 --- a/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py +++ b/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py @@ -4,6 +4,7 @@ from i6_core.datasets.huggingface import DownloadAndPrepareHuggingFaceDatasetJob from i6_experiments.users.zeineldeen.experiments.canary_aed.nemo.download import DownloadNemoModel +from i6_experiments.users.zeineldeen.experiments.canary_aed.nemo.search import SearchJob TEST_DATASETS = ["ami", "earnings22", "gigaspeech"] MODEL_ID = "nvidia/canary-1b" @@ -32,12 +33,27 @@ def download_test_datasets() -> Dict[str, tk.Path]: return out_dirs -def download_canary_1b_model(): +def download_canary_1b_model() -> tk.Path: j = DownloadNemoModel(model_id=MODEL_ID, device=-1) tk.register_output("canary_1b_nemo_model", j.out_model_dir) return j.out_model_dir def py(): - download_test_datasets() - download_canary_1b_model() + dataset_paths = download_test_datasets() + model_path = download_canary_1b_model() + + search_script = tk.Path( + "/u/zeineldeen/setups/ubuntu_22_setups/2024-06-07--canary-aed/recipe/i6_experiments/users/zeineldeen/experiments/canary_aed/nemo/run_eval.py", + hash_overwrite="run_eval_v1", + ) + + search_job = SearchJob( + model_path=model_path, + dataset_path=dataset_paths["ami"], + search_script=search_script, + device="gpu", + time_rqmt=4, + mem_rqmt=4, + cpu_rqmt=2, + ) diff --git a/users/zeineldeen/experiments/canary_aed/nemo/search.py b/users/zeineldeen/experiments/canary_aed/nemo/search.py new file mode 100644 index 000000000..e5a97ee15 --- /dev/null +++ b/users/zeineldeen/experiments/canary_aed/nemo/search.py @@ -0,0 +1,67 @@ +from sisyphus import * +import subprocess as sp +import os + +from typing import Dict, Any, Optional + +from i6_core.util import create_executable + + +class SearchJob(Job): + def __init__( + self, + model_path: tk.Path, + dataset_path: tk.Path, + search_script: tk.Path, + search_args: Optional[Dict[str, Any]] = None, + python_exe: Optional[tk.Path] = None, + device: str = "gpu", + time_rqmt: float = 4, + mem_rqmt: int = 4, + cpu_rqmt: int = 2, + ): + self.model_path = model_path + self.dataset_path = dataset_path + self.search_script = search_script + self.search_args = search_args + self.python_exe = python_exe if python_exe is not None else "python3" + self.device = device + self.rqmt = { + "gpu": 1 if device == "gpu" else 0, + "cpu": cpu_rqmt, + "mem": mem_rqmt, + "time": time_rqmt, + } + + self.out_wer = self.output_path("wer") + + def tasks(self): + yield Task("create_files", mini_task=True) + yield Task("run", rqmt=self.rqmt) + + def get_cmd(self): + cmd = [ + self.python_exe.get_path(), + self.search_script.get_path(), + "--model_path", + self.model_path.get_path(), + "--dataset_path", + self.dataset_path, + "--device", + 0 if self.device == "gpu" else -1, + ] + for k, v in self.search_args.items(): + if k == "device": + continue # ignored. this is only set via job parameter + cmd.append(f"--{k}") + cmd.append(str(v)) + return cmd + + def create_files(self): + create_executable("run.sh", self.get_cmd()) + + def run(self): + env = os.environ.copy() + env["OMP_NUM_THREADS"] = str(self.rqmt["cpu"]) + env["MKL_NUM_THREADS"] = str(self.rqmt["cpu"]) + sp.check_call(self.get_cmd(), env=env) From 1eebd00cbe5ed414af712509b2fd909683cf73d7 Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Mon, 10 Jun 2024 12:36:13 +0000 Subject: [PATCH 129/227] add custom hash --- .../zeineldeen/experiments/canary_aed/nemo/search.py | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/users/zeineldeen/experiments/canary_aed/nemo/search.py b/users/zeineldeen/experiments/canary_aed/nemo/search.py index e5a97ee15..3e5705490 100644 --- a/users/zeineldeen/experiments/canary_aed/nemo/search.py +++ b/users/zeineldeen/experiments/canary_aed/nemo/search.py @@ -65,3 +65,14 @@ def run(self): env["OMP_NUM_THREADS"] = str(self.rqmt["cpu"]) env["MKL_NUM_THREADS"] = str(self.rqmt["cpu"]) sp.check_call(self.get_cmd(), env=env) + + @classmethod + def hash(cls, kwargs): + d = { + "model_path": kwargs["model_path"], + "dataset_path": kwargs["dataset_path"], + "search_script": kwargs["search_script"], + "search_args": kwargs["search_args"], + "python_exe": kwargs["python_exe"], + } + return super().hash(d) From 7db6937792225d643d88f4064ca1e81099de4023 Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Mon, 10 Jun 2024 12:38:49 +0000 Subject: [PATCH 130/227] fix --- .../experiments/canary_aed/configs/canary_1b_recog.py | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py b/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py index f0b9570b0..2101e086c 100644 --- a/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py +++ b/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py @@ -47,13 +47,19 @@ def py(): "/u/zeineldeen/setups/ubuntu_22_setups/2024-06-07--canary-aed/recipe/i6_experiments/users/zeineldeen/experiments/canary_aed/nemo/run_eval.py", hash_overwrite="run_eval_v1", ) + python_exe = tk.Path( + "/work/asr4/zeineldeen/setups-data/ubuntu_22_setups/2024-06-07--canary-aed/nemo_venv/bin/python3" + ) search_job = SearchJob( model_path=model_path, dataset_path=dataset_paths["ami"], search_script=search_script, + python_exe=python_exe, device="gpu", time_rqmt=4, mem_rqmt=4, cpu_rqmt=2, ) + search_job.add_alias("canary_1b_ami") + tk.register_output("canary_1b_ami/wer", search_job.out_wer) From 88c4d966fe7c131b4180d7e40b821a5faae55823 Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Mon, 10 Jun 2024 12:54:00 +0000 Subject: [PATCH 131/227] add nemo search --- .../canary_aed/configs/canary_1b_recog.py | 3 + .../experiments/canary_aed/nemo/run_eval.py | 198 ++++++++++++++++++ .../experiments/canary_aed/nemo/search.py | 15 ++ 3 files changed, 216 insertions(+) create mode 100644 users/zeineldeen/experiments/canary_aed/nemo/run_eval.py diff --git a/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py b/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py index 2101e086c..f218e5cd7 100644 --- a/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py +++ b/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py @@ -52,8 +52,11 @@ def py(): ) search_job = SearchJob( + model_id=MODEL_ID, model_path=model_path, dataset_path=dataset_paths["ami"], + dataset_name="ami", + split="test", search_script=search_script, python_exe=python_exe, device="gpu", diff --git a/users/zeineldeen/experiments/canary_aed/nemo/run_eval.py b/users/zeineldeen/experiments/canary_aed/nemo/run_eval.py new file mode 100644 index 000000000..a46ad6263 --- /dev/null +++ b/users/zeineldeen/experiments/canary_aed/nemo/run_eval.py @@ -0,0 +1,198 @@ +""" +Adapted from here: https://github.com/huggingface/open_asr_leaderboard/blob/5c03c1f85a84ab7a991dcc1b3f14905ec6d632c9/nemo_asr/run_eval.py +""" +import argparse + +import os +import sys + +sys.path.append("/u/zeineldeen/setups/ubuntu_22_setups/2024-06-07--canary-aed/recipe/open_asr_leaderboard/normalizer") + +import shutil +import torch +import evaluate +import soundfile + +from tqdm import tqdm +from normalizer import data_utils + +from nemo.collections.asr.models import ASRModel + +DATA_CACHE_DIR = "/var/tmp/audio_cache" + +wer_metric = evaluate.load("wer") + + +def dataset_iterator(dataset): + for i, item in enumerate(dataset): + yield { + **item["audio"], + "reference": item["norm_text"], + "audio_filename": f"file_{i}", + "sample_rate": 16_000, + "sample_id": i, + } + + +def write_audio(buffer, cache_prefix) -> list: + cache_dir = os.path.join(DATA_CACHE_DIR, cache_prefix) + + if os.path.exists(cache_dir): + shutil.rmtree(cache_dir, ignore_errors=True) + + os.makedirs(cache_dir) + + data_paths = [] + for idx, data in enumerate(buffer): + fn = os.path.basename(data["audio_filename"]) + fn = os.path.splitext(fn)[0] + path = os.path.join(cache_dir, f"{idx}_{fn}.wav") + data_paths.append(path) + + soundfile.write(path, data["array"], samplerate=data["sample_rate"]) + + return data_paths + + +def pack_results(results: list, buffer, transcriptions): + for sample, transcript in zip(buffer, transcriptions): + result = {"reference": sample["reference"], "pred_text": transcript} + results.append(result) + return results + + +def buffer_audio_and_transcribe( + model: ASRModel, dataset, batch_size: int, pnc: bool, cache_prefix: str, verbose: bool = True +): + buffer = [] + results = [] + for sample in tqdm(dataset_iterator(dataset), desc="Evaluating: Sample id", unit="", disable=not verbose): + buffer.append(sample) + + if len(buffer) == batch_size: + filepaths = write_audio(buffer, cache_prefix) + + if pnc is not None: + transcriptions = model.transcribe(filepaths, batch_size=batch_size, pnc=False, verbose=False) + else: + transcriptions = model.transcribe(filepaths, batch_size=batch_size, verbose=False) + # if transcriptions form a tuple (from RNNT), extract just "best" hypothesis + if type(transcriptions) == tuple and len(transcriptions) == 2: + transcriptions = transcriptions[0] + results = pack_results(results, buffer, transcriptions) + buffer.clear() + + if len(buffer) > 0: + filepaths = write_audio(buffer, cache_prefix) + if pnc is not None: + transcriptions = model.transcribe(filepaths, batch_size=batch_size, pnc=False, verbose=False) + else: + transcriptions = model.transcribe(filepaths, batch_size=batch_size, verbose=False) + # if transcriptions form a tuple (from RNNT), extract just "best" hypothesis + if type(transcriptions) == tuple and len(transcriptions) == 2: + transcriptions = transcriptions[0] + results = pack_results(results, buffer, transcriptions) + buffer.clear() + + # Delete temp cache dir + if os.path.exists(DATA_CACHE_DIR): + shutil.rmtree(DATA_CACHE_DIR) + + return results + + +def main(args): + if args.device >= 0: + device = torch.device(f"cuda:{args.device}") + else: + device = torch.device("cpu") + + asr_model = ASRModel.restore_from(args.model_path, map_location=device) + asr_model.freeze() + + from datasets import load_dataset + + # download model is defautl to REUSE_DATASET_IF_EXISTS which means it does not download data again + dataset = load_dataset(args.dataset_path) + + if args.max_eval_samples is not None and args.max_eval_samples > 0: + print(f"Subsampling dataset to first {args.max_eval_samples} samples !") + dataset = dataset.take(args.max_eval_samples) + + dataset = data_utils.prepare_data(dataset) + + predictions = [] + references = [] + + # run streamed inference + cache_prefix = ( + f"{args.model_id.replace('/', '-')}-{args.dataset_path.replace('/', '')}-" + f"{args.dataset.replace('/', '-')}-{args.split}" + ) + results = buffer_audio_and_transcribe(asr_model, dataset, args.batch_size, args.pnc, cache_prefix, verbose=True) + for sample in results: + predictions.append(data_utils.normalizer(sample["pred_text"])) + references.append(sample["reference"]) + + # Write manifest results + manifest_path = data_utils.write_manifest( + references, predictions, args.model_id, args.dataset_path, args.dataset, args.split + ) + print("Results saved at path:", os.path.abspath(manifest_path)) + + wer = wer_metric.compute(references=references, predictions=predictions) + wer = round(100 * wer, 2) + + print("WER:", wer, "%") + + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + + parser.add_argument("--model_id", type=str, required=True, help="Model ID.") + + parser.add_argument( + "--model_path", + type=str, + required=True, + help="Path to nemo model.", + ) + + parser.add_argument("--dataset_path", type=str, required=True, help="Dataset path.") + parser.add_argument("--dataset", type=str, required=True, help="Dataset name.") + parser.add_argument("--split", type=str, required=True, help="Dataset split.") + + parser.add_argument( + "--device", + type=int, + default=-1, + help="The device to run the pipeline on. -1 for CPU (default), 0 for the first GPU and so on.", + ) + parser.add_argument( + "--batch_size", + type=int, + default=32, + help="Number of samples to go through each streamed batch.", + ) + parser.add_argument( + "--max_eval_samples", + type=int, + default=None, + help="Number of samples to be evaluated. Put a lower number e.g. 64 for testing this script.", + ) + parser.add_argument( + "--pnc", + type=bool, + default=None, + help="flag to indicate inferene in pnc mode for models that support punctuation and capitalization", + ) + parser.add_argument( + "--no-streaming", + dest="streaming", + action="store_false", + help="Choose whether you'd like to download the entire dataset or stream it during the evaluation.", + ) + args = parser.parse_args() + parser.set_defaults(streaming=True) + + main(args) diff --git a/users/zeineldeen/experiments/canary_aed/nemo/search.py b/users/zeineldeen/experiments/canary_aed/nemo/search.py index 3e5705490..5203b5c5b 100644 --- a/users/zeineldeen/experiments/canary_aed/nemo/search.py +++ b/users/zeineldeen/experiments/canary_aed/nemo/search.py @@ -10,8 +10,11 @@ class SearchJob(Job): def __init__( self, + model_id: str, model_path: tk.Path, dataset_path: tk.Path, + dataset_name: str, + split: str, search_script: tk.Path, search_args: Optional[Dict[str, Any]] = None, python_exe: Optional[tk.Path] = None, @@ -20,8 +23,11 @@ def __init__( mem_rqmt: int = 4, cpu_rqmt: int = 2, ): + self.model_id = model_id self.model_path = model_path self.dataset_path = dataset_path + self.dataset_name = dataset_name + self.split = split self.search_script = search_script self.search_args = search_args self.python_exe = python_exe if python_exe is not None else "python3" @@ -43,10 +49,16 @@ def get_cmd(self): cmd = [ self.python_exe.get_path(), self.search_script.get_path(), + "--model_id", + self.model_id, "--model_path", self.model_path.get_path(), "--dataset_path", self.dataset_path, + "--dataset", + self.dataset_name, + "--split", + self.split, "--device", 0 if self.device == "gpu" else -1, ] @@ -69,8 +81,11 @@ def run(self): @classmethod def hash(cls, kwargs): d = { + "model_id": kwargs["model_id"], "model_path": kwargs["model_path"], "dataset_path": kwargs["dataset_path"], + "dataset_name": kwargs["dataset_name"], + "split": kwargs["split"], "search_script": kwargs["search_script"], "search_args": kwargs["search_args"], "python_exe": kwargs["python_exe"], From a885383bc5ab2331ad79e14e83a356a054270098 Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Mon, 10 Jun 2024 13:04:22 +0000 Subject: [PATCH 132/227] first version of nemo search --- .../experiments/canary_aed/configs/canary_1b_recog.py | 7 ++++++- users/zeineldeen/experiments/canary_aed/nemo/search.py | 6 +++--- 2 files changed, 9 insertions(+), 4 deletions(-) diff --git a/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py b/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py index f218e5cd7..f4998cf9d 100644 --- a/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py +++ b/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py @@ -36,7 +36,12 @@ def download_test_datasets() -> Dict[str, tk.Path]: def download_canary_1b_model() -> tk.Path: j = DownloadNemoModel(model_id=MODEL_ID, device=-1) tk.register_output("canary_1b_nemo_model", j.out_model_dir) - return j.out_model_dir + # return j.out_model_dir + # TODO: let the job returns directly the model path instead + return tk.Path( + j.out_model_dir.get_path() + + "/models--nvidia--canary-1b/snapshots/dd32c0c709e2bfc79f583e16b9df4b3a160f7e86/canary-1b.nemo" + ) def py(): diff --git a/users/zeineldeen/experiments/canary_aed/nemo/search.py b/users/zeineldeen/experiments/canary_aed/nemo/search.py index 5203b5c5b..0e30dcb82 100644 --- a/users/zeineldeen/experiments/canary_aed/nemo/search.py +++ b/users/zeineldeen/experiments/canary_aed/nemo/search.py @@ -29,7 +29,7 @@ def __init__( self.dataset_name = dataset_name self.split = split self.search_script = search_script - self.search_args = search_args + self.search_args = search_args if search_args is not None else {} self.python_exe = python_exe if python_exe is not None else "python3" self.device = device self.rqmt = { @@ -54,13 +54,13 @@ def get_cmd(self): "--model_path", self.model_path.get_path(), "--dataset_path", - self.dataset_path, + self.dataset_path.get_path(), "--dataset", self.dataset_name, "--split", self.split, "--device", - 0 if self.device == "gpu" else -1, + "0" if self.device == "gpu" else "-1", ] for k, v in self.search_args.items(): if k == "device": From 20d50b9102e947972059510849db608e142f7918 Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Mon, 10 Jun 2024 13:14:02 +0000 Subject: [PATCH 133/227] better --- users/zeineldeen/experiments/canary_aed/nemo/search.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/users/zeineldeen/experiments/canary_aed/nemo/search.py b/users/zeineldeen/experiments/canary_aed/nemo/search.py index 0e30dcb82..d1bba5633 100644 --- a/users/zeineldeen/experiments/canary_aed/nemo/search.py +++ b/users/zeineldeen/experiments/canary_aed/nemo/search.py @@ -30,7 +30,7 @@ def __init__( self.split = split self.search_script = search_script self.search_args = search_args if search_args is not None else {} - self.python_exe = python_exe if python_exe is not None else "python3" + self.python_exe = python_exe self.device = device self.rqmt = { "gpu": 1 if device == "gpu" else 0, From fbab0684d448848ad42194f6502585f819278d84 Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Mon, 10 Jun 2024 13:26:28 +0000 Subject: [PATCH 134/227] fix bug --- users/zeineldeen/experiments/canary_aed/nemo/run_eval.py | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/users/zeineldeen/experiments/canary_aed/nemo/run_eval.py b/users/zeineldeen/experiments/canary_aed/nemo/run_eval.py index a46ad6263..06e869f63 100644 --- a/users/zeineldeen/experiments/canary_aed/nemo/run_eval.py +++ b/users/zeineldeen/experiments/canary_aed/nemo/run_eval.py @@ -20,8 +20,6 @@ DATA_CACHE_DIR = "/var/tmp/audio_cache" -wer_metric = evaluate.load("wer") - def dataset_iterator(dataset): for i, item in enumerate(dataset): @@ -110,10 +108,10 @@ def main(args): asr_model = ASRModel.restore_from(args.model_path, map_location=device) asr_model.freeze() - from datasets import load_dataset + from datasets import load_from_disk - # download model is defautl to REUSE_DATASET_IF_EXISTS which means it does not download data again - dataset = load_dataset(args.dataset_path) + print("Loading dataset...") + dataset = load_from_disk(args.dataset_path) if args.max_eval_samples is not None and args.max_eval_samples > 0: print(f"Subsampling dataset to first {args.max_eval_samples} samples !") @@ -140,6 +138,7 @@ def main(args): ) print("Results saved at path:", os.path.abspath(manifest_path)) + wer_metric = evaluate.load("wer") wer = wer_metric.compute(references=references, predictions=predictions) wer = round(100 * wer, 2) From 536fa29f41aa4705c3c647b6c95e07586a2f9840 Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Mon, 10 Jun 2024 13:30:10 +0000 Subject: [PATCH 135/227] better --- users/zeineldeen/experiments/canary_aed/nemo/run_eval.py | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/users/zeineldeen/experiments/canary_aed/nemo/run_eval.py b/users/zeineldeen/experiments/canary_aed/nemo/run_eval.py index 06e869f63..b81225b43 100644 --- a/users/zeineldeen/experiments/canary_aed/nemo/run_eval.py +++ b/users/zeineldeen/experiments/canary_aed/nemo/run_eval.py @@ -16,6 +16,8 @@ from tqdm import tqdm from normalizer import data_utils +from datasets import load_from_disk + from nemo.collections.asr.models import ASRModel DATA_CACHE_DIR = "/var/tmp/audio_cache" @@ -108,9 +110,6 @@ def main(args): asr_model = ASRModel.restore_from(args.model_path, map_location=device) asr_model.freeze() - from datasets import load_from_disk - - print("Loading dataset...") dataset = load_from_disk(args.dataset_path) if args.max_eval_samples is not None and args.max_eval_samples > 0: From 5c21c8ac744b2eb61ab32a7848541b7d4f2b9298 Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Mon, 10 Jun 2024 14:02:23 +0000 Subject: [PATCH 136/227] add missing search output path --- .../experiments/canary_aed/configs/canary_1b_recog.py | 2 +- users/zeineldeen/experiments/canary_aed/nemo/run_eval.py | 7 +++++-- users/zeineldeen/experiments/canary_aed/nemo/search.py | 3 +++ 3 files changed, 9 insertions(+), 3 deletions(-) diff --git a/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py b/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py index f4998cf9d..b31659c5d 100644 --- a/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py +++ b/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py @@ -70,4 +70,4 @@ def py(): cpu_rqmt=2, ) search_job.add_alias("canary_1b_ami") - tk.register_output("canary_1b_ami/wer", search_job.out_wer) + tk.register_output("canary_1b_ami/search_out", search_job.out_search_results) diff --git a/users/zeineldeen/experiments/canary_aed/nemo/run_eval.py b/users/zeineldeen/experiments/canary_aed/nemo/run_eval.py index b81225b43..ea2ac4519 100644 --- a/users/zeineldeen/experiments/canary_aed/nemo/run_eval.py +++ b/users/zeineldeen/experiments/canary_aed/nemo/run_eval.py @@ -22,6 +22,8 @@ DATA_CACHE_DIR = "/var/tmp/audio_cache" +wer_metric = evaluate.load("wer") + def dataset_iterator(dataset): for i, item in enumerate(dataset): @@ -133,11 +135,10 @@ def main(args): # Write manifest results manifest_path = data_utils.write_manifest( - references, predictions, args.model_id, args.dataset_path, args.dataset, args.split + args.manifest_path, references, predictions, args.model_id, args.dataset_path, args.dataset, args.split ) print("Results saved at path:", os.path.abspath(manifest_path)) - wer_metric = evaluate.load("wer") wer = wer_metric.compute(references=references, predictions=predictions) wer = round(100 * wer, 2) @@ -160,6 +161,8 @@ def main(args): parser.add_argument("--dataset", type=str, required=True, help="Dataset name.") parser.add_argument("--split", type=str, required=True, help="Dataset split.") + parser.add_argument("--manifest_path", type=str, required=True, help="Path to save the search output.") + parser.add_argument( "--device", type=int, diff --git a/users/zeineldeen/experiments/canary_aed/nemo/search.py b/users/zeineldeen/experiments/canary_aed/nemo/search.py index d1bba5633..c785ca8ff 100644 --- a/users/zeineldeen/experiments/canary_aed/nemo/search.py +++ b/users/zeineldeen/experiments/canary_aed/nemo/search.py @@ -39,6 +39,7 @@ def __init__( "time": time_rqmt, } + self.out_search_results = self.output_path("search_results") self.out_wer = self.output_path("wer") def tasks(self): @@ -59,6 +60,8 @@ def get_cmd(self): self.dataset_name, "--split", self.split, + "--manifest_path", + self.out_search_results.get_path(), "--device", "0" if self.device == "gpu" else "-1", ] From c462d05c1d96293812cb989bc175110204ec4d8b Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Mon, 10 Jun 2024 15:02:22 +0000 Subject: [PATCH 137/227] add compute_wer func --- .../experiments/canary_aed/nemo/run_eval.py | 20 ++++++++++++++----- 1 file changed, 15 insertions(+), 5 deletions(-) diff --git a/users/zeineldeen/experiments/canary_aed/nemo/run_eval.py b/users/zeineldeen/experiments/canary_aed/nemo/run_eval.py index ea2ac4519..1f2d37928 100644 --- a/users/zeineldeen/experiments/canary_aed/nemo/run_eval.py +++ b/users/zeineldeen/experiments/canary_aed/nemo/run_eval.py @@ -6,11 +6,11 @@ import os import sys -sys.path.append("/u/zeineldeen/setups/ubuntu_22_setups/2024-06-07--canary-aed/recipe/open_asr_leaderboard/normalizer") +# sys.path.append("/u/zeineldeen/setups/ubuntu_22_setups/2024-06-07--canary-aed/recipe/open_asr_leaderboard/normalizer") import shutil import torch -import evaluate + import soundfile from tqdm import tqdm @@ -22,7 +22,17 @@ DATA_CACHE_DIR = "/var/tmp/audio_cache" -wer_metric = evaluate.load("wer") + +def compute_wer(predictions, references): + from jiwer import compute_measures + + incorrect = 0 + total = 0 + for prediction, reference in zip(predictions, references): + measures = compute_measures(reference, prediction) + incorrect += measures["substitutions"] + measures["deletions"] + measures["insertions"] + total += measures["substitutions"] + measures["deletions"] + measures["hits"] + return incorrect / total def dataset_iterator(dataset): @@ -133,13 +143,13 @@ def main(args): predictions.append(data_utils.normalizer(sample["pred_text"])) references.append(sample["reference"]) - # Write manifest results + # Write manifest results to args.manifest_path manifest_path = data_utils.write_manifest( args.manifest_path, references, predictions, args.model_id, args.dataset_path, args.dataset, args.split ) print("Results saved at path:", os.path.abspath(manifest_path)) - wer = wer_metric.compute(references=references, predictions=predictions) + wer = compute_wer(references=references, predictions=predictions) wer = round(100 * wer, 2) print("WER:", wer, "%") From 3884115111c0ffd8ec386c2b16394d74dd61700b Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Mon, 10 Jun 2024 15:11:51 +0000 Subject: [PATCH 138/227] add wer as output var --- users/zeineldeen/experiments/canary_aed/nemo/run_eval.py | 7 +++++++ users/zeineldeen/experiments/canary_aed/nemo/search.py | 4 +++- 2 files changed, 10 insertions(+), 1 deletion(-) diff --git a/users/zeineldeen/experiments/canary_aed/nemo/run_eval.py b/users/zeineldeen/experiments/canary_aed/nemo/run_eval.py index 1f2d37928..43b467413 100644 --- a/users/zeineldeen/experiments/canary_aed/nemo/run_eval.py +++ b/users/zeineldeen/experiments/canary_aed/nemo/run_eval.py @@ -154,6 +154,11 @@ def main(args): print("WER:", wer, "%") + if args.wer_out_path: + with open(args.wer_out_path, "w") as f: + f.write(f"{wer}\n") + print(f"Wrote WER (%) to {args.wer_out_path}") + if __name__ == "__main__": parser = argparse.ArgumentParser() @@ -173,6 +178,8 @@ def main(args): parser.add_argument("--manifest_path", type=str, required=True, help="Path to save the search output.") + parser.add_argument("--wer_out_path", type=str, default=None, help="Path to save the WER output.") + parser.add_argument( "--device", type=int, diff --git a/users/zeineldeen/experiments/canary_aed/nemo/search.py b/users/zeineldeen/experiments/canary_aed/nemo/search.py index c785ca8ff..75c9cd98f 100644 --- a/users/zeineldeen/experiments/canary_aed/nemo/search.py +++ b/users/zeineldeen/experiments/canary_aed/nemo/search.py @@ -40,7 +40,7 @@ def __init__( } self.out_search_results = self.output_path("search_results") - self.out_wer = self.output_path("wer") + self.out_wer = self.output_var("wer") def tasks(self): yield Task("create_files", mini_task=True) @@ -64,6 +64,8 @@ def get_cmd(self): self.out_search_results.get_path(), "--device", "0" if self.device == "gpu" else "-1", + "--wer_out_path", + self.out_wer.get_path(), ] for k, v in self.search_args.items(): if k == "device": From 2ffa0d8de3bad7bc9df803e758023efafc3dde77 Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Mon, 10 Jun 2024 15:14:14 +0000 Subject: [PATCH 139/227] run search for all test sets with canary 1b model --- .../canary_aed/configs/canary_1b_recog.py | 31 ++++++++++--------- 1 file changed, 16 insertions(+), 15 deletions(-) diff --git a/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py b/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py index b31659c5d..0399321c4 100644 --- a/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py +++ b/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py @@ -56,18 +56,19 @@ def py(): "/work/asr4/zeineldeen/setups-data/ubuntu_22_setups/2024-06-07--canary-aed/nemo_venv/bin/python3" ) - search_job = SearchJob( - model_id=MODEL_ID, - model_path=model_path, - dataset_path=dataset_paths["ami"], - dataset_name="ami", - split="test", - search_script=search_script, - python_exe=python_exe, - device="gpu", - time_rqmt=4, - mem_rqmt=4, - cpu_rqmt=2, - ) - search_job.add_alias("canary_1b_ami") - tk.register_output("canary_1b_ami/search_out", search_job.out_search_results) + for test_set in TEST_DATASETS: + search_job = SearchJob( + model_id=MODEL_ID, + model_path=model_path, + dataset_path=dataset_paths[test_set], + dataset_name=test_set, + split="test", + search_script=search_script, + python_exe=python_exe, + device="gpu", + time_rqmt=4, + mem_rqmt=4, + cpu_rqmt=2, + ) + search_job.add_alias(f"canary_1b/{test_set}") + tk.register_output(f"canary_1b/{test_set}/search_out", search_job.out_search_results) From b6a6b6581c84ffbd39d3e85b3be4cf494429b3d1 Mon Sep 17 00:00:00 2001 From: Judyxujj Date: Mon, 10 Jun 2024 23:48:34 +0800 Subject: [PATCH 140/227] add configs (#224) Co-authored-by: Jingjing Xu --- ...ntly_train_iterative_zero_out_layerwise.py | 245 ++++++++++++++ ...ntly_train_iterative_zero_out_layerwise.py | 316 ++++++++++++++++++ 2 files changed, 561 insertions(+) create mode 100644 users/jxu/experiments/ctc/tedlium2/configs/dynamic_encoder_size/iterative_zero_out_refactored/jointly_train_iterative_zero_out_layerwise.py create mode 100644 users/jxu/experiments/ctc/tedlium2/pytorch_networks/dynamic_encoder_size/iterative_zero_out_refactored/jointly_train_iterative_zero_out_layerwise.py diff --git a/users/jxu/experiments/ctc/tedlium2/configs/dynamic_encoder_size/iterative_zero_out_refactored/jointly_train_iterative_zero_out_layerwise.py b/users/jxu/experiments/ctc/tedlium2/configs/dynamic_encoder_size/iterative_zero_out_refactored/jointly_train_iterative_zero_out_layerwise.py new file mode 100644 index 000000000..713bb5ba5 --- /dev/null +++ b/users/jxu/experiments/ctc/tedlium2/configs/dynamic_encoder_size/iterative_zero_out_refactored/jointly_train_iterative_zero_out_layerwise.py @@ -0,0 +1,245 @@ +import functools +from typing import Any, Dict, List, Optional, Union +import copy + +import i6_core.returnn as returnn +import i6_experiments.users.jxu.experiments.ctc.tedlium2.configs.configs_helper as configs_helper +from i6_experiments.users.berger.systems.dataclasses import ReturnnConfigs +from i6_experiments.common.setups.returnn_pytorch.serialization import Collection +from i6_experiments.users.berger.systems.dataclasses import ConfigVariant + +# ********** Constant values ********** + +num_outputs = 79 +num_subepochs = 250 + + +# ********** Settings ********** + +def get_returnn_config( + network: Optional[Dict] = None, + *, + target: Optional[str] = "classes", + num_inputs: Optional[int] = None, + num_outputs: Optional[int] = None, + python_prolog: Optional[Union[List, Dict]] = None, + extern_data_config: bool = False, + extra_python: Optional[List] = None, + extra_config: Optional[Dict] = None, + hash_full_python_code: bool = False, + **kwargs, +) -> returnn.ReturnnConfig: + python_prolog = python_prolog or ["import numpy as np"] + extra_python = extra_python or [] + config_dict: dict[str, Any] = {"target": target} + if num_inputs is not None: + config_dict["num_inputs"] = num_inputs + if num_outputs is not None: + config_dict["num_outputs"] = {target: num_outputs} + if extern_data_config: + config_dict.update( + configs_helper.get_extern_data_config(num_inputs=num_inputs, num_outputs=num_outputs, target=target, + **kwargs) + ) + config_dict.update(configs_helper.get_base_config()) + + if network: + config_dict.update({"network:": network}) + + lrate_config = configs_helper.get_oclr_config(**kwargs) + config_dict.update(lrate_config) + + config_dict.update(configs_helper.get_base_regularization_config(**kwargs)) + + if extra_config: + config_dict.update(extra_config) + + post_config_dict = {} + post_config_dict.update(configs_helper.get_base_post_config(**kwargs)) + + return returnn.ReturnnConfig( + config=config_dict, + post_config=post_config_dict, + hash_full_python_code=hash_full_python_code, + python_prolog=python_prolog, + python_epilog=extra_python, + pprint_kwargs={"sort_dicts": False}, + ) + + +def get_serializer(model_config, variant: ConfigVariant, in_dim: int = 1) -> Collection: + from i6_experiments.users.jxu.experiments.ctc.tedlium2.pytorch_networks.dynamic_encoder_size.zeroout_with_new_i6_models.joint_train_two_model_iterative_zero_out_modwise import \ + get_train_serializer, get_recog_serializer, get_prior_serializer + if variant == ConfigVariant.TRAIN: + return get_train_serializer(model_config) + if variant == ConfigVariant.PRIOR: + return get_prior_serializer(model_config) + if variant == ConfigVariant.RECOG: + return get_recog_serializer(model_config) + raise NotImplementedError + + +def returnn_config_generator(train_data_config: dict, dev_data_config: dict, peak_lr: float) -> dict: + from i6_experiments.users.jxu.experiments.ctc.tedlium2.pytorch_networks.dynamic_encoder_size.zeroout_with_new_i6_models.joint_train_two_model_iterative_zero_out_modwise import \ + get_default_config_v1 as get_train_config + from i6_experiments.users.jxu.experiments.ctc.tedlium2.pytorch_networks.dynamic_encoder_size.zeroout_with_new_i6_models.joint_train_two_model_iterative_zero_out_modwise import \ + get_default_config_v1 as get_recog_config + + extra_config = { + "train": train_data_config, + "dev": dev_data_config, + } + recog_extra_config = copy.deepcopy(extra_config) + recog_extra_config["model_outputs"] = {"classes": {"dim": num_outputs}} + + config_partial = functools.partial( + get_returnn_config, + num_epochs=num_subepochs, + num_inputs=50, + num_outputs=num_outputs, + target="targets", + extern_data_config=True, + grad_noise=0.0, + grad_clip=0.0, + cycle_epoch=110, + initial_lr=peak_lr / 100, + peak_lr=peak_lr, + final_lr=1e-08, + batch_size=15000, + extra_config=extra_config, + ) + + def get_returnn_configs(train_config, recog_config): + return ReturnnConfigs( + train_config=config_partial( + extra_python=[get_serializer(train_config, ConfigVariant.TRAIN)], + extra_config=extra_config), + prior_config=config_partial(extra_python=[get_serializer(recog_config, ConfigVariant.PRIOR)], + extra_config=extra_config), + recog_configs={ + "recog": config_partial(extra_python=[get_serializer(recog_config, ConfigVariant.RECOG)], + extra_config=recog_extra_config)}, + ) + + # ----------------------------- gumbel_scale 0.05 gumble_top_k_dropout_0_3 init tau 0.5 k annealing every 20 sub-epoch --------------------------------------- + + experiments = {} + for num_steps_per_iter in [[45 * 1400] + [15 * 1400] * 7]: + for num_zeroout_elements_per_iter in [[3,6,9,12,15,18,21,24]]: + for layer_dropout_stage_1, layer_dropout_stage_2 in [(0, 0.3)]: + layer_dropout_kwargs = {"layer_dropout_stage_1": layer_dropout_stage_1, + "layer_dropout_stage_2": layer_dropout_stage_2} + zero_out_kwargs = {"num_steps_per_iter":num_steps_per_iter, "num_zeroout_elements_per_iter":num_zeroout_elements_per_iter, "zeroout_val": -5} + network_args = {"layer_dropout_kwargs": layer_dropout_kwargs, + "zero_out_kwargs": zero_out_kwargs, "num_layers_set": [24, 48], + "layer_gate_activation":"sigmoid", "recog_num_layers": 48} + + train_config = get_train_config(num_inputs=50, num_outputs=num_outputs, + network_args=network_args) + recog_network_args = copy.deepcopy(network_args) + recog_network_args["recog_num_layers"] = 48 + num_recog_mods_48_recog_config = get_recog_config(num_inputs=50, num_outputs=num_outputs, + network_args=recog_network_args) + recog_network_args["recog_num_layers"] = 24 + num_recog_mods_24_recog_config = get_recog_config(num_inputs=50, num_outputs=num_outputs, + network_args=recog_network_args) + + num_recog_mods_48_experiment_name = f"two_models_dropout_{layer_dropout_stage_1}_{layer_dropout_stage_2}_recog_num_mods_48_peak_lr_{peak_lr}" + num_recog_mods_48_experiment_name = num_recog_mods_48_experiment_name.replace(".", "_") + experiments[num_recog_mods_48_experiment_name] = get_returnn_configs(train_config, + num_recog_mods_48_recog_config) + + num_recog_mods_24_experiment_name = f"two_models_dropout_{layer_dropout_stage_1}_{layer_dropout_stage_2}_recog_num_mods_24_peak_lr_{peak_lr}" + num_recog_mods_24_experiment_name = num_recog_mods_24_experiment_name.replace(".", "_") + experiments[num_recog_mods_24_experiment_name] = get_returnn_configs(train_config, + num_recog_mods_24_recog_config) + + for num_steps_per_iter in [[42000,25200,25200,25200,25200,25200,25200,25200]]: + for num_zeroout_elements_per_iter in [[4,8,12,16,20,24,28,32]]: + layer_dropout_kwargs = {"layer_dropout_stage_1": layer_dropout_stage_1, + "layer_dropout_stage_2": layer_dropout_stage_2} + zero_out_kwargs = {"num_steps_per_iter": num_steps_per_iter, + "num_zeroout_elements_per_iter": num_zeroout_elements_per_iter, "zeroout_val": -5} + + network_args = {"layer_dropout_kwargs": layer_dropout_kwargs, + "zero_out_kwargs": zero_out_kwargs, "recog_num_layers": 48, "num_layers_set": [16, 32, 48], + "layer_gate_activation":"sigmoid"} + + train_config = get_train_config(num_inputs=50, num_outputs=num_outputs, + network_args=network_args) + recog_network_args = copy.deepcopy(network_args) + recog_network_args["recog_num_layers"] = 48 + num_recog_mods_48_recog_config = get_recog_config(num_inputs=50, num_outputs=num_outputs, + network_args=recog_network_args) + + recog_network_args["recog_num_layers"] = 32 + num_recog_mods_32_recog_config = get_recog_config(num_inputs=50, num_outputs=num_outputs, + network_args=recog_network_args) + + recog_network_args["recog_num_layers"] = 16 + num_recog_mods_16_recog_config = get_recog_config(num_inputs=50, num_outputs=num_outputs, + network_args=recog_network_args) + + num_recog_mods_48_experiment_name = f"three_models_dropout_{layer_dropout_stage_1}_{layer_dropout_stage_2}_recog_num_mods_48_peak_lr_{peak_lr}" + num_recog_mods_48_experiment_name = num_recog_mods_48_experiment_name.replace(".", "_") + experiments[num_recog_mods_48_experiment_name] = get_returnn_configs(train_config, + num_recog_mods_48_recog_config) + + num_recog_mods_32_experiment_name = f"three_models_dropout_{layer_dropout_stage_1}_{layer_dropout_stage_2}_recog_num_mods_32_peak_lr_{peak_lr}" + num_recog_mods_32_experiment_name = num_recog_mods_32_experiment_name.replace(".", "_") + experiments[num_recog_mods_32_experiment_name] = get_returnn_configs(train_config, + num_recog_mods_32_recog_config) + + num_recog_mods_16_experiment_name = f"three_models_dropout_{layer_dropout_stage_1}_{layer_dropout_stage_2}_recog_num_mods_16_peak_lr_{peak_lr}" + num_recog_mods_16_experiment_name = num_recog_mods_16_experiment_name.replace(".", "_") + experiments[num_recog_mods_16_experiment_name] = get_returnn_configs(train_config, + num_recog_mods_16_recog_config) + + + for num_steps_per_iter in [[10*1400]+[4*1400]*35]: + for num_zeroout_elements_per_iter in [list(range(1,37))]: + for layer_dropout_stage_1, layer_dropout_stage_2 in [(0, 0.3)]: + zero_out_kwargs = {"num_steps_per_iter": num_steps_per_iter, + "num_zeroout_elements_per_iter": num_zeroout_elements_per_iter, "zeroout_val": -5} + layer_dropout_kwargs = {"layer_dropout_stage_1": layer_dropout_stage_1, + "layer_dropout_stage_2": layer_dropout_stage_2} + network_args = {"layer_dropout_kwargs": layer_dropout_kwargs, + "zero_out_kwargs": zero_out_kwargs, "recog_num_layers": 48, "num_layers_set": [12, 24, 36, 48], + "layer_gate_activation":"sigmoid"} + + train_config = get_train_config(num_inputs=50, num_outputs=num_outputs, + network_args=network_args) + recog_network_args = copy.deepcopy(network_args) + recog_network_args["recog_num_layers"] = 48 + num_recog_mods_48_recog_config = get_recog_config(num_inputs=50, num_outputs=num_outputs, + network_args=recog_network_args) + + recog_network_args["recog_num_layers"] = 36 + num_recog_mods_36_recog_config = get_recog_config(num_inputs=50, num_outputs=num_outputs, + network_args=recog_network_args) + + recog_network_args["recog_num_layers"] = 24 + num_recog_mods_24_recog_config = get_recog_config(num_inputs=50, num_outputs=num_outputs, + network_args=recog_network_args) + + recog_network_args["recog_num_layers"] = 12 + num_recog_mods_12_recog_config = get_recog_config(num_inputs=50, num_outputs=num_outputs, + network_args=recog_network_args) + + num_recog_mods_48_experiment_name = f"four_models_dropout_{layer_dropout_stage_1}_{layer_dropout_stage_2}_recog_num_mods_48_peak_lr_{peak_lr}" + num_recog_mods_48_experiment_name = num_recog_mods_48_experiment_name.replace(".", "_") + experiments[num_recog_mods_48_experiment_name] = get_returnn_configs(train_config, num_recog_mods_48_recog_config) + + num_recog_mods_36_experiment_name = f"four_models_{layer_dropout_stage_1}_{layer_dropout_stage_2}_recog_num_mods_36_peak_lr_{peak_lr}" + num_recog_mods_36_experiment_name = num_recog_mods_36_experiment_name.replace(".", "_") + experiments[num_recog_mods_36_experiment_name] = get_returnn_configs(train_config, num_recog_mods_36_recog_config) + + num_recog_mods_24_experiment_name = f"four_models_{layer_dropout_stage_1}_{layer_dropout_stage_2}_recog_num_mods_24_peak_lr_{peak_lr}" + num_recog_mods_24_experiment_name = num_recog_mods_24_experiment_name.replace(".", "_") + experiments[num_recog_mods_24_experiment_name] = get_returnn_configs(train_config, num_recog_mods_24_recog_config) + + num_recog_mods_12_experiment_name = f"four_models_dropout_{layer_dropout_stage_1}_{layer_dropout_stage_2}_recog_num_mods_12_peak_lr_{peak_lr}" + num_recog_mods_12_experiment_name = num_recog_mods_12_experiment_name.replace(".", "_") + experiments[num_recog_mods_12_experiment_name] = get_returnn_configs(train_config, num_recog_mods_12_recog_config) + + return experiments diff --git a/users/jxu/experiments/ctc/tedlium2/pytorch_networks/dynamic_encoder_size/iterative_zero_out_refactored/jointly_train_iterative_zero_out_layerwise.py b/users/jxu/experiments/ctc/tedlium2/pytorch_networks/dynamic_encoder_size/iterative_zero_out_refactored/jointly_train_iterative_zero_out_layerwise.py new file mode 100644 index 000000000..70933243f --- /dev/null +++ b/users/jxu/experiments/ctc/tedlium2/pytorch_networks/dynamic_encoder_size/iterative_zero_out_refactored/jointly_train_iterative_zero_out_layerwise.py @@ -0,0 +1,316 @@ +from dataclasses import dataclass +from typing import Optional +from collections import OrderedDict + +import torch +from torch import nn +from returnn.tensor.tensor_dict import TensorDict +import returnn.frontend as rf +import numpy as np + +from i6_models.parts.frontend.vgg_act import VGG4LayerActFrontendV1, VGG4LayerActFrontendV1Config +from i6_models.parts.conformer.convolution import ConformerConvolutionV1Config +from i6_models.parts.conformer.norm import LayerNormNC +from i6_models.parts.conformer.mhsa import ConformerMHSAV1Config +from i6_models.parts.conformer.feedforward import ConformerPositionwiseFeedForwardV1Config +from i6_models.assemblies.conformer_with_dynamic_model_size.selection_with_iterative_zero_out import ( + ConformerBlockConfig, + ConformerEncoderConfig, + ConformerEncoder +) +from i6_models.primitives.specaugment import specaugment_v1_by_length +from i6_models.config import ModelConfiguration, ModuleFactoryV1 + +from i6_experiments.users.berger.pytorch.models.util import lengths_to_padding_mask +from i6_experiments.common.setups.returnn_pytorch.serialization import Collection +from i6_experiments.users.berger.pytorch.serializers.basic import ( + get_basic_pt_network_serializer, +) + +from i6_experiments.common.setups.serialization import Import + + +@dataclass +class ConformerCTCConfig(ModelConfiguration): + conformer_cfg: ConformerEncoderConfig + target_size: int + recog_num_layers: int + zero_out_kwargs: dict + + +class ConformerCTCModel(torch.nn.Module): + def __init__(self, step: int, cfg: ConformerCTCConfig, **kwargs): + super().__init__() + self.conformer = ConformerEncoder(cfg.conformer_cfg) + self.final_linear_list = torch.nn.ModuleList( + [nn.Linear(cfg.conformer_cfg.block_cfg.ff_cfg.input_dim, cfg.target_size) for _ in + range(len(self.conformer.num_layers_set))]) + self.recog_num_layers = cfg.recog_num_layers + self.conformer.recog_num_layers = cfg.recog_num_layers + self.zero_out_kwargs = cfg.zero_out_kwargs + self.export_mode = False + + def forward( + self, + audio_features: torch.Tensor, + audio_features_len: Optional[torch.Tensor] = None, + global_train_step: int = 0 + ): + if self.training: + x = specaugment_v1_by_length(audio_features, + time_min_num_masks=2, + time_max_mask_per_n_frames=25, + time_mask_max_size=20, + freq_min_num_masks=2, + freq_mask_max_size=5, + freq_max_num_masks=10) # [B, T, F] + else: + x = audio_features + # sequence_mask = None if self.export_mode else lengths_to_padding_mask(audio_features_len) + sequence_mask = lengths_to_padding_mask(audio_features_len) + # sequence_mask = lengths_to_padding_mask((audio_features_len + 2) // 3) + conformer_out_list, total_utilised_layers, sequence_mask = self.conformer(x, sequence_mask, global_train_step, + self.zero_out_kwargs) # [B, T, F] + + log_probs_list = [] + for i in range(len(conformer_out_list)): + logits = self.final_linear_list[i](conformer_out_list[i]) # [B, T, F] + log_probs = torch.log_softmax(logits, dim=2) + log_probs_list.append(log_probs) + + if self.training: + return log_probs_list, total_utilised_layers, sequence_mask + + idx = self.conformer.num_layers_set.index(self.recog_num_layers) + return log_probs_list[idx] + + +def get_default_config_v1(num_inputs: int, num_outputs: int, network_args: dict) -> ConformerCTCConfig: + dropout = 0.2 if "dropout" not in network_args else network_args["dropout"] + num_att_heads = 6 if "num_att_heads" not in network_args else network_args["num_att_heads"] + att_weights_dropout = 0.1 if "att_weights_dropout" not in network_args else network_args["att_weights_dropout"] + num_layers = 12 if "num_layers" not in network_args else network_args["num_layers"] + kernel_size = 31 if "kernel_size" not in network_args else network_args["kernel_size"] + num_layers_set = network_args["num_layers_set"] + layer_dropout_kwargs = network_args["layer_dropout_kwargs"] + recog_num_layers = network_args["recog_num_layers"] + zero_out_kwargs = network_args["zero_out_kwargs"] + layer_gate_activation = network_args["layer_gate_activation"] + + frontend_cfg = VGG4LayerActFrontendV1Config( + in_features=num_inputs, + conv1_channels=32, + conv2_channels=64, + conv3_channels=64, + conv4_channels=32, + conv_kernel_size=(3, 3), + conv_padding=None, + pool1_kernel_size=(2, 1), + pool1_stride=(2, 1), + pool1_padding=None, + pool2_kernel_size=(2, 1), + pool2_stride=(2, 1), + pool2_padding=None, + activation=torch.nn.ReLU(), + out_features=384, + ) + + frontend = ModuleFactoryV1(VGG4LayerActFrontendV1, frontend_cfg) + + ff_cfg = ConformerPositionwiseFeedForwardV1Config( + input_dim=384, + hidden_dim=1536, + dropout=dropout, + activation=torch.nn.SiLU(), + ) + + mhsa_cfg = ConformerMHSAV1Config( + input_dim=384, + num_att_heads=num_att_heads, + att_weights_dropout=att_weights_dropout, + dropout=dropout, + ) + + conv_cfg = ConformerConvolutionV1Config( + channels=384, + kernel_size=kernel_size, + dropout=dropout, + activation=torch.nn.SiLU(), + norm=LayerNormNC(384), + ) + + block_cfg = ConformerBlockConfig( + ff_cfg=ff_cfg, + mhsa_cfg=mhsa_cfg, + conv_cfg=conv_cfg, + layer_dropout=layer_dropout_kwargs["layer_dropout_stage_1"], + modules=["ff", "conv", "mhsa", "ff"], + scales=[0.5, 1.0, 1.0, 0.5] + ) + + + conformer_cfg = ConformerEncoderConfig( + num_layers=num_layers, + frontend=frontend, + block_cfg=block_cfg, + num_layers_set=num_layers_set, + layer_dropout_kwargs=layer_dropout_kwargs, + layer_gate_activation=torch.nn.Sigmoid() if layer_gate_activation=="sigmoid" else torch.nn.Identity() + ) + + return ConformerCTCConfig( + conformer_cfg=conformer_cfg, + target_size=num_outputs, + recog_num_layers=recog_num_layers, + zero_out_kwargs=zero_out_kwargs, + ) + + +def train_step(*, model: torch.nn.Module, extern_data: TensorDict, global_train_step, **kwargs): + audio_features = extern_data["data"].raw_tensor + audio_features_len = extern_data["data"].dims[1].dyn_size_ext.raw_tensor + + targets = extern_data["targets"].raw_tensor.long() + targets_len = extern_data["targets"].dims[1].dyn_size_ext.raw_tensor + + model.train() + + log_probs_list, total_utilised_layers, sequence_mask = model( + audio_features=audio_features, + audio_features_len=audio_features_len.to("cuda"), + global_train_step=global_train_step + ) + sequence_lengths = torch.sum(sequence_mask.type(torch.int32), dim=1) + + num_steps_per_iter = model.zero_out_kwargs["num_steps_per_iter"] + cum_steps_per_iter = np.cumsum(num_steps_per_iter) + num_zeroout_elements_per_iter = model.zero_out_kwargs["num_zeroout_elements_per_iter"] + stage_1_expected_sparsity_per_iter = [n / (4*len(model.conformer.module_list)) for n in num_zeroout_elements_per_iter] + + assert len(num_steps_per_iter) == len(num_zeroout_elements_per_iter) + + loss_layers = model.conformer.num_layers_set + + # stage 1 : jointly train the largest and smallest model + if global_train_step <= cum_steps_per_iter[-1]: + loss_scales = [0.3, 1] + iter_idx = int(model.conformer.iter_idx) + sparsity_loss = torch.abs((48-total_utilised_layers)/48 - stage_1_expected_sparsity_per_iter[iter_idx]) + rf.get_run_ctx().mark_as_loss(name=f"sparsity_loss", loss=sparsity_loss, scale=5) + if global_train_step == cum_steps_per_iter[iter_idx] and global_train_step Collection: + pytorch_package = "i6_experiments.users.berger.pytorch" + + return get_basic_pt_network_serializer( + module_import_path=f"{__name__}.{ConformerCTCModel.__name__}", + model_config=model_config, + additional_serializer_objects=[ + Import(f"{__name__}.forward_step"), + Import(f"{pytorch_package}.forward.prior_callback.ComputePriorCallback", import_as="forward_callback"), + ], + ) + + +def export(*, model: torch.nn.Module, model_filename: str): + model.export_mode = True + dummy_data = torch.randn(1, 30, 50, device="cpu") + dummy_data_len = torch.tensor([30], dtype=torch.int32) + torch.onnx.export( + model=model.eval(), + args=(dummy_data, dummy_data_len), + f=model_filename, + verbose=True, + input_names=["data", "data_len"], + output_names=["classes"], + opset_version=17, + dynamic_axes={ + # dict value: manually named axes + "data": {0: "batch", 1: "time"}, + "data_len": {0: "batch"}, + "targets": {0: "batch", 1: "time"}, + }, + ) + + +def get_recog_serializer( + model_config: ConformerCTCConfig, +) -> Collection: + return get_basic_pt_network_serializer( + module_import_path=f"{__name__}.{ConformerCTCModel.__name__}", + model_config=model_config, + additional_serializer_objects=[ + Import(f"{__name__}.export"), + ], + ) + + +def get_train_serializer( + model_config: ConformerCTCConfig, +) -> Collection: + return get_basic_pt_network_serializer( + module_import_path=f"{__name__}.{ConformerCTCModel.__name__}", + model_config=model_config, + additional_serializer_objects=[ + Import(f"{__name__}.train_step"), + ], + ) From 9b708659573384afa73176552c0b37c1e30b0b7b Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Mon, 10 Jun 2024 15:51:08 +0000 Subject: [PATCH 141/227] update --- .../zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py | 1 + users/zeineldeen/experiments/canary_aed/nemo/run_eval.py | 1 + 2 files changed, 2 insertions(+) diff --git a/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py b/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py index 0399321c4..02efab412 100644 --- a/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py +++ b/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py @@ -64,6 +64,7 @@ def py(): dataset_name=test_set, split="test", search_script=search_script, + search_args={"batch_size": 1}, python_exe=python_exe, device="gpu", time_rqmt=4, diff --git a/users/zeineldeen/experiments/canary_aed/nemo/run_eval.py b/users/zeineldeen/experiments/canary_aed/nemo/run_eval.py index 43b467413..4c3d9d34e 100644 --- a/users/zeineldeen/experiments/canary_aed/nemo/run_eval.py +++ b/users/zeineldeen/experiments/canary_aed/nemo/run_eval.py @@ -122,6 +122,7 @@ def main(args): asr_model = ASRModel.restore_from(args.model_path, map_location=device) asr_model.freeze() + # TODO: how to set the num_workers? dataset = load_from_disk(args.dataset_path) if args.max_eval_samples is not None and args.max_eval_samples > 0: From 8a24d8fcef8c74f323178a9f0644821d0555a8f8 Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Mon, 10 Jun 2024 15:52:15 +0000 Subject: [PATCH 142/227] update --- users/zeineldeen/experiments/canary_aed/nemo/run_eval.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/users/zeineldeen/experiments/canary_aed/nemo/run_eval.py b/users/zeineldeen/experiments/canary_aed/nemo/run_eval.py index 4c3d9d34e..3d65ae83f 100644 --- a/users/zeineldeen/experiments/canary_aed/nemo/run_eval.py +++ b/users/zeineldeen/experiments/canary_aed/nemo/run_eval.py @@ -144,7 +144,7 @@ def main(args): predictions.append(data_utils.normalizer(sample["pred_text"])) references.append(sample["reference"]) - # Write manifest results to args.manifest_path + # Write manifest results to args.manifest_path. This required modification in normalizer/eval_utils.py script manifest_path = data_utils.write_manifest( args.manifest_path, references, predictions, args.model_id, args.dataset_path, args.dataset, args.split ) From 01e4c4c927bc380635d709d479f49b10ecd82848 Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Mon, 10 Jun 2024 19:09:28 +0200 Subject: [PATCH 143/227] register wer as out --- .../zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py | 1 + 1 file changed, 1 insertion(+) diff --git a/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py b/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py index 02efab412..dbf8b786c 100644 --- a/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py +++ b/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py @@ -73,3 +73,4 @@ def py(): ) search_job.add_alias(f"canary_1b/{test_set}") tk.register_output(f"canary_1b/{test_set}/search_out", search_job.out_search_results) + tk.register_output(f"canary_1b/{test_set}/wer", search_job.out_wer) From 898609287c8268f25c60b688045e08c6dc25f126 Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Tue, 11 Jun 2024 00:25:36 +0200 Subject: [PATCH 144/227] update --- .../experiments/canary_aed/configs/canary_1b_recog.py | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py b/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py index dbf8b786c..4f1c51c0f 100644 --- a/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py +++ b/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py @@ -64,13 +64,14 @@ def py(): dataset_name=test_set, split="test", search_script=search_script, - search_args={"batch_size": 1}, + search_args={"batch_size": 64}, python_exe=python_exe, device="gpu", time_rqmt=4, mem_rqmt=4, cpu_rqmt=2, ) - search_job.add_alias(f"canary_1b/{test_set}") - tk.register_output(f"canary_1b/{test_set}/search_out", search_job.out_search_results) - tk.register_output(f"canary_1b/{test_set}/wer", search_job.out_wer) + search_job.rqmt["sbatch_args"] = ["-p", "gpu_24gb"] + search_job.add_alias(f"canary_1b/{test_set}_bs64") + tk.register_output(f"canary_1b/{test_set}_bs64/search_out", search_job.out_search_results) + tk.register_output(f"canary_1b/{test_set}_bs64/wer", search_job.out_wer) From eddd357d7baacac30387f7ee58841128d3cc0ace Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Tue, 11 Jun 2024 12:05:33 +0000 Subject: [PATCH 145/227] add libri test other test set --- .../canary_aed/configs/canary_1b_recog.py | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py b/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py index 4f1c51c0f..b6a601fac 100644 --- a/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py +++ b/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py @@ -6,7 +6,8 @@ from i6_experiments.users.zeineldeen.experiments.canary_aed.nemo.download import DownloadNemoModel from i6_experiments.users.zeineldeen.experiments.canary_aed.nemo.search import SearchJob -TEST_DATASETS = ["ami", "earnings22", "gigaspeech"] +TEST_DATASETS = {"ami": "test", "earnings22": "test", "gigaspeech": "test", "librispeech": "test.other"} + MODEL_ID = "nvidia/canary-1b" @@ -16,11 +17,11 @@ def download_test_datasets() -> Dict[str, tk.Path]: out_dirs = {} - for test_dataset in TEST_DATASETS: + for test_dataset, split in TEST_DATASETS.items(): j = DownloadAndPrepareHuggingFaceDatasetJob( path="open-asr-leaderboard/datasets-test-only", name=test_dataset, - split="test", + split=split, time_rqmt=24, mem_rqmt=4, cpu_rqmt=4, @@ -56,19 +57,19 @@ def py(): "/work/asr4/zeineldeen/setups-data/ubuntu_22_setups/2024-06-07--canary-aed/nemo_venv/bin/python3" ) - for test_set in TEST_DATASETS: + for test_set, split in TEST_DATASETS.items(): search_job = SearchJob( model_id=MODEL_ID, model_path=model_path, dataset_path=dataset_paths[test_set], dataset_name=test_set, - split="test", + split=split, search_script=search_script, search_args={"batch_size": 64}, python_exe=python_exe, device="gpu", time_rqmt=4, - mem_rqmt=4, + mem_rqmt=8, cpu_rqmt=2, ) search_job.rqmt["sbatch_args"] = ["-p", "gpu_24gb"] From bc8e182b56232fe8a37f4786db893565469b8742 Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Tue, 11 Jun 2024 12:21:42 +0000 Subject: [PATCH 146/227] fix args --- .../experiments/canary_aed/configs/canary_1b_recog.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py b/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py index b6a601fac..27e55da77 100644 --- a/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py +++ b/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py @@ -65,14 +65,14 @@ def py(): dataset_name=test_set, split=split, search_script=search_script, - search_args={"batch_size": 64}, + search_args={"batch_size": 64, "pcn": False, "max_eval_samples": -1}, python_exe=python_exe, device="gpu", - time_rqmt=4, + time_rqmt=24, mem_rqmt=8, cpu_rqmt=2, ) search_job.rqmt["sbatch_args"] = ["-p", "gpu_24gb"] - search_job.add_alias(f"canary_1b/{test_set}_bs64") - tk.register_output(f"canary_1b/{test_set}_bs64/search_out", search_job.out_search_results) - tk.register_output(f"canary_1b/{test_set}_bs64/wer", search_job.out_wer) + search_job.add_alias(f"canary_1b/{test_set}_bs64_wo-pcn") + tk.register_output(f"canary_1b/{test_set}_bs64_wo-pcn/search_out", search_job.out_search_results) + tk.register_output(f"canary_1b/{test_set}_bs64_wo-pcn/wer", search_job.out_wer) From 108fa7dad8b9a34befb46fa0694d11dd8a8addaa Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Tue, 11 Jun 2024 12:26:30 +0000 Subject: [PATCH 147/227] fix args --- .../experiments/canary_aed/configs/canary_1b_recog.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py b/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py index 27e55da77..8381a546c 100644 --- a/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py +++ b/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py @@ -65,7 +65,7 @@ def py(): dataset_name=test_set, split=split, search_script=search_script, - search_args={"batch_size": 64, "pcn": False, "max_eval_samples": -1}, + search_args={"batch_size": 64, "pnc": False, "max_eval_samples": -1}, python_exe=python_exe, device="gpu", time_rqmt=24, @@ -73,6 +73,6 @@ def py(): cpu_rqmt=2, ) search_job.rqmt["sbatch_args"] = ["-p", "gpu_24gb"] - search_job.add_alias(f"canary_1b/{test_set}_bs64_wo-pcn") - tk.register_output(f"canary_1b/{test_set}_bs64_wo-pcn/search_out", search_job.out_search_results) - tk.register_output(f"canary_1b/{test_set}_bs64_wo-pcn/wer", search_job.out_wer) + search_job.add_alias(f"canary_1b/{test_set}_bs64_wo-pnc") + tk.register_output(f"canary_1b/{test_set}_bs64_wo-pnc/search_out", search_job.out_search_results) + tk.register_output(f"canary_1b/{test_set}_bs64_wo-pnc/wer", search_job.out_wer) From 0b839fffc6150e709540a33551200ed7185f334c Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Wed, 12 Jun 2024 17:54:12 +0200 Subject: [PATCH 148/227] update --- .../canary_aed/configs/canary_1b_recog.py | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py b/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py index 8381a546c..a01b0da88 100644 --- a/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py +++ b/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py @@ -53,10 +53,22 @@ def py(): "/u/zeineldeen/setups/ubuntu_22_setups/2024-06-07--canary-aed/recipe/i6_experiments/users/zeineldeen/experiments/canary_aed/nemo/run_eval.py", hash_overwrite="run_eval_v1", ) + # to run canary model, this env has installed nemo toolkit with: + # pip3 install git+https://github.com/NVIDIA/NeMo.git@r2.0.0rc0#egg=nemo_toolkit[all] + # related issue: https://github.com/huggingface/open_asr_leaderboard/issues/26 python_exe = tk.Path( "/work/asr4/zeineldeen/setups-data/ubuntu_22_setups/2024-06-07--canary-aed/nemo_venv/bin/python3" ) + # Greedy decoding: + # + # testset | ours | huggingface + # ----------------------------------- + # libri | 2.95 | 2.94 + # ami | 13.96 | 14.0 + # earnings22 | 12.23 | 12.25 + # gigaspeech | 10.14 | 10.19 + for test_set, split in TEST_DATASETS.items(): search_job = SearchJob( model_id=MODEL_ID, From a6a4368c81c000e298bce7d74811eb2ef46a123a Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Wed, 12 Jun 2024 18:37:51 +0200 Subject: [PATCH 149/227] add modified normalized --- .../canary_aed/nemo/normalizer/__init__.py | 1 + .../canary_aed/nemo/normalizer/data_utils.py | 59 + .../nemo/normalizer/english_abbreviations.py | 1743 +++++++++++++++++ .../canary_aed/nemo/normalizer/eval_utils.py | 157 ++ .../canary_aed/nemo/normalizer/normalizer.py | 596 ++++++ 5 files changed, 2556 insertions(+) create mode 100644 users/zeineldeen/experiments/canary_aed/nemo/normalizer/__init__.py create mode 100644 users/zeineldeen/experiments/canary_aed/nemo/normalizer/data_utils.py create mode 100644 users/zeineldeen/experiments/canary_aed/nemo/normalizer/english_abbreviations.py create mode 100644 users/zeineldeen/experiments/canary_aed/nemo/normalizer/eval_utils.py create mode 100644 users/zeineldeen/experiments/canary_aed/nemo/normalizer/normalizer.py diff --git a/users/zeineldeen/experiments/canary_aed/nemo/normalizer/__init__.py b/users/zeineldeen/experiments/canary_aed/nemo/normalizer/__init__.py new file mode 100644 index 000000000..7b3024108 --- /dev/null +++ b/users/zeineldeen/experiments/canary_aed/nemo/normalizer/__init__.py @@ -0,0 +1 @@ +from .normalizer import EnglishTextNormalizer \ No newline at end of file diff --git a/users/zeineldeen/experiments/canary_aed/nemo/normalizer/data_utils.py b/users/zeineldeen/experiments/canary_aed/nemo/normalizer/data_utils.py new file mode 100644 index 000000000..0f8ad7151 --- /dev/null +++ b/users/zeineldeen/experiments/canary_aed/nemo/normalizer/data_utils.py @@ -0,0 +1,59 @@ +from datasets import load_dataset, Audio +from normalizer import EnglishTextNormalizer + +from .eval_utils import read_manifest, write_manifest + + +def is_target_text_in_range(ref): + if ref.strip() == "ignore time segment in scoring": + return False + else: + return ref.strip() != "" + + +def get_text(sample): + if "text" in sample: + return sample["text"] + elif "sentence" in sample: + return sample["sentence"] + elif "normalized_text" in sample: + return sample["normalized_text"] + elif "transcript" in sample: + return sample["transcript"] + elif "transcription" in sample: + return sample["transcription"] + else: + raise ValueError( + f"Expected transcript column of either 'text', 'sentence', 'normalized_text' or 'transcript'. Got sample of " + ".join{sample.keys()}. Ensure a text column name is present in the dataset." + ) + +normalizer = EnglishTextNormalizer() + + +def normalize(batch): + batch["original_text"] = get_text(batch) + batch["norm_text"] = normalizer(batch["original_text"]) + return batch + + +def load_data(args): + dataset = load_dataset( + args.dataset_path, + args.dataset, + split=args.split, + streaming=args.streaming, + token=True, + ) + + return dataset + +def prepare_data(dataset): + # Re-sample to 16kHz and normalise transcriptions + dataset = dataset.cast_column("audio", Audio(sampling_rate=16000)) + dataset = dataset.map(normalize) + dataset = dataset.filter(is_target_text_in_range, input_columns=["norm_text"]) + + return dataset + + diff --git a/users/zeineldeen/experiments/canary_aed/nemo/normalizer/english_abbreviations.py b/users/zeineldeen/experiments/canary_aed/nemo/normalizer/english_abbreviations.py new file mode 100644 index 000000000..5a8cc9320 --- /dev/null +++ b/users/zeineldeen/experiments/canary_aed/nemo/normalizer/english_abbreviations.py @@ -0,0 +1,1743 @@ +english_spelling_normalizer = { + "accessorise": "accessorize", + "accessorised": "accessorized", + "accessorises": "accessorizes", + "accessorising": "accessorizing", + "acclimatisation": "acclimatization", + "acclimatise": "acclimatize", + "acclimatised": "acclimatized", + "acclimatises": "acclimatizes", + "acclimatising": "acclimatizing", + "accoutrements": "accouterments", + "aeon": "eon", + "aeons": "eons", + "aerogramme": "aerogram", + "aerogrammes": "aerograms", + "aeroplane": "airplane", + "aeroplanes": "airplanes", + "aesthete": "esthete", + "aesthetes": "esthetes", + "aesthetic": "esthetic", + "aesthetically": "esthetically", + "aesthetics": "esthetics", + "aetiology": "etiology", + "ageing": "aging", + "aggrandisement": "aggrandizement", + "agonise": "agonize", + "agonised": "agonized", + "agonises": "agonizes", + "agonising": "agonizing", + "agonisingly": "agonizingly", + "almanack": "almanac", + "almanacks": "almanacs", + "aluminium": "aluminum", + "amortisable": "amortizable", + "amortisation": "amortization", + "amortisations": "amortizations", + "amortise": "amortize", + "amortised": "amortized", + "amortises": "amortizes", + "amortising": "amortizing", + "amphitheatre": "amphitheater", + "amphitheatres": "amphitheaters", + "anaemia": "anemia", + "anaemic": "anemic", + "anaesthesia": "anesthesia", + "anaesthetic": "anesthetic", + "anaesthetics": "anesthetics", + "anaesthetise": "anesthetize", + "anaesthetised": "anesthetized", + "anaesthetises": "anesthetizes", + "anaesthetising": "anesthetizing", + "anaesthetist": "anesthetist", + "anaesthetists": "anesthetists", + "anaesthetize": "anesthetize", + "anaesthetized": "anesthetized", + "anaesthetizes": "anesthetizes", + "anaesthetizing": "anesthetizing", + "analogue": "analog", + "analogues": "analogs", + "analyse": "analyze", + "analysed": "analyzed", + "analyses": "analyzes", + "analysing": "analyzing", + "anglicise": "anglicize", + "anglicised": "anglicized", + "anglicises": "anglicizes", + "anglicising": "anglicizing", + "annualised": "annualized", + "antagonise": "antagonize", + "antagonised": "antagonized", + "antagonises": "antagonizes", + "antagonising": "antagonizing", + "apologise": "apologize", + "apologised": "apologized", + "apologises": "apologizes", + "apologising": "apologizing", + "appal": "appall", + "appals": "appalls", + "appetiser": "appetizer", + "appetisers": "appetizers", + "appetising": "appetizing", + "appetisingly": "appetizingly", + "arbour": "arbor", + "arbours": "arbors", + "archaeologically": "archeologically", + "archaeologist": "archeologist", + "archaeologists": "archeologists", + "archaeology": "archeology", + "archeological": "archaeological", + "ardour": "ardor", + "armour": "armor", + "armoured": "armored", + "armourer": "armorer", + "armourers": "armorers", + "armouries": "armories", + "armoury": "armory", + "artefact": "artifact", + "artefacts": "artifacts", + "authorise": "authorize", + "authorised": "authorized", + "authorises": "authorizes", + "authorising": "authorizing", + "axe": "ax", + "backpedalled": "backpedaled", + "backpedalling": "backpedaling", + "bannister": "banister", + "bannisters": "banisters", + "baptise": "baptize", + "baptised": "baptized", + "baptises": "baptizes", + "baptising": "baptizing", + "bastardise": "bastardize", + "bastardised": "bastardized", + "bastardises": "bastardizes", + "bastardising": "bastardizing", + "battleax": "battleaxe", + "baulk": "balk", + "baulked": "balked", + "baulking": "balking", + "baulks": "balks", + "bedevilled": "bedeviled", + "bedevilling": "bedeviling", + "behaviour": "behavior", + "behavioural": "behavioral", + "behaviourism": "behaviorism", + "behaviourist": "behaviorist", + "behaviourists": "behaviorists", + "behaviours": "behaviors", + "behove": "behoove", + "behoved": "behooved", + "behoves": "behooves", + "bejewelled": "bejeweled", + "belabour": "belabor", + "belaboured": "belabored", + "belabouring": "belaboring", + "belabours": "belabors", + "bevelled": "beveled", + "bevvies": "bevies", + "bevvy": "bevy", + "biassed": "biased", + "biassing": "biasing", + "bingeing": "binging", + "bougainvillaea": "bougainvillea", + "bougainvillaeas": "bougainvilleas", + "bowdlerise": "bowdlerize", + "bowdlerised": "bowdlerized", + "bowdlerises": "bowdlerizes", + "bowdlerising": "bowdlerizing", + "breathalyse": "breathalyze", + "breathalysed": "breathalyzed", + "breathalyser": "breathalyzer", + "breathalysers": "breathalyzers", + "breathalyses": "breathalyzes", + "breathalysing": "breathalyzing", + "brutalise": "brutalize", + "brutalised": "brutalized", + "brutalises": "brutalizes", + "brutalising": "brutalizing", + "busses": "buses", + "bussing": "busing", + "caesarean": "cesarean", + "caesareans": "cesareans", + "calibre": "caliber", + "calibres": "calibers", + "calliper": "caliper", + "callipers": "calipers", + "callisthenics": "calisthenics", + "canalise": "canalize", + "canalised": "canalized", + "canalises": "canalizes", + "canalising": "canalizing", + "cancelation": "cancellation", + "cancelations": "cancellations", + "cancelled": "canceled", + "cancelling": "canceling", + "candour": "candor", + "cannibalise": "cannibalize", + "cannibalised": "cannibalized", + "cannibalises": "cannibalizes", + "cannibalising": "cannibalizing", + "canonise": "canonize", + "canonised": "canonized", + "canonises": "canonizes", + "canonising": "canonizing", + "capitalise": "capitalize", + "capitalised": "capitalized", + "capitalises": "capitalizes", + "capitalising": "capitalizing", + "caramelise": "caramelize", + "caramelised": "caramelized", + "caramelises": "caramelizes", + "caramelising": "caramelizing", + "carbonise": "carbonize", + "carbonised": "carbonized", + "carbonises": "carbonizes", + "carbonising": "carbonizing", + "carolled": "caroled", + "carolling": "caroling", + "catalogue": "catalog", + "catalogued": "cataloged", + "catalogues": "catalogs", + "cataloguing": "cataloging", + "catalyse": "catalyze", + "catalysed": "catalyzed", + "catalyses": "catalyzes", + "catalysing": "catalyzing", + "categorise": "categorize", + "categorised": "categorized", + "categorises": "categorizes", + "categorising": "categorizing", + "cauterise": "cauterize", + "cauterised": "cauterized", + "cauterises": "cauterizes", + "cauterising": "cauterizing", + "cavilled": "caviled", + "cavilling": "caviling", + "centigramme": "centigram", + "centigrammes": "centigrams", + "centilitre": "centiliter", + "centilitres": "centiliters", + "centimetre": "centimeter", + "centimetres": "centimeters", + "centralise": "centralize", + "centralised": "centralized", + "centralises": "centralizes", + "centralising": "centralizing", + "centre": "center", + "centred": "centered", + "centrefold": "centerfold", + "centrefolds": "centerfolds", + "centrepiece": "centerpiece", + "centrepieces": "centerpieces", + "centres": "centers", + "channelled": "channeled", + "channelling": "channeling", + "characterise": "characterize", + "characterised": "characterized", + "characterises": "characterizes", + "characterising": "characterizing", + "cheque": "check", + "chequebook": "checkbook", + "chequebooks": "checkbooks", + "chequered": "checkered", + "cheques": "checks", + "chilli": "chili", + "chimaera": "chimera", + "chimaeras": "chimeras", + "chiselled": "chiseled", + "chiselling": "chiseling", + "circularise": "circularize", + "circularised": "circularized", + "circularises": "circularizes", + "circularising": "circularizing", + "civilise": "civilize", + "civilised": "civilized", + "civilises": "civilizes", + "civilising": "civilizing", + "clamour": "clamor", + "clamoured": "clamored", + "clamouring": "clamoring", + "clamours": "clamors", + "clangour": "clangor", + "clarinettist": "clarinetist", + "clarinettists": "clarinetists", + "collectivise": "collectivize", + "collectivised": "collectivized", + "collectivises": "collectivizes", + "collectivising": "collectivizing", + "colonisation": "colonization", + "colonise": "colonize", + "colonised": "colonized", + "coloniser": "colonizer", + "colonisers": "colonizers", + "colonises": "colonizes", + "colonising": "colonizing", + "colour": "color", + "colourant": "colorant", + "colourants": "colorants", + "coloured": "colored", + "coloureds": "coloreds", + "colourful": "colorful", + "colourfully": "colorfully", + "colouring": "coloring", + "colourize": "colorize", + "colourized": "colorized", + "colourizes": "colorizes", + "colourizing": "colorizing", + "colourless": "colorless", + "colours": "colors", + "commercialise": "commercialize", + "commercialised": "commercialized", + "commercialises": "commercializes", + "commercialising": "commercializing", + "compartmentalise": "compartmentalize", + "compartmentalised": "compartmentalized", + "compartmentalises": "compartmentalizes", + "compartmentalising": "compartmentalizing", + "computerise": "computerize", + "computerised": "computerized", + "computerises": "computerizes", + "computerising": "computerizing", + "conceptualise": "conceptualize", + "conceptualised": "conceptualized", + "conceptualises": "conceptualizes", + "conceptualising": "conceptualizing", + "connexion": "connection", + "connexions": "connections", + "contextualise": "contextualize", + "contextualised": "contextualized", + "contextualises": "contextualizes", + "contextualising": "contextualizing", + "cosier": "cozier", + "cosies": "cozies", + "cosiest": "coziest", + "cosily": "cozily", + "cosiness": "coziness", + "cosy": "cozy", + "councillor": "councilor", + "councillors": "councilors", + "counselled": "counseled", + "counselling": "counseling", + "counsellor": "counselor", + "counsellors": "counselors", + "crenelated": "crenellated", + "criminalise": "criminalize", + "criminalised": "criminalized", + "criminalises": "criminalizes", + "criminalising": "criminalizing", + "criticise": "criticize", + "criticised": "criticized", + "criticises": "criticizes", + "criticising": "criticizing", + "crueller": "crueler", + "cruellest": "cruelest", + "crystallisation": "crystallization", + "crystallise": "crystallize", + "crystallised": "crystallized", + "crystallises": "crystallizes", + "crystallising": "crystallizing", + "cudgelled": "cudgeled", + "cudgelling": "cudgeling", + "customise": "customize", + "customised": "customized", + "customises": "customizes", + "customising": "customizing", + "cypher": "cipher", + "cyphers": "ciphers", + "decentralisation": "decentralization", + "decentralise": "decentralize", + "decentralised": "decentralized", + "decentralises": "decentralizes", + "decentralising": "decentralizing", + "decriminalisation": "decriminalization", + "decriminalise": "decriminalize", + "decriminalised": "decriminalized", + "decriminalises": "decriminalizes", + "decriminalising": "decriminalizing", + "defence": "defense", + "defenceless": "defenseless", + "defences": "defenses", + "dehumanisation": "dehumanization", + "dehumanise": "dehumanize", + "dehumanised": "dehumanized", + "dehumanises": "dehumanizes", + "dehumanising": "dehumanizing", + "demeanour": "demeanor", + "demilitarisation": "demilitarization", + "demilitarise": "demilitarize", + "demilitarised": "demilitarized", + "demilitarises": "demilitarizes", + "demilitarising": "demilitarizing", + "demobilisation": "demobilization", + "demobilise": "demobilize", + "demobilised": "demobilized", + "demobilises": "demobilizes", + "demobilising": "demobilizing", + "democratisation": "democratization", + "democratise": "democratize", + "democratised": "democratized", + "democratises": "democratizes", + "democratising": "democratizing", + "demonise": "demonize", + "demonised": "demonized", + "demonises": "demonizes", + "demonising": "demonizing", + "demoralisation": "demoralization", + "demoralise": "demoralize", + "demoralised": "demoralized", + "demoralises": "demoralizes", + "demoralising": "demoralizing", + "denationalisation": "denationalization", + "denationalise": "denationalize", + "denationalised": "denationalized", + "denationalises": "denationalizes", + "denationalising": "denationalizing", + "deodorise": "deodorize", + "deodorised": "deodorized", + "deodorises": "deodorizes", + "deodorising": "deodorizing", + "depersonalise": "depersonalize", + "depersonalised": "depersonalized", + "depersonalises": "depersonalizes", + "depersonalising": "depersonalizing", + "deputise": "deputize", + "deputised": "deputized", + "deputises": "deputizes", + "deputising": "deputizing", + "desensitisation": "desensitization", + "desensitise": "desensitize", + "desensitised": "desensitized", + "desensitises": "desensitizes", + "desensitising": "desensitizing", + "destabilisation": "destabilization", + "destabilise": "destabilize", + "destabilised": "destabilized", + "destabilises": "destabilizes", + "destabilising": "destabilizing", + "dialled": "dialed", + "dialling": "dialing", + "dialogue": "dialog", + "dialogues": "dialogs", + "diarrhoea": "diarrhea", + "digitise": "digitize", + "digitised": "digitized", + "digitises": "digitizes", + "digitising": "digitizing", + "disc": "disk", + "discolour": "discolor", + "discoloured": "discolored", + "discolouring": "discoloring", + "discolours": "discolors", + "discs": "disks", + "disembowelled": "disemboweled", + "disembowelling": "disemboweling", + "disfavour": "disfavor", + "dishevelled": "disheveled", + "dishonour": "dishonor", + "dishonourable": "dishonorable", + "dishonourably": "dishonorably", + "dishonoured": "dishonored", + "dishonouring": "dishonoring", + "dishonours": "dishonors", + "disorganisation": "disorganization", + "disorganised": "disorganized", + "distil": "distill", + "distils": "distills", + "dramatisation": "dramatization", + "dramatisations": "dramatizations", + "dramatise": "dramatize", + "dramatised": "dramatized", + "dramatises": "dramatizes", + "dramatising": "dramatizing", + "draught": "draft", + "draughtboard": "draftboard", + "draughtboards": "draftboards", + "draughtier": "draftier", + "draughtiest": "draftiest", + "draughts": "drafts", + "draughtsman": "draftsman", + "draughtsmanship": "draftsmanship", + "draughtsmen": "draftsmen", + "draughtswoman": "draftswoman", + "draughtswomen": "draftswomen", + "draughty": "drafty", + "drivelled": "driveled", + "drivelling": "driveling", + "duelled": "dueled", + "duelling": "dueling", + "economise": "economize", + "economised": "economized", + "economises": "economizes", + "economising": "economizing", + "editorialise": "editorialize", + "editorialised": "editorialized", + "editorialises": "editorializes", + "editorialising": "editorializing", + "edoema": "edema", + "empathise": "empathize", + "empathised": "empathized", + "empathises": "empathizes", + "empathising": "empathizing", + "emphasise": "emphasize", + "emphasised": "emphasized", + "emphasises": "emphasizes", + "emphasising": "emphasizing", + "enamelled": "enameled", + "enamelling": "enameling", + "enamoured": "enamored", + "encyclopaedia": "encyclopedia", + "encyclopaedias": "encyclopedias", + "encyclopaedic": "encyclopedic", + "endeavour": "endeavor", + "endeavoured": "endeavored", + "endeavouring": "endeavoring", + "endeavours": "endeavors", + "energise": "energize", + "energised": "energized", + "energises": "energizes", + "energising": "energizing", + "enrol": "enroll", + "enrols": "enrolls", + "enthral": "enthrall", + "enthrals": "enthralls", + "epaulette": "epaulet", + "epaulettes": "epaulets", + "epicentre": "epicenter", + "epicentres": "epicenters", + "epilogue": "epilog", + "epilogues": "epilogs", + "epitomise": "epitomize", + "epitomised": "epitomized", + "epitomises": "epitomizes", + "epitomising": "epitomizing", + "equalisation": "equalization", + "equalise": "equalize", + "equalised": "equalized", + "equaliser": "equalizer", + "equalisers": "equalizers", + "equalises": "equalizes", + "equalising": "equalizing", + "eulogise": "eulogize", + "eulogised": "eulogized", + "eulogises": "eulogizes", + "eulogising": "eulogizing", + "evangelise": "evangelize", + "evangelised": "evangelized", + "evangelises": "evangelizes", + "evangelising": "evangelizing", + "exorcise": "exorcize", + "exorcised": "exorcized", + "exorcises": "exorcizes", + "exorcising": "exorcizing", + "extemporisation": "extemporization", + "extemporise": "extemporize", + "extemporised": "extemporized", + "extemporises": "extemporizes", + "extemporising": "extemporizing", + "externalisation": "externalization", + "externalisations": "externalizations", + "externalise": "externalize", + "externalised": "externalized", + "externalises": "externalizes", + "externalising": "externalizing", + "factorise": "factorize", + "factorised": "factorized", + "factorises": "factorizes", + "factorising": "factorizing", + "faecal": "fecal", + "faeces": "feces", + "familiarisation": "familiarization", + "familiarise": "familiarize", + "familiarised": "familiarized", + "familiarises": "familiarizes", + "familiarising": "familiarizing", + "fantasise": "fantasize", + "fantasised": "fantasized", + "fantasises": "fantasizes", + "fantasising": "fantasizing", + "favour": "favor", + "favourable": "favorable", + "favourably": "favorably", + "favoured": "favored", + "favouring": "favoring", + "favourite": "favorite", + "favourites": "favorites", + "favouritism": "favoritism", + "favours": "favors", + "feminise": "feminize", + "feminised": "feminized", + "feminises": "feminizes", + "feminising": "feminizing", + "fertilisation": "fertilization", + "fertilise": "fertilize", + "fertilised": "fertilized", + "fertiliser": "fertilizer", + "fertilisers": "fertilizers", + "fertilises": "fertilizes", + "fertilising": "fertilizing", + "fervour": "fervor", + "fibre": "fiber", + "fibreglass": "fiberglass", + "fibres": "fibers", + "fictionalisation": "fictionalization", + "fictionalisations": "fictionalizations", + "fictionalise": "fictionalize", + "fictionalised": "fictionalized", + "fictionalises": "fictionalizes", + "fictionalising": "fictionalizing", + "fillet": "filet", + "filleted": "fileted", + "filleting": "fileting", + "fillets": "filets", + "finalisation": "finalization", + "finalise": "finalize", + "finalised": "finalized", + "finalises": "finalizes", + "finalising": "finalizing", + "flautist": "flutist", + "flautists": "flutists", + "flavour": "flavor", + "flavoured": "flavored", + "flavouring": "flavoring", + "flavourings": "flavorings", + "flavourless": "flavorless", + "flavours": "flavors", + "flavoursome": "flavorsome", + "flyer / flier": "flier / flyer", + "foetal": "fetal", + "foetid": "fetid", + "foetus": "fetus", + "foetuses": "fetuses", + "formalisation": "formalization", + "formalise": "formalize", + "formalised": "formalized", + "formalises": "formalizes", + "formalising": "formalizing", + "fossilisation": "fossilization", + "fossilise": "fossilize", + "fossilised": "fossilized", + "fossilises": "fossilizes", + "fossilising": "fossilizing", + "fraternisation": "fraternization", + "fraternise": "fraternize", + "fraternised": "fraternized", + "fraternises": "fraternizes", + "fraternising": "fraternizing", + "fulfil": "fulfill", + "fulfilment": "fulfillment", + "fulfils": "fulfills", + "funnelled": "funneled", + "funnelling": "funneling", + "gage": "gauge", + "gaged": "gauged", + "gages": "gauges", + "gaging": "gauging", + "galvanise": "galvanize", + "galvanised": "galvanized", + "galvanises": "galvanizes", + "galvanising": "galvanizing", + "gambolled": "gamboled", + "gambolling": "gamboling", + "gaol": "jail", + "gaolbird": "jailbird", + "gaolbirds": "jailbirds", + "gaolbreak": "jailbreak", + "gaolbreaks": "jailbreaks", + "gaoled": "jailed", + "gaoler": "jailer", + "gaolers": "jailers", + "gaoling": "jailing", + "gaols": "jails", + "gasses": "gases", + "generalisation": "generalization", + "generalisations": "generalizations", + "generalise": "generalize", + "generalised": "generalized", + "generalises": "generalizes", + "generalising": "generalizing", + "ghettoise": "ghettoize", + "ghettoised": "ghettoized", + "ghettoises": "ghettoizes", + "ghettoising": "ghettoizing", + "gipsies": "gypsies", + "glamor": "glamour", + "glamorise": "glamorize", + "glamorised": "glamorized", + "glamorises": "glamorizes", + "glamorising": "glamorizing", + "globalisation": "globalization", + "globalise": "globalize", + "globalised": "globalized", + "globalises": "globalizes", + "globalising": "globalizing", + "glueing": "gluing", + "goitre": "goiter", + "goitres": "goiters", + "gonorrhoea": "gonorrhea", + "gramme": "gram", + "grammes": "grams", + "gravelled": "graveled", + "grey": "gray", + "greyed": "grayed", + "greying": "graying", + "greyish": "grayish", + "greyness": "grayness", + "greys": "grays", + "grovelled": "groveled", + "grovelling": "groveling", + "groyne": "groin", + "groynes": "groins", + "gruelling": "grueling", + "gruellingly": "gruelingly", + "gryphon": "griffin", + "gryphons": "griffins", + "gynaecological": "gynecological", + "gynaecologist": "gynecologist", + "gynaecologists": "gynecologists", + "gynaecology": "gynecology", + "haematological": "hematological", + "haematologist": "hematologist", + "haematologists": "hematologists", + "haematology": "hematology", + "haemoglobin": "hemoglobin", + "haemophilia": "hemophilia", + "haemophiliac": "hemophiliac", + "haemophiliacs": "hemophiliacs", + "haemorrhage": "hemorrhage", + "haemorrhaged": "hemorrhaged", + "haemorrhages": "hemorrhages", + "haemorrhaging": "hemorrhaging", + "haemorrhoids": "hemorrhoids", + "harbour": "harbor", + "harboured": "harbored", + "harbouring": "harboring", + "harbours": "harbors", + "harmonisation": "harmonization", + "harmonise": "harmonize", + "harmonised": "harmonized", + "harmonises": "harmonizes", + "harmonising": "harmonizing", + "homoeopath": "homeopath", + "homoeopathic": "homeopathic", + "homoeopaths": "homeopaths", + "homoeopathy": "homeopathy", + "homogenise": "homogenize", + "homogenised": "homogenized", + "homogenises": "homogenizes", + "homogenising": "homogenizing", + "honour": "honor", + "honourable": "honorable", + "honourably": "honorably", + "honoured": "honored", + "honouring": "honoring", + "honours": "honors", + "hospitalisation": "hospitalization", + "hospitalise": "hospitalize", + "hospitalised": "hospitalized", + "hospitalises": "hospitalizes", + "hospitalising": "hospitalizing", + "humanise": "humanize", + "humanised": "humanized", + "humanises": "humanizes", + "humanising": "humanizing", + "humour": "humor", + "humoured": "humored", + "humouring": "humoring", + "humourless": "humorless", + "humours": "humors", + "hybridise": "hybridize", + "hybridised": "hybridized", + "hybridises": "hybridizes", + "hybridising": "hybridizing", + "hypnotise": "hypnotize", + "hypnotised": "hypnotized", + "hypnotises": "hypnotizes", + "hypnotising": "hypnotizing", + "hypothesise": "hypothesize", + "hypothesised": "hypothesized", + "hypothesises": "hypothesizes", + "hypothesising": "hypothesizing", + "idealisation": "idealization", + "idealise": "idealize", + "idealised": "idealized", + "idealises": "idealizes", + "idealising": "idealizing", + "idolise": "idolize", + "idolised": "idolized", + "idolises": "idolizes", + "idolising": "idolizing", + "immobilisation": "immobilization", + "immobilise": "immobilize", + "immobilised": "immobilized", + "immobiliser": "immobilizer", + "immobilisers": "immobilizers", + "immobilises": "immobilizes", + "immobilising": "immobilizing", + "immortalise": "immortalize", + "immortalised": "immortalized", + "immortalises": "immortalizes", + "immortalising": "immortalizing", + "immunisation": "immunization", + "immunise": "immunize", + "immunised": "immunized", + "immunises": "immunizes", + "immunising": "immunizing", + "impanelled": "impaneled", + "impanelling": "impaneling", + "imperilled": "imperiled", + "imperilling": "imperiling", + "individualise": "individualize", + "individualised": "individualized", + "individualises": "individualizes", + "individualising": "individualizing", + "industrialise": "industrialize", + "industrialised": "industrialized", + "industrialises": "industrializes", + "industrialising": "industrializing", + "inflexion": "inflection", + "inflexions": "inflections", + "initialise": "initialize", + "initialised": "initialized", + "initialises": "initializes", + "initialising": "initializing", + "initialled": "initialed", + "initialling": "initialing", + "instal": "install", + "instalment": "installment", + "instalments": "installments", + "instals": "installs", + "instil": "instill", + "instils": "instills", + "institutionalisation": "institutionalization", + "institutionalise": "institutionalize", + "institutionalised": "institutionalized", + "institutionalises": "institutionalizes", + "institutionalising": "institutionalizing", + "intellectualise": "intellectualize", + "intellectualised": "intellectualized", + "intellectualises": "intellectualizes", + "intellectualising": "intellectualizing", + "internalisation": "internalization", + "internalise": "internalize", + "internalised": "internalized", + "internalises": "internalizes", + "internalising": "internalizing", + "internationalisation": "internationalization", + "internationalise": "internationalize", + "internationalised": "internationalized", + "internationalises": "internationalizes", + "internationalising": "internationalizing", + "ionisation": "ionization", + "ionise": "ionize", + "ionised": "ionized", + "ioniser": "ionizer", + "ionisers": "ionizers", + "ionises": "ionizes", + "ionising": "ionizing", + "italicise": "italicize", + "italicised": "italicized", + "italicises": "italicizes", + "italicising": "italicizing", + "itemise": "itemize", + "itemised": "itemized", + "itemises": "itemizes", + "itemising": "itemizing", + "jeopardise": "jeopardize", + "jeopardised": "jeopardized", + "jeopardises": "jeopardizes", + "jeopardising": "jeopardizing", + "jewelled": "jeweled", + "jeweller": "jeweler", + "jewellers": "jewelers", + "jewellery": "jewelry", + "judgement": "judgment", + "kilogramme": "kilogram", + "kilogrammes": "kilograms", + "kilometre": "kilometer", + "kilometres": "kilometers", + "labelled": "labeled", + "labelling": "labeling", + "labour": "labor", + "laboured": "labored", + "labourer": "laborer", + "labourers": "laborers", + "labouring": "laboring", + "labours": "labors", + "lacklustre": "lackluster", + "legalisation": "legalization", + "legalise": "legalize", + "legalised": "legalized", + "legalises": "legalizes", + "legalising": "legalizing", + "legitimise": "legitimize", + "legitimised": "legitimized", + "legitimises": "legitimizes", + "legitimising": "legitimizing", + "leukaemia": "leukemia", + "levelled": "leveled", + "leveller": "leveler", + "levellers": "levelers", + "levelling": "leveling", + "libelled": "libeled", + "libelling": "libeling", + "libellous": "libelous", + "liberalisation": "liberalization", + "liberalise": "liberalize", + "liberalised": "liberalized", + "liberalises": "liberalizes", + "liberalising": "liberalizing", + "licence": "license", + "licenced": "licensed", + "licences": "licenses", + "licencing": "licensing", + "likeable": "likable", + "lionisation": "lionization", + "lionise": "lionize", + "lionised": "lionized", + "lionises": "lionizes", + "lionising": "lionizing", + "liquidise": "liquidize", + "liquidised": "liquidized", + "liquidiser": "liquidizer", + "liquidisers": "liquidizers", + "liquidises": "liquidizes", + "liquidising": "liquidizing", + "litre": "liter", + "litres": "liters", + "localise": "localize", + "localised": "localized", + "localises": "localizes", + "localising": "localizing", + "louvre": "louver", + "louvred": "louvered", + "louvres": "louvers", + "lustre": "luster", + "magnetise": "magnetize", + "magnetised": "magnetized", + "magnetises": "magnetizes", + "magnetising": "magnetizing", + "manoeuvrability": "maneuverability", + "manoeuvrable": "maneuverable", + "manoeuvre": "maneuver", + "manoeuvred": "maneuvered", + "manoeuvres": "maneuvers", + "manoeuvring": "maneuvering", + "manoeuvrings": "maneuverings", + "marginalisation": "marginalization", + "marginalise": "marginalize", + "marginalised": "marginalized", + "marginalises": "marginalizes", + "marginalising": "marginalizing", + "marshalled": "marshaled", + "marshalling": "marshaling", + "marvelled": "marveled", + "marvelling": "marveling", + "marvellous": "marvelous", + "marvellously": "marvelously", + "materialisation": "materialization", + "materialise": "materialize", + "materialised": "materialized", + "materialises": "materializes", + "materialising": "materializing", + "maximisation": "maximization", + "maximise": "maximize", + "maximised": "maximized", + "maximises": "maximizes", + "maximising": "maximizing", + "meagre": "meager", + "mechanisation": "mechanization", + "mechanise": "mechanize", + "mechanised": "mechanized", + "mechanises": "mechanizes", + "mechanising": "mechanizing", + "mediaeval": "medieval", + "memorialise": "memorialize", + "memorialised": "memorialized", + "memorialises": "memorializes", + "memorialising": "memorializing", + "memorise": "memorize", + "memorised": "memorized", + "memorises": "memorizes", + "memorising": "memorizing", + "mesmerise": "mesmerize", + "mesmerised": "mesmerized", + "mesmerises": "mesmerizes", + "mesmerising": "mesmerizing", + "metabolise": "metabolize", + "metabolised": "metabolized", + "metabolises": "metabolizes", + "metabolising": "metabolizing", + "metre": "meter", + "metres": "meters", + "mhm": "hmm", + "micrometre": "micrometer", + "micrometres": "micrometers", + "militarise": "militarize", + "militarised": "militarized", + "militarises": "militarizes", + "militarising": "militarizing", + "milligramme": "milligram", + "milligrammes": "milligrams", + "millilitre": "milliliter", + "millilitres": "milliliters", + "millimetre": "millimeter", + "millimetres": "millimeters", + "miniaturisation": "miniaturization", + "miniaturise": "miniaturize", + "miniaturised": "miniaturized", + "miniaturises": "miniaturizes", + "miniaturising": "miniaturizing", + "minibusses": "minibuses", + "minimise": "minimize", + "minimised": "minimized", + "minimises": "minimizes", + "minimising": "minimizing", + "misbehaviour": "misbehavior", + "misdemeanour": "misdemeanor", + "misdemeanours": "misdemeanors", + "misspelt": "misspelled", + "mitre": "miter", + "mitres": "miters", + "mm": "hmm", + "mmm": "hmm", + "mobilisation": "mobilization", + "mobilise": "mobilize", + "mobilised": "mobilized", + "mobilises": "mobilizes", + "mobilising": "mobilizing", + "modelled": "modeled", + "modeller": "modeler", + "modellers": "modelers", + "modelling": "modeling", + "modernise": "modernize", + "modernised": "modernized", + "modernises": "modernizes", + "modernising": "modernizing", + "moisturise": "moisturize", + "moisturised": "moisturized", + "moisturiser": "moisturizer", + "moisturisers": "moisturizers", + "moisturises": "moisturizes", + "moisturising": "moisturizing", + "monologue": "monolog", + "monologues": "monologs", + "monopolisation": "monopolization", + "monopolise": "monopolize", + "monopolised": "monopolized", + "monopolises": "monopolizes", + "monopolising": "monopolizing", + "moralise": "moralize", + "moralised": "moralized", + "moralises": "moralizes", + "moralising": "moralizing", + "motorised": "motorized", + "mould": "mold", + "moulded": "molded", + "moulder": "molder", + "mouldered": "moldered", + "mouldering": "moldering", + "moulders": "molders", + "mouldier": "moldier", + "mouldiest": "moldiest", + "moulding": "molding", + "mouldings": "moldings", + "moulds": "molds", + "mouldy": "moldy", + "moult": "molt", + "moulted": "molted", + "moulting": "molting", + "moults": "molts", + "moustache": "mustache", + "moustached": "mustached", + "moustaches": "mustaches", + "moustachioed": "mustachioed", + "multicoloured": "multicolored", + "nationalisation": "nationalization", + "nationalisations": "nationalizations", + "nationalise": "nationalize", + "nationalised": "nationalized", + "nationalises": "nationalizes", + "nationalising": "nationalizing", + "naturalisation": "naturalization", + "naturalise": "naturalize", + "naturalised": "naturalized", + "naturalises": "naturalizes", + "naturalising": "naturalizing", + "neighbour": "neighbor", + "neighbourhood": "neighborhood", + "neighbourhoods": "neighborhoods", + "neighbouring": "neighboring", + "neighbourliness": "neighborliness", + "neighbourly": "neighborly", + "neighbours": "neighbors", + "neutralisation": "neutralization", + "neutralise": "neutralize", + "neutralised": "neutralized", + "neutralises": "neutralizes", + "neutralising": "neutralizing", + "normalisation": "normalization", + "normalise": "normalize", + "normalised": "normalized", + "normalises": "normalizes", + "normalising": "normalizing", + "odour": "odor", + "odourless": "odorless", + "odours": "odors", + "oesophagus": "esophagus", + "oesophaguses": "esophaguses", + "oestrogen": "estrogen", + "offence": "offense", + "offences": "offenses", + "omelette": "omelet", + "omelettes": "omelets", + "optimise": "optimize", + "optimised": "optimized", + "optimises": "optimizes", + "optimising": "optimizing", + "organisation": "organization", + "organisational": "organizational", + "organisations": "organizations", + "organise": "organize", + "organised": "organized", + "organiser": "organizer", + "organisers": "organizers", + "organises": "organizes", + "organising": "organizing", + "orthopaedic": "orthopedic", + "orthopaedics": "orthopedics", + "ostracise": "ostracize", + "ostracised": "ostracized", + "ostracises": "ostracizes", + "ostracising": "ostracizing", + "outmanoeuvre": "outmaneuver", + "outmanoeuvred": "outmaneuvered", + "outmanoeuvres": "outmaneuvers", + "outmanoeuvring": "outmaneuvering", + "overemphasise": "overemphasize", + "overemphasised": "overemphasized", + "overemphasises": "overemphasizes", + "overemphasising": "overemphasizing", + "oxidisation": "oxidization", + "oxidise": "oxidize", + "oxidised": "oxidized", + "oxidises": "oxidizes", + "oxidising": "oxidizing", + "paederast": "pederast", + "paederasts": "pederasts", + "paediatric": "pediatric", + "paediatrician": "pediatrician", + "paediatricians": "pediatricians", + "paediatrics": "pediatrics", + "paedophile": "pedophile", + "paedophiles": "pedophiles", + "paedophilia": "pedophilia", + "palaeolithic": "paleolithic", + "palaeontologist": "paleontologist", + "palaeontologists": "paleontologists", + "palaeontology": "paleontology", + "panelled": "paneled", + "panelling": "paneling", + "panellist": "panelist", + "panellists": "panelists", + "paralyse": "paralyze", + "paralysed": "paralyzed", + "paralyses": "paralyzes", + "paralysing": "paralyzing", + "parcelled": "parceled", + "parcelling": "parceling", + "parlour": "parlor", + "parlours": "parlors", + "particularise": "particularize", + "particularised": "particularized", + "particularises": "particularizes", + "particularising": "particularizing", + "passivisation": "passivization", + "passivise": "passivize", + "passivised": "passivized", + "passivises": "passivizes", + "passivising": "passivizing", + "pasteurisation": "pasteurization", + "pasteurise": "pasteurize", + "pasteurised": "pasteurized", + "pasteurises": "pasteurizes", + "pasteurising": "pasteurizing", + "patronise": "patronize", + "patronised": "patronized", + "patronises": "patronizes", + "patronising": "patronizing", + "patronisingly": "patronizingly", + "pedalled": "pedaled", + "pedalling": "pedaling", + "pedestrianisation": "pedestrianization", + "pedestrianise": "pedestrianize", + "pedestrianised": "pedestrianized", + "pedestrianises": "pedestrianizes", + "pedestrianising": "pedestrianizing", + "penalise": "penalize", + "penalised": "penalized", + "penalises": "penalizes", + "penalising": "penalizing", + "pencilled": "penciled", + "pencilling": "penciling", + "personalise": "personalize", + "personalised": "personalized", + "personalises": "personalizes", + "personalising": "personalizing", + "pharmacopoeia": "pharmacopeia", + "pharmacopoeias": "pharmacopeias", + "philosophise": "philosophize", + "philosophised": "philosophized", + "philosophises": "philosophizes", + "philosophising": "philosophizing", + "philtre": "filter", + "philtres": "filters", + "phoney": "phony", + "plagiarise": "plagiarize", + "plagiarised": "plagiarized", + "plagiarises": "plagiarizes", + "plagiarising": "plagiarizing", + "plough": "plow", + "ploughed": "plowed", + "ploughing": "plowing", + "ploughman": "plowman", + "ploughmen": "plowmen", + "ploughs": "plows", + "ploughshare": "plowshare", + "ploughshares": "plowshares", + "polarisation": "polarization", + "polarise": "polarize", + "polarised": "polarized", + "polarises": "polarizes", + "polarising": "polarizing", + "politicisation": "politicization", + "politicise": "politicize", + "politicised": "politicized", + "politicises": "politicizes", + "politicising": "politicizing", + "popularisation": "popularization", + "popularise": "popularize", + "popularised": "popularized", + "popularises": "popularizes", + "popularising": "popularizing", + "pouffe": "pouf", + "pouffes": "poufs", + "practise": "practice", + "practised": "practiced", + "practises": "practices", + "practising": "practicing", + "praesidium": "presidium", + "praesidiums": "presidiums", + "pressurisation": "pressurization", + "pressurise": "pressurize", + "pressurised": "pressurized", + "pressurises": "pressurizes", + "pressurising": "pressurizing", + "pretence": "pretense", + "pretences": "pretenses", + "primaeval": "primeval", + "prioritisation": "prioritization", + "prioritise": "prioritize", + "prioritised": "prioritized", + "prioritises": "prioritizes", + "prioritising": "prioritizing", + "privatisation": "privatization", + "privatisations": "privatizations", + "privatise": "privatize", + "privatised": "privatized", + "privatises": "privatizes", + "privatising": "privatizing", + "professionalisation": "professionalization", + "professionalise": "professionalize", + "professionalised": "professionalized", + "professionalises": "professionalizes", + "professionalising": "professionalizing", + "programme": "program", + "programmes": "programs", + "prologue": "prolog", + "prologues": "prologs", + "propagandise": "propagandize", + "propagandised": "propagandized", + "propagandises": "propagandizes", + "propagandising": "propagandizing", + "proselytise": "proselytize", + "proselytised": "proselytized", + "proselytiser": "proselytizer", + "proselytisers": "proselytizers", + "proselytises": "proselytizes", + "proselytising": "proselytizing", + "psychoanalyse": "psychoanalyze", + "psychoanalysed": "psychoanalyzed", + "psychoanalyses": "psychoanalyzes", + "psychoanalysing": "psychoanalyzing", + "publicise": "publicize", + "publicised": "publicized", + "publicises": "publicizes", + "publicising": "publicizing", + "pulverisation": "pulverization", + "pulverise": "pulverize", + "pulverised": "pulverized", + "pulverises": "pulverizes", + "pulverising": "pulverizing", + "pummelled": "pummel", + "pummelling": "pummeled", + "pyjama": "pajama", + "pyjamas": "pajamas", + "pzazz": "pizzazz", + "quarrelled": "quarreled", + "quarrelling": "quarreling", + "radicalise": "radicalize", + "radicalised": "radicalized", + "radicalises": "radicalizes", + "radicalising": "radicalizing", + "rancour": "rancor", + "randomise": "randomize", + "randomised": "randomized", + "randomises": "randomizes", + "randomising": "randomizing", + "rationalisation": "rationalization", + "rationalisations": "rationalizations", + "rationalise": "rationalize", + "rationalised": "rationalized", + "rationalises": "rationalizes", + "rationalising": "rationalizing", + "ravelled": "raveled", + "ravelling": "raveling", + "realisable": "realizable", + "realisation": "realization", + "realisations": "realizations", + "realise": "realize", + "realised": "realized", + "realises": "realizes", + "realising": "realizing", + "recognisable": "recognizable", + "recognisably": "recognizably", + "recognisance": "recognizance", + "recognise": "recognize", + "recognised": "recognized", + "recognises": "recognizes", + "recognising": "recognizing", + "reconnoitre": "reconnoiter", + "reconnoitred": "reconnoitered", + "reconnoitres": "reconnoiters", + "reconnoitring": "reconnoitering", + "refuelled": "refueled", + "refuelling": "refueling", + "regularisation": "regularization", + "regularise": "regularize", + "regularised": "regularized", + "regularises": "regularizes", + "regularising": "regularizing", + "remodelled": "remodeled", + "remodelling": "remodeling", + "remould": "remold", + "remoulded": "remolded", + "remoulding": "remolding", + "remoulds": "remolds", + "reorganisation": "reorganization", + "reorganisations": "reorganizations", + "reorganise": "reorganize", + "reorganised": "reorganized", + "reorganises": "reorganizes", + "reorganising": "reorganizing", + "revelled": "reveled", + "reveller": "reveler", + "revellers": "revelers", + "revelling": "reveling", + "revitalise": "revitalize", + "revitalised": "revitalized", + "revitalises": "revitalizes", + "revitalising": "revitalizing", + "revolutionise": "revolutionize", + "revolutionised": "revolutionized", + "revolutionises": "revolutionizes", + "revolutionising": "revolutionizing", + "rhapsodise": "rhapsodize", + "rhapsodised": "rhapsodized", + "rhapsodises": "rhapsodizes", + "rhapsodising": "rhapsodizing", + "rigour": "rigor", + "rigours": "rigors", + "ritualised": "ritualized", + "rivalled": "rivaled", + "rivalling": "rivaling", + "romanticise": "romanticize", + "romanticised": "romanticized", + "romanticises": "romanticizes", + "romanticising": "romanticizing", + "rumour": "rumor", + "rumoured": "rumored", + "rumours": "rumors", + "sabre": "saber", + "sabres": "sabers", + "saltpetre": "saltpeter", + "sanitise": "sanitize", + "sanitised": "sanitized", + "sanitises": "sanitizes", + "sanitising": "sanitizing", + "satirise": "satirize", + "satirised": "satirized", + "satirises": "satirizes", + "satirising": "satirizing", + "saviour": "savior", + "saviours": "saviors", + "savour": "savor", + "savoured": "savored", + "savouries": "savories", + "savouring": "savoring", + "savours": "savors", + "savoury": "savory", + "scandalise": "scandalize", + "scandalised": "scandalized", + "scandalises": "scandalizes", + "scandalising": "scandalizing", + "sceptic": "skeptic", + "sceptical": "skeptical", + "sceptically": "skeptically", + "scepticism": "skepticism", + "sceptics": "skeptics", + "sceptre": "scepter", + "sceptres": "scepters", + "scrutinise": "scrutinize", + "scrutinised": "scrutinized", + "scrutinises": "scrutinizes", + "scrutinising": "scrutinizing", + "secularisation": "secularization", + "secularise": "secularize", + "secularised": "secularized", + "secularises": "secularizes", + "secularising": "secularizing", + "sensationalise": "sensationalize", + "sensationalised": "sensationalized", + "sensationalises": "sensationalizes", + "sensationalising": "sensationalizing", + "sensitise": "sensitize", + "sensitised": "sensitized", + "sensitises": "sensitizes", + "sensitising": "sensitizing", + "sentimentalise": "sentimentalize", + "sentimentalised": "sentimentalized", + "sentimentalises": "sentimentalizes", + "sentimentalising": "sentimentalizing", + "sepulchre": "sepulcher", + "sepulchres": "sepulchers", + "serialisation": "serialization", + "serialisations": "serializations", + "serialise": "serialize", + "serialised": "serialized", + "serialises": "serializes", + "serialising": "serializing", + "sermonise": "sermonize", + "sermonised": "sermonized", + "sermonises": "sermonizes", + "sermonising": "sermonizing", + "sheikh": "sheik", + "shovelled": "shoveled", + "shovelling": "shoveling", + "shrivelled": "shriveled", + "shrivelling": "shriveling", + "signalise": "signalize", + "signalised": "signalized", + "signalises": "signalizes", + "signalising": "signalizing", + "signalled": "signaled", + "signalling": "signaling", + "smoulder": "smolder", + "smouldered": "smoldered", + "smouldering": "smoldering", + "smoulders": "smolders", + "snivelled": "sniveled", + "snivelling": "sniveling", + "snorkelled": "snorkeled", + "snorkelling": "snorkeling", + "snowplough": "snowplow", + "snowploughs": "snowplow", + "socialisation": "socialization", + "socialise": "socialize", + "socialised": "socialized", + "socialises": "socializes", + "socialising": "socializing", + "sodomise": "sodomize", + "sodomised": "sodomized", + "sodomises": "sodomizes", + "sodomising": "sodomizing", + "solemnise": "solemnize", + "solemnised": "solemnized", + "solemnises": "solemnizes", + "solemnising": "solemnizing", + "sombre": "somber", + "specialisation": "specialization", + "specialisations": "specializations", + "specialise": "specialize", + "specialised": "specialized", + "specialises": "specializes", + "specialising": "specializing", + "spectre": "specter", + "spectres": "specters", + "spiralled": "spiraled", + "spiralling": "spiraling", + "splendour": "splendor", + "splendours": "splendors", + "squirrelled": "squirreled", + "squirrelling": "squirreling", + "stabilisation": "stabilization", + "stabilise": "stabilize", + "stabilised": "stabilized", + "stabiliser": "stabilizer", + "stabilisers": "stabilizers", + "stabilises": "stabilizes", + "stabilising": "stabilizing", + "standardisation": "standardization", + "standardise": "standardize", + "standardised": "standardized", + "standardises": "standardizes", + "standardising": "standardizing", + "stencilled": "stenciled", + "stencilling": "stenciling", + "sterilisation": "sterilization", + "sterilisations": "sterilizations", + "sterilise": "sterilize", + "sterilised": "sterilized", + "steriliser": "sterilizer", + "sterilisers": "sterilizers", + "sterilises": "sterilizes", + "sterilising": "sterilizing", + "stigmatisation": "stigmatization", + "stigmatise": "stigmatize", + "stigmatised": "stigmatized", + "stigmatises": "stigmatizes", + "stigmatising": "stigmatizing", + "storey": "story", + "storeys": "stories", + "subsidisation": "subsidization", + "subsidise": "subsidize", + "subsidised": "subsidized", + "subsidiser": "subsidizer", + "subsidisers": "subsidizers", + "subsidises": "subsidizes", + "subsidising": "subsidizing", + "succour": "succor", + "succoured": "succored", + "succouring": "succoring", + "succours": "succors", + "sulphate": "sulfate", + "sulphates": "sulfates", + "sulphide": "sulfide", + "sulphides": "sulfides", + "sulphur": "sulfur", + "sulphurous": "sulfurous", + "summarise": "summarize", + "summarised": "summarized", + "summarises": "summarizes", + "summarising": "summarizing", + "swivelled": "swiveled", + "swivelling": "swiveling", + "symbolise": "symbolize", + "symbolised": "symbolized", + "symbolises": "symbolizes", + "symbolising": "symbolizing", + "sympathise": "sympathize", + "sympathised": "sympathized", + "sympathiser": "sympathizer", + "sympathisers": "sympathizers", + "sympathises": "sympathizes", + "sympathising": "sympathizing", + "synchronisation": "synchronization", + "synchronise": "synchronize", + "synchronised": "synchronized", + "synchronises": "synchronizes", + "synchronising": "synchronizing", + "synthesise": "synthesize", + "synthesised": "synthesized", + "synthesiser": "synthesizer", + "synthesisers": "synthesizers", + "synthesises": "synthesizes", + "synthesising": "synthesizing", + "syphon": "siphon", + "syphoned": "siphoned", + "syphoning": "siphoning", + "syphons": "siphons", + "systematisation": "systematization", + "systematise": "systematize", + "systematised": "systematized", + "systematises": "systematizes", + "systematising": "systematizing", + "tantalise": "tantalize", + "tantalised": "tantalized", + "tantalises": "tantalizes", + "tantalising": "tantalizing", + "tantalisingly": "tantalizingly", + "tasselled": "tasseled", + "technicolour": "technicolor", + "temporise": "temporize", + "temporised": "temporized", + "temporises": "temporizes", + "temporising": "temporizing", + "tenderise": "tenderize", + "tenderised": "tenderized", + "tenderises": "tenderizes", + "tenderising": "tenderizing", + "terrorise": "terrorize", + "terrorised": "terrorized", + "terrorises": "terrorizes", + "terrorising": "terrorizing", + "theatre": "theater", + "theatregoer": "theatergoer", + "theatregoers": "theatergoers", + "theatres": "theaters", + "theorise": "theorize", + "theorised": "theorized", + "theorises": "theorizes", + "theorising": "theorizing", + "tonne": "ton", + "tonnes": "tons", + "towelled": "toweled", + "towelling": "toweling", + "toxaemia": "toxemia", + "tranquillise": "tranquilize", + "tranquillised": "tranquilized", + "tranquilliser": "tranquilizer", + "tranquillisers": "tranquilizers", + "tranquillises": "tranquilizes", + "tranquillising": "tranquilizing", + "tranquillity": "tranquility", + "tranquillize": "tranquilize", + "tranquillized": "tranquilized", + "tranquillizer": "tranquilizer", + "tranquillizers": "tranquilizers", + "tranquillizes": "tranquilizes", + "tranquillizing": "tranquilizing", + "tranquilly": "tranquility", + "transistorised": "transistorized", + "traumatise": "traumatize", + "traumatised": "traumatized", + "traumatises": "traumatizes", + "traumatising": "traumatizing", + "travelled": "traveled", + "traveller": "traveler", + "travellers": "travelers", + "travelling": "traveling", + "travelog": "travelogue", + "travelogs": "travelogues", + "trialled": "trialed", + "trialling": "trialing", + "tricolour": "tricolor", + "tricolours": "tricolors", + "trivialise": "trivialize", + "trivialised": "trivialized", + "trivialises": "trivializes", + "trivialising": "trivializing", + "tumour": "tumor", + "tumours": "tumors", + "tunnelled": "tunneled", + "tunnelling": "tunneling", + "tyrannise": "tyrannize", + "tyrannised": "tyrannized", + "tyrannises": "tyrannizes", + "tyrannising": "tyrannizing", + "tyre": "tire", + "tyres": "tires", + "unauthorised": "unauthorized", + "uncivilised": "uncivilized", + "underutilised": "underutilized", + "unequalled": "unequaled", + "unfavourable": "unfavorable", + "unfavourably": "unfavorably", + "unionisation": "unionization", + "unionise": "unionize", + "unionised": "unionized", + "unionises": "unionizes", + "unionising": "unionizing", + "unorganised": "unorganized", + "unravelled": "unraveled", + "unravelling": "unraveling", + "unrecognisable": "unrecognizable", + "unrecognised": "unrecognized", + "unrivalled": "unrivaled", + "unsavoury": "unsavory", + "untrammelled": "untrammeled", + "urbanisation": "urbanization", + "urbanise": "urbanize", + "urbanised": "urbanized", + "urbanises": "urbanizes", + "urbanising": "urbanizing", + "utilisable": "utilizable", + "utilisation": "utilization", + "utilise": "utilize", + "utilised": "utilized", + "utilises": "utilizes", + "utilising": "utilizing", + "valour": "valor", + "vandalise": "vandalize", + "vandalised": "vandalized", + "vandalises": "vandalizes", + "vandalising": "vandalizing", + "vaporisation": "vaporization", + "vaporise": "vaporize", + "vaporised": "vaporized", + "vaporises": "vaporizes", + "vaporising": "vaporizing", + "vapour": "vapor", + "vapours": "vapors", + "verbalise": "verbalize", + "verbalised": "verbalized", + "verbalises": "verbalizes", + "verbalising": "verbalizing", + "victimisation": "victimization", + "victimise": "victimize", + "victimised": "victimized", + "victimises": "victimizes", + "victimising": "victimizing", + "videodisc": "videodisk", + "videodiscs": "videodisks", + "vigour": "vigor", + "visualisation": "visualization", + "visualisations": "visualizations", + "visualise": "visualize", + "visualised": "visualized", + "visualises": "visualizes", + "visualising": "visualizing", + "vocalisation": "vocalization", + "vocalisations": "vocalizations", + "vocalise": "vocalize", + "vocalised": "vocalized", + "vocalises": "vocalizes", + "vocalising": "vocalizing", + "vulcanised": "vulcanized", + "vulgarisation": "vulgarization", + "vulgarise": "vulgarize", + "vulgarised": "vulgarized", + "vulgarises": "vulgarizes", + "vulgarising": "vulgarizing", + "waggon": "wagon", + "waggons": "wagons", + "watercolour": "watercolor", + "watercolours": "watercolors", + "weaselled": "weaseled", + "weaselling": "weaseling", + "westernisation": "westernization", + "westernise": "westernize", + "westernised": "westernized", + "westernises": "westernizes", + "westernising": "westernizing", + "womanise": "womanize", + "womanised": "womanized", + "womaniser": "womanizer", + "womanisers": "womanizers", + "womanises": "womanizes", + "womanising": "womanizing", + "woollen": "woolen", + "woollens": "woolens", + "woollies": "woolies", + "woolly": "wooly", + "worshipped": "worshiped", + "worshipper": "worshiper", + "worshipping": "worshiping", + "yodelled": "yodeled", + "yodelling": "yodeling", + "yoghourt": "yogurt", + "yoghourts": "yogurts", + "yoghurt": "yogurt", + "yoghurts": "yogurts" +} + diff --git a/users/zeineldeen/experiments/canary_aed/nemo/normalizer/eval_utils.py b/users/zeineldeen/experiments/canary_aed/nemo/normalizer/eval_utils.py new file mode 100644 index 000000000..4e9276b50 --- /dev/null +++ b/users/zeineldeen/experiments/canary_aed/nemo/normalizer/eval_utils.py @@ -0,0 +1,157 @@ +import os +import glob +import json + +import evaluate +from collections import defaultdict + + +def read_manifest(manifest_path: str): + """ + Reads a manifest file (jsonl format) and returns a list of dictionaries containing samples. + """ + data = [] + with open(manifest_path, "r", encoding="utf-8") as f: + for line in f: + if len(line) > 0: + datum = json.loads(line) + data.append(datum) + return data + + +def write_manifest( + manifest_path, + references: list, + transcriptions: list, + model_id: str, + dataset_path: str, + dataset_name: str, + split: str, +): + """ + Writes a manifest file (jsonl format) and returns the path to the file. + + Args: + references: Ground truth reference texts. + transcriptions: Model predicted transcriptions. + model_id: String identifier for the model. + dataset_path: Path to the dataset. + dataset_name: Name of the dataset. + split: Dataset split name. + + Returns: + Path to the manifest file. + """ + model_id = model_id.replace("/", "-") + dataset_path = dataset_path.replace("/", "-") + dataset_name = dataset_name.replace("/", "-") + + if len(references) != len(transcriptions): + raise ValueError( + f"The number of samples in `ground_truths` ({len(references)}) " + f"must match `transcriptions` ({len(transcriptions)})." + ) + + basedir = "./results/" + if not os.path.exists(basedir): + os.makedirs(basedir) + + # manifest_path = os.path.join(basedir, f"MODEL_{model_id}_DATASET_{dataset_path}_{dataset_name}_{split}.jsonl") + + with open(manifest_path, "w", encoding="utf-8") as f: + for idx, (text, transcript) in enumerate(zip(references, transcriptions)): + datum = { + "audio_filepath": f"sample_{idx}", # dummy value for Speech Data Processor + "duration": 0.0, # dummy value for Speech Data Processor + "text": text, + "pred_text": transcript, + } + f.write(f"{json.dumps(datum, ensure_ascii=False)}\n") + return manifest_path + + +def score_results(directory: str, model_id: str = None): + """ + Scores all result files in a directory and returns a composite score over all evaluated datasets. + + Args: + directory: Path to the result directory, containing one or more jsonl files. + model_id: Optional, model name to filter out result files based on model name. + + Returns: + Composite score over all evaluated datasets and a dictionary of all results. + """ + + # Strip trailing slash + if directory.endswith(os.pathsep): + directory = directory[:-1] + + # Find all result files in the directory + result_files = list(glob.glob(f"{directory}/**/*.jsonl", recursive=True)) + result_files = list(sorted(result_files)) + + # Filter files belonging to a specific model id + if model_id is not None and model_id != "": + print("Filtering models by id:", model_id) + model_id = model_id.replace("/", "-") + result_files = [fp for fp in result_files if model_id in fp] + + # Check if any result files were found + if len(result_files) == 0: + raise ValueError(f"No result files found in {directory}") + + # Utility function to parse the file path and extract model id, dataset path, dataset name and split + def parse_filepath(fp: str): + model_index = fp.find("MODEL_") + fp = fp[model_index:] + ds_index = fp.find("DATASET_") + model_id = fp[:ds_index].replace("MODEL_", "").rstrip("_") + author_index = model_id.find("-") + model_id = model_id[:author_index] + "/" + model_id[author_index + 1 :] + + ds_fp = fp[ds_index:] + dataset_id = ds_fp.replace("DATASET_", "").rstrip(".jsonl") + return model_id, dataset_id + + # Compute results per dataset + results = {} + wer_metric = evaluate.load("wer") + + for result_file in result_files: + manifest = read_manifest(result_file) + model_id_of_file, dataset_id = parse_filepath(result_file) + + references = [datum["text"] for datum in manifest] + predictions = [datum["pred_text"] for datum in manifest] + + wer = wer_metric.compute(references=references, predictions=predictions) + wer = round(100 * wer, 2) + + result_key = f"{model_id_of_file} | {dataset_id}" + results[result_key] = wer + + print("*" * 80) + print("Results per dataset:") + print("*" * 80) + + for k, v in results.items(): + print(f"{k}: WER = {v:0.2f} %") + + # composite WER should be computed over all datasets and with the same key + composite_wer = defaultdict(float) + count_entries = defaultdict(int) + for k, v in results.items(): + key = k.split("|")[0].strip() + composite_wer[key] += v + count_entries[key] += 1 + + # normalize scores & print + print() + print("*" * 80) + print("Composite WER:") + print("*" * 80) + for k, v in composite_wer.items(): + wer = v / count_entries[k] + print(f"{k}: WER = {wer:0.2f} %") + print("*" * 80) + return composite_wer, results diff --git a/users/zeineldeen/experiments/canary_aed/nemo/normalizer/normalizer.py b/users/zeineldeen/experiments/canary_aed/nemo/normalizer/normalizer.py new file mode 100644 index 000000000..6fc418b93 --- /dev/null +++ b/users/zeineldeen/experiments/canary_aed/nemo/normalizer/normalizer.py @@ -0,0 +1,596 @@ +# Copyright 2022 The OpenAI team and The HuggingFace Team. All rights reserved. +# Most of the code is copy pasted from the original whisper repository +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import re +import unicodedata +from fractions import Fraction +from typing import Iterator, List, Match, Optional, Union +from .english_abbreviations import english_spelling_normalizer + +import regex + + +# non-ASCII letters that are not separated by "NFKD" normalization +ADDITIONAL_DIACRITICS = { + "œ": "oe", + "Œ": "OE", + "ø": "o", + "Ø": "O", + "æ": "ae", + "Æ": "AE", + "ß": "ss", + "ẞ": "SS", + "đ": "d", + "Đ": "D", + "ð": "d", + "Ð": "D", + "þ": "th", + "Þ": "th", + "ł": "l", + "Ł": "L", +} + + +def remove_symbols_and_diacritics(s: str, keep=""): + """ + Replace any other markers, symbols, and punctuations with a space, and drop any diacritics (category 'Mn' and some + manual mappings) + """ + + def replace_character(char): + if char in keep: + return char + elif char in ADDITIONAL_DIACRITICS: + return ADDITIONAL_DIACRITICS[char] + + elif unicodedata.category(char) == "Mn": + return "" + + elif unicodedata.category(char)[0] in "MSP": + return " " + + return char + + return "".join(replace_character(c) for c in unicodedata.normalize("NFKD", s)) + + +def remove_symbols(s: str): + """ + Replace any other markers, symbols, punctuations with a space, keeping diacritics + """ + return "".join(" " if unicodedata.category(c)[0] in "MSP" else c for c in unicodedata.normalize("NFKC", s)) + + +class BasicTextNormalizer: + def __init__(self, remove_diacritics: bool = False, split_letters: bool = False): + self.clean = remove_symbols_and_diacritics if remove_diacritics else remove_symbols + self.split_letters = split_letters + + def __call__(self, s: str): + s = s.lower() + s = re.sub(r"[<\[][^>\]]*[>\]]", "", s) # remove words between brackets + s = re.sub(r"\(([^)]+?)\)", "", s) # remove words between parenthesis + s = self.clean(s).lower() + + if self.split_letters: + s = " ".join(regex.findall(r"\X", s, regex.U)) + + s = re.sub(r"\s+", " ", s) # replace any successive whitespace characters with a space + + return s + + +class EnglishNumberNormalizer: + """ + Convert any spelled-out numbers into arabic numbers, while handling: + + - remove any commas + - keep the suffixes such as: `1960s`, `274th`, `32nd`, etc. + - spell out currency symbols after the number. e.g. `$20 million` -> `20000000 dollars` + - spell out `one` and `ones` + - interpret successive single-digit numbers as nominal: `one oh one` -> `101` + """ + + def __init__(self): + super().__init__() + + self.zeros = {"o", "oh", "zero"} + # fmt: off + self.ones = { + name: i + for i, name in enumerate( + ["one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen"], + start=1, + ) + } + # fmt: on + self.ones_plural = { + "sixes" if name == "six" else name + "s": (value, "s") for name, value in self.ones.items() + } + self.ones_ordinal = { + "zeroth": (0, "th"), + "first": (1, "st"), + "second": (2, "nd"), + "third": (3, "rd"), + "fifth": (5, "th"), + "twelfth": (12, "th"), + **{ + name + ("h" if name.endswith("t") else "th"): (value, "th") + for name, value in self.ones.items() + if value > 3 and value != 5 and value != 12 + }, + } + self.ones_suffixed = {**self.ones_plural, **self.ones_ordinal} + + self.tens = { + "twenty": 20, + "thirty": 30, + "forty": 40, + "fifty": 50, + "sixty": 60, + "seventy": 70, + "eighty": 80, + "ninety": 90, + } + self.tens_plural = {name.replace("y", "ies"): (value, "s") for name, value in self.tens.items()} + self.tens_ordinal = {name.replace("y", "ieth"): (value, "th") for name, value in self.tens.items()} + self.tens_suffixed = {**self.tens_plural, **self.tens_ordinal} + + self.multipliers = { + "hundred": 100, + "thousand": 1_000, + "million": 1_000_000, + "billion": 1_000_000_000, + "trillion": 1_000_000_000_000, + "quadrillion": 1_000_000_000_000_000, + "quintillion": 1_000_000_000_000_000_000, + "sextillion": 1_000_000_000_000_000_000_000, + "septillion": 1_000_000_000_000_000_000_000_000, + "octillion": 1_000_000_000_000_000_000_000_000_000, + "nonillion": 1_000_000_000_000_000_000_000_000_000_000, + "decillion": 1_000_000_000_000_000_000_000_000_000_000_000, + } + self.multipliers_plural = {name + "s": (value, "s") for name, value in self.multipliers.items()} + self.multipliers_ordinal = {name + "th": (value, "th") for name, value in self.multipliers.items()} + self.multipliers_suffixed = {**self.multipliers_plural, **self.multipliers_ordinal} + self.decimals = {*self.ones, *self.tens, *self.zeros} + + self.preceding_prefixers = { + "minus": "-", + "negative": "-", + "plus": "+", + "positive": "+", + } + self.following_prefixers = { + "pound": "£", + "pounds": "£", + "euro": "€", + "euros": "€", + "dollar": "$", + "dollars": "$", + "cent": "¢", + "cents": "¢", + } + self.prefixes = set(list(self.preceding_prefixers.values()) + list(self.following_prefixers.values())) + self.suffixers = { + "per": {"cent": "%"}, + "percent": "%", + } + self.specials = {"and", "double", "triple", "point"} + + self.words = { + key + for mapping in [ + self.zeros, + self.ones, + self.ones_suffixed, + self.tens, + self.tens_suffixed, + self.multipliers, + self.multipliers_suffixed, + self.preceding_prefixers, + self.following_prefixers, + self.suffixers, + self.specials, + ] + for key in mapping + } + self.literal_words = {"one", "ones"} + + def process_words(self, words: List[str]) -> Iterator[str]: + prefix: Optional[str] = None + value: Optional[Union[str, int]] = None + skip = False + + def to_fraction(s: str): + try: + return Fraction(s) + except ValueError: + return None + + def output(result: Union[str, int]): + nonlocal prefix, value + result = str(result) + if prefix is not None: + result = prefix + result + value = None + prefix = None + return result + + if len(words) == 0: + return + + for i, current in enumerate(words): + prev = words[i - 1] if i != 0 else None + next = words[i + 1] if i != len(words) - 1 else None + if skip: + skip = False + continue + + next_is_numeric = next is not None and re.match(r"^\d+(\.\d+)?$", next) + has_prefix = current[0] in self.prefixes + current_without_prefix = current[1:] if has_prefix else current + if re.match(r"^\d+(\.\d+)?$", current_without_prefix): + # arabic numbers (potentially with signs and fractions) + f = to_fraction(current_without_prefix) + if f is None: + raise ValueError("Converting the fraction failed") + + if value is not None: + if isinstance(value, str) and value.endswith("."): + # concatenate decimals / ip address components + value = str(value) + str(current) + continue + else: + yield output(value) + + prefix = current[0] if has_prefix else prefix + if f.denominator == 1: + value = f.numerator # store integers as int + else: + value = current_without_prefix + elif current not in self.words: + # non-numeric words + if value is not None: + yield output(value) + yield output(current) + elif current in self.zeros: + value = str(value or "") + "0" + elif current in self.ones: + ones = self.ones[current] + + if value is None: + value = ones + elif isinstance(value, str) or prev in self.ones: + if prev in self.tens and ones < 10: # replace the last zero with the digit + value = value[:-1] + str(ones) + else: + value = str(value) + str(ones) + elif ones < 10: + if value % 10 == 0: + value += ones + else: + value = str(value) + str(ones) + else: # eleven to nineteen + if value % 100 == 0: + value += ones + else: + value = str(value) + str(ones) + elif current in self.ones_suffixed: + # ordinal or cardinal; yield the number right away + ones, suffix = self.ones_suffixed[current] + if value is None: + yield output(str(ones) + suffix) + elif isinstance(value, str) or prev in self.ones: + if prev in self.tens and ones < 10: + yield output(value[:-1] + str(ones) + suffix) + else: + yield output(str(value) + str(ones) + suffix) + elif ones < 10: + if value % 10 == 0: + yield output(str(value + ones) + suffix) + else: + yield output(str(value) + str(ones) + suffix) + else: # eleven to nineteen + if value % 100 == 0: + yield output(str(value + ones) + suffix) + else: + yield output(str(value) + str(ones) + suffix) + value = None + elif current in self.tens: + tens = self.tens[current] + if value is None: + value = tens + elif isinstance(value, str): + value = str(value) + str(tens) + else: + if value % 100 == 0: + value += tens + else: + value = str(value) + str(tens) + elif current in self.tens_suffixed: + # ordinal or cardinal; yield the number right away + tens, suffix = self.tens_suffixed[current] + if value is None: + yield output(str(tens) + suffix) + elif isinstance(value, str): + yield output(str(value) + str(tens) + suffix) + else: + if value % 100 == 0: + yield output(str(value + tens) + suffix) + else: + yield output(str(value) + str(tens) + suffix) + elif current in self.multipliers: + multiplier = self.multipliers[current] + if value is None: + value = multiplier + elif isinstance(value, str) or value == 0: + f = to_fraction(value) + p = f * multiplier if f is not None else None + if f is not None and p.denominator == 1: + value = p.numerator + else: + yield output(value) + value = multiplier + else: + before = value // 1000 * 1000 + residual = value % 1000 + value = before + residual * multiplier + elif current in self.multipliers_suffixed: + multiplier, suffix = self.multipliers_suffixed[current] + if value is None: + yield output(str(multiplier) + suffix) + elif isinstance(value, str): + f = to_fraction(value) + p = f * multiplier if f is not None else None + if f is not None and p.denominator == 1: + yield output(str(p.numerator) + suffix) + else: + yield output(value) + yield output(str(multiplier) + suffix) + else: # int + before = value // 1000 * 1000 + residual = value % 1000 + value = before + residual * multiplier + yield output(str(value) + suffix) + value = None + elif current in self.preceding_prefixers: + # apply prefix (positive, minus, etc.) if it precedes a number + if value is not None: + yield output(value) + + if next in self.words or next_is_numeric: + prefix = self.preceding_prefixers[current] + else: + yield output(current) + elif current in self.following_prefixers: + # apply prefix (dollars, cents, etc.) only after a number + if value is not None: + prefix = self.following_prefixers[current] + yield output(value) + else: + yield output(current) + elif current in self.suffixers: + # apply suffix symbols (percent -> '%') + if value is not None: + suffix = self.suffixers[current] + if isinstance(suffix, dict): + if next in suffix: + yield output(str(value) + suffix[next]) + skip = True + else: + yield output(value) + yield output(current) + else: + yield output(str(value) + suffix) + else: + yield output(current) + elif current in self.specials: + if next not in self.words and not next_is_numeric: + # apply special handling only if the next word can be numeric + if value is not None: + yield output(value) + yield output(current) + elif current == "and": + # ignore "and" after hundreds, thousands, etc. + if prev not in self.multipliers: + if value is not None: + yield output(value) + yield output(current) + elif current == "double" or current == "triple": + if next in self.ones or next in self.zeros: + repeats = 2 if current == "double" else 3 + ones = self.ones.get(next, 0) + value = str(value or "") + str(ones) * repeats + skip = True + else: + if value is not None: + yield output(value) + yield output(current) + elif current == "point": + if next in self.decimals or next_is_numeric: + value = str(value or "") + "." + else: + # should all have been covered at this point + raise ValueError(f"Unexpected token: {current}") + else: + # all should have been covered at this point + raise ValueError(f"Unexpected token: {current}") + + if value is not None: + yield output(value) + + def preprocess(self, s: str): + # replace " and a half" with " point five" + results = [] + + segments = re.split(r"\band\s+a\s+half\b", s) + for i, segment in enumerate(segments): + if len(segment.strip()) == 0: + continue + if i == len(segments) - 1: + results.append(segment) + else: + results.append(segment) + last_word = segment.rsplit(maxsplit=2)[-1] + if last_word in self.decimals or last_word in self.multipliers: + results.append("point five") + else: + results.append("and a half") + + s = " ".join(results) + + # put a space at number/letter boundary + s = re.sub(r"([a-z])([0-9])", r"\1 \2", s) + s = re.sub(r"([0-9])([a-z])", r"\1 \2", s) + + # but remove spaces which could be a suffix + s = re.sub(r"([0-9])\s+(st|nd|rd|th|s)\b", r"\1\2", s) + + return s + + def postprocess(self, s: str): + def combine_cents(m: Match): + try: + currency = m.group(1) + integer = m.group(2) + cents = int(m.group(3)) + return f"{currency}{integer}.{cents:02d}" + except ValueError: + return m.string + + def extract_cents(m: Match): + try: + return f"¢{int(m.group(1))}" + except ValueError: + return m.string + + # apply currency postprocessing; "$2 and ¢7" -> "$2.07" + s = re.sub(r"([€£$])([0-9]+) (?:and )?¢([0-9]{1,2})\b", combine_cents, s) + s = re.sub(r"[€£$]0.([0-9]{1,2})\b", extract_cents, s) + + # write "one(s)" instead of "1(s)", just for the readability + s = re.sub(r"\b1(s?)\b", r"one\1", s) + + return s + + def __call__(self, s: str): + s = self.preprocess(s) + s = " ".join(word for word in self.process_words(s.split()) if word is not None) + s = self.postprocess(s) + + return s + + +class EnglishSpellingNormalizer: + """ + Applies British-American spelling mappings as listed in [1]. + + [1] https://www.tysto.com/uk-us-spelling-list.html + """ + + def __init__(self, english_spelling_mapping): + self.mapping = english_spelling_mapping + + def __call__(self, s: str): + return " ".join(self.mapping.get(word, word) for word in s.split()) + + +class EnglishTextNormalizer: + def __init__(self, english_spelling_mapping=english_spelling_normalizer): + self.ignore_patterns = r"\b(hmm|mm|mhm|mmm|uh|um)\b" + self.replacers = { + # common contractions + r"\bwon't\b": "will not", + r"\bcan't\b": "can not", + r"\blet's\b": "let us", + r"\bain't\b": "aint", + r"\by'all\b": "you all", + r"\bwanna\b": "want to", + r"\bgotta\b": "got to", + r"\bgonna\b": "going to", + r"\bi'ma\b": "i am going to", + r"\bimma\b": "i am going to", + r"\bwoulda\b": "would have", + r"\bcoulda\b": "could have", + r"\bshoulda\b": "should have", + r"\bma'am\b": "madam", + # contractions in titles/prefixes + r"\bmr\b": "mister ", + r"\bmrs\b": "missus ", + r"\bst\b": "saint ", + r"\bdr\b": "doctor ", + r"\bprof\b": "professor ", + r"\bcapt\b": "captain ", + r"\bgov\b": "governor ", + r"\bald\b": "alderman ", + r"\bgen\b": "general ", + r"\bsen\b": "senator ", + r"\brep\b": "representative ", + r"\bpres\b": "president ", + r"\brev\b": "reverend ", + r"\bhon\b": "honorable ", + r"\basst\b": "assistant ", + r"\bassoc\b": "associate ", + r"\blt\b": "lieutenant ", + r"\bcol\b": "colonel ", + r"\bjr\b": "junior ", + r"\bsr\b": "senior ", + r"\besq\b": "esquire ", + # prefect tenses, ideally it should be any past participles, but it's harder.. + r"'d been\b": " had been", + r"'s been\b": " has been", + r"'d gone\b": " had gone", + r"'s gone\b": " has gone", + r"'d done\b": " had done", # "'s done" is ambiguous + r"'s got\b": " has got", + # general contractions + r"n't\b": " not", + r"'re\b": " are", + r"'s\b": " is", + r"'d\b": " would", + r"'ll\b": " will", + r"'t\b": " not", + r"'ve\b": " have", + r"'m\b": " am", + } + self.standardize_numbers = EnglishNumberNormalizer() + self.standardize_spellings = EnglishSpellingNormalizer(english_spelling_mapping) + + def __call__(self, s: str): + s = s.lower() + + s = re.sub(r"[<\[][^>\]]*[>\]]", "", s) # remove words between brackets + s = re.sub(r"\(([^)]+?)\)", "", s) # remove words between parenthesis + s = re.sub(self.ignore_patterns, "", s) + s = re.sub(r"\s+'", "'", s) # standardize when there's a space before an apostrophe + + for pattern, replacement in self.replacers.items(): + s = re.sub(pattern, replacement, s) + + s = re.sub(r"(\d),(\d)", r"\1\2", s) # remove commas between digits + s = re.sub(r"\.([^0-9]|$)", r" \1", s) # remove periods not followed by numbers + s = remove_symbols_and_diacritics(s, keep=".%$¢€£") # keep some symbols for numerics + + s = self.standardize_numbers(s) + s = self.standardize_spellings(s) + + # now remove prefix/suffix symbols that are not preceded/followed by numbers + s = re.sub(r"[.$¢€£]([^0-9])", r" \1", s) + s = re.sub(r"([^0-9])%", r"\1 ", s) + + s = re.sub(r"\s+", " ", s) # replace any successive whitespace characters with a space + + return s From a17ad44c1186de28d1f46a710f824c59d63a14d2 Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Wed, 12 Jun 2024 18:39:24 +0200 Subject: [PATCH 150/227] Create README.md --- users/zeineldeen/experiments/canary_aed/nemo/README.md | 1 + 1 file changed, 1 insertion(+) create mode 100644 users/zeineldeen/experiments/canary_aed/nemo/README.md diff --git a/users/zeineldeen/experiments/canary_aed/nemo/README.md b/users/zeineldeen/experiments/canary_aed/nemo/README.md new file mode 100644 index 000000000..601598cef --- /dev/null +++ b/users/zeineldeen/experiments/canary_aed/nemo/README.md @@ -0,0 +1 @@ +The `normalizer` folder is taken from here: https://github.com/huggingface/open_asr_leaderboard/tree/main/normalizer. The `write_manifest` function was modified in order to pass the manifest output path as parameter to the function. From aafdf607e0062b8f70d95b7a571653d74863ee23 Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Wed, 12 Jun 2024 18:42:15 +0200 Subject: [PATCH 151/227] Update README.md --- users/zeineldeen/experiments/canary_aed/nemo/README.md | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/users/zeineldeen/experiments/canary_aed/nemo/README.md b/users/zeineldeen/experiments/canary_aed/nemo/README.md index 601598cef..1757e566a 100644 --- a/users/zeineldeen/experiments/canary_aed/nemo/README.md +++ b/users/zeineldeen/experiments/canary_aed/nemo/README.md @@ -1 +1,4 @@ -The `normalizer` folder is taken from here: https://github.com/huggingface/open_asr_leaderboard/tree/main/normalizer. The `write_manifest` function was modified in order to pass the manifest output path as parameter to the function. +Some code here is based on: https://huggingface.co/spaces/hf-audio/open_asr_leaderboard + +- The `normalizer` folder is taken from here: https://github.com/huggingface/open_asr_leaderboard/tree/main/normalizer. The `write_manifest` function was modified in order to pass the manifest output path as parameter to the function. +- `run_eval.py` reads the dataset path and model path from input instead. From 0e1d235a42b1def90576c967578d4608f75e5cdb Mon Sep 17 00:00:00 2001 From: Simon Berger Date: Wed, 12 Jun 2024 19:31:16 +0200 Subject: [PATCH 152/227] Update users/berger --- users/berger/args/experiments/transducer.py | 2 +- users/berger/args/returnn/learning_rates.py | 1 - .../config_02b_transducer_rasr_features.py | 40 +++-- ...e_transducer_rasr_features_tinaconf_rtf.py | 148 +++++++++++++++--- ...ig_03b_transducer_fullsum_rasr_features.py | 13 +- .../models/context_1_transducer_tinaconf.py | 37 +++++ .../recognition/generic_seq2seq_search_v2.py | 5 +- users/berger/recipe/recognition/statistics.py | 33 +++- 8 files changed, 226 insertions(+), 53 deletions(-) diff --git a/users/berger/args/experiments/transducer.py b/users/berger/args/experiments/transducer.py index c5c37aa21..67b032755 100644 --- a/users/berger/args/experiments/transducer.py +++ b/users/berger/args/experiments/transducer.py @@ -68,7 +68,7 @@ def get_transducer_recog_step_args( "mem_rqmt": 16, }, "rtf": 50, - "mem": 4, + "mem": 8, } return recursive_update(default_args, kwargs) diff --git a/users/berger/args/returnn/learning_rates.py b/users/berger/args/returnn/learning_rates.py index 9845dce64..176129393 100644 --- a/users/berger/args/returnn/learning_rates.py +++ b/users/berger/args/returnn/learning_rates.py @@ -156,7 +156,6 @@ def get_oclr_function( **kwargs, ) -> str: initial_lr = initial_lr or peak_lr / 10 - decayed_lr = decayed_lr or initial_lr final_lr = final_lr or initial_lr / 5 cycle_epoch = cycle_epoch or (num_epochs * 9) // 20 # 45% of the training diff --git a/users/berger/configs/librispeech/20230210_baselines/config_02b_transducer_rasr_features.py b/users/berger/configs/librispeech/20230210_baselines/config_02b_transducer_rasr_features.py index 9970ae508..603fd7e8d 100644 --- a/users/berger/configs/librispeech/20230210_baselines/config_02b_transducer_rasr_features.py +++ b/users/berger/configs/librispeech/20230210_baselines/config_02b_transducer_rasr_features.py @@ -66,7 +66,10 @@ def generate_returnn_config( } if train: - (network_dict, extra_python,) = transducer_model.make_context_1_conformer_transducer( + ( + network_dict, + extra_python, + ) = transducer_model.make_context_1_conformer_transducer( num_outputs=num_classes, specaug_args=specaug_args, conformer_args={ @@ -408,18 +411,35 @@ def run_exp( recog_exp_names=["recog_ilm-0.3"], **recog_args, ) + + # switch to seq2seq v2 and run rescale experiments + + for data_input in data.data_inputs.values(): + data_input.create_lm_images(tools.rasr_binary_path) + system.init_corpora( + dev_keys=data.dev_keys, + test_keys=data.test_keys, + align_keys=data.align_keys, + corpus_data=data.data_inputs, + am_args=exp_args.transducer_recog_am_args, + ) + system.setup_scoring() recog_args["search_parameters"].update( { - "label-pruning": 11.0, + "label-pruning": 10.5, "label-pruning-limit": 300, "word-end-pruning": 0.5, "word-end-pruning-limit": 200, } ) + recog_args["seq2seq_v2"] = True + recog_args["rqmt_update"] = {"sbatch_args": ["-A", "rescale_speed", "-p", "rescale_amd"], "cpu": 2} + system.run_recog_step_for_corpora( exp_names=[f"Conformer_Transducer_Viterbi_specaug-v2_{name_suffix}"], + recog_exp_names=["recog_ilm-0.3"], corpora=["dev-other_4gram"], - recog_descriptor="lp-11_lpl-300_wep-0.5_wepl-200", + recog_descriptor="lp-10.5_lpl-300_wep-0.5_wepl-200", **recog_args, ) @@ -450,20 +470,8 @@ def run_exp( ), ) - for data_input in data.data_inputs.values(): - data_input.create_lm_images(tools.rasr_binary_path) - system.init_corpora( - dev_keys=data.dev_keys, - test_keys=data.test_keys, - align_keys=data.align_keys, - corpus_data=data.data_inputs, - am_args=exp_args.transducer_recog_am_args, - ) - system.setup_scoring() - recog_args.update( { - "seq2seq_v2": True, "label_scorer_type": "precomputed-log-posterior", "model_flow_args": {"output_layer_name": "output_precompute"}, } @@ -473,7 +481,7 @@ def run_exp( system.run_recog_step_for_corpora( exp_names=[f"Conformer_Transducer_Viterbi_specaug-v2_{name_suffix}"], corpora=["dev-other_4gram"], - recog_descriptor="lp-11_lpl-300_wep-0.5_wepl-200", + recog_descriptor="lp-10.5_lpl-300_wep-0.5_wepl-200", **recog_args, ) diff --git a/users/berger/configs/librispeech/20230210_baselines/config_02e_transducer_rasr_features_tinaconf_rtf.py b/users/berger/configs/librispeech/20230210_baselines/config_02e_transducer_rasr_features_tinaconf_rtf.py index a396a92d2..9a2ff9916 100644 --- a/users/berger/configs/librispeech/20230210_baselines/config_02e_transducer_rasr_features_tinaconf_rtf.py +++ b/users/berger/configs/librispeech/20230210_baselines/config_02e_transducer_rasr_features_tinaconf_rtf.py @@ -48,6 +48,7 @@ def generate_returnn_config( *, train_data_config: dict, dev_data_config: dict, + precompute: bool = False, **kwargs, ) -> ReturnnConfig: if train: @@ -84,24 +85,44 @@ def generate_returnn_config( loss_boost_v2=kwargs.get("loss_boost_v2", False), ) else: - network_dict, extra_python = transducer_model.make_context_1_conformer_transducer_recog( - num_inputs=50, - num_outputs=num_classes, - decoder_args={ - "dec_mlp_args": { - "num_layers": 2, - "size": 640, - "activation": "tanh", + if precompute: + network_dict, extra_python = transducer_model.make_context_1_conformer_transducer_precomputed_recog( + num_inputs=50, + num_outputs=num_classes, + decoder_args={ + "dec_mlp_args": { + "num_layers": 2, + "size": 640, + "activation": "tanh", + }, + "combination_mode": "concat", + "joint_mlp_args": { + "num_layers": 1, + "size": 1024, + "activation": "tanh", + }, + "ilm_scale": kwargs.get("ilm_scale", 0.0), }, - "combination_mode": "concat", - "joint_mlp_args": { - "num_layers": 1, - "size": 1024, - "activation": "tanh", + ) + else: + network_dict, extra_python = transducer_model.make_context_1_conformer_transducer_recog( + num_inputs=50, + num_outputs=num_classes, + decoder_args={ + "dec_mlp_args": { + "num_layers": 2, + "size": 640, + "activation": "tanh", + }, + "combination_mode": "concat", + "joint_mlp_args": { + "num_layers": 1, + "size": 1024, + "activation": "tanh", + }, + "ilm_scale": kwargs.get("ilm_scale", 0.0), }, - "ilm_scale": kwargs.get("ilm_scale", 0.0), - }, - ) + ) extra_config = { "train": train_data_config, @@ -134,7 +155,8 @@ def generate_returnn_config( python_prolog=[ "import sys", "sys.setrecursionlimit(10 ** 6)", - ], + ] + + (["from returnn.tf.util.data import FeatureDim"] if precompute else []), extra_python=extra_python, num_inputs=50, num_outputs=num_classes, @@ -281,13 +303,19 @@ def run_exp( returnn_configs = ReturnnConfigs( train_config=train_config, recog_configs={ - f"recog_ilm-{ilm_scale}": generate_returnn_config( + "recog_ilm-0.2": generate_returnn_config( train=False, - ilm_scale=ilm_scale, + ilm_scale=0.2, train_data_config=data.train_data_config, dev_data_config=data.cv_data_config, - ) - for ilm_scale in [0.2] + ), + "recog_ilm-0.2_precompute": generate_returnn_config( + train=False, + precompute=True, + ilm_scale=0.2, + train_data_config=data.train_data_config, + dev_data_config=data.cv_data_config, + ), }, ) @@ -311,7 +339,7 @@ def run_exp( ) recog_args["search_parameters"] = search_params descr = f"lp-{lp:.2f}_lpl-{lpl}_wep-{wep:.2f}_wepl-{wepl}" - # system.run_recog_step_for_corpora(corpora=["dev-other_4gram"], recog_descriptor=descr, **recog_args) + # system.run_recog_step_for_corpora(recog_exp_names=["recog_ilm-0.2"], corpora=["dev-other_4gram"], recog_descriptor=descr, **recog_args) for _ in range(10): lp = np.random.uniform(10.0, 13.0) @@ -328,7 +356,7 @@ def run_exp( ) recog_args["search_parameters"] = search_params descr = f"lp-{lp:.2f}_lpl-{lpl}_wep-{wep:.2f}_wepl-{wepl}" - # system.run_recog_step_for_corpora(corpora=["dev-other_4gram"], recog_descriptor=descr, **recog_args) + # system.run_recog_step_for_corpora(recog_exp_names=["recog_ilm-0.2"], corpora=["dev-other_4gram"], recog_descriptor=descr, **recog_args) for _ in range(20): lp = 12.0 @@ -345,7 +373,7 @@ def run_exp( ) recog_args["search_parameters"] = search_params descr = f"lp-{lp:.2f}_lpl-{lpl}_wep-{wep:.2f}_wepl-{wepl}" - # system.run_recog_step_for_corpora(corpora=["dev-other_4gram"], recog_descriptor=descr, **recog_args) + # system.run_recog_step_for_corpora(recog_exp_names=["recog_ilm-0.2"], corpora=["dev-other_4gram"], recog_descriptor=descr, **recog_args) for lp in [ 2.0, @@ -382,7 +410,9 @@ def run_exp( ) recog_args["search_parameters"] = search_params descr = f"lp-{lp:.2f}_lpl-300_wep-{wep:.2f}_wepl-200" - system.run_recog_step_for_corpora(corpora=["dev-other_4gram"], recog_descriptor=descr, **recog_args) + system.run_recog_step_for_corpora( + recog_exp_names=["recog_ilm-0.2"], corpora=["dev-other_4gram"], recog_descriptor=descr, **recog_args + ) for lp in [ 2.0, @@ -419,7 +449,73 @@ def run_exp( ) recog_args["search_parameters"] = search_params descr = f"lp-{lp:.2f}_lpl-1000_wep-{wep:.2f}_wepl-500" - system.run_recog_step_for_corpora(corpora=["dev-other_4gram"], recog_descriptor=descr, **recog_args) + system.run_recog_step_for_corpora( + recog_exp_names=["recog_ilm-0.2"], corpora=["dev-other_4gram"], recog_descriptor=descr, **recog_args + ) + + recog_args.update( + { + "seq2seq_v2": True, + "label_scorer_type": "precomputed-log-posterior", + "model_flow_args": {"output_layer_name": "output_precompute"}, + } + ) + for lp in [ + 9.0, + 10.0, + 10.5, + 11.0, + 11.5, + 12.0, + 12.5, + 13.0, + ]: + # for wep in [0.3, 0.5, 0.7]: + for wep in [0.5]: + search_params = get_seq2seq_search_parameters( + lp=lp, + lpl=300, + wep=wep, + wepl=200, + allow_blank=True, + allow_loop=False, + ) + recog_args["search_parameters"] = search_params + descr = f"lp-{lp:.2f}_lpl-300_wep-{wep:.2f}_wepl-200" + system.run_recog_step_for_corpora( + recog_exp_names=["recog_ilm-0.2_precompute"], + corpora=["dev-other_4gram"], + recog_descriptor=descr, + **recog_args, + ) + + for lp in [ + 9.0, + 10.0, + 10.5, + 11.0, + 11.5, + 12.0, + 12.5, + 13.0, + ]: + for wep in [0.5, 0.6]: + search_params = get_seq2seq_search_parameters( + lp=lp, + lpl=1000, + wep=wep, + wepl=500, + allow_blank=True, + allow_loop=False, + ) + recog_args["search_parameters"] = search_params + descr = f"lp-{lp:.2f}_lpl-1000_wep-{wep:.2f}_wepl-500" + # system.run_recog_step_for_corpora( + # recog_exp_names=["recog_ilm-0.2_precompute"], + # corpora=["dev-other_4gram"], + # recog_descriptor=descr, + # **recog_args, + # ) # system.run_dev_recog_step(**recog_args) # system.run_test_recog_step(**recog_args) diff --git a/users/berger/configs/librispeech/20230210_baselines/config_03b_transducer_fullsum_rasr_features.py b/users/berger/configs/librispeech/20230210_baselines/config_03b_transducer_fullsum_rasr_features.py index f0cf7ca0d..db0c6d156 100644 --- a/users/berger/configs/librispeech/20230210_baselines/config_03b_transducer_fullsum_rasr_features.py +++ b/users/berger/configs/librispeech/20230210_baselines/config_03b_transducer_fullsum_rasr_features.py @@ -49,7 +49,10 @@ def generate_returnn_config( **kwargs, ) -> ReturnnConfig: if train: - (network_dict, extra_python,) = transducer_model.make_context_1_conformer_transducer_fullsum( + ( + network_dict, + extra_python, + ) = transducer_model.make_context_1_conformer_transducer_fullsum( num_outputs=num_classes, specaug_args={ "max_time_num": 1, @@ -84,7 +87,10 @@ def generate_returnn_config( fullsum_v2=True, ) else: - (network_dict, extra_python,) = transducer_model.make_context_1_conformer_transducer_recog( + ( + network_dict, + extra_python, + ) = transducer_model.make_context_1_conformer_transducer_recog( num_outputs=num_classes, conformer_args={ "num_blocks": 12, @@ -286,7 +292,8 @@ def run_exp(alignments: Dict[str, AlignmentData], viterbi_model_checkpoint: Chec # recog_args["lm_scales"] = [0.8, 0.9] # for lm_lookahead_scale in [0.3, 0.4, 0.45, 0.5, 0.6]: recog_args["lm_scales"] = [0.9] - for lm_lookahead_scale in [0.3, 0.4, 0.45, 0.5, 0.6]: + # for lm_lookahead_scale in [0.3, 0.4, 0.45, 0.5, 0.6]: + for lm_lookahead_scale in [0.45]: recog_args["lookahead_options"].update({"lm_lookahead_scale": lm_lookahead_scale}) system.run_recog_step_for_corpora( diff --git a/users/berger/network/models/context_1_transducer_tinaconf.py b/users/berger/network/models/context_1_transducer_tinaconf.py index d4bd41e11..56390c480 100644 --- a/users/berger/network/models/context_1_transducer_tinaconf.py +++ b/users/berger/network/models/context_1_transducer_tinaconf.py @@ -155,3 +155,40 @@ def make_context_1_conformer_transducer_recog( ) return network, python_code + + +def make_context_1_conformer_transducer_precomputed_recog( + num_inputs: int, + num_outputs: int, + decoder_args: Dict = {}, +) -> Tuple[Dict, List]: + network = {} + python_code = [] + + network.update( + encoder.get_best_conformer_network( + size=512, + num_classes=num_outputs, + num_input_feature=num_inputs, + time_tag_name=None, + upsample_by_transposed_conv=False, + chunking="400:200", + label_smoothing=0.0, + additional_args={ + "feature_stacking": False, + "reduction_factor": (1, 4), + "use_spec_augment": False, + }, + ).network + ) + + network["encoder-output"] = { + "class": "copy", + "from": "encoder", + } + + label_context.add_precomputed_context_1_decoder_recog( + network, num_outputs=num_outputs, encoder="encoder-output", **decoder_args + ) + + return network, python_code diff --git a/users/berger/recipe/recognition/generic_seq2seq_search_v2.py b/users/berger/recipe/recognition/generic_seq2seq_search_v2.py index 134b9c0d9..c08d6b69c 100644 --- a/users/berger/recipe/recognition/generic_seq2seq_search_v2.py +++ b/users/berger/recipe/recognition/generic_seq2seq_search_v2.py @@ -49,7 +49,7 @@ def __init__( self.out_log_file = self.log_file_output_path("build_global_cache", crp, False) self.out_global_cache = self.output_path("global.cache", cached=True) - self.rqmt = {"time": 1, "cpu": 1, "mem": 4} + self.rqmt = {"time": 1, "cpu": 1, "mem": 8} def tasks(self): yield Task("create_files", mini_task=True) @@ -356,7 +356,8 @@ def create_config( if "minimum_representation" in la_opts: la_config.minimum_representation = la_opts["minimum_representation"] if "lm_lookahead_scale" in la_opts: - la_config.lm_lookahead_scale = la_opts["lm_lookahead_scale"] + # la_config.lm_lookahead_scale = la_opts["lm_lookahead_scale"] + la_config.scale = la_opts["lm_lookahead_scale"] if "cache_low" in la_opts: post_config.flf_lattice_tool.network.recognizer.recognizer.lm_lookahead.cache_size_low = la_opts[ "cache_low" diff --git a/users/berger/recipe/recognition/statistics.py b/users/berger/recipe/recognition/statistics.py index a0fc9e50a..a822bc391 100644 --- a/users/berger/recipe/recognition/statistics.py +++ b/users/berger/recipe/recognition/statistics.py @@ -108,13 +108,31 @@ def run(self): features = seg.find('./layer[@name="recognizer"]/statistics/frames[@port="features"]') seq_ss_statistics[full_name]["frames"] = int(features.attrib["number"]) + seq_ss_statistics[full_name]["encoder_fwd"] = 0.0 + for element in seg.iterfind( + './layer[@name="recognizer"]/information[@component="flf-lattice-tool.network.recognizer.label-scorer"]' + ): + if element.text.strip().startswith("encoder fwd time"): + seq_ss_statistics[full_name]["encoder_fwd"] = float(element.text.strip().split()[-1]) + break + + seq_ss_statistics[full_name]["decoder_fwd"] = 0.0 + for element in seg.iterfind( + './layer[@name="recognizer"]/information[@component="flf-lattice-tool.network.recognizer.label-scorer"]' + ): + if element.text.strip().startswith("decoder fwd time"): + seq_ss_statistics[full_name]["decoder_fwd"] = float(element.text.strip().split()[-1]) + break + tf_fwd = seg.find( './layer[@name="recognizer"]/information[@component="flf-lattice-tool.network.recognizer.feature-extraction.tf-fwd"]' ) if tf_fwd is not None: seq_ss_statistics[full_name]["tf_fwd"] = float(tf_fwd.text.strip().split()[-1]) else: - seq_ss_statistics[full_name]["tf_fwd"] = 0.0 + seq_ss_statistics[full_name]["tf_fwd"] = ( + seq_ss_statistics[full_name]["encoder_fwd"] + seq_ss_statistics[full_name]["decoder_fwd"] + ) eval_statistics[full_name] = {} for evaluation in seg.findall(".//evaluation"): @@ -131,7 +149,7 @@ def run(self): for stat, val in s.items(): if stat == "frames": pass - elif stat == "tf_fwd": + elif stat == "tf_fwd" or stat == "encoder_fwd" or stat == "decoder_fwd": prev_count, prev_frames = ss_statistics[stat] ss_statistics[stat] = ( prev_count + val, @@ -162,11 +180,18 @@ def run(self): self.rescoring_rtf.set(rescoring_time / (3600.0 * 1000.0 * self.corpus_duration)) self.tf_lm_time.set(lm_time / (3600.0 * 1000.0)) self.tf_lm_rtf.set(lm_time / (3600.0 * 1000.0 * self.corpus_duration)) - self.decoding_rtf.set((recognizer_time + rescoring_time) / (3600.0 * 1000.0 * self.corpus_duration)) + self.decoding_rtf.set( + (recognizer_time + rescoring_time) / (3600.0 * 1000.0 * self.corpus_duration) + - ss_statistics["encoder_fwd"] + - ss_statistics["decoder_fwd"] + ) self.ss_statistics.set(dict(ss_statistics.items())) self.seq_ss_statistics.set(seq_ss_statistics) self.eval_statistics.set(eval_statistics) - self.overall_rtf.set(self.recognizer_rtf + self.ss_statistics["tf_fwd"]) + if ss_statistics["encoder_fwd"] != 0 and ss_statistics["decoder_fwd"] != 0: + self.overall_rtf.set(self.recognizer_rtf.get()) + else: + self.overall_rtf.set(self.recognizer_rtf + ss_statistics["tf_fwd"]) class ExtractSearchStatisticsJobWeiV2(Job): From 47ba45c149177c47d350788b408793a01851c03f Mon Sep 17 00:00:00 2001 From: Simon Berger Date: Wed, 12 Jun 2024 19:33:27 +0200 Subject: [PATCH 153/227] Update users/berger --- users/berger/args/experiments/ctc.py | 2 +- users/berger/args/returnn/regularization.py | 2 +- .../20230602_rescale_baselines/__init__.py | 27 +- .../config_01_conformer_ctc.py | 47 +- ...ig_02_conformer_transducer_phon_viterbi.py | 298 +++++++++ ...onformer_transducer_phon_viterbi_tuning.py | 533 +++++++++++++++ .../config_03_blstm_ctc.py | 141 ---- ...ig_03_conformer_transducer_phon_fullsum.py | 283 ++++++++ ...onformer_transducer_phon_align_restrict.py | 275 ++++++++ users/berger/corpus/general/hdf.py | 34 +- .../corpus/tedlium2/phon_transducer_data.py | 21 +- .../tedlium2/viterbi_transducer_data.py | 113 ++++ users/berger/helpers/hdf.py | 9 +- .../pytorch/custom_parts/vgg_frontend.py | 327 +++++++-- users/berger/pytorch/forward/transducer.py | 23 +- .../pytorch/forward/transducer_beam_search.py | 7 +- .../pytorch/models/conformer_transducer_v2.py | 633 +++++++++++++----- .../berger/pytorch/train_steps/transducer.py | 263 +++++++- users/berger/recipe/returnn/onnx.py | 70 ++ .../recipe/returnn/optuna_returnn_training.py | 294 ++++---- .../alignment/optuna_legacy_alignment.py | 7 +- .../alignment/optuna_seq2seq_alignment.py | 8 +- .../functors/alignment/seq2seq_alignment.py | 47 +- .../systems/functors/optuna_rasr_base.py | 55 +- .../recognition/optuna_legacy_search.py | 14 +- .../recognition/optuna_seq2seq_search.py | 145 +++- .../functors/recognition/seq2seq_search.py | 8 +- users/berger/systems/functors/seq2seq_base.py | 9 +- .../training/optuna_returnn_training.py | 3 +- users/berger/systems/types.py | 1 - 30 files changed, 2964 insertions(+), 735 deletions(-) create mode 100644 users/berger/configs/tedlium2/20230602_rescale_baselines/config_02_conformer_transducer_phon_viterbi.py create mode 100644 users/berger/configs/tedlium2/20230602_rescale_baselines/config_02a_conformer_transducer_phon_viterbi_tuning.py delete mode 100644 users/berger/configs/tedlium2/20230602_rescale_baselines/config_03_blstm_ctc.py create mode 100644 users/berger/configs/tedlium2/20230602_rescale_baselines/config_03_conformer_transducer_phon_fullsum.py create mode 100644 users/berger/configs/tedlium2/20230602_rescale_baselines/config_05_conformer_transducer_phon_align_restrict.py create mode 100644 users/berger/corpus/tedlium2/viterbi_transducer_data.py diff --git a/users/berger/args/experiments/ctc.py b/users/berger/args/experiments/ctc.py index 32c0c90d9..b50ba678d 100644 --- a/users/berger/args/experiments/ctc.py +++ b/users/berger/args/experiments/ctc.py @@ -67,7 +67,7 @@ def get_ctc_recog_step_args(num_classes: int, reduction_factor: int = 4, **kwarg "mem_rqmt": 16, }, "rtf": 20, - "mem": 4, + "mem": 8, } return recursive_update(default_args, kwargs) diff --git a/users/berger/args/returnn/regularization.py b/users/berger/args/returnn/regularization.py index eda6ff7bf..afde3196b 100644 --- a/users/berger/args/returnn/regularization.py +++ b/users/berger/args/returnn/regularization.py @@ -13,7 +13,7 @@ def get_chunking_config( if isinstance(chunking_factors, list): chunking_factors = {key: 1 for key in chunking_factors} - assert isinstance(chunking_factors, Dict) + assert isinstance(chunking_factors, dict) return { "chunking": ( {key: base_chunk_size // factor for key, factor in chunking_factors.items()}, diff --git a/users/berger/configs/tedlium2/20230602_rescale_baselines/__init__.py b/users/berger/configs/tedlium2/20230602_rescale_baselines/__init__.py index a6c351e5a..5cebc69b1 100644 --- a/users/berger/configs/tedlium2/20230602_rescale_baselines/__init__.py +++ b/users/berger/configs/tedlium2/20230602_rescale_baselines/__init__.py @@ -1,13 +1,17 @@ +import getpass import copy from i6_experiments.users.berger.recipe.summary.report import SummaryReport from i6_experiments.users.berger.systems.dataclasses import SummaryKey from sisyphus import tk, gs - from .config_01_conformer_ctc import py as py_01 +from .config_02_conformer_transducer_phon_viterbi import py as py_02 +from .config_02a_conformer_transducer_phon_viterbi_tuning import py as py_02a +from .config_03_conformer_transducer_phon_fullsum import py as py_03 +from .config_05_conformer_transducer_phon_align_restrict import py as py_05 -from .config_04a_conformer_transducer_bpe import py as py_04a -from .config_04a_conformer_transducer_bpe_rasr import py as py_04a_rasr -from .config_04b_conformer_transducer_phon import py as py_04b +# from .config_04a_conformer_transducer_bpe import py as py_04a +# from .config_04a_conformer_transducer_bpe_rasr import py as py_04a_rasr +# from .config_04b_conformer_transducer_phon import py as py_04b def main() -> SummaryReport: @@ -46,11 +50,14 @@ def worker_wrapper(job, task_name, call): "ReturnnForwardComputePriorJob", "OptunaReturnnForwardComputePriorJob", "CompileKenLMJob", + "OptunaReportIntermediateScoreJob", + "OptunaReportFinalScoreJob", } onnx_jobs = { "ExportPyTorchModelToOnnxJob", "TorchOnnxExportJob", "OptunaExportPyTorchModelToOnnxJob", + "OptunaTorchOnnxExportJob", } jobclass = type(job).__name__ if jobclass in rasr_jobs: @@ -71,6 +78,9 @@ def worker_wrapper(job, task_name, call): "apptainer", "exec", ] + + app_call += ["--env", f"NUMBA_CACHE_DIR=/var/tmp/numba_cache_{getpass.getuser()}"] + if t._rqmt.get("gpu", 0) > 0: app_call += ["--nv"] @@ -88,10 +98,11 @@ def worker_wrapper(job, task_name, call): summary_report = SummaryReport() for subreport in [ - copy.deepcopy(py_01()), - copy.deepcopy(py_04a()), - copy.deepcopy(py_04a_rasr()), - copy.deepcopy(py_04b()), + copy.deepcopy(py_01()[0]), + copy.deepcopy(py_02()[0]), + copy.deepcopy(py_02a()), + copy.deepcopy(py_03()), + copy.deepcopy(py_05()), ]: subreport.collapse([SummaryKey.CORPUS.value], best_selector_key=SummaryKey.ERR.value) summary_report.merge_report(subreport, update_structure=True) diff --git a/users/berger/configs/tedlium2/20230602_rescale_baselines/config_01_conformer_ctc.py b/users/berger/configs/tedlium2/20230602_rescale_baselines/config_01_conformer_ctc.py index 7420c202f..ca75695d1 100644 --- a/users/berger/configs/tedlium2/20230602_rescale_baselines/config_01_conformer_ctc.py +++ b/users/berger/configs/tedlium2/20230602_rescale_baselines/config_01_conformer_ctc.py @@ -1,5 +1,6 @@ import copy import os +from typing import Dict, Tuple from i6_models.config import ModuleFactoryV1 from i6_core.returnn.config import ReturnnConfig @@ -12,7 +13,7 @@ from i6_experiments.users.berger.corpus.tedlium2.ctc_data import get_tedlium2_data_dumped_labels from i6_experiments.users.berger.pytorch.models import conformer_ctc from i6_experiments.users.berger.recipe.summary.report import SummaryReport -from i6_experiments.users.berger.systems.dataclasses import ConfigVariant, FeatureType, ReturnnConfigs +from i6_experiments.users.berger.systems.dataclasses import AlignmentData, ConfigVariant, FeatureType, ReturnnConfigs from i6_experiments.users.berger.systems.returnn_seq2seq_system import ( ReturnnSeq2SeqSystem, ) @@ -63,7 +64,7 @@ def returnn_config_generator( extra_python=[conformer_ctc.get_serializer(model_config, variant=variant)], extern_data_config=True, backend=Backend.PYTORCH, - grad_noise=kwargs.get("grad_noise", 0.0), + grad_noise=0.0, grad_clip=0.0, optimizer=Optimizers.AdamW, schedule=LearningRateSchedules.OCLR_STEP_TORCH, @@ -112,7 +113,7 @@ def get_returnn_config_collection( ) -def run_exp(num_subepochs: int = 250) -> SummaryReport: +def run_exp(num_subepochs: int = 250) -> Tuple[SummaryReport, Dict[str, AlignmentData]]: assert tools.returnn_root assert tools.returnn_python_exe assert tools.rasr_binary_path @@ -140,6 +141,13 @@ def run_exp(num_subepochs: int = 250) -> SummaryReport: search_stats=True, seq2seq_v2=True, ) + align_args = exp_args.get_ctc_align_step_args( + num_classes=num_outputs, + feature_type=FeatureType.LOGMEL_16K, + prior_scale=0.3, + epoch=num_subepochs, + register_output=True, + ) # ********** System ********** @@ -148,6 +156,7 @@ def run_exp(num_subepochs: int = 250) -> SummaryReport: system.init_corpora( dev_keys=data.dev_keys, test_keys=data.test_keys, + align_keys=data.align_keys, corpus_data=data.data_inputs, am_args=exp_args.ctc_recog_am_args, ) @@ -155,34 +164,34 @@ def run_exp(num_subepochs: int = 250) -> SummaryReport: # ********** Returnn Configs ********** - for grad_noise in [0.0, 0.1]: - system.add_experiment_configs( - f"Conformer_CTC_{num_subepochs}-epochs_gn-{grad_noise}", - get_returnn_config_collection( - train_data_config=data.train_data_config, - dev_data_config=data.cv_data_config, - num_subepochs=num_subepochs, - grad_noise=grad_noise, - ), - ) + system.add_experiment_configs( + f"Conformer_CTC_{num_subepochs}-epochs", + get_returnn_config_collection( + train_data_config=data.train_data_config, + dev_data_config=data.cv_data_config, + num_subepochs=num_subepochs, + ), + ) system.run_train_step(**train_args) system.run_dev_recog_step(**recog_args) + align_data = next(iter(system.run_align_step(**align_args).values())) assert system.summary_report - return system.summary_report + return system.summary_report, align_data -def py() -> SummaryReport: +def py() -> Tuple[SummaryReport, Dict[str, AlignmentData]]: filename_handle = os.path.splitext(os.path.basename(__file__))[0][len("config_") :] gs.ALIAS_AND_OUTPUT_SUBDIR = f"{filename_handle}/" summary_report = SummaryReport() - summary_report.merge_report(run_exp(num_subepochs=250), update_structure=True) - summary_report.merge_report(run_exp(num_subepochs=500), update_structure=True) - summary_report.merge_report(run_exp(num_subepochs=1000), update_structure=True) + summary_report.merge_report(run_exp(num_subepochs=250)[0], update_structure=True) + summary_report.merge_report(run_exp(num_subepochs=500)[0], update_structure=True) + report, align_data = run_exp(num_subepochs=1000) + summary_report.merge_report(report, update_structure=True) tk.register_report(f"{gs.ALIAS_AND_OUTPUT_SUBDIR}/summary.report", summary_report) - return summary_report + return summary_report, align_data diff --git a/users/berger/configs/tedlium2/20230602_rescale_baselines/config_02_conformer_transducer_phon_viterbi.py b/users/berger/configs/tedlium2/20230602_rescale_baselines/config_02_conformer_transducer_phon_viterbi.py new file mode 100644 index 000000000..65e6ddbde --- /dev/null +++ b/users/berger/configs/tedlium2/20230602_rescale_baselines/config_02_conformer_transducer_phon_viterbi.py @@ -0,0 +1,298 @@ +import copy +import os +from typing import Dict, List, Tuple + +import i6_core.rasr as rasr +from i6_core.returnn import PtCheckpoint +from i6_core.returnn.config import ReturnnConfig +from i6_experiments.users.berger.args.experiments import transducer as exp_args +from i6_experiments.users.berger.args.returnn.config import Backend, get_returnn_config +from i6_experiments.users.berger.args.returnn.learning_rates import LearningRateSchedules, Optimizers +from i6_experiments.users.berger.corpus.tedlium2.viterbi_transducer_data import get_tedlium2_data +from i6_experiments.users.berger.pytorch.custom_parts.identity import IdentityConfig, IdentityModule +from i6_experiments.users.berger.pytorch.models import conformer_transducer_v2 as model +from i6_experiments.users.berger.recipe.summary.report import SummaryReport +from i6_experiments.users.berger.systems.dataclasses import ( + AlignmentData, + EncDecConfig, + FeatureType, + ReturnnConfigs, + SummaryKey, +) +from i6_experiments.users.berger.systems.returnn_seq2seq_system import ReturnnSeq2SeqSystem +from i6_experiments.users.berger.util import default_tools_v2 +from i6_models.config import ModuleFactoryV1 +from sisyphus import gs, tk + +from .config_01_conformer_ctc import py as py_ctc + +# ********** Settings ********** + +rasr.flow.FlowNetwork.default_flags = {"cache_mode": "task_dependent"} + +num_outputs = 79 +num_subepochs = 500 + +tools = copy.deepcopy(default_tools_v2) +tools.rasr_binary_path = tk.Path("/u/berger/repositories/rasr_versions/gen_seq2seq_dev/arch/linux-x86_64-standard") + + +# ********** Return Config generators ********** + + +def returnn_config_generator( + train_data_config: dict, + dev_data_config: dict, + **kwargs, +) -> ReturnnConfig: + model_config = model.get_default_config_v1(num_outputs=num_outputs) + + extra_config = { + "train": train_data_config, + "dev": dev_data_config, + "max_seq_length": {"audio_features": 560000}, + "torch_amp": {"dtype": "bfloat16"}, + } + serializer = model.get_viterbi_train_serializer(model_config, enc_loss_scales={5: 0.3, 11: 1.0}, **kwargs) + + return get_returnn_config( + num_epochs=num_subepochs, + num_inputs=1, + num_outputs=num_outputs, + target="classes", + extra_python=[serializer], + extern_data_config=True, + backend=Backend.PYTORCH, + grad_noise=0.0, + grad_clip=0.0, + optimizer=Optimizers.AdamW, + weight_decay=5e-06, + schedule=LearningRateSchedules.OCLR, + initial_lr=8e-05, + peak_lr=kwargs.get("peak_lr", 8e-04), + decayed_lr=1e-05, + final_lr=1e-07, + batch_size=30000 * 160, + use_chunking=False, + extra_config=extra_config, + ) + + +def recog_returnn_configs_generator( + ilm_scale: float = 0.0, + **kwargs, +) -> EncDecConfig[ReturnnConfig]: + model_config = model.get_default_config_v1(num_outputs=num_outputs) + model_config.transcriber_cfg.feature_extraction = ModuleFactoryV1( + IdentityModule, + IdentityConfig(), + ) + if ilm_scale != 0: + model_config = model.FFNNTransducerWithIlmConfig( + transcriber_cfg=model_config.transcriber_cfg, + predictor_cfg=model_config.predictor_cfg, + joiner_cfg=model_config.joiner_cfg, + ilm_scale=ilm_scale, + ) + + enc_extra_config = { + "extern_data": { + "sources": {"dim": 80, "dtype": "float32"}, + }, + "model_outputs": { + "source_encodings": { + "dim": 384, + "dtype": "float32", + }, + }, + } + dec_extra_config = { + "extern_data": { + "source_encodings": { + "dim": 384, + "time_dim_axis": None, + "dtype": "float32", + }, + "history": { + "dim": num_outputs, + "time_dim_axis": None, + "sparse": True, + "shape": (1,), + "dtype": "int32", + }, + }, + "model_outputs": { + "log_probs": { + "dim": num_outputs, + "time_dim_axis": None, + "dtype": "float32", + } + }, + } + enc_serializer = model.get_encoder_recog_serializer(model_config, **kwargs) + dec_serializer = model.get_decoder_recog_serializer(model_config, **kwargs) + + return EncDecConfig( + encoder_config=get_returnn_config( + num_inputs=80, + num_outputs=num_outputs, + target=None, + extra_python=[enc_serializer], + extern_data_config=False, + backend=Backend.PYTORCH, + extra_config=enc_extra_config, + ), + decoder_config=get_returnn_config( + num_inputs=1, + num_outputs=num_outputs, + target=None, + extra_python=[dec_serializer], + extern_data_config=False, + backend=Backend.PYTORCH, + extra_config=dec_extra_config, + ), + ) + + +def get_returnn_config_collection( + train_data_config: dict, + dev_data_config: dict, + ilm_scales: List[float] = [0.0, 0.2], + **kwargs, +) -> ReturnnConfigs[ReturnnConfig]: + return ReturnnConfigs( + train_config=returnn_config_generator( + train_data_config=train_data_config, + dev_data_config=dev_data_config, + blank_id=0, + **kwargs, + ), + recog_configs={ + f"recog_ilm-{ilm_scale}": recog_returnn_configs_generator(ilm_scale=ilm_scale, **kwargs) + for ilm_scale in ilm_scales + }, + ) + + +def run_exp(alignments: Dict[str, AlignmentData]) -> Tuple[SummaryReport, PtCheckpoint]: + assert tools.returnn_root + assert tools.returnn_python_exe + assert tools.rasr_binary_path + data = get_tedlium2_data( + alignments=alignments, + returnn_root=tools.returnn_root, + returnn_python_exe=tools.returnn_python_exe, + rasr_binary_path=tools.rasr_binary_path, + augmented_lexicon=True, + feature_type=FeatureType.SAMPLES, + ) + + for data_input in data.data_inputs.values(): + data_input.create_lm_images(tools.rasr_binary_path) + + # ********** Step args ********** + + train_args = exp_args.get_transducer_train_step_args(num_epochs=num_subepochs, gpu_mem_rqmt=24) + recog_args = exp_args.get_transducer_recog_step_args( + num_classes=num_outputs, + epochs=[20, 40, 80, 160, 320, 480, num_subepochs], + label_scorer_type="onnx-ffnn-transducer", + label_scorer_args={"extra_args": {"start_label_index": 0}}, + reduction_subtrahend=3, + reduction_factor=4, + feature_type=FeatureType.LOGMEL_16K, + seq2seq_v2=True, + ) + + # ********** System ********** + + system = ReturnnSeq2SeqSystem( + tool_paths=tools, + summary_keys=[ + SummaryKey.TRAIN_NAME, + SummaryKey.RECOG_NAME, + SummaryKey.CORPUS, + SummaryKey.EPOCH, + SummaryKey.LM, + SummaryKey.WER, + SummaryKey.SUB, + SummaryKey.INS, + SummaryKey.DEL, + SummaryKey.ERR, + ], + summary_sort_keys=[SummaryKey.ERR, SummaryKey.CORPUS], + ) + + system.init_corpora( + dev_keys=data.dev_keys, + test_keys=data.test_keys, + corpus_data=data.data_inputs, + am_args=exp_args.transducer_recog_am_args, + ) + system.setup_scoring() + + # ********** Returnn Configs ********** + + system.add_experiment_configs( + "Conformer_Transducer_Viterbi", + get_returnn_config_collection( + data.train_data_config, + data.cv_data_config, + ), + ) + + system.run_train_step(**train_args) + system.run_dev_recog_step(**recog_args) + + system.add_experiment_configs( + "Conformer_Transducer_Viterbi", + get_returnn_config_collection( + data.train_data_config, + data.cv_data_config, + ilm_scales=[0.0, 0.1, 0.2, 0.3, 0.4, 0.5], + ), + ) + + recog_args.update( + { + "epochs": [320], + "lm_scales": [0.5, 0.7, 0.9, 1.1, 1.3, 1.5], + } + ) + for bp in [0.0, 0.5, 1.0, 2.0, 3.0]: + if bp != 0: + recog_args["search_parameters"]["blank-label-penalty"] = bp + system.run_dev_recog_step(recog_descriptor=f"bp-{bp}", **recog_args) + + recog_args.update( + { + "epochs": [num_subepochs], + "lm_scales": [0.5, 0.6, 0.7], + } + ) + for bp in [0.0, 0.5, 1.0]: + if bp != 0: + recog_args["search_parameters"]["blank-label-penalty"] = bp + system.run_dev_recog_step(recog_descriptor=f"bp-{bp}", **recog_args) + + model = system.get_train_job().out_checkpoints[num_subepochs] + assert isinstance(model, PtCheckpoint) + + assert system.summary_report + return system.summary_report, model + + +def py() -> Tuple[SummaryReport, PtCheckpoint]: + _, alignments = py_ctc() + filename_handle = os.path.splitext(os.path.basename(__file__))[0][len("config_") :] + gs.ALIAS_AND_OUTPUT_SUBDIR = f"{filename_handle}/" + + summary_report = SummaryReport() + + report, model = run_exp(alignments) + + summary_report.merge_report(report, update_structure=True) + + tk.register_report(f"{gs.ALIAS_AND_OUTPUT_SUBDIR}/summary.report", summary_report) + + return summary_report, model diff --git a/users/berger/configs/tedlium2/20230602_rescale_baselines/config_02a_conformer_transducer_phon_viterbi_tuning.py b/users/berger/configs/tedlium2/20230602_rescale_baselines/config_02a_conformer_transducer_phon_viterbi_tuning.py new file mode 100644 index 000000000..f1f69e84d --- /dev/null +++ b/users/berger/configs/tedlium2/20230602_rescale_baselines/config_02a_conformer_transducer_phon_viterbi_tuning.py @@ -0,0 +1,533 @@ +import copy +from enum import Enum, auto +import torch +import os +from pathlib import Path +from typing import Callable, Dict, List + +import optuna + +import i6_core.rasr as rasr +from i6_core.returnn.config import ReturnnConfig +from i6_experiments.users.berger.args.experiments import transducer as exp_args +from i6_experiments.users.berger.args.returnn.config import Backend, get_returnn_config +from i6_experiments.users.berger.args.returnn.learning_rates import LearningRateSchedules, Optimizers +from i6_experiments.users.berger.corpus.tedlium2.viterbi_transducer_data import get_tedlium2_data +from i6_experiments.users.berger.pytorch.custom_parts.identity import IdentityConfig, IdentityModule +from i6_experiments.users.berger.pytorch.models import conformer_transducer_v2 as model +from i6_experiments.users.berger.recipe.summary.report import SummaryReport +from i6_experiments.users.berger.systems.dataclasses import ( + AlignmentData, + EncDecConfig, + FeatureType, + ReturnnConfigs, + SummaryKey, +) +from i6_experiments.users.berger.util import default_tools_v2 +from i6_models.config import ModuleFactoryV1 +from sisyphus import gs, tk +from i6_experiments.users.berger.recipe.returnn.optuna_config import OptunaReturnnConfig +from i6_experiments.users.berger.systems.optuna_returnn_seq2seq_system import OptunaReturnnSeq2SeqSystem +from i6_experiments.users.berger.recipe.returnn.hdf import MatchLengthsJob +from i6_experiments.users.berger.pytorch.custom_parts.vgg_frontend import ( + VGG4LayerActFrontendCeilPoolV1, + VGG4LayerActFrontendCeilPoolV1Config, +) + +from .config_01_conformer_ctc import py as py_ctc + +# ********** Settings ********** + +rasr.flow.FlowNetwork.default_flags = {"cache_mode": "task_dependent"} + +storage_path = Path(__file__).parent.parent / "optuna_studies" / "storage.db" +storage = f"sqlite:///{storage_path.as_posix()}" + +num_outputs = 79 +num_subepochs = 300 +sub_checkpoints = [50, 100, 150, 200, 220, 240, 260, 280, 290, 300] + +tools = copy.deepcopy(default_tools_v2) +tools.rasr_binary_path = tk.Path("/u/berger/repositories/rasr_versions/gen_seq2seq_dev/arch/linux-x86_64-standard") + + +# ********** Return Config generators ********** + + +def subsample_by_4_ceil(x: int) -> int: + return -(-x // 4) + + +def tune_specaugment(trial: optuna.Trial, model_config: model.FFNNTransducerConfig) -> dict: + model_config.transcriber_cfg.specaugment.cfg.time_max_mask_per_n_frames = trial.suggest_int( + "time_max_mask_per_n_frames", 20, 40, step=5 + ) + model_config.transcriber_cfg.specaugment.cfg.time_max_mask_size = trial.suggest_int( + "time_max_mask_size", 10, 30, step=5 + ) + freq_max_num_masks = trial.suggest_categorical("freq_max_num_masks", [8, 10, 16, 20]) + model_config.transcriber_cfg.specaugment.cfg.freq_max_num_masks = freq_max_num_masks + model_config.transcriber_cfg.specaugment.cfg.freq_mask_max_size = 80 // freq_max_num_masks + + return {} + + +def tune_model(trial: optuna.Trial, model_config: model.FFNNTransducerConfig) -> dict: + num_att_heads = trial.suggest_int("att_heads", 6, 8, step=2) + dim_per_head = trial.suggest_int("dim_per_head", 64, 96, step=32) + + total_dim = num_att_heads * dim_per_head + + model_config.transcriber_cfg.encoder.cfg.frontend.cfg.out_features = total_dim + model_config.transcriber_cfg.layer_size = total_dim + model_config.transcriber_cfg.encoder.cfg.block_cfg.ff_cfg.input_dim = total_dim + model_config.transcriber_cfg.encoder.cfg.block_cfg.ff_cfg.hidden_dim = 4 * total_dim + model_config.transcriber_cfg.encoder.cfg.block_cfg.mhsa_cfg.input_dim = total_dim + model_config.transcriber_cfg.encoder.cfg.block_cfg.mhsa_cfg.num_att_heads = num_att_heads + model_config.transcriber_cfg.encoder.cfg.block_cfg.conv_cfg.channels = total_dim + model_config.transcriber_cfg.encoder.cfg.block_cfg.conv_cfg.norm = torch.nn.BatchNorm1d( + num_features=total_dim, affine=False + ) + + model_config.transcriber_cfg.encoder.cfg.block_cfg.conv_cfg.kernel_size = trial.suggest_categorical( + "conv_kernel_size", [7, 15, 31] + ) + + model_config.predictor_cfg.layers = trial.suggest_int("predictor_layers", 1, 2) + + join_combination_mode = trial.suggest_categorical("joiner_combination", ["add", "concat"]) + if join_combination_mode == "add": + predictor_layer_size = total_dim + model_config.joiner_cfg.combination_mode = model.CombinationMode.SUM + model_config.joiner_cfg.input_size = total_dim + else: + predictor_layer_size = trial.suggest_int("predictor_layer_size", 384, 640, step=128) + model_config.joiner_cfg.combination_mode = model.CombinationMode.CONCAT + model_config.joiner_cfg.input_size = total_dim + predictor_layer_size + + model_config.predictor_cfg.layer_size = predictor_layer_size + + dropout = trial.suggest_categorical("dropout", [0.1, 0.2, 0.3]) + + model_config.transcriber_cfg.encoder.cfg.block_cfg.ff_cfg.dropout = dropout + model_config.transcriber_cfg.encoder.cfg.block_cfg.mhsa_cfg.dropout = dropout + model_config.transcriber_cfg.encoder.cfg.block_cfg.mhsa_cfg.att_weights_dropout = dropout + model_config.transcriber_cfg.encoder.cfg.block_cfg.conv_cfg.dropout = dropout + + layer_order = trial.suggest_categorical("layer_order", ["conv_first", "mhsa_first"]) + if layer_order == "conv_first": + model_config.transcriber_cfg.encoder.cfg.block_cfg.modules = ["ff", "conv", "mhsa", "ff"] + else: + model_config.transcriber_cfg.encoder.cfg.block_cfg.modules = ["ff", "mhsa", "conv", "ff"] + + return {} + + +def tune_model_broad(trial: optuna.Trial, model_config: model.FFNNTransducerConfig) -> dict: + size = trial.suggest_categorical("size", ["small", "medium", "large"]) + + def build_model( + att_heads: int, dim_per_head: int, conv_kernel_size: int, predictor_layers: int, predictor_layer_size: int + ) -> None: + total_dim = att_heads * dim_per_head + model_config.transcriber_cfg.encoder.cfg.frontend = ModuleFactoryV1( + VGG4LayerActFrontendCeilPoolV1, + VGG4LayerActFrontendCeilPoolV1Config( + in_features=80, + conv1_channels=32, + conv2_channels=64, + conv3_channels=32, + conv4_channels=32, + conv_kernel_size=(3, 3), + conv_padding=None, + pool1_kernel_size=(2, 1), + pool1_stride=(2, 1), + pool1_padding=None, + pool2_kernel_size=(2, 1), + pool2_stride=(2, 1), + pool2_padding=None, + activation=torch.nn.ReLU(), + out_features=total_dim, + ), + ) + + model_config.transcriber_cfg.encoder.cfg.frontend.cfg.out_features = total_dim + model_config.transcriber_cfg.layer_size = total_dim + model_config.transcriber_cfg.encoder.cfg.block_cfg.ff_cfg.input_dim = total_dim + model_config.transcriber_cfg.encoder.cfg.block_cfg.ff_cfg.hidden_dim = 4 * total_dim + model_config.transcriber_cfg.encoder.cfg.block_cfg.mhsa_cfg.input_dim = total_dim + model_config.transcriber_cfg.encoder.cfg.block_cfg.mhsa_cfg.num_att_heads = att_heads + model_config.transcriber_cfg.encoder.cfg.block_cfg.conv_cfg.channels = total_dim + model_config.transcriber_cfg.encoder.cfg.block_cfg.conv_cfg.norm = torch.nn.BatchNorm1d( + num_features=total_dim, affine=False + ) + + model_config.transcriber_cfg.encoder.cfg.block_cfg.conv_cfg.kernel_size = conv_kernel_size + + model_config.predictor_cfg.layers = predictor_layers + + model_config.joiner_cfg.combination_mode = model.CombinationMode.CONCAT + model_config.joiner_cfg.input_size = total_dim + predictor_layer_size + + model_config.predictor_cfg.layer_size = predictor_layer_size + + model_config.transcriber_cfg.encoder.cfg.block_cfg.ff_cfg.dropout = 0.3 + model_config.transcriber_cfg.encoder.cfg.block_cfg.mhsa_cfg.dropout = 0.3 + model_config.transcriber_cfg.encoder.cfg.block_cfg.mhsa_cfg.att_weights_dropout = 0.3 + model_config.transcriber_cfg.encoder.cfg.block_cfg.conv_cfg.dropout = 0.3 + + model_config.transcriber_cfg.encoder.cfg.block_cfg.modules = ["ff", "conv", "mhsa", "ff"] + + if size == "small": + build_model( + att_heads=6, + dim_per_head=64, + conv_kernel_size=7, + predictor_layers=2, + predictor_layer_size=384, + ) + elif size == "medium": + build_model( + att_heads=8, + dim_per_head=64, + conv_kernel_size=7, + predictor_layers=2, + predictor_layer_size=384, + ) + elif size == "large": + build_model( + att_heads=8, + dim_per_head=96, + conv_kernel_size=7, + predictor_layers=2, + predictor_layer_size=384, + ) + + return {} + + +def tune_learn_schedule(trial: optuna.Trial, _: model.FFNNTransducerConfig) -> dict: + batch_size = trial.suggest_int("batch_size", 10000, 30000, step=5000) + peak_lr = trial.suggest_float("peak_lr", 4e-04, 1e-03, log=True) + initial_lr = peak_lr / 10 + return {"initial_lr": initial_lr, "peak_lr": peak_lr, "batch_size": batch_size * 160} + + +class TuningOption(Enum): + SPECAUGMENT = auto() + MODEL = auto() + MODEL_BROAD = auto() + LEARN_SCHEDULE = auto() + + +def map_tuning_option(tuning_option: TuningOption) -> Callable[[optuna.Trial, model.FFNNTransducerConfig], dict]: + if tuning_option == TuningOption.SPECAUGMENT: + return tune_specaugment + if tuning_option == TuningOption.MODEL: + return tune_model + if tuning_option == TuningOption.MODEL_BROAD: + return tune_model_broad + if tuning_option == TuningOption.LEARN_SCHEDULE: + return tune_learn_schedule + + +def returnn_config_generator( + trial: optuna.Trial, + tuning_options: List[TuningOption], + train_data_config: dict, + dev_data_config: dict, +) -> ReturnnConfig: + model_config = model.get_default_config_v1(num_outputs=num_outputs) + model_config.transcriber_cfg.feature_extraction = ModuleFactoryV1( + IdentityModule, + IdentityConfig(), + ) + + tuning_kwargs = {} + for tuning_option in tuning_options: + tuning_kwargs.update(map_tuning_option(tuning_option)(trial, model_config)) + + extra_config = { + "train": train_data_config, + "dev": dev_data_config, + "max_seq_length": {"audio_features": 560000}, + "torch_amp": {"dtype": "bfloat16"}, + "chunking": ( + { + "data": 256, + "classes": 64, + }, + { + "data": 128, + "classes": 32, + }, + ), + } + serializer = model.get_viterbi_train_serializer(model_config, enc_loss_scales={5: 0.3, 11: 0.7}) + + return get_returnn_config( + num_epochs=num_subepochs, + num_inputs=80, + num_outputs=num_outputs, + target="classes", + extra_python=[serializer], + extern_data_config=True, + backend=Backend.PYTORCH, + grad_noise=0.0, + grad_clip=0.0, + keep_last_n=1, + keep_best_n=0, + keep=sub_checkpoints, + optimizer=Optimizers.AdamW, + weight_decay=5e-06, + schedule=LearningRateSchedules.OCLR, + initial_lr=8e-05, + peak_lr=8e-04, + decayed_lr=1e-05, + final_lr=1e-07, + batch_size=30000 * 160, + use_chunking=False, + extra_config=extra_config, + ) + + +def recog_enc_returnn_config_generator( + trial: optuna.Trial, + tuning_options: List[TuningOption], + ilm_scale: float = 0.0, +) -> ReturnnConfig: + model_config = model.get_default_config_v1(num_outputs=num_outputs) + model_config.transcriber_cfg.feature_extraction = ModuleFactoryV1( + IdentityModule, + IdentityConfig(), + ) + for tuning_option in tuning_options: + map_tuning_option(tuning_option)(trial, model_config) + if ilm_scale != 0: + model_config = model.FFNNTransducerWithIlmConfig( + transcriber_cfg=model_config.transcriber_cfg, + predictor_cfg=model_config.predictor_cfg, + joiner_cfg=model_config.joiner_cfg, + ilm_scale=ilm_scale, + ) + + enc_extra_config = { + "extern_data": { + "sources": {"dim": 80, "dtype": "float32"}, + }, + "model_outputs": { + "source_encodings": { + "dim": model_config.transcriber_cfg.layer_size, + "dtype": "float32", + }, + }, + } + enc_serializer = model.get_encoder_recog_serializer(model_config) + + return get_returnn_config( + num_inputs=80, + num_outputs=num_outputs, + target=None, + extra_python=[enc_serializer], + extern_data_config=False, + backend=Backend.PYTORCH, + extra_config=enc_extra_config, + ) + + +def recog_dec_returnn_config_generator( + trial: optuna.Trial, + tuning_options: List[TuningOption], + ilm_scale: float = 0.0, +) -> ReturnnConfig: + model_config = model.get_default_config_v1(num_outputs=num_outputs) + for tuning_option in tuning_options: + map_tuning_option(tuning_option)(trial, model_config) + model_config.transcriber_cfg.feature_extraction = ModuleFactoryV1( + IdentityModule, + IdentityConfig(), + ) + if ilm_scale != 0: + model_config = model.FFNNTransducerWithIlmConfig( + transcriber_cfg=model_config.transcriber_cfg, + predictor_cfg=model_config.predictor_cfg, + joiner_cfg=model_config.joiner_cfg, + ilm_scale=ilm_scale, + ) + + dec_extra_config = { + "extern_data": { + "source_encodings": { + "dim": model_config.transcriber_cfg.layer_size, + "time_dim_axis": None, + "dtype": "float32", + }, + "history": { + "dim": num_outputs, + "time_dim_axis": None, + "sparse": True, + "shape": (1,), + "dtype": "int32", + }, + }, + "model_outputs": { + "log_probs": { + "dim": num_outputs, + "time_dim_axis": None, + "dtype": "float32", + } + }, + } + dec_serializer = model.get_decoder_recog_serializer(model_config) + + return get_returnn_config( + num_inputs=80, + num_outputs=num_outputs, + target=None, + extra_python=[dec_serializer], + extern_data_config=False, + backend=Backend.PYTORCH, + extra_config=dec_extra_config, + ) + + +def get_returnn_config_collection( + tuning_options: List[TuningOption], + train_data_config: dict, + dev_data_config: dict, + ilm_scales: List[float] = [0.2], +) -> ReturnnConfigs[OptunaReturnnConfig]: + return ReturnnConfigs( + train_config=OptunaReturnnConfig( + returnn_config_generator, + { + "train_data_config": train_data_config, + "dev_data_config": dev_data_config, + "tuning_options": tuning_options, + }, + ), + recog_configs={ + f"recog_ilm-{ilm_scale}": EncDecConfig( + encoder_config=OptunaReturnnConfig( + recog_enc_returnn_config_generator, {"ilm_scale": ilm_scale, "tuning_options": tuning_options} + ), + decoder_config=OptunaReturnnConfig( + recog_dec_returnn_config_generator, {"ilm_scale": ilm_scale, "tuning_options": tuning_options} + ), + ) + for ilm_scale in ilm_scales + }, + ) + + +def run_exp(alignments: Dict[str, AlignmentData]) -> SummaryReport: + assert tools.returnn_root + assert tools.returnn_python_exe + assert tools.rasr_binary_path + data = get_tedlium2_data( + alignments=alignments, + returnn_root=tools.returnn_root, + returnn_python_exe=tools.returnn_python_exe, + rasr_binary_path=tools.rasr_binary_path, + augmented_lexicon=True, + feature_type=FeatureType.LOGMEL_16K, + ) + + for data_input in data.data_inputs.values(): + data_input.create_lm_images(tools.rasr_binary_path) + + for data_config in [data.train_data_config, data.cv_data_config]: + data_config["datasets"]["classes"]["files"] = [ + MatchLengthsJob( + hdf_file, + match_hdfs=data_config["datasets"]["data"]["files"], + match_len_transform_func=subsample_by_4_ceil, + ).out_hdf + for hdf_file in data_config["datasets"]["classes"]["files"] + ] + + # ********** Step args ********** + + train_args = exp_args.get_transducer_train_step_args( + num_epochs=num_subepochs, + study_storage=storage, + num_parallel=5, + gpu_mem_rqmt=24, + backend=Backend.PYTORCH, + ) + recog_args = exp_args.get_transducer_recog_step_args( + num_classes=num_outputs, + epochs=sub_checkpoints, + trial_nums=list(range(30)), + label_scorer_type="onnx-ffnn-transducer", + label_scorer_args={"extra_args": {"start_label_index": 0}}, + search_parameters={"blank-label-penalty": 1.0}, + reduction_subtrahend=3, + reduction_factor=4, + feature_type=FeatureType.LOGMEL_16K, + seq2seq_v2=True, + backend=Backend.PYTORCH, + ) + + # ********** System ********** + + system = OptunaReturnnSeq2SeqSystem( + tool_paths=tools, + summary_keys=[ + SummaryKey.TRAIN_NAME, + SummaryKey.RECOG_NAME, + SummaryKey.CORPUS, + SummaryKey.TRIAL, + SummaryKey.EPOCH, + SummaryKey.LM, + SummaryKey.WER, + SummaryKey.SUB, + SummaryKey.INS, + SummaryKey.DEL, + SummaryKey.ERR, + ], + summary_sort_keys=[SummaryKey.ERR, SummaryKey.CORPUS], + ) + + system.init_corpora( + dev_keys=data.dev_keys, + test_keys=data.test_keys, + corpus_data=data.data_inputs, + am_args=exp_args.transducer_recog_am_args, + ) + system.setup_scoring() + + # ********** Returnn Configs ********** + + train_args["num_trials"] = 30 + recog_args["trial_nums"] = list(range(30)) + system.add_experiment_configs( + "Conformer_Transducer_Viterbi_tuning", + get_returnn_config_collection( + tuning_options=[TuningOption.MODEL_BROAD, TuningOption.LEARN_SCHEDULE, TuningOption.SPECAUGMENT], + train_data_config=data.train_data_config, + dev_data_config=data.cv_data_config, + ), + ) + + system.run_train_step(**train_args) + system.run_dev_recog_step(**recog_args) + + assert system.summary_report + return system.summary_report + + +def py() -> SummaryReport: + _, alignments = py_ctc() + filename_handle = os.path.splitext(os.path.basename(__file__))[0][len("config_") :] + gs.ALIAS_AND_OUTPUT_SUBDIR = f"{filename_handle}/" + + summary_report = SummaryReport() + + report = run_exp(alignments) + + summary_report.merge_report(report, update_structure=True) + + tk.register_report(f"{gs.ALIAS_AND_OUTPUT_SUBDIR}/summary.report", summary_report) + + return summary_report diff --git a/users/berger/configs/tedlium2/20230602_rescale_baselines/config_03_blstm_ctc.py b/users/berger/configs/tedlium2/20230602_rescale_baselines/config_03_blstm_ctc.py deleted file mode 100644 index 9a4788cbc..000000000 --- a/users/berger/configs/tedlium2/20230602_rescale_baselines/config_03_blstm_ctc.py +++ /dev/null @@ -1,141 +0,0 @@ -import copy -import os -from i6_core.returnn.config import ReturnnConfig - -from sisyphus import gs, tk - -import i6_core.rasr as rasr -from i6_experiments.users.berger.args.experiments import ctc as exp_args -from i6_experiments.users.berger.args.returnn.config import get_returnn_config, Backend -from i6_experiments.users.berger.args.returnn.learning_rates import ( - LearningRateSchedules, -) -from i6_experiments.users.berger.corpus.tedlium2.ctc_data import get_tedlium2_pytorch_data -from i6_experiments.users.berger.pytorch.models import conformer_ctc -from i6_experiments.users.berger.recipe.summary.report import SummaryReport -from i6_experiments.users.berger.systems.dataclasses import ConfigVariant, FeatureType, ReturnnConfigs -from i6_experiments.users.berger.systems.returnn_seq2seq_system import ( - ReturnnSeq2SeqSystem, -) -from i6_experiments.users.berger.util import default_tools_v2 - -# ********** Settings ********** - -rasr.flow.FlowNetwork.default_flags = {"cache_mode": "task_dependent"} - -num_outputs = 79 -num_subepochs = 150 - -tools = copy.deepcopy(default_tools_v2) - -tools.rasr_binary_path = tk.Path("/u/berger/repositories/rasr_versions/onnx/arch/linux-x86_64-standard") -# tools.returnn_root = tk.Path("/u/berger/repositories/MiniReturnn") - - -# ********** Return Config generators ********** - - -def returnn_config_generator(variant: ConfigVariant, train_data_config: dict, dev_data_config: dict) -> ReturnnConfig: - model_config = conformer_ctc.get_default_config_v1(num_inputs=50, num_outputs=num_outputs) - - extra_config = { - "train": train_data_config, - "dev": dev_data_config, - } - if variant == ConfigVariant.RECOG: - extra_config["model_outputs"] = {"classes": {"dim": num_outputs}} - - return get_returnn_config( - num_epochs=num_subepochs, - num_inputs=50, - num_outputs=num_outputs, - target="targets", - extra_python=[conformer_ctc.get_serializer(model_config, variant=variant)], - extern_data_config=True, - backend=Backend.PYTORCH, - grad_noise=0.0, - grad_clip=0.0, - schedule=LearningRateSchedules.OCLR, - initial_lr=1e-05, - peak_lr=3e-04, - final_lr=1e-05, - batch_size=10000, - use_chunking=False, - extra_config=extra_config, - ) - - -def get_returnn_config_collection( - train_data_config: dict, - dev_data_config: dict, -) -> ReturnnConfigs[ReturnnConfig]: - generator_kwargs = {"train_data_config": train_data_config, "dev_data_config": dev_data_config} - return ReturnnConfigs( - train_config=returnn_config_generator(variant=ConfigVariant.TRAIN, **generator_kwargs), - prior_config=returnn_config_generator(variant=ConfigVariant.PRIOR, **generator_kwargs), - recog_configs={"recog": returnn_config_generator(variant=ConfigVariant.RECOG, **generator_kwargs)}, - ) - - -def run_exp() -> SummaryReport: - assert tools.returnn_root - assert tools.returnn_python_exe - assert tools.rasr_binary_path - data = get_tedlium2_pytorch_data( - returnn_root=tools.returnn_root, - returnn_python_exe=tools.returnn_python_exe, - rasr_binary_path=tools.rasr_binary_path, - augmented_lexicon=True, - ) - - # ********** Step args ********** - - train_args = exp_args.get_ctc_train_step_args(num_epochs=num_subepochs) - recog_args = exp_args.get_ctc_recog_step_args( - num_classes=num_outputs, - epochs=[40, 80, num_subepochs], - prior_scales=[0.4], - lm_scales=[0.7], - feature_type=FeatureType.GAMMATONE_16K, - ) - - # ********** System ********** - - # tools.returnn_root = tk.Path("/u/berger/repositories/MiniReturnn") - tools.rasr_binary_path = tk.Path( - "/u/berger/repositories/rasr_versions/gen_seq2seq_onnx_apptainer/arch/linux-x86_64-standard" - ) - system = ReturnnSeq2SeqSystem(tools) - - system.init_corpora( - dev_keys=data.dev_keys, - test_keys=data.test_keys, - corpus_data=data.data_inputs, - am_args=exp_args.ctc_recog_am_args, - ) - system.setup_scoring() - - # ********** Returnn Configs ********** - - system.add_experiment_configs( - f"Conformer_CTC", get_returnn_config_collection(data.train_data_config, data.cv_data_config) - ) - - system.run_train_step(**train_args) - system.run_dev_recog_step(**recog_args) - - assert system.summary_report - return system.summary_report - - -def py() -> SummaryReport: - filename_handle = os.path.splitext(os.path.basename(__file__))[0][len("config_") :] - gs.ALIAS_AND_OUTPUT_SUBDIR = f"{filename_handle}/" - - summary_report = SummaryReport() - - summary_report.merge_report(run_exp(), update_structure=True) - - tk.register_report(f"{gs.ALIAS_AND_OUTPUT_SUBDIR}/summary.report", summary_report) - - return summary_report diff --git a/users/berger/configs/tedlium2/20230602_rescale_baselines/config_03_conformer_transducer_phon_fullsum.py b/users/berger/configs/tedlium2/20230602_rescale_baselines/config_03_conformer_transducer_phon_fullsum.py new file mode 100644 index 000000000..5ae641c0f --- /dev/null +++ b/users/berger/configs/tedlium2/20230602_rescale_baselines/config_03_conformer_transducer_phon_fullsum.py @@ -0,0 +1,283 @@ +import copy +import os +from typing import List + +from i6_models.config import ModuleFactoryV1 +import i6_core.rasr as rasr +from i6_core.returnn import PtCheckpoint +from i6_core.returnn.config import ReturnnConfig +from i6_experiments.users.berger.args.experiments import transducer as exp_args +from i6_experiments.users.berger.args.returnn.config import Backend, get_returnn_config +from i6_experiments.users.berger.args.returnn.learning_rates import LearningRateSchedules, Optimizers +from i6_experiments.users.berger.corpus.tedlium2.phon_transducer_data import get_tedlium2_data_dumped_labels +from i6_experiments.users.berger.pytorch.models import conformer_transducer_v2 as model +from i6_experiments.users.berger.recipe.summary.report import SummaryReport +from i6_experiments.users.berger.systems.dataclasses import ( + EncDecConfig, + FeatureType, + ReturnnConfigs, + SummaryKey, +) +from i6_experiments.users.berger.systems.returnn_seq2seq_system import ReturnnSeq2SeqSystem +from i6_experiments.users.berger.util import default_tools_v2 +from sisyphus import gs, tk +from i6_experiments.users.berger.pytorch.custom_parts.identity import IdentityConfig, IdentityModule + +from .config_02_conformer_transducer_phon_viterbi import py as py_viterbi + +# ********** Settings ********** + +rasr.flow.FlowNetwork.default_flags = {"cache_mode": "task_dependent"} + +num_outputs = 79 +num_subepochs = 500 + +tools = copy.deepcopy(default_tools_v2) +tools.rasr_binary_path = tk.Path("/u/berger/repositories/rasr_versions/gen_seq2seq_dev/arch/linux-x86_64-standard") + + +# ********** Return Config generators ********** + + +def returnn_config_generator( + train_data_config: dict, + dev_data_config: dict, + pretrained_checkpoint: PtCheckpoint, + **kwargs, +) -> ReturnnConfig: + model_config = model.get_default_config_v1(num_outputs=num_outputs) + + extra_config = { + "train": train_data_config, + "dev": dev_data_config, + "max_seq_length": {"audio_features": 560000}, + "torch_amp": {"dtype": "bfloat16"}, + "preload_from_files": { + "pretrained_model": { + "filename": pretrained_checkpoint, + "init_for_train": True, + }, + }, + } + serializer = model.get_train_serializer(model_config, **kwargs) + + return get_returnn_config( + num_epochs=num_subepochs, + num_inputs=1, + num_outputs=num_outputs, + target="classes", + extra_python=[serializer], + extern_data_config=True, + backend=Backend.PYTORCH, + grad_noise=0.0, + grad_clip=0.0, + optimizer=Optimizers.AdamW, + schedule=LearningRateSchedules.CONST_DECAY, + const_lr=8e-05, + decayed_lr=1e-05, + final_lr=1e-06, + batch_size=15000 * 160, + accum_grad=2, + use_chunking=False, + extra_config=extra_config, + ) + + +def recog_returnn_configs_generator( + ilm_scale: float = 0.0, + **kwargs, +) -> EncDecConfig[ReturnnConfig]: + model_config = model.get_default_config_v1(num_outputs=num_outputs) + model_config.transcriber_cfg.feature_extraction = ModuleFactoryV1( + IdentityModule, + IdentityConfig(), + ) + + if ilm_scale != 0: + model_config = model.FFNNTransducerWithIlmConfig( + transcriber_cfg=model_config.transcriber_cfg, + predictor_cfg=model_config.predictor_cfg, + joiner_cfg=model_config.joiner_cfg, + ilm_scale=ilm_scale, + ) + + enc_extra_config = { + "extern_data": { + "sources": {"dim": 80, "dtype": "float32"}, + }, + "model_outputs": { + "source_encodings": { + "dim": 384, + "dtype": "float32", + }, + }, + } + dec_extra_config = { + "extern_data": { + "source_encodings": { + "dim": 384, + "time_dim_axis": None, + "dtype": "float32", + }, + "history": { + "dim": num_outputs, + "time_dim_axis": None, + "sparse": True, + "shape": (1,), + "dtype": "int32", + }, + }, + "model_outputs": { + "log_probs": { + "dim": num_outputs, + "time_dim_axis": None, + "dtype": "float32", + } + }, + } + enc_serializer = model.get_encoder_recog_serializer(model_config, **kwargs) + dec_serializer = model.get_decoder_recog_serializer(model_config, **kwargs) + + return EncDecConfig( + encoder_config=get_returnn_config( + num_inputs=80, + num_outputs=num_outputs, + target=None, + extra_python=[enc_serializer], + extern_data_config=False, + backend=Backend.PYTORCH, + extra_config=enc_extra_config, + ), + decoder_config=get_returnn_config( + num_inputs=1, + num_outputs=num_outputs, + target=None, + # python_prolog=["from returnn.tensor.dim import Dim, batch_dim"], + extra_python=[dec_serializer], + extern_data_config=False, + backend=Backend.PYTORCH, + extra_config=dec_extra_config, + ), + ) + + +def get_returnn_config_collection( + train_data_config: dict, + dev_data_config: dict, + ilm_scales: List[float] = [0.2], + **kwargs, +) -> ReturnnConfigs[ReturnnConfig]: + return ReturnnConfigs( + train_config=returnn_config_generator( + train_data_config=train_data_config, + dev_data_config=dev_data_config, + blank_id=0, + **kwargs, + ), + recog_configs={ + f"recog_ilm-{ilm_scale}": recog_returnn_configs_generator(ilm_scale=ilm_scale, **kwargs) + for ilm_scale in ilm_scales + }, + ) + + +def run_exp(pretrained_checkpoint: PtCheckpoint) -> SummaryReport: + assert tools.returnn_root + assert tools.returnn_python_exe + assert tools.rasr_binary_path + data = get_tedlium2_data_dumped_labels( + num_classes=num_outputs, + returnn_root=tools.returnn_root, + returnn_python_exe=tools.returnn_python_exe, + rasr_binary_path=tools.rasr_binary_path, + augmented_lexicon=True, + feature_type=FeatureType.SAMPLES, + ) + + # ********** Step args ********** + + train_args = exp_args.get_transducer_train_step_args(num_epochs=num_subepochs, gpu_mem_rqmt=24) + recog_args = exp_args.get_transducer_recog_step_args( + num_classes=num_outputs, + lm_scales=[0.7], + epochs=[40, 80, 160, 320, 480, num_subepochs], + search_parameters={"blank-label-penalty": 1.0}, + label_scorer_type="onnx-ffnn-transducer", + label_scorer_args={"extra_args": {"start_label_index": 0}}, + reduction_subtrahend=3, + # reduction_subtrahend=0, + reduction_factor=4, + feature_type=FeatureType.LOGMEL_16K, + ) + + # ********** System ********** + + system = ReturnnSeq2SeqSystem( + tool_paths=tools, + summary_keys=[ + SummaryKey.TRAIN_NAME, + SummaryKey.RECOG_NAME, + SummaryKey.CORPUS, + SummaryKey.EPOCH, + SummaryKey.LM, + SummaryKey.WER, + SummaryKey.SUB, + SummaryKey.INS, + SummaryKey.DEL, + SummaryKey.ERR, + ], + summary_sort_keys=[SummaryKey.ERR, SummaryKey.CORPUS], + ) + + system.init_corpora( + dev_keys=data.dev_keys, + test_keys=data.test_keys, + corpus_data=data.data_inputs, + am_args=exp_args.transducer_recog_am_args, + ) + system.setup_scoring() + + # ********** Returnn Configs ********** + + system.add_experiment_configs( + "Conformer_Transducer_Fullsum", + get_returnn_config_collection( + data.train_data_config, + data.cv_data_config, + pretrained_checkpoint=pretrained_checkpoint, + ), + ) + + system.run_train_step(**train_args) + system.run_dev_recog_step(recog_descriptor="bp-1.0", **recog_args) + + system.add_experiment_configs( + "Conformer_Transducer_Fullsum", + get_returnn_config_collection( + data.train_data_config, + data.cv_data_config, + ilm_scales=[0.2, 0.4, 0.6], + pretrained_checkpoint=pretrained_checkpoint, + ), + ) + recog_args["lm_scales"] = [0.7, 0.9, 1.1, 1.3, 1.5] + recog_args["epochs"] = [num_subepochs] + recog_args["search_parameters"]["blank-label-penalty"] = 0.0 + system.run_dev_recog_step(**recog_args) + + assert system.summary_report + return system.summary_report + + +def py() -> SummaryReport: + _, model = py_viterbi() + filename_handle = os.path.splitext(os.path.basename(__file__))[0][len("config_") :] + gs.ALIAS_AND_OUTPUT_SUBDIR = f"{filename_handle}/" + + summary_report = SummaryReport() + + summary_report.merge_report(run_exp(model), update_structure=True) + + tk.register_report(f"{gs.ALIAS_AND_OUTPUT_SUBDIR}/summary.report", summary_report) + + return summary_report diff --git a/users/berger/configs/tedlium2/20230602_rescale_baselines/config_05_conformer_transducer_phon_align_restrict.py b/users/berger/configs/tedlium2/20230602_rescale_baselines/config_05_conformer_transducer_phon_align_restrict.py new file mode 100644 index 000000000..d5a805069 --- /dev/null +++ b/users/berger/configs/tedlium2/20230602_rescale_baselines/config_05_conformer_transducer_phon_align_restrict.py @@ -0,0 +1,275 @@ +import copy +import os +from typing import Dict, List, Tuple + +import i6_core.rasr as rasr +from i6_core.returnn import PtCheckpoint +from i6_core.returnn.config import ReturnnConfig +from i6_experiments.users.berger.args.experiments import transducer as exp_args +from i6_experiments.users.berger.args.returnn.config import Backend, get_returnn_config +from i6_experiments.users.berger.args.returnn.learning_rates import LearningRateSchedules, Optimizers +from i6_experiments.users.berger.corpus.tedlium2.viterbi_transducer_data import get_tedlium2_data +from i6_experiments.users.berger.pytorch.custom_parts.identity import IdentityConfig, IdentityModule +from i6_experiments.users.berger.pytorch.models import conformer_transducer_v2 as model +from i6_experiments.users.berger.recipe.summary.report import SummaryReport +from i6_experiments.users.berger.systems.dataclasses import ( + AlignmentData, + EncDecConfig, + FeatureType, + ReturnnConfigs, + SummaryKey, +) +from i6_experiments.users.berger.systems.returnn_seq2seq_system import ReturnnSeq2SeqSystem +from i6_experiments.users.berger.util import default_tools_v2 +from i6_models.config import ModuleFactoryV1 +from sisyphus import gs, tk + +from .config_01_conformer_ctc import py as py_ctc + +# ********** Settings ********** + +rasr.flow.FlowNetwork.default_flags = {"cache_mode": "task_dependent"} + +num_outputs = 79 +num_subepochs = 500 + +tools = copy.deepcopy(default_tools_v2) +tools.rasr_binary_path = tk.Path("/u/berger/repositories/rasr_versions/gen_seq2seq_dev/arch/linux-x86_64-standard") + + +# ********** Return Config generators ********** + + +def returnn_config_generator( + train_data_config: dict, + dev_data_config: dict, + **kwargs, +) -> ReturnnConfig: + model_config = model.get_default_config_v2(num_outputs=num_outputs) + + extra_config = { + "train": train_data_config, + "dev": dev_data_config, + "max_seqs": 60, + "max_seq_length": {"audio_features": 560000}, + "torch_amp": {"dtype": "bfloat16"}, + } + serializer = model.get_align_restrict_train_serializer( + model_config, + max_distance_from_alignment=kwargs.get("max_shift", 0), + enc_loss_scales={5: 0.2, 11: 0.5}, + blank_idx=0, + ) + + return get_returnn_config( + num_epochs=num_subepochs, + num_inputs=1, + num_outputs=num_outputs, + target="classes", + extra_python=[serializer], + extern_data_config=True, + backend=Backend.PYTORCH, + grad_noise=0.0, + grad_clip=0.0, + optimizer=Optimizers.AdamW, + weight_decay=5e-06, + schedule=LearningRateSchedules.OCLR, + initial_lr=8e-05, + peak_lr=kwargs.get("peak_lr", 8e-04), + decayed_lr=1e-05, + final_lr=1e-07, + batch_size=10000 * 160, + accum_grad=3, + use_chunking=False, + extra_config=extra_config, + ) + + +def recog_returnn_configs_generator( + ilm_scale: float = 0.0, + **kwargs, +) -> EncDecConfig[ReturnnConfig]: + model_config = model.get_default_config_v2(num_outputs=num_outputs) + model_config.transcriber_cfg.feature_extraction = ModuleFactoryV1( + IdentityModule, + IdentityConfig(), + ) + if ilm_scale != 0: + model_config = model.FFNNTransducerWithIlmConfig( + transcriber_cfg=model_config.transcriber_cfg, + predictor_cfg=model_config.predictor_cfg, + joiner_cfg=model_config.joiner_cfg, + ilm_scale=ilm_scale, + ) + + enc_extra_config = { + "extern_data": { + "sources": {"dim": 80, "dtype": "float32"}, + }, + "model_outputs": { + "source_encodings": { + "dim": 768, + "dtype": "float32", + }, + }, + } + dec_extra_config = { + "extern_data": { + "source_encodings": { + "dim": 768, + "time_dim_axis": None, + "dtype": "float32", + }, + "history": { + "dim": num_outputs, + "time_dim_axis": None, + "sparse": True, + "shape": (1,), + "dtype": "int32", + }, + }, + "model_outputs": { + "log_probs": { + "dim": num_outputs, + "time_dim_axis": None, + "dtype": "float32", + } + }, + } + enc_serializer = model.get_encoder_recog_serializer(model_config, **kwargs) + dec_serializer = model.get_decoder_recog_serializer(model_config, **kwargs) + + return EncDecConfig( + encoder_config=get_returnn_config( + num_inputs=80, + num_outputs=num_outputs, + target=None, + extra_python=[enc_serializer], + extern_data_config=False, + backend=Backend.PYTORCH, + extra_config=enc_extra_config, + ), + decoder_config=get_returnn_config( + num_inputs=1, + num_outputs=num_outputs, + target=None, + extra_python=[dec_serializer], + extern_data_config=False, + backend=Backend.PYTORCH, + extra_config=dec_extra_config, + ), + ) + + +def get_returnn_config_collection( + train_data_config: dict, + dev_data_config: dict, + ilm_scales: List[float] = [0.0, 0.2], + **kwargs, +) -> ReturnnConfigs[ReturnnConfig]: + return ReturnnConfigs( + train_config=returnn_config_generator( + train_data_config=train_data_config, + dev_data_config=dev_data_config, + **kwargs, + ), + recog_configs={ + f"recog_ilm-{ilm_scale}": recog_returnn_configs_generator(ilm_scale=ilm_scale, **kwargs) + for ilm_scale in ilm_scales + }, + ) + + +def run_exp(alignments: Dict[str, AlignmentData]) -> SummaryReport: + assert tools.returnn_root + assert tools.returnn_python_exe + assert tools.rasr_binary_path + data = get_tedlium2_data( + alignments=alignments, + returnn_root=tools.returnn_root, + returnn_python_exe=tools.returnn_python_exe, + rasr_binary_path=tools.rasr_binary_path, + augmented_lexicon=True, + feature_type=FeatureType.SAMPLES, + ) + + for data_input in data.data_inputs.values(): + data_input.create_lm_images(tools.rasr_binary_path) + + # ********** Step args ********** + + train_args = exp_args.get_transducer_train_step_args(num_epochs=num_subepochs, gpu_mem_rqmt=24) + recog_args = exp_args.get_transducer_recog_step_args( + num_classes=num_outputs, + epochs=[20, 40, 80, 160, 320, num_subepochs], + lm_scales=[0.7], + label_scorer_type="onnx-ffnn-transducer", + label_scorer_args={"extra_args": {"start_label_index": 0}}, + search_parameters={"blank-label-penalty": 1.0}, + reduction_factor=4, + reduction_subtrahend=3, + feature_type=FeatureType.LOGMEL_16K, + seq2seq_v2=True, + ) + + # ********** System ********** + + system = ReturnnSeq2SeqSystem( + tool_paths=tools, + summary_keys=[ + SummaryKey.TRAIN_NAME, + SummaryKey.RECOG_NAME, + SummaryKey.CORPUS, + SummaryKey.EPOCH, + SummaryKey.LM, + SummaryKey.WER, + SummaryKey.SUB, + SummaryKey.INS, + SummaryKey.DEL, + SummaryKey.ERR, + ], + summary_sort_keys=[SummaryKey.ERR, SummaryKey.CORPUS], + ) + + system.init_corpora( + dev_keys=data.dev_keys, + test_keys=data.test_keys, + corpus_data=data.data_inputs, + am_args=exp_args.transducer_recog_am_args, + ) + system.setup_scoring() + + # ********** Returnn Configs ********** + + for max_shift in [0, 1, 5, 10, 10000]: + system.add_experiment_configs( + f"Conformer_Transducer_Viterbi_shift-{max_shift}", + get_returnn_config_collection( + data.train_data_config, + data.cv_data_config, + max_shift=max_shift, + ilm_scales=[0.2], + ), + ) + + system.run_train_step(**train_args) + system.run_dev_recog_step(**recog_args) + + assert system.summary_report + return system.summary_report + + +def py() -> SummaryReport: + _, alignments = py_ctc() + filename_handle = os.path.splitext(os.path.basename(__file__))[0][len("config_") :] + gs.ALIAS_AND_OUTPUT_SUBDIR = f"{filename_handle}/" + + summary_report = SummaryReport() + + report = run_exp(alignments) + + summary_report.merge_report(report, update_structure=True) + + tk.register_report(f"{gs.ALIAS_AND_OUTPUT_SUBDIR}/summary.report", summary_report) + + return summary_report diff --git a/users/berger/corpus/general/hdf.py b/users/berger/corpus/general/hdf.py index 41df1e7e8..08754d422 100644 --- a/users/berger/corpus/general/hdf.py +++ b/users/berger/corpus/general/hdf.py @@ -1,17 +1,18 @@ -from typing import Optional, List -from i6_core.corpus import SegmentCorpusJob +from typing import List, Optional +from i6_core.corpus import SegmentCorpusJob from i6_core.returnn.hdf import BlissToPcmHDFJob -from i6_experiments.users.berger.recipe.returnn.hdf import BlissCorpusToTargetHdfJob -from i6_experiments.users.berger.args.returnn.dataset import MetaDatasetBuilder, hdf_config_dict_for_files -from i6_experiments.users.berger.systems.dataclasses import AlignmentData, FeatureType from sisyphus import tk + from i6_experiments.users.berger.args.jobs.rasr_init_args import ( - get_feature_extraction_args_16kHz, get_feature_extraction_args_8kHz, + get_feature_extraction_args_16kHz, ) -from i6_experiments.users.berger.helpers import build_rasr_feature_hdfs, RasrDataInput, SeparatedCorpusObject +from i6_experiments.users.berger.args.returnn.dataset import MetaDatasetBuilder, hdf_config_dict_for_files +from i6_experiments.users.berger.helpers import RasrDataInput, SeparatedCorpusObject, build_rasr_feature_hdfs from i6_experiments.users.berger.recipe.corpus.transform import ReplaceUnknownWordsJob +from i6_experiments.users.berger.recipe.returnn.hdf import BlissCorpusToTargetHdfJob +from i6_experiments.users.berger.systems.dataclasses import AlignmentData, FeatureType def build_feature_hdf_dataset_config( @@ -52,7 +53,20 @@ def build_feature_hdf_dataset_config( rasr_arch=rasr_arch, single_hdf=single_hdf, ) - + elif feature_type == FeatureType.LOGMEL_16K: + logmel_args = get_feature_extraction_args_16kHz(dc_detection=dc_detection)["filterbank"] + for data_input in data_inputs: + feature_hdfs += build_rasr_feature_hdfs( + data_input.corpus_object, + split=data_input.concurrent, + feature_type="fb", + feature_extraction_args=logmel_args, + returnn_python_exe=returnn_python_exe, + returnn_root=returnn_root, + rasr_binary_path=rasr_binary_path, + rasr_arch=rasr_arch, + single_hdf=single_hdf, + ) elif feature_type == FeatureType.SAMPLES: for data_input in data_inputs: if single_hdf: @@ -80,6 +94,10 @@ def build_feature_hdf_dataset_config( return hdf_config_dict_for_files(files=feature_hdfs, extra_config=extra_config) +def subsample_by_4(x): + return -(-x // 4) + + def build_feature_alignment_meta_dataset_config( data_inputs: List[RasrDataInput], feature_type: FeatureType, diff --git a/users/berger/corpus/tedlium2/phon_transducer_data.py b/users/berger/corpus/tedlium2/phon_transducer_data.py index f914d1b7b..6589e0a0b 100644 --- a/users/berger/corpus/tedlium2/phon_transducer_data.py +++ b/users/berger/corpus/tedlium2/phon_transducer_data.py @@ -7,7 +7,7 @@ from i6_experiments.users.berger.systems.dataclasses import FeatureType from i6_experiments.users.berger.corpus.general.experiment_data import BasicSetupData -from ..general import build_feature_hdf_dataset_config, build_feature_label_meta_dataset_config +from ..general import build_feature_label_meta_dataset_config from . import data @@ -81,25 +81,6 @@ def get_tedlium2_data_dumped_labels( }, ) - # ********** forward data ********** - - forward_data_config = { - key: build_feature_hdf_dataset_config( - data_inputs=[data_input], - feature_type=feature_type, - returnn_root=returnn_root, - returnn_python_exe=returnn_python_exe, - rasr_binary_path=rasr_binary_path, - rasr_arch=rasr_arch, - single_hdf=True, - extra_config={ - "partition_epoch": 1, - "seq_ordering": "sorted", - }, - ) - for key, data_input in {**dev_data_inputs, **test_data_inputs}.items() - } - # ********** Recog lexicon ********** for rasr_input in {**dev_data_inputs, **test_data_inputs}.values(): diff --git a/users/berger/corpus/tedlium2/viterbi_transducer_data.py b/users/berger/corpus/tedlium2/viterbi_transducer_data.py new file mode 100644 index 000000000..a7a4784dc --- /dev/null +++ b/users/berger/corpus/tedlium2/viterbi_transducer_data.py @@ -0,0 +1,113 @@ +import copy +from typing import Dict, List, Optional + +from i6_core.lexicon.modification import AddEowPhonemesToLexiconJob +from sisyphus import tk + +from i6_experiments.users.berger.systems.dataclasses import AlignmentData, FeatureType +from i6_experiments.users.berger.corpus.general.experiment_data import BasicSetupData +from i6_experiments.users.berger.corpus.general.hdf import build_feature_alignment_meta_dataset_config + +from . import data + + +def get_tedlium2_data( + alignments: Dict[str, AlignmentData], + returnn_root: tk.Path, + returnn_python_exe: tk.Path, + rasr_binary_path: tk.Path, + rasr_arch: str = "linux-x86_64-standard", + train_key: str = "train", + cv_keys: Optional[List[str]] = None, + dev_keys: Optional[List[str]] = None, + test_keys: Optional[List[str]] = None, + add_unknown: bool = False, + augmented_lexicon: bool = True, + feature_type: FeatureType = FeatureType.GAMMATONE_16K, + dc_detection: bool = False, + **kwargs, +) -> BasicSetupData: + if cv_keys is None: + cv_keys = ["dev"] + if dev_keys is None: + dev_keys = ["dev"] + if test_keys is None: + test_keys = ["test"] + + # ********** Data inputs ********** + train_data_inputs, cv_data_inputs, dev_data_inputs, test_data_inputs = copy.deepcopy( + data.get_data_inputs( + ctc_lexicon=True, + use_augmented_lexicon=augmented_lexicon, + add_all_allophones=True, + add_unknown_phoneme_and_mapping=add_unknown, + filter_unk_from_corpus=True, + **kwargs, + ) + ) + + # ********** Train data ********** + + train_lexicon = train_data_inputs[train_key].lexicon.filename + eow_lexicon = AddEowPhonemesToLexiconJob(train_lexicon).out_lexicon + + train_data_config = build_feature_alignment_meta_dataset_config( + data_inputs=[train_data_inputs[train_key]], + feature_type=feature_type, + alignments=[alignments[f"{train_key}_align"]], + returnn_root=returnn_root, + returnn_python_exe=returnn_python_exe, + rasr_binary_path=rasr_binary_path, + rasr_arch=rasr_arch, + dc_detection=dc_detection, + extra_config={ + "partition_epoch": 5, + "seq_ordering": "laplace:.1000", + }, + ) + + # ********** CV data ********** + + cv_data_config = build_feature_alignment_meta_dataset_config( + data_inputs=[cv_data_inputs[cv_key] for cv_key in cv_keys], + feature_type=feature_type, + alignments=[alignments[f"{cv_key}_align"] for cv_key in cv_keys], + returnn_root=returnn_root, + returnn_python_exe=returnn_python_exe, + rasr_binary_path=rasr_binary_path, + rasr_arch=rasr_arch, + dc_detection=dc_detection, + single_hdf=True, + extra_config={ + "partition_epoch": 1, + "seq_ordering": "sorted", + }, + ) + + # ********** Recog lexicon ********** + + for rasr_input in {**dev_data_inputs, **test_data_inputs}.values(): + rasr_input.lexicon.filename = eow_lexicon + + # ********** Align data ********** + + align_data_inputs = { + f"{key}_align": copy.deepcopy(data_input) for key, data_input in {**train_data_inputs, **cv_data_inputs}.items() + } + for data_input in align_data_inputs.values(): + data_input.lexicon.filename = eow_lexicon + + return BasicSetupData( + train_key=train_key, + dev_keys=list(dev_data_inputs.keys()), + test_keys=list(test_data_inputs.keys()), + align_keys=[f"{train_key}_align", *[f"{key}_align" for key in cv_keys]], + train_data_config=train_data_config, + cv_data_config=cv_data_config, + data_inputs={ + **train_data_inputs, + **dev_data_inputs, + **test_data_inputs, + **align_data_inputs, + }, + ) diff --git a/users/berger/helpers/hdf.py b/users/berger/helpers/hdf.py index 523768d50..038a174d3 100644 --- a/users/berger/helpers/hdf.py +++ b/users/berger/helpers/hdf.py @@ -56,9 +56,12 @@ def build_rasr_feature_hdfs( rasr.crp_set_corpus(base_crp, corpus) base_crp.concurrent = split - feature_job = {"mfcc": features.MfccJob, "gt": features.GammatoneJob, "energy": features.EnergyJob}[feature_type]( - crp=base_crp, **feature_extraction_args - ) + feature_job = { + "mfcc": features.MfccJob, + "gt": features.GammatoneJob, + "fb": features.FilterbankJob, + "energy": features.EnergyJob, + }[feature_type](crp=base_crp, **feature_extraction_args) feature_job.set_keep_value(gs.JOB_DEFAULT_KEEP_VALUE - 20) hdf_files = [] diff --git a/users/berger/pytorch/custom_parts/vgg_frontend.py b/users/berger/pytorch/custom_parts/vgg_frontend.py index d42e8ac9a..c8412c787 100644 --- a/users/berger/pytorch/custom_parts/vgg_frontend.py +++ b/users/berger/pytorch/custom_parts/vgg_frontend.py @@ -1,105 +1,294 @@ from dataclasses import dataclass -from typing import Optional, Tuple +from typing import Callable, Optional, Tuple, Union import torch from i6_models.config import ModelConfiguration +from i6_models.parts.frontend.common import get_same_padding, calculate_output_dim + + +def mask_pool(seq_mask: torch.Tensor, *, kernel_size: int, stride: int, padding: int, ceil: bool) -> torch.Tensor: + """ + apply strides to the masking + + :param seq_mask: [B,T] + :param kernel_size: + :param stride: + :param padding: + :return: [B,T'] using maxpool + """ + if stride == 1 and 2 * padding == kernel_size - 1: + return seq_mask + + seq_mask = seq_mask.float() + seq_mask = torch.unsqueeze(seq_mask, 1) # [B,1,T] + seq_mask = torch.nn.functional.max_pool1d(seq_mask, kernel_size, stride, padding, ceil_mode=ceil) # [B,1,T'] + seq_mask = torch.squeeze(seq_mask, 1) # [B,T'] + seq_mask = seq_mask.bool() + return seq_mask @dataclass -class VGGFrontendConfigV1(ModelConfiguration): - num_inputs: int +class VGG4LayerActFrontendCeilPoolV1Config(ModelConfiguration): + """ + Attributes: + in_features: number of input features to module + conv1_channels: number of channels for first conv layer + conv2_channels: number of channels for second conv layer + conv3_channels: number of channels for third conv layer + conv4_channels: number of channels for fourth conv layer + conv_kernel_size: kernel size of conv layers + conv_padding: padding for the convolution + pool1_kernel_size: kernel size of first pooling layer + pool1_stride: stride of first pooling layer + pool1_padding: padding for first pooling layer + pool2_kernel_size: kernel size of second pooling layer + pool2_stride: stride of second pooling layer + pool2_padding: padding for second pooling layer + activation: activation function at the end + out_features: output size of the final linear layer + """ + + in_features: int conv1_channels: int conv2_channels: int conv3_channels: int - conv_kernel_size: int - conv1_stride: int - conv2_stride: int - conv3_stride: int - pool_size: int - linear_size: int - dropout: float + conv4_channels: int + conv_kernel_size: Tuple[int, int] + conv_padding: Optional[Tuple[int, int]] + pool1_kernel_size: Tuple[int, int] + pool1_stride: Optional[Tuple[int, int]] + pool1_padding: Optional[Tuple[int, int]] + pool2_kernel_size: Tuple[int, int] + pool2_stride: Optional[Tuple[int, int]] + pool2_padding: Optional[Tuple[int, int]] + activation: Union[torch.nn.Module, Callable[[torch.Tensor], torch.Tensor]] + out_features: int + + def check_valid(self): + if isinstance(self.conv_kernel_size, int): + assert self.conv_kernel_size % 2 == 1, "ConformerVGGFrontendV1 only supports odd kernel sizes" + if isinstance(self.pool1_kernel_size, int): + assert self.pool1_kernel_size % 2 == 1, "ConformerVGGFrontendV1 only supports odd kernel sizes" + if isinstance(self.pool2_kernel_size, int): + assert self.pool2_kernel_size % 2 == 1, "ConformerVGGFrontendV1 only supports odd kernel sizes" def __post__init__(self): super().__post_init__() - assert self.conv_kernel_size % 2 == 1, "Conv kernel size must be odd." + self.check_valid() -def subsample_mask(sequence_mask: torch.Tensor, subsampling_factor: int): - if subsampling_factor == 1: - return sequence_mask +class VGG4LayerActFrontendCeilPoolV1(torch.nn.Module): + """ + Convolutional Front-End - max_len = sequence_mask.shape[1] + The frond-end utilizes convolutional and pooling layers, as well as activation functions + to transform a feature vector, typically Log-Mel or Gammatone for audio, into an intermediate + representation. - padding = 0 - if (overhang := max_len % subsampling_factor) != 0: - padding = subsampling_factor - overhang + Structure of the front-end: + - Conv + - Conv + - Activation + - Pool + - Conv + - Conv + - Activation + - Pool - padded_mask = torch.nn.functional.pad(sequence_mask, pad=(0, padding), value=0) + Uses explicit padding for ONNX exportability, see: + https://github.com/pytorch/pytorch/issues/68880 + """ - reshaped_mask = padded_mask.reshape(padded_mask.shape[0], -1, subsampling_factor) + def __init__(self, model_cfg: VGG4LayerActFrontendCeilPoolV1Config): + """ + :param model_cfg: model configuration for this module + """ + super().__init__() - subsampled_mask = torch.all(reshaped_mask == 1, dim=2) - subsampled_mask = subsampled_mask.type(sequence_mask.dtype) + model_cfg.check_valid() - return subsampled_mask + self.cfg = model_cfg + conv_padding = ( + model_cfg.conv_padding + if model_cfg.conv_padding is not None + else get_same_padding(model_cfg.conv_kernel_size) + ) + pool1_padding = model_cfg.pool1_padding if model_cfg.pool1_padding is not None else (0, 0) + pool2_padding = model_cfg.pool2_padding if model_cfg.pool2_padding is not None else (0, 0) -class VGGFrontendV1(torch.nn.Module): - def __init__(self, config: VGGFrontendConfigV1): - super().__init__() self.conv1 = torch.nn.Conv2d( in_channels=1, - out_channels=config.conv1_channels, - kernel_size=(config.conv_kernel_size, 1), - padding=(config.conv_kernel_size // 2, 0), - stride=(config.conv1_stride, 1), - ) - self.pool = torch.nn.MaxPool2d( - kernel_size=(1, config.pool_size), - stride=(1, config.pool_size), + out_channels=model_cfg.conv1_channels, + kernel_size=model_cfg.conv_kernel_size, + padding=conv_padding, ) self.conv2 = torch.nn.Conv2d( - in_channels=config.conv1_channels, - out_channels=config.conv2_channels, - kernel_size=config.conv_kernel_size, - padding=config.conv_kernel_size // 2, - stride=(config.conv2_stride, 1), + in_channels=model_cfg.conv1_channels, + out_channels=model_cfg.conv2_channels, + kernel_size=model_cfg.conv_kernel_size, + padding=conv_padding, + ) + self.pool1 = torch.nn.MaxPool2d( + kernel_size=model_cfg.pool1_kernel_size, + stride=model_cfg.pool1_stride, + padding=pool1_padding, + ceil_mode=True, ) self.conv3 = torch.nn.Conv2d( - in_channels=config.conv2_channels, - out_channels=config.conv3_channels, - kernel_size=config.conv_kernel_size, - padding=config.conv_kernel_size // 2, - stride=(config.conv3_stride, 1), + in_channels=model_cfg.conv2_channels, + out_channels=model_cfg.conv3_channels, + kernel_size=model_cfg.conv_kernel_size, + padding=conv_padding, + ) + self.conv4 = torch.nn.Conv2d( + in_channels=model_cfg.conv3_channels, + out_channels=model_cfg.conv4_channels, + kernel_size=model_cfg.conv_kernel_size, + padding=conv_padding, ) + self.pool2 = torch.nn.MaxPool2d( + kernel_size=model_cfg.pool2_kernel_size, + stride=model_cfg.pool2_stride, + padding=pool2_padding, + ceil_mode=True, + ) + self.activation = model_cfg.activation self.linear = torch.nn.Linear( - config.conv3_channels * (config.num_inputs // config.pool_size), config.linear_size + in_features=self._calculate_dim(), + out_features=model_cfg.out_features, + bias=True, ) - self.subsample_factor = config.conv1_stride * config.conv2_stride * config.conv3_stride - self.dropout = config.dropout - self.layer_norm = torch.nn.LayerNorm(config.linear_size) def forward( - self, x: torch.Tensor, sequence_mask: Optional[torch.Tensor] + self, tensor: torch.Tensor, sequence_mask: Optional[torch.Tensor] = None ) -> Tuple[torch.Tensor, Optional[torch.Tensor]]: - x = x[:, None, :, :] # [B, 1, T, F] - x = self.conv1(x) # [B, C_1, T', F] - x = torch.nn.functional.silu(x) # [B, C_1, T', F] - x = self.pool(x) # [B, C_1, T', F'] - x = self.conv2(x) # [B, C_2, T'', F'] - x = torch.nn.functional.silu(x) # [B, C_2, T'', F'] - x = self.conv3(x) # [B, C_3, T''', F'] - x = torch.nn.functional.silu(x) # [B, C_3, T''', F'] - x = torch.transpose(x, 1, 2) # [B, T''', C_3, F'] - x = torch.flatten(x, start_dim=2) # [B, T''', C_3 * F'] - x = self.linear(x) # [B, T''', F''] - x = torch.nn.functional.dropout(x, p=self.dropout, training=self.training) # [B, T''', F''] - x = self.layer_norm(x) # [B, T''', F''] - - if sequence_mask is None: - subsampled_mask = None - else: - subsampled_mask = subsample_mask(sequence_mask, self.subsample_factor) - - return x, subsampled_mask + """ + T might be reduced to T' or T'' depending on stride of the layers + + stride is only allowed for the pool1 and pool2 operation. + other ops do not have stride configurable -> no update of mask sequence required but added anyway + + :param tensor: input tensor of shape [B,T,F] + :param sequence_mask: the sequence mask for the tensor + :return: torch.Tensor of shape [B,T",F'] and the shape of the sequence mask + """ + assert tensor.shape[-1] == self.cfg.in_features, f"shape {tensor.shape} vs in features {self.cfg.in_features}" + # and add a dim + tensor = tensor[:, None, :, :] # [B,C=1,T,F] + + tensor = self.conv1(tensor) + if sequence_mask is not None: + sequence_mask = mask_pool( + seq_mask=sequence_mask, + kernel_size=self.conv1.kernel_size[0], + stride=self.conv1.stride[0], + padding=self.conv1.padding[0], + ceil=False, + ) + + tensor = self.conv2(tensor) + if sequence_mask is not None: + sequence_mask = mask_pool( + sequence_mask, + kernel_size=self.conv2.kernel_size[0], + stride=self.conv2.stride[0], + padding=self.conv2.padding[0], + ceil=False, + ) + + tensor = self.activation(tensor) + tensor = self.pool1(tensor) # [B,C,T',F'] + if sequence_mask is not None: + sequence_mask = mask_pool( + sequence_mask, + kernel_size=self.pool1.kernel_size[0], + stride=self.pool1.stride[0], + padding=self.pool1.padding[0], + ceil=True, + ) + + tensor = self.conv3(tensor) + if sequence_mask is not None: + sequence_mask = mask_pool( + sequence_mask, + kernel_size=self.conv3.kernel_size[0], + stride=self.conv3.stride[0], + padding=self.conv3.padding[0], + ceil=False, + ) + + tensor = self.conv4(tensor) + if sequence_mask is not None: + sequence_mask = mask_pool( + sequence_mask, + kernel_size=self.conv4.kernel_size[0], + stride=self.conv4.stride[0], + padding=self.conv4.padding[0], + ceil=False, + ) + + tensor = self.activation(tensor) + tensor = self.pool2(tensor) # [B,C,T",F"] + if sequence_mask is not None: + sequence_mask = mask_pool( + sequence_mask, + kernel_size=self.pool2.kernel_size[0], + stride=self.pool2.stride[0], + padding=self.pool2.padding[0], + ceil=True, + ) + + tensor = torch.transpose(tensor, 1, 2) # transpose to [B,T",C,F"] + tensor = torch.flatten(tensor, start_dim=2, end_dim=-1) # [B,T",C*F"] + + tensor = self.linear(tensor) + + return tensor, sequence_mask + + def _calculate_dim(self) -> int: + # conv1 + out_dim = calculate_output_dim( + in_dim=self.cfg.in_features, + filter_size=self.conv1.kernel_size[1], + stride=self.conv1.stride[1], + padding=self.conv1.padding[1], + ) + # conv2 + out_dim = calculate_output_dim( + in_dim=out_dim, + filter_size=self.conv2.kernel_size[1], + stride=self.conv2.stride[1], + padding=self.conv2.padding[1], + ) + # pool1 + out_dim = calculate_output_dim( + in_dim=out_dim, + filter_size=self.pool1.kernel_size[1], + stride=self.pool1.stride[1], + padding=self.pool1.padding[1], + ) + # conv3 + out_dim = calculate_output_dim( + in_dim=out_dim, + filter_size=self.conv3.kernel_size[1], + stride=self.conv3.stride[1], + padding=self.conv3.padding[1], + ) + # conv4 + out_dim = calculate_output_dim( + in_dim=out_dim, + filter_size=self.conv4.kernel_size[1], + stride=self.conv4.stride[1], + padding=self.conv4.padding[1], + ) + # pool2 + out_dim = calculate_output_dim( + in_dim=out_dim, + filter_size=self.pool2.kernel_size[1], + stride=self.pool2.stride[1], + padding=self.pool2.padding[1], + ) + out_dim *= self.conv4.out_channels + return out_dim diff --git a/users/berger/pytorch/forward/transducer.py b/users/berger/pytorch/forward/transducer.py index b9b1caaf4..e6b4fcbbc 100644 --- a/users/berger/pytorch/forward/transducer.py +++ b/users/berger/pytorch/forward/transducer.py @@ -1,16 +1,15 @@ -import torch import numpy as np -from torchaudio.models.rnnt import RNNT -from returnn.frontend import Tensor -from returnn.tensor.tensor_dict import TensorDict -from i6_experiments.users.berger.pytorch.forward.transducer_beam_search import monotonic_timesync_beam_search -from sisyphus import tk +import torch from i6_core.lib.lexicon import Lexicon -from i6_experiments.users.berger.pytorch.helper_functions import map_tensor_to_minus1_plus1_interval +from i6_experiments.users.berger.pytorch.forward.transducer_beam_search import monotonic_timesync_beam_search from i6_experiments.users.berger.pytorch.models.conformer_transducer_v2 import ( FFNNTransducerDecoderOnly, FFNNTransducerEncoderOnly, ) +from returnn.frontend import Tensor +from returnn.tensor.tensor_dict import TensorDict +from sisyphus import tk +from torchaudio.models.rnnt import RNNT def encoder_forward_step(*, model: FFNNTransducerEncoderOnly, extern_data: TensorDict, **_): @@ -22,7 +21,7 @@ def encoder_forward_step(*, model: FFNNTransducerEncoderOnly, extern_data: Tenso device = torch.device("cuda" if torch.cuda.is_available() else "cpu") - source_encodings, source_lengths = model( + source_encodings, source_lengths = model.forward( sources=sources.to(device), source_lengths=source_lengths.to(device), ) # [B, T, E], [B] @@ -39,14 +38,14 @@ def decoder_forward_step(*, model: FFNNTransducerDecoderOnly, extern_data: Tenso source_encodings = extern_data["source_encodings"].raw_tensor assert source_encodings is not None - targets = extern_data["targets"].raw_tensor - assert targets is not None + history = extern_data["history"].raw_tensor + assert history is not None device = torch.device("cuda" if torch.cuda.is_available() else "cpu") - log_probs = model( + log_probs = model.forward( source_encodings=source_encodings.to(device), - targets=targets.to(device), + history=history.to(device), ) # [B, C] import returnn.frontend as rf diff --git a/users/berger/pytorch/forward/transducer_beam_search.py b/users/berger/pytorch/forward/transducer_beam_search.py index 0b8de6cb2..dd275cb0d 100644 --- a/users/berger/pytorch/forward/transducer_beam_search.py +++ b/users/berger/pytorch/forward/transducer_beam_search.py @@ -2,7 +2,6 @@ from dataclasses import dataclass import torch -from torchaudio.models.rnnt import RNNT @dataclass @@ -31,7 +30,7 @@ def extended_hypothesis( def monotonic_timesync_beam_search( - *, model: RNNT, features: torch.Tensor, feature_lengths: torch.Tensor, blank_id: int, beam_size: int = 10 + *, model: torch.nn.Module, features: torch.Tensor, feature_lengths: torch.Tensor, blank_id: int, beam_size: int = 10 ) -> Tuple[List[int], float]: # Some dimension checks if features.dim() == 2: # [T, F] @@ -49,8 +48,8 @@ def predict_next( token: int, history_state: Optional[List[List[torch.Tensor]]] ) -> Tuple[torch.Tensor, List[List[torch.Tensor]]]: new_pred_state, _, new_pred_history_state = model.predict( # [1, P] - targets=torch.tensor([[token]], device=enc.device), - target_lengths=torch.tensor([1], device=enc.device), + labels=torch.tensor([[token]], device=enc.device), + label_lengths=torch.tensor([1], device=enc.device), state=history_state, ) diff --git a/users/berger/pytorch/models/conformer_transducer_v2.py b/users/berger/pytorch/models/conformer_transducer_v2.py index 9df3af6c5..dc87638b7 100644 --- a/users/berger/pytorch/models/conformer_transducer_v2.py +++ b/users/berger/pytorch/models/conformer_transducer_v2.py @@ -1,18 +1,19 @@ -from dataclasses import dataclass +from dataclasses import dataclass, field from enum import Enum, auto -from typing import Callable, List, Optional, Tuple, Union +from typing import Callable, Dict, List, Optional, Tuple, Union import i6_models.assemblies.conformer as conformer_i6 import i6_models.parts.conformer as conformer_parts_i6 import torch from i6_core.returnn.config import CodeWrapper +from i6_core.tools.git import CloneGitRepositoryJob from i6_experiments.common.setups.returnn_pytorch.serialization import Collection -from i6_experiments.common.setups.serialization import Import, PartialImport +from i6_experiments.common.setups.serialization import Import, PartialImport, ExternalImport from i6_experiments.users.berger.pytorch.serializers.basic import ( get_basic_pt_network_serializer, ) from i6_models.config import ModelConfiguration, ModuleFactoryV1 -from i6_models.parts.frontend.generic_frontend import FrontendLayerType, GenericFrontendV1, GenericFrontendV1Config +from i6_models.parts.frontend.vgg_act import VGG4LayerActFrontendV1, VGG4LayerActFrontendV1Config from i6_models.primitives.feature_extraction import ( RasrCompatibleLogMelFeatureExtractionV1, RasrCompatibleLogMelFeatureExtractionV1Config, @@ -22,6 +23,7 @@ SpecaugmentByLengthConfigV1, SpecaugmentByLengthModuleV1, ) +from ..custom_parts.vgg_frontend import VGG4LayerActFrontendCeilPoolV1, VGG4LayerActFrontendCeilPoolV1Config from .util import lengths_to_padding_mask @@ -30,6 +32,9 @@ class TransducerTranscriberConfig(ModelConfiguration): feature_extraction: ModuleFactoryV1 specaugment: ModuleFactoryV1 encoder: ModuleFactoryV1 + layer_size: int + target_size: int + enc_loss_layers: List[int] = field(default_factory=list) class TransducerTranscriber(torch.nn.Module): @@ -39,11 +44,19 @@ def __init__(self, cfg: TransducerTranscriberConfig, **_) -> None: self.specaugment = cfg.specaugment() self.encoder = cfg.encoder() + self.enc_loss_layers = cfg.enc_loss_layers + self.output_layers = torch.nn.ModuleDict( + { + f"output_{layer_idx}": torch.nn.Linear(cfg.layer_size, cfg.target_size) + for layer_idx in cfg.enc_loss_layers + } + ) + def forward( self, sources: torch.Tensor, # [B, T, F] source_lengths: torch.Tensor, # [B] - ) -> Tuple[torch.Tensor, torch.Tensor]: # [B, T, C], [B] + ) -> Tuple[torch.Tensor, Dict[int, torch.Tensor], torch.Tensor]: # [B, T, C], Dict(l: [B, T, C]), [B] with torch.no_grad(): sources = sources.squeeze(-1) x, source_lengths = self.feature_extraction(sources, source_lengths) @@ -51,30 +64,46 @@ def forward( x = self.specaugment(x) # [B, T, F] - x, sequence_mask = self.encoder(x, sequence_mask) # [B, T, E], [B, T] - - return x, torch.sum(sequence_mask, dim=1).to(torch.int32) # [B, T, C], [B] - - -class TransducerTranscriberNoFeatExtr(torch.nn.Module): - def __init__(self, cfg: TransducerTranscriberConfig, **_) -> None: - super().__init__() - self.specaugment = cfg.specaugment() - self.encoder = cfg.encoder() - - def forward( - self, - sources: torch.Tensor, # [B, T, F] - source_lengths: torch.Tensor, # [B] - ) -> Tuple[torch.Tensor, torch.Tensor]: # [B, T, C], [B] - with torch.no_grad(): - sequence_mask = lengths_to_padding_mask(source_lengths) - - x = self.specaugment(sources) # [B, T, F] - - x, sequence_mask = self.encoder(x, sequence_mask) # [B, T, E], [B, T] - - return x, torch.sum(sequence_mask, dim=1).to(torch.int32) # [B, T, C], [B] + return_layers = self.enc_loss_layers.copy() + return_layers.append(len(self.encoder.module_list) - 1) + + intermediate_encodings, sequence_mask = self.encoder( + x, sequence_mask=sequence_mask, return_layers=return_layers + ) # List([B, T, E]), [B, T] + + source_encodings = intermediate_encodings[-1] + + intermediate_logits = { + layer_idx: self.output_layers[f"output_{layer_idx}"](encoding) + for layer_idx, encoding in zip(self.enc_loss_layers, intermediate_encodings) + } # Dict(l: [B, T, C]) + + return ( + source_encodings, + intermediate_logits, + torch.sum(sequence_mask, dim=1).to(torch.int32), + ) # [B, T, E], Dict(l: [B, T, C]), [B] + + +# class TransducerTranscriberNoFeatExtr(torch.nn.Module): +# def __init__(self, cfg: TransducerTranscriberConfig, **_) -> None: +# super().__init__() +# self.specaugment = cfg.specaugment() +# self.encoder = cfg.encoder() +# +# def forward( +# self, +# sources: torch.Tensor, # [B, T, F] +# source_lengths: torch.Tensor, # [B] +# ) -> Tuple[torch.Tensor, torch.Tensor]: # [B, T, C], [B] +# with torch.no_grad(): +# sequence_mask = lengths_to_padding_mask(source_lengths) +# +# x = self.specaugment(sources) # [B, T, F] +# +# x, sequence_mask = self.encoder(x, sequence_mask) # [B, T, E], [B, T] +# +# return x, torch.sum(sequence_mask, dim=1).to(torch.int32) # [B, T, C], [B] @dataclass @@ -111,62 +140,72 @@ def forward( self, targets: torch.Tensor, # [B, S], target_lengths: torch.Tensor, # [B], - state: Optional[ - List[List[torch.Tensor]] - ] = None, # Most recently fed inputs, used for higher order context, shape [[[B, H-1]]]; list of lists for compatibility with torchaudio - ) -> Tuple[torch.Tensor, torch.Tensor, List[List[torch.Tensor]]]: # [B, S, C], [B], [[[B, H-1]]] - # print("") - # print("Enter predictor forward") - # print("Predictor received input", input.deeper()) - + history: Optional[torch.Tensor] = None, # [B, H], use all blanks if None + ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]: # [B, S + 1, C], [B], [B, H] # extend input by prepending either the state if it's given or some history consisting of blanks - if state is None: - prepend = torch.full( - (targets.size(0), self.context_history_size - 1), + if history is None: + history = torch.full( + (targets.size(0), self.context_history_size), fill_value=self.blank_id, dtype=targets.dtype, device=targets.device, - ) # [B, H-1] - # print("Predictor received no state. Use", prepend.deeper()) - else: - prepend = state[0][0] # [B, H-1] - # print("Predictor received state", prepend.deeper()) - extended_input = torch.concat([prepend, targets], dim=1) # [B, S+H-1] - # print("extended input", extended_input.deeper()) + ) # [B, H] - if self.context_history_size > 1: - return_state = extended_input[:, -(self.context_history_size - 1) :] # [B, H-1] - else: - return_state = torch.empty( - size=(targets.size(0), 0), dtype=targets.dtype, device=targets.device - ) # [B, 0] = [B, H-1] - # print("New state is ", return_state.deeper()) + extended_targets = torch.concat([history, targets], dim=1) # [B, S+H] + + return_history = extended_targets[:, -(self.context_history_size) :] # [B, H] # Build context at each position by shifting and cutting label sequence. - # E.g. for history size 2 and label sequence a_1, ..., a_S we have context - # a_2 a_3 a_4 ... a_S - # a_1 a_2 a_3 ... a_{S-1} + # E.g. for history size 2 and extended targets 0, 0, a_1, ..., a_S we have context + # 0, a_1, a_2 a_3 a_4 ... a_S + # 0, 0, a_1 a_2 a_3 ... a_{S-1} context = torch.stack( [ - extended_input[:, self.context_history_size - 1 - i : (-i if i != 0 else None)] # [B, S] + extended_targets[:, self.context_history_size - 1 - i : (-i if i != 0 else None)] # [B, S+1] for i in range(self.context_history_size) ], dim=-1, - ) # [B, S, H] - - # print("Predict based on context", context) - a = self.embedding(context) # [B, S, H, E] - a = torch.reshape(a, shape=[*(a.shape[:-2]), a.shape[-2] * a.shape[-1]]) # [B, S, H*E] - a = self.network(a) # [B, S, P] - # topk = torch.topk(torch.nn.functional.softmax(a, dim=-1), k=4) - # print("Result probabilities:") - # print(topk.indices.deeper()) - # print(topk.values.deeper()) - # print( - # "Repeat probabilities:", - # torch.gather(torch.nn.functional.softmax(a, dim=-1), dim=-1, index=context[:, :, -2:-1]).deeper(), - # ) - return a, target_lengths, [[return_state]] + ) # [B, S+1, H] + + a = self.embedding(context) # [B, S+1, H, E] + a = torch.reshape(a, shape=[*(a.shape[:-2]), a.shape[-2] * a.shape[-1]]) # [B, S+1, H*E] + a = self.network(a) # [B, S+1, P] + return a, target_lengths, return_history + + def forward_viterbi( + self, + targets: torch.Tensor, # [B, T], + target_lengths: torch.Tensor, # [B], + ) -> Tuple[torch.Tensor, torch.Tensor]: # [B, T, C], [B] + # Get alignment sequence including blanks as labels, e.g. + # [0, 0, 1, 0, 2, 0, 0, 3, 0] + + B, T = targets.shape + + history = torch.zeros( + (B, T, self.context_history_size), dtype=targets.dtype, device=targets.device + ) # [B, T, H] + + # start with all-blank history + recent_labels = torch.full( + (B, self.context_history_size), fill_value=self.blank_id, dtype=targets.dtype, device=targets.device + ) # [B, H] + + for t in range(T): + # set context at frame t + history[:, t, :] = recent_labels + + current_labels = targets[:, t] # [B] + non_blank_positions = current_labels != self.blank_id # [B] + + # shift recent_labels and append next one if we see a non-blank + recent_labels[non_blank_positions, 1:] = recent_labels[non_blank_positions, :-1] + recent_labels[non_blank_positions, 0] = current_labels[non_blank_positions] + + a = self.embedding(history) # [B, T, H, E] + a = torch.reshape(a, shape=[*(a.shape[:-2]), a.shape[-2] * a.shape[-1]]) # [B, T, H*E] + a = self.network(a) # [B, T, P] + return a, target_lengths class CombinationMode(Enum): @@ -195,25 +234,44 @@ def __init__(self, cfg: TransducerJoinerConfig, **_) -> None: def forward( self, - source_encodings: torch.Tensor, # [B, T, C_1], + source_encodings: torch.Tensor, # [B, T, E], source_lengths: torch.Tensor, # [B], - target_encodings: torch.Tensor, # [B, S, C_2], + target_encodings: torch.Tensor, # [B, S+1, P], target_lengths: torch.Tensor, # [B] - ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]: # [B, T, S, F], [B], [B], + ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]: # [B, T, S+1, C], [B], [B], source_encodings = source_encodings.unsqueeze(2).expand( target_encodings.size(0), -1, target_encodings.size(1), -1 - ) # [B, T, S, C_1] - target_encodings = target_encodings.unsqueeze(1).expand(-1, source_encodings.size(1), -1, -1) # [B, T, S, C_2] + ) # [B, T, S+1, E] + target_encodings = target_encodings.unsqueeze(1).expand(-1, source_encodings.size(1), -1, -1) # [B, T, S+1, P] + + if self.combination_mode == CombinationMode.CONCAT: + joiner_inputs = torch.concat([source_encodings, target_encodings], dim=-1) # [B, T, S+1, E + P] + elif self.combination_mode == CombinationMode.SUM: + joiner_inputs = source_encodings + target_encodings # [B, T, S+1, E=P] + output = self.network(joiner_inputs) # [B, T, S+1, C] + + if not self.training: + output = torch.log_softmax(output, dim=-1) # [B, T, S+1, C] + + return output, source_lengths, target_lengths + + def forward_viterbi( + self, + source_encodings: torch.Tensor, # [B, T, E], + source_lengths: torch.Tensor, # [B], + target_encodings: torch.Tensor, # [B, T, P], + target_lengths: torch.Tensor, # [B] + ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]: # [B, T, C], [B], [B], if self.combination_mode == CombinationMode.CONCAT: - joiner_inputs = torch.concat([source_encodings, target_encodings], dim=-1) # [B, T, S, C_1 + C_2] + joiner_inputs = torch.concat([source_encodings, target_encodings], dim=-1) # [B, T, E + P] elif self.combination_mode == CombinationMode.SUM: - joiner_inputs = source_encodings + target_encodings # [B, T, S, C_1=C_2] + joiner_inputs = source_encodings + target_encodings # [B, T, E=P] - output = self.network(joiner_inputs) # [B, T, S, C] + output = self.network(joiner_inputs) # [B, T, C] if not self.training: - output = torch.log_softmax(output, dim=-1) + output = torch.log_softmax(output, dim=-1) # [B, T, C] return output, source_lengths, target_lengths @@ -230,34 +288,40 @@ def __init__(self, cfg: TransducerJoinerConfig, **_) -> None: def forward( self, - source_encodings: torch.Tensor, # [B, T, C_1], + source_encodings: torch.Tensor, # [B, T, E], source_lengths: torch.Tensor, # [B], - target_encodings: torch.Tensor, # [B, S, C_2], + target_encodings: torch.Tensor, # [B, S+1, P], target_lengths: torch.Tensor, # [B] - ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]: # [T_1 * S_1 + T_2 * S_2 + ... + T_B * S_B, F], [B], [B], + ) -> Tuple[ + torch.Tensor, torch.Tensor, torch.Tensor + ]: # [T_1 * (S_1+1) + T_2 * (S_2+1) + ... + T_B * (S_B+1), C], [B], [B], batch_tensors = [] for b in range(source_encodings.size(0)): - valid_source = source_encodings[b, : source_lengths[b], :] # [T_b, C_1] - valid_target = target_encodings[b, : target_lengths[b], :] # [S_b, C_2] + valid_source = source_encodings[b, : source_lengths[b], :] # [T_b, E] + valid_target = target_encodings[b, : target_lengths[b] + 1, :] # [S_b+1, P] - expanded_source = valid_source.unsqueeze(1).expand(-1, int(target_lengths[b].item()), -1) # [T_b, S_b, C_1] - expanded_target = valid_target.unsqueeze(0).expand(int(source_lengths[b].item()), -1, -1) # [T_b, S_b, C_2] + expanded_source = valid_source.unsqueeze(1).expand( + -1, int(target_lengths[b].item()) + 1, -1 + ) # [T_b, S_b+1, E] + expanded_target = valid_target.unsqueeze(0).expand(int(source_lengths[b].item()), -1, -1) # [T_b, S_b+1, P] if self.combination_mode == CombinationMode.CONCAT: - combination = torch.concat([expanded_source, expanded_target], dim=-1) # [T_b, S_b, C_1 + C_2] + combination = torch.concat([expanded_source, expanded_target], dim=-1) # [T_b, S_b+1, E + P] elif self.combination_mode == CombinationMode.SUM: - combination = expanded_source + expanded_target # [T_b, S_b, C_1 (=C_2)] + combination = expanded_source + expanded_target # [T_b, S_b+1, E (=P)] else: raise NotImplementedError - batch_tensors.append(combination.reshape(-1, combination.size(2))) # [T_b * S_b, C'] + batch_tensors.append(combination.reshape(-1, combination.size(2))) # [T_b * (S_b+1), E(+P)] - joint_encodings = torch.concat(batch_tensors, dim=0) # [T_1 * S_1 + T_2 * S_2 + ... + T_B * S_B, C'] - output = self.network(joint_encodings) # [T_1 * S_1 + T_2 * S_2 + ... + T_B * S_B, F] + joint_encodings = torch.concat( + batch_tensors, dim=0 + ) # [T_1 * (S_1+1) + T_2 * (S_2+1) + ... + T_B * (S_B+1), E(+P)] + output = self.network(joint_encodings) # [T_1 * (S_1+1) + T_2 * (S_2+1) + ... + T_B * (S_B+1), C] if not self.training: - output = torch.log_softmax(output, dim=-1) + output = torch.log_softmax(output, dim=-1) # [T_1 * (S_1+1) + T_2 * (S_2+1) + ... + T_B * (S_B+1), C] return output, source_lengths, target_lengths @@ -269,6 +333,11 @@ class FFNNTransducerConfig(ModelConfiguration): joiner_cfg: TransducerJoinerConfig +@dataclass +class FFNNTransducerWithIlmConfig(FFNNTransducerConfig): + ilm_scale: float + + class FFNNTransducer(torch.nn.Module): def __init__(self, step: int, cfg: FFNNTransducerConfig, **_): super().__init__() @@ -276,22 +345,31 @@ def __init__(self, step: int, cfg: FFNNTransducerConfig, **_): self.predictor = FFNNTransducerPredictor(cfg.predictor_cfg) self.joiner = PackedTransducerJoiner(cfg.joiner_cfg) - def transcribe(self, sources: torch.Tensor, source_lengths: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]: - return self.transcriber(sources=sources, source_lengths=source_lengths) + def transcribe( + self, + sources: torch.Tensor, # [B, T, F] + source_lengths: torch.Tensor, # [B] + ) -> Tuple[torch.Tensor, Dict[int, torch.Tensor], torch.Tensor]: # [B, T, E], Dict(l: [B, T, E]), [B] + return self.transcriber.forward(sources=sources, source_lengths=source_lengths) def predict( - self, targets: torch.Tensor, target_lengths: torch.Tensor, state: Optional[List[List[torch.Tensor]]] - ) -> Tuple[torch.Tensor, torch.Tensor, List[List[torch.Tensor]]]: - return self.predictor(targets=targets, target_lengths=target_lengths, state=state) + self, + targets: torch.Tensor, # [B, S] + target_lengths: torch.Tensor, # [B] + history: Optional[torch.Tensor] = None, # [B, H] + ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]: # [B, S+1, P], [B], [B, H] + return self.predictor.forward(targets=targets, target_lengths=target_lengths, history=history) def join( self, - source_encodings: torch.Tensor, - source_lengths: torch.Tensor, - target_encodings: torch.Tensor, - target_lengths: torch.Tensor, - ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]: - return self.joiner( + source_encodings: torch.Tensor, # [B, T, E] + source_lengths: torch.Tensor, # [B] + target_encodings: torch.Tensor, # [B, S+1, P] + target_lengths: torch.Tensor, # [B] + ) -> Tuple[ + torch.Tensor, torch.Tensor, torch.Tensor + ]: # [T_1 * (S_1+1) + T_2 * (S_2+1) + ... + T_B * (S_B+1), C], [B], [B], + return self.joiner.forward( source_encodings=source_encodings, source_lengths=source_lengths, target_encodings=target_encodings, @@ -300,38 +378,102 @@ def join( def forward( self, - sources: torch.Tensor, - source_lengths: torch.Tensor, - targets: torch.Tensor, - target_lengths: torch.Tensor, - predictor_state: Optional[List[List[torch.Tensor]]] = None, - ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor, List[List[torch.Tensor]]]: - source_encodings, source_lengths = self.transcribe(sources=sources, source_lengths=source_lengths) - target_encodings, target_lengths, state = self.predict( - targets=targets, target_lengths=target_lengths, state=predictor_state + sources: torch.Tensor, # [B, T, F] + source_lengths: torch.Tensor, # [B] + targets: torch.Tensor, # [B, S] + target_lengths: torch.Tensor, # [B] + history: Optional[torch.Tensor] = None, # [B, H] + ) -> Tuple[ + torch.Tensor, Dict[int, torch.Tensor], torch.Tensor, torch.Tensor, torch.Tensor + ]: # [T_1 * (S_1+1) + T_2 * (S_2+1) + ... + T_B * (S_B+1), C], Dict(l: [B, T, C]), [B], [B], [B, H] + source_encodings, intermediate_logits, source_lengths = self.transcribe( + sources=sources, source_lengths=source_lengths + ) + label_encodings, target_lengths, history = self.predict( + targets=targets, target_lengths=target_lengths, history=history ) output, source_lengths, target_lengths = self.join( + source_encodings=source_encodings, + source_lengths=source_lengths, + target_encodings=label_encodings, + target_lengths=target_lengths, + ) + + return output, intermediate_logits, source_lengths, target_lengths, history + + +class FFNNTransducerViterbi(torch.nn.Module): + def __init__(self, step: int, cfg: FFNNTransducerConfig, **_): + super().__init__() + self.transcriber = TransducerTranscriber(cfg.transcriber_cfg) + self.predictor = FFNNTransducerPredictor(cfg.predictor_cfg) + self.joiner = TransducerJoiner(cfg.joiner_cfg) + + def transcribe( + self, + sources: torch.Tensor, # [B, T, F] + source_lengths: torch.Tensor, # [B] + ) -> Tuple[torch.Tensor, Dict[int, torch.Tensor], torch.Tensor]: # [B, T, E], Dict(l: [B, T, C]), [B] + return self.transcriber.forward(sources=sources, source_lengths=source_lengths) + + def predict( + self, + targets: torch.Tensor, # [B, T] + target_lengths: torch.Tensor, # [B] + ) -> Tuple[torch.Tensor, torch.Tensor]: # [B, T, P], [B] + return self.predictor.forward_viterbi(targets=targets, target_lengths=target_lengths) + + def join( + self, + source_encodings: torch.Tensor, # [B, T, E] + source_lengths: torch.Tensor, # [B] + target_encodings: torch.Tensor, # [B, T, P] + target_lengths: torch.Tensor, # [B] + ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]: # [B, T, C], [B], [B] + return self.joiner.forward_viterbi( source_encodings=source_encodings, source_lengths=source_lengths, target_encodings=target_encodings, target_lengths=target_lengths, ) - return output, source_lengths, target_lengths, state + def forward( + self, + sources: torch.Tensor, # [B, T, F] + source_lengths: torch.Tensor, # [B] + targets: torch.Tensor, # [B, T] + target_lengths: torch.Tensor, # [B] + ) -> Tuple[ + torch.Tensor, Dict[int, torch.Tensor], torch.Tensor, torch.Tensor + ]: # [B, T, C], Dict(l: [B, T, C]), [B], [B] + source_encodings, intermediate_logits, source_lengths = self.transcribe( + sources=sources, source_lengths=source_lengths + ) + target_encodings, target_lengths = self.predict(targets=targets, target_lengths=target_lengths) + + output, source_lengths, target_lengths = self.join( + source_encodings=source_encodings, + source_lengths=source_lengths, + target_encodings=target_encodings, + target_lengths=target_lengths, + ) + + return output, intermediate_logits, source_lengths, target_lengths class FFNNTransducerEncoderOnly(torch.nn.Module): def __init__(self, step: int, cfg: FFNNTransducerConfig, **_): super().__init__() - self.transcriber = TransducerTranscriberNoFeatExtr(cfg.transcriber_cfg) + self.transcriber = TransducerTranscriber(cfg.transcriber_cfg) def forward( self, sources: torch.Tensor, # [B, T, F] source_lengths: torch.Tensor, # [B] ) -> Tuple[torch.Tensor, torch.Tensor]: # [B, T', E] - return self.transcriber(sources=sources, source_lengths=source_lengths) + source_encodings, _, source_lengths = self.transcriber.forward(sources=sources, source_lengths=source_lengths) + return source_encodings, source_lengths class FFNNTransducerDecoderOnly(torch.nn.Module): @@ -340,38 +482,72 @@ def __init__(self, step: int, cfg: FFNNTransducerConfig, **_): self.predictor = FFNNTransducerPredictor(cfg.predictor_cfg) self.joiner = TransducerJoiner(cfg.joiner_cfg) + if isinstance(cfg, FFNNTransducerWithIlmConfig): + self.ilm_scale = cfg.ilm_scale + else: + self.ilm_scale = 0.0 + def forward( self, source_encodings: torch.Tensor, # [B, E] - targets: torch.Tensor, # [B, H] + history: torch.Tensor, # [B, H] ) -> torch.Tensor: # [B, C] - dec_state = [[targets[:, :-1]]] # [[[B, H-1]]] - dec_current_label = targets[:, -1:] # [B, 1] - dec_length = torch.tensor([1] * targets.size(0), device=targets.device) # [B] + device = source_encodings.device + B = history.size(0) + source_lengths = torch.tensor([1] * B, device=device) # [B] + target_lengths = torch.tensor([0] * B, device=device) # [B] - decoder, _, _ = self.predictor( - targets=dec_current_label, target_lengths=dec_length, state=dec_state + history_encoding, _, _ = self.predictor.forward( + targets=torch.empty((B, 0), dtype=history.dtype, device=device), + target_lengths=target_lengths, + history=history, ) # [B, 1, P] source_encodings = source_encodings.unsqueeze(1) # [B, 1, E] - joint_output, _, _ = self.joiner( + joint_output, _, _ = self.joiner.forward( source_encodings=source_encodings, - source_lengths=dec_length, - target_encodings=decoder, - target_lengths=dec_length, + source_lengths=source_lengths, # [B] + target_encodings=history_encoding, + target_lengths=target_lengths, ) # [B, 1, 1, C] + joint_output = joint_output.squeeze(2).squeeze(1) # [B, C] + + if self.ilm_scale != 0: + assert self.predictor.blank_id == 0 + joint_output_ilm, _, _ = self.joiner.forward( + source_encodings=torch.zeros_like(source_encodings), + source_lengths=source_lengths, + target_encodings=history_encoding, + target_lengths=target_lengths, + ) # [B, 1, 1, C] + joint_output_ilm = joint_output_ilm.squeeze(2).squeeze(1) # [B, C] + + blank_log_probs = joint_output_ilm[:, :1] # [B, 1] + non_blank_log_probs = joint_output_ilm[:, 1:] # [B, C-1] + + joint_output_ilm = torch.concat( + [ + torch.zeros_like(blank_log_probs), + non_blank_log_probs - torch.log(1.0 - torch.exp(blank_log_probs)), + ], + dim=-1, + ) # [B, C] - return joint_output.squeeze(2).squeeze(1) # [B, C] + joint_output -= self.ilm_scale * joint_output_ilm + + return joint_output # [B, C] def get_train_serializer(model_config: FFNNTransducerConfig, **kwargs) -> Collection: assert __package__ is not None pytorch_package = __package__.rpartition(".")[0] + loss_repo = CloneGitRepositoryJob("https://github.com/SimBe195/monotonic-rnnt.git").out_repository return get_basic_pt_network_serializer( module_import_path=f"{__name__}.{FFNNTransducer.__name__}", model_config=model_config, additional_serializer_objects=[ + ExternalImport(import_path=loss_repo), PartialImport( code_object_path=f"{pytorch_package}.train_steps.transducer.train_step", hashed_arguments=kwargs, @@ -382,6 +558,46 @@ def get_train_serializer(model_config: FFNNTransducerConfig, **kwargs) -> Collec ) +def get_viterbi_train_serializer(model_config: FFNNTransducerConfig, **kwargs) -> Collection: + assert __package__ is not None + pytorch_package = __package__.rpartition(".")[0] + return get_basic_pt_network_serializer( + module_import_path=f"{__name__}.{FFNNTransducerViterbi.__name__}", + model_config=model_config, + additional_serializer_objects=[ + PartialImport( + code_object_path=f"{pytorch_package}.train_steps.transducer.train_step_viterbi", + import_as="train_step", + hashed_arguments=kwargs, + unhashed_package_root="", + unhashed_arguments={}, + ), + ], + ) + + +def get_align_restrict_train_serializer(model_config: FFNNTransducerConfig, **kwargs) -> Collection: + assert __package__ is not None + pytorch_package = __package__.rpartition(".")[0] + loss_repo = CloneGitRepositoryJob( + "https://github.com/SimBe195/monotonic-rnnt.git", commit="3fbb480107f7379347b25953be0727dcc4d0e57b" + ).out_repository + return get_basic_pt_network_serializer( + module_import_path=f"{__name__}.{FFNNTransducer.__name__}", + model_config=model_config, + additional_serializer_objects=[ + ExternalImport(import_path=loss_repo), + PartialImport( + code_object_path=f"{pytorch_package}.train_steps.transducer.train_step_align_restrict", + import_as="train_step", + hashed_arguments=kwargs, + unhashed_package_root="", + unhashed_arguments={}, + ), + ], + ) + + def get_torchaudio_train_serializer(model_config: FFNNTransducerConfig, **kwargs) -> Collection: assert __package__ is not None pytorch_package = __package__.rpartition(".")[0] @@ -505,26 +721,22 @@ def get_default_config_v1(num_outputs: int) -> FFNNTransducerConfig: ) frontend = ModuleFactoryV1( - GenericFrontendV1, - GenericFrontendV1Config( + VGG4LayerActFrontendV1, + VGG4LayerActFrontendV1Config( in_features=80, - layer_ordering=[ - FrontendLayerType.Conv2d, - FrontendLayerType.Conv2d, - FrontendLayerType.Pool2d, - FrontendLayerType.Conv2d, - FrontendLayerType.Conv2d, - FrontendLayerType.Pool2d, - FrontendLayerType.Activation, - ], - conv_kernel_sizes=[(3, 3), (3, 3), (3, 3), (3, 3)], - conv_paddings=None, - conv_out_dims=[32, 64, 64, 32], - conv_strides=[(1, 1), (1, 1), (1, 1), (1, 1)], - pool_kernel_sizes=[(2, 1), (2, 1)], - pool_strides=None, - pool_paddings=None, - activations=[torch.nn.ReLU()], + conv1_channels=32, + conv2_channels=64, + conv3_channels=64, + conv4_channels=32, + conv_kernel_size=(3, 3), + conv_padding=None, + pool1_kernel_size=(2, 1), + pool1_stride=(2, 1), + pool1_padding=None, + pool2_kernel_size=(2, 1), + pool2_stride=(2, 1), + pool2_padding=None, + activation=torch.nn.ReLU(), out_features=384, ), ) @@ -551,13 +763,13 @@ def get_default_config_v1(num_outputs: int) -> FFNNTransducerConfig: norm=torch.nn.BatchNorm1d(num_features=384, affine=False), ) - block_cfg = conformer_i6.ConformerBlockV1Config( + block_cfg = conformer_i6.ConformerBlockV2Config( ff_cfg=ff_cfg, mhsa_cfg=mhsa_cfg, conv_cfg=conv_cfg, ) - conformer_cfg = conformer_i6.ConformerEncoderV1Config( + conformer_cfg = conformer_i6.ConformerEncoderV2Config( num_layers=12, frontend=frontend, block_cfg=block_cfg, @@ -566,7 +778,10 @@ def get_default_config_v1(num_outputs: int) -> FFNNTransducerConfig: transcriber_cfg = TransducerTranscriberConfig( feature_extraction=feature_extraction, specaugment=specaugment, - encoder=ModuleFactoryV1(module_class=conformer_i6.ConformerEncoderV1, cfg=conformer_cfg), + encoder=ModuleFactoryV1(module_class=conformer_i6.ConformerEncoderV2, cfg=conformer_cfg), + layer_size=384, + target_size=num_outputs, + enc_loss_layers=[5, 11], ) predictor_cfg = FFNNTransducerPredictorConfig( @@ -593,3 +808,119 @@ def get_default_config_v1(num_outputs: int) -> FFNNTransducerConfig: predictor_cfg=predictor_cfg, joiner_cfg=joiner_cfg, ) + + +def get_default_config_v2(num_outputs: int) -> FFNNTransducerConfig: + feature_extraction = ModuleFactoryV1( + module_class=RasrCompatibleLogMelFeatureExtractionV1, + cfg=RasrCompatibleLogMelFeatureExtractionV1Config( + sample_rate=16000, + win_size=0.025, + hop_size=0.01, + min_amp=1.175494e-38, + num_filters=80, + alpha=0.97, + ), + ) + + specaugment = ModuleFactoryV1( + module_class=SpecaugmentByLengthModuleV1, + cfg=SpecaugmentByLengthConfigV1( + time_min_num_masks=2, + time_max_mask_per_n_frames=20, + time_mask_max_size=30, + freq_min_num_masks=2, + freq_max_num_masks=16, + freq_mask_max_size=5, + ), + ) + + frontend = ModuleFactoryV1( + VGG4LayerActFrontendV1, + VGG4LayerActFrontendV1Config( + in_features=80, + conv1_channels=32, + conv2_channels=64, + conv3_channels=64, + conv4_channels=32, + conv_kernel_size=(3, 3), + conv_padding=None, + pool1_kernel_size=(2, 1), + pool1_stride=(2, 1), + pool1_padding=None, + pool2_kernel_size=(2, 1), + pool2_stride=(2, 1), + pool2_padding=None, + activation=torch.nn.ReLU(), + out_features=768, + ), + ) + + ff_cfg = conformer_parts_i6.ConformerPositionwiseFeedForwardV1Config( + input_dim=768, + hidden_dim=3072, + dropout=0.3, + activation=torch.nn.SiLU(), + ) + + mhsa_cfg = conformer_parts_i6.ConformerMHSAV1Config( + input_dim=768, + num_att_heads=8, + att_weights_dropout=0.3, + dropout=0.3, + ) + + conv_cfg = conformer_parts_i6.ConformerConvolutionV1Config( + channels=768, + kernel_size=7, + dropout=0.3, + activation=torch.nn.SiLU(), + norm=torch.nn.BatchNorm1d(num_features=768, affine=False), + ) + + block_cfg = conformer_i6.ConformerBlockV2Config( + ff_cfg=ff_cfg, + mhsa_cfg=mhsa_cfg, + conv_cfg=conv_cfg, + modules=["ff", "conv", "mhsa", "ff"], + ) + + conformer_cfg = conformer_i6.ConformerEncoderV2Config( + num_layers=12, + frontend=frontend, + block_cfg=block_cfg, + ) + + transcriber_cfg = TransducerTranscriberConfig( + feature_extraction=feature_extraction, + specaugment=specaugment, + encoder=ModuleFactoryV1(module_class=conformer_i6.ConformerEncoderV2, cfg=conformer_cfg), + layer_size=768, + target_size=num_outputs, + enc_loss_layers=[5, 11], + ) + + predictor_cfg = FFNNTransducerPredictorConfig( + layers=2, + layer_size=384, + activation=torch.nn.Tanh(), + dropout=0.3, + context_history_size=1, + context_embedding_size=256, + blank_id=0, + target_size=num_outputs, + ) + + joiner_cfg = TransducerJoinerConfig( + input_size=1152, + layer_size=1024, + act=torch.nn.Tanh(), + target_size=num_outputs, + combination_mode=CombinationMode.CONCAT, + ) + + return FFNNTransducerConfig( + transcriber_cfg=transcriber_cfg, + predictor_cfg=predictor_cfg, + joiner_cfg=joiner_cfg, + ) diff --git a/users/berger/pytorch/train_steps/transducer.py b/users/berger/pytorch/train_steps/transducer.py index ceaae3809..e23a41d23 100644 --- a/users/berger/pytorch/train_steps/transducer.py +++ b/users/berger/pytorch/train_steps/transducer.py @@ -1,47 +1,268 @@ +from typing import Dict, Optional + import torch from returnn.tensor.tensor_dict import TensorDict -from i6_experiments.users.berger.pytorch.helper_functions import map_tensor_to_minus1_plus1_interval +from i6_experiments.users.berger.pytorch.models.conformer_transducer_v2 import FFNNTransducer, FFNNTransducerViterbi + + +def train_step( + *, + model: FFNNTransducer, + extern_data: TensorDict, + blank_idx: int = 0, + enc_loss_scales: Optional[Dict[int, float]] = None, + **_, +): + import returnn.frontend as rf + from pytorch_binding.monotonic_rnnt_op import monotonic_rnnt_loss + from returnn.tensor import batch_dim -def train_step(*, model: torch.nn.Module, extern_data: TensorDict, blank_idx: int = 0, **kwargs): - from returnn.extern_private.BergerMonotonicRNNT.monotonic_rnnt.pytorch_binding import monotonic_rnnt_loss + if enc_loss_scales is None: + enc_loss_scales = {} - audio_features = extern_data["data"].raw_tensor - assert audio_features is not None - audio_features = audio_features.float() - # audio_features = map_tensor_to_minus1_plus1_interval(audio_features) + sources = extern_data["data"].raw_tensor + assert sources is not None + sources = sources.float() assert extern_data["data"].dims[1].dyn_size_ext is not None - audio_feature_lengths = extern_data["data"].dims[1].dyn_size_ext.raw_tensor - assert audio_feature_lengths is not None - audio_feature_lengths = audio_feature_lengths.to(device="cuda") + source_lengths = extern_data["data"].dims[1].dyn_size_ext.raw_tensor + assert source_lengths is not None + source_lengths = source_lengths.to(device="cuda") assert extern_data["classes"].raw_tensor is not None targets = extern_data["classes"].raw_tensor.to(dtype=torch.int32) - assert extern_data["classes"].dims[1].dyn_size_ext is not None - target_lengths = extern_data["classes"].dims[1].dyn_size_ext.raw_tensor + target_lengths_rf = extern_data["classes"].dims[1].dyn_size_ext + assert target_lengths_rf is not None + + target_lengths = target_lengths_rf.raw_tensor assert target_lengths is not None target_lengths = target_lengths.to(device="cuda") - targets_padded = torch.nn.functional.pad(targets, (1, 0), mode="constant", value=blank_idx) - targets_padded_lengths = target_lengths + 1 + loss_norm_factor = rf.reduce_sum(target_lengths_rf, axis=batch_dim) - model_logits, input_lengths, _, _ = model( - sources=audio_features, - source_lengths=audio_feature_lengths, - targets=targets_padded, - target_lengths=targets_padded_lengths, + model_logits, intermediate_logits, source_lengths, _, _ = model.forward( + sources=sources, + source_lengths=source_lengths, + targets=targets, + target_lengths=target_lengths, ) loss = monotonic_rnnt_loss( acts=model_logits.to(dtype=torch.float32), labels=targets, - input_lengths=input_lengths, + input_lengths=source_lengths, label_lengths=target_lengths, blank_label=blank_idx, ) + rf.get_run_ctx().mark_as_loss(name="monotonic_rnnt", loss=loss, custom_inv_norm_factor=loss_norm_factor) + + targets_packed = torch.nn.utils.rnn.pack_padded_sequence( + targets, target_lengths.cpu(), batch_first=True, enforce_sorted=False + ) + + for layer_idx, scale in enc_loss_scales.items(): + logits = intermediate_logits[layer_idx] + log_probs = torch.nn.functional.log_softmax(logits, dim=-1) # [B, T, C] + log_probs = torch.transpose(log_probs, 0, 1) # [T, B, C] + + loss = torch.nn.functional.ctc_loss( + log_probs=log_probs, + targets=targets, + input_lengths=source_lengths, + target_lengths=target_lengths, + blank=blank_idx, + reduction="sum", + zero_infinity=True, + ) + + rf.get_run_ctx().mark_as_loss( + name=f"CTC_enc-{layer_idx}", + loss=loss, + scale=scale, + custom_inv_norm_factor=loss_norm_factor, + ) + + predictions = torch.argmax(log_probs, dim=-1) + predictions_packed = torch.nn.utils.rnn.pack_padded_sequence( + predictions, target_lengths.cpu(), batch_first=True, enforce_sorted=False + ) + num_incorrect_frames = torch.sum((targets_packed.data != predictions_packed.data)) + + rf.get_run_ctx().mark_as_loss( + name=f"FER_enc-{layer_idx}", + loss=num_incorrect_frames, + custom_inv_norm_factor=loss_norm_factor, + as_error=True, + ) + + +def train_step_viterbi( + *, + model: FFNNTransducerViterbi, + extern_data: TensorDict, + enc_loss_scales: Optional[Dict[int, float]] = None, + **_, +): + import returnn.frontend as rf + from returnn.tensor import batch_dim + + if enc_loss_scales is None: + enc_loss_scales = {} + + sources = extern_data["data"].raw_tensor + assert sources is not None + sources = sources.float() + + assert extern_data["classes"].raw_tensor is not None + targets = extern_data["classes"].raw_tensor.to(dtype=torch.int32) + + assert extern_data["data"].dims[1].dyn_size_ext is not None + source_lengths = extern_data["data"].dims[1].dyn_size_ext.raw_tensor + assert source_lengths is not None + source_lengths = source_lengths.to(device="cuda") + + target_lengths_rf = extern_data["classes"].dims[1].dyn_size_ext + assert target_lengths_rf is not None + + target_lengths = target_lengths_rf.raw_tensor + assert target_lengths is not None + target_lengths = target_lengths.to(device="cuda") + + loss_norm_factor = rf.reduce_sum(target_lengths_rf, axis=batch_dim) + + model_logits, intermediate_logits, _, _ = model.forward( + sources=sources, + source_lengths=source_lengths, + targets=targets, + target_lengths=target_lengths, + ) + + targets_packed = torch.nn.utils.rnn.pack_padded_sequence( + targets.long(), target_lengths.cpu(), batch_first=True, enforce_sorted=False + ) + targets_masked, _ = torch.nn.utils.rnn.pad_packed_sequence(targets_packed, batch_first=True, padding_value=-100) + for logits, scale, suffix in [(model_logits, 1.0, "final")] + [ + (intermediate_logits[layer_idx], scale, f"enc-{layer_idx}") for layer_idx, scale in enc_loss_scales.items() + ]: + log_probs = torch.log_softmax(logits, dim=-1) # [B, T, F] + log_probs = torch.transpose(log_probs, 1, 2) # [B, F, T] + + loss = torch.nn.functional.cross_entropy( + input=log_probs, target=targets_masked, ignore_index=-100, reduction="sum" + ) + + predictions = torch.argmax(logits, dim=-1) + predictions_packed = torch.nn.utils.rnn.pack_padded_sequence( + predictions.long(), target_lengths.cpu(), batch_first=True, enforce_sorted=False + ) + num_incorrect_frames = torch.sum((targets_packed.data != predictions_packed.data)) + + rf.get_run_ctx().mark_as_loss( + name=f"CE_{suffix}", loss=loss, scale=scale, custom_inv_norm_factor=loss_norm_factor + ) + rf.get_run_ctx().mark_as_loss( + name=f"FER_{suffix}", loss=num_incorrect_frames, custom_inv_norm_factor=loss_norm_factor, as_error=True + ) + + +def train_step_align_restrict( + *, + model: FFNNTransducer, + extern_data: TensorDict, + max_distance_from_alignment: int, + blank_idx: int = 0, + enc_loss_scales: Optional[Dict[int, float]] = None, + **_, +): import returnn.frontend as rf + from pytorch_binding.monotonic_rnnt_op import monotonic_rnnt_loss + from returnn.tensor import batch_dim + + if enc_loss_scales is None: + enc_loss_scales = {} + + sources = extern_data["data"].raw_tensor + assert sources is not None + sources = sources.float() + + assert extern_data["data"].dims[1].dyn_size_ext is not None + source_lengths = extern_data["data"].dims[1].dyn_size_ext.raw_tensor + assert source_lengths is not None + source_lengths = source_lengths.to(device="cuda") + + assert extern_data["classes"].raw_tensor is not None + alignments = extern_data["classes"].raw_tensor.to(torch.int32) # [B, T] + alignment_lengths_rf = extern_data["classes"].dims[1].dyn_size_ext + assert alignment_lengths_rf is not None + + target_lengths = (alignments != blank_idx).sum(dim=1) # [B] + target_lengths = target_lengths.to(device="cuda", dtype=torch.int32) + target_lengths_rf = rf.Tensor("target_lengths", dims=[batch_dim], dtype="int32", raw_tensor=target_lengths) + + max_target_length = target_lengths.max().item() + targets = torch.zeros((target_lengths.size(0), max_target_length), dtype=alignments.dtype, device=alignments.device) + + for i in range(targets.size(0)): + non_blanks = alignments[i][alignments[i] != blank_idx] + targets[i, : non_blanks.size(0)] = non_blanks + + target_loss_norm_factor = rf.reduce_sum(target_lengths_rf, axis=batch_dim) + alignment_loss_norm_factor = rf.reduce_sum(alignment_lengths_rf, axis=batch_dim) + + model_logits, intermediate_logits, source_lengths, _, _ = model.forward( + sources=sources, + source_lengths=source_lengths, + targets=targets, + target_lengths=target_lengths, + ) + + loss = monotonic_rnnt_loss( + acts=model_logits.to(dtype=torch.float32), + labels=targets, + input_lengths=source_lengths, + label_lengths=target_lengths, + alignment=alignments, + max_distance_from_alignment=max_distance_from_alignment, + blank_label=blank_idx, + ) + rf.get_run_ctx().mark_as_loss( + name=f"monotonic_rnnt_restrict-{max_distance_from_alignment}", + loss=loss, + custom_inv_norm_factor=target_loss_norm_factor, + ) + + alignments_packed = torch.nn.utils.rnn.pack_padded_sequence( + alignments, source_lengths.cpu(), batch_first=True, enforce_sorted=False + ) + alignments_masked, _ = torch.nn.utils.rnn.pad_packed_sequence( + alignments_packed, batch_first=True, padding_value=-100 + ) + + for logits, scale, suffix in [ + (intermediate_logits[layer_idx], scale, f"enc-{layer_idx}") for layer_idx, scale in enc_loss_scales.items() + ]: + log_probs = torch.log_softmax(logits, dim=-1) # [B, T, F] + log_probs = torch.transpose(log_probs, 1, 2) # [B, F, T] + + loss = torch.nn.functional.cross_entropy( + input=log_probs, target=alignments_masked.long(), ignore_index=-100, reduction="sum" + ) + + predictions = torch.argmax(logits, dim=-1) + predictions_packed = torch.nn.utils.rnn.pack_padded_sequence( + predictions.long(), source_lengths.cpu(), batch_first=True, enforce_sorted=False + ) + num_incorrect_frames = torch.sum((alignments_packed.data != predictions_packed.data)) - rf.get_run_ctx().mark_as_loss(name="MonoRNNT", loss=loss) + rf.get_run_ctx().mark_as_loss( + name=f"CE_{suffix}", loss=loss, scale=scale, custom_inv_norm_factor=alignment_loss_norm_factor + ) + rf.get_run_ctx().mark_as_loss( + name=f"FER_{suffix}", + loss=num_incorrect_frames, + custom_inv_norm_factor=alignment_loss_norm_factor, + as_error=True, + ) diff --git a/users/berger/recipe/returnn/onnx.py b/users/berger/recipe/returnn/onnx.py index 4e5794020..6e43b1726 100644 --- a/users/berger/recipe/returnn/onnx.py +++ b/users/berger/recipe/returnn/onnx.py @@ -1,6 +1,9 @@ import shutil import subprocess as sp import sys +from typing import Optional + +from optuna import Trial from i6_core import util from i6_core.returnn.config import ReturnnConfig @@ -8,6 +11,8 @@ from i6_experiments.users.berger.recipe.returnn.optuna_config import OptunaReturnnConfig from sisyphus import Job, Task, tk +from returnn.config import Config + class ExportPyTorchModelToOnnxJob(Job): """ @@ -34,6 +39,7 @@ def tasks(self): def run(self): sys.path.insert(0, self.returnn_root.get()) import torch + from returnn.config import Config config = Config() @@ -135,6 +141,7 @@ def tasks(self): def run(self): sys.path.insert(0, self.returnn_root.get()) import torch + from returnn.config import Config config = Config() @@ -160,3 +167,66 @@ def run(self): export_func = config.typed_value("export") assert export_func export_func(model=model, model_filename=self.out_onnx_model.get()) + + +class OptunaTorchOnnxExportJob(Job): + """ + Export an ONNX model using the appropriate RETURNN tool script. + + Currently only supports PyTorch via tools/torch_export_to_onnx.py + """ + + def __init__( + self, + *, + returnn_config: OptunaReturnnConfig, + checkpoint: PtCheckpoint, + trial: tk.Variable, + returnn_python_exe: tk.Path, + returnn_root: tk.Path, + device: str = "cpu", + ): + """ + + :param returnn_config: RETURNN config object + :param checkpoint: Path to the checkpoint for export + :param device: target device for graph creation + :param returnn_python_exe: file path to the executable for running returnn (python binary or .sh) + :param returnn_root: file path to the RETURNN repository root folder + """ + + self.returnn_config = returnn_config + self.trial = trial + self.checkpoint = checkpoint + self.device = device + self.returnn_python_exe = returnn_python_exe + self.returnn_root = returnn_root + + self.out_returnn_config = self.output_path("returnn.config") + self.out_onnx_model = self.output_path("model.onnx") + + def tasks(self): + yield Task("run", mini_task=True) + + def run(self): + returnn_config = self.returnn_config.generate_config(self.trial.get()) + returnn_config_path = self.out_returnn_config.get_path() + returnn_config.write(returnn_config_path) + + config = Config() + config.load_file(returnn_config_path) + + cmd = [ + self.returnn_python_exe.get_path(), + self.returnn_root.join_right("tools/torch_export_to_onnx.py").get_path(), + returnn_config_path, + str(self.checkpoint), + self.out_onnx_model.get_path(), + "--device", + self.device, + "--verbosity", + "5", + ] + + util.create_executable("compile.sh", cmd) # convenience file for manual execution + sp.run(cmd, check=True) diff --git a/users/berger/recipe/returnn/optuna_returnn_training.py b/users/berger/recipe/returnn/optuna_returnn_training.py index 11fb101ad..2334661fa 100644 --- a/users/berger/recipe/returnn/optuna_returnn_training.py +++ b/users/berger/recipe/returnn/optuna_returnn_training.py @@ -1,6 +1,5 @@ -__all__ = ["OptunaReturnnTrainingJob"] +__all__ = ["OptunaReturnnTrainingJob", "OptunaReportIntermediateScoreJob", "OptunaReportFinalScoreJob"] -import glob import inspect import logging import os @@ -28,7 +27,6 @@ def __init__( study_name: Optional[str] = None, study_storage: Optional[str] = None, sampler_seed: int = 42, - score_key: str = "dev_score", num_trials: int = 15, num_parallel: int = 3, *, @@ -41,6 +39,7 @@ def __init__( time_rqmt: int = 4, mem_rqmt: int = 4, cpu_rqmt: int = 2, + gpu_mem_rqmt: int = 11, horovod_num_processes: Optional[int] = None, multi_node_slots: Optional[int] = None, returnn_python_exe: Optional[tk.Path] = None, @@ -52,9 +51,8 @@ def __init__( self.optuna_returnn_config = optuna_returnn_config self.study_name = study_name or "optuna_study" - self.study_storage = study_storage or f"sqlite:///study_storage.db" + self.study_storage = study_storage or "sqlite:///study_storage.db" self.sampler_seed = sampler_seed - self.score_key = score_key self.num_trials = num_trials self.num_parallel = num_parallel @@ -93,11 +91,6 @@ def __init__( } for i in range(self.num_trials) } - self.out_checkpoints = { - k: Checkpoint(self.output_path(f"models/epoch.{k:03d}.index")) - for k in stored_epochs - if k in self.keep_epochs - } elif backend == Backend.PYTORCH: self.out_trial_checkpoints = { i: { @@ -107,31 +100,19 @@ def __init__( } for i in range(self.num_trials) } - self.out_checkpoints = { - k: PtCheckpoint(self.output_path(f"models/epoch.{k:03d}.pt")) - for k in stored_epochs - if k in self.keep_epochs - } else: raise NotImplementedError - self.out_trial_nums = {i: self.output_var(f"trial-{i:03d}/trial_num") for i in range(self.num_trials)} + self.out_task_id_to_trial_num = {i: self.output_var(f"task-{i:03d}-trial") for i in range(self.num_trials)} self.out_trials = {i: self.output_var(f"trial-{i:03d}/trial", pickle=True) for i in range(self.num_trials)} self.out_trial_params = {i: self.output_var(f"trial-{i:03d}/params") for i in range(self.num_trials)} - self.out_trial_scores = {i: self.output_var(f"trial-{i:03d}/score") for i in range(self.num_trials)} - self.out_best_trial_num = self.output_var("best_trial_num") - self.out_best_trial = self.output_var("best_trial", pickle=True) - self.out_best_params = self.output_var("best_params") - self.out_best_score = self.output_var("best_score") - - self.out_plot_se = self.output_path(f"score_and_error.png") - self.out_plot_lr = self.output_path(f"learning_rate.png") self.rqmt = { "gpu": 1 if device == "gpu" else 0, "cpu": cpu_rqmt, "mem": mem_rqmt, "time": time_rqmt, + "gpu_mem": gpu_mem_rqmt, } if self.multi_node_slots: @@ -203,33 +184,25 @@ def path_available(self, path: tk.Path) -> bool: return False - def get_returnn_config(self, trial: "optuna.Trial", task_id: int) -> ReturnnConfig: + def get_returnn_config(self, trial: "optuna.Trial") -> ReturnnConfig: returnn_config = self.optuna_returnn_config.generate_config(trial) - returnn_config.post_config["model"] = os.path.join(self.out_trial_model_dir[task_id].get_path(), "epoch") + trial_num = trial.number + returnn_config.post_config["model"] = os.path.join(self.out_trial_model_dir[trial_num].get_path(), "epoch") returnn_config.post_config.pop("learning_rate_file", None) - returnn_config.config["learning_rate_file"] = f"trial-{task_id:03d}/learning_rates" + returnn_config.config["learning_rate_file"] = f"trial-{trial_num:03d}/learning_rates" - returnn_config.post_config["log"] = f"./trial-{task_id:03d}/returnn.log" + returnn_config.post_config["log"] = f"./trial-{trial_num:03d}/returnn.log" ReturnnTrainingJob.check_blacklisted_parameters(returnn_config) returnn_config = ReturnnTrainingJob.create_returnn_config(returnn_config, **self.kwargs) return returnn_config - def prepare_trial_files(self, returnn_config: ReturnnConfig, task_id: int) -> None: - config_file = self.out_trial_returnn_config_files[task_id] + def prepare_trial_files(self, returnn_config: ReturnnConfig, trial_num: int) -> None: + config_file = self.out_trial_returnn_config_files[trial_num] returnn_config.write(config_file.get_path()) - os.mkdir(f"trial-{task_id:03d}") - util.create_executable(f"trial-{task_id:03d}/rnn.sh", self._get_run_cmd(config_file)) - - # Additional import packages that are created by returnn common - for f in glob.glob("../output/*"): - f_name = os.path.basename(f) - if f_name.startswith("trial-"): - continue - if f_name == "models": - continue - os.symlink(f"../{f_name}", f"../output/trial-{task_id:03d}/{f_name}") + os.mkdir(f"trial-{trial_num:03d}") + util.create_executable(f"trial-{trial_num:03d}/rnn.sh", self._get_run_cmd(config_file)) def prepare_env(self) -> None: if not self.multi_node_slots: @@ -246,31 +219,15 @@ def prepare_env(self) -> None: print("Cannot read:", exc) sys.stdout.flush() - def parse_lr_file(self, task_id: Optional[int] = None) -> dict: + def parse_lr_file(self, trial_num: int) -> dict: def EpochData(learningRate, error): return {"learning_rate": learningRate, "error": error} - if task_id is None: - filename = self.out_learning_rates - else: - filename = f"trial-{task_id:03d}/learning_rates" + filename = f"trial-{trial_num:03d}/learning_rates" with open(filename, "rt") as f: lr_text = f.read() return eval(lr_text) - def link_to_final_output(self, task_id: int) -> None: - os.link( - self.out_trial_returnn_config_files[task_id], - self.out_returnn_config_file, - ) - os.link(self.out_trial_learning_rates[task_id], self.out_learning_rates) - for k in self.out_checkpoints: - for suffix in ["index", "meta", "data-00000-of-00001", "pt"]: - orig_file = f"{self.out_trial_checkpoints[task_id][k]}.{suffix}" - if not os.path.exists(orig_file): - continue - os.link(orig_file, f"{self.out_checkpoints[k]}.{suffix}") - # ------------------ Tasks ------------------ def tasks(self) -> Generator[Task, None, None]: @@ -282,8 +239,6 @@ def tasks(self) -> Generator[Task, None, None]: parallel=self.num_parallel, args=range(self.num_trials), ) - yield Task("select_best_trial", mini_task=True) - yield Task("plot", resume="plot", mini_task=True) def create_study(self) -> None: import optuna @@ -320,17 +275,14 @@ def run(self, task_id: int) -> None: study = optuna.load_study( study_name=self.study_name, storage=storage, - pruner=optuna.pruners.PatientPruner( - wrapped_pruner=optuna.pruners.MedianPruner( - n_startup_trials=max(5, self.num_parallel), - ), - patience=10, - min_delta=0.1, + pruner=optuna.pruners.MedianPruner( + n_startup_trials=max(5, self.num_parallel), + n_warmup_steps=self.num_epochs // 2, ), ) - if self.out_trials[task_id].is_set(): - trial_num = int(self.out_trial_nums[task_id].get()) + if self.out_task_id_to_trial_num[task_id].is_set(): + trial_num = int(self.out_task_id_to_trial_num[task_id].get()) logging.info(f"Found existing trial with number {trial_num}") if self._check_trial_finished(study, trial_num): @@ -345,56 +297,40 @@ def run(self, task_id: int) -> None: else: trial = study.ask() trial_num = trial.number + self.out_task_id_to_trial_num[task_id].set(trial_num) logging.info(f"Start new trial with number {trial_num}") - returnn_config = self.get_returnn_config(trial, task_id) - self.prepare_trial_files(returnn_config, task_id) - self.out_trial_nums[task_id].set(trial_num) - self.out_trial_params[task_id].set(trial.params) - self.out_trials[task_id].set(optuna.trial.FixedTrial(trial.params, trial_num)) + returnn_config = self.get_returnn_config(trial) + self.prepare_trial_files(returnn_config, trial_num) + self.out_trial_params[trial_num].set(trial.params) + self.out_trials[trial_num].set(optuna.trial.FixedTrial(trial.params, trial_num)) - config_file = self.out_trial_returnn_config_files[task_id] + config_file = self.out_trial_returnn_config_files[trial_num] run_cmd = self._get_run_cmd(config_file) training_process = sp.Popen(run_cmd) - max_epoch = 0 - best_score = float("inf") trial_pruned = False while training_process.poll() is None: time.sleep(30) - try: - lr_data = self.parse_lr_file(task_id) - except (FileNotFoundError, SyntaxError): - continue - epochs = list(sorted(lr_data.keys())) - new_epochs = [e for e in epochs if e > max_epoch] - for e in new_epochs: - if self.score_key not in lr_data[e]["error"]: - continue - max_epoch = e - score = lr_data[e]["error"][self.score_key] - if score < best_score: - best_score = score - - trial.report(score, e) if trial.should_prune(): trial_pruned = True training_process.terminate() - study.tell(trial_num, state=optuna.trial.TrialState.PRUNED) + study.tell(trial, state=optuna.trial.TrialState.PRUNED) break if trial_pruned: logging.info("Pruned trial run") - self.out_trial_scores[task_id].set(best_score) os.link( - f"trial-{task_id:03d}/learning_rates", - self.out_trial_learning_rates[task_id].get_path(), + f"trial-{trial_num:03d}/learning_rates", + self.out_trial_learning_rates[trial_num].get_path(), ) + lr_data = self.parse_lr_file(trial_num) + max_epoch = max([ep for ep, ep_data in lr_data.items() if ep_data["error"] != {}]) + if not trial_pruned and max_epoch == self.num_epochs: logging.info("Finished trial run normally") - study.tell(trial_num, best_score, state=optuna.trial.TrialState.COMPLETE) os.link( f"trial-{task_id:03d}/learning_rates", self.out_trial_learning_rates[task_id].get_path(), @@ -404,95 +340,125 @@ def run(self, task_id: int) -> None: logging.info("Training had an error") raise sp.CalledProcessError(-1, cmd=run_cmd) - def select_best_trial(self) -> None: + @classmethod + def hash(cls, kwargs): + d = { + "returnn_config_generator": inspect.getsource(kwargs["optuna_returnn_config"].config_generator), + "returnn_config_generator_kwargs": list(sorted(kwargs["optuna_returnn_config"].config_kwargs)), + "sampler_seed": kwargs["sampler_seed"], + "num_trials": kwargs["num_trials"], + "num_parallel": kwargs["num_parallel"], + "returnn_python_exe": kwargs["returnn_python_exe"], + "returnn_root": kwargs["returnn_root"], + } + + if kwargs["study_name"] is not None: + d["study_name"] = kwargs["study_name"] + if kwargs["study_storage"] is not None: + d["study_storage"] = kwargs["study_storage"] + if kwargs["horovod_num_processes"] is not None: + d["horovod_num_processes"] = kwargs["horovod_num_processes"] + if kwargs["multi_node_slots"] is not None: + d["multi_node_slots"] = kwargs["multi_node_slots"] + + return super().hash(d) + + +class OptunaReportIntermediateScoreJob(Job): + def __init__( + self, + trial_num: int, + step: int, + score: tk.Variable, + study_name: Optional[str] = None, + study_storage: Optional[str] = None, + ) -> None: + self.study_name = study_name or "optuna_study" + self.study_storage = study_storage or "sqlite:///study_storage.db" + self.trial_num = trial_num + self.step = step + self.score = score + + self.out_reported_score = self.output_var("reported_score") + + def tasks(self) -> Generator[Task, None, None]: + yield Task("run", mini_task=True) + + def run(self) -> None: import optuna - study = optuna.load_study(study_name=self.study_name, storage=self.study_storage) - self.out_best_params.set(study.best_params) - self.out_best_trial.set(study.best_trial) - self.out_best_score.set(study.best_value) - for task_id, trial_num in self.out_trial_nums.items(): - if trial_num.get() == study.best_trial.number: - self.out_best_trial_num.set(task_id) - self.link_to_final_output(task_id=task_id) - break + storage = optuna.storages.get_storage(self.study_storage) + study = optuna.load_study( + study_name=self.study_name, + storage=storage, + ) - def plot(self): - data = self.parse_lr_file() + study_id = storage.get_study_id_from_name(self.study_name) + trial_id = storage.get_trial_id_from_study_id_trial_number(study_id, self.trial_num) + trial = optuna.Trial(study, trial_id) - epochs = list(sorted(data.keys())) - train_score_keys = [k for k in data[epochs[0]]["error"] if k.startswith("train_score")] - dev_score_keys = [k for k in data[epochs[0]]["error"] if k.startswith("dev_score")] - dev_error_keys = [k for k in data[epochs[0]]["error"] if k.startswith("dev_error")] + trial.report(value=self.score.get(), step=self.step) + self.out_reported_score.set(self.score.get()) - train_scores = [ - [(epoch, data[epoch]["error"][tsk]) for epoch in epochs if tsk in data[epoch]["error"]] - for tsk in train_score_keys - ] - dev_scores = [ - [(epoch, data[epoch]["error"][dsk]) for epoch in epochs if dsk in data[epoch]["error"]] - for dsk in dev_score_keys - ] - dev_errors = [ - [(epoch, data[epoch]["error"][dek]) for epoch in epochs if dek in data[epoch]["error"]] - for dek in dev_error_keys - ] - learing_rates = [data[epoch]["learning_rate"] for epoch in epochs] + @classmethod + def hash(cls, kwargs): + d = { + "trial_num": kwargs["trial_num"], + "step": kwargs["step"], + "score": kwargs["score"], + } - colors = ["#2A4D6E", "#AA3C39", "#93A537"] # blue red yellowgreen + if kwargs["study_name"] is not None: + d["study_name"] = kwargs["study_name"] + if kwargs["study_storage"] is not None: + d["study_storage"] = kwargs["study_storage"] - import matplotlib + return super().hash(d) + + +class OptunaReportFinalScoreJob(Job): + def __init__( + self, + trial_num: int, + scores: List[tk.Variable], + study_name: Optional[str] = None, + study_storage: Optional[str] = None, + ) -> None: + self.study_name = study_name or "optuna_study" + self.study_storage = study_storage or "sqlite:///study_storage.db" + self.trial_num = trial_num + self.scores = scores - matplotlib.use("Agg") - import matplotlib.pyplot as plt + self.out_reported_score = self.output_var("reported_score") - fig, ax1 = plt.subplots() - for ts in train_scores: - ax1.plot([d[0] for d in ts], [d[1] for d in ts], "o-", color=colors[0]) - for ds in dev_scores: - ax1.plot([d[0] for d in ds], [d[1] for d in ds], "o-", color=colors[1]) - ax1.set_xlabel("epoch") - ax1.set_ylabel("scores", color=colors[0]) - for tl in ax1.get_yticklabels(): - tl.set_color(colors[0]) + def tasks(self) -> Generator[Task, None, None]: + yield Task("run", mini_task=True) - if len(dev_errors) > 0 and any(len(de) > 0 for de in dev_errors): - ax2 = ax1.twinx() - ax2.set_ylabel("dev error", color=colors[2]) - for de in dev_errors: - ax2.plot([d[0] for d in de], [d[1] for d in de], "o-", color=colors[2]) - for tl in ax2.get_yticklabels(): - tl.set_color(colors[2]) + def run(self) -> None: + import optuna - fig.savefig(fname=self.out_plot_se.get_path()) + storage = optuna.storages.get_storage(self.study_storage) + study = optuna.load_study( + study_name=self.study_name, + storage=storage, + ) - fig, ax1 = plt.subplots() - ax1.semilogy(epochs, learing_rates, "ro-") - ax1.set_xlabel("epoch") - ax1.set_ylabel("learning_rate") + best_score = min([score.get() for score in self.scores]) - fig.savefig(fname=self.out_plot_lr.get_path()) + study.tell( + trial=self.trial_num, values=best_score, state=optuna.trial.TrialState.COMPLETE, skip_if_finished=True + ) @classmethod def hash(cls, kwargs): d = { - "returnn_config_generator": inspect.getsource(kwargs["optuna_returnn_config"].config_generator), - "returnn_config_generator_kwargs": list(sorted(kwargs["optuna_returnn_config"].config_kwargs)), - "sampler_seed": kwargs["sampler_seed"], - "score_key": kwargs["score_key"], - "num_trials": kwargs["num_trials"], - "num_parallel": kwargs["num_parallel"], - "returnn_python_exe": kwargs["returnn_python_exe"], - "returnn_root": kwargs["returnn_root"], + "trial_num": kwargs["trial_num"], + "scores": kwargs["scores"], } if kwargs["study_name"] is not None: d["study_name"] = kwargs["study_name"] if kwargs["study_storage"] is not None: d["study_storage"] = kwargs["study_storage"] - if kwargs["horovod_num_processes"] is not None: - d["horovod_num_processes"] = kwargs["horovod_num_processes"] - if kwargs["multi_node_slots"] is not None: - d["multi_node_slots"] = kwargs["multi_node_slots"] return super().hash(d) diff --git a/users/berger/systems/functors/alignment/optuna_legacy_alignment.py b/users/berger/systems/functors/alignment/optuna_legacy_alignment.py index 0dc2b6e53..af0b76a78 100644 --- a/users/berger/systems/functors/alignment/optuna_legacy_alignment.py +++ b/users/berger/systems/functors/alignment/optuna_legacy_alignment.py @@ -25,7 +25,7 @@ def __call__( num_inputs: int, num_classes: int, epoch: types.EpochType, - trial_num: types.TrialType = "best", + trial_num: int, prior_scale: float = 0, prior_args: Dict = {}, feature_type: dataclasses.FeatureType = dataclasses.FeatureType.SAMPLES, @@ -78,10 +78,7 @@ def __call__( ) exp_full = f"align_e-{self._get_epoch_string(epoch)}_prior-{prior_scale:02.2f}" - if trial_num is None: - path = f"nn_align/{align_corpus.name}/{train_job.name}/{exp_full}" - else: - path = f"nn_align/{align_corpus.name}/{train_job.name}/trial-{trial_num:03d}/{exp_full}" + path = f"nn_align/{align_corpus.name}/{train_job.name}/trial-{trial_num:03d}/{exp_full}" align.set_vis_name(f"Alignment {path}") align.add_alias(path) diff --git a/users/berger/systems/functors/alignment/optuna_seq2seq_alignment.py b/users/berger/systems/functors/alignment/optuna_seq2seq_alignment.py index c9ad662e6..8f32f7f54 100644 --- a/users/berger/systems/functors/alignment/optuna_seq2seq_alignment.py +++ b/users/berger/systems/functors/alignment/optuna_seq2seq_alignment.py @@ -26,7 +26,7 @@ def __call__( align_config: returnn.OptunaReturnnConfig, align_corpus: dataclasses.NamedCorpusInfo, epoch: types.EpochType, - trial_num: types.TrialType = "best", + trial_num: int, prior_scale: float = 0, prior_args: Dict = {}, label_unit: str = "phoneme", @@ -88,11 +88,7 @@ def __call__( ) exp_full = f"align_e-{self._get_epoch_string(epoch)}_prior-{prior_scale:02.2f}" - - if trial_num == "best": - path = f"nn_align/{align_corpus.name}/{train_job.name}/trial-{trial_num}/{exp_full}" - else: - path = f"nn_align/{align_corpus.name}/{train_job.name}/trial-{trial_num:03d}/{exp_full}" + path = f"nn_align/{align_corpus.name}/{train_job.name}/trial-{trial_num:03d}/{exp_full}" align.set_vis_name(f"Alignment {path}") align.add_alias(path) diff --git a/users/berger/systems/functors/alignment/seq2seq_alignment.py b/users/berger/systems/functors/alignment/seq2seq_alignment.py index 389dccfe6..8b99aaf35 100644 --- a/users/berger/systems/functors/alignment/seq2seq_alignment.py +++ b/users/berger/systems/functors/alignment/seq2seq_alignment.py @@ -6,6 +6,7 @@ from i6_experiments.users.berger.recipe import mm from i6_core.lexicon.allophones import DumpStateTyingJob, StoreAllophonesJob from sisyphus import tk +from i6_experiments.users.berger.recipe.returnn.training import Backend, get_backend from ... import dataclasses from ... import types @@ -32,6 +33,7 @@ def __call__( label_scorer_args: Dict = {}, feature_type: dataclasses.FeatureType = dataclasses.FeatureType.SAMPLES, flow_args: Dict = {}, + model_flow_args: Dict = {}, silence_phone: str = "", register_output: bool = False, **kwargs, @@ -46,15 +48,9 @@ def __call__( align_corpus.corpus_info, feature_type=feature_type, **flow_args ) - tf_graph = self._make_tf_graph( - train_job=train_job.job, - returnn_config=align_config, - epoch=epoch, - label_scorer_type=label_scorer_type, - ) + backend = get_backend(align_config) checkpoint = self._get_checkpoint(train_job=train_job.job, epoch=epoch) - assert isinstance(checkpoint, returnn.Checkpoint) if label_scorer_args.get("use_prior", False) and prior_scale: prior_file = self._get_prior_file(prior_config=prior_config, checkpoint=checkpoint, **prior_args) @@ -65,12 +61,37 @@ def __call__( label_scorer = custom_rasr.LabelScorer(label_scorer_type, **mod_label_scorer_args) - feature_flow = self._get_tf_feature_flow_for_label_scorer( - label_scorer=label_scorer, - base_feature_flow=base_feature_flow, - tf_graph=tf_graph, - checkpoint=checkpoint, - ) + if backend == Backend.TENSORFLOW: + tf_graph = self._make_tf_graph( + train_job=train_job.job, + returnn_config=align_config, + epoch=epoch, + label_scorer_type=label_scorer_type, + ) + assert isinstance(checkpoint, returnn.Checkpoint) + + feature_flow = self._get_tf_feature_flow_for_label_scorer( + label_scorer=label_scorer, + base_feature_flow=base_feature_flow, + tf_graph=tf_graph, + checkpoint=checkpoint, + **model_flow_args, + ) + elif backend == Backend.PYTORCH: + assert isinstance(checkpoint, returnn.PtCheckpoint) + onnx_model = self._make_onnx_model( + returnn_config=align_config, + checkpoint=checkpoint, + ) + feature_flow = self._get_onnx_feature_flow_for_label_scorer( + label_scorer=label_scorer, + base_feature_flow=base_feature_flow, + onnx_model=onnx_model, + feature_type=feature_type, + **model_flow_args, + ) + else: + raise NotImplementedError align = mm.Seq2SeqAlignmentJob( crp=crp, diff --git a/users/berger/systems/functors/optuna_rasr_base.py b/users/berger/systems/functors/optuna_rasr_base.py index a84edf950..c80120031 100644 --- a/users/berger/systems/functors/optuna_rasr_base.py +++ b/users/berger/systems/functors/optuna_rasr_base.py @@ -17,15 +17,12 @@ def _get_epoch_value( self, train_job: returnn.OptunaReturnnTrainingJob, epoch: types.EpochType, - trial_num: types.TrialType, + trial_num: int, ) -> Union[int, tk.Variable]: if epoch != "best": return epoch - if trial_num == "best": - lr = train_job.out_learning_rates - else: - lr = train_job.out_trial_learning_rates[trial_num] + lr = train_job.out_trial_learning_rates[trial_num] return returnn.GetBestEpochJob(lr).out_epoch def _make_tf_graph( @@ -33,13 +30,10 @@ def _make_tf_graph( train_job: returnn.OptunaReturnnTrainingJob, returnn_config: returnn.OptunaReturnnConfig, epoch: types.EpochType, + trial_num: int, label_scorer_type: str = "precomputed-log-posterior", - trial_num: types.TrialType = "best", ) -> tk.Path: - if trial_num == "best": - trial = train_job.out_best_trial - else: - trial = train_job.out_trials[trial_num] + trial = train_job.out_trials[trial_num] rec_step_by_step = "output" if self._is_autoregressive_decoding(label_scorer_type) else None graph_compile_job = returnn.OptunaCompileTFGraphJob( returnn_config, @@ -57,17 +51,15 @@ def _make_onnx_model( train_job: returnn.OptunaReturnnTrainingJob, returnn_config: returnn.OptunaReturnnConfig, checkpoint: returnn.PtCheckpoint, - trial_num: types.TrialType = "best", + trial_num: int, ) -> tk.Path: - if trial_num == "best": - trial = train_job.out_best_trial - else: - trial = train_job.out_trials[trial_num] + trial = train_job.out_trials[trial_num] - onnx_export_job = returnn.OptunaExportPyTorchModelToOnnxJob( - pytorch_checkpoint=checkpoint, + onnx_export_job = returnn.OptunaTorchOnnxExportJob( returnn_config=returnn_config, + checkpoint=checkpoint, trial=trial, + returnn_python_exe=self.returnn_python_exe, returnn_root=self.returnn_root, ) return onnx_export_job.out_onnx_model @@ -77,18 +69,9 @@ def _get_checkpoint( self, train_job: returnn.OptunaReturnnTrainingJob, epoch: types.EpochType, - trial_num: types.TrialType = "best", + trial_num: int, backend: Backend = Backend.TENSORFLOW, ) -> Checkpoint: - if trial_num == "best": - if epoch == "best": - return returnn.GetBestCheckpointJob( - model_dir=train_job.out_model_dir, - learning_rates=train_job.out_learning_rates, - backend=backend, - ).out_checkpoint - return train_job.out_checkpoints[epoch] - if epoch == "best": return returnn.GetBestCheckpointJob( model_dir=train_job.out_trial_model_dir[trial_num], @@ -102,14 +85,11 @@ def _get_prior_file( train_job: returnn.OptunaReturnnTrainingJob, prior_config: returnn.OptunaReturnnConfig, checkpoint: Checkpoint, - trial_num: types.TrialType = "best", + trial_num: int, backend: Backend = Backend.TENSORFLOW, **kwargs, ) -> tk.Path: - if trial_num == "best": - trial = train_job.out_best_trial - else: - trial = train_job.out_trials[trial_num] + trial = train_job.out_trials[trial_num] if backend == backend.TENSORFLOW: prior_job = returnn.OptunaReturnnComputePriorJob( model_checkpoint=checkpoint, @@ -134,14 +114,3 @@ def _get_prior_file( return forward_job.out_prior_xml_file else: raise NotImplementedError - - @lru_cache_with_signature - def _get_trial_value( - self, - train_job: returnn.OptunaReturnnTrainingJob, - trial_num: types.TrialType = "best", - ) -> Union[int, tk.Variable]: - if trial_num != "best": - return trial_num - - return train_job.out_best_trial_num diff --git a/users/berger/systems/functors/recognition/optuna_legacy_search.py b/users/berger/systems/functors/recognition/optuna_legacy_search.py index 9d3e9343b..ae367cc10 100644 --- a/users/berger/systems/functors/recognition/optuna_legacy_search.py +++ b/users/berger/systems/functors/recognition/optuna_legacy_search.py @@ -1,13 +1,13 @@ import copy import itertools -from typing import Dict, List, Optional +from typing import Dict, List from i6_core import mm, rasr, recognition -from i6_experiments.users.berger.recipe import returnn from sisyphus import tk -from ... import dataclasses -from ... import types +from i6_experiments.users.berger.recipe import returnn + +from ... import dataclasses, types from ..base import RecognitionFunctor from ..optuna_rasr_base import OptunaRasrFunctor @@ -25,7 +25,7 @@ def __call__( num_classes: int, epochs: List[types.EpochType], lm_scales: List[float], - trial_nums: List[Optional[int]] = [None], + trial_nums: List[int], prior_scales: List[float] = [0], pronunciation_scales: List[float] = [0], prior_args: Dict = {}, @@ -117,8 +117,8 @@ def __call__( dataclasses.SummaryKey.TRAIN_NAME.value: train_job.name, dataclasses.SummaryKey.RECOG_NAME.value: recog_config.name, dataclasses.SummaryKey.CORPUS.value: recog_corpus.name, - dataclasses.SummaryKey.TRIAL.value: self._get_trial_value(train_job.job, trial_num), - dataclasses.SummaryKey.EPOCH.value: self._get_epoch_value(train_job.job, epoch), + dataclasses.SummaryKey.TRIAL.value: trial_num, + dataclasses.SummaryKey.EPOCH.value: self._get_epoch_value(train_job.job, epoch, trial_num), dataclasses.SummaryKey.PRON.value: pronunciation_scale, dataclasses.SummaryKey.PRIOR.value: prior_scale, dataclasses.SummaryKey.LM.value: lm_scale, diff --git a/users/berger/systems/functors/recognition/optuna_seq2seq_search.py b/users/berger/systems/functors/recognition/optuna_seq2seq_search.py index c7ba7fc90..90d3ad5b6 100644 --- a/users/berger/systems/functors/recognition/optuna_seq2seq_search.py +++ b/users/berger/systems/functors/recognition/optuna_seq2seq_search.py @@ -1,11 +1,12 @@ import copy import itertools -from typing import Dict, List +from typing import Dict, List, Optional, Union from i6_experiments.users.berger.recipe import rasr as custom_rasr from i6_experiments.users.berger.recipe import recognition, returnn from i6_experiments.users.berger.recipe.returnn.training import Backend from sisyphus import tk +from i6_experiments.users.berger.systems.functors.rasr_base import RecognitionScoringType from ..base import RecognitionFunctor from ..optuna_rasr_base import OptunaRasrFunctor from ..seq2seq_base import Seq2SeqFunctor @@ -22,12 +23,14 @@ def __call__( self, train_job: dataclasses.NamedTrainJob[returnn.OptunaReturnnTrainingJob], prior_config: returnn.OptunaReturnnConfig, - recog_config: dataclasses.NamedConfig[returnn.OptunaReturnnConfig], + recog_config: dataclasses.NamedConfig[ + Union[returnn.OptunaReturnnConfig, dataclasses.EncDecConfig[returnn.OptunaReturnnConfig]] + ], recog_corpus: dataclasses.NamedCorpusInfo, lookahead_options: Dict, epochs: List[types.EpochType], + trial_nums: List[int], lm_scales: List[float] = [0], - trial_nums: List[types.TrialType] = ["best"], prior_scales: List[float] = [0], prior_args: Dict = {}, lattice_to_ctm_kwargs: Dict = {}, @@ -37,7 +40,12 @@ def __call__( label_scorer_args: Dict = {}, feature_type: dataclasses.FeatureType = dataclasses.FeatureType.SAMPLES, flow_args: Dict = {}, + model_flow_args: Dict = {}, backend: Backend = Backend.TENSORFLOW, + recognition_scoring_type=RecognitionScoringType.Lattice, + rqmt_update: Optional[dict] = None, + search_stats: bool = False, + seq2seq_v2: bool = False, **kwargs, ) -> List[Dict]: assert recog_corpus is not None @@ -60,6 +68,8 @@ def __call__( recog_results = [] + out_scores = {trial_num: [] for trial_num in trial_nums} + for lm_scale, prior_scale, epoch, trial_num in itertools.product(lm_scales, prior_scales, epochs, trial_nums): checkpoint = self._get_checkpoint(train_job.job, epoch, trial_num=trial_num, backend=backend) @@ -82,6 +92,7 @@ def __call__( label_scorer = custom_rasr.LabelScorer(label_scorer_type, **mod_label_scorer_args) if backend == Backend.TENSORFLOW: + assert isinstance(recog_config.config, returnn.OptunaReturnnConfig) tf_graph = self._make_tf_graph( train_job=train_job.job, returnn_config=recog_config.config, @@ -96,45 +107,84 @@ def __call__( base_feature_flow=base_feature_flow, tf_graph=tf_graph, checkpoint=checkpoint, + feature_type=feature_type, + **model_flow_args, ) elif backend == Backend.PYTORCH: assert isinstance(checkpoint, returnn.PtCheckpoint) - onnx_model = self._make_onnx_model( - train_job=train_job.job, - returnn_config=recog_config.config, - checkpoint=checkpoint, - trial_num=trial_num, - ) - feature_flow = self._get_onnx_feature_flow_for_label_scorer( + if isinstance(recog_config.config, returnn.OptunaReturnnConfig): + onnx_model = self._make_onnx_model( + train_job=train_job.job, + returnn_config=recog_config.config, + checkpoint=checkpoint, + trial_num=trial_num, + ) + feature_flow = self._get_onnx_feature_flow_for_label_scorer( + label_scorer=label_scorer, + base_feature_flow=base_feature_flow, + onnx_model=onnx_model, + feature_type=feature_type, + **model_flow_args, + ) + else: + enc_model = self._make_onnx_model( + train_job=train_job.job, + returnn_config=recog_config.config.encoder_config, + checkpoint=checkpoint, + trial_num=trial_num, + ) + dec_model = self._make_onnx_model( + train_job=train_job.job, + returnn_config=recog_config.config.decoder_config, + checkpoint=checkpoint, + trial_num=trial_num, + ) + feature_flow = self._get_onnx_feature_flow_for_label_scorer( + label_scorer=label_scorer, + base_feature_flow=base_feature_flow, + enc_onnx_model=enc_model, + dec_onnx_model=dec_model, + feature_type=feature_type, + **model_flow_args, + ) + else: + raise NotImplementedError + + if seq2seq_v2: + rec = recognition.GenericSeq2SeqSearchJobV2( + crp=crp, + feature_flow=feature_flow, label_scorer=label_scorer, - base_feature_flow=base_feature_flow, - onnx_model=onnx_model, + label_tree=label_tree, + lookahead_options=lookahead_options, + **kwargs, ) else: - raise NotImplementedError + rec = recognition.GenericSeq2SeqSearchJob( + crp=crp, + feature_flow=feature_flow, + label_scorer=label_scorer, + label_tree=label_tree, + lookahead_options=lookahead_options, + **kwargs, + ) - rec = recognition.GenericSeq2SeqSearchJob( - crp=crp, - feature_flow=feature_flow, - label_scorer=label_scorer, - label_tree=label_tree, - lookahead_options=lookahead_options, - **kwargs, - ) + if rqmt_update is not None: + rec.rqmt.update(rqmt_update) - exp_full = ( - f"{recog_config.name}_e-{self._get_epoch_string(epoch)}_prior-{prior_scale:02.2f}_lm-{lm_scale:02.2f}" - ) + exp_full = f"{recog_config.name}_e-{self._get_epoch_string(epoch)}" + if prior_scale != 0: + exp_full += f"_prior-{prior_scale:02.2f}" + if lm_scale != 0: + exp_full += f"_lm-{lm_scale:02.2f}" - if trial_num == "best": - path = f"nn_recog/{recog_corpus.name}/{train_job.name}/trial-{trial_num}/{exp_full}" - else: - path = f"nn_recog/{recog_corpus.name}/{train_job.name}/trial-{trial_num:03d}/{exp_full}" + path = f"nn_recog/{recog_corpus.name}/{train_job.name}/trial-{trial_num:03d}/{exp_full}" rec.set_vis_name(f"Recog {path}") rec.add_alias(path) - scorer_job = self._lattice_scoring( + scorer_job = self._score_recognition_output( + recognition_scoring_type=recognition_scoring_type, crp=crp, lattice_bundle=rec.out_lattice_bundle, scorer=recog_corpus.corpus_info.scorer, @@ -145,15 +195,36 @@ def __call__( scorer_job.out_report_dir, ) + out_scores[trial_num].append( + returnn.OptunaReportIntermediateScoreJob( + trial_num=trial_num, + step=epoch, + score=scorer_job.out_wer, + study_name=train_job.job.study_name, + study_storage=train_job.job.study_storage, + ).out_reported_score + ) + + rtf = None + if search_stats: + stats_job = recognition.ExtractSeq2SeqSearchStatisticsJob( + search_logs=list(rec.out_log_file.values()), + corpus_duration_hours=recog_corpus.corpus_info.data.corpus_object.duration, + ) + rtf = stats_job.overall_rtf + + tk.register_output(f"{path}.rtf", rtf) + recog_results.append( { dataclasses.SummaryKey.TRAIN_NAME.value: train_job.name, dataclasses.SummaryKey.RECOG_NAME.value: recog_config.name, dataclasses.SummaryKey.CORPUS.value: recog_corpus.name, - dataclasses.SummaryKey.TRIAL.value: self._get_trial_value(train_job.job, trial_num), + dataclasses.SummaryKey.TRIAL.value: trial_num, dataclasses.SummaryKey.EPOCH.value: self._get_epoch_value(train_job.job, epoch, trial_num), dataclasses.SummaryKey.PRIOR.value: prior_scale, dataclasses.SummaryKey.LM.value: lm_scale, + dataclasses.SummaryKey.RTF.value: rtf, dataclasses.SummaryKey.WER.value: scorer_job.out_wer, dataclasses.SummaryKey.SUB.value: scorer_job.out_percent_substitution, dataclasses.SummaryKey.DEL.value: scorer_job.out_percent_deletions, @@ -162,4 +233,18 @@ def __call__( } ) + path = f"nn_recog/{recog_corpus.name}/{train_job.name}/trial-{trial_num:03d}/{exp_full}" + + for trial_num in trial_nums: + final_score = returnn.OptunaReportFinalScoreJob( + trial_num=trial_num, + scores=out_scores[trial_num], + study_name=train_job.job.study_name, + study_storage=train_job.job.study_storage, + ).out_reported_score + tk.register_output( + f"optuna/{recog_corpus.name}/{train_job.name}/trial-{trial_num:03d}/best_wer", + value=final_score, + ) + return recog_results diff --git a/users/berger/systems/functors/recognition/seq2seq_search.py b/users/berger/systems/functors/recognition/seq2seq_search.py index 0667834c4..5a806b0d0 100644 --- a/users/berger/systems/functors/recognition/seq2seq_search.py +++ b/users/berger/systems/functors/recognition/seq2seq_search.py @@ -158,9 +158,11 @@ def __call__( if rqmt_update is not None: rec.rqmt.update(rqmt_update) - exp_full = ( - f"{recog_config.name}_e-{self._get_epoch_string(epoch)}_prior-{prior_scale:02.2f}_lm-{lm_scale:02.2f}" - ) + exp_full = f"{recog_config.name}_e-{self._get_epoch_string(epoch)}" + if prior_scale != 0: + exp_full += f"_prior-{prior_scale:02.2f}" + if lm_scale != 0: + exp_full += f"_lm-{lm_scale:02.2f}" path = f"nn_recog/{recog_corpus.name}/{train_job.name}/{exp_full}" diff --git a/users/berger/systems/functors/seq2seq_base.py b/users/berger/systems/functors/seq2seq_base.py index 46f95b3a2..dfa521efa 100644 --- a/users/berger/systems/functors/seq2seq_base.py +++ b/users/berger/systems/functors/seq2seq_base.py @@ -1,13 +1,14 @@ -from abc import ABC import copy +from abc import ABC from i6_core import lexicon, rasr, returnn +from sisyphus import tk + from i6_experiments.users.berger.recipe import rasr as custom_rasr from i6_experiments.users.berger.util import lru_cache_with_signature -from sisyphus import tk -from .rasr_base import RasrFunctor from ..dataclasses import FeatureType +from .rasr_base import RasrFunctor class Seq2SeqFunctor(RasrFunctor, ABC): @@ -38,7 +39,7 @@ def _make_onnx_enc_dec_config_for_label_scorer( enc_features_size: str = "sources:size1", enc_output_name: str = "source_encodings", dec_features_name: str = "source_encodings", - dec_history_name: str = "targets", + dec_history_name: str = "history", dec_output_name: str = "log_probs", ) -> None: encoder_io_map = rasr.RasrConfig() diff --git a/users/berger/systems/functors/training/optuna_returnn_training.py b/users/berger/systems/functors/training/optuna_returnn_training.py index 820ee813b..b8aeca6d7 100644 --- a/users/berger/systems/functors/training/optuna_returnn_training.py +++ b/users/berger/systems/functors/training/optuna_returnn_training.py @@ -28,6 +28,7 @@ def __call__( ) train_job.add_alias(f"train_nn/{train_config.name}") - tk.register_output(f"train_nn/{train_config.name}/learning_rate.png", train_job.out_plot_lr) + for trial_num, learning_rate_file in train_job.out_trial_learning_rates.items(): + tk.register_output(f"train_nn/{train_config.name}/trial-{trial_num:03d}/learning_rates", learning_rate_file) return train_job diff --git a/users/berger/systems/types.py b/users/berger/systems/types.py index 10601be47..e4ca32f4d 100644 --- a/users/berger/systems/types.py +++ b/users/berger/systems/types.py @@ -6,7 +6,6 @@ ScoreJobType = Union[Type[recognition.ScliteJob], Type[recognition.Hub5ScoreJob], Type[MeetEvalJob]] ScoreJob = Union[recognition.ScliteJob, recognition.Hub5ScoreJob] EpochType = Union[int, Literal["best"]] -TrialType = Union[int, Literal["best"]] CheckpointType = Union[returnn.Checkpoint, returnn.PtCheckpoint] ConfigType = TypeVar("ConfigType") From 747e8a45acf746312e97d36272b4a2c3a17ac2f3 Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Tue, 11 Jun 2024 09:19:12 +0200 Subject: [PATCH 154/227] more --- users/zeyer/experiments/exp2024_04_23_baselines/ctc.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py index e4ef939e8..2abdb5b21 100644 --- a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py +++ b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py @@ -78,7 +78,7 @@ def py(): (5, 1e-2), # (1, 1e-4), # 9.24 (1, 1e-3), - (1, 1e-2), + (1, 1e-2), # 8.16 ]: train_exp( f"v6-bhv20-11gb-f32-bs15k-accgrad{acc}" @@ -174,7 +174,7 @@ def py(): }, ) - train_exp( + train_exp( # 7.36 (vs without EOS 6.99), so EOS made it worse "v6-bhv20-11gb-f32-bs15k-accgrad1-mgpu4-pavg100-wd1e_2-lrlin1e_5_295k-speedpertV2-spm10k-eos-spmSample07", config_11gb_v6_f32_accgrad1_mgpu4_pavg100_wd1e_4, config_updates={ @@ -199,6 +199,7 @@ def py(): # featBN: {"dev-clean": 3.63, "dev-other": 6.96, "test-clean": 3.82, "test-other": 7.15} "featBN": {"feature_batch_norm": True}, # batch norm "featNorm": {"feature_norm": True}, # normalize (on sequence level) + # featGN: {"dev-clean": 3.65, "dev-other": 7.04, "test-clean": 3.82, "test-other": 7.27} "featGN": {"feature_stats": {"mean": feature_stats.mean, "std_dev": feature_stats.std_dev}}, # global norm }.items(): train_exp( From 411b58a8397bc48cee8b6fb0a4c3f95796b4bb23 Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Tue, 11 Jun 2024 21:12:05 +0200 Subject: [PATCH 155/227] more --- users/zeyer/experiments/exp2024_04_23_baselines/ctc.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py index 2abdb5b21..f0882934c 100644 --- a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py +++ b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py @@ -77,7 +77,7 @@ def py(): (5, 1e-3), (5, 1e-2), # (1, 1e-4), # 9.24 - (1, 1e-3), + (1, 1e-3), # 9.19 (1, 1e-2), # 8.16 ]: train_exp( @@ -198,6 +198,7 @@ def py(): None: None, # {"dev-clean": 3.69, "dev-other": 6.99, "test-clean": 3.83, "test-other": 7.32} # featBN: {"dev-clean": 3.63, "dev-other": 6.96, "test-clean": 3.82, "test-other": 7.15} "featBN": {"feature_batch_norm": True}, # batch norm + # featNorm: {"dev-clean": 3.65, "dev-other": 6.97, "test-clean": 3.74, "test-other": 7.34} "featNorm": {"feature_norm": True}, # normalize (on sequence level) # featGN: {"dev-clean": 3.65, "dev-other": 7.04, "test-clean": 3.82, "test-other": 7.27} "featGN": {"feature_stats": {"mean": feature_stats.mean, "std_dev": feature_stats.std_dev}}, # global norm From 365c3b22771022844762ff3953046c4b63ce810e Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Wed, 12 Jun 2024 09:18:21 +0200 Subject: [PATCH 156/227] more --- users/zeyer/experiments/exp2024_04_23_baselines/ctc.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py index f0882934c..1a50460e1 100644 --- a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py +++ b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py @@ -74,8 +74,8 @@ def py(): for acc, wd in [ # (5, 1e-5), # 9.90 - (5, 1e-3), - (5, 1e-2), + (5, 1e-3), # 9.53 + (5, 1e-2), # 9.23 # (1, 1e-4), # 9.24 (1, 1e-3), # 9.19 (1, 1e-2), # 8.16 From c55fefaa53dcdf9b7c4806733dc839d848671d26 Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Thu, 13 Jun 2024 00:36:01 +0200 Subject: [PATCH 157/227] more --- .../exp2024_04_23_baselines/ctc.py | 20 +++++++++++++------ 1 file changed, 14 insertions(+), 6 deletions(-) diff --git a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py index 1a50460e1..2963c7ec6 100644 --- a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py +++ b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py @@ -139,20 +139,28 @@ def py(): # Testing different vocabs together with sampling. for vocab, alpha in [ # See archive/returnn-spm10-sample.config for playing around with alpha and checking avg seq len. - ("spm10k", 0.3), # 7.88 - ("spm10k", 0.5), # 7.13 + # The lower the alpha, the longer the seq len, i.e. the more aggressive the sampling. + # spm10k no sampling: 8.12 + ("spm10k", 0.8), # 7.08 ("spm10k", 0.7), # 6.99 - ("spm10k", 0.8), + ("spm10k", 0.5), # 7.13 + ("spm10k", 0.3), # 7.88 # alpha for SPM-BPE has a very different effect, and it causes the seq len to be much longer. # The higher the alpha, the longer (the reverse as for SPM Unigram). # See archive/returnn-spm_bpe10-sample.config. - ("spm_bpe10k", 0.005), - ("spm_bpe10k", 0.01), + # spm_bpe10k no sampling: 7.97 + ("spm_bpe10k", 0.001), + ("spm_bpe10k", 0.005), # 8.66 + ("spm_bpe10k", 0.01), # 8.99 # ("spm_bpe10k", 0.3), # broken # ("spm_bpe10k", 0.7), # broken # alpha for BPE is again a bit different, but more similar to SPM-BPE than SPM-Unigram. # See archive/returnn-bpe10-sample.config. - ("bpe10k", 0.01), + # The higher the alpha, the longer the sequence, i.e. the more aggressive the sampling. + # bpe10k no sampling: 8.23 + ("bpe10k", 0.005), + ("bpe10k", 0.01), # 7.10 + ("bpe10k", 0.02), ]: train_exp( f"v6-bhv20-11gb-f32-bs15k-accgrad1-mgpu4-pavg100-wd1e_2-lrlin1e_5_295k-speedpertV2-{vocab}" From c35b50a8f05cb854c3c94d1ba256cd26322a12df Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Thu, 13 Jun 2024 00:41:51 +0200 Subject: [PATCH 158/227] more --- .../exp2024_04_23_baselines/aed.py | 43 ++++++++++++------- 1 file changed, 28 insertions(+), 15 deletions(-) diff --git a/users/zeyer/experiments/exp2024_04_23_baselines/aed.py b/users/zeyer/experiments/exp2024_04_23_baselines/aed.py index 8099b81df..7a3354ec3 100644 --- a/users/zeyer/experiments/exp2024_04_23_baselines/aed.py +++ b/users/zeyer/experiments/exp2024_04_23_baselines/aed.py @@ -85,21 +85,28 @@ def py(): vocab=vocab, ) - # Testing sampling in SPM. Baseline without sampling: 5.24 dev-other. - # The lower the alpha, the more aggressive the sampling. - # alpha=0.1 seems too aggressive for AED, bad convergence - for alpha in [ - 0.3, # 5.26 - 0.5, # 5.13 - 0.6, # 5.13 - 0.7, # 4.98 (!!) - 0.8, # 5.14 - 0.9, # 5.18 - 1.0, # 5.35. sanity check, should be like baseline (5.16), could be attributed to randomness? + for vocab, alpha in [ + # Testing sampling in SPM. + # The lower the alpha, the more aggressive the sampling. + # See archive/returnn-spm10-sample.config for playing around with alpha and checking avg seq len. + # spm10k without sampling: 5.24 dev-other + ("spm10k", 1.0), # 5.35. sanity check, should be like baseline (5.16), could be attributed to randomness? + ("spm10k", 0.9), # 5.18 + ("spm10k", 0.8), # 5.14 + ("spm10k", 0.7), # 4.98 (!!) + ("spm10k", 0.6), # 5.13 + ("spm10k", 0.5), # 5.13 + ("spm10k", 0.3), # 5.26 + # spm10k, alpha=0.1: seems too aggressive for AED, bad convergence + # alpha for BPE is again a bit different, but more similar to SPM-BPE than SPM-Unigram. + # See archive/returnn-bpe10-sample.config. + # The higher the alpha, the longer the sequence, i.e. the more aggressive the sampling. + # bpe10k without sampling: 5.32 + ("bpe10k", 0.01), ]: train_exp( - f"v6-bhv20-11gb-f32-bs15k-accgrad1-mgpu4-pavg100-wd1e_2-lrlin1e_5_295k-speedpertV2-spm10k" - f"-spmSample{str(alpha).replace('.', '')}", + f"v6-bhv20-11gb-f32-bs15k-accgrad1-mgpu4-pavg100-wd1e_2-lrlin1e_5_295k-speedpertV2-{vocab}" + f"-{'spmSample' if vocab.startswith('spm') else 'bpeSample'}{str(alpha).replace('.', '')}", config_11gb_v6_f32_accgrad1_mgpu4_pavg100_wd1e_4, config_updates={ **_get_cfg_lrlin_oclr_by_bs_nep(15_000, 500), @@ -107,8 +114,14 @@ def py(): "__train_audio_preprocess": speed_pert_librosa_config, "speed_pert_discrete_values": [0.7, 0.8, 0.9, 1.0, 1.1], }, - vocab="spm10k", - train_vocab_opts={"other_opts": {"enable_sampling": True, "alpha": alpha}}, + vocab=vocab, + train_vocab_opts={ + "other_opts": ( + {"enable_sampling": True, "alpha": alpha} + if vocab.startswith("spm") + else {"class": "SamplingBytePairEncoding", "breadth_prob": alpha} + ) + }, ) From 69d746504520b1535b9a5c0fd0f236aa78aee740 Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Thu, 13 Jun 2024 09:14:34 +0200 Subject: [PATCH 159/227] more --- users/zeyer/experiments/exp2024_04_23_baselines/aed.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/users/zeyer/experiments/exp2024_04_23_baselines/aed.py b/users/zeyer/experiments/exp2024_04_23_baselines/aed.py index 7a3354ec3..17e26e500 100644 --- a/users/zeyer/experiments/exp2024_04_23_baselines/aed.py +++ b/users/zeyer/experiments/exp2024_04_23_baselines/aed.py @@ -69,9 +69,12 @@ def py(): ) for vocab in [ + "spm20k", "bpe10k", # 5.32 "spm10k", # 5.16 "spm_bpe10k", # 5.21 + "spm4k", + "spm1k", ]: train_exp( # 5.16 f"v6-bhv20-11gb-f32-bs15k-accgrad1-mgpu4-pavg100-wd1e_2-lrlin1e_5_295k-speedpertV2-{vocab}", From 3a71ddc004cee23accba5a66e7d68f2e24788f57 Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Thu, 13 Jun 2024 10:09:22 +0200 Subject: [PATCH 160/227] prepare for some more modeling code --- users/zeyer/nn_rf/README.md | 5 ++++ users/zeyer/nn_rf/__init__.py | 0 users/zeyer/nn_rf/frontend.py | 36 ++++++++++++++++++++++++++++ users/zeyer/returnn/models/README.md | 3 +++ 4 files changed, 44 insertions(+) create mode 100644 users/zeyer/nn_rf/README.md create mode 100644 users/zeyer/nn_rf/__init__.py create mode 100644 users/zeyer/nn_rf/frontend.py create mode 100644 users/zeyer/returnn/models/README.md diff --git a/users/zeyer/nn_rf/README.md b/users/zeyer/nn_rf/README.md new file mode 100644 index 000000000..7e963a8cd --- /dev/null +++ b/users/zeyer/nn_rf/README.md @@ -0,0 +1,5 @@ +Putting some custom neural network modeling code here, +specifically using RETURNN frontend (RF) +(although the code could also be used outside of RETURNN). + +Some more modeling code is in `..returnn.models`. diff --git a/users/zeyer/nn_rf/__init__.py b/users/zeyer/nn_rf/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/users/zeyer/nn_rf/frontend.py b/users/zeyer/nn_rf/frontend.py new file mode 100644 index 000000000..5c6328b43 --- /dev/null +++ b/users/zeyer/nn_rf/frontend.py @@ -0,0 +1,36 @@ +""" +Custom frontends. + +In RF `ConformerEncoder`, that would be an argument for `input_layer`. + +Default we used in the past:: + + input_layer=ConformerConvSubsample( + in_dim, + out_dims=[Dim(32, name="conv1"), Dim(64, name="conv2"), Dim(64, name="conv3")], + filter_sizes=[(3, 3), (3, 3), (3, 3)], + pool_sizes=[(1, 2)], + strides=[(1, 1), (3, 1), (2, 1)], + ), + +This uses a downsampling factor of 6. +""" + +from typing import Tuple +from returnn.tensor import Dim +from returnn.frontend.encoder.conformer import ConformerConvSubsample +from returnn.frontend.encoder.base import ISeqDownsamplingEncoder + + +# TODO how to serialize variants? + + +def get_default(*, in_dim: Dim, time_strides: Tuple[int, int, int] = (1, 3, 2)) -> ISeqDownsamplingEncoder: + assert len(time_strides) == 3 + return ConformerConvSubsample( + in_dim, + out_dims=[Dim(32, name="conv1"), Dim(64, name="conv2"), Dim(64, name="conv3")], + filter_sizes=[(3, 3), (3, 3), (3, 3)], + strides=[(s, 1) for s in time_strides], + pool_sizes=[(1, 2)], + ) diff --git a/users/zeyer/returnn/models/README.md b/users/zeyer/returnn/models/README.md new file mode 100644 index 000000000..b0222aa37 --- /dev/null +++ b/users/zeyer/returnn/models/README.md @@ -0,0 +1,3 @@ +Some modeling code. + +Note, more is in module `...nn_rf` and `...nn_tf`. From 8c4d63f3012ae9abdbc3b8d426177a33232afcb4 Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Thu, 13 Jun 2024 10:12:15 +0200 Subject: [PATCH 161/227] move SequentialLayerDrop --- users/zeyer/nn_rf/layerdrop.py | 37 ++++++++++++++++++++++ users/zeyer/returnn/models/rf_layerdrop.py | 35 ++------------------ 2 files changed, 40 insertions(+), 32 deletions(-) create mode 100644 users/zeyer/nn_rf/layerdrop.py diff --git a/users/zeyer/nn_rf/layerdrop.py b/users/zeyer/nn_rf/layerdrop.py new file mode 100644 index 000000000..5eeb0fb57 --- /dev/null +++ b/users/zeyer/nn_rf/layerdrop.py @@ -0,0 +1,37 @@ +""" +Layerdrop, the most simple way, like ESPnet + +https://github.com/espnet/espnet/blob/7c140c2ac9b4f642acb36131217dd984d4601681/espnet2/asr/encoder/conformer_encoder.py#L278 +https://github.com/espnet/espnet/blob/7c140c2ac9b4f642acb36131217dd984d4601681/espnet/nets/pytorch_backend/transformer/repeat.py#L29 +""" + +from __future__ import annotations +from typing import Optional, Dict +from returnn.tensor import Tensor, Dim +import returnn.frontend as rf + + +class SequentialLayerDrop(rf.Sequential): + def __init__(self, *args, layer_drop: float): + super().__init__(*args) + self.layer_drop = layer_drop + + def __call__(self, inp, *, collected_outputs: Optional[Dict[str, Tensor]] = None, **kwargs) -> Tensor: + def _layer_drop_call(): + x = inp + num_layers_dim = Dim(len(self), name="num_layers") + drop_probs = rf.random_uniform([num_layers_dim], device="cpu") + for i, (name, module) in enumerate(self.items()): + x = rf.cond( + rf.gather(drop_probs, indices=i, axis=num_layers_dim) >= self.layer_drop, + lambda: module(x, **kwargs), + lambda: x, + ) + if collected_outputs is not None: + collected_outputs[name] = x + return x + + def _no_layer_drop_call(): + return rf.Sequential.__call__(self, inp, collected_outputs=collected_outputs, **kwargs) + + return rf.cond(rf.get_run_ctx().train_flag, _layer_drop_call, _no_layer_drop_call) diff --git a/users/zeyer/returnn/models/rf_layerdrop.py b/users/zeyer/returnn/models/rf_layerdrop.py index 5eeb0fb57..3e47805dd 100644 --- a/users/zeyer/returnn/models/rf_layerdrop.py +++ b/users/zeyer/returnn/models/rf_layerdrop.py @@ -1,37 +1,8 @@ """ -Layerdrop, the most simple way, like ESPnet - -https://github.com/espnet/espnet/blob/7c140c2ac9b4f642acb36131217dd984d4601681/espnet2/asr/encoder/conformer_encoder.py#L278 -https://github.com/espnet/espnet/blob/7c140c2ac9b4f642acb36131217dd984d4601681/espnet/nets/pytorch_backend/transformer/repeat.py#L29 +Layerdrop """ -from __future__ import annotations -from typing import Optional, Dict -from returnn.tensor import Tensor, Dim -import returnn.frontend as rf - - -class SequentialLayerDrop(rf.Sequential): - def __init__(self, *args, layer_drop: float): - super().__init__(*args) - self.layer_drop = layer_drop - - def __call__(self, inp, *, collected_outputs: Optional[Dict[str, Tensor]] = None, **kwargs) -> Tensor: - def _layer_drop_call(): - x = inp - num_layers_dim = Dim(len(self), name="num_layers") - drop_probs = rf.random_uniform([num_layers_dim], device="cpu") - for i, (name, module) in enumerate(self.items()): - x = rf.cond( - rf.gather(drop_probs, indices=i, axis=num_layers_dim) >= self.layer_drop, - lambda: module(x, **kwargs), - lambda: x, - ) - if collected_outputs is not None: - collected_outputs[name] = x - return x +from ...nn_rf.layerdrop import * - def _no_layer_drop_call(): - return rf.Sequential.__call__(self, inp, collected_outputs=collected_outputs, **kwargs) - return rf.cond(rf.get_run_ctx().train_flag, _layer_drop_call, _no_layer_drop_call) +SequentialLayerDrop # noqa From bb6bb4295b53b4a6b03b225c413d82b3f2e1d8e0 Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Thu, 13 Jun 2024 10:12:39 +0200 Subject: [PATCH 162/227] better --- users/zeyer/returnn/models/rf_layerdrop.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/users/zeyer/returnn/models/rf_layerdrop.py b/users/zeyer/returnn/models/rf_layerdrop.py index 3e47805dd..282957223 100644 --- a/users/zeyer/returnn/models/rf_layerdrop.py +++ b/users/zeyer/returnn/models/rf_layerdrop.py @@ -5,4 +5,4 @@ from ...nn_rf.layerdrop import * -SequentialLayerDrop # noqa +__all__ = ["SequentialLayerDrop"] From 468537a19fdd4451b309d3c45f6b4af4024db4aa Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Thu, 13 Jun 2024 10:14:27 +0200 Subject: [PATCH 163/227] move mixup --- users/zeyer/nn_rf/mixup.py | 177 +++++++++++++++++++++++++ users/zeyer/returnn/models/rf_mixup.py | 175 +----------------------- 2 files changed, 180 insertions(+), 172 deletions(-) create mode 100644 users/zeyer/nn_rf/mixup.py diff --git a/users/zeyer/nn_rf/mixup.py b/users/zeyer/nn_rf/mixup.py new file mode 100644 index 000000000..a0c8cc375 --- /dev/null +++ b/users/zeyer/nn_rf/mixup.py @@ -0,0 +1,177 @@ +""" +Mixup with RF +""" + +from __future__ import annotations +from dataclasses import dataclass +from returnn.tensor import Tensor, Dim +import returnn.frontend as rf + + +@dataclass +class MixupOpts: + """ + Arguments: + buffer_size: number of frames. + apply_prob: probability to apply mixup at all + max_num_mix: maximum number of mixups (random int in [1, max_num_mix]) + lambda_min: minimum lambda value + lambda_max: maximum lambda value + """ + + buffer_size: int = 1_000_000 + apply_prob: float = 1.0 + max_num_mix: int = 4 + lambda_min: float = 0.1 + lambda_max: float = 0.4 + + +class Mixup(rf.Module): + """ + Mixup + """ + + def __init__(self, *, feature_dim: Dim, opts: MixupOpts): + super().__init__() + self.feature_dim = feature_dim + self.opts = opts + self.buffer_size_dim = Dim(opts.buffer_size, name="buffer_size") + self.buffer = rf.Parameter([self.buffer_size_dim, feature_dim], auxiliary=True) + self.buffer_pos = rf.Parameter( + [], dtype="int32", sparse_dim=self.buffer_size_dim, initial=0, auxiliary=True, device="cpu" + ) + self.buffer_filled = rf.Parameter([], dtype="bool", initial=False, auxiliary=True, device="cpu") + + def __call__(self, src: Tensor, *, spatial_dim: Dim) -> Tensor: + if not rf.get_run_ctx().train_flag: + return src + + assert spatial_dim in src.dims and self.feature_dim in src.dims + + # Apply mixup before we add the new data to the buffer. + src_ = self._maybe_apply_mixup(src, spatial_dim=spatial_dim) + + self._append_to_buffer(src, spatial_dim=spatial_dim) + + return src_ + + def _append_to_buffer(self, src: Tensor, *, spatial_dim: Dim): + batch_dims = src.remaining_dims((spatial_dim, self.feature_dim)) + opts = self.opts + + # Fill buffer with new data: + src_flat, src_flat_dim = rf.pack_padded(src, dims=batch_dims + [spatial_dim]) + new_pos = rf.minimum(self.buffer_pos + src_flat_dim.get_size_tensor(), opts.buffer_size) + part_fill_len = new_pos - self.buffer_pos + src_flat_part, src_flat_part_dim = rf.slice(src_flat, axis=src_flat_dim, end=part_fill_len) + self.buffer.assign_key( + axis=self.buffer_size_dim, + key=slice(self.buffer_pos, new_pos), + key_dim=src_flat_part_dim, + value=src_flat_part, + ) + if (self.buffer_pos + src_flat_dim.get_size_tensor() >= opts.buffer_size).raw_tensor: + self.buffer_filled.assign(True) + part_fill_len_ = rf.minimum(src_flat_dim.get_size_tensor() - part_fill_len, opts.buffer_size) + src_flat_part, src_flat_part_dim = rf.slice( + src_flat, axis=src_flat_dim, start=part_fill_len, end=part_fill_len + part_fill_len_ + ) + self.buffer.assign_key( + axis=self.buffer_size_dim, key=slice(0, part_fill_len_), key_dim=src_flat_part_dim, value=src_flat_part + ) + new_pos = part_fill_len_ + self.buffer_pos.assign(new_pos) + + def _maybe_apply_mixup(self, src: Tensor, *, spatial_dim: Dim) -> Tensor: + batch_dims = src.remaining_dims((spatial_dim, self.feature_dim)) + opts = self.opts + + if (rf.random_uniform((), device="cpu") >= opts.apply_prob).raw_tensor: + return src + + buffer_filled_size = rf.where(self.buffer_filled, opts.buffer_size, self.buffer_pos) + if (buffer_filled_size < spatial_dim.get_dim_value_tensor()).raw_tensor: + return src + + # Apply Mixup. Collect all data we are going to add for each sequence. + num_mixup = rf.random_uniform( + batch_dims, minval=1, maxval=opts.max_num_mix + 1, dtype="int32", device="cpu" + ) # [B] + num_mixup_dim = Dim(num_mixup, name="num_mixup") + + buffer_start = rf.random_uniform( + batch_dims + [num_mixup_dim], + maxval=buffer_filled_size - spatial_dim.get_dim_value_tensor() + 1, + dtype="int32", + sparse_dim=self.buffer_size_dim, + ) # [B, N] + n_mask = rf.sequence_mask(num_mixup_dim) # [B, N] + buffer_start_flat, num_mixup_flat_dim = rf.masked_select( + buffer_start, mask=n_mask, dims=batch_dims + [num_mixup_dim] + ) # [B_N'] + + idx = rf.range_over_dim(spatial_dim) # [T] + idx = rf.combine_bc(idx, "+", buffer_start_flat) # [B_N', T] + + mixup_values = rf.gather(self.buffer, indices=idx, axis=self.buffer_size_dim) # [B_N', T, F] + + # Scale the mixup values. + lambda_ = rf.random_uniform( + batch_dims + [num_mixup_dim], minval=opts.lambda_min, maxval=opts.lambda_max, dtype=src.dtype + ) + mixup_scales = rf.random_uniform(batch_dims + [num_mixup_dim], minval=0.001, maxval=1.0, dtype=src.dtype) + mixup_scales *= lambda_ / rf.reduce_sum(mixup_scales, axis=num_mixup_dim) # [B,N] + mixup_scales_flat, _ = rf.masked_select( + mixup_scales, mask=n_mask, dims=batch_dims + [num_mixup_dim], out_dim=num_mixup_flat_dim + ) # [B_N'] + mixup_values *= mixup_scales_flat # [B_N', T, F] + + idx_b = rf.range_over_merged_dims(batch_dims) # [B] -> B + idx_b, _ = rf.masked_select( + idx_b, mask=n_mask, dims=batch_dims + [num_mixup_dim], out_dim=num_mixup_flat_dim + ) # [B_N'] -> B + + mixup_value = rf.scatter( + mixup_values, indices=idx_b, indices_dim=num_mixup_flat_dim, out_dim=batch_dims + ) # [B,T,F] + + src = src + rf.stop_gradient(mixup_value) + return src + + +def _test_mixup(): + import numpy as np + + rf.select_backend_torch() + rf.init_train_step_run_ctx(train_flag=True, step=0) + + batch_dim = Dim(2, name="batch") + time_dim = Dim(rf.convert_to_tensor(np.array([7, 8], dtype="int32"), dims=[batch_dim]), name="time") + feature_dim = Dim(5, name="feature") + data = rf.convert_to_tensor( + np.arange(2 * 8 * 5).reshape(2, 8, 5).astype("float32"), dims=[batch_dim, time_dim, feature_dim] + ) + data /= rf.reduce_max(data, axis=time_dim) + print("data:", data, data.raw_tensor) + + mixup = Mixup(feature_dim=feature_dim, opts=MixupOpts(buffer_size=30, lambda_min=1.0, lambda_max=1.0)) + + x = mixup(data, spatial_dim=time_dim) + print("x:", x, x.raw_tensor) + print("buffer:", mixup.buffer, mixup.buffer.raw_tensor) + + batch_dim = Dim(3, name="batch") + time_dim = Dim(rf.convert_to_tensor(np.array([3, 4, 2], dtype="int32"), dims=[batch_dim]), name="time") + data = rf.ones([batch_dim, time_dim, feature_dim]) + x = mixup(data, spatial_dim=time_dim) + print("x':", x, x.raw_tensor) + print("buffer':", mixup.buffer, mixup.buffer.raw_tensor) + + data = -rf.ones([batch_dim, time_dim, feature_dim]) + x = mixup(data, spatial_dim=time_dim) + print("x'':", x, x.raw_tensor) + print("buffer'':", mixup.buffer, mixup.buffer.raw_tensor) + + +if __name__ == "__main__": + _test_mixup() diff --git a/users/zeyer/returnn/models/rf_mixup.py b/users/zeyer/returnn/models/rf_mixup.py index a0c8cc375..2e5272349 100644 --- a/users/zeyer/returnn/models/rf_mixup.py +++ b/users/zeyer/returnn/models/rf_mixup.py @@ -1,177 +1,8 @@ """ -Mixup with RF +Mixup """ -from __future__ import annotations -from dataclasses import dataclass -from returnn.tensor import Tensor, Dim -import returnn.frontend as rf +from ...nn_rf.mixup import * -@dataclass -class MixupOpts: - """ - Arguments: - buffer_size: number of frames. - apply_prob: probability to apply mixup at all - max_num_mix: maximum number of mixups (random int in [1, max_num_mix]) - lambda_min: minimum lambda value - lambda_max: maximum lambda value - """ - - buffer_size: int = 1_000_000 - apply_prob: float = 1.0 - max_num_mix: int = 4 - lambda_min: float = 0.1 - lambda_max: float = 0.4 - - -class Mixup(rf.Module): - """ - Mixup - """ - - def __init__(self, *, feature_dim: Dim, opts: MixupOpts): - super().__init__() - self.feature_dim = feature_dim - self.opts = opts - self.buffer_size_dim = Dim(opts.buffer_size, name="buffer_size") - self.buffer = rf.Parameter([self.buffer_size_dim, feature_dim], auxiliary=True) - self.buffer_pos = rf.Parameter( - [], dtype="int32", sparse_dim=self.buffer_size_dim, initial=0, auxiliary=True, device="cpu" - ) - self.buffer_filled = rf.Parameter([], dtype="bool", initial=False, auxiliary=True, device="cpu") - - def __call__(self, src: Tensor, *, spatial_dim: Dim) -> Tensor: - if not rf.get_run_ctx().train_flag: - return src - - assert spatial_dim in src.dims and self.feature_dim in src.dims - - # Apply mixup before we add the new data to the buffer. - src_ = self._maybe_apply_mixup(src, spatial_dim=spatial_dim) - - self._append_to_buffer(src, spatial_dim=spatial_dim) - - return src_ - - def _append_to_buffer(self, src: Tensor, *, spatial_dim: Dim): - batch_dims = src.remaining_dims((spatial_dim, self.feature_dim)) - opts = self.opts - - # Fill buffer with new data: - src_flat, src_flat_dim = rf.pack_padded(src, dims=batch_dims + [spatial_dim]) - new_pos = rf.minimum(self.buffer_pos + src_flat_dim.get_size_tensor(), opts.buffer_size) - part_fill_len = new_pos - self.buffer_pos - src_flat_part, src_flat_part_dim = rf.slice(src_flat, axis=src_flat_dim, end=part_fill_len) - self.buffer.assign_key( - axis=self.buffer_size_dim, - key=slice(self.buffer_pos, new_pos), - key_dim=src_flat_part_dim, - value=src_flat_part, - ) - if (self.buffer_pos + src_flat_dim.get_size_tensor() >= opts.buffer_size).raw_tensor: - self.buffer_filled.assign(True) - part_fill_len_ = rf.minimum(src_flat_dim.get_size_tensor() - part_fill_len, opts.buffer_size) - src_flat_part, src_flat_part_dim = rf.slice( - src_flat, axis=src_flat_dim, start=part_fill_len, end=part_fill_len + part_fill_len_ - ) - self.buffer.assign_key( - axis=self.buffer_size_dim, key=slice(0, part_fill_len_), key_dim=src_flat_part_dim, value=src_flat_part - ) - new_pos = part_fill_len_ - self.buffer_pos.assign(new_pos) - - def _maybe_apply_mixup(self, src: Tensor, *, spatial_dim: Dim) -> Tensor: - batch_dims = src.remaining_dims((spatial_dim, self.feature_dim)) - opts = self.opts - - if (rf.random_uniform((), device="cpu") >= opts.apply_prob).raw_tensor: - return src - - buffer_filled_size = rf.where(self.buffer_filled, opts.buffer_size, self.buffer_pos) - if (buffer_filled_size < spatial_dim.get_dim_value_tensor()).raw_tensor: - return src - - # Apply Mixup. Collect all data we are going to add for each sequence. - num_mixup = rf.random_uniform( - batch_dims, minval=1, maxval=opts.max_num_mix + 1, dtype="int32", device="cpu" - ) # [B] - num_mixup_dim = Dim(num_mixup, name="num_mixup") - - buffer_start = rf.random_uniform( - batch_dims + [num_mixup_dim], - maxval=buffer_filled_size - spatial_dim.get_dim_value_tensor() + 1, - dtype="int32", - sparse_dim=self.buffer_size_dim, - ) # [B, N] - n_mask = rf.sequence_mask(num_mixup_dim) # [B, N] - buffer_start_flat, num_mixup_flat_dim = rf.masked_select( - buffer_start, mask=n_mask, dims=batch_dims + [num_mixup_dim] - ) # [B_N'] - - idx = rf.range_over_dim(spatial_dim) # [T] - idx = rf.combine_bc(idx, "+", buffer_start_flat) # [B_N', T] - - mixup_values = rf.gather(self.buffer, indices=idx, axis=self.buffer_size_dim) # [B_N', T, F] - - # Scale the mixup values. - lambda_ = rf.random_uniform( - batch_dims + [num_mixup_dim], minval=opts.lambda_min, maxval=opts.lambda_max, dtype=src.dtype - ) - mixup_scales = rf.random_uniform(batch_dims + [num_mixup_dim], minval=0.001, maxval=1.0, dtype=src.dtype) - mixup_scales *= lambda_ / rf.reduce_sum(mixup_scales, axis=num_mixup_dim) # [B,N] - mixup_scales_flat, _ = rf.masked_select( - mixup_scales, mask=n_mask, dims=batch_dims + [num_mixup_dim], out_dim=num_mixup_flat_dim - ) # [B_N'] - mixup_values *= mixup_scales_flat # [B_N', T, F] - - idx_b = rf.range_over_merged_dims(batch_dims) # [B] -> B - idx_b, _ = rf.masked_select( - idx_b, mask=n_mask, dims=batch_dims + [num_mixup_dim], out_dim=num_mixup_flat_dim - ) # [B_N'] -> B - - mixup_value = rf.scatter( - mixup_values, indices=idx_b, indices_dim=num_mixup_flat_dim, out_dim=batch_dims - ) # [B,T,F] - - src = src + rf.stop_gradient(mixup_value) - return src - - -def _test_mixup(): - import numpy as np - - rf.select_backend_torch() - rf.init_train_step_run_ctx(train_flag=True, step=0) - - batch_dim = Dim(2, name="batch") - time_dim = Dim(rf.convert_to_tensor(np.array([7, 8], dtype="int32"), dims=[batch_dim]), name="time") - feature_dim = Dim(5, name="feature") - data = rf.convert_to_tensor( - np.arange(2 * 8 * 5).reshape(2, 8, 5).astype("float32"), dims=[batch_dim, time_dim, feature_dim] - ) - data /= rf.reduce_max(data, axis=time_dim) - print("data:", data, data.raw_tensor) - - mixup = Mixup(feature_dim=feature_dim, opts=MixupOpts(buffer_size=30, lambda_min=1.0, lambda_max=1.0)) - - x = mixup(data, spatial_dim=time_dim) - print("x:", x, x.raw_tensor) - print("buffer:", mixup.buffer, mixup.buffer.raw_tensor) - - batch_dim = Dim(3, name="batch") - time_dim = Dim(rf.convert_to_tensor(np.array([3, 4, 2], dtype="int32"), dims=[batch_dim]), name="time") - data = rf.ones([batch_dim, time_dim, feature_dim]) - x = mixup(data, spatial_dim=time_dim) - print("x':", x, x.raw_tensor) - print("buffer':", mixup.buffer, mixup.buffer.raw_tensor) - - data = -rf.ones([batch_dim, time_dim, feature_dim]) - x = mixup(data, spatial_dim=time_dim) - print("x'':", x, x.raw_tensor) - print("buffer'':", mixup.buffer, mixup.buffer.raw_tensor) - - -if __name__ == "__main__": - _test_mixup() +__all__ = ["MixupOpts", "Mixup"] From 87aae2537a09b4ecaaae5bdbea41a0aa9345569c Mon Sep 17 00:00:00 2001 From: "luca.gaudino" Date: Thu, 13 Jun 2024 11:54:11 +0200 Subject: [PATCH 164/227] rnnt dec rf WIP --- .../experiments/rnnt_bpe/baseline.py | 6 +- .../conformer_import_moh_att_2023_06_30.py | 6 +- .../conformer_import_moh_att_train.py | 2 +- .../librispeech_960/_import_model_nick.py | 333 +++++++++++++ .../librispeech_960/conformer_ctc_train.py | 47 +- .../librispeech_960/conformer_rnnt_train.py | 336 +++++++++++++ .../tedlium2/conformer_rnnt_train.py | 23 +- .../rf/conformer_rnnt/model_conformer_rnnt.py | 76 ++- .../asr/rf/conformer_rnnt/model_recog_rnnt.py | 441 +++++++++--------- 9 files changed, 1005 insertions(+), 265 deletions(-) create mode 100644 users/gaudino/experiments/rf_conformer_rnnt_2024/librispeech_960/_import_model_nick.py create mode 100644 users/gaudino/experiments/rf_conformer_rnnt_2024/librispeech_960/conformer_rnnt_train.py diff --git a/users/gaudino/experiments/ctc_rnnt_standalone_2024/librispeech_960/experiments/rnnt_bpe/baseline.py b/users/gaudino/experiments/ctc_rnnt_standalone_2024/librispeech_960/experiments/rnnt_bpe/baseline.py index abb40af5a..2dba0efab 100644 --- a/users/gaudino/experiments/ctc_rnnt_standalone_2024/librispeech_960/experiments/rnnt_bpe/baseline.py +++ b/users/gaudino/experiments/ctc_rnnt_standalone_2024/librispeech_960/experiments/rnnt_bpe/baseline.py @@ -149,7 +149,7 @@ def evaluate_helper( predictor_config = PredictorConfig( symbol_embedding_dim=256, emebdding_dropout=0.2, - num_lstm_layers=2, + num_lstm_layers=1, # 2 lstm_hidden_dim=512, lstm_dropout=0.1, ) @@ -222,8 +222,8 @@ def evaluate_helper( } training_name = ( - prefix_name + "/" + network_module + ".512dim_sub6_24gbgpu_25eps_accum2_fullspec1_continue_from_ctc50eps_numlstm2" - # prefix_name + "/" + network_module + ".512dim_sub6_24gbgpu_25eps_accum2_fullspec1_continue_from_ctc50eps" + # prefix_name + "/" + network_module + ".512dim_sub6_24gbgpu_25eps_accum2_fullspec1_continue_from_ctc50eps_numlstm2" + prefix_name + "/" + network_module + ".512dim_sub6_24gbgpu_25eps_accum2_fullspec1_continue_from_ctc50eps" ) train_job = training( training_name, train_data_bpe5000, train_args_warprnnt_accum2_fullspec1, num_epochs=250, **default_returnn diff --git a/users/gaudino/experiments/rf_conformer_att_2023/librispeech_960/conformer_import_moh_att_2023_06_30.py b/users/gaudino/experiments/rf_conformer_att_2023/librispeech_960/conformer_import_moh_att_2023_06_30.py index 4b0b70543..faa8edbb8 100644 --- a/users/gaudino/experiments/rf_conformer_att_2023/librispeech_960/conformer_import_moh_att_2023_06_30.py +++ b/users/gaudino/experiments/rf_conformer_att_2023/librispeech_960/conformer_import_moh_att_2023_06_30.py @@ -627,7 +627,7 @@ def sis_run_with_prefix(prefix_name: str = None): task, model_with_checkpoint, model_recog, - dev_sets=["dev-other"], + dev_sets=["dev-clean", "dev-other", "test-clean", "test-other"], model_args=model_args, search_args=search_args, prefix_name=name, @@ -639,7 +639,7 @@ def sis_run_with_prefix(prefix_name: str = None): # opls att + ctc + trafo lm + ilm for scales, prior_scale, lm_scale, ilm_scale, beam_size in product( - [(0.8, 0.2)], [0.05, 0.07], [0.65], [0.4], [32, 48, 64] + [(0.8, 0.2)], [0.05, 0.07], [0.65], [0.4], [32, 40] ): att_scale, ctc_scale = scales recog_name = ( @@ -668,7 +668,7 @@ def sis_run_with_prefix(prefix_name: str = None): task, model_with_checkpoint, model_recog, - dev_sets=["dev-clean", "dev-other"], + dev_sets=["dev-clean", "dev-other", "test-clean", "test-other"], model_args=model_args, search_args=search_args, prefix_name=name, diff --git a/users/gaudino/experiments/rf_conformer_att_2023/librispeech_960/conformer_import_moh_att_train.py b/users/gaudino/experiments/rf_conformer_att_2023/librispeech_960/conformer_import_moh_att_train.py index 5bdc5eff2..475f6d6d7 100644 --- a/users/gaudino/experiments/rf_conformer_att_2023/librispeech_960/conformer_import_moh_att_train.py +++ b/users/gaudino/experiments/rf_conformer_att_2023/librispeech_960/conformer_import_moh_att_train.py @@ -334,7 +334,7 @@ def sis_run_with_prefix(prefix_name: Optional[str] = None): "learning_rate_piecewise_values": [1e-5, 1e-3, 1e-5, 1e-6], }, ) - model = train_exp( + model = train_exp( # 5.42 "base-24gb-v6-lrlin1e_5_600k_noCTC", config_24gb_v6, config_updates={ diff --git a/users/gaudino/experiments/rf_conformer_rnnt_2024/librispeech_960/_import_model_nick.py b/users/gaudino/experiments/rf_conformer_rnnt_2024/librispeech_960/_import_model_nick.py new file mode 100644 index 000000000..0a4835e40 --- /dev/null +++ b/users/gaudino/experiments/rf_conformer_rnnt_2024/librispeech_960/_import_model_nick.py @@ -0,0 +1,333 @@ +from __future__ import annotations + +from typing import Dict, Optional + +import os +import torch +import numpy + +from sisyphus import tk + +# from i6_core.returnn.training import Checkpoint +# from i6_experiments.users.zeyer.utils.generic_job_output import generic_job_output +# from i6_experiments.users.gaudino.returnn.convert_ckpt_rf import ( +# ConvertTfCheckpointToRfPtJob, +# ) + +from i6_experiments.users.gaudino.experiments.rf_conformer_att_2023.librispeech_960.conformer_import_moh_att_2023_06_30 import ( + MakeModel, +) + +from i6_experiments.users.gaudino.models.asr.rf.conformer_rnnt.model_conformer_rnnt import MakeModel as MakeModelRNNT + +from i6_experiments.users.gaudino.models.asr.rf.nn_lm.lm_import_2023_11_09 import ( + MakeModel as MakeModelLM, +) + +from i6_experiments.users.gaudino.models.asr.rf.nn_lm.lm_import_2023_09_03 import ( + MakeModel as MakeModelLSTMLM, +) + +from i6_experiments.users.gaudino.models.asr.rf.ilm_import_2024_04_17 import ( + MakeModel as MakeModelILM, +) + +import returnn.frontend as rf + +from itertools import product + +_nick_pure_torch_rnnt_ckpt_path = "/work/asr4/rossenbach/sisyphus_work_folders/tts_decoder_asr_work/i6_core/returnn/training/ReturnnTrainingJob.6lwn4XuFkhkI/output/models/epoch.250.pt" + +from i6_experiments.users.gaudino.experiments.conformer_att_2023.tedlium2.model_ckpt_info import models + + +def convert_checkpoint( + *, + ckpt_path: str, + ckpt_path_lm: Optional[str] = None, + ckpt_path_sep: Optional[str] = None, + out_dir: str, + print_params: bool = False, + save_model: bool = True, +): + """run""" + import returnn.frontend as rf + from returnn.torch.frontend.bridge import rf_module_to_pt_module + from returnn.util.basic import model_epoch_from_filename + + print("Input checkpoint:" + ckpt_path) + ckpt = torch.load(ckpt_path, map_location="cpu") + + if print_params: + for k, v in ckpt["model"].items(): + print(f"{k}: {v.shape if hasattr(v, 'shape') else v}") + # print(reader.debug_string().decode("utf-8")) + + + print() + + + print("Creating model...") + rf.select_backend_torch() + model = MakeModelRNNT(80, 1_057)() + + print("Created model:", model) + print("Model parameters:") + for name, param in model.named_parameters(): + assert isinstance(name, str) + assert isinstance(param, rf.Parameter) + if print_params: + print(f"{name}: {param}") + print() + + print("Create ParamMapping...") + param_mapping = {} + _add_params_predictor_joiner(param_mapping) + # _add_params_conformer(param_mapping, prefix="") + # if not ctc_only: + # _add_params_att_decoder(param_mapping) + # _add_params_trafo_lm(param_mapping) + # if model_args.get("encoder_ctc", False): + # _add_params_conformer(param_mapping, prefix="sep_enc_ctc_") + + for name, param in model.named_parameters(): + if name in param_mapping: + assert isinstance(name, str) + assert isinstance(param, rf.Parameter) + + value = map_param_func(ckpt, name, param, param_mapping) + assert isinstance(value, numpy.ndarray) + # noinspection PyProtectedMember + param._raw_backend.set_parameter_initial_value(param, value) + + epoch = 1 + if epoch is None: + epoch = model_epoch_from_filename(tk.Path(ckpt_path)) + pass + + step = 0 + # if step is None: + # assert reader.has_tensor("global_step") + # step = int(reader.get_tensor("global_step")) + + ckpt_name = os.path.basename(ckpt_path) + + pt_model = rf_module_to_pt_module(model) + + breakpoint() + + if save_model: + os.makedirs(out_dir, exist_ok=True) + filename = out_dir + "/" + ckpt_name + ".pt" + print(f"*** saving PyTorch model checkpoint: {filename}") + torch.save( + {"model": pt_model.state_dict(), "epoch": epoch, "step": step}, filename + ) + + if ckpt_name != "checkpoint": + symlink_filename = out_dir + "/checkpoint.pt" + print( + f"*** creating symlink {symlink_filename} -> {os.path.basename(filename)}" + ) + os.symlink(os.path.basename(filename), symlink_filename) + # create meta information + meta_filename = out_dir + "/" + ckpt_name + "." + str(epoch) + ".meta" + open(meta_filename, "w").close() + symlink_filename_1 = out_dir + "/checkpoint." + str(epoch) + ".meta" + symlink_filename_2 = out_dir + "/" + ckpt_name + ".meta" + os.symlink(os.path.basename(meta_filename), symlink_filename_1) + os.symlink(os.path.basename(meta_filename), symlink_filename_2) + # assert os.path.exists(self.out_checkpoint.get_path()) + +def _add_params_conformer(param_mapping: Dict[str, str], prefix: str): + # rf -> pt + # frontend + for layer_idx in [0, 1, 2]: + orig_name = "conv0" if layer_idx == 0 else f"subsample_conv{layer_idx - 1}" + param_mapping.update( + { + prefix + + f"encoder.input_layer.conv_layers.{layer_idx}.filter": f"{orig_name}/W", + prefix + + f"encoder.input_layer.conv_layers.{layer_idx}.bias": f"{orig_name}/bias", + } + ) + param_mapping.update( + { + prefix + "encoder.input_projection.weight": "source_linear/W", + # prefix + "ctc.weight": "ctc/W", + # prefix + "ctc.bias": "ctc/b", + prefix + "enc_aux_logits_12.weight": "ctc/W", + prefix + "enc_aux_logits_12.bias": "ctc/b", + } + ) + # conformer + for layer_idx in range(12): + # FF + for sub in [1, 2]: + param_mapping[ + prefix + f"encoder.layers.{layer_idx}.ffn{sub}.linear_ff.weight" + ] = f"conformer_block_{layer_idx + 1:02d}_ffmod_{sub}_ff1/W" + param_mapping[ + prefix + f"encoder.layers.{layer_idx}.ffn{sub}.linear_ff.bias" + ] = f"conformer_block_{layer_idx + 1:02d}_ffmod_{sub}_ff1/b" + param_mapping[ + prefix + f"encoder.layers.{layer_idx}.ffn{sub}.linear_out.weight" + ] = f"conformer_block_{layer_idx + 1:02d}_ffmod_{sub}_ff2/W" + param_mapping[ + prefix + f"encoder.layers.{layer_idx}.ffn{sub}.linear_out.bias" + ] = f"conformer_block_{layer_idx + 1:02d}_ffmod_{sub}_ff2/b" + param_mapping[ + prefix + f"encoder.layers.{layer_idx}.ffn{sub}_layer_norm.scale" + ] = f"conformer_block_{layer_idx + 1:02d}_ffmod_{sub}_ln/scale" + param_mapping[ + prefix + f"encoder.layers.{layer_idx}.ffn{sub}_layer_norm.bias" + ] = f"conformer_block_{layer_idx + 1:02d}_ffmod_{sub}_ln/bias" + # conv + param_mapping[ + prefix + f"encoder.layers.{layer_idx}.conv_block.positionwise_conv1.weight" + ] = f"conformer_block_{layer_idx + 1:02d}_conv_mod_pointwise_conv1/W" + param_mapping[ + prefix + f"encoder.layers.{layer_idx}.conv_block.positionwise_conv1.bias" + ] = f"conformer_block_{layer_idx + 1:02d}_conv_mod_pointwise_conv1/b" + param_mapping[ + prefix + f"encoder.layers.{layer_idx}.conv_block.depthwise_conv.filter" + ] = f"conformer_block_{layer_idx + 1:02d}_conv_mod_depthwise_conv2/W" + param_mapping[ + prefix + f"encoder.layers.{layer_idx}.conv_block.depthwise_conv.bias" + ] = f"conformer_block_{layer_idx + 1:02d}_conv_mod_depthwise_conv2/bias" + param_mapping[ + prefix + f"encoder.layers.{layer_idx}.conv_block.positionwise_conv2.weight" + ] = f"conformer_block_{layer_idx + 1:02d}_conv_mod_pointwise_conv2/W" + param_mapping[ + prefix + f"encoder.layers.{layer_idx}.conv_block.positionwise_conv2.bias" + ] = f"conformer_block_{layer_idx + 1:02d}_conv_mod_pointwise_conv2/b" + param_mapping[ + prefix + f"encoder.layers.{layer_idx}.conv_layer_norm.scale" + ] = f"conformer_block_{layer_idx + 1:02d}_conv_mod_ln/scale" + param_mapping[ + prefix + f"encoder.layers.{layer_idx}.conv_layer_norm.bias" + ] = f"conformer_block_{layer_idx + 1:02d}_conv_mod_ln/bias" + # self-att + param_mapping[ + prefix + f"encoder.layers.{layer_idx}.self_att.qkv.weight" + ] = f"conformer_block_{layer_idx + 1:02d}_self_att/QKV" + param_mapping[ + prefix + f"encoder.layers.{layer_idx}.self_att.proj.weight" + ] = f"conformer_block_{layer_idx + 1:02d}_self_att_linear/W" + param_mapping[ + prefix + f"encoder.layers.{layer_idx}.self_att_layer_norm.scale" + ] = f"conformer_block_{layer_idx + 1:02d}_self_att_ln/scale" + param_mapping[ + prefix + f"encoder.layers.{layer_idx}.self_att_layer_norm.bias" + ] = f"conformer_block_{layer_idx + 1:02d}_self_att_ln/bias" + param_mapping[ + prefix + f"encoder.layers.{layer_idx}.self_att.learned_pos_emb.pos_emb" + ] = f"conformer_block_{layer_idx + 1:02d}_self_att_ln_rel_pos_enc/encoding_matrix" + # final layer norm + param_mapping[ + prefix + f"encoder.layers.{layer_idx}.final_layer_norm.scale" + ] = f"conformer_block_{layer_idx + 1:02d}_ln/scale" + param_mapping[ + prefix + f"encoder.layers.{layer_idx}.final_layer_norm.bias" + ] = f"conformer_block_{layer_idx + 1:02d}_ln/bias" + +def _add_params_predictor_joiner(param_mapping: Dict[str, str]): + # add params of trafo lm + for layer_idx in range(1): + param_mapping.update( + { + f"predictor.layers.{layer_idx}.ff_weight": f"predictor.lstm_layers.{layer_idx}.weight_ih_l0", + + f"predictor.layers.{layer_idx}.rec_weight": f"predictor.lstm_layers.{layer_idx}.weight_hh_l0", + f"predictor.layers.{layer_idx}.bias": f"predictor.lstm_layers.{layer_idx}.bias_ih_l0", + } + ) + + param_mapping.update( + { + "predictor.embedding.weight": "predictor.embedding.weight", + "predictor.input_layer_norm.scale": "predictor.input_layer_norm.weight", + "predictor.input_layer_norm.bias": "predictor.input_layer_norm.bias", + "predictor.linear.weight": "predictor.linear.weight", + "predictor.linear.bias": "predictor.linear.bias", + "predictor.output_layer_norm.scale": "predictor.output_layer_norm.weight", + "predictor.output_layer_norm.bias": "predictor.output_layer_norm.bias", + # joiner + "joiner.linear.weight": "joiner.linear.weight", + "joiner.linear.bias": "joiner.linear.bias", + } + ) + + +def map_param_func( + ckpt, name: str, var: rf.Parameter, param_mapping: Dict[str, str] +) -> numpy.ndarray: + """map params, TF to RF""" + from i6_experiments.users.zeyer.returnn.convert.params import ( + numpy as convert_params_np, + ) + from i6_experiments.users.zeyer.returnn.convert.params import ( + tf_to_rf_np as convert_params_tf_to_rf_np, + ) + + assert isinstance(var, rf.Parameter) + + if name in param_mapping: + breakpoint() + var_name = param_mapping[name] + assert name in ckpt["model"].keys(), f"missing {var_name}" + value = ckpt["model"][name].numpy() + assert isinstance(value, numpy.ndarray) + + assert ( + value.shape == var.batch_shape + ), f"new param {name} {var.batch_shape} vs ckpt param {var_name} {value.shape}" + assert ( + value.dtype.name == var.dtype + ), f"new param {name} {var.dtype} vs ckpt param {var_name} {value.dtype}" + return value + + # if name == "s.ff_weight": + # value = reader.get_tensor("output/rec/s/rec/lstm_cell/kernel") + # value = convert_params_np.convert_tf_lstm_to_native_lstm_ff(value) + # assert value.shape == var.batch_shape, name + # assert value.dtype.name == var.dtype, name + # return value + # + # if name == "s.rec_weight": + # value = reader.get_tensor("output/rec/s/rec/lstm_cell/kernel") + # value = convert_params_np.convert_tf_lstm_to_native_lstm_rec(value) + # assert value.shape == var.batch_shape, name + # assert value.dtype.name == var.dtype, name + # return value + # + # if name == "s.bias": + # value = reader.get_tensor("output/rec/s/rec/lstm_cell/bias") + # value = convert_params_np.convert_tf_lstm_to_native_lstm_bias( + # value, forget_gate_bias=1.0 + # ) + # assert value.shape == var.batch_shape, name + # assert value.dtype.name == var.dtype, name + # return value + # + # if ".conv_block.norm." in name: + # assert name.startswith("encoder.layers.") + # layer_idx = int(name.split(".")[2]) + # value = convert_params_tf_to_rf_np.convert_tf_batch_norm_to_rf( + # reader=reader, + # rf_name=name, + # rf_prefix_name=f"encoder.layers.{layer_idx}.conv_block.norm.", + # tf_prefix_name=f"conformer_block_{layer_idx + 1:02d}_conv_mod_bn/batch_norm/", + # var=var, + # ) + # assert value.shape == var.batch_shape, name + # assert value.dtype.name == var.dtype, name + # return value + + raise NotImplementedError(f"cannot map {name!r} {var}") + + + +if __name__ == "__main__": + convert_checkpoint(ckpt_path=_nick_pure_torch_rnnt_ckpt_path, print_params=True, out_dir="", save_model=False) \ No newline at end of file diff --git a/users/gaudino/experiments/rf_conformer_rnnt_2024/librispeech_960/conformer_ctc_train.py b/users/gaudino/experiments/rf_conformer_rnnt_2024/librispeech_960/conformer_ctc_train.py index 66fe36592..29ff6ef1f 100644 --- a/users/gaudino/experiments/rf_conformer_rnnt_2024/librispeech_960/conformer_ctc_train.py +++ b/users/gaudino/experiments/rf_conformer_rnnt_2024/librispeech_960/conformer_ctc_train.py @@ -183,6 +183,46 @@ def sis_run_with_prefix(prefix_name: Optional[str] = None): }, ) + # no eos + train_exp( # dev-other + "base-24gb-lrlin1e_5_600k_ctc_only_no_eos", + config_24gb_v6, + config_updates={ + "learning_rate": 1.0, + "dynamic_learning_rate": dyn_lr_piecewise_linear, + # total steps after 2000 epochs: 982.312 + "learning_rate_piecewise_steps": [600_000, 900_000, 982_000], + "learning_rate_piecewise_values": [1e-5, 1e-3, 1e-5, 1e-6], + "aux_loss_layers":[], + "mel_normalization_ted2": False, + "hash_override": 1, + }, + search_config={ + "mel_normalization_ted2": False, + }, + with_eos_postfix=False, + ) + + train_exp( # dev-other + "base-24gb-lrlin1e_5_600k_ctc_only_aux4_8_no_eos", + config_24gb_v6, + config_updates={ + "learning_rate": 1.0, + "dynamic_learning_rate": dyn_lr_piecewise_linear, + # total steps after 2000 epochs: 982.312 + "learning_rate_piecewise_steps": [600_000, 900_000, 982_000], + "learning_rate_piecewise_values": [1e-5, 1e-3, 1e-5, 1e-6], + "mel_normalization_ted2": False, + "hash_override": 1, + }, + search_config = { + "mel_normalization_ted2": False, + }, + with_eos_postfix=False, + + ) + + _torch_ckpt_path = "/u/luca.gaudino/setups/2023-08-10--rf-librispeech/work/i6_core/returnn/training/ReturnnTrainingJob.AWwVft0oGy8e/output/models/epoch.1981.pt" new_ckpt_path = tk.Path( @@ -262,6 +302,7 @@ def train_exp( time_rqmt: Optional[int] = None, model_avg: bool = False, search_config: Optional[Dict[str, Any]] = None, + with_eos_postfix: bool = True, ) -> ModelWithCheckpoints: """ Train experiment @@ -275,7 +316,7 @@ def train_exp( _sis_setup_global_prefix() prefix = _sis_prefix + "/" + name - task = _get_ls_task() + task = _get_ls_task(with_eos_postfix=with_eos_postfix) config = config.copy() config = dict_update_deep(config, config_updates, config_deletes) if "__num_epochs" in config: @@ -362,7 +403,7 @@ def train_exp( _ls_task = None -def _get_ls_task(): +def _get_ls_task(with_eos_postfix=True): global _ls_task if _ls_task: return _ls_task @@ -371,7 +412,7 @@ def _get_ls_task(): get_librispeech_task_bpe10k_raw, ) - _ls_task = get_librispeech_task_bpe10k_raw(with_eos_postfix=True) + _ls_task = get_librispeech_task_bpe10k_raw(with_eos_postfix=with_eos_postfix) return _ls_task diff --git a/users/gaudino/experiments/rf_conformer_rnnt_2024/librispeech_960/conformer_rnnt_train.py b/users/gaudino/experiments/rf_conformer_rnnt_2024/librispeech_960/conformer_rnnt_train.py new file mode 100644 index 000000000..3ce450f69 --- /dev/null +++ b/users/gaudino/experiments/rf_conformer_rnnt_2024/librispeech_960/conformer_rnnt_train.py @@ -0,0 +1,336 @@ +"""Copied from Albert Zeyer 25.03.2024, then modified +""" + +from __future__ import annotations + +from typing import TYPE_CHECKING, Optional, Union, Tuple, Sequence, List, Collection +import tree +import math +import numpy as np +import torch +import hashlib +import contextlib +import functools +from sisyphus import tk + +from returnn.tensor import Tensor, Dim, single_step_dim +import returnn.frontend as rf +from returnn.frontend.tensor_array import TensorArray +from returnn.frontend.encoder.conformer import ConformerEncoder, ConformerConvSubsample + +from i6_experiments.users.gaudino.model_interfaces.supports_label_scorer_torch import ( + RFModelWithMakeLabelScorer, +) +from i6_experiments.users.gaudino.experiments.rf_conformer_att_2023.tedlium2.configs import * +from i6_experiments.users.gaudino.experiments.rf_conformer_att_2023.tedlium2.configs import ( + _batch_size_factor, + _cfg_lrlin1e_5_295k, + _get_cfg_lrlin_oclr_by_bs_nep, +) +from i6_experiments.users.gaudino.experiments.rf_conformer_att_2023.librispeech_960.trafo_lm import trafo_lm_kazuki_import + +if TYPE_CHECKING: + from i6_experiments.users.gaudino.model_interfaces import ModelDef, RecogDef, TrainDef + +from i6_experiments.users.gaudino.model_with_checkpoints import ( + ModelWithCheckpoints, + ModelWithCheckpoint, +) + +from i6_experiments.users.gaudino.models.asr.rf.conformer_rnnt.model_conformer_rnnt import from_scratch_model_def, from_scratch_training +from i6_experiments.users.gaudino.models.asr.rf.conformer_rnnt.model_recog_rnnt import model_recog + + +# The model gets raw features (16khz) and does feature extraction internally. +_log_mel_feature_dim = 80 + + +def sis_run_with_prefix(prefix_name: Optional[str] = None): + """run the exp""" + + from i6_core.returnn.training import PtCheckpoint + + _sis_setup_global_prefix(prefix_name) + + # Moh: dev-clean 2.27, dev-other 5.39, test-clean 2.41, test-other 5.51 + # RF recog: {"dev-clean": 2.25, "dev-other": 5.34, "test-clean": 2.42, "test-other": 5.56} + # _recog_imported() + + rnnt_train_config = dict( + batching="laplace:.1000", + batch_size=15_000 * _batch_size_factor, + max_seqs=200, + # max_seq_length_default_target=75, + # specaugment_steps=(10_000, 20_000, 40_000), + specaugment_steps=(5_900, 18_000, 36_000), + # gradient_clip=0, + # gradient_clip_global_norm = 1.0 + optimizer={ + "class": "adamw", + "epsilon": 1e-8, + "weight_decay": 1e-6, + }, + # accum_grad_multiple_step=4, + # gradient_noise=0.0, + learning_rate=2.5e-3, + dynamic_learning_rate=dyn_lr_piecewise_linear, + # learning_rate_piecewise_steps= [261_000, 522_000, 580_000], # 45% 45 % 10% # 11gb + learning_rate_piecewise_steps = [85_500, 171_000, 190_000], # 45% 45 % 10% # 24gb + # aux_loss_layers=[4, 8], + max_seq_length_default_target=None, + # gradient_clip_global_norm=5.0, + accum_grad_multiple_step=2, + # aux_loss_layers=[12], +) + + # train_exp("base-11gb", config_11gb, gpu_mem=11) + # train_exp("base-11gb-v1", my_config_11gb, num_epochs=400, gpu_mem=11) + + train_exp( + "from-scratch-24gb_aux4_8", + config_24gb_v6, + config_updates={ + "batch_size": 8_000 * _batch_size_factor, + "learning_rate": 1.0, + "dynamic_learning_rate": dyn_lr_piecewise_linear, + # total steps after 2000 epochs: 982.312 + "learning_rate_piecewise_steps": [600_000, 900_000, 982_000], + "learning_rate_piecewise_values": [1e-5, 1e-3, 1e-5, 1e-6], + "mel_normalization_ted2": False, + }, + config_deletes=["torch_amp"], + search_config={ + "mel_normalization_ted2": False, + }, + num_epochs=400, + gpu_mem=24, + ) + + + # some recog for debugging + _torch_ckpt_path = "/work/asr3/zeineldeen/hiwis/luca.gaudino/setups-data/2023-08-10--rf-librispeech/work/i6_core/returnn/training/ReturnnTrainingJob.J6Uj9xtt1v5J/output/models/epoch.003.pt" + + new_ckpt_path = tk.Path( + _torch_ckpt_path, + hash_overwrite= "rnnt" + "_torch_ckpt", + ) + new_ckpt = PtCheckpoint(new_ckpt_path) + + # _recog( + # "model_recogs/from-scratch-24gb/rnnt_beam_search/recog_results", + # ModelWithCheckpoint( + # definition=from_scratch_model_def, checkpoint=new_ckpt + # ), + # model_recog, + # dev_sets=["dev"] + # ) + + +_sis_prefix: Optional[str] = None + + +def _sis_setup_global_prefix(prefix_name: Optional[str] = None): + if not prefix_name: + from .sis_setup import get_prefix_for_config + + prefix_name = get_prefix_for_config(__file__) + global _sis_prefix + _sis_prefix = prefix_name + + +def _recog( + name: str, + model_with_checkpoint: ModelWithCheckpoint, + recog_def: RecogDef = None, + recog_config: Optional[Dict[str, Any]] = None, + *, + search_rqmt: Optional[Dict[str, Any]] = None, + dev_sets: Optional[Collection[str]] = None, +): + from sisyphus import tk + from i6_experiments.users.zeyer.recog import recog_model + + if recog_def is None: + recog_def = model_recog + + task = _get_ted2_task() + + res = recog_model( + task, + model_with_checkpoint, + recog_def=recog_def, + config=recog_config, + search_rqmt=search_rqmt, + dev_sets=dev_sets, + ) + tk.register_output(_sis_prefix + "/" + name, res.output) + + +# noinspection PyShadowingNames +def train_exp( + name: str, + config: Dict[str, Any], + *, + config_updates: Optional[Dict[str, Any]] = None, + config_deletes: Optional[Sequence[str]] = None, + post_config_updates: Optional[Dict[str, Any]] = None, + num_epochs: int = 2000, + gpu_mem: Optional[int] = 24, + num_processes: Optional[int] = None, + fine_tune: Optional[Union[int, List[Tuple[int, Dict[str, Any]]]]] = None, + time_rqmt: Optional[int] = None, + model_avg: bool = False, + search_config: Optional[Dict[str, Any]] = None, +) -> ModelWithCheckpoints: + """ + Train experiment + """ + from i6_experiments.users.gaudino.experiments.rf_conformer_att_2023.train import ( + train, + ) + from i6_experiments.users.zeyer.recog import recog_training_exp + + if _sis_prefix is None: + _sis_setup_global_prefix() + + prefix = _sis_prefix + "/" + name + task = _get_ls_task() + config = config.copy() + config = dict_update_deep(config, config_updates, config_deletes) + if "__num_epochs" in config: + num_epochs = config.pop("__num_epochs") + if "__gpu_mem" in config: + gpu_mem = config.pop("__gpu_mem") + if "__num_processes" in config: + num_processes = config.pop("__num_processes") + + model_with_checkpoint = train( + prefix, + task=task, + config=config, + post_config=dict_update_deep(post_config, post_config_updates), + model_def=from_scratch_model_def, + train_def=from_scratch_training, + num_epochs=num_epochs, + gpu_mem=gpu_mem, + num_processes=num_processes, + distributed_launch_cmd="torchrun" if num_processes else "mpirun", + time_rqmt=time_rqmt, + include_native_ops=True, + ) + recog_training_exp( + prefix, task, model_with_checkpoint, recog_def=model_recog, model_avg=model_avg, search_config=search_config + ) + + if fine_tune: + if isinstance(fine_tune, int): + fine_tune = [(fine_tune, {})] + for ep, opts in fine_tune: + assert isinstance(ep, int) and isinstance(opts, dict) + suffix = f"/finetune/{ep}" + opts = opts.copy() + if opts: + for k, v in sorted(opts.items()): + k: str + suffix += "-" + k.lstrip("_") + v = str(v).replace("-", "_") + if len(v) > 16 and not k.startswith("_"): + suffix += "_" + hashlib.md5(v.encode("utf8")).hexdigest()[:8] + else: + suffix += v + num_epochs_ = opts.pop("num_epochs", 50) + config_ = config.copy() + config_["import_model_train_epoch1"] = model_with_checkpoint.get_epoch( + ep + ).checkpoint + config_.pop("dynamic_learning_rate") + lrs = opts.pop("learning_rates", None) + if lrs is None: + lr_decay_type = opts.pop( + "lr_decay_type", "geomspace" + ) # geomspace or linspace + lr_decay_func = getattr(np, lr_decay_type) + lr = config_["learning_rate"] + final_lr = opts.pop("final_lr", 1e-7) + lrs = list(lr_decay_func(lr, final_lr, num=num_epochs_)) + else: + assert isinstance(lrs, (list, tuple)) + assert len(lrs) == num_epochs_ + config_["learning_rates"] = lrs + config_["learning_rate"] = float(lrs[-1]) + config_["specaugment_steps"] = (0, 0, 0) + config_.update({k: v for k, v in opts.items() if not k.startswith("_")}) + + finetune_model_with_ckpt = train( + prefix + suffix, + task=task, + config=config_, + post_config=post_config, + model_def=from_scratch_model_def, + train_def=from_scratch_training, + num_epochs=num_epochs_, + gpu_mem=gpu_mem, + ) + # _recog(name + suffix + "/recog/last", finetune_model_with_ckpt.get_last_fixed_epoch()) + recog_training_exp( + prefix + suffix, task, finetune_model_with_ckpt, recog_def=model_recog + ) + + return model_with_checkpoint + + +_ls_task = None +_ted2_task = None + + +def _get_ls_task(): + global _ls_task + if _ls_task: + return _ls_task + + from i6_experiments.users.zeyer.datasets.librispeech import ( + get_librispeech_task_bpe10k_raw, + ) + + _ls_task = get_librispeech_task_bpe10k_raw(with_eos_postfix=True) + return _ls_task + + +def _get_ted2_task(): + global _ted2_task + if _ted2_task: + return _ted2_task + + from i6_experiments.users.gaudino.datasets.tedlium2 import ( + get_tedlium2_task_bpe1k_raw, + ) + + _ted2_task = get_tedlium2_task_bpe1k_raw(with_eos_postfix=True, train_epoch_wise_filter=None) + return _ted2_task + + +py = sis_run_with_prefix # if run directly via `sis m ... + + +def model_warmup(*, model: Model, **_kwargs): + """warmup, for more reliable timing measures""" + import torch + import time + from returnn.config import get_global_config + from returnn.tensor import Dim + import returnn.frontend as rf + + config = get_global_config() + start_time = time.monotonic() + limit = start_time + config.float("model_warmup_time", 10.0) + + print("*** warming up...") + while time.monotonic() < limit: + batch_dim = Dim(10, name="dummy_batch") + time_dim = Dim(rf.full(dims=[batch_dim], fill_value=16_000), name="dummy_time") + feat_dim = Dim(1, name="dummy_feat") + source = rf.zeros([batch_dim, time_dim, feat_dim]) + res = model.encode(source=source, in_spatial_dim=time_dim) + if source.raw_tensor.device.type == "cuda": + torch.cuda.synchronize(source.raw_tensor.device) + res # noqa # keep ref to make sure it is calculated diff --git a/users/gaudino/experiments/rf_conformer_rnnt_2024/tedlium2/conformer_rnnt_train.py b/users/gaudino/experiments/rf_conformer_rnnt_2024/tedlium2/conformer_rnnt_train.py index d075dec27..f552ed0e4 100644 --- a/users/gaudino/experiments/rf_conformer_rnnt_2024/tedlium2/conformer_rnnt_train.py +++ b/users/gaudino/experiments/rf_conformer_rnnt_2024/tedlium2/conformer_rnnt_train.py @@ -56,7 +56,7 @@ def sis_run_with_prefix(prefix_name: Optional[str] = None): # RF recog: {"dev-clean": 2.25, "dev-other": 5.34, "test-clean": 2.42, "test-other": 5.56} # _recog_imported() - rnnt_train_config = dict( + rnnt_train_config_24gb = dict( batching="laplace:.1000", batch_size=15_000 * _batch_size_factor, max_seqs=200, @@ -86,16 +86,17 @@ def sis_run_with_prefix(prefix_name: Optional[str] = None): # train_exp("base-11gb", config_11gb, gpu_mem=11) # train_exp("base-11gb-v1", my_config_11gb, num_epochs=400, gpu_mem=11) - # train_exp( # TODO: runs in loss nan - # "from-scratch-24gb", - # rnnt_train_config, - # config_updates={ - # "learning_rate": 1.0, - # "learning_rate_piecewise_values": [8e-5, 8e-4, 8e-5, 1e-6], - # }, - # num_epochs=400, - # gpu_mem=24, - # ) + train_exp( # TODO: runs in loss nan + "from-scratch-24gb_norm_loss", + rnnt_train_config_24gb, + config_updates={ + "learning_rate": 1.0, + "learning_rate_piecewise_values": [8e-5, 8e-4, 8e-5, 1e-6], + "hash_override": 1, + }, + num_epochs=400, + gpu_mem=24, + ) _torch_ckpt_path = "/work/asr3/zeineldeen/hiwis/luca.gaudino/setups-data/2023-08-10--rf-librispeech/work/i6_core/returnn/training/ReturnnTrainingJob.J6Uj9xtt1v5J/output/models/epoch.003.pt" diff --git a/users/gaudino/models/asr/rf/conformer_rnnt/model_conformer_rnnt.py b/users/gaudino/models/asr/rf/conformer_rnnt/model_conformer_rnnt.py index 0bdac51aa..8198baeac 100644 --- a/users/gaudino/models/asr/rf/conformer_rnnt/model_conformer_rnnt.py +++ b/users/gaudino/models/asr/rf/conformer_rnnt/model_conformer_rnnt.py @@ -1,6 +1,15 @@ from __future__ import annotations -from typing import TYPE_CHECKING, Optional, Union, Tuple, Sequence, List, Collection, Dict +from typing import ( + TYPE_CHECKING, + Optional, + Union, + Tuple, + Sequence, + List, + Collection, + Dict, +) import tree import math import numpy as np @@ -145,6 +154,7 @@ def __init__( self.output_dim = output_dim self.embedding_dropout = emebdding_dropout self.lstm_dropout = lstm_dropout + self.num_lstm_layers = num_lstm_layers self.symbol_embedding_dim = Dim( name="symbol_embedding", dimension=symbol_embedding_dim @@ -159,7 +169,7 @@ def __init__( self.symbol_embedding_dim if idx == 0 else self.lstm_hidden_dim, self.lstm_hidden_dim, ) - for idx in range(num_lstm_layers) + for idx in range(self.num_lstm_layers) ) # self.lstm_layers = torch.nn.ModuleList( @@ -291,6 +301,7 @@ def __call__( # source_lengths: rf.Tensor, target_encodings: rf.Tensor, # target_lengths: rf.Tensor, + batch_dims: Sequence[Dim], ) -> Tuple[rf.Tensor, rf.Tensor, rf.Tensor]: r"""Forward pass for training. @@ -320,19 +331,21 @@ def __call__( number of valid elements along dim 2 for i-th batch element in joint network output. """ + time_axis = len(batch_dims) + joint_encodings_raw = ( - source_encodings.raw_tensor.unsqueeze(2).contiguous() - + target_encodings.raw_tensor.unsqueeze(1).contiguous() + source_encodings.raw_tensor.unsqueeze(time_axis + 1).contiguous() + + target_encodings.raw_tensor.unsqueeze(time_axis).contiguous() ) joint_encodings = rf.Tensor( name="joint_encodings", raw_tensor=joint_encodings_raw, - dims=[ - source_encodings.dims[0], - source_encodings.dims[1], - target_encodings.dims[1], - source_encodings.dims[2], + dims=batch_dims + + [ + source_encodings.dims[time_axis], # T + target_encodings.dims[time_axis], # U + source_encodings.dims[-1], # F ], dtype=source_encodings.dtype, ) @@ -372,7 +385,6 @@ def __init__( enc_att_dropout: float = 0.1, l2: float = 0.0001, language_model: Optional[RFModelWithMakeLabelScorer] = None, - mel_normalization: bool = True, joiner_dim: int = 640, ): super(Model, self).__init__() @@ -381,7 +393,7 @@ def __init__( config = get_global_config(return_empty_if_none=True) - self.mel_normalization = mel_normalization + self.mel_normalization = config.typed_value("mel_normalization_ted2", True) self.in_dim = in_dim self.encoder = ConformerEncoder( @@ -603,12 +615,13 @@ def loop_step( state: Optional[rf.State] = None, ) -> Tuple[Dict[str, rf.Tensor], rf.State]: """step of the inner loop""" + batch_dims = enc.remaining_dims( + remove=(enc.feature_dim, enc_spatial_dim) + if enc_spatial_dim != single_step_dim + else (enc.feature_dim,) + ) + if state is None: - batch_dims = enc.remaining_dims( - remove=(enc.feature_dim, enc_spatial_dim) - if enc_spatial_dim != single_step_dim - else (enc.feature_dim,) - ) state = self.decoder_default_initial_state( batch_dims=batch_dims, enc_spatial_dim=enc_spatial_dim ) @@ -619,9 +632,9 @@ def loop_step( target, state.predictor, spatial_dim=target_spatial_dim ) - pred_out = pred_lstm.copy_swap_axes(0,1) + pred_out = pred_lstm.copy_swap_axes(0, 1) - joiner = self.joiner(enc_lin, pred_out) + joiner = self.joiner(enc_lin, pred_out, batch_dims=batch_dims) return {"output": joiner}, state_ @@ -746,12 +759,26 @@ def from_scratch_training( targets_mod = targets.copy() targets_mod.sparse_dim = model.target_dim_w_blank - blanks = rf.expand_dim(rf.full(dims=targets_mod.dims[:-1], fill_value=model.blank_idx, dtype=targets_mod.dtype), Dim(1)) + blanks = rf.expand_dim( + rf.full( + dims=targets_mod.dims[:-1], + fill_value=model.blank_idx, + dtype=targets_mod.dtype, + ), + Dim(1), + ) blanks.sparse_dim = model.target_dim_w_blank - targets_mod, targets_spatial_dim = rf.concat((blanks, blanks.dims[1]), (targets_mod, targets.dims[1])) + targets_mod, targets_spatial_dim = rf.concat( + (blanks, blanks.dims[1]), (targets_mod, targets.dims[1]) + ) - step_out, _ = model.loop_step(**enc_args, enc_spatial_dim=enc_spatial_dim, target=targets_mod, target_spatial_dim=targets_spatial_dim) + step_out, _ = model.loop_step( + **enc_args, + enc_spatial_dim=enc_spatial_dim, + target=targets_mod, + target_spatial_dim=targets_spatial_dim, + ) logits = step_out["output"] @@ -783,10 +810,10 @@ def from_scratch_training( dtype=logprobs.dtype, ) - num_phonemes = rf.reduce_sum(labels_len, axis=labels_len.dims[0]) - rnnt_loss.mark_as_loss( - name="rnnt", custom_inv_norm_factor=num_phonemes + name="rnnt", + custom_inv_norm_factor=targets_spatial_dim.get_size_tensor(), + use_normalized_loss=use_normalized_loss, ) # def _body(input_embed: Tensor, state: rf.State): @@ -842,6 +869,7 @@ def from_scratch_training( from_scratch_training: TrainDef[Model] from_scratch_training.learning_rate_control_error_measure = "dev_score_full_sum" + @contextlib.contextmanager def _opt_apply_pretrain_to_encoder( encoder: ConformerEncoder, diff --git a/users/gaudino/models/asr/rf/conformer_rnnt/model_recog_rnnt.py b/users/gaudino/models/asr/rf/conformer_rnnt/model_recog_rnnt.py index e47145a67..7c512166f 100644 --- a/users/gaudino/models/asr/rf/conformer_rnnt/model_recog_rnnt.py +++ b/users/gaudino/models/asr/rf/conformer_rnnt/model_recog_rnnt.py @@ -51,28 +51,13 @@ def _get_hypo_key(hypo: Hypothesis) -> str: return str(hypo[0]) -def _batch_state(hypos: List[Hypothesis]) -> List[List[torch.Tensor]]: # TODO - states: List[List[torch.Tensor]] = [] - for i in range(len(_get_hypo_state(hypos[0]))): - batched_state_components: List[torch.Tensor] = [] - for j in range(len(_get_hypo_state(hypos[0])[i])): - batched_state_components.append(torch.cat([_get_hypo_state(hypo)[i][j] for hypo in hypos])) - states.append(batched_state_components) - return states - - -def _slice_state(states: List[List[torch.Tensor]], idx: int, device: torch.device) -> List[List[torch.Tensor]]: # TODO - idx_tensor = torch.tensor([idx], device=device) - return [[state.index_select(0, idx_tensor) for state in state_tuple] for state_tuple in states] - - def _default_hypo_sort_key(hypo: Hypothesis) -> float: return _get_hypo_score(hypo) / (len(_get_hypo_tokens(hypo)) + 1) # is this doing length normalization ? def _compute_updated_scores( hypos: List[Hypothesis], - next_token_probs: Tensor, + next_token_probs: torch.Tensor, beam_width: int, ) -> Tuple[Tensor, Tensor, Tensor]: # TODO hypo_scores = torch.tensor([_get_hypo_score(h) for h in hypos]).unsqueeze(1) @@ -135,24 +120,61 @@ def model_recog( ended = rf.constant(False, dims=batch_dims_) out_seq_len = rf.constant(0, dims=batch_dims_) seq_log_prob = rf.constant(0.0, dims=batch_dims_) + batch_dim = batch_dims[0] + batch_size = batch_dim.get_dim_value() blank_idx = model.target_dim.get_dim_value() - enc_out = enc_args["enc"] + enc_out = model.encoder_out_linear(enc_args["enc"]) # TODO implement rnnt search temperature = 1.0 step_max_tokens = 100 + def _batch_state(hypos: List[Hypothesis], beam_dim: Dim) -> List[List[torch.Tensor]]: # TODO + + accum_state = rf.State() + # might be improved by not hardcoding lstm predictor + for i in range(model.predictor.num_lstm_layers): + state_h_arr = TensorArray(_get_hypo_state(hypos[0])[str(i)]["h"]) + state_c_arr = TensorArray(_get_hypo_state(hypos[0])[str(i)]["c"]) + for hypo in hypos: + state_h_arr = state_h_arr.push_back(_get_hypo_state(hypo)[str(i)]["h"]) + state_c_arr = state_c_arr.push_back(_get_hypo_state(hypo)[str(i)]["c"]) + state_lay_i = rf.State() + state_lay_i["h"] = state_h_arr.stack(axis=beam_dim) + state_lay_i["c"] = state_c_arr.stack(axis=beam_dim) + accum_state[str(i)] = state_lay_i + + return accum_state + + # states: List[List[torch.Tensor]] = [] + # for i in range(len(_get_hypo_state(hypos[0]))): + # batched_state_components: List[torch.Tensor] = [] + # for j in range(len(_get_hypo_state(hypos[0])[i])): + # batched_state_components.append(torch.cat([_get_hypo_state(hypo)[i][j] for hypo in hypos])) + # states.append(batched_state_components) + # return states + + def _slice_state(states: List[List[torch.Tensor]], idx: int, beam_dim: Dim, device: torch.device) -> List[ + List[torch.Tensor]]: # TODO + sliced_state = rf.State() + for i in range(model.predictor.num_lstm_layers): + sliced_state[str(i)] = rf.State() + sliced_state[str(i)]["h"] = rf.gather(states[str(i)]["h"], indices=idx, axis=beam_dim) + sliced_state[str(i)]["c"] = rf.gather(states[str(i)]["c"], indices=idx, axis=beam_dim) + return sliced_state + # return [[state.index_select(0, idx_tensor) for state in state_tuple] for state_tuple in states] + def _init_b_hypos(device: torch.device) -> List[Hypothesis]: token = blank_idx decoder_state = model.decoder_default_initial_state( - batch_dims=batch_dims_, enc_spatial_dim=enc_spatial_dim + batch_dims=[], enc_spatial_dim=enc_spatial_dim ) - blank_tensor = rf.constant(blank_idx, dims=Dim(1), sparse_dim=model.target_dim_w_blank) - pred_out, _, pred_state = model.predictor(blank_tensor, decoder_state.predictor) + blank_tensor = rf.constant(blank_idx, dims=[], sparse_dim=model.target_dim_w_blank) + pred_out, pred_state = model.predictor(blank_tensor, decoder_state.predictor) init_hypo = ( [token], pred_out, # pred_out[0].detach(), TODO: what is this doing? @@ -164,16 +186,28 @@ def _init_b_hypos(device: torch.device) -> List[Hypothesis]: def _gen_next_token_probs( enc_out: Tensor, hypos: List[Hypothesis], device: torch.device ) -> torch.Tensor: - one_tensor = torch.tensor([1], device=device) - predictor_out = torch.stack([_get_hypo_predictor_out(h) for h in hypos], dim=0) - joined_out, _, _ = model.join( + pred_out_template = _get_hypo_predictor_out(hypos[0]) + state_arr = TensorArray(pred_out_template) + for hypo in hypos: + state_arr = state_arr.push_back(_get_hypo_predictor_out(hypo)) + + step_beam_dim = Dim(len(hypos), name="beam") + step_u_dim = Dim(1, name="u") + predictor_out = state_arr.stack(axis=step_beam_dim) + predictor_out = rf.expand_dim(predictor_out, dim=step_u_dim) + enc_out = rf.expand_dim(enc_out, dim=step_beam_dim) + enc_out = rf.expand_dim(enc_out, dim=single_step_dim) + + joined_out = model.joiner( enc_out, - one_tensor, predictor_out, - torch.tensor([1] * len(hypos), device=device), - ) # [beam_width, 1, 1, num_tokens] - joined_out = torch.nn.functional.log_softmax(joined_out / temperature, dim=3) - return joined_out[:, 0, 0] + batch_dims=[step_beam_dim], + ) # [beam_width,1, 1, num_tokens] + joined_out = rf.log_softmax(joined_out / temperature, axis=model.target_dim_w_blank) + joined_out = rf.squeeze(joined_out, axis=single_step_dim) + joined_out = rf.squeeze(joined_out, axis=step_u_dim) + + return joined_out def _gen_b_hypos( b_hypos: List[Hypothesis], @@ -245,147 +279,114 @@ def _gen_new_hypos( t: int, device: torch.device, ) -> List[Hypothesis]: - tgt_tokens = torch.tensor([[token] for token in tokens], device=device) - states = _batch_state(base_hypos) - pred_out, _, pred_states = model.predict( + beam_dim=Dim(len(base_hypos), name="beam") + tgt_tokens_raw = torch.tensor(tokens, device=device) + tgt_tokens = rf.Tensor( + name="tgt_tokens", + dims=[beam_dim], + raw_tensor=tgt_tokens_raw, + sparse_dim=model.target_dim_w_blank, + dtype="int64", + ) + + states = _batch_state(base_hypos, beam_dim) + pred_out, pred_state = model.predictor( tgt_tokens, - torch.tensor([1] * len(base_hypos), device=device), states, ) new_hypos: List[Hypothesis] = [] for i, h_a in enumerate(base_hypos): new_tokens = _get_hypo_tokens(h_a) + [tokens[i]] - new_hypos.append((new_tokens, pred_out[i].detach(), _slice_state(pred_states, i, device), scores[i])) + new_hypos.append((new_tokens, rf.gather(pred_out, indices=i, axis=beam_dim), _slice_state(pred_state, i, beam_dim, device), scores[i])) # detach? return new_hypos - # TODO: call for every seq - # for enc_out in enc_out_batched: - - # from _search function - n_time_steps = enc_out.get_dim(1) device = enc_out.device + beam_width = beam_size - breakpoint() - a_hypos: List[Hypothesis] = [] - b_hypos = _init_b_hypos(device) # used for streaming: if hypo is None else hypo - for t in range(n_time_steps): - a_hypos = b_hypos - b_hypos = torch.jit.annotate(List[Hypothesis], []) - key_to_b_hypo: Dict[str, Hypothesis] = {} - symbols_current_t = 0 - - while a_hypos: - next_token_probs = _gen_next_token_probs(enc_out[:, t: t + 1], a_hypos, device) - next_token_probs = next_token_probs.cpu() - b_hypos = _gen_b_hypos(b_hypos, a_hypos, next_token_probs, key_to_b_hypo) - - if symbols_current_t == step_max_tokens: - break - - a_hypos = _gen_a_hypos( - a_hypos, - b_hypos, - next_token_probs, - t, - beam_width, - device, - ) - if a_hypos: - symbols_current_t += 1 - _, sorted_idx = torch.tensor([hypo_sort_key(hyp) for hyp in b_hypos]).topk(beam_width) - b_hypos = [b_hypos[idx] for idx in sorted_idx] + seq_log_scores_raw = torch.full((batch_size, beam_width), fill_value= 1e-30, device=device) + seq_targets_raw = [[[] for _ in range(beam_width)] for _ in range(batch_size)] - # return b_hypos - # results is in b_hypoes - # TODO: extract results + # non-batched search + for i in range(batch_size): + enc_out_i = rf.gather(enc_out, indices=i, axis=batch_dim) - return seq_targets, seq_log_prob, out_spatial_dim, beam_dim + # from _search function + n_time_steps = enc_out_i.get_dim(0) - # old search code - i = 0 - seq_targets = [] - seq_backrefs = [] - while True: - # if i == 0: - # input_embed = rf.zeros( - # batch_dims_ + [model.target_embed.out_dim], - # feature_dim=model.target_embed.out_dim, - # ) - # else: - # input_embed = model.target_embed(target) - step_out, decoder_state = model.loop_step( - **enc_args, - enc_spatial_dim=enc_spatial_dim, - input_embed=target, - state=decoder_state, - ) - # logits = model.decode_logits(input_embed=input_embed, **step_out) - label_log_prob = rf.log_softmax(step_out["output"], axis=model.target_dim) - - # Filter out finished beams - label_log_prob = rf.where( - ended, - rf.sparse_to_dense( - model.eos_idx, - axis=model.target_dim, - label_value=0.0, - other_value=-1.0e30, - ), - label_log_prob, - ) - seq_log_prob = seq_log_prob + label_log_prob # Batch, InBeam, Vocab - seq_log_prob, (backrefs, target), beam_dim = rf.top_k( - seq_log_prob, - k_dim=Dim(beam_size, name=f"dec-step{i}-beam"), - axis=[beam_dim, model.target_dim], - ) # seq_log_prob, backrefs, target: Batch, Beam - seq_targets.append(target) - seq_backrefs.append(backrefs) - decoder_state = tree.map_structure( - lambda s: rf.gather(s, indices=backrefs), decoder_state - ) - ended = rf.gather(ended, indices=backrefs) - out_seq_len = rf.gather(out_seq_len, indices=backrefs) - i += 1 + a_hypos: List[Hypothesis] = [] + b_hypos = _init_b_hypos(device) # used for streaming: if hypo is None else hypo + for t in range(n_time_steps): + a_hypos = b_hypos + b_hypos = torch.jit.annotate(List[Hypothesis], []) + key_to_b_hypo: Dict[str, Hypothesis] = {} + symbols_current_t = 0 - ended = rf.logical_or(ended, target == model.eos_idx) - ended = rf.logical_or(ended, rf.copy_to_device(i >= max_seq_len)) - if bool(rf.reduce_all(ended, axis=ended.dims).raw_tensor): - break - out_seq_len = out_seq_len + rf.where(ended, 0, 1) - - if i > 1 and length_normalization_exponent != 0: - # Length-normalized scores, so we evaluate score_t/len. - # If seq ended, score_i/i == score_{i-1}/(i-1), thus score_i = score_{i-1}*(i/(i-1)) - # Because we count with EOS symbol, shifted by one. - seq_log_prob *= rf.where( - ended, - (i / (i - 1)) ** length_normalization_exponent, - 1.0, - ) + while a_hypos: + next_token_probs = _gen_next_token_probs(rf.gather(enc_out_i, indices=t, axis=enc_out_i.dims[0]), a_hypos, device) + next_token_probs = rf.copy_to_device(next_token_probs, "cpu") + b_hypos = _gen_b_hypos(b_hypos, a_hypos, next_token_probs.raw_tensor, key_to_b_hypo) - if i > 0 and length_normalization_exponent != 0: - seq_log_prob *= (1 / i) ** length_normalization_exponent + if symbols_current_t == step_max_tokens: + break - # Backtrack via backrefs, resolve beams. - seq_targets_ = [] - indices = rf.range_over_dim(beam_dim) # FinalBeam -> FinalBeam - for backrefs, target in zip(seq_backrefs[::-1], seq_targets[::-1]): - # indices: FinalBeam -> Beam - # backrefs: Beam -> PrevBeam - seq_targets_.insert(0, rf.gather(target, indices=indices)) - indices = rf.gather(backrefs, indices=indices) # FinalBeam -> PrevBeam + a_hypos = _gen_a_hypos( + a_hypos, + b_hypos, + next_token_probs.raw_tensor, + t, + beam_width, + device, + ) + if a_hypos: + symbols_current_t += 1 + + _, sorted_idx = torch.tensor([_default_hypo_sort_key(hyp) for hyp in b_hypos]).topk(beam_width) + b_hypos = [b_hypos[idx] for idx in sorted_idx] - seq_targets__ = TensorArray(seq_targets_[0]) - for target in seq_targets_: - seq_targets__ = seq_targets__.push_back(target) - out_spatial_dim = Dim(out_seq_len, name="out-spatial") - seq_targets = seq_targets__.stack(axis=out_spatial_dim) + seq_log_scores_raw[i] = torch.tensor([_get_hypo_score(hypo) for hypo in b_hypos]) + for j, hypo in enumerate(b_hypos): + seq_targets_raw[i][j] = _get_hypo_tokens(hypo) + + # pad targets to max length + # how to create a dynamic tensor? + lens = [] + for i in range(batch_size): + for j in range(beam_width): + lens.append(len(seq_targets_raw[i][j])-1) + max_hyp_len = max(lens) # first blank token will be removed + + seq_targets_raw_padded = torch.full((batch_size, beam_width, max_hyp_len), fill_value=model.eos_idx, device=device) + for i in range(batch_size): + for j in range(beam_width): + seq_targets_raw_padded[i, j, :len(seq_targets_raw[i][j])-1] = torch.tensor(seq_targets_raw[i][j][1:]) # remove first blank token + + out_spatial_dim = Dim(max_hyp_len, name="out-spatial") + beam_dim = Dim(beam_width, name="beam") + out_spatial_dim.dyn_size_ext = rf.Tensor( + name="out_seq_lens", + dims=[batch_dim, beam_dim], + raw_tensor=torch.tensor(lens, dtype=torch.int32).view(batch_size, beam_width), + dtype="int32", + ) + + seq_targets = rf.Tensor( + name="seq_targets", + dims=[batch_dim, beam_dim, out_spatial_dim], + raw_tensor=seq_targets_raw_padded, + dtype="int64", + sparse_dim=model.target_dim, + ) + + seq_log_prob = rf.Tensor( + name="seq_log_prob", + dims=[batch_dim, beam_dim], + raw_tensor=seq_log_scores_raw, + dtype="float32", + ) return seq_targets, seq_log_prob, out_spatial_dim, beam_dim - # RecogDef API model_recog: RecogDef[Model] model_recog.output_with_beam = True @@ -399,78 +400,78 @@ def _gen_new_hypos( ### Copied from torchaudio # TODO: Adapt to rf -from typing import Callable, Dict, List, Optional, Tuple - -import torch -from torchaudio.models import RNNT - - -__all__ = ["Hypothesis", "RNNTBeamSearch"] - - -Hypothesis = Tuple[List[int], torch.Tensor, List[List[torch.Tensor]], float] -Hypothesis.__doc__ = """Hypothesis generated by RNN-T beam search decoder, - represented as tuple of (tokens, prediction network output, prediction network state, score). - """ - - -def _get_hypo_tokens(hypo: Hypothesis) -> List[int]: - return hypo[0] - - -def _get_hypo_predictor_out(hypo: Hypothesis) -> torch.Tensor: - return hypo[1] - - -def _get_hypo_state(hypo: Hypothesis) -> List[List[torch.Tensor]]: - return hypo[2] - - -def _get_hypo_score(hypo: Hypothesis) -> float: - return hypo[3] - - -def _get_hypo_key(hypo: Hypothesis) -> str: - return str(hypo[0]) - - -def _batch_state(hypos: List[Hypothesis]) -> List[List[torch.Tensor]]: - states: List[List[torch.Tensor]] = [] - for i in range(len(_get_hypo_state(hypos[0]))): - batched_state_components: List[torch.Tensor] = [] - for j in range(len(_get_hypo_state(hypos[0])[i])): - batched_state_components.append(torch.cat([_get_hypo_state(hypo)[i][j] for hypo in hypos])) - states.append(batched_state_components) - return states - - -def _slice_state(states: List[List[torch.Tensor]], idx: int, device: torch.device) -> List[List[torch.Tensor]]: - idx_tensor = torch.tensor([idx], device=device) - return [[state.index_select(0, idx_tensor) for state in state_tuple] for state_tuple in states] - - -def _default_hypo_sort_key(hypo: Hypothesis) -> float: - return _get_hypo_score(hypo) / (len(_get_hypo_tokens(hypo)) + 1) - - -def _compute_updated_scores( - hypos: List[Hypothesis], - next_token_probs: torch.Tensor, - beam_width: int, -) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]: - hypo_scores = torch.tensor([_get_hypo_score(h) for h in hypos]).unsqueeze(1) - nonblank_scores = hypo_scores + next_token_probs[:, :-1] # [beam_width, num_tokens - 1] - nonblank_nbest_scores, nonblank_nbest_idx = nonblank_scores.reshape(-1).topk(beam_width) - nonblank_nbest_hypo_idx = nonblank_nbest_idx.div(nonblank_scores.shape[1], rounding_mode="trunc") - nonblank_nbest_token = nonblank_nbest_idx % nonblank_scores.shape[1] - return nonblank_nbest_scores, nonblank_nbest_hypo_idx, nonblank_nbest_token - - -def _remove_hypo(hypo: Hypothesis, hypo_list: List[Hypothesis]) -> None: - for i, elem in enumerate(hypo_list): - if _get_hypo_key(hypo) == _get_hypo_key(elem): - del hypo_list[i] - break +# from typing import Callable, Dict, List, Optional, Tuple +# +# import torch +# from torchaudio.models import RNNT +# +# +# __all__ = ["Hypothesis", "RNNTBeamSearch"] +# +# +# Hypothesis = Tuple[List[int], torch.Tensor, List[List[torch.Tensor]], float] +# Hypothesis.__doc__ = """Hypothesis generated by RNN-T beam search decoder, +# represented as tuple of (tokens, prediction network output, prediction network state, score). +# """ +# +# +# def _get_hypo_tokens(hypo: Hypothesis) -> List[int]: +# return hypo[0] +# +# +# def _get_hypo_predictor_out(hypo: Hypothesis) -> torch.Tensor: +# return hypo[1] +# +# +# def _get_hypo_state(hypo: Hypothesis) -> List[List[torch.Tensor]]: +# return hypo[2] +# +# +# def _get_hypo_score(hypo: Hypothesis) -> float: +# return hypo[3] +# +# +# def _get_hypo_key(hypo: Hypothesis) -> str: +# return str(hypo[0]) +# +# +# def _batch_state(hypos: List[Hypothesis]) -> List[List[torch.Tensor]]: +# states: List[List[torch.Tensor]] = [] +# for i in range(len(_get_hypo_state(hypos[0]))): +# batched_state_components: List[torch.Tensor] = [] +# for j in range(len(_get_hypo_state(hypos[0])[i])): +# batched_state_components.append(torch.cat([_get_hypo_state(hypo)[i][j] for hypo in hypos])) +# states.append(batched_state_components) +# return states +# +# +# def _slice_state(states: List[List[torch.Tensor]], idx: int, device: torch.device) -> List[List[torch.Tensor]]: +# idx_tensor = torch.tensor([idx], device=device) +# return [[state.index_select(0, idx_tensor) for state in state_tuple] for state_tuple in states] +# +# +# def _default_hypo_sort_key(hypo: Hypothesis) -> float: +# return _get_hypo_score(hypo) / (len(_get_hypo_tokens(hypo)) + 1) +# +# +# def _compute_updated_scores( +# hypos: List[Hypothesis], +# next_token_probs: torch.Tensor, +# beam_width: int, +# ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]: +# hypo_scores = torch.tensor([_get_hypo_score(h) for h in hypos]).unsqueeze(1) +# nonblank_scores = hypo_scores + next_token_probs[:, :-1] # [beam_width, num_tokens - 1] +# nonblank_nbest_scores, nonblank_nbest_idx = nonblank_scores.reshape(-1).topk(beam_width) +# nonblank_nbest_hypo_idx = nonblank_nbest_idx.div(nonblank_scores.shape[1], rounding_mode="trunc") +# nonblank_nbest_token = nonblank_nbest_idx % nonblank_scores.shape[1] +# return nonblank_nbest_scores, nonblank_nbest_hypo_idx, nonblank_nbest_token +# +# +# def _remove_hypo(hypo: Hypothesis, hypo_list: List[Hypothesis]) -> None: +# for i, elem in enumerate(hypo_list): +# if _get_hypo_key(hypo) == _get_hypo_key(elem): +# del hypo_list[i] +# break class RNNTBeamSearch(torch.nn.Module): From 00219c564f91d73111e91eebbe36e518e5844ac7 Mon Sep 17 00:00:00 2001 From: Simon Berger Date: Thu, 13 Jun 2024 16:21:09 +0200 Subject: [PATCH 165/227] Update users/berger --- .../__init__.py | 2 + .../config_02b_transducer_wei_data.py | 301 +++++++++----- ...config_02c_transducer_wei_data_tinaconf.py | 56 ++- ...onfig_02d_transducer_wei_data_am_scales.py | 379 ++++++++++++++++++ .../config_03b_transducer_fullsum_wei_data.py | 28 +- users/berger/corpus/switchboard/lm_data.py | 10 +- 6 files changed, 650 insertions(+), 126 deletions(-) create mode 100644 users/berger/configs/switchboard/20240202_phoneme_transducer_pipeline/config_02d_transducer_wei_data_am_scales.py diff --git a/users/berger/configs/switchboard/20240202_phoneme_transducer_pipeline/__init__.py b/users/berger/configs/switchboard/20240202_phoneme_transducer_pipeline/__init__.py index 4715643f8..4a6c7734c 100644 --- a/users/berger/configs/switchboard/20240202_phoneme_transducer_pipeline/__init__.py +++ b/users/berger/configs/switchboard/20240202_phoneme_transducer_pipeline/__init__.py @@ -9,6 +9,7 @@ from .config_01c_ctc_blstm_wei_data import py as py_01c from .config_02b_transducer_wei_data import py as py_02b from .config_02c_transducer_wei_data_tinaconf import py as py_02c +from .config_02d_transducer_wei_data_am_scales import py as py_02d from .config_03b_transducer_fullsum_wei_data import py as py_03b @@ -21,6 +22,7 @@ def main() -> SummaryReport: py_01c()[0], py_02b()[0], py_02c()[0], + py_02d()[0], py_03b(), ]: subreport = copy.deepcopy(subreport) diff --git a/users/berger/configs/switchboard/20240202_phoneme_transducer_pipeline/config_02b_transducer_wei_data.py b/users/berger/configs/switchboard/20240202_phoneme_transducer_pipeline/config_02b_transducer_wei_data.py index 9ec52b39d..d90590e69 100644 --- a/users/berger/configs/switchboard/20240202_phoneme_transducer_pipeline/config_02b_transducer_wei_data.py +++ b/users/berger/configs/switchboard/20240202_phoneme_transducer_pipeline/config_02b_transducer_wei_data.py @@ -180,7 +180,9 @@ def generate_returnn_config( return returnn_config -def run_exp(alignments: Dict[str, AlignmentData], name_suffix: str = "") -> Tuple[SummaryReport, Checkpoint]: +def run_exp( + alignments: Dict[str, AlignmentData], name_suffix: str = "" +) -> Tuple[SummaryReport, Checkpoint]: assert tools.returnn_root is not None assert tools.returnn_python_exe is not None assert tools.rasr_binary_path is not None @@ -306,134 +308,225 @@ def run_exp(alignments: Dict[str, AlignmentData], name_suffix: str = "") -> Tupl train_data_config=data.train_data_config, dev_data_config=data.cv_data_config, ) - for ilm_scale in [0.0, 0.2] + for ilm_scale in [0.0, 0.1, 0.15, 0.2, 0.25, 0.3] }, ), ) system.run_train_step(**train_args) - system.run_dev_recog_step(**recog_args) - recog_args.update( - { - "lm_scales": [0.6, 0.7], - "epochs": [ - 213, - 249, - 261, - 279, - 283, - 283, - 284, - 285, - 286, - 289, - 291, - 297, - 298, - 299, - 300, + if False: + recog_args.update( + { + "lm_scales": [0.6, 0.7], + "epochs": [ + 213, + 249, + 261, + 279, + 283, + 283, + 284, + 285, + 286, + 289, + 291, + 297, + 298, + 299, + 300, + ], + } + ) + system.run_dev_recog_step( + exp_names=[ + f"Conformer_Transducer_Viterbi_wei-data_{name_suffix}_lr-0.0008" ], - } - ) + recog_exp_names=["recog_ilm-0.1", "recog_ilm-0.2"], + **recog_args, + ) + + recog_args.update({"lm_scales": [0.6], "epochs": [298]}) system.run_dev_recog_step( exp_names=[f"Conformer_Transducer_Viterbi_wei-data_{name_suffix}_lr-0.0008"], - recog_exp_names=["recog_ilm-0.1", "recog_ilm-0.2"], + recog_exp_names=["recog_ilm-0.2"], **recog_args, ) - recog_args.update( - { - "epochs": [ - 213, - 249, - 261, - 267, - 273, - 276, - 279, - 280, - 281, - 282, - 283, - 284, - 285, - 286, - 289, - 291, - 298, - 298, - 299, - 300, - ] - } - ) + if False: + recog_args.update( + { + "epochs": [ + 213, + 249, + 261, + 267, + 273, + 276, + 279, + 280, + 281, + 282, + 283, + 284, + 285, + 286, + 289, + 291, + 298, + 298, + 299, + 300, + ] + } + ) + system.run_dev_recog_step( + exp_names=[ + f"Conformer_Transducer_Viterbi_wei-data_{name_suffix}_lr-0.0008_loss-boost" + ], + recog_exp_names=["recog_ilm-0.1", "recog_ilm-0.2"], + **recog_args, + ) + + recog_args.update({"epochs": [300], "lm_scales": [0.7]}) system.run_dev_recog_step( - exp_names=[f"Conformer_Transducer_Viterbi_wei-data_{name_suffix}_lr-0.0008_loss-boost"], - recog_exp_names=["recog_ilm-0.1", "recog_ilm-0.2"], + exp_names=[ + f"Conformer_Transducer_Viterbi_wei-data_{name_suffix}_lr-0.0008_loss-boost" + ], + recog_exp_names=["recog_ilm-0.1"], **recog_args, ) - recog_args.update( - { - "epochs": [ - 213, - 249, - 261, - 267, - 273, - 279, - 284, - 285, - 289, - 291, - 297, - 298, - 299, - 300, - ] - } - ) + if False: + recog_args.update( + { + "epochs": [ + 213, + 249, + 261, + 267, + 273, + 279, + 284, + 285, + 289, + 291, + 297, + 298, + 299, + 300, + ] + } + ) + system.run_dev_recog_step( + exp_names=[ + f"Conformer_Transducer_Viterbi_wei-data_{name_suffix}_lr-0.0008_ls-0.2" + ], + recog_exp_names=["recog_ilm-0.1", "recog_ilm-0.2"], + **recog_args, + ) + + recog_args.update({"epochs": [300], "lm_scales": [0.4]}) system.run_dev_recog_step( - exp_names=[f"Conformer_Transducer_Viterbi_wei-data_{name_suffix}_lr-0.0008_ls-0.2"], - recog_exp_names=["recog_ilm-0.1", "recog_ilm-0.2"], + exp_names=[ + f"Conformer_Transducer_Viterbi_wei-data_{name_suffix}_lr-0.0008_ls-0.2" + ], + recog_exp_names=["recog_ilm-0.1"], **recog_args, ) - recog_args.update( - { - "epochs": [ - 213, - 249, - 261, - 267, - 273, - 274, - 279, - 280, - 281, - 282, - 283, - 284, - 285, - 286, - 289, - 291, - 297, - 298, - 299, - 300, - ] - } + if False: + recog_args.update( + { + "epochs": [ + 213, + 249, + 261, + 267, + 273, + 274, + 279, + 280, + 281, + 282, + 283, + 284, + 285, + 286, + 289, + 291, + 297, + 298, + 299, + 300, + ] + } + ) + system.run_dev_recog_step( + exp_names=[ + f"Conformer_Transducer_Viterbi_wei-data_{name_suffix}_lr-0.0008_ls-0.2_loss-boost" + ], + recog_exp_names=["recog_ilm-0.1", "recog_ilm-0.2"], + **recog_args, + ) + + recog_args.update({"epochs": [291], "lm_scales": [0.7]}) + system.run_dev_recog_step( + exp_names=[ + f"Conformer_Transducer_Viterbi_wei-data_{name_suffix}_lr-0.0008_ls-0.2_loss-boost" + ], + recog_exp_names=["recog_ilm-0.1"], + **recog_args, ) + + if False: + recog_args.update( + { + "epochs": [ + 213, + 225, + 249, + 261, + 280, + 281, + 285, + 286, + 289, + 292, + 297, + 298, + 299, + 300, + ], + "lm_scales": [0.4, 0.45, 0.5, 0.55, 0.6, 0.65, 0.7], + } + ) + system.run_dev_recog_step( + exp_names=[ + f"Conformer_Transducer_Viterbi_wei-data_specaug-v2_{name_suffix}" + ], + recog_exp_names=[ + "recog_ilm-0.0", + "recog_ilm-0.1", + "recog_ilm-0.15", + "recog_ilm-0.2", + "recog_ilm-0.25", + "recog_ilm-0.3", + ], + **recog_args, + ) + + recog_args.update({"epochs": [292], "lm_scales": [0.45]}) system.run_dev_recog_step( - exp_names=[f"Conformer_Transducer_Viterbi_wei-data_{name_suffix}_lr-0.0008_ls-0.2_loss-boost"], - recog_exp_names=["recog_ilm-0.1", "recog_ilm-0.2"], + exp_names=[f"Conformer_Transducer_Viterbi_wei-data_specaug-v2_{name_suffix}"], + recog_exp_names=["recog_ilm-0.15"], **recog_args, ) - train_job = system.get_train_job(f"Conformer_Transducer_Viterbi_wei-data_{name_suffix}_lr-0.0008") - model = train_job.out_checkpoints[298] + train_job = system.get_train_job( + f"Conformer_Transducer_Viterbi_wei-data_specaug-v2_{name_suffix}" + ) + model = train_job.out_checkpoints[292] assert isinstance(model, Checkpoint) assert system.summary_report diff --git a/users/berger/configs/switchboard/20240202_phoneme_transducer_pipeline/config_02c_transducer_wei_data_tinaconf.py b/users/berger/configs/switchboard/20240202_phoneme_transducer_pipeline/config_02c_transducer_wei_data_tinaconf.py index 5ad7a0e0e..5e304575b 100644 --- a/users/berger/configs/switchboard/20240202_phoneme_transducer_pipeline/config_02c_transducer_wei_data_tinaconf.py +++ b/users/berger/configs/switchboard/20240202_phoneme_transducer_pipeline/config_02c_transducer_wei_data_tinaconf.py @@ -16,11 +16,17 @@ from i6_experiments.users.berger.systems.returnn_seq2seq_system import ( ReturnnSeq2SeqSystem, ) -from i6_experiments.users.berger.systems.dataclasses import ReturnnConfigs, FeatureType, SummaryKey +from i6_experiments.users.berger.systems.dataclasses import ( + ReturnnConfigs, + FeatureType, + SummaryKey, +) from i6_experiments.users.berger.util import default_tools, recursive_update from i6_private.users.vieting.helpers.returnn import serialize_dim_tags from i6_experiments.users.berger.systems.dataclasses import AlignmentData -from i6_experiments.users.berger.corpus.switchboard.viterbi_transducer_data import get_switchboard_data +from i6_experiments.users.berger.corpus.switchboard.viterbi_transducer_data import ( + get_switchboard_data, +) from .config_01c_ctc_blstm_wei_data import py as py_ctc_blstm from sisyphus import gs, tk @@ -151,7 +157,9 @@ def generate_returnn_config( return returnn_config -def run_exp(alignments: Dict[str, AlignmentData], name_suffix: str = "") -> Tuple[SummaryReport, Checkpoint]: +def run_exp( + alignments: Dict[str, AlignmentData], name_suffix: str = "" +) -> Tuple[SummaryReport, Checkpoint]: assert tools.returnn_root is not None assert tools.returnn_python_exe is not None assert tools.rasr_binary_path is not None @@ -277,7 +285,9 @@ def run_exp(alignments: Dict[str, AlignmentData], name_suffix: str = "") -> Tupl ) system.run_dev_recog_step( - exp_names=["Conformer_Transducer_Viterbi_wei-data_tinaconf_align-blstm-am-1.0_lr-0.0008"], + exp_names=[ + "Conformer_Transducer_Viterbi_wei-data_tinaconf_align-blstm-am-1.0_lr-0.0008" + ], recog_descriptor=f"bp-{bp}", **recog_args, ) @@ -288,26 +298,46 @@ def run_exp(alignments: Dict[str, AlignmentData], name_suffix: str = "") -> Tupl { "epochs": [300], "lm_scales": [0.8], - "search_parameters": {"blank-label-penalty": 1.0, "label-pruning": lp}, + "search_parameters": { + "blank-label-penalty": 1.0, + "label-pruning": lp, + }, }, ) system.run_dev_recog_step( - exp_names=["Conformer_Transducer_Viterbi_wei-data_tinaconf_align-blstm-am-1.0_lr-0.0008"], + exp_names=[ + "Conformer_Transducer_Viterbi_wei-data_tinaconf_align-blstm-am-1.0_lr-0.0008" + ], recog_exp_names={ - "Conformer_Transducer_Viterbi_wei-data_tinaconf_align-blstm-am-1.0_lr-0.0008": ["recog_ilm-0.1"] + "Conformer_Transducer_Viterbi_wei-data_tinaconf_align-blstm-am-1.0_lr-0.0008": [ + "recog_ilm-0.1" + ] }, recog_descriptor=f"lp-{lp}", **recog_args, ) recursive_update( - recog_args, {"epochs": [300], "lm_scales": [0.8], "search_parameters": {"blank-label-penalty": 1.0}} + recog_args, + { + "epochs": [300], + "lm_scales": [0.8], + "search_parameters": {"blank-label-penalty": 1.0}, + }, + ) + system.run_dev_recog_step( + recog_exp_names={key: ["recog_ilm-0.1"] for key in system.get_exp_names()}, + **recog_args, + ) + system.run_test_recog_step( + recog_exp_names={key: ["recog_ilm-0.1"] for key in system.get_exp_names()}, + **recog_args, ) - system.run_dev_recog_step(recog_exp_names={key: ["recog_ilm-0.1"] for key in system.get_exp_names()}, **recog_args) - system.run_test_recog_step(recog_exp_names={key: ["recog_ilm-0.1"] for key in system.get_exp_names()}, **recog_args) - train_job = system.get_train_job(f"Conformer_Transducer_Viterbi_wei-data_tinaconf_{name_suffix}_lr-0.0008") + train_job = system.get_train_job( + f"Conformer_Transducer_Viterbi_wei-data_tinaconf_{name_suffix}_lr-0.0008" + ) model = train_job.out_checkpoints[300] assert isinstance(model, Checkpoint) @@ -326,7 +356,9 @@ def py() -> Tuple[SummaryReport, Dict[str, Checkpoint]]: for align_model_name, alignments in alignments_blstm.items(): am_scale_pos = align_model_name.find("am-") - align_model_name = "blstm-" + align_model_name[am_scale_pos : am_scale_pos + len("am-1.0")] + align_model_name = ( + "blstm-" + align_model_name[am_scale_pos : am_scale_pos + len("am-1.0")] + ) sub_report, model = run_exp(alignments, name_suffix=f"align-{align_model_name}") models[align_model_name] = model summary_report.merge_report(sub_report, update_structure=True) diff --git a/users/berger/configs/switchboard/20240202_phoneme_transducer_pipeline/config_02d_transducer_wei_data_am_scales.py b/users/berger/configs/switchboard/20240202_phoneme_transducer_pipeline/config_02d_transducer_wei_data_am_scales.py new file mode 100644 index 000000000..2fe0411fe --- /dev/null +++ b/users/berger/configs/switchboard/20240202_phoneme_transducer_pipeline/config_02d_transducer_wei_data_am_scales.py @@ -0,0 +1,379 @@ +import copy +import os +from typing import Dict, Tuple + +import i6_core.rasr as rasr +from i6_core.recognition import Hub5ScoreJob +from i6_core.returnn import Checkpoint +from i6_core.returnn.config import ReturnnConfig +from i6_experiments.users.berger.args.experiments import transducer as exp_args +from i6_experiments.users.berger.args.returnn.config import get_returnn_config +from i6_experiments.users.berger.args.returnn.learning_rates import ( + LearningRateSchedules, +) +import i6_experiments.users.berger.network.models.context_1_transducer as transducer_model +from i6_experiments.users.berger.recipe.summary.report import SummaryReport +from i6_experiments.users.berger.systems.returnn_seq2seq_system import ( + ReturnnSeq2SeqSystem, +) +from i6_experiments.users.berger.systems.dataclasses import ( + ReturnnConfigs, + FeatureType, + SummaryKey, +) +from i6_experiments.users.berger.util import default_tools +from i6_private.users.vieting.helpers.returnn import serialize_dim_tags +from i6_experiments.users.berger.systems.dataclasses import AlignmentData +from i6_experiments.users.berger.corpus.switchboard.viterbi_transducer_data import ( + get_switchboard_data, +) +from .config_01c_ctc_blstm_wei_data import py as py_ctc_blstm +from sisyphus import gs, tk + +tools = copy.deepcopy(default_tools) + +# ********** Settings ********** + +rasr.flow.FlowNetwork.default_flags = {"cache_mode": "task_dependent"} + + +num_classes = 88 + + +# ********** Return Config ********** + + +def generate_returnn_config( + train: bool, + *, + train_data_config: dict, + dev_data_config: dict, + **kwargs, +) -> ReturnnConfig: + specaug_v2 = kwargs.get("specaug_v2", False) + + if specaug_v2: + specaug_args = { + "min_reps_time": 0, + "max_reps_time": 20, + "max_len_time": 20, + "min_reps_feature": 0, + "max_reps_feature": 1, + "max_len_feature": 15, + } + else: + specaug_args = { + "max_time_num": 1, + "max_time": 15, + "max_feature_num": 5, + "max_feature": 4, + } + + if train: + ( + network_dict, + extra_python, + ) = transducer_model.make_context_1_conformer_transducer( + num_outputs=num_classes, + specaug_args=specaug_args, + conformer_args={ + "num_blocks": 12, + "size": 512, + "dropout": 0.1, + "l2": 5e-06, + }, + decoder_args={ + "dec_mlp_args": { + "num_layers": 2, + "size": 640, + "activation": "tanh", + "dropout": 0.1, + "l2": 5e-06, + }, + "combination_mode": "concat", + "joint_mlp_args": { + "num_layers": 1, + "size": 1024, + "dropout": 0.1, + "l2": 5e-06, + "activation": "tanh", + }, + }, + output_args={ + "label_smoothing": kwargs.get("label_smoothing", None), + }, + loss_boost_scale=kwargs.get("loss_boost_scale", 5.0), + loss_boost_v2=kwargs.get("loss_boost_v2", False), + specaug_v2=specaug_v2, + ) + else: + ( + network_dict, + extra_python, + ) = transducer_model.make_context_1_conformer_transducer_recog( + num_outputs=num_classes, + conformer_args={ + "num_blocks": 12, + "size": 512, + "dropout": 0.1, + "l2": 5e-06, + }, + decoder_args={ + "dec_mlp_args": { + "num_layers": 2, + "size": 640, + "activation": "tanh", + }, + "combination_mode": "concat", + "joint_mlp_args": { + "num_layers": 1, + "size": 1024, + "activation": "tanh", + }, + "ilm_scale": kwargs.get("ilm_scale", 0.0), + }, + ) + + extra_config = { + "train": train_data_config, + "dev": dev_data_config, + "chunking": ( + { + "data": 256, + "classes": 64, + }, + { + "data": 128, + "classes": 32, + }, + ), + } + + if kwargs.get("model_preload", None) is not None: + extra_config["preload_from_files"] = { + "base": { + "init_for_train": True, + "ignore_missing": True, + "filename": kwargs.get("model_preload", None), + } + } + + returnn_config = get_returnn_config( + network=network_dict, + target="classes", + num_epochs=300, + python_prolog=[ + "import sys", + "sys.setrecursionlimit(10 ** 6)", + ], + extra_python=extra_python, + num_inputs=40, + num_outputs=num_classes, + extern_target_kwargs={"dtype": "int8" if train else "int32"}, + extern_data_config=True, + grad_noise=0.0, + grad_clip=0.0, + schedule=LearningRateSchedules.OCLR, + initial_lr=1e-05, + peak_lr=kwargs.get("peak_lr", 8e-04), + final_lr=1e-06, + n_steps_per_epoch=3210, + batch_size=12500, + extra_config=extra_config, + ) + returnn_config = serialize_dim_tags(returnn_config) + + return returnn_config + + +def run_exp( + alignments: Dict[str, AlignmentData], name_suffix: str = "" +) -> Tuple[SummaryReport, Checkpoint]: + assert tools.returnn_root is not None + assert tools.returnn_python_exe is not None + assert tools.rasr_binary_path is not None + + data = get_switchboard_data( + tools.returnn_root, + tools.returnn_python_exe, + rasr_binary_path=tools.rasr_binary_path, + alignments=alignments, + use_wei_data=True, + test_keys=["hub5e01"], + feature_type=FeatureType.GAMMATONE_8K, + dc_detection=True, + ) + + # ********** System ********** + + system = ReturnnSeq2SeqSystem( + tools, + summary_keys=[ + SummaryKey.TRAIN_NAME, + SummaryKey.CORPUS, + SummaryKey.RECOG_NAME, + SummaryKey.EPOCH, + SummaryKey.LM, + SummaryKey.WER, + SummaryKey.SUB, + SummaryKey.INS, + SummaryKey.DEL, + SummaryKey.ERR, + ], + summary_sort_keys=[SummaryKey.ERR, SummaryKey.CORPUS], + ) + + # ********** Step args ********** + + train_args = exp_args.get_transducer_train_step_args( + num_epochs=300, + ) + + recog_args = exp_args.get_transducer_recog_step_args( + num_classes, + lm_scales=[0.4, 0.45, 0.5], + epochs=list(range(290, 301)), + search_parameters={"label-pruning": 14.4}, + feature_type=FeatureType.GAMMATONE_8K, + reduction_factor=4, + reduction_subtrahend=0, + flow_args={"dc_detection": True}, + ) + recog_am_args = copy.deepcopy(exp_args.transducer_recog_am_args) + recog_am_args.update( + { + # "state_tying": "lookup", + # "state_tying_file": tk.Path("/work/asr4/berger/dependencies/switchboard/state_tying/wei_mono-eow"), + "tying_type": "global-and-nonword", + "nonword_phones": ["[NOISE]", "[VOCALIZEDNOISE]", "[LAUGHTER]"], + } + ) + + system.init_corpora( + dev_keys=data.dev_keys, + test_keys=data.test_keys, + align_keys=data.align_keys, + corpus_data=data.data_inputs, + am_args=recog_am_args, + ) + system.setup_scoring(scorer_type=Hub5ScoreJob) + + # ********** Returnn Configs ********** + + for lr in [8e-04]: + for label_smoothing in [None]: + for loss_boost_scale in [0.0]: + train_config = generate_returnn_config( + train=True, + train_data_config=data.train_data_config, + dev_data_config=data.cv_data_config, + peak_lr=lr, + label_smoothing=label_smoothing, + loss_boost_v2=True, + loss_boost_scale=loss_boost_scale, + model_preload=None, + specaug_v2=True, + ) + + returnn_configs = ReturnnConfigs( + train_config=train_config, + recog_configs={ + f"recog_ilm-{ilm_scale}": generate_returnn_config( + train=False, + ilm_scale=ilm_scale, + train_data_config=data.train_data_config, + dev_data_config=data.cv_data_config, + ) + for ilm_scale in [0.0, 0.1, 0.15, 0.2, 0.3] + }, + ) + name = f"Conformer_Transducer_Viterbi_wei-data_{name_suffix}_lr-{lr}" + if label_smoothing: + name += f"_ls-{label_smoothing}" + if loss_boost_scale: + name += "_loss-boost" + + system.add_experiment_configs(name, returnn_configs) + + system.run_train_step(**train_args) + + if False: + system.run_dev_recog_step(**recog_args) + + if "am-1.0" in name_suffix: + recog_args.update( + { + "lm_scales": [0.5], + "epochs": [291], + } + ) + system.run_dev_recog_step(recog_exp_names=["recog_ilm-0.2"], **recog_args) + system.run_test_recog_step(recog_exp_names=["recog_ilm-0.2"], **recog_args) + elif "am-0.7" in name_suffix: + recog_args.update( + { + "lm_scales": [0.5], + "epochs": [291], + } + ) + system.run_dev_recog_step(recog_exp_names=["recog_ilm-0.3"], **recog_args) + system.run_test_recog_step(recog_exp_names=["recog_ilm-0.3"], **recog_args) + elif "am-0.5" in name_suffix: + recog_args.update( + { + "lm_scales": [0.4], + "epochs": [297], + } + ) + system.run_dev_recog_step(recog_exp_names=["recog_ilm-0.3"], **recog_args) + system.run_test_recog_step(recog_exp_names=["recog_ilm-0.3"], **recog_args) + elif "am-0.3" in name_suffix: + recog_args.update( + { + "lm_scales": [0.4], + "epochs": [297], + } + ) + system.run_dev_recog_step(recog_exp_names=["recog_ilm-0.3"], **recog_args) + system.run_test_recog_step(recog_exp_names=["recog_ilm-0.3"], **recog_args) + elif "am-0.1" in name_suffix: + recog_args.update( + { + "lm_scales": [0.4], + "epochs": [297], + } + ) + system.run_dev_recog_step(recog_exp_names=["recog_ilm-0.3"], **recog_args) + system.run_test_recog_step(recog_exp_names=["recog_ilm-0.3"], **recog_args) + + train_job = system.get_train_job( + f"Conformer_Transducer_Viterbi_wei-data_{name_suffix}_lr-0.0008" + ) + model = train_job.out_checkpoints[300] + assert isinstance(model, Checkpoint) + + assert system.summary_report + return system.summary_report, model + + +def py() -> Tuple[SummaryReport, Dict[str, Checkpoint]]: + _, alignments_blstm = py_ctc_blstm() + + filename_handle = os.path.splitext(os.path.basename(__file__))[0][len("config_") :] + gs.ALIAS_AND_OUTPUT_SUBDIR = f"{filename_handle}/" + + summary_report = SummaryReport() + models = {} + + for align_model_name, alignments in alignments_blstm.items(): + am_scale_pos = align_model_name.find("am-") + align_model_name = ( + "blstm-" + align_model_name[am_scale_pos : am_scale_pos + len("am-1.0")] + ) + sub_report, model = run_exp(alignments, name_suffix=f"align-{align_model_name}") + models[align_model_name] = model + summary_report.merge_report(sub_report, update_structure=True) + + tk.register_report(f"{gs.ALIAS_AND_OUTPUT_SUBDIR}/summary.report", summary_report) + + return summary_report, models diff --git a/users/berger/configs/switchboard/20240202_phoneme_transducer_pipeline/config_03b_transducer_fullsum_wei_data.py b/users/berger/configs/switchboard/20240202_phoneme_transducer_pipeline/config_03b_transducer_fullsum_wei_data.py index 6e103088c..e9487f3cc 100644 --- a/users/berger/configs/switchboard/20240202_phoneme_transducer_pipeline/config_03b_transducer_fullsum_wei_data.py +++ b/users/berger/configs/switchboard/20240202_phoneme_transducer_pipeline/config_03b_transducer_fullsum_wei_data.py @@ -11,13 +11,19 @@ from i6_experiments.users.berger.args.returnn.learning_rates import ( LearningRateSchedules, ) -from i6_experiments.users.berger.corpus.switchboard.viterbi_transducer_data import get_switchboard_data +from i6_experiments.users.berger.corpus.switchboard.viterbi_transducer_data import ( + get_switchboard_data, +) import i6_experiments.users.berger.network.models.context_1_transducer as transducer_model from i6_experiments.users.berger.recipe.summary.report import SummaryReport from i6_experiments.users.berger.systems.returnn_seq2seq_system import ( ReturnnSeq2SeqSystem, ) -from i6_experiments.users.berger.systems.dataclasses import ReturnnConfigs, FeatureType, SummaryKey +from i6_experiments.users.berger.systems.dataclasses import ( + ReturnnConfigs, + FeatureType, + SummaryKey, +) from i6_experiments.users.berger.util import default_tools from i6_private.users.vieting.helpers.returnn import serialize_dim_tags from i6_experiments.users.berger.systems.dataclasses import AlignmentData @@ -47,7 +53,7 @@ def generate_returnn_config( **kwargs, ) -> ReturnnConfig: if train: - (network_dict, extra_python,) = transducer_model.make_context_1_conformer_transducer_fullsum( + network_dict, extra_python = transducer_model.make_context_1_conformer_transducer_fullsum( num_outputs=num_classes, specaug_args={ "max_time_num": 1, @@ -79,9 +85,10 @@ def generate_returnn_config( "activation": "tanh", }, }, + fullsum_v2=True, ) else: - (network_dict, extra_python,) = transducer_model.make_context_1_conformer_transducer_recog( + network_dict, extra_python = transducer_model.make_context_1_conformer_transducer_recog( num_outputs=num_classes, conformer_args={ "num_blocks": 12, @@ -164,7 +171,7 @@ def run_exp(alignments: Dict[str, AlignmentData], viterbi_model_checkpoint: Chec recog_args = exp_args.get_transducer_recog_step_args( num_classes, - lm_scales=[0.5, 0.6, 0.7], + lm_scales=[0.45, 0.5, 0.6, 0.7], epochs=[300], search_parameters={"label-pruning": 14.4}, feature_type=FeatureType.GAMMATONE_8K, @@ -220,13 +227,17 @@ def run_exp(alignments: Dict[str, AlignmentData], viterbi_model_checkpoint: Chec for lr, batch_size, accum_grad in [(8e-05, 3000, 3)]: train_config = generate_returnn_config( - train=True, lr=lr, batch_size=batch_size, accum_grad=accum_grad, **config_generator_kwargs + train=True, + lr=lr, + batch_size=batch_size, + accum_grad=accum_grad, + **config_generator_kwargs, ) recog_configs = { f"recog_ilm-{ilm_scale}": generate_returnn_config( train=False, ilm_scale=ilm_scale, **config_generator_kwargs ) - for ilm_scale in [0.0, 0.25] + for ilm_scale in [0.0, 0.15, 0.25] } returnn_configs = ReturnnConfigs( @@ -234,7 +245,8 @@ def run_exp(alignments: Dict[str, AlignmentData], viterbi_model_checkpoint: Chec recog_configs=recog_configs, ) system.add_experiment_configs( - f"Conformer_Transducer_Fullsum_lr-{lr}_bs-{batch_size*accum_grad}", returnn_configs + f"Conformer_Transducer_Fullsum_lr-{lr}_bs-{batch_size*accum_grad}", + returnn_configs, ) system.run_train_step(**train_args) diff --git a/users/berger/corpus/switchboard/lm_data.py b/users/berger/corpus/switchboard/lm_data.py index cd566bd73..79a586991 100644 --- a/users/berger/corpus/switchboard/lm_data.py +++ b/users/berger/corpus/switchboard/lm_data.py @@ -5,9 +5,15 @@ def get_lm(name: str) -> rasr_lm_config.LMData: if name == "zoltan_4gram": - return rasr_lm_config.ArpaLMData(10, tk.Path("/work/asr4/berger/dependencies/switchboard/lm/zoltan_4gram.gz")) + return rasr_lm_config.ArpaLMData( + scale=10, + filename=tk.Path("/work/asr4/berger/dependencies/switchboard/lm/zoltan_4gram.gz"), + lookahead_lm=None, + ) elif name == "fisher_4gram": return rasr_lm_config.ArpaLMData( - 10, tk.Path("/home/tuske/work/ASR/switchboard/corpus/lm/data/mylm/swb.fsh.4gr.voc30k.LM.gz") + scale=10, + filename=tk.Path("/home/tuske/work/ASR/switchboard/corpus/lm/data/mylm/swb.fsh.4gr.voc30k.LM.gz"), + lookahead_lm=None, ) raise ValueError From 7a97565677255e933c9116ae6eed60b108999051 Mon Sep 17 00:00:00 2001 From: marvin84 Date: Thu, 13 Jun 2024 16:21:05 +0200 Subject: [PATCH 166/227] update users/raissi monofactored --- .../swb/legacy/data_preparation/lm_data.py | 10 +- .../data_preparation/pipeline_base_args_v2.py | 144 +++++ .../raissi/setups/common/analysis/__init__.py | 6 +- .../common/analysis/frame_statistics.py | 289 +++++++++ users/raissi/setups/common/analysis/labels.py | 610 ++++++++++++++++++ .../analysis/phoneme_length_statistics.py | 124 ++++ .../decoder/BASE_factored_hybrid_search.py | 2 + .../common/helpers/train/network_params.py | 20 +- .../legacy/SWB_TF_factored_hybrid_system.py | 3 + 9 files changed, 1199 insertions(+), 9 deletions(-) create mode 100644 users/raissi/experiments/tedlium/data_preparation/pipeline_base_args_v2.py create mode 100755 users/raissi/setups/common/analysis/frame_statistics.py create mode 100644 users/raissi/setups/common/analysis/labels.py create mode 100755 users/raissi/setups/common/analysis/phoneme_length_statistics.py diff --git a/users/raissi/experiments/swb/legacy/data_preparation/lm_data.py b/users/raissi/experiments/swb/legacy/data_preparation/lm_data.py index 81631b7e1..bb02038b0 100644 --- a/users/raissi/experiments/swb/legacy/data_preparation/lm_data.py +++ b/users/raissi/experiments/swb/legacy/data_preparation/lm_data.py @@ -6,16 +6,18 @@ def get_lm(name: str) -> rasr_lm_config.LMData: if name == "zoltan_4gram": return rasr_lm_config.ArpaLMData( - 10, - tk.Path( + scale=10, + lookahead_lm=None, + filename=tk.Path( "/work/asr4/berger/dependencies/switchboard/lm/zoltan_4gram.gz", hash_overwrite="/work/asr4/berger/dependencies", ), ) elif name == "fisher_4gram": return rasr_lm_config.ArpaLMData( - 10, - tk.Path( + scale=10, + lookahead_lm=None, + filename=tk.Path( "/work/asr4/vieting/setups/swb/dependencies/swb.fsh.4gr.voc30k.LM.gz", hash_overwrite="/home/tuske/work/ASR/switchboard/corpus/lm/data/mylm/swb.fsh.4gr.voc30k.LM.gz", ), diff --git a/users/raissi/experiments/tedlium/data_preparation/pipeline_base_args_v2.py b/users/raissi/experiments/tedlium/data_preparation/pipeline_base_args_v2.py new file mode 100644 index 000000000..4adace3cc --- /dev/null +++ b/users/raissi/experiments/tedlium/data_preparation/pipeline_base_args_v2.py @@ -0,0 +1,144 @@ +__all__ = [ + "get_init_args", + "get_corpus_data_inputs", + "get_final_output", +] + +from typing import Dict +from collections import defaultdict + +#----------recipes-------------------- +from i6_core.features.filterbank import filter_width_from_channels + +from i6_experiments.common.baselines.librispeech.default_tools import SCTK_BINARY_PATH +from i6_experiments.common.baselines.librispeech.data import CorpusData +import i6_experiments.common.datasets.tedlium2_v2 as ted_dataset +import i6_experiments.common.setups.rasr as rasr_util +from i6_experiments.common.setups.rasr.config.lex_config import ( + LexiconRasrConfig, +) +from i6_experiments.common.setups.rasr.config.lm_config import ArpaLmRasrConfig + +#TED specific +from i6_experiments.common.datasets.tedlium2.constants import CONCURRENT +from i6_experiments.common.datasets.tedlium2_v2.corpus import get_corpus_object_dict +from i6_experiments.common.datasets.tedlium2_v2.lexicon import ( + get_g2p_augmented_bliss_lexicon, +) +from i6_experiments.common.baselines.tedlium2.lm.ngram_config import run_tedlium2_ngram_lm + +from i6_experiments.users.raissi.setups.common.data.pipeline_helpers import ( + InputKey +) + +def get_init_args(): + am_args = { + "state_tying": "monophone", + "states_per_phone": 3, + "state_repetitions": 1, + "across_word_model": True, + "early_recombination": False, + "tdp_scale": 1.0, + "tdp_transition": (3.0, 0.0, "infinity", 0.0), + "tdp_silence": (0.0, 3.0, "infinity", 20.0), + "tying_type": "global", + "nonword_phones": "", + "tdp_nonword": ( + 0.0, + 3.0, + "infinity", + 6.0, + ), # only used when tying_type = global-and-nonword + } + + costa_args = {"eval_recordings": True, "eval_lm": False} + + feature_extraction_args = { + "fb": { + "filterbank_options": { + "warping_function": "mel", + "filter_width": filter_width_from_channels(channels=80, warping_function="mel", f_max=8000), + "normalize": True, + "normalization_options": None, + "without_samples": False, + "samples_options": { + "audio_format": "wav", + "dc_detection": False, + }, + "fft_options": None, + "add_features_output": True, + "apply_log": True, + "add_epsilon": True, + } + } + } + + scorer_args = {"sctk_binary_path": SCTK_BINARY_PATH} + + return rasr_util.RasrInitArgs( + costa_args=costa_args, + am_args=am_args, + feature_extraction_args=feature_extraction_args, + scorer_args=scorer_args, + ) + + + +def get_corpus_data_inputs(add_unknown_phoneme_and_mapping: bool = True) -> Dict[str, Dict[str, rasr_util.RasrDataInput]]: + + corpus_object_dict = get_corpus_object_dict(audio_format="wav", output_prefix="corpora") + + train_lexicon = LexiconRasrConfig( + get_g2p_augmented_bliss_lexicon( + add_unknown_phoneme_and_mapping=add_unknown_phoneme_and_mapping, output_prefix="lexicon" + ), + False, + ) + + lms_system = run_tedlium2_ngram_lm(add_unknown_phoneme_and_mapping=False) + lm = lms_system.interpolated_lms["dev-pruned"]["4gram"] + comb_lm = ArpaLmRasrConfig(lm_path=lm.ngram_lm) + + train_data_inputs = {} + dev_data_inputs = {} + test_data_inputs = {} + + train_data_inputs["train"] = rasr_util.RasrDataInput( + corpus_object=corpus_object_dict["train"], + lexicon=train_lexicon.get_dict(), + concurrent=CONCURRENT["train"], + lm=None, + ) + dev_data_inputs["dev"] = rasr_util.RasrDataInput( + corpus_object=corpus_object_dict["dev"], + lexicon=train_lexicon.get_dict(), + concurrent=CONCURRENT["dev"], + lm=comb_lm.get_dict(), + ) + test_data_inputs["test"] = rasr_util.RasrDataInput( + corpus_object=corpus_object_dict["test"], + lexicon=train_lexicon.get_dict(), + concurrent=CONCURRENT["test"], + lm=comb_lm.get_dict(), + ) + + return CorpusData( + train_data=train_data_inputs, + dev_data=dev_data_inputs, + test_data=test_data_inputs, + ) + + + + +# -------------------- helpers -------------------- +def get_final_output(name=InputKey.BASE): + output_args = rasr_util.OutputArgs(name) + + output_args.define_corpus_type("train", "train") + output_args.define_corpus_type("dev", "dev") + output_args.define_corpus_type("test", "test") + + output_args.add_feature_to_extract("fb") + + return output_args diff --git a/users/raissi/setups/common/analysis/__init__.py b/users/raissi/setups/common/analysis/__init__.py index 401678888..4809f11e9 100644 --- a/users/raissi/setups/common/analysis/__init__.py +++ b/users/raissi/setups/common/analysis/__init__.py @@ -1,4 +1,2 @@ -from .plot import PlotPhonemeDurationsJob, PlotViterbiAlignmentsJob -from .sample_alignment import ComputeAlignmentSamplingStatisticsJob -from .statistics import ComputeSilencePercentageJob -from .tse import ComputeTimestampErrorJob, ComputeWordLevelTimestampErrorJob +from .plot import PlotViterbiAlignmentsJob +from .tse import ComputeWordLevelTimestampErrorJob diff --git a/users/raissi/setups/common/analysis/frame_statistics.py b/users/raissi/setups/common/analysis/frame_statistics.py new file mode 100755 index 000000000..96b8e0239 --- /dev/null +++ b/users/raissi/setups/common/analysis/frame_statistics.py @@ -0,0 +1,289 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- + +import argparse +import collections +import itertools as it +import matplotlib.pyplot as plt +import os +import pandas as pd +import pickle +import sys + +import sprint_cache as sc + + +def load_alignment(allophones_path, alignments_path): + alignments = [] + f = sc.FileArchive(alignments_path) + f.setAllophones(allophones_path) + for i, k in enumerate(f.ft): + finfo = f.ft[k] + if 'attrib' not in finfo.name: + alignment = [(f.allophones[mix], state) for time, mix, state, _ in f.read(finfo.name, 'align')] + alignments.append(alignment) + return alignments + + +def count_hmm_states(alignment): + label_lengths = list() + for cur_label, val in it.groupby(alignment): + label_lengths.append(tuple([cur_label, len(list(val))])) + return label_lengths + + +def count_merge_hmm_states(alignment): + label_lengths = list() + for cur_label, val in it.groupby(alignment, key=lambda t : t[0]): + label_lengths.append(tuple([cur_label, len(list(val))])) + return label_lengths + + +def count_cart_lengths(count, silence_symbol): + cart_lengths = [] + hmm0_lengths = [] + hmm1_lengths = [] + hmm2_lengths = [] + for label, length in count: + if label[0].strip().find(silence_symbol) == 0: + continue + cart_lengths.append(length) + if label[1] == 0: + hmm0_lengths.append(length) + if label[1] == 1: + hmm1_lengths.append(length) + if label[1] == 2: + hmm2_lengths.append(length) + return cart_lengths, hmm0_lengths, hmm1_lengths, hmm2_lengths + + +def count_phon_lengths(count, silence_symbol): + phon_lengths = [] + for label, length in count: + if label[0].strip().find(silence_symbol) == 0: + continue + phon_lengths.append(length) + return phon_lengths + + +def count_silence(count, silence_symbol): + if count[0][0][0].strip().find(silence_symbol) == 0: + sil_begin_length = count.pop(0)[1] + else: + sil_begin_length = 0 + if count[-1][0][0].strip().find(silence_symbol) == 0: + sil_end_length = count.pop(-1)[1] + else: + sil_end_length = 0 + sil_middle_length = [] + for label, length in count: + if label[0].strip().find(silence_symbol) == 0: + sil_middle_length.append(length) + return [sil_begin_length], sil_middle_length, [sil_end_length] + + +def main(allophones_path, alignments_path, output_dir, silence_symbol, non_speech_symbol): + assert isinstance(silence_symbol, str), (silence_symbol, "is not str type") + pickle_path = f"{output_dir}/data.pickle" + + alignments = collections.defaultdict(list) # dict(int:list) + alignments_merge = collections.defaultdict(list) + silence_begin = list() + silence_end = list() + silence_intra = list() + phoneme_total_lengths = list() + cart_total_lengths = list() + hmm0_total_lengths = list() + hmm1_total_lengths = list() + hmm2_total_lengths = list() + sil_hist_begin = collections.defaultdict(int) + sil_hist_end = collections.defaultdict(int) + sil_hist_intra = collections.defaultdict(int) + cart_hist = collections.defaultdict(int) + hmm0_hist = collections.defaultdict(int) + hmm1_hist = collections.defaultdict(int) + hmm2_hist = collections.defaultdict(int) + phon_hist = collections.defaultdict(int) + if not os.path.isfile(pickle_path): + print("collecting statistics") + num_alignments = len(alignments_path) + idx = 0 + for i, ap in enumerate(alignments_path): + print(f"alignment: {i+1}/{num_alignments}") + assert os.path.isfile(ap), ap + alignment = load_alignment(allophones_path, ap) + for align in alignment: + alignments[idx] = count = count_hmm_states(align) + alignments_merge[idx] = count_merge = count_merge_hmm_states(align) + + sil_begin, sil_intra, sil_end = count_silence(count, silence_symbol) + + silence_begin.extend(sil_begin) + silence_intra.extend(sil_intra) + silence_end.extend(sil_end) + sil_hist_begin[sil_begin[0]] += 1 + sil_hist_end[sil_end[0]] += 1 + for i in sil_intra: + sil_hist_intra[i] += 1 + + cart_lengths, hmm0_lengths, hmm1_lengths, hmm2_lengths = count_cart_lengths(count, non_speech_symbol) + for cart in cart_lengths: + cart_hist[cart] += 1 + for h0 in hmm0_lengths: + hmm0_hist[h0] += 1 + for h1 in hmm1_lengths: + hmm1_hist[h1] += 1 + for h2 in hmm2_lengths: + hmm2_hist[h2] += 1 + + phon_lengths = count_phon_lengths(count_merge, non_speech_symbol) + for phon in phon_lengths: + phon_hist[phon] += 1 + + phoneme_total_lengths.extend(phon_lengths) + cart_total_lengths.extend(cart_lengths) + hmm0_total_lengths.extend(hmm0_lengths) + hmm1_total_lengths.extend(hmm1_lengths) + hmm2_total_lengths.extend(hmm2_lengths) + + idx += 1 + + results = [alignments, alignments_merge, silence_begin, silence_intra, silence_end, sil_hist_begin, sil_hist_intra, sil_hist_end, cart_total_lengths, hmm0_total_lengths, hmm1_total_lengths, hmm2_total_lengths, phoneme_total_lengths, cart_hist, hmm0_hist, hmm1_hist, hmm2_hist, phon_hist] + + with open(pickle_path, "wb") as out_pickle: + data_dump = tuple(results) + pickle.dump(data_dump, out_pickle, protocol=4) # protocol version4 for python 3.4+ support + else: + print("found pickled statistics") + with open(pickle_path, "rb") as in_pickle: + results = pickle.load(in_pickle) + + # alignments : dict[int] = list[cart labels, cart lengths] + # alignments_merge : dict[int] = list[phon labels, phon lengths] + # silence_begin : list[sil lengths] + # silence_intra : list[sil lengths] + # silence_end : list[sil lengths] + # sil_hist_begin : dict[sil lengths] = occurences + # sil_hist_intra : dict[sil lengths] = occurences + # sil_hist_end : dict[sil lengths] = occurences + # cart_lengths : list[cart labels lengths] + # hmm0_lengths : list[hmm state 0 lengths] + # hmm1_lengths : list[hmm state 1 lengths] + # hmm2_lengths : list[hmm state 2 lengths] + # phon_lengths : list[phon labels lengths] + # cart_hist : dict[cart labels] = occurences + # hmm0_hist : dict[hmm state 0] = occurences + # hmm1_hist : dict[hmm state 1] = occurences + # hmm2_hist : dict[hmm state 2] = occurences + # phon_hist : dict[phon labels] = occurences + return results + + +def hist_data_to_dataframe(x_label, y_label, data_dict): + d_t = collections.defaultdict(list) + for k, v in sorted(data_dict.items()): + d_t[x_label].append(k) + d_t[y_label].append(v) + + df = pd.DataFrame(data=d_t) + + return df + + +def plot(output_dir, plot_dir, inputs): + print("calculating averages") + alignments, alignments_merge, silence_begin, silence_intra, silence_end, sil_hist_begin, sil_hist_intra, sil_hist_end, cart_lengths, hmm0_lengths, hmm1_lengths, hmm2_lengths, phon_lengths, cart_hist, hmm0_hist, hmm1_hist, hmm2_hist, phon_hist = inputs + # *** stat calculation *** + num_seqs = len(alignments.keys()) + assert num_seqs == len(silence_begin) + assert num_seqs == len(silence_end) + total_num_sil = sum(silence_begin) + sum(silence_intra) + sum(silence_end) + avg_sil_begin = sum(silence_begin) / num_seqs + avg_sil_intra = sum(silence_intra) / len(silence_intra) if len(silence_intra) > 0 else 0 + avg_sil_end = sum(silence_end) / num_seqs + avg_cart = sum(cart_lengths) / len(cart_lengths) + avg_hmm0 = sum(hmm0_lengths) / len(hmm0_lengths) + avg_hmm1 = sum(hmm1_lengths) / len(hmm1_lengths) + avg_hmm2 = sum(hmm2_lengths) / len(hmm2_lengths) + avg_phon = sum(phon_lengths) / len(phon_lengths) + + total_num_frames = 0 + for _, v in alignments.items(): + for label, length in v: + total_num_frames += int(length) + + + with open(f"{output_dir}/statistics.txt", "wt") as out_stats: + out_stats.write(f"average silence length at sequence begin: {avg_sil_begin:.2f}\n") + out_stats.write(f"average silence length intra sequence : {avg_sil_intra:.2f}\n") + out_stats.write(f"average silence length at sequence end : {avg_sil_end:.2f}\n") + out_stats.write(f"average cart label length : {avg_cart:.2f}\n") + out_stats.write(f"average 0. hmm state length : {avg_hmm0:.2f}\n") + out_stats.write(f"average 1. hmm state length : {avg_hmm1:.2f}\n") + out_stats.write(f"average 2. hmm state length : {avg_hmm2:.2f}\n") + out_stats.write(f"average phoneme label length : {avg_phon:.2f}\n") + out_stats.write(f"average number of frames per sequence : {total_num_frames/num_seqs:.2f}\n") + out_stats.write(f"total number of silence frames : {total_num_sil:.0f}\n") + out_stats.write(f"total number of frames : {total_num_frames:.0f}\n") + out_stats.write(f"number of sequences : {num_seqs:.0f}\n") + + + print("creating plots") + # *** data to pandas dataframe *** + sil_begin_dataframe = hist_data_to_dataframe("begin silence lengths", "occurences", sil_hist_begin) + sil_intra_dataframe = hist_data_to_dataframe("intra silence lengths", "occurences", sil_hist_intra) + sil_end_dataframe = hist_data_to_dataframe("end silence lengths", "occurences", sil_hist_end) + cart_dataframe = hist_data_to_dataframe("cart lengths", "occurences", cart_hist) + hmm0_dataframe = hist_data_to_dataframe("hmm 0 lengths", "occurences", hmm0_hist) + hmm1_dataframe = hist_data_to_dataframe("hmm 1 lengths", "occurences", hmm1_hist) + hmm2_dataframe = hist_data_to_dataframe("hmm 2 lengths", "occurences", hmm2_hist) + phon_dataframe = hist_data_to_dataframe("phon lengths", "occurences", phon_hist) + + # *** plot histogram *** + sil_begin_dataframe.plot(x="begin silence lengths", y="occurences", logy=True).get_figure().savefig(f"{plot_dir}/silence_begin_histogram.png") + sil_intra_dataframe.plot(x="intra silence lengths", y="occurences", logy=True).get_figure().savefig(f"{plot_dir}/silence_intra_histogram.png") + sil_end_dataframe.plot(x="end silence lengths", y="occurences", logy=True).get_figure().savefig(f"{plot_dir}/silence_end_histogram.png") + cart_dataframe.plot(x="cart lengths", y="occurences", logy=True).get_figure().savefig(f"{plot_dir}/cart_label_histogram.png") + hmm0_dataframe.plot(x="hmm 0 lengths", y="occurences", logy=True).get_figure().savefig(f"{plot_dir}/hmm0_histogram.png") + hmm1_dataframe.plot(x="hmm 1 lengths", y="occurences", logy=True).get_figure().savefig(f"{plot_dir}/hmm1_histogram.png") + hmm2_dataframe.plot(x="hmm 2 lengths", y="occurences", logy=True).get_figure().savefig(f"{plot_dir}/hmm2_histogram.png") + phon_dataframe.plot(x="phon lengths", y="occurences", logy=True).get_figure().savefig(f"{plot_dir}/phon_label_histogram.png") + + +if __name__ == "__main__": + parser = argparse.ArgumentParser(description="alignment statistics") + parser.add_argument("allophones", nargs=1, type=str, help="allophone file path") + parser.add_argument("alignments", nargs="*", type=str, help="alignment file paths") + parser.add_argument("--root_dir", nargs=1, type=str, help="output directory path") + parser.add_argument("--sub_dir", nargs=1, type=str, help="plot directory path") + parser.add_argument("--silence_symbol", nargs=1, type=str, help="which silence symbol to use", default=["[SILENCE]{#+#}@i@f"]) + parser.add_argument("--non_speech_symbol", nargs=1, type=str, help="which non speech symbol to use", default=["["]) + args = parser.parse_args() + + assert len(args.allophones) == 1 + allophones_path = args.allophones[0] + assert os.path.isfile(allophones_path) + + assert len(args.root_dir) == 1 + root_dir = args.root_dir[0] + assert len(args.sub_dir) == 1 + sub_dir = args.sub_dir[0] + output_dir = os.path.join(root_dir, "statistics", sub_dir) + if not os.path.exists(output_dir): + os.makedirs(output_dir) + plot_dir = os.path.join(root_dir, "plots", sub_dir) + if not os.path.exists(plot_dir): + os.makedirs(plot_dir) + + alignments_path = args.alignments + + assert len(args.silence_symbol) == 1 + silence_symbol = args.silence_symbol[0] + + assert len(args.non_speech_symbol) == 1 + non_speech_symbol = args.non_speech_symbol[0] + + intermediate = main(allophones_path, alignments_path, output_dir, silence_symbol, non_speech_symbol) + + plot(output_dir, plot_dir, intermediate) + diff --git a/users/raissi/setups/common/analysis/labels.py b/users/raissi/setups/common/analysis/labels.py new file mode 100644 index 000000000..99204a2f2 --- /dev/null +++ b/users/raissi/setups/common/analysis/labels.py @@ -0,0 +1,610 @@ +__all__ = ["ComputeSilenceRatioJob", "ComputeAveragePhonemeLengthJob", "ComputeLabelStatisticsJob"] + +from collections import Counter, defaultdict +import itertools +import logging +from typing import List, Union + +from sisyphus import tk, Job, Task + +import i6_core.lib.rasr_cache as rasr_cache + + +class ComputeSilenceRatioJob(Job): + def __init__( + self, + allophone_file: tk.Path, + alignment_files: Union[tk.Path, List[tk.Path]], + silence_label: str, + ): + self.allophone_file = allophone_file + self.alignment_files = alignment_files + self.silence_label = silence_label + + self.out_silence_frames = self.output_var("silence_frames.txt") + self.out_total_frames = self.output_var("total_frames.txt") + self.out_silence_ratio = self.output_var("silence_ratio.txt") + + self.rqmt = {"cpu": 1, "mem": 24, "time": 24, "sbatch_args": ["-p", "cpu_slow"]} + + def tasks(self): + yield Task("run", rqmt=self.rqmt) + + @staticmethod + def load_alignment(allophones_file: tk.Path, alignment_file: Union[tk.Path, rasr_cache.FileArchive]): + if isinstance(alignment_file, tk.Path): + f = rasr_cache.FileArchive(alignment_file.get_path()) + f.setAllophones(allophones_file.get_path()) + elif isinstance(alignment_file, rasr_cache.FileArchive): + f = alignment_file + else: + raise NotImplementedError + + alignments = [] + for i, k in enumerate(f.ft): + finfo = f.ft[k] + if "attrib" not in finfo.name: + alignment = [(f.allophones[mix], state) for time, mix, state, _ in f.read(finfo.name, "align")] + alignments.append(alignment) + return alignments + + @staticmethod + def count(alignment, silence_symbol): + silence_frames = list() + total_frames = list() + for cur_label, val in itertools.groupby(alignment): + v_len = len(list(val)) + if cur_label[0] == silence_symbol: + print("silence:", cur_label, v_len) + silence_frames.append(v_len) + + print("frame:", cur_label, v_len) + total_frames.append(v_len) + + return sum(silence_frames), sum(total_frames) + + def run(self): + logging.info("Collection statistics...") + if isinstance(self.alignment_files, List): + num_alignments = len(self.alignment_files) + alignment_files = self.alignment_files + elif isinstance(self.alignment_files, tk.Path): + if self.alignment_files.get_path().endswith(".bundle"): + bundle_file = rasr_cache.FileArchiveBundle(self.alignment_files.get_path()) + bundle_file.setAllophones(self.allophone_file.get_path()) + alignment_files = list(bundle_file.archives.values()) + num_alignments = len(alignment_files) + else: + alignment_files = [self.alignment_files] + num_alignments = 1 + else: + raise NotImplementedError + + silence_frames = [] + total_frames = [] + + for i, ap in enumerate(alignment_files, start=1): + logging.info(f"Alignment: {i}/{num_alignments}") + alignment_content = self.load_alignment(self.allophone_file, ap) + for align in alignment_content: + seg_silence_frames, seg_total_frames = self.count(align, self.silence_label) + silence_frames.append(seg_silence_frames) + total_frames.append(seg_total_frames) + + sum_silence_frames = sum(silence_frames) + sum_total_frames = sum(total_frames) + + self.out_silence_frames.set(sum_silence_frames) + self.out_total_frames.set(sum_total_frames) + self.out_silence_ratio.set(sum_silence_frames / sum_total_frames) + + +class ComputeAveragePhonemeLengthJob(Job): + def __init__( + self, + allophone_file: tk.Path, + alignment_files: Union[tk.Path, List[tk.Path]], + silence_label: str, + non_speech_labels: Union[str, List[str]], + ): + self.allophone_file = allophone_file + self.alignment_files = alignment_files + self.silence_label = silence_label + self.non_speech_labels = non_speech_labels + + self.out_average_phoneme_length = self.output_var("average_phoneme_length.txt") + self.out_average_phoneme_length_state_0 = self.output_var("average_phoneme_length_state_0.txt") + self.out_average_phoneme_length_state_1 = self.output_var("average_phoneme_length_state_1.txt") + self.out_average_phoneme_length_state_2 = self.output_var("average_phoneme_length_state_2.txt") + self.out_average_phoneme_length_with_non_speech = self.output_var("average_phoneme_length_with_non_speech.txt") + self.out_total_frames = self.output_var("total_frames.txt") + self.out_num_seqs = self.output_var("num_seqs.txt") + + self.rqmt = {"cpu": 1, "mem": 24, "time": 24, "sbatch_args": ["-p", "cpu_slow"]} + + def tasks(self): + yield Task("run", rqmt=self.rqmt) + + @staticmethod + def load_alignment(allophones_file: tk.Path, alignment_file: Union[tk.Path, rasr_cache.FileArchive]): + if isinstance(alignment_file, tk.Path): + f = rasr_cache.FileArchive(alignment_file.get_path()) + f.setAllophones(allophones_file.get_path()) + elif isinstance(alignment_file, rasr_cache.FileArchive): + f = alignment_file + else: + raise NotImplementedError + + alignments = [] + for i, k in enumerate(f.ft): + finfo = f.ft[k] + if "attrib" not in finfo.name: + alignment = [(f.allophones[mix], state) for time, mix, state, _ in f.read(finfo.name, "align")] + alignments.append(alignment) + return alignments + + @staticmethod + def count(alignment, silence_symbol, non_speech_symbols): + hmm_lengths = list() + hmm_unk_lengths = list() + hmm_0_lengths = list() + hmm_1_lengths = list() + hmm_2_lengths = list() + hmm_num = 0 + hmm_unk_num = 0 + hmm_0_num = 0 + hmm_1_num = 0 + hmm_2_num = 0 + total_frames = list() + + for cur_label, val in itertools.groupby(alignment): + v_len = len(list(val)) + total_frames.append(v_len) + + if cur_label[0].strip() == silence_symbol: + continue + + hmm_unk_lengths.append(v_len) + hmm_unk_num += 1 + + if cur_label[0].strip() in non_speech_symbols: + continue + + hmm_lengths.append(v_len) + hmm_num += 1 + + if cur_label[1] == 0: + hmm_0_lengths.append(v_len) + hmm_0_num += 1 + if cur_label[1] == 1: + hmm_1_lengths.append(v_len) + hmm_1_num += 1 + if cur_label[1] == 2: + hmm_2_lengths.append(v_len) + hmm_2_num += 1 + + return ( + hmm_lengths, + hmm_num, + hmm_0_lengths, + hmm_0_num, + hmm_1_lengths, + hmm_1_num, + hmm_2_lengths, + hmm_2_num, + total_frames, + hmm_unk_lengths, + hmm_unk_num, + ) + + def run(self): + logging.info("Collection statistics...") + if isinstance(self.alignment_files, List): + num_alignments = len(self.alignment_files) + alignment_files = self.alignment_files + elif isinstance(self.alignment_files, tk.Path): + if self.alignment_files.get_path().endswith(".bundle"): + bundle_file = rasr_cache.FileArchiveBundle(self.alignment_files.get_path()) + bundle_file.setAllophones(self.allophone_file.get_path()) + alignment_files = list(bundle_file.archives.values()) + num_alignments = len(alignment_files) + else: + alignment_files = [self.alignment_files] + num_alignments = 1 + else: + raise NotImplementedError + + num_seqs = 0 + hmm_lengths = 0 + hmm_unk_lengths = 0 + hmm_0_lengths = 0 + hmm_1_lengths = 0 + hmm_2_lengths = 0 + hmm_num = 0 + hmm_unk_num = 0 + hmm_0_num = 0 + hmm_1_num = 0 + hmm_2_num = 0 + total_frames = 0 + + for i, ap in enumerate(alignment_files, start=1): + logging.info(f"Alignment: {i}/{num_alignments}") + alignment_content = self.load_alignment(self.allophone_file, ap) + for align in alignment_content: + num_seqs += 1 + ( + seg_hmm_lengths, + seg_hmm_num, + seg_hmm_0_lengths, + seg_hmm_0_num, + seg_hmm_1_lengths, + seq_hmm_1_num, + seg_hmm_2_lengths, + seg_hmm_2_num, + seg_total_frames, + seg_hmm_unk_lengths, + seg_hmm_unk_num, + ) = self.count( + align, + self.silence_label, + self.non_speech_labels, + ) + hmm_lengths += sum(seg_hmm_lengths) + hmm_0_lengths += sum(seg_hmm_0_lengths) + hmm_1_lengths += sum(seg_hmm_1_lengths) + hmm_2_lengths += sum(seg_hmm_2_lengths) + hmm_unk_lengths += sum(seg_hmm_unk_lengths) + hmm_num += seg_hmm_num + hmm_0_num += seg_hmm_0_num + hmm_1_num += seq_hmm_1_num + hmm_2_num += seg_hmm_2_num + hmm_unk_num += seg_hmm_unk_num + total_frames += sum(seg_total_frames) + + self.out_average_phoneme_length.set(hmm_lengths / hmm_num) + self.out_average_phoneme_length_with_non_speech.set(hmm_unk_lengths / hmm_unk_num) + self.out_average_phoneme_length_state_0.set(hmm_0_lengths / hmm_0_num) + self.out_average_phoneme_length_state_1.set(hmm_1_lengths / hmm_1_num if hmm_1_num > 0 else 0) + self.out_average_phoneme_length_state_2.set(hmm_2_lengths / hmm_2_num if hmm_2_num > 0 else 0) + self.out_total_frames.set(total_frames) + self.out_num_seqs.set(num_seqs) + + +class ComputeLabelStatisticsJob(Job): + def __init__( + self, + allophone_file: tk.Path, + alignment_files: Union[tk.Path, List[tk.Path]], + silence_label: str, + non_speech_labels: Union[str, List[str]], + ): + self.allophone_file = allophone_file + self.alignment_files = alignment_files + self.silence_label = silence_label + self.non_speech_labels = non_speech_labels + + self.out_counts = self.output_var("counts.pickle", pickle=True) + self.out_label_lengths = self.output_var("label_lengths.txt") + self.out_statistics = self.output_path("statistics.txt") + self.out_silence_begin_histogram = self.output_path("silence_begin_histogram.png") + self.out_silence_intra_histogram = self.output_path("silence_intra_histogram.png") + self.out_silence_end_histogram = self.output_path("silence_end_histogram.png") + self.out_hmm_histogram = self.output_path("hmm_label_histogram.png") + self.out_hmm_0_histogram = self.output_path("hmm_0_histogram.png") + self.out_hmm_1_histogram = self.output_path("hmm_1_histogram.png") + self.out_hmm_2_histogram = self.output_path("hmm_2_histogram.png") + self.out_phoneme_histogram = self.output_path("label_histogram.png") + + self.rqmt = {"cpu": 1, "mem": 24, "time": 24, "sbatch_args": ["-p", "cpu_slow"]} + + def tasks(self): + yield Task("count", rqmt=self.rqmt) + yield Task("plot", rqmt=self.rqmt) + + @staticmethod + def load_alignment(allophones_file: tk.Path, alignment_file: Union[tk.Path, rasr_cache.FileArchive]): + if isinstance(alignment_file, tk.Path): + f = rasr_cache.FileArchive(alignment_file.get_path()) + f.setAllophones(allophones_file.get_path()) + elif isinstance(alignment_file, rasr_cache.FileArchive): + f = alignment_file + else: + raise NotImplementedError + + alignments = [] + for i, k in enumerate(f.ft): + finfo = f.ft[k] + if "attrib" not in finfo.name: + alignment = [(f.allophones[mix], state) for time, mix, state, _ in f.read(finfo.name, "align")] + alignments.append(alignment) + return alignments + + @staticmethod + def count_hmm_states(alignment): + label_lengths = list() + for cur_label, val in itertools.groupby(alignment): + label_lengths.append(tuple([cur_label, len(list(val))])) + return label_lengths + + @staticmethod + def count_merge_hmm_states(alignment): + label_lengths = list() + for cur_label, val in itertools.groupby(alignment, key=lambda t: t[0]): + label_lengths.append(tuple([cur_label, len(list(val))])) + return label_lengths + + @staticmethod + def count_hmm_lengths(count, silence_symbol): + hmm_lengths = [] + hmm0_lengths = [] + hmm1_lengths = [] + hmm2_lengths = [] + for label, length in count: + if isinstance(silence_symbol, str): + if label[0].strip().find(silence_symbol) == 0: + continue + elif isinstance(silence_symbol, List): + for s in silence_symbol: + if label[0].strip().find(s) == 0: + continue + else: + raise NotImplementedError + + hmm_lengths.append(length) + if label[1] == 0: + hmm0_lengths.append(length) + if label[1] == 1: + hmm1_lengths.append(length) + if label[1] == 2: + hmm2_lengths.append(length) + return hmm_lengths, hmm0_lengths, hmm1_lengths, hmm2_lengths + + @staticmethod + def count_phon_lengths(count, silence_symbol): + phon_lengths = [] + for label, length in count: + if isinstance(silence_symbol, str): + if label.strip().find(silence_symbol) == 0: + continue + elif isinstance(silence_symbol, List): + for s in silence_symbol: + if label.strip().find(s) == 0: + continue + else: + raise NotImplementedError + + phon_lengths.append(length) + return phon_lengths + + @staticmethod + def count_silence(count, silence_symbol): + if count[0][0][0].strip().find(silence_symbol) == 0: + sil_begin_length = count.pop(0)[1] + else: + sil_begin_length = 0 + if count[-1][0][0].strip().find(silence_symbol) == 0: + sil_end_length = count.pop(-1)[1] + else: + sil_end_length = 0 + sil_middle_length = [] + for label, length in count: + if label[0].strip().find(silence_symbol) == 0: + sil_middle_length.append(length) + return [sil_begin_length], sil_middle_length, [sil_end_length] + + @staticmethod + def hist_data_to_dataframe(x_label, y_label, data_dict): + import pandas + + d_t = defaultdict(list) + for k, v in sorted(data_dict.items()): + d_t[x_label].append(k) + d_t[y_label].append(v) + + df = pandas.DataFrame(data=d_t) + + return df + + def count(self): + logging.info("Collection statistics...") + if isinstance(self.alignment_files, List): + num_alignments = len(self.alignment_files) + alignment_files = self.alignment_files + elif isinstance(self.alignment_files, tk.Path): + if self.alignment_files.get_path().endswith(".bundle"): + bundle_file = rasr_cache.FileArchiveBundle(self.alignment_files.get_path()) + bundle_file.setAllophones(self.allophone_file.get_path()) + alignment_files = list(bundle_file.archives.values()) + num_alignments = len(alignment_files) + else: + alignment_files = [self.alignment_files] + num_alignments = 1 + else: + raise NotImplementedError + + labels_counter = defaultdict(list) + labels_merged_counter = defaultdict(list) + silence_begin_counter = list() + silence_intra_counter = list() + silence_end_counter = list() + silence_begin_histogram = Counter() + silence_end_histogram = Counter() + silence_intra_histogram = Counter() + hmm_histogram = Counter() + hmm_0_histogram = Counter() + hmm_1_histogram = Counter() + hmm_2_histogram = Counter() + phoneme_histogram = Counter() + phoneme_counter = list() + hmm_counter = list() + hmm_0_counter = list() + hmm_1_counter = list() + hmm_2_counter = list() + + idx = 0 + for i, ap in enumerate(alignment_files, start=1): + logging.info(f"Alignment: {i}/{num_alignments}") + alignment_content = self.load_alignment(self.allophone_file, ap) + for align in alignment_content: + labels_counter[idx] = count = self.count_hmm_states(align) + labels_merged_counter[idx] = count_merge = self.count_merge_hmm_states(align) + + sil_begin, sil_intra, sil_end = self.count_silence(count, self.silence_label) + + silence_begin_counter.extend(sil_begin) + silence_intra_counter.extend(sil_intra) + silence_end_counter.extend(sil_end) + silence_begin_histogram[sil_begin[0]] += 1 + silence_end_histogram[sil_end[0]] += 1 + for ii in sil_intra: + silence_intra_histogram[i] += 1 + + hmm_lengths, hmm0_lengths, hmm1_lengths, hmm2_lengths = self.count_hmm_lengths( + count, self.non_speech_labels + ) + for hmm in hmm_lengths: + hmm_histogram[hmm] += 1 + for h0 in hmm0_lengths: + hmm_0_histogram[h0] += 1 + for h1 in hmm1_lengths: + hmm_1_histogram[h1] += 1 + for h2 in hmm2_lengths: + hmm_2_histogram[h2] += 1 + + phon_lengths = self.count_phon_lengths(count_merge, self.non_speech_labels) + for phon in phon_lengths: + phoneme_histogram[phon] += 1 + + phoneme_counter.extend(phon_lengths) + hmm_counter.extend(hmm_lengths) + hmm_0_counter.extend(hmm0_lengths) + hmm_1_counter.extend(hmm1_lengths) + hmm_2_counter.extend(hmm2_lengths) + + idx += 1 + + del alignment_content, alignment_files + + results = [ + labels_counter, + labels_merged_counter, + silence_begin_counter, + silence_intra_counter, + silence_end_counter, + silence_begin_histogram, + silence_intra_histogram, + silence_end_histogram, + hmm_counter, + hmm_0_counter, + hmm_1_counter, + hmm_2_counter, + phoneme_counter, + hmm_histogram, + hmm_0_histogram, + hmm_1_histogram, + hmm_2_histogram, + phoneme_histogram, + ] + + logging.info("Pickling...") + self.out_counts.set(tuple(results)) + + def plot(self): + logging.info("Unpickling") + ( + labels_counter, + labels_merged_counter, + silence_begin_counter, + silence_intra_counter, + silence_end_counter, + silence_begin_histogram, + silence_intra_histogram, + silence_end_histogram, + hmm_counter, + hmm_0_counter, + hmm_1_counter, + hmm_2_counter, + phoneme_counter, + hmm_histogram, + hmm_0_histogram, + hmm_1_histogram, + hmm_2_histogram, + phoneme_histogram, + ) = self.out_counts.get() + + # *** stat calculation *** + logging.info("Calculating averages") + num_seqs = len(labels_counter.keys()) + assert num_seqs == len(silence_begin_counter), (num_seqs, len(silence_begin_counter)) + assert num_seqs == len(silence_end_counter), (num_seqs, len(silence_end_counter)) + total_num_sil = sum(silence_begin_counter) + sum(silence_intra_counter) + sum(silence_end_counter) + avg_sil_begin = sum(silence_begin_counter) / num_seqs + avg_sil_intra = sum(silence_intra_counter) / len(silence_intra_counter) if len(silence_intra_counter) > 0 else 0 + avg_sil_end = sum(silence_end_counter) / num_seqs + avg_hmm = sum(hmm_counter) / len(hmm_counter) + avg_hmm0 = sum(hmm_0_counter) / len(hmm_0_counter) + avg_hmm1 = sum(hmm_1_counter) / len(hmm_1_counter) if len(hmm_1_counter) > 0 else 0 + avg_hmm2 = sum(hmm_2_counter) / len(hmm_2_counter) if len(hmm_2_counter) > 0 else 0 + avg_phon = sum(phoneme_counter) / len(phoneme_counter) + + total_num_frames = 0 + for _, v in labels_counter.items(): + for label, length in v: + total_num_frames += int(length) + + with open(self.out_statistics.get_path(), "wt") as out_stats: + out_stats.write(f"average silence length at sequence begin: {avg_sil_begin:.2f}\n") + out_stats.write(f"average silence length intra sequence : {avg_sil_intra:.2f}\n") + out_stats.write(f"average silence length at sequence end : {avg_sil_end:.2f}\n") + out_stats.write(f"average cart label length : {avg_hmm:.2f}\n") + out_stats.write(f"average 0. hmm state length : {avg_hmm0:.2f}\n") + out_stats.write(f"average 1. hmm state length : {avg_hmm1:.2f}\n") + out_stats.write(f"average 2. hmm state length : {avg_hmm2:.2f}\n") + out_stats.write(f"average phoneme label length : {avg_phon:.2f}\n") + out_stats.write(f"average number of frames per sequence : {total_num_frames / num_seqs:.2f}\n") + out_stats.write(f"total number of silence frames : {total_num_sil:.0f}\n") + out_stats.write(f"total number of frames : {total_num_frames:.0f}\n") + out_stats.write(f"number of sequences : {num_seqs:.0f}\n") + + print("creating plots") + # *** data to pandas dataframe *** + sil_begin_dataframe = self.hist_data_to_dataframe( + "begin silence lengths", "occurences", silence_begin_histogram + ) + sil_intra_dataframe = self.hist_data_to_dataframe( + "intra silence lengths", "occurences", silence_intra_histogram + ) + sil_end_dataframe = self.hist_data_to_dataframe("end silence lengths", "occurences", silence_end_histogram) + cart_dataframe = self.hist_data_to_dataframe("hmm lengths", "occurences", hmm_histogram) + hmm0_dataframe = self.hist_data_to_dataframe("hmm 0 lengths", "occurences", hmm_0_histogram) + hmm1_dataframe = self.hist_data_to_dataframe("hmm 1 lengths", "occurences", hmm_1_histogram) + hmm2_dataframe = self.hist_data_to_dataframe("hmm 2 lengths", "occurences", hmm_2_histogram) + phon_dataframe = self.hist_data_to_dataframe("phon lengths", "occurences", phoneme_histogram) + + # *** plot histogram *** + sil_begin_dataframe.plot(x="begin silence lengths", y="occurences", logy=True).get_figure().savefig( + self.out_silence_begin_histogram.get_path() + ) + sil_intra_dataframe.plot(x="intra silence lengths", y="occurences", logy=True).get_figure().savefig( + self.out_silence_intra_histogram.get_path() + ) + sil_end_dataframe.plot(x="end silence lengths", y="occurences", logy=True).get_figure().savefig( + self.out_silence_end_histogram.get_path() + ) + cart_dataframe.plot(x="hmm lengths", y="occurences", logy=True).get_figure().savefig( + self.out_hmm_histogram.get_path() + ) + hmm0_dataframe.plot(x="hmm 0 lengths", y="occurences", logy=True).get_figure().savefig( + self.out_hmm_0_histogram.get_path() + ) + if len(hmm_1_counter) > 0: + hmm1_dataframe.plot(x="hmm 1 lengths", y="occurences", logy=True).get_figure().savefig( + self.out_hmm_1_histogram.get_path() + ) + if len(hmm_2_counter) > 0: + hmm2_dataframe.plot(x="hmm 2 lengths", y="occurences", logy=True).get_figure().savefig( + self.out_hmm_2_histogram.get_path() + ) + phon_dataframe.plot(x="phon lengths", y="occurences", logy=True).get_figure().savefig( + self.out_phoneme_histogram.get_path() + ) diff --git a/users/raissi/setups/common/analysis/phoneme_length_statistics.py b/users/raissi/setups/common/analysis/phoneme_length_statistics.py new file mode 100755 index 000000000..9426e326b --- /dev/null +++ b/users/raissi/setups/common/analysis/phoneme_length_statistics.py @@ -0,0 +1,124 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- + +import argparse +import collections +import itertools as it +import matplotlib.pyplot as plt +import os +import pandas as pd +import pickle +import sys + +import sprint_cache as sc + +from frame_statistics import load_alignment + + +def get_phoneme(label): + return label.strip().split("{")[0] + + +def main(allophones_path, alignments_path, output_dir): + pickle_path = f"{output_dir}/data2.pickle" + + single_phoneme_lengths = collections.defaultdict(list) + long_sequences = list() + + if not os.path.isfile(pickle_path): + print("collecting statistics") + num_alignments = len(alignments_path) + for i, ap in enumerate(alignments_path): + print(f"alignment: {i+1}/{num_alignments}") + assert os.path.isfile(ap), ap + alignment = load_alignment(allophones_path, ap) + for align in alignment: + for cur_label, val in it.groupby(align, key=lambda t : t[0]): + single_phon = get_phoneme(cur_label) + label_length = len(list(val)) + single_phoneme_lengths[single_phon].append(label_length) + if label_length >= 50: + long_sequences.append(tuple([single_phon, label_length, align])) + + results = [single_phoneme_lengths, long_sequences] + + with open(pickle_path, "wb") as out_pickle: + data_dump = tuple(results) + pickle.dump(data_dump, out_pickle, protocol=4) # protocol version4 for python 3.4+ support + else: + print("found pickled statistics") + with open(pickle_path, "rb") as in_pickle: + results = pickle.load(in_pickle) + + return results + + +def hist_data_to_dataframe(x_label, y_label, data_dict): + d_t = collections.defaultdict(list) + for k, v in sorted(data_dict.items()): + d_t[x_label].append(k) + d_t[y_label].append(v) + + df = pd.DataFrame(data=d_t) + + return df + + +def plot(output_dir, plot_dir, inputs): + long_sequences_path = f"{output_dir}/long_sequences.txt" + print("calculating averages") + single_phoneme_lengths, long_sequences = inputs + # *** dump stats *** + with open(long_sequences_path, "wt") as out_seqs: + for seq in long_sequences: + out_seqs.write(f"{seq}\n\n") + + with open(f"{output_dir}/phoneme_lengths.txt", "wt") as out_stats: + out_stats.write("average phoneme length") + for k, v in sorted(single_phoneme_lengths.items()): + avg = sum(v)/len(v) + out_stats.write(f"{k}: {avg:.2f}\n") + + + print("creating plots") + # *** data to pandas dataframe *** + for label, lengths in sorted(single_phoneme_lengths.items()): + hist = collections.defaultdict(int) + for l in lengths: + hist[l] += 1 + + phon_df = hist_data_to_dataframe(f"phoneme label lengths {label}", "occurences", hist) + + # *** plot histogram *** + phon_df.plot(x=f"phoneme label lengths {label}", y="occurences", logy=True).get_figure().savefig(f"{plot_dir}/phoneme_{label}.png") + + +if __name__ == "__main__": + parser = argparse.ArgumentParser(description="alignment statistics") + parser.add_argument("allophones", nargs=1, type=str, help="allophone file path") + parser.add_argument("alignments", nargs="*", type=str, help="alignment file paths") + parser.add_argument("--root_dir", nargs=1, type=str, help="output directory path") + parser.add_argument("--sub_dir", nargs=1, type=str, help="plot directory path") + args = parser.parse_args() + + assert len(args.allophones) == 1 + allophones_path = args.allophones[0] + assert os.path.isfile(allophones_path) + + assert len(args.root_dir) == 1 + root_dir = args.root_dir[0] + assert len(args.sub_dir) == 1 + sub_dir = args.sub_dir[0] + output_dir = os.path.join(root_dir, "statistics", sub_dir) + if not os.path.exists(output_dir): + os.makedirs(output_dir) + plot_dir = os.path.join(root_dir, "plots", sub_dir) + if not os.path.exists(plot_dir): + os.makedirs(plot_dir) + + alignments_path = args.alignments + + intermediate = main(allophones_path, alignments_path, output_dir) + + plot(output_dir, plot_dir, intermediate) + diff --git a/users/raissi/setups/common/decoder/BASE_factored_hybrid_search.py b/users/raissi/setups/common/decoder/BASE_factored_hybrid_search.py index c27141a02..61bfbeb1f 100644 --- a/users/raissi/setups/common/decoder/BASE_factored_hybrid_search.py +++ b/users/raissi/setups/common/decoder/BASE_factored_hybrid_search.py @@ -948,6 +948,8 @@ def recognize( name_after_rerun = re.sub(r"Lm[0-9]*.[0.9*]", f"Lm{rounded_lm_scale}", name) name_prefix_len = len(f"{name_prefix}{self.name}/") + #in order to have access afterwards to the lm scale mainly + self.tuned_params = params return self.recognize( add_sis_alias_and_output=add_sis_alias_and_output, diff --git a/users/raissi/setups/common/helpers/train/network_params.py b/users/raissi/setups/common/helpers/train/network_params.py index 03be19583..9e8a055c2 100644 --- a/users/raissi/setups/common/helpers/train/network_params.py +++ b/users/raissi/setups/common/helpers/train/network_params.py @@ -83,7 +83,25 @@ def get_sa_name(self): #Conformer from-scratch -frameshift40_conformer_fullsum_from_scratch = GeneralNetworkParams( +frameshift40_conformer_fullsum_from_scratch_multi_nomlp = GeneralNetworkParams( + l2=5e-6, + use_multi_task=True, + add_mlps=False, + specaug_args=asdict(default_sa_args), + frame_rate_reduction_ratio_factor=4, + auxilary_loss_layers=[], +) + +frameshift40_conformer_fullsum_from_scratch_multi_mlp = GeneralNetworkParams( + l2=5e-6, + use_multi_task=True, + add_mlps=True, + specaug_args=asdict(default_sa_args), + frame_rate_reduction_ratio_factor=4, + auxilary_loss_layers=[], +) + +frameshift40_conformer_fullsum_from_scratch= GeneralNetworkParams( l2=5e-6, use_multi_task=False, add_mlps=False, diff --git a/users/raissi/setups/swb/legacy/SWB_TF_factored_hybrid_system.py b/users/raissi/setups/swb/legacy/SWB_TF_factored_hybrid_system.py index b4916131a..ca1cdd8a2 100644 --- a/users/raissi/setups/swb/legacy/SWB_TF_factored_hybrid_system.py +++ b/users/raissi/setups/swb/legacy/SWB_TF_factored_hybrid_system.py @@ -197,6 +197,9 @@ def __init__( } # 1/9 for 3-state, same amount of silence } + self.transcript_prior_xml = {"monostate": ("/").join( + [self.dependencies_path, "haotian/monostate/monostate.we.transcript.prior.xml"] + ),} # -------------------- External helpers -------------------- From cb8687953c3341089a9ac4e502239be134ab9ad6 Mon Sep 17 00:00:00 2001 From: schmitt Date: Thu, 6 Jun 2024 11:14:48 +0200 Subject: [PATCH 167/227] update --- .../segmental/model_new/blank_model/train.py | 47 ++++++++++++++----- 1 file changed, 35 insertions(+), 12 deletions(-) diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/blank_model/train.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/blank_model/train.py index 0d961b411..7c03707fb 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/blank_model/train.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/blank_model/train.py @@ -141,9 +141,18 @@ def viterbi_training_v4( emit_blank_target_dim: Dim, batch_dims: List[Dim], ): - enc_spatial_dim.declare_same_as(non_blank_mask_dim) + # using dim.declare_same_as() leads to an error after an epoch is finished + # (UnicodeDecodeError: 'ascii' codec can't decode byte 0xe2 in position 0: ordinal not in range(128)) + # therefore, we use the following workaround + enc = enc_args["enc"] # type: rf.Tensor + enc_raw = enc.raw_tensor + enc = enc.copy_template_replace_dim_tag( + enc.get_axis_from_description(enc_spatial_dim), non_blank_mask_dim + ) + enc.raw_tensor = enc_raw + am, _ = utils.get_masked( - input=enc_args["enc"], + input=enc, mask=non_blank_mask, mask_dim=non_blank_mask_dim, batch_dims=batch_dims, @@ -152,9 +161,9 @@ def viterbi_training_v4( singleton_dim = Dim(name="singleton", dimension=1) first_enc_frame = rf.gather( - enc_args["enc"], + enc, indices=rf.convert_to_tensor(0, dtype="int32"), - axis=enc_spatial_dim, + axis=non_blank_mask_dim, ) first_enc_frame = rf.expand_dim(first_enc_frame, singleton_dim) am, _ = rf.concat( @@ -178,7 +187,7 @@ def viterbi_training_v4( blank_logits_packed, pack_dim, emit_ground_truth_packed = get_packed_logits_and_emit_ground_truth( blank_logits=model.decode_logits(s_blank=s_unmasked), - align_targets_spatial_dim=enc_spatial_dim, + align_targets_spatial_dim=non_blank_mask_dim, emit_ground_truth=emit_ground_truth, batch_dims=batch_dims ) @@ -202,11 +211,18 @@ def viterbi_training_v5( emit_blank_target_dim: Dim, batch_dims: List[Dim], ): - enc_spatial_dim.declare_same_as(label_states_unmasked_spatial_dim) - blank_logits = model.emit_prob(rf.concat_features(enc_args["enc"], label_states_unmasked)) + # using dim.declare_same_as() leads to an error after an epoch is finished (see viterbi_training_v4) + enc = enc_args["enc"] # type: rf.Tensor + enc_raw = enc.raw_tensor + enc = enc.copy_template_replace_dim_tag( + enc.get_axis_from_description(enc_spatial_dim), label_states_unmasked_spatial_dim + ) + enc.raw_tensor = enc_raw + + blank_logits = model.emit_prob(rf.concat_features(enc, label_states_unmasked)) blank_logits_packed, pack_dim, emit_ground_truth_packed = get_packed_logits_and_emit_ground_truth( blank_logits=blank_logits, - align_targets_spatial_dim=enc_spatial_dim, + align_targets_spatial_dim=label_states_unmasked_spatial_dim, emit_ground_truth=emit_ground_truth, batch_dims=batch_dims ) @@ -230,16 +246,23 @@ def viterbi_training_v6( emit_blank_target_dim: Dim, batch_dims: List[Dim], ): - enc_spatial_dim.declare_same_as(label_states_unmasked_spatial_dim) + # using dim.declare_same_as() leads to an error after an epoch is finished (see viterbi_training_v4) + enc = enc_args["enc"] # type: rf.Tensor + enc_raw = enc.raw_tensor + enc = enc.copy_template_replace_dim_tag( + enc.get_axis_from_description(enc_spatial_dim), label_states_unmasked_spatial_dim + ) + enc.raw_tensor = enc_raw + s, _ = model.s( - enc_args["enc"], + enc, state=model.s.default_initial_state(batch_dims=batch_dims,), - spatial_dim=enc_spatial_dim + spatial_dim=label_states_unmasked_spatial_dim ) blank_logits = model.emit_prob(rf.concat_features(s, label_states_unmasked)) blank_logits_packed, pack_dim, emit_ground_truth_packed = get_packed_logits_and_emit_ground_truth( blank_logits=blank_logits, - align_targets_spatial_dim=enc_spatial_dim, + align_targets_spatial_dim=label_states_unmasked_spatial_dim, emit_ground_truth=emit_ground_truth, batch_dims=batch_dims ) From c0d85963f87064cd8c1113d729806d34bdfabc53 Mon Sep 17 00:00:00 2001 From: schmitt Date: Fri, 14 Jun 2024 10:33:58 +0200 Subject: [PATCH 168/227] update --- .../global_vs_segmental_2022_23/recog_new.py | 192 +++-- .../returnn/config_builder_rf/base.py | 189 ++++- .../returnn/network_builder_rf/base.py | 105 ++- .../network_builder_rf/global_/decoder.py | 31 +- .../network_builder_rf/global_/model.py | 17 +- .../network_builder_rf/global_/recog.py | 111 ++- .../network_builder_rf/global_/train.py | 4 + .../returnn/network_builder_rf/lm/__init__.py | 0 .../network_builder_rf/lm/lstm/__init__.py | 0 .../network_builder_rf/lm/lstm/model.py | 120 +++ .../lm/lstm/model_import.py | 126 +++ .../network_builder_rf/lm/trafo/__init__.py | 0 .../network_builder_rf/lm/trafo/model.py | 263 ++++++ .../lm/trafo/model_import.py | 127 +++ .../returnn/network_builder_rf/recog.py | 7 +- .../network_builder_rf/segmental/model.py | 22 +- .../segmental/model_new/blank_model/model.py | 12 + .../segmental/model_new/blank_model/train.py | 18 +- .../segmental/model_new/label_model/model.py | 15 +- .../segmental/model_new/label_model/train.py | 794 +----------------- .../segmental/realignment.py | 476 +++++++++++ .../network_builder_rf/segmental/recog.py | 474 ++++++----- .../segmental/recombination.py | 28 +- .../network_builder_rf/segmental/train.py | 298 +++++-- .../network_builder_rf/segmental/utils.py | 70 +- .../center_window_att/baseline_v3/__init__.py | 211 +++-- .../center_window_att/baseline_v3/baseline.py | 2 + .../center_window_att/baseline_v4/__init__.py | 166 ++-- .../center_window_att/config_builder.py | 11 +- .../center_window_att/realign.py | 80 ++ .../center_window_att/recog.py | 1 + .../center_window_att/train.py | 27 +- .../global_att/baseline_v1/__init__.py | 41 +- .../global_att/baseline_v1/baseline.py | 46 +- .../global_att/config_builder.py | 41 + .../pipeline_ls_conf/global_att/recog.py | 7 +- users/schmitt/hdf.py | 69 ++ .../model_interfaces/training.py | 4 + users/schmitt/visualization/visualization.py | 83 +- 39 files changed, 2899 insertions(+), 1389 deletions(-) create mode 100644 users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/lm/__init__.py create mode 100644 users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/lm/lstm/__init__.py create mode 100644 users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/lm/lstm/model.py create mode 100644 users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/lm/lstm/model_import.py create mode 100644 users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/lm/trafo/__init__.py create mode 100644 users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/lm/trafo/model.py create mode 100644 users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/lm/trafo/model_import.py create mode 100644 users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/realignment.py create mode 100644 users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/realign.py create mode 100644 users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/global_att/config_builder.py diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/recog_new.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/recog_new.py index 5e88e111e..c3b8704f3 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/recog_new.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23/recog_new.py @@ -18,7 +18,8 @@ from i6_experiments.users.schmitt.flow import get_raw_wav_feature_flow from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23.dependencies.general.rasr.config import RasrConfigBuilder -from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.config_builder_rf.base import ConfigBuilderRF +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.config_builder_rf.base import ConfigBuilderRF, GlobalAttConfigBuilderRF, SegmentalAttConfigBuilderRF +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.pipelines.pipeline_ls_conf.global_att.config_builder import get_global_att_config_builder_rf from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23.dependencies.returnn.config_builder.base import ConfigBuilder from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23.dependencies.returnn.config_builder.global_ import GlobalConfigBuilder from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23.dependencies.returnn.config_builder.segmental import SegmentalConfigBuilder @@ -41,6 +42,7 @@ TEDLIUM2BPE1057_CTC_ALIGNMENT, ) from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23.dependencies.corpora import tedlium2, librispeech +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.global_.train import _returnn_v2_train_step, from_scratch_training class DecodingExperiment(ABC): @@ -166,28 +168,60 @@ def __init__(self, config_builder: GlobalConfigBuilder, **kwargs): def get_mini_att_checkpoint(self, train_mini_lstm_opts: Dict) -> Checkpoint: assert train_mini_lstm_opts["use_eos"], "trivial for global att but set for clarity" - num_epochs = 10 - train_mini_lstm_exp = GlobalTrainExperiment( - config_builder=self.config_builder, - alias=self.alias, - num_epochs=num_epochs, - train_opts={ - "import_model_train_epoch1": self.checkpoint, - "lr_opts": { - "type": "newbob", - "learning_rate": 1e-4, - "learning_rate_control": "newbob_multi_epoch", - "learning_rate_control_min_num_epochs_per_new_lr": 3, - "learning_rate_control_relative_error_relative_lr": True, - "learning_rate_control_error_measure": "dev_error_label_model/output_prob" - }, - "train_mini_lstm_opts": train_mini_lstm_opts, - "tf_session_opts": {"gpu_options": {"per_process_gpu_memory_fraction": 0.95}}, - "max_seq_length": {"targets": 75} - } - ) - mini_att_checkpoints, model_dir, learning_rates = train_mini_lstm_exp.run_train() + + if isinstance(self.config_builder, GlobalConfigBuilder): + train_mini_lstm_exp = GlobalTrainExperiment( + config_builder=self.config_builder, + alias=self.alias, + num_epochs=num_epochs, + train_opts={ + "import_model_train_epoch1": self.checkpoint, + "lr_opts": { + "type": "newbob", + "learning_rate": 1e-4, + "learning_rate_control": "newbob_multi_epoch", + "learning_rate_control_min_num_epochs_per_new_lr": 3, + "learning_rate_control_relative_error_relative_lr": True, + "learning_rate_control_error_measure": "dev_error_label_model/output_prob" + }, + "train_mini_lstm_opts": train_mini_lstm_opts, + "tf_session_opts": {"gpu_options": {"per_process_gpu_memory_fraction": 0.95}}, + "max_seq_length": {"targets": 75} + } + ) + mini_att_checkpoints, model_dir, learning_rates = train_mini_lstm_exp.run_train() + else: + assert isinstance(self.config_builder, GlobalAttConfigBuilderRF) + train_mini_lstm_exp = GlobalTrainExperiment( + config_builder=self.config_builder, + alias=self.alias, + num_epochs=num_epochs, + train_rqmt={"time": 10}, + train_opts={ + "preload_from_files": { + "pretrained_global_att_params": { + "filename": self.checkpoint, + "init_for_train": True, + "ignore_missing": True, + } + }, + "train_def": from_scratch_training, + "train_step_func": _returnn_v2_train_step, + "batching": "random", + "aux_loss_layers": None, + "lr_opts": { + "type": "const_then_linear", + "const_lr": 1e-4, + "const_frac": 1 / 3, + "final_lr": 1e-6, + "num_epochs": num_epochs + }, + "train_mini_lstm_opts": train_mini_lstm_opts, + } + ) + mini_att_checkpoints, model_dir, learning_rates = train_mini_lstm_exp.run_train() + return mini_att_checkpoints[num_epochs] @@ -209,24 +243,61 @@ def get_mini_att_checkpoint(self, train_mini_lstm_opts: Dict) -> Checkpoint: train_opts = {"dataset_opts": {"hdf_targets": align_targets}} num_epochs = 10 - train_mini_lstm_exp = SegmentalTrainExperiment( - config_builder=self.config_builder, - alias=self.alias, - num_epochs=num_epochs, - train_opts={ - "import_model_train_epoch1": self.checkpoint, - "lr_opts": { - "type": "newbob", - "learning_rate": 1e-4, - "learning_rate_control": "newbob_multi_epoch", - "learning_rate_control_min_num_epochs_per_new_lr": 3, - "learning_rate_control_relative_error_relative_lr": True, - "learning_rate_control_error_measure": "dev_error_label_model/output_prob" - }, - "train_mini_lstm_opts": train_mini_lstm_opts, - **train_opts - } - ) + + if isinstance(self.config_builder, SegmentalConfigBuilder): + train_mini_lstm_exp = SegmentalTrainExperiment( + config_builder=self.config_builder, + alias=self.alias, + num_epochs=num_epochs, + train_opts={ + "import_model_train_epoch1": self.checkpoint, + "lr_opts": { + "type": "newbob", + "learning_rate": 1e-4, + "learning_rate_control": "newbob_multi_epoch", + "learning_rate_control_min_num_epochs_per_new_lr": 3, + "learning_rate_control_relative_error_relative_lr": True, + "learning_rate_control_error_measure": "dev_error_label_model/output_prob" + }, + "train_mini_lstm_opts": train_mini_lstm_opts, + **train_opts + } + ) + else: + assert isinstance(self.config_builder, SegmentalAttConfigBuilderRF) + _, config_builder_ = get_global_att_config_builder_rf( + use_weight_feedback=self.config_builder.use_weight_feedback, + use_att_ctx_in_state=self.config_builder.use_att_ctx_in_state + ) + + train_mini_lstm_exp = GlobalTrainExperiment( + config_builder=config_builder_, + alias=self.alias, + num_epochs=num_epochs, + train_rqmt={"time": 10}, + train_opts={ + "preload_from_files": { + "pretrained_global_att_params": { + "filename": self.checkpoint, + "init_for_train": True, + "ignore_missing": True, + } + }, + "train_def": from_scratch_training, + "train_step_func": _returnn_v2_train_step, + "batching": "random", + "aux_loss_layers": None, + "lr_opts": { + "type": "const_then_linear", + "const_lr": 1e-4, + "const_frac": 1 / 3, + "final_lr": 1e-6, + "num_epochs": num_epochs + }, + "train_mini_lstm_opts": train_mini_lstm_opts, + } + ) + mini_att_checkpoints, model_dir, learning_rates = train_mini_lstm_exp.run_train() return mini_att_checkpoints[num_epochs] @@ -733,12 +804,12 @@ def __init__( ilm_opts: Optional[Dict] = None, run_analysis: bool = False, search_rqmt: Optional[Dict] = None, - search_alias: Optional[str] = None + search_alias: Optional[str] = None, + corpus_keys: Tuple[str, ...] = ("dev-other",) ): self.recog_opts = recog_opts if recog_opts is not None else {} - assert "lm_opts" not in self.recog_opts, "lm_opts are set by the pipeline" - assert "ilm_correction_opts" not in self.recog_opts, "ilm_correction_opts are set by the pipeline" - assert "beam_size" not in self.recog_opts, "beam_size is set by the pipeline" + for key in ("lm_opts", "ilm_correction_opts", "beam_size", "search_corpus_key"): + assert key not in self.recog_opts, f"{key} is set by the pipeline" self.alias = alias self.config_builder = config_builder @@ -753,6 +824,7 @@ def __init__( self.run_analysis = run_analysis self.search_rqmt = search_rqmt self.search_alias = search_alias + self.corpus_keys = corpus_keys @abstractmethod def run_experiment( @@ -764,12 +836,20 @@ def run(self): for beam_size in self.beam_sizes: for lm_scale in self.lm_scales: for ilm_scale in self.ilm_scales: - self.run_experiment( - beam_size=beam_size, - lm_scale=lm_scale, - ilm_scale=ilm_scale, - checkpoint_alias=checkpoint_alias - ) + for corpus_key in self.corpus_keys: + self.recog_opts.update({ + "lm_opts": {"scale": lm_scale, **self.lm_opts} if lm_scale > 0 else None, + "ilm_correction_opts": { + "scale": ilm_scale, **self.ilm_opts} if ilm_scale > 0 and lm_scale > 0 else None, + "beam_size": beam_size, + "search_corpus_key": corpus_key + }) + self.run_experiment( + beam_size=beam_size, + lm_scale=lm_scale, + ilm_scale=ilm_scale, + checkpoint_alias=checkpoint_alias + ) class ReturnnGlobalAttDecodingPipeline(DecodingPipeline): @@ -778,12 +858,6 @@ def __init__(self, config_builder: GlobalConfigBuilder, **kwargs): self.config_builder = config_builder def run_experiment(self, beam_size: int, lm_scale: float, ilm_scale: float, checkpoint_alias: str): - self.recog_opts.update({ - "lm_opts": {"scale": lm_scale, **self.lm_opts} if lm_scale > 0 else None, - "ilm_correction_opts": {"scale": ilm_scale, **self.ilm_opts} if ilm_scale > 0 and lm_scale > 0 else None, - "beam_size": beam_size - }) - if lm_scale > 0 and beam_size in (50, 84) and "batch_size" not in self.recog_opts: self.recog_opts["batch_size"] = 4000 * 160 @@ -826,12 +900,6 @@ def __init__(self, config_builder: SegmentalConfigBuilder, **kwargs): self.analysis_opts["ground_truth_hdf"] = self.realignment def run_experiment(self, beam_size: int, lm_scale: float, ilm_scale: float, checkpoint_alias: str): - self.recog_opts.update({ - "lm_opts": {"scale": lm_scale, **self.lm_opts} if lm_scale > 0 else None, - "ilm_correction_opts": {"scale": ilm_scale, **self.ilm_opts} if ilm_scale > 0 else None, - "beam_size": beam_size - }) - if lm_scale > 0: if beam_size == 12 and "batch_size" not in self.recog_opts: self.recog_opts["batch_size"] = 7500 * 160 diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/config_builder_rf/base.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/config_builder_rf/base.py index 6130a6092..5c969dc99 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/config_builder_rf/base.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/config_builder_rf/base.py @@ -1,5 +1,8 @@ from i6_experiments.users.schmitt.datasets.oggzip import get_dataset_dict as get_oggzip_dataset_dict from i6_experiments.users.schmitt.datasets.concat import get_concat_dataset_dict +from i6_experiments.users.schmitt.datasets.variable import ( + get_interpolation_alignment_dataset, get_interpolation_alignment_scores_dataset +) from i6_experiments.users.schmitt.datasets.extern_sprint import get_dataset_dict as get_extern_sprint_dataset_dict from i6_experiments.users.schmitt.specaugment import * from i6_experiments.users.schmitt import dynamic_lr @@ -68,6 +71,10 @@ def get_train_config(self, opts: Dict): python_epilog = copy.deepcopy(self.python_epilog) dataset_opts = opts.pop("dataset_opts", {}) + + if opts.get("full_sum_alignment_interpolation_factor", 0.0) > 0.0: + dataset_opts["add_alignment_interpolation_datasets"] = True + config_dict.update(self.get_train_datasets(dataset_opts=dataset_opts)) extern_data_raw = self.get_extern_data_dict(dataset_opts) extern_data_raw = instanciate_delayed(extern_data_raw) @@ -82,6 +89,9 @@ def get_train_config(self, opts: Dict): if opts.get("cleanup_old_models"): post_config_dict["cleanup_old_models"] = opts.pop("cleanup_old_models") + if opts.get("train_mini_lstm_opts") is not None: + config_dict["use_mini_att"] = True + config_dict.update(self.get_lr_settings(lr_opts=opts.pop("lr_opts"), python_epilog=python_epilog)) config_dict["batch_size"] = opts.pop("batch_size", 15_000) * self.batch_size_factor @@ -101,8 +111,7 @@ def get_train_config(self, opts: Dict): "gradient_clip_global_norm", # "specaugment_steps", "torch_amp", - "full_sum_training_beam_size", - # "max_seq_length" + # "max_seq_length", ] config_dict.update( {k: opts.pop(k) for k in remaining_opt_keys if k in opts} @@ -159,6 +168,62 @@ def get_recog_config(self, opts: Dict): config_dict["batch_size"] = opts.get("batch_size", 15_000) * self.batch_size_factor + config_dict["beam_search_opts"] = { + "beam_size": opts.get("beam_size", 12), + } + + lm_opts = opts.get("lm_opts", None) # type: Optional[Dict] + if lm_opts is not None: + assert lm_opts.get("type", "trafo") == "trafo" + + config_dict["external_lm"] = { + "class": "TransformerDecoder", + "vocab_dim": 10_025, + "model_dim": 1024, + "embed_dim": 128, + "num_layers": 24, + "decoder_layer_opts": {"self_att_opts": {"with_bias": False, "att_dropout_broadcast": False}}, + "input_embedding_scale": 1.0, + "share_embedding": False, + "logits_with_bias": True, + "input_dropout": 0.1, + } + + if "preload_from_files" not in config_dict: + config_dict["preload_from_files"] = {} + config_dict["preload_from_files"]["external_lm"] = { + "filename": "/work/asr3/zeyer/schmitt/sisyphus_work_dirs/segmental_models_2022_23_rf/i6_experiments/users/schmitt/returnn_frontend/convert/checkpoint/ConvertTfCheckpointToRfPtJob.7haAE0Cx93dA/output/model/network.023.pt", + "prefix": "language_model.", + "ignore_missing": False, + } + + config_dict["beam_search_opts"]["external_lm_scale"] = lm_opts["scale"] + + ilm_correction_opts = opts.get("ilm_correction_opts", None) + if ilm_correction_opts is not None: + assert ilm_correction_opts["type"] == "mini_att" + + config_dict["use_mini_att"] = True + + if "preload_from_files" not in config_dict: + config_dict["preload_from_files"] = {} + config_dict["preload_from_files"]["mini_lstm"] = { + "filename": ilm_correction_opts["mini_att_checkpoint"], + "prefix": "do_not_load_", + "var_name_mapping": {layer: f"do_not_load_{layer}" for layer in ( + "label_decoder.mini_att.bias", + "label_decoder.mini_att.weight", + "label_decoder.mini_att_lstm.bias", + "label_decoder.mini_att_lstm.rec_weight", + "label_decoder.mini_att_lstm.ff_weight", + )} + } + + config_dict["beam_search_opts"].update({ + "ilm_type": "mini_att", + "ilm_correction_scale": ilm_correction_opts["scale"], + }) + python_epilog.append( serialization.Collection( [ @@ -188,7 +253,6 @@ def get_recog_config(self, opts: Dict): # serialize remaining functions, e.g. dynamic learning rate return get_serializable_config(returnn_train_config, serialize_dim_tags=False) - def get_recog_checkpoints( self, model_dir: Path, learning_rates: Path, key: str, checkpoints: Dict[int, Checkpoint], n_epochs: int): # last checkpoint @@ -230,6 +294,16 @@ def get_lr_settings(self, lr_opts, python_epilog: Optional[List] = None): "learning_rates": [const_lr] * int((num_epochs*const_frac)) + list(np.linspace(const_lr, final_lr, num_epochs - int((num_epochs*const_frac)))), }) elif lr_opts["type"] == "dyn_lr_piecewise_linear": + # By batch size (in k) and num (sub)epochs. + # 500 subepochs is usually for multi-GPU with 4 GPUs, + # i.e. the same as single-GPU 2000 subepochs. + # If the dict is missing some entry, + # unfortunately there is currently no good automatic way to get the number. + # I need to log at the stats of some setup with this batch size. + # I just run some setup with some arbitrary LR scheduling (calling it "wrongLr"), + # or maybe with sqrt-decay, and then look at the stats (steps/ep, or total num steps), + # and give some estimates for the steps here, i.e. 45%, 90%, almost 100%, + # making sure the last number is slightly below the real total number of steps. _lrlin_oclr_steps_by_bs_nep = { (3, 125): [194_000, 388_000, 430_000], # ~3450steps/ep, 125 eps -> 430k steps in total (8, 125): [139_000, 279_000, 310_000], # ~2485steps/ep, 125 eps -> 310k steps in total @@ -415,9 +489,14 @@ def get_extern_data_dict(self, dataset_opts: Dict): extern_data_dict["data"] = {"dim_tags": [batch_dim, time_dim, audio_dim]} out_spatial_dim = Dim(description="out_spatial", dimension=None, kind=Dim.Types.Spatial) + + if isinstance(self, SegmentalAttConfigBuilderRF) and self.use_joint_model: + vocab_dimension = self.variant_params["dependencies"].model_hyperparameters.target_num_labels_wo_blank + else: + vocab_dimension = self.variant_params["dependencies"].model_hyperparameters.target_num_labels vocab_dim = Dim( description="vocab", - dimension=self.variant_params["dependencies"].model_hyperparameters.target_num_labels, + dimension=vocab_dimension, kind=Dim.Types.Spatial ) extern_data_dict["targets"] = { @@ -425,15 +504,49 @@ def get_extern_data_dict(self, dataset_opts: Dict): "sparse_dim": vocab_dim, } + if dataset_opts.get("add_alignment_interpolation_datasets"): + score_dim = Dim(description="interpolation_alignment_score", dimension=1, kind=Dim.Types.Feature) + interpolation_alignment_spatial_dim = Dim( + description="interpolation_alignment_spatial", dimension=None, kind=Dim.Types.Spatial) + extern_data_dict.update({ + "interpolation_alignment": { + "dim_tags": [batch_dim, interpolation_alignment_spatial_dim], "sparse_dim": vocab_dim}, + "interpolation_alignment_scores": {"dim_tags": [batch_dim, score_dim]} + }) + return extern_data_dict def get_train_datasets(self, dataset_opts: Dict): - return dict( + datasets = dict( train=self.get_train_dataset_dict(dataset_opts), dev=self.get_cv_dataset_dict(dataset_opts), eval_datasets={"devtrain": self.get_devtrain_dataset_dict(dataset_opts)} ) + if dataset_opts.get("add_alignment_interpolation_datasets"): + for corpus_key, dataset_dict in datasets.items(): + if corpus_key == "eval_datasets": + dataset_dict = dataset_dict["devtrain"] + + assert dataset_dict["class"] == "MetaDataset" + assert set(dataset_dict["data_map"].keys()) == {"data", "targets"} + dataset_dict["datasets"].update({ + "interpolation_alignment_dataset": { + "class": "VariableDataset", + "get_dataset": get_interpolation_alignment_dataset, + }, + "interpolation_alignment_scores_dataset": { + "class": "VariableDataset", + "get_dataset": get_interpolation_alignment_scores_dataset, + } + }) + dataset_dict["data_map"].update({ + "interpolation_alignment": ("interpolation_alignment_dataset", "data"), + "interpolation_alignment_scores": ("interpolation_alignment_scores_dataset", "data"), + }) + + return datasets + def get_search_dataset(self, search_corpus_key: str, dataset_opts: Dict): return dict( forward_data=self.get_search_dataset_dict(corpus_key=search_corpus_key, dataset_opts=dataset_opts) @@ -499,6 +612,9 @@ def __init__( self.config_dict.update(dict( center_window_size=center_window_size, )) + self.use_joint_model = use_joint_model + self.label_decoder_state = label_decoder_state + self.use_weight_feedback = use_weight_feedback if use_joint_model: assert not blank_decoder_version, "Either use joint model or separate label and blank model" @@ -518,6 +634,16 @@ def get_train_config(self, opts: Dict): if opts.get("alignment_augmentation_opts"): train_config.config["alignment_augmentation_opts"] = opts["alignment_augmentation_opts"] + remaining_opt_keys = [ + "full_sum_beam_size", + "full_sum_alignment_interpolation_factor", + "full_sum_lattice_downsampling", + "full_sum_train_on_viterbi_paths", + ] + train_config.config.update( + {k: opts.pop(k) for k in remaining_opt_keys if k in opts} + ) + return train_config def get_recog_config(self, opts: Dict): @@ -533,6 +659,57 @@ def get_recog_config(self, opts: Dict): use_recombination = opts.get("use_recombination") if use_recombination is not None: - recog_config.config["use_recombination"] = use_recombination + recog_config.config["beam_search_opts"]["use_recombination"] = use_recombination return recog_config + + def get_realign_config(self, opts: Dict): + config_dict = copy.deepcopy(self.config_dict) + post_config_dict = copy.deepcopy(self.post_config_dict) + python_prolog = copy.deepcopy(self.python_prolog) + python_epilog = copy.deepcopy(self.python_epilog) + + dataset_opts = opts.get("dataset_opts", {}) + config_dict.update(dict( + task="forward", + batching=opts.get("batching", "random") + )) + + config_dict.update( + self.get_search_dataset( + search_corpus_key=opts["corpus_key"], + dataset_opts=dataset_opts + )) + extern_data_raw = self.get_extern_data_dict(dataset_opts) + extern_data_raw = instanciate_delayed(extern_data_raw) + + config_dict["batch_size"] = opts.get("batch_size", 15_000) * self.batch_size_factor + + python_epilog.append( + serialization.Collection( + [ + serialization.NonhashedCode(get_import_py_code()), + serialization.NonhashedCode( + nn.ReturnnConfigSerializer.get_base_extern_data_py_code_str_direct(extern_data_raw) + ), + *serialize_model_def(self.model_def), + serialization.Import(self.get_model_func, import_as="get_model"), + serialization.Import(opts["realign_def"], import_as="_realign_def", ignore_import_as_for_hash=True), + serialization.Import(opts["forward_step_func"], import_as="forward_step"), + serialization.Import(opts["forward_callback"], import_as="forward_callback"), + serialization.PythonEnlargeStackWorkaroundNonhashedCode, + serialization.PythonCacheManagerFunctionNonhashedCode, + serialization.PythonModelineNonhashedCode + ] + ) + ) + + returnn_train_config = ReturnnConfig( + config=config_dict, + post_config=post_config_dict, + python_prolog=python_prolog, + python_epilog=python_epilog, + ) + + # serialize remaining functions, e.g. dynamic learning rate + return get_serializable_config(returnn_train_config, serialize_dim_tags=False) diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/base.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/base.py index 4151392f2..b2f3e7baa 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/base.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/base.py @@ -25,6 +25,8 @@ def __init__( l2: float = 0.0001, use_weight_feedback: bool = True, use_att_ctx_in_state: bool = True, + decoder_state: str = "nb-lstm", + use_mini_att: bool = False, ): super(BaseLabelDecoder, self).__init__() @@ -40,29 +42,53 @@ def __init__( self.target_embed = rf.Embedding(target_dim, Dim(name="target_embed", dimension=640)) - zoneout_lstm_opts = dict( - out_dim=Dim(name="lstm", dimension=1024), - zoneout_factor_cell=0.15, - zoneout_factor_output=0.05, - use_zoneout_output=False, # like RETURNN/TF ZoneoutLSTM old default - # parts_order="icfo", # like RETURNN/TF ZoneoutLSTM - # parts_order="ifco", - parts_order="jifo", # NativeLSTM (the code above converts it...) - forget_bias=0.0, # the code above already adds it during conversion - ) self.use_att_ctx_in_state = use_att_ctx_in_state - if use_att_ctx_in_state: - self.s = rf.ZoneoutLSTM( - self.target_embed.out_dim + att_num_heads * enc_out_dim, - **zoneout_lstm_opts, + self.use_weight_feedback = use_weight_feedback + + self.decoder_state = decoder_state + if "lstm" in decoder_state: + ilm_layer_class = rf.ZoneoutLSTM + ilm_layer_opts = dict( + out_dim=Dim(name="lstm", dimension=1024), + zoneout_factor_cell=0.15, + zoneout_factor_output=0.05, + use_zoneout_output=False, # like RETURNN/TF ZoneoutLSTM old default + # parts_order="icfo", # like RETURNN/TF ZoneoutLSTM + # parts_order="ifco", + parts_order="jifo", # NativeLSTM (the code above converts it...) + forget_bias=0.0, # the code above already adds it during conversion ) + if use_att_ctx_in_state: + self.s = ilm_layer_class( + self.target_embed.out_dim + att_num_heads * enc_out_dim, + **ilm_layer_opts, + ) + else: + self.s_wo_att = ilm_layer_class( + self.target_embed.out_dim, + **ilm_layer_opts, + ) else: - self.s_wo_att = rf.ZoneoutLSTM( - self.target_embed.out_dim, - **zoneout_lstm_opts, + ilm_layer_class = rf.Linear + ilm_layer_opts = dict( + out_dim=Dim(name="linear-ilm", dimension=1024), ) + if use_att_ctx_in_state: + self.s_linear = ilm_layer_class( + self.target_embed.out_dim + att_num_heads * enc_out_dim, + **ilm_layer_opts, + ) + else: + self.s_wo_att_linear = ilm_layer_class( + self.target_embed.out_dim, + **ilm_layer_opts, + ) + + self.use_mini_att = use_mini_att + if use_mini_att: + self.mini_att_lstm = rf.LSTM(self.target_embed.out_dim, Dim(name="mini-att-lstm", dimension=50)) + self.mini_att = rf.Linear(self.mini_att_lstm.out_dim, self.att_num_heads * self.enc_out_dim) - self.use_weight_feedback = use_weight_feedback if use_weight_feedback: self.weight_feedback = rf.Linear(att_num_heads, enc_key_total_dim, with_bias=False) @@ -86,15 +112,42 @@ def _update_state( self, input_embed: rf.Tensor, prev_att: rf.Tensor, - prev_s_state: rf.LstmState, - ): - if self.use_att_ctx_in_state: - return self.s(rf.concat_features(input_embed, prev_att), state=prev_s_state, spatial_dim=single_step_dim) + prev_s_state: Optional[rf.LstmState], + ) -> Tuple[rf.Tensor, Optional[rf.LstmState]]: + if "lstm" in self.decoder_state: + ilm_forward_opts = dict( + state=prev_s_state, + spatial_dim=single_step_dim, + ) + if self.use_att_ctx_in_state: + return self.s(rf.concat_features(input_embed, prev_att), **ilm_forward_opts) + else: + return self.s_wo_att(input_embed, **ilm_forward_opts) else: - return self.s_wo_att(input_embed, state=prev_s_state, spatial_dim=single_step_dim) + if self.use_att_ctx_in_state: + return self.s_linear(rf.concat_features(input_embed, prev_att)), None + else: + return self.s_wo_att_linear(input_embed), None def get_lstm(self): - if self.use_att_ctx_in_state: - return self.s + if "lstm" in self.decoder_state: + if self.use_att_ctx_in_state: + return self.s + else: + return self.s_wo_att else: - return self.s_wo_att + if self.use_att_ctx_in_state: + return self.s_linear + else: + return self.s_wo_att_linear + + def get_att( + self, + att_weights: rf.Tensor, + enc: rf.Tensor, + reduce_dim: Dim + ) -> rf.Tensor: + att0 = rf.dot(att_weights, enc, reduce=reduce_dim, use_mask=False) + att0.feature_dim = self.enc_out_dim + att, _ = rf.merge_dims(att0, dims=(self.att_num_heads, self.enc_out_dim)) + return att diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/decoder.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/decoder.py index 6aed0ba96..d6d5c95d5 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/decoder.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/decoder.py @@ -22,6 +22,9 @@ def decoder_default_initial_state(self, *, batch_dims: Sequence[Dim], enc_spatia ) state.att.feature_dim_axis = len(state.att.dims) - 1 + if self.use_mini_att: + state.mini_att_lstm = self.mini_att_lstm.default_initial_state(batch_dims=batch_dims) + if self.use_weight_feedback: state.accum_att_weights = rf.zeros( list(batch_dims) + [enc_spatial_dim, self.att_num_heads], feature_dim=self.att_num_heads @@ -52,6 +55,7 @@ def loop_step( enc_spatial_dim: Dim, input_embed: rf.Tensor, state: Optional[rf.State] = None, + use_mini_att: bool = False, ) -> Tuple[Dict[str, rf.Tensor], rf.State]: """step of the inner loop""" if state is None: @@ -79,9 +83,12 @@ def loop_step( if self.use_weight_feedback: state_.accum_att_weights = state.accum_att_weights + att_weights * inv_fertility * 0.5 - att0 = rf.dot(att_weights, enc, reduce=enc_spatial_dim, use_mask=False) - att0.feature_dim = self.enc_out_dim - att, _ = rf.merge_dims(att0, dims=(self.att_num_heads, self.enc_out_dim)) + if use_mini_att: + att_lstm, state_.mini_att_lstm = self.mini_att_lstm( + input_embed, state=state.mini_att_lstm, spatial_dim=single_step_dim) + att = self.mini_att(att_lstm) + else: + att = self.get_att(att_weights, enc, enc_spatial_dim) state_.att = att return {"s": s, "att": att}, state_ @@ -110,6 +117,9 @@ def __call__( enc_ctx: rf.Tensor, enc_spatial_dim: Dim, s: rf.Tensor, + input_embed: rf.Tensor, + input_embed_spatial_dim: Dim, + use_mini_att: bool = False, ) -> rf.Tensor: s_transformed = self.s_transformed(s) @@ -118,10 +128,17 @@ def __call__( energy_in = enc_ctx + weight_feedback + s_transformed energy = self.energy(rf.tanh(energy_in)) att_weights = rf.softmax(energy, axis=enc_spatial_dim) - # we do not need use_mask because the softmax output is already padded with zeros - att0 = rf.dot(att_weights, enc, reduce=enc_spatial_dim, use_mask=False) - att0.feature_dim = self.enc_out_dim - att, _ = rf.merge_dims(att0, dims=(self.att_num_heads, self.enc_out_dim)) + if use_mini_att: + att_lstm, _ = self.mini_att_lstm( + input_embed, + state=self.mini_att_lstm.default_initial_state( + batch_dims=input_embed.remaining_dims([input_embed_spatial_dim, input_embed.feature_dim])), + spatial_dim=input_embed_spatial_dim + ) + att = self.mini_att(att_lstm) + else: + # we do not need use_mask because the softmax output is already padded with zeros + att = self.get_att(att_weights, enc, enc_spatial_dim) return att diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/model.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/model.py index 8af71daf3..d8f595ed2 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/model.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/model.py @@ -23,7 +23,7 @@ def __init__( enc_key_total_dim: Dim = Dim(name="enc_key_total_dim", dimension=1024), att_dropout: float = 0.1, l2: float = 0.0001, - language_model: Optional[RFModelWithMakeLabelScorer] = None, + language_model: Optional[rf.Module] = None, enc_in_dim: Dim, enc_out_dim: Dim = Dim(name="enc", dimension=512), enc_num_layers: int = 12, @@ -36,6 +36,7 @@ def __init__( eos_idx: int, use_weight_feedback: bool = True, use_att_ctx_in_state: bool = True, + use_mini_att: bool = False, ): super(GlobalAttentionModel, self).__init__() @@ -72,17 +73,22 @@ def __init__( eos_idx=eos_idx, use_weight_feedback=use_weight_feedback, use_att_ctx_in_state=use_att_ctx_in_state, + use_mini_att=use_mini_att, ) if language_model: - self.language_model, self.language_model_make_label_scorer = language_model + self.language_model = language_model else: self.language_model = None - self.language_model_make_label_scorer = None self.blank_idx = blank_idx self.target_dim = target_dim + if use_mini_att: + for name, param in self.named_parameters(): + if "mini_att" not in name: + param.trainable = False + class MakeModel: """for import""" @@ -131,6 +137,7 @@ def make_model( language_model: Optional[Dict[str, Any]] = None, use_weight_feedback: bool = True, use_att_ctx_in_state: bool = True, + use_mini_att: bool = False, **extra, ) -> GlobalAttentionModel: """make""" @@ -145,7 +152,6 @@ def make_model( from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.lm.trafo import model as trafo_lm lm = trafo_lm.MakeModel(vocab_dim=target_dim, **language_model)() - lm = (lm, functools.partial(trafo_lm.make_label_scorer_torch, model=lm)) return GlobalAttentionModel( enc_in_dim=in_dim, @@ -172,6 +178,7 @@ def make_model( language_model=lm, use_weight_feedback=use_weight_feedback, use_att_ctx_in_state=use_att_ctx_in_state, + use_mini_att=use_mini_att, **extra, ) @@ -213,6 +220,7 @@ def from_scratch_model_def(*, epoch: int, in_dim: Dim, target_dim: Dim) -> Globa lm_opts = config.typed_value("external_lm") use_weight_feedback = config.bool("use_weight_feedback", True) use_att_ctx_in_state = config.bool("use_att_ctx_in_state", True) + use_mini_att = config.bool("use_mini_att", False) return MakeModel.make_model( in_dim, @@ -222,6 +230,7 @@ def from_scratch_model_def(*, epoch: int, in_dim: Dim, target_dim: Dim) -> Globa language_model=lm_opts, use_weight_feedback=use_weight_feedback, use_att_ctx_in_state=use_att_ctx_in_state, + use_mini_att=use_mini_att, ) diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/recog.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/recog.py index 8448a5744..084d0b401 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/recog.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/recog.py @@ -1,7 +1,7 @@ from typing import Optional, Dict, Any, Tuple import tree -from returnn.tensor import Tensor, Dim +from returnn.tensor import Tensor, Dim, single_step_dim import returnn.frontend as rf from returnn.frontend.tensor_array import TensorArray @@ -15,7 +15,11 @@ def model_recog( model: GlobalAttentionModel, data: Tensor, data_spatial_dim: Dim, + beam_size: int, max_seq_len: Optional[int] = None, + external_lm_scale: Optional[float] = None, + ilm_type: Optional[str] = None, + ilm_correction_scale: Optional[float] = None, ) -> Tuple[Tensor, Tensor, Dim, Dim]: """ Function is run within RETURNN. @@ -30,37 +34,70 @@ def model_recog( out_spatial_dim, final beam_dim """ - assert not model.label_decoder.language_model # not implemented here. use the pure PyTorch search instead - batch_dims = data.remaining_dims((data_spatial_dim, data.feature_dim)) + if ilm_type is not None: + assert ilm_type in ("mini_att",) + assert ilm_correction_scale is not None + + # --------------------------------- init encoder, dims, etc --------------------------------- + enc_args, enc_spatial_dim = model.encoder.encode(data, in_spatial_dim=data_spatial_dim) - beam_size = 12 - length_normalization_exponent = 1.0 + if max_seq_len is None: max_seq_len = enc_spatial_dim.get_size_tensor() else: max_seq_len = rf.convert_to_tensor(max_seq_len, dtype="int32") - print("** max seq len:", max_seq_len.raw_tensor) - # Eager-mode implementation of beam search. - # Initial state. + batch_dims = data.remaining_dims((data_spatial_dim, data.feature_dim)) beam_dim = Dim(1, name="initial-beam") batch_dims_ = [beam_dim] + batch_dims - decoder_state = model.label_decoder.decoder_default_initial_state(batch_dims=batch_dims_, enc_spatial_dim=enc_spatial_dim) - target = rf.constant(model.label_decoder.bos_idx, dims=batch_dims_, sparse_dim=model.target_dim) + + length_normalization_exponent = 1.0 + ended = rf.constant(False, dims=batch_dims_) out_seq_len = rf.constant(0, dims=batch_dims_) seq_log_prob = rf.constant(0.0, dims=batch_dims_) - i = 0 + # lists of [B, beam] tensors seq_targets = [] seq_backrefs = [] + + # --------------------------------- init states --------------------------------- + + decoder_state = model.label_decoder.decoder_default_initial_state( + batch_dims=batch_dims_, enc_spatial_dim=enc_spatial_dim) + + # external LM + if model.language_model: + lm_state = model.language_model.default_initial_state(batch_dims=batch_dims_) + else: + lm_state = None + + # ILM + if ilm_type is not None: + ilm_state = model.label_decoder.decoder_default_initial_state( + batch_dims=batch_dims_, enc_spatial_dim=enc_spatial_dim) + else: + ilm_state = None + + # --------------------------------- init targets --------------------------------- + + target = rf.constant(model.label_decoder.bos_idx, dims=batch_dims_, sparse_dim=model.target_dim) + + # --------------------------------- main loop --------------------------------- + + i = 0 while True: + # --------------------------------- get embeddings --------------------------------- + if i == 0: input_embed = rf.zeros( batch_dims_ + [model.label_decoder.target_embed.out_dim], feature_dim=model.label_decoder.target_embed.out_dim) else: input_embed = model.label_decoder.target_embed(target) + + # --------------------------------- decoder step --------------------------------- + step_out, decoder_state = model.label_decoder.loop_step( **enc_args, enc_spatial_dim=enc_spatial_dim, @@ -69,19 +106,71 @@ def model_recog( ) logits = model.label_decoder.decode_logits(input_embed=input_embed, **step_out) label_log_prob = rf.log_softmax(logits, axis=model.target_dim) + + # --------------------------------- external LM step --------------------------------- + + if lm_state is not None: + lm_logits, lm_state = model.language_model( + target, + spatial_dim=single_step_dim, + state=lm_state, + ) + lm_label_log_prob = rf.log_softmax(lm_logits, axis=model.target_dim) + label_log_prob += external_lm_scale * lm_label_log_prob + + # --------------------------------- ILM step --------------------------------- + + if ilm_state is not None: + ilm_step_out, ilm_state = model.label_decoder.loop_step( + **enc_args, + enc_spatial_dim=enc_spatial_dim, + input_embed=input_embed, + state=ilm_state, + use_mini_att=True + ) + ilm_logits = model.label_decoder.decode_logits(input_embed=input_embed, **ilm_step_out) + ilm_label_log_prob = rf.log_softmax(ilm_logits, axis=model.target_dim) + label_log_prob -= ilm_correction_scale * ilm_label_log_prob + + # --------------------------------- filter finished beams, pick top-k --------------------------------- + # Filter out finished beams label_log_prob = rf.where( ended, rf.sparse_to_dense(model.label_decoder.eos_idx, axis=model.target_dim, label_value=0.0, other_value=-1.0e30), label_log_prob, ) + seq_log_prob = seq_log_prob + label_log_prob # Batch, InBeam, Vocab seq_log_prob, (backrefs, target), beam_dim = rf.top_k( seq_log_prob, k_dim=Dim(beam_size, name=f"dec-step{i}-beam"), axis=[beam_dim, model.target_dim] ) # seq_log_prob, backrefs, target: Batch, Beam seq_targets.append(target) seq_backrefs.append(backrefs) + + # --------------------------------- update states --------------------------------- + + # decoder decoder_state = tree.map_structure(lambda s: rf.gather(s, indices=backrefs), decoder_state) + + # external LM + if lm_state is not None: + def _get_lm_state(state): + if isinstance(state, Dim): + return state + + assert isinstance(state, Tensor) + if len(state.dims) == 0: + return state + + return rf.gather(state, indices=backrefs) + + lm_state = tree.map_structure(lambda state: _get_lm_state(state), lm_state) + + # ILM + if ilm_state is not None: + ilm_state = tree.map_structure(lambda s: rf.gather(s, indices=backrefs), ilm_state) + ended = rf.gather(ended, indices=backrefs) out_seq_len = rf.gather(out_seq_len, indices=backrefs) i += 1 diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/train.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/train.py index b068dc565..ccc65e321 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/train.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/global_/train.py @@ -48,6 +48,7 @@ def _body(input_embed: Tensor, state: rf.State): enc_spatial_dim=enc_spatial_dim, input_embed=input_embed, state=state.decoder, + use_mini_att=model.use_mini_att, ) return loop_out_, new_state @@ -84,6 +85,9 @@ def get_s_and_att_efficient( enc_ctx=enc_args["enc_ctx"], enc_spatial_dim=enc_spatial_dim, s=s, + input_embed=input_embeddings, + input_embed_spatial_dim=targets_spatial_dim, + use_mini_att=model.use_mini_att, ) return s, att diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/lm/__init__.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/lm/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/lm/lstm/__init__.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/lm/lstm/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/lm/lstm/model.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/lm/lstm/model.py new file mode 100644 index 000000000..9e0ba43bc --- /dev/null +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/lm/lstm/model.py @@ -0,0 +1,120 @@ +from typing import Optional, Any, Tuple, Dict, Sequence, List +import tree +from returnn.tensor import Tensor, Dim, single_step_dim +import returnn.frontend as rf + + +class LSTM_LM_Model(rf.Module): + """Model definition""" + + def __init__( + self, + in_dim: Dim, + target_dim: Dim, + *, + num_enc_layers: int = 12, + + lstm_input_dim: Dim = Dim(name="lstm-input", dimension=128), + lstm_model_dim: Dim = Dim(name="lstm-model", dimension=2048), + # enc_att_num_heads: int = 4, + # enc_conformer_layer_opts: Optional[Dict[str, Any]] = None, + # enc_key_total_dim: Dim = Dim(name="enc_key_total_dim", dimension=1024), + # att_num_heads: Dim = Dim(name="att_num_heads", dimension=1), + # att_dropout: float = 0.1, + # enc_dropout: float = 0.1, + # enc_att_dropout: float = 0.1, + # l2: float = 0.0001, + search_args: Optional[Dict[str, Any]] = None, + ): + super(LSTM_LM_Model, self).__init__() + self.in_dim = in_dim + + self.input = rf.Embedding(in_dim, lstm_input_dim) + self.input_bias = rf.Parameter((lstm_input_dim,)) + + self.lstm_0 = rf.LSTM(lstm_input_dim, lstm_model_dim, with_bias=True) + self.lstm_1 = rf.LSTM(lstm_model_dim, lstm_model_dim, with_bias=True) + self.lstm_2 = rf.LSTM(lstm_model_dim, lstm_model_dim, with_bias=True) + self.lstm_3 = rf.LSTM(lstm_model_dim, lstm_model_dim, with_bias=True) + + self.output = rf.Linear(lstm_model_dim, target_dim) + + def loop_step(self, prev_target, prev_state): + """loop step""" + lm_state = rf.State() + input = self.input(prev_target) + input += self.input_bias + # breakpoint() + lstm_0, lstm_0_state = self.lstm_0(input, state=prev_state.lstm_0, spatial_dim=single_step_dim) + lm_state.lstm_0 = lstm_0_state + lstm_1, lstm_1_state = self.lstm_1(lstm_0, state=prev_state.lstm_1, spatial_dim=single_step_dim) + lm_state.lstm_1 = lstm_1_state + lstm_2, lstm_2_state = self.lstm_2(lstm_1, state=prev_state.lstm_2, spatial_dim=single_step_dim) + lm_state.lstm_2 = lstm_2_state + lstm_3, lstm_3_state = self.lstm_3(lstm_2, state=prev_state.lstm_3, spatial_dim=single_step_dim) + lm_state.lstm_3 = lstm_3_state + output = self.output(lstm_3) + return {"output": output}, lm_state + + def lm_default_initial_state(self, *, batch_dims: Sequence[Dim] + ) -> rf.State: + """Default initial state""" + state = rf.State( + lstm_0=self.lstm_0.default_initial_state(batch_dims=batch_dims), + lstm_1=self.lstm_1.default_initial_state(batch_dims=batch_dims), + lstm_2=self.lstm_2.default_initial_state(batch_dims=batch_dims), + lstm_3=self.lstm_3.default_initial_state(batch_dims=batch_dims), + ) + return state + + def select_state(self, state: rf.State, backrefs) -> rf.State: + state = tree.map_structure( + lambda s: rf.gather(s, indices=backrefs), state + ) + return state + +class MakeModel: + """for import""" + + def __init__( + self, + in_dim: int, + target_dim: int, + *, + eos_label: int = 0, + # num_enc_layers: int = 12, + ): + self.in_dim = in_dim + self.target_dim = target_dim + + self.eos_label = eos_label + + + def __call__(self) -> LSTM_LM_Model: + from returnn.datasets.util.vocabulary import Vocabulary + + in_dim = Dim(name="in", dimension=self.in_dim, kind=Dim.Types.Feature) + target_dim = Dim( + name="target", dimension=self.target_dim, kind=Dim.Types.Feature + ) + target_dim.vocab = Vocabulary.create_vocab_from_labels( + [str(i) for i in range(target_dim.dimension)], eos_label=self.eos_label + ) + + return self.make_model(in_dim, target_dim) + + @classmethod + def make_model( + cls, + in_dim: Dim, + target_dim: Dim, + # *, + # search_args: Optional[Dict[str, Any]], + # num_enc_layers: int = 12, + ) -> LSTM_LM_Model: + """make""" + return LSTM_LM_Model( + in_dim, + # num_enc_layers=num_enc_layers, + target_dim=target_dim, + ) \ No newline at end of file diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/lm/lstm/model_import.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/lm/lstm/model_import.py new file mode 100644 index 000000000..68f78cf12 --- /dev/null +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/lm/lstm/model_import.py @@ -0,0 +1,126 @@ +""" +https://arxiv.org/abs/1905.04226 +Reference: https://github.com/rwth-i6/returnn-experiments/blob/master/2019-lm-transformers/librispeech/bpe_10k/transfo_24_d00.4096_1024.sgd.lr1.8_heads.config +""" + +from __future__ import annotations + +from typing import Dict + +import numpy + +from sisyphus import tk + +from i6_core.returnn.training import Checkpoint +from i6_experiments.users.schmitt.returnn_frontend.convert.checkpoint import ConvertTfCheckpointToRfPtJob + +import returnn.frontend as rf + +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.lm.trafo import model as trafo_lm + +_returnn_tf_ckpt_filename = "/u/zhou/asr-exps/librispeech/dependencies/kazuki_lstmlm_27062019/network.040" +TrafoLmOpts = { + "vocab_dim": 10_025, + "model_dim": 1024, + "embed_dim": 128, + "num_layers": 24, + "decoder_layer_opts": {"self_att_opts": {"with_bias": False, "att_dropout_broadcast": False}}, + "input_embedding_scale": 1.0, + "share_embedding": False, + "logits_with_bias": True, + "input_dropout": 0.1, +} + +_ParamMapping = {} # type: Dict[str,str] + + +def get_tf_checkpoint_path() -> tk.Path: + """ + :return: Sisyphus tk.Path to the original TF checkpoint file + + https://arxiv.org/abs/1905.04226 + Reference: https://github.com/rwth-i6/returnn-experiments/blob/master/2019-lm-transformers/librispeech/bpe_10k/transfo_24_d00.4096_1024.sgd.lr1.8_heads.config + """ + return tk.Path( + _returnn_tf_ckpt_filename, hash_overwrite="librispeech-2018-kazuki-transfo_24_d00.4096_1024.sgd.lr1.8_heads" + ) + + +def get_pt_checkpoint_path() -> tk.Path: + """ + :return: Sisyphus tk.Path to the PyTorch checkpoint file + + https://arxiv.org/abs/1905.04226 + Reference: https://github.com/rwth-i6/returnn-experiments/blob/master/2019-lm-transformers/librispeech/bpe_10k/transfo_24_d00.4096_1024.sgd.lr1.8_heads.config + """ + old_tf_ckpt_path = get_tf_checkpoint_path() + old_tf_ckpt = Checkpoint(index_path=old_tf_ckpt_path) + make_model_func = trafo_lm.MakeModel(**TrafoLmOpts) # eos_label=0 + converter = ConvertTfCheckpointToRfPtJob( + checkpoint=old_tf_ckpt, + make_model_func=make_model_func, + map_func=map_param_func_v2, + epoch=1, + step=0, + ) + return converter.out_checkpoint + + +def _add_params(): + _ParamMapping.update( + { + "input_embedding.weight": "output/rec/target_embed_raw/W", + "input_embedding_proj.weight": "output/rec/target_embed_lin/W", + "final_layer_norm.scale": "output/rec/decoder/scale", + "final_layer_norm.bias": "output/rec/decoder/bias", + "logits.weight": "output/rec/output/W", + "logits.bias": "output/rec/output/b", + } + ) + + for layer_idx in range(TrafoLmOpts["num_layers"]): + # FF + _ParamMapping[f"layers.{layer_idx}.ff.linear_ff.weight"] = f"output/rec/dec_{layer_idx}_ff_conv1/W" + _ParamMapping[f"layers.{layer_idx}.ff.linear_ff.bias"] = f"output/rec/dec_{layer_idx}_ff_conv1/b" + _ParamMapping[f"layers.{layer_idx}.ff.linear_out.weight"] = f"output/rec/dec_{layer_idx}_ff_conv2/W" + _ParamMapping[f"layers.{layer_idx}.ff.linear_out.bias"] = f"output/rec/dec_{layer_idx}_ff_conv2/b" + _ParamMapping[f"layers.{layer_idx}.ff_layer_norm.scale"] = f"output/rec/dec_{layer_idx}_ff_laynorm/scale" + _ParamMapping[f"layers.{layer_idx}.ff_layer_norm.bias"] = f"output/rec/dec_{layer_idx}_ff_laynorm/bias" + + # self-att + _ParamMapping[f"layers.{layer_idx}.self_att.qkv.weight"] = f"output/rec/dec_{layer_idx}_self_att_att/QKV" + _ParamMapping[f"layers.{layer_idx}.self_att.proj.weight"] = f"output/rec/dec_{layer_idx}_self_att_lin/W" + _ParamMapping[f"layers.{layer_idx}.self_att_layer_norm.scale"] = ( + f"output/rec/dec_{layer_idx}_self_att_laynorm/scale" + ) + _ParamMapping[f"layers.{layer_idx}.self_att_layer_norm.bias"] = ( + f"output/rec/dec_{layer_idx}_self_att_laynorm/bias" + ) + + +_add_params() + + +def map_param_func_v2(reader, name: str, var: rf.Parameter) -> numpy.ndarray: + """map params, TF to RF""" + from tensorflow.python.training.py_checkpoint_reader import CheckpointReader + + assert isinstance(reader, CheckpointReader) + assert isinstance(var, rf.Parameter) + + tf_var_name = name.replace(".", "/") + if reader.has_tensor(tf_var_name): + return reader.get_tensor(tf_var_name) + + if name in _ParamMapping: + var_name = _ParamMapping[name] + assert reader.has_tensor(var_name) + value = reader.get_tensor(var_name) + assert isinstance(value, numpy.ndarray) + assert ( + value.shape == var.batch_shape + ), f"new param {name} {var.batch_shape} vs ckpt param {var_name} {value.shape}" + assert value.dtype.name == var.dtype, f"new param {name} {var.dtype} vs ckpt param {var_name} {value.dtype}" + return value + + raise NotImplementedError(f"cannot map {name!r} {var}") diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/lm/trafo/__init__.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/lm/trafo/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/lm/trafo/model.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/lm/trafo/model.py new file mode 100644 index 000000000..863e2ddac --- /dev/null +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/lm/trafo/model.py @@ -0,0 +1,263 @@ +""" +Transformer LM + +First: import our existing TF model + +checkpoint: /work/asr3/irie/experiments/lm/librispeech/2018-03-05--lmbpe-zeyer/data-train/transfo_24_d00.4096_1024.sgd.lr1.8_heads/bk-net-model/network.023 +config example: /work/asr4/zeineldeen/setups-data/ubuntu_22_setups/2023-04-17--conformer-att/work/i6_core/returnn/search/ReturnnSearchJobV2.i6YlJ7HAXfGs/output/returnn.config +""" + +from __future__ import annotations +from typing import Union, Any, Tuple, Optional +from returnn.tensor import Tensor, Dim, single_step_dim +import returnn.frontend as rf +from returnn.frontend.decoder.transformer import TransformerDecoder +from i6_experiments.users.schmitt.returnn_frontend.model_interfaces.label_scorer import LabelScorerIntf + + +class MakeModel: + """for import""" + + def __init__(self, vocab_dim: Union[int, Dim], model_dim: Union[int, Dim], *, num_layers: int, **extra): + self.vocab_dim = vocab_dim + self.model_dim = model_dim + self.num_layers = num_layers + self.extra = extra + + def __call__(self) -> TransformerDecoder: + if isinstance(self.vocab_dim, int): + vocab_dim = Dim(self.vocab_dim, name="vocab") + elif isinstance(self.vocab_dim, Dim): + vocab_dim = self.vocab_dim + else: + raise TypeError(f"vocab dim type {type(self.vocab_dim).__name__}") + + if isinstance(self.model_dim, int): + model_dim = Dim(self.model_dim, name="model") + elif isinstance(self.model_dim, Dim): + model_dim = self.model_dim + else: + raise TypeError(f"model dim type {type(self.model_dim).__name__}") + + if vocab_dim.vocab is None: + from returnn.datasets.util.vocabulary import Vocabulary + + vocab_dim.vocab = Vocabulary.create_vocab_from_labels( + [str(i) for i in range(vocab_dim.dimension)], + ) + + opts = self.extra.copy() + for k, v in list(opts.items()): + if k.endswith("_dim") and isinstance(v, int): + opts[k] = Dim(v, name=k[: -len("_dim")]) + + return self.make_model(vocab_dim=vocab_dim, model_dim=model_dim, num_layers=self.num_layers, **opts) + + @classmethod + def make_model(cls, vocab_dim: Dim, model_dim: Dim, *, num_layers: int, **extra) -> TransformerDecoder: + """make""" + return TransformerDecoder( + encoder_dim=None, + vocab_dim=vocab_dim, + model_dim=model_dim, + num_layers=num_layers, + **extra, + ) + + +def make_label_sync_label_scorer_torch( + model: TransformerDecoder, +) -> LabelScorerIntf: + """ + Make label scorer + """ + import torch + import tree + import functools + from i6_experiments.users.schmitt.returnn_frontend.model_interfaces.label_scorer import ( + StateObjTensorExt, + StateObjIgnored, + ) + + class LabelScorer(LabelScorerIntf): + """TransformerDecoder label scorer""" + + def get_initial_state(self, *, batch_size: int, device: torch.device) -> Any: + """Initial state.""" + batch_dim = Dim(batch_size, name="batch") + beam_dim = Dim(1, name="initial-beam") + batch_dims_ = [batch_dim, beam_dim] + decoder_state = model.default_initial_state(batch_dims=batch_dims_) + return tree.map_structure( + functools.partial(self._map_tensor_to_raw, batch_dim=batch_dim, beam_dim=beam_dim), decoder_state + ) + + def max_remaining_seq_score( + self, *, state: Any, max_remaining_steps: torch.Tensor, device: torch.device + ) -> torch.Tensor: + """max remaining""" + return torch.zeros((1, 1), device=device) + + def score_and_update_state( + self, + *, + prev_state: Any, + prev_label: torch.Tensor, + prev_align_label: Optional[torch.Tensor] = None, # not used + t: Optional[int] = None, # not used + ) -> Tuple[torch.Tensor, Any]: + """update state""" + batch_dim = Dim(prev_label.shape[0], name="batch") + beam_dim = Dim(prev_label.shape[1], name="beam") + + def _map_raw_to_tensor(v): + if isinstance(v, StateObjTensorExt): + tensor: Tensor = v.extra + tensor = tensor.copy_template_new_dim_tags( + (batch_dim, beam_dim) + tensor.dims[2:], keep_special_axes=True + ) + tensor.raw_tensor = v.tensor + return tensor + elif isinstance(v, StateObjIgnored): + return v.content + else: + raise TypeError(f"_map_raw_to_tensor: unexpected {v} ({type(v).__name__})") + + logits, decoder_state = model( + rf.convert_to_tensor(prev_label, dims=[batch_dim, beam_dim], sparse_dim=model.vocab_dim), + spatial_dim=single_step_dim, + state=tree.map_structure(_map_raw_to_tensor, prev_state), + ) + label_log_prob = rf.log_softmax(logits, axis=model.vocab_dim) + assert set(label_log_prob.dims) == {batch_dim, beam_dim, model.vocab_dim} + + return ( + self._map_tensor_to_raw(label_log_prob, batch_dim=batch_dim, beam_dim=beam_dim).tensor, + tree.map_structure( + functools.partial(self._map_tensor_to_raw, batch_dim=batch_dim, beam_dim=beam_dim), decoder_state + ), + ) + + @staticmethod + def _map_tensor_to_raw(v, *, batch_dim: Dim, beam_dim: Dim): + if isinstance(v, Tensor): + if beam_dim not in v.dims: + return StateObjIgnored(v) + batch_dims_ = [batch_dim, beam_dim] + v = v.copy_transpose(batch_dims_ + [dim for dim in v.dims if dim not in batch_dims_]) + raw = v.raw_tensor + return StateObjTensorExt(raw, v.copy_template()) + elif isinstance(v, Dim): + return StateObjIgnored(v) + else: + raise TypeError(f"_map_tensor_to_raw: unexpected {v} ({type(v).__name__})") + + return LabelScorer() + + +def make_time_sync_label_scorer_torch( + model: TransformerDecoder, + align_target_dim: Dim, +) -> LabelScorerIntf: + """ + Make label scorer + """ + import torch + import tree + import functools + from i6_experiments.users.schmitt.returnn_frontend.model_interfaces.label_scorer import ( + StateObjTensorExt, + StateObjIgnored, + ) + + class LabelScorer(LabelScorerIntf): + """TransformerDecoder label scorer""" + + def get_initial_state(self, *, batch_size: int, device: torch.device) -> Any: + """Initial state.""" + batch_dim = Dim(batch_size, name="batch") + beam_dim = Dim(1, name="initial-beam") + batch_dims_ = [batch_dim, beam_dim] + decoder_state = model.default_initial_state(batch_dims=batch_dims_) + return tree.map_structure( + functools.partial(self._map_tensor_to_raw, batch_dim=batch_dim, beam_dim=beam_dim), decoder_state + ) + + def max_remaining_seq_score( + self, *, state: Any, max_remaining_steps: torch.Tensor, device: torch.device + ) -> torch.Tensor: + """max remaining""" + return torch.zeros((1, 1), device=device) + + def score_and_update_state( + self, + *, + prev_state: Any, + prev_label: torch.Tensor, + prev_align_label: Optional[torch.Tensor] = None, + t: Optional[int] = None, + ) -> Tuple[torch.Tensor, Any]: + """update state""" + batch_dim = Dim(prev_label.shape[0], name="batch") + beam_dim = Dim(prev_label.shape[1], name="beam") + + def _map_raw_to_tensor(v): + if isinstance(v, StateObjTensorExt): + tensor: Tensor = v.extra + tensor = tensor.copy_template_new_dim_tags( + (batch_dim, beam_dim) + tensor.dims[2:], keep_special_axes=True + ) + tensor.raw_tensor = v.tensor + return tensor + elif isinstance(v, StateObjIgnored): + return v.content + else: + raise TypeError(f"_map_raw_to_tensor: unexpected {v} ({type(v).__name__})") + + initial_output_mask = rf.convert_to_tensor(prev_label == -1, dims=[batch_dim, beam_dim]) + prev_label = rf.convert_to_tensor(prev_label, dims=[batch_dim, beam_dim], sparse_dim=model.vocab_dim) + # replace -1 by 0 (assuming 0 is the BOS symbol) + prev_label = rf.where( + initial_output_mask, + rf.zeros_like(prev_label), + prev_label + ) + logits, decoder_state = model( + prev_label, + spatial_dim=single_step_dim, + state=tree.map_structure(_map_raw_to_tensor, prev_state), + ) + label_log_prob = rf.log_softmax(logits, axis=model.vocab_dim) + blank_log_prob = rf.zeros( + [Dim(1, name="blank_log_prob_label_scorer")], + dtype="float32" + ) + output_log_prob, _ = rf.concat( + (label_log_prob, model.vocab_dim), (blank_log_prob, blank_log_prob.dims[0]), + out_dim=align_target_dim, + allow_broadcast=True + ) + assert set(output_log_prob.dims) == {batch_dim, beam_dim, align_target_dim} + + return ( + self._map_tensor_to_raw(output_log_prob, batch_dim=batch_dim, beam_dim=beam_dim).tensor, + tree.map_structure( + functools.partial(self._map_tensor_to_raw, batch_dim=batch_dim, beam_dim=beam_dim), decoder_state + ), + ) + + @staticmethod + def _map_tensor_to_raw(v, *, batch_dim: Dim, beam_dim: Dim): + if isinstance(v, Tensor): + if beam_dim not in v.dims: + return StateObjIgnored(v) + batch_dims_ = [batch_dim, beam_dim] + v = v.copy_transpose(batch_dims_ + [dim for dim in v.dims if dim not in batch_dims_]) + raw = v.raw_tensor + return StateObjTensorExt(raw, v.copy_template()) + elif isinstance(v, Dim): + return StateObjIgnored(v) + else: + raise TypeError(f"_map_tensor_to_raw: unexpected {v} ({type(v).__name__})") + + return LabelScorer() diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/lm/trafo/model_import.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/lm/trafo/model_import.py new file mode 100644 index 000000000..b1371afd1 --- /dev/null +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/lm/trafo/model_import.py @@ -0,0 +1,127 @@ +""" +https://arxiv.org/abs/1905.04226 +Reference: https://github.com/rwth-i6/returnn-experiments/blob/master/2019-lm-transformers/librispeech/bpe_10k/transfo_24_d00.4096_1024.sgd.lr1.8_heads.config +""" + +from __future__ import annotations + +from typing import Dict + +import numpy + +from sisyphus import tk + +from i6_core.returnn.training import Checkpoint +from i6_experiments.users.schmitt.returnn_frontend.convert.checkpoint import ConvertTfCheckpointToRfPtJob + +import returnn.frontend as rf + +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.lm.trafo import model as trafo_lm + +_returnn_tf_ckpt_filename = "/work/asr3/irie/experiments/lm/librispeech/2018-03-05--lmbpe-zeyer/data-train/transfo_24_d00.4096_1024.sgd.lr1.8_heads/bk-net-model/network.023.index" +_load_existing_ckpt_in_test = True +TrafoLmOpts = { + "vocab_dim": 10_025, + "model_dim": 1024, + "embed_dim": 128, + "num_layers": 24, + "decoder_layer_opts": {"self_att_opts": {"with_bias": False, "att_dropout_broadcast": False}}, + "input_embedding_scale": 1.0, + "share_embedding": False, + "logits_with_bias": True, + "input_dropout": 0.1, +} + +_ParamMapping = {} # type: Dict[str,str] + + +def get_tf_checkpoint_path() -> tk.Path: + """ + :return: Sisyphus tk.Path to the original TF checkpoint file + + https://arxiv.org/abs/1905.04226 + Reference: https://github.com/rwth-i6/returnn-experiments/blob/master/2019-lm-transformers/librispeech/bpe_10k/transfo_24_d00.4096_1024.sgd.lr1.8_heads.config + """ + return tk.Path( + _returnn_tf_ckpt_filename, hash_overwrite="librispeech-2018-kazuki-transfo_24_d00.4096_1024.sgd.lr1.8_heads" + ) + + +def get_pt_checkpoint_path() -> tk.Path: + """ + :return: Sisyphus tk.Path to the PyTorch checkpoint file + + https://arxiv.org/abs/1905.04226 + Reference: https://github.com/rwth-i6/returnn-experiments/blob/master/2019-lm-transformers/librispeech/bpe_10k/transfo_24_d00.4096_1024.sgd.lr1.8_heads.config + """ + old_tf_ckpt_path = get_tf_checkpoint_path() + old_tf_ckpt = Checkpoint(index_path=old_tf_ckpt_path) + make_model_func = trafo_lm.MakeModel(**TrafoLmOpts) # eos_label=0 + converter = ConvertTfCheckpointToRfPtJob( + checkpoint=old_tf_ckpt, + make_model_func=make_model_func, + map_func=map_param_func_v2, + epoch=1, + step=0, + ) + return converter.out_checkpoint + + +def _add_params(): + _ParamMapping.update( + { + "input_embedding.weight": "output/rec/target_embed_raw/W", + "input_embedding_proj.weight": "output/rec/target_embed_lin/W", + "final_layer_norm.scale": "output/rec/decoder/scale", + "final_layer_norm.bias": "output/rec/decoder/bias", + "logits.weight": "output/rec/output/W", + "logits.bias": "output/rec/output/b", + } + ) + + for layer_idx in range(TrafoLmOpts["num_layers"]): + # FF + _ParamMapping[f"layers.{layer_idx}.ff.linear_ff.weight"] = f"output/rec/dec_{layer_idx}_ff_conv1/W" + _ParamMapping[f"layers.{layer_idx}.ff.linear_ff.bias"] = f"output/rec/dec_{layer_idx}_ff_conv1/b" + _ParamMapping[f"layers.{layer_idx}.ff.linear_out.weight"] = f"output/rec/dec_{layer_idx}_ff_conv2/W" + _ParamMapping[f"layers.{layer_idx}.ff.linear_out.bias"] = f"output/rec/dec_{layer_idx}_ff_conv2/b" + _ParamMapping[f"layers.{layer_idx}.ff_layer_norm.scale"] = f"output/rec/dec_{layer_idx}_ff_laynorm/scale" + _ParamMapping[f"layers.{layer_idx}.ff_layer_norm.bias"] = f"output/rec/dec_{layer_idx}_ff_laynorm/bias" + + # self-att + _ParamMapping[f"layers.{layer_idx}.self_att.qkv.weight"] = f"output/rec/dec_{layer_idx}_self_att_att/QKV" + _ParamMapping[f"layers.{layer_idx}.self_att.proj.weight"] = f"output/rec/dec_{layer_idx}_self_att_lin/W" + _ParamMapping[f"layers.{layer_idx}.self_att_layer_norm.scale"] = ( + f"output/rec/dec_{layer_idx}_self_att_laynorm/scale" + ) + _ParamMapping[f"layers.{layer_idx}.self_att_layer_norm.bias"] = ( + f"output/rec/dec_{layer_idx}_self_att_laynorm/bias" + ) + + +_add_params() + + +def map_param_func_v2(reader, name: str, var: rf.Parameter) -> numpy.ndarray: + """map params, TF to RF""" + from tensorflow.python.training.py_checkpoint_reader import CheckpointReader + + assert isinstance(reader, CheckpointReader) + assert isinstance(var, rf.Parameter) + + tf_var_name = name.replace(".", "/") + if reader.has_tensor(tf_var_name): + return reader.get_tensor(tf_var_name) + + if name in _ParamMapping: + var_name = _ParamMapping[name] + assert reader.has_tensor(var_name) + value = reader.get_tensor(var_name) + assert isinstance(value, numpy.ndarray) + assert ( + value.shape == var.batch_shape + ), f"new param {name} {var.batch_shape} vs ckpt param {var_name} {value.shape}" + assert value.dtype.name == var.dtype, f"new param {name} {var.dtype} vs ckpt param {var_name} {value.dtype}" + return value + + raise NotImplementedError(f"cannot map {name!r} {var}") diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/recog.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/recog.py index 902ee0481..c2ff922b3 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/recog.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/recog.py @@ -1,4 +1,4 @@ -from typing import Optional +from typing import Optional, Dict from returnn.tensor import TensorDict @@ -25,9 +25,8 @@ def _returnn_v2_forward_step(*, model, extern_data: TensorDict, **_kwargs_unused targets = extern_data[default_target_key] extra.update(dict(targets=targets, targets_spatial_dim=targets.get_time_dim_tag())) - use_recombination = config.typed_value("use_recombination", None) - if use_recombination: - extra.update(dict(use_recombination=use_recombination)) + beam_search_opts = config.typed_value("beam_search_opts", {}) # type: Dict + extra.update(beam_search_opts) recog_out = recog_def(model=model, data=data, data_spatial_dim=data_spatial_dim, **extra) if len(recog_out) == 5: diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model.py index 7e441184c..f87653f90 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model.py @@ -68,9 +68,9 @@ def __init__( ) assert blank_decoder_version in {1, 3, 4, 5, 6} - assert label_decoder_state in {"nb-lstm", "joint-lstm"} + assert label_decoder_state in {"nb-lstm", "joint-lstm", "nb-linear1"} if not use_joint_model: - assert label_decoder_state == "nb-lstm" + assert label_decoder_state in ("nb-lstm", "nb-linear1") if not use_weight_feedback and not use_att_ctx_in_state: label_decoder_cls = SegmentalAttEfficientLabelDecoder @@ -88,6 +88,7 @@ def __init__( center_window_size=center_window_size, use_weight_feedback=use_weight_feedback, use_att_ctx_in_state=use_att_ctx_in_state, + decoder_state=label_decoder_state, ) if not use_joint_model: @@ -280,6 +281,10 @@ def from_scratch_model_def( def _returnn_v2_get_model(*, epoch: int, **_kwargs_unused): + """ + Here, we use a separate blank model and define the blank_index=len(target_vocab). In this case, the target_dim + is one smaller than the align_target_dim and the EOS label is unused. + """ from returnn.tensor import Tensor, Dim from returnn.config import get_global_config @@ -302,9 +307,14 @@ def _returnn_v2_get_model(*, epoch: int, **_kwargs_unused): return model -def _returnn_v2_get_model_for_full_sum_training(*, epoch: int, **_kwargs_unused): - from returnn.tensor import Tensor, Dim +def _returnn_v2_get_joint_model(*, epoch: int, **_kwargs_unused): + """ + Here, we reinterpret the EOS label as a blank label and use a single softmax for both blank and non-blank labels. + Therefore, we assume align_target_dim and target_dim to be the same. + """ + from returnn.tensor import Tensor from returnn.config import get_global_config + from returnn.datasets.util.vocabulary import BytePairEncoding config = get_global_config() default_input_key = config.typed_value("default_input") @@ -313,6 +323,10 @@ def _returnn_v2_get_model_for_full_sum_training(*, epoch: int, **_kwargs_unused) data = Tensor(name=default_input_key, **extern_data_dict[default_input_key]) targets = Tensor(name=default_target_key, **extern_data_dict[default_target_key]) + non_blank_vocab = config.typed_value("non_blank_vocab") + if non_blank_vocab is not None: + targets.sparse_dim.vocab = BytePairEncoding(**non_blank_vocab) + model_def = config.typed_value("_model_def") model = model_def( epoch=epoch, in_dim=data.feature_dim, align_target_dim=targets.sparse_dim, target_dim=targets.sparse_dim) diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/blank_model/model.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/blank_model/model.py index 3954b544f..af571e7bf 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/blank_model/model.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/blank_model/model.py @@ -229,6 +229,11 @@ def __init__( self.emit_prob = rf.Linear(encoder_out_dim + label_state_dim, self.emit_prob_dim) + def default_initial_state(self, *, batch_dims: Sequence[Dim]) -> rf.State: + """Default initial state""" + state = rf.State() + return state + def get_label_decoder_deps(self) -> Optional[List[str]]: return ["s"] @@ -249,6 +254,13 @@ def __init__( ) self.emit_prob = rf.Linear(self.length_model_state_dim + label_state_dim, self.emit_prob_dim) + def default_initial_state(self, *, batch_dims: Sequence[Dim]) -> rf.State: + """Default initial state""" + state = rf.State( + s_blank=self._s.default_initial_state(batch_dims=batch_dims), + ) + return state + @property def _s(self) -> rf.LSTM: return self.s diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/blank_model/train.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/blank_model/train.py index 7c03707fb..40c4c019b 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/blank_model/train.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/blank_model/train.py @@ -145,11 +145,7 @@ def viterbi_training_v4( # (UnicodeDecodeError: 'ascii' codec can't decode byte 0xe2 in position 0: ordinal not in range(128)) # therefore, we use the following workaround enc = enc_args["enc"] # type: rf.Tensor - enc_raw = enc.raw_tensor - enc = enc.copy_template_replace_dim_tag( - enc.get_axis_from_description(enc_spatial_dim), non_blank_mask_dim - ) - enc.raw_tensor = enc_raw + enc = utils.copy_tensor_replace_dim_tag(enc, enc_spatial_dim, non_blank_mask_dim) am, _ = utils.get_masked( input=enc, @@ -213,11 +209,7 @@ def viterbi_training_v5( ): # using dim.declare_same_as() leads to an error after an epoch is finished (see viterbi_training_v4) enc = enc_args["enc"] # type: rf.Tensor - enc_raw = enc.raw_tensor - enc = enc.copy_template_replace_dim_tag( - enc.get_axis_from_description(enc_spatial_dim), label_states_unmasked_spatial_dim - ) - enc.raw_tensor = enc_raw + enc = utils.copy_tensor_replace_dim_tag(enc, enc_spatial_dim, label_states_unmasked_spatial_dim) blank_logits = model.emit_prob(rf.concat_features(enc, label_states_unmasked)) blank_logits_packed, pack_dim, emit_ground_truth_packed = get_packed_logits_and_emit_ground_truth( @@ -248,11 +240,7 @@ def viterbi_training_v6( ): # using dim.declare_same_as() leads to an error after an epoch is finished (see viterbi_training_v4) enc = enc_args["enc"] # type: rf.Tensor - enc_raw = enc.raw_tensor - enc = enc.copy_template_replace_dim_tag( - enc.get_axis_from_description(enc_spatial_dim), label_states_unmasked_spatial_dim - ) - enc.raw_tensor = enc_raw + enc = utils.copy_tensor_replace_dim_tag(enc, enc_spatial_dim, label_states_unmasked_spatial_dim) s, _ = model.s( enc, diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/label_model/model.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/label_model/model.py index be2c24c36..9de6a3894 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/label_model/model.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/label_model/model.py @@ -23,13 +23,15 @@ def default_initial_state( ) -> rf.State: """Default initial state""" state = rf.State( - s=self.get_lstm().default_initial_state(batch_dims=batch_dims), att=rf.zeros(list(batch_dims) + [self.att_num_heads * self.enc_out_dim]), segment_starts=rf.zeros(batch_dims, sparse_dim=segment_starts_sparse_dim, dtype="int32"), segment_lens=rf.zeros(batch_dims, sparse_dim=segment_lens_sparse_dim, dtype="int32"), ) state.att.feature_dim_axis = len(state.att.dims) - 1 + if "lstm" in self.decoder_state: + state.s = self.get_lstm().default_initial_state(batch_dims=batch_dims) + if self.use_weight_feedback: state.accum_att_weights = rf.zeros( list(batch_dims) + [self.accum_att_weights_dim, self.att_num_heads], feature_dim=self.att_num_heads @@ -144,11 +146,14 @@ def loop_step( # during search, these need to be the values from the previous "emit" step (not necessarily the previous time step) prev_att = state.att - prev_s_state = state.s + prev_s_state = state.s if "lstm" in self.decoder_state else None prev_segment_starts = state.segment_starts prev_segment_lens = state.segment_lens - s, state_.s = self._update_state(input_embed, prev_att, prev_s_state) + s, s_state = self._update_state(input_embed, prev_att, prev_s_state) + if "lstm" in self.decoder_state: + state_.s = s_state + s_transformed = self.s_transformed(s) slice_dim = Dim(name="slice", dimension=segment_lens) @@ -177,9 +182,7 @@ def loop_step( energy = self.energy(rf.tanh(energy_in)) att_weights = rf.softmax(energy, axis=slice_dim) # we do not need use_mask because the softmax output is already padded with zeros - att0 = rf.dot(att_weights, enc_sliced, reduce=slice_dim, use_mask=False) - att0.feature_dim = self.enc_out_dim - att, _ = rf.merge_dims(att0, dims=(self.att_num_heads, self.enc_out_dim)) + att = self.get_att(att_weights, enc_sliced, reduce_dim=slice_dim) state_.att = att if self.use_weight_feedback: diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/label_model/train.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/label_model/train.py index 52fb27d5b..42c66a89b 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/label_model/train.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/model_new/label_model/train.py @@ -23,8 +23,12 @@ def _calc_ce_loss_and_fer( batch_dims: List[Dim], targets_spatial_dim: Dim, target_dim: Dim, + beam_dim: Optional[Dim] = None, ): + if beam_dim is not None: + batch_dims = logits.remaining_dims([beam_dim, targets_spatial_dim, target_dim]) logits_packed, pack_dim = rf.pack_padded(logits, dims=batch_dims + [targets_spatial_dim], enforce_sorted=False) + non_blank_targets_packed, _ = rf.pack_padded( targets, dims=batch_dims + [targets_spatial_dim], enforce_sorted=False, out_dim=pack_dim ) @@ -133,20 +137,25 @@ def viterbi_training_efficient( non_blank_mask: Optional[rf.Tensor] = None, non_blank_mask_spatial_dim: Optional[Dim] = None, return_label_model_states: bool = False, + beam_dim: Optional[Dim] = None, ) -> Optional[Tuple[rf.Tensor, Dim]]: input_embeddings = model.target_embed(targets) input_embeddings_shifted = rf.shift_right( input_embeddings, axis=targets_spatial_dim, pad_value=0.0) - label_lstm_out, final_state = model.s_wo_att( - input_embeddings_shifted, - state=model.s_wo_att.default_initial_state(batch_dims=batch_dims), - spatial_dim=targets_spatial_dim, - ) + if "lstm" in model.decoder_state: + s_out, s_final_state = model.s_wo_att( + input_embeddings_shifted, + state=model.s_wo_att.default_initial_state(batch_dims=batch_dims), + spatial_dim=targets_spatial_dim, + ) + else: + s_out = model.s_wo_att_linear(input_embeddings_shifted) + s_final_state = None if non_blank_mask is not None: - label_lstm_out = utils.get_unmasked( - input=label_lstm_out, + s_out = utils.get_unmasked( + input=s_out, input_spatial_dim=targets_spatial_dim, mask=non_blank_mask, mask_spatial_dim=non_blank_mask_spatial_dim, @@ -161,14 +170,14 @@ def viterbi_training_efficient( # need to move size tensor to GPU since otherwise there is an error in some merge_dims call inside rf.gather # because two tensors have different devices # TODO: fix properly in the gather implementation - targets_spatial_dim.dyn_size_ext = rf.copy_to_device(targets_spatial_dim.dyn_size_ext, label_lstm_out.device) + targets_spatial_dim.dyn_size_ext = rf.copy_to_device(targets_spatial_dim.dyn_size_ext, s_out.device) if non_blank_mask_spatial_dim is not None: - non_blank_mask_spatial_dim.dyn_size_ext = rf.copy_to_device(non_blank_mask_spatial_dim.dyn_size_ext, label_lstm_out.device) + non_blank_mask_spatial_dim.dyn_size_ext = rf.copy_to_device(non_blank_mask_spatial_dim.dyn_size_ext, s_out.device) att = model( enc=enc_args["enc"], enc_ctx=enc_args["enc_ctx"], enc_spatial_dim=enc_spatial_dim, - s=label_lstm_out, + s=s_out, segment_starts=segment_starts, segment_lens=segment_lens, ) @@ -179,10 +188,10 @@ def viterbi_training_efficient( logits = model.decode_logits( input_embed=input_embeddings_shifted, att=att, - s=label_lstm_out, + s=s_out, ) - _calc_ce_loss_and_fer(logits, ce_targets, batch_dims, ce_spatial_dim, model.target_dim) + _calc_ce_loss_and_fer(logits, ce_targets, batch_dims, ce_spatial_dim, model.target_dim, beam_dim=beam_dim) if return_label_model_states: # need to run the lstm one more time to get the last output (which is not needed for the loss computation) @@ -194,14 +203,18 @@ def viterbi_training_efficient( clip_to_valid=True, ) singleton_dim = Dim(name="singleton", dimension=1) - last_lstm_out, _ = model.s_wo_att( - last_embedding, - state=final_state, - spatial_dim=singleton_dim, - ) + if "lstm" in model.decoder_state: + last_s_out, _ = model.s_wo_att( + last_embedding, + state=s_final_state, + spatial_dim=single_step_dim, + ) + else: + last_s_out = model.s_wo_att_linear(last_embedding) + return rf.concat( - (label_lstm_out, targets_spatial_dim), - (rf.expand_dim(last_lstm_out, singleton_dim), singleton_dim), + (s_out, targets_spatial_dim), + (rf.expand_dim(last_s_out, singleton_dim), singleton_dim), ) return None @@ -270,746 +283,3 @@ def full_sum_training( loss.mark_as_loss("full_sum_loss", scale=1.0, use_normalized_loss=True) return None - - -def full_sum_training_w_beam( - *, - model: SegmentalAttEfficientLabelDecoder, - enc_args: Dict, - enc_spatial_dim: Dim, - non_blank_targets: rf.Tensor, # [B, S, V] - non_blank_targets_spatial_dim: Dim, - # segment_starts: rf.Tensor, # [B, T] - # segment_lens: rf.Tensor, # [B, T] - batch_dims: List[Dim], - beam_size: int, -) -> Optional[Dict[str, Tuple[rf.Tensor, Dim]]]: - assert len(batch_dims) == 1, "not supported yet" - - non_blank_input_embeddings = model.target_embed(non_blank_targets) # [B, S, D] - non_blank_input_embeddings, non_blank_targets_padded_spatial_dim = rf.pad( - non_blank_input_embeddings, - axes=[non_blank_targets_spatial_dim], - padding=[(1, 0)], - value=0.0, - ) - non_blank_targets_padded_spatial_dim = non_blank_targets_padded_spatial_dim[0] - - # add blank idx on the right - # this way, when the label index for gathering reached the last non-blank index, it will gather blank after that - # which then only allows corresponding hypotheses to be extended by blank - non_blank_targets_padded, _ = rf.pad( - non_blank_targets, - axes=[non_blank_targets_spatial_dim], - padding=[(0, 1)], - value=model.blank_idx, - out_dims=[non_blank_targets_padded_spatial_dim] - ) - - non_blank_targets_padded_sizes = rf.copy_to_device( - non_blank_targets_padded_spatial_dim.dyn_size_ext, non_blank_targets.device - ) - non_blank_targets_spatial_sizes = rf.copy_to_device( - non_blank_targets_spatial_dim.dyn_size_ext, non_blank_targets.device) - enc_spatial_sizes = rf.copy_to_device(enc_spatial_dim.dyn_size_ext, non_blank_targets.device) - - linear_label_positions = enc_spatial_sizes / non_blank_targets_spatial_sizes - linear_label_positions = linear_label_positions * rf.range_over_dim(non_blank_targets_spatial_dim) - # print("linear_label_positions", linear_label_positions.raw_tensor) - # exit() - - # print("non_blank_targets_padded", non_blank_targets_padded.raw_tensor) - - beam_dim = Dim(1, name="initial-beam") - batch_dims_ = [beam_dim] + batch_dims - bos_idx = 0 - seq_log_prob = rf.constant(0.0, dims=batch_dims_) - - max_seq_len = enc_spatial_dim.get_size_tensor() - max_seq_len = rf.reduce_max(max_seq_len, axis=max_seq_len.dims) - - label_lstm_state = model.s_wo_att.default_initial_state(batch_dims=batch_dims_) - target = rf.constant(bos_idx, dims=batch_dims_, sparse_dim=model.target_dim) - # target_non_blank = target.copy() - update_state_mask = rf.convert_to_tensor(target != model.blank_idx) - label_indices = rf.zeros(batch_dims_, dtype="int64") - - # input_embed = rf.zeros( - # batch_dims_ + [model.target_embed.out_dim], - # feature_dim=model.target_embed.out_dim, - # dtype="float32" - # ) - - vocab_range = rf.range_over_dim(model.target_dim) - blank_tensor = rf.convert_to_tensor(model.blank_idx, dtype=vocab_range.dtype) - log_lambda = rf.log(rf.convert_to_tensor(0.004)) * rf.ones([model.target_dim], dtype="float32") - # lambda_ = rf.shift_right(lambda_, axis=model.target_dim, pad_value=0.0) - log_lambda = rf.where( - vocab_range == model.blank_idx, - rf.constant(0.0, dims=[model.target_dim], dtype="float32"), - log_lambda - ) - - old_beam_dim = beam_dim.copy() - backrefs = rf.zeros(batch_dims_, dtype="int32") - - i = 0 - seq_targets = [] - seq_backrefs = [] - while i < max_seq_len.raw_tensor: - if i > 0: - # target_non_blank = rf.where(update_state_mask, target, rf.gather(target_non_blank, indices=backrefs)) - # input_embed = rf.where( - # update_state_mask, - # model.target_embed(target_non_blank), - # rf.gather(input_embed, indices=backrefs) - # ) - prev_label_indices = rf.gather(label_indices, indices=backrefs) - label_indices = rf.where( - update_state_mask, - rf.where( - prev_label_indices == non_blank_targets_padded_sizes - 1, - prev_label_indices, - prev_label_indices + 1 - ), - prev_label_indices - ) - - ground_truth = rf.gather( - non_blank_targets_padded, - indices=label_indices, - axis=non_blank_targets_padded_spatial_dim, - clip_to_valid=True - ) - input_embed = rf.gather( - non_blank_input_embeddings, - indices=label_indices, - axis=non_blank_targets_padded_spatial_dim, - clip_to_valid=True - ) - - label_lstm_out, label_lstm_state_updated = model.s_wo_att( - input_embed, - state=label_lstm_state, - spatial_dim=single_step_dim, - ) - - center_position = rf.minimum( - rf.full(dims=[beam_dim] + batch_dims, fill_value=i, dtype="int32"), - rf.copy_to_device(enc_spatial_dim.get_size_tensor() - 1, label_lstm_out.device) - ) - segment_starts = rf.maximum( - rf.convert_to_tensor(0, dtype="int32"), center_position - model.center_window_size // 2) - segment_ends = rf.minimum( - rf.copy_to_device(enc_spatial_dim.get_size_tensor() - 1, label_lstm_out.device), - center_position + model.center_window_size // 2 - ) - segment_lens = segment_ends - segment_starts + 1 - - att = model( - enc=enc_args["enc"], - enc_ctx=enc_args["enc_ctx"], - enc_spatial_dim=enc_spatial_dim, - s=label_lstm_out, - segment_starts=segment_starts, - segment_lens=segment_lens, - ) # [B, S+1, T, D] - # print("att", att) - - logits = model.decode_logits( - input_embed=input_embed, - att=att, - s=label_lstm_out, - ) # [B, S+1, T, D] - # print("logits", logits) - - label_log_prob = rf.log_softmax(logits, axis=model.target_dim) - - def custom_backward(grad): - grad[:, :, 0] *= 0.001 - return grad - - if rf.get_run_ctx().train_flag: - label_log_prob.raw_tensor.register_hook(custom_backward) - - # log prob needs to correspond to the next non-blank label... - log_prob_mask = vocab_range == ground_truth - rem_frames = enc_spatial_sizes - i - rem_labels = non_blank_targets_spatial_sizes - label_indices - # ... or to blank if there are more frames than labels left - log_prob_mask = rf.logical_or( - log_prob_mask, - rf.logical_and( - vocab_range == blank_tensor, - rem_frames > rem_labels - ) - ) - label_log_prob = rf.where( - log_prob_mask, - label_log_prob, - rf.constant(-float("inf"), dims=batch_dims + [beam_dim, model.target_dim]) - ) - - seq_log_prob = seq_log_prob + label_log_prob # Batch, InBeam, Vocab - old_beam_dim = beam_dim.copy() - seq_log_prob, (backrefs, target), beam_dim = rf.top_k( - seq_log_prob, - k_dim=Dim(beam_size, name=f"dec-step{i}-beam"), - axis=[beam_dim, model.target_dim] - ) # seq_log_prob, backrefs, target: Batch, Beam - seq_targets.append(target) - seq_backrefs.append(backrefs) - - update_state_mask = rf.logical_and( - rf.convert_to_tensor(target != model.blank_idx), - seq_log_prob != rf.convert_to_tensor(-float("inf"), dtype="float32") - ) - - def _get_masked_state(old, new, mask): - old = rf.gather(old, indices=backrefs, axis=old_beam_dim) - new = rf.gather(new, indices=backrefs, axis=old_beam_dim) - return rf.where(mask, new, old) - - label_lstm_state = tree.map_structure( - lambda old_state, new_state: _get_masked_state(old_state, new_state, update_state_mask), - label_lstm_state, label_lstm_state_updated - ) - - i += 1 - - # # Backtrack via backrefs, resolve beams. - # seq_targets_ = [] - # indices = rf.range_over_dim(beam_dim) # FinalBeam -> FinalBeam - # for backrefs, target in zip(seq_backrefs[::-1], seq_targets[::-1]): - # # indices: FinalBeam -> Beam - # # backrefs: Beam -> PrevBeam - # seq_targets_.insert(0, rf.gather(target, indices=indices)) - # indices = rf.gather(backrefs, indices=indices) # FinalBeam -> PrevBeam - # - # seq_targets__ = TensorArray(seq_targets_[0]) - # for target in seq_targets_: - # seq_targets__ = seq_targets__.push_back(target) - # seq_targets = seq_targets__.stack(axis=enc_spatial_dim) - - # torch.set_printoptions(threshold=10_000) - # print("seq_targets", seq_targets.copy_transpose(batch_dims + [beam_dim, enc_spatial_dim]).raw_tensor[0, 0]) - # print("seq_log_prob", seq_log_prob.raw_tensor[0]) - - # calculate full-sum loss using the log-sum-exp trick - max_log_prob = rf.reduce_max(seq_log_prob, axis=beam_dim) - loss = -1 * (max_log_prob + rf.log(rf.reduce_sum(rf.exp(seq_log_prob - max_log_prob), axis=beam_dim))) - - # loss = -rf.log(rf.reduce_sum(rf.exp(seq_log_prob), axis=beam_dim)) - loss.mark_as_loss("full_sum_loss", scale=1.0, use_normalized_loss=True) - - return None - - -def full_sum_training_w_beam_eff( - *, - model: SegmentalAttEfficientLabelDecoder, - enc_args: Dict, - enc_spatial_dim: Dim, - non_blank_targets: rf.Tensor, # [B, S, V] - non_blank_targets_spatial_dim: Dim, - segment_starts: rf.Tensor, # [B, T] - segment_lens: rf.Tensor, # [B, T] - batch_dims: List[Dim], - beam_size: int, -) -> Optional[Dict[str, Tuple[rf.Tensor, Dim]]]: - assert len(batch_dims) == 1, "not supported yet" - assert model.blank_idx == 0, "blank idx needs to be zero because of the way the gradient is scaled" - - # ------------------------ init some variables ------------------------ - beam_dim = Dim(1, name="initial-beam") - batch_dims_ = [beam_dim] + batch_dims - bos_idx = 0 - seq_log_prob = rf.constant(0.0, dims=batch_dims_) - max_seq_len = enc_spatial_dim.get_size_tensor() - max_seq_len = rf.reduce_max(max_seq_len, axis=max_seq_len.dims) - label_lstm_state = model.s_wo_att.default_initial_state(batch_dims=batch_dims) - target = rf.constant(bos_idx, dims=batch_dims_, sparse_dim=model.target_dim) - update_state_mask = rf.convert_to_tensor(target != model.blank_idx) - label_indices = rf.zeros(batch_dims_, dtype="int32") - vocab_range = rf.range_over_dim(model.target_dim) - blank_tensor = rf.convert_to_tensor(model.blank_idx, dtype=vocab_range.dtype) - backrefs = rf.zeros(batch_dims_, dtype="int32") - seq_hash = rf.constant(0, dims=batch_dims_, dtype="int64") - - # ------------------------ targets/embeddings ------------------------ - - non_blank_input_embeddings = model.target_embed(non_blank_targets) # [B, S, D] - non_blank_input_embeddings, non_blank_targets_padded_spatial_dim = rf.pad( - non_blank_input_embeddings, - axes=[non_blank_targets_spatial_dim], - padding=[(1, 0)], - value=0.0, - ) # [B, S+1, D] - non_blank_targets_padded_spatial_dim = non_blank_targets_padded_spatial_dim[0] - - # add blank idx on the right - # this way, when the label index for gathering reached the last non-blank index, it will gather blank after that - # which then only allows corresponding hypotheses to be extended by blank - non_blank_targets_padded, _ = rf.pad( - non_blank_targets, - axes=[non_blank_targets_spatial_dim], - padding=[(0, 1)], - value=model.blank_idx, - out_dims=[non_blank_targets_padded_spatial_dim] - ) - - # ------------------------ sizes ------------------------ - - non_blank_targets_padded_spatial_sizes = rf.copy_to_device( - non_blank_targets_padded_spatial_dim.dyn_size_ext, non_blank_targets.device - ) - non_blank_targets_spatial_sizes = rf.copy_to_device( - non_blank_targets_spatial_dim.dyn_size_ext, non_blank_targets.device) - max_num_labels = rf.reduce_max( - non_blank_targets_spatial_sizes, axis=non_blank_targets_spatial_sizes.dims - ).raw_tensor.item() - enc_spatial_sizes = rf.copy_to_device(enc_spatial_dim.dyn_size_ext, non_blank_targets.device) - - # ------------------------ compute LSTM sequence ------------------------ - - label_lstm_out_seq, _ = model.s_wo_att( - non_blank_input_embeddings, - state=label_lstm_state, - spatial_dim=non_blank_targets_padded_spatial_dim, - ) - - # ------------------------ chunk dim ------------------------ - - chunk_size = 20 - chunk_dim = Dim(chunk_size, name="chunk") - chunk_range = rf.expand_dim(rf.range_over_dim(chunk_dim), batch_dims[0]) - - i = 0 - seq_targets = [] - seq_backrefs = [] - while i < max_seq_len.raw_tensor: - # get current number of labels for each hypothesis - if i > 0: - prev_label_indices = rf.gather(label_indices, indices=backrefs) - label_indices = rf.where( - update_state_mask, - rf.where( - prev_label_indices == non_blank_targets_padded_spatial_sizes - 1, - prev_label_indices, - prev_label_indices + 1 - ), - prev_label_indices - ) - - # gather ground truth, input embeddings and LSTM output for current label index - ground_truth = rf.gather( - non_blank_targets_padded, - indices=label_indices, - axis=non_blank_targets_padded_spatial_dim, - clip_to_valid=True - ) - input_embed = rf.gather( - non_blank_input_embeddings, - indices=label_indices, - axis=non_blank_targets_padded_spatial_dim, - clip_to_valid=True - ) - label_lstm_out = rf.gather( - label_lstm_out_seq, - indices=label_indices, - axis=non_blank_targets_padded_spatial_dim, - clip_to_valid=True - ) - - # precompute attention for the current chunk (more efficient than computing it individually for each label index) - if i % chunk_size == 0: - seg_starts = rf.gather( - segment_starts, - indices=chunk_range, - axis=enc_spatial_dim, - clip_to_valid=True - ) - seg_lens = rf.gather( - segment_lens, - indices=chunk_range, - axis=enc_spatial_dim, - clip_to_valid=True - ) - att = model( - enc=enc_args["enc"], - enc_ctx=enc_args["enc_ctx"], - enc_spatial_dim=enc_spatial_dim, - s=label_lstm_out_seq, - segment_starts=seg_starts, - segment_lens=seg_lens, - ) # [B, S+1, T, D] - chunk_range += chunk_size - - # gather attention for the current label index - att_step = rf.gather( - att, - indices=label_indices, - axis=non_blank_targets_padded_spatial_dim, - clip_to_valid=True - ) - att_step = rf.gather( - att_step, - indices=rf.constant(i % chunk_size, dims=batch_dims, device=att_step.device), - axis=chunk_dim, - clip_to_valid=True - ) - - logits = model.decode_logits( - input_embed=input_embed, - att=att_step, - s=label_lstm_out, - ) # [B, S+1, T, D] - - label_log_prob = rf.log_softmax(logits, axis=model.target_dim) - - # alpha = 0. - # label_log_prob = label_log_prob + rf.stop_gradient(label_log_prob * (alpha - 1)) - - # # scale down blank gradient to avoid outputting only blanks in the beginning - # # and then all other labels in the end - # def custom_backward(grad): - # grad[:, :, 0] *= 0.00005 - # return grad - # - # if rf.get_run_ctx().train_flag: - # label_log_prob.raw_tensor.register_hook(custom_backward) - - # mask label log prob in order to only allow hypotheses corresponding to the ground truth: - # log prob needs to correspond to the next non-blank label... - log_prob_mask = vocab_range == ground_truth - rem_frames = enc_spatial_sizes - i - rem_labels = non_blank_targets_spatial_sizes - label_indices - # ... or to blank if there are more frames than labels left - log_prob_mask = rf.logical_or( - log_prob_mask, - rf.logical_and( - vocab_range == blank_tensor, - rem_frames > rem_labels - ) - ) - label_log_prob = rf.where( - log_prob_mask, - label_log_prob, - rf.constant(-1.0e30, dims=batch_dims + [beam_dim, model.target_dim]) - ) - - # recombine hypotheses corresponding to the same node in the lattice (= same hash value -> same label history) - # do this by setting the log prob of all but the best hypothesis to -inf - # and setting the log prob of the best hypothesis to either the max or the sum of the equivalent hypotheses - seq_log_prob = recombination.recombine_seqs(seq_targets, seq_log_prob, seq_hash, beam_dim, batch_dims[0]) - - # set the beam size as low as possible according to the following rules (using recombination): - # 1) in frame i, there are i+1 nodes in the lattice and from each node, we can spawn 2 hypotheses - # 2) if T-i frames remain, only (T-i)*2 hypotheses can survive in order to reach the last node - # 3) in a frame, there are at most S+1 nodes, i.e. (S+1)*2 hypotheses can be spawned (see 1)) - # 4) the beam size should not exceed the given beam size - beam_size_ = min( - min((i + 1) * 2, rf.reduce_max(rem_frames, axis=rem_frames.dims).raw_tensor.item() * 2), - min((max_num_labels + 1) * 2 - 1, beam_size) - ) - - # update sequence log prob and beam indices - seq_log_prob = seq_log_prob + label_log_prob # Batch, InBeam, Vocab - seq_log_prob, (backrefs, target), beam_dim = rf.top_k( - seq_log_prob, - k_dim=Dim(beam_size_, name=f"dec-step{i}-beam"), - axis=[beam_dim, model.target_dim] - ) # seq_log_prob, backrefs, target: Batch, Beam - seq_targets.append(target) - seq_backrefs.append(backrefs) - - seq_hash = recombination.update_seq_hash(seq_hash, target, backrefs, model.blank_idx) - - # mask blank label - update_state_mask = rf.convert_to_tensor(target != model.blank_idx) - - i += 1 - - # last recombination - seq_log_prob = recombination.recombine_seqs(seq_targets, seq_log_prob, seq_hash, beam_dim, batch_dims[0]) - - # # Backtrack via backrefs, resolve beams. - # seq_targets_ = [] - # indices = rf.range_over_dim(beam_dim) # FinalBeam -> FinalBeam - # for backrefs, target in zip(seq_backrefs[::-1], seq_targets[::-1]): - # # indices: FinalBeam -> Beam - # # backrefs: Beam -> PrevBeam - # seq_targets_.insert(0, rf.gather(target, indices=indices)) - # indices = rf.gather(backrefs, indices=indices) # FinalBeam -> PrevBeam - # - # seq_targets__ = TensorArray(seq_targets_[0]) - # for target in seq_targets_: - # seq_targets__ = seq_targets__.push_back(target) - # seq_targets = seq_targets__.stack(axis=enc_spatial_dim) - # - # torch.set_printoptions(threshold=10_000) - # print("seq_targets", seq_targets.copy_transpose(batch_dims + [beam_dim, enc_spatial_dim]).raw_tensor[0, :]) - # print("seq_log_prob", seq_log_prob.raw_tensor[0]) - - # calculate full-sum loss using the log-sum-exp trick - max_log_prob = rf.reduce_max(seq_log_prob, axis=beam_dim) - loss = -1 * (max_log_prob + rf.log(rf.reduce_sum(rf.exp(seq_log_prob - max_log_prob), axis=beam_dim))) - - # loss = -rf.log(rf.reduce_sum(rf.exp(seq_log_prob), axis=beam_dim)) - loss.mark_as_loss("full_sum_loss", scale=1.0, use_normalized_loss=True) - - return None - - -def full_sum_training_w_beam_eff_w_recomb( - *, - model: SegmentalAttEfficientLabelDecoder, - enc_args: Dict, - enc_spatial_dim: Dim, - non_blank_targets: rf.Tensor, # [B, S, V] - non_blank_targets_spatial_dim: Dim, - segment_starts: rf.Tensor, # [B, T] - segment_lens: rf.Tensor, # [B, T] - batch_dims: List[Dim], - beam_size: int, -) -> Optional[Dict[str, Tuple[rf.Tensor, Dim]]]: - assert len(batch_dims) == 1, "not supported yet" - assert model.blank_idx == 0, "blank idx needs to be zero because of the way the gradient is scaled" - - # ------------------------ init some variables ------------------------ - beam_dim = Dim(1, name="initial-beam") - batch_dims_ = [beam_dim] + batch_dims - bos_idx = 0 - seq_log_prob = rf.constant(0.0, dims=batch_dims_) - max_seq_len = enc_spatial_dim.get_size_tensor() - max_seq_len = rf.reduce_max(max_seq_len, axis=max_seq_len.dims) - label_lstm_state = model.s_wo_att.default_initial_state(batch_dims=batch_dims) - target = rf.constant(bos_idx, dims=batch_dims_, sparse_dim=model.target_dim) - vocab_range = rf.range_over_dim(model.target_dim) - blank_tensor = rf.convert_to_tensor(model.blank_idx, dtype=vocab_range.dtype) - backrefs = rf.zeros(batch_dims_, dtype="int32") - - # ------------------------ targets/embeddings ------------------------ - - non_blank_input_embeddings = model.target_embed(non_blank_targets) # [B, S, D] - non_blank_input_embeddings, non_blank_targets_padded_spatial_dim = rf.pad( - non_blank_input_embeddings, - axes=[non_blank_targets_spatial_dim], - padding=[(1, 0)], - value=0.0, - ) # [B, S+1, D] - non_blank_targets_padded_spatial_dim = non_blank_targets_padded_spatial_dim[0] - - # add blank idx on the right - # this way, when the label index for gathering reached the last non-blank index, it will gather blank after that - # which then only allows corresponding hypotheses to be extended by blank - non_blank_targets_padded, _ = rf.pad( - non_blank_targets, - axes=[non_blank_targets_spatial_dim], - padding=[(0, 1)], - value=model.blank_idx, - out_dims=[non_blank_targets_padded_spatial_dim] - ) - - # ------------------------ sizes ------------------------ - - non_blank_targets_padded_spatial_sizes = rf.copy_to_device( - non_blank_targets_padded_spatial_dim.dyn_size_ext, non_blank_targets.device - ) - non_blank_targets_spatial_sizes = rf.copy_to_device( - non_blank_targets_spatial_dim.dyn_size_ext, non_blank_targets.device) - max_num_labels = rf.reduce_max( - non_blank_targets_spatial_sizes, axis=non_blank_targets_spatial_sizes.dims - ).raw_tensor.item() - single_col_dim = Dim(dimension=max_num_labels + 1, name="max-num-labels") - label_indices = rf.zeros(batch_dims_, dtype="int32", sparse_dim=single_col_dim) - - enc_spatial_sizes = rf.copy_to_device(enc_spatial_dim.dyn_size_ext, non_blank_targets.device) - - # ------------------------ compute LSTM sequence ------------------------ - - label_lstm_out_seq, _ = model.s_wo_att( - non_blank_input_embeddings, - state=label_lstm_state, - spatial_dim=non_blank_targets_padded_spatial_dim, - ) - - # ------------------------ chunk dim ------------------------ - - chunk_size = 20 - chunk_dim = Dim(chunk_size, name="chunk") - chunk_range = rf.expand_dim(rf.range_over_dim(chunk_dim), batch_dims[0]) - - i = 0 - seq_targets = [] - seq_backrefs = [] - while i < max_seq_len.raw_tensor: - # get current number of labels for each hypothesis - if i > 0: - prev_label_indices = rf.gather(label_indices, indices=backrefs) - # mask blank label - update_state_mask = rf.convert_to_tensor(target != prev_label_indices) - label_indices = rf.where( - update_state_mask, - rf.where( - prev_label_indices == non_blank_targets_padded_spatial_sizes - 1, - prev_label_indices, - prev_label_indices + 1 - ), - prev_label_indices - ) - - # gather ground truth, input embeddings and LSTM output for current label index - ground_truth = rf.gather( - non_blank_targets_padded, - indices=label_indices, - axis=non_blank_targets_padded_spatial_dim, - clip_to_valid=True - ) - input_embed = rf.gather( - non_blank_input_embeddings, - indices=label_indices, - axis=non_blank_targets_padded_spatial_dim, - clip_to_valid=True - ) - label_lstm_out = rf.gather( - label_lstm_out_seq, - indices=label_indices, - axis=non_blank_targets_padded_spatial_dim, - clip_to_valid=True - ) - - # precompute attention for the current chunk (more efficient than computing it individually for each label index) - if i % chunk_size == 0: - seg_starts = rf.gather( - segment_starts, - indices=chunk_range, - axis=enc_spatial_dim, - clip_to_valid=True - ) - seg_lens = rf.gather( - segment_lens, - indices=chunk_range, - axis=enc_spatial_dim, - clip_to_valid=True - ) - att = model( - enc=enc_args["enc"], - enc_ctx=enc_args["enc_ctx"], - enc_spatial_dim=enc_spatial_dim, - s=label_lstm_out_seq, - segment_starts=seg_starts, - segment_lens=seg_lens, - ) # [B, S+1, T, D] - chunk_range += chunk_size - - # gather attention for the current label index - att_step = rf.gather( - att, - indices=label_indices, - axis=non_blank_targets_padded_spatial_dim, - clip_to_valid=True - ) - att_step = rf.gather( - att_step, - indices=rf.constant(i % chunk_size, dims=batch_dims, device=att_step.device), - axis=chunk_dim, - clip_to_valid=True - ) - - logits = model.decode_logits( - input_embed=input_embed, - att=att_step, - s=label_lstm_out, - ) # [B, S+1, T, D] - - label_log_prob = rf.log_softmax(logits, axis=model.target_dim) - - # mask label log prob in order to only allow hypotheses corresponding to the ground truth: - # log prob needs to correspond to the next non-blank label... - log_prob_mask = vocab_range == ground_truth - rem_frames = enc_spatial_sizes - i - rem_labels = non_blank_targets_spatial_sizes - label_indices - # ... or to blank if there are more frames than labels left - log_prob_mask = rf.logical_or( - log_prob_mask, - rf.logical_and( - vocab_range == blank_tensor, - rem_frames > rem_labels - ) - ) - label_log_prob = rf.where( - log_prob_mask, - label_log_prob, - rf.constant(-1.0e30, dims=batch_dims + [beam_dim, model.target_dim]) - ) - - label_log_prob = rf.where( - rf.convert_to_tensor(i >= rf.copy_to_device(enc_spatial_dim.get_size_tensor(), label_log_prob.device)), - rf.sparse_to_dense( - model.blank_idx, - axis=model.target_dim, - label_value=0.0, - other_value=-1.0e30 - ), - label_log_prob - ) - - seq_log_prob = recombination.recombine_seqs_train( - seq_log_prob=seq_log_prob, - label_log_prob=label_log_prob, - label_indices=label_indices, - ground_truth=ground_truth, - target_dim=model.target_dim, - single_col_dim=single_col_dim, - labels_padded_spatial_sizes=non_blank_targets_padded_spatial_sizes, - beam_dim=beam_dim, - batch_dims=batch_dims, - blank_idx=model.blank_idx, - ) - - beam_size_ = min( - min((i + 2), rf.reduce_max(rem_frames, axis=rem_frames.dims).raw_tensor.item()), - min((max_num_labels + 1), beam_size) - ) - - # update sequence log prob and beam indices - # seq_log_prob = seq_log_prob + label_log_prob # Batch, InBeam, Vocab - seq_log_prob, (backrefs, target), beam_dim = rf.top_k( - seq_log_prob, - k_dim=Dim(beam_size_, name=f"dec-step{i}-beam"), - axis=[beam_dim, single_col_dim] - ) # seq_log_prob, backrefs, target: Batch, Beam - seq_targets.append(target) - seq_backrefs.append(backrefs) - - i += 1 - - # Backtrack via backrefs, resolve beams. - seq_targets_ = [] - indices = rf.range_over_dim(beam_dim) # FinalBeam -> FinalBeam - for backrefs, target in zip(seq_backrefs[::-1], seq_targets[::-1]): - # indices: FinalBeam -> Beam - # backrefs: Beam -> PrevBeam - seq_targets_.insert(0, rf.gather(target, indices=indices)) - indices = rf.gather(backrefs, indices=indices) # FinalBeam -> PrevBeam - - seq_targets__ = TensorArray(seq_targets_[0]) - for target in seq_targets_: - seq_targets__ = seq_targets__.push_back(target) - seq_targets = seq_targets__.stack(axis=enc_spatial_dim) - - torch.set_printoptions(threshold=10_000) - print("seq_targets", seq_targets.copy_transpose(batch_dims + [beam_dim, enc_spatial_dim]).raw_tensor[0, 0]) - - loss = -1 * seq_log_prob - - # loss = -rf.log(rf.reduce_sum(rf.exp(seq_log_prob), axis=beam_dim)) - loss.mark_as_loss("full_sum_loss", scale=1.0, use_normalized_loss=True) - - # print("loss", loss.raw_tensor) - # print("single_col_dim", single_col_dim.dimension) - # exit() - - return None - diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/realignment.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/realignment.py new file mode 100644 index 000000000..7e4b1a0b3 --- /dev/null +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/realignment.py @@ -0,0 +1,476 @@ +from typing import Optional, Dict, Any, Sequence, Tuple, List + +import torch + +from i6_experiments.users.schmitt import hdf +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental import utils +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental import recombination +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model import SegmentalAttentionModel +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model_new.label_model.model import ( + SegmentalAttLabelDecoder, + SegmentalAttEfficientLabelDecoder +) + +from returnn.tensor import Dim, single_step_dim, TensorDict +import returnn.frontend as rf +from returnn.frontend.tensor_array import TensorArray + + +def model_realign_( + *, + model: SegmentalAttentionModel, + data: rf.Tensor, + data_spatial_dim: Dim, + non_blank_targets: rf.Tensor, + non_blank_targets_spatial_dim: Dim, +): + assert model.use_joint_model + assert isinstance(model.label_decoder, SegmentalAttEfficientLabelDecoder) + assert model.label_decoder_state == "nb-lstm" + + if data.feature_dim and data.feature_dim.dimension == 1: + data = rf.squeeze(data, axis=data.feature_dim) + assert not data.feature_dim # raw audio + + batch_dims = data.remaining_dims(data_spatial_dim) + enc_args, enc_spatial_dim = model.encoder.encode(data, in_spatial_dim=data_spatial_dim) + + segment_starts, segment_lens = utils.get_segment_starts_and_lens( + rf.sequence_mask(batch_dims + [enc_spatial_dim]), # this way, every frame is interpreted as non-blank + enc_spatial_dim, + model, + batch_dims, + enc_spatial_dim + ) + + max_num_labels = rf.reduce_max( + non_blank_targets_spatial_dim.dyn_size_ext, + axis=batch_dims + ) + max_num_labels = max_num_labels.raw_tensor.item() + + seq_log_prob, viterbi_alignment, viterbi_alignment_spatial_dim = model_realign( + model=model.label_decoder, + enc=enc_args["enc"], + enc_ctx=enc_args["enc_ctx"], + enc_spatial_dim=enc_spatial_dim, + non_blank_targets=non_blank_targets, + non_blank_targets_spatial_dim=non_blank_targets_spatial_dim, + segment_starts=segment_starts, + segment_lens=segment_lens, + batch_dims=batch_dims, + beam_size=max_num_labels, + downsampling=1, + precompute_chunk_size=10, + interpolation_alignment=None, + interpolation_alignment_factor=0.0, + use_recombination="max", + return_realignment=True, + ) + + return viterbi_alignment, seq_log_prob, viterbi_alignment_spatial_dim + + +def model_realign( + *, + model: SegmentalAttEfficientLabelDecoder, + enc: rf.Tensor, + enc_ctx: rf.Tensor, + enc_spatial_dim: Dim, + non_blank_targets: rf.Tensor, # [B, S, V] + non_blank_targets_spatial_dim: Dim, + segment_starts: rf.Tensor, # [B, T] + segment_lens: rf.Tensor, # [B, T] + batch_dims: List[Dim], + beam_size: int, + downsampling: int, + precompute_chunk_size: int, + interpolation_alignment: Optional[rf.Tensor], + interpolation_alignment_factor: float, + use_recombination: Optional[str] = "sum", + return_realignment: bool = False, +) -> Tuple[rf.Tensor, Optional[rf.Tensor], Optional[Dim]]: + assert len(batch_dims) == 1, "not supported yet" + assert model.blank_idx == 0, "blank idx needs to be zero because of the way the gradient is scaled" + if interpolation_alignment_factor > 0.0: + assert interpolation_alignment is not None + + # ------------------------ downsample encoder ------------------------ + + if downsampling > 1: + enc_spatial_dim_downsampled = enc_spatial_dim // downsampling + downsample_indices = rf.range_over_dim(enc_spatial_dim_downsampled) * downsampling + downsample_indices = rf.expand_dim(downsample_indices, batch_dims[0]) + segment_starts_downsampled = rf.gather(segment_starts, indices=downsample_indices, axis=enc_spatial_dim, clip_to_valid=True) + segment_lens_downsampled = rf.gather(segment_lens, indices=downsample_indices, axis=enc_spatial_dim, clip_to_valid=True) + + segment_starts = segment_starts_downsampled + segment_lens = segment_lens_downsampled + else: + enc_spatial_dim_downsampled = enc_spatial_dim + + # ------------------------ init some variables ------------------------ + beam_dim = Dim(1, name="initial-beam") + batch_dims_ = [beam_dim] + batch_dims + bos_idx = 0 + seq_log_prob = rf.constant(0.0, dims=batch_dims_) + max_seq_len = enc_spatial_dim_downsampled.get_size_tensor() + max_seq_len = rf.reduce_max(max_seq_len, axis=max_seq_len.dims) + label_lstm_state = model.s_wo_att.default_initial_state(batch_dims=batch_dims) + target = rf.constant(bos_idx, dims=batch_dims_, sparse_dim=model.target_dim) + vocab_range = rf.range_over_dim(model.target_dim) + blank_tensor = rf.convert_to_tensor(model.blank_idx, dtype=vocab_range.dtype) + backrefs = rf.zeros(batch_dims_, dtype="int32") + update_state_mask = rf.ones(batch_dims_, dtype="bool") + + # ------------------------ targets/embeddings ------------------------ + + non_blank_input_embeddings = model.target_embed(non_blank_targets) # [B, S, D] + non_blank_input_embeddings, non_blank_targets_padded_spatial_dim = rf.pad( + non_blank_input_embeddings, + axes=[non_blank_targets_spatial_dim], + padding=[(1, 0)], + value=0.0, + ) # [B, S+1, D] + non_blank_targets_padded_spatial_dim = non_blank_targets_padded_spatial_dim[0] + + # add blank idx on the right + # this way, when the label index for gathering reached the last non-blank index, it will gather blank after that + # which then only allows corresponding hypotheses to be extended by blank + non_blank_targets_padded, _ = rf.pad( + non_blank_targets, + axes=[non_blank_targets_spatial_dim], + padding=[(0, 1)], + value=model.blank_idx, + out_dims=[non_blank_targets_padded_spatial_dim] + ) + + # ------------------------ sizes ------------------------ + + non_blank_targets_padded_spatial_sizes = rf.copy_to_device( + non_blank_targets_padded_spatial_dim.dyn_size_ext, non_blank_targets.device + ) + non_blank_targets_spatial_sizes = rf.copy_to_device( + non_blank_targets_spatial_dim.dyn_size_ext, non_blank_targets.device) + max_num_labels = rf.reduce_max( + non_blank_targets_spatial_sizes, axis=non_blank_targets_spatial_sizes.dims + ).raw_tensor.item() + single_col_dim = Dim(dimension=max_num_labels + 1, name="max-num-labels") + label_indices = rf.zeros(batch_dims_, dtype="int32", sparse_dim=single_col_dim) + prev_label_indices = label_indices.copy() + + enc_spatial_sizes = rf.copy_to_device(enc_spatial_dim_downsampled.dyn_size_ext, non_blank_targets.device) + + # ------------------------ compute LSTM sequence ------------------------ + + label_lstm_out_seq, _ = model.s_wo_att( + non_blank_input_embeddings, + state=label_lstm_state, + spatial_dim=non_blank_targets_padded_spatial_dim, + ) + + # ------------------------ chunk dim ------------------------ + + chunk_dim = Dim(precompute_chunk_size, name="chunk") + chunk_range = rf.expand_dim(rf.range_over_dim(chunk_dim), batch_dims[0]) + + i = 0 + seq_targets = [] + seq_backrefs = [] + while i < max_seq_len.raw_tensor: + # get current number of labels for each hypothesis + if i > 0: + label_indices = rf.where( + update_state_mask, + rf.where( + prev_label_indices == non_blank_targets_padded_spatial_sizes - 1, + prev_label_indices, + prev_label_indices + 1 + ), + prev_label_indices + ) + + # gather ground truth, input embeddings and LSTM output for current label index + label_ground_truth = rf.gather( + non_blank_targets_padded, + indices=label_indices, + axis=non_blank_targets_padded_spatial_dim, + clip_to_valid=True + ) + input_embed = rf.gather( + non_blank_input_embeddings, + indices=label_indices, + axis=non_blank_targets_padded_spatial_dim, + clip_to_valid=True + ) + label_lstm_out = rf.gather( + label_lstm_out_seq, + indices=label_indices, + axis=non_blank_targets_padded_spatial_dim, + clip_to_valid=True + ) + + # precompute attention for the current chunk (more efficient than computing it individually for each label index) + if i % precompute_chunk_size == 0: + seg_starts = rf.gather( + segment_starts, + indices=chunk_range, + axis=enc_spatial_dim_downsampled, + clip_to_valid=True + ) + seg_lens = rf.gather( + segment_lens, + indices=chunk_range, + axis=enc_spatial_dim_downsampled, + clip_to_valid=True + ) + att = model( + enc=enc, + enc_ctx=enc_ctx, + enc_spatial_dim=enc_spatial_dim, + s=label_lstm_out_seq, + segment_starts=seg_starts, + segment_lens=seg_lens, + ) # [B, S+1, T, D] + chunk_range += precompute_chunk_size + + # gather attention for the current label index + att_step = rf.gather( + att, + indices=label_indices, + axis=non_blank_targets_padded_spatial_dim, + clip_to_valid=True + ) + att_step = rf.gather( + att_step, + indices=rf.constant(i % precompute_chunk_size, dims=batch_dims, device=att_step.device), + axis=chunk_dim, + clip_to_valid=True + ) + + logits = model.decode_logits( + input_embed=input_embed, + att=att_step, + s=label_lstm_out, + ) # [B, S+1, T, D] + + label_log_prob = rf.log_softmax(logits, axis=model.target_dim) + + # mask label log prob in order to only allow hypotheses corresponding to the ground truth: + # log prob needs to correspond to the next non-blank label... + log_prob_mask = vocab_range == label_ground_truth + rem_frames = enc_spatial_sizes - i + rem_labels = non_blank_targets_spatial_sizes - label_indices + # ... or to blank if there are more frames than labels left + log_prob_mask = rf.logical_or( + log_prob_mask, + rf.logical_and( + vocab_range == blank_tensor, + rem_frames > rem_labels + ) + ) + label_log_prob = rf.where( + log_prob_mask, + label_log_prob, + rf.constant(-1.0e30, dims=batch_dims + [beam_dim, model.target_dim]) + ) + + # interpolate with given alignment: a * one_hot + (1 - a) * label_log_prob + if interpolation_alignment_factor > 0.0: + interpolation_alignment_ground_truth = rf.gather( + interpolation_alignment, + indices=i, + axis=enc_spatial_dim_downsampled, + ) + label_log_prob = interpolation_alignment_factor * rf.log(rf.sparse_to_dense( + interpolation_alignment_ground_truth, label_value=0.9, other_value=0.1 / model.target_dim.dimension + )) + (1 - interpolation_alignment_factor) * label_log_prob + + label_log_prob = rf.where( + rf.convert_to_tensor(i >= enc_spatial_sizes), + rf.sparse_to_dense( + model.blank_idx, + axis=model.target_dim, + label_value=0.0, + other_value=-1.0e30 + ), + label_log_prob + ) + + if use_recombination is not None: + seq_log_prob = recombination.recombine_seqs_train( + seq_log_prob=seq_log_prob, + label_log_prob=label_log_prob, + label_indices=label_indices, + ground_truth=label_ground_truth, + target_dim=model.target_dim, + single_col_dim=single_col_dim, + beam_dim=beam_dim, + batch_dims=batch_dims, + blank_idx=model.blank_idx, + use_sum_recombination=use_recombination == "sum" + ) + beam_size_ = min( + min((i + 2), rf.reduce_max(rem_frames, axis=rem_frames.dims).raw_tensor.item()), + min((max_num_labels + 1), beam_size) + ) + seq_log_prob, (backrefs, target), beam_dim = rf.top_k( + seq_log_prob, + k_dim=Dim(beam_size_, name=f"dec-step{i}-beam"), + axis=[beam_dim, single_col_dim] + ) + + prev_label_indices = rf.gather(label_indices, indices=backrefs) + # mask blank label + update_state_mask = rf.convert_to_tensor(target != prev_label_indices) + else: + beam_size_ = beam_size + + seq_log_prob = seq_log_prob + label_log_prob # Batch, InBeam, Vocab + seq_log_prob, (backrefs, target), beam_dim = rf.top_k( + seq_log_prob, + k_dim=Dim(beam_size_, name=f"dec-step{i}-beam"), + axis=[beam_dim, model.target_dim] + ) + + prev_label_indices = rf.gather(label_indices, indices=backrefs) + # mask blank label + update_state_mask = rf.convert_to_tensor(target != model.blank_idx) + + seq_targets.append(target) + seq_backrefs.append(backrefs) + + i += 1 + + if return_realignment: + # Backtrack via backrefs, resolve beams. + seq_targets_ = [] + indices = rf.range_over_dim(beam_dim) # FinalBeam -> FinalBeam + for backrefs, target in zip(seq_backrefs[::-1], seq_targets[::-1]): + # indices: FinalBeam -> Beam + # backrefs: Beam -> PrevBeam + seq_targets_.insert(0, rf.gather(target, indices=indices)) + indices = rf.gather(backrefs, indices=indices) # FinalBeam -> PrevBeam + + seq_targets__ = TensorArray(seq_targets_[0]) + for target in seq_targets_: + seq_targets__ = seq_targets__.push_back(target) + seq_targets = seq_targets__.stack(axis=enc_spatial_dim_downsampled) + + if use_recombination is not None: + seq_targets_padded = rf.shift_right(seq_targets, axis=enc_spatial_dim_downsampled, pad_value=0) + seq_targets = rf.where( + seq_targets == seq_targets_padded, + model.blank_idx, + rf.gather( + non_blank_targets, indices=rf.cast(seq_targets - 1, "int32"), axis=non_blank_targets_spatial_dim, clip_to_valid=True) + ) + realignment = rf.squeeze(seq_targets, beam_dim) + else: + realignment = seq_targets + + realignment_spatial_dim = enc_spatial_dim_downsampled + else: + realignment = None + realignment_spatial_dim = None + + if use_recombination is not None: + seq_log_prob = rf.squeeze(seq_log_prob, beam_dim) + + return seq_log_prob, realignment, realignment_spatial_dim + + +def _returnn_v2_forward_step(*, model, extern_data: TensorDict, **_kwargs_unused): + import returnn.frontend as rf + from returnn.tensor import Tensor, Dim, batch_dim + from returnn.config import get_global_config + + if rf.is_executing_eagerly(): + batch_size = int(batch_dim.get_dim_value()) + for batch_idx in range(batch_size): + seq_tag = extern_data["seq_tag"].raw_tensor[batch_idx].item() + print(f"batch {batch_idx + 1}/{batch_size} seq_tag: {seq_tag!r}") + + config = get_global_config() + default_input_key = config.typed_value("default_input") + data = extern_data[default_input_key] + data_spatial_dim = data.get_time_dim_tag() + realign_def = config.typed_value("_realign_def") + + default_target_key = config.typed_value("target") + targets = extern_data[default_target_key] + targets_spatial_dim = targets.get_time_dim_tag() + + realign_out = realign_def( + model=model, + data=data, + data_spatial_dim=data_spatial_dim, + non_blank_targets=targets, + non_blank_targets_spatial_dim=targets_spatial_dim, + ) + + if len(realign_out) == 3: + # realign results including viterbi_align, + # log probs {batch,}, + # out_spatial_dim, + viterbi_align, scores, out_spatial_dim = realign_out + else: + raise ValueError(f"unexpected num outputs {len(realign_out)} from recog_def") + assert isinstance(viterbi_align, Tensor) and isinstance(scores, Tensor) + assert isinstance(out_spatial_dim, Dim) + rf.get_run_ctx().mark_as_output(viterbi_align, "viterbi_align", dims=[batch_dim, out_spatial_dim]) + rf.get_run_ctx().mark_as_output(scores, "scores", dims=[batch_dim,]) + + +_v2_forward_out_scores_filename = "scores.py.gz" +_v2_forward_out_alignment_filename = "realignment.hdf" + + +def _returnn_v2_get_forward_callback(): + from typing import TextIO + import numpy as np + from returnn.tensor import Tensor, TensorDict + from returnn.forward_iface import ForwardCallbackIface + from returnn.config import get_global_config + from returnn.datasets.hdf import SimpleHDFWriter + + class _ReturnnRecogV2ForwardCallbackIface(ForwardCallbackIface): + def __init__(self): + self.score_file: Optional[TextIO] = None + self.alignment_file: Optional[SimpleHDFWriter] = None + + def init(self, *, model): + import gzip + + self.score_file = gzip.open(_v2_forward_out_scores_filename, "wt") + self.score_file.write("{\n") + + self.alignment_file = SimpleHDFWriter( + filename=_v2_forward_out_alignment_filename, dim=model.target_dim.dimension, ndim=1 + ) + + def process_seq(self, *, seq_tag: str, outputs: TensorDict): + viterbi_align: Tensor = outputs["viterbi_align"] # [T] + scores: Tensor = outputs["scores"] # [] + assert len(viterbi_align.dims) == 1, f"expected hyps to be 1D, but got {viterbi_align.dims}" + assert viterbi_align.dims[0].dyn_size_ext, f"viterbi_align {viterbi_align} does not define seq lengths" + self.score_file.write(f"{seq_tag!r}: ") + score = float(scores.raw_tensor) + self.score_file.write(f"{score!r},\n") + + seq_len = viterbi_align.dims[0].dyn_size_ext.raw_tensor.item() + viterbi_align_raw = viterbi_align.raw_tensor[:seq_len] + + hdf.dump_hdf_numpy( + hdf_dataset=self.alignment_file, + data=viterbi_align_raw[None], # [1, T] + seq_lens=np.array([seq_len]), # [1] + seq_tags=[seq_tag], + ) + + def finish(self): + self.score_file.write("}\n") + self.score_file.close() + self.alignment_file.close() + + return _ReturnnRecogV2ForwardCallbackIface() diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/recog.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/recog.py index 53e39d302..e070839d9 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/recog.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/recog.py @@ -1,7 +1,8 @@ -from typing import Optional, Dict, Any, Tuple +from typing import Optional, Dict, Any, Tuple, Sequence import tree from returnn.tensor import Tensor, Dim, single_step_dim +from returnn.frontend.state import State import returnn.frontend as rf from returnn.frontend.tensor_array import TensorArray @@ -14,15 +15,223 @@ from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model_new.blank_model.model import ( BlankDecoderV1, BlankDecoderV3, + BlankDecoderV5, + BlankDecoderV6, ) +def update_state( + model: SegmentalAttentionModel, + update_state_mask: Tensor, + backrefs: Tensor, + label_decoder_state: State, + label_decoder_state_updated: State, + blank_decoder_state: Optional[State], + blank_decoder_state_updated: Optional[State], + lm_state: Optional[State], + lm_state_updated: Optional[State], +) -> Tuple[State, Optional[State], Optional[State]]: + + # ------------------- update blank decoder state ------------------- + + if blank_decoder_state is not None: + blank_decoder_state = tree.map_structure( + lambda s: rf.gather(s, indices=backrefs), blank_decoder_state_updated) + + # ------------------- update label decoder state ------------------- + + if model.label_decoder_state == "joint-lstm": + label_decoder_state = tree.map_structure( + lambda s: rf.gather(s, indices=backrefs), label_decoder_state_updated) + else: + def _get_masked_state(old, new, mask): + old = rf.gather(old, indices=backrefs) + new = rf.gather(new, indices=backrefs) + return rf.where(mask, new, old) + + label_decoder_state = tree.map_structure( + lambda old_state, new_state: _get_masked_state(old_state, new_state, update_state_mask), + label_decoder_state, label_decoder_state_updated + ) + + # ------------------- update external LM state ------------------- + + if lm_state is not None: + for state in lm_state: + if state == "pos": + lm_state[state] = rf.where( + update_state_mask, + rf.gather(lm_state_updated[state], indices=backrefs), + rf.gather(lm_state[state], indices=backrefs) + ) + else: + updated_accum_axis = lm_state_updated[state].self_att.accum_axis + + updated_self_att_expand_dim_dyn_size_ext = rf.gather(updated_accum_axis.dyn_size_ext, indices=backrefs) + masked_self_att_expand_dim_dyn_size_ext = rf.where( + update_state_mask, + updated_self_att_expand_dim_dyn_size_ext, + updated_self_att_expand_dim_dyn_size_ext - 1 + ) + masked_self_att_expand_dim = Dim(masked_self_att_expand_dim_dyn_size_ext, name="self_att_expand_dim_init") + lm_state[state].self_att.accum_axis = masked_self_att_expand_dim + + def _mask_lm_state(tensor: rf.Tensor): + tensor = rf.gather(tensor, indices=backrefs) + tensor = tensor.copy_transpose( + [updated_accum_axis] + tensor.remaining_dims(updated_accum_axis)) + tensor_raw = tensor.raw_tensor + tensor_raw = tensor_raw[:rf.reduce_max( + masked_self_att_expand_dim_dyn_size_ext, + axis=masked_self_att_expand_dim_dyn_size_ext.dims + ).raw_tensor.item()] + tensor = tensor.copy_template_replace_dim_tag( + tensor.get_axis_from_description(updated_accum_axis), masked_self_att_expand_dim + ) + tensor.raw_tensor = tensor_raw + return tensor + + lm_state[state].self_att.k_accum = _mask_lm_state(lm_state_updated[state].self_att.k_accum) + lm_state[state].self_att.v_accum = _mask_lm_state(lm_state_updated[state].self_att.v_accum) + + return label_decoder_state, blank_decoder_state, lm_state + + +def get_score( + model: SegmentalAttentionModel, + i: int, + input_embed_label_model: Tensor, + input_embed_blank_model: Optional[Tensor], + nb_target: Tensor, + label_decoder_state: State, + blank_decoder_state: Optional[State], + lm_state: Optional[State], + enc_args: Dict[str, Tensor], + enc_spatial_dim: Dim, + beam_dim: Dim, + batch_dims: Sequence[Dim], + external_lm_scale: Optional[float] = None, +) -> Tuple[Tensor, State, Optional[State], Optional[State]]: + # ------------------- label step ------------------- + + center_position = rf.minimum( + rf.full(dims=[beam_dim] + batch_dims, fill_value=i, dtype="int32"), + rf.copy_to_device(enc_spatial_dim.get_size_tensor() - 1, input_embed_label_model.device) + ) + segment_starts = rf.maximum( + rf.convert_to_tensor(0, dtype="int32"), center_position - model.center_window_size // 2) + segment_ends = rf.minimum( + rf.copy_to_device(enc_spatial_dim.get_size_tensor() - 1, input_embed_label_model.device), + center_position + model.center_window_size // 2 + ) + segment_lens = segment_ends - segment_starts + 1 + + label_step_out, label_decoder_state = model.label_decoder.loop_step( + **enc_args, + enc_spatial_dim=enc_spatial_dim, + input_embed=input_embed_label_model, + segment_lens=segment_lens, + segment_starts=segment_starts, + state=label_decoder_state, + ) + label_logits = model.label_decoder.decode_logits(input_embed=input_embed_label_model, **label_step_out) + label_log_prob = rf.log_softmax(label_logits, axis=model.target_dim) + + # ------------------- external LM step ------------------- + + lm_eos_log_prob = rf.zeros(batch_dims, dtype="float32") + if lm_state is not None: + lm_logits, lm_state = model.language_model( + nb_target, + spatial_dim=single_step_dim, + state=lm_state, + ) + lm_label_log_prob = rf.log_softmax(lm_logits, axis=model.target_dim) + label_log_prob += external_lm_scale * lm_label_log_prob + + lm_eos_log_prob = rf.where( + rf.convert_to_tensor(i == rf.copy_to_device(enc_spatial_dim.get_size_tensor(), input_embed_label_model.device) - 1), + # TODO: change to non hard-coded BOS index + rf.gather(lm_label_log_prob, indices=rf.constant(0, dtype="int32", dims=batch_dims, sparse_dim=nb_target.sparse_dim)), + lm_eos_log_prob + ) + + # ------------------- blank step ------------------- + + if blank_decoder_state is not None: + if model.blank_decoder_version in (1, 3): + blank_loop_step_kwargs = dict( + enc=enc_args["enc"], + enc_spatial_dim=enc_spatial_dim, + state=blank_decoder_state, + ) + if isinstance(model.blank_decoder, BlankDecoderV1): + blank_loop_step_kwargs["input_embed"] = input_embed_blank_model + else: + blank_loop_step_kwargs["label_model_state"] = label_step_out["s"] + + blank_step_out, blank_decoder_state = model.blank_decoder.loop_step(**blank_loop_step_kwargs) + blank_logits = model.blank_decoder.decode_logits(**blank_step_out) + else: + assert isinstance(model.blank_decoder, BlankDecoderV5) or isinstance(model.blank_decoder, BlankDecoderV6) + enc_position = rf.minimum( + rf.full(dims=batch_dims, fill_value=i, dtype="int32"), + rf.copy_to_device(enc_spatial_dim.get_size_tensor() - 1, input_embed_label_model.device) + ) + enc_frame = rf.gather(enc_args["enc"], indices=enc_position, axis=enc_spatial_dim) + enc_frame = rf.expand_dim(enc_frame, beam_dim) + if isinstance(model.blank_decoder, BlankDecoderV5): + # no LSTM -> no state -> just leave (empty) state as is + blank_logits = model.blank_decoder.emit_prob( + rf.concat_features(enc_frame, label_step_out["s"])) + else: + prev_lstm_state = blank_decoder_state.s_blank + blank_decoder_state = rf.State() + s_blank, blank_decoder_state.s_blank = model.blank_decoder.s( + enc_frame, + state=prev_lstm_state, + spatial_dim=single_step_dim + ) + blank_logits = model.blank_decoder.emit_prob(rf.concat_features(s_blank, label_step_out["s"])) + + emit_log_prob = rf.log(rf.sigmoid(blank_logits)) + emit_log_prob = rf.squeeze(emit_log_prob, axis=emit_log_prob.feature_dim) + blank_log_prob = rf.log(rf.sigmoid(-blank_logits)) + blank_log_prob += lm_eos_log_prob + + # ------------------- combination ------------------- + + label_log_prob += emit_log_prob + output_log_prob, _ = rf.concat( + (label_log_prob, model.target_dim), (blank_log_prob, blank_log_prob.feature_dim), + out_dim=model.align_target_dim + ) + else: + output_log_prob = label_log_prob + + # for shorter seqs in the batch, set the blank score to zero and the others to ~-inf + output_log_prob = rf.where( + rf.convert_to_tensor(i >= rf.copy_to_device(enc_spatial_dim.get_size_tensor(), input_embed_label_model.device)), + rf.sparse_to_dense( + model.blank_idx, + axis=model.target_dim if model.use_joint_model else model.align_target_dim, + label_value=0.0, + other_value=-1.0e30 + ), + output_log_prob + ) + + return output_log_prob, label_decoder_state, blank_decoder_state, lm_state + + def model_recog( *, model: SegmentalAttentionModel, data: Tensor, data_spatial_dim: Dim, + beam_size: int, use_recombination: Optional[str] = None, + external_lm_scale: Optional[float] = None, ) -> Tuple[Tensor, Tensor, Dim, Dim]: """ Function is run within RETURNN. @@ -37,32 +246,60 @@ def model_recog( out_spatial_dim, final beam_dim """ - # assert not model.language_model # not implemented here. use the pure PyTorch search instead assert any( - isinstance(model.blank_decoder, cls) for cls in (BlankDecoderV1, BlankDecoderV3) + isinstance(model.blank_decoder, cls) for cls in (BlankDecoderV1, BlankDecoderV3, BlankDecoderV5, BlankDecoderV6) ) or model.blank_decoder is None, "blank_decoder not supported" if model.blank_decoder is None: assert model.use_joint_model, "blank_decoder is None, so use_joint_model must be True" + if model.language_model: + assert external_lm_scale is not None, "external_lm_scale must be defined with LM" + assert model.label_decoder_state in {"nb-lstm", "joint-lstm", "nb-linear1"} + + # --------------------------------- init encoder, dims, etc --------------------------------- - batch_dims = data.remaining_dims((data_spatial_dim, data.feature_dim)) enc_args, enc_spatial_dim = model.encoder.encode(data, in_spatial_dim=data_spatial_dim) - beam_size = 12 + max_seq_len = enc_spatial_dim.get_size_tensor() - print("** max seq len:", max_seq_len.raw_tensor) max_seq_len = rf.reduce_max(max_seq_len, axis=max_seq_len.dims) - # Initial state. + batch_dims = data.remaining_dims((data_spatial_dim, data.feature_dim)) beam_dim = Dim(1, name="initial-beam") batch_dims_ = [beam_dim] + batch_dims + backrefs = rf.zeros(batch_dims_, dtype="int32") + + bos_idx = 0 + + seq_log_prob = rf.constant(0.0, dims=batch_dims_) + + if use_recombination: + assert len(batch_dims) == 1 + assert use_recombination in {"sum", "max"} + seq_hash = rf.constant(0, dims=batch_dims_, dtype="int64") + else: + seq_hash = None + + # lists of [B, beam] tensors + seq_targets = [] + seq_backrefs = [] + + update_state_mask = rf.constant(True, dims=batch_dims_) + # --------------------------------- init states --------------------------------- + + # label decoder label_decoder_state = model.label_decoder.default_initial_state(batch_dims=batch_dims_, ) + + # blank decoder if model.blank_decoder is not None: blank_decoder_state = model.blank_decoder.default_initial_state(batch_dims=batch_dims_) + else: + blank_decoder_state = None + + # external LM if model.language_model: lm_state = model.language_model.default_initial_state(batch_dims=batch_dims_) for state in lm_state: if state == "pos": - # pass lm_state[state] = rf.zeros(batch_dims_, dtype="int32") else: self_att_expand_dim = Dim(rf.zeros(batch_dims_, dtype="int32"), name="self_att_expand_dim_init") @@ -81,24 +318,19 @@ def model_recog( v_accum.get_axis_from_description("stag:self_att_expand_dim_init"), self_att_expand_dim ) lm_state[state].self_att.v_accum.raw_tensor = v_accum_raw + else: + lm_state = None - bos_idx = 0 + # --------------------------------- init targets, embeddings --------------------------------- if model.use_joint_model: target = rf.constant(bos_idx, dims=batch_dims_, sparse_dim=model.target_dim) - if model.label_decoder_state == "nb-lstm": + if model.label_decoder_state in ("nb-lstm", "nb-linear1"): target_non_blank = target.copy() else: target = rf.constant(bos_idx, dims=batch_dims_, sparse_dim=model.align_target_dim) - update_state_mask = rf.convert_to_tensor(target != model.blank_idx) target_non_blank = rf.constant(bos_idx, dims=batch_dims_, sparse_dim=model.target_dim) - seq_log_prob = rf.constant(0.0, dims=batch_dims_) - if use_recombination: - assert len(batch_dims) == 1 - assert use_recombination in {"sum", "max"} - seq_hash = rf.constant(0, dims=batch_dims_, dtype="int64") - input_embed = rf.zeros( batch_dims_ + [model.label_decoder.target_embed.out_dim], feature_dim=model.label_decoder.target_embed.out_dim, @@ -111,12 +343,9 @@ def model_recog( else: input_embed_length_model = None - old_beam_dim = beam_dim.copy() - backrefs = rf.zeros(batch_dims_, dtype="int32") + # --------------------------------- main loop --------------------------------- i = 0 - seq_targets = [] - seq_backrefs = [] while i < max_seq_len.raw_tensor: if i > 0: if model.label_decoder_state == "joint-lstm": @@ -127,94 +356,28 @@ def model_recog( input_embed = rf.where( update_state_mask, model.label_decoder.target_embed(target_non_blank), - rf.gather(input_embed, indices=backrefs, axis=old_beam_dim) + rf.gather(input_embed, indices=backrefs) ) if isinstance(model.blank_decoder, BlankDecoderV1): input_embed_length_model = model.blank_decoder.target_embed(target) - # ------------------- label step ------------------- - - center_position = rf.minimum( - rf.full(dims=[beam_dim] + batch_dims, fill_value=i, dtype="int32"), - rf.copy_to_device(enc_spatial_dim.get_size_tensor() - 1, data.device) - ) - segment_starts = rf.maximum( - rf.convert_to_tensor(0, dtype="int32"), center_position - model.center_window_size // 2) - segment_ends = rf.minimum( - rf.copy_to_device(enc_spatial_dim.get_size_tensor() - 1, data.device), - center_position + model.center_window_size // 2 - ) - segment_lens = segment_ends - segment_starts + 1 - - label_step_out, label_decoder_state_updated = model.label_decoder.loop_step( - **enc_args, + output_log_prob, label_decoder_state_updated, blank_decoder_state_updated, lm_state_updated = get_score( + model=model, + i=i, + input_embed_label_model=input_embed, + input_embed_blank_model=input_embed_length_model, + nb_target=target_non_blank, + label_decoder_state=label_decoder_state, + blank_decoder_state=blank_decoder_state, + lm_state=lm_state, + enc_args=enc_args, enc_spatial_dim=enc_spatial_dim, - input_embed=input_embed, - segment_lens=segment_lens, - segment_starts=segment_starts, - state=label_decoder_state, - ) - label_logits = model.label_decoder.decode_logits(input_embed=input_embed, **label_step_out) - label_log_prob = rf.log_softmax(label_logits, axis=model.target_dim) - - # ------------------- external LM step ------------------- - - if model.language_model: - lm_logits, lm_state_updated = model.language_model( - target_non_blank, - spatial_dim=single_step_dim, - state=lm_state, - ) - lm_label_log_prob = rf.log_softmax(lm_logits, axis=model.target_dim) - # print(i) - # print("lm_label_log_prob: ", lm_label_log_prob.copy_transpose(batch_dims + [beam_dim, model.target_dim]).raw_tensor[0, :, :6]) - # print() - # if i == 10: - # exit() - label_log_prob += 0.4 * lm_label_log_prob - - # ------------------- blank step ------------------- - - if not model.use_joint_model: - blank_loop_step_kwargs = dict( - enc=enc_args["enc"], - enc_spatial_dim=enc_spatial_dim, - state=blank_decoder_state, - ) - if isinstance(model.blank_decoder, BlankDecoderV1): - blank_loop_step_kwargs["input_embed"] = input_embed_length_model - else: - blank_loop_step_kwargs["label_model_state"] = label_step_out["s"] - - blank_step_out, blank_decoder_state = model.blank_decoder.loop_step(**blank_loop_step_kwargs) - blank_logits = model.blank_decoder.decode_logits(**blank_step_out) - emit_log_prob = rf.log(rf.sigmoid(blank_logits)) - emit_log_prob = rf.squeeze(emit_log_prob, axis=emit_log_prob.feature_dim) - blank_log_prob = rf.log(rf.sigmoid(-blank_logits)) - - # ------------------- combination ------------------- - - label_log_prob += emit_log_prob - output_log_prob, _ = rf.concat( - (label_log_prob, model.target_dim), (blank_log_prob, blank_log_prob.feature_dim), - out_dim=model.align_target_dim - ) - else: - output_log_prob = label_log_prob - - # for shorter seqs in the batch, set the blank score to zero and the others to ~-inf - output_log_prob = rf.where( - rf.convert_to_tensor(i >= rf.copy_to_device(enc_spatial_dim.get_size_tensor(), data.device)), - rf.sparse_to_dense( - model.blank_idx, - axis=model.target_dim if model.use_joint_model else model.align_target_dim, - label_value=0.0, - other_value=-1.0e30 - ), - output_log_prob + beam_dim=beam_dim, + batch_dims=batch_dims, + external_lm_scale=external_lm_scale, ) - # ------------------- top-k ------------------- + # ------------------- recombination ------------------- if use_recombination: seq_log_prob = recombination.recombine_seqs( @@ -226,108 +389,36 @@ def model_recog( use_sum=use_recombination == "sum" ) + # ------------------- top-k ------------------- + seq_log_prob = seq_log_prob + output_log_prob # Batch, InBeam, Vocab - old_beam_dim = beam_dim.copy() seq_log_prob, (backrefs, target), beam_dim = rf.top_k( seq_log_prob, k_dim=Dim(beam_size, name=f"dec-step{i}-beam"), axis=[beam_dim, model.target_dim if model.use_joint_model else model.align_target_dim] - ) # seq_log_prob, backrefs, target: Batch, Beam - # print("seq_log_prob: ", seq_log_prob.raw_tensor) + ) seq_targets.append(target) seq_backrefs.append(backrefs) + # ------------------- update hash for recombination ------------------- + if use_recombination: seq_hash = recombination.update_seq_hash(seq_hash, target, backrefs, model.blank_idx) # mask for updating label-sync states update_state_mask = rf.convert_to_tensor(target != model.blank_idx) - # ------------------- update blank decoder state ------------------- - - if not model.use_joint_model: - blank_decoder_state = tree.map_structure(lambda s: rf.gather(s, indices=backrefs), blank_decoder_state) - - # ------------------- update label decoder state ------------------- - - if model.label_decoder_state == "joint-lstm": - label_decoder_state = tree.map_structure(lambda s: rf.gather(s, indices=backrefs), label_decoder_state_updated) - else: - def _get_masked_state(old, new, mask): - old = rf.gather(old, indices=backrefs, axis=old_beam_dim) - new = rf.gather(new, indices=backrefs, axis=old_beam_dim) - return rf.where(mask, new, old) - - label_decoder_state = tree.map_structure( - lambda old_state, new_state: _get_masked_state(old_state, new_state, update_state_mask), - label_decoder_state, label_decoder_state_updated - ) - - # ------------------- update external LM state ------------------- - - if model.language_model: - for state in lm_state: - if state == "pos": - lm_state[state] = rf.where( - update_state_mask, - rf.gather(lm_state_updated[state], indices=backrefs), - rf.gather(lm_state[state], indices=backrefs) - ) - else: - updated_accum_axis = lm_state_updated[state].self_att.accum_axis - - updated_self_att_expand_dim_dyn_size_ext = rf.gather(updated_accum_axis.dyn_size_ext, indices=backrefs) - masked_self_att_expand_dim_dyn_size_ext = rf.where( - update_state_mask, - updated_self_att_expand_dim_dyn_size_ext, - updated_self_att_expand_dim_dyn_size_ext - 1 - ) - masked_self_att_expand_dim = Dim(masked_self_att_expand_dim_dyn_size_ext, name="self_att_expand_dim_init") - lm_state[state].self_att.accum_axis = masked_self_att_expand_dim - - def _mask_lm_state(tensor: rf.Tensor): - tensor = rf.gather(tensor, indices=backrefs) - tensor = tensor.copy_transpose( - [updated_accum_axis] + tensor.remaining_dims(updated_accum_axis)) - tensor_raw = tensor.raw_tensor - tensor_raw = tensor_raw[:rf.reduce_max( - masked_self_att_expand_dim_dyn_size_ext, - axis=masked_self_att_expand_dim_dyn_size_ext.dims - ).raw_tensor.item()] - tensor = tensor.copy_template_replace_dim_tag( - tensor.get_axis_from_description(updated_accum_axis), masked_self_att_expand_dim - ) - tensor.raw_tensor = tensor_raw - return tensor - - lm_state[state].self_att.k_accum = _mask_lm_state(lm_state_updated[state].self_att.k_accum) - lm_state[state].self_att.v_accum = _mask_lm_state(lm_state_updated[state].self_att.v_accum) - - # lm_state[state].self_att.k_accum = rf.gather(lm_state_updated[state].self_att.k_accum, indices=backrefs) - # lm_state[state].self_att.k_accum = lm_state[state].self_att.k_accum.copy_transpose( - # [updated_accum_axis] + lm_state[state].self_att.k_accum.remaining_dims(updated_accum_axis)) - # k_accum_raw = lm_state[state].self_att.k_accum.raw_tensor - # k_accum_raw = k_accum_raw[:rf.reduce_max( - # masked_self_att_expand_dim_dyn_size_ext, - # axis=masked_self_att_expand_dim_dyn_size_ext.dims - # ).raw_tensor.item()] - # lm_state[state].self_att.k_accum = lm_state[state].self_att.k_accum.copy_template_replace_dim_tag( - # lm_state[state].self_att.k_accum.get_axis_from_description(updated_accum_axis), masked_self_att_expand_dim - # ) - # lm_state[state].self_att.k_accum.raw_tensor = k_accum_raw - # - # lm_state[state].self_att.v_accum = rf.gather(lm_state_updated[state].self_att.v_accum, indices=backrefs) - # lm_state[state].self_att.v_accum = lm_state[state].self_att.v_accum.copy_transpose( - # [updated_accum_axis] + lm_state[state].self_att.v_accum.remaining_dims(updated_accum_axis)) - # v_accum_raw = lm_state[state].self_att.v_accum.raw_tensor - # v_accum_raw = v_accum_raw[:rf.reduce_max( - # masked_self_att_expand_dim_dyn_size_ext, - # axis=masked_self_att_expand_dim_dyn_size_ext.dims - # ).raw_tensor.item()] - # lm_state[state].self_att.v_accum = lm_state[state].self_att.v_accum.copy_template_replace_dim_tag( - # lm_state[state].self_att.v_accum.get_axis_from_description(updated_accum_axis), masked_self_att_expand_dim - # ) - # lm_state[state].self_att.v_accum.raw_tensor = v_accum_raw + label_decoder_state, blank_decoder_state, lm_state = update_state( + model=model, + update_state_mask=update_state_mask, + backrefs=backrefs, + label_decoder_state=label_decoder_state, + label_decoder_state_updated=label_decoder_state_updated, + blank_decoder_state=blank_decoder_state, + blank_decoder_state_updated=blank_decoder_state_updated, + lm_state=lm_state, + lm_state_updated=lm_state_updated, + ) i += 1 @@ -342,9 +433,6 @@ def _mask_lm_state(tensor: rf.Tensor): use_sum=use_recombination == "sum" ) - # print("seq_log_prob: ", seq_log_prob.raw_tensor) - # exit() - # Backtrack via backrefs, resolve beams. seq_targets_ = [] indices = rf.range_over_dim(beam_dim) # FinalBeam -> FinalBeam diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/recombination.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/recombination.py index b8017325c..20225e6a5 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/recombination.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/recombination.py @@ -68,12 +68,12 @@ def recombine_seqs_train( label_log_prob: Tensor, label_indices: Tensor, ground_truth: Tensor, - labels_padded_spatial_sizes: Tensor, target_dim: Dim, single_col_dim: Dim, beam_dim: Dim, batch_dims: Sequence[Dim], blank_idx: int, + use_sum_recombination: bool = True, ) -> Tensor: # local horizontal scores for each hyp: [B, beam] horizontal_scores = rf.gather( @@ -176,22 +176,30 @@ def recombine_seqs_train( rf.constant(-1.0e30, dims=batch_dims) ) + # for each hyp, merge horizontal and diagonal scores into one column + # i.e. [-inf, ..., d, ..., -inf] + [-inf, ..., h, ..., -inf] -> [-inf, ..., d, h, ..., -inf] best_scores = rf.maximum(horizontal_scores, diagonal_scores) - sum_scores = rf.exp(horizontal_scores - best_scores) + rf.exp(diagonal_scores - best_scores) - sum_scores = best_scores + rf.safe_log(sum_scores) + merged_scores = rf.exp(horizontal_scores - best_scores) + rf.exp(diagonal_scores - best_scores) + merged_scores = best_scores + rf.safe_log(merged_scores) - best_scores = rf.reduce_max(sum_scores, axis=beam_dim) - is_max = sum_scores == best_scores - sum_scores = best_scores + rf.log(rf.reduce_sum(rf.exp(sum_scores - best_scores), axis=beam_dim)) + # recombine the scores of different hypotheses + best_scores = rf.reduce_max(merged_scores, axis=beam_dim) + is_max = merged_scores == best_scores - sum_scores = rf.expand_dim(sum_scores, beam_dim) - sum_scores = rf.where( + if use_sum_recombination: + recombined_score = best_scores + rf.log(rf.reduce_sum(rf.exp(merged_scores - best_scores), axis=beam_dim)) + else: + recombined_score = best_scores + + # add back the beam dimension and set the score of the worse hypotheses to -1.0e30 + recombined_score = rf.expand_dim(recombined_score, beam_dim) + recombined_score = rf.where( is_max, - sum_scores, + recombined_score, rf.constant(-1.0e30, dims=batch_dims) ) - return sum_scores + return recombined_score def update_seq_hash(seq_hash: Tensor, target: Tensor, backrefs: Tensor, blank_idx: int) -> Tensor: diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/train.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/train.py index bb5c56b40..1de1c0047 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/train.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/train.py @@ -1,10 +1,14 @@ +from typing import Optional, Dict, List import torch +import os from i6_experiments.users.schmitt.returnn_frontend.model_interfaces.training import FramewiseTrainDef, FullSumTrainDef from returnn.tensor import TensorDict +from returnn.datasets.hdf import SimpleHDFWriter from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental import utils +from i6_experiments.users.schmitt import hdf from i6_experiments.users.schmitt.augmentation.alignment import shift_alignment_boundaries_batched from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model import SegmentalAttentionModel from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model_new.label_model.train import ( @@ -16,14 +20,8 @@ from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model_new.label_model.train import ( full_sum_training as label_model_full_sum_training ) -from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model_new.label_model.train import ( - full_sum_training_w_beam as label_model_full_sum_training_w_beam -) -from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model_new.label_model.train import ( - full_sum_training_w_beam_eff as label_model_full_sum_training_w_beam_eff -) -from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model_new.label_model.train import ( - full_sum_training_w_beam_eff_w_recomb as label_model_full_sum_training_w_beam_eff_w_recomb +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.realignment import ( + model_realign ) from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model_new.blank_model.train import ( viterbi_training as blank_model_viterbi_training @@ -87,6 +85,13 @@ def _returnn_v2_full_sum_train_step(*, model, extern_data: TensorDict, **_kwargs data_spatial_dim = data.get_time_dim_tag() targets = extern_data[default_target_key] targets_spatial_dim = targets.get_time_dim_tag() + interpolation_alignment = extern_data.data.get("interpolation_alignment") + if interpolation_alignment is not None: + interpolation_alignment_spatial_dim = interpolation_alignment.get_time_dim_tag() + else: + interpolation_alignment_spatial_dim = None + interpolation_alignment_scores = extern_data.data.get("interpolation_alignment_scores") + train_def: FullSumTrainDef = config.typed_value("_train_def") train_def( model=model, @@ -94,6 +99,10 @@ def _returnn_v2_full_sum_train_step(*, model, extern_data: TensorDict, **_kwargs data_spatial_dim=data_spatial_dim, non_blank_targets=targets, non_blank_targets_spatial_dim=targets_spatial_dim, + seq_tags=extern_data["seq_tag"], + interpolation_alignment=interpolation_alignment, + interpolation_alignment_spatial_dim=interpolation_alignment_spatial_dim, + interpolation_alignment_scores=interpolation_alignment_scores, ) @@ -103,9 +112,15 @@ def viterbi_training( data: rf.Tensor, data_spatial_dim: Dim, align_targets: rf.Tensor, - align_targets_spatial_dim: Dim + align_targets_spatial_dim: Dim, + enc_args: Optional[Dict[str, rf.Tensor]] = None, + enc_spatial_dim: Optional[Dim] = None, + batch_dims: Optional[List[Dim]] = None, + beam_dim: Optional[Dim] = None, ): - """Function is run within RETURNN.""" + if enc_args is not None: + assert enc_spatial_dim is not None + from returnn.config import get_global_config config = get_global_config() # noqa @@ -119,7 +134,8 @@ def viterbi_training( data = rf.squeeze(data, axis=data.feature_dim) assert not data.feature_dim # raw audio - batch_dims = data.remaining_dims(data_spatial_dim) + if batch_dims is None: + batch_dims = data.remaining_dims(data_spatial_dim) alignment_augmentation_opts = config.typed_value("alignment_augmentation_opts", None) if alignment_augmentation_opts is not None: @@ -165,53 +181,54 @@ def viterbi_training( non_blank_targets_spatial_dim ) - # ------------------- encoder aux loss ------------------- - - collected_outputs = {} - enc_args, enc_spatial_dim = model.encoder.encode( - data, in_spatial_dim=data_spatial_dim, collected_outputs=collected_outputs) - - if aux_loss_layers: - if use_ctc_loss: - for i, layer_idx in enumerate(aux_loss_layers): - if layer_idx > len(model.encoder.layers): - continue + if enc_args is None: + # ------------------- encoder aux loss ------------------- + + collected_outputs = {} + enc_args, enc_spatial_dim = model.encoder.encode( + data, in_spatial_dim=data_spatial_dim, collected_outputs=collected_outputs) + + if aux_loss_layers: + if use_ctc_loss: + for i, layer_idx in enumerate(aux_loss_layers): + if layer_idx > len(model.encoder.layers): + continue + linear = getattr(model.encoder, f"enc_aux_logits_{layer_idx}") + aux_logits = linear(collected_outputs[str(layer_idx - 1)]) + aux_loss = rf.ctc_loss( + logits=aux_logits, + targets=non_blank_targets, + input_spatial_dim=enc_spatial_dim, + targets_spatial_dim=non_blank_targets_spatial_dim, + blank_index=model.blank_idx, + ) + aux_loss.mark_as_loss( + f"ctc_{layer_idx}", + scale=aux_loss_scales[i], + custom_inv_norm_factor=align_targets_spatial_dim.get_size_tensor(), + use_normalized_loss=True, + ) + elif generate_ctc_alignments_on_the_fly: + assert len(aux_loss_layers) == 1 + assert len(batch_dims) == 1 + assert model.blank_idx == model.target_dim.dimension + print("Generating CTC alignments on the fly") + layer_idx = aux_loss_layers[0] linear = getattr(model.encoder, f"enc_aux_logits_{layer_idx}") - aux_logits = linear(collected_outputs[str(layer_idx - 1)]) - aux_loss = rf.ctc_loss( - logits=aux_logits, - targets=non_blank_targets, - input_spatial_dim=enc_spatial_dim, - targets_spatial_dim=non_blank_targets_spatial_dim, - blank_index=model.blank_idx, - ) - aux_loss.mark_as_loss( - f"ctc_{layer_idx}", - scale=aux_loss_scales[i], - custom_inv_norm_factor=align_targets_spatial_dim.get_size_tensor(), - use_normalized_loss=True, + aux_logits = linear(collected_outputs[str(layer_idx - 1)]) # type: rf.Tensor + print("aux_logits", aux_logits) + + from torchaudio.functional import forced_align + rem_dims = aux_logits.remaining_dims(batch_dims + [enc_spatial_dim]) + ctc_align = forced_align( + log_probs=aux_logits.copy_transpose(batch_dims + [enc_spatial_dim] + rem_dims).raw_tensor, + targets=non_blank_targets.copy_transpose(batch_dims + [non_blank_targets_spatial_dim]).raw_tensor.contiguous(), + input_lengths=enc_spatial_dim.get_size_tensor().raw_tensor, + target_lengths=non_blank_targets_spatial_dim.get_size_tensor().raw_tensor, + blank=model.blank_idx, ) - elif generate_ctc_alignments_on_the_fly: - assert len(aux_loss_layers) == 1 - assert len(batch_dims) == 1 - assert model.blank_idx == model.target_dim.dimension - print("Generating CTC alignments on the fly") - layer_idx = aux_loss_layers[0] - linear = getattr(model.encoder, f"enc_aux_logits_{layer_idx}") - aux_logits = linear(collected_outputs[str(layer_idx - 1)]) # type: rf.Tensor - print("aux_logits", aux_logits) - - from torchaudio.functional import forced_align - rem_dims = aux_logits.remaining_dims(batch_dims + [enc_spatial_dim]) - ctc_align = forced_align( - log_probs=aux_logits.copy_transpose(batch_dims + [enc_spatial_dim] + rem_dims).raw_tensor, - targets=non_blank_targets.copy_transpose(batch_dims + [non_blank_targets_spatial_dim]).raw_tensor.contiguous(), - input_lengths=enc_spatial_dim.get_size_tensor().raw_tensor, - target_lengths=non_blank_targets_spatial_dim.get_size_tensor().raw_tensor, - blank=model.blank_idx, - ) - print("ctc_align", ctc_align.shape) - exit() + print("ctc_align", ctc_align.shape) + exit() if model.use_joint_model: @@ -256,6 +273,7 @@ def viterbi_training( ce_targets=align_targets, ce_spatial_dim=align_targets_spatial_dim, batch_dims=batch_dims, + beam_dim=beam_dim, ) else: @@ -375,11 +393,17 @@ def full_sum_training( data: rf.Tensor, data_spatial_dim: Dim, non_blank_targets: rf.Tensor, - non_blank_targets_spatial_dim: Dim + non_blank_targets_spatial_dim: Dim, + seq_tags: rf.Tensor, + interpolation_alignment: Optional[rf.Tensor] = None, + interpolation_alignment_spatial_dim: Optional[Dim] = None, + interpolation_alignment_scores: Optional[rf.Tensor] = None, ): assert model.use_joint_model assert isinstance(model.label_decoder, SegmentalAttEfficientLabelDecoder) assert model.label_decoder_state == "nb-lstm" + if interpolation_alignment is not None: + assert interpolation_alignment_scores is not None from returnn.config import get_global_config @@ -387,13 +411,14 @@ def full_sum_training( aux_loss_layers = config.typed_value("aux_loss_layers") aux_loss_scales = config.typed_value("aux_loss_scales", ([1.0] * len(aux_loss_layers)) if aux_loss_layers else None) - full_sum_training_beam_size = config.int("full_sum_training_beam_size", None) + full_sum_beam_size = config.int("full_sum_beam_size", None) if data.feature_dim and data.feature_dim.dimension == 1: data = rf.squeeze(data, axis=data.feature_dim) assert not data.feature_dim # raw audio batch_dims = data.remaining_dims(data_spatial_dim) + assert len(batch_dims) == 1 # ------------------- encoder aux loss ------------------- @@ -431,20 +456,151 @@ def full_sum_training( enc_spatial_dim ) - # ------------------- joint loop ------------------- + if full_sum_beam_size: + downsampling = config.int("full_sum_lattice_downsampling", 1) + precompute_chunk_size = config.int("full_sum_precompute_chunk_size", 10) + interpolation_alignment_factor = config.float("full_sum_alignment_interpolation_factor", 0.0) + partition_epoch = config.int("train_partition_epoch", 20) + train_on_viterbi_paths = config.bool("full_sum_train_on_viterbi_paths", False) + + # do not use interpolation alignment for eval datasets + if not rf.get_run_ctx().train_flag or interpolation_alignment_factor == 0.0: + interpolation_alignment_factor = 0.0 + # in the first full epoch (20 subepochs), use linear alignment for interpolation + elif 1 <= rf.get_run_ctx().epoch <= partition_epoch: + interpolation_alignment = utils.get_linear_alignment( + non_blank_targets=non_blank_targets, + non_blank_targets_spatial_dim=non_blank_targets_spatial_dim, + enc_spatial_dim=enc_spatial_dim, + batch_dims=batch_dims, + blank_idx=model.blank_idx, + ) + # log(uniform) * T + interpolation_alignment_scores = rf.copy_to_device( + enc_spatial_dim.get_size_tensor(), device=data.device) * rf.log( + rf.convert_to_tensor(1 / model.target_dim.dimension)) + # otherwise, use given interpolation alignment + else: + # set spatial dim to enc_spatial_dim + interpolation_alignment = utils.copy_tensor_replace_dim_tag( + interpolation_alignment, interpolation_alignment_spatial_dim, enc_spatial_dim) + interpolation_alignment_scores = rf.squeeze( + interpolation_alignment_scores, axis=interpolation_alignment_scores.feature_dim) + + if train_on_viterbi_paths: + with torch.no_grad(): + viterbi_alignment_scores, viterbi_alignment, viterbi_alignment_spatial_dim = model_realign( + model=model.label_decoder, + enc=enc_args["enc"], + enc_ctx=enc_args["enc_ctx"], + enc_spatial_dim=enc_spatial_dim, + non_blank_targets=non_blank_targets, + non_blank_targets_spatial_dim=non_blank_targets_spatial_dim, + segment_starts=segment_starts, + segment_lens=segment_lens, + batch_dims=batch_dims, + beam_size=100 if full_sum_beam_size == 1 else full_sum_beam_size, + downsampling=downsampling if rf.get_run_ctx().train_flag else 1, + precompute_chunk_size=precompute_chunk_size, + interpolation_alignment=interpolation_alignment, + interpolation_alignment_factor=interpolation_alignment_factor, + use_recombination="max" if full_sum_beam_size == 1 else None, + return_realignment=True, + ) - if full_sum_training_beam_size: - label_model_full_sum_training_w_beam_eff_w_recomb( - model=model.label_decoder, - enc_args=enc_args, - enc_spatial_dim=enc_spatial_dim, - non_blank_targets=non_blank_targets, - non_blank_targets_spatial_dim=non_blank_targets_spatial_dim, - segment_starts=segment_starts, - segment_lens=segment_lens, - batch_dims=batch_dims, - beam_size=full_sum_training_beam_size - ) + if full_sum_beam_size > 1: + beam_dim = viterbi_alignment.remaining_dims(batch_dims + [viterbi_alignment_spatial_dim]) + assert len(beam_dim) == 1 + beam_dim = beam_dim[0] + else: + beam_dim = None + + viterbi_training( + model=model, + data=data, + data_spatial_dim=data_spatial_dim, + align_targets=viterbi_alignment, + align_targets_spatial_dim=viterbi_alignment_spatial_dim, + enc_args=enc_args, + enc_spatial_dim=enc_spatial_dim, + batch_dims=(batch_dims + [beam_dim]) if beam_dim is not None else batch_dims, + beam_dim=beam_dim, + ) + else: + # full-sum loss with beam search + seq_log_prob, _, _ = model_realign( + model=model.label_decoder, + enc=enc_args["enc"], + enc_ctx=enc_args["enc_ctx"], + enc_spatial_dim=enc_spatial_dim, + non_blank_targets=non_blank_targets, + non_blank_targets_spatial_dim=non_blank_targets_spatial_dim, + segment_starts=segment_starts, + segment_lens=segment_lens, + batch_dims=batch_dims, + beam_size=full_sum_beam_size, + downsampling=downsampling if rf.get_run_ctx().train_flag else 1, + precompute_chunk_size=precompute_chunk_size, + interpolation_alignment=interpolation_alignment, + interpolation_alignment_factor=interpolation_alignment_factor, + use_recombination=None, + ) + loss = -1 * seq_log_prob + loss.mark_as_loss("full_sum_loss", scale=1.0, use_normalized_loss=True) + + # in training, do realignment and update previous interpolation alignment if realignment is better + if rf.get_run_ctx().train_flag and interpolation_alignment_factor > 0.0: + with torch.no_grad(): + viterbi_alignment_scores, viterbi_alignment, viterbi_alignment_spatial_dim = model_realign( + model=model.label_decoder, + enc=enc_args["enc"], + enc_ctx=enc_args["enc_ctx"], + enc_spatial_dim=enc_spatial_dim, + non_blank_targets=non_blank_targets, + non_blank_targets_spatial_dim=non_blank_targets_spatial_dim, + segment_starts=segment_starts, + segment_lens=segment_lens, + batch_dims=batch_dims, + beam_size=100, + downsampling=1, + precompute_chunk_size=10, + interpolation_alignment=None, + interpolation_alignment_factor=0.0, + use_recombination="max", + return_realignment=True, + ) + + interpolation_alignment = rf.where( + viterbi_alignment_scores > interpolation_alignment_scores, + viterbi_alignment, + interpolation_alignment + ) + interpolation_alignment_scores = rf.where( + viterbi_alignment_scores > interpolation_alignment_scores, + viterbi_alignment_scores, + interpolation_alignment_scores + ) + + for name, tensor, dim, ndim in zip( + ("interpolation-alignment", "interpolation-alignment-scores"), + (interpolation_alignment, interpolation_alignment_scores), + (model.target_dim.dimension, 1), + (1, 0) + ): + # dump the new interpolation alignment to hdf + hdf_filename = f"{name}_full-epoch-{(rf.get_run_ctx().epoch - 1) // partition_epoch + 1}.hdf" + hdf_dataset = SimpleHDFWriter( + filename=hdf_filename, + dim=dim, + ndim=ndim, + extend_existing_file=os.path.exists(hdf_filename), + ) + hdf.dump_hdf_rf( + hdf_dataset=hdf_dataset, + data=tensor, + batch_dim=batch_dims[0], + seq_tags=seq_tags, + ) else: label_model_full_sum_training( model=model.label_decoder, diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/utils.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/utils.py index 73da27aa7..7654a10e6 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/utils.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/utils.py @@ -21,7 +21,7 @@ def get_masked( else: new_lens = rf.copy_to_device(result_spatial_dim.get_size_tensor(), input.device) # max number of non-blank targets in the batch - result_spatial_size = rf.cast(rf.reduce_max(new_lens, axis=batch_dims), "int32") + result_spatial_size = rf.cast(rf.reduce_max(new_lens, axis=new_lens.dims), "int32") mask_axis = mask.get_axis_from_description(mask_dim) # scatter indices idxs = rf.cast(mask, "int32").copy_template() @@ -74,7 +74,8 @@ def get_segment_starts_and_lens( out_spatial_dim: Dim ): targets_range = rf.range_over_dim(align_targets_spatial_dim, dtype="int32") - targets_range = rf.expand_dim(targets_range, batch_dims[0]) + for batch_dim in batch_dims: + targets_range = rf.expand_dim(targets_range, batch_dim) non_blank_positions, _ = get_masked( targets_range, non_blank_mask, align_targets_spatial_dim, batch_dims, out_spatial_dim ) @@ -101,3 +102,68 @@ def get_emit_ground_truth( torch.set_printoptions(threshold=10000) return result, sparse_dim + + +def copy_tensor_replace_dim_tag(tensor: Tensor, old_dim_tag: Dim, new_dim_tag: Dim): + tensor_raw = tensor.raw_tensor + tensor = tensor.copy_template_replace_dim_tag( + tensor.get_axis_from_description(old_dim_tag), new_dim_tag + ) + tensor.raw_tensor = tensor_raw + return tensor + + +def get_linear_alignment( + non_blank_targets: Tensor, + non_blank_targets_spatial_dim: Dim, + enc_spatial_dim: Dim, + batch_dims: Sequence[Dim], + blank_idx: int, +): + enc_spatial_sizes = rf.copy_to_device(enc_spatial_dim.get_size_tensor(), non_blank_targets.device) + non_blank_targets_spatial_sizes = rf.copy_to_device( + non_blank_targets_spatial_dim.get_size_tensor(), non_blank_targets.device) + + # linearly distributed label positions over encoder dimension + linear_label_positions = rf.range_over_dim(non_blank_targets_spatial_dim) + linear_label_positions = rf.cast( + (linear_label_positions + 0.5) * (enc_spatial_sizes / non_blank_targets_spatial_sizes), + "int32" + ) + # set positions, which are too large, to T+1 (cut off this dummy frame later) + linear_label_positions = rf.where( + linear_label_positions < enc_spatial_sizes, + linear_label_positions, + enc_spatial_sizes + ) + enc_spatial_dim_ext = enc_spatial_dim + 1 + linear_label_positions.sparse_dim = enc_spatial_dim_ext + + # scatter non-blank targets into zero tensor + linear_alignment = rf.scatter( + non_blank_targets, + indices=linear_label_positions, + indices_dim=non_blank_targets_spatial_dim, + out_dim=enc_spatial_dim_ext, + ) + # replace all non-blank frames with blank + linear_label_positions_scattered = rf.scatter( + linear_label_positions, + indices=linear_label_positions, + indices_dim=non_blank_targets_spatial_dim, + out_dim=enc_spatial_dim_ext, + ) + linear_alignment = rf.where( + rf.range_over_dim(enc_spatial_dim_ext) != linear_label_positions_scattered, + blank_idx, + linear_alignment + ) + # cut off dummy frame + linear_alignment = linear_alignment.copy_transpose([enc_spatial_dim_ext] + batch_dims) + linear_alignment_raw = linear_alignment.raw_tensor + linear_alignment = linear_alignment.copy_template_replace_dim_tag( + linear_alignment.get_axis_from_description(enc_spatial_dim_ext), + enc_spatial_dim, + ) + linear_alignment.raw_tensor = linear_alignment_raw[:-1] + return linear_alignment diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v3/__init__.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v3/__init__.py index 8be9edbfb..dadf251bd 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v3/__init__.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v3/__init__.py @@ -10,77 +10,73 @@ def run_exps(): + # ------------------------------------- ctx-1 models ------------------------------------- + for model_alias, config_builder in baseline.center_window_att_baseline_rf( - win_size_list=(5,), blank_decoder_version=4, + win_size_list=(5,), label_decoder_state="nb-linear1", blank_decoder_version=5 ): - for train_alias, checkpoint in train.train_center_window_att_viterbi_import_global_tf( - alias=model_alias, - config_builder=config_builder, - n_epochs_list=(10,), - const_lr_list=(1e-4,), - ): - recog.center_window_returnn_frame_wise_beam_search( - alias=train_alias, + for import_model_name in ("glob.conformer.mohammad.5.4",): + for train_alias, checkpoint in train.train_center_window_att_viterbi_import_global_tf( + alias=model_alias, config_builder=config_builder, - checkpoint=checkpoint, - ) + n_epochs_list=(100,), + const_lr_list=(1e-4,), + import_model_name=import_model_name, + ): + recog.center_window_returnn_frame_wise_beam_search( + alias=train_alias, + config_builder=config_builder, + checkpoint=checkpoint, + ) - # for model_alias, config_builder in baseline.center_window_att_baseline_rf( - # win_size_list=(5,), blank_decoder_version=5, - # ): - # for train_alias, checkpoint in train.train_center_window_att_viterbi_import_global_tf( - # alias=model_alias, - # config_builder=config_builder, - # n_epochs_list=(10,), - # const_lr_list=(1e-4,), - # ): - # pass - # recog.center_window_returnn_frame_wise_beam_search( - # alias=train_alias, - # config_builder=config_builder, - # checkpoint=checkpoint, - # ) + for model_alias, config_builder in baseline.center_window_att_baseline_rf( + win_size_list=(5,), label_decoder_state="nb-linear1", blank_decoder_version=3 + ): + for import_model_name in ("glob.conformer.mohammad.5.4",): + for train_alias, checkpoint in train.train_center_window_att_viterbi_import_global_tf( + alias=model_alias, + config_builder=config_builder, + n_epochs_list=(100,), + const_lr_list=(1e-4,), + import_model_name=import_model_name, + ): + recog.center_window_returnn_frame_wise_beam_search( + alias=train_alias, + config_builder=config_builder, + checkpoint=checkpoint, + ) - # for model_alias, config_builder in baseline.center_window_att_baseline_rf( - # win_size_list=(5,), blank_decoder_version=6, - # ): - # for train_alias, checkpoint in train.train_center_window_att_viterbi_import_global_tf( - # alias=model_alias, - # config_builder=config_builder, - # n_epochs_list=(10,), - # const_lr_list=(1e-4,), - # ): - # pass - # recog.center_window_returnn_frame_wise_beam_search( - # alias=train_alias, - # config_builder=config_builder, - # checkpoint=checkpoint, - # ) + for model_alias, config_builder in baseline.center_window_att_baseline_rf( + win_size_list=(5,), + label_decoder_state="nb-linear1", + blank_decoder_version=5, + use_weight_feedback=False, + use_att_ctx_in_state=False + ): + for import_model_name in ("glob.conformer.mohammad.5.4",): + for train_alias, checkpoint in train.train_center_window_att_viterbi_import_global_tf( + alias=model_alias, + config_builder=config_builder, + n_epochs_list=(100,), + const_lr_list=(1e-4,), + import_model_name=import_model_name, + ): + recog.center_window_returnn_frame_wise_beam_search( + alias=train_alias, + config_builder=config_builder, + checkpoint=checkpoint, + ) - # for model_alias, config_builder in baseline.center_window_att_baseline_rf( - # win_size_list=(5,) - # ): - # for max_shift, num_iterations in [(1, 1), (2, 1), (1, 2)]: - # for train_alias, checkpoint in train.train_center_window_att_viterbi_import_global_tf( - # alias=model_alias, - # config_builder=config_builder, - # n_epochs_list=(100,), - # const_lr_list=(1e-4,), - # alignment_augmentation_opts={"max_shift": max_shift, "num_iterations": num_iterations}, - # ): - # recog.center_window_returnn_frame_wise_beam_search( - # alias=train_alias, - # config_builder=config_builder, - # checkpoint=checkpoint, - # ) + # ------------------------------------- blank decoder variants ------------------------------------- for model_alias, config_builder in baseline.center_window_att_baseline_rf( - win_size_list=(5,), + win_size_list=(5,), blank_decoder_version=5, ): - for train_alias, checkpoint in train.train_center_window_att_viterbi_from_scratch( + for train_alias, checkpoint in train.train_center_window_att_viterbi_import_global_tf( alias=model_alias, config_builder=config_builder, - n_epochs_list=(500,), + n_epochs_list=(100,), + const_lr_list=(1e-4,), ): recog.center_window_returnn_frame_wise_beam_search( alias=train_alias, @@ -88,24 +84,8 @@ def run_exps(): checkpoint=checkpoint, ) - # for model_alias, config_builder in baseline.center_window_att_baseline_rf( - # win_size_list=(5,), - # ): - # for train_alias, checkpoint in train.train_center_window_att_viterbi_from_scratch( - # alias=model_alias, - # config_builder=config_builder, - # n_epochs_list=(500,), - # use_speed_pert=True, - # ): - # recog.center_window_returnn_frame_wise_beam_search( - # alias=train_alias, - # config_builder=config_builder, - # checkpoint=checkpoint, - # ) - - # ------------------------------------- best models: KEEP! ------------------------------------- for model_alias, config_builder in baseline.center_window_att_baseline_rf( - win_size_list=(5, 129), + win_size_list=(5,), blank_decoder_version=6, ): for train_alias, checkpoint in train.train_center_window_att_viterbi_import_global_tf( alias=model_alias, @@ -119,20 +99,85 @@ def run_exps(): checkpoint=checkpoint, ) + # ------------------------------------- from-scratch Viterbi training ------------------------------------- + for model_alias, config_builder in baseline.center_window_att_baseline_rf( win_size_list=(5,), ): - for train_alias, checkpoint in train.train_center_window_att_viterbi_import_global_tf( + for train_alias, checkpoint in train.train_center_window_att_viterbi_from_scratch( alias=model_alias, config_builder=config_builder, - n_epochs_list=(100,), - const_lr_list=(1e-4,), + n_epochs_list=(500,), ): - for use_recombination in {"max", "sum"}: + recog.center_window_returnn_frame_wise_beam_search( + alias=train_alias, + config_builder=config_builder, + checkpoint=checkpoint, + ) + + # ------------------------------------- best models: KEEP! ------------------------------------- + + for use_weight_feedback in (True, False): + for use_att_ctx_in_state in (True, False): + for model_alias, config_builder in baseline.center_window_att_baseline_rf( + win_size_list=(5,), use_weight_feedback=use_weight_feedback, use_att_ctx_in_state=use_att_ctx_in_state + ): + for import_model_name in ("glob.conformer.mohammad.5.4",): + for train_alias, checkpoint in train.train_center_window_att_viterbi_import_global_tf( + alias=model_alias, + config_builder=config_builder, + n_epochs_list=(100,), + const_lr_list=(1e-4,), + import_model_name=import_model_name, + ): + recog.center_window_returnn_frame_wise_beam_search( + alias=train_alias, + config_builder=config_builder, + checkpoint=checkpoint, + ) + if "129" not in model_alias: + recog.center_window_returnn_frame_wise_beam_search( + alias=train_alias, + config_builder=config_builder, + checkpoint=checkpoint, + checkpoint_aliases=("last",), + # lm_type="trafo", + # lm_scale_list=(0.4,), + ) + if use_weight_feedback and use_att_ctx_in_state: + recog.center_window_returnn_frame_wise_beam_search( + alias=train_alias, + config_builder=config_builder, + checkpoint=checkpoint, + checkpoint_aliases=("last",), + lm_type="trafo", + lm_scale_list=(0.54,), + ilm_type="mini_att", + ilm_scale_list=(0.4,), + ) + + for model_alias, config_builder in baseline.center_window_att_baseline_rf( + win_size_list=(129,), + ): + for import_model_name in ("glob.conformer.mohammad.5.4",): + for train_alias, checkpoint in train.train_center_window_att_viterbi_import_global_tf( + alias=model_alias, + config_builder=config_builder, + n_epochs_list=(100,), + const_lr_list=(1e-4,), + import_model_name=import_model_name, + ): recog.center_window_returnn_frame_wise_beam_search( alias=train_alias, config_builder=config_builder, checkpoint=checkpoint, - checkpoint_aliases=("best-4-avg",), - use_recombination=use_recombination, ) + if "129" not in model_alias: + recog.center_window_returnn_frame_wise_beam_search( + alias=train_alias, + config_builder=config_builder, + checkpoint=checkpoint, + checkpoint_aliases=("last",), + # lm_type="trafo", + # lm_scale_list=(0.4,), + ) diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v3/baseline.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v3/baseline.py index 8068a8061..e39569b0a 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v3/baseline.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v3/baseline.py @@ -9,6 +9,7 @@ def center_window_att_baseline_rf( use_att_ctx_in_state: bool = True, use_weight_feedback: bool = True, blank_decoder_version: int = 3, + label_decoder_state: str = "nb-lstm", ): for win_size in win_size_list: alias, config_builder = get_center_window_att_config_builder_rf( @@ -17,6 +18,7 @@ def center_window_att_baseline_rf( blank_decoder_version=blank_decoder_version, use_joint_model=False, use_weight_feedback=use_weight_feedback, + label_decoder_state=label_decoder_state, ) alias = f"{base_alias}/baseline_rf/{alias}" yield alias, config_builder diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v4/__init__.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v4/__init__.py index 478e6957d..da72bdf7e 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v4/__init__.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/baseline_v4/__init__.py @@ -2,104 +2,166 @@ baseline, ) from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.pipelines.pipeline_ls_conf.center_window_att import ( - train, recog + train, recog, realign ) def run_exps(): for model_alias, config_builder in baseline.center_window_att_baseline_rf( - win_size_list=(5,), label_decoder_state="nb-lstm", use_att_ctx_in_state=False, use_weight_feedback=False, + win_size_list=(5,), label_decoder_state="nb-linear1", use_att_ctx_in_state=False, use_weight_feedback=False, ): - for train_alias, checkpoint in train.train_center_window_att_viterbi_import_global_tf( - alias=model_alias, - config_builder=config_builder, - n_epochs_list=(200, 300), - ): - recog.center_window_returnn_frame_wise_beam_search( - alias=train_alias, + for import_model_name in ("glob.conformer.mohammad.5.4",): + for train_alias, checkpoint in train.train_center_window_att_viterbi_import_global_tf( + alias=model_alias, config_builder=config_builder, - checkpoint=checkpoint, - ) + n_epochs_list=(100,), + import_model_name=import_model_name, + ): + for recombination in (None,): + recog.center_window_returnn_frame_wise_beam_search( + alias=train_alias, + config_builder=config_builder, + checkpoint=checkpoint, + # checkpoint_aliases=("last",), + use_recombination=recombination, + ) - for model_alias, config_builder in baseline.center_window_att_baseline_rf( - win_size_list=(5,), label_decoder_state="joint-lstm", use_att_ctx_in_state=False, use_weight_feedback=False, - ): - for train_alias, checkpoint in train.train_center_window_att_viterbi_import_global_tf( - alias=model_alias, - config_builder=config_builder, - n_epochs_list=(200, 300), - ): - recog.center_window_returnn_frame_wise_beam_search( - alias=train_alias, - config_builder=config_builder, - checkpoint=checkpoint, - ) + # for model_alias, config_builder in baseline.center_window_att_baseline_rf( + # win_size_list=(5,), label_decoder_state="joint-lstm", + # ): + # for import_model_name in ("glob.conformer.mohammad.5.4",): + # for train_alias, checkpoint in train.train_center_window_att_viterbi_import_global_tf( + # alias=model_alias, + # config_builder=config_builder, + # n_epochs_list=(100,), + # import_model_name=import_model_name, + # ): + # for recombination in (None,): + # recog.center_window_returnn_frame_wise_beam_search( + # alias=train_alias, + # config_builder=config_builder, + # checkpoint=checkpoint, + # # checkpoint_aliases=("last",), + # use_recombination=recombination, + # ) for model_alias, config_builder in baseline.center_window_att_baseline_rf( win_size_list=(5,), label_decoder_state="nb-lstm", use_att_ctx_in_state=False, use_weight_feedback=False, - bpe_vocab_size=1056, ): for train_alias, checkpoint in train.train_center_window_att_full_sum_from_scratch( alias=model_alias, config_builder=config_builder, n_epochs_list=(125,), use_speed_pert=True, - batch_size=3_000, + batch_size=8_000, + time_rqmt=80, + use_mgpu=False, + beam_size=4, + lattice_downsampling=1, + alignment_interpolation_factor=0.5, + ): + for epoch, chckpt in checkpoint["checkpoints"].items(): + realign.center_window_returnn_realignment( + alias=train_alias, + config_builder=config_builder, + checkpoint=chckpt, + checkpoint_alias=f"epoch-{epoch}", + plot=True, + ) + + for train_alias, checkpoint in train.train_center_window_att_full_sum_from_scratch( + alias=model_alias, + config_builder=config_builder, + n_epochs_list=(125,), + use_speed_pert=True, + batch_size=8_000, time_rqmt=80, use_mgpu=False, + beam_size=100, + lattice_downsampling=3, + alignment_interpolation_factor=0.0, ): - pass - # recog.center_window_returnn_frame_wise_beam_search( - # alias=train_alias, - # config_builder=config_builder, - # checkpoint=checkpoint, - # ) + for epoch, chckpt in checkpoint["checkpoints"].items(): + realign.center_window_returnn_realignment( + alias=train_alias, + config_builder=config_builder, + checkpoint=chckpt, + checkpoint_alias=f"epoch-{epoch}", + plot=True, + ) + + for train_alias, checkpoint in train.train_center_window_att_full_sum_from_scratch( + alias=model_alias, + config_builder=config_builder, + n_epochs_list=(125,), + use_speed_pert=True, + batch_size=8_000, + time_rqmt=80, + use_mgpu=False, + beam_size=1, + lattice_downsampling=1, + alignment_interpolation_factor=0.0, + train_on_viterbi_paths=True, + ): + for epoch, chckpt in checkpoint["checkpoints"].items(): + realign.center_window_returnn_realignment( + alias=train_alias, + config_builder=config_builder, + checkpoint=chckpt, + checkpoint_alias=f"epoch-{epoch}", + plot=True, + ) for model_alias, config_builder in baseline.center_window_att_baseline_rf( - win_size_list=(5,), + win_size_list=(15,), label_decoder_state="nb-lstm", use_att_ctx_in_state=False, use_weight_feedback=False, - bpe_vocab_size=1056, ): for train_alias, checkpoint in train.train_center_window_att_full_sum_from_scratch( alias=model_alias, config_builder=config_builder, n_epochs_list=(125,), use_speed_pert=True, - batch_size=3_000, - time_rqmt=1, - use_mgpu=True, + batch_size=8_000, + time_rqmt=80, + use_mgpu=False, + beam_size=100, + lattice_downsampling=8, + alignment_interpolation_factor=0.0, ): - pass - # recog.center_window_returnn_frame_wise_beam_search( - # alias=train_alias, - # config_builder=config_builder, - # checkpoint=checkpoint, - # ) + for epoch, chckpt in checkpoint["checkpoints"].items(): + realign.center_window_returnn_realignment( + alias=train_alias, + config_builder=config_builder, + checkpoint=chckpt, + checkpoint_alias=f"epoch-{epoch}", + plot=True, + ) for model_alias, config_builder in baseline.center_window_att_baseline_rf( - win_size_list=(1,), + win_size_list=(5,), label_decoder_state="nb-lstm", use_att_ctx_in_state=False, use_weight_feedback=False, + bpe_vocab_size=1056, ): for train_alias, checkpoint in train.train_center_window_att_full_sum_from_scratch( alias=model_alias, config_builder=config_builder, n_epochs_list=(125,), use_speed_pert=True, - batch_size=3_000, + batch_size=8_000, time_rqmt=80, use_mgpu=False, - beam_size=100 ): - pass - # recog.center_window_returnn_frame_wise_beam_search( - # alias=train_alias, - # config_builder=config_builder, - # checkpoint=checkpoint, - # ) + for epoch, chckpt in checkpoint["checkpoints"].items(): + realign.center_window_returnn_realignment( + alias=train_alias, + config_builder=config_builder, + checkpoint=chckpt, + checkpoint_alias=f"epoch-{epoch}", + ) diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/config_builder.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/config_builder.py index d43cc8813..8b876f61d 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/config_builder.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/config_builder.py @@ -8,7 +8,7 @@ from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23.dependencies.general.returnn.exes import RETURNN_EXE_NEW, RETURNN_CURRENT_ROOT from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.config_builder_rf.base import SegmentalAttConfigBuilderRF -from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model import from_scratch_model_def, _returnn_v2_get_model +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model import from_scratch_model_def, _returnn_v2_get_model, _returnn_v2_get_joint_model def get_center_window_att_config_builder_rf( @@ -35,16 +35,21 @@ def get_center_window_att_config_builder_rf( "returnn_root": RETURNN_CURRENT_ROOT } + if use_joint_model: + get_model_func = _returnn_v2_get_joint_model + else: + get_model_func = _returnn_v2_get_model + config_builder = SegmentalAttConfigBuilderRF( variant_params=variant_params, model_def=from_scratch_model_def, - get_model_func=_returnn_v2_get_model, + get_model_func=get_model_func, center_window_size=win_size, use_att_ctx_in_state=use_att_ctx_in_state, blank_decoder_version=blank_decoder_version, use_joint_model=use_joint_model, use_weight_feedback=use_weight_feedback, - label_decoder_state=label_decoder_state + label_decoder_state=label_decoder_state, ) alias = ( diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/realign.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/realign.py new file mode 100644 index 000000000..efa96d460 --- /dev/null +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/realign.py @@ -0,0 +1,80 @@ +from typing import Tuple, Optional, List, Union, Dict +import copy + +from i6_core.returnn.training import PtCheckpoint +from i6_core.returnn.forward import ReturnnForwardJob, ReturnnForwardJobV2 +from sisyphus import Path, tk + +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.config_builder_rf.base import SegmentalAttConfigBuilderRF +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23.recog_new import ReturnnSegmentalAttDecodingPipeline, RasrSegmentalAttDecodingExperiment +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23.realignment_new import RasrRealignmentExperiment +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.recog import _returnn_v2_forward_step, _returnn_v2_get_forward_callback +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.realignment import model_realign_, _returnn_v2_forward_step, _returnn_v2_get_forward_callback +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model import _returnn_v2_get_joint_model +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23.dependencies.general.returnn.exes import RETURNN_EXE_NEW, RETURNN_CURRENT_ROOT +from i6_experiments.users.schmitt.visualization.visualization import PlotAlignmentJob +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23.dependencies.labels.v2.librispeech.label_singletons import LibrispeechBPE10025_CTC_ALIGNMENT + +def center_window_returnn_realignment( + alias: str, + config_builder: SegmentalAttConfigBuilderRF, + checkpoint: Union[PtCheckpoint, Dict], + checkpoint_alias: str, + plot: bool = False, +): + alias += ( + f"/returnn_realignment/{checkpoint_alias}-checkpoint" + ) + + if isinstance(checkpoint, PtCheckpoint): + checkpoint = checkpoint + else: + assert isinstance(checkpoint, dict) + checkpoint = config_builder.get_recog_checkpoints(**checkpoint)[checkpoint_alias] + + realign_config = config_builder.get_realign_config( + opts={ + "corpus_key": "dev-other", + "realign_def": model_realign_, + "forward_step_func": _returnn_v2_forward_step, + "forward_callback": _returnn_v2_get_forward_callback, + }) + + realign_job = ReturnnForwardJobV2( + model_checkpoint=checkpoint, + returnn_config=realign_config, + returnn_root=RETURNN_CURRENT_ROOT, + returnn_python_exe=RETURNN_EXE_NEW, + output_files=["scores.py.gz", "realignment.hdf"], + mem_rqmt=6, + time_rqmt=1, + ) + realign_job.add_alias(f"{alias}/realignment") + tk.register_output(realign_job.get_one_alias(), realign_job.out_files["realignment.hdf"]) + + if plot: + plot_alignment_job = PlotAlignmentJob( + alignment_hdf=realign_job.out_files["realignment.hdf"], + # ref_alignment_hdf=Path( + # "/u/schmitt/experiments/segmental_models_2022_23_rf/alias/models/ls_conformer/global_att/baseline_v1/baseline/no-finetuning/ctc_alignments/dev-other/output/alignments.hdf"), + ref_alignment_hdf=LibrispeechBPE10025_CTC_ALIGNMENT.alignment_paths["dev-other"], + json_vocab_path=Path( + "/u/zeineldeen/setups/librispeech/2022-11-28--conformer-att/work/i6_core/text/label/subword_nmt/train/ReturnnTrainBpeJob.vTq56NZ8STWt/output/bpe.vocab"), + target_blank_idx=0, + segment_list=[ + "dev-other/3660-6517-0005/3660-6517-0005", + "dev-other/6467-62797-0001/6467-62797-0001", + "dev-other/6467-62797-0002/6467-62797-0002", + "dev-other/7697-105815-0015/7697-105815-0015", + "dev-other/7697-105815-0051/7697-105815-0051", + # high ctc-cog error + "dev-other/6123-59150-0027/6123-59150-0027", + # non-monotonic att weights + "dev-other/1255-138279-0000/1255-138279-0000", + "dev-other/7601-291468-0006/7601-291468-0006", + "dev-other/7601-101619-0003/7601-101619-0003" + ], + ref_alignment_blank_idx=10025, + ) + plot_alignment_job.add_alias(f"{alias}/plot_realignment") + tk.register_output(plot_alignment_job.get_one_alias(), plot_alignment_job.out_plot_dir) diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/recog.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/recog.py index dc0ffa994..de6da6cad 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/recog.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/recog.py @@ -48,6 +48,7 @@ def center_window_returnn_frame_wise_beam_search( "forward_step_func": _returnn_v2_forward_step, "forward_callback": _returnn_v2_get_forward_callback, "use_recombination": use_recombination, + "batch_size": 15_000 }, search_alias=f'returnn_decoding{"_pure_torch" if pure_torch else ""}' ).run() diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/train.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/train.py index 61e373208..35946f178 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/train.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/center_window_att/train.py @@ -9,7 +9,6 @@ viterbi_training, full_sum_training, ) -from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model import _returnn_v2_get_model_for_full_sum_training from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.pipelines.pipeline_ls_conf.checkpoints import ( external_checkpoints, default_import_model_name, @@ -27,7 +26,7 @@ def train_center_window_att_viterbi_from_scratch( use_mgpu: bool = True, ): for n_epochs in n_epochs_list: - alias += f"/viterbi-train_from_scratch/{n_epochs}-epochs_bs-{batch_size}_w-ctc-loss_{'w' if use_speed_pert else 'wo'}-speed-pert" + alias += f"/viterbi-train_from_scratch/{n_epochs}-epochs_bs-{batch_size}_wo-ctc-loss_{'w' if use_speed_pert else 'wo'}-speed-pert" train_opts = { "dataset_opts": { @@ -110,12 +109,19 @@ def train_center_window_att_full_sum_from_scratch( batch_size: int = 15_000, use_mgpu: bool = True, beam_size: Optional[int] = None, + lattice_downsampling: int = 1, + alignment_interpolation_factor: float = 0.5, + train_on_viterbi_paths: bool = False, ): - # TODO: do this in a nicer way - config_builder = copy.deepcopy(config_builder) - config_builder.get_model_func = _returnn_v2_get_model_for_full_sum_training + # # TODO: do this in a nicer way + # config_builder = copy.deepcopy(config_builder) + # config_builder.get_model_func = _returnn_v2_get_model_for_full_sum_training for n_epochs in n_epochs_list: - alias += f"/full-sum-train_from_scratch/{n_epochs}-epochs_bs-{batch_size}_w-ctc-loss_{'w' if use_speed_pert else 'wo'}-speed-pert" + alias += ( + f"/full-sum-train_from_scratch/{n_epochs}-epochs_bs-{batch_size}_{'w' if use_speed_pert else 'wo'}-sp" + f"_beams-{beam_size}_lat-down-{lattice_downsampling}_{alignment_interpolation_factor}-interp" + f"_{'ce' if train_on_viterbi_paths else 'sum'}-loss" + ) train_opts = { "dataset_opts": { @@ -152,10 +158,15 @@ def train_center_window_att_full_sum_from_scratch( # "max_seq_length": {"targets": 75}, "train_def": full_sum_training, "train_step_func": _returnn_v2_full_sum_train_step, + "full_sum_alignment_interpolation_factor": alignment_interpolation_factor, + "full_sum_lattice_downsampling": lattice_downsampling, } if beam_size is not None: - train_opts["full_sum_training_beam_size"] = beam_size + train_opts["full_sum_beam_size"] = beam_size + + if train_on_viterbi_paths: + train_opts["full_sum_train_on_viterbi_paths"] = True train_rqmt = { "time": time_rqmt, @@ -195,7 +206,7 @@ def train_center_window_att_viterbi_import_global_tf( alignment_augmentation_opts: Optional[Dict] = None, import_model_name: str = default_import_model_name, ): - if not config_builder.use_att_ctx_in_state: + if not config_builder.use_att_ctx_in_state and "lstm" in config_builder.label_decoder_state: # only randomly init FF weights, since only the input dim of the lstm layer is different custom_missing_load_func = load_missing_params else: diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/global_att/baseline_v1/__init__.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/global_att/baseline_v1/__init__.py index c6c6301de..c5d7a6835 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/global_att/baseline_v1/__init__.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/global_att/baseline_v1/__init__.py @@ -8,27 +8,54 @@ def run_exps(): - for use_weight_feedback in (True,): - for model_alias, config_builder in baseline.global_att_baseline_rf(use_weight_feedback=use_weight_feedback): - for train_alias, checkpoint in ( - (f"{model_alias}/import_{default_import_model_name}", external_checkpoints[default_import_model_name]), - (f"{model_alias}/import_glob.conformer.mohammad.5.4", external_checkpoints["glob.conformer.mohammad.5.4"]), + for model_alias, config_builder in baseline.global_att_baseline_rf(use_weight_feedback=True): + for train_alias, checkpoint in ( + (f"{model_alias}/import_{default_import_model_name}", external_checkpoints[default_import_model_name]), + (f"{model_alias}/import_glob.conformer.mohammad.5.4", external_checkpoints["glob.conformer.mohammad.5.4"]), + ): + recog.global_att_returnn_label_sync_beam_search( + alias=train_alias, + config_builder=config_builder, + checkpoint=checkpoint, + checkpoint_aliases=("best-4-avg",), + ) + + for import_model_name in ("glob.conformer.mohammad.5.4",): + for train_alias, checkpoint in train.train_import_global_tf( + alias=model_alias, + config_builder=config_builder, + n_epochs_list=(100,), + const_lr_list=(1e-4,), + import_model_name=import_model_name, ): recog.global_att_returnn_label_sync_beam_search( alias=train_alias, config_builder=config_builder, checkpoint=checkpoint, - checkpoint_aliases=("best-4-avg",), + checkpoint_aliases=("best",), + lm_type="trafo", + lm_scale_list=(0.4, 0.54), + ilm_scale_list=(0.4,), + ilm_type="mini_att", + beam_size_list=(12,) ) + for model_alias, config_builder in baseline.global_att_baseline_rf( + use_weight_feedback=False, use_att_ctx_in_state=False + ): + for import_model_name in ("glob.conformer.mohammad.5.4",): for train_alias, checkpoint in train.train_import_global_tf( alias=model_alias, config_builder=config_builder, - n_epochs_list=(10, 100), + n_epochs_list=(100,), const_lr_list=(1e-4,), + import_model_name=import_model_name, ): recog.global_att_returnn_label_sync_beam_search( alias=train_alias, config_builder=config_builder, checkpoint=checkpoint, ) + + + diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/global_att/baseline_v1/baseline.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/global_att/baseline_v1/baseline.py index c9a3a3c95..7b50a3562 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/global_att/baseline_v1/baseline.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/global_att/baseline_v1/baseline.py @@ -1,49 +1,5 @@ -import copy -from typing import Dict, List, Any, Optional, Tuple - -from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.config_builder_rf.base import GlobalAttConfigBuilderRF -from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.global_.model import from_scratch_model_def, _returnn_v2_get_model -from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23.model_variants.model_variants_ls_conf import models from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23.pipelines.pipeline_ls_conf.global_att.baseline_v1.alias import alias as base_alias -from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23.dependencies.labels.v2.librispeech.label_singletons import ( - LibrispeechBPE10025_LABELS, -LIBRISPEECH_CORPUS -) -from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23.dependencies.general.returnn.exes import RETURNN_EXE_NEW, RETURNN_CURRENT_ROOT - - -def get_global_att_config_builder_rf( - use_weight_feedback: bool = True, - use_att_ctx_in_state: bool = True, -): - variant_params = { - "dependencies": LibrispeechBPE10025_LABELS, - "dataset": { - "feature_type": "raw", - "corpus": LIBRISPEECH_CORPUS - }, - "config": { - "train_seq_ordering": "laplace:.1000" - }, - "network": {"length_scale": 1.0}, - "returnn_python_exe": RETURNN_EXE_NEW, - "returnn_root": RETURNN_CURRENT_ROOT - } - - config_builder = GlobalAttConfigBuilderRF( - variant_params=variant_params, - model_def=from_scratch_model_def, - get_model_func=_returnn_v2_get_model, - use_weight_feedback=use_weight_feedback, - use_att_ctx_in_state=use_att_ctx_in_state, - ) - - alias = ( - f"{'w' if use_weight_feedback else 'wo'}-weight-feedback/" - f"{'w' if use_att_ctx_in_state else 'wo'}-att-ctx-in-state" - ) - - return alias, config_builder +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.pipelines.pipeline_ls_conf.global_att.config_builder import get_global_att_config_builder_rf def global_att_baseline_rf(use_weight_feedback: bool = True, use_att_ctx_in_state: bool = True): diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/global_att/config_builder.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/global_att/config_builder.py new file mode 100644 index 000000000..c79921858 --- /dev/null +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/global_att/config_builder.py @@ -0,0 +1,41 @@ +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.config_builder_rf.base import GlobalAttConfigBuilderRF +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.global_.model import from_scratch_model_def, _returnn_v2_get_model +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23.dependencies.labels.v2.librispeech.label_singletons import ( + LibrispeechBPE10025_LABELS, +LIBRISPEECH_CORPUS +) +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23.dependencies.general.returnn.exes import RETURNN_EXE_NEW, RETURNN_CURRENT_ROOT + + +def get_global_att_config_builder_rf( + use_weight_feedback: bool = True, + use_att_ctx_in_state: bool = True, +): + variant_params = { + "dependencies": LibrispeechBPE10025_LABELS, + "dataset": { + "feature_type": "raw", + "corpus": LIBRISPEECH_CORPUS + }, + "config": { + "train_seq_ordering": "laplace:.1000" + }, + "network": {"length_scale": 1.0}, + "returnn_python_exe": RETURNN_EXE_NEW, + "returnn_root": RETURNN_CURRENT_ROOT + } + + config_builder = GlobalAttConfigBuilderRF( + variant_params=variant_params, + model_def=from_scratch_model_def, + get_model_func=_returnn_v2_get_model, + use_weight_feedback=use_weight_feedback, + use_att_ctx_in_state=use_att_ctx_in_state, + ) + + alias = ( + f"{'w' if use_weight_feedback else 'wo'}-weight-feedback/" + f"{'w' if use_att_ctx_in_state else 'wo'}-att-ctx-in-state" + ) + + return alias, config_builder diff --git a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/global_att/recog.py b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/global_att/recog.py index f599574a3..4fbb46542 100644 --- a/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/global_att/recog.py +++ b/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/pipelines/pipeline_ls_conf/global_att/recog.py @@ -21,7 +21,7 @@ def global_att_returnn_label_sync_beam_search( checkpoint_aliases: Tuple[str, ...] = ("last", "best", "best-4-avg"), run_analysis: bool = False, att_weight_seq_tags: Optional[List] = None, - pure_torch: bool = False + corpus_keys: Tuple[str, ...] = ("dev-other",), ): ilm_opts = {"type": ilm_type} if ilm_type == "mini_att": @@ -42,9 +42,10 @@ def global_att_returnn_label_sync_beam_search( run_analysis=run_analysis, analysis_opts={"att_weight_seq_tags": att_weight_seq_tags}, recog_opts={ - "recog_def": model_recog_pure_torch if pure_torch else model_recog, + "recog_def": model_recog, "forward_step_func": _returnn_v2_forward_step, "forward_callback": _returnn_v2_get_forward_callback, }, - search_alias=f'returnn_decoding{"_pure_torch" if pure_torch else ""}' + search_alias=f'returnn_decoding', + corpus_keys=corpus_keys, ).run() diff --git a/users/schmitt/hdf.py b/users/schmitt/hdf.py index cad04e016..4cbbba212 100644 --- a/users/schmitt/hdf.py +++ b/users/schmitt/hdf.py @@ -1,9 +1,12 @@ import h5py from typing import List +import numpy as np from sisyphus import Path, tk from i6_core.returnn import ReturnnDumpHDFJob +from returnn.datasets.hdf import SimpleHDFWriter +from returnn.tensor import Dim, Tensor def load_hdf_data(hdf_path: Path, num_dims: int = 1, segment_list: List = None): @@ -68,3 +71,69 @@ def build_hdf_from_alignment( ).out_hdf return hdf_file + + +def dump_hdf_numpy( + hdf_dataset: SimpleHDFWriter, + data: np.array, + seq_lens: np.array, + seq_tags: List[str], +): + """ + Dump data to an hdf file. + + :param data: torch.Tensor of shape (batch, spatial) with sparse_dim=dimension + :param seq_lens: torch.Tensor of shape (batch,) + :param seq_tags: torch.Tensor of shape (batch,) + :param dimension: int, the sparse dimension of the data + """ + assert len(data.shape) == 2 + assert len(seq_lens.shape) == 1 + assert data.shape[0] == seq_lens.shape[0] + + seq_lens = {0: seq_lens} + batch_seq_sizes = np.expand_dims(seq_lens[0], 1) + + hdf_dataset.insert_batch( + data, + seq_len=seq_lens, + seq_tag=list(seq_tags), + extra={"seq_sizes": batch_seq_sizes} + ) + + +def dump_hdf_rf( + hdf_dataset: SimpleHDFWriter, + data: Tensor, + batch_dim: Dim, + seq_tags: Tensor, +): + """ + Dump data to an hdf file. + + :param data: torch.Tensor of shape (batch, spatial) with sparse_dim=dimension + :param seq_lens: torch.Tensor of shape (batch,) + :param seq_tags: torch.Tensor of shape (batch,) + :param dimension: int, the sparse dimension of the data + """ + assert len(data.batch_shape) <= 2 + + spatial_dims = data.remaining_dims(batch_dim) + data_raw = data.copy_transpose( + [batch_dim] + spatial_dims + ).raw_tensor + + if len(spatial_dims) == 1: + seq_lens = {0: spatial_dims[0].get_size_tensor().raw_tensor.numpy()} + batch_seq_sizes = np.expand_dims(seq_lens[0], 1) + else: + seq_lens = {} + batch_seq_sizes = np.zeros((batch_dim.get_dim_value(), 1)) + + hdf_dataset.insert_batch( + data_raw.to(device="cpu").numpy(), + seq_len=seq_lens, + seq_tag=list(seq_tags.raw_tensor), + extra={"seq_sizes": batch_seq_sizes} + ) + hdf_dataset.close() diff --git a/users/schmitt/returnn_frontend/model_interfaces/training.py b/users/schmitt/returnn_frontend/model_interfaces/training.py index d834db360..14b14c834 100644 --- a/users/schmitt/returnn_frontend/model_interfaces/training.py +++ b/users/schmitt/returnn_frontend/model_interfaces/training.py @@ -63,6 +63,10 @@ def __call__( data_spatial_dim: Dim, non_blank_targets: Tensor, non_blank_targets_spatial_dim: Dim, + seq_tags: Tensor, + interpolation_alignment: Optional[Tensor] = None, + interpolation_alignment_spatial_dim: Optional[Dim] = None, + interpolation_alignment_scores: Optional[Tensor] = None, ): raise NotImplementedError diff --git a/users/schmitt/visualization/visualization.py b/users/schmitt/visualization/visualization.py index 89d3abcad..a733c89f5 100644 --- a/users/schmitt/visualization/visualization.py +++ b/users/schmitt/visualization/visualization.py @@ -269,6 +269,7 @@ def set_ticks( vocab: Dict[int, str], ref_alignment_blank_idx: int, target_blank_idx: Optional[int] = None, + draw_vertical_lines: bool = False ): """ Set the ticks and labels for the x and y axis. @@ -281,7 +282,8 @@ def set_ticks( ref_labels = ref_alignment[ref_alignment != ref_alignment_blank_idx] ref_labels = [vocab[idx] for idx in ref_labels] # x axis - ax.set_xticks([tick - 1.0 for tick in ref_label_positions]) + xticks = [tick - 1.0 for tick in ref_label_positions] + ax.set_xticks(xticks) ax.set_xticklabels(ref_labels, rotation=90) # output labels of the model @@ -297,6 +299,10 @@ def set_ticks( for ytick in yticks: ax.axhline(y=ytick - .5, xmin=0, xmax=1, color="k", linewidth=.5) + if draw_vertical_lines: + for xtick in xticks: + ax.axvline(x=xtick, ymin=0, ymax=1, color="r", linewidth=.5, linestyle="--", alpha=0.5) + @staticmethod def _draw_segment_boundaries( ax: plt.Axes, @@ -330,7 +336,13 @@ def _draw_center_positions( ax.axvline(x=center_position + .5, ymin=ymin, ymax=ymax, color="lime") @staticmethod - def plot_ctc_alignment(ax: plt.Axes, ctc_alignment: np.ndarray, num_labels: int, ctc_blank_idx: int): + def plot_ctc_alignment( + ax: plt.Axes, + ctc_alignment: np.ndarray, + num_labels: int, + ctc_blank_idx: int, + plot_trailing_blanks: bool = False + ): label_idx = 0 # store alignment like: 000011112222223333, where the number is the label index (~ height in the plot) ctc_alignment_plot_data = [] @@ -339,7 +351,7 @@ def plot_ctc_alignment(ax: plt.Axes, ctc_alignment: np.ndarray, num_labels: int, if ctc_label != ctc_blank_idx: label_idx += 1 # stop if we reached the last label, the rest of the ctc alignment are blanks - if label_idx == num_labels: + if label_idx == num_labels and not plot_trailing_blanks: break ax.plot(ctc_alignment_plot_data, "o", color="black", alpha=.4) @@ -530,13 +542,20 @@ def __init__( json_vocab_path: Path, target_blank_idx: int, segment_list: List[str], + ref_alignment_hdf: Optional[Path] = None, + ref_alignment_blank_idx: Optional[int] = None, silence_idx: Optional[int] = None, ): + if ref_alignment_hdf is not None: + assert ref_alignment_blank_idx is not None + self.alignment_hdf = alignment_hdf self.json_vocab_path = json_vocab_path self.target_blank_idx = target_blank_idx self.segment_list = segment_list self.silence_idx = silence_idx + self.ref_alignment_hdf = ref_alignment_hdf if ref_alignment_hdf is not None else alignment_hdf + self.ref_alignment_blank_idx = ref_alignment_blank_idx if ref_alignment_blank_idx is not None else target_blank_idx self.out_plot_dir = self.output_path("plots", True) @@ -582,9 +601,38 @@ def _set_ticks( for i, position in enumerate(label_positions): ax.axvline(x=position - 1.0, ymin=ymin, ymax=ymax, color=color) + @staticmethod + def _set_ticks_alt( + ax: plt.Axes, + alignment: np.ndarray, + ref_alignment: np.ndarray, + vocab: Dict[int, str], + blank_idx: int, + ref_alignment_blank_idx: int, + ): + """ + Set the ticks and labels for the x and y axis. + x-axis: reference alignment + y-axis: model output + """ + PlotAttentionWeightsJobV2.set_ticks( + ax, + ref_alignment=ref_alignment, + targets=alignment, + vocab=vocab, + ref_alignment_blank_idx=ref_alignment_blank_idx, + target_blank_idx=blank_idx, + draw_vertical_lines=True + ) + + # draw last horizontal line for trailing blanks + labels = alignment[alignment != blank_idx] + ax.axhline(y=len(labels) - .5, xmin=0, xmax=1, color="k", linewidth=.5) + def run(self): # load data from hdf alignment_dict = hdf.load_hdf_data(self.alignment_hdf, segment_list=self.segment_list) + ref_alignment_dict = hdf.load_hdf_data(self.ref_alignment_hdf, segment_list=self.segment_list) # load vocabulary as dictionary with open(self.json_vocab_path.get_path(), "r") as f: @@ -597,13 +645,38 @@ def run(self): # for each seq tag, plot the corresponding att weights for seq_tag in alignment_dict.keys(): alignment = alignment_dict[seq_tag] + ref_alignment = ref_alignment_dict[seq_tag] labels = alignment[alignment != self.target_blank_idx] - fig, ax = self._get_fig_ax(alignment) + dummy_matrix = np.zeros((len(labels) + 1, len(alignment))) + fig, ax = PlotAttentionWeightsJobV2._get_fig_ax(att_weights=dummy_matrix) + ax.matshow(dummy_matrix, aspect="auto", alpha=0.0) # set y ticks and labels - self._set_ticks(ax, alignment, labels, vocab, self.target_blank_idx) + self._set_ticks_alt( + ax, + alignment, + ref_alignment, + vocab, + self.target_blank_idx, + ref_alignment_blank_idx=self.ref_alignment_blank_idx + ) + PlotAttentionWeightsJobV2.plot_ctc_alignment( + ax, + alignment, + num_labels=labels.shape[0], + ctc_blank_idx=self.target_blank_idx, + plot_trailing_blanks=True + ) + # plt.gca().invert_yaxis() dirname = self.out_plot_dir.get_path() filename = os.path.join(dirname, "plot.%s" % seq_tag.replace("/", "_")) plt.savefig(filename + ".png") plt.savefig(filename + ".pdf") + + @classmethod + def hash(cls, kwargs): + if kwargs["ref_alignment_hdf"] is None: + kwargs.pop("ref_alignment_hdf") + kwargs.pop("ref_alignment_blank_idx") + return super().hash(kwargs) From 524a2ca4bfa556d4031971fa66ca61f2f1464941 Mon Sep 17 00:00:00 2001 From: Peter Vieting Date: Tue, 11 Jun 2024 15:11:03 +0200 Subject: [PATCH 169/227] ls960 pretrain: use phoneme info for mask boundaries --- .../wav2vec2/config_02_fairseq_phoneme.py | 40 +++++++++++++++++-- 1 file changed, 37 insertions(+), 3 deletions(-) diff --git a/users/vieting/experiments/librispeech/librispeech_960_pretraining/wav2vec2/config_02_fairseq_phoneme.py b/users/vieting/experiments/librispeech/librispeech_960_pretraining/wav2vec2/config_02_fairseq_phoneme.py index ff0dc5ae0..8b4cf6d01 100644 --- a/users/vieting/experiments/librispeech/librispeech_960_pretraining/wav2vec2/config_02_fairseq_phoneme.py +++ b/users/vieting/experiments/librispeech/librispeech_960_pretraining/wav2vec2/config_02_fairseq_phoneme.py @@ -63,7 +63,7 @@ def get_fairseq_root(commit="e4a2e4e93efbcbaaae52a17ae6600beb2083fb33", fairseq_ return fairseq_root -def run_fairseq_pretraining_informed(): +def run_fairseq_pretraining_negatives_other_target(): prefix_name = "experiments/librispeech/librispeech_960_pretraining/wav2vec2/" alignment = get_alignment_hdf() num_gpus = 8 @@ -82,7 +82,7 @@ def run_fairseq_pretraining_informed(): ) # run pre-training - exp_name = "monophone1" + exp_name = "monophone_negatives_other_target_v1" fairseq_args = get_fairseq_args(num_gpus=num_gpus) fairseq_args["task"]["alignment"] = alignment fairseq_args["model"]["negative_sampling_strategy"] = "other_target" @@ -95,5 +95,39 @@ def run_fairseq_pretraining_informed(): return job +def run_fairseq_pretraining_phoneme_boundary_masking(): + prefix_name = "experiments/librispeech/librispeech_960_pretraining/wav2vec2/" + alignment = get_alignment_hdf() + num_gpus = 8 + fairseq_python_exe = tk.Path( + "/home/pv653172/setups/librispeech/20230328_wav2vec2/dependencies/python_launcher.sh", + hash_overwrite="itc_python_launcher_py310_torch", + ) + fairseq_root = get_fairseq_root(fairseq_exe=fairseq_python_exe) + fairseq_training_args = dict( + save_interval=25, + max_epoch=600, + max_update=420000, + fairseq_root=fairseq_root, + fairseq_python_exe=fairseq_python_exe, + rqmt={"time": 120, "mem": 12, "cpu": 2, "gpu": num_gpus}, + ) + + # run pre-training + exp_name = "monophone_boundary_masking_v1" + fairseq_args = get_fairseq_args(num_gpus=num_gpus) + fairseq_args["task"]["alignment"] = alignment + fairseq_args["model"]["mask_strategy"] = "phoneme" + fairseq_args["model"]["mask_length"] = 1 + fairseq_root = get_fairseq_root(fairseq_exe=fairseq_python_exe, commit="b768be5b81987364d39a07d1caad2bfe1e956896") + fairseq_training_args["fairseq_root"] = fairseq_root + fairseq_config = FairseqHydraConfig(fairseq_args) + job = FairseqHydraTrainingJob(fairseq_config, **fairseq_training_args) + job.add_alias(os.path.join(prefix_name, exp_name, "pretraining")) + tk.register_output(f"{prefix_name}/{exp_name}/pretraining/scores.png", job.out_plot_se) + return job + + def py(): - run_fairseq_pretraining_informed() + run_fairseq_pretraining_negatives_other_target() + run_fairseq_pretraining_phoneme_boundary_masking() From 01b526b780a2a11c5b10d58dd51972e1ea786693 Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Fri, 14 Jun 2024 15:22:52 +0200 Subject: [PATCH 170/227] BatchRenorm initial implementation (untested) --- users/zeyer/nn_rf/batchnorm.py | 165 +++++++++++++++++++++++++++++++++ 1 file changed, 165 insertions(+) create mode 100644 users/zeyer/nn_rf/batchnorm.py diff --git a/users/zeyer/nn_rf/batchnorm.py b/users/zeyer/nn_rf/batchnorm.py new file mode 100644 index 000000000..ae92bb6dd --- /dev/null +++ b/users/zeyer/nn_rf/batchnorm.py @@ -0,0 +1,165 @@ +""" +Batch norm variations, e.g. Batch Renormalization + +https://github.com/rwth-i6/returnn/issues/1539 +""" + +from __future__ import annotations +from typing import Optional, Union, Callable +from returnn.tensor import Tensor, Dim +import returnn.frontend as rf + + +class BatchRenorm(rf.Module): + """ + Batch Renormalization. https://arxiv.org/abs/1702.03275 + + We calculate statistics over all axes except the given in_dim. + I.e. all other axes are reduced for the statistics. + + To compensate the normalization, there are learnable parameters gamma and beta + (optional, used when option `affine` is True, which is the default). + + The usual behavior depends on whether this is used in training or evaluation, + although this often configurable in other frameworks. + The usual behavior, in training:: + + # Using statistics from current batch. + mean_cur_batch, variance_cur_batch = moments(source, reduce_dims) + y = (x - mean_cur_batch) / sqrt(variance_cur_batch + epsilon) + y = gamma * y + beta + + # Updating running statistics for later use. + mean = (1 - momentum) * mean + momentum * mean_cur_batch + variance = (1 - momentum) * variance + momentum * variance_cur_batch + + The usual behavior, not in training (i.e. in evaluation):: + + # Using collected statistics. Not using statistics from current batch. + y = (x - mean) / sqrt(variance + epsilon) + y = gamma * y + beta + + """ + + def __init__( + self, + in_dim: Dim, + *, + affine: bool = True, + momentum: float = 0.1, + eps: float = 1e-3, + use_mask: Optional[bool] = None, + unbiased: bool = False, + r_max: Union[float, Callable[[BatchRenorm], float]] = 1.0, + d_max: Union[float, Callable[[BatchRenorm], float]] = 0.0, + ): + """ + :param in_dim: the feature dimension of the input + :param affine: whether to use learnable parameters gamma and beta + :param momentum: momentum for the running mean and variance + :param eps: epsilon for the variance + :param use_mask: whether to use a mask for dynamic spatial dims. + This must be specified if the input has dynamic spatial dims. + True would use the correct masking then. However, that is inconsistent to all other frameworks. + False would be consistent to all other frameworks. + :param unbiased: if True, uses unbiased variance calculation + via `Bessel correction `__ + :param r_max: clip how much we should use the running variance instead of the current batch variance + during training. + Value should be >= 1.0. + r_max=1.0 means always use the current batch variance, i.e. like standard batch norm. + r_max=inf means always use the running variance. + r_max can also be scheduled via a callable, e.g. using rf.get_run_ctx().step inside. + The original paper suggests to keep r_max=1.0 for the first 5k steps, + then linearly increase to reach r_max=3.0 at 40k steps. + :param d_max: clip how much we should use the running mean instead of the current batch mean during training. + Value should be >= 0.0. + d_max=0.0 means always use the current batch mean, i.e. like standard batch norm. + d_max=inf means always use the running mean. + d_max can also be scheduled via a callable, e.g. using rf.get_run_ctx().step inside. + The original paper suggests to keep d_max=0.0 for the first 5k steps, + then linearly increase to reach d_max=5.0 at 25k steps. + """ + super().__init__() + assert isinstance(in_dim, Dim) + self.in_dim = in_dim + self.affine = affine + self.momentum = momentum + self.eps = eps + self.use_mask = use_mask + self.unbiased = unbiased + self.r_max = r_max + self.d_max = d_max + self.running_mean = rf.Parameter([in_dim], auxiliary=True) + self.running_mean.initial = 0.0 + self.running_variance = rf.Parameter([in_dim], auxiliary=True) + self.running_variance.initial = 1.0 + self.gamma = None # type: Optional[rf.Parameter] + self.beta = None # type: Optional[rf.Parameter] + if self.affine: + self.gamma = rf.Parameter([in_dim]) + self.gamma.initial = 1.0 + self.beta = rf.Parameter([in_dim]) + self.beta.initial = 0.0 + + def __call__(self, source: Tensor) -> Tensor: + assert self.in_dim in source.dims + + if any(d.need_masking() for d in source.dims if d != self.in_dim): + if self.use_mask is None: + raise ValueError( + f"{self}: use_mask must be specified if the input {source} has any dynamic spatial dims" + ) + use_mask = self.use_mask + else: + use_mask = False # not needed. False because this potentially enables an efficient fused op. + + train_flag = rf.get_run_ctx().train_flag + d_max = self.d_max(self) if callable(self.d_max) else self.d_max + r_max = self.r_max(self) if callable(self.r_max) else self.r_max + + mean_cur_batch, variance_cur_batch = rf.cond( + train_flag, + # Only conditionally calculate the moments when needed. + lambda: rf.moments( + source, + axis=[d for d in source.dims if d != self.in_dim], + use_mask=use_mask, + correction=1 if self.unbiased else 0, + ), + # Return some dummy values. They are not used. + lambda: (self.running_mean, self.running_variance), + ) + + def _update_running_stats(): + self.running_mean.assign_add((mean_cur_batch - self.running_mean) * self.momentum) + self.running_variance.assign_add((variance_cur_batch - self.running_variance) * self.momentum) + + rf.cond(train_flag, _update_running_stats, lambda: None) + + def _train_mean_std_dev(): + inv_std_dev_ = rf.rsqrt(variance_cur_batch + self.eps) + if r_max > 1: + inv_std_dev_ *= rf.clip_by_value( + rf.rsqrt(self.running_variance + self.eps) + * rf.sqrt(rf.stop_gradient(variance_cur_batch) + self.eps), + 1 / r_max, + r_max, + ) + mean_ = mean_cur_batch + if d_max > 0: + limit = d_max * rf.reciprocal(rf.stop_gradient(inv_std_dev_)) + mean_ += rf.clip_by_value(self.running_mean - rf.stop_gradient(mean_cur_batch), -limit, limit) + return mean_, inv_std_dev_ + + mean, inv_std_dev = rf.cond( + train_flag, _train_mean_std_dev, lambda: (self.running_mean, rf.rsqrt(self.running_variance + self.eps)) + ) + + m = inv_std_dev + if self.gamma is not None: + m *= self.gamma + bn = (source - mean) * m + if self.beta is not None: + bn += self.beta + return bn From f23b1177d41c4f5ddc03a38f9bf94e8e2da0b346 Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Fri, 14 Jun 2024 22:45:14 +0200 Subject: [PATCH 171/227] test_piecewise_linear --- users/zeyer/lr_schedules/piecewise_linear.py | 28 ++++++++++++++++++++ 1 file changed, 28 insertions(+) diff --git a/users/zeyer/lr_schedules/piecewise_linear.py b/users/zeyer/lr_schedules/piecewise_linear.py index 68672702c..f76b78c89 100644 --- a/users/zeyer/lr_schedules/piecewise_linear.py +++ b/users/zeyer/lr_schedules/piecewise_linear.py @@ -25,3 +25,31 @@ def dyn_lr_piecewise_linear(*, global_train_step: int, learning_rate: float, **_ last_step = step return learning_rate * lrs[-1] + + +def test_piecewise_linear(): + from numpy.testing import assert_almost_equal, assert_equal + + def _f(x, xs, ys): + assert isinstance(x, int) + assert len(xs) + 1 == len(ys) + last_step = 0 + for i, step in enumerate(xs): + assert isinstance(step, int) + assert step > last_step + assert x >= last_step + if x < step: + factor = (x + 1 - last_step) / (step - last_step) + return ys[i + 1] * factor + ys[i] * (1 - factor) + last_step = step + + return ys[-1] + + assert_almost_equal(_f(0, [10, 20], [0, 1, 0.5]), 0.1) + assert_almost_equal(_f(5, [10, 20], [0, 1, 0.5]), 0.6) + assert_equal(_f(9, [10, 20], [0, 1, 0.5]), 1) + assert_almost_equal(_f(10, [10, 20], [0, 1, 0.5]), 0.95) + assert_almost_equal(_f(11, [10, 20], [0, 1, 0.5]), 0.90) + assert_almost_equal(_f(15, [10, 20], [0, 1, 0.5]), 0.70) + assert_almost_equal(_f(19, [10, 20], [0, 1, 0.5]), 0.5) + assert_equal(_f(20, [10, 20], [0, 1, 0.5]), 0.5) From 53cbaecbf7e6c740dcc199e3f0dcdf0ec2dd18df Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Fri, 14 Jun 2024 22:47:02 +0200 Subject: [PATCH 172/227] test_piecewise_linear use dyn_lr_piecewise_linear --- users/zeyer/lr_schedules/piecewise_linear.py | 16 +++------------- 1 file changed, 3 insertions(+), 13 deletions(-) diff --git a/users/zeyer/lr_schedules/piecewise_linear.py b/users/zeyer/lr_schedules/piecewise_linear.py index f76b78c89..2c9a440c9 100644 --- a/users/zeyer/lr_schedules/piecewise_linear.py +++ b/users/zeyer/lr_schedules/piecewise_linear.py @@ -28,22 +28,12 @@ def dyn_lr_piecewise_linear(*, global_train_step: int, learning_rate: float, **_ def test_piecewise_linear(): + from returnn.config import global_config_ctx, Config from numpy.testing import assert_almost_equal, assert_equal def _f(x, xs, ys): - assert isinstance(x, int) - assert len(xs) + 1 == len(ys) - last_step = 0 - for i, step in enumerate(xs): - assert isinstance(step, int) - assert step > last_step - assert x >= last_step - if x < step: - factor = (x + 1 - last_step) / (step - last_step) - return ys[i + 1] * factor + ys[i] * (1 - factor) - last_step = step - - return ys[-1] + with global_config_ctx(Config({"learning_rate_piecewise_steps": xs, "learning_rate_piecewise_values": ys})): + return dyn_lr_piecewise_linear(global_train_step=x, learning_rate=1.0) assert_almost_equal(_f(0, [10, 20], [0, 1, 0.5]), 0.1) assert_almost_equal(_f(5, [10, 20], [0, 1, 0.5]), 0.6) From 04894c96756b28c43c8e9d89511dc1cf2199103a Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Fri, 14 Jun 2024 23:09:58 +0200 Subject: [PATCH 173/227] dyn_lr_piecewise_linear use RETURNN PiecewiseLinear --- users/zeyer/lr_schedules/piecewise_linear.py | 28 +++++++++----------- 1 file changed, 13 insertions(+), 15 deletions(-) diff --git a/users/zeyer/lr_schedules/piecewise_linear.py b/users/zeyer/lr_schedules/piecewise_linear.py index 2c9a440c9..d418939ac 100644 --- a/users/zeyer/lr_schedules/piecewise_linear.py +++ b/users/zeyer/lr_schedules/piecewise_linear.py @@ -8,23 +8,21 @@ def dyn_lr_piecewise_linear(*, global_train_step: int, learning_rate: float, **_ Piecewise linear """ from returnn.config import get_global_config + from returnn.util.math import PiecewiseLinear config = get_global_config() - - steps = config.int_list("learning_rate_piecewise_steps") - lrs = config.float_list("learning_rate_piecewise_values") - assert len(steps) + 1 == len(lrs) - - last_step = 0 - for i, step in enumerate(steps): - assert step > last_step - assert global_train_step >= last_step - if global_train_step < step: - factor = (global_train_step + 1 - last_step) / (step - last_step) - return learning_rate * (lrs[i + 1] * factor + lrs[i] * (1 - factor)) - last_step = step - - return learning_rate * lrs[-1] + f = config.typed_dict.get("_learning_rate_piecewise_cache") + if f is None: + steps = config.int_list("learning_rate_piecewise_steps") + lrs = config.float_list("learning_rate_piecewise_values") + assert len(steps) + 1 == len(lrs) + last_step = 0 + for i, step in enumerate(steps): + assert step > last_step + last_step = step + f = PiecewiseLinear(dict(zip([0] + list(steps), lrs))) + config.typed_dict["_learning_rate_piecewise_cache"] = f + return f(global_train_step + 1) * learning_rate def test_piecewise_linear(): From 37f0d3d6eff25f39435dd87d9caaa5f34741022e Mon Sep 17 00:00:00 2001 From: vieting <45091115+vieting@users.noreply.github.com> Date: Mon, 17 Jun 2024 11:25:17 +0200 Subject: [PATCH 174/227] DeleteLemmataFromLexiconJob (#225) --- users/berger/recipe/lexicon/modification.py | 30 +++++++++++++++++++++ 1 file changed, 30 insertions(+) diff --git a/users/berger/recipe/lexicon/modification.py b/users/berger/recipe/lexicon/modification.py index fae2d7c4e..f2ab83ec3 100644 --- a/users/berger/recipe/lexicon/modification.py +++ b/users/berger/recipe/lexicon/modification.py @@ -1,3 +1,4 @@ +from typing import List from sisyphus import Job, Task, tk from i6_core.lib.lexicon import Lexicon, Lemma @@ -101,6 +102,35 @@ def run(self): write_xml(self.out_lexicon.get_path(), out_lexicon.to_xml()) +class DeleteLemmataFromLexiconJob(Job): + """ + Remove lemmata from a bliss lexicon based on their orth + """ + + def __init__(self, bliss_lexicon: tk.Path, orths: List[str]): + self.bliss_lexicon = bliss_lexicon + self.orths = orths + + self.out_lexicon = self.output_path("lexicon.xml") + + def tasks(self): + yield Task("run", mini_task=True) + + def run(self): + in_lexicon = Lexicon() + in_lexicon.load(self.bliss_lexicon.get_path()) + + out_lexicon = Lexicon() + out_lexicon.phonemes = in_lexicon.phonemes + out_lexicon.lemmata = [] + + for lemma in in_lexicon.lemmata: + if not any(orth in lemma.orth for orth in self.orths): + out_lexicon.lemmata.append(lemma) + + write_xml(self.out_lexicon.get_path(), out_lexicon.to_xml()) + + class EnsureSilenceFirstJob(Job): """ Moves the silence phoneme (defined via lemma) to the beginning in the inventory for RASR CTC/Transducer compatibility From 8fc42f84ec61b6e2e5ac3f735e33aae2b6d4f3db Mon Sep 17 00:00:00 2001 From: Peter Vieting Date: Mon, 17 Jun 2024 14:00:42 +0200 Subject: [PATCH 175/227] ls960 pretrain: phoneme mask and other targets --- .../wav2vec2/config_02_fairseq_phoneme.py | 35 +++++++++++++++++++ 1 file changed, 35 insertions(+) diff --git a/users/vieting/experiments/librispeech/librispeech_960_pretraining/wav2vec2/config_02_fairseq_phoneme.py b/users/vieting/experiments/librispeech/librispeech_960_pretraining/wav2vec2/config_02_fairseq_phoneme.py index 8b4cf6d01..79bf27e47 100644 --- a/users/vieting/experiments/librispeech/librispeech_960_pretraining/wav2vec2/config_02_fairseq_phoneme.py +++ b/users/vieting/experiments/librispeech/librispeech_960_pretraining/wav2vec2/config_02_fairseq_phoneme.py @@ -128,6 +128,41 @@ def run_fairseq_pretraining_phoneme_boundary_masking(): return job +def run_fairseq_pretraining_phoneme_negatives_other_target_boundary_masking(): + prefix_name = "experiments/librispeech/librispeech_960_pretraining/wav2vec2/" + alignment = get_alignment_hdf() + num_gpus = 8 + fairseq_python_exe = tk.Path( + "/home/pv653172/setups/librispeech/20230328_wav2vec2/dependencies/python_launcher.sh", + hash_overwrite="itc_python_launcher_py310_torch", + ) + fairseq_root = get_fairseq_root(fairseq_exe=fairseq_python_exe) + fairseq_training_args = dict( + save_interval=25, + max_epoch=600, + max_update=420000, + fairseq_root=fairseq_root, + fairseq_python_exe=fairseq_python_exe, + rqmt={"time": 120, "mem": 12, "cpu": 2, "gpu": num_gpus}, + ) + + # run pre-training + exp_name = "monophone_negatives_other_target_boundary_masking_v1" + fairseq_args = get_fairseq_args(num_gpus=num_gpus) + fairseq_args["task"]["alignment"] = alignment + fairseq_args["model"]["negative_sampling_strategy"] = "other_target" + fairseq_args["model"]["mask_strategy"] = "phoneme" + fairseq_args["model"]["mask_length"] = 1 + fairseq_root = get_fairseq_root(fairseq_exe=fairseq_python_exe, commit="b768be5b81987364d39a07d1caad2bfe1e956896") + fairseq_training_args["fairseq_root"] = fairseq_root + fairseq_config = FairseqHydraConfig(fairseq_args) + job = FairseqHydraTrainingJob(fairseq_config, **fairseq_training_args) + job.add_alias(os.path.join(prefix_name, exp_name, "pretraining")) + tk.register_output(f"{prefix_name}/{exp_name}/pretraining/scores.png", job.out_plot_se) + return job + + def py(): run_fairseq_pretraining_negatives_other_target() run_fairseq_pretraining_phoneme_boundary_masking() + run_fairseq_pretraining_phoneme_negatives_other_target_boundary_masking() From 3b5959b15ebc837d6a14046ca2db7fff9cb3ae50 Mon Sep 17 00:00:00 2001 From: Peter Vieting Date: Mon, 17 Jun 2024 17:32:25 +0200 Subject: [PATCH 176/227] ls960 pretrain: update num epochs --- .../wav2vec2/config_01_fairseq_main.py | 4 ++-- .../wav2vec2/config_02_fairseq_phoneme.py | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/users/vieting/experiments/librispeech/librispeech_960_pretraining/wav2vec2/config_01_fairseq_main.py b/users/vieting/experiments/librispeech/librispeech_960_pretraining/wav2vec2/config_01_fairseq_main.py index d1c67fa69..4313042b7 100755 --- a/users/vieting/experiments/librispeech/librispeech_960_pretraining/wav2vec2/config_01_fairseq_main.py +++ b/users/vieting/experiments/librispeech/librispeech_960_pretraining/wav2vec2/config_01_fairseq_main.py @@ -146,8 +146,8 @@ def run_fairseq_pretraining(): job = FairseqHydraTrainingJob( fairseq_config, save_interval=25, - max_epoch=300, - max_update=400000, + max_epoch=600, + max_update=420000, fairseq_root=fairseq_root, fairseq_python_exe=fairseq_exe, rqmt={"time": 120, "mem": 12, "cpu": 2, "gpu": num_gpus}, diff --git a/users/vieting/experiments/librispeech/librispeech_960_pretraining/wav2vec2/config_02_fairseq_phoneme.py b/users/vieting/experiments/librispeech/librispeech_960_pretraining/wav2vec2/config_02_fairseq_phoneme.py index 79bf27e47..53aef623a 100644 --- a/users/vieting/experiments/librispeech/librispeech_960_pretraining/wav2vec2/config_02_fairseq_phoneme.py +++ b/users/vieting/experiments/librispeech/librispeech_960_pretraining/wav2vec2/config_02_fairseq_phoneme.py @@ -74,8 +74,8 @@ def run_fairseq_pretraining_negatives_other_target(): fairseq_root = get_fairseq_root(fairseq_exe=fairseq_python_exe) fairseq_training_args = dict( save_interval=25, - max_epoch=300, - max_update=400000, + max_epoch=600, + max_update=420000, fairseq_root=fairseq_root, fairseq_python_exe=fairseq_python_exe, rqmt={"time": 120, "mem": 12, "cpu": 2, "gpu": num_gpus}, From 8a2a9bb99f98b72a0ec48949a78154f608ac7e65 Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Tue, 18 Jun 2024 00:50:50 +0200 Subject: [PATCH 177/227] better --- users/zeineldeen/experiments/canary_aed/nemo/run_eval.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/users/zeineldeen/experiments/canary_aed/nemo/run_eval.py b/users/zeineldeen/experiments/canary_aed/nemo/run_eval.py index 3d65ae83f..f6a62aaf3 100644 --- a/users/zeineldeen/experiments/canary_aed/nemo/run_eval.py +++ b/users/zeineldeen/experiments/canary_aed/nemo/run_eval.py @@ -85,9 +85,11 @@ def buffer_audio_and_transcribe( filepaths = write_audio(buffer, cache_prefix) if pnc is not None: - transcriptions = model.transcribe(filepaths, batch_size=batch_size, pnc=False, verbose=False) + transcriptions = model.transcribe( + filepaths, batch_size=batch_size, pnc=False, verbose=False, num_workers=4 + ) else: - transcriptions = model.transcribe(filepaths, batch_size=batch_size, verbose=False) + transcriptions = model.transcribe(filepaths, batch_size=batch_size, verbose=False, num_workers=4) # if transcriptions form a tuple (from RNNT), extract just "best" hypothesis if type(transcriptions) == tuple and len(transcriptions) == 2: transcriptions = transcriptions[0] From 471199541560cbfd843ebb6adfd2d666ca1a6cfd Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Tue, 18 Jun 2024 13:02:52 +0200 Subject: [PATCH 178/227] first version of beam search --- .../canary_aed/nemo/run_eval_beam_search.py | 420 ++++++++++++++++++ 1 file changed, 420 insertions(+) create mode 100644 users/zeineldeen/experiments/canary_aed/nemo/run_eval_beam_search.py diff --git a/users/zeineldeen/experiments/canary_aed/nemo/run_eval_beam_search.py b/users/zeineldeen/experiments/canary_aed/nemo/run_eval_beam_search.py new file mode 100644 index 000000000..1116d62bd --- /dev/null +++ b/users/zeineldeen/experiments/canary_aed/nemo/run_eval_beam_search.py @@ -0,0 +1,420 @@ +""" +Adapted from here: https://github.com/huggingface/open_asr_leaderboard/blob/5c03c1f85a84ab7a991dcc1b3f14905ec6d632c9/nemo_asr/run_eval.py +""" +from __future__ import annotations + +import argparse + +import os +import sys +import shutil + +from typing import Any, Tuple, List + +import tree + +import torch + +import soundfile + +from tqdm import tqdm +from normalizer import data_utils + +from datasets import load_from_disk + +from nemo.collections.asr.models import ASRModel +from nemo.collections.asr.models.aed_multitask_models import MultiTaskTranscriptionConfig +from nemo.collections.asr.parts.mixins.transcription import GenericTranscriptionType +from nemo.collections.common.parts.transformer_utils import mask_padded_tokens + +sys.path.insert(0, "/u/zeineldeen/setups/ubuntu_22_setups/2024-06-07--canary-aed/recipe") + +from i6_experiments.users.zeyer.decoding.beam_search_torch.interface import ( + LabelScorerIntf, + StateObjIgnored, +) +from i6_experiments.users.zeyer.decoding.beam_search_torch.beam_search_v5 import ( + beam_search_v5, + BeamSearchOptsV5, +) + +DATA_CACHE_DIR = "/var/tmp/audio_cache" + + +def compute_wer(predictions, references): + from jiwer import compute_measures + + incorrect = 0 + total = 0 + for prediction, reference in zip(predictions, references): + measures = compute_measures(reference, prediction) + incorrect += measures["substitutions"] + measures["deletions"] + measures["insertions"] + total += measures["substitutions"] + measures["deletions"] + measures["hits"] + return incorrect / total + + +def dataset_iterator(dataset): + for i, item in enumerate(dataset): + yield { + **item["audio"], + "reference": item["norm_text"], + "audio_filename": f"file_{i}", + "sample_rate": 16_000, + "sample_id": i, + } + + +def write_audio(buffer, cache_prefix) -> list: + cache_dir = os.path.join(DATA_CACHE_DIR, cache_prefix) + + if os.path.exists(cache_dir): + shutil.rmtree(cache_dir, ignore_errors=True) + + os.makedirs(cache_dir) + + data_paths = [] + for idx, data in enumerate(buffer): + fn = os.path.basename(data["audio_filename"]) + fn = os.path.splitext(fn)[0] + path = os.path.join(cache_dir, f"{idx}_{fn}.wav") + data_paths.append(path) + + soundfile.write(path, data["array"], samplerate=data["sample_rate"]) + + return data_paths + + +def pack_results(results: list, buffer, transcriptions): + for sample, transcript in zip(buffer, transcriptions): + result = {"reference": sample["reference"], "pred_text": transcript} + results.append(result) + return results + + +def get_our_canary_label_scorer( + model: ASRModel, enc: torch.Tensor, enc_input_mask: torch.Tensor, pad_id: int, bos_prefix_seq: List[int] +) -> LabelScorerIntf: + """ + Creates a CanaryLabelScorer object that is used in the beam search implementation. + + :param model: nemo ASRModel object + :param enc: [B,T] + :param enc_input_mask: [B,T] + :param pad_id: + :param bos_prefix_seq: + """ + + trafo_decoder_module = model.transf_decoder # type: torch.nn.Module + log_softmax_module = model.log_softmax # type: torch.nn.Module + + class CanaryLabelScorer(LabelScorerIntf): + def get_initial_state(self, *, batch_size: int, device: torch.device) -> Any: + return { + "step": StateObjIgnored(0), + "prefix_input": torch.tile( + torch.tensor(bos_prefix_seq, device=device)[None, :], [batch_size, 1] + ), # [Batch,InputSeqLen] + "model_state": None, + } + + def score_and_update_state( + self, + *, + prev_state: Any, + prev_label: torch.Tensor, + ) -> Tuple[torch.Tensor, Any]: + """ + :param prev_state: state of the scorer (decoder). any nested structure. + all tensors are expected to have shape [Batch, Beam, ...]. + :param prev_label: shape [Batch, Beam] -> index in [0...Label-1] + :return: (scores, state). + scores: shape [Batch, Beam, Label], log-prob-like scores. + Broadcasting is allowed for any of the dims (e.g. think of :class:`LengthRewardScorer`). + state: all tensors are expected to have shape [Batch, Beam, ...]. + """ + batch_size, beam_size = prev_label.shape + + # Convert all [batch,beam,...] tensors to [batch*beam,...]. + def _map(x): + if x is None: + return None + assert isinstance(x, torch.Tensor) and x.shape[:2] == (batch_size, beam_size) + return x.flatten(0, 1) + + prev_model_state = tree.map_structure(_map, prev_state["model_state"]) + + input = prev_state["prefix_input"] # [batch*beam,in_seq_len] or None + if input is None: + input = prev_label.flatten(0, 1)[:, None] # [batch*beam,1] + + # start_pos is used for the positional encoding added to the embeddings + dec_embed = trafo_decoder_module.embedding.forward( + input, start_pos=prev_state["step"].content + ) # [batch*beam,in_seq_len|1,D] + dec_input_mask = mask_padded_tokens(input, pad_id=pad_id).float() + + import pdb + + pdb.set_trace() + + # decoder_mems_list is a list of size num_layers that cache output activations of shape + # [batch*beam,history,D] + decoder_mems_list = trafo_decoder_module.decoder.forward( + decoder_states=dec_embed, + decoder_mask=dec_input_mask, + encoder_states=enc, + encoder_mask=enc_input_mask, + decoder_mems_list=prev_model_state, + return_mems=True, + return_mems_as_list=True, + ) + + # decoder_mems_list[-1][:, -1:] is the output of the last layer at the current decoding step position + log_probs = log_softmax_module.forward(hidden_states=decoder_mems_list[-1][:, -1:]) # [batch*beam,1,V] + + def _map(x): + assert isinstance(x, torch.Tensor) and x.shape[:1] == (batch_size * beam_size,) + return x.unflatten(0, (batch_size, beam_size)) + + log_probs = log_probs.squeeze(1) # [batch*beam,V] + log_probs = _map(log_probs) # [batch,beam,V] + + # if input is not None: + # for j in range(len(decoder_mems_list)): + # decoder_mems_list[j] = decoder_mems_list[j].repeat(beam_size, 1, 1) + + def _map(x): + assert isinstance(x, torch.Tensor) and x.shape[:1] == (batch_size * beam_size,) + return x.unflatten(0, (batch_size, beam_size)) + + decoder_mems_list = tree.map_structure(_map, decoder_mems_list) + + return log_probs, { + "step": StateObjIgnored(prev_state["step"].content + input.size(1)), + "prefix_input": None, + "model_state": decoder_mems_list, + } + + return CanaryLabelScorer() + + +# TODO: make this configurable +beam_search_v5_opts = BeamSearchOptsV5( + beam_size=4, + bos_label=3, + eos_label=2, + num_labels=4128, + length_normalization_exponent=1, + pruning_threshold=0.0, + adaptive_pruning=False, +) + +# debug with batch size 3 and beam size 4: +# running their beam search: +# +# (Pdb) decoder_input_ids +# tensor([[ 3, 4, 8, 4, 10], +# [ 3, 4, 8, 4, 10], +# [ 3, 4, 8, 4, 10]]) +# [batch*1,out_len|5] +# +# (Pdb) decoder_hidden_states.shape +# torch.Size([3, 5, 1024]) # [batch*1,out_len|5,D] +# +# (Pdb) decoder_mems_list[0].shape +# torch.Size([3, 5, 1024]) # [batch*1,out_len|5,D] +# +# (Pdb) log_probs.shape +# torch.Size([3, 1, 4128]) # [batch*1,1,V] +# +# step 2: +# +# (Pdb) decoder_input_ids.shape +# torch.Size([12, 1]) # [batch*beam,out_len|1] +# +# (Pdb) decoder_hidden_states.shape +# torch.Size([12, 1, 1024]) +# +# prev_state: +# (Pdb) decoder_mems_list[0].shape +# torch.Size([12, 5, 1024]) + + +def _transcribe_output_processing_our_beam_search( + outputs, trcfg: MultiTaskTranscriptionConfig +) -> GenericTranscriptionType: + # outputs are returned from `_transcribe_forward` function call + enc_states = outputs.pop("encoder_states") + enc_lens = outputs.pop("encoded_lengths") + enc_mask = outputs.pop("encoder_mask") + + canary_label_scorer = get_our_canary_label_scorer( + model=asr_model, enc=enc_states, enc_input_mask=enc_mask, pad_id=1, bos_prefix_seq=[3, 4, 8, 4, 10] + ) + + seq_targets, _, out_seq_len = beam_search_v5( + canary_label_scorer, + batch_size=enc_states.size(0), + max_seq_len=enc_lens, + device=enc_states.device, + opts=beam_search_v5_opts, + ) # [B,Beam,L] + + import pdb + + pdb.set_trace() + + best_hyp_int = seq_targets[:, 0, : out_seq_len[:, 0]] # [B,1,L] + # TODO: convert hyp to text using model.tokenizer + # TODO: filter out EOS? + return best_hyp_int + + +def buffer_audio_and_transcribe( + model: ASRModel, dataset, batch_size: int, pnc: bool, cache_prefix: str, verbose: bool = True +): + buffer = [] + results = [] + for sample in tqdm(dataset_iterator(dataset), desc="Evaluating: Sample id", unit="", disable=not verbose): + buffer.append(sample) + + if len(buffer) == batch_size: + filepaths = write_audio(buffer, cache_prefix) + + if pnc is not None: + transcriptions = model.transcribe( + filepaths, batch_size=batch_size, pnc=False, verbose=False, num_workers=4 + ) + else: + transcriptions = model.transcribe(filepaths, batch_size=batch_size, verbose=False, num_workers=4) + + # if transcriptions form a tuple (from RNNT), extract just "best" hypothesis + if type(transcriptions) == tuple and len(transcriptions) == 2: + transcriptions = transcriptions[0] + results = pack_results(results, buffer, transcriptions) + buffer.clear() + + if len(buffer) > 0: + filepaths = write_audio(buffer, cache_prefix) + if pnc is not None: + transcriptions = model.transcribe(filepaths, batch_size=batch_size, pnc=False, verbose=False) + else: + transcriptions = model.transcribe(filepaths, batch_size=batch_size, verbose=False) + # if transcriptions form a tuple (from RNNT), extract just "best" hypothesis + if type(transcriptions) == tuple and len(transcriptions) == 2: + transcriptions = transcriptions[0] + results = pack_results(results, buffer, transcriptions) + buffer.clear() + + # Delete temp cache dir + if os.path.exists(DATA_CACHE_DIR): + shutil.rmtree(DATA_CACHE_DIR) + + return results + + +def main(args): + if args.device >= 0: + device = torch.device(f"cuda:{args.device}") + else: + device = torch.device("cpu") + + global asr_model + asr_model = ASRModel.restore_from(args.model_path, map_location=device) + asr_model.freeze() + + # hook our beam search implementation + asr_model._transcribe_output_processing = _transcribe_output_processing_our_beam_search + + dataset = load_from_disk(args.dataset_path) + + if args.max_eval_samples is not None and args.max_eval_samples > 0: + print(f"Subsampling dataset to first {args.max_eval_samples} samples !") + dataset = dataset.take(args.max_eval_samples) + + dataset = data_utils.prepare_data(dataset) + + predictions = [] + references = [] + + # run streamed inference + cache_prefix = ( + f"{args.model_id.replace('/', '-')}-{args.dataset_path.replace('/', '')}-" + f"{args.dataset.replace('/', '-')}-{args.split}" + ) + results = buffer_audio_and_transcribe(asr_model, dataset, args.batch_size, args.pnc, cache_prefix, verbose=True) + for sample in results: + predictions.append(data_utils.normalizer(sample["pred_text"])) + references.append(sample["reference"]) + + # Write manifest results to args.manifest_path. This required modification in normalizer/eval_utils.py script + manifest_path = data_utils.write_manifest( + args.manifest_path, references, predictions, args.model_id, args.dataset_path, args.dataset, args.split + ) + print("Results saved at path:", os.path.abspath(manifest_path)) + + wer = compute_wer(references=references, predictions=predictions) + wer = round(100 * wer, 2) + + print("WER:", wer, "%") + + if args.wer_out_path: + with open(args.wer_out_path, "w") as f: + f.write(f"{wer}\n") + print(f"Wrote WER (%) to {args.wer_out_path}") + + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + + parser.add_argument("--model_id", type=str, required=True, help="Model ID.") + + parser.add_argument( + "--model_path", + type=str, + required=True, + help="Path to nemo model.", + ) + + parser.add_argument("--dataset_path", type=str, required=True, help="Dataset path.") + parser.add_argument("--dataset", type=str, required=True, help="Dataset name.") + parser.add_argument("--split", type=str, required=True, help="Dataset split.") + + parser.add_argument("--manifest_path", type=str, required=True, help="Path to save the search output.") + + parser.add_argument("--wer_out_path", type=str, default=None, help="Path to save the WER output.") + + parser.add_argument( + "--device", + type=int, + default=-1, + help="The device to run the pipeline on. -1 for CPU (default), 0 for the first GPU and so on.", + ) + parser.add_argument( + "--batch_size", + type=int, + default=32, + help="Number of samples to go through each streamed batch.", + ) + parser.add_argument( + "--max_eval_samples", + type=int, + default=None, + help="Number of samples to be evaluated. Put a lower number e.g. 64 for testing this script.", + ) + parser.add_argument( + "--pnc", + type=bool, + default=None, + help="flag to indicate inferene in pnc mode for models that support punctuation and capitalization", + ) + parser.add_argument( + "--no-streaming", + dest="streaming", + action="store_false", + help="Choose whether you'd like to download the entire dataset or stream it during the evaluation.", + ) + args = parser.parse_args() + parser.set_defaults(streaming=True) + + main(args) From 681fffe01ea17d46f4277a9104b96346d0c32e89 Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Tue, 18 Jun 2024 13:38:44 +0200 Subject: [PATCH 179/227] fix --- .../canary_aed/nemo/run_eval_beam_search.py | 53 ++++--------------- 1 file changed, 11 insertions(+), 42 deletions(-) diff --git a/users/zeineldeen/experiments/canary_aed/nemo/run_eval_beam_search.py b/users/zeineldeen/experiments/canary_aed/nemo/run_eval_beam_search.py index 1116d62bd..a43f9a30b 100644 --- a/users/zeineldeen/experiments/canary_aed/nemo/run_eval_beam_search.py +++ b/users/zeineldeen/experiments/canary_aed/nemo/run_eval_beam_search.py @@ -153,10 +153,6 @@ def _map(x): ) # [batch*beam,in_seq_len|1,D] dec_input_mask = mask_padded_tokens(input, pad_id=pad_id).float() - import pdb - - pdb.set_trace() - # decoder_mems_list is a list of size num_layers that cache output activations of shape # [batch*beam,history,D] decoder_mems_list = trafo_decoder_module.decoder.forward( @@ -179,10 +175,6 @@ def _map(x): log_probs = log_probs.squeeze(1) # [batch*beam,V] log_probs = _map(log_probs) # [batch,beam,V] - # if input is not None: - # for j in range(len(decoder_mems_list)): - # decoder_mems_list[j] = decoder_mems_list[j].repeat(beam_size, 1, 1) - def _map(x): assert isinstance(x, torch.Tensor) and x.shape[:1] == (batch_size * beam_size,) return x.unflatten(0, (batch_size, beam_size)) @@ -209,36 +201,6 @@ def _map(x): adaptive_pruning=False, ) -# debug with batch size 3 and beam size 4: -# running their beam search: -# -# (Pdb) decoder_input_ids -# tensor([[ 3, 4, 8, 4, 10], -# [ 3, 4, 8, 4, 10], -# [ 3, 4, 8, 4, 10]]) -# [batch*1,out_len|5] -# -# (Pdb) decoder_hidden_states.shape -# torch.Size([3, 5, 1024]) # [batch*1,out_len|5,D] -# -# (Pdb) decoder_mems_list[0].shape -# torch.Size([3, 5, 1024]) # [batch*1,out_len|5,D] -# -# (Pdb) log_probs.shape -# torch.Size([3, 1, 4128]) # [batch*1,1,V] -# -# step 2: -# -# (Pdb) decoder_input_ids.shape -# torch.Size([12, 1]) # [batch*beam,out_len|1] -# -# (Pdb) decoder_hidden_states.shape -# torch.Size([12, 1, 1024]) -# -# prev_state: -# (Pdb) decoder_mems_list[0].shape -# torch.Size([12, 5, 1024]) - def _transcribe_output_processing_our_beam_search( outputs, trcfg: MultiTaskTranscriptionConfig @@ -264,10 +226,13 @@ def _transcribe_output_processing_our_beam_search( pdb.set_trace() - best_hyp_int = seq_targets[:, 0, : out_seq_len[:, 0]] # [B,1,L] - # TODO: convert hyp to text using model.tokenizer - # TODO: filter out EOS? - return best_hyp_int + best_hyps = [] + for i in range(seq_targets.shape[0]): + # TODO: convert hyp to text using model.tokenizer + # TODO: filter out EOS? + best_hyp_int = seq_targets[i, 0, : out_seq_len[i, 0]] # [B,1,L] + best_hyps.append(best_hyp_int) + return best_hyps def buffer_audio_and_transcribe( @@ -314,6 +279,10 @@ def buffer_audio_and_transcribe( def main(args): + import better_exchook + + better_exchook.install() + if args.device >= 0: device = torch.device(f"cuda:{args.device}") else: From 0a00b4209d9fa39658e2429ebe8ae30c6ad71b89 Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Tue, 18 Jun 2024 11:46:36 +0000 Subject: [PATCH 180/227] fix enc shape --- .../experiments/canary_aed/nemo/run_eval_beam_search.py | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/users/zeineldeen/experiments/canary_aed/nemo/run_eval_beam_search.py b/users/zeineldeen/experiments/canary_aed/nemo/run_eval_beam_search.py index a43f9a30b..ef431883c 100644 --- a/users/zeineldeen/experiments/canary_aed/nemo/run_eval_beam_search.py +++ b/users/zeineldeen/experiments/canary_aed/nemo/run_eval_beam_search.py @@ -153,13 +153,17 @@ def _map(x): ) # [batch*beam,in_seq_len|1,D] dec_input_mask = mask_padded_tokens(input, pad_id=pad_id).float() + _, enc_len, enc_dim = enc.size() + enc_input_mask_ = enc_input_mask.repeat(1, beam_size).view(-1, enc_len) + enc_ = enc.repeat(1, beam_size, 1).view(-1, enc_len, enc_dim) + # decoder_mems_list is a list of size num_layers that cache output activations of shape # [batch*beam,history,D] decoder_mems_list = trafo_decoder_module.decoder.forward( decoder_states=dec_embed, decoder_mask=dec_input_mask, - encoder_states=enc, - encoder_mask=enc_input_mask, + encoder_states=enc_, + encoder_mask=enc_input_mask_, decoder_mems_list=prev_model_state, return_mems=True, return_mems_as_list=True, From 5463d1194ae9a596ac19542934886429a1269325 Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Tue, 18 Jun 2024 12:17:20 +0000 Subject: [PATCH 181/227] use expand instead of repeat for efficiency --- .../experiments/canary_aed/nemo/run_eval_beam_search.py | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-) diff --git a/users/zeineldeen/experiments/canary_aed/nemo/run_eval_beam_search.py b/users/zeineldeen/experiments/canary_aed/nemo/run_eval_beam_search.py index ef431883c..767c52503 100644 --- a/users/zeineldeen/experiments/canary_aed/nemo/run_eval_beam_search.py +++ b/users/zeineldeen/experiments/canary_aed/nemo/run_eval_beam_search.py @@ -154,8 +154,8 @@ def _map(x): dec_input_mask = mask_padded_tokens(input, pad_id=pad_id).float() _, enc_len, enc_dim = enc.size() - enc_input_mask_ = enc_input_mask.repeat(1, beam_size).view(-1, enc_len) - enc_ = enc.repeat(1, beam_size, 1).view(-1, enc_len, enc_dim) + enc_input_mask_ = enc_input_mask.unsqueeze(1).expand(-1, beam_size, -1).contiguous().view(-1, enc_len) + enc_ = enc.unsqueeze(1).expand(-1, beam_size, -1, -1).contiguous().view(-1, enc_len, enc_dim) # decoder_mems_list is a list of size num_layers that cache output activations of shape # [batch*beam,history,D] @@ -226,10 +226,6 @@ def _transcribe_output_processing_our_beam_search( opts=beam_search_v5_opts, ) # [B,Beam,L] - import pdb - - pdb.set_trace() - best_hyps = [] for i in range(seq_targets.shape[0]): # TODO: convert hyp to text using model.tokenizer From 8a071b29ca42310b961d29cd285f9c84ec4a4132 Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Tue, 18 Jun 2024 12:30:09 +0000 Subject: [PATCH 182/227] better --- .../canary_aed/nemo/run_eval_beam_search.py | 43 +++++++++++-------- 1 file changed, 26 insertions(+), 17 deletions(-) diff --git a/users/zeineldeen/experiments/canary_aed/nemo/run_eval_beam_search.py b/users/zeineldeen/experiments/canary_aed/nemo/run_eval_beam_search.py index 767c52503..86fae43cd 100644 --- a/users/zeineldeen/experiments/canary_aed/nemo/run_eval_beam_search.py +++ b/users/zeineldeen/experiments/canary_aed/nemo/run_eval_beam_search.py @@ -92,7 +92,7 @@ def pack_results(results: list, buffer, transcriptions): def get_our_canary_label_scorer( - model: ASRModel, enc: torch.Tensor, enc_input_mask: torch.Tensor, pad_id: int, bos_prefix_seq: List[int] + model: ASRModel, enc: torch.Tensor, enc_input_mask: torch.Tensor, pad_id: int, bos_prefix_seq: torch.Tensor ) -> LabelScorerIntf: """ Creates a CanaryLabelScorer object that is used in the beam search implementation. @@ -111,9 +111,10 @@ class CanaryLabelScorer(LabelScorerIntf): def get_initial_state(self, *, batch_size: int, device: torch.device) -> Any: return { "step": StateObjIgnored(0), - "prefix_input": torch.tile( - torch.tensor(bos_prefix_seq, device=device)[None, :], [batch_size, 1] - ), # [Batch,InputSeqLen] + # "prefix_input": torch.tile( + # torch.tensor(bos_prefix_seq, device=device)[None, :], [batch_size, 1] + # ), # [Batch,InputSeqLen] + "prefix_input": bos_prefix_seq, # [Batch,InputSeqLen] "model_state": None, } @@ -194,18 +195,6 @@ def _map(x): return CanaryLabelScorer() -# TODO: make this configurable -beam_search_v5_opts = BeamSearchOptsV5( - beam_size=4, - bos_label=3, - eos_label=2, - num_labels=4128, - length_normalization_exponent=1, - pruning_threshold=0.0, - adaptive_pruning=False, -) - - def _transcribe_output_processing_our_beam_search( outputs, trcfg: MultiTaskTranscriptionConfig ) -> GenericTranscriptionType: @@ -213,9 +202,14 @@ def _transcribe_output_processing_our_beam_search( enc_states = outputs.pop("encoder_states") enc_lens = outputs.pop("encoded_lengths") enc_mask = outputs.pop("encoder_mask") + dec_input_ids = outputs.pop("decoder_input_ids") canary_label_scorer = get_our_canary_label_scorer( - model=asr_model, enc=enc_states, enc_input_mask=enc_mask, pad_id=1, bos_prefix_seq=[3, 4, 8, 4, 10] + model=asr_model, + enc=enc_states, + enc_input_mask=enc_mask, + pad_id=asr_model.tokenizer.pad_id, + bos_prefix_seq=dec_input_ids, # [3, 4, 8, 4, 10], ) seq_targets, _, out_seq_len = beam_search_v5( @@ -292,6 +286,17 @@ def main(args): asr_model = ASRModel.restore_from(args.model_path, map_location=device) asr_model.freeze() + global beam_search_v5_opts + beam_search_v5_opts = BeamSearchOptsV5( + beam_size=args.beam_size, + bos_label=asr_model.tokenizer.bos_id, + eos_label=asr_model.tokenizer.eos_id, + num_labels=len(asr_model.tokenizer.vocab), + length_normalization_exponent=1, + pruning_threshold=args.pruning_threshold, + adaptive_pruning=args.adaptive_pruning, + ) + # hook our beam search implementation asr_model._transcribe_output_processing = _transcribe_output_processing_our_beam_search @@ -353,6 +358,10 @@ def main(args): parser.add_argument("--wer_out_path", type=str, default=None, help="Path to save the WER output.") + parser.add_argument("--beam_size", type=int, default=4) + parser.add_argument("--pruning_threshold", type=float, default=0.0) + parser.add_argument("--adaptive_pruning", type=bool, default=False) + parser.add_argument( "--device", type=int, From f8399c62abc8111141faf42787e60c549fbea96f Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Tue, 18 Jun 2024 12:34:47 +0000 Subject: [PATCH 183/227] add hyp postprocessing --- .../experiments/canary_aed/nemo/run_eval_beam_search.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/users/zeineldeen/experiments/canary_aed/nemo/run_eval_beam_search.py b/users/zeineldeen/experiments/canary_aed/nemo/run_eval_beam_search.py index 86fae43cd..b5ad60ece 100644 --- a/users/zeineldeen/experiments/canary_aed/nemo/run_eval_beam_search.py +++ b/users/zeineldeen/experiments/canary_aed/nemo/run_eval_beam_search.py @@ -222,10 +222,10 @@ def _transcribe_output_processing_our_beam_search( best_hyps = [] for i in range(seq_targets.shape[0]): - # TODO: convert hyp to text using model.tokenizer - # TODO: filter out EOS? - best_hyp_int = seq_targets[i, 0, : out_seq_len[i, 0]] # [B,1,L] - best_hyps.append(best_hyp_int) + best_hyp_int = seq_targets[i, 0, : out_seq_len[i, 0]].tolist() + best_hyp_text = asr_model.tokenizer.ids_to_text(best_hyp_int) + best_hyps.append(asr_model.decoding.strip_special_tokens(best_hyp_text)) + print(best_hyps) return best_hyps From 748596a13bad41737c631b356ab0d8f46b1575dd Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Tue, 18 Jun 2024 12:36:24 +0000 Subject: [PATCH 184/227] better --- .../experiments/canary_aed/nemo/run_eval_beam_search.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/users/zeineldeen/experiments/canary_aed/nemo/run_eval_beam_search.py b/users/zeineldeen/experiments/canary_aed/nemo/run_eval_beam_search.py index b5ad60ece..d50250a3b 100644 --- a/users/zeineldeen/experiments/canary_aed/nemo/run_eval_beam_search.py +++ b/users/zeineldeen/experiments/canary_aed/nemo/run_eval_beam_search.py @@ -209,7 +209,7 @@ def _transcribe_output_processing_our_beam_search( enc=enc_states, enc_input_mask=enc_mask, pad_id=asr_model.tokenizer.pad_id, - bos_prefix_seq=dec_input_ids, # [3, 4, 8, 4, 10], + bos_prefix_seq=dec_input_ids, # [3, 4, 8, 4, 10] ) seq_targets, _, out_seq_len = beam_search_v5( From 01b8c7f1011b0f872a0ac8693625e59b5cd95760 Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Tue, 18 Jun 2024 12:49:18 +0000 Subject: [PATCH 185/227] add beam search --- .../canary_aed/configs/canary_1b_recog.py | 39 ++++++++++++++++--- 1 file changed, 34 insertions(+), 5 deletions(-) diff --git a/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py b/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py index a01b0da88..e316d1e42 100644 --- a/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py +++ b/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py @@ -49,10 +49,15 @@ def py(): dataset_paths = download_test_datasets() model_path = download_canary_1b_model() - search_script = tk.Path( + huggface_search_script = tk.Path( "/u/zeineldeen/setups/ubuntu_22_setups/2024-06-07--canary-aed/recipe/i6_experiments/users/zeineldeen/experiments/canary_aed/nemo/run_eval.py", hash_overwrite="run_eval_v1", ) + our_beam_search_script = tk.Path( + "/u/zeineldeen/setups/ubuntu_22_setups/2024-06-07--canary-aed/recipe/i6_experiments/users/zeineldeen/experiments/canary_aed/nemo/run_eval_beam_search.py", + hash_overwrite="run_eval_v2", + ) + # to run canary model, this env has installed nemo toolkit with: # pip3 install git+https://github.com/NVIDIA/NeMo.git@r2.0.0rc0#egg=nemo_toolkit[all] # related issue: https://github.com/huggingface/open_asr_leaderboard/issues/26 @@ -76,7 +81,7 @@ def py(): dataset_path=dataset_paths[test_set], dataset_name=test_set, split=split, - search_script=search_script, + search_script=huggface_search_script, search_args={"batch_size": 64, "pnc": False, "max_eval_samples": -1}, python_exe=python_exe, device="gpu", @@ -85,6 +90,30 @@ def py(): cpu_rqmt=2, ) search_job.rqmt["sbatch_args"] = ["-p", "gpu_24gb"] - search_job.add_alias(f"canary_1b/{test_set}_bs64_wo-pnc") - tk.register_output(f"canary_1b/{test_set}_bs64_wo-pnc/search_out", search_job.out_search_results) - tk.register_output(f"canary_1b/{test_set}_bs64_wo-pnc/wer", search_job.out_wer) + search_job.add_alias(f"canary_1b/huggingface/{test_set}_bs64_greedy") + tk.register_output(f"canary_1b/huggingface/{test_set}_bs64_greedy/search_out", search_job.out_search_results) + tk.register_output(f"canary_1b/huggingface/{test_set}_bs64_greedy/wer", search_job.out_wer) + + # Run with our beam search + for beam_size in [4]: + for test_set, split in TEST_DATASETS.items(): + search_job = SearchJob( + model_id=MODEL_ID, + model_path=model_path, + dataset_path=dataset_paths[test_set], + dataset_name=test_set, + split=split, + search_script=our_beam_search_script, + search_args={"batch_size": 64, "pnc": False, "max_eval_samples": -1, "beam_size": beam_size}, + python_exe=python_exe, + device="gpu", + time_rqmt=24, + mem_rqmt=8, + cpu_rqmt=2, + ) + search_job.rqmt["sbatch_args"] = ["-p", "gpu_24gb"] + search_job.add_alias(f"canary_1b/beam_search_v5/{test_set}_bs64_beam{beam_size}") + tk.register_output( + f"canary_1b/beam_search_v5/{test_set}_bs64_beam{beam_size}/search_out", search_job.out_search_results + ) + tk.register_output(f"canary_1b/beam_search_v5/{test_set}_bs64_beam{beam_size}/wer", search_job.out_wer) From f464e26fbd50eb86c09331c8fd695e9cb252f614 Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Tue, 18 Jun 2024 12:50:37 +0000 Subject: [PATCH 186/227] remove print --- .../experiments/canary_aed/nemo/run_eval_beam_search.py | 1 - 1 file changed, 1 deletion(-) diff --git a/users/zeineldeen/experiments/canary_aed/nemo/run_eval_beam_search.py b/users/zeineldeen/experiments/canary_aed/nemo/run_eval_beam_search.py index d50250a3b..06621b306 100644 --- a/users/zeineldeen/experiments/canary_aed/nemo/run_eval_beam_search.py +++ b/users/zeineldeen/experiments/canary_aed/nemo/run_eval_beam_search.py @@ -225,7 +225,6 @@ def _transcribe_output_processing_our_beam_search( best_hyp_int = seq_targets[i, 0, : out_seq_len[i, 0]].tolist() best_hyp_text = asr_model.tokenizer.ids_to_text(best_hyp_int) best_hyps.append(asr_model.decoding.strip_special_tokens(best_hyp_text)) - print(best_hyps) return best_hyps From 63a45f886ab341895be5fd338017b34d2dc0073a Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Sun, 16 Jun 2024 12:09:27 +0200 Subject: [PATCH 187/227] more --- .../exp2024_04_23_baselines/ctc.py | 23 ++++++++++++++----- 1 file changed, 17 insertions(+), 6 deletions(-) diff --git a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py index 2963c7ec6..d3e020b2e 100644 --- a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py +++ b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py @@ -32,6 +32,10 @@ def py(): """Sisyphus entry point""" + from i6_experiments.users.zeyer.datasets.librispeech import get_librispeech_log_mel_stats + + feature_stats = get_librispeech_log_mel_stats(_log_mel_feature_dim) + """ Luca: @@ -53,9 +57,10 @@ def py(): - Luca uses larger batch 2_400_000 -> 6_400_000, grad accum 1 -> 2 - Luca uses wd 1e-06 - Luca uses older behavior_version 21 -> 16. + - Luca uses feature normalization (global based on Tedlium statistics...). """ - train_exp( + train_exp( # {"dev-clean": 6.44, "dev-other": 9.77, "test-clean": 6.89, "test-other": 9.98} f"v6-bhv21-24gb-bf16-bs40k-accgrad2-wd1e_6-lrlin1e_5_450k-bpe10k", config_24gb_v6, config_updates={ @@ -63,7 +68,7 @@ def py(): }, ) - train_exp( + train_exp( # {"dev-clean": 6.61, "dev-other": 9.68, "test-clean": 7.01, "test-other": 10.36} f"v6-bhv21-24gb-bf16-bs40k-accgrad2-wd1e_6-lrlin1e_5_600k-bpe10k", config_24gb_v6, config_updates={ @@ -72,6 +77,16 @@ def py(): }, ) + train_exp( + f"v6-bhv21-24gb-bf16-bs40k-accgrad2-wd1e_6-lrlin1e_5_600k-featGN-bpe10k", + config_24gb_v6, + model_config={"feature_stats": {"mean": feature_stats.mean, "std_dev": feature_stats.std_dev}}, + config_updates={ + **_get_cfg_lrlin_oclr_by_bs_nep(40_000, 2000), + "learning_rate_piecewise_steps": [600_000, 900_000, 982_000], + }, + ) + for acc, wd in [ # (5, 1e-5), # 9.90 (5, 1e-3), # 9.53 @@ -196,10 +211,6 @@ def py(): train_vocab_opts={"other_opts": {"enable_sampling": True, "alpha": 0.7}}, ) - from i6_experiments.users.zeyer.datasets.librispeech import get_librispeech_log_mel_stats - - feature_stats = get_librispeech_log_mel_stats(_log_mel_feature_dim) - # Test different feature normalization schemes. # Note: It seems the diff between dev-other and test-other is less here, probably du to the normalization. for name, model_opts in { From 68d90d619626a3cc38d7dc51a3aa3cbd3e514dad Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Mon, 17 Jun 2024 12:29:15 +0200 Subject: [PATCH 188/227] BatchRenorm with build_from_dict --- users/zeyer/nn_rf/batchnorm.py | 14 +++++++++----- 1 file changed, 9 insertions(+), 5 deletions(-) diff --git a/users/zeyer/nn_rf/batchnorm.py b/users/zeyer/nn_rf/batchnorm.py index ae92bb6dd..0167e3f04 100644 --- a/users/zeyer/nn_rf/batchnorm.py +++ b/users/zeyer/nn_rf/batchnorm.py @@ -5,7 +5,7 @@ """ from __future__ import annotations -from typing import Optional, Union, Callable +from typing import Optional, Union, Any, Callable from returnn.tensor import Tensor, Dim import returnn.frontend as rf @@ -50,8 +50,8 @@ def __init__( eps: float = 1e-3, use_mask: Optional[bool] = None, unbiased: bool = False, - r_max: Union[float, Callable[[BatchRenorm], float]] = 1.0, - d_max: Union[float, Callable[[BatchRenorm], float]] = 0.0, + r_max: Union[float, Callable[[BatchRenorm], Union[float, Tensor]], Any] = 1.0, + d_max: Union[float, Callable[[BatchRenorm], Union[float, Tensor]], Any] = 0.0, ): """ :param in_dim: the feature dimension of the input @@ -88,6 +88,10 @@ def __init__( self.eps = eps self.use_mask = use_mask self.unbiased = unbiased + if isinstance(r_max, dict): + r_max = rf.build_from_dict(r_max) + if isinstance(d_max, dict): + d_max = rf.build_from_dict(d_max) self.r_max = r_max self.d_max = d_max self.running_mean = rf.Parameter([in_dim], auxiliary=True) @@ -139,7 +143,7 @@ def _update_running_stats(): def _train_mean_std_dev(): inv_std_dev_ = rf.rsqrt(variance_cur_batch + self.eps) - if r_max > 1: + if isinstance(r_max, Tensor) or r_max > 1: inv_std_dev_ *= rf.clip_by_value( rf.rsqrt(self.running_variance + self.eps) * rf.sqrt(rf.stop_gradient(variance_cur_batch) + self.eps), @@ -147,7 +151,7 @@ def _train_mean_std_dev(): r_max, ) mean_ = mean_cur_batch - if d_max > 0: + if isinstance(d_max, Tensor) or d_max > 0: limit = d_max * rf.reciprocal(rf.stop_gradient(inv_std_dev_)) mean_ += rf.clip_by_value(self.running_mean - rf.stop_gradient(mean_cur_batch), -limit, limit) return mean_, inv_std_dev_ From 7d87cc735578c5a7533ee2d096e1132a3805afde Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Mon, 17 Jun 2024 13:49:33 +0200 Subject: [PATCH 189/227] more --- .../exp2024_04_23_baselines/ctc.py | 38 ++++++++++++++++++- users/zeyer/nn_rf/batchnorm.py | 2 + 2 files changed, 38 insertions(+), 2 deletions(-) diff --git a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py index d3e020b2e..ccecb2ed6 100644 --- a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py +++ b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py @@ -126,7 +126,7 @@ def py(): "spm1k", # 12.72 "spm_bpe1k", # 11.76 ]: - train_exp( # 8.23 + train_exp( f"v6-bhv20-11gb-f32-bs15k-accgrad1-mgpu4-pavg100-wd1e_2-lrlin1e_5_295k-speedpertV2-{vocab}", config_11gb_v6_f32_accgrad1_mgpu4_pavg100_wd1e_4, config_updates={ @@ -138,6 +138,7 @@ def py(): vocab=vocab, ) + # lrlin1e_5_393k train_exp( f"v6-bhv20-11gb-f32-bs15k-accgrad1-mgpu4-pavg100-wd1e_2-lrlin1e_5_393k-speedpertV2-bpe10k", config_11gb_v6_f32_accgrad1_mgpu4_pavg100_wd1e_4, @@ -237,6 +238,36 @@ def py(): train_vocab_opts={"other_opts": {"enable_sampling": True, "alpha": 0.7}}, ) + from i6_experiments.users.zeyer.nn_rf.batchnorm import BatchRenorm + + for vocab, alpha in [("bpe10k", 0.01)]: # [("bpe10k", 0.01), ("spm10k", 0.7)]: + train_exp( + f"v6-batchRenorm-bhv20-11gb-f32-bs15k-accgrad1-mgpu4-pavg100-wd1e_2-lrlin1e_5_295k-speedpertV2-{vocab}" + f"-{'spmSample' if vocab.startswith('spm') else 'bpeSample'}{str(alpha).replace('.', '')}", + config_11gb_v6_f32_accgrad1_mgpu4_pavg100_wd1e_4, + model_config={ + "conv_norm": rf.build_dict( + BatchRenorm, + r_max=rf.build_dict(rf.PiecewiseLinearStepwiseScheduler, points={5_000: 1.0, 40_000: 3.0}), + d_max=rf.build_dict(rf.PiecewiseLinearStepwiseScheduler, points={5_000: 0.0, 25_000: 5.0}), + ) + }, + config_updates={ + **_get_cfg_lrlin_oclr_by_bs_nep(15_000, 500), + "optimizer.weight_decay": 1e-2, + "__train_audio_preprocess": speed_pert_librosa_config, + "speed_pert_discrete_values": [0.7, 0.8, 0.9, 1.0, 1.1], + }, + vocab=vocab, + train_vocab_opts={ + "other_opts": ( + {"enable_sampling": True, "alpha": alpha} + if vocab.startswith("spm") + else {"class": "SamplingBytePairEncoding", "breadth_prob": alpha} + ) + }, + ) + # noinspection PyShadowingNames def train_exp( @@ -342,6 +373,9 @@ def ctc_model_def(*, epoch: int, in_dim: Dim, target_dim: Dim) -> Model: # real input is raw audio, internally it does logmel in_dim = Dim(name="logmel", dimension=_log_mel_feature_dim, kind=Dim.Types.Feature) + conv_norm = config.typed_value("conv_norm", None) + conv_norm: Dict[str, Any] = {"class": "rf.BatchNorm", "use_mask": True} if not conv_norm else conv_norm + return Model( in_dim, num_enc_layers=num_enc_layers, @@ -349,7 +383,7 @@ def ctc_model_def(*, epoch: int, in_dim: Dim, target_dim: Dim) -> Model: enc_ff_dim=Dim(name="enc-ff", dimension=2048, kind=Dim.Types.Feature), enc_att_num_heads=8, enc_conformer_layer_opts=dict( - conv_norm_opts=dict(use_mask=True), + conv_norm=conv_norm, self_att_opts=dict( # Shawn et al 2018 style, old RETURNN way. with_bias=False, diff --git a/users/zeyer/nn_rf/batchnorm.py b/users/zeyer/nn_rf/batchnorm.py index 0167e3f04..40b5eba87 100644 --- a/users/zeyer/nn_rf/batchnorm.py +++ b/users/zeyer/nn_rf/batchnorm.py @@ -72,6 +72,7 @@ def __init__( r_max can also be scheduled via a callable, e.g. using rf.get_run_ctx().step inside. The original paper suggests to keep r_max=1.0 for the first 5k steps, then linearly increase to reach r_max=3.0 at 40k steps. + You can use ``rf.build_dict(rf.PiecewiseLinearStepwiseScheduler, points={5_000: 1.0, 40_000: 3.0})``. :param d_max: clip how much we should use the running mean instead of the current batch mean during training. Value should be >= 0.0. d_max=0.0 means always use the current batch mean, i.e. like standard batch norm. @@ -79,6 +80,7 @@ def __init__( d_max can also be scheduled via a callable, e.g. using rf.get_run_ctx().step inside. The original paper suggests to keep d_max=0.0 for the first 5k steps, then linearly increase to reach d_max=5.0 at 25k steps. + You can use ``rf.build_dict(rf.PiecewiseLinearStepwiseScheduler, points={5_000: 0.0, 25_000: 5.0})``. """ super().__init__() assert isinstance(in_dim, Dim) From 87f41f25f3a9bcdbd9066bee8194180efae4ee92 Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Mon, 17 Jun 2024 14:47:29 +0200 Subject: [PATCH 190/227] small fix --- users/zeyer/experiments/exp2024_04_23_baselines/ctc.py | 1 + 1 file changed, 1 insertion(+) diff --git a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py index ccecb2ed6..24e61fa84 100644 --- a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py +++ b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py @@ -248,6 +248,7 @@ def py(): model_config={ "conv_norm": rf.build_dict( BatchRenorm, + use_mask=True, r_max=rf.build_dict(rf.PiecewiseLinearStepwiseScheduler, points={5_000: 1.0, 40_000: 3.0}), d_max=rf.build_dict(rf.PiecewiseLinearStepwiseScheduler, points={5_000: 0.0, 25_000: 5.0}), ) From 00dd150ebef00ae7885b14cb8977b5f9c6cba4a6 Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Mon, 17 Jun 2024 19:07:18 +0200 Subject: [PATCH 191/227] more --- .../exp2024_04_23_baselines/ctc.py | 59 ++++++++++--------- 1 file changed, 31 insertions(+), 28 deletions(-) diff --git a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py index 24e61fa84..a24e29122 100644 --- a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py +++ b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py @@ -240,34 +240,37 @@ def py(): from i6_experiments.users.zeyer.nn_rf.batchnorm import BatchRenorm - for vocab, alpha in [("bpe10k", 0.01)]: # [("bpe10k", 0.01), ("spm10k", 0.7)]: - train_exp( - f"v6-batchRenorm-bhv20-11gb-f32-bs15k-accgrad1-mgpu4-pavg100-wd1e_2-lrlin1e_5_295k-speedpertV2-{vocab}" - f"-{'spmSample' if vocab.startswith('spm') else 'bpeSample'}{str(alpha).replace('.', '')}", - config_11gb_v6_f32_accgrad1_mgpu4_pavg100_wd1e_4, - model_config={ - "conv_norm": rf.build_dict( - BatchRenorm, - use_mask=True, - r_max=rf.build_dict(rf.PiecewiseLinearStepwiseScheduler, points={5_000: 1.0, 40_000: 3.0}), - d_max=rf.build_dict(rf.PiecewiseLinearStepwiseScheduler, points={5_000: 0.0, 25_000: 5.0}), - ) - }, - config_updates={ - **_get_cfg_lrlin_oclr_by_bs_nep(15_000, 500), - "optimizer.weight_decay": 1e-2, - "__train_audio_preprocess": speed_pert_librosa_config, - "speed_pert_discrete_values": [0.7, 0.8, 0.9, 1.0, 1.1], - }, - vocab=vocab, - train_vocab_opts={ - "other_opts": ( - {"enable_sampling": True, "alpha": alpha} - if vocab.startswith("spm") - else {"class": "SamplingBytePairEncoding", "breadth_prob": alpha} - ) - }, - ) + for name, opts in { + "batchRenorm": rf.build_dict( + BatchRenorm, + use_mask=True, + r_max=rf.build_dict(rf.PiecewiseLinearStepwiseScheduler, points={5_000: 1.0, 40_000: 3.0}), + d_max=rf.build_dict(rf.PiecewiseLinearStepwiseScheduler, points={5_000: 0.0, 25_000: 5.0}), + ), + "groupNorm": {"class": rf.GroupNorm, "num_groups": 32}, + "layerNorm": {"class": rf.LayerNorm}, + }.items(): + for vocab, alpha in [("bpe10k", 0.01)]: # [("bpe10k", 0.01), ("spm10k", 0.7)]: + train_exp( + f"v6-{name}-bhv20-11gb-f32-bs15k-accgrad1-mgpu4-pavg100-wd1e_2-lrlin1e_5_295k-speedpertV2-{vocab}" + f"-{'spmSample' if vocab.startswith('spm') else 'bpeSample'}{str(alpha).replace('.', '')}", + config_11gb_v6_f32_accgrad1_mgpu4_pavg100_wd1e_4, + model_config={"conv_norm": opts}, + config_updates={ + **_get_cfg_lrlin_oclr_by_bs_nep(15_000, 500), + "optimizer.weight_decay": 1e-2, + "__train_audio_preprocess": speed_pert_librosa_config, + "speed_pert_discrete_values": [0.7, 0.8, 0.9, 1.0, 1.1], + }, + vocab=vocab, + train_vocab_opts={ + "other_opts": ( + {"enable_sampling": True, "alpha": alpha} + if vocab.startswith("spm") + else {"class": "SamplingBytePairEncoding", "breadth_prob": alpha} + ) + }, + ) # noinspection PyShadowingNames From d87eb8d01101013174f10d59114751d7cfa07c46 Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Mon, 17 Jun 2024 19:09:34 +0200 Subject: [PATCH 192/227] small fix --- users/zeyer/experiments/exp2024_04_23_baselines/ctc.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py index a24e29122..fc2ed32d1 100644 --- a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py +++ b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py @@ -247,8 +247,8 @@ def py(): r_max=rf.build_dict(rf.PiecewiseLinearStepwiseScheduler, points={5_000: 1.0, 40_000: 3.0}), d_max=rf.build_dict(rf.PiecewiseLinearStepwiseScheduler, points={5_000: 0.0, 25_000: 5.0}), ), - "groupNorm": {"class": rf.GroupNorm, "num_groups": 32}, - "layerNorm": {"class": rf.LayerNorm}, + "groupNorm": rf.build_dict(rf.GroupNorm, num_groups=32), + "layerNorm": rf.build_dict(rf.LayerNorm), }.items(): for vocab, alpha in [("bpe10k", 0.01)]: # [("bpe10k", 0.01), ("spm10k", 0.7)]: train_exp( From 9ec8ad098738d32fb65b66dc6bef6ae5a0185a78 Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Tue, 18 Jun 2024 10:50:03 +0200 Subject: [PATCH 193/227] reorder code --- users/zeyer/collect_model_dataset_stats.py | 78 +++++++++++----------- 1 file changed, 39 insertions(+), 39 deletions(-) diff --git a/users/zeyer/collect_model_dataset_stats.py b/users/zeyer/collect_model_dataset_stats.py index c65e13c4a..f03f3875c 100644 --- a/users/zeyer/collect_model_dataset_stats.py +++ b/users/zeyer/collect_model_dataset_stats.py @@ -27,6 +27,45 @@ from returnn.tensor import Tensor, Dim, TensorDict +@dataclass +class StatisticsOutput: + """statistics""" + + mean: tk.Path + std_dev: tk.Path + min: tk.Path + max: tk.Path + info: tk.Path + + +def collect_log_mel_feature_statistics( + *, dataset: DatasetConfig, dim: int, backend: str = "torch", behavior_version: int = 21, **kwargs +) -> StatisticsOutput: + """ + Get feature stats + + :param dataset: + :param dim: log mel feature dim + :param backend: + :param behavior_version: + :param kwargs: all passed to rf.audio.log_mel_filterbank_from_raw. + Default sampling_rate is 16_000, which is also what we have for Librispeech usually. + Note on log_base: Default is 10.0. + Note that in some earlier setups, and also Mohammads original AED setup, + we used log_base=math.exp(2.3026), which is almost 10.0 but not exactly... + """ + return collect_statistics( + dataset=dataset, + forward_def=_log_mel_stats_returnn_forward, + config={ + "backend": backend, + "behavior_version": behavior_version, + "_audio_feature_dim": dim, + "_audio_feature_opts": kwargs, + }, + ) + + def collect_statistics( *, dataset: DatasetConfig, @@ -73,34 +112,6 @@ def collect_statistics( return StatisticsOutput(**{k: forward_job.out_files[v] for k, v in out_files.items()}) -def collect_log_mel_feature_statistics( - *, dataset: DatasetConfig, dim: int, backend: str = "torch", behavior_version: int = 21, **kwargs -): - """ - Get feature stats - - :param dataset: - :param dim: log mel feature dim - :param backend: - :param behavior_version: - :param kwargs: all passed to rf.audio.log_mel_filterbank_from_raw. - Default sampling_rate is 16_000, which is also what we have for Librispeech usually. - Note on log_base: Default is 10.0. - Note that in some earlier setups, and also Mohammads original AED setup, - we used log_base=math.exp(2.3026), which is almost 10.0 but not exactly... - """ - return collect_statistics( - dataset=dataset, - forward_def=_log_mel_stats_returnn_forward, - config={ - "backend": backend, - "behavior_version": behavior_version, - "_audio_feature_dim": dim, - "_audio_feature_opts": kwargs, - }, - ) - - def _log_mel_stats_returnn_forward(source: Tensor, /, in_spatial_dim: Dim, model: Any) -> Tuple[Tensor, Dim]: from returnn.config import get_global_config import returnn.frontend as rf @@ -120,17 +131,6 @@ def _log_mel_stats_returnn_forward(source: Tensor, /, in_spatial_dim: Dim, model return source, out_spatial_dim -@dataclass -class StatisticsOutput: - """statistics""" - - mean: tk.Path - std_dev: tk.Path - min: tk.Path - max: tk.Path - info: tk.Path - - _prior_mean_out_filename = "stats.mean.txt" _prior_std_dev_out_filename = "stats.std_dev.txt" _prior_min_out_filename = "stats.min.txt" From ccdc9e67699fb28be52bd723d06505ba7e71329f Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Tue, 18 Jun 2024 11:02:37 +0200 Subject: [PATCH 194/227] comment --- users/zeyer/collect_model_dataset_stats.py | 1 + 1 file changed, 1 insertion(+) diff --git a/users/zeyer/collect_model_dataset_stats.py b/users/zeyer/collect_model_dataset_stats.py index f03f3875c..95cbb70cd 100644 --- a/users/zeyer/collect_model_dataset_stats.py +++ b/users/zeyer/collect_model_dataset_stats.py @@ -113,6 +113,7 @@ def collect_statistics( def _log_mel_stats_returnn_forward(source: Tensor, /, in_spatial_dim: Dim, model: Any) -> Tuple[Tensor, Dim]: + """ForwardDef API""" from returnn.config import get_global_config import returnn.frontend as rf from returnn.tensor import Dim From 17e2b6cc4843a4ebe694e3b7f1fc628db5a6790c Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Tue, 18 Jun 2024 11:33:49 +0200 Subject: [PATCH 195/227] prior --- users/zeyer/collect_model_dataset_stats.py | 64 ++++++++++++++++++++++ 1 file changed, 64 insertions(+) diff --git a/users/zeyer/collect_model_dataset_stats.py b/users/zeyer/collect_model_dataset_stats.py index 95cbb70cd..234dbc96f 100644 --- a/users/zeyer/collect_model_dataset_stats.py +++ b/users/zeyer/collect_model_dataset_stats.py @@ -66,6 +66,45 @@ def collect_log_mel_feature_statistics( ) +def compute_model_softmax_prior_statistics( + *, + model: ModelWithCheckpoint, + model_output_kind: str = "logits", + dataset: DatasetConfig, + backend: str = "torch", + behavior_version: int = 21, + **kwargs, +) -> StatisticsOutput: + """ + Calculate model softmax prior average. + + :param model: after construction, the model will be called as: + ``out, out_spatial_dim = model(input, in_spatial_dim=in_spatial_dim)`` + (This is the RETURNN ISeqDownsamplingEncoder interface.) + ``out.feature_dim`` is expected to be set. + Use ``model_output_kind`` to specify what kind of output you have in the model output ``out``. + (If you have a model with a different interface, just call :collect_statistics` directly + with your custom ``forward_def`` function.) + :param model_output_kind: "logits", "log_prob" or "prob" + :param dataset: + :param backend: + :param behavior_version: + :param kwargs: passed to :func:`collect_statistics` + """ + assert model_output_kind in {"logits", "log_prob", "prob"} + return collect_statistics( + model=model, + dataset=dataset, + forward_def=_model_softmax_prior_returnn_forward, + config={ + "backend": backend, + "behavior_version": behavior_version, + "_model_output_kind": model_output_kind, + }, + **kwargs, + ) + + def collect_statistics( *, dataset: DatasetConfig, @@ -132,6 +171,31 @@ def _log_mel_stats_returnn_forward(source: Tensor, /, in_spatial_dim: Dim, model return source, out_spatial_dim +def _model_softmax_prior_returnn_forward(source: Tensor, /, in_spatial_dim: Dim, model: Any) -> Tuple[Tensor, Dim]: + """ForwardDef API""" + from returnn.config import get_global_config + import returnn.frontend as rf + from returnn.tensor import Tensor, Dim + + out, out_spatial_dim = model(source, in_spatial_dim=in_spatial_dim) + assert isinstance(out, Tensor) and isinstance(out_spatial_dim, Dim) + assert out.feature_dim # we expect a feature dim + assert out_spatial_dim in out.dims + + config = get_global_config() + model_output_kind = config.typed_value("_model_output_kind", None) + if model_output_kind == "logits": + out = rf.softmax(out, axis=out.feature_dim) + elif model_output_kind == "log_prob": + out = rf.exp(out) + elif model_output_kind == "prob": + pass + else: + raise ValueError(f"invalid model_output_kind {model_output_kind!r}") + + return out, out_spatial_dim + + _prior_mean_out_filename = "stats.mean.txt" _prior_std_dev_out_filename = "stats.std_dev.txt" _prior_min_out_filename = "stats.min.txt" From 973c32839ef2c9ff97cd799ce34e4dcbafde5cc2 Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Tue, 18 Jun 2024 11:34:02 +0200 Subject: [PATCH 196/227] cleanup --- .../zeyer/experiments/exp2024_04_23_baselines/ctc.py | 11 ----------- 1 file changed, 11 deletions(-) diff --git a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py index fc2ed32d1..8e13c8ef8 100644 --- a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py +++ b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py @@ -581,17 +581,6 @@ def model_recog( model_recog.batch_size_dependent = False # not totally correct, but we treat it as such... -def _gather_backrefs(s, *, backrefs: Tensor): - if isinstance(s, Tensor): - if backrefs.sparse_dim in s.dims: - return rf.gather(s, indices=backrefs) # really the default case - return s # e.g. scalar or so, independent from beam - if isinstance(s, Dim): - assert s.dimension or backrefs not in s.dyn_size_ext.dims # currently not supported, also not expected - return s - raise TypeError(f"_gather_backrefs: unexpected type ({type(s)})") - - class Model(rf.Module): """Model definition""" From 0476918a4fda8326cb418278f59b11eed6ea6ece Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Tue, 18 Jun 2024 15:24:40 +0200 Subject: [PATCH 197/227] cache enc beam expansion --- .../canary_aed/nemo/run_eval_beam_search.py | 15 +++++++++++---- 1 file changed, 11 insertions(+), 4 deletions(-) diff --git a/users/zeineldeen/experiments/canary_aed/nemo/run_eval_beam_search.py b/users/zeineldeen/experiments/canary_aed/nemo/run_eval_beam_search.py index 06621b306..52e61f65d 100644 --- a/users/zeineldeen/experiments/canary_aed/nemo/run_eval_beam_search.py +++ b/users/zeineldeen/experiments/canary_aed/nemo/run_eval_beam_search.py @@ -1,6 +1,7 @@ """ Adapted from here: https://github.com/huggingface/open_asr_leaderboard/blob/5c03c1f85a84ab7a991dcc1b3f14905ec6d632c9/nemo_asr/run_eval.py """ + from __future__ import annotations import argparse @@ -98,7 +99,7 @@ def get_our_canary_label_scorer( Creates a CanaryLabelScorer object that is used in the beam search implementation. :param model: nemo ASRModel object - :param enc: [B,T] + :param enc: [B,T,D] :param enc_input_mask: [B,T] :param pad_id: :param bos_prefix_seq: @@ -107,6 +108,9 @@ def get_our_canary_label_scorer( trafo_decoder_module = model.transf_decoder # type: torch.nn.Module log_softmax_module = model.log_softmax # type: torch.nn.Module + enc = enc[:, None] # [B,Beam=1,T,D] + enc_input_mask = enc_input_mask[:, None] # [B,Beam=1,T] + class CanaryLabelScorer(LabelScorerIntf): def get_initial_state(self, *, batch_size: int, device: torch.device) -> Any: return { @@ -154,9 +158,12 @@ def _map(x): ) # [batch*beam,in_seq_len|1,D] dec_input_mask = mask_padded_tokens(input, pad_id=pad_id).float() - _, enc_len, enc_dim = enc.size() - enc_input_mask_ = enc_input_mask.unsqueeze(1).expand(-1, beam_size, -1).contiguous().view(-1, enc_len) - enc_ = enc.unsqueeze(1).expand(-1, beam_size, -1, -1).contiguous().view(-1, enc_len, enc_dim) + nonlocal enc, enc_input_mask + if enc.size(1) < beam_size: + enc = enc[:, :1].expand(-1, beam_size, -1, -1).continguous() # [batch,beam,T,D] + enc_input_mask = enc_input_mask[:, :1].expand(-1, beam_size, -1).continguous() # [batch,beam,T] + enc_ = enc[:, :beam_size].flatten(0, 1) + enc_input_mask_ = enc_input_mask[:, :beam_size].flatten(0, 1) # [batch*beam,T] # decoder_mems_list is a list of size num_layers that cache output activations of shape # [batch*beam,history,D] From cd16ba0b4017dd55224c865654909bb47885ab97 Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Tue, 18 Jun 2024 13:40:17 +0000 Subject: [PATCH 198/227] fix bug --- .../experiments/canary_aed/nemo/run_eval_beam_search.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/users/zeineldeen/experiments/canary_aed/nemo/run_eval_beam_search.py b/users/zeineldeen/experiments/canary_aed/nemo/run_eval_beam_search.py index 52e61f65d..cc928f526 100644 --- a/users/zeineldeen/experiments/canary_aed/nemo/run_eval_beam_search.py +++ b/users/zeineldeen/experiments/canary_aed/nemo/run_eval_beam_search.py @@ -160,8 +160,8 @@ def _map(x): nonlocal enc, enc_input_mask if enc.size(1) < beam_size: - enc = enc[:, :1].expand(-1, beam_size, -1, -1).continguous() # [batch,beam,T,D] - enc_input_mask = enc_input_mask[:, :1].expand(-1, beam_size, -1).continguous() # [batch,beam,T] + enc = enc[:, :1].expand(-1, beam_size, -1, -1).contiguous() # [batch,beam,T,D] + enc_input_mask = enc_input_mask[:, :1].expand(-1, beam_size, -1).contiguous() # [batch,beam,T] enc_ = enc[:, :beam_size].flatten(0, 1) enc_input_mask_ = enc_input_mask[:, :beam_size].flatten(0, 1) # [batch*beam,T] From 94274d3211c0bc4b5801095cc167837864cbb6e7 Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Wed, 19 Jun 2024 00:37:07 +0200 Subject: [PATCH 199/227] update --- .../experiments/canary_aed/configs/canary_1b_recog.py | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py b/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py index e316d1e42..28db5beb1 100644 --- a/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py +++ b/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py @@ -95,8 +95,10 @@ def py(): tk.register_output(f"canary_1b/huggingface/{test_set}_bs64_greedy/wer", search_job.out_wer) # Run with our beam search - for beam_size in [4]: + for beam_size in [1, 4, 8]: for test_set, split in TEST_DATASETS.items(): + if test_set == "gigaspeech": + continue # TODO: need to ask nick to set a reservaion tag to increase time limit search_job = SearchJob( model_id=MODEL_ID, model_path=model_path, @@ -107,11 +109,11 @@ def py(): search_args={"batch_size": 64, "pnc": False, "max_eval_samples": -1, "beam_size": beam_size}, python_exe=python_exe, device="gpu", - time_rqmt=24, + time_rqmt=0.5, mem_rqmt=8, cpu_rqmt=2, ) - search_job.rqmt["sbatch_args"] = ["-p", "gpu_24gb"] + search_job.rqmt["sbatch_args"] = ["-p", "gpu_test_24gb"] search_job.add_alias(f"canary_1b/beam_search_v5/{test_set}_bs64_beam{beam_size}") tk.register_output( f"canary_1b/beam_search_v5/{test_set}_bs64_beam{beam_size}/search_out", search_job.out_search_results From bd0dfe47f1aadd11de547e46ff4f9bdedcdb4221 Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Tue, 18 Jun 2024 16:52:27 +0200 Subject: [PATCH 200/227] more --- users/zeyer/experiments/exp2024_04_23_baselines/ctc.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py index 8e13c8ef8..138d56d79 100644 --- a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py +++ b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py @@ -165,7 +165,8 @@ def py(): # The higher the alpha, the longer (the reverse as for SPM Unigram). # See archive/returnn-spm_bpe10-sample.config. # spm_bpe10k no sampling: 7.97 - ("spm_bpe10k", 0.001), + ("spm_bpe10k", 0.0001), + ("spm_bpe10k", 0.001), # 8.15 ("spm_bpe10k", 0.005), # 8.66 ("spm_bpe10k", 0.01), # 8.99 # ("spm_bpe10k", 0.3), # broken @@ -174,7 +175,7 @@ def py(): # See archive/returnn-bpe10-sample.config. # The higher the alpha, the longer the sequence, i.e. the more aggressive the sampling. # bpe10k no sampling: 8.23 - ("bpe10k", 0.005), + ("bpe10k", 0.005), # 7.32 ("bpe10k", 0.01), # 7.10 ("bpe10k", 0.02), ]: From 293e11cbf2d70a035285ad3de975d787e7c6f69e Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Tue, 18 Jun 2024 20:33:16 +0200 Subject: [PATCH 201/227] more --- users/zeyer/experiments/exp2024_04_23_baselines/aed.py | 3 ++- users/zeyer/experiments/exp2024_04_23_baselines/ctc.py | 2 ++ 2 files changed, 4 insertions(+), 1 deletion(-) diff --git a/users/zeyer/experiments/exp2024_04_23_baselines/aed.py b/users/zeyer/experiments/exp2024_04_23_baselines/aed.py index 17e26e500..c9319cb50 100644 --- a/users/zeyer/experiments/exp2024_04_23_baselines/aed.py +++ b/users/zeyer/experiments/exp2024_04_23_baselines/aed.py @@ -105,7 +105,8 @@ def py(): # See archive/returnn-bpe10-sample.config. # The higher the alpha, the longer the sequence, i.e. the more aggressive the sampling. # bpe10k without sampling: 5.32 - ("bpe10k", 0.01), + ("bpe10k", 0.01), # 5.25 + ("bpe10k", 0.02), ]: train_exp( f"v6-bhv20-11gb-f32-bs15k-accgrad1-mgpu4-pavg100-wd1e_2-lrlin1e_5_295k-speedpertV2-{vocab}" diff --git a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py index 138d56d79..ee1af23f1 100644 --- a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py +++ b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py @@ -154,6 +154,8 @@ def py(): # Testing different vocabs together with sampling. for vocab, alpha in [ + # spm20k no sampling: 7.44 + ("spm20k", 0.7), # See archive/returnn-spm10-sample.config for playing around with alpha and checking avg seq len. # The lower the alpha, the longer the seq len, i.e. the more aggressive the sampling. # spm10k no sampling: 8.12 From 818a37b9aaf81a2383c3adccc3db1ecf85499ffe Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Tue, 18 Jun 2024 20:35:44 +0200 Subject: [PATCH 202/227] more --- users/zeyer/experiments/exp2024_04_23_baselines/ctc.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py index ee1af23f1..28fae2cce 100644 --- a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py +++ b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py @@ -179,7 +179,7 @@ def py(): # bpe10k no sampling: 8.23 ("bpe10k", 0.005), # 7.32 ("bpe10k", 0.01), # 7.10 - ("bpe10k", 0.02), + ("bpe10k", 0.02), # 7.35 ]: train_exp( f"v6-bhv20-11gb-f32-bs15k-accgrad1-mgpu4-pavg100-wd1e_2-lrlin1e_5_295k-speedpertV2-{vocab}" From 0ed3c7d5e41e1acce7ece8bec31df7d0cb863276 Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Wed, 19 Jun 2024 10:37:31 +0200 Subject: [PATCH 203/227] more --- .../exp2024_04_23_baselines/ctc.py | 36 +++++++++++++++++++ 1 file changed, 36 insertions(+) diff --git a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py index 28fae2cce..ef17629d9 100644 --- a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py +++ b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py @@ -117,6 +117,7 @@ def py(): }, ) + # Comparing vocabs. Note that max_seq_length_default_target=75 always here... for vocab in [ "spm20k", # 7.44 "bpe10k", # 8.23 @@ -138,6 +139,39 @@ def py(): vocab=vocab, ) + # Comparing vocabs with better settings: feature norm, sampling, no max seq len. + for vocab, alpha in [ + ("spm20k", 0.7), + ("bpe10k", 0.01), + ("spm10k", 0.7), + # ("spm_bpe10k", ...), # unclear what sampling scheme... + ("spm4k", 0.7), + ("spm1k", 0.7), + # ("spm_bpe1k", ...) + ]: + train_exp( + f"v6-bhv20-11gb-f32-bs15k-accgrad1-mgpu4-pavg100-maxSeqLenNone" + f"-wd1e_2-lrlin1e_5_295k-featBN-speedpertV2-{vocab}" + f"-{'spmSample' if vocab.startswith('spm') else 'bpeSample'}{str(alpha).replace('.', '')}", + config_11gb_v6_f32_accgrad1_mgpu4_pavg100_wd1e_4, + model_config={"feature_batch_norm": True}, + config_updates={ + **_get_cfg_lrlin_oclr_by_bs_nep(15_000, 500), + "optimizer.weight_decay": 1e-2, + "__train_audio_preprocess": speed_pert_librosa_config, + "speed_pert_discrete_values": [0.7, 0.8, 0.9, 1.0, 1.1], + "max_seq_length_default_target": None, + }, + vocab=vocab, + train_vocab_opts={ + "other_opts": ( + {"enable_sampling": True, "alpha": alpha} + if vocab.startswith("spm") + else {"class": "SamplingBytePairEncoding", "breadth_prob": alpha} + ) + }, + ) + # lrlin1e_5_393k train_exp( f"v6-bhv20-11gb-f32-bs15k-accgrad1-mgpu4-pavg100-wd1e_2-lrlin1e_5_393k-speedpertV2-bpe10k", @@ -201,6 +235,7 @@ def py(): }, ) + # Checking EOS. train_exp( # 7.36 (vs without EOS 6.99), so EOS made it worse "v6-bhv20-11gb-f32-bs15k-accgrad1-mgpu4-pavg100-wd1e_2-lrlin1e_5_295k-speedpertV2-spm10k-eos-spmSample07", config_11gb_v6_f32_accgrad1_mgpu4_pavg100_wd1e_4, @@ -243,6 +278,7 @@ def py(): from i6_experiments.users.zeyer.nn_rf.batchnorm import BatchRenorm + # Replacing batch norm in the Conformer Convolution Module with other normalization schemes. for name, opts in { "batchRenorm": rf.build_dict( BatchRenorm, From a2b6d49e4babcc8aefebf333b3c7390308821219 Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Wed, 19 Jun 2024 10:46:18 +0200 Subject: [PATCH 204/227] LS spm vocab alias --- users/zeyer/datasets/librispeech.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/users/zeyer/datasets/librispeech.py b/users/zeyer/datasets/librispeech.py index 630fc3fbe..4b7c94a1f 100644 --- a/users/zeyer/datasets/librispeech.py +++ b/users/zeyer/datasets/librispeech.py @@ -30,6 +30,8 @@ from i6_experiments.users.zeyer.collect_model_dataset_stats import StatisticsOutput +_alias_prefix = "datasets/LibriSpeech/" + librispeech_ogg_zip_dict = librispeech.get_ogg_zip_dict() # $ ls -la /u/zeyer/setups/librispeech/dataset/tars/ @@ -59,6 +61,7 @@ def _get_spm_vocab( *, dim: Union[int, str], model_type: SentencePieceType = SentencePieceType.UNIGRAM ) -> SentencePieceModel: + dim_str = str(dim) if isinstance(dim, str): # Not sure if power-of-two or just multiple-of-64, but 10240 has more 2s in it (2048*5) than 10048. dim = {"20k": 20_480, "10k": 10_240, "5k": 5_120, "4k": 4_096, "1k": 1_024}[dim] @@ -76,6 +79,7 @@ def _get_spm_vocab( "eos_id": 0, # default is 2 }, ) + _spm_train_job.add_alias(_alias_prefix + f"vocab/spm{dim_str}{model_type}-train") spm = SentencePieceModel( dim=dim, model_file=_spm_train_job.out_model, From e15023279bbd9ee5d15928017f2300ba51d8530a Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Wed, 19 Jun 2024 10:49:19 +0200 Subject: [PATCH 205/227] make private --- users/zeyer/datasets/librispeech.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/users/zeyer/datasets/librispeech.py b/users/zeyer/datasets/librispeech.py index 4b7c94a1f..d5bf26cfd 100644 --- a/users/zeyer/datasets/librispeech.py +++ b/users/zeyer/datasets/librispeech.py @@ -32,7 +32,7 @@ _alias_prefix = "datasets/LibriSpeech/" -librispeech_ogg_zip_dict = librispeech.get_ogg_zip_dict() +_librispeech_ogg_zip_dict = librispeech.get_ogg_zip_dict() # $ ls -la /u/zeyer/setups/librispeech/dataset/tars/ # -rw-r--r-- 1 zeyer assi 360977013 Feb 26 2018 dev-clean.zip @@ -43,7 +43,7 @@ # -rw-r--r-- 1 zeyer assi 6625963133 Feb 26 2018 train-clean-100.zip # -rw-r--r-- 1 zeyer assi 23919296392 Feb 26 2018 train-clean-360.zip # -rw-r--r-- 1 zeyer assi 31839925140 Feb 26 2018 train-other-500.zip -librispeech_tars_zip_base_path = tk.Path( +_librispeech_tars_zip_base_path = tk.Path( "/u/zeyer/setups/librispeech/dataset/tars", hash_overwrite="Librispeech-tars-zip-base-path" ) @@ -181,7 +181,7 @@ def _get_dataset(key: str, *, subset=None, train_partition_epoch=None, training: parts = [part for part in _Parts if part.startswith(key)] assert parts, f"invalid key {key!r}" for part in parts: - files += [librispeech_ogg_zip_dict[part]] + files += [_librispeech_ogg_zip_dict[part]] d = { "class": "OggZipDataset", "path": files, @@ -328,7 +328,7 @@ def get_dataset(self, key: str, *, training: bool = False, subset: Optional[int] parts = [part for part in _Parts if part.startswith(key)] assert parts, f"invalid key {key!r}" for part in parts: - files += [librispeech_ogg_zip_dict[part]] + files += [_librispeech_ogg_zip_dict[part]] d = { "class": "OggZipDataset", "path": files, @@ -457,7 +457,7 @@ def get_main_dataset(self) -> Dict[str, Any]: def get_dataset(self, key: str, *, training: bool = False, subset: Optional[int] = None) -> Dict[str, Any]: d = { "class": "LibriSpeechCorpus", - "path": librispeech_tars_zip_base_path, + "path": _librispeech_tars_zip_base_path, "use_zip": True, "prefix": key, "use_cache_manager": True, From ac81ea89a68169106a1c4d3a0a8a014c3d0dee0b Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Wed, 19 Jun 2024 10:51:29 +0200 Subject: [PATCH 206/227] move --- users/zeyer/datasets/librispeech.py | 28 ++++++++++++++-------------- 1 file changed, 14 insertions(+), 14 deletions(-) diff --git a/users/zeyer/datasets/librispeech.py b/users/zeyer/datasets/librispeech.py index d5bf26cfd..e4790b229 100644 --- a/users/zeyer/datasets/librispeech.py +++ b/users/zeyer/datasets/librispeech.py @@ -34,19 +34,6 @@ _librispeech_ogg_zip_dict = librispeech.get_ogg_zip_dict() -# $ ls -la /u/zeyer/setups/librispeech/dataset/tars/ -# -rw-r--r-- 1 zeyer assi 360977013 Feb 26 2018 dev-clean.zip -# -rw-r--r-- 1 zeyer assi 338709788 Feb 26 2018 dev-other.zip -# -rw-r--r-- 1 zeyer assi 1024 Feb 27 2018 .history.zeyer -# -rw-r--r-- 1 zeyer assi 369096021 Feb 26 2018 test-clean.zip -# -rw-r--r-- 1 zeyer assi 353841318 Feb 26 2018 test-other.zip -# -rw-r--r-- 1 zeyer assi 6625963133 Feb 26 2018 train-clean-100.zip -# -rw-r--r-- 1 zeyer assi 23919296392 Feb 26 2018 train-clean-360.zip -# -rw-r--r-- 1 zeyer assi 31839925140 Feb 26 2018 train-other-500.zip -_librispeech_tars_zip_base_path = tk.Path( - "/u/zeyer/setups/librispeech/dataset/tars", hash_overwrite="Librispeech-tars-zip-base-path" -) - # Get Bliss corpus. Same audio format as in ogg_zip, so already there anyway due to how we created the ogg_zip. # WARNING: Do not use these directly... It will keep another ogg copy of the audio... # However, these are used later in the scoring, so when changing them, make sure it's optional, @@ -372,6 +359,19 @@ class LibrispeechOldFlacTarZip(DatasetConfig): i.e. keeping the original flac files inside the zip files. """ + # $ ls -la /u/zeyer/setups/librispeech/dataset/tars/ + # -rw-r--r-- 1 zeyer assi 360977013 Feb 26 2018 dev-clean.zip + # -rw-r--r-- 1 zeyer assi 338709788 Feb 26 2018 dev-other.zip + # -rw-r--r-- 1 zeyer assi 1024 Feb 27 2018 .history.zeyer + # -rw-r--r-- 1 zeyer assi 369096021 Feb 26 2018 test-clean.zip + # -rw-r--r-- 1 zeyer assi 353841318 Feb 26 2018 test-other.zip + # -rw-r--r-- 1 zeyer assi 6625963133 Feb 26 2018 train-clean-100.zip + # -rw-r--r-- 1 zeyer assi 23919296392 Feb 26 2018 train-clean-360.zip + # -rw-r--r-- 1 zeyer assi 31839925140 Feb 26 2018 train-other-500.zip + _librispeech_tars_zip_base_path = tk.Path( + "/u/zeyer/setups/librispeech/dataset/tars", hash_overwrite="Librispeech-tars-zip-base-path" + ) + def __init__( self, *, @@ -457,7 +457,7 @@ def get_main_dataset(self) -> Dict[str, Any]: def get_dataset(self, key: str, *, training: bool = False, subset: Optional[int] = None) -> Dict[str, Any]: d = { "class": "LibriSpeechCorpus", - "path": _librispeech_tars_zip_base_path, + "path": self._librispeech_tars_zip_base_path, "use_zip": True, "prefix": key, "use_cache_manager": True, From 222a1c59635f74efe1636f9ffe1357237b705787 Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Wed, 19 Jun 2024 11:11:07 +0200 Subject: [PATCH 207/227] lazy, aliases --- users/zeyer/datasets/librispeech.py | 49 ++++++++++++++++++++--------- 1 file changed, 34 insertions(+), 15 deletions(-) diff --git a/users/zeyer/datasets/librispeech.py b/users/zeyer/datasets/librispeech.py index e4790b229..2a068c7c0 100644 --- a/users/zeyer/datasets/librispeech.py +++ b/users/zeyer/datasets/librispeech.py @@ -32,16 +32,35 @@ _alias_prefix = "datasets/LibriSpeech/" -_librispeech_ogg_zip_dict = librispeech.get_ogg_zip_dict() -# Get Bliss corpus. Same audio format as in ogg_zip, so already there anyway due to how we created the ogg_zip. -# WARNING: Do not use these directly... It will keep another ogg copy of the audio... -# However, these are used later in the scoring, so when changing them, make sure it's optional, -# to not break hashes of old setups. -_bliss_corpus_dict = librispeech.get_bliss_corpus_dict(audio_format="ogg") -_corpus_text_dicts = {k: CorpusToTextDictJob(v, gzip=True).out_dictionary for k, v in _bliss_corpus_dict.items()} -_train_corpus_text_dict = _corpus_text_dicts["train-other-960"] -_train_corpus_text = TextDictToTextLinesJob(_train_corpus_text_dict, gzip=True).out_text_lines +@cache +def _get_librispeech_ogg_zip_dict() -> Dict[str, tk.Path]: + return librispeech.get_ogg_zip_dict() + + +@cache +def _get_bliss_corpus_dict() -> Dict[str, tk.Path]: + # Get Bliss corpus. Same audio format as in ogg_zip, so already there anyway due to how we created the ogg_zip. + # WARNING: Do not use these directly... It will keep another ogg copy of the audio... + # However, these are used later in the scoring, so when changing them, make sure it's optional, + # to not break hashes of old setups. + return librispeech.get_bliss_corpus_dict(audio_format="ogg") + + +@cache +def _get_corpus_text_dict(key: str) -> tk.Path: + job = CorpusToTextDictJob(_get_bliss_corpus_dict()[key], gzip=True) + job.add_alias(_alias_prefix + f"{key.replace('-', '_')}_corpus_text_dict") + return job.out_dictionary + + +@cache +def _get_train_corpus_text() -> tk.Path: + key = "train-other-960" + train_corpus_text_dict = _get_corpus_text_dict(key) + job = TextDictToTextLinesJob(train_corpus_text_dict, gzip=True) + job.add_alias(_alias_prefix + f"{key.replace('-', '_')}_corpus_text_lines") + return job.out_text_lines @cache @@ -56,7 +75,7 @@ def _get_spm_vocab( # https://github.com/google/sentencepiece/blob/master/doc/options.md _spm_train_job = TrainSentencePieceJob( - training_text=_train_corpus_text, + training_text=_get_train_corpus_text(), vocab_size=dim, model_type=model_type, additional_options={ @@ -66,7 +85,7 @@ def _get_spm_vocab( "eos_id": 0, # default is 2 }, ) - _spm_train_job.add_alias(_alias_prefix + f"vocab/spm{dim_str}{model_type}-train") + _spm_train_job.add_alias(_alias_prefix + f"vocab/spm_{model_type.name.lower()}_{dim_str}_train") spm = SentencePieceModel( dim=dim, model_file=_spm_train_job.out_model, @@ -168,7 +187,7 @@ def _get_dataset(key: str, *, subset=None, train_partition_epoch=None, training: parts = [part for part in _Parts if part.startswith(key)] assert parts, f"invalid key {key!r}" for part in parts: - files += [_librispeech_ogg_zip_dict[part]] + files += [_get_librispeech_ogg_zip_dict()[part]] d = { "class": "OggZipDataset", "path": files, @@ -315,7 +334,7 @@ def get_dataset(self, key: str, *, training: bool = False, subset: Optional[int] parts = [part for part in _Parts if part.startswith(key)] assert parts, f"invalid key {key!r}" for part in parts: - files += [_librispeech_ogg_zip_dict[part]] + files += [_get_librispeech_ogg_zip_dict()[part]] d = { "class": "OggZipDataset", "path": files, @@ -652,7 +671,7 @@ def _score_recog_out_v1(dataset: DatasetConfig, recog_output: RecogOutput) -> Sc hyp_words = recog_output.output corpus_name = dataset.get_main_name() - bliss_corpus = _bliss_corpus_dict[corpus_name] + bliss_corpus = _get_bliss_corpus_dict()[corpus_name] search_ctm = SearchWordsToCTMJob(recog_words_file=hyp_words, bliss_corpus=bliss_corpus).out_ctm_file stm_file = CorpusToStmJob(bliss_corpus=bliss_corpus).out_stm_path @@ -674,7 +693,7 @@ def _score_recog_out_v2(dataset: DatasetConfig, recog_output: RecogOutput) -> Sc hyp_words = recog_output.output corpus_name = dataset.get_main_name() - corpus_text_dict = _corpus_text_dicts[corpus_name] + corpus_text_dict = _get_corpus_text_dict(corpus_name) # Arbitrary seg length time. The jobs SearchWordsDummyTimesToCTMJob and TextDictToStmJob # serialize two points after decimal, so long seqs (>1h or so) might be problematic, # and no reason not to just use a high value here to avoid this problem whenever we get to it. From 323b0f8e0e49f46dfdca2586ce7df59452fd5079 Mon Sep 17 00:00:00 2001 From: "luca.gaudino" Date: Wed, 19 Jun 2024 13:23:29 +0200 Subject: [PATCH 208/227] update and test rf vs torch mhsa --- users/gaudino/datasets/librispeech.py | 11 + .../rnnt/decoder/experimental_rnnt_decoder.py | 6 + .../rnnt/decoder/rnnt_beam_search.py | 1 + .../conformer_import_moh_att_train.py | 58 ++++- .../librispeech_960/_import_model_nick.py | 181 +++++++++----- .../_test_returnn_torch_mhsa.py | 140 +++++++++++ .../librispeech_960/conformer_ctc_train.py | 19 ++ .../librispeech_960/conformer_rnnt_train.py | 88 +++++-- .../rf/conformer_ctc/model_conformer_ctc.py | 3 +- .../rf/conformer_rnnt/model_conformer_rnnt.py | 232 ++++++++++++++++-- .../asr/rf/conformer_rnnt/model_recog_rnnt.py | 2 + 11 files changed, 626 insertions(+), 115 deletions(-) create mode 100644 users/gaudino/experiments/rf_conformer_rnnt_2024/librispeech_960/_test_returnn_torch_mhsa.py diff --git a/users/gaudino/datasets/librispeech.py b/users/gaudino/datasets/librispeech.py index be0d7d821..7ee057ea6 100644 --- a/users/gaudino/datasets/librispeech.py +++ b/users/gaudino/datasets/librispeech.py @@ -53,6 +53,15 @@ # unknown_label="", unknown_label=None, ) +bpe5k = Bpe( + dim=5_048, + eos_idx=0, + bos_idx=0, + codes=generic_job_output("i6_core/text/label/subword_nmt/train/ReturnnTrainBpeJob.yH3Z10x9CgDt/output/bpe.codes"), + vocab=generic_job_output("i6_core/text/label/subword_nmt/train/ReturnnTrainBpeJob.yH3Z10x9CgDt/output/bpe.vocab"), + # unknown_label="", + unknown_label=None, +) _Parts = ["train-clean-100", "train-clean-360", "train-other-500", "dev-clean", "dev-other", "test-clean", "test-other"] @@ -310,6 +319,8 @@ def get_librispeech_task_raw(*, vocab: VocabConfig, **dataset_train_opts) -> Tas def get_librispeech_task_bpe10k_raw(**dataset_train_opts) -> Task: return get_librispeech_task_raw(vocab=bpe10k, **dataset_train_opts) +def get_librispeech_task_bpe5k_raw(**dataset_train_opts) -> Task: + return get_librispeech_task_raw(vocab=bpe5k, **dataset_train_opts) def _bpe_to_words(bpe: RecogOutput) -> RecogOutput: """BPE to words""" diff --git a/users/gaudino/experiments/ctc_rnnt_standalone_2024/librispeech_960/pytorch_networks/rnnt/decoder/experimental_rnnt_decoder.py b/users/gaudino/experiments/ctc_rnnt_standalone_2024/librispeech_960/pytorch_networks/rnnt/decoder/experimental_rnnt_decoder.py index 139fef54e..bccd05905 100644 --- a/users/gaudino/experiments/ctc_rnnt_standalone_2024/librispeech_960/pytorch_networks/rnnt/decoder/experimental_rnnt_decoder.py +++ b/users/gaudino/experiments/ctc_rnnt_standalone_2024/librispeech_960/pytorch_networks/rnnt/decoder/experimental_rnnt_decoder.py @@ -76,12 +76,18 @@ def forward(self, input: torch.Tensor, lengths: torch.Tensor) -> Tuple[torch.Ten """ squeezed_features = torch.squeeze(input) + breakpoint() with torch.no_grad(): audio_features, audio_features_len = self.feature_extraction(squeezed_features, lengths) mask = mask_tensor(audio_features, audio_features_len) + breakpoint() + encoder_out, out_mask = self.encoder(audio_features, mask) + + breakpoint() + encoder_out = self.mapping(encoder_out) encoder_out_lengths = torch.sum(out_mask, dim=1) # [B, T] -> [B] diff --git a/users/gaudino/experiments/ctc_rnnt_standalone_2024/librispeech_960/pytorch_networks/rnnt/decoder/rnnt_beam_search.py b/users/gaudino/experiments/ctc_rnnt_standalone_2024/librispeech_960/pytorch_networks/rnnt/decoder/rnnt_beam_search.py index d8a488928..996d818bf 100644 --- a/users/gaudino/experiments/ctc_rnnt_standalone_2024/librispeech_960/pytorch_networks/rnnt/decoder/rnnt_beam_search.py +++ b/users/gaudino/experiments/ctc_rnnt_standalone_2024/librispeech_960/pytorch_networks/rnnt/decoder/rnnt_beam_search.py @@ -77,6 +77,7 @@ def forward_semi_batched( Returns: List[Hypothesis]: top-``beam_width`` hypotheses found by beam search. """ + if input.dim() != 3: raise ValueError("input must be of shape (B, T, D)") diff --git a/users/gaudino/experiments/rf_conformer_att_2023/librispeech_960/conformer_import_moh_att_train.py b/users/gaudino/experiments/rf_conformer_att_2023/librispeech_960/conformer_import_moh_att_train.py index 475f6d6d7..a86dfd478 100644 --- a/users/gaudino/experiments/rf_conformer_att_2023/librispeech_960/conformer_import_moh_att_train.py +++ b/users/gaudino/experiments/rf_conformer_att_2023/librispeech_960/conformer_import_moh_att_train.py @@ -323,8 +323,35 @@ def sis_run_with_prefix(prefix_name: Optional[str] = None): # # OOM in ep 889 # post_config_updates={"PYTORCH_CUDA_ALLOC_CONF": "backend:cudaMallocAsync"}, # ) - model = train_exp( # 5.41 - "base-24gb-v6-lrlin1e_5_600k", + + + # model = train_exp( # 5.41 + # "base-24gb-v6-lrlin1e_5_600k", + # config_24gb_v6, + # config_updates={ + # "learning_rate": 1.0, + # "dynamic_learning_rate": dyn_lr_piecewise_linear, + # # total steps after 2000 epochs: 982.312 + # "learning_rate_piecewise_steps": [600_000, 900_000, 982_000], + # "learning_rate_piecewise_values": [1e-5, 1e-3, 1e-5, 1e-6], + # }, + # ) + # model = train_exp( # 5.42 + # "base-24gb-v6-lrlin1e_5_600k_noCTC", + # config_24gb_v6, + # config_updates={ + # "learning_rate": 1.0, + # "dynamic_learning_rate": dyn_lr_piecewise_linear, + # # total steps after 2000 epochs: 982.312 + # "learning_rate_piecewise_steps": [600_000, 900_000, 982_000], + # "learning_rate_piecewise_values": [1e-5, 1e-3, 1e-5, 1e-6], + # "aux_loss_layers": [], + # }, + # ) + + # train with bpe5k vocab + model = train_exp( + "base-24gb-v6-lrlin1e_5_600k-bpe5k", config_24gb_v6, config_updates={ "learning_rate": 1.0, @@ -332,10 +359,12 @@ def sis_run_with_prefix(prefix_name: Optional[str] = None): # total steps after 2000 epochs: 982.312 "learning_rate_piecewise_steps": [600_000, 900_000, 982_000], "learning_rate_piecewise_values": [1e-5, 1e-3, 1e-5, 1e-6], + "bpe_size": "BPE5k", }, + bpe_size="BPE5k", ) - model = train_exp( # 5.42 - "base-24gb-v6-lrlin1e_5_600k_noCTC", + model = train_exp( + "base-24gb-v6-lrlin1e_5_600k_noCTC-bpe5k", config_24gb_v6, config_updates={ "learning_rate": 1.0, @@ -344,8 +373,11 @@ def sis_run_with_prefix(prefix_name: Optional[str] = None): "learning_rate_piecewise_steps": [600_000, 900_000, 982_000], "learning_rate_piecewise_values": [1e-5, 1e-3, 1e-5, 1e-6], "aux_loss_layers": [], + "bpe_size": "BPE5k", }, + bpe_size="BPE5k", ) + # All beam search experiments using model_recog_pure_torch, beam_search_sep_ended_keep_v6. # for name, recog_config in { # "beam12-batch200-lenReward01": { @@ -1027,6 +1059,7 @@ def train_exp( fine_tune: Optional[Union[int, List[Tuple[int, Dict[str, Any]]]]] = None, time_rqmt: Optional[int] = None, model_avg: bool = False, + bpe_size: str = "BPE10k", ) -> ModelWithCheckpoints: """ Train experiment @@ -1034,13 +1067,13 @@ def train_exp( from i6_experiments.users.gaudino.experiments.rf_conformer_att_2023.train import ( train, ) - from i6_experiments.users.zeyer.recog import recog_training_exp + from i6_experiments.users.gaudino.recog_2 import recog_training_exp if _sis_prefix is None: _sis_setup_global_prefix() prefix = _sis_prefix + "/" + name - task = _get_ls_task() + task = _get_ls_task(bpe_size) config = config.copy() config = dict_update_deep(config, config_updates, config_deletes) if "__num_epochs" in config: @@ -1127,16 +1160,21 @@ def train_exp( _ls_task = None -def _get_ls_task(): +def _get_ls_task(bpe_size): global _ls_task if _ls_task: return _ls_task - from i6_experiments.users.zeyer.datasets.librispeech import ( - get_librispeech_task_bpe10k_raw, + from i6_experiments.users.gaudino.datasets.librispeech import ( + get_librispeech_task_bpe10k_raw, get_librispeech_task_bpe5k_raw ) - _ls_task = get_librispeech_task_bpe10k_raw(with_eos_postfix=True) + if bpe_size == "BPE10k": + _ls_task = get_librispeech_task_bpe10k_raw(with_eos_postfix=True) + + if bpe_size == "BPE5k": + _ls_task = get_librispeech_task_bpe5k_raw(with_eos_postfix=True) + return _ls_task diff --git a/users/gaudino/experiments/rf_conformer_rnnt_2024/librispeech_960/_import_model_nick.py b/users/gaudino/experiments/rf_conformer_rnnt_2024/librispeech_960/_import_model_nick.py index 0a4835e40..d944d6c95 100644 --- a/users/gaudino/experiments/rf_conformer_rnnt_2024/librispeech_960/_import_model_nick.py +++ b/users/gaudino/experiments/rf_conformer_rnnt_2024/librispeech_960/_import_model_nick.py @@ -18,7 +18,9 @@ MakeModel, ) -from i6_experiments.users.gaudino.models.asr.rf.conformer_rnnt.model_conformer_rnnt import MakeModel as MakeModelRNNT +from i6_experiments.users.gaudino.models.asr.rf.conformer_rnnt.model_conformer_rnnt import ( + MakeModelV2 as MakeModelRNNT, +) from i6_experiments.users.gaudino.models.asr.rf.nn_lm.lm_import_2023_11_09 import ( MakeModel as MakeModelLM, @@ -38,7 +40,9 @@ _nick_pure_torch_rnnt_ckpt_path = "/work/asr4/rossenbach/sisyphus_work_folders/tts_decoder_asr_work/i6_core/returnn/training/ReturnnTrainingJob.6lwn4XuFkhkI/output/models/epoch.250.pt" -from i6_experiments.users.gaudino.experiments.conformer_att_2023.tedlium2.model_ckpt_info import models +from i6_experiments.users.gaudino.experiments.conformer_att_2023.tedlium2.model_ckpt_info import ( + models, +) def convert_checkpoint( @@ -63,13 +67,12 @@ def convert_checkpoint( print(f"{k}: {v.shape if hasattr(v, 'shape') else v}") # print(reader.debug_string().decode("utf-8")) - print() - print("Creating model...") rf.select_backend_torch() - model = MakeModelRNNT(80, 1_057)() + # model = MakeModelRNNT(80, 1_057)() + model = MakeModelRNNT(80, 5048)() print("Created model:", model) print("Model parameters:") @@ -83,7 +86,8 @@ def convert_checkpoint( print("Create ParamMapping...") param_mapping = {} _add_params_predictor_joiner(param_mapping) - # _add_params_conformer(param_mapping, prefix="") + _add_params_conformer(param_mapping, prefix="") + # if not ctc_only: # _add_params_att_decoder(param_mapping) # _add_params_trafo_lm(param_mapping) @@ -91,14 +95,13 @@ def convert_checkpoint( # _add_params_conformer(param_mapping, prefix="sep_enc_ctc_") for name, param in model.named_parameters(): - if name in param_mapping: - assert isinstance(name, str) - assert isinstance(param, rf.Parameter) + assert isinstance(name, str) + assert isinstance(param, rf.Parameter) - value = map_param_func(ckpt, name, param, param_mapping) - assert isinstance(value, numpy.ndarray) - # noinspection PyProtectedMember - param._raw_backend.set_parameter_initial_value(param, value) + value = map_param_func(ckpt, name, param, param_mapping) + assert isinstance(value, numpy.ndarray) + # noinspection PyProtectedMember + param._raw_backend.set_parameter_initial_value(param, value) epoch = 1 if epoch is None: @@ -114,11 +117,9 @@ def convert_checkpoint( pt_model = rf_module_to_pt_module(model) - breakpoint() - if save_model: os.makedirs(out_dir, exist_ok=True) - filename = out_dir + "/" + ckpt_name + ".pt" + filename = out_dir + "/" + ckpt_name # + ".pt" print(f"*** saving PyTorch model checkpoint: {filename}") torch.save( {"model": pt_model.state_dict(), "epoch": epoch, "step": step}, filename @@ -139,98 +140,145 @@ def convert_checkpoint( os.symlink(os.path.basename(meta_filename), symlink_filename_2) # assert os.path.exists(self.out_checkpoint.get_path()) + +_transpose_list = [ + "encoder_out_linear.weight", + "encoder.input_projection.weight", + "joiner.linear.weight", + "predictor.linear.weight", +] + +for layer_idx in range(12): + _transpose_list.append(f"encoder.layers.{layer_idx}.ffn1.linear_ff.weight") + _transpose_list.append(f"encoder.layers.{layer_idx}.ffn1.linear_out.weight") + _transpose_list.append(f"encoder.layers.{layer_idx}.ffn2.linear_ff.weight") + _transpose_list.append(f"encoder.layers.{layer_idx}.ffn2.linear_out.weight") + + _transpose_list.append( + f"encoder.layers.{layer_idx}.conv_block.positionwise_conv1.weight" + ) + _transpose_list.append( + f"encoder.layers.{layer_idx}.self_att.qkv.weight" + ) + + def _add_params_conformer(param_mapping: Dict[str, str], prefix: str): # rf -> pt # frontend - for layer_idx in [0, 1, 2]: - orig_name = "conv0" if layer_idx == 0 else f"subsample_conv{layer_idx - 1}" + for layer_idx in [0, 1, 2, 3]: + orig_name = f"conformer.frontend.conv{layer_idx + 1}" param_mapping.update( { prefix - + f"encoder.input_layer.conv_layers.{layer_idx}.filter": f"{orig_name}/W", + + f"enc_input_layer.conv_layers.{layer_idx}.filter": f"{orig_name}.weight", prefix - + f"encoder.input_layer.conv_layers.{layer_idx}.bias": f"{orig_name}/bias", + + f"enc_input_layer.conv_layers.{layer_idx}.bias": f"{orig_name}.bias", } ) param_mapping.update( { - prefix + "encoder.input_projection.weight": "source_linear/W", + prefix + + "encoder.input_projection.weight": "conformer.frontend.linear.weight", + prefix + "encoder.input_projection.bias": "conformer.frontend.linear.bias", # prefix + "ctc.weight": "ctc/W", # prefix + "ctc.bias": "ctc/b", - prefix + "enc_aux_logits_12.weight": "ctc/W", - prefix + "enc_aux_logits_12.bias": "ctc/b", + # prefix + "enc_aux_logits_12.weight": "ctc/W", + # prefix + "enc_aux_logits_12.bias": "ctc/b", } ) # conformer for layer_idx in range(12): + orig_name_prefix = f"conformer.module_list.{layer_idx}." # FF for sub in [1, 2]: param_mapping[ prefix + f"encoder.layers.{layer_idx}.ffn{sub}.linear_ff.weight" - ] = f"conformer_block_{layer_idx + 1:02d}_ffmod_{sub}_ff1/W" + ] = (orig_name_prefix + f"ff{sub}.linear_ff.weight") param_mapping[ prefix + f"encoder.layers.{layer_idx}.ffn{sub}.linear_ff.bias" - ] = f"conformer_block_{layer_idx + 1:02d}_ffmod_{sub}_ff1/b" + ] = (orig_name_prefix + f"ff{sub}.linear_ff.bias") param_mapping[ prefix + f"encoder.layers.{layer_idx}.ffn{sub}.linear_out.weight" - ] = f"conformer_block_{layer_idx + 1:02d}_ffmod_{sub}_ff2/W" + ] = (orig_name_prefix + f"ff{sub}.linear_out.weight") param_mapping[ prefix + f"encoder.layers.{layer_idx}.ffn{sub}.linear_out.bias" - ] = f"conformer_block_{layer_idx + 1:02d}_ffmod_{sub}_ff2/b" + ] = (orig_name_prefix + f"ff{sub}.linear_out.bias") param_mapping[ prefix + f"encoder.layers.{layer_idx}.ffn{sub}_layer_norm.scale" - ] = f"conformer_block_{layer_idx + 1:02d}_ffmod_{sub}_ln/scale" + ] = (orig_name_prefix + f"ff{sub}.layer_norm.weight") param_mapping[ prefix + f"encoder.layers.{layer_idx}.ffn{sub}_layer_norm.bias" - ] = f"conformer_block_{layer_idx + 1:02d}_ffmod_{sub}_ln/bias" + ] = (orig_name_prefix + f"ff{sub}.layer_norm.bias") # conv param_mapping[ prefix + f"encoder.layers.{layer_idx}.conv_block.positionwise_conv1.weight" - ] = f"conformer_block_{layer_idx + 1:02d}_conv_mod_pointwise_conv1/W" + ] = (orig_name_prefix + "conv.pointwise_conv1.weight") param_mapping[ prefix + f"encoder.layers.{layer_idx}.conv_block.positionwise_conv1.bias" - ] = f"conformer_block_{layer_idx + 1:02d}_conv_mod_pointwise_conv1/b" + ] = (orig_name_prefix + "conv.pointwise_conv1.bias") param_mapping[ prefix + f"encoder.layers.{layer_idx}.conv_block.depthwise_conv.filter" - ] = f"conformer_block_{layer_idx + 1:02d}_conv_mod_depthwise_conv2/W" + ] = (orig_name_prefix + "conv.depthwise_conv.weight") param_mapping[ prefix + f"encoder.layers.{layer_idx}.conv_block.depthwise_conv.bias" - ] = f"conformer_block_{layer_idx + 1:02d}_conv_mod_depthwise_conv2/bias" + ] = (orig_name_prefix + "conv.depthwise_conv.bias") param_mapping[ prefix + f"encoder.layers.{layer_idx}.conv_block.positionwise_conv2.weight" - ] = f"conformer_block_{layer_idx + 1:02d}_conv_mod_pointwise_conv2/W" + ] = (orig_name_prefix + "conv.pointwise_conv2.weight") param_mapping[ prefix + f"encoder.layers.{layer_idx}.conv_block.positionwise_conv2.bias" - ] = f"conformer_block_{layer_idx + 1:02d}_conv_mod_pointwise_conv2/b" - param_mapping[ - prefix + f"encoder.layers.{layer_idx}.conv_layer_norm.scale" - ] = f"conformer_block_{layer_idx + 1:02d}_conv_mod_ln/scale" - param_mapping[ - prefix + f"encoder.layers.{layer_idx}.conv_layer_norm.bias" - ] = f"conformer_block_{layer_idx + 1:02d}_conv_mod_ln/bias" + ] = (orig_name_prefix + "conv.pointwise_conv2.bias") + param_mapping[prefix + f"encoder.layers.{layer_idx}.conv_block.norm.gamma"] = ( + orig_name_prefix + "conv.norm.weight" + ) + param_mapping[prefix + f"encoder.layers.{layer_idx}.conv_block.norm.beta"] = ( + orig_name_prefix + "conv.norm.bias" + ) + param_mapping[prefix + f"encoder.layers.{layer_idx}.conv_layer_norm.scale"] = ( + orig_name_prefix + "conv.layer_norm.weight" + ) + param_mapping[prefix + f"encoder.layers.{layer_idx}.conv_layer_norm.bias"] = ( + orig_name_prefix + "conv.layer_norm.bias" + ) # self-att - param_mapping[ - prefix + f"encoder.layers.{layer_idx}.self_att.qkv.weight" - ] = f"conformer_block_{layer_idx + 1:02d}_self_att/QKV" - param_mapping[ - prefix + f"encoder.layers.{layer_idx}.self_att.proj.weight" - ] = f"conformer_block_{layer_idx + 1:02d}_self_att_linear/W" + param_mapping[prefix + f"encoder.layers.{layer_idx}.self_att.qkv.weight"] = ( + orig_name_prefix + "mhsa.mhsa.in_proj_weight" + ) + param_mapping[prefix + f"encoder.layers.{layer_idx}.self_att.qkv.bias"] = ( + orig_name_prefix + "mhsa.mhsa.in_proj_bias" + ) + param_mapping[prefix + f"encoder.layers.{layer_idx}.self_att.proj.weight"] = ( + orig_name_prefix + "mhsa.mhsa.out_proj.weight" + ) + param_mapping[prefix + f"encoder.layers.{layer_idx}.self_att.proj.bias"] = ( + orig_name_prefix + "mhsa.mhsa.out_proj.bias" + ) param_mapping[ prefix + f"encoder.layers.{layer_idx}.self_att_layer_norm.scale" - ] = f"conformer_block_{layer_idx + 1:02d}_self_att_ln/scale" + ] = (orig_name_prefix + "mhsa.layernorm.weight") param_mapping[ prefix + f"encoder.layers.{layer_idx}.self_att_layer_norm.bias" - ] = f"conformer_block_{layer_idx + 1:02d}_self_att_ln/bias" - param_mapping[ - prefix + f"encoder.layers.{layer_idx}.self_att.learned_pos_emb.pos_emb" - ] = f"conformer_block_{layer_idx + 1:02d}_self_att_ln_rel_pos_enc/encoding_matrix" + ] = (orig_name_prefix + "mhsa.layernorm.bias") + # param_mapping[ + # prefix + f"encoder.layers.{layer_idx}.self_att.learned_pos_emb.pos_emb" + # ] = f"conformer_block_{layer_idx + 1:02d}_self_att_ln_rel_pos_enc/encoding_matrix" + # final layer norm - param_mapping[ - prefix + f"encoder.layers.{layer_idx}.final_layer_norm.scale" - ] = f"conformer_block_{layer_idx + 1:02d}_ln/scale" - param_mapping[ - prefix + f"encoder.layers.{layer_idx}.final_layer_norm.bias" - ] = f"conformer_block_{layer_idx + 1:02d}_ln/bias" + param_mapping[prefix + f"encoder.layers.{layer_idx}.final_layer_norm.scale"] = ( + orig_name_prefix + "final_layer_norm.weight" + ) + param_mapping[prefix + f"encoder.layers.{layer_idx}.final_layer_norm.bias"] = ( + orig_name_prefix + "final_layer_norm.bias" + ) + + # output layer + param_mapping.update( + { + prefix + "encoder_out_linear.weight": "encoder_out_linear.weight", + prefix + "encoder_out_linear.bias": "encoder_out_linear.bias", + } + ) + def _add_params_predictor_joiner(param_mapping: Dict[str, str]): # add params of trafo lm @@ -238,7 +286,6 @@ def _add_params_predictor_joiner(param_mapping: Dict[str, str]): param_mapping.update( { f"predictor.layers.{layer_idx}.ff_weight": f"predictor.lstm_layers.{layer_idx}.weight_ih_l0", - f"predictor.layers.{layer_idx}.rec_weight": f"predictor.lstm_layers.{layer_idx}.weight_hh_l0", f"predictor.layers.{layer_idx}.bias": f"predictor.lstm_layers.{layer_idx}.bias_ih_l0", } @@ -274,12 +321,14 @@ def map_param_func( assert isinstance(var, rf.Parameter) if name in param_mapping: - breakpoint() var_name = param_mapping[name] - assert name in ckpt["model"].keys(), f"missing {var_name}" - value = ckpt["model"][name].numpy() + assert var_name in ckpt["model"].keys(), f"missing {var_name}" + value = ckpt["model"][var_name].numpy() assert isinstance(value, numpy.ndarray) + if name in _transpose_list: + value = value.T + assert ( value.shape == var.batch_shape ), f"new param {name} {var.batch_shape} vs ckpt param {var_name} {value.shape}" @@ -328,6 +377,10 @@ def map_param_func( raise NotImplementedError(f"cannot map {name!r} {var}") - if __name__ == "__main__": - convert_checkpoint(ckpt_path=_nick_pure_torch_rnnt_ckpt_path, print_params=True, out_dir="", save_model=False) \ No newline at end of file + convert_checkpoint( + ckpt_path=_nick_pure_torch_rnnt_ckpt_path, + print_params=True, + out_dir="/work/asr3/zeineldeen/hiwis/luca.gaudino/setups-data/2023-08-10--rf-librispeech/work/i6_experiments/users/gaudino/returnn/convert_ckpt_rf/librispeech/rnnt_nick_240614", + save_model=True, + ) diff --git a/users/gaudino/experiments/rf_conformer_rnnt_2024/librispeech_960/_test_returnn_torch_mhsa.py b/users/gaudino/experiments/rf_conformer_rnnt_2024/librispeech_960/_test_returnn_torch_mhsa.py new file mode 100644 index 000000000..11b545e0d --- /dev/null +++ b/users/gaudino/experiments/rf_conformer_rnnt_2024/librispeech_960/_test_returnn_torch_mhsa.py @@ -0,0 +1,140 @@ +# test whether the torch and returnn implementation of the mhsa layer are equivalent + +import torch + +import returnn.frontend as rf + +from returnn.tensor import Dim + +import itertools + +torch.backends.mha.set_fastpath_enabled(False) + +rf.select_backend_torch() +rf.init_forward_step_run_ctx() + +spatial_dim = Dim(3, name="spatial_dim") +out_dim = Dim(512, name="out_dim") + +random_opts = { + "distribution": "normal", + "dtype": "float32", +} + +rf.set_random_seed(1) + +rf_input = rf.random(dims=[Dim(1), spatial_dim, out_dim], **random_opts) + +qkv_weight = rf.random(dims=[out_dim, 3*out_dim], **random_opts) +# qkv_weight = rf.full(dims=[out_dim, 3*out_dim], fill_value=0.0, dtype="float32") +# qkv_weight.raw_tensor[:,1024:] = 0.0 +# qkv_weight.raw_tensor[:,0:1023] = 0.0 +# +# eye = torch.eye(512) +# zeros = torch.zeros(512, 512) +# +# qkv_raw = torch.cat([eye, eye, zeros], dim=1) +# +# qkv_weight.raw_tensor = qkv_raw + +qkv_bias = rf.random(dims=[3*out_dim], **random_opts) +# qkv_bias = rf.full(dims=[3*out_dim], fill_value=0.0, dtype="float32") +# qkv_bias.raw_tensor[1024:] = 0.0 + +proj_weight = rf.random(dims=[out_dim, out_dim], **random_opts) +proj_bias = rf.random(dims=[out_dim], **random_opts) + +torch_input = rf_input.raw_tensor + +rf_mhsa = rf.SelfAttention( + in_dim=out_dim, + proj_dim=out_dim, + key_dim_total=out_dim, + value_dim_total=out_dim, + num_heads=1, + att_dropout=0.1, +) + +rf_mhsa.qkv.weight._raw_backend.set_parameter_initial_value(rf_mhsa.qkv.weight, qkv_weight) +rf_mhsa.qkv.bias._raw_backend.set_parameter_initial_value(rf_mhsa.qkv.bias, qkv_bias) + +rf_mhsa.proj.weight._raw_backend.set_parameter_initial_value(rf_mhsa.proj.weight, proj_weight.raw_tensor) +rf_mhsa.proj.bias._raw_backend.set_parameter_initial_value(rf_mhsa.proj.bias, proj_bias) + +torch_mhsa = torch.nn.MultiheadAttention( + 512, 1, dropout=0.1, batch_first=True, + ) + +state_dict = torch_mhsa.state_dict() +state_dict['in_proj_weight'] = qkv_weight.raw_tensor.T +state_dict['in_proj_bias'] = qkv_bias.raw_tensor +state_dict['out_proj.weight'] = proj_weight.raw_tensor +state_dict['out_proj.bias'] = proj_bias.raw_tensor + +torch_mhsa.load_state_dict(state_dict) +torch_mhsa.eval() + +rf_output = rf_mhsa(rf_input, axis=spatial_dim) +torch_output, _ = torch_mhsa(torch_input, torch_input, torch_input, key_padding_mask=None, need_weights=False) + +print("RF output") +print(rf_output.raw_tensor) +print(rf_output.raw_tensor.shape) +print("---------------------------") +print("Torch output") +print(torch_output) +print(torch_output.shape) +print("Same: ", torch.allclose(rf_output.raw_tensor, torch_output, atol=1e-6)) + +## extended checks + +if False: + q_raw, k_raw, v_raw = torch.split(qkv_weight.raw_tensor, 512, dim=1) + + weights = [q_raw, k_raw, v_raw] + + any = False + + for perm in itertools.permutations(weights): + for q_inv, k_inv, v_inv in itertools.product([0,1], [0,1], [0,1]): + q_raw, k_raw, v_raw = perm + + if q_inv == 1: + q_raw = q_raw.T + if k_inv == 1: + k_raw = k_raw.T + if v_inv == 1: + v_raw = v_raw.T + + qkv_weight_adj_raw = torch.cat([q_raw.T, k_raw.T, v_raw.T], dim=1) + + state_dict = torch_mhsa.state_dict() + state_dict['in_proj_weight'] = qkv_weight_adj_raw.T + state_dict['in_proj_bias'] = qkv_bias.raw_tensor + state_dict['out_proj.weight'] = proj_weight.raw_tensor + state_dict['out_proj.bias'] = proj_bias.raw_tensor + + torch_mhsa.load_state_dict(state_dict) + torch_mhsa.eval() + + rf_output = rf_mhsa(rf_input, axis=spatial_dim) + torch_output, _ = torch_mhsa(torch_input, torch_input, torch_input, key_padding_mask=None, need_weights=False) + + print("RF output") + print(rf_output.raw_tensor) + print(rf_output.raw_tensor.shape) + print("---------------------------") + print("Torch output") + print(torch_output) + print(torch_output.shape) + + if torch.allclose(rf_output.raw_tensor, torch_output, atol=1e-6): + print("Match with perm: ", perm) + print("Match with inversions: ", q_inv, k_inv, v_inv) + any = True + break + + if any: + break + + print("Done") diff --git a/users/gaudino/experiments/rf_conformer_rnnt_2024/librispeech_960/conformer_ctc_train.py b/users/gaudino/experiments/rf_conformer_rnnt_2024/librispeech_960/conformer_ctc_train.py index 29ff6ef1f..3787a9f76 100644 --- a/users/gaudino/experiments/rf_conformer_rnnt_2024/librispeech_960/conformer_ctc_train.py +++ b/users/gaudino/experiments/rf_conformer_rnnt_2024/librispeech_960/conformer_ctc_train.py @@ -222,6 +222,25 @@ def sis_run_with_prefix(prefix_name: Optional[str] = None): ) + train_exp( # dev-other + "base-24gb-lrlin1e_5_600k_ctc_only_aux4_8_40subsample", + config_24gb_v6, + config_updates={ + "learning_rate": 1.0, + "dynamic_learning_rate": dyn_lr_piecewise_linear, + # total steps after 2000 epochs: 982.312 + "learning_rate_piecewise_steps": [600_000, 900_000, 982_000], + "learning_rate_piecewise_values": [1e-5, 1e-3, 1e-5, 1e-6], + "mel_normalization_ted2": False, + "conv_2nd_stride": 2, + }, + search_config = { + "mel_normalization_ted2": False, + }, + with_eos_postfix=False, + + ) + _torch_ckpt_path = "/u/luca.gaudino/setups/2023-08-10--rf-librispeech/work/i6_core/returnn/training/ReturnnTrainingJob.AWwVft0oGy8e/output/models/epoch.1981.pt" diff --git a/users/gaudino/experiments/rf_conformer_rnnt_2024/librispeech_960/conformer_rnnt_train.py b/users/gaudino/experiments/rf_conformer_rnnt_2024/librispeech_960/conformer_rnnt_train.py index 3ce450f69..604e6afc0 100644 --- a/users/gaudino/experiments/rf_conformer_rnnt_2024/librispeech_960/conformer_rnnt_train.py +++ b/users/gaudino/experiments/rf_conformer_rnnt_2024/librispeech_960/conformer_rnnt_train.py @@ -37,7 +37,7 @@ ModelWithCheckpoint, ) -from i6_experiments.users.gaudino.models.asr.rf.conformer_rnnt.model_conformer_rnnt import from_scratch_model_def, from_scratch_training +from i6_experiments.users.gaudino.models.asr.rf.conformer_rnnt.model_conformer_rnnt import from_scratch_model_def, from_scratch_training, from_scratch_model_def_v2 from i6_experiments.users.gaudino.models.asr.rf.conformer_rnnt.model_recog_rnnt import model_recog @@ -86,24 +86,47 @@ def sis_run_with_prefix(prefix_name: Optional[str] = None): # train_exp("base-11gb", config_11gb, gpu_mem=11) # train_exp("base-11gb-v1", my_config_11gb, num_epochs=400, gpu_mem=11) - train_exp( - "from-scratch-24gb_aux4_8", - config_24gb_v6, - config_updates={ - "batch_size": 8_000 * _batch_size_factor, - "learning_rate": 1.0, - "dynamic_learning_rate": dyn_lr_piecewise_linear, - # total steps after 2000 epochs: 982.312 - "learning_rate_piecewise_steps": [600_000, 900_000, 982_000], - "learning_rate_piecewise_values": [1e-5, 1e-3, 1e-5, 1e-6], - "mel_normalization_ted2": False, - }, - config_deletes=["torch_amp"], - search_config={ + # train_exp( + # "from-scratch-24gb_aux4_8", + # config_24gb_v6, + # config_updates={ + # "batch_size": 8_000 * _batch_size_factor, + # "learning_rate": 1.0, + # "dynamic_learning_rate": dyn_lr_piecewise_linear, + # # total steps after 2000 epochs: 982.312 + # "learning_rate_piecewise_steps": [600_000, 900_000, 982_000], + # "learning_rate_piecewise_values": [1e-5, 1e-3, 1e-5, 1e-6], + # "mel_normalization_ted2": False, + # }, + # config_deletes=["torch_amp"], + # search_config={ + # "mel_normalization_ted2": False, + # }, + # num_epochs=400, + # gpu_mem=24, + # ) + + ## recog rnnt BPE5k nick + + # imported checkpoint + _torch_ckpt_path = "/work/asr3/zeineldeen/hiwis/luca.gaudino/setups-data/2023-08-10--rf-librispeech/work/i6_experiments/users/gaudino/returnn/convert_ckpt_rf/librispeech/rnnt_nick_240614/epoch.250.pt" + + new_ckpt_path = tk.Path( + _torch_ckpt_path, + hash_overwrite= "rnnt_nick" + "_torch_rf_ckpt", + ) + new_ckpt = PtCheckpoint(new_ckpt_path) + + _recog( + "model_recogs/rnnt_nick_1/rnnt_beam_search/recog_results", + ModelWithCheckpoint( + definition=from_scratch_model_def_v2, checkpoint=new_ckpt + ), + model_recog, + dev_sets=["dev-other"], + recog_config={ "mel_normalization_ted2": False, }, - num_epochs=400, - gpu_mem=24, ) @@ -153,7 +176,7 @@ def _recog( if recog_def is None: recog_def = model_recog - task = _get_ted2_task() + task = _get_ls_task(bpe_size="BPE5k") res = recog_model( task, @@ -194,7 +217,7 @@ def train_exp( _sis_setup_global_prefix() prefix = _sis_prefix + "/" + name - task = _get_ls_task() + task = _get_ls_task(bpe_size="BPE10k") config = config.copy() config = dict_update_deep(config, config_updates, config_deletes) if "__num_epochs" in config: @@ -282,20 +305,37 @@ def train_exp( _ls_task = None _ted2_task = None - -def _get_ls_task(): +def _get_ls_task(bpe_size): global _ls_task if _ls_task: return _ls_task - from i6_experiments.users.zeyer.datasets.librispeech import ( - get_librispeech_task_bpe10k_raw, + from i6_experiments.users.gaudino.datasets.librispeech import ( + get_librispeech_task_bpe10k_raw, get_librispeech_task_bpe5k_raw ) - _ls_task = get_librispeech_task_bpe10k_raw(with_eos_postfix=True) + if bpe_size == "BPE10k": + _ls_task = get_librispeech_task_bpe10k_raw(with_eos_postfix=True) + + if bpe_size == "BPE5k": + _ls_task = get_librispeech_task_bpe5k_raw(with_eos_postfix=True) + return _ls_task +# def _get_ls_task(): +# global _ls_task +# if _ls_task: +# return _ls_task +# +# from i6_experiments.users.zeyer.datasets.librispeech import ( +# get_librispeech_task_bpe10k_raw, +# ) +# +# _ls_task = get_librispeech_task_bpe10k_raw(with_eos_postfix=True) +# return _ls_task + + def _get_ted2_task(): global _ted2_task if _ted2_task: diff --git a/users/gaudino/models/asr/rf/conformer_ctc/model_conformer_ctc.py b/users/gaudino/models/asr/rf/conformer_ctc/model_conformer_ctc.py index f32fc88dd..217d6df49 100644 --- a/users/gaudino/models/asr/rf/conformer_ctc/model_conformer_ctc.py +++ b/users/gaudino/models/asr/rf/conformer_ctc/model_conformer_ctc.py @@ -151,6 +151,7 @@ def __init__( self.mel_normalization = config.typed_value("mel_normalization_ted2", True) self.use_specaugment = config.typed_value("use_specaugment", True) + self.conv_2nd_stride = config.typed_value("conv_2nd_stride", 3) self.in_dim = in_dim self.encoder = ConformerEncoder( @@ -166,7 +167,7 @@ def __init__( ], filter_sizes=[(3, 3), (3, 3), (3, 3)], pool_sizes=[(1, 2)], - strides=[(1, 1), (3, 1), (2, 1)], + strides=[(1, 1), (self.conv_2nd_stride, 1), (2, 1)], ), encoder_layer_opts=enc_conformer_layer_opts, num_layers=num_enc_layers, diff --git a/users/gaudino/models/asr/rf/conformer_rnnt/model_conformer_rnnt.py b/users/gaudino/models/asr/rf/conformer_rnnt/model_conformer_rnnt.py index 8198baeac..b9fc28ec7 100644 --- a/users/gaudino/models/asr/rf/conformer_rnnt/model_conformer_rnnt.py +++ b/users/gaudino/models/asr/rf/conformer_rnnt/model_conformer_rnnt.py @@ -21,7 +21,7 @@ from returnn.tensor import Tensor, Dim, single_step_dim import returnn.frontend as rf from returnn.frontend.tensor_array import TensorArray -from returnn.frontend.encoder.conformer import ConformerEncoder, ConformerConvSubsample +from returnn.frontend.encoder.conformer import ConformerEncoder, ConformerConvSubsampleV2 from i6_experiments.users.gaudino.model_interfaces.supports_label_scorer_torch import ( RFModelWithMakeLabelScorer, @@ -125,6 +125,117 @@ def make_model( ) +class MakeModelV2: + """for import""" + + def __init__( + self, + in_dim: int, + target_dim: int, + *, + eos_label: int = 0, + num_enc_layers: int = 12, + ): + self.in_dim = in_dim + self.target_dim = target_dim + self.eos_label = eos_label + self.num_enc_layers = num_enc_layers + + def __call__(self) -> Model: + from returnn.datasets.util.vocabulary import Vocabulary + + in_dim = Dim(name="in", dimension=self.in_dim, kind=Dim.Types.Feature) + target_dim = Dim( + name="target", dimension=self.target_dim, kind=Dim.Types.Feature + ) + target_dim.vocab = Vocabulary.create_vocab_from_labels( + [str(i) for i in range(target_dim.dimension)], eos_label=self.eos_label + ) + + return self.make_model(in_dim, target_dim, num_enc_layers=self.num_enc_layers) + + @classmethod + def make_model( + cls, + in_dim: Dim, + target_dim: Dim, + *, + num_enc_layers: int = 12, + pos_emb_dropout: float = 0.0, + language_model: Optional[Dict[str, Any]] = None, + **extra, + ) -> Model: + """make""" + lm = None + if language_model: + assert isinstance(language_model, dict) + language_model = language_model.copy() + cls_name = language_model.pop("class") + assert cls_name == "TransformerDecoder" + language_model.pop("vocab_dim", None) # will just overwrite + + from i6_experiments.users.gaudino.experiments.rf_conformer_att_2023.librispeech_960.trafo_lm.trafo_lm import ( + trafo_lm, + ) + + lm = trafo_lm.MakeModel(vocab_dim=target_dim, **language_model)() + lm = (lm, functools.partial(trafo_lm.make_label_scorer_torch, model=lm)) + + return Model( + in_dim, + num_enc_layers=num_enc_layers, + enc_model_dim=Dim(name="enc", dimension=512, kind=Dim.Types.Feature), + enc_ff_dim=Dim(name="enc-ff", dimension=2048, kind=Dim.Types.Feature), + enc_att_num_heads=8, + enc_conformer_layer_opts=dict( + conv_norm_opts=dict( + use_mask=True, track_running_stats=False + ), # Changed: track_running_stats=False + self_att=rf.SelfAttention, + self_att_opts=dict( + with_bias=True, # Changed: with_bias=True + # with_linear_pos=False, + # with_pos_bias=False, + # learnable_pos_emb=False, # Changed: learnable_pos_emb=False + # separate_pos_emb_per_head=False, + # pos_emb_dropout=pos_emb_dropout, + ), + ff_activation=rf.silu, # Changed: rf.silu + conv_kernel_size=31, # Changed: conv_kernel_size=31 + ), + enc_input_layer=ConformerConvSubsampleV2( + in_dim, + out_dims=[ + Dim(32, name="conv1"), + Dim(64, name="conv2"), + Dim(64, name="conv3"), + Dim(32, name="conv4"), # Changed: Dim(64, name="conv4") + ], + filter_sizes=[(3, 3), (3, 3), (3, 3), (3, 3)], # Changed + activation_times=[False, True, False, True], # Changed + pool_sizes=[(1, 1), (3, 1), (1, 1), (2, 1)], # Changed + strides=[(1, 1), (1, 1), (1, 1), (1, 1)], # Changed + padding="same", # Changed: padding="valid" + pool_padding="valid", # Changed + swap_merge_dim_order=True, # Changed + # Note: uses relu activation by default + ), + enc_use_input_proj_bias=True, # Changed: enc_use_input_proj_bias=True + target_dim=target_dim, + blank_idx=target_dim.dimension, + bos_idx=_get_bos_idx(target_dim), + eos_idx=_get_eos_idx(target_dim), + language_model=lm, + use_i6_models_feat_ext = True, + # feat_ext_opts=dict( + # f_min=60, + # f_max=7600, + # n_fft=400, + # ), + **extra, + ) + + class Predictor(rf.Module): r"""Recurrent neural network transducer (RNN-T) prediction network. @@ -378,6 +489,8 @@ def __init__( enc_ff_dim: Dim = Dim(name="enc-ff", dimension=2048), enc_att_num_heads: int = 4, enc_conformer_layer_opts: Optional[Dict[str, Any]] = None, + enc_input_layer: Optional[ConformerConvSubsampleV2] = None, + enc_use_input_proj_bias: bool = False, # enc_key_total_dim: Dim = Dim(name="enc_key_total_dim", dimension=1024), # att_num_heads: Dim = Dim(name="att_num_heads", dimension=1), # att_dropout: float = 0.1, @@ -386,6 +499,8 @@ def __init__( l2: float = 0.0001, language_model: Optional[RFModelWithMakeLabelScorer] = None, joiner_dim: int = 640, + use_i6_models_feat_ext: bool = False, + feat_ext_opts: Optional[Dict[str, Any]] = None, ): super(Model, self).__init__() @@ -394,13 +509,30 @@ def __init__( config = get_global_config(return_empty_if_none=True) self.mel_normalization = config.typed_value("mel_normalization_ted2", True) + self.use_i6_models_feat_ext = use_i6_models_feat_ext + if self.use_i6_models_feat_ext: + from i6_models.primitives.feature_extraction import ( + LogMelFeatureExtractionV1, + LogMelFeatureExtractionV1Config, + ) - self.in_dim = in_dim - self.encoder = ConformerEncoder( - in_dim, - enc_model_dim, - ff_dim=enc_ff_dim, - input_layer=ConformerConvSubsample( + mel_config = LogMelFeatureExtractionV1Config( + sample_rate=16000, + win_size=0.025, + hop_size=0.01, + f_min=60, + f_max=7600, + min_amp=1e-10, + num_filters=80, + center=False, + **(feat_ext_opts or {}), + ) + self.feature_extraction = LogMelFeatureExtractionV1(cfg=mel_config) + + self.feat_ext_opts = feat_ext_opts + + if enc_input_layer is None: + self.enc_input_layer = ConformerConvSubsampleV2( in_dim, out_dims=[ Dim(32, name="conv1"), @@ -410,7 +542,16 @@ def __init__( filter_sizes=[(3, 3), (3, 3), (3, 3)], pool_sizes=[(1, 2)], strides=[(1, 1), (3, 1), (2, 1)], - ), + ) + else: + self.enc_input_layer = enc_input_layer + + self.in_dim = in_dim + self.encoder = ConformerEncoder( + in_dim, + enc_model_dim, + ff_dim=enc_ff_dim, + input_layer=self.enc_input_layer, encoder_layer_opts=enc_conformer_layer_opts, num_layers=num_enc_layers, num_heads=enc_att_num_heads, @@ -418,6 +559,17 @@ def __init__( att_dropout=enc_att_dropout, ) + self.enc_use_input_proj_bias = enc_use_input_proj_bias + + if self.enc_use_input_proj_bias: + self.encoder.input_projection = rf.Linear( + self.encoder.input_layer.out_dim + if self.encoder.input_layer + else self.encoder.in_dim, + self.encoder.out_dim, + with_bias=True, + ) + self.target_dim = target_dim self.target_dim_w_blank = target_dim + 1 self.blank_idx = blank_idx @@ -501,14 +653,36 @@ def encode( collected_outputs: Optional[Dict[str, Tensor]] = None, ) -> Tuple[Dict[str, Tensor], Dim]: """encode, and extend the encoder output for things we need in the decoder""" - # log mel filterbank features - source, in_spatial_dim = rf.audio.log_mel_filterbank_from_raw( - source, - in_spatial_dim=in_spatial_dim, - out_dim=self.in_dim, - sampling_rate=16_000, - log_base=math.exp(2.3026), # almost 10.0 but not exactly... - ) + + if self.use_i6_models_feat_ext: + squeezed_features = torch.squeeze(source.raw_tensor) + raw_audio_len = in_spatial_dim.dyn_size_ext.raw_tensor + audio_features, audio_features_len_raw = self.feature_extraction( + squeezed_features, raw_audio_len + ) + audio_features_len = rf.Tensor( + name="audio-features-len", + dims=[source.dims[0]], + raw_tensor=audio_features_len_raw, + dtype="int32", + ) + in_spatial_dim = Dim(None, name="in-spatial-dim", dyn_size_ext=audio_features_len) + source = rf.Tensor( + name="audio-features", + dims=[source.dims[0], in_spatial_dim, self.in_dim], + raw_tensor=audio_features, + dtype="float32", + ) + else: + # log mel filterbank features + source, in_spatial_dim = rf.audio.log_mel_filterbank_from_raw_v2( + source, + in_spatial_dim=in_spatial_dim, + out_dim=self.in_dim, + sampling_rate=16_000, + log_base=math.exp(2.3026), # almost 10.0 but not exactly... + **(self.feat_ext_opts or {}), + ) if self.mel_normalization: ted2_global_mean = rf.Tensor( @@ -701,6 +875,32 @@ def from_scratch_model_def(*, epoch: int, in_dim: Dim, target_dim: Dim) -> Model from_scratch_model_def.batch_size_factor = 160 +def from_scratch_model_def_v2(*, epoch: int, in_dim: Dim, target_dim: Dim) -> Model: + """Function is run within RETURNN.""" + from returnn.config import get_global_config + + in_dim, epoch # noqa + config = get_global_config() # noqa + enc_aux_logits = config.typed_value("aux_loss_layers") + pos_emb_dropout = config.float("pos_emb_dropout", 0.0) + # real input is raw audio, internally it does logmel + in_dim = Dim(name="logmel", dimension=_log_mel_feature_dim, kind=Dim.Types.Feature) + lm_opts = config.typed_value("external_language_model") + return MakeModelV2.make_model( + in_dim, + target_dim, + enc_aux_logits=enc_aux_logits or (), + pos_emb_dropout=pos_emb_dropout, + language_model=lm_opts, + ) + + +from_scratch_model_def_v2: ModelDef[Model] +from_scratch_model_def_v2.behavior_version = 16 +from_scratch_model_def_v2.backend = "torch" +from_scratch_model_def_v2.batch_size_factor = 160 + + def from_scratch_training( *, model: Model, diff --git a/users/gaudino/models/asr/rf/conformer_rnnt/model_recog_rnnt.py b/users/gaudino/models/asr/rf/conformer_rnnt/model_recog_rnnt.py index 7c512166f..f8ec639c1 100644 --- a/users/gaudino/models/asr/rf/conformer_rnnt/model_recog_rnnt.py +++ b/users/gaudino/models/asr/rf/conformer_rnnt/model_recog_rnnt.py @@ -101,6 +101,8 @@ def model_recog( not model.language_model ) # not implemented here. use the pure PyTorch search instead + breakpoint() + batch_dims = data.remaining_dims((data_spatial_dim, data.feature_dim)) enc_args, enc_spatial_dim = model.encode(data, in_spatial_dim=data_spatial_dim) beam_size = 12 From 82e79b11286c3d429972419d150817c805efd571 Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Wed, 19 Jun 2024 11:21:14 +0200 Subject: [PATCH 209/227] fix warning --- users/zeyer/datasets/librispeech.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/users/zeyer/datasets/librispeech.py b/users/zeyer/datasets/librispeech.py index 2a068c7c0..011bf8a38 100644 --- a/users/zeyer/datasets/librispeech.py +++ b/users/zeyer/datasets/librispeech.py @@ -335,7 +335,7 @@ def get_dataset(self, key: str, *, training: bool = False, subset: Optional[int] assert parts, f"invalid key {key!r}" for part in parts: files += [_get_librispeech_ogg_zip_dict()[part]] - d = { + d: Dict[str, Any] = { "class": "OggZipDataset", "path": files, "use_cache_manager": True, From 8fc236e4991f39c35694c8c3919c408b12e8a246 Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Wed, 19 Jun 2024 14:39:17 +0000 Subject: [PATCH 210/227] fix bug --- .../canary_aed/configs/canary_1b_recog.py | 22 +++++++++---------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py b/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py index 28db5beb1..41f025593 100644 --- a/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py +++ b/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py @@ -95,10 +95,11 @@ def py(): tk.register_output(f"canary_1b/huggingface/{test_set}_bs64_greedy/wer", search_job.out_wer) # Run with our beam search - for beam_size in [1, 4, 8]: + for beam_size in [1, 4, 8, 12]: for test_set, split in TEST_DATASETS.items(): if test_set == "gigaspeech": - continue # TODO: need to ask nick to set a reservaion tag to increase time limit + continue + bs_ = 64 if beam_size <= 4 else 32 search_job = SearchJob( model_id=MODEL_ID, model_path=model_path, @@ -106,16 +107,15 @@ def py(): dataset_name=test_set, split=split, search_script=our_beam_search_script, - search_args={"batch_size": 64, "pnc": False, "max_eval_samples": -1, "beam_size": beam_size}, + search_args={"batch_size": bs_, "pnc": False, "max_eval_samples": -1, "beam_size": beam_size}, python_exe=python_exe, device="gpu", - time_rqmt=0.5, + time_rqmt=24, mem_rqmt=8, - cpu_rqmt=2, + cpu_rqmt=4, ) - search_job.rqmt["sbatch_args"] = ["-p", "gpu_test_24gb"] - search_job.add_alias(f"canary_1b/beam_search_v5/{test_set}_bs64_beam{beam_size}") - tk.register_output( - f"canary_1b/beam_search_v5/{test_set}_bs64_beam{beam_size}/search_out", search_job.out_search_results - ) - tk.register_output(f"canary_1b/beam_search_v5/{test_set}_bs64_beam{beam_size}/wer", search_job.out_wer) + search_job.rqmt["sbatch_args"] = ["-p", "gpu_test_24gb", "-w", "cn-290", "--reservation", "hlt_6"] + name = f"{test_set}_bs{bs_}_beam{beam_size}" + search_job.add_alias(f"canary_1b/beam_search_v5/{name}") + tk.register_output(f"canary_1b/beam_search_v5/{name}/search_out", search_job.out_search_results) + tk.register_output(f"canary_1b/beam_search_v5/{name}/wer", search_job.out_wer) From 3532a025f90c8a31791e3ef3b381823cb7ee3f40 Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Wed, 19 Jun 2024 22:05:11 +0200 Subject: [PATCH 211/227] vocab outputs --- users/zeyer/datasets/librispeech.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/users/zeyer/datasets/librispeech.py b/users/zeyer/datasets/librispeech.py index 011bf8a38..d260fa165 100644 --- a/users/zeyer/datasets/librispeech.py +++ b/users/zeyer/datasets/librispeech.py @@ -51,6 +51,7 @@ def _get_bliss_corpus_dict() -> Dict[str, tk.Path]: def _get_corpus_text_dict(key: str) -> tk.Path: job = CorpusToTextDictJob(_get_bliss_corpus_dict()[key], gzip=True) job.add_alias(_alias_prefix + f"{key.replace('-', '_')}_corpus_text_dict") + tk.register_output(_alias_prefix + f"{key.replace('-', '_')}_corpus_text_dict.py.gz", job.out_dictionary) return job.out_dictionary @@ -60,6 +61,7 @@ def _get_train_corpus_text() -> tk.Path: train_corpus_text_dict = _get_corpus_text_dict(key) job = TextDictToTextLinesJob(train_corpus_text_dict, gzip=True) job.add_alias(_alias_prefix + f"{key.replace('-', '_')}_corpus_text_lines") + tk.register_output(_alias_prefix + f"{key.replace('-', '_')}_corpus_text_lines.txt.gz", job.out_text_lines) return job.out_text_lines @@ -85,7 +87,8 @@ def _get_spm_vocab( "eos_id": 0, # default is 2 }, ) - _spm_train_job.add_alias(_alias_prefix + f"vocab/spm_{model_type.name.lower()}_{dim_str}_train") + _spm_train_job.add_alias(_alias_prefix + f"vocab/spm_{model_type.value}_{dim_str}_train") + tk.register_output(_alias_prefix + f"vocab/spm_{model_type.value}_{dim_str}_train.model", _spm_train_job.out_model) spm = SentencePieceModel( dim=dim, model_file=_spm_train_job.out_model, From 4dda58ba9165b5ce6000001d849e4fcd0df9cf61 Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Thu, 20 Jun 2024 10:02:48 +0200 Subject: [PATCH 212/227] more --- users/zeyer/experiments/exp2024_04_23_baselines/aed.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/users/zeyer/experiments/exp2024_04_23_baselines/aed.py b/users/zeyer/experiments/exp2024_04_23_baselines/aed.py index c9319cb50..4d83029e8 100644 --- a/users/zeyer/experiments/exp2024_04_23_baselines/aed.py +++ b/users/zeyer/experiments/exp2024_04_23_baselines/aed.py @@ -68,8 +68,9 @@ def py(): }, ) + # Comparing vocabs. for vocab in [ - "spm20k", + "spm20k", # 5.14 (but test-other is 6.18!) "bpe10k", # 5.32 "spm10k", # 5.16 "spm_bpe10k", # 5.21 From 44fb0a54c419db31e5769af152e834080313fd8a Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Thu, 20 Jun 2024 10:03:52 +0200 Subject: [PATCH 213/227] more, AED featBN, sampling --- .../exp2024_04_23_baselines/aed.py | 59 +++++++++++++++++++ 1 file changed, 59 insertions(+) diff --git a/users/zeyer/experiments/exp2024_04_23_baselines/aed.py b/users/zeyer/experiments/exp2024_04_23_baselines/aed.py index 4d83029e8..9bafab989 100644 --- a/users/zeyer/experiments/exp2024_04_23_baselines/aed.py +++ b/users/zeyer/experiments/exp2024_04_23_baselines/aed.py @@ -14,6 +14,7 @@ import copy import functools from typing import TYPE_CHECKING, Optional, Union, Tuple, Sequence +import numpy import tree from returnn.tensor import Tensor, Dim, single_step_dim @@ -89,6 +90,40 @@ def py(): vocab=vocab, ) + # Comparing vocabs with better settings: feature norm, sampling, no max seq len. + for vocab, alpha in [ + # ("spm20k", 0.7), + ("bpe10k", 0.01), + ("spm10k", 0.7), + # ("spm_bpe10k", ...), # unclear what sampling scheme... + # ("spm4k", 0.7), + # ("spm1k", 0.7), + # ("spm_bpe1k", ...) + ]: + train_exp( # 5.16 + f"v6-bhv20-11gb-f32-bs15k-accgrad1-mgpu4-pavg100-maxSeqLenNone" + f"-wd1e_2-lrlin1e_5_295k-featBN-speedpertV2-{vocab}" + f"-{'spmSample' if vocab.startswith('spm') else 'bpeSample'}{str(alpha).replace('.', '')}", + config_11gb_v6_f32_accgrad1_mgpu4_pavg100_wd1e_4, + model_config={"feature_batch_norm": True}, + config_updates={ + **_get_cfg_lrlin_oclr_by_bs_nep(15_000, 500), + "optimizer.weight_decay": 1e-2, + "__train_audio_preprocess": speed_pert_librosa_config, + "speed_pert_discrete_values": [0.7, 0.8, 0.9, 1.0, 1.1], + "max_seq_length_default_target": None, + }, + vocab=vocab, + train_vocab_opts={ + "other_opts": ( + {"enable_sampling": True, "alpha": alpha} + if vocab.startswith("spm") + else {"class": "SamplingBytePairEncoding", "breadth_prob": alpha} + ) + }, + ) + + # Sampling. for vocab, alpha in [ # Testing sampling in SPM. # The lower the alpha, the more aggressive the sampling. @@ -567,6 +602,24 @@ def __init__( for i in enc_aux_logits: setattr(self, f"enc_aux_logits_{i}", rf.Linear(self.encoder.out_dim, wb_target_dim)) + self.feature_batch_norm = None + if config.bool("feature_batch_norm", False): + self.feature_batch_norm = rf.BatchNorm(self.in_dim, affine=False, use_mask=True) + self.feature_norm = config.bool("feature_norm", False) + self.feature_stats = None + feature_stats = config.typed_value("feature_stats") + if feature_stats: + assert isinstance(feature_stats, dict) + self.feature_stats = rf.ParameterList( + { + k: rf.Parameter( + rf.convert_to_tensor(numpy.loadtxt(v), dims=[self.in_dim], dtype=rf.get_default_float_dtype()), + auxiliary=True, + ) + for k, v in feature_stats.items() + } + ) + self._specaugment_opts = { "steps": config.typed_value("specaugment_steps") or (0, 1000, 2000), "max_consecutive_spatial_dims": config.typed_value("specaugment_max_consecutive_spatial_dims") or 20, @@ -596,6 +649,12 @@ def encode( out_dim=self.in_dim, sampling_rate=16_000, ) + if self.feature_batch_norm: + source = self.feature_batch_norm(source) + if self.feature_norm: + source = rf.normalize(source, axis=in_spatial_dim) + if self.feature_stats: + source = (source - self.feature_stats.mean) / self.feature_stats.std_dev if self._mixup: source = self._mixup(source, spatial_dim=in_spatial_dim) # SpecAugment From ebfc2e7f2cc90bc78fc0b07cd215e96abea2ee93 Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Thu, 20 Jun 2024 10:16:57 +0200 Subject: [PATCH 214/227] extract SPM vocab --- users/zeyer/datasets/librispeech.py | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/users/zeyer/datasets/librispeech.py b/users/zeyer/datasets/librispeech.py index d260fa165..fdce05400 100644 --- a/users/zeyer/datasets/librispeech.py +++ b/users/zeyer/datasets/librispeech.py @@ -12,6 +12,7 @@ from i6_core.corpus.convert import CorpusToTextDictJob from i6_core.text.convert import TextDictToTextLinesJob from i6_core.text.label.sentencepiece.train import TrainSentencePieceJob, SentencePieceType +from i6_core.text.label.sentencepiece.vocab import ExtractSentencePieceVocabJob from returnn.util.basic import NotSpecified from returnn_common.datasets_old_2022_10.interface import DatasetConfig, VocabConfig from i6_experiments.common.datasets import librispeech @@ -89,6 +90,10 @@ def _get_spm_vocab( ) _spm_train_job.add_alias(_alias_prefix + f"vocab/spm_{model_type.value}_{dim_str}_train") tk.register_output(_alias_prefix + f"vocab/spm_{model_type.value}_{dim_str}_train.model", _spm_train_job.out_model) + tk.register_output( + _alias_prefix + f"vocab/spm_{model_type.value}_{dim_str}_train.vocab", + ExtractSentencePieceVocabJob(_spm_train_job.out_model).out_vocab, + ) spm = SentencePieceModel( dim=dim, model_file=_spm_train_job.out_model, From 8b7dae5c680f4fecf0fe7b5553d08e594ad9825c Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Thu, 20 Jun 2024 11:33:33 +0000 Subject: [PATCH 215/227] add rtfs --- .../experiments/canary_aed/nemo/run_eval.py | 18 ++++++++++++++++-- .../canary_aed/nemo/run_eval_beam_search.py | 19 +++++++++++++++++-- 2 files changed, 33 insertions(+), 4 deletions(-) diff --git a/users/zeineldeen/experiments/canary_aed/nemo/run_eval.py b/users/zeineldeen/experiments/canary_aed/nemo/run_eval.py index f6a62aaf3..eab4d1d32 100644 --- a/users/zeineldeen/experiments/canary_aed/nemo/run_eval.py +++ b/users/zeineldeen/experiments/canary_aed/nemo/run_eval.py @@ -78,6 +78,12 @@ def buffer_audio_and_transcribe( ): buffer = [] results = [] + + model.total_audio_length_in_sec = 0.0 + model.total_recog_time_in_sec = 0.0 + model.total_enc_recog_time_in_sec = 0.0 + model.total_dec_recog_time_in_sec = 0.0 + for sample in tqdm(dataset_iterator(dataset), desc="Evaluating: Sample id", unit="", disable=not verbose): buffer.append(sample) @@ -86,10 +92,10 @@ def buffer_audio_and_transcribe( if pnc is not None: transcriptions = model.transcribe( - filepaths, batch_size=batch_size, pnc=False, verbose=False, num_workers=4 + filepaths, batch_size=batch_size, pnc=False, verbose=False, num_workers=2 ) else: - transcriptions = model.transcribe(filepaths, batch_size=batch_size, verbose=False, num_workers=4) + transcriptions = model.transcribe(filepaths, batch_size=batch_size, verbose=False, num_workers=2) # if transcriptions form a tuple (from RNNT), extract just "best" hypothesis if type(transcriptions) == tuple and len(transcriptions) == 2: transcriptions = transcriptions[0] @@ -108,6 +114,14 @@ def buffer_audio_and_transcribe( results = pack_results(results, buffer, transcriptions) buffer.clear() + print(f"Total audio duration: {model.total_audio_length_in_sec:.3f} sec") + print(f"Total recog time: {model.total_recog_time_in_sec:.3f} sec") + print(f"Total enc recog time: {model.total_enc_recog_time_in_sec:.3f} sec") + print(f"Total dec recog time: {model.total_dec_recog_time_in_sec:.3f} sec") + print(f"Overall RTF: {model.total_recog_time_in_sec / model.total_audio_length_in_sec:.3f}") + print(f"Enc RTF: {model.total_enc_recog_time_in_sec / model.total_audio_length_in_sec:.3f}") + print(f"Dec RTF: {model.total_dec_recog_time_in_sec / model.total_audio_length_in_sec:.3f}") + # Delete temp cache dir if os.path.exists(DATA_CACHE_DIR): shutil.rmtree(DATA_CACHE_DIR) diff --git a/users/zeineldeen/experiments/canary_aed/nemo/run_eval_beam_search.py b/users/zeineldeen/experiments/canary_aed/nemo/run_eval_beam_search.py index cc928f526..20996fb0a 100644 --- a/users/zeineldeen/experiments/canary_aed/nemo/run_eval_beam_search.py +++ b/users/zeineldeen/experiments/canary_aed/nemo/run_eval_beam_search.py @@ -225,6 +225,7 @@ def _transcribe_output_processing_our_beam_search( max_seq_len=enc_lens, device=enc_states.device, opts=beam_search_v5_opts, + # debug_out=sys.stdout, ) # [B,Beam,L] best_hyps = [] @@ -240,6 +241,12 @@ def buffer_audio_and_transcribe( ): buffer = [] results = [] + + model.total_audio_length_in_sec = 0.0 + model.total_recog_time_in_sec = 0.0 + model.total_enc_recog_time_in_sec = 0.0 + model.total_dec_recog_time_in_sec = 0.0 + for sample in tqdm(dataset_iterator(dataset), desc="Evaluating: Sample id", unit="", disable=not verbose): buffer.append(sample) @@ -248,10 +255,10 @@ def buffer_audio_and_transcribe( if pnc is not None: transcriptions = model.transcribe( - filepaths, batch_size=batch_size, pnc=False, verbose=False, num_workers=4 + filepaths, batch_size=batch_size, pnc=False, verbose=False, num_workers=2 ) else: - transcriptions = model.transcribe(filepaths, batch_size=batch_size, verbose=False, num_workers=4) + transcriptions = model.transcribe(filepaths, batch_size=batch_size, verbose=False, num_workers=2) # if transcriptions form a tuple (from RNNT), extract just "best" hypothesis if type(transcriptions) == tuple and len(transcriptions) == 2: @@ -271,6 +278,14 @@ def buffer_audio_and_transcribe( results = pack_results(results, buffer, transcriptions) buffer.clear() + print(f"Total audio duration: {model.total_audio_length_in_sec:.3f} sec") + print(f"Total recog time: {model.total_recog_time_in_sec:.3f} sec") + print(f"Total enc recog time: {model.total_enc_recog_time_in_sec:.3f} sec") + print(f"Total dec recog time: {model.total_dec_recog_time_in_sec:.3f} sec") + print(f"Overall RTF: {model.total_recog_time_in_sec / model.total_audio_length_in_sec:.3f}") + print(f"Enc RTF: {model.total_enc_recog_time_in_sec / model.total_audio_length_in_sec:.3f}") + print(f"Dec RTF: {model.total_dec_recog_time_in_sec / model.total_audio_length_in_sec:.3f}") + # Delete temp cache dir if os.path.exists(DATA_CACHE_DIR): shutil.rmtree(DATA_CACHE_DIR) From a79f06a710ec49e155e93a8799c3725a7b9e3cfd Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Thu, 20 Jun 2024 11:38:44 +0000 Subject: [PATCH 216/227] add cache suffix --- .../canary_aed/configs/canary_1b_recog.py | 105 +++++++++--------- .../experiments/canary_aed/nemo/run_eval.py | 4 + .../canary_aed/nemo/run_eval_beam_search.py | 6 + .../experiments/canary_aed/nemo/search.py | 5 + 4 files changed, 69 insertions(+), 51 deletions(-) diff --git a/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py b/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py index 41f025593..0f4f0d64d 100644 --- a/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py +++ b/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py @@ -49,15 +49,6 @@ def py(): dataset_paths = download_test_datasets() model_path = download_canary_1b_model() - huggface_search_script = tk.Path( - "/u/zeineldeen/setups/ubuntu_22_setups/2024-06-07--canary-aed/recipe/i6_experiments/users/zeineldeen/experiments/canary_aed/nemo/run_eval.py", - hash_overwrite="run_eval_v1", - ) - our_beam_search_script = tk.Path( - "/u/zeineldeen/setups/ubuntu_22_setups/2024-06-07--canary-aed/recipe/i6_experiments/users/zeineldeen/experiments/canary_aed/nemo/run_eval_beam_search.py", - hash_overwrite="run_eval_v2", - ) - # to run canary model, this env has installed nemo toolkit with: # pip3 install git+https://github.com/NVIDIA/NeMo.git@r2.0.0rc0#egg=nemo_toolkit[all] # related issue: https://github.com/huggingface/open_asr_leaderboard/issues/26 @@ -74,48 +65,60 @@ def py(): # earnings22 | 12.23 | 12.25 # gigaspeech | 10.14 | 10.19 - for test_set, split in TEST_DATASETS.items(): - search_job = SearchJob( - model_id=MODEL_ID, - model_path=model_path, - dataset_path=dataset_paths[test_set], - dataset_name=test_set, - split=split, - search_script=huggface_search_script, - search_args={"batch_size": 64, "pnc": False, "max_eval_samples": -1}, - python_exe=python_exe, - device="gpu", - time_rqmt=24, - mem_rqmt=8, - cpu_rqmt=2, + for run in range(1): + huggface_search_script = tk.Path( + "/u/zeineldeen/setups/ubuntu_22_setups/2024-06-07--canary-aed/recipe/i6_experiments/users/zeineldeen/experiments/canary_aed/nemo/run_eval.py", + hash_overwrite=f"run_eval_v1_rtf_run{run}", ) - search_job.rqmt["sbatch_args"] = ["-p", "gpu_24gb"] - search_job.add_alias(f"canary_1b/huggingface/{test_set}_bs64_greedy") - tk.register_output(f"canary_1b/huggingface/{test_set}_bs64_greedy/search_out", search_job.out_search_results) - tk.register_output(f"canary_1b/huggingface/{test_set}_bs64_greedy/wer", search_job.out_wer) + for test_set, split in TEST_DATASETS.items(): + for bs in [64]: # [16, 32, 64]: + name = f"{test_set}_bs{bs}_greedy_run{run}" + search_job = SearchJob( + model_id=MODEL_ID, + model_path=model_path, + dataset_path=dataset_paths[test_set], + dataset_name=test_set, + cache_dir_name_suffix=name, + split=split, + search_script=huggface_search_script, + search_args={"batch_size": bs, "pnc": False, "max_eval_samples": -1}, + python_exe=python_exe, + device="gpu", + time_rqmt=24, + mem_rqmt=8, + cpu_rqmt=4, + ) + search_job.rqmt["sbatch_args"] = ["-p", "gpu_test_24gb", "-w", "cn-290", "--reservation", "hlt_6"] + search_job.add_alias(f"canary_1b/huggingface/{name}") + tk.register_output(f"canary_1b/huggingface/{name}/search_out", search_job.out_search_results) + tk.register_output(f"canary_1b/huggingface/{name}/wer", search_job.out_wer) # Run with our beam search - for beam_size in [1, 4, 8, 12]: - for test_set, split in TEST_DATASETS.items(): - if test_set == "gigaspeech": - continue - bs_ = 64 if beam_size <= 4 else 32 - search_job = SearchJob( - model_id=MODEL_ID, - model_path=model_path, - dataset_path=dataset_paths[test_set], - dataset_name=test_set, - split=split, - search_script=our_beam_search_script, - search_args={"batch_size": bs_, "pnc": False, "max_eval_samples": -1, "beam_size": beam_size}, - python_exe=python_exe, - device="gpu", - time_rqmt=24, - mem_rqmt=8, - cpu_rqmt=4, - ) - search_job.rqmt["sbatch_args"] = ["-p", "gpu_test_24gb", "-w", "cn-290", "--reservation", "hlt_6"] - name = f"{test_set}_bs{bs_}_beam{beam_size}" - search_job.add_alias(f"canary_1b/beam_search_v5/{name}") - tk.register_output(f"canary_1b/beam_search_v5/{name}/search_out", search_job.out_search_results) - tk.register_output(f"canary_1b/beam_search_v5/{name}/wer", search_job.out_wer) + for run in range(1): + our_beam_search_script = tk.Path( + "/u/zeineldeen/setups/ubuntu_22_setups/2024-06-07--canary-aed/recipe/i6_experiments/users/zeineldeen/experiments/canary_aed/nemo/run_eval_beam_search.py", + hash_overwrite=f"run_eval_v2_rtf_run{run}", + ) + for beam_size in [1, 4]: + for bs_ in [16, 32]: + for test_set, split in TEST_DATASETS.items(): + name = f"{test_set}_bs{bs_}_beam{beam_size}_run{run}" + search_job = SearchJob( + model_id=MODEL_ID, + model_path=model_path, + dataset_path=dataset_paths[test_set], + dataset_name=test_set, + cache_dir_name_suffix=name, + split=split, + search_script=our_beam_search_script, + search_args={"batch_size": bs_, "pnc": False, "max_eval_samples": -1, "beam_size": beam_size}, + python_exe=python_exe, + device="gpu", + time_rqmt=24, + mem_rqmt=8, + cpu_rqmt=4, + ) + search_job.rqmt["sbatch_args"] = ["-p", "gpu_test_24gb", "-w", "cn-290", "--reservation", "hlt_6"] + search_job.add_alias(f"canary_1b/beam_search_v5/{name}") + tk.register_output(f"canary_1b/beam_search_v5/{name}/search_out", search_job.out_search_results) + tk.register_output(f"canary_1b/beam_search_v5/{name}/wer", search_job.out_wer) diff --git a/users/zeineldeen/experiments/canary_aed/nemo/run_eval.py b/users/zeineldeen/experiments/canary_aed/nemo/run_eval.py index eab4d1d32..ce379c02c 100644 --- a/users/zeineldeen/experiments/canary_aed/nemo/run_eval.py +++ b/users/zeineldeen/experiments/canary_aed/nemo/run_eval.py @@ -155,6 +155,8 @@ def main(args): f"{args.model_id.replace('/', '-')}-{args.dataset_path.replace('/', '')}-" f"{args.dataset.replace('/', '-')}-{args.split}" ) + if args.cache_dir_name_suffix: + cache_prefix += f"_{args.cache_dir_name_suffix}" results = buffer_audio_and_transcribe(asr_model, dataset, args.batch_size, args.pnc, cache_prefix, verbose=True) for sample in results: predictions.append(data_utils.normalizer(sample["pred_text"])) @@ -193,6 +195,8 @@ def main(args): parser.add_argument("--dataset", type=str, required=True, help="Dataset name.") parser.add_argument("--split", type=str, required=True, help="Dataset split.") + parser.add_argument("--cache_dir_name_suffix", type=str, default=None, help="Cache dir name suffix.") + parser.add_argument("--manifest_path", type=str, required=True, help="Path to save the search output.") parser.add_argument("--wer_out_path", type=str, default=None, help="Path to save the WER output.") diff --git a/users/zeineldeen/experiments/canary_aed/nemo/run_eval_beam_search.py b/users/zeineldeen/experiments/canary_aed/nemo/run_eval_beam_search.py index 20996fb0a..0aff98d42 100644 --- a/users/zeineldeen/experiments/canary_aed/nemo/run_eval_beam_search.py +++ b/users/zeineldeen/experiments/canary_aed/nemo/run_eval_beam_search.py @@ -337,6 +337,8 @@ def main(args): f"{args.model_id.replace('/', '-')}-{args.dataset_path.replace('/', '')}-" f"{args.dataset.replace('/', '-')}-{args.split}" ) + if args.cache_dir_name_suffix: + cache_prefix += f"_{args.cache_dir_name_suffix}" results = buffer_audio_and_transcribe(asr_model, dataset, args.batch_size, args.pnc, cache_prefix, verbose=True) for sample in results: predictions.append(data_utils.normalizer(sample["pred_text"])) @@ -375,6 +377,10 @@ def main(args): parser.add_argument("--dataset", type=str, required=True, help="Dataset name.") parser.add_argument("--split", type=str, required=True, help="Dataset split.") + parser.add_argument("--cache_dir_name_suffix", type=str, default=None, help="Cache dir name suffix.") + + parser.add_argument("--cache_dir_name_suffix", type=str, required=True, help="Cache dir name suffix.") + parser.add_argument("--manifest_path", type=str, required=True, help="Path to save the search output.") parser.add_argument("--wer_out_path", type=str, default=None, help="Path to save the WER output.") diff --git a/users/zeineldeen/experiments/canary_aed/nemo/search.py b/users/zeineldeen/experiments/canary_aed/nemo/search.py index 75c9cd98f..09d57454f 100644 --- a/users/zeineldeen/experiments/canary_aed/nemo/search.py +++ b/users/zeineldeen/experiments/canary_aed/nemo/search.py @@ -14,6 +14,7 @@ def __init__( model_path: tk.Path, dataset_path: tk.Path, dataset_name: str, + cache_dir_name_suffix: str, split: str, search_script: tk.Path, search_args: Optional[Dict[str, Any]] = None, @@ -27,6 +28,7 @@ def __init__( self.model_path = model_path self.dataset_path = dataset_path self.dataset_name = dataset_name + self.cache_dir_name_suffix = cache_dir_name_suffix self.split = split self.search_script = search_script self.search_args = search_args if search_args is not None else {} @@ -58,6 +60,8 @@ def get_cmd(self): self.dataset_path.get_path(), "--dataset", self.dataset_name, + "--cache_dir_name_suffix", + self.cache_dir_name_suffix, "--split", self.split, "--manifest_path", @@ -90,6 +94,7 @@ def hash(cls, kwargs): "model_path": kwargs["model_path"], "dataset_path": kwargs["dataset_path"], "dataset_name": kwargs["dataset_name"], + "cache_dir_name_suffix": kwargs["cache_dir_name_suffix"], "split": kwargs["split"], "search_script": kwargs["search_script"], "search_args": kwargs["search_args"], From 801e5060c501da72d88bc6d79327963fcdb79cee Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Thu, 20 Jun 2024 11:42:27 +0000 Subject: [PATCH 217/227] update --- .../experiments/canary_aed/configs/canary_1b_recog.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py b/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py index 0f4f0d64d..6a2325a50 100644 --- a/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py +++ b/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py @@ -71,7 +71,7 @@ def py(): hash_overwrite=f"run_eval_v1_rtf_run{run}", ) for test_set, split in TEST_DATASETS.items(): - for bs in [64]: # [16, 32, 64]: + for bs in [16, 32, 64]: name = f"{test_set}_bs{bs}_greedy_run{run}" search_job = SearchJob( model_id=MODEL_ID, From 37a681d2ae9a44671acaa48acd94e0f9dda26846 Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Thu, 20 Jun 2024 11:45:45 +0000 Subject: [PATCH 218/227] fix --- .../experiments/canary_aed/nemo/run_eval_beam_search.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/users/zeineldeen/experiments/canary_aed/nemo/run_eval_beam_search.py b/users/zeineldeen/experiments/canary_aed/nemo/run_eval_beam_search.py index 0aff98d42..0246be0c6 100644 --- a/users/zeineldeen/experiments/canary_aed/nemo/run_eval_beam_search.py +++ b/users/zeineldeen/experiments/canary_aed/nemo/run_eval_beam_search.py @@ -379,8 +379,6 @@ def main(args): parser.add_argument("--cache_dir_name_suffix", type=str, default=None, help="Cache dir name suffix.") - parser.add_argument("--cache_dir_name_suffix", type=str, required=True, help="Cache dir name suffix.") - parser.add_argument("--manifest_path", type=str, required=True, help="Path to save the search output.") parser.add_argument("--wer_out_path", type=str, default=None, help="Path to save the WER output.") From e38138014abcebc746f8129ee0b4e303edace91f Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Thu, 20 Jun 2024 11:46:15 +0000 Subject: [PATCH 219/227] add debug out --- .../experiments/canary_aed/nemo/run_eval_beam_search.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/users/zeineldeen/experiments/canary_aed/nemo/run_eval_beam_search.py b/users/zeineldeen/experiments/canary_aed/nemo/run_eval_beam_search.py index 0246be0c6..acd49d0ad 100644 --- a/users/zeineldeen/experiments/canary_aed/nemo/run_eval_beam_search.py +++ b/users/zeineldeen/experiments/canary_aed/nemo/run_eval_beam_search.py @@ -225,7 +225,7 @@ def _transcribe_output_processing_our_beam_search( max_seq_len=enc_lens, device=enc_states.device, opts=beam_search_v5_opts, - # debug_out=sys.stdout, + debug_out=sys.stdout, ) # [B,Beam,L] best_hyps = [] From 352299ea0b0743fadfb91fae2ea98d72a2ce3a22 Mon Sep 17 00:00:00 2001 From: Mohammad Zeineldeen Date: Thu, 20 Jun 2024 14:13:45 +0000 Subject: [PATCH 220/227] add batch size logging --- .../canary_aed/configs/canary_1b_recog.py | 69 +++++++++++++------ .../experiments/canary_aed/nemo/run_eval.py | 1 + .../canary_aed/nemo/run_eval_beam_search.py | 1 + 3 files changed, 49 insertions(+), 22 deletions(-) diff --git a/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py b/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py index 6a2325a50..8c658458f 100644 --- a/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py +++ b/users/zeineldeen/experiments/canary_aed/configs/canary_1b_recog.py @@ -100,25 +100,50 @@ def py(): hash_overwrite=f"run_eval_v2_rtf_run{run}", ) for beam_size in [1, 4]: - for bs_ in [16, 32]: - for test_set, split in TEST_DATASETS.items(): - name = f"{test_set}_bs{bs_}_beam{beam_size}_run{run}" - search_job = SearchJob( - model_id=MODEL_ID, - model_path=model_path, - dataset_path=dataset_paths[test_set], - dataset_name=test_set, - cache_dir_name_suffix=name, - split=split, - search_script=our_beam_search_script, - search_args={"batch_size": bs_, "pnc": False, "max_eval_samples": -1, "beam_size": beam_size}, - python_exe=python_exe, - device="gpu", - time_rqmt=24, - mem_rqmt=8, - cpu_rqmt=4, - ) - search_job.rqmt["sbatch_args"] = ["-p", "gpu_test_24gb", "-w", "cn-290", "--reservation", "hlt_6"] - search_job.add_alias(f"canary_1b/beam_search_v5/{name}") - tk.register_output(f"canary_1b/beam_search_v5/{name}/search_out", search_job.out_search_results) - tk.register_output(f"canary_1b/beam_search_v5/{name}/wer", search_job.out_wer) + for bs in [16, 32]: + for thre_pruning in [0.0]: + for adaptive_prune in [False]: + if beam_size == 1 and (thre_pruning != 0.0 or adaptive_prune is True): + continue + for test_set, split in TEST_DATASETS.items(): + name = f"{test_set}_bs{bs}_beam{beam_size}_run{run}" + search_args = { + "batch_size": bs, + "pnc": False, + "max_eval_samples": -1, + "beam_size": beam_size, + } + if adaptive_prune: + search_args["adaptive_pruning"] = True + name += "adaptivePrune" + if thre_pruning: + search_args["threshold_pruning"] = thre_pruning + name += f"threPruning{thre_pruning}" + search_job = SearchJob( + model_id=MODEL_ID, + model_path=model_path, + dataset_path=dataset_paths[test_set], + dataset_name=test_set, + cache_dir_name_suffix=name, + split=split, + search_script=our_beam_search_script, + search_args=search_args, + python_exe=python_exe, + device="gpu", + time_rqmt=24, + mem_rqmt=8, + cpu_rqmt=4, + ) + search_job.rqmt["sbatch_args"] = [ + "-p", + "gpu_test_24gb", + "-w", + "cn-290", + "--reservation", + "hlt_6", + ] + search_job.add_alias(f"canary_1b/beam_search_v5/{name}") + tk.register_output( + f"canary_1b/beam_search_v5/{name}/search_out", search_job.out_search_results + ) + tk.register_output(f"canary_1b/beam_search_v5/{name}/wer", search_job.out_wer) diff --git a/users/zeineldeen/experiments/canary_aed/nemo/run_eval.py b/users/zeineldeen/experiments/canary_aed/nemo/run_eval.py index ce379c02c..4ad20b795 100644 --- a/users/zeineldeen/experiments/canary_aed/nemo/run_eval.py +++ b/users/zeineldeen/experiments/canary_aed/nemo/run_eval.py @@ -157,6 +157,7 @@ def main(args): ) if args.cache_dir_name_suffix: cache_prefix += f"_{args.cache_dir_name_suffix}" + print(f"Using batch size: {args.batch_size}") results = buffer_audio_and_transcribe(asr_model, dataset, args.batch_size, args.pnc, cache_prefix, verbose=True) for sample in results: predictions.append(data_utils.normalizer(sample["pred_text"])) diff --git a/users/zeineldeen/experiments/canary_aed/nemo/run_eval_beam_search.py b/users/zeineldeen/experiments/canary_aed/nemo/run_eval_beam_search.py index acd49d0ad..46c30e22a 100644 --- a/users/zeineldeen/experiments/canary_aed/nemo/run_eval_beam_search.py +++ b/users/zeineldeen/experiments/canary_aed/nemo/run_eval_beam_search.py @@ -339,6 +339,7 @@ def main(args): ) if args.cache_dir_name_suffix: cache_prefix += f"_{args.cache_dir_name_suffix}" + print(f"Using batch size: {args.batch_size}") results = buffer_audio_and_transcribe(asr_model, dataset, args.batch_size, args.pnc, cache_prefix, verbose=True) for sample in results: predictions.append(data_utils.normalizer(sample["pred_text"])) From c42d139015ee4246dfc476789b2104a8ee9fa101 Mon Sep 17 00:00:00 2001 From: "luca.gaudino" Date: Thu, 20 Jun 2024 16:34:40 +0200 Subject: [PATCH 221/227] import i6_models conformer in rf, batch 1 --- .../librispeech_960/_import_model_nick.py | 71 +++-- .../_test_returnn_torch_mhsa.py | 72 +++-- .../librispeech_960/conformer_ctc_train.py | 24 +- .../conformer_diff_i6_models_vs_rf.md | 85 ++++++ .../rf_robin_rnnt_2024/__init__.py | 0 .../output/recog_config.config | 136 +++++++++ .../ReturnnForwardJobV2/work/rnn.sh | 2 + .../output/train_config.config | 263 ++++++++++++++++++ .../ReturnnTrainingJob/work/rnn.sh | 2 + .../luca_example_transducer/__init__.py | 0 .../transducer_model_luca.py | 234 ++++++++++++++++ .../rf/conformer_rnnt/model_conformer_rnnt.py | 7 +- 12 files changed, 845 insertions(+), 51 deletions(-) create mode 100644 users/gaudino/experiments/rf_conformer_rnnt_2024/librispeech_960/conformer_diff_i6_models_vs_rf.md create mode 100644 users/gaudino/experiments/rf_robin_rnnt_2024/__init__.py create mode 100644 users/gaudino/experiments/rf_robin_rnnt_2024/luca_example_transducer/ReturnnForwardJobV2/output/recog_config.config create mode 100755 users/gaudino/experiments/rf_robin_rnnt_2024/luca_example_transducer/ReturnnForwardJobV2/work/rnn.sh create mode 100644 users/gaudino/experiments/rf_robin_rnnt_2024/luca_example_transducer/ReturnnTrainingJob/output/train_config.config create mode 100755 users/gaudino/experiments/rf_robin_rnnt_2024/luca_example_transducer/ReturnnTrainingJob/work/rnn.sh create mode 100644 users/gaudino/experiments/rf_robin_rnnt_2024/luca_example_transducer/__init__.py create mode 100644 users/gaudino/experiments/rf_robin_rnnt_2024/luca_example_transducer/transducer_model_luca.py diff --git a/users/gaudino/experiments/rf_conformer_rnnt_2024/librispeech_960/_import_model_nick.py b/users/gaudino/experiments/rf_conformer_rnnt_2024/librispeech_960/_import_model_nick.py index d944d6c95..fb589c306 100644 --- a/users/gaudino/experiments/rf_conformer_rnnt_2024/librispeech_960/_import_model_nick.py +++ b/users/gaudino/experiments/rf_conformer_rnnt_2024/librispeech_960/_import_model_nick.py @@ -98,7 +98,7 @@ def convert_checkpoint( assert isinstance(name, str) assert isinstance(param, rf.Parameter) - value = map_param_func(ckpt, name, param, param_mapping) + value = map_param_func(ckpt, name, param, param_mapping, model) assert isinstance(value, numpy.ndarray) # noinspection PyProtectedMember param._raw_backend.set_parameter_initial_value(param, value) @@ -119,7 +119,7 @@ def convert_checkpoint( if save_model: os.makedirs(out_dir, exist_ok=True) - filename = out_dir + "/" + ckpt_name # + ".pt" + filename = out_dir + "/" + ckpt_name # + ".pt" print(f"*** saving PyTorch model checkpoint: {filename}") torch.save( {"model": pt_model.state_dict(), "epoch": epoch, "step": step}, filename @@ -158,10 +158,11 @@ def convert_checkpoint( f"encoder.layers.{layer_idx}.conv_block.positionwise_conv1.weight" ) _transpose_list.append( - f"encoder.layers.{layer_idx}.self_att.qkv.weight" + f"encoder.layers.{layer_idx}.conv_block.positionwise_conv2.weight" ) + def _add_params_conformer(param_mapping: Dict[str, str], prefix: str): # rf -> pt # frontend @@ -228,10 +229,10 @@ def _add_params_conformer(param_mapping: Dict[str, str], prefix: str): param_mapping[ prefix + f"encoder.layers.{layer_idx}.conv_block.positionwise_conv2.bias" ] = (orig_name_prefix + "conv.pointwise_conv2.bias") - param_mapping[prefix + f"encoder.layers.{layer_idx}.conv_block.norm.gamma"] = ( + param_mapping[prefix + f"encoder.layers.{layer_idx}.conv_block.norm.scale"] = ( orig_name_prefix + "conv.norm.weight" ) - param_mapping[prefix + f"encoder.layers.{layer_idx}.conv_block.norm.beta"] = ( + param_mapping[prefix + f"encoder.layers.{layer_idx}.conv_block.norm.bias"] = ( orig_name_prefix + "conv.norm.bias" ) param_mapping[prefix + f"encoder.layers.{layer_idx}.conv_layer_norm.scale"] = ( @@ -241,15 +242,15 @@ def _add_params_conformer(param_mapping: Dict[str, str], prefix: str): orig_name_prefix + "conv.layer_norm.bias" ) # self-att - param_mapping[prefix + f"encoder.layers.{layer_idx}.self_att.qkv.weight"] = ( - orig_name_prefix + "mhsa.mhsa.in_proj_weight" - ) - param_mapping[prefix + f"encoder.layers.{layer_idx}.self_att.qkv.bias"] = ( - orig_name_prefix + "mhsa.mhsa.in_proj_bias" - ) - param_mapping[prefix + f"encoder.layers.{layer_idx}.self_att.proj.weight"] = ( - orig_name_prefix + "mhsa.mhsa.out_proj.weight" - ) + # param_mapping[prefix + f"encoder.layers.{layer_idx}.self_att.qkv.weight"] = ( + # orig_name_prefix + "mhsa.mhsa.in_proj_weight" + # ) + # param_mapping[prefix + f"encoder.layers.{layer_idx}.self_att.qkv.bias"] = ( + # orig_name_prefix + "mhsa.mhsa.in_proj_bias" + # ) + # param_mapping[prefix + f"encoder.layers.{layer_idx}.self_att.proj.weight"] = ( + # orig_name_prefix + "mhsa.mhsa.out_proj.weight" + # ) param_mapping[prefix + f"encoder.layers.{layer_idx}.self_att.proj.bias"] = ( orig_name_prefix + "mhsa.mhsa.out_proj.bias" ) @@ -308,7 +309,7 @@ def _add_params_predictor_joiner(param_mapping: Dict[str, str]): def map_param_func( - ckpt, name: str, var: rf.Parameter, param_mapping: Dict[str, str] + ckpt, name: str, var: rf.Parameter, param_mapping: Dict[str, str], model: rf.Module ) -> numpy.ndarray: """map params, TF to RF""" from i6_experiments.users.zeyer.returnn.convert.params import ( @@ -337,13 +338,49 @@ def map_param_func( ), f"new param {name} {var.dtype} vs ckpt param {var_name} {value.dtype}" return value + layer_idx = int(name.split(".")[2]) + num_heads = model.encoder.layers[layer_idx].self_att.num_heads.dimension + self_att_dim = model.encoder.layers[layer_idx].self_att.out_dim.dimension + + if name.endswith(".self_att.qkv.weight"): + value = ckpt["model"][ + f"conformer.module_list.{layer_idx}.mhsa.mhsa.in_proj_weight" + ] + # from rf to torch + # value = ( + # value.reshape(self_att_dim, num_heads, 3, self_att_dim // num_heads) + # .permute(2, 1, 3, 0) + # .reshape(-1, self_att_dim) + # ) + value = value.reshape(3, num_heads, self_att_dim // num_heads, self_att_dim).permute(3, 1, 0, 2).reshape(self_att_dim, -1) + assert value.shape == var.batch_shape, name + f" {value.shape} vs {var.batch_shape}" + return value.numpy() + + if name.endswith(".self_att.qkv.bias"): + value = ckpt["model"][ + f"conformer.module_list.{layer_idx}.mhsa.mhsa.in_proj_bias" + ] + # value = value.reshape(num_heads, 3, self_att_dim // num_heads).permute(1, 0, 2).reshape(-1) + value = value.reshape(3, num_heads, self_att_dim // num_heads).permute(1, 0, 2).reshape(-1) + assert value.shape == var.batch_shape, name + f" {value.shape} vs {var.batch_shape}" + return value.numpy() + + if name.endswith(".self_att.proj.weight"): + value = ckpt["model"][ + f"conformer.module_list.{layer_idx}.mhsa.mhsa.out_proj.weight" + ] + # value = value.reshape(num_heads, self_att_dim // num_heads, self_att_dim).permute(2, 0, 1).reshape(-1, self_att_dim) + value = value.reshape(self_att_dim, num_heads, self_att_dim // num_heads).permute(1, 2, 0).reshape(self_att_dim, -1) + assert value.shape == var.batch_shape, name + f" {value.shape} vs {var.batch_shape}" + return value.numpy() + # if name == "s.ff_weight": # value = reader.get_tensor("output/rec/s/rec/lstm_cell/kernel") # value = convert_params_np.convert_tf_lstm_to_native_lstm_ff(value) # assert value.shape == var.batch_shape, name # assert value.dtype.name == var.dtype, name # return value - # + #0 # if name == "s.rec_weight": # value = reader.get_tensor("output/rec/s/rec/lstm_cell/kernel") # value = convert_params_np.convert_tf_lstm_to_native_lstm_rec(value) @@ -381,6 +418,6 @@ def map_param_func( convert_checkpoint( ckpt_path=_nick_pure_torch_rnnt_ckpt_path, print_params=True, - out_dir="/work/asr3/zeineldeen/hiwis/luca.gaudino/setups-data/2023-08-10--rf-librispeech/work/i6_experiments/users/gaudino/returnn/convert_ckpt_rf/librispeech/rnnt_nick_240614", + out_dir="/work/asr3/zeineldeen/hiwis/luca.gaudino/setups-data/2023-08-10--rf-librispeech/work/i6_experiments/users/gaudino/returnn/convert_ckpt_rf/librispeech/rnnt_nick_240619", save_model=True, ) diff --git a/users/gaudino/experiments/rf_conformer_rnnt_2024/librispeech_960/_test_returnn_torch_mhsa.py b/users/gaudino/experiments/rf_conformer_rnnt_2024/librispeech_960/_test_returnn_torch_mhsa.py index 11b545e0d..62c92a83e 100644 --- a/users/gaudino/experiments/rf_conformer_rnnt_2024/librispeech_960/_test_returnn_torch_mhsa.py +++ b/users/gaudino/experiments/rf_conformer_rnnt_2024/librispeech_960/_test_returnn_torch_mhsa.py @@ -25,7 +25,7 @@ rf_input = rf.random(dims=[Dim(1), spatial_dim, out_dim], **random_opts) -qkv_weight = rf.random(dims=[out_dim, 3*out_dim], **random_opts) +qkv_weight = rf.random(dims=[out_dim, 3 * out_dim], **random_opts) # qkv_weight = rf.full(dims=[out_dim, 3*out_dim], fill_value=0.0, dtype="float32") # qkv_weight.raw_tensor[:,1024:] = 0.0 # qkv_weight.raw_tensor[:,0:1023] = 0.0 @@ -37,7 +37,7 @@ # # qkv_weight.raw_tensor = qkv_raw -qkv_bias = rf.random(dims=[3*out_dim], **random_opts) +qkv_bias = rf.random(dims=[3 * out_dim], **random_opts) # qkv_bias = rf.full(dims=[3*out_dim], fill_value=0.0, dtype="float32") # qkv_bias.raw_tensor[1024:] = 0.0 @@ -51,31 +51,59 @@ proj_dim=out_dim, key_dim_total=out_dim, value_dim_total=out_dim, - num_heads=1, + num_heads=8, att_dropout=0.1, ) -rf_mhsa.qkv.weight._raw_backend.set_parameter_initial_value(rf_mhsa.qkv.weight, qkv_weight) +rf_mhsa.qkv.weight._raw_backend.set_parameter_initial_value( + rf_mhsa.qkv.weight, qkv_weight +) rf_mhsa.qkv.bias._raw_backend.set_parameter_initial_value(rf_mhsa.qkv.bias, qkv_bias) -rf_mhsa.proj.weight._raw_backend.set_parameter_initial_value(rf_mhsa.proj.weight, proj_weight.raw_tensor) +rf_mhsa.proj.weight._raw_backend.set_parameter_initial_value( + rf_mhsa.proj.weight, proj_weight.raw_tensor +) rf_mhsa.proj.bias._raw_backend.set_parameter_initial_value(rf_mhsa.proj.bias, proj_bias) torch_mhsa = torch.nn.MultiheadAttention( - 512, 1, dropout=0.1, batch_first=True, - ) + 512, + 8, + dropout=0.1, + batch_first=True, +) state_dict = torch_mhsa.state_dict() -state_dict['in_proj_weight'] = qkv_weight.raw_tensor.T -state_dict['in_proj_bias'] = qkv_bias.raw_tensor -state_dict['out_proj.weight'] = proj_weight.raw_tensor -state_dict['out_proj.bias'] = proj_bias.raw_tensor + +num_heads = 8 + +state_dict["in_proj_weight"] = ( + qkv_weight.raw_tensor.reshape( + out_dim.dimension, num_heads, 3, out_dim.dimension // num_heads + ) + .permute(2, 1, 3, 0) + .reshape(-1, out_dim.dimension) +) +state_dict["in_proj_bias"] = ( + qkv_bias.raw_tensor.reshape(num_heads, 3, out_dim.dimension // num_heads) + .permute(1, 0, 2) + .reshape(-1) +) +state_dict["out_proj.weight"] = ( + proj_weight.raw_tensor.reshape( + num_heads, out_dim.dimension // num_heads, out_dim.dimension + ) + .permute(2, 0, 1) + .reshape(-1, out_dim.dimension) +) +state_dict["out_proj.bias"] = proj_bias.raw_tensor torch_mhsa.load_state_dict(state_dict) torch_mhsa.eval() rf_output = rf_mhsa(rf_input, axis=spatial_dim) -torch_output, _ = torch_mhsa(torch_input, torch_input, torch_input, key_padding_mask=None, need_weights=False) +torch_output, _ = torch_mhsa( + torch_input, torch_input, torch_input, key_padding_mask=None, need_weights=False +) print("RF output") print(rf_output.raw_tensor) @@ -84,7 +112,7 @@ print("Torch output") print(torch_output) print(torch_output.shape) -print("Same: ", torch.allclose(rf_output.raw_tensor, torch_output, atol=1e-6)) +print("Same: ", torch.allclose(rf_output.raw_tensor, torch_output, atol=1e-3)) ## extended checks @@ -96,7 +124,7 @@ any = False for perm in itertools.permutations(weights): - for q_inv, k_inv, v_inv in itertools.product([0,1], [0,1], [0,1]): + for q_inv, k_inv, v_inv in itertools.product([0, 1], [0, 1], [0, 1]): q_raw, k_raw, v_raw = perm if q_inv == 1: @@ -109,16 +137,22 @@ qkv_weight_adj_raw = torch.cat([q_raw.T, k_raw.T, v_raw.T], dim=1) state_dict = torch_mhsa.state_dict() - state_dict['in_proj_weight'] = qkv_weight_adj_raw.T - state_dict['in_proj_bias'] = qkv_bias.raw_tensor - state_dict['out_proj.weight'] = proj_weight.raw_tensor - state_dict['out_proj.bias'] = proj_bias.raw_tensor + state_dict["in_proj_weight"] = qkv_weight_adj_raw.T + state_dict["in_proj_bias"] = qkv_bias.raw_tensor + state_dict["out_proj.weight"] = proj_weight.raw_tensor + state_dict["out_proj.bias"] = proj_bias.raw_tensor torch_mhsa.load_state_dict(state_dict) torch_mhsa.eval() rf_output = rf_mhsa(rf_input, axis=spatial_dim) - torch_output, _ = torch_mhsa(torch_input, torch_input, torch_input, key_padding_mask=None, need_weights=False) + torch_output, _ = torch_mhsa( + torch_input, + torch_input, + torch_input, + key_padding_mask=None, + need_weights=False, + ) print("RF output") print(rf_output.raw_tensor) diff --git a/users/gaudino/experiments/rf_conformer_rnnt_2024/librispeech_960/conformer_ctc_train.py b/users/gaudino/experiments/rf_conformer_rnnt_2024/librispeech_960/conformer_ctc_train.py index 3787a9f76..880000ee1 100644 --- a/users/gaudino/experiments/rf_conformer_rnnt_2024/librispeech_960/conformer_ctc_train.py +++ b/users/gaudino/experiments/rf_conformer_rnnt_2024/librispeech_960/conformer_ctc_train.py @@ -123,18 +123,18 @@ def sis_run_with_prefix(prefix_name: Optional[str] = None): # }, # ) - train_exp( # dev-other 9.01 - "base-24gb-lrlin1e_5_600k_ctc_only", - config_24gb_v6, - config_updates={ - "learning_rate": 1.0, - "dynamic_learning_rate": dyn_lr_piecewise_linear, - # total steps after 2000 epochs: 982.312 - "learning_rate_piecewise_steps": [600_000, 900_000, 982_000], - "learning_rate_piecewise_values": [1e-5, 1e-3, 1e-5, 1e-6], - "aux_loss_layers":[], - }, - ) + # train_exp( # dev-other 9.01 + # "base-24gb-lrlin1e_5_600k_ctc_only", + # config_24gb_v6, + # config_updates={ + # "learning_rate": 1.0, + # "dynamic_learning_rate": dyn_lr_piecewise_linear, + # # total steps after 2000 epochs: 982.312 + # "learning_rate_piecewise_steps": [600_000, 900_000, 982_000], + # "learning_rate_piecewise_values": [1e-5, 1e-3, 1e-5, 1e-6], + # "aux_loss_layers":[], + # }, + # ) train_exp( # dev-other 6.93 "base-24gb-lrlin1e_5_600k_ctc_only_aux4_8", diff --git a/users/gaudino/experiments/rf_conformer_rnnt_2024/librispeech_960/conformer_diff_i6_models_vs_rf.md b/users/gaudino/experiments/rf_conformer_rnnt_2024/librispeech_960/conformer_diff_i6_models_vs_rf.md new file mode 100644 index 000000000..464916a8d --- /dev/null +++ b/users/gaudino/experiments/rf_conformer_rnnt_2024/librispeech_960/conformer_diff_i6_models_vs_rf.md @@ -0,0 +1,85 @@ +# Importing i6_models conformer into returnn frontend setup + +## Structural differences +| Difference | * | i6_models | rf | +|--------------------------------------------------------|---|-----------|--| +| input_projection uses bias | | yes | no | +| self attention qkv uses bias | | yes | no | +| convolutional kernel size | | 31 | 32 | +| positional encoding in mhsa | * | no | yes | +| batch norm | * | no | yes | +| ff_activation | | silu | rf.relu(x) ** 2.0 | +| vgg frontend (several differences) | | | | +| feature extraction (not sure of the exact difference ) | | | | + +VGG Frontend configuration for rf: +``` +ConformerConvSubsampleV2( + in_dim, + out_dims=[ + Dim(32, name="conv1"), + Dim(64, name="conv2"), + Dim(64, name="conv3"), + Dim(32, name="conv4"), # Changed: Dim(64, name="conv4") + ], + filter_sizes=[(3, 3), (3, 3), (3, 3), (3, 3)], # Changed + activation_times=[False, True, False, True], # Changed + pool_sizes=[(1, 1), (3, 1), (1, 1), (2, 1)], # Changed + strides=[(1, 1), (1, 1), (1, 1), (1, 1)], # Changed + padding="same", # Changed: padding="valid" + pool_padding="valid", # Changed + swap_merge_dim_order=True, # Changed + # Note: uses relu activation by default + ), +``` + +## Adjust weights + +Transpose: + +``` +_transpose_list = [ + "encoder_out_linear.weight", + "encoder.input_projection.weight", + "joiner.linear.weight", + "predictor.linear.weight", +] + +for layer_idx in range(12): + _transpose_list.append(f"encoder.layers.{layer_idx}.ffn1.linear_ff.weight") + _transpose_list.append(f"encoder.layers.{layer_idx}.ffn1.linear_out.weight") + _transpose_list.append(f"encoder.layers.{layer_idx}.ffn2.linear_ff.weight") + _transpose_list.append(f"encoder.layers.{layer_idx}.ffn2.linear_out.weight") + + _transpose_list.append( + f"encoder.layers.{layer_idx}.conv_block.positionwise_conv1.weight" + ) + _transpose_list.append( + f"encoder.layers.{layer_idx}.conv_block.positionwise_conv2.weight" + ) + +``` + +Adjust self att weights: +``` + if name.endswith(".self_att.qkv.weight"): + value = ckpt["model"][ + f"conformer.module_list.{layer_idx}.mhsa.mhsa.in_proj_weight" + ] + value = value.reshape(3, num_heads, self_att_dim // num_heads, self_att_dim).permute(3, 1, 0, 2).reshape(self_att_dim, -1) + return value.numpy() + + if name.endswith(".self_att.qkv.bias"): + value = ckpt["model"][ + f"conformer.module_list.{layer_idx}.mhsa.mhsa.in_proj_bias" + ] + value = value.reshape(3, num_heads, self_att_dim // num_heads).permute(1, 0, 2).reshape(-1) + return value.numpy() + + if name.endswith(".self_att.proj.weight"): + value = ckpt["model"][ + f"conformer.module_list.{layer_idx}.mhsa.mhsa.out_proj.weight" + ] + value = value.reshape(self_att_dim, num_heads, self_att_dim // num_heads).permute(1, 2, 0).reshape(self_att_dim, -1) + return value.numpy() +``` \ No newline at end of file diff --git a/users/gaudino/experiments/rf_robin_rnnt_2024/__init__.py b/users/gaudino/experiments/rf_robin_rnnt_2024/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/users/gaudino/experiments/rf_robin_rnnt_2024/luca_example_transducer/ReturnnForwardJobV2/output/recog_config.config b/users/gaudino/experiments/rf_robin_rnnt_2024/luca_example_transducer/ReturnnForwardJobV2/output/recog_config.config new file mode 100644 index 000000000..d4c45598a --- /dev/null +++ b/users/gaudino/experiments/rf_robin_rnnt_2024/luca_example_transducer/ReturnnForwardJobV2/output/recog_config.config @@ -0,0 +1,136 @@ +#!rnn.py + + +accum_grad_multiple_step = 4 +backend = "torch" +batch_size = 2400000 +batching = "random" +beam_search_opts = {"beam_size": 12} +debug_print_layer_output_template = True +default_input = "data" +device = "gpu" +forward_data = { + "class": "MetaDataset", + "data_map": { + "data": ("zip_dataset", "data"), + "targets": ("zip_dataset", "classes"), + }, + "datasets": { + "zip_dataset": { + "audio": { + "features": "raw", + "peak_normalization": True, + "pre_process": None, + "preemphasis": None, + }, + "class": "OggZipDataset", + "epoch_wise_filter": None, + "fixed_random_subset": None, + "partition_epoch": 1, + "path": [ + "/u/zeineldeen/setups/librispeech/2022-11-28--conformer-att/work/i6_core/returnn/oggzip/BlissToOggZipJob.NSdIHfk1iw2M/output/out.ogg.zip" + ], + "segment_file": None, + "seq_ordering": "sorted_reverse", + "targets": { + "bpe_file": "/u/zeineldeen/setups/librispeech/2022-11-28--conformer-att/work/i6_core/text/label/subword_nmt/train/ReturnnTrainBpeJob.vTq56NZ8STWt/output/bpe.codes", + "class": "BytePairEncoding", + "seq_postfix": [0], + "unknown_label": None, + "vocab_file": "/u/zeineldeen/setups/librispeech/2022-11-28--conformer-att/work/i6_core/text/label/subword_nmt/train/ReturnnTrainBpeJob.vTq56NZ8STWt/output/bpe.vocab", + }, + "use_cache_manager": True, + } + }, + "seq_order_control_dataset": "zip_dataset", +} + +log = ["./returnn.log"] +log_batch_size = True +log_verbosity = 5 +max_seqs = 200 +non_blank_vocab = { + "bos_label": 0, + "bpe_file": "/u/zeineldeen/setups/librispeech/2022-11-28--conformer-att/work/i6_core/text/label/subword_nmt/train/ReturnnTrainBpeJob.vTq56NZ8STWt/output/bpe.codes", + "eos_label": 0, + "unknown_label": None, + "vocab_file": "/u/zeineldeen/setups/librispeech/2022-11-28--conformer-att/work/i6_core/text/label/subword_nmt/train/ReturnnTrainBpeJob.vTq56NZ8STWt/output/bpe.vocab", +} +optimizer = {"class": "adamw", "epsilon": 1e-08, "weight_decay": 1e-06} +search_output_layer = "decision" +target = "targets" +task = "forward" +tf_log_dir = "returnn-tf-log" +torch_dataloader_opts = {"num_workers": 1} +torch_log_memory_usage = True +config = {} + +locals().update(**config) + +import os +import sys + +sys.path.insert(0, "/u/schmitt/experiments/segmental_models_2022_23_rf/recipe") +sys.path.insert(1, "/u/schmitt/src/sisyphus") +from returnn.tensor import Dim, batch_dim, single_step_dim +from returnn.tensor.marked_dim import ImplicitDynSizeDim, ImplicitSparseDim + +time_dim = Dim(description="time", dimension=None, kind=Dim.Types.Spatial) +audio_dim = Dim(description="audio", dimension=1, kind=Dim.Types.Feature) +out_spatial_dim = Dim(description="out_spatial", dimension=None, kind=Dim.Types.Spatial) +vocab_dim = Dim(description="vocab", dimension=10026, kind=Dim.Types.Spatial) + +extern_data = { + "data": {"dim_tags": [batch_dim, time_dim, audio_dim]}, + "targets": {"dim_tags": [batch_dim, out_spatial_dim], "sparse_dim": vocab_dim}, +} + +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.luca_example_transducer.transducer_model_luca import ( + from_scratch_model_def as _model_def, +) +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.luca_example_transducer.transducer_model_luca import ( + _returnn_v2_get_model as get_model, +) +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.recog import ( + model_recog as _recog_def, +) +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.recog import ( + _returnn_v2_forward_step as forward_step, +) +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.recog import ( + _returnn_v2_get_forward_callback as forward_callback, +) + +# https://github.com/rwth-i6/returnn/issues/957 +# https://stackoverflow.com/a/16248113/133374 +import resource +import sys + +try: + resource.setrlimit(resource.RLIMIT_STACK, (2**29, -1)) +except Exception as exc: + print(f"resource.setrlimit {type(exc).__name__}: {exc}") +sys.setrecursionlimit(10**6) +_cf_cache = {} + + +def cf(filename): + "Cache manager" + from subprocess import check_output, CalledProcessError + + if filename in _cf_cache: + return _cf_cache[filename] + if int(os.environ.get("RETURNN_DEBUG", "0")): + print("use local file: %s" % filename) + return filename # for debugging + try: + cached_fn = check_output(["cf", filename]).strip().decode("utf8") + except CalledProcessError: + print("Cache manager: Error occurred, using local file") + return filename + assert os.path.exists(cached_fn) + _cf_cache[filename] = cached_fn + return cached_fn + + +# -*- mode: python; tab-width: 4 -*- diff --git a/users/gaudino/experiments/rf_robin_rnnt_2024/luca_example_transducer/ReturnnForwardJobV2/work/rnn.sh b/users/gaudino/experiments/rf_robin_rnnt_2024/luca_example_transducer/ReturnnForwardJobV2/work/rnn.sh new file mode 100755 index 000000000..6edd841f1 --- /dev/null +++ b/users/gaudino/experiments/rf_robin_rnnt_2024/luca_example_transducer/ReturnnForwardJobV2/work/rnn.sh @@ -0,0 +1,2 @@ +#!/usr/bin/env bash +/usr/bin/python3 /u/schmitt/src/returnn_new/rnn.py /u/schmitt/experiments/segmental_models_2022_23_rf_pycharm/recipe/i6_experiments/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/luca_example_transducer/ReturnnForwardJobV2/output/recog_config.config \ No newline at end of file diff --git a/users/gaudino/experiments/rf_robin_rnnt_2024/luca_example_transducer/ReturnnTrainingJob/output/train_config.config b/users/gaudino/experiments/rf_robin_rnnt_2024/luca_example_transducer/ReturnnTrainingJob/output/train_config.config new file mode 100644 index 000000000..0b9458b25 --- /dev/null +++ b/users/gaudino/experiments/rf_robin_rnnt_2024/luca_example_transducer/ReturnnTrainingJob/output/train_config.config @@ -0,0 +1,263 @@ +#!rnn.py + + +def dyn_lr_piecewise_linear( + *, global_train_step: int, learning_rate: float, **_kwargs +) -> float: + """ + Piecewise linear + """ + from returnn.config import get_global_config + + config = get_global_config() + + steps = config.int_list("learning_rate_piecewise_steps") + lrs = config.float_list("learning_rate_piecewise_values") + assert len(steps) + 1 == len(lrs) + + last_step = 0 + for i, step in enumerate(steps): + assert step > last_step + assert global_train_step >= last_step + if global_train_step < step: + factor = (global_train_step + 1 - last_step) / (step - last_step) + return learning_rate * (lrs[i + 1] * factor + lrs[i] * (1 - factor)) + last_step = step + + return learning_rate * lrs[-1] + + +accum_grad_multiple_step = 4 +aux_loss_layers = None +backend = "torch" +batch_size = 2400000 +batching = "laplace:.1000" +cleanup_old_models = {"keep": [500], "keep_best_n": 4, "keep_last_n": 1} +debug_print_layer_output_template = True +default_input = "data" +dev = { + "class": "MetaDataset", + "data_map": {"data": ("zip_dataset", "data"), "targets": ("align", "data")}, + "datasets": { + "align": { + "class": "HDFDataset", + "files": [ + "/u/schmitt/experiments/segmental_models_2022_23_rf/work/i6_core/returnn/forward/ReturnnForwardJob.xERLI3g7bpFq/output/alignments.hdf" + ], + "partition_epoch": 1, + "seq_list_filter_file": "/u/zeineldeen/setups/librispeech/2022-11-28--conformer-att/work/i6_core/text/processing/PipelineJob.gTty7UHs0uBu/output/out", + "use_cache_manager": True, + }, + "zip_dataset": { + "audio": { + "features": "raw", + "peak_normalization": True, + "pre_process": None, + "preemphasis": None, + }, + "class": "OggZipDataset", + "epoch_wise_filter": None, + "fixed_random_subset": None, + "partition_epoch": 1, + "path": [ + "/u/zeineldeen/setups/librispeech/2022-11-28--conformer-att/work/i6_core/returnn/oggzip/BlissToOggZipJob.RvwLniNrgMit/output/out.ogg.zip", + "/u/zeineldeen/setups/librispeech/2022-11-28--conformer-att/work/i6_core/returnn/oggzip/BlissToOggZipJob.NSdIHfk1iw2M/output/out.ogg.zip", + ], + "segment_file": "/u/zeineldeen/setups/librispeech/2022-11-28--conformer-att/work/i6_core/text/processing/PipelineJob.gTty7UHs0uBu/output/out", + "seq_ordering": "sorted_reverse", + "targets": { + "bpe_file": "/u/zeineldeen/setups/librispeech/2022-11-28--conformer-att/work/i6_core/text/label/subword_nmt/train/ReturnnTrainBpeJob.vTq56NZ8STWt/output/bpe.codes", + "class": "BytePairEncoding", + "seq_postfix": [0], + "unknown_label": None, + "vocab_file": "/u/zeineldeen/setups/librispeech/2022-11-28--conformer-att/work/i6_core/text/label/subword_nmt/train/ReturnnTrainBpeJob.vTq56NZ8STWt/output/bpe.vocab", + }, + "use_cache_manager": True, + }, + }, + "seq_order_control_dataset": "zip_dataset", +} +device = "gpu" +dynamic_learning_rate = dyn_lr_piecewise_linear +eval_datasets = { + "devtrain": { + "class": "MetaDataset", + "data_map": {"data": ("zip_dataset", "data"), "targets": ("align", "data")}, + "datasets": { + "align": { + "class": "HDFDataset", + "files": [ + "/u/schmitt/experiments/segmental_models_2022_23_rf/work/i6_core/returnn/forward/ReturnnForwardJob.4k03LS27KUmL/output/alignments.hdf" + ], + "partition_epoch": 1, + "seq_list_filter_file": None, + "use_cache_manager": True, + }, + "zip_dataset": { + "audio": { + "features": "raw", + "peak_normalization": True, + "pre_process": None, + "preemphasis": None, + }, + "class": "OggZipDataset", + "epoch_wise_filter": None, + "fixed_random_subset": 3000, + "partition_epoch": 1, + "path": [ + "/u/zeineldeen/setups/librispeech/2022-11-28--conformer-att/work/i6_core/returnn/oggzip/BlissToOggZipJob.Cbboscd6En6A/output/out.ogg.zip" + ], + "segment_file": None, + "seq_ordering": "sorted_reverse", + "targets": { + "bpe_file": "/u/zeineldeen/setups/librispeech/2022-11-28--conformer-att/work/i6_core/text/label/subword_nmt/train/ReturnnTrainBpeJob.vTq56NZ8STWt/output/bpe.codes", + "class": "BytePairEncoding", + "seq_postfix": [0], + "unknown_label": None, + "vocab_file": "/u/zeineldeen/setups/librispeech/2022-11-28--conformer-att/work/i6_core/text/label/subword_nmt/train/ReturnnTrainBpeJob.vTq56NZ8STWt/output/bpe.vocab", + }, + "use_cache_manager": True, + }, + }, + "seq_order_control_dataset": "zip_dataset", + } +} +grad_scaler = None +gradient_clip_global_norm = 5.0 +learning_rate = 1.0 +learning_rate_file = "learning_rates" +learning_rate_piecewise_steps = [295000, 590000, 652000] +learning_rate_piecewise_values = [1e-05, 0.001, 1e-05, 1e-06] +log = ["./returnn.log"] +log_batch_size = True +log_verbosity = 5 +max_seqs = 200 +model = "/u/schmitt/experiments/segmental_models_2022_23_rf/work/i6_core/returnn/training/ReturnnTrainingJob.9zPcngFbJCDE/output/models/epoch" +num_epochs = 500 +optimizer = { + "class": "adamw", + "epsilon": 1e-16, + "weight_decay": 1e-06, + "weight_decay_modules_blacklist": [ + "rf.Embedding", + "rf.LearnedRelativePositionalEncoding", + ], +} +pos_emb_dropout = 0.1 +rf_att_dropout_broadcast = False +save_interval = 1 +target = "targets" +task = "train" +torch_dataloader_opts = {"num_workers": 1} +torch_distributed = {} +torch_log_memory_usage = True +train = { + "class": "MetaDataset", + "data_map": {"data": ("zip_dataset", "data"), "targets": ("align", "data")}, + "datasets": { + "align": { + "class": "HDFDataset", + "files": [ + "/u/schmitt/experiments/segmental_models_2022_23_rf/work/i6_core/returnn/forward/ReturnnForwardJob.4k03LS27KUmL/output/alignments.hdf" + ], + "partition_epoch": 20, + "seq_list_filter_file": None, + "use_cache_manager": True, + }, + "zip_dataset": { + "audio": { + "features": "raw", + "peak_normalization": True, + "pre_process": None, + "preemphasis": None, + }, + "class": "OggZipDataset", + "epoch_wise_filter": {(1, 5): {"max_mean_len": 1000}}, + "fixed_random_subset": None, + "partition_epoch": 20, + "path": [ + "/u/zeineldeen/setups/librispeech/2022-11-28--conformer-att/work/i6_core/returnn/oggzip/BlissToOggZipJob.Cbboscd6En6A/output/out.ogg.zip" + ], + "segment_file": None, + "seq_ordering": "laplace:.1000", + "targets": { + "bpe_file": "/u/zeineldeen/setups/librispeech/2022-11-28--conformer-att/work/i6_core/text/label/subword_nmt/train/ReturnnTrainBpeJob.vTq56NZ8STWt/output/bpe.codes", + "class": "BytePairEncoding", + "seq_postfix": [0], + "unknown_label": None, + "vocab_file": "/u/zeineldeen/setups/librispeech/2022-11-28--conformer-att/work/i6_core/text/label/subword_nmt/train/ReturnnTrainBpeJob.vTq56NZ8STWt/output/bpe.vocab", + }, + "use_cache_manager": True, + }, + }, + "seq_order_control_dataset": "zip_dataset", +} +use_horovod = True +config = {} + +locals().update(**config) + +import os +import sys + +sys.path.insert(0, "/u/schmitt/experiments/segmental_models_2022_23_rf/recipe") +sys.path.insert(1, "/u/schmitt/src/sisyphus") +from returnn.tensor import Dim, batch_dim, single_step_dim +from returnn.tensor.marked_dim import ImplicitDynSizeDim, ImplicitSparseDim + +time_dim = Dim(description="time", dimension=None, kind=Dim.Types.Spatial) +audio_dim = Dim(description="audio", dimension=1, kind=Dim.Types.Feature) +out_spatial_dim = Dim(description="out_spatial", dimension=None, kind=Dim.Types.Spatial) +vocab_dim = Dim(description="vocab", dimension=10026, kind=Dim.Types.Spatial) + +extern_data = { + "data": {"dim_tags": [batch_dim, time_dim, audio_dim]}, + "targets": {"dim_tags": [batch_dim, out_spatial_dim], "sparse_dim": vocab_dim}, +} + +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.luca_example_transducer.transducer_model_luca import ( + from_scratch_model_def as _model_def, +) +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.luca_example_transducer.transducer_model_luca import ( + _returnn_v2_get_model as get_model, +) +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.train import ( + viterbi_training as _train_def, +) +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.train import ( + _returnn_v2_train_step as train_step, +) + +# https://github.com/rwth-i6/returnn/issues/957 +# https://stackoverflow.com/a/16248113/133374 +import resource +import sys + +try: + resource.setrlimit(resource.RLIMIT_STACK, (2**29, -1)) +except Exception as exc: + print(f"resource.setrlimit {type(exc).__name__}: {exc}") +sys.setrecursionlimit(10**6) +_cf_cache = {} + + +def cf(filename): + "Cache manager" + from subprocess import check_output, CalledProcessError + + if filename in _cf_cache: + return _cf_cache[filename] + if int(os.environ.get("RETURNN_DEBUG", "0")): + print("use local file: %s" % filename) + return filename # for debugging + try: + cached_fn = check_output(["cf", filename]).strip().decode("utf8") + except CalledProcessError: + print("Cache manager: Error occurred, using local file") + return filename + assert os.path.exists(cached_fn) + _cf_cache[filename] = cached_fn + return cached_fn + + +# -*- mode: python; tab-width: 4 -*- diff --git a/users/gaudino/experiments/rf_robin_rnnt_2024/luca_example_transducer/ReturnnTrainingJob/work/rnn.sh b/users/gaudino/experiments/rf_robin_rnnt_2024/luca_example_transducer/ReturnnTrainingJob/work/rnn.sh new file mode 100755 index 000000000..b3bc931a7 --- /dev/null +++ b/users/gaudino/experiments/rf_robin_rnnt_2024/luca_example_transducer/ReturnnTrainingJob/work/rnn.sh @@ -0,0 +1,2 @@ +#!/usr/bin/env bash +/usr/bin/python3 -mtorch.distributed.run --standalone --nnodes=1 --nproc-per-node=4 /u/schmitt/src/returnn_new/rnn.py /u/schmitt/experiments/segmental_models_2022_23_rf_pycharm/recipe/i6_experiments/users/schmitt/experiments/config/pipelines/global_vs_segmental_2022_23_rf/dependencies/returnn/network_builder_rf/segmental/luca_example_transducer/ReturnnTrainingJob/output/train_config.config \ No newline at end of file diff --git a/users/gaudino/experiments/rf_robin_rnnt_2024/luca_example_transducer/__init__.py b/users/gaudino/experiments/rf_robin_rnnt_2024/luca_example_transducer/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/users/gaudino/experiments/rf_robin_rnnt_2024/luca_example_transducer/transducer_model_luca.py b/users/gaudino/experiments/rf_robin_rnnt_2024/luca_example_transducer/transducer_model_luca.py new file mode 100644 index 000000000..07655dab5 --- /dev/null +++ b/users/gaudino/experiments/rf_robin_rnnt_2024/luca_example_transducer/transducer_model_luca.py @@ -0,0 +1,234 @@ +from typing import Optional, Dict, Any, Sequence, Tuple, List +import functools + +from returnn.tensor import Dim +import returnn.frontend as rf + +from i6_experiments.users.schmitt.returnn_frontend.model_interfaces.model import ModelDef +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.base import _batch_size_factor, _log_mel_feature_dim +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.segmental.model_new.label_model.model import ( + SegmentalAttEfficientLabelDecoder +) +from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.encoder.global_ import GlobalConformerEncoder +from i6_experiments.users.schmitt.returnn_frontend.model_interfaces.supports_label_scorer_torch import RFModelWithMakeLabelScorer + + +class SegmentalAttentionModel(rf.Module): + def __init__( + self, + *, + center_window_size: int, + align_target_dim: Dim, + target_dim: Dim, + blank_idx: int, + enc_key_total_dim: Dim = Dim(name="enc_key_total_dim", dimension=1024), + att_dropout: float = 0.1, + l2: float = 0.0001, + language_model: Optional[RFModelWithMakeLabelScorer] = None, + enc_in_dim: Dim, + enc_out_dim: Dim = Dim(name="enc", dimension=512), + enc_num_layers: int = 12, + enc_aux_logits: Sequence[int] = (), # layers + enc_ff_dim: Dim = Dim(name="enc-ff", dimension=2048), + enc_num_heads: int = 4, + encoder_layer_opts: Optional[Dict[str, Any]] = None, + dec_att_num_heads: Dim = Dim(name="att_num_heads", dimension=1), + enc_dropout: float = 0.1, + use_att_ctx_in_state: bool = True, + blank_decoder_version: int = 1, + use_joint_model: bool = False, + use_weight_feedback: bool = True, + label_decoder_state: str = "nb-lstm", + ): + super(SegmentalAttentionModel, self).__init__() + + self.encoder = GlobalConformerEncoder( + enc_in_dim, + enc_out_dim, + num_layers=enc_num_layers, + target_dim=target_dim, + wb_target_dim=align_target_dim, + aux_logits=enc_aux_logits, + ff_dim=enc_ff_dim, + num_heads=enc_num_heads, + encoder_layer_opts=encoder_layer_opts, + enc_key_total_dim=enc_key_total_dim, + dec_att_num_heads=dec_att_num_heads, + dropout=enc_dropout, + att_dropout=att_dropout, + l2=l2, + ) + + assert label_decoder_state in {"nb-lstm", "joint-lstm", "nb-2linear-ctx1"} + + self.label_decoder = SegmentalAttEfficientLabelDecoder( + enc_out_dim=self.encoder.out_dim, + target_dim=target_dim, + att_num_heads=dec_att_num_heads, + att_dropout=att_dropout, + blank_idx=blank_idx, + enc_key_total_dim=enc_key_total_dim, + l2=l2, + center_window_size=center_window_size, + use_weight_feedback=use_weight_feedback, + use_att_ctx_in_state=use_att_ctx_in_state, + decoder_state=label_decoder_state, + ) + + if language_model: + self.language_model, self.language_model_make_label_scorer = language_model + else: + self.language_model = None + self.language_model_make_label_scorer = None + + self.blank_idx = self.label_decoder.blank_idx + self.center_window_size = center_window_size + self.target_dim = self.label_decoder.target_dim + self.align_target_dim = align_target_dim + self.use_joint_model = use_joint_model + self.blank_decoder_version = blank_decoder_version + self.label_decoder_state = label_decoder_state + + +class MakeModel: + """for import""" + + def __init__(self, in_dim: int, align_target_dim: int, target_dim: int, *, center_window_size: int, eos_label: int = 0, num_enc_layers: int = 12): + self.in_dim = in_dim + self.align_target_dim = align_target_dim + self.target_dim = target_dim + self.center_window_size = center_window_size + self.eos_label = eos_label + self.num_enc_layers = num_enc_layers + + def __call__(self) -> SegmentalAttentionModel: + from returnn.datasets.util.vocabulary import Vocabulary + + in_dim = Dim(name="in", dimension=self.in_dim, kind=Dim.Types.Feature) + align_target_dim = Dim(name="align_target", dimension=self.align_target_dim, kind=Dim.Types.Feature) + target_dim = Dim(name="non_blank_target", dimension=self.target_dim, kind=Dim.Types.Feature) + target_dim.vocab = Vocabulary.create_vocab_from_labels( + [str(i) for i in range(target_dim.dimension)], eos_label=self.eos_label + ) + + return self.make_model(in_dim, align_target_dim, target_dim, center_window_size=self.center_window_size) + + @classmethod + def make_model( + cls, + in_dim: Dim, + align_target_dim: Dim, + target_dim: Dim, + *, + num_enc_layers: int = 12, + pos_emb_dropout: float = 0.0, + language_model: Optional[Dict[str, Any]] = None, + enc_out_dim: int, + enc_key_total_dim: int, + enc_ff_dim: int, + **extra, + ) -> SegmentalAttentionModel: + """make""" + lm = None + if language_model: + assert isinstance(language_model, dict) + language_model = language_model.copy() + cls_name = language_model.pop("class") + assert cls_name == "TransformerDecoder" + language_model.pop("vocab_dim", None) # will just overwrite + + from i6_experiments.users.schmitt.experiments.config.pipelines.global_vs_segmental_2022_23_rf.dependencies.returnn.network_builder_rf.lm.trafo import model as trafo_lm + + lm = trafo_lm.MakeModel(vocab_dim=target_dim, **language_model)() + lm = (lm, functools.partial(trafo_lm.make_time_sync_label_scorer_torch, model=lm, align_target_dim=align_target_dim)) + + return SegmentalAttentionModel( + enc_in_dim=in_dim, + enc_num_layers=num_enc_layers, + enc_out_dim=Dim(name="enc", dimension=enc_out_dim, kind=Dim.Types.Feature), + enc_ff_dim=Dim(name="enc-ff", dimension=enc_ff_dim, kind=Dim.Types.Feature), + enc_key_total_dim=Dim(name="enc_key_total_dim", dimension=enc_key_total_dim), + enc_num_heads=8, + encoder_layer_opts=dict( + conv_norm_opts=dict(use_mask=True), + self_att_opts=dict( + # Shawn et al 2018 style, old RETURNN way. + with_bias=False, + with_linear_pos=False, + with_pos_bias=False, + learnable_pos_emb=True, + separate_pos_emb_per_head=False, + pos_emb_dropout=pos_emb_dropout, + ), + ff_activation=lambda x: rf.relu(x) ** 2.0, + ), + target_dim=target_dim, + align_target_dim=align_target_dim, + blank_idx=0, + language_model=lm, + center_window_size=1, + use_att_ctx_in_state=False, + blank_decoder_version=3, + use_joint_model=True, + use_weight_feedback=False, + label_decoder_state="nb-lstm", + **extra, + ) + + +def from_scratch_model_def( + *, epoch: int, in_dim: Dim, align_target_dim: Dim, target_dim: Dim) -> SegmentalAttentionModel: + """Function is run within RETURNN.""" + from returnn.config import get_global_config + + in_dim, epoch # noqa + config = get_global_config() # noqa + enc_aux_logits = config.typed_value("aux_loss_layers") + pos_emb_dropout = config.float("pos_emb_dropout", 0.0) + # real input is raw audio, internally it does logmel + in_dim = Dim(name="logmel", dimension=_log_mel_feature_dim, kind=Dim.Types.Feature) + lm_opts = config.typed_value("external_lm") + + enc_out_dim = config.int("enc_out_dim", 512) + enc_key_total_dim = config.int("enc_key_total_dim", 1024) + enc_ff_dim = config.int("enc_ff_dim", 2048) + + return MakeModel.make_model( + in_dim, + align_target_dim, + target_dim, + enc_aux_logits=enc_aux_logits or (), + pos_emb_dropout=pos_emb_dropout, + language_model=lm_opts, + enc_out_dim=enc_out_dim, + enc_key_total_dim=enc_key_total_dim, + enc_ff_dim=enc_ff_dim, + ) + + +from_scratch_model_def: ModelDef[SegmentalAttentionModel] +from_scratch_model_def.behavior_version = 16 +from_scratch_model_def.backend = "torch" +from_scratch_model_def.batch_size_factor = _batch_size_factor + + +def _returnn_v2_get_model(*, epoch: int, **_kwargs_unused): + from returnn.tensor import Tensor + from returnn.config import get_global_config + from returnn.datasets.util.vocabulary import BytePairEncoding + + config = get_global_config() + default_input_key = config.typed_value("default_input") + default_target_key = config.typed_value("target") + extern_data_dict = config.typed_value("extern_data") + data = Tensor(name=default_input_key, **extern_data_dict[default_input_key]) + targets = Tensor(name=default_target_key, **extern_data_dict[default_target_key]) + + non_blank_vocab = config.typed_value("non_blank_vocab") + if non_blank_vocab is not None: + targets.sparse_dim.vocab = BytePairEncoding(**non_blank_vocab) + + model_def = config.typed_value("_model_def") + model = model_def( + epoch=epoch, in_dim=data.feature_dim, align_target_dim=targets.sparse_dim, target_dim=targets.sparse_dim) + return model diff --git a/users/gaudino/models/asr/rf/conformer_rnnt/model_conformer_rnnt.py b/users/gaudino/models/asr/rf/conformer_rnnt/model_conformer_rnnt.py index b9fc28ec7..a93eb834e 100644 --- a/users/gaudino/models/asr/rf/conformer_rnnt/model_conformer_rnnt.py +++ b/users/gaudino/models/asr/rf/conformer_rnnt/model_conformer_rnnt.py @@ -188,9 +188,10 @@ def make_model( enc_ff_dim=Dim(name="enc-ff", dimension=2048, kind=Dim.Types.Feature), enc_att_num_heads=8, enc_conformer_layer_opts=dict( - conv_norm_opts=dict( - use_mask=True, track_running_stats=False - ), # Changed: track_running_stats=False + conv_norm = rf.LayerNorm, + # conv_norm_opts=dict( + # in_dim= + # ), # Changed below self_att=rf.SelfAttention, self_att_opts=dict( with_bias=True, # Changed: with_bias=True From 05c2c3502fb58cddc098092952ab03bdc98700b2 Mon Sep 17 00:00:00 2001 From: Albert Zeyer Date: Thu, 20 Jun 2024 21:25:46 +0200 Subject: [PATCH 222/227] SamplingBytePairEncoding for SentencePiece --- users/zeyer/datasets/utils/spm.py | 11 +++++++++++ .../exp2024_04_23_baselines/ctc.py | 19 ++++++++++--------- 2 files changed, 21 insertions(+), 9 deletions(-) diff --git a/users/zeyer/datasets/utils/spm.py b/users/zeyer/datasets/utils/spm.py index 92116a16a..3ffc5b823 100644 --- a/users/zeyer/datasets/utils/spm.py +++ b/users/zeyer/datasets/utils/spm.py @@ -52,6 +52,17 @@ def get_opts(self) -> Dict[str, Any]: } if self.other_opts: d.update(self.other_opts) + if d["class"] == "SamplingBytePairEncoding": + # Need to fix this a bit. model_file not used here. But we need vocab_file instead. + model_file = d.pop("model_file") + if not d.get("vocab_file"): + from i6_core.text.label.sentencepiece.vocab import ExtractSentencePieceVocabJob + + d["vocab_file"] = ExtractSentencePieceVocabJob(model_file).out_vocab + d.setdefault("word_prefix_symbol", "▁") + d.setdefault("unknown_label", self.unknown_label) + d.setdefault("bos_label", self.bos_idx) + d.setdefault("eos_label", self.eos_idx) return d def get_eos_idx(self) -> Optional[int]: diff --git a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py index ef17629d9..bcbc97fbd 100644 --- a/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py +++ b/users/zeyer/experiments/exp2024_04_23_baselines/ctc.py @@ -140,19 +140,20 @@ def py(): ) # Comparing vocabs with better settings: feature norm, sampling, no max seq len. - for vocab, alpha in [ - ("spm20k", 0.7), - ("bpe10k", 0.01), - ("spm10k", 0.7), - # ("spm_bpe10k", ...), # unclear what sampling scheme... - ("spm4k", 0.7), - ("spm1k", 0.7), + for vocab, sample, alpha in [ + ("spm20k", "spm", 0.7), + ("bpe10k", "bpe", 0.01), + ("spm10k", "spm", 0.7), + ("spm10k", "bpe", 0.01), + ("spm_bpe10k", "bpe", 0.01), + ("spm4k", "spm", 0.7), + ("spm1k", "spm", 0.7), # ("spm_bpe1k", ...) ]: train_exp( f"v6-bhv20-11gb-f32-bs15k-accgrad1-mgpu4-pavg100-maxSeqLenNone" f"-wd1e_2-lrlin1e_5_295k-featBN-speedpertV2-{vocab}" - f"-{'spmSample' if vocab.startswith('spm') else 'bpeSample'}{str(alpha).replace('.', '')}", + f"-{sample}Sample{str(alpha).replace('.', '')}", config_11gb_v6_f32_accgrad1_mgpu4_pavg100_wd1e_4, model_config={"feature_batch_norm": True}, config_updates={ @@ -166,7 +167,7 @@ def py(): train_vocab_opts={ "other_opts": ( {"enable_sampling": True, "alpha": alpha} - if vocab.startswith("spm") + if sample == "spm" else {"class": "SamplingBytePairEncoding", "breadth_prob": alpha} ) }, From ed093d93fbcc75a8ca706503eebdeb0f4de371e5 Mon Sep 17 00:00:00 2001 From: Nick Rossenbach Date: Thu, 20 Jun 2024 22:26:34 +0200 Subject: [PATCH 223/227] add gradient clipping to example baseline --- .../ctc_rnnt_standalone_2024/experiments/ctc_phon/baseline.py | 1 + 1 file changed, 1 insertion(+) diff --git a/example_setups/librispeech/ctc_rnnt_standalone_2024/experiments/ctc_phon/baseline.py b/example_setups/librispeech/ctc_rnnt_standalone_2024/experiments/ctc_phon/baseline.py index 6bdd99499..1769f682e 100644 --- a/example_setups/librispeech/ctc_rnnt_standalone_2024/experiments/ctc_phon/baseline.py +++ b/example_setups/librispeech/ctc_rnnt_standalone_2024/experiments/ctc_phon/baseline.py @@ -195,6 +195,7 @@ def tune_and_evaluate_helper( "max_seq_length": {"audio_features": 35 * 16000}, "accum_grad_multiple_step": 1, "torch_amp_options": {"dtype": "bfloat16"}, + "gradient_clip": 1.0, } network_module = "ctc.conformer_1023.i6modelsV1_VGG4LayerActFrontendV1_v6" From 1190b57d834c8573bedc87657224e0b306c3bb7a Mon Sep 17 00:00:00 2001 From: Nick Rossenbach Date: Thu, 20 Jun 2024 22:27:37 +0200 Subject: [PATCH 224/227] 2-precision WER and quantization helper --- .../ctc_rnnt_standalone_2024/pipeline.py | 97 +++++++++++++++++-- 1 file changed, 89 insertions(+), 8 deletions(-) diff --git a/users/rossenbach/experiments/librispeech/ctc_rnnt_standalone_2024/pipeline.py b/users/rossenbach/experiments/librispeech/ctc_rnnt_standalone_2024/pipeline.py index 01dc3ac5e..f5fdb0f86 100644 --- a/users/rossenbach/experiments/librispeech/ctc_rnnt_standalone_2024/pipeline.py +++ b/users/rossenbach/experiments/librispeech/ctc_rnnt_standalone_2024/pipeline.py @@ -31,6 +31,12 @@ class ASRModel: prior_file: Optional[tk.Path] prefix_name: Optional[str] +@dataclass +class NeuralLM: + checkpoint: tk.Path + net_args: Dict[str, Any] + network_module: str + prefix_name: Optional[str] def search_single( prefix_name: str, @@ -79,7 +85,7 @@ def search_single( stm_file = CorpusToStmJob(bliss_corpus=recognition_bliss_corpus).out_stm_path - sclite_job = ScliteJob(ref=stm_file, hyp=search_ctm, sctk_binary_path=SCTK_BINARY_PATH) + sclite_job = ScliteJob(ref=stm_file, hyp=search_ctm, sctk_binary_path=SCTK_BINARY_PATH, precision_ndigit=2) tk.register_output(prefix_name + "/sclite/wer", sclite_job.out_wer) tk.register_output(prefix_name + "/sclite/report", sclite_job.out_report_dir) @@ -204,6 +210,16 @@ def training(training_name, datasets, train_args, num_epochs, returnn_exe, retur return train_job +@dataclass +class QuantArgs: + quant_config_dict: Dict[str, Any] + num_samples: int + seed: int + datasets: TrainingDatasets + network_module: str + filter_args: Optional[Dict[str, Any]] = None + + def prepare_asr_model( training_name, train_job, @@ -214,6 +230,7 @@ def prepare_asr_model( get_best_averaged_checkpoint: Optional[Tuple[int, str]] = None, get_last_averaged_checkpoint: Optional[int] = None, prior_config: Optional[Dict[str, Any]] = None, + quant_args: Optional[QuantArgs] = None ): """ :param training_name: @@ -291,12 +308,76 @@ def prepare_asr_model( if prior_config is not None: raise ValueError("prior_config can only be set if with_prior is True") - asr_model = ASRModel( - checkpoint=checkpoint, - network_module=train_args["network_module"], - net_args=train_args["net_args"], - prior_file=prior_file, - prefix_name=training_name, - ) + if quant_args: + from .config import get_static_quant_config + quant_config = get_static_quant_config( + training_datasets=quant_args.datasets, + network_module=quant_args.network_module, + net_args=train_args["net_args"], + quant_args=quant_args.quant_config_dict, + config={}, + num_samples=quant_args.num_samples, + dataset_seed=quant_args.seed, + debug=False, + dataset_filter_args=quant_args.filter_args + ) + quant_chkpt = quantize_static( + prefix_name=training_name, + returnn_config=quant_config, + checkpoint=checkpoint, + returnn_exe=RETURNN_EXE, + returnn_root=MINI_RETURNN_ROOT, + ) + asr_model = ASRModel( + checkpoint=quant_chkpt, + net_args=train_args["net_args"] | quant_args.quant_config_dict, + network_module=quant_args.network_module, + prior_file=prior_file, + prefix_name=training_name + ) + else: + asr_model = ASRModel( + checkpoint=checkpoint, + network_module=train_args["network_module"], + net_args=train_args["net_args"], + prior_file=prior_file, + prefix_name=training_name, + ) return asr_model + + +@tk.block() +def quantize_static( + prefix_name: str, + returnn_config: ReturnnConfig, + checkpoint: tk.Path, + returnn_exe: tk.Path, + returnn_root: tk.Path, + mem_rqmt: int = 16, +): + """ + Run search for a specific test dataset + + :param prefix_name: prefix folder path for alias and output files + :param returnn_config: the RETURNN config to be used for forwarding + :param Checkpoint checkpoint: path to RETURNN PyTorch model checkpoint + :param returnn_exe: The python executable to run the job with (when using container just "python3") + :param returnn_root: Path to a checked out RETURNN repository + :param mem_rqmt: override the default memory requirement + """ + quantize_job = ReturnnForwardJobV2( + model_checkpoint=checkpoint, + returnn_config=returnn_config, + log_verbosity=5, + mem_rqmt=mem_rqmt, + time_rqmt=2, + device="gpu", + cpu_rqmt=8, + returnn_python_exe=returnn_exe, + returnn_root=returnn_root, + output_files=['model.pt', "seq_tags.txt"], + ) + quantize_job.set_keep_value(5) + quantize_job.add_alias(prefix_name + "/calibration") + return quantize_job.out_files['model.pt'] From 8799f2b93ea0f62e1c858c74cbde6513fb05619a Mon Sep 17 00:00:00 2001 From: Nick Rossenbach Date: Thu, 20 Jun 2024 22:29:16 +0200 Subject: [PATCH 225/227] HDF alignment labels example data pipeline --- .../data/alignment.py | 105 ++++++++++++++++++ .../ctc_rnnt_standalone_2024/data/common.py | 54 ++++++--- 2 files changed, 146 insertions(+), 13 deletions(-) create mode 100644 users/rossenbach/experiments/librispeech/ctc_rnnt_standalone_2024/data/alignment.py diff --git a/users/rossenbach/experiments/librispeech/ctc_rnnt_standalone_2024/data/alignment.py b/users/rossenbach/experiments/librispeech/ctc_rnnt_standalone_2024/data/alignment.py new file mode 100644 index 000000000..7f9e41c87 --- /dev/null +++ b/users/rossenbach/experiments/librispeech/ctc_rnnt_standalone_2024/data/alignment.py @@ -0,0 +1,105 @@ +from dataclasses import dataclass +from sisyphus import tk +from typing import List, Optional + +from i6_core.returnn.hdf import RasrAlignmentDumpHDFJob + +from i6_experiments.common.datasets.librispeech import get_ogg_zip_dict + +from .common import build_training_datasets, TrainingDatasets, DatasetSettings, TrainingHDFLabelFiles +from ..default_tools import MINI_RETURNN_ROOT, RETURNN_EXE + +@dataclass +class HDFAlignmentData: + alignment_caches: [tk.Path] + allophone_file: tk.Path + state_tying_file: tk.Path + + +def build_hdf_from_alignment( + prefix: str, + alignment_data: HDFAlignmentData, + returnn_root: tk.Path, +) -> List[tk.Path]: + """ + + :param prefix: + :param alignment_data: + :param returnn_root: + :return: list of HDF files (one for each cache) + """ + hdf_file_job = RasrAlignmentDumpHDFJob( + alignment_caches=alignment_data.alignment_caches, + allophone_file=alignment_data.allophone_file, + state_tying_file=alignment_data.state_tying_file, + returnn_root=returnn_root, + # TODO: unclear if it should be sparse + ) + hdf_file_job.add_alias(prefix + "/dump_hdf_job") + return hdf_file_job.out_hdf_files + + +def build_rasr_alignment_target_training_datasets( + prefix: str, + librispeech_key: str, + settings: DatasetSettings, + train_alignment_caches: List[tk.Path], + dev_clean_alignment_caches: List[tk.Path], + dev_other_alignment_caches: List[tk.Path], + allophone_file: tk.Path, + state_tying_file: tk.Path, +) -> TrainingDatasets: + """ + :param prefix: + :param librispeech_key: which librispeech corpus to use + :param settings: configuration object for the dataset pipeline + """ + ogg_zip_dict = get_ogg_zip_dict(prefix, returnn_root=MINI_RETURNN_ROOT, returnn_python_exe=RETURNN_EXE) + train_ogg = ogg_zip_dict[librispeech_key] + dev_clean_ogg = ogg_zip_dict["dev-clean"] + dev_other_ogg = ogg_zip_dict["dev-other"] + + train_alignment_data = HDFAlignmentData( + alignment_caches=train_alignment_caches, + allophone_file=allophone_file, + state_tying_file=state_tying_file + ) + + dev_clean_alignment_data = HDFAlignmentData( + alignment_caches=dev_clean_alignment_caches, + allophone_file=allophone_file, + state_tying_file=state_tying_file + ) + + dev_other_alignment_data = HDFAlignmentData( + alignment_caches=dev_other_alignment_caches, + allophone_file=allophone_file, + state_tying_file=state_tying_file + ) + + train_hdf_label_files = TrainingHDFLabelFiles( + train=build_hdf_from_alignment( + prefix=prefix + "/train", + alignment_data=train_alignment_data, + returnn_root=MINI_RETURNN_ROOT + ), + dev_clean=build_hdf_from_alignment( + prefix=prefix + "/dev_clean", + alignment_data=dev_clean_alignment_data, + returnn_root=MINI_RETURNN_ROOT + ), + dev_other=build_hdf_from_alignment( + prefix=prefix + "/dev_other", + alignment_data=dev_other_alignment_data, + returnn_root=MINI_RETURNN_ROOT + ), + ) + + return build_training_datasets( + train_ogg=train_ogg, + dev_clean_ogg=dev_clean_ogg, + dev_other_ogg=dev_other_ogg, + settings=settings, + label_datastream=None, + training_hdf_label_files=train_hdf_label_files, + ) diff --git a/users/rossenbach/experiments/librispeech/ctc_rnnt_standalone_2024/data/common.py b/users/rossenbach/experiments/librispeech/ctc_rnnt_standalone_2024/data/common.py index 81cd46ca3..0631df216 100644 --- a/users/rossenbach/experiments/librispeech/ctc_rnnt_standalone_2024/data/common.py +++ b/users/rossenbach/experiments/librispeech/ctc_rnnt_standalone_2024/data/common.py @@ -12,7 +12,7 @@ from i6_experiments.common.setups.returnn.datastreams.audio import AudioRawDatastream, ReturnnAudioRawOptions from i6_experiments.common.setups.returnn.datastreams.base import Datastream from i6_experiments.common.setups.returnn.datastreams.vocabulary import LabelDatastream -from i6_experiments.common.setups.returnn.datasets import Dataset, OggZipDataset, MetaDataset +from i6_experiments.common.setups.returnn.datasets import Dataset, OggZipDataset, MetaDataset, HDFDataset from .cv_segments import get_mixed_cv_segments @@ -96,13 +96,19 @@ def get_zip(alias_name: str, bliss_dataset: tk.Path) -> tk.Path: # --------------------------- Dataset functions ----------------------------------- +@dataclass() +class TrainingHDFLabelFiles: + train: List[tk.Path] + dev_clean: List[tk.Path] + dev_other: List[tk.Path] def build_training_datasets( train_ogg: Union[tk.Path, List[tk.Path]], dev_clean_ogg: tk.Path, dev_other_ogg: tk.Path, - label_datastream: LabelDatastream, + label_datastream: Optional[LabelDatastream], settings: DatasetSettings, + training_hdf_label_files: Optional[TrainingHDFLabelFiles] = None, ) -> TrainingDatasets: """ generic dataset construction helper to be used by the phon/bpe specific variants @@ -110,7 +116,9 @@ def build_training_datasets( :param train_ogg: path to the train zip, potentially containing altered transcriptions :param dev_clean_ogg: path to the ls dev-clean zip, potentially containing altered transcriptions :param dev_other_ogg: path to the ls dev-other zip, potentially containing altered transcriptions - :param label_datastream: label datastream (e.g. phoneme or bpe related) + :param label_datastream: label datastream for the ogg zip (e.g. phoneme or bpe related) + :param training_hdf_label_files: e.g. as alternative to label_datastream, use labels from HDF + (can be time-synchronous but do not have to) :param settings: settings object for the RETURNN data pipeline """ audio_datastream = get_audio_raw_datastream(settings.preemphasis, settings.peak_normalization) @@ -120,52 +128,72 @@ def build_training_datasets( "labels": label_datastream, } - data_map = {"raw_audio": ("zip_dataset", "data"), "labels": ("zip_dataset", "classes")} + if training_hdf_label_files is not None: + data_map = {"raw_audio": ("zip_dataset", "data"), "labels": ("hdf_dataset", "data")} + else: + data_map = {"raw_audio": ("zip_dataset", "data"), "labels": ("zip_dataset", "classes")} training_audio_opts = audio_datastream.as_returnn_audio_opts() - def make_meta(dataset: OggZipDataset): + def make_meta_oggzip(dataset: OggZipDataset, *args, **kwargs): return MetaDataset( data_map=data_map, datasets={"zip_dataset": dataset}, seq_order_control_dataset="zip_dataset" ) + def make_meta_oggzip_hdf(dataset: OggZipDataset, hdf_files: List): + return MetaDataset( + data_map=data_map, + datasets={ + "zip_dataset": dataset, + "hdf_dataset": HDFDataset( + files=hdf_files + ) + }, + seq_order_control_dataset="zip_dataset" + ) + + if training_hdf_label_files is None: + make_meta = make_meta_oggzip + else: + make_meta = make_meta_oggzip_hdf + train_zip_dataset = OggZipDataset( files=train_ogg, audio_options=training_audio_opts, - target_options=label_datastream.as_returnn_targets_opts(), + target_options=label_datastream.as_returnn_targets_opts() if label_datastream is not None else None, partition_epoch=settings.train_partition_epoch, seq_ordering=settings.train_seq_ordering, additional_options=settings.train_additional_options, ) - train_dataset = make_meta(train_zip_dataset) + train_dataset = make_meta(train_zip_dataset, training_hdf_label_files.train) cv_zip_dataset = OggZipDataset( files=[dev_clean_ogg, dev_other_ogg], audio_options=audio_datastream.as_returnn_audio_opts(), - target_options=label_datastream.as_returnn_targets_opts(), + target_options=label_datastream.as_returnn_targets_opts() if label_datastream is not None else None, segment_file=get_mixed_cv_segments(), seq_ordering="sorted_reverse", ) - cv_dataset = make_meta(cv_zip_dataset) + cv_dataset = make_meta(cv_zip_dataset, training_hdf_label_files.dev_clean + training_hdf_label_files.dev_other) devtrain_zip_dataset = OggZipDataset( files=train_ogg, audio_options=audio_datastream.as_returnn_audio_opts(), - target_options=label_datastream.as_returnn_targets_opts(), + target_options=label_datastream.as_returnn_targets_opts() if label_datastream is not None else None, seq_ordering="sorted_reverse", random_subset=3000, ) - devtrain_dataset = make_meta(devtrain_zip_dataset) + devtrain_dataset = make_meta(devtrain_zip_dataset, training_hdf_label_files.train) prior_zip_dataset = OggZipDataset( files=train_ogg, audio_options=training_audio_opts, - target_options=label_datastream.as_returnn_targets_opts(), + target_options=label_datastream.as_returnn_targets_opts() if label_datastream is not None else None, partition_epoch=1, seq_ordering="sorted_reverse", additional_options=None, ) - prior_dataset = make_meta(prior_zip_dataset) + prior_dataset = make_meta(prior_zip_dataset, training_hdf_label_files.train) return TrainingDatasets( train=train_dataset, From 0291789284b531075e2a5d783d3dc402e0c4a9a5 Mon Sep 17 00:00:00 2001 From: Peter Vieting Date: Fri, 21 Jun 2024 11:46:46 +0200 Subject: [PATCH 226/227] ls960 pretrain: fix python launcher for itc/i6 --- .../wav2vec2/config_01_fairseq_main.py | 9 +++++---- .../wav2vec2/config_02_fairseq_phoneme.py | 9 +++++---- 2 files changed, 10 insertions(+), 8 deletions(-) diff --git a/users/vieting/experiments/librispeech/librispeech_960_pretraining/wav2vec2/config_01_fairseq_main.py b/users/vieting/experiments/librispeech/librispeech_960_pretraining/wav2vec2/config_01_fairseq_main.py index 4313042b7..2d5db0ade 100755 --- a/users/vieting/experiments/librispeech/librispeech_960_pretraining/wav2vec2/config_01_fairseq_main.py +++ b/users/vieting/experiments/librispeech/librispeech_960_pretraining/wav2vec2/config_01_fairseq_main.py @@ -139,10 +139,11 @@ def run_fairseq_pretraining(): fairseq_args = get_fairseq_args(num_gpus=num_gpus) fairseq_config = FairseqHydraConfig(fairseq_args) fairseq_root = get_fairseq_root() - fairseq_exe = tk.Path( - "/home/pv653172/setups/librispeech/20230328_wav2vec2/dependencies/python_launcher.sh", - hash_overwrite="python_launcher", - ) + itc_python_launcher = "/home/pv653172/setups/librispeech/20230328_wav2vec2/dependencies/python_launcher.sh" + if os.path.exists(itc_python_launcher): + fairseq_exe = tk.Path(itc_python_launcher, hash_overwrite="python_launcher") + else: + fairseq_exe = tk.Path("/usr/bin/python3", hash_overwrite="python_launcher") job = FairseqHydraTrainingJob( fairseq_config, save_interval=25, diff --git a/users/vieting/experiments/librispeech/librispeech_960_pretraining/wav2vec2/config_02_fairseq_phoneme.py b/users/vieting/experiments/librispeech/librispeech_960_pretraining/wav2vec2/config_02_fairseq_phoneme.py index 53aef623a..b347b7979 100644 --- a/users/vieting/experiments/librispeech/librispeech_960_pretraining/wav2vec2/config_02_fairseq_phoneme.py +++ b/users/vieting/experiments/librispeech/librispeech_960_pretraining/wav2vec2/config_02_fairseq_phoneme.py @@ -67,10 +67,11 @@ def run_fairseq_pretraining_negatives_other_target(): prefix_name = "experiments/librispeech/librispeech_960_pretraining/wav2vec2/" alignment = get_alignment_hdf() num_gpus = 8 - fairseq_python_exe = tk.Path( - "/home/pv653172/setups/librispeech/20230328_wav2vec2/dependencies/python_launcher.sh", - hash_overwrite="itc_python_launcher_py310_torch", - ) + itc_python_launcher = "/home/pv653172/setups/librispeech/20230328_wav2vec2/dependencies/python_launcher.sh" + if os.path.exists(itc_python_launcher): + fairseq_python_exe = tk.Path(itc_python_launcher, hash_overwrite="itc_python_launcher_py310_torch") + else: + fairseq_python_exe = tk.Path("/usr/bin/python3", hash_overwrite="itc_python_launcher_py310_torch") fairseq_root = get_fairseq_root(fairseq_exe=fairseq_python_exe) fairseq_training_args = dict( save_interval=25, From aa2b3fbca67bd9083e8aa26b5075c8f67a54e60b Mon Sep 17 00:00:00 2001 From: marvin84 Date: Fri, 21 Jun 2024 12:43:57 +0200 Subject: [PATCH 227/227] latest users/raissi --- .../decoder/BASE_factored_hybrid_search.py | 104 +++++++++++++++++- .../common/helpers/train/network_params.py | 8 ++ .../legacy/SWB_TF_factored_hybrid_system.py | 56 ++++++++-- users/raissi/utils/default_tools.py | 7 ++ 4 files changed, 165 insertions(+), 10 deletions(-) diff --git a/users/raissi/setups/common/decoder/BASE_factored_hybrid_search.py b/users/raissi/setups/common/decoder/BASE_factored_hybrid_search.py index 61bfbeb1f..187d6927f 100644 --- a/users/raissi/setups/common/decoder/BASE_factored_hybrid_search.py +++ b/users/raissi/setups/common/decoder/BASE_factored_hybrid_search.py @@ -1362,6 +1362,99 @@ def push_delayed_tuple( ) + def recognize_optimize_transtition_values( + self, + *, + label_info: LabelInfo, + num_encoder_output: int, + search_parameters: SearchParameters, + tdp_sil: Optional[List[Tuple[TDP, TDP, TDP, TDP]]] = None, + tdp_speech: Optional[List[Tuple[TDP, TDP, TDP, TDP]]] = None, + altas_value=14.0, + altas_beam=14.0, + keep_value=10, + gpu: Optional[bool] = None, + cpu_rqmt: Optional[int] = None, + mem_rqmt: Optional[int] = None, + crp_update: Optional[Callable[[rasr.RasrConfig], Any]] = None, + pre_path: str = "transition-values", + cpu_slow: bool = True, + ) -> SearchParameters: + + recog_args = dataclasses.replace(search_parameters, altas=altas_value, beam=altas_beam) + + tdp_sil = tdp_sil if tdp_sil is not None else [recog_args.tdp_silence] + tdp_speech = tdp_speech if tdp_speech is not None else [recog_args.tdp_speech] + jobs = { + (tdp_sl, tdp_sp): self.recognize_count_lm( + add_sis_alias_and_output=False, + calculate_stats=False, + cpu_rqmt=cpu_rqmt, + crp_update=crp_update, + gpu=gpu, + is_min_duration=False, + keep_value=keep_value, + label_info=label_info, + mem_rqmt=mem_rqmt, + name_override=f"{self.name}-tdpSil{tdp_sl}-tdpSp{tdp_sp}-", + num_encoder_output=num_encoder_output, + opt_lm_am=False, + rerun_after_opt_lm=False, + search_parameters=dataclasses.replace( + recog_args, tdp_silence=tdp_sl, tdp_speech=tdp_sp + ), + remove_or_set_concurrency=False, + ) + for (tdp_sl, tdp_sp) in itertools.product( + tdp_sil, tdp_speech + ) + } + jobs_num_e = {k: v.scorer.out_num_errors for k, v in jobs.items()} + + for (tdp_sl, tdp_sp), recog_jobs in jobs.items(): + if cpu_slow: + recog_jobs.search.update_rqmt("run", {"cpu_slow": True}) + + pre_name = ( + f"{pre_path}/{self.name}/" + f"tdpSil{format_tdp(tdp_sl)}tdpSp{format_tdp(tdp_sp)}" + ) + + recog_jobs.lat2ctm.set_keep_value(keep_value) + recog_jobs.search.set_keep_value(keep_value) + + recog_jobs.search.add_alias(pre_name) + tk.register_output(f"{pre_name}.wer", recog_jobs.scorer.out_report_dir) + + best_overall_wer = ComputeArgminJob({k: v.scorer.out_wer for k, v in jobs.items()}) + best_overall_n = ComputeArgminJob(jobs_num_e) + tk.register_output( + f"decoding/tdp-best/{self.name}/args", + best_overall_n.out_argmin, + ) + tk.register_output( + f"decoding/tdp-best/{self.name}/wer", + best_overall_wer.out_min, + ) + + def push_delayed_tuple( + argmin: DelayedBase, + ) -> Tuple[DelayedBase, DelayedBase, DelayedBase, DelayedBase]: + return tuple(argmin[i] for i in range(4)) + + # cannot destructure, need to use indices + best_tdp_sil = best_overall_n.out_argmin[0] + best_tdp_sp = best_overall_n.out_argmin[1] + + base_cfg = dataclasses.replace( + search_parameters, + tdp_silence=push_delayed_tuple(best_tdp_sil), + tdp_speech=push_delayed_tuple(best_tdp_sp), + ) + + return base_cfg + + class BASEFactoredHybridAligner(BASEFactoredHybridDecoder): @@ -1401,21 +1494,28 @@ def __init__( set_batch_major_for_feature_scorer=set_batch_major_for_feature_scorer, ) - def correct_transition_applicator(self, crp): + def correct_transition_applicator(self, crp, correct_fsa_strcuture=False): # correct for the FSA bug crp.acoustic_model_config.tdp.applicator_type = "corrected" # The exit penalty is on the lemma level and should not be applied for alignment for tdp_type in ["*", "silence", "nonword-0", "nonword-1"]: crp.acoustic_model_config.tdp[tdp_type]["exit"] = 0.0 + if correct_fsa_strcuture: + crp.acoustic_model_config["*"]["fix-allophone-context-at-word-boundaries"] = True + crp.acoustic_model_config["*"]["transducer-builder-filter-out-invalid-allophones"] = True + crp.acoustic_model_config["*"]["allow-for-silence-repetitions"] = False return crp + + def get_alignment_job( self, label_info: LabelInfo, alignment_parameters: AlignmentParameters, num_encoder_output: int, pre_path: Optional[str] = "alignments", + correct_fsa_structure: bool = False, is_min_duration: bool = False, use_estimated_tdps: bool = False, crp_update: Optional[Callable[[rasr.RasrConfig], Any]] = None, @@ -1562,7 +1662,7 @@ def get_alignment_job( warnings.warn("you planned to use exit penalty for alignment, we set this to zero") - align_crp = self.correct_transition_applicator(align_crp) + align_crp = self.correct_transition_applicator(align_crp, correct_fsa_strcuture=correct_fsa_structure) alignment = mm.AlignmentJob( crp=align_crp, diff --git a/users/raissi/setups/common/helpers/train/network_params.py b/users/raissi/setups/common/helpers/train/network_params.py index 9e8a055c2..5127a6e67 100644 --- a/users/raissi/setups/common/helpers/train/network_params.py +++ b/users/raissi/setups/common/helpers/train/network_params.py @@ -83,6 +83,14 @@ def get_sa_name(self): #Conformer from-scratch +frameshift40_conformer_fullsum_from_scratch_mlp = GeneralNetworkParams( + l2=5e-6, + use_multi_task=False, + add_mlps=True, + specaug_args=asdict(default_sa_args), + frame_rate_reduction_ratio_factor=4, + auxilary_loss_layers=[], +) frameshift40_conformer_fullsum_from_scratch_multi_nomlp = GeneralNetworkParams( l2=5e-6, use_multi_task=True, diff --git a/users/raissi/setups/swb/legacy/SWB_TF_factored_hybrid_system.py b/users/raissi/setups/swb/legacy/SWB_TF_factored_hybrid_system.py index ca1cdd8a2..5c662a4f3 100644 --- a/users/raissi/setups/swb/legacy/SWB_TF_factored_hybrid_system.py +++ b/users/raissi/setups/swb/legacy/SWB_TF_factored_hybrid_system.py @@ -3,6 +3,7 @@ import copy import dataclasses import itertools +import numpy as np import sys from IPython import embed @@ -197,9 +198,9 @@ def __init__( } # 1/9 for 3-state, same amount of silence } - self.transcript_prior_xml = {"monostate": ("/").join( - [self.dependencies_path, "haotian/monostate/monostate.we.transcript.prior.xml"] - ),} + self.transcript_prior_xml = { + "monostate": ("/").join([self.dependencies_path, "haotian/monostate/monostate.we.transcript.prior.xml"]), + } # -------------------- External helpers -------------------- @@ -207,9 +208,7 @@ def set_gammatone_features(self): feature_name = self.feature_info.feature_type.get() for corpus_key in ["train", "hub500", "hub501"]: self.feature_bundles[corpus_key] = {feature_name: feature_bundles[corpus_key]} - self.feature_flows[corpus_key] = { - feature_name: features.basic_cache_flow(feature_bundles[corpus_key]) - } + self.feature_flows[corpus_key] = {feature_name: features.basic_cache_flow(feature_bundles[corpus_key])} mapping = {"train": "train", "hub500": "dev", "hub501": "eval"} cache_pattern = feature_bundles[corpus_key].get_path().split(".bundle")[0] caches = [tk.Path(f"{cache_pattern}.{i}") for i in range(1, concurrent[mapping[corpus_key]] + 1)] @@ -254,7 +253,6 @@ def prepare_data_with_separate_cv_legacy(self, cv_key="train.cvtrain", bw_key="b [self.cross_validation_info["pre_path"], self.cross_validation_info["merged_corpus_segment"]] ) - def get_recognizer_and_args( self, key: str, @@ -344,6 +342,48 @@ def get_recognizer_and_args( return recognizer, recog_args + def get_best_recog_scales_and_transition_values( + self, + key: str, + num_encoder_output: int, + recog_args: SWBSearchParameters, + lm_scale: float, + ) -> SWBSearchParameters: + + assert self.experiments[key]["decode_job"]["runner"] is not None, "Please set the recognizer" + recognizer = self.experiments[key]["decode_job"]["runner"] + + tune_args = recog_args.with_lm_scale(lm_scale) + best_config_scales = recognizer.recognize_optimize_scales_v2( + label_info=self.label_info, + search_parameters=tune_args, + num_encoder_output=num_encoder_output, + altas_value=2.0, + altas_beam=16.0, + tdp_sil=[(11.0, 0.0, "infinity", 20.0)], + tdp_speech=[(8.0, 0.0, "infinity", 0.0)], + tdp_nonword=[(8.0, 0.0, "infinity", 0.0)], + prior_scales=[[v] for v in np.arange(0.1, 0.8, 0.1).round(1)], + tdp_scales=[0.1, 0.2], + ) + + nnsp_tdp = [(l, 0.0, "infinity", e) for l in [8.0, 11.0, 13.0] for e in [10.0, 15.0, 20.0]] + sp_tdp = [(l, 0.0, "infinity", e) for l in [5.0, 8.0, 11.0] for e in [0.0, 5.0]] + best_config= recognizer.recognize_optimize_transtition_values( + label_info=self.label_info, + search_parameters=best_config_scales, + num_encoder_output=512, + altas_value=2.0, + altas_beam=16.0, + tdp_sil=nnsp_tdp, + tdp_speech=sp_tdp, + ) + + return best_config + + + + def get_aligner_and_args( self, key: str, @@ -405,7 +445,7 @@ def get_aligner_and_args( if feature_path is None: feature_path = self.feature_flows[crp_corpus] - #consider if you need to create separate alignment params + # consider if you need to create separate alignment params align_args = self.get_parameters_for_aligner(context_type=context_type, prior_info=p_info) align_args = dataclasses.replace(align_args, non_word_phonemes="[LAUGHTER],[NOISE],[VOCALIZEDNOISE]") diff --git a/users/raissi/utils/default_tools.py b/users/raissi/utils/default_tools.py index baef3b003..91f1cda0e 100644 --- a/users/raissi/utils/default_tools.py +++ b/users/raissi/utils/default_tools.py @@ -45,6 +45,7 @@ def get_rasr_binary_path(rasr_path): hash_overwrite="CONFORMER_DEFAULT_RASR_BINARY_PATH_TF2", ) +U16_RASR_GENERIC_SEQ2SEQ = tk.Path("/work/tools/users/raissi/rasr/generic-seq2seq-dev/arch/linux-x86_64-standard", hash_overwrite="u16") U16_RASR_BINARY_PATHS = {"TF1": u16_rasr_path_tf2, "TF2": u16_rasr_path_tf2_barcelona, "TED_COMMON": u16_rasr_path_ted_common} u16_returnn_launcher_tf2 = tk.Path( "/u/raissi/bin/apptainer-launchers/u16/returnn_tf2.3_apptainer_u16_launcher.sh", @@ -138,6 +139,12 @@ def __post_init__(self) -> None: rasr_binary_path=U16_RASR_BINARY_PATHS["TED_COMMON"], ) +u16_tools_factored = ToolPaths( + returnn_root=RETURNN_ROOT_BW_FACTORED, + returnn_python_exe=U16_RETURNN_LAUNCHERS["TF2"], + rasr_binary_path=U16_RASR_GENERIC_SEQ2SEQ +) + u22_tools_tf = ToolPaths( returnn_root=RETURNN_ROOT_TORCH,