class_docstr: EarlyStopping handler can be used to stop the training if no improvement after a given number of events.
  
  Args:
      patience: Number of events to wait if no improvement and then stop the training.
      score_function: It should be a function taking a single argument, an :class:`~ignite.engine.engine.Engine`
          object, and return a score `float`. An improvement is considered if the score is higher.
      trainer: Trainer engine to stop the run if no improvement.
      min_delta: A minimum increase in the score to qualify as an improvement,
          i.e. an increase of less than or equal to `min_delta`, will count as no improvement.
      cumulative_delta: It True, `min_delta` defines an increase since the last `patience` reset, otherwise,
          it defines an increase after the last event. Default value is False.
  
  Examples:
      .. code-block:: python
  
          from ignite.engine import Engine, Events
          from ignite.handlers import EarlyStopping
  
          def score_function(engine):
              val_loss = engine.state.metrics['nll']
              return -val_loss
  
          handler = EarlyStopping(patience=10, score_function=score_function, trainer=trainer)
          # Note: the handler is attached to an *Evaluator* (runs one epoch on validation dataset).
          evaluator.add_event_handler(Events.COMPLETED, handler)
code: def __init__(
      self,
      patience: int,
      score_function: Callable,
      trainer: Engine,
      min_delta: float = 0.0,
      cumulative_delta: bool = False,
  ):
      if not callable(score_function):
          raise TypeError(
              "Argument score_function should be a function."
          )
  
      if patience < 1:
          raise ValueError(
              "Argument patience should be positive integer."
          )
  
      if min_delta < 0.0:
          raise ValueError(
              "Argument min_delta should not be a negative number."
          )
  
      if not isinstance(trainer, Engine):
          raise TypeError(
              "Argument trainer should be an instance of Engine."
          )
  
      self.score_function = score_function
      self.patience = patience
      self.min_delta = min_delta
      self.cumulative_delta = cumulative_delta
      self.trainer = trainer
      self.counter = 0
      self.best_score: Optional[float] = None
      self.logger = setup_logger(
          __name__ + "." + self.__class__.__name__
      )
  
file_path: ignite/ignite/handlers/early_stopping.py
imports: from collections import OrderedDict
  from typing import Callable, cast, Mapping, Optional
  from ignite.base import Serializable
  from ignite.engine import Engine
  from ignite.utils import setup_logger
label_desc: Use image node_id 1 to create a new EarlyStopping object from inherited base classes: Serializable with example: obj = EarlyStopping(patience, score_function, trainer, min_delta, cumulative_delta)