optimized-svm 0.1.0__py3-none-any.whl

optimized_svm/hypergradient.py

@@ -0,0 +1,153 @@
+"""Cross-validation error and its gradient w.r.t. the hyperparameters (Strasdat, Sec. 9.2).
+
+Hyperparameters are ``theta = (log lam, log s_1, ..., log s_K)`` (regularization and feature
+block scalings). For each fold the training problem is solved and the derivative of the
+solution is obtained from the implicit function theorem applied to the (semismooth) optimality
+conditions ``a_l + phi_l'(ka_l + b + s_l c) = 0``, ``sum(a) = 0`` (and ``s^T a = A``). Only the
+terms with positive curvature ``h_l = phi_l''`` react to parameter changes. Instead of the
+``K`` forward sensitivities, a single *adjoint* system is solved per fold:
+
+``[[K_PP / lam + diag(1 / h_P), 1, s_P], [1^T, 0, 0], [s_P^T, 0, 0]] [u; .]``
+``= [K_VP^T dE / lam; sum dE; 0]``
+
+after which ``dE/dtheta = -u^T (d ka_P / dtheta) + dE^T (d f_V / dtheta)`` with ``a`` fixed.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from dataclasses import dataclass, field
+from typing import Any
+
+import numpy as np
+from numpy.typing import NDArray
+
+from .kernels import Blocks, n_blocks, rbf, rbf_with_gradient, scale_features
+from .linalg import solve_bordered
+from .losses import Loss
+from .problem import TrainingProblem
+from .training import Solution, train
+from .validation import ValidationLoss
+
+Array = NDArray[np.float64]
+Fold = tuple[NDArray[np.intp], NDArray[np.intp]]
+
+
+@dataclass
+class FoldResult:
+    error: float
+    gradient: Array
+    solution: Solution
+    n_support: int
+    time: float
+
+
+def fold_error_and_gradient(
+    x_train: Array,
+    y_train: Array,
+    w_train: Array,
+    x_val: Array,
+    y_val: Array,
+    loss: Loss,
+    validation: ValidationLoss,
+    lam: float,
+    blocks: Blocks,
+    max_asum: float | None = None,
+    smo_options: dict[str, Any] | None = None,
+    newton_options: dict[str, Any] | None = None,
+    alpha0: Array | None = None,
+) -> FoldResult:
+    """Validation error of one fold and its gradient w.r.t. ``(log lam, log s_k)``.
+
+    ``x_train``/``x_val`` must already be scaled.
+    """
+    prob = TrainingProblem(x_train, y_train, loss, lam, w_train, max_asum)
+    sol = train(prob, smo_options, newton_options, alpha0)
+    a = sol.a
+    sv = np.flatnonzero(a)
+    a_sv = a[sv] / lam
+    x_terms = prob.x[prob.terms.kernel_index]
+
+    # validation predictions and explicit derivatives (a fixed)
+    k_val_sv, dk_val_sv = rbf_with_gradient(x_val, x_terms[sv], blocks)
+    ka_val = k_val_sv @ a_sv
+    f_val = ka_val + sol.b
+    err, d_err = validation(f_val, y_val)
+    grad = np.zeros(1 + n_blocks(blocks))
+    grad[0] = -d_err @ ka_val
+    grad[1:] = a_sv @ np.tensordot(d_err, dk_val_sv, axes=(0, 0))
+
+    # implicit part: adjoint system on terms with positive curvature
+    dec = prob.decision(sol.b, sol.c, sol.ka)
+    h = prob.loss.d2(dec, prob.terms)
+    p = np.flatnonzero(h > 0.0)
+    if p.size > 0:
+        _, dk_p_sv = rbf_with_gradient(x_terms[p], x_terms[sv], blocks)
+        q = prob.kernel(p, p) / lam + np.diag(1.0 / h[p])
+        cols = [np.ones(p.size)]
+        rhs0 = [d_err.sum()]
+        if max_asum is not None and sol.c > 0.0:
+            cols.append(prob.sign[p])
+            rhs0.append(0.0)
+        k_val_p = rbf(x_val, x_terms[p])
+        u, _ = solve_bordered(q, np.stack(cols, axis=1), k_val_p.T @ d_err / lam, np.array(rhs0))
+        # d ka_P / d log lam = -ka_P,  d ka_P / d log s_k = dK_{P,SV} a_SV / lam
+        grad[0] += u @ sol.ka[p]
+        grad[1:] -= a_sv @ np.tensordot(u, dk_p_sv, axes=(0, 0))
+    return FoldResult(err, grad, sol, int(sv.size), sol.time_smo + sol.time_newton)
+
+
+@dataclass
+class CVResult:
+    error: float
+    gradient: Array
+    folds: list[FoldResult] = field(default_factory=list)
+
+
+def cv_error_and_gradient(
+    theta: Array,
+    x: Array,
+    y: Array,
+    w: Array,
+    folds: Sequence[Fold],
+    loss: Loss,
+    validation: ValidationLoss,
+    blocks: Blocks = None,
+    max_asum: float | None = None,
+    smo_options: dict[str, Any] | None = None,
+    newton_options: dict[str, Any] | None = None,
+    warm_start: list[Array | None] | None = None,
+) -> CVResult:
+    """Mean validation error over all folds and its gradient w.r.t. ``theta``.
+
+    ``warm_start`` is a list with one (possibly ``None``) start vector per fold; it is updated
+    in place with the new solutions.
+    """
+    lam = float(np.exp(theta[0]))
+    xs = scale_features(x, np.exp(theta[1:]), blocks)
+    total, grad, results = 0.0, np.zeros_like(theta, dtype=np.float64), []
+    n_val = 0
+    for i, (train_idx, val_idx) in enumerate(folds):
+        start = warm_start[i] if warm_start is not None else None
+        res = fold_error_and_gradient(
+            xs[train_idx],
+            y[train_idx],
+            w[train_idx],
+            xs[val_idx],
+            y[val_idx],
+            loss,
+            validation,
+            lam,
+            blocks,
+            max_asum,
+            smo_options,
+            newton_options,
+            start,
+        )
+        if warm_start is not None:
+            warm_start[i] = res.solution.a
+        total += res.error
+        grad += res.gradient
+        n_val += len(val_idx)
+        results.append(res)
+    return CVResult(total / n_val, grad / n_val, results)

optimized_svm/kernels.py

@@ -0,0 +1,63 @@
+"""Gaussian kernel with feature scaling and its derivatives w.r.t. log-scalings.
+
+The hyperparameters of the kernel are scalings ``s_k > 0`` of feature blocks ``B_k``:
+``k(x, z) = exp(-sum_k s_k^2 |x_{B_k} - z_{B_k}|^2)``. With a single block this is the RBF
+kernel with ``gamma = s^2``; with one block per feature it is an ARD kernel. The training code
+works on *scaled* features ``x_{B_k} * s_k`` and an RBF kernel with ``gamma = 1``.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+
+import numpy as np
+from numpy.typing import ArrayLike, NDArray
+
+Array = NDArray[np.float64]
+Blocks = Sequence[Sequence[int]] | None
+
+
+def squared_distances(x: Array, z: Array) -> Array:
+    """Matrix of squared Euclidean distances ``|x_i - z_j|^2`` (clipped at zero)."""
+    d = (x * x).sum(axis=1)[:, None] + (z * z).sum(axis=1)[None, :] - 2.0 * x @ z.T
+    return np.maximum(d, 0.0)
+
+
+def rbf(x: Array, z: Array) -> Array:
+    """``exp(-|x - z|^2)`` for already scaled features."""
+    return np.exp(-squared_distances(x, z))
+
+
+def rbf_with_gradient(x: Array, z: Array, blocks: Blocks = None) -> tuple[Array, Array]:
+    """Kernel matrix and its derivatives w.r.t. the log-scalings of all blocks.
+
+    Returns ``K`` of shape ``(n, m)`` and ``dK`` of shape ``(n, m, n_blocks)`` with
+    ``dK[..., k] = d K / d log s_k = -2 K * |x_{B_k} - z_{B_k}|^2`` (features already scaled).
+    """
+    if blocks is None:
+        d = squared_distances(x, z)
+        k = np.exp(-d)
+        return k, (-2.0 * k * d)[:, :, None]
+    parts = [squared_distances(x[:, list(b)], z[:, list(b)]) for b in blocks]
+    k = np.exp(-sum(parts))
+    return k, -2.0 * k[:, :, None] * np.stack(parts, axis=-1)
+
+
+def n_blocks(blocks: Blocks) -> int:
+    return 1 if blocks is None else len(blocks)
+
+
+def scale_features(x: ArrayLike, scaling: ArrayLike, blocks: Blocks = None) -> Array:
+    """Multiplies the features of each block by its scaling."""
+    x = np.asarray(x, dtype=np.float64)
+    scaling = np.atleast_1d(np.asarray(scaling, dtype=np.float64))
+    if blocks is None:
+        if scaling.size != 1:
+            raise ValueError("a single scaling is required without blocks")
+        return x * scaling[0]
+    if scaling.size != len(blocks):
+        raise ValueError(f"expected {len(blocks)} scalings, got {scaling.size}")
+    xs = x.copy()
+    for s, block in zip(scaling, blocks, strict=True):
+        xs[:, list(block)] *= s
+    return xs

optimized_svm/linalg.py

@@ -0,0 +1,24 @@
+"""Bordered symmetric positive definite systems."""
+
+from __future__ import annotations
+
+import numpy as np
+from numpy.typing import NDArray
+from scipy.linalg import cho_factor, cho_solve
+
+Array = NDArray[np.float64]
+
+
+def solve_bordered(q: Array, a: Array, r: Array, r0: Array) -> tuple[Array, Array]:
+    """Solves ``[[Q, A], [A^T, 0]] [u; v] = [r; r0]`` for SPD ``Q`` (Schur complement).
+
+    ``A`` has shape ``(n, k)`` with ``k`` small (one column per equality constraint).
+    """
+    k = a.shape[1]
+    if q.shape[0] == 0:
+        return np.zeros(0), np.zeros(k)
+    q_cho = cho_factor(q)
+    qia = cho_solve(q_cho, a)
+    qir = cho_solve(q_cho, r)
+    v = np.linalg.solve(a.T @ qia, a.T @ qir - r0)
+    return qir - qia @ v, v

optimized_svm/losses.py

@@ -0,0 +1,176 @@
+"""Loss functions of the training problem, expressed per *loss term*.
+
+A training problem with ``n`` samples consists of ``m`` loss terms: one per sample, or two for
+the epsilon-insensitive loss (one for each side of the tube). Term ``l`` belongs to sample
+``kernel_index[l]``, has weight ``w_l``, label ``y_l`` and sign ``s_l`` (used by the optional
+1-norm constraint, ``0`` if not applicable). The decision value of a term is
+``f(x_l) + s_l c``.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import numpy as np
+from numpy.typing import NDArray
+from scipy.special import gammaln
+
+from .smooth_max import Degree, smooth_max
+
+Array = NDArray[np.float64]
+
+
+@dataclass(frozen=True)
+class Terms:
+    """Term structure of a training problem."""
+
+    kernel_index: NDArray[np.intp]
+    y: Array
+    w: Array
+    sign: Array
+
+    @property
+    def size(self) -> int:
+        return self.y.size
+
+
+class Loss:
+    """Base class: per-term loss ``phi_l(t)`` and its derivatives."""
+
+    #: whether the dual of this loss can be solved by ``smo_solver`` (as warm start)
+    smo_kind: str | None = None
+    #: whether the 1-norm constraint is meaningful (non-zero signs)
+    signed: bool = False
+
+    def terms(self, y: Array, w: Array) -> Terms:
+        n = y.size
+        return Terms(np.arange(n), y, w, np.zeros(n))
+
+    def value(self, t: Array, terms: Terms) -> Array:
+        raise NotImplementedError
+
+    def d1(self, t: Array, terms: Terms) -> Array:
+        raise NotImplementedError
+
+    def d2(self, t: Array, terms: Terms) -> Array:
+        raise NotImplementedError
+
+
+@dataclass(frozen=True)
+class HingeLoss(Loss):
+    """Smoothed hinge loss ``w * m_delta(shift - y t)`` for labels ``y`` in ``{-1, +1}``."""
+
+    shift: float = 1.0
+    smoothing: float = 0.5
+    degree: Degree = "2"
+    smo_kind = "classification"
+    signed = True
+
+    def terms(self, y: Array, w: Array) -> Terms:
+        return Terms(np.arange(y.size), y, w, y.astype(float))
+
+    def value(self, t: Array, terms: Terms) -> Array:
+        m = smooth_max(self.smoothing, self.degree)[0]
+        return terms.w * m(self.shift - terms.y * t)
+
+    def d1(self, t: Array, terms: Terms) -> Array:
+        dm = smooth_max(self.smoothing, self.degree)[1]
+        return -terms.w * terms.y * dm(self.shift - terms.y * t)
+
+    def d2(self, t: Array, terms: Terms) -> Array:
+        ddm = smooth_max(self.smoothing, self.degree)[2]
+        return terms.w * ddm(self.shift - terms.y * t)
+
+
+@dataclass(frozen=True)
+class EpsilonInsensitiveLoss(Loss):
+    """Smoothed epsilon-insensitive loss ``w * (m(y - t - eps) + m(t - y - eps))``.
+
+    Uses two terms per sample: sign ``+1`` for ``m(y - t - eps)`` and ``-1`` for the other side.
+    """
+
+    epsilon: float = 0.1
+    smoothing: float = 0.5
+    degree: Degree = "2"
+    smo_kind = "regression"
+    signed = True
+
+    def terms(self, y: Array, w: Array) -> Terms:
+        n = y.size
+        idx = np.arange(n)
+        return Terms(
+            np.concatenate((idx, idx)),
+            np.concatenate((y, y)),
+            np.concatenate((w, w)),
+            np.concatenate((np.ones(n), -np.ones(n))),
+        )
+
+    def _arg(self, t: Array, terms: Terms) -> Array:
+        return -terms.sign * (t - terms.y) - self.epsilon
+
+    def value(self, t: Array, terms: Terms) -> Array:
+        m = smooth_max(self.smoothing, self.degree)[0]
+        return terms.w * m(self._arg(t, terms))
+
+    def d1(self, t: Array, terms: Terms) -> Array:
+        dm = smooth_max(self.smoothing, self.degree)[1]
+        return -terms.sign * terms.w * dm(self._arg(t, terms))
+
+    def d2(self, t: Array, terms: Terms) -> Array:
+        ddm = smooth_max(self.smoothing, self.degree)[2]
+        return terms.w * ddm(self._arg(t, terms))
+
+
+@dataclass(frozen=True)
+class SquaredLoss(Loss):
+    """Least-squares loss ``w / 2 * (t - y)^2`` (LS-SVM)."""
+
+    def value(self, t: Array, terms: Terms) -> Array:
+        return 0.5 * terms.w * (t - terms.y) ** 2
+
+    def d1(self, t: Array, terms: Terms) -> Array:
+        return terms.w * (t - terms.y)
+
+    def d2(self, t: Array, terms: Terms) -> Array:
+        return terms.w * np.ones_like(t)
+
+
+@dataclass(frozen=True)
+class PoissonLoss(Loss):
+    """Poisson negative log-likelihood ``w * (exp(t) - y t + log(y!))`` for counts ``y``."""
+
+    def value(self, t: Array, terms: Terms) -> Array:
+        with np.errstate(over="ignore"):  # inf is handled by the line search
+            return terms.w * (np.exp(t) - terms.y * t + gammaln(terms.y + 1))
+
+    def d1(self, t: Array, terms: Terms) -> Array:
+        return terms.w * (np.exp(t) - terms.y)
+
+    def d2(self, t: Array, terms: Terms) -> Array:
+        return terms.w * np.exp(t)
+
+
+@dataclass(frozen=True)
+class ApproxPoissonLoss(Loss):
+    """Poisson-type loss with a linear left tail (from the original experiments):
+
+    ``w * (exp(t) - (y + 1) t - 1 + log(y!))`` for ``t > 0`` and ``w * (-y t + log(y!))`` else.
+
+    It is convex and continuously differentiable; for ``t <= 0`` its curvature vanishes.
+    """
+
+    def value(self, t: Array, terms: Terms) -> Array:
+        pos = t > 0.0
+        with np.errstate(over="ignore"):
+            r = np.where(
+                pos, np.exp(np.where(pos, t, 0.0)) - (terms.y + 1.0) * t - 1.0, -terms.y * t
+            )
+        return terms.w * (r + gammaln(terms.y + 1))
+
+    def d1(self, t: Array, terms: Terms) -> Array:
+        pos = t > 0.0
+        return terms.w * np.where(pos, np.exp(np.where(pos, t, 0.0)) - (terms.y + 1.0), -terms.y)
+
+    def d2(self, t: Array, terms: Terms) -> Array:
+        pos = t > 0.0
+        return terms.w * np.where(pos, np.exp(np.where(pos, t, 0.0)), 0.0)

optimized_svm/problem.py

@@ -0,0 +1,99 @@
+"""Training problem in the dual parametrisation used by the Newton method.
+
+For loss terms ``phi_l`` (see :mod:`optimized_svm.losses`), the primal training problem
+``min lam/2 |w|^2 + sum_l phi_l(<w, x_l> + b + s_l c) + A c`` is written in terms of
+``a`` with ``w = 1/lam sum_l a_l phi(x_l)`` (representer theorem). With
+``ka = K a / lam`` the objective reads ``1/2 a^T ka + sum_l phi_l(ka_l + b + s_l c) + A c``
+(Strasdat, Ch. 6 and 8).
+"""
+
+from __future__ import annotations
+
+import numpy as np
+from numpy.typing import NDArray
+
+from .kernels import rbf
+from .losses import Loss
+
+Array = NDArray[np.float64]
+Index = NDArray[np.intp] | NDArray[np.bool_] | slice
+
+#: kernel matrices up to this number of samples are computed once and kept in memory
+PRECOMPUTE_LIMIT = 8000
+
+
+class TrainingProblem:
+    """Training problem on (already scaled) features ``x`` with an RBF kernel (``gamma = 1``)."""
+
+    def __init__(
+        self,
+        x: Array,
+        y: Array,
+        loss: Loss,
+        lam: float,
+        weights: Array | None = None,
+        max_asum: float | None = None,
+    ) -> None:
+        if lam <= 0:
+            raise ValueError(f"lam must be positive, got {lam}")
+        if max_asum is not None and not loss.signed:
+            raise ValueError(f"max_asum is not supported for {type(loss).__name__}")
+        self.x = np.ascontiguousarray(x, dtype=np.float64)
+        self.y = np.asarray(y, dtype=np.float64)
+        self.w = np.ones_like(self.y) if weights is None else np.asarray(weights, dtype=np.float64)
+        self.loss = loss
+        self.lam = float(lam)
+        self.max_asum = max_asum
+        self.terms = loss.terms(self.y, self.w)
+        n = self.x.shape[0]
+        # the matrix is stored per *sample*, not per loss term
+        self._k = rbf(self.x, self.x) if n <= PRECOMPUTE_LIMIT else None
+
+    @property
+    def n_samples(self) -> int:
+        return self.x.shape[0]
+
+    @property
+    def size(self) -> int:
+        """Number of loss terms (= dual variables)."""
+        return self.terms.size
+
+    @property
+    def sign(self) -> Array:
+        return self.terms.sign
+
+    def kernel(self, rows: Index = slice(None), cols: Index = slice(None)) -> Array:
+        """Kernel matrix between loss terms ``rows`` and ``cols``."""
+        ki = self.terms.kernel_index
+        r, c = ki[rows], ki[cols]
+        if self._k is not None:
+            return self._k[np.ix_(r, c)]
+        return rbf(self.x[r], self.x[c])
+
+    def kernel_to(self, z: Array, rows: Index = slice(None)) -> Array:
+        """Kernel matrix between loss terms ``rows`` and new (scaled) points ``z``."""
+        return rbf(self.x[self.terms.kernel_index[rows]], z)
+
+    def sample_coefficients(self, a: Array) -> Array:
+        """Coefficients per sample ``beta_k = sum_{l: k(l) = k} a_l``."""
+        return np.bincount(self.terms.kernel_index, weights=a, minlength=self.n_samples)
+
+    def ka(self, a: Array) -> Array:
+        """``K a / lam`` per loss term (computed via the sample coefficients)."""
+        beta = self.sample_coefficients(a)
+        sv = np.flatnonzero(beta)
+        if self._k is not None:
+            per_sample = self._k[:, sv] @ beta[sv]
+        else:
+            per_sample = rbf(self.x, self.x[sv]) @ beta[sv]
+        return per_sample[self.terms.kernel_index] / self.lam
+
+    def decision(self, b: float, c: float, ka: Array) -> Array:
+        return ka + b + self.sign * c
+
+    def objective(self, a: Array, b: float, c: float, ka: Array) -> float:
+        dec = self.decision(b, c, ka)
+        obj = 0.5 * float(a @ ka) + float(self.loss.value(dec, self.terms).sum())
+        if self.max_asum is not None:
+            obj += self.max_asum * c
+        return obj

optimized_svm/smooth_max.py

@@ -0,0 +1,90 @@
+"""Smooth approximations of the maximum function ``max(0, t)`` (Strasdat, Sec. 4.4).
+
+Each approximation ``m_delta`` coincides with ``max(0, t)`` for ``|t| >= delta`` and is a
+polynomial on ``(-delta, delta)``. The degree determines the smoothness:
+
+* ``"2"``: ``C^1``, piecewise quadratic (its conjugate is quadratic, so SMO applies),
+* ``"3"``: ``C^2``, piecewise cubic,
+* ``"6"``: ``C^2``, a single sextic polynomial on ``(-delta, delta)``.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import Literal
+
+import numpy as np
+from numpy.typing import NDArray
+
+Array = NDArray[np.float64]
+Degree = Literal["2", "3", "6"]
+SmoothMax = tuple[Callable[[Array], Array], Callable[[Array], Array], Callable[[Array], Array]]
+
+
+def _deg2(d: float) -> SmoothMax:
+    def m(t: Array) -> Array:
+        return np.where(t >= d, t, np.where(t <= -d, 0.0, 0.25 / d * (t + d) ** 2))
+
+    def dm(t: Array) -> Array:
+        return np.where(t >= d, 1.0, np.where(t <= -d, 0.0, 0.5 / d * (t + d)))
+
+    def ddm(t: Array) -> Array:
+        return np.where(np.abs(t) < d, 0.5 / d, 0.0)
+
+    return m, dm, ddm
+
+
+def _deg3(d: float) -> SmoothMax:
+    def m(t: Array) -> Array:
+        inner = np.where(t <= 0.0, (d + t) ** 3 / (6 * d**2), t + (d - t) ** 3 / (6 * d**2))
+        return np.where(t >= d, t, np.where(t <= -d, 0.0, inner))
+
+    def dm(t: Array) -> Array:
+        inner = np.where(t <= 0.0, (d + t) ** 2 / (2 * d**2), 1.0 - (d - t) ** 2 / (2 * d**2))
+        return np.where(t >= d, 1.0, np.where(t <= -d, 0.0, inner))
+
+    def ddm(t: Array) -> Array:
+        return np.where(np.abs(t) < d, (d - np.abs(t)) / d**2, 0.0)
+
+    return m, dm, ddm
+
+
+def _deg6(d: float) -> SmoothMax:
+    def m(t: Array) -> Array:
+        u = t / d
+        inner = d * (5 + u * (16 + u * (15 + u * u * (-5 + u * u)))) / 32
+        return np.where(t >= d, t, np.where(t <= -d, 0.0, inner))
+
+    def dm(t: Array) -> Array:
+        u = t / d
+        inner = (8 + u * (15 + u * u * (-10 + 3 * u * u))) / 16
+        return np.where(t >= d, 1.0, np.where(t <= -d, 0.0, inner))
+
+    def ddm(t: Array) -> Array:
+        u = t / d
+        return np.where(np.abs(t) < d, (15 + u * u * (-30 + 15 * u * u)) / (16 * d), 0.0)
+
+    return m, dm, ddm
+
+
+def _exact() -> SmoothMax:
+    return (
+        lambda t: np.maximum(t, 0.0),
+        lambda t: (t > 0.0).astype(float),
+        lambda t: np.zeros_like(t, dtype=float),
+    )
+
+
+def smooth_max(delta: float, degree: Degree = "2") -> SmoothMax:
+    """Returns ``(m, dm, ddm)``: the smoothed maximum and its first two derivatives.
+
+    ``delta = 0`` yields the (non-smooth) maximum itself.
+    """
+    if delta < 0:
+        raise ValueError(f"delta must be non-negative, got {delta}")
+    if delta == 0:
+        return _exact()
+    try:
+        return {"2": _deg2, "3": _deg3, "6": _deg6}[str(degree)](float(delta))
+    except KeyError:
+        raise ValueError(f"unknown degree {degree!r}, use '2', '3' or '6'") from None