review comments

Author: RaviTezu

ignite/contrib/engines/common.py

@@ -35,19 +35,19 @@ def setup_common_training_handlers(
     trainer: Engine,
     train_sampler: Optional[DistributedSampler] = None,
     to_save: Optional[Dict[str, Any]] = None,
-    save_every_iters: Optional[int] = 1000,
+    save_every_iters: int = 1000,
     output_path: Optional[str] = None,
     lr_scheduler: Optional[Union[ParamScheduler, _LRScheduler]] = None,
-    with_gpu_stats: Optional[bool] = False,
+    with_gpu_stats: bool = False,
     output_names: Optional[Iterable[str]] = None,
-    with_pbars: Optional[bool] = True,
-    with_pbar_on_iters: Optional[bool] = True,
-    log_every_iters: Optional[int] = 100,
+    with_pbars: bool = True,
+    with_pbar_on_iters: bool = True,
+    log_every_iters: int = 100,
     device: Optional[Union[str, torch.device]] = None,
-    stop_on_nan: Optional[bool] = True,
-    clear_cuda_cache: Optional[bool] = True,
+    stop_on_nan: bool = True,
+    clear_cuda_cache: bool = True,
     save_handler: Optional[Union[Callable, BaseSaveHandler]] = None,
-    **kwargs: Mapping,
+    **kwargs: Any,
 ):
     """Helper method to setup trainer with common handlers (it also supports distributed configuration):
         - :class:`~ignite.handlers.TerminateOnNan`
@@ -126,18 +126,18 @@ class to use to store ``to_save``. See :class:`~ignite.handlers.checkpoint.Check
 def _setup_common_training_handlers(
     trainer: Engine,
     to_save: Optional[Dict[str, Any]] = None,
-    save_every_iters: Optional[int] = 1000,
+    save_every_iters: int = 1000,
     output_path: Optional[str] = None,
     lr_scheduler: Optional[Union[ParamScheduler, _LRScheduler]] = None,
-    with_gpu_stats: Optional[bool] = False,
+    with_gpu_stats: bool = False,
     output_names: Optional[Iterable[str]] = None,
-    with_pbars: Optional[bool] = True,
-    with_pbar_on_iters: Optional[bool] = True,
-    log_every_iters: Optional[int] = 100,
-    stop_on_nan: Optional[bool] = True,
-    clear_cuda_cache: Optional[bool] = True,
+    with_pbars: bool = True,
+    with_pbar_on_iters: bool = True,
+    log_every_iters: int = 100,
+    stop_on_nan: bool = True,
+    clear_cuda_cache: bool = True,
     save_handler: Optional[Union[Callable, BaseSaveHandler]] = None,
-    **kwargs: Mapping,
+    **kwargs: Any,
 ):
     if output_path is not None and save_handler is not None:
         raise ValueError(
@@ -208,18 +208,18 @@ def _setup_common_distrib_training_handlers(
     trainer: Engine,
     train_sampler: Optional[DistributedSampler] = None,
     to_save: Optional[Dict[str, Any]] = None,
-    save_every_iters: Optional[int] = 1000,
+    save_every_iters: int = 1000,
     output_path: Optional[str] = None,
     lr_scheduler: Optional[Union[ParamScheduler, _LRScheduler]] = None,
-    with_gpu_stats: Optional[bool] = False,
+    with_gpu_stats: bool = False,
     output_names: Optional[Iterable[str]] = None,
-    with_pbars: Optional[bool] = True,
-    with_pbar_on_iters: Optional[bool] = True,
-    log_every_iters: Optional[int] = 100,
-    stop_on_nan: Optional[bool] = True,
-    clear_cuda_cache: Optional[bool] = True,
+    with_pbars: bool = True,
+    with_pbar_on_iters: bool = True,
+    log_every_iters: int = 100,
+    stop_on_nan: bool = True,
+    clear_cuda_cache: bool = True,
     save_handler: Optional[Union[Callable, BaseSaveHandler]] = None,
-    **kwargs: Mapping,
+    **kwargs: Any,
 ):
 
     _setup_common_training_handlers(
@@ -265,9 +265,9 @@ def setup_any_logging(logger, logger_module, trainer, optimizers, evaluators, lo
 def _setup_logging(
     logger: BaseLogger,
     trainer: Engine,
-    optimizers: Optional[Union[Optimizer, Dict[str, Optimizer]]],
-    evaluators: Optional[Union[Engine, Dict[str, Engine]]],
-    log_every_iters: Optional[int],
+    optimizers: Union[Optimizer, Dict[str, Optimizer]],
+    evaluators: Union[Engine, Dict[str, Engine]],
+    log_every_iters: int,
 ):
     if optimizers is not None:
         if not isinstance(optimizers, (Optimizer, Mapping)):
@@ -312,8 +312,8 @@ def setup_tb_logging(
     trainer: Engine,
     optimizers: Optional[Union[Optimizer, Dict[str, Optimizer]]] = None,
     evaluators: Optional[Union[Engine, Dict[str, Engine]]] = None,
-    log_every_iters: Optional[int] = 100,
-    **kwargs: Mapping,
+    log_every_iters: int = 100,
+    **kwargs: Any,
 ):
     """Method to setup TensorBoard logging on trainer and a list of evaluators. Logged metrics are:
         - Training metrics, e.g. running average loss values
@@ -343,8 +343,8 @@ def setup_visdom_logging(
     trainer: Engine,
     optimizers: Optional[Union[Optimizer, Dict[str, Optimizer]]] = None,
     evaluators: Optional[Union[Engine, Dict[str, Engine]]] = None,
-    log_every_iters: Optional[int] = 100,
-    **kwargs: Mapping,
+    log_every_iters: int = 100,
+    **kwargs: Any,
 ):
     """Method to setup Visdom logging on trainer and a list of evaluators. Logged metrics are:
         - Training metrics, e.g. running average loss values
@@ -373,8 +373,8 @@ def setup_mlflow_logging(
     trainer: Engine,
     optimizers: Optional[Union[Optimizer, Dict[str, Optimizer]]] = None,
     evaluators: Optional[Union[Engine, Dict[str, Engine]]] = None,
-    log_every_iters: Optional[int] = 100,
-    **kwargs: Mapping,
+    log_every_iters: int = 100,
+    **kwargs: Any,
 ):
     """Method to setup MLflow logging on trainer and a list of evaluators. Logged metrics are:
         - Training metrics, e.g. running average loss values
@@ -403,8 +403,8 @@ def setup_neptune_logging(
     trainer: Engine,
     optimizers: Optional[Union[Optimizer, Dict[str, Optimizer]]] = None,
     evaluators: Optional[Union[Engine, Dict[str, Engine]]] = None,
-    log_every_iters: Optional[int] = 100,
-    **kwargs: Mapping,
+    log_every_iters: int = 100,
+    **kwargs: Any,
 ):
     """Method to setup Neptune logging on trainer and a list of evaluators. Logged metrics are:
         - Training metrics, e.g. running average loss values
@@ -433,8 +433,8 @@ def setup_wandb_logging(
     trainer: Engine,
     optimizers: Optional[Union[Optimizer, Dict[str, Optimizer]]] = None,
     evaluators: Optional[Union[Engine, Dict[str, Engine]]] = None,
-    log_every_iters: Optional[int] = 100,
-    **kwargs: Mapping,
+    log_every_iters: int = 100,
+    **kwargs: Any,
 ):
     """Method to setup WandB logging on trainer and a list of evaluators. Logged metrics are:
         - Training metrics, e.g. running average loss values
@@ -463,8 +463,8 @@ def setup_plx_logging(
     trainer: Engine,
     optimizers: Optional[Union[Optimizer, Dict[str, Optimizer]]] = None,
     evaluators: Optional[Union[Engine, Dict[str, Engine]]] = None,
-    log_every_iters: Optional[int] = 100,
-    **kwargs: Mapping,
+    log_every_iters: int = 100,
+    **kwargs: Any,
 ):
     """Method to setup Polyaxon logging on trainer and a list of evaluators. Logged metrics are:
         - Training metrics, e.g. running average loss values
@@ -493,8 +493,8 @@ def setup_trains_logging(
     trainer: Engine,
     optimizers: Optional[Union[Optimizer, Dict[str, Optimizer]]] = None,
     evaluators: Optional[Union[Engine, Dict[str, Engine]]] = None,
-    log_every_iters: Optional[int] = 100,
-    **kwargs: Mapping,
+    log_every_iters: int = 100,
+    **kwargs: Any,
 ):
     """Method to setup Trains logging on trainer and a list of evaluators. Logged metrics are:
         - Training metrics, e.g. running average loss values
@@ -532,10 +532,10 @@ def gen_save_best_models_by_val_score(
     evaluator: Engine,
     models: torch.nn.Module,
     metric_name: str,
-    n_saved: Optional[int] = 3,
+    n_saved: int = 3,
     trainer: Optional[Engine] = None,
-    tag: Optional[str] = "val",
-    **kwargs: Mapping,
+    tag: str = "val",
+    **kwargs: Any,
 ):
     """Method adds a handler to ``evaluator`` to save ``n_saved`` of best models based on the metric
     (named by ``metric_name``) provided by ``evaluator`` (i.e. ``evaluator.state.metrics[metric_name]``).
@@ -590,10 +590,10 @@ def save_best_model_by_val_score(
     evaluator: Engine,
     model: torch.nn.Module,
     metric_name: str,
-    n_saved: Optional[int] = 3,
+    n_saved: int = 3,
     trainer: Optional[Engine] = None,
-    tag: Optional[str] = "val",
-    **kwargs: Mapping,
+    tag: str = "val",
+    **kwargs: Any,
 ):
     """Method adds a handler to ``evaluator`` to save on a disk ``n_saved`` of best models based on the metric
     (named by ``metric_name``) provided by ``evaluator`` (i.e. ``evaluator.state.metrics[metric_name]``).

ignite/contrib/engines/tbptt.py

@@ -35,10 +35,10 @@ def create_supervised_tbptt_trainer(
     optimizer: Optimizer,
     loss_fn: _Loss,
     tbtt_step: int,
-    dim: Optional[int] = 0,
+    dim: int = 0,
     device: Optional[str] = None,
-    non_blocking: Optional[bool] = False,
-    prepare_batch: Optional[Callable] = _prepare_batch,
+    non_blocking: bool = False,
+    prepare_batch: Callable = _prepare_batch,
 ):
     """Create a trainer for truncated backprop through time supervised models.
 
@@ -59,7 +59,7 @@ def create_supervised_tbptt_trainer(
         optimizer (`torch.optim.Optimizer`): the optimizer to use.
         loss_fn (torch.nn loss function): the loss function to use.
         tbtt_step (int): the length of time chunks (last one may be smaller).
-        dim (int, optional): axis representing the time dimension.
+        dim (int): axis representing the time dimension.
         device (str, optional): device type specification (default: None).
             Applies to batches.
         non_blocking (bool, optional): if True and this copy is between CPU and GPU,
@@ -84,7 +84,7 @@ def create_supervised_tbptt_trainer(
 
     """
 
-    def _update(engine: Engine, batch: Tuple[torch.Tensor, torch.Tensor]):
+    def _update(engine: Engine, batch: Sequence[torch.Tensor]):
         loss_list = []
         hidden = None
 

ignite/contrib/handlers/base_logger.py

@@ -1,7 +1,7 @@
 import numbers
 import warnings
 from abc import ABCMeta, abstractmethod
-from typing import Any, Callable, List, Mapping, Optional, Sequence, Union
+from typing import Any, Callable, List, Optional, Sequence, Union
 
 import torch
 from torch.optim import Optimizer
@@ -20,7 +20,7 @@ class BaseOptimizerParamsHandler(BaseHandler):
     Base handler for logging optimizer parameters
     """
 
-    def __init__(self, optimizer: Optimizer, param_name: Optional[str] = "lr", tag: Optional[str] = None):
+    def __init__(self, optimizer: Optimizer, param_name: str = "lr", tag: Optional[str] = None):
         if not (
             isinstance(optimizer, Optimizer)
             or (hasattr(optimizer, "param_groups") and isinstance(optimizer.param_groups, Sequence))
@@ -107,7 +107,7 @@ class BaseWeightsScalarHandler(BaseHandler):
     Helper handler to log model's weights as scalars.
     """
 
-    def __init__(self, model: torch.nn.Module, reduction: Optional[Callable] = torch.norm, tag: Optional[str] = None):
+    def __init__(self, model: torch.nn.Module, reduction: Callable = torch.norm, tag: Optional[str] = None):
         if not isinstance(model, torch.nn.Module):
             raise TypeError("Argument model should be of type torch.nn.Module, " "but given {}".format(type(model)))
 
@@ -166,7 +166,7 @@ def attach(self, engine: Engine, log_handler: Callable, event_name: Any):
 
         return engine.add_event_handler(event_name, log_handler, self, name)
 
-    def attach_output_handler(self, engine: Engine, event_name: Any, *args: Any, **kwargs: Mapping):
+    def attach_output_handler(self, engine: Engine, event_name: Any, *args: Any, **kwargs: Any):
         """Shortcut method to attach `OutputHandler` to the logger.
 
         Args:
@@ -182,7 +182,7 @@ def attach_output_handler(self, engine: Engine, event_name: Any, *args: Any, **k
         """
         return self.attach(engine, self._create_output_handler(*args, **kwargs), event_name=event_name)
 
-    def attach_opt_params_handler(self, engine: Engine, event_name: Any, *args: Any, **kwargs: Mapping):
+    def attach_opt_params_handler(self, engine: Engine, event_name: Any, *args: Any, **kwargs: Any):
         """Shortcut method to attach `OptimizerParamsHandler` to the logger.
 
         Args:
@@ -199,11 +199,11 @@ def attach_opt_params_handler(self, engine: Engine, event_name: Any, *args: Any,
         self.attach(engine, self._create_opt_params_handler(*args, **kwargs), event_name=event_name)
 
     @abstractmethod
-    def _create_output_handler(self, engine, *args: Any, **kwargs: Mapping):
+    def _create_output_handler(self, engine, *args: Any, **kwargs: Any):
         pass
 
     @abstractmethod
-    def _create_opt_params_handler(self, *args: Any, **kwargs: Mapping):
+    def _create_opt_params_handler(self, *args: Any, **kwargs: Any):
         pass
 
     def __enter__(self):

ignite/contrib/handlers/lr_finder.py

@@ -186,7 +186,7 @@ def get_results(self):
         """
         return self._history
 
-    def plot(self, skip_start: Optional[int] = 10, skip_end: Optional[int] = 5, log_lr: Optional[bool] = True):
+    def plot(self, skip_start: int = 10, skip_end: int = 5, log_lr: bool = True):
         """Plots the learning rate range test.
 
         This method requires `matplotlib` package to be installed:
@@ -255,12 +255,12 @@ def attach(
         self,
         trainer: Engine,
         to_save: Dict[str, Any],
-        output_transform: Optional[Callable] = lambda output: output,
+        output_transform: Callable = lambda output: output,
         num_iter: Optional[int] = None,
-        end_lr: Optional[float] = 10.0,
-        step_mode: Optional[str] = "exp",
-        smooth_f: Optional[float] = 0.05,
-        diverge_th: Optional[float] = 5.0,
+        end_lr: float = 10.0,
+        step_mode: str = "exp",
+        smooth_f: float = 0.05,
+        diverge_th: float = 5.0,
     ):
         """Attaches lr_finder to a given trainer. It also resets model and optimizer at the end of the run.
 
@@ -372,7 +372,7 @@ class _ExponentialLR(_LRScheduler):
 
     """
 
-    def __init__(self, optimizer: Optimizer, end_lr: float, num_iter: int, last_epoch: Optional[int] = -1):
+    def __init__(self, optimizer: Optimizer, end_lr: float, num_iter: int, last_epoch: int = -1):
         self.end_lr = end_lr
         self.num_iter = num_iter
         super(_ExponentialLR, self).__init__(optimizer, last_epoch)

ignite/contrib/handlers/mlflow_logger.py

@@ -1,6 +1,6 @@
 import numbers
 import warnings
-from typing import Any, Callable, List, Mapping, Optional, Union
+from typing import Any, Callable, List, Optional, Union
 
 import torch
 from torch.optim import Optimizer
@@ -113,10 +113,10 @@ def close(self):
 
         mlflow.end_run()
 
-    def _create_output_handler(self, *args: Any, **kwargs: Mapping):
+    def _create_output_handler(self, *args: Any, **kwargs: Any):
         return OutputHandler(*args, **kwargs)
 
-    def _create_opt_params_handler(self, *args: Any, **kwargs: Mapping):
+    def _create_opt_params_handler(self, *args: Any, **kwargs: Any):
         return OptimizerParamsHandler(*args, **kwargs)
 
 
@@ -290,7 +290,7 @@ class OptimizerParamsHandler(BaseOptimizerParamsHandler):
         tag (str, optional): common title for all produced plots. For example, 'generator'
     """
 
-    def __init__(self, optimizer: Optimizer, param_name: Optional[str] = "lr", tag: Optional[str] = None):
+    def __init__(self, optimizer: Optimizer, param_name: str = "lr", tag: Optional[str] = None):
         super(OptimizerParamsHandler, self).__init__(optimizer, param_name, tag)
 
     def __call__(self, engine: Engine, logger: MLflowLogger, event_name):