vecadvisor 0.1.0a1__py3-none-any.whl

vecadvisor/bench/crossover.py

@@ -0,0 +1,440 @@
+from __future__ import annotations
+
+import json
+import math
+from collections import Counter
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from .sweep import SweepReport, sweep_report_to_json
+
+
+@dataclass(frozen=True)
+class StrategyPointSummary:
+    strategy: str
+    recall_at_k: float
+    returns_k_rate: float
+    latency_ms_mean: float
+    latency_ms_p95: float
+
+
+@dataclass(frozen=True)
+class SweepAnalysisPoint:
+    target_filter_selectivity: float
+    target_correlation: float
+    observed_filter_selectivity: float
+    s_local_p10: float
+    s_local_median: float
+    measured_best: str
+    predicted_best: str | None
+    prediction_match: bool | None
+    postfilter_recall_at_k: float | None
+    postfilter_returns_k_rate: float | None
+    postfilter_viable: bool | None
+    strategies: tuple[StrategyPointSummary, ...]
+
+
+@dataclass(frozen=True)
+class WinnerRegion:
+    kind: str
+    correlation: float
+    strategy: str
+    selectivity_min: float
+    selectivity_max: float
+    point_count: int
+
+
+@dataclass(frozen=True)
+class WinnerCrossover:
+    kind: str
+    correlation: float
+    lower_selectivity: float
+    upper_selectivity: float
+    estimated_selectivity: float
+    from_strategy: str
+    to_strategy: str
+
+
+@dataclass(frozen=True)
+class CrossoverAnalysis:
+    backend: str
+    point_count: int
+    correlations: tuple[float, ...]
+    recall_target: float
+    returns_k_target: float
+    prediction_match_rate: float | None
+    measured_win_counts: Mapping[str, int]
+    predicted_win_counts: Mapping[str, int]
+    regions: tuple[WinnerRegion, ...]
+    measured_crossovers: tuple[WinnerCrossover, ...]
+    predicted_crossovers: tuple[WinnerCrossover, ...]
+    postfilter_failure_count: int
+    points: tuple[SweepAnalysisPoint, ...]
+    notes: tuple[str, ...] = ()
+
+
+def load_sweep_payload(path: Path) -> Mapping[str, Any]:
+    """Load a JSON sweep report produced by benchmark-sweep or benchmark-sweep-db."""
+
+    try:
+        raw = json.loads(path.read_text(encoding="utf-8"))
+    except OSError as exc:
+        raise ValueError(f"could not read sweep report: {path}") from exc
+    except json.JSONDecodeError as exc:
+        raise ValueError(f"sweep report JSON is invalid: {exc}") from exc
+    if not isinstance(raw, Mapping):
+        raise ValueError("sweep report must be a JSON object")
+    return raw
+
+
+def analyze_sweep_report(report: SweepReport) -> CrossoverAnalysis:
+    """Analyze an in-memory sweep report."""
+
+    return analyze_sweep_payload(sweep_report_to_json(report, calibration_source="in-memory"))
+
+
+def analyze_sweep_payload(payload: Mapping[str, Any]) -> CrossoverAnalysis:
+    """Compute winner regions, crossovers, and prediction quality from sweep JSON."""
+
+    sweep = _mapping_value(payload, "sweep")
+    backend = _str_value(sweep, "backend")
+    recall_target = _float_value(sweep, "recall_target")
+    returns_k_target = _float_value(sweep, "returns_k_target")
+    points = tuple(
+        _analysis_point(point, recall_target=recall_target, returns_k_target=returns_k_target)
+        for point in _sequence_value(payload, "points")
+    )
+    if not points:
+        raise ValueError("sweep report must contain at least one point")
+
+    correlations = tuple(sorted({point.target_correlation for point in points}))
+    predicted_points = [point for point in points if point.predicted_best is not None]
+    prediction_match_rate = (
+        sum(1 for point in predicted_points if point.prediction_match) / len(predicted_points)
+        if predicted_points
+        else None
+    )
+    measured_win_counts = dict(Counter(point.measured_best for point in points))
+    predicted_winners: list[str] = []
+    for point in predicted_points:
+        assert point.predicted_best is not None
+        predicted_winners.append(point.predicted_best)
+    predicted_win_counts = dict(Counter(predicted_winners))
+    postfilter_failure_count = sum(1 for point in points if point.postfilter_viable is False)
+
+    measured_regions = _winner_regions(points, kind="measured")
+    predicted_regions = _winner_regions(points, kind="predicted")
+    measured_crossovers = _winner_crossovers(points, kind="measured")
+    predicted_crossovers = _winner_crossovers(points, kind="predicted")
+
+    return CrossoverAnalysis(
+        backend=backend,
+        point_count=len(points),
+        correlations=correlations,
+        recall_target=recall_target,
+        returns_k_target=returns_k_target,
+        prediction_match_rate=prediction_match_rate,
+        measured_win_counts=measured_win_counts,
+        predicted_win_counts=predicted_win_counts,
+        regions=(*measured_regions, *predicted_regions),
+        measured_crossovers=measured_crossovers,
+        predicted_crossovers=predicted_crossovers,
+        postfilter_failure_count=postfilter_failure_count,
+        points=points,
+        notes=(
+            "crossovers are estimated between adjacent sampled selectivity points",
+            "estimated_selectivity uses the geometric midpoint for positive selectivities",
+            "postfilter_failure_count uses the sweep recall and returns-k targets",
+        ),
+    )
+
+
+def crossover_analysis_to_json(analysis: CrossoverAnalysis) -> dict[str, object]:
+    return {
+        "analysis": {
+            "backend": analysis.backend,
+            "point_count": analysis.point_count,
+            "correlations": list(analysis.correlations),
+            "recall_target": analysis.recall_target,
+            "returns_k_target": analysis.returns_k_target,
+            "prediction_match_rate": analysis.prediction_match_rate,
+            "postfilter_failure_count": analysis.postfilter_failure_count,
+        },
+        "measured_win_counts": dict(analysis.measured_win_counts),
+        "predicted_win_counts": dict(analysis.predicted_win_counts),
+        "regions": [_region_to_json(region) for region in analysis.regions],
+        "measured_crossovers": [
+            _crossover_to_json(crossover) for crossover in analysis.measured_crossovers
+        ],
+        "predicted_crossovers": [
+            _crossover_to_json(crossover) for crossover in analysis.predicted_crossovers
+        ],
+        "points": [_point_to_json(point) for point in analysis.points],
+        "notes": list(analysis.notes),
+    }
+
+
+def write_crossover_analysis(analysis: CrossoverAnalysis, path: Path) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(
+        json.dumps(crossover_analysis_to_json(analysis), indent=2) + "\n",
+        encoding="utf-8",
+    )
+
+
+def _analysis_point(
+    raw: object,
+    *,
+    recall_target: float,
+    returns_k_target: float,
+) -> SweepAnalysisPoint:
+    point = _as_mapping(raw, "sweep point")
+    dataset = _mapping_value(point, "dataset")
+    local = _mapping_value(point, "local_selectivity")
+    strategies = tuple(
+        _strategy_summary(strategy) for strategy in _sequence_value(point, "strategies")
+    )
+    postfilter = next(
+        (strategy for strategy in strategies if strategy.strategy == "postfilter"),
+        None,
+    )
+    postfilter_viable = (
+        postfilter.recall_at_k >= recall_target
+        and postfilter.returns_k_rate >= returns_k_target
+        if postfilter is not None
+        else None
+    )
+    return SweepAnalysisPoint(
+        target_filter_selectivity=_float_value(point, "target_filter_selectivity"),
+        target_correlation=_float_value(point, "target_correlation"),
+        observed_filter_selectivity=_float_value(dataset, "observed_filter_selectivity"),
+        s_local_p10=_float_value(local, "s_local_p10"),
+        s_local_median=_float_value(local, "s_local_median"),
+        measured_best=_str_value(point, "measured_best"),
+        predicted_best=_optional_str_value(point, "predicted_best"),
+        prediction_match=_optional_bool_value(point, "prediction_match"),
+        postfilter_recall_at_k=None if postfilter is None else postfilter.recall_at_k,
+        postfilter_returns_k_rate=None if postfilter is None else postfilter.returns_k_rate,
+        postfilter_viable=postfilter_viable,
+        strategies=strategies,
+    )
+
+
+def _strategy_summary(raw: object) -> StrategyPointSummary:
+    strategy = _as_mapping(raw, "strategy")
+    latency = _mapping_value(strategy, "latency_ms")
+    return StrategyPointSummary(
+        strategy=_str_value(strategy, "strategy"),
+        recall_at_k=_float_value(strategy, "recall_at_k"),
+        returns_k_rate=_float_value(strategy, "returns_k_rate"),
+        latency_ms_mean=_float_value(latency, "mean"),
+        latency_ms_p95=_float_value(latency, "p95"),
+    )
+
+
+def _winner_regions(
+    points: Sequence[SweepAnalysisPoint],
+    *,
+    kind: str,
+) -> tuple[WinnerRegion, ...]:
+    regions: list[WinnerRegion] = []
+    for correlation in sorted({point.target_correlation for point in points}):
+        group = _points_for_correlation(points, correlation=correlation, kind=kind)
+        if not group:
+            continue
+        start = group[0]
+        current_strategy = _winner(start, kind=kind)
+        assert current_strategy is not None
+        current_points = [start]
+        for point in group[1:]:
+            strategy = _winner(point, kind=kind)
+            if strategy == current_strategy:
+                current_points.append(point)
+                continue
+            regions.append(_region_from_points(kind, correlation, current_strategy, current_points))
+            assert strategy is not None
+            current_strategy = strategy
+            current_points = [point]
+        regions.append(_region_from_points(kind, correlation, current_strategy, current_points))
+    return tuple(regions)
+
+
+def _winner_crossovers(
+    points: Sequence[SweepAnalysisPoint],
+    *,
+    kind: str,
+) -> tuple[WinnerCrossover, ...]:
+    crossovers: list[WinnerCrossover] = []
+    for correlation in sorted({point.target_correlation for point in points}):
+        group = _points_for_correlation(points, correlation=correlation, kind=kind)
+        for lower, upper in zip(group, group[1:], strict=False):
+            lower_winner = _winner(lower, kind=kind)
+            upper_winner = _winner(upper, kind=kind)
+            if lower_winner is None or upper_winner is None or lower_winner == upper_winner:
+                continue
+            crossovers.append(
+                WinnerCrossover(
+                    kind=kind,
+                    correlation=correlation,
+                    lower_selectivity=lower.target_filter_selectivity,
+                    upper_selectivity=upper.target_filter_selectivity,
+                    estimated_selectivity=_midpoint_selectivity(
+                        lower.target_filter_selectivity,
+                        upper.target_filter_selectivity,
+                    ),
+                    from_strategy=lower_winner,
+                    to_strategy=upper_winner,
+                )
+            )
+    return tuple(crossovers)
+
+
+def _points_for_correlation(
+    points: Sequence[SweepAnalysisPoint],
+    *,
+    correlation: float,
+    kind: str,
+) -> list[SweepAnalysisPoint]:
+    return sorted(
+        (
+            point
+            for point in points
+            if point.target_correlation == correlation and _winner(point, kind=kind) is not None
+        ),
+        key=lambda point: point.target_filter_selectivity,
+    )
+
+
+def _winner(point: SweepAnalysisPoint, *, kind: str) -> str | None:
+    if kind == "measured":
+        return point.measured_best
+    if kind == "predicted":
+        return point.predicted_best
+    raise ValueError("kind must be measured or predicted")
+
+
+def _region_from_points(
+    kind: str,
+    correlation: float,
+    strategy: str,
+    points: Sequence[SweepAnalysisPoint],
+) -> WinnerRegion:
+    selectivities = [point.target_filter_selectivity for point in points]
+    return WinnerRegion(
+        kind=kind,
+        correlation=correlation,
+        strategy=strategy,
+        selectivity_min=min(selectivities),
+        selectivity_max=max(selectivities),
+        point_count=len(points),
+    )
+
+
+def _midpoint_selectivity(lower: float, upper: float) -> float:
+    if lower > 0.0 and upper > 0.0:
+        return math.sqrt(lower * upper)
+    return (lower + upper) / 2.0
+
+
+def _point_to_json(point: SweepAnalysisPoint) -> dict[str, object]:
+    return {
+        "target_filter_selectivity": point.target_filter_selectivity,
+        "target_correlation": point.target_correlation,
+        "observed_filter_selectivity": point.observed_filter_selectivity,
+        "s_local_p10": point.s_local_p10,
+        "s_local_median": point.s_local_median,
+        "measured_best": point.measured_best,
+        "predicted_best": point.predicted_best,
+        "prediction_match": point.prediction_match,
+        "postfilter_recall_at_k": point.postfilter_recall_at_k,
+        "postfilter_returns_k_rate": point.postfilter_returns_k_rate,
+        "postfilter_viable": point.postfilter_viable,
+        "strategies": [_strategy_to_json(strategy) for strategy in point.strategies],
+    }
+
+
+def _strategy_to_json(strategy: StrategyPointSummary) -> dict[str, object]:
+    return {
+        "strategy": strategy.strategy,
+        "recall_at_k": strategy.recall_at_k,
+        "returns_k_rate": strategy.returns_k_rate,
+        "latency_ms_mean": strategy.latency_ms_mean,
+        "latency_ms_p95": strategy.latency_ms_p95,
+    }
+
+
+def _region_to_json(region: WinnerRegion) -> dict[str, object]:
+    return {
+        "kind": region.kind,
+        "correlation": region.correlation,
+        "strategy": region.strategy,
+        "selectivity_min": region.selectivity_min,
+        "selectivity_max": region.selectivity_max,
+        "point_count": region.point_count,
+    }
+
+
+def _crossover_to_json(crossover: WinnerCrossover) -> dict[str, object]:
+    return {
+        "kind": crossover.kind,
+        "correlation": crossover.correlation,
+        "lower_selectivity": crossover.lower_selectivity,
+        "upper_selectivity": crossover.upper_selectivity,
+        "estimated_selectivity": crossover.estimated_selectivity,
+        "from_strategy": crossover.from_strategy,
+        "to_strategy": crossover.to_strategy,
+    }
+
+
+def _mapping_value(payload: Mapping[str, Any], key: str) -> Mapping[str, Any]:
+    return _as_mapping(payload.get(key), key)
+
+
+def _sequence_value(payload: Mapping[str, Any], key: str) -> Sequence[object]:
+    value = payload.get(key)
+    if not isinstance(value, Sequence) or isinstance(value, (str, bytes, bytearray)):
+        raise ValueError(f"{key} must be a list")
+    return value
+
+
+def _as_mapping(value: object, name: str) -> Mapping[str, Any]:
+    if not isinstance(value, Mapping):
+        raise ValueError(f"{name} must be an object")
+    return value
+
+
+def _str_value(payload: Mapping[str, Any], key: str) -> str:
+    value = payload.get(key)
+    if not isinstance(value, str) or not value:
+        raise ValueError(f"{key} must be a non-empty string")
+    return value
+
+
+def _optional_str_value(payload: Mapping[str, Any], key: str) -> str | None:
+    value = payload.get(key)
+    if value is None:
+        return None
+    if not isinstance(value, str) or not value:
+        raise ValueError(f"{key} must be null or a non-empty string")
+    return value
+
+
+def _optional_bool_value(payload: Mapping[str, Any], key: str) -> bool | None:
+    value = payload.get(key)
+    if value is None:
+        return None
+    if not isinstance(value, bool):
+        raise ValueError(f"{key} must be null or boolean")
+    return value
+
+
+def _float_value(payload: Mapping[str, Any], key: str) -> float:
+    value = payload.get(key)
+    if isinstance(value, bool) or not isinstance(value, (int, float)):
+        raise ValueError(f"{key} must be numeric")
+    number = float(value)
+    if not math.isfinite(number):
+        raise ValueError(f"{key} must be finite")
+    return number

vecadvisor/bench/datasets.py

@@ -0,0 +1,246 @@
+from __future__ import annotations
+
+import importlib
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+
+@dataclass(frozen=True)
+class SyntheticDataset:
+    vectors: Any
+    filter_mask: Any
+    cluster_ids: Any
+    centers: Any
+    filter_probabilities: tuple[float, ...]
+    filter_selectivity: float
+    correlation: float
+    seed: int
+    dataset_id: str = "synthetic"
+
+    @property
+    def n_rows(self) -> int:
+        return int(self.vectors.shape[0])
+
+    @property
+    def dim(self) -> int:
+        return int(self.vectors.shape[1])
+
+    @property
+    def observed_selectivity(self) -> float:
+        return float(self.filter_mask.mean())
+
+
+@dataclass(frozen=True)
+class SyntheticQueries:
+    vectors: Any
+    cluster_ids: Any
+    seed: int
+    cluster_policy: str
+
+    @property
+    def n_queries(self) -> int:
+        return int(self.vectors.shape[0])
+
+
+def generate_synthetic_dataset(
+    *,
+    n_rows: int = 10_000,
+    dim: int = 64,
+    n_clusters: int = 16,
+    filter_selectivity: float = 0.1,
+    correlation: float = 0.0,
+    seed: int = 0,
+    cluster_std: float = 0.08,
+) -> SyntheticDataset:
+    """Generate clustered vectors with a tunable correlated boolean filter."""
+
+    if n_rows <= 0:
+        raise ValueError("n_rows must be positive")
+    if dim <= 0:
+        raise ValueError("dim must be positive")
+    if n_clusters <= 0:
+        raise ValueError("n_clusters must be positive")
+    if not 0.0 < filter_selectivity < 1.0:
+        raise ValueError("filter_selectivity must be in (0, 1)")
+    if not -1.0 <= correlation <= 1.0:
+        raise ValueError("correlation must be in [-1, 1]")
+    if cluster_std <= 0.0:
+        raise ValueError("cluster_std must be positive")
+
+    np = _numpy()
+    rng = np.random.default_rng(seed)
+    centers = rng.normal(0.0, 1.0, size=(n_clusters, dim)).astype("float32")
+    centers /= np.maximum(np.linalg.norm(centers, axis=1, keepdims=True), 1e-12)
+
+    cluster_ids = rng.integers(0, n_clusters, size=n_rows, dtype="int32")
+    vectors = centers[cluster_ids] + rng.normal(0.0, cluster_std, size=(n_rows, dim)).astype(
+        "float32"
+    )
+    probabilities = _cluster_filter_probabilities(
+        filter_selectivity=filter_selectivity,
+        correlation=correlation,
+        n_clusters=n_clusters,
+    )
+    probability_array = np.asarray(probabilities, dtype="float64")
+    filter_mask = rng.random(n_rows) < probability_array[cluster_ids]
+    if not bool(filter_mask.any()):
+        filter_mask[int(rng.integers(0, n_rows))] = True
+    if bool(filter_mask.all()):
+        filter_mask[int(rng.integers(0, n_rows))] = False
+
+    return SyntheticDataset(
+        vectors=vectors.astype("float32", copy=False),
+        filter_mask=filter_mask,
+        cluster_ids=cluster_ids,
+        centers=centers,
+        filter_probabilities=probabilities,
+        filter_selectivity=filter_selectivity,
+        correlation=correlation,
+        seed=seed,
+    )
+
+
+def generate_synthetic_queries(
+    dataset: SyntheticDataset,
+    *,
+    n_queries: int = 100,
+    seed: int = 1,
+    cluster_policy: str = "uniform",
+    query_std: float = 0.04,
+) -> SyntheticQueries:
+    """Generate query vectors around dataset clusters."""
+
+    if n_queries <= 0:
+        raise ValueError("n_queries must be positive")
+    if query_std <= 0.0:
+        raise ValueError("query_std must be positive")
+
+    np = _numpy()
+    rng = np.random.default_rng(seed)
+    n_clusters = int(dataset.centers.shape[0])
+    if cluster_policy == "uniform":
+        probabilities = None
+    elif cluster_policy == "filter_hot":
+        weights = np.asarray(dataset.filter_probabilities, dtype="float64")
+        probabilities = weights / weights.sum()
+    elif cluster_policy == "filter_cold":
+        weights = 1.0 - np.asarray(dataset.filter_probabilities, dtype="float64")
+        probabilities = weights / weights.sum()
+    else:
+        raise ValueError("cluster_policy must be one of: uniform, filter_hot, filter_cold")
+
+    cluster_ids = rng.choice(n_clusters, size=n_queries, replace=True, p=probabilities).astype(
+        "int32"
+    )
+    vectors = dataset.centers[cluster_ids] + rng.normal(
+        0.0,
+        query_std,
+        size=(n_queries, dataset.dim),
+    ).astype("float32")
+    return SyntheticQueries(
+        vectors=vectors.astype("float32", copy=False),
+        cluster_ids=cluster_ids,
+        seed=seed,
+        cluster_policy=cluster_policy,
+    )
+
+
+def load_file_dataset(
+    *,
+    vectors_path: Path,
+    filter_mask_path: Path,
+    dataset_id: str = "file",
+) -> SyntheticDataset:
+    """Load vectors and a boolean filter mask from .npy files."""
+
+    np = _numpy()
+    vectors = np.load(vectors_path, mmap_mode="r")
+    if int(vectors.ndim) != 2:
+        raise ValueError("vectors .npy must be a 2D array")
+    if int(vectors.shape[0]) <= 0 or int(vectors.shape[1]) <= 0:
+        raise ValueError("vectors .npy must have at least one row and one dimension")
+    if vectors.dtype.kind not in {"f", "i", "u"}:
+        raise ValueError("vectors .npy must contain numeric values")
+
+    raw_mask = np.load(filter_mask_path, mmap_mode="r")
+    if int(raw_mask.ndim) != 1:
+        raise ValueError("filter mask .npy must be a 1D array")
+    if int(raw_mask.shape[0]) != int(vectors.shape[0]):
+        raise ValueError("filter mask length must match vector row count")
+    if raw_mask.dtype.kind not in {"b", "i", "u", "f"}:
+        raise ValueError("filter mask .npy must contain boolean or numeric values")
+
+    filter_mask = np.asarray(raw_mask, dtype="bool")
+    observed_selectivity = float(filter_mask.mean())
+    cluster_ids = np.zeros(int(vectors.shape[0]), dtype="int32")
+    centers = np.zeros((1, int(vectors.shape[1])), dtype="float32")
+    return SyntheticDataset(
+        vectors=vectors,
+        filter_mask=filter_mask,
+        cluster_ids=cluster_ids,
+        centers=centers,
+        filter_probabilities=(observed_selectivity,),
+        filter_selectivity=observed_selectivity,
+        correlation=0.0,
+        seed=0,
+        dataset_id=dataset_id,
+    )
+
+
+def load_file_queries(
+    *,
+    query_vectors_path: Path,
+    expected_dim: int,
+) -> SyntheticQueries:
+    """Load benchmark query vectors from a .npy file."""
+
+    np = _numpy()
+    vectors = np.load(query_vectors_path, mmap_mode="r")
+    if int(vectors.ndim) != 2:
+        raise ValueError("query vectors .npy must be a 2D array")
+    if int(vectors.shape[0]) <= 0:
+        raise ValueError("query vectors .npy must contain at least one query")
+    if int(vectors.shape[1]) != expected_dim:
+        raise ValueError("query vector dimension must match dataset vector dimension")
+    if vectors.dtype.kind not in {"f", "i", "u"}:
+        raise ValueError("query vectors .npy must contain numeric values")
+    return SyntheticQueries(
+        vectors=vectors,
+        cluster_ids=np.zeros(int(vectors.shape[0]), dtype="int32"),
+        seed=0,
+        cluster_policy="file",
+    )
+
+
+def _cluster_filter_probabilities(
+    *,
+    filter_selectivity: float,
+    correlation: float,
+    n_clusters: int,
+) -> tuple[float, ...]:
+    np = _numpy()
+    if abs(correlation) < 1e-12:
+        return tuple(float(filter_selectivity) for _ in range(n_clusters))
+
+    scores = np.linspace(1.0, -1.0, n_clusters, dtype="float64")
+    if correlation < 0.0:
+        scores = -scores
+    weights = np.exp(abs(correlation) * 4.0 * scores)
+    low = 0.0
+    high = max(1.0, filter_selectivity / float(weights.mean()))
+    while float(np.minimum(1.0, high * weights).mean()) < filter_selectivity:
+        high *= 2.0
+    for _ in range(64):
+        mid = (low + high) / 2.0
+        mean = float(np.minimum(1.0, mid * weights).mean())
+        if mean < filter_selectivity:
+            low = mid
+        else:
+            high = mid
+    probabilities = np.minimum(1.0, high * weights)
+    return tuple(float(value) for value in probabilities)
+
+
+def _numpy() -> Any:
+    return importlib.import_module("numpy")