rename M to mapper

segasai · segasai · commit 844bccd1ab50 · 2025-04-23T22:34:17.000+01:00
remove old_stopping_function
diff --git a/py/dynesty/dynamicsampler.py b/py/dynesty/dynamicsampler.py
@@ -204,7 +204,7 @@ def _get_update_interval_ratio(update_interval, sample, bound, ndim, nlive,
 def stopping_function(results,
                       args=None,
                       rstate=None,
-                      M=None,
+                      mapper=None,
                       return_vals=False):
     """
     The default stopping function utilized by :class:`DynamicSampler`.
@@ -245,7 +245,7 @@ def stopping_function(results,
     rstate : `~numpy.random.Generator`, optional
         `~numpy.random.Generator` instance.
 
-    M : `map` function, optional
+    mapper : `map` function, optional
         An alias to a `map`-like function. This allows users to pass
         functions from pools (e.g., `pool.map`) to compute realizations in
         parallel. By default the standard `map` function is used.
@@ -269,8 +269,8 @@ def stopping_function(results,
     # Initialize values.
     if args is None:
         args = {}
-    if M is None:
-        M = map
+    if mapper is None:
+        mapper = map
 
     # Initialize hyperparameters.
     pfrac = args.get('pfrac', 1.0)
@@ -307,7 +307,7 @@ def stopping_function(results,
         approx_list = [approx for i in range(n_mc)]
         seeds = get_seed_sequence(rstate, n_mc)
         args = zip(rlist, error_list, approx_list, seeds)
-        outputs = list(M(_kld_error, args))
+        outputs = list(mapper(_kld_error, args))
         lnz_arr = np.array([res[1].logz[-1] for res in outputs])
         # Evidence stopping value.
         lnz_std = np.std(lnz_arr)
@@ -645,7 +645,7 @@ def _configure_batch_sampler(main_sampler,
              None,
              main_sampler.prior_transform,
              main_sampler.loglikelihood,
-             main_sampler.M,
+             main_sampler.mapper,
              nlive=nlive_new,
              ndim=main_sampler.ndim,
              rstate=main_sampler.rstate,
@@ -938,9 +938,9 @@ def __init__(self, loglikelihood, prior_transform, ndim, bound, method,
         self.queue_size = queue_size
         self.pool = pool
         if self.pool is None:
-            self.M = map
+            self.mapper = map
         else:
-            self.M = pool.map
+            self.mapper = pool.map
 
         self.use_pool = use_pool  # provided flags for when to use the pool
         self.use_pool_ptform = use_pool.get('prior_transform', True)
@@ -983,7 +983,7 @@ def __init__(self, loglikelihood, prior_transform, ndim, bound, method,
     def __setstate__(self, state):
         self.__dict__ = state
         self.pool = None
-        self.M = map
+        self.mapper = map
 
     def __getstate__(self):
         """Get state information for pickling."""
@@ -992,7 +992,7 @@ def __getstate__(self):
 
         # deal with pool
         del state['pool']  # remove pool
-        del state['M']  # remove `pool.map` function hook
+        del state['mapper']  # remove `pool.map` function hook
 
         return state
 
@@ -1264,7 +1264,7 @@ def sample_initial(self,
                  live_points,
                  self.prior_transform,
                  self.loglikelihood,
-                 self.M,
+                 self.mapper,
                  nlive=nlive,
                  ndim=self.ndim,
                  rstate=self.rstate,
@@ -2041,13 +2041,13 @@ def run_nested(self,
                 miter = min(maxiter - niter, maxiter_batch)
                 if mcall > 0 and miter > 0 and use_stop:
                     if self.use_pool_stopfn:
-                        M = self.M
+                        mapper = self.mapper
                     else:
-                        M = map
+                        mapper = map
                     stop, stop_vals = stop_function(res,
                                                     stop_kwargs,
                                                     rstate=self.rstate,
-                                                    M=M,
+                                                    mapper=mapper,
                                                     return_vals=True)
                     stop_val = stop_vals[2]
                 else:
diff --git a/py/dynesty/sampler.py b/py/dynesty/sampler.py
@@ -157,9 +157,9 @@ def __init__(self,
         # parallelism
         self.pool = pool  # provided pool
         if self.pool is None:
-            self.M = map
+            self.mapper = map
         else:
-            self.M = pool.map
+            self.mapper = pool.map
         self.use_pool = use_pool or {
         }  # provided flags for when to use the pool
         self.use_pool_ptform = use_pool.get('prior_transform', True)
@@ -318,13 +318,13 @@ def update_bound(self, subset=slice(None)):
     def __setstate__(self, state):
         self.__dict__ = state
         self.pool = None
-        self.M = map
+        self.mapper = map
 
     def __getstate__(self):
         """Get state information for pickling."""
 
         state = self.__dict__.copy()
-        for k in ['M', 'pool']:
+        for k in ['mapper', 'pool']:
             if k in state:
                 del state[k]
         return state
@@ -337,7 +337,8 @@ def reset(self):
         if self.use_pool_ptform:
             # Use the pool to compute the prior transform.
             self.live_v = np.array(
-                list(self.M(self.prior_transform, np.asarray(self.live_u))))
+                list(self.mapper(self.prior_transform,
+                                 np.asarray(self.live_u))))
         else:
             # Compute the prior transform using the default `map` function.
             self.live_v = np.array(
@@ -502,7 +503,7 @@ def _fill_queue(self, loglstar):
 
         if self.use_pool_evolve:
             # Use the pool to propose ("evolve") a new live point.
-            mapper = self.M
+            mapper = self.mapper
         else:
             # Propose ("evolve") a new live point using the default `map`
             # function.
diff --git a/py/dynesty/utils.py b/py/dynesty/utils.py
@@ -2125,121 +2125,6 @@ def _kld_error(args):
                      approx=approx)
 
 
-def old_stopping_function(results,
-                          args=None,
-                          rstate=None,
-                          M=None,
-                          return_vals=False):
-    """
-    The old stopping function utilized by :class:`DynamicSampler`.
-    Zipped parameters are passed to the function via :data:`args`.
-    Assigns the run a stopping value based on a weighted average of the
-    stopping values for the posterior and evidence::
-        stop = pfrac * stop_post + (1.- pfrac) * stop_evid
-    The evidence stopping value is based on the estimated evidence error
-    (i.e. standard deviation) relative to a given threshold::
-        stop_evid = evid_std / evid_thresh
-    The posterior stopping value is based on the fractional error (i.e.
-    standard deviation / mean) in the Kullback-Leibler (KL) divergence
-    relative to a given threshold::
-        stop_post = (kld_std / kld_mean) / post_thresh
-    Estimates of the mean and standard deviation are computed using `n_mc`
-    realizations of the input using a provided `'error'` keyword (either
-    `'jitter'` or `'resample'`).
-    Returns the boolean `stop <= 1`. If `True`, the :class:`DynamicSampler`
-    will stop adding new samples to our results.
-    Parameters
-    ----------
-    results : :class:`Results` instance
-        :class:`Results` instance.
-    args : dictionary of keyword arguments, optional
-        Arguments used to set the stopping values. Default values are
-        `pfrac = 1.0`, `evid_thresh = 0.1`, `post_thresh = 0.02`,
-        `n_mc = 128`, `error = 'jitter'`, and `approx = True`.
-    rstate : `~numpy.random.Generator`, optional
-        `~numpy.random.Generator` instance.
-    M : `map` function, optional
-        An alias to a `map`-like function. This allows users to pass
-        functions from pools (e.g., `pool.map`) to compute realizations in
-        parallel. By default the standard `map` function is used.
-    return_vals : bool, optional
-        Whether to return the stopping value (and its components). Default
-        is `False`.
-    Returns
-    -------
-    stop_flag : bool
-        Boolean flag indicating whether we have passed the desired stopping
-        criteria.
-    stop_vals : tuple of shape (3,), optional
-        The individual stopping values `(stop_post, stop_evid, stop)` used
-        to determine the stopping criteria.
-    """
-
-    with warnings.catch_warnings():
-        warnings.filterwarnings("once")
-        warnings.warn(
-            "This an old stopping function that will "
-            "be removed in future releases", DeprecationWarning)
-    # Initialize values.
-    if args is None:
-        args = {}
-    if M is None:
-        M = map
-
-    # Initialize hyperparameters.
-    pfrac = args.get('pfrac', 1.0)
-    if not 0. <= pfrac <= 1.:
-        raise ValueError(
-            f"The provided `pfrac` {pfrac} is not between 0. and 1.")
-    evid_thresh = args.get('evid_thresh', 0.1)
-    if pfrac < 1. and evid_thresh < 0.:
-        raise ValueError(
-            f"The provided `evid_thresh` {evid_thresh} is not non-negative "
-            f"even though `pfrac` is {pfrac}.")
-    post_thresh = args.get('post_thresh', 0.02)
-    if pfrac > 0. and post_thresh < 0.:
-        raise ValueError(
-            f"The provided `post_thresh` {post_thresh} is not non-negative "
-            f"even though `pfrac` is {pfrac}.")
-    n_mc = args.get('n_mc', 128)
-    if n_mc <= 1:
-        raise ValueError(f"The number of realizations {n_mc} must be greater "
-                         "than 1.")
-    if n_mc < 20:
-        warnings.warn("Using a small number of realizations might result in "
-                      "excessively noisy stopping value estimates.")
-    error = args.get('error', 'jitter')
-    if error not in {'jitter', 'resample'}:
-        raise ValueError(f"The chosen `'error'` option {error} is not valid.")
-    approx = args.get('approx', True)
-
-    # Compute realizations of ln(evidence) and the KL divergence.
-    rlist = [results for i in range(n_mc)]
-    error_list = [error for i in range(n_mc)]
-    approx_list = [approx for i in range(n_mc)]
-    seeds = get_seed_sequence(rstate, n_mc)
-    args = zip(rlist, error_list, approx_list, seeds)
-    outputs = list(M(_kld_error, args))
-    kld_arr, lnz_arr = np.array([(kld[-1], res.logz[-1])
-                                 for kld, res in outputs]).T
-
-    # Evidence stopping value.
-    lnz_std = np.std(lnz_arr)
-    stop_evid = lnz_std / evid_thresh
-
-    # Posterior stopping value.
-    kld_mean, kld_std = np.mean(kld_arr), np.std(kld_arr)
-    stop_post = (kld_std / kld_mean) / post_thresh
-
-    # Effective stopping value.
-    stop = pfrac * stop_post + (1. - pfrac) * stop_evid
-
-    if return_vals:
-        return stop <= 1., (stop_post, stop_evid, stop)
-    else:
-        return stop <= 1.
-
-
 def restore_sampler(fname, pool=None):
     """
     Restore the dynamic sampler from a file.
@@ -2293,7 +2178,7 @@ def restore_sampler(fname, pool=None):
         samplers = [sampler]
 
     for cursamp in samplers:
-        cursamp.M = mapper
+        cursamp.mapper = mapper
         cursamp.pool = pool
         cursamp.loglikelihood.pool = pool
     return sampler
diff --git a/tests/test_misc.py b/tests/test_misc.py
@@ -277,23 +277,6 @@ def test_neff():
     assert sampler.n_effective > 10000
 
 
-def test_oldstop():
-    # test of old stopping function functionality
-    ndim = 2
-    rstate = get_rstate()
-    import dynesty.utils as dyutil
-    stopfn = dyutil.old_stopping_function
-    sampler = dynesty.DynamicNestedSampler(loglike,
-                                           prior_transform,
-                                           ndim,
-                                           nlive=nlive,
-                                           rstate=rstate)
-    sampler.run_nested(dlogz_init=1,
-                       n_effective=None,
-                       stop_function=stopfn,
-                       print_progress=printing)
-
-
 def test_stop_nmc():
     # test stopping relying in n_mc
     ndim = 2
