sampledisco 0.4.2__tar.gz → 0.5.0__tar.gz

{sampledisco-0.4.2/src/sampledisco.egg-info → sampledisco-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sampledisco
-Version: 0.4.2
+Version: 0.5.0
 Summary: Cross-omics, cross-condition sample embedding for single-cell data (RNA + ATAC)
 Author: Hongkai Ji
 Author-email: Harry Jiang <hjiang55@jh.edu>
@@ -109,6 +109,7 @@ code/
 │   ├── sample_clustering/         # Hierarchical (HRA / HRC / NN / UPGMA / consensus), K-means, proportion test, RAISIN
 │   ├── sample_trajectory/         # CCA (supervised) and TSCAN (unsupervised) + GAM-based trajectory DGE
 │   ├── sample_association/        # Per-PC variance explained vs sample-level covariates (permutation FDR)
+│   ├── sample_prediction/         # Cross-validated phenotype prediction from the PCs; kNN label transfer
 │   ├── visualization/             # Embedding plots, dendrograms, DGE volcanos, modality-aware multi-omics scatters
 │   ├── utils/                     # Shared helpers: seed, safe h5ad I/O, limma, TF-IDF, batch regress, Grouping
 │   └── gene_activity/             # ATAC peak → gene activity inference + RNA-ATAC validation

{sampledisco-0.4.2 → sampledisco-0.5.0}/README.md

@@ -61,6 +61,7 @@ code/
 │   ├── sample_clustering/         # Hierarchical (HRA / HRC / NN / UPGMA / consensus), K-means, proportion test, RAISIN
 │   ├── sample_trajectory/         # CCA (supervised) and TSCAN (unsupervised) + GAM-based trajectory DGE
 │   ├── sample_association/        # Per-PC variance explained vs sample-level covariates (permutation FDR)
+│   ├── sample_prediction/         # Cross-validated phenotype prediction from the PCs; kNN label transfer
 │   ├── visualization/             # Embedding plots, dendrograms, DGE volcanos, modality-aware multi-omics scatters
 │   ├── utils/                     # Shared helpers: seed, safe h5ad I/O, limma, TF-IDF, batch regress, Grouping
 │   └── gene_activity/             # ATAC peak → gene activity inference + RNA-ATAC validation

{sampledisco-0.4.2 → sampledisco-0.5.0}/pyproject.toml

@@ -9,7 +9,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "sampledisco"
-version = "0.4.2"
+version = "0.5.0"
 description = "Cross-omics, cross-condition sample embedding for single-cell data (RNA + ATAC)"
 readme = "README.md"
 requires-python = ">=3.10"

{sampledisco-0.4.2 → sampledisco-0.5.0}/src/sampledisco/__init__.py

@@ -6,6 +6,8 @@ pull scanpy / torch / scGLUE until you actually call into the pipeline):
     import sampledisco
     sampledisco.wrapper(...)                 # full pipeline (RNA / ATAC / multi-omics)
     sampledisco.compute_sample_embedding(...)  # the core method only
+    sampledisco.predict_phenotype(...)       # cross-validated phenotype prediction from the PCs
+    sampledisco.transfer_labels(...)         # kNN label transfer in the sample embedding
 
 The CLI entry point is ``sampledisco --config <yaml>`` (see ``sampledisco.cli``).
 """
@@ -18,7 +20,7 @@ try:
 except PackageNotFoundError:  # running from a source tree that isn't installed
     __version__ = "0.0.0+unknown"
 
-__all__ = ["wrapper", "compute_sample_embedding"]
+__all__ = ["wrapper", "compute_sample_embedding", "predict_phenotype", "transfer_labels"]
 
 
 def __getattr__(name: str):
@@ -29,4 +31,7 @@ def __getattr__(name: str):
     if name == "compute_sample_embedding":
         from sampledisco.sample_embedding import compute_sample_embedding
         return compute_sample_embedding
+    if name in ("predict_phenotype", "transfer_labels"):
+        from sampledisco.sample_prediction import prediction
+        return getattr(prediction, name)
     raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

sampledisco-0.5.0/src/sampledisco/sample_prediction/__init__.py

@@ -0,0 +1,4 @@
+"""Supervised downstream use of the sample embedding: phenotype prediction and label transfer."""
+from sampledisco.sample_prediction.prediction import predict_phenotype, transfer_labels
+
+__all__ = ["predict_phenotype", "transfer_labels"]

sampledisco-0.5.0/src/sampledisco/sample_prediction/prediction.py

@@ -0,0 +1,186 @@
+"""Supervised use of the sample embedding: phenotype prediction and label transfer.
+
+Both functions take a one-row-per-sample AnnData (``build_sample_adata``), read the
+first ``n_pcs`` components of ``uns['X_DR_sample']`` (``obsm`` as fallback) and the
+labels from ``.obs``.
+"""
+from typing import Dict, Optional, Sequence, Tuple
+
+import numpy as np
+import pandas as pd
+from anndata import AnnData
+from scipy.spatial.distance import cdist
+from sklearn.linear_model import LogisticRegression, Ridge
+from sklearn.metrics import accuracy_score, balanced_accuracy_score, r2_score, roc_auc_score
+from sklearn.model_selection import GridSearchCV, GroupKFold, StratifiedGroupKFold
+from sklearn.pipeline import Pipeline
+from sklearn.preprocessing import StandardScaler
+
+
+def _embedding(pseudo_adata: AnnData, n_pcs: Optional[int]) -> np.ndarray:
+    emb = pseudo_adata.uns.get("X_DR_sample")
+    if isinstance(emb, pd.DataFrame):
+        X = emb.loc[pseudo_adata.obs_names].to_numpy(dtype=float)
+    elif "X_DR_sample" in pseudo_adata.obsm:
+        X = np.asarray(pseudo_adata.obsm["X_DR_sample"], dtype=float)
+    else:
+        raise KeyError("'X_DR_sample' not found in .uns or .obsm; build the AnnData with build_sample_adata.")
+    return X[:, :n_pcs]
+
+
+def predict_phenotype(
+    pseudo_adata: AnnData,
+    label_col: str,
+    *,
+    group_col: Optional[str] = None,
+    n_pcs: Optional[int] = None,
+    task: str = "classification",
+    score_by: str = "sample",
+    n_splits: int = 5,
+    random_state: int = 0,
+) -> Tuple[pd.DataFrame, Dict]:
+    """Out-of-fold prediction of a sample phenotype from the first ``n_pcs`` embedding PCs.
+
+    Standardized PCs feed an L2 logistic regression (``task="classification"``, binary or
+    multiclass) or a ridge regression (``task="regression"``). The penalty is chosen by an
+    inner 3-fold grouped CV inside each training split (scored by AUC, balanced accuracy
+    or R²) from C in {10, 1, 0.1, 0.01} or alpha in {0.1, 1, 10, 100}; a tie goes to the
+    weakest penalty. The outer split is ``n_splits``-fold, stratified by class for
+    classification and seeded by ``random_state``. With ``group_col`` (e.g. donor) every
+    sample of a group falls in the same fold, outer and inner, so draws of one donor are
+    never in training and test at once. Samples with a missing label are left out. This is
+    the recipe of the paper's Sound Life trait prediction.
+
+    ``score_by="group"`` scores groups instead of samples: the out-of-fold probabilities
+    (or predictions) and the labels are averaged over ``group_col`` before scoring (the
+    majority label for classification), as for the paper's donor-level AUCs.
+
+    Returns ``(predictions, metrics)``. ``predictions`` is indexed by sample with columns
+    ``label``, ``predicted``, ``fold`` and, for classification, ``prob_<class>``.
+    ``metrics`` holds ``n_samples``, ``n_groups``, ``n_pcs``, the penalty chosen in each
+    fold (``C`` or ``alpha``) and ``auc`` (binary; the second class in sorted order is
+    positive), ``accuracy`` and ``balanced_accuracy`` (classification) or ``r2``
+    (regression), computed on the out-of-fold predictions at the ``score_by`` level.
+    """
+    if task not in ("classification", "regression") or score_by not in ("sample", "group"):
+        raise ValueError("task must be 'classification' or 'regression', score_by 'sample' or 'group'.")
+    obs = pseudo_adata.obs
+    keep = obs[label_col].notna().to_numpy()
+    X = _embedding(pseudo_adata, n_pcs)[keep]
+    labels = obs[label_col].to_numpy()[keep]
+    groups = (obs[group_col] if group_col else obs.index.to_series()).astype(str).to_numpy()[keep]
+
+    if task == "classification":
+        classes, y = np.unique(labels, return_inverse=True)
+        model, param = LogisticRegression(max_iter=3000), "C"
+        grid, scoring = [10, 1, 0.1, 0.01], "roc_auc" if len(classes) == 2 else "balanced_accuracy"
+        outer = StratifiedGroupKFold(n_splits, shuffle=True, random_state=random_state).split(X, y, groups)
+        P = np.zeros((len(y), len(classes)))
+    else:
+        y = labels.astype(float)
+        model, param, grid, scoring = Ridge(), "alpha", [0.1, 1, 10, 100], "r2"
+        codes = np.unique(groups, return_inverse=True)[1]
+        shuffled = np.random.default_rng(random_state).permutation(codes.max() + 1)[codes]
+        outer = GroupKFold(n_splits).split(X, y, shuffled)
+        pred = np.zeros(len(y))
+
+    fold, chosen = np.zeros(len(y), dtype=int), []
+    pipe = Pipeline([("scale", StandardScaler()), ("model", model)])
+    for i, (tr, te) in enumerate(outer):
+        gs = GridSearchCV(pipe, {f"model__{param}": grid}, cv=GroupKFold(3), scoring=scoring)
+        gs.fit(X[tr], y[tr], groups=groups[tr])
+        chosen.append(gs.best_params_[f"model__{param}"])
+        fold[te] = i
+        if task == "classification":
+            P[np.ix_(te, gs.classes_)] = gs.predict_proba(X[te])
+        else:
+            pred[te] = gs.predict(X[te])
+
+    metrics = {"task": task, "score_by": score_by, "n_samples": len(y), "n_groups": len(np.unique(groups)),
+               "n_pcs": X.shape[1], param: chosen}
+    out = pd.DataFrame({"label": labels}, index=obs.index[keep])
+    if task == "classification":
+        out["predicted"] = classes[P.argmax(1)]
+        for j, c in enumerate(classes):
+            out[f"prob_{c}"] = P[:, j]
+        Y = np.eye(len(classes))[y]  # one-hot; summed over a group = class counts
+        if score_by == "group":
+            Y = pd.DataFrame(Y).groupby(groups).sum().to_numpy()
+            P = pd.DataFrame(P).groupby(groups).mean().to_numpy()
+        y, hard = Y.argmax(1), P.argmax(1)
+        if len(classes) == 2:
+            metrics["auc"] = float(roc_auc_score(y, P[:, 1]))
+        metrics["accuracy"] = float(accuracy_score(y, hard))
+        metrics["balanced_accuracy"] = float(balanced_accuracy_score(y, hard))
+    else:
+        out["predicted"] = pred
+        if score_by == "group":
+            y, pred = (pd.Series(v).groupby(groups).mean().to_numpy() for v in (y, pred))
+        metrics["r2"] = float(r2_score(y, pred))
+    out["fold"] = fold
+    return out.infer_objects(), metrics
+
+
+def _knn_vote(D: np.ndarray, y: np.ndarray, k: int, weighted: bool) -> Tuple[np.ndarray, np.ndarray]:
+    pred, conf = np.full(len(D), np.nan, dtype=object), np.full(len(D), np.nan)
+    for i, d in enumerate(D):
+        nn = np.argsort(d, kind="stable")[:k]
+        nn = nn[np.isfinite(d[nn])]
+        if nn.size == 0:
+            continue
+        w = 1.0 / np.maximum(d[nn], 1e-12) if weighted else np.ones(nn.size)
+        votes = pd.Series(w).groupby(y[nn], sort=False).sum()  # labels in order of first (nearest) neighbour
+        pred[i], conf[i] = votes.idxmax(), votes.max() / w.sum()
+    return pred, conf
+
+
+def transfer_labels(
+    pseudo_adata: AnnData,
+    label_col: str,
+    *,
+    query: Optional[Sequence[bool]] = None,
+    n_neighbors: int = 5,
+    weighted: bool = False,
+    n_pcs: Optional[int] = None,
+    group_col: Optional[str] = None,
+) -> Tuple[pd.DataFrame, Dict]:
+    """Label query samples by a k-nearest-neighbour vote in the sample embedding.
+
+    References are the samples with a label in ``label_col`` that are not in the boolean
+    ``query`` mask; every other sample is a query (by default, the unlabelled samples).
+    Each query takes the majority label of its ``n_neighbors`` nearest references
+    (Euclidean distance on the first ``n_pcs`` PCs); with ``weighted=True`` each vote
+    counts 1/distance. Ties go to the label of the nearest tied neighbour. The confidence
+    is the (weighted) share of the votes won by the assigned label.
+
+    To judge reliability, every reference is also labelled from the other references
+    (leave-one-out). With ``group_col`` (a donor, or ``sample`` for multi-omics units) the
+    references of the same group are left out as well, so a unit is never matched to
+    another unit of the same donor or sample.
+
+    Returns ``(table, metrics)``. ``table`` is indexed by sample with columns ``label``,
+    ``query``, ``predicted`` (the transferred label for queries, the leave-one-out label for
+    references) and ``confidence``. ``metrics`` holds ``loo_accuracy``,
+    ``loo_balanced_accuracy``, ``n_reference``, ``n_query``, ``n_neighbors`` and ``n_pcs``.
+    """
+    obs = pseudo_adata.obs
+    X = _embedding(pseudo_adata, n_pcs)
+    labels = obs[label_col]
+    ref = labels.notna().to_numpy()
+    if query is not None:
+        ref &= ~np.asarray(query, dtype=bool)
+    y = labels.to_numpy()[ref]
+
+    D = cdist(X, X[ref])
+    g = (obs[group_col] if group_col else obs.index.to_series()).astype(str).to_numpy()[ref]
+    D[ref] = np.where(g[:, None] == g[None, :], np.inf, D[ref])
+    pred, conf = _knn_vote(D, y, n_neighbors, weighted)
+
+    table = pd.DataFrame({"label": labels.to_numpy(), "query": ~ref, "predicted": pred, "confidence": conf},
+                         index=obs.index).infer_objects()  # numeric labels back to a numeric dtype
+    loo = table[ref & pd.notna(pred)]
+    metrics = {"loo_accuracy": float(accuracy_score(loo["label"], loo["predicted"])),
+               "loo_balanced_accuracy": float(balanced_accuracy_score(loo["label"], loo["predicted"])),
+               "n_reference": int(ref.sum()), "n_query": int((~ref).sum()),
+               "n_neighbors": n_neighbors, "n_pcs": X.shape[1]}
+    return table, metrics

{sampledisco-0.4.2 → sampledisco-0.5.0/src/sampledisco.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sampledisco
-Version: 0.4.2
+Version: 0.5.0
 Summary: Cross-omics, cross-condition sample embedding for single-cell data (RNA + ATAC)
 Author: Hongkai Ji
 Author-email: Harry Jiang <hjiang55@jh.edu>
@@ -109,6 +109,7 @@ code/
 │   ├── sample_clustering/         # Hierarchical (HRA / HRC / NN / UPGMA / consensus), K-means, proportion test, RAISIN
 │   ├── sample_trajectory/         # CCA (supervised) and TSCAN (unsupervised) + GAM-based trajectory DGE
 │   ├── sample_association/        # Per-PC variance explained vs sample-level covariates (permutation FDR)
+│   ├── sample_prediction/         # Cross-validated phenotype prediction from the PCs; kNN label transfer
 │   ├── visualization/             # Embedding plots, dendrograms, DGE volcanos, modality-aware multi-omics scatters
 │   ├── utils/                     # Shared helpers: seed, safe h5ad I/O, limma, TF-IDF, batch regress, Grouping
 │   └── gene_activity/             # ATAC peak → gene activity inference + RNA-ATAC validation

{sampledisco-0.4.2 → sampledisco-0.5.0}/src/sampledisco.egg-info/SOURCES.txt

@@ -53,6 +53,8 @@ src/sampledisco/sample_embedding/__init__.py
 src/sampledisco/sample_embedding/blocks.py
 src/sampledisco/sample_embedding/sample_embedding.py
 src/sampledisco/sample_embedding/sample_embedding_gpu.py
+src/sampledisco/sample_prediction/__init__.py
+src/sampledisco/sample_prediction/prediction.py
 src/sampledisco/sample_trajectory/CCA.py
 src/sampledisco/sample_trajectory/CCA_test.py
 src/sampledisco/sample_trajectory/TSCAN.py
@@ -89,4 +91,5 @@ src/sampledisco/wrapper/rna_wrapper.py
 src/sampledisco/wrapper/wrapper.py
 tests/test_config_validation.py
 tests/test_inplace_uns_and_equal_weight.py
-tests/test_sample_embedding_equivalence.py
+tests/test_sample_embedding_equivalence.py
+tests/test_sample_prediction.py

sampledisco-0.5.0/tests/test_sample_prediction.py

@@ -0,0 +1,154 @@
+"""predict_phenotype and transfer_labels on synthetic sample embeddings with a known answer.
+Run with `pytest tests/` or `python tests/test_sample_prediction.py`."""
+import anndata as ad
+import numpy as np
+import pandas as pd
+
+from sklearn.metrics import r2_score, roc_auc_score
+
+from sampledisco import predict_phenotype, transfer_labels
+
+
+def make(X, **obs):
+    a = ad.AnnData(X=X.astype(np.float32), obs=pd.DataFrame(obs, index=[f"s{i}" for i in range(len(X))]))
+    a.uns["X_DR_sample"] = pd.DataFrame(X, index=a.obs_names, columns=[f"PC{j + 1}" for j in range(X.shape[1])])
+    return a
+
+
+def separated(n=60, pc=0, seed=0):
+    """Two classes 12 SD apart on one PC (``pc``), pure noise on the other four."""
+    rng = np.random.default_rng(seed)
+    y = np.repeat(["healthy", "severe"], n // 2)
+    X = rng.normal(size=(n, 5))
+    X[:, pc] += np.where(y == "severe", 6.0, -6.0)
+    return make(X, status=y)
+
+
+def test_binary_perfect():
+    pred, m = predict_phenotype(separated(), "status")
+    assert m["auc"] == 1.0 and m["accuracy"] == 1.0 and m["n_pcs"] == 5
+    assert m["C"] == [10] * 5                                  # every C ties on separable data: weakest penalty
+    assert (pred["predicted"] == pred["label"]).all()
+    assert np.allclose(pred[["prob_healthy", "prob_severe"]].sum(1), 1)
+
+
+def test_only_first_n_pcs_used():
+    a = separated(pc=2)                                       # signal on PC3 only
+    assert predict_phenotype(a, "status", n_pcs=3)[1]["auc"] == 1.0
+    assert predict_phenotype(a, "status", n_pcs=2)[1]["auc"] < 0.75
+    assert transfer_labels(a, "status", n_pcs=3)[1]["loo_accuracy"] == 1.0
+    assert transfer_labels(a, "status", n_pcs=2)[1]["loo_accuracy"] < 0.75
+
+
+def test_random_labels_near_chance():
+    rng = np.random.default_rng(1)
+    a = make(rng.normal(size=(200, 10)), status=rng.choice(["a", "b"], 200))
+    _, m = predict_phenotype(a, "status")
+    assert 0.3 < m["auc"] < 0.7
+
+
+def test_multiclass_and_regression():
+    rng = np.random.default_rng(2)
+    y = np.repeat([0, 1, 2], 30)
+    X = rng.normal(size=(90, 4))
+    X[:, 0] += 8 * y
+    a = make(X, grade=y, score=3 * X[:, 0] + rng.normal(size=90))
+    pred, m = predict_phenotype(a, "grade")
+    assert "auc" not in m and m["accuracy"] > 0.95 and {"prob_0", "prob_1", "prob_2"} <= set(pred.columns)
+    pred, m = predict_phenotype(a, "score", task="regression")
+    assert m["r2"] > 0.95 and len(m["alpha"]) == 5
+
+
+def test_groups_never_split_and_seeded():
+    """Each donor's draws share a fold. The label is a donor trait unrelated to X, and donors sit
+    apart in 30 dimensions: when draws of a donor are split across folds the model memorizes donors."""
+    rng = np.random.default_rng(3)
+    donors = np.repeat([f"d{i}" for i in range(20)], 4)
+    status = np.repeat(rng.permutation(np.repeat(["neg", "pos"], 10)), 4)
+    X = np.repeat(rng.normal(size=(20, 30)), 4, axis=0) + rng.normal(size=(80, 30)) * 0.05
+    a = make(X, status=status, donor=donors)
+    pred, m = predict_phenotype(a, "status", group_col="donor")
+    assert (pred.groupby(a.obs["donor"])["fold"].nunique() == 1).all() and m["n_groups"] == 20
+    assert m["auc"] < 0.8                                    # no donor leakage: near chance
+    _, leaky = predict_phenotype(a, "status")                 # draws split across folds: inflated
+    assert leaky["auc"] > 0.95
+    again, _ = predict_phenotype(a, "status", group_col="donor")
+    assert again.equals(pred)
+
+
+def test_score_by_group():
+    """Group scores = scores of the per-group mean of the out-of-fold predictions."""
+    rng = np.random.default_rng(5)
+    donors = np.repeat([f"d{i}" for i in range(30)], 3)
+    trait = np.repeat(rng.choice(["neg", "pos"], 30), 3)
+    X = rng.normal(size=(90, 4))
+    X[:, 0] += np.where(trait == "pos", 1.0, -1.0)
+    a = make(X, trait=trait, donor=donors, bmi=X[:, 0] + rng.normal(size=90))
+    pred, m = predict_phenotype(a, "trait", group_col="donor", score_by="group")
+    d = pred.groupby(a.obs["donor"]).agg(label=("label", "first"), p=("prob_pos", "mean"))
+    assert np.isclose(m["auc"], roc_auc_score(d["label"] == "pos", d["p"]))
+    assert np.isclose(m["accuracy"], ((d["p"] > 0.5) == (d["label"] == "pos")).mean())
+    assert pred.equals(predict_phenotype(a, "trait", group_col="donor")[0])   # only the scoring changes
+    pred, m = predict_phenotype(a, "bmi", group_col="donor", task="regression", score_by="group")
+    d = pred.groupby(a.obs["donor"])[["label", "predicted"]].mean()
+    assert np.isclose(m["r2"], r2_score(d["label"], d["predicted"]))
+
+
+def test_missing_labels_skipped_and_obsm_fallback():
+    a = separated()
+    a.obs.loc[["s0", "s1"], "status"] = np.nan
+    a.obsm["X_DR_sample"] = a.uns.pop("X_DR_sample").to_numpy()
+    pred, m = predict_phenotype(a, "status")
+    assert m["n_samples"] == 58 and "s0" not in pred.index and m["auc"] > 0.99
+
+
+def test_transfer_recovers_held_out_labels():
+    a = separated()
+    hidden = a.obs["status"].copy()
+    a.obs.loc[a.obs_names[::6], "status"] = np.nan
+    table, m = transfer_labels(a, "status")
+    q = table[table["query"]]
+    assert len(q) == 10 and (q["predicted"] == hidden[q.index]).all() and (q["confidence"] == 1).all()
+    assert m["loo_accuracy"] == 1.0 and m["n_reference"] == 50 and m["n_query"] == 10
+
+
+def test_transfer_mask_vote_tie_and_weights():
+    """Query at 0; references at 1 (A), 2 (B), 3 (B), 4 (A). k=4 is a 2:2 tie -> nearest (A).
+    k=3: majority B (2/3); distance-weighted A wins (1 vs 1/2 + 1/3)."""
+    X = np.array([[0.0], [1.0], [2.0], [3.0], [4.0]])
+    a = make(X, cls=["A", "A", "B", "B", "A"])
+    query = np.array([True, False, False, False, False])        # labelled but masked
+    table, _ = transfer_labels(a, "cls", query=query, n_neighbors=4)
+    assert table.loc["s0", "predicted"] == "A" and table.loc["s0", "confidence"] == 0.5
+    table, _ = transfer_labels(a, "cls", query=query, n_neighbors=3)
+    assert table.loc["s0", "predicted"] == "B" and np.isclose(table.loc["s0", "confidence"], 2 / 3)
+    table, _ = transfer_labels(a, "cls", query=query, n_neighbors=3, weighted=True)
+    assert table.loc["s0", "predicted"] == "A" and np.isclose(table.loc["s0", "confidence"], 1 / (1 + 1 / 2 + 1 / 3))
+
+
+def test_transfer_loo_excludes_group():
+    """Paired units (one sample in two modalities) sit on top of each other: without group_col each
+    unit's nearest reference is its partner, so leave-one-out accuracy is inflated."""
+    rng = np.random.default_rng(4)
+    centres = rng.normal(size=(40, 3)) * 5
+    lab = rng.choice(["x", "y"], 40)                         # unrelated to position
+    X = np.repeat(centres, 2, axis=0) + rng.normal(size=(80, 3)) * 0.01
+    a = make(X, sample=np.repeat([f"p{i}" for i in range(40)], 2), cls=np.repeat(lab, 2))
+    _, leaky = transfer_labels(a, "cls", n_neighbors=1)
+    _, fair = transfer_labels(a, "cls", n_neighbors=1, group_col="sample")
+    assert leaky["loo_accuracy"] == 1.0 and fair["loo_accuracy"] < 0.75
+
+
+def test_numeric_labels_keep_dtype():
+    a = separated()
+    a.obs["sev"] = np.where(a.obs["status"] == "severe", 4.0, 1.0)
+    a.obs.loc["s3", "sev"] = np.nan
+    table, m = transfer_labels(a, "sev")
+    assert table["predicted"].dtype == float and table.loc["s3", "predicted"] == 1.0 and m["loo_accuracy"] == 1.0
+
+
+if __name__ == "__main__":
+    for name, fn in list(globals().items()):
+        if name.startswith("test_"):
+            fn()
+            print("ok", name)