Datasets:
Formats:
parquet
Size:
100K - 1M
Tags:
population-genetics
demographic-inference
effective-population-size
coalescent
msprime
simulation
License:
| """Loader for the frozen stdpopsim single-population trajectories. | |
| These eighteen models, across eight species, are the held-out evaluation set. | |
| They exist so that generalisation can be measured against histories that were | |
| published by other people for other reasons, rather than against our own prior | |
| re-drawn -- which measures nothing. phlash validates the same way, on twelve | |
| stdpopsim models across eight species. | |
| The trajectories are frozen into ``data/templates/stdpopsim_single_pop`` by | |
| ``scripts/build_stdpopsim_single_pop.py`` rather than imported at runtime; the | |
| reasons are in that script's docstring. | |
| """ | |
| from __future__ import annotations | |
| import csv | |
| from dataclasses import dataclass | |
| from functools import lru_cache | |
| from pathlib import Path | |
| import numpy as np | |
| from .assets import asset_path | |
| from .config import NE_LOG10_BOUNDS, Config | |
| DEFAULT_STDPOPSIM_TEMPLATE_PATH = "data/templates/stdpopsim_single_pop/trajectories.csv" | |
| # Models held out of the draw because another recipe produces them. Empty at | |
| # present: Zigzag_1S14 had a recipe of its own for a while and was excluded here | |
| # so that exactly one code path produced it; that recipe is gone and the model | |
| # is back in the catalogue. The hand-written published event table stays in | |
| # ``demography.py`` as the independent source this freeze is checked against. | |
| CATALOGUE_EXCLUSIONS: frozenset[str] = frozenset() | |
| class StdpopsimTemplate: | |
| species: str | |
| model_id: str | |
| population: str | |
| generation_time_years: float | |
| breaks: tuple[float, ...] | |
| values: tuple[float, ...] | |
| growth_rates: tuple[float, ...] | |
| ne_rescale: float | |
| def key(self) -> str: | |
| return "%s/%s" % (self.species, self.model_id) | |
| def _fit_to_bounds(values: tuple[float, ...]) -> float: | |
| """Return the single factor that slides a trajectory into the Ne band. | |
| Two of the eighteen models -- *Anopheles gambiae* and the Indian | |
| *M. m. castaneus* -- carry effective sizes above a million, and one Holstein | |
| model dips below a hundred. Clipping them would flatten exactly the | |
| features they are held out to test, so the whole trajectory is multiplied by | |
| one constant instead: Ne is only identifiable jointly with the mutation | |
| rate, and a uniform factor leaves the shape -- which is what generalisation | |
| is being measured on -- bit-for-bit intact. The factor is recorded so the | |
| published model can always be recovered. | |
| """ | |
| low, high = 10.0 ** NE_LOG10_BOUNDS[0], 10.0 ** NE_LOG10_BOUNDS[1] | |
| smallest, largest = min(values), max(values) | |
| if largest / smallest > high / low: | |
| raise ValueError("trajectory spans more than the declared Ne band") | |
| if largest > high: | |
| return high / largest | |
| if smallest < low: | |
| return low / smallest | |
| return 1.0 | |
| def _load(path: str) -> tuple[StdpopsimTemplate, ...]: | |
| source = asset_path(path) | |
| if not source.exists(): | |
| return () | |
| grouped: dict[tuple[str, str], list[dict[str, str]]] = {} | |
| with source.open(newline="") as stream: | |
| for row in csv.DictReader(stream): | |
| grouped.setdefault((row["species"], row["model_id"]), []).append(row) | |
| out: list[StdpopsimTemplate] = [] | |
| for (species, model_id), rows in sorted(grouped.items()): | |
| rows.sort(key=lambda item: int(item["epoch_index"])) | |
| starts = [float(item["start_generations_ago"]) for item in rows] | |
| sizes = tuple(float(item["size"]) for item in rows) | |
| rates = tuple(float(item["growth_rate_per_generation"]) for item in rows) | |
| rescale = _fit_to_bounds(sizes) | |
| out.append( | |
| StdpopsimTemplate( | |
| species=species, | |
| model_id=model_id, | |
| population=rows[0]["population"], | |
| generation_time_years=float(rows[0]["generation_time_years"]), | |
| breaks=tuple(starts[1:]), | |
| values=tuple(size * rescale for size in sizes), | |
| growth_rates=rates, | |
| ne_rescale=float(rescale), | |
| ) | |
| ) | |
| return tuple(out) | |
| def load_stdpopsim_templates(cfg: Config) -> tuple[StdpopsimTemplate, ...]: | |
| return _load(str(getattr(cfg, "stdpopsim_template_path", DEFAULT_STDPOPSIM_TEMPLATE_PATH))) | |
| def stdpopsim_templates_available(cfg: Config) -> bool: | |
| return len(drawable_stdpopsim_templates(cfg)) > 0 | |
| def drawable_stdpopsim_templates(cfg: Config) -> tuple[StdpopsimTemplate, ...]: | |
| """The catalogue minus the models that have a recipe of their own.""" | |
| return tuple( | |
| template | |
| for template in load_stdpopsim_templates(cfg) | |
| if template.model_id not in CATALOGUE_EXCLUSIONS | |
| ) | |
| def choose_stdpopsim_template( | |
| rng: np.random.Generator, cfg: Config | |
| ) -> StdpopsimTemplate | None: | |
| templates = drawable_stdpopsim_templates(cfg) | |
| if not templates: | |
| return None | |
| return templates[int(rng.integers(0, len(templates)))] | |