ergodic 0.2.0__tar.gz → 0.2.1__tar.gz

{ergodic-0.2.0 → ergodic-0.2.1}/CHANGELOG.md

@@ -7,9 +7,24 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-## [0.2.0] - Unreleased
+## [0.2.1] - 2026-10-15
 
-To be released together with welt-client 0.13.
+### Fixed
+- `WeltLearner` fits a slot with no feature columns locally. An empty adjustment set
+  leaves nothing for a model to learn, so the nuisance is the training mean (or the
+  class frequencies for classification): no upload, no paid fit, no charge to
+  `max_fits`, and `predictor_id_` is `None`. In 0.2.0 it raised, so the "Discover in
+  Welt, estimate in ergodic" guide stopped whenever Welt's Arrow found no confounders
+  for the treatment, as it does on the guide's own data today. With no adjustment
+  variables, DML is then the cross-fitted regression slope of the outcome on the
+  treatment, identical to DML with ergodic's `ols` learner.
+- `ArcStats` treats two NaN gaps (START and END arcs) as equal and hashes them alike,
+  so `process_map(log) == process_map(log)` holds on Python 3.13 and 3.14, where
+  dataclass equality compares fields one by one.
+
+## [0.2.0] - 2026-10-15
+
+Released together with welt-client 0.13.
 
 ### Added
 - A versioned graph format. `MixedGraph.to_dict()` writes
@@ -710,7 +725,8 @@ inference, discovery, process, SCM, and forecast pillars.
   silently with single-graph semantics; it now dispatches on the face, and
   mixed graphs raise instead of being misread.
 
-[Unreleased]: https://github.com/ergodic-ai/ergodic/compare/v0.2.0...HEAD
+[Unreleased]: https://github.com/ergodic-ai/ergodic/compare/v0.2.1...HEAD
+[0.2.1]: https://github.com/ergodic-ai/ergodic/compare/v0.2.0...v0.2.1
 [0.2.0]: https://github.com/ergodic-ai/ergodic/compare/v0.1.1...v0.2.0
 [0.1.1]: https://github.com/ergodic-ai/ergodic/compare/v0.1.0...v0.1.1
 [0.1.0]: https://github.com/ergodic-ai/ergodic/releases/tag/v0.1.0

{ergodic-0.2.0 → ergodic-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: ergodic
-Version: 0.2.0
+Version: 0.2.1
 Summary: Causal AI: causal discovery, causal inference, and process intelligence.
 Project-URL: Homepage, https://docs.ergodic.dev
 Project-URL: Documentation, https://docs.ergodic.dev

{ergodic-0.2.0 → ergodic-0.2.1}/docsite/pages/compatibility.md

@@ -74,7 +74,7 @@ Only a graph that Welt declares a native DAG converts. `CausalResult.to_ergodic(
 in welt-client keeps every variable, unconnected ones included, and the native
 edge directions. It never projects, thresholds or relabels a graph into a DAG.
 
-| Welt model | Native graph | In ergodic 0.2.0 |
+| Welt model | Native graph | In ergodic 0.2 |
 | --- | --- | --- |
 | `arrow` | DAG | Converts. `ergodic.welt.discover` returns it as a `DiscoveryResult`. |
 | `cdfm` | Directed, may hold cycles | Refused before paying by default. With an explicit `decoder=`, its scores are decoded locally into a DAG labelled decoded. |

{ergodic-0.2.0 → ergodic-0.2.1}/docsite/pages/install.md

@@ -72,7 +72,7 @@ for module, use in optional.items():
 ```
 
 ```output from="install_check.py" lines="1"
-ergodic 0.2.0 writes ergodic.graph/1
+ergodic 0.2.1 writes ergodic.graph/1
 ```
 
 - **Step 1.** The version, and `ergodic.graph/1`: the format `MixedGraph.to_dict()`
@@ -104,7 +104,7 @@ xgboost yourself to use their models (the `welt` extra brings scikit-learn in).
 
 <details markdown="1"><summary>What are the neural and foundation extras?</summary>
 
-`neural` and `foundation` install PyTorch 2.2 or later. ergodic 0.2.0 has no
+`neural` and `foundation` install PyTorch 2.2 or later. ergodic 0.2 has no
 learner that uses it: asking `cate` for a neural or foundation-model learner raises
 `NotImplementedError`.
 

{ergodic-0.2.0 → ergodic-0.2.1}/docsite/pages/start.md

@@ -95,6 +95,6 @@ treatment does not affect.
 - [Estimate an average effect](estimate-average-effect.md): adjust for known confounders on real data.
 - [Notebooks](notebooks.md): the learn series and case studies.
 - [Python reference](reference.md): every function and its parameters.
-- [Example scripts](https://github.com/ergodic-ai/ergodic/tree/v0.2.0/examples): runnable analyses of the bundled datasets.
+- [Example scripts](https://github.com/ergodic-ai/ergodic/tree/v0.2.1/examples): runnable analyses of the bundled datasets.
 
 </div>

{ergodic-0.2.0 → ergodic-0.2.1}/docsite/pages/welt.md

@@ -1,7 +1,8 @@
 # Discover in Welt, estimate in ergodic
 
 Learn a causal graph with a hosted Welt model, then identify and estimate an effect
-on it in ergodic. Welt also fits the nuisance models inside the estimate.
+on it in ergodic. When the graph leaves variables to adjust for, Welt also fits the
+nuisance models inside the estimate.
 
 !!! need "You'll need"
     - Python 3.11, 3.12 or 3.13.
@@ -72,8 +73,10 @@ depends on the Arrow version Welt serves. Each step prints:
   variables, so a directed path from `nprenatal` to `bweight` is identified by
   adjustment. The record names the adjustment set.
 - **Step 4.** An `EffectEstimate(dml, analytic: …)` line: the average change in
-  grams per extra prenatal visit, its standard error and 95% interval. Then
-  `paid fits: 4`.
+  grams per extra prenatal visit, its standard error and 95% interval. Then the
+  paid fits: 4 (two slots times two folds) when the adjustment set has variables,
+  or 0 when it is empty, because a slot with no features is just a mean and runs
+  locally.
 
 ## Read the provenance
 
@@ -215,8 +218,10 @@ With no directed path from `nprenatal` to `bweight`, `identify_effect` returns t
 `null` strategy: by the graph, the effect is zero. `strategy="dml"` then raises,
 because DML estimates adjustment effects only.
 
-With an empty adjustment set, DML's nuisance models have no features, and
-`WeltLearner` raises before it fits. Leave those slots to the default learner.
+With an empty adjustment set, DML's nuisance models have no features: each one is
+just the training mean. `WeltLearner` fits that locally, with no upload and no paid
+fit, so the program prints `paid fits: 0` and the estimate is the regression slope
+of `bweight` on `nprenatal` across folds.
 
 </details>
 

{ergodic-0.2.0 → ergodic-0.2.1}/docsite/site.toml

@@ -31,7 +31,7 @@ commands = [
 
 [versions]
 # Published versions older than this build that stay in the picker (v<version>/), oldest first.
-previous = []
+previous = ["0.2.0"]
 
 [[products]]
 name = "ergodic"

{ergodic-0.2.0 → ergodic-0.2.1}/scripts/docsite/__main__.py

@@ -36,6 +36,11 @@ def main(argv: list[str] | None = None) -> int:
         )
     links = commands.add_parser("links", help="check internal links of a built site")
     links.add_argument("output", type=Path, nargs="?", default=ROOT / "site")
+    links.add_argument(
+        "--retained-elsewhere",
+        action="store_true",
+        help="count links into the retained versions (site.toml previous) as present",
+    )
     notebooks = commands.add_parser("notebooks", help="execute every notebook (release CI)")
     notebooks.add_argument("--timeout", type=int, default=1800)
     notebooks.add_argument("--workers", type=int, default=1)
@@ -93,7 +98,8 @@ def main(argv: list[str] | None = None) -> int:
         if args.command == "links":
             from .links import check_links
 
-            problems = check_links(args.output)
+            elsewhere = load_site().previous_versions if args.retained_elsewhere else ()
+            problems = check_links(args.output, elsewhere)
             for problem in problems:
                 print(problem, file=sys.stderr)
             print(f"Links: {len(problems)} problem(s) in {args.output}")

{ergodic-0.2.0 → ergodic-0.2.1}/scripts/docsite/links.py

@@ -22,9 +22,16 @@ def target_file(base: Path, reference: str) -> Path:
     return target / "index.html" if target.is_dir() else target
 
 
-def check_links(output: Path) -> list[str]:
+def check_links(output: Path, elsewhere: tuple[str, ...] = ()) -> list[str]:
+    """Problems with the site's internal links, assets and anchors.
+
+    ``elsewhere`` names version folders (``"0.2.0"`` for ``v0.2.0/``) that another
+    build publishes next to this one: links into them count as present. The full
+    published site is checked without it.
+    """
     problems = []
     root = output.resolve()
+    retained = [root / f"v{version}" for version in elsewhere]
     for page in sorted(root.rglob("*.html")):
         text = page.read_text()
         for match in ATTRIBUTE.finditer(text):
@@ -39,6 +46,8 @@ def check_links(output: Path) -> list[str]:
             if not target.is_relative_to(root):
                 problems.append(f"{where}: {reference} leaves the site")
                 continue
+            if any(target == folder or target.is_relative_to(folder) for folder in retained):
+                continue
             if not target.exists():
                 problems.append(f"{where}: missing {reference}")
                 continue

{ergodic-0.2.0 → ergodic-0.2.1}/src/ergodic/__init__.py

@@ -132,7 +132,7 @@ from .scm import (
     Sensitivity,
 )
 
-__version__ = "0.2.0"
+__version__ = "0.2.1"
 
 __all__ = [
     "GRAPH_FORMAT",

{ergodic-0.2.0 → ergodic-0.2.1}/src/ergodic/process/_map.py

@@ -46,19 +46,40 @@ def _is_boundary(pair: tuple[str, str]) -> bool:
     return pair[0] == START or pair[1] == END
 
 
-@dataclass(frozen=True)
+def _same_gap(a: float, b: float) -> bool:
+    return a == b or (math.isnan(a) and math.isnan(b))
+
+
+@dataclass(frozen=True, eq=False)
 class ArcStats:
     """Traversal count and gap timing for one arc of the map.
 
     ``mean_gap`` and ``median_gap`` are seconds between the two events. A
-    START or END arc has no second event, so both are NaN there (the one
-    shared ``math.nan`` object, which keeps identically built maps equal).
+    START or END arc has no second event, so both are NaN there. Equality treats
+    two NaN gaps as equal, so identically built maps compare equal on every
+    Python (dataclass equality compares fields one by one from 3.13 on, where
+    ``nan == nan`` is false).
     """
 
     count: int
     mean_gap: float
     median_gap: float
 
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, ArcStats):
+            return NotImplemented
+        return (
+            self.count == other.count
+            and _same_gap(self.mean_gap, other.mean_gap)
+            and _same_gap(self.median_gap, other.median_gap)
+        )
+
+    def __hash__(self) -> int:
+        def key(gap: float) -> float | None:
+            return None if math.isnan(gap) else gap
+
+        return hash((self.count, key(self.mean_gap), key(self.median_gap)))
+
 
 @dataclass(frozen=True)
 class ProcessMap:

{ergodic-0.2.0 → ergodic-0.2.1}/src/ergodic/welt/_learner.py

@@ -51,11 +51,6 @@ def _features(X: Any) -> npt.NDArray[np.float64]:
     matrix = np.asarray(X, dtype=np.float64)
     if matrix.ndim != 2:
         raise ValueError(f"X must be a 2-D matrix; got shape {matrix.shape}")
-    if matrix.shape[1] == 0:
-        raise ValueError(
-            "WeltLearner needs at least one feature column, and this slot has none (an "
-            "empty adjustment set). Leave this slot to the default learner"
-        )
     if matrix.shape[0] == 0:
         raise ValueError("X has no rows")
     return matrix
@@ -85,6 +80,11 @@ class WeltLearner:
     is a paid prediction, sent in batches no larger than the model's prediction-row
     limit. DML with ``n_folds=k`` fits ``2 * k`` times.
 
+    A slot with no feature columns (an empty adjustment set) has nothing for a model
+    to learn: its conditional mean is the training mean, or the class frequencies for
+    classification. The learner fits that locally, with no upload, no paid fit and no
+    charge to ``max_fits``, and ``predictor_id_`` is ``None``.
+
     The learner and its clones share one budget of ``max_fits`` fits. It caps paid
     fits only, not predictions: each fit is followed by one prediction call per
     batch of held-out rows (DML on 8,000 rows with five folds and a 100-row limit
@@ -113,8 +113,10 @@ class WeltLearner:
             leaves the job running in Welt.
 
     Attributes:
-        predictor_id_: The fitted Welt predictor's id.
-        model_version_: The exact model version Welt fitted.
+        predictor_id_: The fitted Welt predictor's id; ``None`` after a no-feature
+            (local) fit.
+        model_version_: The exact model version Welt fitted; ``None`` after a
+            no-feature fit.
         classes_: The class labels, sorted (classification only).
         supports_sample_weight: Always ``False``; read by ergodic's weighted slots.
     """
@@ -224,7 +226,8 @@ class WeltLearner:
         """Fit a Welt predictor on these rows: one paid fit.
 
         Args:
-            X: The feature matrix, one row per unit and at least one column.
+            X: The feature matrix, one row per unit. With no columns the fit is the
+                local training mean (or class frequencies) and costs nothing.
             y: The target, one value per row: numbers for regression, labels for
                 classification.
             sample_weight: Must be ``None``. Welt fits take no row weights, and a
@@ -234,8 +237,8 @@ class WeltLearner:
             This learner, fitted.
 
         Raises:
-            ValueError: ``sample_weight`` was given, ``X`` has no columns or rows,
-                or ``y`` does not match ``X``. Nothing is uploaded.
+            ValueError: ``sample_weight`` was given, ``X`` has no rows, or ``y``
+                does not match ``X``. Nothing is uploaded.
             RuntimeError: The shared ``max_fits`` budget is spent.
         """
         if sample_weight is not None:
@@ -254,10 +257,12 @@ class WeltLearner:
                 raise ValueError("regression targets must be finite")
         else:
             labels = [_label(value) for value in target]
+        for name in ("predictor_id_", "model_version_", "classes_", "_order", "_local"):
+            self.__dict__.pop(name, None)
+        if matrix.shape[1] == 0:
+            return self._fit_local(labels)
         columns = [f"x{i}" for i in range(matrix.shape[1])]
         rows = [[*row, label] for row, label in zip(matrix_rows(matrix), labels, strict=True)]
-        for name in ("predictor_id_", "model_version_", "classes_", "_order"):
-            self.__dict__.pop(name, None)
         with using(self.client) as client:
             # The free catalogue read comes first, so a failed lookup costs no fit
             # and cannot strand a paid predictor.
@@ -278,8 +283,8 @@ class WeltLearner:
             predictor = job.result(timeout=self.timeout)
         if predictor.get("task") != self.task:
             raise ValueError("Welt fitted a predictor for a different task")
-        self.predictor_id_: str = predictor["id"]
-        self.model_version_: str = predictor["model_version"]
+        self.predictor_id_: str | None = predictor["id"]
+        self.model_version_: str | None = predictor["model_version"]
         self._n_features = matrix.shape[1]
         if self.task == "classification":
             classes = np.asarray(predictor["classes"])
@@ -287,6 +292,20 @@ class WeltLearner:
             self.classes_ = classes[self._order]
         return self
 
+    def _fit_local(self, labels: list[Any]) -> Self:
+        """The no-feature fit: the training mean, or the class frequencies, kept here."""
+        self.predictor_id_ = None
+        self.model_version_ = None
+        self._n_features = 0
+        if self.task == "regression":
+            self._local: npt.NDArray[Any] = np.asarray([np.mean(labels)], dtype=np.float64)
+            return self
+        classes, counts = np.unique(np.asarray(labels), return_counts=True)
+        self.classes_ = classes
+        self._order = np.arange(len(classes))
+        self._local = counts / counts.sum()
+        return self
+
     def _limit(self, client: Any) -> int | None:
         """The model's prediction-row limit from Welt's catalogue, if it states one."""
         for profile in client.model(self.model).get("task_profiles", []):
@@ -295,12 +314,16 @@ class WeltLearner:
                 return int(limit) if limit else None
         return None
 
-    def _predict(self, X: npt.NDArray[np.float64], probabilities: bool) -> list[dict[str, Any]]:
+    def _checked(self, X: npt.NDArray[np.float64]) -> npt.NDArray[np.float64]:
         if not hasattr(self, "predictor_id_"):
             raise RuntimeError("WeltLearner is not fitted; call fit first")
         matrix = _features(X)
         if matrix.shape[1] != self._n_features:
             raise ValueError(f"X has {matrix.shape[1]} columns; the fit had {self._n_features}")
+        return matrix
+
+    def _predict(self, X: npt.NDArray[np.float64], probabilities: bool) -> list[dict[str, Any]]:
+        matrix = self._checked(X)
         columns = [f"x{i}" for i in range(matrix.shape[1])]
         rows = matrix_rows(matrix)
         size = self._budget.prediction_rows.get((self.model, self.task)) or len(rows)
@@ -334,6 +357,11 @@ class WeltLearner:
             Numbers in the target's units for regression, class labels for
             classification.
         """
+        if "_local" in self.__dict__:
+            n = self._checked(X).shape[0]
+            if self.task == "regression":
+                return np.full(n, self._local[0], dtype=np.float64)
+            return np.full(n, self.classes_[int(np.argmax(self._local))])
         answers = self._predict(X, probabilities=False)
         values = [value for answer in answers for value in answer["predictions"]]
         if self.task == "regression":
@@ -341,6 +369,8 @@ class WeltLearner:
         return np.asarray(values)
 
     def _predict_proba(self, X: npt.NDArray[np.float64]) -> npt.NDArray[np.float64]:
+        if "_local" in self.__dict__:
+            return np.tile(self._local, (self._checked(X).shape[0], 1))
         answers = self._predict(X, probabilities=True)
         blocks = []
         for answer in answers:

{ergodic-0.2.0 → ergodic-0.2.1}/tests/test_docs_welt_page.py

@@ -26,9 +26,7 @@ from scripts.docsite.examples import programs_of  # noqa: E402
 from tests.test_welt import FakeWelt  # noqa: E402
 
 
-def test_the_welt_page_program_runs_against_the_fake(
-    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
-) -> None:
+def _run_page_program(fake: FakeWelt, monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> list[str]:
     site = load_site()
     page = site.pages_dir / "welt.md"
     (program,) = [p for p in programs_of(page, site) if p.name == "welt_effect.py"]
@@ -36,7 +34,6 @@ def test_the_welt_page_program_runs_against_the_fake(
 
     monkeypatch.delenv("WELT_WORKSPACE", raising=False)
     monkeypatch.delenv("WELT_BASE_URL", raising=False)
-    fake = FakeWelt()
     real = welt.Client
 
     def client(*args: Any, **kwargs: Any) -> Any:
@@ -49,7 +46,14 @@ def test_the_welt_page_program_runs_against_the_fake(
     printed = io.StringIO()
     with contextlib.redirect_stdout(printed):
         runpy.run_path(str(script), run_name="__main__")
-    lines = printed.getvalue().splitlines()
+    return printed.getvalue().splitlines()
+
+
+def test_the_welt_page_program_runs_against_the_fake(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    fake = FakeWelt()
+    lines = _run_page_program(fake, monkeypatch, tmp_path)
 
     # The fake's discovery returns a chain over the uploaded column order (the last
     # column left unconnected), so the page's story holds: a path from nprenatal to
@@ -69,6 +73,34 @@ def test_the_welt_page_program_runs_against_the_fake(
     assert sent[("POST", "datasets")] == 5
 
 
+def test_the_welt_page_program_runs_when_the_graph_leaves_nothing_to_adjust(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    """The graph production Arrow returned on 2026-10-15: nprenatal has no parents.
+
+    The adjustment set is empty, so both DML slots are training means fitted locally:
+    the page still prints an estimate, and the only paid request is the discovery.
+    """
+    edges = [
+        ("nprenatal", "bweight"),
+        ("fage", "mage"),
+        ("fage", "medu"),
+        ("mage", "medu"),
+    ]
+    flat = [[0.0 if i == j else 0.25 for j in range(5)] for i in range(5)]
+    fake = FakeWelt(native={"arrow": {"values": flat, "edges": edges, "decoder": {"name": "x"}}})
+    lines = _run_page_program(fake, monkeypatch, tmp_path)
+
+    assert "bweight <-- nprenatal" in lines
+    assert any(line.startswith("Identification(adjustment:") for line in lines)
+    assert any(line.startswith("EffectEstimate(dml, analytic:") for line in lines)
+    assert lines[-1] == "paid fits: 0"
+    sent = Counter((method, path.split("/")[2]) for method, path in fake.calls)
+    assert sent[("POST", "discoveries")] == 1
+    assert sent[("POST", "fits")] == 0
+    assert sent[("POST", "predictors")] == 0
+
+
 # CDFM in the fake: an adaptive threshold of 0.3 and four native edges above it, three
 # of which (medu -> nprenatal -> bweight -> medu) form a cycle.
 _COLUMNS = ["mage", "medu", "nprenatal", "bweight", "fage"]

{ergodic-0.2.0 → ergodic-0.2.1}/tests/test_docsite.py

@@ -227,7 +227,12 @@ def test_build_is_versioned_and_linked(tmp_path: Path) -> None:
     changelog = (output / "changelog.html").read_text()
     release = re.search(r"^## \[(\d+\.\d+\.\d+)\]", (ROOT / "CHANGELOG.md").read_text(), re.M)
     assert release is not None and f">{release[1]}</a> - " in changelog
-    assert check_links(output) == []
+    # The retained versions come from their own tags' builds; until those are placed,
+    # links into them are the only problems, and --retained-elsewhere excuses them.
+    assert check_links(output, site.previous_versions) == []
+    missing = check_links(output)
+    assert missing  # The picker links to every retained version.
+    assert all(any(f"v{v}/" in problem for v in site.previous_versions) for problem in missing)
 
 
 def test_build_fails_on_an_undocumented_public_name(

{ergodic-0.2.0 → ergodic-0.2.1}/tests/test_process_map.py

@@ -214,6 +214,17 @@ def test_performance_unknown_lifecycle_column_raises() -> None:
 # -- determinism ---------------------------------------------------------------
 
 
+def test_arc_stats_with_nan_gaps_compare_and_hash_equal() -> None:
+    from ergodic.process._map import ArcStats
+
+    # Distinct NaN objects, so equality cannot lean on identity.
+    left = ArcStats(count=2, mean_gap=float("nan"), median_gap=float("nan"))
+    right = ArcStats(count=2, mean_gap=float("nan"), median_gap=float("nan"))
+    assert left == right and hash(left) == hash(right)
+    assert left != ArcStats(count=3, mean_gap=float("nan"), median_gap=float("nan"))
+    assert ArcStats(1, 2.0, 2.0) != ArcStats(1, 2.0, float("nan"))
+
+
 def test_repeated_calls_give_equal_objects() -> None:
     plain = _two_case_log()
     skewed = _skewed_log()

{ergodic-0.2.0 → ergodic-0.2.1}/tests/test_welt.py

@@ -588,9 +588,45 @@ def test_sample_weight_is_refused_not_ignored() -> None:
     assert learner.fits_used == 0
 
 
-def test_an_empty_feature_matrix_is_refused_before_a_fit() -> None:
-    with pytest.raises(ValueError, match="at least one feature"):
-        WeltLearner(client=object()).fit(np.empty((5, 0)), np.arange(5.0))
+def test_a_slot_with_no_features_is_fitted_locally_for_free() -> None:
+    """An empty adjustment set leaves the mean (or class frequencies): no request, no fit."""
+    fake = FakeWelt()
+    with fake.client() as client:
+        regression = WeltLearner(client=client, max_fits=1).fit(
+            np.empty((4, 0)), np.array([1.0, 2, 3, 6])
+        )
+        np.testing.assert_allclose(regression.predict(np.empty((3, 0))), [3.0, 3.0, 3.0])
+        classifier = WeltLearner(task="classification", client=client, max_fits=1)
+        classifier.fit(np.empty((4, 0)), np.array([1.0, 0.0, 1.0, 1.0]))
+        np.testing.assert_allclose(classifier.predict_proba(np.empty((2, 0))), [[0.25, 0.75]] * 2)
+        assert classifier.predict(np.empty((2, 0))).tolist() == [1.0, 1.0]
+        with pytest.raises(ValueError, match="columns"):
+            regression.predict(np.ones((3, 1)))
+    assert fake.calls == []
+    assert regression.fits_used == 0 and classifier.fits_used == 0
+    assert regression.predictor_id_ is None and regression.model_version_ is None
+    assert classifier.classes_.tolist() == [0, 1]
+    with pytest.raises(ValueError, match="no rows"):
+        WeltLearner(client=object()).fit(np.empty((0, 0)), np.array([]))
+
+
+def test_dml_with_an_empty_adjustment_set_pays_for_nothing() -> None:
+    """No confounders: both DML nuisances are training means, exactly as ergodic's OLS."""
+    fake = FakeWelt()
+    data = continuous(n=200).select(["X", "Y"])
+    graph = dag(["X -> Y"])
+    native = estimate_effect(
+        graph, data, "X", "Y", strategy="dml", learner="ols", random_state=3, n_folds=2
+    )
+    with fake.client() as client:
+        learner = WeltLearner("tabicl-v2", client=client)
+        hosted = estimate_effect(
+            graph, data, "X", "Y", strategy="dml", learner=learner, random_state=3, n_folds=2
+        )
+    assert hosted.value == pytest.approx(native.value, rel=1e-9)
+    assert hosted.std_error == pytest.approx(native.std_error, rel=1e-9)
+    assert learner.fits_used == 0
+    assert fake.calls == []
 
 
 def test_regression_fit_and_batched_predict() -> None: