Add convergence criteria

[teytaud]

Types of changes

• Docs change / refactoring / dependency upgrade
• Bug fix (non-breaking change which fixes an issue)
• New feature (non-breaking change which adds functionality)
• Breaking change (fix or feature that would cause existing functionality to change)

Motivation and Context / Related issue

User request

How Has This Been Tested (if it applies)

Checklist

• The documentation is up-to-date with the changes I made.
• I have read the CONTRIBUTING document and completed the CLA (see CLA).
• All tests passed, and additional code has been covered with new tests.

[jrapin]

It would be simpler / more tunable / more independent if we use callbacks

nevergrad/nevergrad/optimization/callbacks.py

Lines 307 to 359 in ac86807

	class EarlyStopping:
	"""Callback for stopping the :code:`minimize` method before the budget is
	fully used.
	Parameters
	----------
	stopping_criterion: func(optimizer) -> bool
	function that takes the current optimizer as input and returns True
	if the minimization must be stopped
	Note
	----
	This callback must be register on the "ask" method only.
	Example
	-------
	In the following code, the :code:`minimize` method will be stopped at the 4th "ask"
	>>> early_stopping = ng.callbacks.EarlyStopping(lambda opt: opt.num_ask > 3)
	>>> optimizer.register_callback("ask", early_stopping)
	>>> optimizer.minimize(_func, verbosity=2)
	A couple other options (equivalent in case of non-noisy optimization) for stopping
	if the loss is below 12:
	>>> early_stopping = ng.callbacks.EarlyStopping(lambda opt: opt.recommend().loss < 12)
	>>> early_stopping = ng.callbacks.EarlyStopping(lambda opt: opt.current_bests["minimum"].mean < 12)
	"""
	def __init__(self, stopping_criterion: tp.Callable[[base.Optimizer], bool]) -> None:
	self.stopping_criterion = stopping_criterion
	def __call__(self, optimizer: base.Optimizer, *args: tp.Any, **kwargs: tp.Any) -> None:
	if args or kwargs:
	raise errors.NevergradRuntimeError("EarlyStopping must be registered on ask method")
	if self.stopping_criterion(optimizer):
	raise errors.NevergradEarlyStopping("Early stopping criterion is reached")
	@classmethod
	def timer(cls, max_duration: float) -> "EarlyStopping":
	"""Early stop when max_duration seconds has been reached (from the first ask)"""
	return cls(_DurationCriterion(max_duration))
	class _DurationCriterion:
	def __init__(self, max_duration: float) -> None:
	self._start = float("inf")
	self._max_duration = max_duration
	def __call__(self, optimizer: base.Optimizer) -> bool:
	if np.isinf(self._start):
	self._start = time.time()
	return time.time() > self._start + self._max_duration