quantecarlo 0.1.2__tar.gz → 0.2.0__tar.gz

quantecarlo-0.2.0/PKG-INFO

@@ -0,0 +1,163 @@
+Metadata-Version: 2.4
+Name: quantecarlo
+Version: 0.2.0
+Summary: Batch Bayesian optimization sampler (q-EI) for Optuna, backed by a remote GP service
+License-Expression: MIT
+Project-URL: Homepage, https://quantecarlo.com
+Classifier: Programming Language :: Python :: 3
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: optuna>=3.0
+Requires-Dist: numpy>=1.24
+Requires-Dist: scipy>=1.10
+
+# quantecarlo
+
+Batch Bayesian optimization for [Optuna](https://optuna.org) using **q-Expected Improvement (q-EI)**. Two drop-in `suggest_fn` implementations for the optunahub [`BatchSampler`](https://hub.optuna.org/samplers/batch_sampler/):
+
+| Function | Description |
+|---|---|
+| `fantasize_suggest` | Self-contained in-process GP (numpy/scipy). No server required. |
+| `modal_suggest` | Delegates to a hosted GPU GP endpoint (Modal). Higher quality, requires deployment. |
+
+---
+
+## Quickstart
+
+```bash
+pip install quantecarlo
+pip install optunahub
+```
+
+### In-process GP — no server required
+
+```python
+import optuna
+import optunahub
+from functools import partial
+from quantecarlo import DimSpec, fantasize_suggest
+
+search_space = [
+    DimSpec(name="x", type="float", low=-5.0, high=5.0),
+    DimSpec(name="y", type="float", low=-5.0, high=5.0),
+]
+
+module = optunahub.load_module("package/samplers/batch_sampler")
+BatchSampler = module.BatchSampler
+
+sampler = BatchSampler(
+    search_space=search_space,
+    suggest_fn=partial(fantasize_suggest, direction="minimize"),
+    q=4,
+    n_startup_trials=8,
+)
+
+def objective(trial):
+    x = trial.suggest_float("x", -5.0, 5.0)
+    y = trial.suggest_float("y", -5.0, 5.0)
+    return (x - 1.3) ** 2 + (y + 0.7) ** 2
+
+study = optuna.create_study(direction="minimize", sampler=sampler)
+study.optimize(objective, n_trials=40)
+print(study.best_params)
+```
+
+### Remote GP — Modal endpoint
+
+```python
+from quantecarlo import DimSpec, modal_suggest
+
+sampler = BatchSampler(
+    search_space=search_space,
+    suggest_fn=partial(modal_suggest, direction="minimize",
+                       api_url="https://markshipman4273--bo-gp-service-gp-suggest.modal.run"),
+    q=4,
+    n_startup_trials=8,
+)
+```
+
+### Why ask-tell instead of `study.optimize`?
+
+The ask-tell loop makes batching explicit and correct. With `study.optimize(n_jobs=q)`, each worker calls the sampler independently — no worker knows what the other `q-1` workers are about to try. Suggestions cluster.
+
+The ask-tell pattern fixes this: all `q` asks happen before any evaluation. The first ask fires one API call that selects `q` jointly diverse candidates; asks 2 through `q` pop from a local cache. This is what makes joint q-EI meaningful in practice.
+
+```python
+from concurrent.futures import ThreadPoolExecutor
+
+with ThreadPoolExecutor(max_workers=Q) as executor:
+    for _ in range(N_ITERATIONS):
+        trials = [study.ask() for _ in range(Q)]          # fills cache on ask #1
+        futures = {executor.submit(objective, t): t for t in trials}
+        for future, trial in futures.items():
+            study.tell(trial, future.result())
+```
+
+See `demos/demo.py` for the full working example.
+
+---
+
+## Reference
+
+### `DimSpec`
+
+Describes one dimension of the search space.
+
+| Field  | Type                  | Description |
+|--------|-----------------------|-------------|
+| `name` | `str`                 | Must match the `suggest_*` call in your objective. |
+| `type` | `"float"` \| `"int"` | Continuous float or integer (snapped on decode). |
+| `low`  | `float`               | Lower bound (inclusive). |
+| `high` | `float`               | Upper bound (inclusive). |
+| `log`  | `bool`                | Log-uniform sampling. Default `False`. |
+| `step` | `float \| None`       | Grid step for `int` dims. Default `1`. |
+
+### `modal_suggest`
+
+```python
+modal_suggest(X, y, search_space, q, *, direction="minimize", api_url, n_candidates=512,
+              train_steps=60, lr=0.1, xi=0.01, mode="production", seed=None, timeout=120.0)
+```
+
+Sends `X`, `y`, and a random candidate pool to the Modal GP endpoint; returns the highest q-EI batch. Bind parameters with `functools.partial` before passing to `BatchSampler`.
+
+| Parameter      | Default          | Description |
+|----------------|------------------|-------------|
+| `direction`    | `"minimize"`     | Must match the Optuna study direction. |
+| `api_url`      | *(hosted)*       | Modal GP endpoint URL. |
+| `n_candidates` | `512`            | Random candidates scored per call. |
+| `train_steps`  | `60`             | Adam steps for GP kernel optimisation. |
+| `lr`           | `0.1`            | Adam learning rate. |
+| `xi`           | `0.01`           | EI exploration bonus. |
+| `mode`         | `"production"`   | `"debug"` returns full posterior arrays. |
+| `seed`         | `None`           | Random seed for the candidate pool. |
+| `timeout`      | `120.0`          | HTTP timeout in seconds. |
+
+### `fantasize_suggest`
+
+```python
+fantasize_suggest(X, y, search_space, q, direction="minimize", n_candidates=512,
+                  noise=1e-3, xi=0.01, seed=None)
+```
+
+In-process RBF GP with sequential kriging (fantasization). Picks one candidate per GP fit, then fantasizes its outcome as the posterior mean before the next pick — so the batch spreads across the space without a remote call.
+
+| Parameter      | Default      | Description |
+|----------------|--------------|-------------|
+| `direction`    | `"minimize"` | Must match the Optuna study direction. |
+| `n_candidates` | `512`        | Random candidates evaluated per GP call. |
+| `noise`        | `1e-3`       | GP observation noise variance. |
+| `xi`           | `0.01`       | EI exploration bonus. |
+| `seed`         | `None`       | Random seed for the candidate pool. |
+
+---
+
+## Why q-EI instead of just adding more threads?
+
+Running `study.optimize(n_jobs=q)` with a standard sampler (TPE, random) parallelises evaluation but each worker samples **independently** — it has no visibility into what the other `q-1` workers are about to try. Candidates often cluster near the same local optimum.
+
+**q-EI scores the whole batch jointly.** It computes the expected improvement of the *best point in the batch* over the current best, accounting for the full joint posterior covariance across all `q` candidates. The algorithm naturally diversifies: a second candidate near an already-selected point contributes little to the joint maximum, so the batch spreads across promising but distinct regions.
+
+Each batch of `q` trials carries more information than `q` independently-drawn trials. You reach good solutions in fewer total evaluations — which matters when each evaluation is expensive (a training run, an experiment, a simulation).

quantecarlo-0.2.0/README.md

@@ -0,0 +1,148 @@
+# quantecarlo
+
+Batch Bayesian optimization for [Optuna](https://optuna.org) using **q-Expected Improvement (q-EI)**. Two drop-in `suggest_fn` implementations for the optunahub [`BatchSampler`](https://hub.optuna.org/samplers/batch_sampler/):
+
+| Function | Description |
+|---|---|
+| `fantasize_suggest` | Self-contained in-process GP (numpy/scipy). No server required. |
+| `modal_suggest` | Delegates to a hosted GPU GP endpoint (Modal). Higher quality, requires deployment. |
+
+---
+
+## Quickstart
+
+```bash
+pip install quantecarlo
+pip install optunahub
+```
+
+### In-process GP — no server required
+
+```python
+import optuna
+import optunahub
+from functools import partial
+from quantecarlo import DimSpec, fantasize_suggest
+
+search_space = [
+    DimSpec(name="x", type="float", low=-5.0, high=5.0),
+    DimSpec(name="y", type="float", low=-5.0, high=5.0),
+]
+
+module = optunahub.load_module("package/samplers/batch_sampler")
+BatchSampler = module.BatchSampler
+
+sampler = BatchSampler(
+    search_space=search_space,
+    suggest_fn=partial(fantasize_suggest, direction="minimize"),
+    q=4,
+    n_startup_trials=8,
+)
+
+def objective(trial):
+    x = trial.suggest_float("x", -5.0, 5.0)
+    y = trial.suggest_float("y", -5.0, 5.0)
+    return (x - 1.3) ** 2 + (y + 0.7) ** 2
+
+study = optuna.create_study(direction="minimize", sampler=sampler)
+study.optimize(objective, n_trials=40)
+print(study.best_params)
+```
+
+### Remote GP — Modal endpoint
+
+```python
+from quantecarlo import DimSpec, modal_suggest
+
+sampler = BatchSampler(
+    search_space=search_space,
+    suggest_fn=partial(modal_suggest, direction="minimize",
+                       api_url="https://markshipman4273--bo-gp-service-gp-suggest.modal.run"),
+    q=4,
+    n_startup_trials=8,
+)
+```
+
+### Why ask-tell instead of `study.optimize`?
+
+The ask-tell loop makes batching explicit and correct. With `study.optimize(n_jobs=q)`, each worker calls the sampler independently — no worker knows what the other `q-1` workers are about to try. Suggestions cluster.
+
+The ask-tell pattern fixes this: all `q` asks happen before any evaluation. The first ask fires one API call that selects `q` jointly diverse candidates; asks 2 through `q` pop from a local cache. This is what makes joint q-EI meaningful in practice.
+
+```python
+from concurrent.futures import ThreadPoolExecutor
+
+with ThreadPoolExecutor(max_workers=Q) as executor:
+    for _ in range(N_ITERATIONS):
+        trials = [study.ask() for _ in range(Q)]          # fills cache on ask #1
+        futures = {executor.submit(objective, t): t for t in trials}
+        for future, trial in futures.items():
+            study.tell(trial, future.result())
+```
+
+See `demos/demo.py` for the full working example.
+
+---
+
+## Reference
+
+### `DimSpec`
+
+Describes one dimension of the search space.
+
+| Field  | Type                  | Description |
+|--------|-----------------------|-------------|
+| `name` | `str`                 | Must match the `suggest_*` call in your objective. |
+| `type` | `"float"` \| `"int"` | Continuous float or integer (snapped on decode). |
+| `low`  | `float`               | Lower bound (inclusive). |
+| `high` | `float`               | Upper bound (inclusive). |
+| `log`  | `bool`                | Log-uniform sampling. Default `False`. |
+| `step` | `float \| None`       | Grid step for `int` dims. Default `1`. |
+
+### `modal_suggest`
+
+```python
+modal_suggest(X, y, search_space, q, *, direction="minimize", api_url, n_candidates=512,
+              train_steps=60, lr=0.1, xi=0.01, mode="production", seed=None, timeout=120.0)
+```
+
+Sends `X`, `y`, and a random candidate pool to the Modal GP endpoint; returns the highest q-EI batch. Bind parameters with `functools.partial` before passing to `BatchSampler`.
+
+| Parameter      | Default          | Description |
+|----------------|------------------|-------------|
+| `direction`    | `"minimize"`     | Must match the Optuna study direction. |
+| `api_url`      | *(hosted)*       | Modal GP endpoint URL. |
+| `n_candidates` | `512`            | Random candidates scored per call. |
+| `train_steps`  | `60`             | Adam steps for GP kernel optimisation. |
+| `lr`           | `0.1`            | Adam learning rate. |
+| `xi`           | `0.01`           | EI exploration bonus. |
+| `mode`         | `"production"`   | `"debug"` returns full posterior arrays. |
+| `seed`         | `None`           | Random seed for the candidate pool. |
+| `timeout`      | `120.0`          | HTTP timeout in seconds. |
+
+### `fantasize_suggest`
+
+```python
+fantasize_suggest(X, y, search_space, q, direction="minimize", n_candidates=512,
+                  noise=1e-3, xi=0.01, seed=None)
+```
+
+In-process RBF GP with sequential kriging (fantasization). Picks one candidate per GP fit, then fantasizes its outcome as the posterior mean before the next pick — so the batch spreads across the space without a remote call.
+
+| Parameter      | Default      | Description |
+|----------------|--------------|-------------|
+| `direction`    | `"minimize"` | Must match the Optuna study direction. |
+| `n_candidates` | `512`        | Random candidates evaluated per GP call. |
+| `noise`        | `1e-3`       | GP observation noise variance. |
+| `xi`           | `0.01`       | EI exploration bonus. |
+| `seed`         | `None`       | Random seed for the candidate pool. |
+
+---
+
+## Why q-EI instead of just adding more threads?
+
+Running `study.optimize(n_jobs=q)` with a standard sampler (TPE, random) parallelises evaluation but each worker samples **independently** — it has no visibility into what the other `q-1` workers are about to try. Candidates often cluster near the same local optimum.
+
+**q-EI scores the whole batch jointly.** It computes the expected improvement of the *best point in the batch* over the current best, accounting for the full joint posterior covariance across all `q` candidates. The algorithm naturally diversifies: a second candidate near an already-selected point contributes little to the joint maximum, so the batch spreads across promising but distinct regions.
+
+Each batch of `q` trials carries more information than `q` independently-drawn trials. You reach good solutions in fewer total evaluations — which matters when each evaluation is expensive (a training run, an experiment, a simulation).

{quantecarlo-0.1.2 → quantecarlo-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "quantecarlo"
-version = "0.1.2"
+version = "0.2.0"
 description = "Batch Bayesian optimization sampler (q-EI) for Optuna, backed by a remote GP service"
 readme = "README.md"
 requires-python = ">=3.10"

quantecarlo-0.2.0/quantecarlo/__init__.py

@@ -0,0 +1,11 @@
+from quantecarlo.bo_sampler import DimSpec, modal_suggest
+from quantecarlo._modal_api import call_modal_api, call_modal_api_multioutput
+from quantecarlo._fantasize import fantasize_suggest
+
+__all__ = [
+    "DimSpec",
+    "modal_suggest",
+    "call_modal_api",
+    "call_modal_api_multioutput",
+    "fantasize_suggest",
+]

{quantecarlo-0.1.2 → quantecarlo-0.2.0}/quantecarlo/_fantasize.py

@@ -17,6 +17,7 @@ def fantasize_suggest(
     y: list[float],
     search_space: list,
     q: int,
+    direction: str = "minimize",
     n_candidates: int = 512,
     noise: float = 1e-3,
     xi: float = 0.01,
@@ -34,11 +35,14 @@ def fantasize_suggest(
     X:
         Completed-trial parameter vectors, shape (n, d).
     y:
-        Raw objective values — lower is better (minimize convention).
+        Raw objective values. Pass in the same convention as the Optuna study
+        direction — lower is better for "minimize", higher is better for "maximize".
     search_space:
         DimSpec-like objects with .name, .type, .low, .high, .log, .step.
     q:
         Number of candidates to return.
+    direction:
+        "minimize" or "maximize" — must match the Optuna study direction.
     n_candidates:
         Random candidates evaluated per GP call.
     noise:
@@ -69,8 +73,10 @@ def fantasize_suggest(
     X_arr = np.array(X, dtype=float)
     X_unit = np.column_stack([_to_unit(X_arr[:, i], i) for i in range(d)])
 
-    # Standardise y for GP numerical stability
+    # GP always works higher-is-better internally; negate for minimize studies.
     y_arr = np.array(y, dtype=float)
+    if direction == "minimize":
+        y_arr = -y_arr
     y_std = y_arr.std()
     if y_std < 1e-8:
         y_std = 1.0
@@ -111,10 +117,10 @@ def fantasize_suggest(
         var = np.maximum(1.0 - np.sum(v ** 2, axis=0), 1e-9)
         sigma = np.sqrt(var)
 
-        # Expected Improvement (minimise)
-        best_y = y_aug.min()
-        z = (best_y - xi - mu) / sigma
-        ei = (best_y - xi - mu) * norm.cdf(z) + sigma * norm.pdf(z)
+        # Expected Improvement (maximise — y_aug is already higher-is-better)
+        best_y = y_aug.max()
+        z = (mu - best_y - xi) / sigma
+        ei = (mu - best_y - xi) * norm.cdf(z) + sigma * norm.pdf(z)
 
         idx = int(np.argmax(ei))
         best_unit = cands[idx]

quantecarlo-0.2.0/quantecarlo/_modal_api.py

@@ -0,0 +1,152 @@
+"""Raw HTTP client for the Modal GP endpoint.
+
+This is the single source of truth for the Modal API contract. Both
+modal_suggest (Optuna/BatchSampler integration) and direct callers such as
+meta-ads-demo import from here. When the API payload changes, update this
+file and every consumer gets the change.
+
+y convention: higher is better. Callers that use a minimise objective must
+negate y before calling these functions.
+"""
+from __future__ import annotations
+
+import json
+import logging
+import urllib.error
+import urllib.request
+from typing import Any
+
+import numpy as np
+
+logger = logging.getLogger(__name__)
+
+
+def _post(api_url: str, payload: dict, timeout: float) -> dict:
+    body = json.dumps(payload).encode("utf-8")
+    req = urllib.request.Request(
+        api_url,
+        data=body,
+        headers={"Content-Type": "application/json"},
+        method="POST",
+    )
+    try:
+        with urllib.request.urlopen(req, timeout=timeout) as resp:
+            return json.loads(resp.read().decode("utf-8"))
+    except urllib.error.HTTPError as exc:
+        detail = exc.read().decode("utf-8", errors="replace")
+        raise urllib.error.HTTPError(
+            exc.url, exc.code, f"{exc.reason} — {detail}", exc.headers, None
+        ) from None
+
+
+def call_modal_api(
+    api_url: str,
+    X: np.ndarray,
+    y: np.ndarray,
+    candidates: np.ndarray,
+    q: int = 2,
+    n_batches: int = 512,
+    train_steps: int = 100,
+    lr: float = 0.1,
+    xi: float = 0.01,
+    mode: str = "production",
+    timeout: float = 120.0,
+) -> list[dict[str, Any]]:
+    """POST to the Modal GP endpoint and return q candidate dicts.
+
+    y convention: higher is better. Pass scores directly for maximisation
+    objectives; negate first for minimisation.
+
+    X:          observed points, shape (n_obs, n_dims)
+    y:          observed scores, shape (n_obs,)
+    candidates: discrete candidate pool to select from, shape (n_cands, n_dims)
+
+    Each returned dict has:
+        "index"  — int, index into candidates
+        "x"      — np.ndarray shape (n_dims,), the selected candidate vector
+        "mu"     — float | None, GP posterior mean
+        "sigma"  — float | None, GP posterior std
+    """
+    payload: dict[str, Any] = {
+        "X": X.tolist(),
+        "y": y.tolist(),
+        "candidates": candidates.tolist(),
+        "q": q,
+        "n_batches": n_batches,
+        "train_steps": train_steps,
+        "lr": lr,
+        "xi": xi,
+        "mode": mode,
+    }
+    logger.debug(
+        "call_modal_api: POST %s (n_obs=%d, n_cands=%d, n_dims=%d, q=%d)",
+        api_url, len(y), len(candidates), candidates.shape[1], q,
+    )
+    data = _post(api_url, payload, timeout)
+    return [
+        {
+            "index": int(c["index"]),
+            "x": np.array(c["x"], dtype=np.float32),
+            "mu": c.get("mu"),
+            "sigma": c.get("sigma"),
+        }
+        for c in data["candidates"]
+    ]
+
+
+def call_modal_api_multioutput(
+    api_url: str,
+    X: np.ndarray,
+    y: np.ndarray,
+    candidates: np.ndarray,
+    d_train: np.ndarray,
+    d_cands: np.ndarray,
+    rho: float = 0.5,
+    q: int = 2,
+    n_batches: int = 512,
+    train_steps: int = 100,
+    lr: float = 0.1,
+    xi: float = 0.01,
+    mode: str = "production",
+    timeout: float = 120.0,
+) -> list[dict[str, Any]]:
+    """POST to the Modal GP multioutput endpoint and return q candidate dicts.
+
+    Identical to call_modal_api but additionally sends d_train, d_cands, and
+    rho. The server branches to the multioutput GP when d and d_candidates are
+    present in the payload.
+
+    d_train: int array shape (n_obs,)   — output index per training point (e.g. 0=Meta, 1=Google)
+    d_cands: int array shape (n_cands,) — output index per candidate
+    rho:     cross-platform correlation in (-1, 1)
+
+    Return format is identical to call_modal_api.
+    """
+    payload: dict[str, Any] = {
+        "X": X.tolist(),
+        "y": y.tolist(),
+        "candidates": candidates.tolist(),
+        "d": d_train.tolist(),
+        "d_candidates": d_cands.tolist(),
+        "rho": float(rho),
+        "q": q,
+        "n_batches": n_batches,
+        "train_steps": train_steps,
+        "lr": lr,
+        "xi": xi,
+        "mode": mode,
+    }
+    logger.debug(
+        "call_modal_api_multioutput: POST %s (n_obs=%d, n_cands=%d, n_dims=%d, q=%d, rho=%.2f)",
+        api_url, len(y), len(candidates), candidates.shape[1], q, rho,
+    )
+    data = _post(api_url, payload, timeout)
+    return [
+        {
+            "index": int(c["index"]),
+            "x": np.array(c["x"], dtype=np.float32),
+            "mu": c.get("mu"),
+            "sigma": c.get("sigma"),
+        }
+        for c in data["candidates"]
+    ]

quantecarlo-0.2.0/quantecarlo/bo_sampler.py

@@ -0,0 +1,92 @@
+# quantecarlo/bo_sampler.py
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+import numpy as np
+
+from quantecarlo._modal_api import call_modal_api
+
+
+@dataclass
+class DimSpec:
+    """Describes one dimension of the search space."""
+    name: str
+    type: str          # "float" | "int"
+    low: float
+    high: float
+    log: bool = False
+    step: float | None = None
+
+
+def modal_suggest(
+    X: list[list[float]],
+    y: list[float],
+    search_space: list[DimSpec],
+    q: int,
+    *,
+    direction: str = "minimize",
+    api_url: str = "https://markshipman4273--bo-gp-service-gp-suggest.modal.run",
+    n_candidates: int = 512,
+    train_steps: int = 60,
+    lr: float = 0.1,
+    xi: float = 0.01,
+    mode: str = "production",
+    seed: int | None = None,
+    timeout: float = 120.0,
+) -> list[dict[str, Any]]:
+    """suggest_fn for BatchSampler that delegates to a remote Modal GP endpoint.
+
+    direction: "minimize" or "maximize" — must match the Optuna study direction.
+    BatchSampler passes raw study values; this function converts to the Modal API's
+    higher-is-better convention internally.
+
+    Bind extra parameters with functools.partial before passing to BatchSampler:
+
+        from functools import partial
+        from quantecarlo import modal_suggest, DimSpec
+        suggest = partial(modal_suggest, direction="minimize", api_url="https://...", n_candidates=1024)
+        sampler = BatchSampler(search_space=dims, suggest_fn=suggest, q=4)
+    """
+    rng = np.random.default_rng(seed)
+    candidates = np.array(_sample_candidates(search_space, n_candidates, rng), dtype=np.float32)
+    # Modal API is higher-is-better; negate y for minimize studies.
+    y_send = np.array([-v for v in y] if direction == "minimize" else list(y), dtype=np.float32)
+    X_arr = np.array(X, dtype=np.float32)
+
+    raw = call_modal_api(
+        api_url, X_arr, y_send, candidates,
+        q=q, n_batches=n_candidates, train_steps=train_steps,
+        lr=lr, xi=xi, mode=mode, timeout=timeout,
+    )
+
+    results: list[dict[str, Any]] = []
+    for item in raw:
+        params: dict[str, Any] = {}
+        for i, dim in enumerate(search_space):
+            val = float(item["x"][i])
+            if dim.type == "int":
+                val = int(round(val))
+            params[dim.name] = val
+        results.append(params)
+    return results
+
+
+def _sample_candidates(
+    dims: list[DimSpec], n: int, rng: np.random.Generator
+) -> list[list[float]]:
+    candidates = []
+    for _ in range(n):
+        point = []
+        for dim in dims:
+            if dim.type == "float":
+                if dim.log:
+                    val = float(np.exp(rng.uniform(np.log(dim.low), np.log(dim.high))))
+                else:
+                    val = float(rng.uniform(dim.low, dim.high))
+            else:
+                val = float(rng.integers(int(dim.low), int(dim.high) + 1))
+            point.append(val)
+        candidates.append(point)
+    return candidates