hone-python 0.9.0__py3-none-any.whl → 0.11.0__py3-none-any.whl

hone/__init__.py

@@ -10,7 +10,7 @@ from hone.optimizers import (
     UnsupportedSearchSpace,
     choose_optimizer,
 )
-from hone.parameters import ChoiceParameter, FixedParameter, RangeParameter, SearchSpace
+from hone.parameters import ChoiceParameter, Condition, Constraint, FixedParameter, InfeasibleSearchSpace, RangeParameter, SearchSpace
 from hone.result import GenerationStats, Progress, Result, RunInfo, print_progress
 
 __all__ = [
@@ -19,11 +19,14 @@ __all__ = [
     "CMAES",
     "CMAESConfig",
     "ChoiceParameter",
+    "Condition",
+    "Constraint",
     "EvaluationFailed",
     "FixedParameter",
     "GenerationStats",
     "GeneticOptimizer",
     "GeneticOptimizerConfig",
+    "InfeasibleSearchSpace",
     "Optimizer",
     "OptimizerConfig",
     "Progress",

hone/benchmarks/__init__.py

@@ -1,4 +1,6 @@
 """Benchmark problems and a runner for comparing optimizers. Run `python -m hone.benchmarks --help`."""
+from .conditional import conditional_problems
+from .constrained import constrained_problems
 from .ml import ml_problems
 from .problems import Problem, noisy_problems, quick_problems, standard_problems
 from .runner import (

hone/benchmarks/__main__.py

@@ -6,6 +6,8 @@ from collections.abc import Sequence
 from importlib.metadata import version
 
 from . import ml
+from .conditional import conditional_problems
+from .constrained import constrained_problems
 from .problems import noisy_problems, quick_problems, standard_problems
 from .runner import BUDGETS, load_summaries, regressions, run_benchmark, save_summaries, summarize, to_markdown
 
@@ -26,6 +28,10 @@ def main(argv: list[str] | None = None) -> int:
     suite.add_argument("--quick", action="store_true", help="run the small CI subset with fewer seeds and evaluations")
     suite.add_argument("--ml", action="store_true", help="run the machine learning tuning problems instead (needs scikit-learn)")
     suite.add_argument("--noisy", action="store_true", help="run the problems with noise added to every evaluation instead")
+    suite.add_argument("--constrained", action="store_true", help="run the problems with constraints instead")
+    suite.add_argument(
+        "--conditional", action="store_true", help="run the problems with conditional parameters, and their flat versions, instead"
+    )
     parser.add_argument("--seeds", type=int, help="number of seeds per problem (default 10, or 5 with --quick)")
     parser.add_argument(
         "--budgets",
@@ -49,6 +55,10 @@ def main(argv: list[str] | None = None) -> int:
         problems, default_budgets = ml.ml_problems(), ml.BUDGETS
     elif args.noisy:
         problems, default_budgets = noisy_problems(), NOISY_BUDGETS
+    elif args.constrained:
+        problems, default_budgets = constrained_problems(), BUDGETS
+    elif args.conditional:
+        problems, default_budgets = conditional_problems(), BUDGETS
     else:
         problems, default_budgets = standard_problems(), BUDGETS
     seeds = args.seeds or (5 if args.quick else 10)

hone/benchmarks/conditional.py

@@ -0,0 +1,109 @@
+"""Conditional test problems, each in two versions: with conditions, and with every parameter switched on.
+
+- branches-3x2d and branches-3x5d: a choice of three branches, each a function of its own
+  numbers. The best branch is a steep, narrow bowl reaching 0; the decoys are a wide, shallow
+  bowl whose floor is 1 and a shallow Rastrigin grid whose floor is 0.5. Random points score
+  better in the decoys, so an optimizer has to look past them.
+- nested-9: a choice of model; one model has a choice of kernel, and one kernel has numbers of
+  its own, so the best point is two conditions deep. The other model is a wide, shallow decoy
+  whose floor is 0.25.
+- layers-7: a layer count from 1 to 5 whose larger values switch on more numbers, as a
+  network's units per layer would be. Three layers is best. Its conditions test a range, so
+  CMA-ES can search it.
+
+The "-flat" version of each has the same parameters, function and optimum, with no conditions:
+every parameter is always on and the function ignores those it doesn't use, which was the way
+to search such a space before conditions. Comparing the two shows what conditions are worth.
+"""
+from typing import Any, Callable
+
+import numpy as np
+
+from hone.parameters import ChoiceParameter, Condition, Parameter, RangeParameter, SearchSpace
+
+from .problems import BOUND, Problem, _shift, rastrigin, sphere
+
+
+def _problem(name: str, function: Callable[..., float], parameters: list[Parameter], conditions: list[Condition]) -> list[Problem]:
+    function.__name__ = name.replace("-", "_")
+    return [
+        Problem(
+            name=name,
+            function=function,
+            search_space=SearchSpace(parameters, conditions=conditions),
+            optimum=0.0,
+            tags=frozenset({"conditional"}),
+        ),
+        Problem(
+            name=f"{name}-flat",
+            function=function,
+            search_space=SearchSpace(parameters),
+            optimum=0.0,
+            tags=frozenset({"conditional", "flat"}),
+        ),
+    ]
+
+
+def _numbers(prefix: str, count: int) -> list[RangeParameter]:
+    return [RangeParameter(f"{prefix}{i}", -BOUND, BOUND) for i in range(count)]
+
+
+def _vector(params: dict[str, Any], numbers: list[RangeParameter]) -> np.ndarray:
+    return np.array([params[p.name] for p in numbers], dtype=float)
+
+
+def branches(dimensions: int) -> list[Problem]:
+    name = f"branches-3x{dimensions}d"
+    branch = ChoiceParameter("branch", ["narrow", "wide", "grid"])
+    numbers = {b: _numbers(f"{b}_", dimensions) for b in branch.choices}
+    shifts = {b: _shift(f"{name}/{b}", dimensions) for b in branch.choices}
+    # (function, scale, floor) for each branch
+    bases = {"narrow": (sphere, 4.0, 0.0), "wide": (sphere, 0.05, 1.0), "grid": (rastrigin, 0.1, 0.5)}
+
+    def function(branch: str, **params: Any) -> float:
+        base, scale, floor = bases[branch]
+        return floor + scale * float(base(_vector(params, numbers[branch]) - shifts[branch]))
+
+    parameters: list[Parameter] = [branch, *(p for b in branch.choices for p in numbers[b])]
+    return _problem(name, function, parameters, [branch[b] >> numbers[b] for b in branch.choices])
+
+
+def nested() -> list[Problem]:
+    name = "nested-9"
+    model = ChoiceParameter("model", ["kernel_machine", "forest"])
+    kernel = ChoiceParameter("kernel", ["linear", "rbf"])
+    shared, width, forest = _numbers("s", 2), _numbers("g", 2), _numbers("f", 3)
+    centres = {key: _shift(f"{name}/{key}", len(group)) for key, group in [("s", shared), ("g", width), ("f", forest)]}
+
+    def function(model: str, kernel: str | None = None, **params: Any) -> float:
+        if model == "forest":
+            return 0.25 + 0.05 * float(sphere(_vector(params, forest) - centres["f"]))
+        value = float(sphere(_vector(params, shared) - centres["s"]))
+        if kernel == "linear":
+            return 0.5 + value
+        return value + 4 * float(sphere(_vector(params, width) - centres["g"]))
+
+    parameters: list[Parameter] = [model, kernel, *shared, *width, *forest]
+    conditions = [model["kernel_machine"] >> [kernel, *shared], kernel["rbf"] >> width, model["forest"] >> forest]
+    return _problem(name, function, parameters, conditions)
+
+
+def layers() -> list[Problem]:
+    name = "layers-7"
+    count = RangeParameter("layers", 1, 5, integer=True)
+    rate = RangeParameter("rate", -BOUND, BOUND)
+    units = _numbers("units_", 5)
+    centre = _shift(f"{name}/units", 5)
+    best_rate = float(_shift(f"{name}/rate", 1)[0])
+
+    def function(layers: int, rate: float, **params: Any) -> float:
+        used = units[:layers]
+        return 0.5 * abs(layers - 3) + float(sphere(_vector(params, used) - centre[:layers])) + (rate - best_rate) ** 2
+
+    parameters: list[Parameter] = [count, rate, *units]
+    return _problem(name, function, parameters, [(count >= i + 1) >> units[i] for i in range(1, 5)])
+
+
+def conditional_problems() -> list[Problem]:
+    """Each conditional problem, followed by its flat version."""
+    return [*branches(2), *branches(5), *nested(), *layers()]

hone/benchmarks/constrained.py

@@ -0,0 +1,172 @@
+"""Constrained test problems, whose optima lie on a constraint's boundary, as they usually do in engineering.
+
+- boundary-sphere and boundary-ellipsoid: a shifted sphere or ellipsoid with a linear constraint
+  that cuts off its unconstrained optimum, so the answer is on the cutting plane. Both optima are
+  known exactly.
+- rosenbrock-disk: Rosenbrock's function inside the disk x² + y² ≤ 2, whose optimum (1, 1) sits
+  on the disk's edge.
+- pressure-vessel, tension-spring and welded-beam: three standard engineering design problems,
+  scored against the best designs published for them. The welded beam's stress formulas need
+  square roots, so its constraints are functions; the others are expressions.
+"""
+import math
+import zlib
+from typing import Any
+
+import numpy as np
+
+from hone.parameters import Constraint, RangeParameter, SearchSpace
+
+from .problems import BOUND, Problem, _shift
+
+
+def _normal(name: str, dimensions: int) -> np.ndarray:
+    """A fixed unit vector for the named problem, with no component near zero."""
+    rng = np.random.default_rng(zlib.crc32(f"{name}/normal".encode()))
+    w = rng.uniform(0.3, 1.0, dimensions) * rng.choice([-1.0, 1.0], dimensions)
+    return w / np.linalg.norm(w)
+
+
+def _boundary(name: str, dimensions: int, weights: np.ndarray) -> Problem:
+    """Minimize sum(weights * (x - c)²) subject to w·x ≤ w·c - 1, which the unconstrained optimum c breaks.
+
+    The optimum is at c + z with z = -D⁻¹w / (wᵀD⁻¹w), where D is diag(weights), and its value is 1 / (wᵀD⁻¹w).
+    """
+    names = [f"x{i}" for i in range(dimensions)]
+    parameters = [RangeParameter(n, -BOUND, BOUND) for n in names]
+    centre, w = _shift(name, dimensions), _normal(name, dimensions)
+    limit = float(w @ centre) - 1.0
+    terms = [float(wi) * p for wi, p in zip(w, parameters)]
+    plane = terms[0]
+    for term in terms[1:]:
+        plane = plane + term
+    inverse = 1.0 / weights
+    best = centre - inverse * w / float(w @ (inverse * w))
+    assert np.all(np.abs(best) <= BOUND), f"{name}: the constrained optimum must lie inside the bounds"
+
+    def function(**params: Any) -> float:
+        x = np.array([params[n] for n in names], dtype=float)
+        return float(np.sum(weights * (x - centre) ** 2))
+
+    function.__name__ = name.replace("-", "_")
+    space = SearchSpace(parameters, [plane <= limit])
+    return Problem(name=name, function=function, search_space=space, optimum=1.0 / float(w @ (inverse * w)), tags=frozenset({"constrained"}))
+
+
+def boundary_sphere(dimensions: int) -> Problem:
+    return _boundary(f"boundary-sphere-{dimensions}d", dimensions, np.ones(dimensions))
+
+
+def boundary_ellipsoid(dimensions: int) -> Problem:
+    # Axis weights from 1 to 1,000: wide enough to need scaling, narrow enough to keep the optimum in bounds.
+    return _boundary(f"boundary-ellipsoid-{dimensions}d", dimensions, 10.0 ** (3 * np.arange(dimensions) / max(dimensions - 1, 1)))
+
+
+def rosenbrock_disk() -> Problem:
+    x, y = RangeParameter("x", -1.5, 1.5), RangeParameter("y", -1.5, 1.5)
+
+    def rosenbrock_disk(x: float, y: float) -> float:
+        return (1 - x) ** 2 + 100 * (y - x**2) ** 2
+
+    space = SearchSpace([x, y], [x**2 + y**2 <= 2])
+    return Problem(name="rosenbrock-disk-2d", function=rosenbrock_disk, search_space=space, optimum=0.0, tags=frozenset({"constrained"}))
+
+
+def pressure_vessel() -> Problem:
+    """A cylindrical vessel with hemispherical heads, at least 1,296,000 cubic inches, of least cost.
+
+    Shell and head thicknesses come in sixteenths of an inch, so they are integers here. The best
+    published design costs 6059.714 (Ts = 13/16, Th = 7/16, R = 42.098, L = 176.637).
+    """
+    shell, head = RangeParameter("shell", 1, 99, integer=True), RangeParameter("head", 1, 99, integer=True)
+    radius, length = RangeParameter("radius", 10, 200), RangeParameter("length", 10, 200)
+
+    def pressure_vessel(shell: int, head: int, radius: float, length: float) -> float:
+        ts, th = shell / 16, head / 16
+        return 0.6224 * ts * radius * length + 1.7781 * th * radius**2 + 3.1661 * ts**2 * length + 19.84 * ts**2 * radius
+
+    space = SearchSpace(
+        [shell, head, radius, length],
+        [
+            shell / 16 >= 0.0193 * radius,
+            head / 16 >= 0.00954 * radius,
+            math.pi * radius**2 * length + 4 / 3 * math.pi * radius**3 >= 1_296_000,
+        ],
+    )
+    return Problem(name="pressure-vessel", function=pressure_vessel, search_space=space, optimum=6059.714335, tags=frozenset({"constrained", "mixed", "engineering"}))
+
+
+def tension_spring() -> Problem:
+    """A coil spring of least weight under limits on deflection, shear stress, surge frequency and diameter.
+
+    The best published design weighs 0.0126652 (d = 0.051690, D = 0.356750, N = 11.287126).
+    """
+    d, coil, n = RangeParameter("wire", 0.05, 2.0), RangeParameter("coil", 0.25, 1.3), RangeParameter("turns", 2.0, 15.0)
+
+    def tension_spring(wire: float, coil: float, turns: float) -> float:
+        return (turns + 2) * coil * wire**2
+
+    space = SearchSpace(
+        [d, coil, n],
+        [
+            coil**3 * n / (71785 * d**4) >= 1,
+            (4 * coil**2 - d * coil) / (12566 * (coil * d**3 - d**4)) + 1 / (5108 * d**2) <= 1,
+            140.45 * d / (coil**2 * n) >= 1,
+            d + coil <= 1.5,
+        ],
+    )
+    return Problem(name="tension-spring", function=tension_spring, search_space=space, optimum=0.012665233, tags=frozenset({"constrained", "engineering"}))
+
+
+# The welded beam's load and material: load P (lb), length L (in), Young's and shear moduli (psi).
+P, L, E, G = 6000.0, 14.0, 30e6, 12e6
+
+
+def _shear(weld: float, length: float, thickness: float) -> float:
+    primary = P / (math.sqrt(2) * weld * length)
+    moment = P * (L + length / 2)
+    r = math.sqrt(length**2 / 4 + ((weld + thickness) / 2) ** 2)
+    j = 2 * math.sqrt(2) * weld * length * (length**2 / 12 + ((weld + thickness) / 2) ** 2)
+    secondary = moment * r / j
+    return math.sqrt(primary**2 + primary * secondary * length / r + secondary**2)
+
+
+def _buckling(thickness: float, width: float) -> float:
+    return 4.013 * E * math.sqrt(thickness**2 * width**6 / 36) / L**2 * (1 - thickness / (2 * L) * math.sqrt(E / (4 * G)))
+
+
+def welded_beam() -> Problem:
+    """A beam welded to a support, of least cost under limits on shear, bending, buckling and deflection.
+
+    The best published design costs 1.724852 (h = 0.205730, l = 3.470489, t = 9.036624, b = 0.205730).
+    """
+    weld, length = RangeParameter("weld", 0.1, 2.0), RangeParameter("length", 0.1, 10.0)
+    thickness, width = RangeParameter("thickness", 0.1, 10.0), RangeParameter("width", 0.1, 2.0)
+
+    def welded_beam(weld: float, length: float, thickness: float, width: float) -> float:
+        return 1.10471 * weld**2 * length + 0.04811 * thickness * width * (14 + length)
+
+    def shear(weld: float, length: float, thickness: float) -> float:
+        return _shear(weld, length, thickness) - 13600
+
+    def buckling(thickness: float, width: float) -> float:
+        return P - _buckling(thickness, width)
+
+    space = SearchSpace(
+        [weld, length, thickness, width],
+        [
+            Constraint.function(shear),
+            6 * P * L / (width * thickness**2) <= 30000,
+            weld <= width,
+            0.10471 * weld**2 + 0.04811 * thickness * width * (14 + length) <= 5,
+            4 * P * L**3 / (E * thickness**3 * width) <= 0.25,
+            Constraint.function(buckling),
+        ],
+    )
+    return Problem(name="welded-beam", function=welded_beam, search_space=space, optimum=1.724852, tags=frozenset({"constrained", "engineering"}))
+
+
+def constrained_problems(dimensions: tuple[int, ...] = (2, 5, 10)) -> list[Problem]:
+    """The constrained suite: boundary sphere and ellipsoid in each dimension, Rosenbrock in a disk, and three engineering designs."""
+    problems = [factory(d) for d in dimensions for factory in (boundary_sphere, boundary_ellipsoid)]
+    return problems + [rosenbrock_disk(), pressure_vessel(), tension_spring(), welded_beam()]

hone/benchmarks/ml.py

@@ -16,7 +16,7 @@ from typing import Callable
 
 from threadpoolctl import threadpool_limits
 
-from hone.parameters import ChoiceParameter, RangeParameter, SearchSpace
+from hone.parameters import ChoiceParameter, Condition, Parameter, RangeParameter, SearchSpace
 
 from .problems import Problem
 
@@ -92,11 +92,56 @@ def random_forest_wine(max_depth: int, min_samples_leaf: int, max_features: floa
     return _cross_validate(model, "wine", classification=True)
 
 
+def model_selection_breast_cancer(
+    model: str,
+    C: float | None = None,
+    gamma: float | None = None,
+    max_depth: int | None = None,
+    min_samples_leaf: int | None = None,
+    max_features: float | None = None,
+    n_neighbors: int | None = None,
+    weights: str | None = None,
+) -> float:
+    """One of three classifiers, and its settings, on the 569 breast tumour samples svm-breast-cancer uses.
+
+    A support vector classifier with an RBF kernel, a 20-tree random forest, or k nearest
+    neighbours. With conditions, only the chosen model's settings are searched.
+    """
+    from sklearn.ensemble import RandomForestClassifier
+    from sklearn.neighbors import KNeighborsClassifier
+    from sklearn.pipeline import make_pipeline
+    from sklearn.preprocessing import StandardScaler
+    from sklearn.svm import SVC
+
+    if model == "svm":
+        estimator = make_pipeline(StandardScaler(), SVC(C=C, gamma=gamma))
+    elif model == "forest":
+        estimator = RandomForestClassifier(
+            n_estimators=20, max_depth=max_depth, min_samples_leaf=min_samples_leaf, max_features=max_features, random_state=0, n_jobs=1
+        )
+    else:
+        estimator = make_pipeline(StandardScaler(), KNeighborsClassifier(n_neighbors=n_neighbors, weights=weights))
+    return _cross_validate(estimator, "breast_cancer", classification=True)
+
+
+_MODEL = ChoiceParameter("model", ["svm", "forest", "knn"])
+_SVM = [RangeParameter("C", 1e-3, 1e3, log=True), RangeParameter("gamma", 1e-5, 10, log=True)]
+_FOREST = [
+    RangeParameter("max_depth", 1, 12, integer=True),
+    RangeParameter("min_samples_leaf", 1, 20, integer=True),
+    RangeParameter("max_features", 0.05, 1.0),
+]
+_KNN: list[Parameter] = [RangeParameter("n_neighbors", 1, 50, integer=True), ChoiceParameter("weights", ["uniform", "distance"])]
+MODEL_SELECTION: list[Parameter] = [_MODEL, *_SVM, *_FOREST, *_KNN]
+MODEL_CONDITIONS: list[Condition] = [_MODEL["svm"] >> _SVM, _MODEL["forest"] >> _FOREST, _MODEL["knn"] >> _KNN]
+
 # The best value of each problem found by REFERENCE_SEARCH.
 OPTIMA = {
     "svm-breast-cancer": 0.014066138798323302,  # accuracy 98.6%, found by CMA-ES
     "kernel-ridge-diabetes": 0.4961748264794844,  # R² 0.504, found by Bayesian optimization
     "random-forest-wine": 0.005555555555555536,  # accuracy 99.4%, found by Bayesian optimization
+    # Every reference run chose the support vector classifier, and the best matched svm-breast-cancer's.
+    "model-selection-breast-cancer": 0.014066138798323302,
 }
 
 SPACES: dict[str, tuple[Callable[..., float], list]] = {
@@ -125,9 +170,30 @@ SPACES: dict[str, tuple[Callable[..., float], list]] = {
 
 
 def ml_problems() -> list[Problem]:
-    """The machine learning tuning problems. Needs scikit-learn."""
+    """The machine learning tuning problems. Needs scikit-learn.
+
+    model-selection-breast-cancer comes twice: with conditions, and as model-selection-breast-cancer-flat
+    with every setting always searched, as before conditions, to show what they are worth.
+    """
     _require_sklearn()
-    return [
+    problems = [
         Problem(name=name, function=function, search_space=SearchSpace(parameters), optimum=OPTIMA[name], tags=frozenset({"ml"}))
         for name, (function, parameters) in SPACES.items()
     ]
+    optimum = OPTIMA["model-selection-breast-cancer"]
+    return problems + [
+        Problem(
+            name="model-selection-breast-cancer",
+            function=model_selection_breast_cancer,
+            search_space=SearchSpace(MODEL_SELECTION, conditions=MODEL_CONDITIONS),
+            optimum=optimum,
+            tags=frozenset({"ml", "conditional"}),
+        ),
+        Problem(
+            name="model-selection-breast-cancer-flat",
+            function=model_selection_breast_cancer,
+            search_space=SearchSpace(MODEL_SELECTION),
+            optimum=optimum,
+            tags=frozenset({"ml", "conditional", "flat"}),
+        ),
+    ]

hone/config/genetic_optimizer_config.py

@@ -48,8 +48,9 @@ class GeneticOptimizerConfig(OptimizerConfig):
     tournament_p: float = Field(default=1.0, ge=0, le=1)  # chance a tournament picks its best rather than its worst
     # Share of children bred within niches of parents with the same choice parameter values, so
     # each option keeps tuning its own numbers. Helps problems where the best choice is found
-    # late, on large budgets; costs on small ones. 0 turns niches off.
-    niche_share: float = Field(default=0.0, ge=0, lt=1)
+    # late, on large budgets; costs on small ones. 0 turns niches off. None, the default, means
+    # 0.5 for a search space with conditions, where each branch is a niche, and 0 otherwise.
+    niche_share: float | None = Field(default=None, ge=0, lt=1)
 
     @model_validator(mode="before")
     @classmethod

hone/objective_function/objective_function.py

@@ -43,5 +43,20 @@ class ObjectiveFunction(BaseModel):
         )
         if unknown:
             raise ValueError(f"{self.name}() does not accept parameters: {', '.join(unknown)}")
+        # A parameter a condition switches off isn't passed, so the function needs a default for it.
+        no_default = sorted(
+            name
+            for name in names
+            if self.search_space.is_conditional(name)
+            and name in accepted
+            and accepted[name].default is inspect.Parameter.empty
+            and accepted[name].kind is not inspect.Parameter.VAR_KEYWORD
+        )
+        if no_default:
+            raise ValueError(
+                f"{self.name}() isn't passed {', '.join(no_default)} at points where a condition switches "
+                f"{'it' if len(no_default) == 1 else 'them'} off, so give {'it' if len(no_default) == 1 else 'each'} a default, "
+                f"such as {no_default[0]}=None"
+            )
         if missing:
             raise ValueError(f"{self.name}() requires parameters missing from the search space: {', '.join(missing)}")

hone/optimizers/base.py

@@ -74,9 +74,15 @@ class Optimizer(ABC):
         config: The optimizer's configuration. Defaults are used if omitted.
         initial_points: Points to evaluate first, such as a known good design or the best
             parameters of an earlier run: one dict of parameter values, or a list of them.
-            Fixed parameters may be left out.
+            Fixed parameters may be left out, and so must parameters a condition switches off.
+
+    Every individual an optimizer breeds holds a value for every parameter, including those
+    the conditions switch off at its point, so an optimizer can keep them to use again. The
+    base class leaves them out of what it hands out and reports: trials, results and progress.
     """
     config_class: ClassVar[type[OptimizerConfig]] = OptimizerConfig
+    supports_constraints: ClassVar[bool] = False  # whether it keeps to a search space's constraints
+    supports_conditions: ClassVar[bool] = False  # whether it handles parameters that conditions switch on and off
 
     def __init__(
         self,
@@ -91,9 +97,19 @@ class Optimizer(ABC):
         self.config = config if config is not None else self.config_class()
         if not isinstance(self.config, self.config_class):
             raise TypeError(f"{type(self).__name__} needs a {self.config_class.__name__}, got {type(self.config).__name__}")
+        if search_space.constraints and not self.supports_constraints:
+            raise UnsupportedSearchSpace(f"{type(self).__name__} doesn't support constraints yet; RandomSearch does")
+        if search_space.conditions and not self.supports_conditions:
+            raise UnsupportedSearchSpace(f"{type(self).__name__} doesn't support conditional parameters yet; RandomSearch does")
         if isinstance(initial_points, dict):
             initial_points = [initial_points]
         self.initial_points = [search_space.check(point) for point in initial_points or []]
+        for point in self.initial_points:
+            if broken := search_space.broken(point):
+                raise ValueError(f"the initial point {point} breaks the constraint `{broken[0]}`")
+        if search_space.constraints and not self.initial_points:
+            # Fail now, before any evaluation, if the constraints leave nothing to search.
+            search_space.sample(np.random.default_rng(0))
         self._workers = 1  # how many evaluations run at once; optimizers may size their population from it
         self.reset()
 
@@ -168,13 +184,20 @@ class Optimizer(ABC):
         reissued = [outstanding[i] for i in self._reissue if i in outstanding][:n]
         self._reissue = [i for i in self._reissue if i in outstanding and i not in {ind.id for ind in reissued}]
         if self._done:
-            return [Trial(id=ind.id, params=dict(ind.params), generation=ind.generation) for ind in reissued]
+            return [self._trial(ind) for ind in reissued]
         ready = [ind for ind_id, ind in self._waiting.items() if ind_id not in self._handed_out]
         limits = [None if n is None else n - len(reissued), self._budget_left()]
         ready = ready[: min((limit for limit in limits if limit is not None), default=len(ready))]
         self._handed_out.update(ind.id for ind in ready)
         self._handed_out_total += len(ready)
-        return [Trial(id=ind.id, params=dict(ind.params), generation=ind.generation) for ind in reissued + ready]
+        return [self._trial(ind) for ind in reissued + ready]
+
+    def _trial(self, individual: Individual) -> Trial:
+        return Trial(id=individual.id, params=self.search_space.active(individual.params), generation=individual.generation)
+
+    def _key(self, params: dict[str, Any]) -> tuple:
+        """A hashable form of the point params are at: two that differ only where conditions switch parameters off share it."""
+        return _key(self.search_space.active(params))
 
     def tell(self, trial: Trial | int, value: float | None = None, *, failed: bool = False) -> None:
         """Report the outcome of a trial from ask(), by the trial or its id.
@@ -206,7 +229,7 @@ class Optimizer(ABC):
             individual.fitness = float(value)
             if self.config.noise:
                 # Average every evaluation of the same point, so a lucky value regresses toward its mean.
-                key = _key(individual.params)
+                key = self._key(individual.params)
                 self._observations.setdefault(key, []).append(float(value))
                 self._points.setdefault(key, dict(individual.params))
                 individual.fitness = float(np.mean(self._observations[key]))
@@ -262,8 +285,8 @@ class Optimizer(ABC):
             # Once the finalists have been re-evaluated, the one with the best average; before
             # that, the most promising point by the optimizer's best estimate.
             key = self._ranked_keys(self._finalists)[0] if self._finalists else self._finalist_order()[0]
-            return self._average(key), self._points[key]
-        return _fitness(self._best), self._best.params
+            return self._average(key), self.search_space.active(self._points[key])
+        return _fitness(self._best), self.search_space.active(self._best.params)
 
     def _run_info(self) -> RunInfo:
         return RunInfo(
@@ -297,7 +320,9 @@ class Optimizer(ABC):
 
         The file is replaced in one step, so a crash while saving leaves the previous checkpoint intact.
         """
-        state = dict(self.__dict__)
+        # The search space is left out: the loading optimizer has its own, which must match, and a
+        # constraint function may not be picklable.
+        state = {name: value for name, value in self.__dict__.items() if name != "search_space"}
         elapsed = self._elapsed() if self._start_clock is not None else None
         state.update(_start_clock=None, _end_clock=None, _workers=1)
         checkpoint = {
@@ -527,7 +552,7 @@ class Optimizer(ABC):
         """Set each successful individual's fitness to the current average of every evaluation of its point."""
         for individual in individuals:
             if not individual.failed and individual.fitness is not None:
-                individual.fitness = self._average(_key(individual.params))
+                individual.fitness = self._average(self._key(individual.params))
 
     def _final_population(self, generation: int) -> list[Individual]:
         """The final round with noise: the most promising points, each evaluated again.
@@ -550,7 +575,14 @@ class Optimizer(ABC):
         return list(self._late.values())
 
     def _initial_individuals(self, generation: int) -> list[Individual]:
-        return [Individual(params=dict(point), generation=generation) for point in self.initial_points]
+        """The initial points as individuals, with a random value for each parameter a condition switches off."""
+        return [
+            Individual(
+                params={p.name: point[p.name] if p.name in point else p.sample(self.rng) for p in self.search_space.parameters},
+                generation=generation,
+            )
+            for point in self.initial_points
+        ]
 
     def _random_individual(self, generation: int) -> Individual:
         return Individual(params=self.search_space.sample(self.rng), generation=generation)
@@ -581,7 +613,7 @@ class Optimizer(ABC):
             evaluations=evaluations,
             failures=failures,
             best_fitness=succeeded[0].fitness,
-            best_params=dict(succeeded[0].params),
+            best_params=self.search_space.active(succeeded[0].params),
             worst_fitness=succeeded[-1].fitness,
             mean=float(np.mean(fitnesses)),
             median=float(np.median(fitnesses)),