update mixins and engine

Author: leej3

ignite/base/mixins.py

@@ -1,11 +1,18 @@
 from collections import OrderedDict
 from collections.abc import Mapping
-from typing import Tuple
+from typing import List, Tuple
 
 
 class Serializable:
-    _state_dict_all_req_keys: Tuple = ()
-    _state_dict_one_of_opt_keys: Tuple = ()
+    _state_dict_all_req_keys: Tuple[str, ...] = ()
+    _state_dict_one_of_opt_keys: Tuple[Tuple[str, ...], ...] = ((),)
+
+    def __init__(self) -> None:
+        self._state_dict_user_keys: List[str] = []
+
+    @property
+    def state_dict_user_keys(self) -> List:
+        return self._state_dict_user_keys
 
     def state_dict(self) -> OrderedDict:
         raise NotImplementedError
@@ -19,6 +26,13 @@ def load_state_dict(self, state_dict: Mapping) -> None:
                 raise ValueError(
                     f"Required state attribute '{k}' is absent in provided state_dict '{state_dict.keys()}'"
                 )
-        opts = [k in state_dict for k in self._state_dict_one_of_opt_keys]
-        if len(opts) > 0 and ((not any(opts)) or (all(opts))):
-            raise ValueError(f"state_dict should contain only one of '{self._state_dict_one_of_opt_keys}' keys")
+        for one_of_opt_keys in self._state_dict_one_of_opt_keys:
+            opts = [k in state_dict for k in one_of_opt_keys]
+            if len(opts) > 0 and (not any(opts)) or (all(opts)):
+                raise ValueError(f"state_dict should contain only one of '{one_of_opt_keys}' keys")
+
+        for k in self._state_dict_user_keys:
+            if k not in state_dict:
+                raise ValueError(
+                    f"Required user state attribute '{k}' is absent in provided state_dict '{state_dict.keys()}'"
+                )

ignite/engine/engine.py

@@ -129,7 +129,16 @@ def compute_mean_std(engine, batch):
     """
 
     _state_dict_all_req_keys = ("epoch_length", "max_epochs")
-    _state_dict_one_of_opt_keys = ("iteration", "epoch")
+    _state_dict_one_of_opt_keys = (
+        (
+            "iteration",
+            "epoch",
+        ),
+        (
+            "max_epochs",
+            "max_iters",
+        ),
+    )
 
     # Flag to disable engine._internal_run as generator feature for BC
     interrupt_resume_enabled = True
@@ -310,6 +319,7 @@ def execute_something():
             for e in event_name:
                 self.add_event_handler(e, handler, *args, **kwargs)
             return RemovableEventHandle(event_name, handler, self)
+
         if isinstance(event_name, CallableEventWithFilter) and event_name.filter is not None:
             event_filter = event_name.filter
             handler = self._handler_wrapper(handler, event_name, event_filter)
@@ -332,6 +342,16 @@ def execute_something():
 
         return RemovableEventHandle(event_name, handler, self)
 
+    @staticmethod
+    def _assert_non_filtered_event(event_name: Any) -> None:
+        if (
+            isinstance(event_name, CallableEventWithFilter)
+            and event_name.filter != CallableEventWithFilter.default_event_filter
+        ):
+            raise TypeError(
+                "Argument event_name should not be a filtered event, " "please use event without any event filtering"
+            )
+
     def has_event_handler(self, handler: Callable, event_name: Optional[Any] = None) -> bool:
         """Check if the specified event has the specified handler.
 
@@ -675,7 +695,12 @@ def save_engine(_):
                 a dictionary containing engine's state
 
         """
-        keys: Tuple[str, ...] = self._state_dict_all_req_keys + (self._state_dict_one_of_opt_keys[0],)
+        keys: Tuple[str, ...] = self._state_dict_all_req_keys
+        keys += ("iteration",)
+        if self.state.max_epochs is not None:
+            keys += ("max_epochs",)
+        else:
+            keys += ("max_iters",)
         keys += tuple(self._state_dict_user_keys)
         return OrderedDict([(k, getattr(self.state, k)) for k in keys])
 
@@ -728,6 +753,8 @@ def load_state_dict(self, state_dict: Mapping) -> None:
                     f"Input state_dict: {state_dict}"
                 )
             self.state.iteration = self.state.epoch_length * self.state.epoch
+        self._check_and_set_max_epochs(state_dict.get("max_epochs", None))
+        self._check_and_set_max_iters(state_dict.get("max_iters", None))
 
     @staticmethod
     def _is_done(state: State) -> bool:
@@ -864,12 +891,26 @@ def switch_batch(engine):
 
                 epoch_length = self._get_data_length(data)
                 if epoch_length is not None and epoch_length < 1:
-                    raise ValueError("Input data has zero size. Please provide non-empty data")
+                    raise ValueError(
+                        "Argument epoch_length is invalid. Please, either set a"
+                        " correct epoch_length value or check if input data has"
+                        " non-zero size."
+                    )
 
             if max_iters is None:
                 if max_epochs is None:
                     max_epochs = 1
             else:
+                if max_iters < 1:
+                    raise ValueError("Argument max_iters is invalid. Please, set a correct max_iters positive value")
+                if (self.state.max_iters is not None) and max_iters <= self.state.iteration:
+                    raise ValueError(
+                        "Argument max_iters should be larger than the current iteration "
+                        f"defined in the state: {max_iters} vs {self.state.iteration}. "
+                        "Please, set engine.state.max_iters = None "
+                        "before calling engine.run() in order to restart the training from the beginning."
+                    )
+                self.state.max_iters = max_iters
                 if max_epochs is not None:
                     raise ValueError(
                         "Arguments max_iters and max_epochs are mutually exclusive."
@@ -932,6 +973,53 @@ def _setup_dataloader_iter(self) -> None:
         else:
             self._dataloader_iter = iter(self.state.dataloader)
 
+    def _check_and_set_max_epochs(self, max_epochs: Optional[int] = None) -> None:
+        if max_epochs is not None:
+            if max_epochs < 1:
+                raise ValueError("Argument max_epochs is invalid. Please, set a correct max_epochs positive value")
+            if self.state.max_epochs is not None and max_epochs <= self.state.epoch:
+                raise ValueError(
+                    "Argument max_epochs should be larger than the current epoch "
+                    f"defined in the state: {max_epochs} vs {self.state.epoch}. "
+                    "Please, set engine.state.max_epochs = None "
+                    "before calling engine.run() in order to restart the training from the beginning."
+                )
+            self.state.max_epochs = max_epochs
+
+    def _check_and_set_max_iters(self, max_iters: Optional[int] = None) -> None:
+        if max_iters is not None:
+            if max_iters < 1:
+                raise ValueError("Argument max_iters is invalid. Please, set a correct max_iters positive value")
+            if (self.state.max_iters is not None) and max_iters <= self.state.iteration:
+                raise ValueError(
+                    "Argument max_iters should be larger than the current iteration "
+                    f"defined in the state: {max_iters} vs {self.state.iteration}. "
+                    "Please, set engine.state.max_iters = None "
+                    "before calling engine.run() in order to restart the training from the beginning."
+                )
+            self.state.max_iters = max_iters
+
+    def _check_and_set_epoch_length(self, data: Iterable, epoch_length: Optional[int] = None) -> None:
+        # Can't we accept a redefinition ?
+        if self.state.epoch_length is not None:
+            if epoch_length is not None:
+                if epoch_length != self.state.epoch_length:
+                    raise ValueError(
+                        "Argument epoch_length should be same as in the state, "
+                        f"but given {epoch_length} vs {self.state.epoch_length}"
+                    )
+        else:
+            if epoch_length is None:
+                epoch_length = self._get_data_length(data)
+
+            if epoch_length is not None and epoch_length < 1:
+                raise ValueError(
+                    "Argument epoch_length is invalid. Please, either set a correct epoch_length value or "
+                    "check if input data has non-zero size."
+                )
+
+            self.state.epoch_length = epoch_length
+
     def _setup_engine(self) -> None:
         self._setup_dataloader_iter()
 
@@ -1064,6 +1152,13 @@ def _run_once_on_dataset_as_gen(self) -> Generator[State, None, float]:
                         self.state.epoch_length = iter_counter
                         if self.state.max_iters is not None:
                             self.state.max_epochs = math.ceil(self.state.max_iters / self.state.epoch_length)
+                            # Warn but will continue until max iters is reached
+                            warnings.warn(
+                                "Data iterator can not provide data anymore but required total number of "
+                                "iterations to run is not reached. "
+                                f"Current iteration: {self.state.iteration} vs Total iterations to run :"
+                                f" {self.state.max_iters}"
+                            )
                         break
 
                     # Should exit while loop if we can not iterate
@@ -1106,7 +1201,13 @@ def _run_once_on_dataset_as_gen(self) -> Generator[State, None, float]:
 
                 if self.state.max_iters is not None and self.state.iteration == self.state.max_iters:
                     self.should_terminate = True
-                    raise _EngineTerminateException()
+                    warnings.warn(
+                        "Data iterator can not provide data anymore but required total number of "
+                        "iterations to run is not reached. "
+                        f"Current iteration: {self.state.iteration} vs Total iterations to run : ? total_iters"
+                    )
+                    break
+                    # raise _EngineTerminateException()
 
         except _EngineTerminateSingleEpochException:
             self._fire_event(Events.TERMINATE_SINGLE_EPOCH, iter_counter=iter_counter)
@@ -1231,6 +1332,13 @@ def _run_once_on_dataset_legacy(self) -> float:
                         self.state.epoch_length = iter_counter
                         if self.state.max_iters is not None:
                             self.state.max_epochs = math.ceil(self.state.max_iters / self.state.epoch_length)
+                            # Warn but will continue until max iters is reached
+                            warnings.warn(
+                                "Data iterator can not provide data anymore but required total number of "
+                                "iterations to run is not reached. "
+                                f"Current iteration: {self.state.iteration} vs Total iterations to run :"
+                                f" {self.state.max_iters}"
+                            )
                         break
 
                     # Should exit while loop if we can not iterate
@@ -1291,6 +1399,16 @@ def _run_once_on_dataset_legacy(self) -> float:
 
         return time.time() - start_time
 
+    def debug(self, enabled: bool = True) -> None:
+        """Enables/disables engine's logging debug mode"""
+        from ignite.utils import setup_logger
+
+        if enabled:
+            setattr(self, "_stored_logger", self.logger)
+            self.logger = setup_logger(level=logging.DEBUG)
+        elif hasattr(self, "_stored_logger"):
+            self.logger = getattr(self, "_stored_logger")
+
 
 def _get_none_data_iter(size: int) -> Iterator:
     # Sized iterator for data as None

tests/ignite/base/test_mixins.py

@@ -13,6 +13,7 @@ def test_state_dict():
     with pytest.raises(NotImplementedError):
         s.state_dict()
 
+
 def test_load_state_dict():
 
     s = ExampleSerializable()

tests/ignite/engine/test_engine.py

@@ -11,7 +11,7 @@
 from ignite.engine import Engine, Events, State
 from ignite.engine.deterministic import keep_random_state
 from ignite.metrics import Average
-from tests.ignite.engine import BatchChecker, EpochCounter, get_iterable_dataset, IterationCounter
+from tests.ignite.engine import BatchChecker, EpochCounter, IterationCounter
 
 
 class RecordedEngine(Engine):
@@ -520,7 +520,7 @@ def test__setup_engine(self):
         data = list(range(100))
         engine.state.dataloader = data
         engine._setup_engine()
-        assert len(engine._init_iter) == 1 and engine._init_iter[0] == 10
+        assert engine._init_iter == 10
 
     def test_run_asserts(self):
         engine = Engine(lambda e, b: 1)
@@ -531,7 +531,7 @@ def test_run_asserts(self):
             r"value or check if input data has non-zero size.",
         ):
             engine.run([])
-        with pytest.raises(ValueError, match=r"Argument max_epochs should be larger than"):
+        with pytest.raises(ValueError, match=r"Argument max_epochs should be greater than or equal to the start epoch"):
             engine.state.max_epochs = 5
             engine.state.epoch = 5
             engine.run([0, 1], max_epochs=3)
@@ -707,8 +707,8 @@ def infinite_data_iterator():
         kwargs = dict(exp_iter_stops=0, n_epoch_started=2, n_epoch_completed=1)
         self._test_check_triggered_events(infinite_data_iterator(), max_iters=30, epoch_length=20, **kwargs)
 
-        def limited_data_iterator():
-            for i in range(100):
+        def limited_data_iterator(length=100):
+            for i in range(length):
                 yield i
 
         self._test_check_triggered_events(limited_data_iterator(), max_epochs=1, epoch_length=100, exp_iter_stops=0)
@@ -730,7 +730,7 @@ def limited_data_iterator():
                 n_batch_completed=20,
                 n_terminate=1,
             )
-            self._test_check_triggered_events(limited_data_iterator(), max_epochs=3, epoch_length=20, **kwargs)
+            self._test_check_triggered_events(limited_data_iterator(length=20), max_epochs=3, epoch_length=20, **kwargs)
 
         with pytest.warns(UserWarning, match=r"Data iterator can not provide data anymore"):
             kwargs = dict(
@@ -1019,7 +1019,7 @@ def restart_iter():
         _test(max_iters=known_size)
         _test(max_iters=known_size // 2)
 
-    def test_faq_inf_iterator_with_epoch_length():
+    def test_faq_inf_iterator_with_epoch_length(self):
         def _test(max_epochs, max_iters):
             # Code snippet from FAQ
             # import torch
@@ -1132,59 +1132,6 @@ def val_step(evaluator, batch):
 
         _test(max_epochs=None, max_iters=None)
 
-    def test_faq_fin_iterator(self):
-        # Code snippet from FAQ
-        # import torch
-
-        torch.manual_seed(12)
-
-        size = 11
-
-        def finite_size_data_iter(size):
-            for i in range(size):
-                yield i
-
-        def train_step(trainer, batch):
-            # ...
-            s = trainer.state
-            print(f"{s.epoch}/{s.max_epochs} : {s.iteration} - {batch:.3f}")
-
-        trainer = Engine(train_step)
-
-        @trainer.on(Events.ITERATION_COMPLETED(every=size))
-        def restart_iter():
-            trainer.state.dataloader = finite_size_data_iter(size)
-
-        data_iter = finite_size_data_iter(size)
-        trainer.run(data_iter, max_epochs=5)
-
-        assert trainer.state.epoch == 5
-        assert trainer.state.iteration == 5 * size
-
-        # Code snippet from FAQ
-        # import torch
-
-        torch.manual_seed(12)
-
-        size = 11
-
-        def finite_size_data_iter(size):
-            for i in range(size):
-                yield i
-
-        def val_step(evaluator, batch):
-            # ...
-            s = evaluator.state
-            print(f"{s.epoch}/{s.max_epochs} : {s.iteration} - {batch:.3f}")
-
-        evaluator = Engine(val_step)
-
-        data_iter = finite_size_data_iter(size)
-        evaluator.run(data_iter)
-
-        assert evaluator.state.epoch == 1
-        assert evaluator.state.iteration == size
-
     def test_faq_fin_iterator(self):
         def _test(max_epochs, max_iters):
             # Code snippet from FAQ
@@ -1475,7 +1422,8 @@ def test_restart_training(self):
         state = engine.run(data, max_epochs=5)
         with pytest.raises(
             ValueError,
-            match=r"Argument max_epochs should be larger than the current epoch defined in the state: 2 vs 5. "
+            match=r"Argument max_epochs should be greater than or equal to the start epoch"
+            " defined in the state: 2 vs 5. "
             r"Please, .+ "
             r"before calling engine.run\(\) in order to restart the training from the beginning.",
         ):