| """ | |
| Inspired by https://github.com/jonathf/chaospy/blob/master/chaospy/ | |
| distributions/sampler/sequences/halton.py | |
| """ | |
| import numpy as np | |
| from sklearn.utils import check_random_state | |
| from ..space import Space | |
| from .base import InitialPointGenerator | |
| class Halton(InitialPointGenerator): | |
| """Creates `Halton` sequence samples. | |
| In statistics, Halton sequences are sequences used to generate | |
| points in space for numerical methods such as Monte Carlo simulations. | |
| Although these sequences are deterministic, they are of low discrepancy, | |
| that is, appear to be random | |
| for many purposes. They were first introduced in 1960 and are an example | |
| of a quasi-random number sequence. They generalise the one-dimensional | |
| van der Corput sequences. | |
| For ``dim == 1`` the sequence falls back to Van Der Corput sequence. | |
| Parameters | |
| ---------- | |
| min_skip : int | |
| Minimum skipped seed number. When `min_skip != max_skip` | |
| a random number is picked. | |
| max_skip : int | |
| Maximum skipped seed number. When `min_skip != max_skip` | |
| a random number is picked. | |
| primes : tuple, default=None | |
| The (non-)prime base to calculate values along each axis. If | |
| empty or None, growing prime values starting from 2 will be used. | |
| """ | |
| def __init__(self, min_skip=0, max_skip=0, primes=None): | |
| self.primes = primes | |
| self.min_skip = min_skip | |
| self.max_skip = max_skip | |
| def generate(self, dimensions, n_samples, random_state=None): | |
| """Creates samples from Halton set. | |
| Parameters | |
| ---------- | |
| dimensions : list, shape (n_dims,) | |
| List of search space dimensions. | |
| Each search dimension can be defined either as | |
| - a `(lower_bound, upper_bound)` tuple (for `Real` or `Integer` | |
| dimensions), | |
| - a `(lower_bound, upper_bound, "prior")` tuple (for `Real` | |
| dimensions), | |
| - as a list of categories (for `Categorical` dimensions), or | |
| - an instance of a `Dimension` object (`Real`, `Integer` or | |
| `Categorical`). | |
| n_samples : int | |
| The order of the Halton sequence. Defines the number of samples. | |
| random_state : int, RandomState instance, or None (default) | |
| Set random state to something other than None for reproducible | |
| results. | |
| Returns | |
| ------- | |
| np.array, shape=(n_dim, n_samples) | |
| Halton set. | |
| """ | |
| rng = check_random_state(random_state) | |
| if self.primes is None: | |
| primes = [] | |
| else: | |
| primes = list(self.primes) | |
| space = Space(dimensions) | |
| n_dim = space.n_dims | |
| transformer = space.get_transformer() | |
| space.set_transformer("normalize") | |
| if len(primes) < n_dim: | |
| prime_order = 10 * n_dim | |
| while len(primes) < n_dim: | |
| primes = _create_primes(prime_order) | |
| prime_order *= 2 | |
| primes = primes[:n_dim] | |
| assert len(primes) == n_dim, "not enough primes" | |
| if self.min_skip == self.max_skip: | |
| skip = self.min_skip | |
| elif self.min_skip < 0 and self.max_skip < 0: | |
| skip = max(primes) | |
| elif self.min_skip < 0 or self.max_skip < 0: | |
| skip = np.max(self.min_skip, self.max_skip) | |
| else: | |
| skip = rng.randint(self.min_skip, self.max_skip) | |
| out = np.empty((n_dim, n_samples)) | |
| indices = [idx + skip for idx in range(n_samples)] | |
| for dim_ in range(n_dim): | |
| out[dim_] = _van_der_corput_samples(indices, number_base=primes[dim_]) | |
| out = space.inverse_transform(np.transpose(out)) | |
| space.set_transformer(transformer) | |
| return out | |
| def _van_der_corput_samples(idx, number_base=2): | |
| """Create `Van Der Corput` low discrepancy sequence samples. | |
| A van der Corput sequence is an example of the simplest one-dimensional | |
| low-discrepancy sequence over the unit interval; it was first described in | |
| 1935 by the Dutch mathematician J. G. van der Corput. It is constructed by | |
| reversing the base-n representation of the sequence of natural numbers | |
| (1, 2, 3, ...). | |
| In practice, use Halton sequence instead of Van Der Corput, as it is the | |
| same, but generalized to work in multiple dimensions. | |
| Parameters | |
| ---------- | |
| idx (int, numpy.ndarray): | |
| The index of the sequence. If array is provided, all values in | |
| array is returned. | |
| number_base : int | |
| The numerical base from where to create the samples from. | |
| Returns | |
| ------- | |
| float, numpy.ndarray | |
| Van der Corput samples. | |
| """ | |
| assert number_base > 1 | |
| idx = np.asarray(idx).flatten() | |
| out = np.zeros(len(idx), dtype=float) | |
| base = float(number_base) | |
| active = np.ones(len(idx), dtype=bool) | |
| while np.any(active): | |
| out[active] += (idx[active] % number_base) / base | |
| idx //= number_base | |
| base *= number_base | |
| active = idx > 0 | |
| return out | |
| def _create_primes(threshold): | |
| """Generate prime values using sieve of Eratosthenes method. | |
| Parameters | |
| ---------- | |
| threshold : int | |
| The upper bound for the size of the prime values. | |
| Returns | |
| ------ | |
| List | |
| All primes from 2 and up to ``threshold``. | |
| """ | |
| if threshold == 2: | |
| return [2] | |
| elif threshold < 2: | |
| return [] | |
| numbers = list(range(3, threshold + 1, 2)) | |
| root_of_threshold = threshold**0.5 | |
| half = int((threshold + 1) / 2 - 1) | |
| idx = 0 | |
| counter = 3 | |
| while counter <= root_of_threshold: | |
| if numbers[idx]: | |
| idy = int((counter * counter - 3) / 2) | |
| numbers[idy] = 0 | |
| while idy < half: | |
| numbers[idy] = 0 | |
| idy += counter | |
| idx += 1 | |
| counter = 2 * idx + 3 | |
| return [2] + [number for number in numbers if number] | |