returnn 1.20251106.185107__tar.gz → 1.20251118.160612__tar.gz

{returnn-1.20251106.185107/returnn.egg-info → returnn-1.20251118.160612}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: returnn
-Version: 1.20251106.185107
+Version: 1.20251118.160612
 Summary: The RWTH extensible training framework for universal recurrent neural networks
 Home-page: https://github.com/rwth-i6/returnn/
 Author: Albert Zeyer

returnn-1.20251118.160612/_setup_info_generated.py

@@ -0,0 +1,2 @@
+version = '1.20251118.160612'
+long_version = '1.20251118.160612+git.5320f71'

{returnn-1.20251106.185107 → returnn-1.20251118.160612}/returnn/datasets/meta.py

@@ -253,22 +253,12 @@ class MetaDataset(CachedDataset2):
         }
 
         self._seq_list_file = seq_list_file
-        self.seq_list_original = self._load_seq_list(seq_list_file)
-        self.num_total_seqs = len(self.seq_list_original[self.default_dataset_key])
-        for key in self.dataset_keys:
-            assert len(self.seq_list_original[key]) == self.num_total_seqs
-
-        self.tag_idx = {tag: idx for (idx, tag) in enumerate(self.seq_list_original[self.default_dataset_key])}
+        self.seq_list_original: Optional[Dict[str, List[str]]] = None
+        self.tag_idx: Optional[Dict[str, int]] = None
 
         self._seq_lens: Optional[Dict[str, NumbersDict]] = None
         self._num_timesteps: Optional[NumbersDict] = None
         self._seq_lens_file = seq_lens_file
-        if seq_lens_file:
-            seq_lens = load_json(filename=seq_lens_file)
-            assert isinstance(seq_lens, dict)
-            # dict[str,NumbersDict], seq-tag -> data-key -> len
-            self._seq_lens = {tag: NumbersDict(l) for (tag, l) in seq_lens.items()}
-            self._num_timesteps = sum([self._seq_lens[s] for s in self.seq_list_original[self.default_dataset_key]])
 
         if data_dims:
             data_dims = convert_data_dims(data_dims)
@@ -290,19 +280,20 @@ class MetaDataset(CachedDataset2):
         self.num_outputs = self.data_dims
 
         self.orig_seq_order_is_initialized = False
+        self._current_seq_order: List[int] = []
         self.seq_list_ordered: Optional[Dict[str, List[str]]] = None
 
-    def _load_seq_list(self, seq_list_file: Optional[Union[str, Dict[str, str]]] = None) -> Dict[str, List[str]]:
-        """
-        :param seq_list_file:
-        :return: dict: dataset key -> seq list
-        """
-        if not seq_list_file:
+    def _lazy_init_seq_list(self):
+        if self.seq_list_original is not None:
+            return
+
+        if not self._seq_list_file:
             # We create a sequence list from all the sequences of the default dataset
             # and hope that it also applies to the
             # other datasets.
             # This can only work if all datasets have the same tag format and the sequences in the other
             # datasets are a subset of those in the default dataset.
+            # (But the order does not matter.)
             default_dataset = self.datasets[self.default_dataset_key]
             assert isinstance(default_dataset, Dataset)
             print(
@@ -349,17 +340,18 @@ class MetaDataset(CachedDataset2):
                         break  # only print one
                 del seq_list_set
                 raise Exception("Dataset %r is missing seqs." % key)
-        elif isinstance(seq_list_file, str):
-            seq_list = Dataset._load_seq_list_file(seq_list_file, expect_list=False)
-        elif isinstance(seq_list_file, dict):
+        elif isinstance(self._seq_list_file, str):
+            seq_list = Dataset._load_seq_list_file(self._seq_list_file, expect_list=False)
+        elif isinstance(self._seq_list_file, dict):
             for key in self.dataset_keys:
-                if key not in seq_list_file:
+                if key not in self._seq_list_file:
                     raise ValueError(f"seq_list_file does not contain all datasets, missing {key}")
-            seq_list = {key: Dataset._load_seq_list_file(seq_list_file[key]) for key in self.dataset_keys}
+            seq_list = {key: Dataset._load_seq_list_file(self._seq_list_file[key]) for key in self.dataset_keys}
         else:
-            raise TypeError(f"unexpected seq_list_file type {type(seq_list_file)}")
+            raise TypeError(f"unexpected seq_list_file type {type(self._seq_list_file)}")
 
         if isinstance(seq_list, list):
+            # Use same seq list for all datasets
             seq_list = {key: seq_list for key in self.dataset_keys}
         elif isinstance(seq_list, dict):
             for key in self.dataset_keys:
@@ -368,10 +360,29 @@ class MetaDataset(CachedDataset2):
         else:
             raise TypeError(f"unexpected seq_list type {type(seq_list)}")
 
-        return seq_list
+        for key in self.dataset_keys:
+            assert len(seq_list[key]) == len(seq_list[self.default_dataset_key])
+
+        self.seq_list_original = seq_list
+
+    def _lazy_init_tag_idx(self):
+        if self.tag_idx is not None:
+            return
+        self._lazy_init_seq_list()
+        self.tag_idx = {tag: idx for (idx, tag) in enumerate(self.seq_list_original[self.default_dataset_key])}
+
+    def _lazy_init_seq_lens(self):
+        if self._seq_lens is not None:
+            return
+        assert self._seq_lens_file
+        seq_lens = load_json(filename=self._seq_lens_file)
+        assert isinstance(seq_lens, dict)
+        # dict[str,NumbersDict], seq-tag -> data-key -> len
+        self._seq_lens = {tag: NumbersDict(lens) for (tag, lens) in seq_lens.items()}
 
     def _get_dataset_seq_length(self, seq_idx: int):
         if not self.orig_seq_order_is_initialized:
+            self._lazy_init_seq_list()
             # To use get_seq_length() we first have to init the sequence order once in original order.
             # If sequence lengths are not needed by get_seq_order_for_epoch this is never executed.
             self.datasets[self.default_dataset_key].init_seq_order(
@@ -379,6 +390,9 @@ class MetaDataset(CachedDataset2):
             )
             self.orig_seq_order_is_initialized = True
 
+        # Warning: This is not correct in the general case.
+        # get_seq_length needs to have load_seqs called beforehand per API contract.
+        # For some datasets, it might anyway work.
         return self.datasets[self.default_dataset_key].get_seq_length(seq_idx)["data"]
 
     def init_seq_order(self, epoch=None, seq_list=None, seq_order=None):
@@ -392,6 +406,7 @@ class MetaDataset(CachedDataset2):
             self.epoch is None
             or self.epoch != epoch
             or self.seq_list_ordered is None
+            or not self._current_seq_order
             or seq_list is not None
             or seq_order is not None
             or self.expected_load_seq_start > 0
@@ -401,16 +416,17 @@ class MetaDataset(CachedDataset2):
             # This is called via initialize() with epoch=None, just to init some other things.
             # We are not expected to have prepared any real epoch here.
             self._num_seqs = 0
+            self._current_seq_order = []
             return True
 
         if not need_reinit:
-            self._num_seqs = len(self.seq_list_ordered[self.default_dataset_key])
             return False
 
         seq_order_dataset = None
         if seq_order is not None:
             seq_index = seq_order
         elif seq_list is not None:
+            self._lazy_init_tag_idx()
             seq_index = [self.tag_idx[tag] for tag in seq_list]
         elif self.seq_order_control_dataset:
             seq_order_dataset = self.datasets[self.seq_order_control_dataset]
@@ -418,13 +434,15 @@ class MetaDataset(CachedDataset2):
             seq_order_dataset.init_seq_order(epoch=epoch)
             seq_index = seq_order_dataset.get_current_seq_order()
         else:
-            if self._seq_lens:
+            if self._seq_lens_file:
 
                 def get_seq_len(s):
                     """
                     :param int s:
                     :rtype: int
                     """
+                    self._lazy_init_seq_list()
+                    self._lazy_init_seq_lens()
                     return self._seq_lens[self.seq_list_original[self.default_dataset_key][s]]["data"]
 
             elif self._seq_order_seq_lens_file:
@@ -432,8 +450,10 @@ class MetaDataset(CachedDataset2):
             else:
                 self.orig_seq_order_is_initialized = False
                 get_seq_len = self._get_dataset_seq_length
-            seq_index = self.get_seq_order_for_epoch(epoch, self.num_total_seqs, get_seq_len)
+            seq_index = self.get_seq_order_for_epoch(epoch, self.get_total_num_seqs(), get_seq_len)
         self._num_seqs = len(seq_index)
+        self._current_seq_order = seq_index
+        self._lazy_init_seq_list()
         self.seq_list_ordered = {key: [ls[s] for s in seq_index] for (key, ls) in self.seq_list_original.items()}
 
         for dataset_key, dataset in self.datasets.items():
@@ -447,7 +467,7 @@ class MetaDataset(CachedDataset2):
         """supports sorting"""
         if self.seq_order_control_dataset:
             return self.datasets[self.seq_order_control_dataset].supports_seq_order_sorting()
-        if self._seq_lens or self._seq_order_seq_lens_file:
+        if self._seq_lens_file or self._seq_order_seq_lens_file:
             return True
         return False
 
@@ -464,20 +484,40 @@ class MetaDataset(CachedDataset2):
         :return: current seq order for the current epoch, after self.init_seq_order was called.
         :rtype: list[int]
         """
-        return [self.tag_idx[tag] for tag in self.seq_list_ordered[self.default_dataset_key]]
+        return self._current_seq_order
 
     def get_all_tags(self):
         """
         :return: list of all seq tags, of the whole dataset, without partition epoch
         :rtype: list[str]
         """
+        if self._seq_list_file is None:
+            return self.datasets[self.default_dataset_key].get_all_tags()
+        self._lazy_init_seq_list()
+        assert self.seq_list_original is not None
         return self.seq_list_original[self.default_dataset_key]
 
     def get_total_num_seqs(self, *, fast: bool = False) -> int:
         """
+        :param fast: if True, might raise an exception if not possible to get fast.
         :return: total number of seqs, without partition epoch
         """
-        return self.num_total_seqs
+        if self._seq_list_file is None:
+            return self.datasets[self.default_dataset_key].get_total_num_seqs(fast=fast)
+        if fast and self.seq_list_original is None:
+            raise OptionalNotImplementedError(f"{self} get_total_num_seqs, seq list not loaded yet")
+        self._lazy_init_seq_list()
+        assert self.seq_list_original is not None
+        return len(self.seq_list_original[self.default_dataset_key])
+
+    def get_num_timesteps(self):
+        """num timesteps"""
+        if self._num_timesteps is None and self._seq_lens_file:
+            self._lazy_init_seq_lens()
+            self._num_timesteps = sum([self._seq_lens[s] for s in self.get_all_tags()], start=NumbersDict())
+        if self._seq_list_file is None:
+            return self.datasets[self.default_dataset_key].get_num_timesteps()
+        return super().get_num_timesteps()
 
     def finish_epoch(self, *, free_resources: bool = False):
         """
@@ -503,8 +543,9 @@ class MetaDataset(CachedDataset2):
         if start_ < end:
             for dataset_key in self.dataset_keys:
                 self.datasets[dataset_key].load_seqs(start_, end)
-                for seq_idx in range(start_, end):
-                    self._check_dataset_seq(dataset_key, seq_idx)
+                if self.seq_list_ordered is not None:
+                    for seq_idx in range(start_, end):
+                        self._check_dataset_seq(dataset_key, seq_idx)
         super(MetaDataset, self)._load_seqs(start=start, end=end)
 
     def _check_dataset_seq(self, dataset_key, seq_idx):
@@ -531,7 +572,7 @@ class MetaDataset(CachedDataset2):
         :type seq_idx: int
         :rtype: DatasetSeq
         """
-        seq_tag = self.seq_list_ordered[self.default_dataset_key][seq_idx]
+        seq_tag = self.get_tag(seq_idx)
         features = {data_key: self._get_data(seq_idx, data_key) for data_key in self.data_keys}
         return DatasetSeq(seq_idx=seq_idx, seq_tag=seq_tag, features=features)
 
@@ -540,8 +581,9 @@ class MetaDataset(CachedDataset2):
         :param int sorted_seq_idx:
         :rtype: NumbersDict
         """
-        if self._seq_lens:
-            return self._seq_lens[self.seq_list_ordered[self.default_dataset_key][sorted_seq_idx]]
+        if self._seq_lens_file:
+            self._lazy_init_seq_lens()
+            return self._seq_lens[self.get_tag(sorted_seq_idx)]
         return super(MetaDataset, self).get_seq_length(sorted_seq_idx)
 
     def get_tag(self, sorted_seq_idx):
@@ -549,7 +591,10 @@ class MetaDataset(CachedDataset2):
         :param int sorted_seq_idx:
         :rtype: str
         """
-        return self.seq_list_ordered[self.default_dataset_key][sorted_seq_idx]
+        if self.seq_list_ordered is not None:
+            return self.seq_list_ordered[self.default_dataset_key][sorted_seq_idx]
+        else:
+            return self.datasets[self.default_dataset_key].get_tag(sorted_seq_idx)
 
     def get_complete_frac(self, sorted_seq_idx: int, **kwargs) -> Optional[float]:
         """
@@ -961,6 +1006,7 @@ class CombinedDataset(CachedDataset2):
         super(CombinedDataset, self).__init__(**kwargs)
         assert self.shuffle_frames_of_nseqs == 0  # not implemented. anyway only for non-recurrent nets
 
+        self.data_map = data_map
         self.dataset_keys = set([m[0] for m in data_map.keys()])  # type: typing.Set[str]
         self.dataset_idx2key_map = dict(enumerate(sorted(self.dataset_keys)))  # idx -> dataset-key
         self.data_keys = set(data_map.values())  # type: typing.Set[str]
@@ -1248,6 +1294,10 @@ class CombinedDataset(CachedDataset2):
         # Cur meaning for the next sequence to be added to dataset_sorted_seq_idx_list.
         seq_idx = self.used_num_seqs_per_subset[dataset_idx]
         cur_start, cur_end = self._sub_dataset_cur_loaded_seq_range[dataset_idx]
+
+        if not self.datasets[self.dataset_idx2key_map[dataset_idx]].is_less_than_num_seqs(seq_idx):
+            return False
+
         if seq_idx >= cur_end:
             self._sub_dataset_load_seqs(dataset_idx, cur_start, seq_idx + 1)
             return True
@@ -1294,10 +1344,12 @@ class CombinedDataset(CachedDataset2):
                 complete_fracs_and_ds_idx = [
                     (
                         self.datasets[self.dataset_idx2key_map[j]].get_complete_frac(
-                            self.used_num_seqs_per_subset[j] - 1, allow_only_lr_suitable=True
+                            self.used_num_seqs_per_subset[j], allow_only_lr_suitable=True
+                        )
+                        if self.datasets[self.dataset_idx2key_map[j]].is_less_than_num_seqs(
+                            self.used_num_seqs_per_subset[j]
                         )
-                        if self.used_num_seqs_per_subset[j] > 0
-                        else 0.0,
+                        else float("inf"),
                         j,
                     )
                     for j in range(len(self.datasets))
@@ -1309,9 +1361,7 @@ class CombinedDataset(CachedDataset2):
                 # Sort by complete frac, i.e. datasets with the lowest complete frac first.
                 complete_fracs_and_ds_idx.sort()
                 for complete_frac, dataset_idx in complete_fracs_and_ds_idx:
-                    if self.datasets[self.dataset_idx2key_map[dataset_idx]].is_less_than_num_seqs(
-                        self.used_num_seqs_per_subset[dataset_idx]
-                    ):
+                    if complete_frac < float("inf"):
                         break
                 else:
                     return False  # No dataset has remaining data

{returnn-1.20251106.185107 → returnn-1.20251118.160612}/returnn/util/basic.py

@@ -365,12 +365,9 @@ def get_checkpoint_filepattern(filepath):
     :return: CheckpointLoader compatible filepattern
     :rtype: str
     """
-    if filepath.endswith(".meta"):
-        return filepath[: -len(".meta")]
-    elif filepath.endswith(".index"):
-        return filepath[: -len(".index")]
-    elif filepath.endswith(".pt"):
-        return filepath[: -len(".pt")]
+    for ext in [".meta", ".index", ".pt"]:
+        if filepath.endswith(ext):
+            return filepath[: -len(ext)]
     return filepath
 
 

{returnn-1.20251106.185107 → returnn-1.20251118.160612}/returnn/util/better_exchook.py

@@ -1093,6 +1093,7 @@ def format_tb(
     with_color=None,
     with_vars=None,
     clear_frames=True,
+    colorize=None,
 ):
     """
     Formats a traceback into a list of strings, each corresponding to one frame.
@@ -1110,11 +1111,14 @@ def format_tb(
         That will potentially fix some mem leaks regarding locals, so it can be important.
         Also see https://github.com/python/cpython/issues/113939.
         However, any further access to frame locals will not work (e.g., if you want to use a debugger afterward).
+    :param colorize: for compat with Python >=3.13, currently ignored
     :return: list of strings, each corresponding to one frame in the traceback.
         Each string contains the file name, line number, function name, source code line, maybe relevant variables,
         etc., and a final newline.
     :rtype: list[str]
     """
+    if colorize is not None and with_color is None:
+        with_color = colorize
     color = Color(enable=with_color)
     output = _OutputLinesCollector(color=color)
 

{returnn-1.20251106.185107 → returnn-1.20251118.160612/returnn.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: returnn
-Version: 1.20251106.185107
+Version: 1.20251118.160612
 Summary: The RWTH extensible training framework for universal recurrent neural networks
 Home-page: https://github.com/rwth-i6/returnn/
 Author: Albert Zeyer

{returnn-1.20251106.185107 → returnn-1.20251118.160612}/tests/test_Dataset.py

@@ -906,6 +906,52 @@ def test_MetaDataset():
         assert len(classes) == len(_demo_txt) + 1
 
 
+def test_MetaDataset_LmDataset_lazy_init():
+    # https://github.com/rwth-i6/returnn/issues/1793
+    from returnn.datasets.lm import LmDataset
+
+    with tempfile.NamedTemporaryFile("wt", suffix=".txt") as txt_file:
+        txt_file.write("Hello world\n")
+        txt_file.write("Next line\n")
+        txt_file.flush()
+
+        orig_lazy_init = LmDataset._lazy_init
+
+        try:
+
+            def _wrapped_lazy_init(self):
+                print(f"{self} lazy init...")
+                raise Exception("we want to test that lazy init is not called")
+
+            LmDataset._lazy_init = _wrapped_lazy_init
+
+            dataset = init_dataset(
+                {
+                    "class": "MetaDataset",
+                    "datasets": {
+                        "base": {
+                            "class": "LmDataset",
+                            "corpus_file": txt_file.name,
+                            "use_cache_manager": True,
+                            "skip_empty_lines": False,
+                            "orth_vocab": {"class": "Utf8ByteTargets"},
+                            "seq_end_symbol": None,
+                            "unknown_symbol": None,
+                            "partition_epoch": 2,
+                            "seq_ordering": "laplace:.10",
+                        }
+                    },
+                    "data_map": {"data": ("base", "data")},
+                    "seq_order_control_dataset": "base",
+                }
+            )
+            print("Dataset:", dataset)
+            print("len info:", dataset.len_info(fast=True))
+
+        finally:
+            LmDataset._lazy_init = orig_lazy_init
+
+
 def test_CombinedDataset():
     seq_len = 11
     num_seqs = [10, 5]
@@ -976,17 +1022,16 @@ def test_CombinedDataset():
     seqs = dummy_iter_dataset(dataset)
     assert len(seqs) == sum(num_seqs)
     beginnings = []
-    visited_num_seqs = [0] * num_sub_ds
+    ds_indices = []
     for i, seq in enumerate(seqs):
         relevant_ds_idx = [i for i, k in enumerate(keys) if seq.features[k].shape[0] > 0]
         assert len(relevant_ds_idx) == 1
         ds_idx = relevant_ds_idx[0]
-        complete_fracs = [visited_num_seqs[j] / num_seqs[j] for j in range(num_sub_ds)]
-        assert complete_fracs[ds_idx] == min(complete_fracs)
+        ds_indices.append(ds_idx)
         beginnings.append(int(seq.features[keys[ds_idx]][0]))
-        visited_num_seqs[ds_idx] += 1
     assert len(set(beginnings)) == sum(num_seqs)  # unique, see above
-    assert visited_num_seqs == num_seqs
+    assert len(ds_indices) == sum(num_seqs)
+    assert ds_indices == [0, 0, 1] * 5
 
 
 def test_MapDatasetWrapper():

{returnn-1.20251106.185107 → returnn-1.20251118.160612}/tests/test_Util.py

@@ -21,7 +21,7 @@ my_dir = os.path.dirname(os.path.realpath(__file__))
 
 
 def _sig_alarm_handler(signum, frame):
-    raise Exception(f"Alarm (timeout) signal handler")
+    raise Exception("Alarm (timeout) signal handler")
 
 
 signal.signal(signal.SIGALRM, _sig_alarm_handler)
@@ -200,6 +200,22 @@ def test_NumbersDict_eq_2():
     assert a != 5
 
 
+def test_NumbersDict_add0():
+    a = NumbersDict(numbers_dict={"data": 3, "classes": 2}, broadcast_value=1)
+    b = NumbersDict() + a
+    assert isinstance(b, NumbersDict)
+    assert b.value == 1
+    assert b.dict == {"data": 3, "classes": 2}
+
+
+def test_NumbersDict_add0a():
+    a = NumbersDict(numbers_dict={"data": 3, "classes": 2})
+    b = NumbersDict() + a
+    assert isinstance(b, NumbersDict)
+    assert b.value is None
+    assert b.dict == {"data": 3, "classes": 2}
+
+
 def test_NumbersDict_mul():
     a = NumbersDict(numbers_dict={"data": 3, "classes": 2}, broadcast_value=1)
     b = a * 2
@@ -599,11 +615,11 @@ def test_import_wrong_pkg_py_import():
     del sys.modules[mod_name]
 
     try:
-        import returnn_import.github_com.rwth_i6.returnn_experiments.v20210302153450_10beb9d1c57e
+        import returnn_import.github_com.rwth_i6.returnn_experiments.v20210302153450_10beb9d1c57e as _mod
     except MissingExplicitImport as exc:  # but *not* a normal ImportError
         print("Got expected exception:", exc)
     else:
-        raise Exception("We expected an import error exception but got nothing.")
+        raise Exception(f"We expected an import error exception but got nothing and module {_mod}")
 
 
 def test_literal_py_to_pickle():

returnn-1.20251106.185107/_setup_info_generated.py

@@ -1,2 +0,0 @@
-version = '1.20251106.185107'
-long_version = '1.20251106.185107+git.fd8d2d8'