From 978a235bc8098017ec6c3623403ed65d3cc39424 Mon Sep 17 00:00:00 2001 From: parashardhapola Date: Thu, 22 Oct 2026 21:48:29 +0200 Subject: [PATCH] Scale HVG detection bounds with the selection and add seurat_v3, Pearson residuals, and batch-aware selection HVG detection bounds were absolute (`min_cells=20`, `max_cells=n-20`), so subsets lost markers, for example Iapp, Pyy, Chgb, and Chga on 150 beta cells. This also adds batch-aware selection and the seurat_v3 and Pearson residual flavors. --- THIRD_PARTY_NOTICES.md | 36 +- cytearc/assay/__init__.py | 2 + cytearc/assay/atac.py | 7 +- cytearc/assay/base.py | 8 +- cytearc/assay/hvg_statistics.py | 578 ++++++ cytearc/assay/normalization.py | 107 ++ cytearc/assay/rna.py | 236 ++- cytearc/datastore/_operations/features.py | 553 +++++- cytearc/datastore/_pipeline_recipe.py | 29 +- cytearc/datastore/pipeline_accessor.py | 7 +- cytearc/features/gene_families.py | 20 +- cytearc/features/variability.py | 1019 +++++++++- cytearc/storage/feature_selection.py | 143 +- cytearc/storage/operation_revisions.py | 52 + docs/source/developers/architecture.md | 21 +- docs/source/reference/api/artifacts.md | 2 +- docs/source/reference/api/assays.md | 32 +- docs/source/reference/api/pipeline.md | 22 +- docs/source/reference/methods.md | 17 + docs/source/scanpy.md | 2 + docs/source/tutorials/feature_selection.ipynb | 893 +++++++-- scripts/export_scanpy_hvg_golden.py | 175 ++ skills/cytearc-single-cell/SKILL.md | 15 +- .../references/features-and-graphs.md | 41 +- .../references/gene-blacklists.md | 30 +- .../references/markers-and-annotation.md | 2 +- tests/scanpy_hvg_1_12_4_golden.json | 1 + tests/test_datastore.py | 8 +- tests/test_datastore_contracts.py | 6 +- tests/test_feature_operation_paths.py | 14 +- tests/test_gene_families.py | 4 +- tests/test_hvg_flavors.py | 1658 +++++++++++++++++ tests/test_hvg_kernel_parity.py | 270 +++ tests/test_hvg_plot_dependency.py | 80 + tests/test_hvg_selection.py | 6 +- tests/test_pipeline_params.py | 10 +- 36 files changed, 5660 insertions(+), 446 deletions(-) create mode 100644 cytearc/assay/hvg_statistics.py create mode 100644 scripts/export_scanpy_hvg_golden.py create mode 100644 tests/scanpy_hvg_1_12_4_golden.json create mode 100644 tests/test_hvg_flavors.py create mode 100644 tests/test_hvg_kernel_parity.py create mode 100644 tests/test_hvg_plot_dependency.py diff --git a/THIRD_PARTY_NOTICES.md b/THIRD_PARTY_NOTICES.md index c7c5d75..8fa600e 100644 --- a/THIRD_PARTY_NOTICES.md +++ b/THIRD_PARTY_NOTICES.md @@ -118,6 +118,18 @@ use but does not install. `duplicate_feature_ids="make_unique"`, which follows `make_index_unique`, the function behind `var_names_make_unique`). +### netlib loess (dloess) + +- Source: , the local regression code that R's `loess` and + scikit-misc's `loess` wrap +- Copyright (c) 1989, 1992 by AT&T; William S. Cleveland, Eric Grosse, and Ming-Jen Shyu +- License: the netlib dloess permission notice, reproduced below +- Used in: `cytearc/features/variability.py` (`fit_loess(surface="interpolate")`, which places the + vertices of its k-d tree as dloess does: the bounding interval widened by 0.5% of the data range, + cells of at most `floor(0.2 * span * n)` points, and median splits moved off tied values). The + rules were written in Python from that description, not translated from the Fortran, and are + checked against the fitted values of scikit-misc 0.5.3. + ## Fonts ### Inter @@ -135,9 +147,11 @@ use but does not install. `tests/test_genomic_motifs.py`. Rauluseviciute et al. (2024), Nucleic Acids Research, doi:10.1093/nar/gkad1059. - **10x Genomics**, CC BY 4.0: `tests/seurat_wnn_5_5_1_golden.json` holds Seurat 5.5.1 outputs on - principal components of 300 cells of the `tenx_8K_pbmc_citeseq` dataset, and the reference - images in `tests/visual/showcase/` are rendered from the 1k PBMC CITE-seq test fixture. Both - datasets are credited below. + principal components of 300 cells of the `tenx_8K_pbmc_citeseq` dataset, + `tests/scanpy_hvg_1_12_4_golden.json` holds scanpy 1.12.4 highly variable gene selections and + scores computed from the RNA counts of the 1k PBMC CITE-seq test fixture by + `scripts/export_scanpy_hvg_golden.py`, and the reference images in `tests/visual/showcase/` are + rendered from the same fixture. Both datasets are credited below. - **GEO GSE245108**: hashtag counts in `tests/seurat_hto_5_5_1_golden.json`, from Zhang et al. (2024), Nature Immunology, doi:10.1038/s41590-024-01782-4. - **HGNC** (), CC0 1.0: the previous symbols of the default cell-cycle @@ -611,6 +625,22 @@ OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ``` +### netlib loess (dloess) + +```text +The authors of this software are Cleveland, Grosse, and Shyu. +Copyright (c) 1989, 1992 by AT&T. +Permission to use, copy, modify, and distribute this software for any +purpose without fee is hereby granted, provided that this entire notice +is included in all copies of any software which is or includes a copy +or modification of this software and in all copies of the supporting +documentation for such software. +THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED +WARRANTY. IN PARTICULAR, NEITHER THE AUTHORS NOR AT&T MAKE ANY +REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY +OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE. +``` + ### Inter ```text diff --git a/cytearc/assay/__init__.py b/cytearc/assay/__init__.py index d717850..2702056 100644 --- a/cytearc/assay/__init__.py +++ b/cytearc/assay/__init__.py @@ -18,6 +18,7 @@ from .classification import preset_assay_types as preset_assay_types from .classification import resolve_persisted_assay_type as resolve_persisted_assay_type from .normalization import NormMethod as NormMethod +from .normalization import PearsonResidualNormalizer as PearsonResidualNormalizer from .normalization import ( lib_size_feature_stream_eligible as lib_size_feature_stream_eligible, ) @@ -25,6 +26,7 @@ from .normalization import norm_dummy as norm_dummy from .normalization import norm_lib_size as norm_lib_size from .normalization import norm_lib_size_log as norm_lib_size_log +from .normalization import norm_pearson_residuals as norm_pearson_residuals from .normalization import norm_tf_idf as norm_tf_idf from .persistence import _read_block as _read_block from .rna import RNAassay as RNAassay diff --git a/cytearc/assay/atac.py b/cytearc/assay/atac.py index 63c99c5..80892fc 100644 --- a/cytearc/assay/atac.py +++ b/cytearc/assay/atac.py @@ -9,6 +9,7 @@ from ..utils.compute import compute_with_progress from .base import Assay from .normalization import ( + PearsonResidualNormalizer, check_normalization_flags, inverse_document_frequency, norm_clr, @@ -115,11 +116,11 @@ def _normalization_flags(self) -> frozenset[str]: ``normed`` hands every normalizer each cell's term-frequency denominator in ``n_term_per_doc``, so TF-IDF and custom normalizers take ``renormalize_subset``. ATAC values are never log transformed, - and the CLR, ``norm_dummy``, and library-size normalizers read no - term frequencies. + and the CLR, ``norm_dummy``, library-size, and Pearson residual + normalizers read no term frequencies. """ method = self.normMethod - if any( + if isinstance(method, PearsonResidualNormalizer) or any( method is builtin for builtin in (norm_clr, norm_dummy, norm_lib_size, norm_lib_size_log) ): diff --git a/cytearc/assay/base.py b/cytearc/assay/base.py index b609b29..9b0cffc 100644 --- a/cytearc/assay/base.py +++ b/cytearc/assay/base.py @@ -23,6 +23,7 @@ from ..utils.compute import controlled_compute from ..utils.logging import logger from .normalization import ( + PearsonResidualNormalizer, NormMethod, check_normalization_flags, iter_feature_group_means, @@ -338,11 +339,12 @@ def _normalization_flags(self) -> frozenset[str]: ``normed`` hands the configured normalizer the selected counts and no totals, so ``renormalize_subset`` never applies. It can take ``log1p`` of the values of ``norm_dummy`` and of custom normalizers. CLR values - are already log ratios, and the library-size and TF-IDF normalizers - need totals or fitted state that this class does not hand them. + are already log ratios, and the library-size, Pearson residual, and + TF-IDF normalizers need totals or fitted state that this class does + not hand them. """ method = self.normMethod - if any( + if isinstance(method, PearsonResidualNormalizer) or any( method is builtin for builtin in (norm_clr, norm_lib_size, norm_lib_size_log, norm_tf_idf) ): diff --git a/cytearc/assay/hvg_statistics.py b/cytearc/assay/hvg_statistics.py new file mode 100644 index 0000000..9960584 --- /dev/null +++ b/cytearc/assay/hvg_statistics.py @@ -0,0 +1,578 @@ +"""Streamed per-batch feature statistics for highly variable feature selection. + +Batch-aware selection and the seurat_v3 and pearson_residuals flavors need +statistics of each batch rather than the persisted feature summary of all +selected cells. These functions stream the feature-major ``countsT`` bands of +the selected cells once per call and keep, for every batch and feature, +statistics that merge exactly across cell bands: detections and sums add, +centered sums of squares merge with the update of Chan, Golub, and LeVeque, +and maxima take the larger value. The bands of a feature group are merged in +band order with a fixed pairwise tree once all of them have arrived, so the +results do not depend on which thread finished first, and the group's +statistics are released. + +Each selected cell belongs to one batch, given as a code from 0 to +``n_groups - 1`` aligned with the selected cells. +""" + +from collections.abc import Callable +from dataclasses import dataclass +from typing import TYPE_CHECKING, Any + +import numpy as np +from numba import njit + +from ..storage.geometry import array_geometry +from ..utils.compute import pairwise_merge_tree +from ..utils.moments import add_implicit_zeros, welford_add +from .normalization import library_size_divisors + +if TYPE_CHECKING: + from .rna import RNAassay + +__all__ = [ + "BatchHvgScores", + "GroupedMoments", + "grouped_clipped_squares", + "grouped_moments", + "grouped_pearson_residual_moments", +] + +# The statistics of one cell band of one feature group: the cells of each +# batch in the band, then arrays with a row per batch and a column per +# selected feature of the group. +type _BandStatistics = tuple[np.ndarray, ...] + + +@dataclass(frozen=True, slots=True) +class BatchHvgScores: + """The HVG scores of every feature in every batch. + + Attributes: + sizes: The number of selected cells in each batch. + scores: Each batch's score of each feature, one row per batch. + mean_nonzero: Each batch's mean value over the cells where a feature + is detected: normalized values for the cytearc flavor, counts for + the others. + detected: The number of selected cells where each feature is detected. + pooled_mean_nonzero: The mean value of each feature over every + selected cell where it is detected. + """ + + sizes: np.ndarray + scores: np.ndarray + mean_nonzero: np.ndarray + detected: np.ndarray + pooled_mean_nonzero: np.ndarray + + +@dataclass(frozen=True, slots=True) +class GroupedMoments: + """Per-batch statistics of each feature, one row per batch. + + Attributes: + sizes: The number of selected cells in each batch. + detected: The number of cells with a positive value. + total: The sum of the values. + m2: The sum of squared deviations from the batch mean. + maximum: The largest value, at least 0. + """ + + sizes: np.ndarray + detected: np.ndarray + total: np.ndarray + m2: np.ndarray + maximum: np.ndarray + + +@njit(cache=True, nogil=True) +def _band_moments_kernel( + values: np.ndarray, + value_rows: np.ndarray, + local: np.ndarray, + groups: np.ndarray, + scale: float, + inverse_totals: np.ndarray, + sizes: np.ndarray, + total: np.ndarray, + m2: np.ndarray, + detected: np.ndarray, + maximum: np.ndarray, + means: np.ndarray, + counts: np.ndarray, +) -> None: + """Write each batch's moments of ``scale * count * inverse_total``. + + Row ``value_rows[k]`` of ``values`` writes column ``k``. Stored counts + update a running mean and ``m2`` per batch, and each batch's cells + without a count then join as zeros, as the summary kernel of all selected + cells does. + """ + n_groups = sizes.shape[0] + for k in range(value_rows.shape[0]): + row = value_rows[k] + for group in range(n_groups): + means[group] = 0.0 + counts[group] = 0 + for cell in range(local.shape[0]): + count = values[row, local[cell]] + if count == 0: + continue + group = groups[cell] + value = scale * np.float64(count) * inverse_totals[cell] + detected[group, k] += value > 0.0 + total[group, k] += value + if value > maximum[group, k]: + maximum[group, k] = value + counts[group] += 1 + means[group], m2[group, k] = welford_add( + counts[group], means[group], m2[group, k], value + ) + for group in range(n_groups): + m2[group, k] = add_implicit_zeros( + m2[group, k], means[group], counts[group], sizes[group] + ) + + +@njit(cache=True, nogil=True) +def _band_clipped_squares_kernel( + values: np.ndarray, + value_rows: np.ndarray, + local: np.ndarray, + groups: np.ndarray, + means: np.ndarray, + clips: np.ndarray, + sizes: np.ndarray, + out: np.ndarray, + stored: np.ndarray, +) -> None: + """Write each batch's sum of ``(min(count, clip) - mean)**2``. + + Row ``value_rows[k]`` of ``values`` writes column ``k``, with the means + and clips of column ``k``. The cells of a batch without a count add + ``mean**2`` each. + """ + n_groups = sizes.shape[0] + for k in range(value_rows.shape[0]): + row = value_rows[k] + for group in range(n_groups): + stored[group] = 0 + for cell in range(local.shape[0]): + count = values[row, local[cell]] + if count == 0: + continue + group = groups[cell] + deviation = min(np.float64(count), clips[group, k]) - means[group, k] + out[group, k] += deviation * deviation + stored[group] += 1 + for group in range(n_groups): + mean = means[group, k] + out[group, k] += (sizes[group] - stored[group]) * (mean * mean) + + +@njit(cache=True, nogil=True) +def _band_pearson_kernel( + values: np.ndarray, + value_rows: np.ndarray, + local: np.ndarray, + groups: np.ndarray, + totals: np.ndarray, + fractions: np.ndarray, + theta: float, + clips: np.ndarray, + total: np.ndarray, + m2: np.ndarray, + means: np.ndarray, + counts: np.ndarray, +) -> None: + """Write each batch's sum and ``m2`` of clipped Pearson residuals. + + Row ``value_rows[k]`` of ``values`` writes column ``k``, with the + fractions of column ``k``. A cell's expected count is its total times the + feature's fraction in the cell's batch, and its residual + ``(x - mu) / sqrt(mu + mu**2 / theta)`` is clipped to the batch's clip; + an expected count of 0 gives a residual of 0. Every selected cell + contributes, with or without a count. + """ + n_groups = clips.shape[0] + for k in range(value_rows.shape[0]): + row = value_rows[k] + for group in range(n_groups): + means[group] = 0.0 + counts[group] = 0 + for cell in range(local.shape[0]): + group = groups[cell] + expected = totals[cell] * fractions[group, k] + residual = 0.0 + if expected > 0.0: + residual = (np.float64(values[row, local[cell]]) - expected) / np.sqrt( + expected + expected * expected / theta + ) + residual = min(max(residual, -clips[group]), clips[group]) + total[group, k] += residual + counts[group] += 1 + means[group], m2[group, k] = welford_add( + counts[group], means[group], m2[group, k], residual + ) + + +def _merge_moments(first: _BandStatistics, second: _BandStatistics) -> _BandStatistics: + """Merge the per-batch moments of two cell bands of one feature group. + + The statistics are the cells of each batch, the sums, the ``m2``, and + optionally the detections and the maxima. Each batch merges its sums and + ``m2`` as ``ColumnMoments.merge`` merges columns, so a batch without + cells in a band keeps the other band's values exactly. + """ + sizes_a, total_a, m2_a = first[:3] + sizes_b, total_b, m2_b = second[:3] + m2 = m2_a + m2_b + for group in np.flatnonzero((sizes_a > 0) & (sizes_b > 0)): + count_a, count_b = int(sizes_a[group]), int(sizes_b[group]) + merged = np.divide(total_b[group], count_b) + merged -= total_a[group] / count_a + np.square(merged, out=merged) + merged *= count_a * count_b / (count_a + count_b) + merged += m2_a[group] + merged += m2_b[group] + m2[group] = merged + merged_statistics: _BandStatistics = (sizes_a + sizes_b, total_a + total_b, m2) + if len(first) > 3: + merged_statistics += (first[3] + second[3], np.maximum(first[4], second[4])) + return merged_statistics + + +def _merge_sums(first: _BandStatistics, second: _BandStatistics) -> _BandStatistics: + """Add the per-batch sums of two cell bands of one feature group.""" + return tuple(a + b for a, b in zip(first, second, strict=True)) + + +def _stream_groups( + assay: "RNAassay", + cell_idx: np.ndarray, + groups: np.ndarray, + n_groups: int, + feat_idx: np.ndarray, + *, + compute: Callable[[Any, np.ndarray, np.ndarray, np.ndarray], _BandStatistics], + merge: Callable[[_BandStatistics, _BandStatistics], _BandStatistics], + outputs: tuple[np.ndarray, ...], + resident_bytes: int, + progress: str, +) -> None: + """Stream the bands of the selected cells and features into ``outputs``. + + ``compute(band, value_rows, columns, band_groups)`` returns one band's + statistics: the cells of each batch in the band, then one array per + output with a row per batch and a column per entry of ``value_rows``, the + rows of the band's values that hold selected features. ``columns`` are + their columns in the outputs, which have a row per batch and a column per + feature of ``feat_idx``. ``merge`` combines two bands' statistics. + """ + from ..storage.feature_stream import map_feature_cell_bands, persisted_read_group + + counts_t = assay.rawDataT + # An RNA assay opens only with a complete countsT. + assert counts_t is not None + n_feats = int(counts_t.shape[0]) + dest_of = np.full(n_feats, -1, dtype=np.int64) + dest_of[feat_idx] = np.arange(len(feat_idx), dtype=np.int64) + geometry = array_geometry(counts_t) + assert geometry is not None + cell_chunk = int(geometry.axisChunk(1)) + n_bands = int(np.unique(cell_idx // cell_chunk).size) + widest = min( + len(feat_idx), max(geometry.axisChunk(0), persisted_read_group(counts_t)[0]) + ) + # A band's statistics hold a row per batch, and a column index, for every + # selected feature of its group. As in the summary of all selected cells, + # every band of every group may wait for its group to complete; each + # compute worker also holds one band's statistics and batch codes. + feature_bytes = (len(outputs) * n_groups + 1) * 8 + scratch = ( + resident_bytes + + dest_of.nbytes + + sum(output.nbytes for output in outputs) + + n_bands * (feature_bytes * len(feat_idx) + 8 * n_groups) + + assay.resources.workers + * (feature_bytes * widest + 16 * min(cell_chunk, len(cell_idx))) + ) + pending: dict[tuple[int, int], list[tuple[int, _BandStatistics]]] = {} + + def process(band: Any) -> tuple[int, tuple[int, int], np.ndarray, _BandStatistics]: + destinations = dest_of[band.featStart + band.featureRows()] + value_rows = np.flatnonzero(destinations >= 0) + columns = destinations[value_rows] + statistics = compute( + band, value_rows, columns, groups[band.selectedDestinations] + ) + return int(band.unitIndex), (band.featStart, band.featEnd), columns, statistics + + for unit, key, columns, statistics in map_feature_cell_bands( + counts_t, + process, + cell_idx=cell_idx, + feat_idx=feat_idx, + resources=assay.resources, + progress=progress, + io=getattr(assay, "storageIo", None), + scratchBytes=scratch, + orderedCompute=False, + ): + pending.setdefault(key, []).append((unit, statistics)) + if len(pending[key]) < n_bands: + continue + # Every band of a group selects the same features, so the last band's + # columns are the group's. + items = sorted(pending.pop(key), key=lambda item: item[0]) + merged = pairwise_merge_tree([item[1] for item in items], merge) + for output, values in zip(outputs, merged[1:], strict=True): + output[:, columns] = values + # Every feature group has a band in every cell band of the selection. + assert not pending + + +def _checked_inputs( + cell_idx: np.ndarray, groups: np.ndarray, n_groups: int, feat_idx: np.ndarray +) -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]: + """Return the inputs as int64 arrays and the number of cells of each batch.""" + cell_idx = np.asarray(cell_idx, dtype=np.int64) + groups = np.asarray(groups, dtype=np.int64) + feat_idx = np.asarray(feat_idx, dtype=np.int64) + if cell_idx.ndim != 1 or groups.shape != cell_idx.shape: + raise ValueError("groups must hold one batch code per selected cell") + if groups.size and (int(groups.min()) < 0 or int(groups.max()) >= n_groups): + raise ValueError(f"Batch codes must lie from 0 to {n_groups - 1}") + sizes = np.bincount(groups, minlength=n_groups).astype(np.int64) + return cell_idx, groups, feat_idx, sizes + + +def _band_sizes(band_groups: np.ndarray, n_groups: int) -> np.ndarray: + return np.bincount(band_groups, minlength=n_groups).astype(np.int64) + + +def grouped_moments( + assay: "RNAassay", + cell_idx: np.ndarray, + groups: np.ndarray, + n_groups: int, + feat_idx: np.ndarray, + *, + library_size: bool, +) -> GroupedMoments: + """Return each batch's detections, sums, ``m2``, and maxima of the features. + + With ``library_size`` the values are those of ``norm_lib_size``, + ``sf * count / total`` over each cell's prepared total, as the feature + summary of all selected cells has them; otherwise they are the counts. + + Args: + assay: An RNA assay, which normalizes with ``norm_lib_size`` and a + size factor when ``library_size`` is set. + cell_idx: The sorted, unique selected cells. + groups: The batch code of each selected cell. + n_groups: The number of batches. + feat_idx: The features to summarize. + library_size: Whether to summarize library-size normalized values. + + Returns: + The statistics, each with a row per batch and a column per feature. + """ + cell_idx, groups, feat_idx, sizes = _checked_inputs( + cell_idx, groups, n_groups, feat_idx + ) + shape = (n_groups, len(feat_idx)) + # The sums, m2, detections, and maxima. + outputs = tuple(np.zeros(shape, dtype=np.float64) for _ in range(4)) + if library_size: + assert assay.sf is not None + scale = float(assay.sf) + inverse_totals = library_size_divisors( + assay._cell_count_totals(cell_idx), source=assay._totals_name, copy=False + ) + np.reciprocal(inverse_totals, out=inverse_totals) + else: + scale = 1.0 + inverse_totals = np.ones(len(cell_idx), dtype=np.float64) + + def compute( + band: Any, value_rows: np.ndarray, _columns: np.ndarray, band_groups: np.ndarray + ) -> _BandStatistics: + band_sizes = _band_sizes(band_groups, n_groups) + total, m2, detected, maximum = ( + np.zeros((n_groups, len(value_rows)), dtype=np.float64) for _ in range(4) + ) + _band_moments_kernel( + band.values, + value_rows, + band.selectedLocal, + band_groups, + scale, + inverse_totals[band.selectedDestinations], + band_sizes, + total, + m2, + detected, + maximum, + np.zeros(n_groups, dtype=np.float64), + np.zeros(n_groups, dtype=np.int64), + ) + return band_sizes, total, m2, detected, maximum + + if len(cell_idx) and len(feat_idx): + _stream_groups( + assay, + cell_idx, + groups, + n_groups, + feat_idx, + compute=compute, + merge=_merge_moments, + outputs=outputs, + resident_bytes=inverse_totals.nbytes + groups.nbytes, + progress="Calculating batch feature statistics", + ) + total, m2, detected, maximum = outputs + return GroupedMoments(sizes, detected, total, m2, maximum) + + +def grouped_clipped_squares( + assay: "RNAassay", + cell_idx: np.ndarray, + groups: np.ndarray, + n_groups: int, + feat_idx: np.ndarray, + *, + means: np.ndarray, + clips: np.ndarray, +) -> np.ndarray: + """Return each batch's sum of ``(min(count, clip) - mean)**2`` per feature. + + Args: + assay: An RNA assay. + cell_idx: The sorted, unique selected cells. + groups: The batch code of each selected cell. + n_groups: The number of batches. + feat_idx: The features to summarize. + means: Each batch's mean count of each feature of ``feat_idx``. + clips: Each batch's clip of each feature of ``feat_idx``. + + Returns: + The sums, with a row per batch and a column per feature. + """ + cell_idx, groups, feat_idx, _sizes = _checked_inputs( + cell_idx, groups, n_groups, feat_idx + ) + means = np.asarray(means, dtype=np.float64) + clips = np.asarray(clips, dtype=np.float64) + squares = np.zeros((n_groups, len(feat_idx)), dtype=np.float64) + + def compute( + band: Any, value_rows: np.ndarray, columns: np.ndarray, band_groups: np.ndarray + ) -> _BandStatistics: + band_sizes = _band_sizes(band_groups, n_groups) + out = np.zeros((n_groups, len(value_rows)), dtype=np.float64) + _band_clipped_squares_kernel( + band.values, + value_rows, + band.selectedLocal, + band_groups, + np.ascontiguousarray(means[:, columns]), + np.ascontiguousarray(clips[:, columns]), + band_sizes, + out, + np.zeros(n_groups, dtype=np.int64), + ) + return band_sizes, out + + if len(cell_idx) and len(feat_idx): + _stream_groups( + assay, + cell_idx, + groups, + n_groups, + feat_idx, + compute=compute, + merge=_merge_sums, + outputs=(squares,), + resident_bytes=means.nbytes + clips.nbytes + groups.nbytes, + progress="Calculating clipped feature variances", + ) + return squares + + +def grouped_pearson_residual_moments( + assay: "RNAassay", + cell_idx: np.ndarray, + groups: np.ndarray, + n_groups: int, + feat_idx: np.ndarray, + *, + totals: np.ndarray, + fractions: np.ndarray, + theta: float, + clips: np.ndarray, +) -> tuple[np.ndarray, np.ndarray]: + """Return each batch's sum and ``m2`` of clipped Pearson residuals. + + Args: + assay: An RNA assay. + cell_idx: The sorted, unique selected cells. + groups: The batch code of each selected cell. + n_groups: The number of batches. + feat_idx: The features to summarize. + totals: The total count of each selected cell. + fractions: Each batch's fraction of its counts in each feature of + ``feat_idx``. + theta: The negative binomial overdispersion. + clips: The residual clip of each batch. + + Returns: + The sums and ``m2``, each with a row per batch and a column per + feature, over every cell of the batch. + """ + cell_idx, groups, feat_idx, _sizes = _checked_inputs( + cell_idx, groups, n_groups, feat_idx + ) + totals = np.asarray(totals, dtype=np.float64) + fractions = np.asarray(fractions, dtype=np.float64) + clips = np.asarray(clips, dtype=np.float64) + shape = (n_groups, len(feat_idx)) + outputs = (np.zeros(shape, dtype=np.float64), np.zeros(shape, dtype=np.float64)) + + def compute( + band: Any, value_rows: np.ndarray, columns: np.ndarray, band_groups: np.ndarray + ) -> _BandStatistics: + band_sizes = _band_sizes(band_groups, n_groups) + total = np.zeros((n_groups, len(value_rows)), dtype=np.float64) + m2 = np.zeros((n_groups, len(value_rows)), dtype=np.float64) + _band_pearson_kernel( + band.values, + value_rows, + band.selectedLocal, + band_groups, + totals[band.selectedDestinations], + np.ascontiguousarray(fractions[:, columns]), + float(theta), + clips, + total, + m2, + np.zeros(n_groups, dtype=np.float64), + np.zeros(n_groups, dtype=np.int64), + ) + return band_sizes, total, m2 + + if len(cell_idx) and len(feat_idx): + _stream_groups( + assay, + cell_idx, + groups, + n_groups, + feat_idx, + compute=compute, + merge=_merge_moments, + outputs=outputs, + resident_bytes=totals.nbytes + fractions.nbytes + groups.nbytes, + progress="Calculating Pearson residual variances", + ) + return outputs diff --git a/cytearc/assay/normalization.py b/cytearc/assay/normalization.py index 71be7cf..b8de847 100644 --- a/cytearc/assay/normalization.py +++ b/cytearc/assay/normalization.py @@ -477,6 +477,113 @@ def norm_tf_idf(assay: "Assay", counts: ChunkedArray) -> ChunkedArray: ) +def _pearson_residual_block( + counts: np.ndarray, + totals: np.ndarray, + *, + fractions: np.ndarray, + theta: float, + clip: float, +) -> NDArray[np.float64]: + """Return the clipped Pearson residuals of one block of cells in float64.""" + expected = np.asarray(totals, dtype=np.float64).reshape(-1, 1) * fractions + residuals: NDArray[np.float64] = np.subtract(counts, expected, dtype=np.float64) + positive = expected > 0 + residuals[positive] /= np.sqrt( + expected[positive] + expected[positive] * expected[positive] / theta + ) + # An expected count of 0, of a cell or a feature without counts, gives 0. + residuals[~positive] = 0.0 + np.clip(residuals, -clip, clip, out=residuals) + return residuals + + +class PearsonResidualNormalizer: + """Analytic Pearson residuals of RNA counts, a normalizer for ``normMethod``. + + The residuals are those of Lause, Berens and Kobak (2021), Genome Biology + 22:258, which scanpy's ``normalize_pearson_residuals`` computes. The + expected count of a feature in a cell is ``mu = n_c * p_g``: the cell's + total, which ``normed`` hands the normalizer in ``assay.scalar``, times + the feature's share of the counts of the normalized cells, its sum over + them divided by the sum of their totals. The residual + ``(x - mu) / sqrt(mu + mu**2 / theta)`` is clipped to ``[-clip, clip]``, + ``sqrt(n)`` over ``n`` normalized cells by default, and is 0 where + ``mu`` is 0. By default the totals are over every feature, so the + residuals of selected features are those of the full matrix; + ``renormalize_subset=True`` takes the totals over the selected features, + as scanpy's ``recipe_pearson_residuals`` does after subsetting to highly + variable genes. Residuals are already standardized, so they are never + log transformed, and PCA should not rescale them + (``reduction.pca(normalized, feat_scaling=False)``). + + Use ``cytearc.assay.norm_pearson_residuals`` for ``theta=100`` and the + default clip, or construct one with other values. + + Args: + theta: The negative binomial overdispersion, greater than 0. + clip: The largest absolute residual, at least 0, or None for the + square root of the number of normalized cells. + """ + + def __init__(self, theta: float = 100.0, clip: float | None = None) -> None: + from ..utils.arguments import float_argument + + self.theta = float_argument(theta, "theta") + if self.theta <= 0: + raise ValueError("theta must be greater than 0") + self.clip = None if clip is None else float_argument(clip, "clip") + if self.clip is not None and self.clip < 0: + raise ValueError("clip must be at least 0") + clip_identity = "sqrt-n" if self.clip is None else repr(self.clip) + self.artifact_identity = ( + f"cytearc.assay.pearson_residuals:theta={self.theta!r}:clip={clip_identity}" + ) + + def __repr__(self) -> str: + return f"PearsonResidualNormalizer(theta={self.theta!r}, clip={self.clip!r})" + + def __call__(self, assay: "Assay", counts: ChunkedArray) -> ChunkedArray: + totals = getattr(assay, "scalar", None) + if totals is None: + raise ValueError( + "Pearson residuals need each cell's total, which only an RNA " + "assay's normed provides" + ) + cell_totals = np.asarray(totals, dtype=np.float64) + n_cells = len(counts) + if isinstance(counts, ChunkedArray): + feature_totals = np.asarray( + counts.sum(axis=0, dtype=np.float64).compute( + nthreads=getattr(assay, "nthreads", None), + msg=f"({getattr(assay, 'name', '')}) Summing features for " + "Pearson residuals", + ), + dtype=np.float64, + ) + else: + feature_totals = np.asarray(counts, dtype=np.float64).sum(axis=0) + grand_total = float(cell_totals.sum()) + fractions = ( + feature_totals / grand_total + if grand_total > 0 + else np.zeros_like(feature_totals) + ).reshape(1, -1) + residuals = partial( + _pearson_residual_block, + fractions=fractions, + theta=self.theta, + clip=float(np.sqrt(n_cells)) if self.clip is None else self.clip, + ) + if isinstance(counts, ChunkedArray): + return counts._binary(residuals, cell_totals.reshape(-1, 1), "left") + return cast(ChunkedArray, residuals(np.asarray(counts), cell_totals)) + + +norm_pearson_residuals = PearsonResidualNormalizer() +"""Analytic Pearson residuals with ``theta=100``, clipped at ``sqrt(n)``.""" + + _LOG_TRANSFORM = "log_transform" _RENORMALIZE_SUBSET = "renormalize_subset" diff --git a/cytearc/assay/rna.py b/cytearc/assay/rna.py index 01ec9bb..95a9724 100644 --- a/cytearc/assay/rna.py +++ b/cytearc/assay/rna.py @@ -22,8 +22,15 @@ from ..utils.logging import logger from ..utils.moments import ColumnMoments, add_implicit_zeros, welford_add from .base import Assay +from .hvg_statistics import ( + BatchHvgScores, + grouped_clipped_squares, + grouped_moments, + grouped_pearson_residual_moments, +) from .normalization import ( NORMALIZATION_PARAM_NAMES, + PearsonResidualNormalizer, _feature_group_positions, _feature_subset_source, check_normalization_flags, @@ -149,6 +156,40 @@ def _merge_band_statistics( return first[0] + second[0], first[1].merge(second[1]) +def _corrected_variance( + normed_tot: np.ndarray, + sigmas: np.ndarray, + n_selected: int, + *, + n_bins: int, + lowess_frac: float, + bin_strategy: Literal["fixed", "adaptive"], +) -> np.ndarray: + """Return the cytearc flavor's corrected variance of every feature. + + Features with a positive mean normalized value are divided by the trend + of ``fit_lowess``; the others get 0. + """ + from ..features.variability import fit_lowess + + avg = ( + normed_tot / n_selected + if n_selected > 0 + else np.zeros_like(normed_tot, dtype=np.float64) + ) + positive = avg > 0 + corrected_variance = np.zeros(avg.shape, dtype=np.float64) + if positive.any(): + corrected_variance[positive] = fit_lowess( + avg[positive], + sigmas[positive], + n_bins, + lowess_frac, + bin_strategy=bin_strategy, + ) + return corrected_variance + + class RNAassay(Assay): """This subclass of Assay is designed for feature selection and normalization of scRNA-Seq data. @@ -458,6 +499,10 @@ class this method is optimized for scRNA-Seq data and supports # Zero-total cells normalize to zero, as on every library-size # path, and invalid totals raise. scalar = library_size_divisors(scalar, source=source, copy=False) + elif isinstance(method, PearsonResidualNormalizer): + # Residuals read the true totals: a cell without counts expects + # none, and its residuals are 0. + library_size_divisors(scalar, source=source) else: # Another normalization need not read the totals, so they are not # checked; one that reads them finds a zero total replaced by 1. @@ -486,9 +531,11 @@ def _normalization_flags(self) -> frozenset[str]: so it takes only ``renormalize_subset``. ``norm_dummy`` reads no totals, so it takes only ``log_transform``. CLR values are log ratios and TF-IDF values are never logged, and neither reads the totals. + Pearson residuals read the totals but are signed, so they take only + ``renormalize_subset``. """ method = self.normMethod - if method is norm_lib_size_log: + if method is norm_lib_size_log or isinstance(method, PearsonResidualNormalizer): return frozenset({"renormalize_subset"}) if method is norm_dummy: return frozenset({"log_transform"}) @@ -961,35 +1008,25 @@ def _select_hvgs( holds one name per feature; ``select_highly_variable_features`` rejects inputs of any other length. """ - from ..features.variability import ( - fit_lowess, - select_highly_variable_features, - ) + from ..features.variability import select_highly_variable_features normed_tot = np.asarray(summary["normed_tot"], dtype=np.float64) normed_n = np.asarray(summary["normed_n"], dtype=np.float64) sigmas = np.asarray(summary["sigmas"], dtype=np.float64) - avg = ( - normed_tot / n_selected - if n_selected > 0 - else np.zeros_like(normed_tot, dtype=np.float64) - ) nz_mean = np.divide( normed_tot, normed_n, out=np.zeros_like(normed_tot, dtype=np.float64), where=normed_n != 0, ) - positive = avg > 0 - corrected_variance = np.zeros(avg.shape, dtype=np.float64) - if positive.any(): - corrected_variance[positive] = fit_lowess( - avg[positive], - sigmas[positive], - n_bins, - lowess_frac, - bin_strategy=bin_strategy, - ) + corrected_variance = _corrected_variance( + normed_tot, + sigmas, + n_selected, + n_bins=n_bins, + lowess_frac=lowess_frac, + bin_strategy=bin_strategy, + ) values = select_highly_variable_features( corrected_variance=corrected_variance, normalized_cell_counts=normed_n, @@ -1009,6 +1046,165 @@ def _select_hvgs( logger.info(f"{int(values.sum())} genes marked as HVGs") return np.asarray(values, dtype=bool), corrected_variance + def _batch_hvg_scores( + self, + cell_idx: np.ndarray, + groups: np.ndarray, + n_groups: int, + *, + flavor: str, + n_bins: int, + lowess_frac: float, + bin_strategy: Literal["fixed", "adaptive"], + span: float, + theta: float, + clip: float | None, + ) -> "BatchHvgScores": + """Score every feature in every batch with an HVG flavor. + + The cytearc flavor divides each batch's variance of normalized values + by its own trend. seurat_v3 fits each batch's trend of count variance + on count mean with ``span``, standardizes the counts with it, clips + them ``sqrt(n)`` standard deviations above the mean, and scores their + variance; only features with a count above the clip are read again. + pearson_residuals scores the variance of each batch's Pearson + residuals with ``theta``, clipped at ``clip`` or at the square root of + the batch's cell count, from the counts and the prepared cell totals. + + Args: + cell_idx: The sorted, unique selected cells. + groups: The batch code of each selected cell. + n_groups: The number of batches, each with at least two cells. + flavor: The HVG flavor. + n_bins: The cytearc trend's evaluation density. + lowess_frac: The cytearc trend's window radius. + bin_strategy: The cytearc trend's strategy. + span: The seurat_v3 trend's span. + theta: The Pearson residuals' overdispersion. + clip: The Pearson residuals' clip, or None for ``sqrt(n)``. + + Returns: + The scores and detection statistics of every batch and feature. + """ + from ..features.variability import ( + pearson_residual_clip, + seurat_v3_clip_values, + seurat_v3_expected_variance, + seurat_v3_standardized_variance, + ) + + cell_idx = np.asarray(cell_idx, dtype=np.int64) + groups = np.asarray(groups, dtype=np.int64) + feat_idx = np.arange(self.feats.N, dtype=np.int64) + library_size = flavor == "cytearc" + if library_size and not uses_library_size_normalization(self): + # Another normalizer is fitted over each batch's own cells. + summaries = [ + self._compute_feature_summary(cell_idx[groups == group], feat_idx) + for group in range(n_groups) + ] + sizes = np.bincount(groups, minlength=n_groups).astype(np.int64) + total = np.stack([summary["normed_tot"] for summary in summaries]) + detected = np.stack([summary["normed_n"] for summary in summaries]) + m2 = np.stack([summary["sigmas"] for summary in summaries]) + m2 *= sizes[:, None] + maximum = np.zeros_like(total) + else: + moments = grouped_moments( + self, cell_idx, groups, n_groups, feat_idx, library_size=library_size + ) + sizes, total, m2 = moments.sizes, moments.total, moments.m2 + detected, maximum = moments.detected, moments.maximum + if (sizes < 2).any(): + raise ValueError("Every batch needs at least two selected cells") + scores = np.zeros(total.shape, dtype=np.float64) + if flavor == "cytearc": + for group in range(n_groups): + scores[group] = _corrected_variance( + total[group], + m2[group] / sizes[group], + int(sizes[group]), + n_bins=n_bins, + lowess_frac=lowess_frac, + bin_strategy=bin_strategy, + ) + elif flavor == "seurat_v3": + means = total / sizes[:, None] + expected = np.stack( + [ + seurat_v3_expected_variance( + means[group], m2[group] / (sizes[group] - 1), span=span + ) + for group in range(n_groups) + ] + ) + clips = seurat_v3_clip_values(means, expected, sizes[:, None]) + clipped = (maximum > clips) & (expected > 0) + squares = m2.copy() + # Only genes with a count above their clip are read again. + reread = np.flatnonzero(clipped.any(axis=0)) + again = grouped_clipped_squares( + self, + cell_idx, + groups, + n_groups, + reread, + means=means[:, reread], + clips=clips[:, reread], + ) + squares[:, reread] = np.where(clipped[:, reread], again, squares[:, reread]) + for group in range(n_groups): + scores[group] = seurat_v3_standardized_variance( + squares[group], expected[group], int(sizes[group]) + ) + else: + cell_totals = self._cell_count_totals(cell_idx) + if not (np.isfinite(cell_totals).all() and (cell_totals >= 0).all()): + raise ValueError( + f"{self._totals_name} holds negative or non-finite totals of " + "selected cells; Pearson residuals require finite non-negative " + "counts" + ) + batch_totals = np.bincount(groups, weights=cell_totals, minlength=n_groups) + fractions = np.divide( + total, + batch_totals[:, None], + out=np.zeros_like(total), + where=batch_totals[:, None] > 0, + ) + # Genes without counts in any batch have residuals of 0. + expressed = np.flatnonzero((total > 0).any(axis=0)) + _, residual_m2 = grouped_pearson_residual_moments( + self, + cell_idx, + groups, + n_groups, + expressed, + totals=cell_totals, + fractions=fractions[:, expressed], + theta=theta, + clips=np.asarray( + [pearson_residual_clip(clip, int(size)) for size in sizes] + ), + ) + scores[:, expressed] = residual_m2 / sizes[:, None] + pooled_total = total.sum(axis=0) + pooled_detected = detected.sum(axis=0) + return BatchHvgScores( + sizes=sizes, + scores=scores, + mean_nonzero=np.divide( + total, detected, out=np.zeros_like(total), where=detected != 0 + ), + detected=pooled_detected, + pooled_mean_nonzero=np.divide( + pooled_total, + pooled_detected, + out=np.zeros_like(pooled_total), + where=pooled_detected != 0, + ), + ) + @staticmethod def _plot_hvgs( summary: Mapping[str, np.ndarray], diff --git a/cytearc/datastore/_operations/features.py b/cytearc/datastore/_operations/features.py index 4f8740e..e5ee2f9 100644 --- a/cytearc/datastore/_operations/features.py +++ b/cytearc/datastore/_operations/features.py @@ -11,9 +11,13 @@ from ...features.variability import ( DEFAULT_HVG_BLACKLIST, + DEFAULT_LOESS_SPAN, + DEFAULT_PEARSON_THETA, _ADAPTIVE_QUANTILE, + hvg_flavor_options, hvg_options, - resolve_hvg_max_cells, + resolve_hvg_detection_bounds, + select_batch_highly_variable_features, ) from ...assay.feature_summary import ( ensure_feature_summary, @@ -41,9 +45,12 @@ _ordered_feature_ids_fingerprint, _write_feature_selection, ) +from ...storage.arrays import linked_missing_mask +from ...storage.identity import read_dataset_fingerprint from ...storage.selections import ( read_stored_selection_indices, snapshot_run_metadata, + validate_run_metadata_snapshot, validate_stored_selection_integrity, ) from ...storage.types import as_zarr_array, as_zarr_group @@ -107,11 +114,16 @@ FeatureRef, NormalizationSpec, StudyDesign, + grouping_value_name, resolve_complete_labels, resolve_grouping, valid_category_mask, ) -from ...metadata.rows import read_metadata_missing_rows, read_metadata_rows +from ...metadata.rows import ( + read_array_rows_chunkwise, + read_metadata_missing_rows, + read_metadata_rows, +) from ...utils.arguments import float_argument, integer_argument from ...utils.arrays import ( array_digest, @@ -120,6 +132,7 @@ sort_categories, ) from ...utils.logging import logger +from ...utils.warnings import warn from .enrichment_store import ( _ENRICHMENT_LAYOUT, _EnrichmentScorer, @@ -187,6 +200,34 @@ def _group_assignment_digest(values: np.ndarray) -> str: return array_digest(np.asarray(values).astype(str)) +def _matplotlib_available() -> bool: + """Return whether matplotlib, an optional dependency, can be imported.""" + try: + import matplotlib # noqa: F401 + except ImportError: + return False + return True + + +def _hvg_batch_argument(batch: object, columns: Sequence[str]) -> None: + """Check the ``batch`` of ``features.hvgs`` before anything is written. + + Raises: + TypeError: If ``batch`` is not None, a column name, or an ArtifactRef. + KeyError: If the column is not in the cell metadata. + ValueError: If the artifact holds no categorical cell labels. + """ + if batch is None: + return + if isinstance(batch, str): + if batch not in columns: + raise KeyError(f"Batch column {batch!r} is not in the cell metadata") + return + if not isinstance(batch, ArtifactRef): + raise TypeError("batch must be a cell metadata column name or an ArtifactRef") + grouping_value_name(batch.kind) + + class _FeatureOperationsMixin(_FeatureOperationsBase): @validation_scoped def _features_universe( @@ -354,6 +395,86 @@ def _features_detected( ) return planned.ref + def _hvg_batch_codes( + self, + batch: str | ArtifactRef, + cell_selection: ArtifactRef, + *, + invalidate_cache: bool, + ) -> tuple[ArtifactRef, str | None, np.ndarray, list[str]]: + """Freeze the batch labels of the selected cells and code them. + + A column name is snapshotted, so the selection records the labels it + read; a label artifact is recorded as it is. Returns the recorded + input, the column name or None, each selected cell's batch code, and + the batch names in code order. + + Raises: + ValueError: If a selected cell has no batch label, or a batch has + fewer than two selected cells. + """ + if isinstance(batch, str): + source = snapshot_run_metadata( + self.zw, + table_path="cellData", + id_column="ids", + columns=(batch,), + axis="cell", + invalidate_cache=invalidate_cache, + ) + snapshot = validate_run_metadata_snapshot( + self.zw, + source, + axis="cell", + assay=None, + table_path="cellData", + ordered_columns=(batch,), + ) + values = as_zarr_array(snapshot[batch], name=batch) + cell_idx = read_stored_selection_indices( + self.zw, + cell_selection, + kind="cell_selection", + scope="datastore", + assay=None, + table_path="cellData", + ) + labels = np.asarray(read_array_rows_chunkwise(values, cell_idx)) + mask = linked_missing_mask(snapshot, batch, values=values) + missing = ( + None + if mask is None + else np.asarray(read_array_rows_chunkwise(mask, cell_idx), dtype=bool) + ) + column: str | None = batch + else: + source = batch + resolved = resolve_grouping( + self.zw, self.cells, batch, cell_selection=cell_selection + ) + labels, missing, column = resolved.labels, resolved.missing_mask, None + unlabelled = int((~valid_category_mask(labels, missing_mask=missing)).sum()) + if unlabelled: + raise ValueError( + f"The batch labels miss {unlabelled} selected cells; select the " + "labelled cells with select_cells before selecting highly " + "variable genes by batch" + ) + names, codes = np.unique(np.asarray(labels).astype(str), return_inverse=True) + sizes = np.bincount(codes, minlength=len(names)) + small = [ + f"{str(name)!r} ({size})" for name, size in zip(names, sizes) if size < 2 + ] + if small: + raise ValueError( + "Batch-aware HVG selection scores every batch on its own, so every " + "batch needs at least two selected cells; these have fewer: " + + ", ".join(small) + + ". Leave their cells out with select_cells or merge them into " + "other batches." + ) + return source, column, codes.astype(np.int64), [str(name) for name in names] + def _select_hvgs_artifact( self, *, @@ -361,7 +482,7 @@ def _select_hvgs_artifact( cell_selection: ArtifactRef, feature_names: np.ndarray, feature_snapshot: ArtifactRef, - min_cells: int = 20, + min_cells: int | None = None, top_n: int = 1000, min_var: float = -np.inf, max_var: float = np.inf, @@ -374,6 +495,11 @@ def _select_hvgs_artifact( show_plot: bool = True, max_cells: float | None = None, bin_strategy: Literal["fixed", "adaptive"] = "adaptive", + flavor: Literal["cytearc", "seurat_v3", "pearson_residuals"] = "cytearc", + batch: str | ArtifactRef | None = None, + span: float = DEFAULT_LOESS_SPAN, + theta: float = DEFAULT_PEARSON_THETA, + clip: float | None = None, invalidate_cache: bool = False, **plot_kwargs: Any, ) -> ArtifactRef: @@ -387,21 +513,222 @@ def _select_hvgs_artifact( keep_bounds=keep_bounds, bin_strategy=bin_strategy, ) + options = hvg_flavor_options( + flavor=flavor, + max_cells=max_cells, + min_mean=min_mean, + max_mean=max_mean, + min_var=min_var, + max_var=max_var, + n_bins=n_bins, + lowess_frac=lowess_frac, + bin_strategy=bin_strategy, + span=span, + theta=theta, + clip=clip, + ) + _hvg_batch_argument(batch, self.cells.columns) blacklist_fingerprint = ( fingerprint_array(regex_match_mask(feature_names, blacklist)) if blacklist else None ) + n_selected = feature_summary_selected_count(self.zw, cell_selection) + min_cells, max_cells_int = resolve_hvg_detection_bounds( + min_cells, + max_cells, + n_selected=n_selected, + keep_bounds=keep_bounds, + flavor=options.flavor, + ) + parameters: dict[str, Any] = { + **({} if options.flavor == "cytearc" else {"flavor": options.flavor}), + "min_cells": min_cells, + "max_cells": max_cells_int, + "top_n": top_n, + } + if options.flavor == "cytearc": + parameters.update( + min_var=min_var, + max_var=max_var, + min_mean=min_mean, + max_mean=max_mean, + n_bins=n_bins, + lowess_frac=lowess_frac, + ) + parameters["blacklist"] = blacklist + if blacklist_fingerprint is not None: + parameters["blacklist_fingerprint"] = blacklist_fingerprint + parameters["keep_bounds"] = keep_bounds + if options.flavor == "cytearc": + parameters["bin_strategy"] = bin_strategy + if bin_strategy == "adaptive": + parameters.update( + variance_estimator="regularized_local_quantile", + variance_quantile=_ADAPTIVE_QUANTILE, + ) + elif options.flavor == "seurat_v3": + parameters["span"] = options.span + else: + parameters.update(theta=options.theta, clip=options.clip) + feature_ids_fingerprint = _ordered_feature_ids_fingerprint(assay.z) + execution_options = { + "show_plot": show_plot, + "plot_kwargs": plot_kwargs, + "nthreads": assay.nthreads, + "invalidate_cache": invalidate_cache, + } + if options.flavor == "cytearc" and batch is None: + return self._select_hvgs_from_summary( + assay=assay, + cell_selection=cell_selection, + feature_names=feature_names, + feature_snapshot=feature_snapshot, + parameters=parameters, + execution_options=execution_options, + n_selected=n_selected, + min_var=min_var, + max_var=max_var, + min_mean=min_mean, + max_mean=max_mean, + show_plot=show_plot, + invalidate_cache=invalidate_cache, + plot_kwargs=plot_kwargs, + ) + inputs: dict[str, Any] = { + "cell_selection": cell_selection, + "dataset_fingerprint": read_dataset_fingerprint(assay.z), + "feature_snapshot": feature_snapshot, + } + names = ["all"] + if batch is not None: + source, column, codes, names = self._hvg_batch_codes( + batch, cell_selection, invalidate_cache=invalidate_cache + ) + inputs["batch"] = source + if column is not None: + parameters["batch_column"] = column + elif n_selected < 2: + raise ValueError( + f"flavor={options.flavor!r} needs at least two selected cells" + ) + payload_names: tuple[str, ...] = ( + "values", + "corrected_variance", + "mean_nonzero", + "detected", + ) + if batch is not None: + payload_names += ("batch_count", "median_batch_rank") + planned = _feature_selection_plan( + self.zw, + assay=assay.name, + n_features=assay.feats.N, + ordered_feature_ids_fingerprint=feature_ids_fingerprint, + operation="select_hvgs", + parameters=parameters, + inputs=inputs, + execution_options=execution_options, + payload_names=payload_names, + invalidate_cache=invalidate_cache, + ) + if not planned.reused: + cell_idx = read_stored_selection_indices( + self.zw, + cell_selection, + kind="cell_selection", + scope="datastore", + assay=None, + table_path="cellData", + ).astype(np.int64, copy=False) + if batch is None: + codes = np.zeros(len(cell_idx), dtype=np.int64) + scores = assay._batch_hvg_scores( + cell_idx, + codes, + len(names), + flavor=options.flavor, + n_bins=n_bins, + lowess_frac=lowess_frac, + bin_strategy=bin_strategy, + span=options.span, + theta=options.theta, + clip=options.clip, + ) + ranking = select_batch_highly_variable_features( + scores.scores, + scores.mean_nonzero, + scores.detected, + feature_names, + min_cells=min_cells, + max_cells=max_cells_int, + top_n=top_n, + min_var=min_var, + max_var=max_var, + min_mean=min_mean, + max_mean=max_mean, + blacklist=blacklist, + keep_bounds=keep_bounds, + batch_names=names, + ) + logger.info(f"{int(ranking.selected.sum())} genes marked as HVGs") + payload = { + "values": ranking.selected, + "corrected_variance": scores.scores.mean(axis=0), + "mean_nonzero": scores.pooled_mean_nonzero, + "detected": scores.detected, + "batch_count": ranking.batch_count.astype(np.float64), + "median_batch_rank": ranking.median_rank, + } + _write_feature_selection( + self.zw, + planned, + ordered_feature_ids_fingerprint=feature_ids_fingerprint, + payload=payload, + payload_names=payload_names, + ) + if show_plot: + from ...plotting import highly_variable_features + + highly_variable_features( + mean_nonzero=_feature_selection_values( + self.zw, planned.ref, "mean_nonzero" + ), + corrected_variance=_feature_selection_values( + self.zw, planned.ref, "corrected_variance" + ), + n_cells=_feature_selection_values(self.zw, planned.ref, "detected"), + selected=_feature_selection_values(self.zw, planned.ref), + show=True, + **plot_kwargs, + ) + return planned.ref + + def _select_hvgs_from_summary( + self, + *, + assay: RNAassay, + cell_selection: ArtifactRef, + feature_names: np.ndarray, + feature_snapshot: ArtifactRef, + parameters: dict[str, Any], + execution_options: dict[str, Any], + n_selected: int, + min_var: float, + max_var: float, + min_mean: float, + max_mean: float, + show_plot: bool, + invalidate_cache: bool, + plot_kwargs: dict[str, Any], + ) -> ArtifactRef: + """Select the cytearc flavor's HVGs of all selected cells from their summary.""" summary_ref = ensure_feature_summary( self.zw, assay, cell_selection, invalidate_cache=invalidate_cache, ) - n_selected = feature_summary_selected_count(self.zw, cell_selection) - max_cells_int = resolve_hvg_max_cells( - max_cells, n_selected=n_selected, min_cells=min_cells - ) feature_ids_fingerprint = _ordered_feature_ids_fingerprint(assay.z) planned = _feature_selection_plan( self.zw, @@ -409,43 +736,12 @@ def _select_hvgs_artifact( n_features=assay.feats.N, ordered_feature_ids_fingerprint=feature_ids_fingerprint, operation="select_hvgs", - parameters={ - "min_cells": min_cells, - "max_cells": max_cells_int, - "top_n": top_n, - "min_var": min_var, - "max_var": max_var, - "min_mean": min_mean, - "max_mean": max_mean, - "n_bins": n_bins, - "lowess_frac": lowess_frac, - "blacklist": blacklist, - **( - {"blacklist_fingerprint": blacklist_fingerprint} - if blacklist_fingerprint is not None - else {} - ), - "keep_bounds": keep_bounds, - "bin_strategy": bin_strategy, - **( - { - "variance_estimator": "regularized_local_quantile", - "variance_quantile": _ADAPTIVE_QUANTILE, - } - if bin_strategy == "adaptive" - else {} - ), - }, + parameters=parameters, inputs={ "feature_summary": summary_ref, "feature_snapshot": feature_snapshot, }, - execution_options={ - "show_plot": show_plot, - "plot_kwargs": plot_kwargs, - "nthreads": assay.nthreads, - "invalidate_cache": invalidate_cache, - }, + execution_options=execution_options, payload_names=("values", "corrected_variance"), invalidate_cache=invalidate_cache, ) @@ -459,31 +755,26 @@ def _select_hvgs_artifact( values, corrected_variance = assay._select_hvgs( summary, n_selected=n_selected, - min_cells=min_cells, - max_cells=max_cells_int, - top_n=top_n, + min_cells=parameters["min_cells"], + max_cells=parameters["max_cells"], + top_n=parameters["top_n"], min_var=min_var, max_var=max_var, min_mean=min_mean, max_mean=max_mean, - n_bins=n_bins, - lowess_frac=lowess_frac, - blacklist=blacklist, - keep_bounds=keep_bounds, - bin_strategy=bin_strategy, + n_bins=parameters["n_bins"], + lowess_frac=parameters["lowess_frac"], + blacklist=parameters["blacklist"], + keep_bounds=parameters["keep_bounds"], + bin_strategy=parameters["bin_strategy"], feature_names=feature_names, ) - selected_values = np.asarray(values, dtype=bool) - if not selected_values.any(): - raise ValueError( - "HVG selection contains no features; adjust the HVG filters" - ) _write_feature_selection( self.zw, planned, ordered_feature_ids_fingerprint=feature_ids_fingerprint, payload={ - "values": selected_values, + "values": np.asarray(values, dtype=bool), "corrected_variance": corrected_variance, }, payload_names=("values", "corrected_variance"), @@ -513,7 +804,7 @@ def _features_hvgs( cell_selection: ArtifactRef, *, from_assay: str | None = None, - min_cells: int = 20, + min_cells: int | None = None, top_n: int = 1000, min_var: float = -np.inf, max_var: float = np.inf, @@ -526,22 +817,144 @@ def _features_hvgs( show_plot: bool = True, max_cells: float | None = None, bin_strategy: Literal["fixed", "adaptive"] = "adaptive", + flavor: Literal["cytearc", "seurat_v3", "pearson_residuals"] = "cytearc", + batch: str | ArtifactRef | None = None, + span: float = DEFAULT_LOESS_SPAN, + theta: float = DEFAULT_PEARSON_THETA, + clip: float | None = None, invalidate_cache: bool = False, **plot_kwargs: Any, ) -> ArtifactRef: """Persist highly variable genes as an immutable feature selection. + Every flavor scores each gene's variability among the selected cells, + keeps the candidates that pass the filters below, and selects the + ``top_n`` candidates with the highest scores, ties broken by lower + feature index, or every candidate when fewer pass. The filters apply + before the ranking, so they never shrink the selection below + ``top_n`` while enough candidates pass. ``flavor`` sets the score: + + - ``"cytearc"`` (default): the variance of library-size normalized + values, ``sf * count / total`` with the assay's size factor + (1,000 by default) and no logarithm, divided by an + expression-dependent background, the lower quartile of the + variances of genes with a similar mean (``fit_lowess``). A + corrected variance of 1 lies on the background. + - ``"seurat_v3"``: the variance-stabilizing transformation of Stuart + et al. (2019) on raw counts, scanpy's ``flavor="seurat_v3"``. A + local quadratic regression of log10 variance on log10 mean with + ``span`` gives each gene an expected variance, counts are + standardized with it and clipped ``sqrt(n)`` standard deviations + above the mean, and the score is the variance of the standardized + values. + - ``"pearson_residuals"``: the variance of analytic Pearson residuals + of the raw counts with overdispersion ``theta``, clipped at + ``clip`` or ``sqrt(n)``, Lause, Berens and Kobak (2021), scanpy's + experimental ``flavor="pearson_residuals"``. The expected count of + a gene in a cell is the cell's prepared total times the gene's + share of the counts. + + seurat_v3 and pearson_residuals read the counts and the prepared cell + totals and ignore the assay's ``normMethod``. Each passes over the + counts twice, seurat_v3 reading again only genes with a count above + their clip. + + With ``batch``, every batch is scored on its own, each batch's + ``top_n`` candidates are highly variable in it, and genes are + selected by the number of batches in which they are highly variable, + most first, then by their median rank in those batches. This is the + order of Seurat's ``SelectIntegrationFeatures`` and of scanpy's + ``flavor="seurat_v3_paper"``; scanpy's ``flavor="seurat_v3"`` sorts by + median rank first. The stored ``corrected_variance`` is then the mean + score over the batches, and the selection also stores each gene's + ``batch_count`` and ``median_batch_rank`` (NaN for a gene that no + batch ranks among its ``top_n``). + + The artifact holds the ``values`` mask and each gene's + ``corrected_variance`` (the flavor's score). seurat_v3, + pearson_residuals, and batch-aware selections also store each gene's + ``mean_nonzero`` and ``detected`` count, which their plot shows. + Extra keyword arguments are options of :func:`cytearc.plotting.highly_variable_features`, used when ``show_plot`` is True. Any other keyword raises ``TypeError`` before anything is computed or saved. + Args: + cell_selection: The cells whose variability is scored. + from_assay: The RNA assay; the default assay when None. + min_cells: Keep genes detected in at least this many selected + cells. None uses the flavor's default: for cytearc, 1% of + the selected cells rounded up, at least 3 and at most 20, and + never more than a fifth of the cells; for the other flavors, + 0. + top_n: The number of genes to select, and with ``batch`` the + number that each batch ranks as highly variable. + min_var: cytearc only. The log2 of the smallest corrected + variance to keep: a gene stays only if its corrected variance + exceeds ``2**min_var``. ``-np.inf`` sets no bound. + max_var: cytearc only. The log2 of the largest corrected variance + to keep, ``2**max_var``. ``np.inf`` sets no bound. + min_mean: cytearc only. The log2 of the smallest mean normalized + value to keep, where the mean is over the selected cells in + which the gene is detected, not over all of them: a gene + stays only if that mean exceeds ``2**min_mean``. + ``min_mean=0`` keeps genes whose mean over detected cells + exceeds 1 normalized count. ``-np.inf`` sets no bound. + max_mean: cytearc only. The log2 of the largest such mean, + ``2**max_mean``. ``np.inf`` sets no bound. + n_bins: cytearc only. The number of points at which the adaptive + background is evaluated, or of bins of the fixed one. + lowess_frac: cytearc only. The background's window radius as a + fraction of the log-mean range. + blacklist: A case-insensitive regular expression; genes whose + names match it from their start are never selected. The + default excludes every family of + ``cytearc.features.gene_families``; ``""`` excludes none. + keep_bounds: Keep genes equal to a bound, which every bound + excludes otherwise. + show_plot: Plot the mean-variance diagnostic. Without matplotlib, + a warning says so and the selection is returned unplotted. + max_cells: Keep genes detected in fewer than this many selected + cells (at most this many with ``keep_bounds``). None uses + the flavor's default: for cytearc, exclude genes detected in + more than 99.5% of the selected cells; for the other + flavors, no bound. ``np.inf`` sets no bound. + bin_strategy: cytearc only. ``"adaptive"`` local quantile + regression or ``"fixed"`` LOWESS over the minimum-variance + gene of each bin. + flavor: ``"cytearc"``, ``"seurat_v3"``, or + ``"pearson_residuals"``. + batch: A cell metadata column, whose current values are + snapshotted, or a label artifact such as a clustering or HTO + identities, whose labels are the batches. Every selected cell + needs a label, and every batch at least two selected cells. + The detection bounds count the detections over every selected + cell; the mean and variance bounds apply within each batch. + span: seurat_v3 only. The fraction of genes in each local fit of + the trend. + theta: pearson_residuals only. The negative binomial + overdispersion. + clip: pearson_residuals only. The largest absolute residual; None + clips at the square root of each batch's cell count. + invalidate_cache: Compute again even when a matching selection + exists. + **plot_kwargs: Options of the plot. + + Returns: + The reference of the ``feature_selection`` artifact. Its + provenance records the resolved ``min_cells`` and ``max_cells``. + Raises: + TypeError: If an option has the wrong type or a keyword is unknown. + ValueError: If an option is invalid or does not apply to the + flavor, a batch is missing or too small, or no gene passes + the filters. UnmeasuredCellsError: If the assay did not measure a selected cell. """ if not isinstance(cell_selection, ArtifactRef): raise TypeError("cell_selection must be an ArtifactRef") - # The snapshot below writes, so the options are checked first; the + # The snapshots below write, so the options are checked first; the # artifact method checks them again. hvg_options( min_cells=min_cells, @@ -551,6 +964,29 @@ def _features_hvgs( keep_bounds=keep_bounds, bin_strategy=bin_strategy, ) + hvg_flavor_options( + flavor=flavor, + max_cells=max_cells, + min_mean=min_mean, + max_mean=max_mean, + min_var=min_var, + max_var=max_var, + n_bins=n_bins, + lowess_frac=lowess_frac, + bin_strategy=bin_strategy, + span=span, + theta=theta, + clip=clip, + ) + _hvg_batch_argument(batch, self.cells.columns) + if show_plot and not _matplotlib_available(): + warn( + "features.hvgs draws its mean-variance plot with matplotlib, which " + "is not installed, so it returns the selection without the plot; " + "install it with pip install 'cytearc[extra]', or pass " + "show_plot=False" + ) + show_plot = False if plot_kwargs: import inspect @@ -611,6 +1047,11 @@ def _features_hvgs( show_plot=show_plot, max_cells=max_cells, bin_strategy=bin_strategy, + flavor=flavor, + batch=batch, + span=span, + theta=theta, + clip=clip, invalidate_cache=invalidate_cache, **plot_kwargs, ) diff --git a/cytearc/datastore/_pipeline_recipe.py b/cytearc/datastore/_pipeline_recipe.py index 5a16001..044c24b 100644 --- a/cytearc/datastore/_pipeline_recipe.py +++ b/cytearc/datastore/_pipeline_recipe.py @@ -12,7 +12,12 @@ from ..clustering.leiden import canonical_resolution from ..embeddings import sgtsne from ..features.gene_reference import species_registry -from ..features.variability import HVG_OPTION_NAMES, hvg_options +from ..features.variability import ( + HVG_FLAVOR_OPTION_NAMES, + HVG_OPTION_NAMES, + hvg_flavor_options, + hvg_options, +) from ..graph.arguments import graph_flag from ..metadata.membership import require_measured_cells from ..quality_control.filtering import validate_filter_bounds @@ -48,6 +53,12 @@ def _keyword_default(method: Callable[..., Any], keyword: str) -> Any: for name in HVG_OPTION_NAMES } ) +_HVG_FLAVOR_OPTION_DEFAULTS: Mapping[str, Any] = MappingProxyType( + { + name: _keyword_default(_FeatureOperationsMixin._features_hvgs, name) + for name in HVG_FLAVOR_OPTION_NAMES + } +) # The embedding dimensions, and so the run fields, of settings that omit them. _UMAP_DIMS_DEFAULT: int = _keyword_default( _EmbeddingOperationsMixin._embeddings_umap, "umap_dims" @@ -213,6 +224,11 @@ def _resolve_leiden( "blacklist", "keep_bounds", "bin_strategy", + "flavor", + "batch", + "span", + "theta", + "clip", } ), "normalization": frozenset({"log_transform", "renormalize_subset"}), @@ -394,6 +410,14 @@ def _resolve_params( for name, default in _HVG_OPTION_DEFAULTS.items() } ) + hvg_flavor_options( + **{ + name: value.get(name, default) + for name, default in _HVG_FLAVOR_OPTION_DEFAULTS.items() + } + ) + if not isinstance(value.get("batch"), str | None): + raise TypeError(f"{name}['batch'] must be a cell metadata column") elif stage in {"tsne", "umap"}: # The checks of embeddings.tsne and the embeddings.umap graph # flags. The stages run late, so an invalid setting would @@ -691,6 +715,9 @@ def settings(stage: str) -> dict[str, Any]: raise ValueError("params['harmony'] needs batch_columns") harmony_batch_columns = harmony_params.pop("batch_columns") hvg_params = settings("hvg") + hvg_batch = hvg_params.get("batch") + if hvg_batch is not None and hvg_batch not in store.cells.columns: + raise KeyError(f"HVG batch column {hvg_batch!r} was not found") hvg_count = setting(hvg_params, "top_n", "hvg_count", hvg_count, HVG_COUNT_DEFAULT) pca_params = settings("pca") pca_dims = setting(pca_params, "dims", "pca_dims", pca_dims, PCA_DIMS_DEFAULT) diff --git a/cytearc/datastore/pipeline_accessor.py b/cytearc/datastore/pipeline_accessor.py index 9f6e46f..8940579 100644 --- a/cytearc/datastore/pipeline_accessor.py +++ b/cytearc/datastore/pipeline_accessor.py @@ -148,7 +148,7 @@ def run( forwards to that stage's function, so one mapping can configure a run: ``{"filtering": {"method": "manual", "lows": [...], "highs": [...]}, - "hvg": {"min_mean": 0.01, "keep_bounds": True}, "pca": {"dims": 30}, + "hvg": {"flavor": "seurat_v3", "top_n": 2000}, "pca": {"dims": 30}, "umap": {"n_epochs": 400}, "leiden": {"partitions": [0.8, 1.0], "selected": 1.0}, "tsne": {"max_iter": 800}}`` @@ -159,7 +159,10 @@ def run( mapping of settings, or a bool that switches the stage. - ``hvg``, ``normalization``, ``pca``, ``ann_index``, ``neighbors``, ``connectivity``, ``embedding_initialization``: settings for stages - that always run. ``pca`` ``dims=0`` skips PCA and builds the graph + that always run. The ``hvg`` settings are the keywords of + ``features.hvgs``, whose ``min_mean``, ``max_mean``, ``min_var``, + and ``max_var`` are log2 values; its ``batch`` names a cell + metadata column. ``pca`` ``dims=0`` skips PCA and builds the graph on the normalized values of the selected features; it requires ``doublets=False`` and no Harmony batch columns. - ``harmony``: ``batch_columns`` plus ``harmony_params`` (the keyword diff --git a/cytearc/features/gene_families.py b/cytearc/features/gene_families.py index bbc58a8..c5b1413 100644 --- a/cytearc/features/gene_families.py +++ b/cytearc/features/gene_families.py @@ -8,8 +8,17 @@ ``ribosomal`` covers cytosolic and mitochondrial ribosomal protein genes (RPS, RPL, MRPS, and MRPL), as the default ``percentRibo`` column does. ``mitochondrial`` covers ``MT-`` genes, as the default ``percentMito`` column -does. ``sexLinked`` lists ten sex-linked genes by exact name. The default HVG -blacklist excludes every registered family, in registry order. +does. ``cellCycleCcn`` covers the cyclins, whose symbols continue ``CCN`` with +a letter (``CCNA2``, ``CCND1``, ``CCNT1``), and leaves out the CCN family of +matricellular proteins, ``CCN1`` to ``CCN6`` (formerly ``CYR61``, ``CTGF``, +``NOV``, and ``WISP1`` to ``WISP3``). ``histone`` covers the +replication-dependent histone genes under their pre-2020 cluster symbols +(``HIST1H2AC``) and under their current HGNC and MGI symbols: the linker +histones ``H1-1`` to ``H1-6`` (mouse ``H1f1`` to ``H1f6``), the cluster genes +``H2AC*``, ``H2BC*``, ``H3C*``, and ``H4C*``, and ``H2AW``, ``H3-4``, and +``H4-16``. Replacement histones such as ``H3-3A``, ``H2AZ1``, and ``H1-0`` are +not in it. ``sexLinked`` lists ten sex-linked genes by exact name. The default +HVG blacklist excludes every registered family, in registry order. """ from collections.abc import Sequence @@ -32,10 +41,13 @@ { "mitochondrial": "^MT-", "ribosomal": "^RPS|^RPL|^MRPS|^MRPL", - "cellCycleCcn": "^CCN", + "cellCycleCcn": "^CCN[A-Z]", "hla": "^HLA-", "h2": "^H2-", - "histone": "^HIST", + "histone": ( + "^HIST|^H1-[1-6]$|^H1F[1-6]$|^H2AC\\d+$|^H2BC\\d+$|^H3C\\d+$|^H4C\\d+$|" + "^H2AW$|^H3-4$|^H4-16$" + ), "sexLinked": ( "^XIST$|^DDX3Y$|^USP9Y$|^EIF1AY$|^KDM5D$|^SRY$|^ZFY$|^UTY$|" "^TMSB4Y$|^NLGN4Y$" diff --git a/cytearc/features/variability.py b/cytearc/features/variability.py index 6df0415..96dd978 100644 --- a/cytearc/features/variability.py +++ b/cytearc/features/variability.py @@ -1,7 +1,35 @@ +"""Highly variable feature selection. + +``features.hvgs`` scores how variable each feature is among the selected +cells, keeps the candidates that pass its filters, and selects the ``top_n`` +candidates with the highest scores. Three flavors score a feature: + +- ``"cytearc"``: the variance of library-size normalized values divided by an + expression-dependent background, the lower quartile of the variances of + features with a similar mean (:func:`fit_lowess`). +- ``"seurat_v3"``: the variance-stabilizing transformation of Stuart et al. + (2019), Cell 177:1888-1902. A local quadratic regression of log10 variance + on log10 mean of the raw counts (:func:`fit_loess`) gives each feature an + expected variance; counts are standardized with it, clipped at + ``sqrt(n)`` standard deviations above the mean, and the score is the + variance of the standardized values (:func:`seurat_v3_expected_variance`, + :func:`seurat_v3_standardized_variance`). +- ``"pearson_residuals"``: the variance of analytic Pearson residuals of a + negative binomial model with a fixed overdispersion ``theta``, Lause, + Berens and Kobak (2021), Genome Biology 22:258 + (:func:`pearson_residuals`). + +With batches, every batch is scored on its own, each batch ranks the +candidates, and :func:`combine_batch_rankings` selects features by the +number of batches that rank them among their ``top_n`` and then by their +median rank, the order of Seurat's ``SelectIntegrationFeatures``. +""" + from typing import Any, Literal, NamedTuple, cast import numpy as np import pandas as pd +from numba import njit from ..utils.arguments import float_argument, integer_argument from ..utils.arrays import regex_match_mask, within_bounds @@ -10,13 +38,32 @@ __all__ = [ "DEFAULT_HVG_BLACKLIST", + "DEFAULT_LOESS_SPAN", + "DEFAULT_PEARSON_THETA", + "HVG_FLAVORS", + "HVG_FLAVOR_OPTION_NAMES", + "HVG_MIN_CELLS_CAP", + "HVG_MIN_CELLS_FLOOR", "HVG_OPTION_NAMES", - "HVG_UBIQUITOUS_SLACK", + "BatchRanking", + "HvgFlavorOptions", "HvgOptions", + "combine_batch_rankings", + "default_hvg_min_cells", + "default_hvg_ubiquity_limit", + "fit_loess", "fit_lowess", + "hvg_candidates", + "hvg_flavor_options", "hvg_options", - "resolve_hvg_max_cells", + "pearson_residual_clip", + "pearson_residuals", + "resolve_hvg_detection_bounds", + "select_batch_highly_variable_features", "select_highly_variable_features", + "seurat_v3_clip_values", + "seurat_v3_expected_variance", + "seurat_v3_standardized_variance", ] _ADAPTIVE_MIN_SUPPORT = 50 @@ -29,7 +76,21 @@ # Excludes every registered gene family. Patterns match names case-insensitively # unless a scoped regex flag overrides it. DEFAULT_HVG_BLACKLIST = "|".join(GENE_FAMILY_PATTERNS.values()) -HVG_UBIQUITOUS_SLACK = 20 + +# The flavors of features.hvgs; the first is the default. +HVG_FLAVORS: tuple[str, ...] = ("cytearc", "seurat_v3", "pearson_residuals") +# The span of the seurat_v3 trend and the overdispersion of Pearson residuals. +DEFAULT_LOESS_SPAN = 0.3 +DEFAULT_PEARSON_THETA = 100.0 +# The default min_cells of the cytearc flavor is 1% of the selected cells, +# at least HVG_MIN_CELLS_FLOOR and at most HVG_MIN_CELLS_CAP. +HVG_MIN_CELLS_CAP = 20 +HVG_MIN_CELLS_FLOOR = 3 +_MIN_CELLS_DIVISOR = 100 +# The default max_cells of the cytearc flavor excludes features detected in +# more than 99.5% of the selected cells, computed in integers as 199/200. +_UBIQUITY_NUMERATOR = 199 +_UBIQUITY_DENOMINATOR = 200 def _fit_local_quantile( @@ -328,6 +389,373 @@ def fit_lowess( return corrected +@njit(cache=True, nogil=True) +def _fit_loess_points( + x: np.ndarray, + y: np.ndarray, + q: int, + degree: int, + points: np.ndarray, + values: np.ndarray, + slopes: np.ndarray, +) -> None: + """Write the local polynomial fit and its slope at each ascending point. + + ``x`` is sorted ascending. The ``q`` data points nearest to a point + ``x0`` are a contiguous run of them, and ``h`` is the distance to the + farthest. A data point at distance ``d < h`` has the tricube weight + ``(1 - (d / h)**3)**3``; the others weigh zero. The weighted + least-squares polynomial of ``degree`` in ``(x - x0) / h`` is built from + orthogonal polynomials under the weights; its value and derivative at + ``x0`` are the fit and the slope. A polynomial whose weighted norm + vanishes, as when the weighted points take fewer distinct values than the + degree needs, is left out, so the fit lowers its degree instead of + failing. When all ``q`` points sit at ``x0``, the fit is the mean of every + data point at ``x0`` and the slope is 0. + """ + n = x.shape[0] + left = 0 + for i in range(points.shape[0]): + x0 = points[i] + if i > 0 and x0 == points[i - 1]: + # The fit depends on x0 alone. + values[i] = values[i - 1] + slopes[i] = slopes[i - 1] + continue + while left + q < n and x[left + q] - x0 < x0 - x[left]: + left += 1 + h = max(x0 - x[left], x[left + q - 1] - x0) + if h <= 0.0: + # The window never starts past the first data point at or above + # x0, so here it starts at the first point tied with x0. + end = left + q + while end < n and x[end] == x0: + end += 1 + total = 0.0 + for j in range(left, end): + total += y[j] + values[i] = total / (end - left) + slopes[i] = 0.0 + continue + sum_w = 0.0 + sum_wu = 0.0 + sum_wy = 0.0 + for j in range(left, left + q): + ratio = abs(x[j] - x0) / h + if ratio >= 1.0: + continue + weight = (1.0 - ratio * ratio * ratio) ** 3 + sum_w += weight + sum_wu += weight * (x[j] - x0) / h + sum_wy += weight * y[j] + if sum_w <= 0.0: + # Every point of the window sits at distance h, which happens only + # with fewer than three points or a vertex midway between two. + total = 0.0 + for j in range(left, left + q): + total += y[j] + values[i] = total / q + slopes[i] = 0.0 + continue + value = sum_wy / sum_w + slope = 0.0 + if degree >= 1: + alpha1 = sum_wu / sum_w + norm1 = 0.0 + dot1 = 0.0 + moment1 = 0.0 + for j in range(left, left + q): + ratio = abs(x[j] - x0) / h + if ratio >= 1.0: + continue + weight = (1.0 - ratio * ratio * ratio) ** 3 + u = (x[j] - x0) / h + p1 = u - alpha1 + norm1 += weight * p1 * p1 + dot1 += weight * p1 * y[j] + moment1 += weight * u * p1 * p1 + if norm1 > 1e-12 * sum_w: + value -= alpha1 * dot1 / norm1 + slope += dot1 / norm1 + if degree >= 2: + alpha2 = moment1 / norm1 + beta1 = norm1 / sum_w + norm2 = 0.0 + dot2 = 0.0 + for j in range(left, left + q): + ratio = abs(x[j] - x0) / h + if ratio >= 1.0: + continue + weight = (1.0 - ratio * ratio * ratio) ** 3 + u = (x[j] - x0) / h + p2 = (u - alpha2) * (u - alpha1) - beta1 + norm2 += weight * p2 * p2 + dot2 += weight * p2 * y[j] + if norm2 > 1e-12 * sum_w: + value += (alpha2 * alpha1 - beta1) * dot2 / norm2 + slope -= (alpha1 + alpha2) * dot2 / norm2 + values[i] = value + slopes[i] = slope / h + + +# Cells of the k-d tree that interpolation evaluates hold at most this fraction +# of span * n points, the default ``cell`` of R's ``loess.control``. +_LOESS_CELL = 0.2 + + +def _loess_vertices(x: np.ndarray, max_points: int) -> np.ndarray: + """Return the ascending vertices of a one-dimensional k-d tree over sorted ``x``. + + The root cell spans the data widened by 0.5% of their range on each side. + A cell with more than ``max_points`` points splits at the median point, + moved to the nearest position where it does not separate tied values, so + that the lower cell ends at that value; a cell whose split would fall on + one of its vertices stays whole. + """ + low, high = float(x[0]), float(x[-1]) + margin = 0.005 * max(high - low, 1e-10 * max(abs(low), abs(high)) + 1e-30) + vertices = [low - margin, high + margin] + cells = [(0, len(x) - 1, low - margin, high + margin)] + while cells: + first, last, lower, upper = cells.pop() + if last - first + 1 <= max_points: + continue + middle = (first + last) // 2 + offset = 0 + while first <= middle + offset < last: + if x[middle + offset] != x[middle + offset + 1]: + middle += offset + break + offset = -offset + if offset >= 0: + offset += 1 + split = float(x[middle]) + if split in (lower, upper): + continue + vertices.append(split) + cells.append((first, middle, lower, split)) + cells.append((middle + 1, last, split, upper)) + return np.unique(np.asarray(vertices, dtype=np.float64)) + + +def fit_loess( + x: np.ndarray, + y: np.ndarray, + *, + span: float = DEFAULT_LOESS_SPAN, + degree: int = 2, + surface: Literal["interpolate", "direct"] = "interpolate", +) -> np.ndarray: + """Fit a local polynomial regression of ``y`` on ``x`` at every ``x``. + + This is local regression in the sense of Cleveland and Devlin (1988), + Journal of the American Statistical Association 83:596-610, without + robustness iterations: the ``floor(span * n)`` points nearest to a point, + at least ``degree + 1`` of them, carry tricube weights of their distance + relative to the farthest of them, and a weighted least-squares polynomial + of ``degree`` gives the fitted value. ``surface="direct"`` computes this + fit at every point. ``surface="interpolate"``, the default of R's + ``loess`` and of scikit-misc, follows Cleveland and Grosse (1991), + Statistics and Computing 1:47-62: it computes the fit and its slope at + the vertices of a k-d tree whose cells hold at most + ``floor(0.2 * span * n)`` points, and blends them between vertices with + cubic Hermite polynomials. + + Args: + x: One predictor value per point. + y: One response value per point. + span: The fraction of the points that each local fit uses, greater + than 0 and at most 1. + degree: The local polynomial degree, 0, 1, or 2. + surface: ``"interpolate"`` or ``"direct"``. + + Returns: + The float64 fitted value at each point, in the order of ``x``. + + Raises: + ValueError: If the inputs are not finite one-dimensional arrays of + equal length, or ``span``, ``degree``, or ``surface`` is out of + range. + """ + predictor = np.asarray(x, dtype=np.float64) + response = np.asarray(y, dtype=np.float64) + if predictor.ndim != 1 or predictor.shape != response.shape: + raise ValueError("LOESS inputs must be one-dimensional arrays of equal length") + if not (np.isfinite(predictor).all() and np.isfinite(response).all()): + raise ValueError("LOESS inputs must be finite") + span = _loess_span(span) + degree = integer_argument(degree, "degree", minimum=0, maximum=2) + if surface not in ("interpolate", "direct"): + raise ValueError("surface must be 'interpolate' or 'direct'") + n_points = predictor.shape[0] + fitted = np.empty(n_points, dtype=np.float64) + if n_points == 0: + return fitted + neighbours = min(n_points, max(int(np.floor(span * n_points)), degree + 1)) + order = np.argsort(predictor, kind="stable") + sorted_x = np.ascontiguousarray(predictor[order]) + sorted_y = np.ascontiguousarray(response[order]) + points = ( + sorted_x + if surface == "direct" + else _loess_vertices( + sorted_x, max(1, int(np.floor(n_points * span * _LOESS_CELL))) + ) + ) + values = np.empty(points.shape[0], dtype=np.float64) + slopes = np.empty(points.shape[0], dtype=np.float64) + _fit_loess_points(sorted_x, sorted_y, neighbours, degree, points, values, slopes) + if surface == "direct": + fitted[order] = values + return fitted + # Cubic Hermite blending of the vertex values and slopes in each cell. + cell = np.clip( + np.searchsorted(points, predictor, side="right") - 1, 0, len(points) - 2 + ) + width = points[cell + 1] - points[cell] + t = (predictor - points[cell]) / width + fitted[:] = ( + (1 - t) ** 2 * (1 + 2 * t) * values[cell] + + t**2 * (3 - 2 * t) * values[cell + 1] + + (t * (1 - t) ** 2 * slopes[cell] - t**2 * (1 - t) * slopes[cell + 1]) * width + ) + return fitted + + +def _loess_span(value: object) -> float: + """Return a checked LOESS span as a float.""" + resolved = float_argument(value, "span") + if not 0 < resolved <= 1: + raise ValueError("span must be greater than 0 and at most 1") + return resolved + + +def seurat_v3_expected_variance( + means: np.ndarray, + variances: np.ndarray, + *, + span: float = DEFAULT_LOESS_SPAN, +) -> np.ndarray: + """Return the count variance that the seurat_v3 trend expects per feature. + + The trend is :func:`fit_loess` of degree 2 of ``log10(variance)`` on + ``log10(mean)`` over the features whose variance is positive. A feature + with zero variance is constant, so its expected variance is 0 and its + standardized variance is 0 too. + + Args: + means: The mean count of each feature over the cells. + variances: The variance of each feature's counts, with one degree of + freedom removed. + span: The fraction of the features in each local fit. + + Returns: + The float64 expected variance of each feature. + + Raises: + ValueError: If a varying feature has a mean that is not positive. + """ + means = np.asarray(means, dtype=np.float64) + variances = np.asarray(variances, dtype=np.float64) + expected = np.zeros(means.shape, dtype=np.float64) + varying = variances > 0 + if varying.any(): + if not (means[varying] > 0).all(): + raise ValueError("Features with a positive variance need a positive mean") + trend = fit_loess( + np.log10(means[varying]), np.log10(variances[varying]), span=span + ) + expected[varying] = np.power(10.0, trend) + return expected + + +def seurat_v3_clip_values( + means: np.ndarray, expected_variance: np.ndarray, n_cells: int | np.ndarray +) -> np.ndarray: + """Return the count at which seurat_v3 clips each feature. + + A count is clipped at ``sqrt(n_cells)`` expected standard deviations above + the feature's mean, so no standardized value exceeds ``sqrt(n_cells)``. + ``n_cells`` broadcasts against the means, such as one count per batch + row. + """ + clips: np.ndarray = np.asarray(means, dtype=np.float64) + np.sqrt( + np.asarray(expected_variance, dtype=np.float64) + ) * np.sqrt(np.asarray(n_cells, dtype=np.float64)) + return clips + + +def seurat_v3_standardized_variance( + clipped_squares: np.ndarray, expected_variance: np.ndarray, n_cells: int +) -> np.ndarray: + """Return the variance of each feature's standardized, clipped counts. + + ``clipped_squares`` holds, for each feature, the sum over the cells of + ``(min(count, clip) - mean)**2`` with the clip of + :func:`seurat_v3_clip_values`. Dividing by ``(n_cells - 1)`` and the + expected variance gives the variance of the standardized values. A + feature whose expected variance is 0 is constant and scores 0. + + Raises: + ValueError: If there are fewer than two cells. + """ + if n_cells < 2: + raise ValueError("A standardized variance needs at least two cells") + expected = np.asarray(expected_variance, dtype=np.float64) + standardized = np.zeros(expected.shape, dtype=np.float64) + np.divide( + np.asarray(clipped_squares, dtype=np.float64), + (n_cells - 1) * expected, + out=standardized, + where=expected > 0, + ) + return standardized + + +def pearson_residual_clip(clip: float | None, n_cells: int) -> float: + """Return the clip of Pearson residuals: ``clip``, or ``sqrt(n_cells)`` if None.""" + return float(np.sqrt(n_cells)) if clip is None else float(clip) + + +def pearson_residuals( + counts: np.ndarray, + cell_totals: np.ndarray, + feature_fractions: np.ndarray, + *, + theta: float = DEFAULT_PEARSON_THETA, + clip: float, +) -> np.ndarray: + """Return analytic Pearson residuals of counts, clipped to ``[-clip, clip]``. + + The expected count of a feature in a cell is ``mu = n_c * p_g``, the + cell's total times the feature's fraction of all counts, and the residual + is ``(x - mu) / sqrt(mu + mu**2 / theta)``, Lause, Berens and Kobak + (2021). A residual whose expected count is 0 is 0, its limit as the + expected count goes to 0. Every step runs in float64. + + Args: + counts: Counts with one row per cell and one column per feature. + cell_totals: The total count of each cell. + feature_fractions: Each feature's share of all counts. + theta: The negative binomial overdispersion. + clip: The largest absolute residual. + + Returns: + Float64 residuals with the shape of ``counts``. + """ + values = np.asarray(counts, dtype=np.float64) + expected = np.multiply.outer( + np.asarray(cell_totals, dtype=np.float64), + np.asarray(feature_fractions, dtype=np.float64), + ) + residuals = np.zeros(values.shape, dtype=np.float64) + positive = expected > 0 + residuals[positive] = (values[positive] - expected[positive]) / np.sqrt( + expected[positive] + expected[positive] ** 2 / theta + ) + return np.clip(residuals, -clip, clip, out=residuals) + + # The ``select_hvgs`` keywords that ``hvg_options`` checks. HVG_OPTION_NAMES = ( "min_cells", @@ -340,9 +768,12 @@ def fit_lowess( class HvgOptions(NamedTuple): - """Checked ``select_hvgs`` options, each as an HVG selection records it.""" + """Checked ``select_hvgs`` options, each as an HVG selection records it. - min_cells: int + ``min_cells`` is None when the flavor's default applies. + """ + + min_cells: int | None top_n: int n_bins: int lowess_frac: float @@ -360,7 +791,11 @@ def hvg_options( bin_strategy: object, ) -> HvgOptions: """Return the checked counts, trend options, and flag of ``select_hvgs``.""" - checked_min_cells = integer_argument(min_cells, "min_cells", minimum=0) + checked_min_cells = ( + None + if min_cells is None + else integer_argument(min_cells, "min_cells", minimum=0) + ) checked_top_n = integer_argument(top_n, "top_n", minimum=1) checked_n_bins = integer_argument(n_bins, "n_bins", minimum=1) _lowess_frac(lowess_frac) @@ -376,36 +811,196 @@ def hvg_options( ) -def resolve_hvg_max_cells( +# The ``select_hvgs`` keywords that ``hvg_flavor_options`` checks. +HVG_FLAVOR_OPTION_NAMES = ( + "flavor", + "max_cells", + "min_mean", + "max_mean", + "min_var", + "max_var", + "n_bins", + "lowess_frac", + "bin_strategy", + "span", + "theta", + "clip", +) +# The options of the cytearc flavor and the defaults that other flavors keep. +_CYTEARC_DEFAULTS: dict[str, object] = { + "min_mean": -np.inf, + "max_mean": np.inf, + "min_var": -np.inf, + "max_var": np.inf, + "n_bins": 200, + "lowess_frac": 0.1, + "bin_strategy": "adaptive", +} + + +class HvgFlavorOptions(NamedTuple): + """The checked flavor of ``select_hvgs`` and its own options. + + ``span`` is a float for ``"seurat_v3"`` and ``theta`` a float for + ``"pearson_residuals"``; ``clip`` is None when residuals are clipped at + the square root of each batch's cell count. + """ + + flavor: Literal["cytearc", "seurat_v3", "pearson_residuals"] + max_cells: float | None + span: float + theta: float + clip: float | None + + +def _bound(value: object, name: str) -> float: + """Return a log2 HVG bound: a real number, which may be infinite.""" + if isinstance(value, bool | np.bool_) or not isinstance( + value, int | float | np.integer | np.floating + ): + raise TypeError(f"{name} must be a real number") + resolved = float(value) + if np.isnan(resolved): + raise ValueError(f"{name} must not be NaN") + return resolved + + +def hvg_flavor_options( + *, + flavor: object, + max_cells: object, + min_mean: object, + max_mean: object, + min_var: object, + max_var: object, + n_bins: object, + lowess_frac: object, + bin_strategy: object, + span: object, + theta: object, + clip: object, +) -> HvgFlavorOptions: + """Check the flavor of ``select_hvgs`` and the options that depend on it. + + The mean and variance bounds and the trend options belong to the cytearc + flavor, ``span`` to seurat_v3, and ``theta`` and ``clip`` to + pearson_residuals; another flavor refuses a value other than the default. + + Raises: + TypeError: If an option has the wrong type. + ValueError: If an option is out of range or does not apply to the + flavor. + """ + if not isinstance(flavor, str) or flavor not in HVG_FLAVORS: + raise ValueError( + "flavor must be one of " + ", ".join(repr(name) for name in HVG_FLAVORS) + ) + if max_cells is not None: + if isinstance(max_cells, bool | np.bool_) or not isinstance( + max_cells, int | float | np.integer | np.floating + ): + raise TypeError("max_cells must be a number, infinity, or None") + if np.isnan(max_cells) or max_cells < 0: + raise ValueError("max_cells must be at least 0") + bounds = { + "min_mean": _bound(min_mean, "min_mean"), + "max_mean": _bound(max_mean, "max_mean"), + "min_var": _bound(min_var, "min_var"), + "max_var": _bound(max_var, "max_var"), + } + checked_span = _loess_span(span) + checked_theta = float_argument(theta, "theta") + if checked_theta <= 0: + raise ValueError("theta must be greater than 0") + checked_clip = None if clip is None else float_argument(clip, "clip") + if checked_clip is not None and checked_clip < 0: + raise ValueError("clip must be at least 0") + if flavor != "cytearc": + given = { + **bounds, + "n_bins": n_bins, + "lowess_frac": lowess_frac, + "bin_strategy": bin_strategy, + } + changed = [ + name for name, value in given.items() if value != _CYTEARC_DEFAULTS[name] + ] + if changed: + raise ValueError( + ", ".join(changed) + + f" apply only to flavor='cytearc'; leave them at their defaults " + f"for flavor={flavor!r}" + ) + if flavor != "seurat_v3" and checked_span != DEFAULT_LOESS_SPAN: + raise ValueError("span applies only to flavor='seurat_v3'") + if flavor != "pearson_residuals" and ( + checked_theta != DEFAULT_PEARSON_THETA or checked_clip is not None + ): + raise ValueError("theta and clip apply only to flavor='pearson_residuals'") + return HvgFlavorOptions( + flavor=cast(Literal["cytearc", "seurat_v3", "pearson_residuals"], flavor), + max_cells=None if max_cells is None else float(cast(float, max_cells)), + span=checked_span, + theta=checked_theta, + clip=checked_clip, + ) + + +def default_hvg_min_cells(n_selected: int) -> int: + """Return the default ``min_cells`` of the cytearc flavor for ``n_selected`` cells. + + It is 1% of the selected cells rounded up, at least 3 and at most 20, so + selections of 2,000 cells or more keep the earlier fixed 20. It never + exceeds a fifth of the cells, at least 1, so a tiny selection keeps a + band of detection counts to choose from. + """ + scaled = -(-int(n_selected) // _MIN_CELLS_DIVISOR) + return min( + HVG_MIN_CELLS_CAP, + max(HVG_MIN_CELLS_FLOOR, scaled), + max(1, int(n_selected) // 5), + ) + + +def default_hvg_ubiquity_limit(n_selected: int) -> int: + """Return the most cells a feature may be detected in under the default cap. + + Features detected in more than 99.5% of the selected cells are ubiquitous, + so the limit is ``floor(0.995 * n_selected)``. + """ + return int(n_selected) * _UBIQUITY_NUMERATOR // _UBIQUITY_DENOMINATOR + + +def resolve_hvg_detection_bounds( + min_cells: int | None, max_cells: float | None, *, n_selected: int, - min_cells: int, -) -> int | float: - """Return the detected-cell cutoff that HVG selection applies and records. + keep_bounds: bool, + flavor: str = "cytearc", +) -> tuple[int, int | float]: + """Return the detection bounds that HVG selection applies and records. - None selects the automatic cutoff and infinity sets no cutoff; any other - value is taken as an integer. + A feature is a candidate when it is detected in at least ``min_cells`` + selected cells and in fewer than ``max_cells``, or in at most + ``max_cells`` with ``keep_bounds``. For the cytearc flavor, a ``min_cells`` + of None is :func:`default_hvg_min_cells`, and a ``max_cells`` of None + excludes features detected in more than 99.5% of the selected cells: + :func:`default_hvg_ubiquity_limit` plus one, or the limit itself with + ``keep_bounds``. Other flavors bound detection only when asked, so their + None bounds are 0 and infinity. Infinity sets no upper bound, and any + other ``max_cells`` is taken as an integer. """ + if min_cells is None: + min_cells = default_hvg_min_cells(n_selected) if flavor == "cytearc" else 0 if max_cells is None: - candidate = n_selected - HVG_UBIQUITOUS_SLACK - if candidate <= min_cells: - logger.info( - "Skipping ubiquitous-gene HVG filter because too few cells are " - f"selected ({n_selected}); need more than " - f"{min_cells + HVG_UBIQUITOUS_SLACK} cells to apply " - f"max_cells = n_selected - {HVG_UBIQUITOUS_SLACK}." - ) - return np.inf - logger.debug( - f"Setting `max_cells` to {candidate} " - f"(n_selected - {HVG_UBIQUITOUS_SLACK}). Genes detected in at " - "least this many cells are excluded as ubiquitous." - ) - return int(candidate) + if flavor != "cytearc": + return min_cells, np.inf + limit = default_hvg_ubiquity_limit(n_selected) + return min_cells, limit if keep_bounds else limit + 1 if max_cells == np.inf: - return np.inf - return int(max_cells) + return min_cells, np.inf + return min_cells, int(max_cells) def _linear_threshold(value: float, unbounded_value: float) -> float: @@ -414,6 +1009,84 @@ def _linear_threshold(value: float, unbounded_value: float) -> float: return float(2**value) +def hvg_candidates( + corrected_variance: np.ndarray, + normalized_cell_counts: np.ndarray, + mean_nonzero: np.ndarray, + *, + allowed: np.ndarray, + min_cells: int, + max_cells: int | float, + min_var: float, + max_var: float, + min_mean: float, + max_mean: float, + keep_bounds: bool, +) -> np.ndarray: + """Return the features that pass the HVG candidate filters. + + A candidate is ``allowed``, is detected in at least ``min_cells`` cells + and in fewer than ``max_cells`` (at most with ``keep_bounds``), and has + a mean over the cells where it is detected and a corrected variance + within the bounds. The mean and variance bounds are log2 values, so a + bound ``b`` compares with ``2**b``, and an infinite bound leaves its side + open. Bounds exclude equal values unless ``keep_bounds`` is set, and NaN + never lies within them. + """ + detected = np.asarray(normalized_cell_counts) + candidates = np.asarray(allowed, dtype=bool) & (detected >= min_cells) + candidates &= detected <= max_cells if keep_bounds else detected < max_cells + candidates &= within_bounds( + np.asarray(mean_nonzero), + _linear_threshold(min_mean, -np.inf), + _linear_threshold(max_mean, np.inf), + keep_bounds=keep_bounds, + ) + candidates &= within_bounds( + np.asarray(corrected_variance), + _linear_threshold(min_var, -np.inf), + _linear_threshold(max_var, np.inf), + keep_bounds=keep_bounds, + ) + return candidates + + +def _top_candidates( + scores: np.ndarray, candidates: np.ndarray, top_n: int +) -> np.ndarray: + """Return the ``top_n`` candidates by score, ties broken by lower index.""" + candidate_idx = np.flatnonzero(candidates) + order = np.lexsort((candidate_idx, -scores[candidate_idx])) + return candidate_idx[order[:top_n]] + + +def _no_candidates_message( + *, + min_cells: int, + max_cells: int | float, + min_var: float, + max_var: float, + min_mean: float, + max_mean: float, + where: str = "", +) -> str: + """Return the error of an HVG selection that no feature passes.""" + return ( + "HVG selection contains no features. No features passed HVG candidate " + f"filters{where} (min_cells={min_cells}, max_cells={max_cells}, log2 " + f"bounds min_mean={min_mean}, max_mean={max_mean}, min_var={min_var}, " + f"max_var={max_var}). Widen the bounds or change the blacklist." + ) + + +def _warn_few_candidates(n_candidates: int, top_n: int) -> None: + """Warn that fewer than ``top_n`` features passed the candidate filters.""" + logger.warning( + f"Only {n_candidates} features passed the HVG candidate filters, fewer " + f"than top_n={top_n}; all of them are selected" + ) + + def select_highly_variable_features( corrected_variance: np.ndarray, normalized_cell_counts: np.ndarray, @@ -431,7 +1104,20 @@ def select_highly_variable_features( blacklist: str, keep_bounds: bool, ) -> np.ndarray: - """Select highly variable features from precomputed feature statistics.""" + """Select highly variable features from precomputed feature statistics. + + Every filter applies to the candidates before they are ranked: the + blacklist, the detection bounds ``min_cells`` and ``max_cells``, the + log2 bounds on the mean over detected cells ``min_mean`` and + ``max_mean``, and the log2 bounds on the corrected variance ``min_var`` + and ``max_var`` (see :func:`hvg_candidates`). The ``top_n`` candidates + with the highest corrected variance are selected, ties broken by lower + feature index, or every candidate when fewer pass. + + Raises: + ValueError: If the inputs are misaligned, ``top_n`` is below 1, or no + feature passes the filters. + """ corrected_variance = np.asarray(corrected_variance) normalized_cell_counts = np.asarray(normalized_cell_counts) mean_nonzero = np.asarray(mean_nonzero) @@ -448,77 +1134,220 @@ def select_highly_variable_features( ) ): raise ValueError("HVG inputs must be one-dimensional arrays of equal length") - - min_var = _linear_threshold(min_var, -np.inf) - max_var = _linear_threshold(max_var, np.inf) - min_mean = _linear_threshold(min_mean, -np.inf) - max_mean = _linear_threshold(max_mean, np.inf) - + if top_n < 1: + raise ValueError( + "ERROR: Please provide a value greater than 0 for `top_n` parameter" + ) + allowed = active_features.copy() if blacklist: - allowed = ~regex_match_mask(feature_names, blacklist) - else: - allowed = np.ones(size, dtype=bool) - - cell_count_candidates = normalized_cell_counts >= min_cells - cell_count_candidates &= ( - normalized_cell_counts <= max_cells - if keep_bounds - else normalized_cell_counts < max_cells - ) - candidates = ( - cell_count_candidates - & within_bounds(mean_nonzero, min_mean, max_mean, keep_bounds=keep_bounds) - & active_features - & allowed + allowed &= ~regex_match_mask(feature_names, blacklist) + candidates = hvg_candidates( + corrected_variance, + normalized_cell_counts, + mean_nonzero, + allowed=allowed, + min_cells=min_cells, + max_cells=max_cells, + min_var=min_var, + max_var=max_var, + min_mean=min_mean, + max_mean=max_mean, + keep_bounds=keep_bounds, ) - if min_var == -np.inf: - if top_n < 1: - raise ValueError( - "ERROR: Please provide a value greater than 0 for `top_n` parameter" - ) - n_valid_features = int(candidates.sum()) - if n_valid_features == 0: - raise ValueError( - "No features passed HVG candidate filters " - f"(min_cells={min_cells}, max_cells={max_cells}, " - f"min_mean={min_mean}, max_mean={max_mean})." + n_candidates = int(candidates.sum()) + if n_candidates == 0: + raise ValueError( + _no_candidates_message( + min_cells=min_cells, + max_cells=max_cells, + min_var=min_var, + max_var=max_var, + min_mean=min_mean, + max_mean=max_mean, ) - if top_n > n_valid_features: + ) + if top_n > n_candidates: + _warn_few_candidates(n_candidates, top_n) + selected = np.zeros(size, dtype=bool) + selected[_top_candidates(corrected_variance, candidates, top_n)] = True + return selected + + +class BatchRanking(NamedTuple): + """Highly variable features chosen across batches. + + Attributes: + selected: Whether each feature is selected. + batch_count: The number of batches that rank each feature among their + ``top_n``. + median_rank: Each feature's median rank over those batches, counted + from 0 for the most variable feature, and NaN for a feature that + no batch ranks among its ``top_n``. + """ + + selected: np.ndarray + batch_count: np.ndarray + median_rank: np.ndarray + + +def combine_batch_rankings( + scores: np.ndarray, + candidates: np.ndarray, + *, + top_n: int, + batch_names: list[str] | None = None, +) -> BatchRanking: + """Select features that many batches rank as highly variable. + + Each batch ranks its candidates by score, highest first and ties broken by + lower feature index, and its first ``top_n`` are highly variable in it. + Features are then ordered by the number of batches in which they are + highly variable, most first, then by their median rank over those + batches, then by feature index, and the first ``top_n`` are selected. This + is the order of Seurat's ``SelectIntegrationFeatures``; scanpy's + ``seurat_v3`` flavor sorts by median rank first, and its + ``seurat_v3_paper`` flavor by batch count first, as here. With one batch + the selection is the ``top_n`` candidates by score. + + A warning names each of several batches with fewer than ``top_n`` + candidates, and another reports a selection of fewer than ``top_n`` + features. + + Args: + scores: Each batch's score of each feature, one row per batch. + candidates: Whether each feature is a candidate in each batch. + top_n: The number of features that each batch ranks as highly + variable, and the number selected. + batch_names: The name of each batch for messages. + + Returns: + The selection with each feature's batch count and median rank. + + Raises: + ValueError: If no batch has a candidate. + """ + scores = np.asarray(scores, dtype=np.float64) + candidates = np.asarray(candidates, dtype=bool) + n_batches, n_features = scores.shape + names = batch_names or [str(index) for index in range(n_batches)] + ranks = np.full((n_batches, n_features), np.nan) + for batch in range(n_batches): + n_candidates = int(candidates[batch].sum()) + if n_batches > 1 and n_candidates < top_n: logger.warning( - f"WARNING: Number of valid features is less than value " - f"of parameter `top_n`: {top_n}. Resetting `top_n` to " - f"{n_valid_features}" - ) - top_n = n_valid_features - # Deterministic tie-break: higher variance first, then lower feature index. - candidate_idx = np.flatnonzero(candidates) - order = np.lexsort( - ( - candidate_idx, - -corrected_variance[candidate_idx], + f"Batch {names[batch]!r} has {n_candidates} HVG candidates, fewer " + f"than top_n={top_n}; all of them count as highly variable in it" ) + top = _top_candidates(scores[batch], candidates[batch], top_n) + ranks[batch, top] = np.arange(len(top), dtype=np.float64) + ranked = ~np.isnan(ranks) + batch_count = ranked.sum(axis=0).astype(np.int64) + eligible = np.flatnonzero(batch_count > 0) + if eligible.size == 0: + raise ValueError( + "HVG selection contains no features. No features passed HVG candidate " + "filters in any batch. Widen the bounds or change the blacklist." ) - ranked = candidate_idx[order] - selected = np.zeros(size, dtype=bool) - selected[ranked[:top_n]] = True - return np.asarray( - selected - & within_bounds( - corrected_variance, - None, - max_var, - keep_bounds=keep_bounds, - ), - dtype=bool, + median_rank = np.full(n_features, np.nan) + median_rank[eligible] = np.nanmedian(ranks[:, eligible], axis=0) + order = eligible[ + np.lexsort((eligible, median_rank[eligible], -batch_count[eligible])) + ] + selected = np.zeros(n_features, dtype=bool) + selected[order[:top_n]] = True + if len(order) < top_n and n_batches == 1: + _warn_few_candidates(len(order), top_n) + elif len(order) < top_n: + logger.warning( + f"Only {len(order)} features are highly variable in some batch, fewer " + f"than top_n={top_n}; all of them are selected" ) + return BatchRanking(selected, batch_count, median_rank) + - return np.asarray( - candidates - & within_bounds( - corrected_variance, - min_var, - max_var, - keep_bounds=keep_bounds, - ), - dtype=bool, +def select_batch_highly_variable_features( + scores: np.ndarray, + mean_nonzero: np.ndarray, + detected: np.ndarray, + feature_names: np.ndarray, + *, + min_cells: int, + max_cells: int | float, + top_n: int, + min_var: float, + max_var: float, + min_mean: float, + max_mean: float, + blacklist: str, + keep_bounds: bool, + batch_names: list[str] | None = None, +) -> BatchRanking: + """Select highly variable features from the scores of each batch. + + Each batch's candidates pass the blacklist, the detection bounds over + every selected cell, and the log2 bounds on that batch's mean over + detected cells and on its score (see :func:`hvg_candidates`); + :func:`combine_batch_rankings` then ranks them. With one batch this is + the ``top_n`` candidates by score. + + Args: + scores: Each batch's score of each feature, one row per batch. + mean_nonzero: Each batch's mean over the cells where a feature is + detected, one row per batch. + detected: The number of selected cells where each feature is detected. + feature_names: The name of each feature, matched against ``blacklist``. + min_cells: The fewest cells a candidate is detected in. + max_cells: The detection cutoff, exclusive unless ``keep_bounds``. + top_n: The number of features each batch ranks and the selection keeps. + min_var: The log2 lower bound of the score. + max_var: The log2 upper bound of the score. + min_mean: The log2 lower bound of the mean over detected cells. + max_mean: The log2 upper bound of the mean over detected cells. + blacklist: A case-insensitive regular expression of excluded names. + keep_bounds: Whether bounds keep equal values. + batch_names: The name of each batch for messages. + + Returns: + The selection with each feature's batch count and median rank. + + Raises: + ValueError: If no batch has a candidate; the message names the + filters. + """ + scores = np.asarray(scores, dtype=np.float64) + allowed = np.ones(scores.shape[1], dtype=bool) + if blacklist: + allowed &= ~regex_match_mask(np.asarray(feature_names), blacklist) + candidates = np.stack( + [ + hvg_candidates( + scores[batch], + detected, + np.asarray(mean_nonzero)[batch], + allowed=allowed, + min_cells=min_cells, + max_cells=max_cells, + min_var=min_var, + max_var=max_var, + min_mean=min_mean, + max_mean=max_mean, + keep_bounds=keep_bounds, + ) + for batch in range(scores.shape[0]) + ] + ) + if not candidates.any(): + raise ValueError( + _no_candidates_message( + min_cells=min_cells, + max_cells=max_cells, + min_var=min_var, + max_var=max_var, + min_mean=min_mean, + max_mean=max_mean, + where=" in any batch" if scores.shape[0] > 1 else "", + ) + ) + return combine_batch_rankings( + scores, candidates, top_n=top_n, batch_names=batch_names ) diff --git a/cytearc/storage/feature_selection.py b/cytearc/storage/feature_selection.py index 3a23b25..6e9deb1 100644 --- a/cytearc/storage/feature_selection.py +++ b/cytearc/storage/feature_selection.py @@ -233,26 +233,9 @@ def _validate_ref_scope(ref: ArtifactRef, assay: str) -> None: frozenset({"min_cells"}), ("values",), ), - "select_hvgs": ( - frozenset({"feature_snapshot", "feature_summary"}), - frozenset( - { - "min_cells", - "max_cells", - "top_n", - "min_var", - "max_var", - "min_mean", - "max_mean", - "n_bins", - "lowess_frac", - "blacklist", - "keep_bounds", - "bin_strategy", - } - ), - ("values", "corrected_variance"), - ), + # The inputs and parameters of an HVG selection depend on its flavor and + # batches; see _hvg_contract. + "select_hvgs": (frozenset(), frozenset(), ()), "select_prevalent_peaks": ( frozenset({"feature_summary"}), frozenset({"top_n"}), @@ -462,6 +445,120 @@ def _hvg_optional_parameters( return frozenset(names) +# The parameters that every HVG flavor records, those of the cytearc flavor's +# trend and bounds, and those that each other flavor adds with its name. +_HVG_COMMON_PARAMETERS = frozenset( + {"min_cells", "max_cells", "top_n", "blacklist", "keep_bounds"} +) +_HVG_TREND_PARAMETERS = frozenset( + { + "min_var", + "max_var", + "min_mean", + "max_mean", + "n_bins", + "lowess_frac", + "bin_strategy", + } +) +_HVG_FLAVOR_PARAMETERS = { + "seurat_v3": frozenset({"flavor", "span"}), + "pearson_residuals": frozenset({"flavor", "theta", "clip"}), +} + + +def _hvg_contract( + parameters: Mapping[str, Any], + inputs: Mapping[str, Any], + context: dict[str, str | None], +) -> tuple[frozenset[str], frozenset[str], tuple[str, ...]]: + """Return the inputs, parameters, and payload of one HVG selection. + + The cytearc flavor of all selected cells reads the feature summary. Other + flavors and batch-aware selections read the counts of the selected cells, + record the dataset they read and the batch labels, and store the plotted + statistics and, with batches, each feature's batch count and median rank. + """ + flavor = parameters.get("flavor", "cytearc") + if flavor in _HVG_FLAVOR_PARAMETERS: + names = _HVG_COMMON_PARAMETERS | _HVG_FLAVOR_PARAMETERS[flavor] + elif "flavor" not in parameters: + names = _HVG_COMMON_PARAMETERS | _HVG_TREND_PARAMETERS + else: + raise ArtifactResolutionError( + "HVG flavor is incompatible", + code="corrupt_payload", + context=context, + ) + names |= _hvg_optional_parameters(parameters, context) + batch = "batch" in inputs + if batch and isinstance(parameters.get("batch_column"), str): + names |= {"batch_column"} + if flavor == "cytearc" and not batch: + return ( + frozenset({"feature_snapshot", "feature_summary"}), + names, + ("values", "corrected_variance"), + ) + input_names = {"cell_selection", "dataset_fingerprint", "feature_snapshot"} + payload: tuple[str, ...] = ( + "values", + "corrected_variance", + "mean_nonzero", + "detected", + ) + if batch: + input_names.add("batch") + payload += ("batch_count", "median_batch_rank") + return frozenset(input_names), names, payload + + +def _validate_hvg_count_inputs( + root: zarr.Group, + assay: str, + status: ArtifactStatus, + context: dict[str, str | None], +) -> None: + """Check the recorded cells, dataset, and batches of a count-based HVG selection.""" + from .identity import read_dataset_fingerprint + + inputs = status.inputs or {} + if inputs.get("dataset_fingerprint") != read_dataset_fingerprint( + as_zarr_group(root[assay], name=assay) + ): + raise ArtifactResolutionError( + "Feature selection does not match the current prepared dataset", + code="corrupt_payload", + context=context, + ) + validate_cell_selection(root, status.input_ref("cell_selection")) + if "batch" not in inputs: + return + batch = status.input_ref("batch") + if batch.kind == "metadata_snapshot": + column = (status.parameters or {}).get("batch_column") + if not isinstance(column, str): + raise ArtifactResolutionError( + "HVG batch snapshot records no batch column", + code="corrupt_payload", + context=context, + ) + validate_run_metadata_snapshot( + root, + batch, + axis="cell", + assay=None, + table_path="cellData", + ordered_columns=(column,), + ) + elif not inspect_artifact(root, batch).complete: + raise ArtifactResolutionError( + "HVG batch labels are missing or incomplete", + code="corrupt_payload", + context=context, + ) + + def _validate_feature_selection_provenance( root: zarr.Group, assay: str, @@ -495,8 +592,8 @@ def _validate_feature_selection_provenance( context=context, ) if status.operation == "select_hvgs": - parameter_names = parameter_names | _hvg_optional_parameters( - parameters, context + input_names, parameter_names, payload_names = _hvg_contract( + parameters, inputs, context ) received_inputs = set(inputs) if received_inputs != input_names or set(parameters) != parameter_names: @@ -532,6 +629,8 @@ def _validate_feature_selection_provenance( status.input_ref("feature_summary"), row_fingerprint=row_fingerprint, ) + if "dataset_fingerprint" in inputs: + _validate_hvg_count_inputs(root, assay, status, context) if "feature_snapshot" in inputs: snapshot = status.input_ref("feature_snapshot") if ( diff --git a/cytearc/storage/operation_revisions.py b/cytearc/storage/operation_revisions.py index 6e3bbe7..ba7019e 100644 --- a/cytearc/storage/operation_revisions.py +++ b/cytearc/storage/operation_revisions.py @@ -21,6 +21,7 @@ a revision and how to add one. """ +import math from collections.abc import Callable, Mapping from dataclasses import dataclass from types import MappingProxyType @@ -137,6 +138,44 @@ def _records_normalizer_outside_cytearc( applies=_records_normalizer_outside_cytearc, ) + +def _finite_number(value: object) -> bool: + """Return whether a recorded value is a finite number, not a special float.""" + return ( + isinstance(value, int | float) + and not isinstance(value, bool) + and math.isfinite(value) + ) + + +# The default HVG blacklist before 1.3.0. Its ``^CCN`` also removed CCN1 to +# CCN6, and its ``^HIST`` missed the current histone symbols. +_HVG_BLACKLIST_BEFORE_1_3 = ( + "^MT-|^RPS|^RPL|^MRPS|^MRPL|^CCN|^HLA-|^H2-|^HIST|" + "^XIST$|^DDX3Y$|^USP9Y$|^EIF1AY$|^KDM5D$|^SRY$|^ZFY$|^UTY$|^TMSB4Y$|^NLGN4Y$" +) + + +def _hvg_selection_1_3( + kind: str, parameters: Mapping[str, Any], inputs: Mapping[str, Any] +) -> bool: + """Select HVG selections that the candidate filters and defaults of 1.3.0 change. + + A finite ``min_var`` or ``max_var`` now filters candidates before + ``top_n``. Every selection with the earlier default detection bounds + records ``min_cells`` 20; those bounds did not scale with the selected + cells, and the ``max_cells`` they recorded cannot be told from a value + passed explicitly. Selections with the earlier default blacklist excluded + CCN1 to CCN6 and kept the current histone symbols. + """ + variance_bound = _finite_number(parameters.get("min_var")) or _finite_number( + parameters.get("max_var") + ) + earlier_bounds = parameters.get("min_cells") == 20 + earlier_blacklist = parameters.get("blacklist") == _HVG_BLACKLIST_BEFORE_1_3 + return variance_bound or earlier_bounds or earlier_blacklist + + # Released revisions by operation. An operation that is not listed has no # revisions, so every artifact of it is revision 1. Append a revision to the # tuple of the operation it changes, adding the operation if needed; never @@ -189,6 +228,19 @@ def _records_normalizer_outside_cytearc( "run_statistical_testing": (_NORMALIZER_CODE,), "summarize_atac_features": (_NORMALIZER_CODE,), "summarize_rna_features": (_NORMALIZER_CODE,), + "select_hvgs": ( + OperationRevision( + revision=2, + release="1.3.0", + change=( + "min_var and max_var filter HVG candidates before top_n, and the " + "default min_cells, max_cells, and blacklist changed; affects " + "selections with a finite min_var or max_var, min_cells 20, or " + "the earlier default blacklist" + ), + applies=_hvg_selection_1_3, + ), + ), } diff --git a/docs/source/developers/architecture.md b/docs/source/developers/architecture.md index c5dc592..0f6f363 100644 --- a/docs/source/developers/architecture.md +++ b/docs/source/developers/architecture.md @@ -73,6 +73,9 @@ Facade aliases do not change implementation ownership. Shared value-selection contracts also live here so domain, orchestration, and presentation code can use one typed contract without reversing dependencies. These include the nullable value contract of metadata columns (`metadata/encoding.py`), the assay-membership contract (`metadata/membership.py`), and `CELL_VALUE_NAMES`, the table of cell-aligned artifact kinds, with the reader that aligns their rows to cells (`metadata/selection.py`). - `assay/` owns normalization, blockwise feature-summary computation, and the RNA, ATAC, and ADT assay types. + `assay/hvg_statistics.py` streams the per-batch count statistics of the HVG flavors from + `countsT`, and `RNAassay._batch_hvg_scores` turns them into each batch's scores with the trend + and residual formulas of `features.variability`. `DataStore` owns planning and persistence of feature-summary artifacts; a bare `Assay.score_features` remains computation-only. `assay/normalization.py` owns the normalizer flag policy: each assay class declares the flags that its `normed` applies, and callers resolve flags through `applicable_normalization_flags` and `default_normalization_flags` instead of per-assay branches. - `graph/` owns graph feature projection through named artifact inputs and rejects encoded-path inputs. @@ -98,7 +101,8 @@ They must not import those packages at module load time. `run_leiden_clustering` scoped to `backend == "cytearc"` (placement rule 10). - `trajectory/` owns pseudotime scoring, feature-profile aggregation, feature module clustering, and pseudotime result records. - `metrics/` owns LISI, silhouette, graph, concordance, and integration scores, including the neighbor label agreement that membership strength stores. -- `features/` owns variability selection, LOWESS trend fitting, feature scoring, enrichment, rank and regression marker searches, group-wise statistical tests, bulk aggregation, GFF parsing, genomic intervals, coordinate-based feature construction, and the name-based gene-family registry. +- `features/` owns variability selection (the cytearc, seurat_v3, and pearson_residuals flavors, + their LOWESS and LOESS trend fits, and batch-aware ranking), feature scoring, enrichment, rank and regression marker searches, group-wise statistical tests, bulk aggregation, GFF parsing, genomic intervals, coordinate-based feature construction, and the name-based gene-family registry. `features/genomic/` also owns genome sequence access (`sequence.py`: an indexed FASTA reader and GC content), gene annotations and region-to-gene windows (`annotation.py`), and motif matrices with MOODS-equivalent thresholds and a two-strand scanner (`motifs.py`). @@ -1118,6 +1122,21 @@ CyteArc validates persisted data and public arguments against the following cont integer of at least 0, `top_n` and `n_bins` integers of at least 1, `lowess_frac` from 0 to 1, `keep_bounds` a boolean, and `bin_strategy` `"adaptive"` or `"fixed"`. Floats such as `min_cells=20.0` now raise. +- `features.hvgs` takes `flavor` (`"cytearc"`, the earlier method and default; `"seurat_v3"`; + `"pearson_residuals"`) and `batch`, a cell column that it snapshots or a label artifact, and + combines batches by the number of batches in which a gene is highly variable, then its median + rank. Selections of the cytearc flavor over all selected cells keep their provenance; the other + flavors and batch-aware selections record `cell_selection`, `dataset_fingerprint`, + `feature_snapshot`, and `batch` inputs, record `flavor` and its options only for the new flavors, + and store `mean_nonzero`, `detected`, and with batches `batch_count` and `median_batch_rank`. + `min_mean`, `max_mean`, `min_var`, and `max_var` filter candidates before `top_n`; before, a + finite `min_var` ignored `top_n` and `max_var` applied after the cut. `min_cells` defaults to + None: 1% of the selected cells rounded up, from 3 to 20, and `max_cells` None excludes genes + detected in more than 99.5% of them, recorded as the resolved integers; before they were 20 and + `n_selected - 20`. The gene-family blacklist spares CCN1 to CCN6 (`^CCN[A-Z]`) and matches the + current histone symbols. `select_hvgs` revision 2 covers selections with a finite variance bound, + with `min_cells` 20 (every selection with the earlier default bounds), or with the earlier default + blacklist. `norm_pearson_residuals` is an RNA normalizer that takes only `renormalize_subset`. - `compare.compute_bulk(aggr_type="mean")` on RNA divides each cell by its library-size divisor, as `normed` does, which is 1 for a cell without counts. Before, such a cell made its group NaN, which was returned as zeros. `compare.compute_bulk` no longer replaces NaN with 0 and raises `ValueError` for a diff --git a/docs/source/reference/api/artifacts.md b/docs/source/reference/api/artifacts.md index 7d1e922..4f81cf3 100644 --- a/docs/source/reference/api/artifacts.md +++ b/docs/source/reference/api/artifacts.md @@ -87,7 +87,7 @@ ATAC summaries persist `prevalence` and `document_frequency`. | manual selection | `all_features` | supplied values fingerprint | | RNA or ATAC summary | `cell_selection` | normalizer settings | | detected features | `feature_summary` | `min_cells` | -| highly variable genes | `feature_summary` | resolved variability settings | +| highly variable genes | `feature_summary` and `feature_snapshot`; for the seurat_v3 and pearson_residuals flavors and with batches, `cell_selection`, `dataset_fingerprint`, `feature_snapshot`, and the `batch` labels | resolved variability settings, including the resolved `min_cells` and `max_cells` | | prevalent peaks | `feature_summary` | `top_n` | | mapping overlap | mapping reference and query `all_features` | exact inputs | diff --git a/docs/source/reference/api/assays.md b/docs/source/reference/api/assays.md index 3de3d8f..f6b16d5 100644 --- a/docs/source/reference/api/assays.md +++ b/docs/source/reference/api/assays.md @@ -55,9 +55,10 @@ a flag it cannot apply defaults to False, and passing True raises `ValueError`: |---|---|---| | RNA `norm_lib_size` (default) and custom normalizers | yes | yes, through `assay.scalar` | | RNA `norm_lib_size_log` | no, its values are already logarithms | yes | +| RNA `norm_pearson_residuals` and other `PearsonResidualNormalizer` instances | no, residuals are signed | yes, as each cell's total in the expected counts | | `norm_dummy` (the generic default) of RNA, ADT, and generic assays, and custom ADT and generic normalizers | yes | no | | ATAC `norm_tf_idf` (default) and custom normalizers | no, ATAC values are never logged | yes, as the term-frequency denominator | -| `norm_clr` (the ADT default) on any assay, built-in normalizers of another assay class (`norm_tf_idf` outside ATAC, library-size normalizers outside RNA), and `norm_dummy` of ATAC | no | no | +| `norm_clr` (the ADT default) on any assay, built-in normalizers of another assay class (`norm_tf_idf` outside ATAC, library-size and Pearson residual normalizers outside RNA), and `norm_dummy` of ATAC | no | no | A custom RNA normalizer is a callable `(assay, counts)` that may read each cell's total from `assay.scalar` while it builds its result; `normed(log_transform=True)` returns the `log1p` of what @@ -85,6 +86,31 @@ code. Operation revision 2 of each operation that records a normalizer (`run_nor applies to the results that record a normalizer defined outside CyteArc: their earlier results are reported stale, and planning logs one line when it computes one of them again. +`cytearc.assay.norm_pearson_residuals` normalizes RNA counts to the analytic Pearson residuals of +Lause, Berens and Kobak (2021), the values of scanpy's `normalize_pearson_residuals`, with +`theta=100` and a clip of the square root of the number of normalized cells; +`PearsonResidualNormalizer(theta=..., clip=...)` makes one with other values, and its options are +part of the normalization's identity. The expected count of a gene in a cell is the cell's total +times the gene's share of the counts of the normalized cells, and a residual whose expected count +is 0 is 0. By default the totals are over every gene, as the residuals of the full matrix; with +`renormalize_subset=True` they are over the selected genes, as scanpy's `recipe_pearson_residuals` +computes them after subsetting to highly variable genes. Set it as the assay's `normMethod`, save +the residuals of the highly variable genes with `features.normalize`, and run +`reduction.pca(normalized, feat_scaling=False)`: residuals are already standardized. + +```python +from cytearc.assay import norm_pearson_residuals + +ds.RNA.normMethod = norm_pearson_residuals +hvgs = ds.features.hvgs(cells, flavor="pearson_residuals", top_n=2000) +residuals = ds.features.normalize(cells, hvgs) +pca = ds.reduction.pca(residuals, dims=50, feat_scaling=False) +``` + +Every normalized path of the assay applies the residuals while it is the `normMethod`, including +marker search and scores, which then rank or average residuals; set the library-size normalizer +back, `ds.RNA.normMethod = cytearc.assay.norm_lib_size`, for those steps. + RNA library-size normalization divides each cell by its total, the `_nCounts` value or, with `renormalize_subset=True`, its sum over the selected features, and a cell whose total is zero normalizes to zeros. `cytearc.assay.normalization.library_size_divisors` holds this rule for every @@ -118,6 +144,10 @@ not check them and replaces a zero total with 1. .. autofunction:: cytearc.assay.norm_dummy ``` +```{eval-rst} +.. autoclass:: cytearc.assay.PearsonResidualNormalizer +``` + ```{eval-rst} .. autoclass:: cytearc.metadata.MetaData :members: diff --git a/docs/source/reference/api/pipeline.md b/docs/source/reference/api/pipeline.md index fdd6d96..352028b 100644 --- a/docs/source/reference/api/pipeline.md +++ b/docs/source/reference/api/pipeline.md @@ -120,9 +120,10 @@ artifacts each stage consumes. A setting has exactly the meaning of the same key in the table below, and omitting it uses that method's default. Settings are JSON values, so a run configuration can be saved and passed again; infinity and NaN are -never settings. Some settings spell a derived default as `None`: `hvg` `max_cells`, which excludes -genes detected in at least the number of selected cells minus 20; `batch_size` of every stage that -takes it; `cell_cycle` `ctrl_size` and `log_transform`; `paris` `min_cluster_size`; and +never settings. Some settings spell a derived default as `None`: `hvg` `min_cells`, 1% of the +selected cells rounded up, from 3 to 20, for the default flavor; `hvg` `max_cells`, which for the +default flavor excludes genes detected in more than 99.5% of the selected cells; `batch_size` of +every stage that takes it; `cell_cycle` `ctrl_size` and `log_transform`; `paris` `min_cluster_size`; and `normalization` `log_transform` and `renormalize_subset`, whose defaults follow the assay's normalizer ({doc}`assays`). The run records `params` as given, and each artifact records the values its method resolved. @@ -131,7 +132,7 @@ its method resolved. run = ds.pipeline.run( params={ "filtering": {"method": "manual", "attrs": ["RNA_nCounts"], "lows": [500], "highs": [20000]}, - "hvg": {"min_mean": 0.01, "max_mean": 5.0, "keep_bounds": True}, + "hvg": {"flavor": "seurat_v3", "top_n": 2000}, "pca": {"dims": 30}, "neighbors": {"k": 15}, "umap": {"n_epochs": 400, "min_dist": 1.0, "spread": 2.0, "parallel": True}, @@ -147,7 +148,7 @@ run = ds.pipeline.run( | --- | --- | --- | | `filtering` | the `filtering` option | the filtering mapping above, or a bool | | `cell_cycle` | cell-cycle scoring | `s_genes`, `g2m_genes`, `ctrl_size`, `log_transform`, `n_bins`, `rand_seed` | -| `hvg` | {py:meth}`~cytearc.datastore.namespaces.FeaturesAccessor.hvgs` | `top_n`, `min_cells`, `max_cells`, `min_mean`, `max_mean`, `min_var`, `max_var`, `n_bins`, `lowess_frac`, `blacklist`, `keep_bounds`, `bin_strategy` | +| `hvg` | {py:meth}`~cytearc.datastore.namespaces.FeaturesAccessor.hvgs` | `top_n`, `flavor`, `batch` (a cell metadata column), `min_cells`, `max_cells`, `min_mean`, `max_mean`, `min_var`, `max_var` (the last four are log2 values), `n_bins`, `lowess_frac`, `blacklist`, `keep_bounds`, `bin_strategy`, `span`, `theta`, `clip` | | `normalization` | {py:meth}`~cytearc.datastore.namespaces.FeaturesAccessor.normalize` | `log_transform`, `renormalize_subset` | | `pca` | {py:meth}`~cytearc.datastore.namespaces.ReductionAccessor.pca` | `dims`, `feat_scaling`, `batch_size` | | `harmony` | {py:meth}`~cytearc.datastore.namespaces.ReductionAccessor.harmony` | `batch_columns` (required), `harmony_params` (the keyword options of {py:func}`~cytearc.embeddings.fit_harmony`), `batch_size` | @@ -219,10 +220,13 @@ or pass `doublets=False`. Unknown sections or settings, settings without a JSON value such as infinity, and `True` for a stage that always runs are rejected before a run record is created; `hvg` settings also get the checks of -`features.hvgs` then. `min_cells` must be an integer of at least 0, `top_n` and `n_bins` integers of -at least 1, `lowess_frac` a finite number from 0 to 1 for either `bin_strategy`, `keep_bounds` a -boolean, and `bin_strategy` `"adaptive"` or `"fixed"`; an omitted setting is checked as its -`features.hvgs` default. +`features.hvgs` then. `min_cells` must be None or an integer of at least 0, `top_n` and `n_bins` +integers of at least 1, `lowess_frac` a finite number from 0 to 1 for either `bin_strategy`, +`keep_bounds` a boolean, `bin_strategy` `"adaptive"` or `"fixed"`, `flavor` `"cytearc"`, +`"seurat_v3"`, or `"pearson_residuals"`, `span` greater than 0 and at most 1, `theta` positive, and +`clip` None or at least 0; the options of one flavor keep their defaults under another, and +`batch` must name a cell metadata column. An omitted setting is checked as its `features.hvgs` +default. `tsne` settings get the checks of `embeddings.tsne` then too, because the stage runs after most others: `tsne_dims`, `max_iter`, and `alpha` must be integers of at least 1, `early_iter` an integer of at least 0, `lambda_scale` and `box_h` finite positive numbers, and `symmetric_graph` and diff --git a/docs/source/reference/methods.md b/docs/source/reference/methods.md index 6412292..fc8850e 100644 --- a/docs/source/reference/methods.md +++ b/docs/source/reference/methods.md @@ -27,6 +27,11 @@ It uses established libraries where they fit the streaming and provenance model. The aim is one coherent execution path, not reimplementation for its own sake. - **Reduction and graph construction:** streamed normalization, exact covariance (Gram-matrix) PCA with a randomized block Krylov solver for more than 4,096 features ({ref}`details `), randomized streaming {term}`LSI`, approximate nearest-neighbour search, UMAP, {term}`densMAP`, and graph-based t-SNE through the optional `tsne` extra (see {ref}`Optional t-SNE `). +- **Feature selection:** highly variable genes by CyteArc's mean-variance trend of normalized + values, by the variance-stabilizing transformation of [Seurat v3](https://doi.org/10.1016/j.cell.2019.05.031) + on raw counts, or by the variance of [analytic Pearson residuals](https://doi.org/10.1186/s13059-021-02451-7), + with batch-aware selection in the order of Seurat's `SelectIntegrationFeatures`, and Pearson + residual normalization. - **Batch correction and mapping:** CyteArc implementations of [Harmony2](https://doi.org/10.64898/2026.03.16.711825), which builds on the original [Harmony](https://doi.org/10.1038/s41592-019-0619-0) algorithm, and of [Symphony-style](https://doi.org/10.1038/s41467-021-25957-x) fixed-reference mapping, with label transfer and mapping diagnostics. - **Matched multi-omics:** {term}`SNN integration` and [Hao-inspired WNN](https://doi.org/10.1016/j.cell.2021.04.048) integration for two or more assays, with WNN reporting one per-cell weight per modality. - **Clustering:** a native, multi-threaded implementation of [Leiden](https://doi.org/10.1038/s41598-019-41695-z) community detection ({ref}`details `) and a native implementation of [Paris hierarchical clustering](https://doi.org/10.48550/arXiv.1806.01664) with fixed and branch-adaptive cuts. @@ -130,6 +135,18 @@ Agreement measured for one method is not evidence of equivalence for the rest of rises while cell-type purity stays at its uncorrected level. CyteArc's Harmony2 was written from the two papers, independently of other Harmony implementations, and is not expected to match them number for number. +- Highly variable gene flavors are compared with scanpy 1.12.4 and scikit-misc 0.5.3 on the + 892 cells and 36,601 genes of the 1k PBMC CITE-seq test fixture, selecting 2,000 genes. + The seurat_v3 trend matches scikit-misc's interpolated LOESS to within 1e-12 on the log10 scale, + so the scores agree to the 10 digits the fixture keeps; the selections differ only in 4 genes tied + at the last selected score (Jaccard 0.998). Pearson residual variances agree to the same digits and select + the same genes, with and without two batches. With two batches, seurat_v3 scores differ from + scanpy's `seurat_v3_paper` by up to 7e-4 and 8 selected genes differ (Jaccard 0.996), because + scanpy's Welford batch means break ties between genes with equal means, which moves the + interpolated trend. scanpy clips every batch's residuals at the square root of the first + batch's cell count; CyteArc clips each batch at its own, so the batch comparison passes an + explicit clip. The LOESS, the standardized variance, and the residuals are also checked against + direct NumPy computations of their published formulas. - Marker statistics are checked against SciPy, including continuity and large-tie corrections. - Paris hierarchies are compared with the scikit-network reference implementation on tie-free graphs. - The native Leiden backend is checked against brute-force calculations on small random graphs, diff --git a/docs/source/scanpy.md b/docs/source/scanpy.md index 161f650..1ea76bc 100644 --- a/docs/source/scanpy.md +++ b/docs/source/scanpy.md @@ -27,6 +27,8 @@ of normalization, log transformation, and then HVG selection. | Calculate QC metrics | `sc.pp.calculate_qc_metrics` | Opening a new `DataStore` calculates count and feature metrics, plus detected RNA mitochondrial and ribosomal percentages | | Filter cells | `sc.pp.filter_cells` or an `obs` mask | `ds.qc.filter` or `ds.qc.auto_filter` returns a cell-selection artifact without deleting cells or changing `I`. Bounds are exclusive: `lows=[200]` removes a cell with exactly 200 genes, which `min_genes=200` keeps, so pass `keep_bounds=True` to match. For imported `total_counts` or `pct_counts_mt` columns, pass `metric_policies` to `qc.auto_filter` | | Select and normalize features | `sc.pp.normalize_total`, `sc.pp.log1p`, `sc.pp.highly_variable_genes` | `ds.features.hvgs`, then `ds.features.normalize`, using the same cell-selection ref | +| Select genes by raw-count variance or Pearson residuals | `sc.pp.highly_variable_genes(flavor="seurat_v3")`, `sc.experimental.pp.highly_variable_genes(flavor="pearson_residuals")`, with `batch_key` | `ds.features.hvgs(cells, flavor="seurat_v3")` or `flavor="pearson_residuals"`, with `batch=` a cell column or label artifact; batches combine in Seurat's order, that of scanpy's `flavor="seurat_v3_paper"`. Pass `blacklist=""` to keep every gene name, as scanpy does | +| Normalize to Pearson residuals | `sc.experimental.pp.normalize_pearson_residuals` | `ds.RNA.normMethod = cytearc.assay.norm_pearson_residuals`, then `ds.features.normalize` and `ds.reduction.pca(..., feat_scaling=False)` | | Run PCA and find neighbours | `sc.pp.pca`, then `sc.pp.neighbors` | `ds.reduction.pca`, then CyteArc's neighbour-graph methods | | Embed the graph | `sc.tl.umap` | `ds.embeddings.umap` | | Cluster cells | `sc.tl.leiden` | `ds.clusters.leiden`; Paris hierarchy diagnostics are covered in the advanced clustering guide | diff --git a/docs/source/tutorials/feature_selection.ipynb b/docs/source/tutorials/feature_selection.ipynb index 3da6b41..90097a8 100644 --- a/docs/source/tutorials/feature_selection.ipynb +++ b/docs/source/tutorials/feature_selection.ipynb @@ -23,7 +23,8 @@ "\n", "The PBMC store carries an analysis saved as `docs_default`. It used 500 genes and 15 PCs to keep\n", "this teaching example small. The current API defaults are 1,000 genes and 21 PCs.\n", - "We first repeat the saved 500-gene selection to inspect how those genes were chosen." + "We first select 500 genes from the same cells with the current defaults, to inspect how such a\n", + "selection is made." ] }, { @@ -32,20 +33,20 @@ "id": "0bac849c", "metadata": { "execution": { - "iopub.execute_input": "2026-10-21T12:14:01.760469Z", - "iopub.status.busy": "2026-10-21T12:14:01.760139Z", - "iopub.status.idle": "2026-10-21T12:14:08.924797Z", - "shell.execute_reply": "2026-10-21T12:14:08.916245Z" + "iopub.execute_input": "2026-10-22T16:51:51.268712Z", + "iopub.status.busy": "2026-10-22T16:51:51.268486Z", + "iopub.status.idle": "2026-10-22T16:51:54.906874Z", + "shell.execute_reply": "2026-10-22T16:51:54.905551Z" } }, "outputs": [ { "data": { "text/html": [ - "Started: 2026-10-21T12:14:01.760139Z | Wall time: 7.165 s" + "Started: 2026-10-22T16:51:51.268486Z | Wall time: 3.638 s" ], "text/plain": [ - "Started: 2026-10-21T12:14:01.760139Z | Wall time: 7.165 s" + "Started: 2026-10-22T16:51:51.268486Z | Wall time: 3.638 s" ] }, "metadata": { @@ -85,10 +86,10 @@ "id": "cbbd697f", "metadata": { "execution": { - "iopub.execute_input": "2026-10-21T12:14:08.937801Z", - "iopub.status.busy": "2026-10-21T12:14:08.934081Z", - "iopub.status.idle": "2026-10-21T12:14:11.947363Z", - "shell.execute_reply": "2026-10-21T12:14:11.945997Z" + "iopub.execute_input": "2026-10-22T16:51:54.909670Z", + "iopub.status.busy": "2026-10-22T16:51:54.909290Z", + "iopub.status.idle": "2026-10-22T16:51:57.010951Z", + "shell.execute_reply": "2026-10-22T16:51:57.009914Z" } }, "outputs": [ @@ -113,10 +114,10 @@ { "data": { "text/html": [ - "Started: 2026-10-21T12:14:08.934081Z | Wall time: 3.013 s" + "Started: 2026-10-22T16:51:54.909290Z | Wall time: 2.102 s" ], "text/plain": [ - "Started: 2026-10-21T12:14:08.934081Z | Wall time: 3.013 s" + "Started: 2026-10-22T16:51:54.909290Z | Wall time: 2.102 s" ] }, "metadata": { @@ -144,7 +145,9 @@ "id": "a8737cc5", "metadata": {}, "source": [ - "Fit and inspect the 500-gene selection used by the saved example." + "Fit and inspect a 500-gene selection on the saved analysis's cells. An earlier CyteArc release\n", + "made the saved selection with different default settings, so this call computes a new selection\n", + "instead of reusing the saved one. The check below also compares the selected genes themselves." ] }, { @@ -153,10 +156,10 @@ "id": "c8f6746d", "metadata": { "execution": { - "iopub.execute_input": "2026-10-21T12:14:11.950851Z", - "iopub.status.busy": "2026-10-21T12:14:11.950348Z", - "iopub.status.idle": "2026-10-21T12:14:12.955213Z", - "shell.execute_reply": "2026-10-21T12:14:12.952826Z" + "iopub.execute_input": "2026-10-22T16:51:57.014182Z", + "iopub.status.busy": "2026-10-22T16:51:57.013818Z", + "iopub.status.idle": "2026-10-22T16:51:58.498483Z", + "shell.execute_reply": "2026-10-22T16:51:58.497173Z" }, "figure_descriptions": [ "Mean-variance plot for selecting 500 highly variable genes. Outlined selected genes lie above much of the unselected cloud across a range of mean nonzero expression." @@ -176,7 +179,9 @@ { "data": { "text/plain": [ - "{'matches docs_default': True, 'selected genes': 500}" + "{'reused the saved selection': False,\n", + " 'same genes as the saved selection': True,\n", + " 'selected genes': 500}" ] }, "execution_count": 3, @@ -186,10 +191,10 @@ { "data": { "text/html": [ - "Started: 2026-10-21T12:14:11.950348Z | Wall time: 1.005 s" + "Started: 2026-10-22T16:51:57.013818Z | Wall time: 1.485 s" ], "text/plain": [ - "Started: 2026-10-21T12:14:11.950348Z | Wall time: 1.005 s" + "Started: 2026-10-22T16:51:57.013818Z | Wall time: 1.485 s" ] }, "metadata": { @@ -199,15 +204,23 @@ } ], "source": [ - "# Select the same 500 genes used by the prepared baseline.\n", + "# Select 500 genes on the saved analysis's cells with the current defaults.\n", "hvg_500 = ds.features.hvgs(cell_selection, top_n=500)\n", "\n", "# Load the selected-gene mask on the full feature axis.\n", "hvg_500_values = np.asarray(ds.artifacts.load(hvg_500)[\"values\"][:])\n", "\n", - "# Check agreement with the saved selection and its gene count.\n", + "# Load the saved analysis's selected-gene mask for comparison.\n", + "saved_values = np.asarray(\n", + " ds.artifacts.load(baseline[\"highly_variable_features\"])[\"values\"][:]\n", + ")\n", + "\n", + "# Compare the two selection results, their genes, and the gene count.\n", "{\n", - " \"matches docs_default\": hvg_500 == baseline[\"highly_variable_features\"],\n", + " \"reused the saved selection\": hvg_500 == baseline[\"highly_variable_features\"],\n", + " \"same genes as the saved selection\": bool(\n", + " np.array_equal(hvg_500_values, saved_values)\n", + " ),\n", " \"selected genes\": int(hvg_500_values.sum()),\n", "}" ] @@ -217,6 +230,9 @@ "id": "1d7f2230", "metadata": {}, "source": [ + "The new selection is a separate result, but it holds the same 500 genes as the saved one: for\n", + "these cells, the newer defaults leave the selection unchanged.\n", + "\n", "The plot should retain genes above the fitted mean-variance trend across a useful expression range.\n", "A selection concentrated only among the most abundant genes can make library size or housekeeping programs dominate the graph.\n", "\n", @@ -225,7 +241,8 @@ "CyteArc applies the following case-insensitive regular expression to gene names:\n", "\n", "```text\n", - "^MT-|^RPS|^RPL|^MRPS|^MRPL|^CCN|^HLA-|^H2-|^HIST|\n", + "^MT-|^RPS|^RPL|^MRPS|^MRPL|^CCN[A-Z]|^HLA-|^H2-|\n", + "^HIST|^H1-[1-6]$|^H1F[1-6]$|^H2AC\\d+$|^H2BC\\d+$|^H3C\\d+$|^H4C\\d+$|^H2AW$|^H3-4$|^H4-16$|\n", "^XIST$|^DDX3Y$|^USP9Y$|^EIF1AY$|^KDM5D$|^SRY$|^ZFY$|^UTY$|^TMSB4Y$|^NLGN4Y$\n", "```\n", "\n", @@ -240,10 +257,10 @@ "id": "af765b41", "metadata": { "execution": { - "iopub.execute_input": "2026-10-21T12:14:12.959216Z", - "iopub.status.busy": "2026-10-21T12:14:12.958700Z", - "iopub.status.idle": "2026-10-21T12:14:13.227212Z", - "shell.execute_reply": "2026-10-21T12:14:13.225657Z" + "iopub.execute_input": "2026-10-22T16:51:58.502018Z", + "iopub.status.busy": "2026-10-22T16:51:58.501632Z", + "iopub.status.idle": "2026-10-22T16:51:58.689138Z", + "shell.execute_reply": "2026-10-22T16:51:58.688032Z" } }, "outputs": [ @@ -274,10 +291,10 @@ { "data": { "text/html": [ - "Started: 2026-10-21T12:14:12.958700Z | Wall time: 0.269 s" + "Started: 2026-10-22T16:51:58.501632Z | Wall time: 0.188 s" ], "text/plain": [ - "Started: 2026-10-21T12:14:12.958700Z | Wall time: 0.269 s" + "Started: 2026-10-22T16:51:58.501632Z | Wall time: 0.188 s" ] }, "metadata": { @@ -318,14 +335,18 @@ "your question. Treat the default as a starting point and decide which programs the graph should\n", "capture before excluding them.\n", "\n", - "These are name patterns, not a complete classification of gene function. For example, `^CCN`\n", - "matches both `CCN1` and `CCND1`, while `^HIST` matches `HIST1H2AC` but not `H2AC1`. Check the\n", - "actual names removed in your gene annotation before relying on a family label. Supplying\n", - "`blacklist=` replaces the whole default pattern.\n", + "These are name patterns, not a complete classification of gene function. For example,\n", + "`^CCN[A-Z]` matches the cyclin `CCND1` but not `CCN1`, and the histone family matches the\n", + "replication-dependent histones under their old names, such as `HIST1H2AC`, and their current\n", + "ones, such as `H2AC1`, but not replacement histones such as `H3-3A`. Check the actual names\n", + "removed in your gene annotation before relying on a family label. Supplying `blacklist=` replaces\n", + "the whole default pattern.\n", "\n", - "By default, `max_cells` is `n_selected - 20`. With the default strict upper bound, genes detected\n", - "in at least that many selected cells are excluded as nearly ubiquitous. The cutoff is skipped\n", - "when too few selected cells remain to satisfy the minimum detection requirement.\n", + "Two detection bounds also apply by default, and both scale with the number of selected cells.\n", + "`min_cells` keeps genes detected in at least 1% of the selected cells, rounded up and between 3\n", + "and 20 cells, so a small subset still keeps genes of its rarer cells. `max_cells` excludes genes\n", + "detected in more than 99.5% of the selected cells as nearly ubiquitous. The saved selection\n", + "records both as cell counts.\n", "\n", "Clearing the blacklist keeps every gene name while retaining other HVG filters.\n", "Compare the same `top_n` with and without the default pattern:" @@ -337,10 +358,10 @@ "id": "0cadf7e7", "metadata": { "execution": { - "iopub.execute_input": "2026-10-21T12:14:13.230284Z", - "iopub.status.busy": "2026-10-21T12:14:13.229978Z", - "iopub.status.idle": "2026-10-21T12:14:14.428671Z", - "shell.execute_reply": "2026-10-21T12:14:14.427341Z" + "iopub.execute_input": "2026-10-22T16:51:58.691253Z", + "iopub.status.busy": "2026-10-22T16:51:58.691058Z", + "iopub.status.idle": "2026-10-22T16:51:59.546314Z", + "shell.execute_reply": "2026-10-22T16:51:59.545213Z" } }, "outputs": [ @@ -359,10 +380,10 @@ { "data": { "text/html": [ - "Started: 2026-10-21T12:14:13.229978Z | Wall time: 1.199 s" + "Started: 2026-10-22T16:51:58.691058Z | Wall time: 0.855 s" ], "text/plain": [ - "Started: 2026-10-21T12:14:13.229978Z | Wall time: 1.199 s" + "Started: 2026-10-22T16:51:58.691058Z | Wall time: 0.855 s" ] }, "metadata": { @@ -399,10 +420,10 @@ "id": "de896572", "metadata": { "execution": { - "iopub.execute_input": "2026-10-21T12:14:14.431423Z", - "iopub.status.busy": "2026-10-21T12:14:14.431097Z", - "iopub.status.idle": "2026-10-21T12:14:14.449620Z", - "shell.execute_reply": "2026-10-21T12:14:14.448188Z" + "iopub.execute_input": "2026-10-22T16:51:59.548638Z", + "iopub.status.busy": "2026-10-22T16:51:59.548427Z", + "iopub.status.idle": "2026-10-22T16:51:59.563049Z", + "shell.execute_reply": "2026-10-22T16:51:59.562248Z" } }, "outputs": [ @@ -437,10 +458,10 @@ { "data": { "text/html": [ - "Started: 2026-10-21T12:14:14.431097Z | Wall time: 0.019 s" + "Started: 2026-10-22T16:51:59.548427Z | Wall time: 0.015 s" ], "text/plain": [ - "Started: 2026-10-21T12:14:14.431097Z | Wall time: 0.019 s" + "Started: 2026-10-22T16:51:59.548427Z | Wall time: 0.015 s" ] }, "metadata": { @@ -484,25 +505,388 @@ "```\n", "\n", "Repeating a selection with the same cells and settings reuses the saved result, including the\n", - "diagnostics used for its plot. See [](reuse_and_tracing.ipynb) for details.\n", + "diagnostics used for its plot. A selection saved by an earlier release is reused only while its\n", + "recorded settings and operation revision still match the request, which is why the first\n", + "selection on this page was computed again. See [](reuse_and_tracing.ipynb) for details." + ] + }, + { + "cell_type": "markdown", + "id": "83a7cdd1", + "metadata": {}, + "source": [ + "## Choose a variability score\n", + "\n", + "`features.hvgs` scores variability with one of three flavors. The default, `\"cytearc\"`, divides\n", + "the variance of library-size normalized values by the background of genes with a similar mean, as\n", + "above. `\"seurat_v3\"` fits a trend of raw-count variance against mean with local regression, then\n", + "scores each gene by the variance of its counts standardized with that trend and clipped, as\n", + "Seurat's `vst` and Scanpy's `flavor=\"seurat_v3\"` do. `\"pearson_residuals\"` scores the variance of\n", + "analytic Pearson residuals of a negative binomial model, Scanpy's experimental flavor. The two\n", + "count flavors apply no detection bounds unless you pass them, but they keep the blacklist; pass\n", + "`blacklist=\"\"` to reproduce Scanpy's selection. Compare 500 genes of each flavor:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "840516eb", + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-22T16:51:59.565098Z", + "iopub.status.busy": "2026-10-22T16:51:59.564911Z", + "iopub.status.idle": "2026-10-22T16:52:02.588066Z", + "shell.execute_reply": "2026-10-22T16:52:02.587280Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
cytearcseurat_v3pearson_residuals
cytearc500362414
seurat_v3362500374
pearson_residuals414374500
\n", + "
" + ], + "text/plain": [ + " cytearc seurat_v3 pearson_residuals\n", + "cytearc 500 362 414\n", + "seurat_v3 362 500 374\n", + "pearson_residuals 414 374 500" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/html": [ + "Started: 2026-10-22T16:51:59.564911Z | Wall time: 3.023 s" + ], + "text/plain": [ + "Started: 2026-10-22T16:51:59.564911Z | Wall time: 3.023 s" + ] + }, + "metadata": { + "cytearc_execution_timing": true + }, + "output_type": "display_data" + } + ], + "source": [ + "# Select 500 genes with each flavor on the same cells.\n", + "flavor_refs = {\n", + " flavor: ds.features.hvgs(cell_selection, flavor=flavor, top_n=500, show_plot=False)\n", + " for flavor in (\"cytearc\", \"seurat_v3\", \"pearson_residuals\")\n", + "}\n", + "\n", + "# Load each selection on the full feature axis.\n", + "flavor_values = {\n", + " flavor: np.asarray(ds.artifacts.load(ref)[\"values\"][:])\n", + " for flavor, ref in flavor_refs.items()\n", + "}\n", "\n", + "# Count the genes that each pair of flavors selects together.\n", + "pd.DataFrame(\n", + " {\n", + " first: {\n", + " second: int((flavor_values[first] & flavor_values[second]).sum())\n", + " for second in flavor_values\n", + " }\n", + " for first in flavor_values\n", + " }\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "7c98abae", + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-22T16:52:02.591327Z", + "iopub.status.busy": "2026-10-22T16:52:02.591025Z", + "iopub.status.idle": "2026-10-22T16:52:02.606870Z", + "shell.execute_reply": "2026-10-22T16:52:02.605600Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
cytearcseurat_v3pearson_residuals
CD3DTrueFalseTrue
MS4A1TrueTrueTrue
CD14TrueTrueTrue
LYZTrueTrueTrue
NKG7TrueTrueTrue
GNLYTrueTrueTrue
PPBPTrueTrueTrue
\n", + "
" + ], + "text/plain": [ + " cytearc seurat_v3 pearson_residuals\n", + "CD3D True False True\n", + "MS4A1 True True True\n", + "CD14 True True True\n", + "LYZ True True True\n", + "NKG7 True True True\n", + "GNLY True True True\n", + "PPBP True True True" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/html": [ + "Started: 2026-10-22T16:52:02.591025Z | Wall time: 0.016 s" + ], + "text/plain": [ + "Started: 2026-10-22T16:52:02.591025Z | Wall time: 0.016 s" + ] + }, + "metadata": { + "cytearc_execution_timing": true + }, + "output_type": "display_data" + } + ], + "source": [ + "# Check which flavors keep the lineage markers of this dataset.\n", + "lineage_markers = [\"CD3D\", \"MS4A1\", \"CD14\", \"LYZ\", \"NKG7\", \"GNLY\", \"PPBP\"]\n", + "pd.DataFrame(\n", + " {\n", + " flavor: {\n", + " gene: bool(values[feature_names.astype(str) == gene].any())\n", + " for gene in lineage_markers\n", + " }\n", + " for flavor, values in flavor_values.items()\n", + " }\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "99312416", + "metadata": {}, + "source": [ + "Each pair of flavors shares 362 to 414 of its 500 genes. The default and Pearson residual flavors\n", + "keep all seven lineage markers, but `seurat_v3` leaves out the T-cell marker `CD3D`. The flavors\n", + "differ most on sparse genes: `seurat_v3` ranks genes detected in few cells highly, while the\n", + "default flavor's detection bounds and background favor genes that vary across many cells. Check\n", + "known markers and the genes unique to each selection before preferring one.\n", + "\n", + "Pearson residuals are also a normalization. Set the assay's normalizer to\n", + "`norm_pearson_residuals`, save the residuals of the genes the residual flavor selected, and run\n", + "PCA without rescaling the genes, because residuals are already standardized. Every normalized\n", + "path of the assay, including marker search, applies the configured normalizer, so restore\n", + "library-size normalization afterwards:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "7b6828e9", + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-22T16:52:02.609030Z", + "iopub.status.busy": "2026-10-22T16:52:02.608779Z", + "iopub.status.idle": "2026-10-22T16:52:03.903938Z", + "shell.execute_reply": "2026-10-22T16:52:03.902738Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(3948, 15)" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/html": [ + "Started: 2026-10-22T16:52:02.608779Z | Wall time: 1.295 s" + ], + "text/plain": [ + "Started: 2026-10-22T16:52:02.608779Z | Wall time: 1.295 s" + ] + }, + "metadata": { + "cytearc_execution_timing": true + }, + "output_type": "display_data" + } + ], + "source": [ + "# Normalize the genes of the residual flavor to Pearson residuals.\n", + "ds.RNA.normMethod = cytearc.assay.norm_pearson_residuals\n", + "residuals = ds.features.normalize(cell_selection, flavor_refs[\"pearson_residuals\"])\n", + "\n", + "# Reduce the residuals without rescaling each gene.\n", + "residual_pca = ds.reduction.pca(residuals, dims=15, feat_scaling=False)\n", + "\n", + "# Restore library-size normalization for the rest of the analysis.\n", + "ds.RNA.normMethod = cytearc.assay.norm_lib_size\n", + "\n", + "# Inspect the cell and principal-component counts of the residual PCA.\n", + "ds.artifacts.load(residual_pca)[\"data\"].shape" + ] + }, + { + "cell_type": "markdown", + "id": "05aa2754", + "metadata": {}, + "source": [ + "When samples differ technically, a pooled selection can favor genes that separate the\n", + "samples rather than cell states. `batch` scores every sample on its own, counts the samples in\n", + "which each gene ranks among the `top_n`, and selects the genes variable in the most samples, ties\n", + "broken by their median rank, as Seurat's `SelectIntegrationFeatures` does. Scanpy's\n", + "`flavor=\"seurat_v3\"` sorts by median rank first; its `\"seurat_v3_paper\"` sorts as CyteArc does.\n", + "`batch` takes a cell metadata column, which is snapshotted, or a label artifact such as HTO\n", + "identities. Every selected cell needs a label and every sample at least two selected cells. This\n", + "dataset holds one sample, so the call is shown without running it:\n", + "\n", + "```python\n", + "# Score each sample on its own and keep the genes variable in the most samples.\n", + "by_sample = ds.features.hvgs(cell_selection, flavor=\"seurat_v3\", batch=\"sample\", top_n=2000)\n", + "\n", + "# Count, for each gene, the samples that rank it among their top 2,000.\n", + "batch_count = ds.artifacts.load(by_sample)[\"batch_count\"][:]\n", + "```" + ] + }, + { + "cell_type": "markdown", + "id": "ac9386b8", + "metadata": {}, + "source": [ "## Compare feature-set size\n", "\n", "The number of selected genes changes the PCA basis and can change neighbourhood structure.\n", - "This comparison keeps all other graph choices fixed. The 500-gene branch comes directly from\n", - "`docs_default`; only the 1,000-gene branch is new." + "This comparison keeps all other graph choices fixed: both branches are built here with the saved\n", + "analysis's 15 PCs, 11 neighbours, and Leiden resolution 0.5, so only the number of selected genes\n", + "differs." ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 10, "id": "4fa57e46", "metadata": { "execution": { - "iopub.execute_input": "2026-10-21T12:14:14.452413Z", - "iopub.status.busy": "2026-10-21T12:14:14.452131Z", - "iopub.status.idle": "2026-10-21T12:14:15.655922Z", - "shell.execute_reply": "2026-10-21T12:14:15.654748Z" + "iopub.execute_input": "2026-10-22T16:52:03.906647Z", + "iopub.status.busy": "2026-10-22T16:52:03.906388Z", + "iopub.status.idle": "2026-10-22T16:52:04.826883Z", + "shell.execute_reply": "2026-10-22T16:52:04.825738Z" } }, "outputs": [ @@ -512,17 +896,17 @@ "{'selected genes': 1000}" ] }, - "execution_count": 7, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" }, { "data": { "text/html": [ - "Started: 2026-10-21T12:14:14.452131Z | Wall time: 1.204 s" + "Started: 2026-10-22T16:52:03.906388Z | Wall time: 0.920 s" ], "text/plain": [ - "Started: 2026-10-21T12:14:14.452131Z | Wall time: 1.204 s" + "Started: 2026-10-22T16:52:03.906388Z | Wall time: 0.920 s" ] }, "metadata": { @@ -547,39 +931,85 @@ "id": "9ab0ebe4", "metadata": {}, "source": [ - "Normalize the selected genes and construct the new graph." + "Normalize each selection and construct its graph with the same settings." ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 11, "id": "48124bb3", "metadata": { "execution": { - "iopub.execute_input": "2026-10-21T12:14:15.658163Z", - "iopub.status.busy": "2026-10-21T12:14:15.657906Z", - "iopub.status.idle": "2026-10-21T12:14:42.666278Z", - "shell.execute_reply": "2026-10-21T12:14:42.664481Z" + "iopub.execute_input": "2026-10-22T16:52:04.829206Z", + "iopub.status.busy": "2026-10-22T16:52:04.828979Z", + "iopub.status.idle": "2026-10-22T16:52:25.916761Z", + "shell.execute_reply": "2026-10-22T16:52:25.915583Z" } }, "outputs": [ { "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
cellsPCs
selected genes
500394815
1000394815
\n", + "
" + ], "text/plain": [ - "{'cells': 3948, 'PCs': 15}" + " cells PCs\n", + "selected genes \n", + "500 3948 15\n", + "1000 3948 15" ] }, - "execution_count": 8, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" }, { "data": { "text/html": [ - "Started: 2026-10-21T12:14:15.657906Z | Wall time: 27.008 s" + "Started: 2026-10-22T16:52:04.828979Z | Wall time: 21.088 s" ], "text/plain": [ - "Started: 2026-10-21T12:14:15.657906Z | Wall time: 27.008 s" + "Started: 2026-10-22T16:52:04.828979Z | Wall time: 21.088 s" ] }, "metadata": { @@ -589,29 +1019,36 @@ } ], "source": [ - "# Normalize the new feature selection.\n", - "normalized_1000 = ds.features.normalize(cell_selection, feature_1000)\n", + "# Hold each feature count's PCA, graph, and embedding initialization.\n", + "graph_inputs = {}\n", "\n", - "# Keep 15 PCA dimensions for this feature-count comparison.\n", - "pca_1000 = ds.reduction.pca(normalized_1000, dims=15)\n", + "# Build both branches with the saved analysis's graph settings.\n", + "for top_n, features in {500: hvg_500, 1000: feature_1000}.items():\n", "\n", - "# Prepare the embedding initialization from the new PCA.\n", - "initialization_1000 = ds.embeddings.initialization(pca_1000)\n", + " # Normalize the selected genes on the frozen cells.\n", + " normalized = ds.features.normalize(cell_selection, features)\n", "\n", - "# Build a neighbor-search index for the new PCA.\n", - "ann_1000 = ds.graph.ann_index(pca_1000)\n", + " # Keep 15 PCA dimensions, as the saved analysis did.\n", + " pca = ds.reduction.pca(normalized, dims=15)\n", "\n", - "# Keep the baseline neighbor count of 11.\n", - "neighbors_1000 = ds.graph.neighbors(ann_1000, k=11)\n", + " # Find 11 neighbors per cell in a search index of this PCA.\n", + " neighbors = ds.graph.neighbors(ds.graph.ann_index(pca), k=11)\n", "\n", - "# Build connectivity from the new neighbors.\n", - "graph_1000 = ds.graph.connectivity(neighbors_1000)\n", - "\n", - "# Read the PCA dimensions supplied to this graph without loading its values.\n", - "pca_shape = ds.artifacts.load(pca_1000)[\"data\"].shape\n", + " # Keep the PCA, its connectivity graph, and its layout initialization.\n", + " graph_inputs[top_n] = (\n", + " pca,\n", + " ds.graph.connectivity(neighbors),\n", + " ds.embeddings.initialization(pca),\n", + " )\n", "\n", - "# Inspect the cell and principal-component counts.\n", - "{\"cells\": pca_shape[0], \"PCs\": pca_shape[1]}" + "# Inspect the cell and principal-component counts of each branch.\n", + "pd.DataFrame(\n", + " {\n", + " top_n: ds.artifacts.load(pca)[\"data\"].shape\n", + " for top_n, (pca, _, _) in graph_inputs.items()\n", + " },\n", + " index=[\"cells\", \"PCs\"],\n", + ").T.rename_axis(\"selected genes\")" ] }, { @@ -619,19 +1056,19 @@ "id": "7c09abd9", "metadata": {}, "source": [ - "Build the layout and clustering for the new graph." + "Build the layout and clustering for each graph." ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 12, "id": "4249a394", "metadata": { "execution": { - "iopub.execute_input": "2026-10-21T12:14:42.670465Z", - "iopub.status.busy": "2026-10-21T12:14:42.670116Z", - "iopub.status.idle": "2026-10-21T12:15:30.478520Z", - "shell.execute_reply": "2026-10-21T12:15:30.476990Z" + "iopub.execute_input": "2026-10-22T16:52:25.919921Z", + "iopub.status.busy": "2026-10-22T16:52:25.919623Z", + "iopub.status.idle": "2026-10-22T16:53:04.193795Z", + "shell.execute_reply": "2026-10-22T16:53:04.192331Z" } }, "outputs": [ @@ -687,17 +1124,17 @@ "1000 3948 2" ] }, - "execution_count": 9, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" }, { "data": { "text/html": [ - "Started: 2026-10-21T12:14:42.670116Z | Wall time: 47.808 s" + "Started: 2026-10-22T16:52:25.919623Z | Wall time: 38.274 s" ], "text/plain": [ - "Started: 2026-10-21T12:14:42.670116Z | Wall time: 47.808 s" + "Started: 2026-10-22T16:52:25.919623Z | Wall time: 38.274 s" ] }, "metadata": { @@ -709,14 +1146,14 @@ "source": [ "# Pair the layout and clustering for each feature count.\n", "feature_branches = {\n", - " 500: (baseline[\"umap\"], baseline[\"leiden_0.5\"]),\n", - " 1000: (\n", - " ds.embeddings.umap(graph_1000, initialization_1000),\n", - " ds.clusters.leiden(graph_1000, resolution=0.5),\n", - " ),\n", + " top_n: (\n", + " ds.embeddings.umap(graph, initialization),\n", + " ds.clusters.leiden(graph, resolution=0.5),\n", + " )\n", + " for top_n, (_, graph, initialization) in graph_inputs.items()\n", "}\n", "\n", - "# Read the dimensions of the saved layout for each feature count.\n", + "# Read the dimensions of the layout for each feature count.\n", "layout_shapes = {\n", " top_n: ds.artifacts.load(layout_ref)[\"values\"].shape\n", " for top_n, (layout_ref, _) in feature_branches.items()\n", @@ -730,14 +1167,14 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 13, "id": "6a66c8e2", "metadata": { "execution": { - "iopub.execute_input": "2026-10-21T12:15:30.485082Z", - "iopub.status.busy": "2026-10-21T12:15:30.484777Z", - "iopub.status.idle": "2026-10-21T12:15:31.589034Z", - "shell.execute_reply": "2026-10-21T12:15:31.587056Z" + "iopub.execute_input": "2026-10-22T16:53:04.196472Z", + "iopub.status.busy": "2026-10-22T16:53:04.196195Z", + "iopub.status.idle": "2026-10-22T16:53:04.685108Z", + "shell.execute_reply": "2026-10-22T16:53:04.683536Z" }, "figure_descriptions": [ "UMAPs compare analyses using 500 and 1,000 selected genes, each colored by its own cluster labels. The layouts and partitions differ, so cluster numbers are not directly interchangeable." @@ -746,22 +1183,22 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] }, - "execution_count": 10, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" }, { "data": { "text/html": [ - "Started: 2026-10-21T12:15:30.484777Z | Wall time: 1.104 s" + "Started: 2026-10-22T16:53:04.196195Z | Wall time: 0.489 s" ], "text/plain": [ - "Started: 2026-10-21T12:15:30.484777Z | Wall time: 1.104 s" + "Started: 2026-10-22T16:53:04.196195Z | Wall time: 0.489 s" ] }, "metadata": { @@ -822,14 +1259,14 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 14, "id": "4c758e0e", "metadata": { "execution": { - "iopub.execute_input": "2026-10-21T12:15:31.592183Z", - "iopub.status.busy": "2026-10-21T12:15:31.591818Z", - "iopub.status.idle": "2026-10-21T12:15:31.629902Z", - "shell.execute_reply": "2026-10-21T12:15:31.628758Z" + "iopub.execute_input": "2026-10-22T16:53:04.687814Z", + "iopub.status.busy": "2026-10-22T16:53:04.687510Z", + "iopub.status.idle": "2026-10-22T16:53:04.714100Z", + "shell.execute_reply": "2026-10-22T16:53:04.712952Z" } }, "outputs": [ @@ -865,6 +1302,9 @@ " 9\n", " 10\n", " 11\n", + " 12\n", + " 13\n", + " 14\n", " All\n", " \n", " \n", @@ -881,28 +1321,36 @@ " \n", " \n", " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", " \n", " 1\n", - " 1154\n", + " 921\n", " 0\n", - " 58\n", - " 2\n", + " 7\n", + " 282\n", " 0\n", " 0\n", " 0\n", - " 28\n", + " 0\n", + " 5\n", + " 2\n", " 0\n", " 0\n", " 0\n", - " 1242\n", + " 0\n", + " 1217\n", " \n", " \n", " 2\n", " 0\n", - " 713\n", + " 701\n", + " 0\n", + " 0\n", " 0\n", " 0\n", " 0\n", @@ -912,37 +1360,44 @@ " 0\n", " 3\n", " 0\n", - " 716\n", + " 0\n", + " 704\n", " \n", " \n", " 3\n", + " 2\n", + " 0\n", + " 236\n", + " 0\n", " 9\n", + " 279\n", " 0\n", - " 459\n", - " 107\n", " 0\n", " 0\n", " 0\n", - " 12\n", + " 2\n", " 0\n", " 0\n", " 0\n", - " 587\n", + " 528\n", " \n", " \n", " 4\n", + " 60\n", " 0\n", + " 309\n", + " 55\n", " 0\n", " 0\n", - " 281\n", " 0\n", - " 91\n", " 0\n", " 0\n", - " 3\n", + " 50\n", + " 0\n", " 0\n", " 0\n", - " 375\n", + " 0\n", + " 474\n", " \n", " \n", " 5\n", @@ -950,14 +1405,17 @@ " 0\n", " 0\n", " 0\n", + " 276\n", + " 4\n", + " 0\n", " 0\n", - " 154\n", " 0\n", " 0\n", - " 135\n", + " 3\n", " 0\n", " 0\n", - " 289\n", + " 0\n", + " 283\n", " \n", " \n", " 6\n", @@ -965,13 +1423,16 @@ " 0\n", " 0\n", " 0\n", - " 247\n", " 0\n", + " 0\n", + " 247\n", " 9\n", " 0\n", " 0\n", " 0\n", " 0\n", + " 0\n", + " 0\n", " 256\n", " \n", " \n", @@ -980,29 +1441,35 @@ " 0\n", " 0\n", " 0\n", - " 17\n", " 0\n", + " 0\n", + " 17\n", " 222\n", " 0\n", " 0\n", " 0\n", " 0\n", + " 0\n", + " 0\n", " 239\n", " \n", " \n", " 8\n", - " 29\n", + " 11\n", + " 0\n", " 0\n", + " 58\n", " 0\n", " 0\n", " 0\n", " 0\n", + " 97\n", " 0\n", - " 146\n", " 0\n", " 0\n", " 0\n", - " 175\n", + " 0\n", + " 166\n", " \n", " \n", " 9\n", @@ -1014,9 +1481,12 @@ " 0\n", " 0\n", " 0\n", + " 0\n", + " 0\n", " 29\n", " 0\n", " 0\n", + " 0\n", " 29\n", " \n", " \n", @@ -1030,8 +1500,11 @@ " 0\n", " 0\n", " 0\n", + " 0\n", + " 0\n", " 25\n", " 0\n", + " 0\n", " 25\n", " \n", " \n", @@ -1046,22 +1519,46 @@ " 0\n", " 0\n", " 0\n", + " 0\n", + " 0\n", " 15\n", + " 0\n", " 15\n", " \n", " \n", + " 12\n", + " 0\n", + " 0\n", + " 0\n", + " 0\n", + " 0\n", + " 0\n", + " 0\n", + " 0\n", + " 0\n", + " 0\n", + " 0\n", + " 0\n", + " 0\n", + " 12\n", + " 12\n", + " \n", + " \n", " All\n", - " 1192\n", - " 713\n", - " 517\n", - " 390\n", + " 994\n", + " 701\n", + " 552\n", + " 395\n", + " 285\n", + " 283\n", " 264\n", - " 245\n", " 231\n", - " 186\n", - " 167\n", + " 102\n", + " 52\n", + " 34\n", " 28\n", " 15\n", + " 12\n", " 3948\n", " \n", " \n", @@ -1069,33 +1566,50 @@ "" ], "text/plain": [ - "1,000 genes 1 2 3 4 5 6 7 8 9 10 11 All\n", - "500 genes \n", - "1 1154 0 58 2 0 0 0 28 0 0 0 1242\n", - "2 0 713 0 0 0 0 0 0 0 3 0 716\n", - "3 9 0 459 107 0 0 0 12 0 0 0 587\n", - "4 0 0 0 281 0 91 0 0 3 0 0 375\n", - "5 0 0 0 0 0 154 0 0 135 0 0 289\n", - "6 0 0 0 0 247 0 9 0 0 0 0 256\n", - "7 0 0 0 0 17 0 222 0 0 0 0 239\n", - "8 29 0 0 0 0 0 0 146 0 0 0 175\n", - "9 0 0 0 0 0 0 0 0 29 0 0 29\n", - "10 0 0 0 0 0 0 0 0 0 25 0 25\n", - "11 0 0 0 0 0 0 0 0 0 0 15 15\n", - "All 1192 713 517 390 264 245 231 186 167 28 15 3948" + "1,000 genes 1 2 3 4 5 6 7 8 9 10 11 12 13 14 \\\n", + "500 genes \n", + "1 921 0 7 282 0 0 0 0 5 2 0 0 0 0 \n", + "2 0 701 0 0 0 0 0 0 0 0 0 3 0 0 \n", + "3 2 0 236 0 9 279 0 0 0 0 2 0 0 0 \n", + "4 60 0 309 55 0 0 0 0 0 50 0 0 0 0 \n", + "5 0 0 0 0 276 4 0 0 0 0 3 0 0 0 \n", + "6 0 0 0 0 0 0 247 9 0 0 0 0 0 0 \n", + "7 0 0 0 0 0 0 17 222 0 0 0 0 0 0 \n", + "8 11 0 0 58 0 0 0 0 97 0 0 0 0 0 \n", + "9 0 0 0 0 0 0 0 0 0 0 29 0 0 0 \n", + "10 0 0 0 0 0 0 0 0 0 0 0 25 0 0 \n", + "11 0 0 0 0 0 0 0 0 0 0 0 0 15 0 \n", + "12 0 0 0 0 0 0 0 0 0 0 0 0 0 12 \n", + "All 994 701 552 395 285 283 264 231 102 52 34 28 15 12 \n", + "\n", + "1,000 genes All \n", + "500 genes \n", + "1 1217 \n", + "2 704 \n", + "3 528 \n", + "4 474 \n", + "5 283 \n", + "6 256 \n", + "7 239 \n", + "8 166 \n", + "9 29 \n", + "10 25 \n", + "11 15 \n", + "12 12 \n", + "All 3948 " ] }, - "execution_count": 11, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" }, { "data": { "text/html": [ - "Started: 2026-10-21T12:15:31.591818Z | Wall time: 0.038 s" + "Started: 2026-10-22T16:53:04.687510Z | Wall time: 0.027 s" ], "text/plain": [ - "Started: 2026-10-21T12:15:31.591818Z | Wall time: 0.038 s" + "Started: 2026-10-22T16:53:04.687510Z | Wall time: 0.027 s" ] }, "metadata": { @@ -1121,35 +1635,35 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 15, "id": "3fd3b706", "metadata": { "execution": { - "iopub.execute_input": "2026-10-21T12:15:31.633480Z", - "iopub.status.busy": "2026-10-21T12:15:31.633131Z", - "iopub.status.idle": "2026-10-21T12:15:31.668125Z", - "shell.execute_reply": "2026-10-21T12:15:31.666641Z" + "iopub.execute_input": "2026-10-22T16:53:04.716372Z", + "iopub.status.busy": "2026-10-22T16:53:04.716107Z", + "iopub.status.idle": "2026-10-22T16:53:04.739591Z", + "shell.execute_reply": "2026-10-22T16:53:04.738733Z" } }, "outputs": [ { "data": { "text/plain": [ - "adjusted Rand index 0.839422\n", + "adjusted Rand index 0.703847\n", "Name: 500 vs 1,000 selected genes, dtype: float64" ] }, - "execution_count": 12, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" }, { "data": { "text/html": [ - "Started: 2026-10-21T12:15:31.633131Z | Wall time: 0.035 s" + "Started: 2026-10-22T16:53:04.716107Z | Wall time: 0.023 s" ], "text/plain": [ - "Started: 2026-10-21T12:15:31.633131Z | Wall time: 0.035 s" + "Started: 2026-10-22T16:53:04.716107Z | Wall time: 0.023 s" ] }, "metadata": { @@ -1175,9 +1689,12 @@ "id": "9fc5007d", "metadata": {}, "source": [ - "In the saved comparison, the 500-gene cluster 5 divides almost evenly between 1,000-gene\n", - "clusters 6 and 9; cluster 4 divides mainly between 4 and 6. Those are specific boundaries to review with\n", - "markers. A larger set can recover weaker populations, but it can also include unwanted programs.\n", + "In this comparison, four 500-gene clusters divide. Cluster 1 divides between 1,000-gene\n", + "clusters 1 (921 cells) and 4 (282), and cluster 8 between 9 (97) and 4 (58). Cluster 3 divides\n", + "between 6 (279) and 3 (236), and 1,000-gene cluster 3 also takes 309 cells of cluster 4, whose\n", + "other cells go to 1, 4, and 10 (50 to 60 each). The other clusters keep at least 90% of their\n", + "cells together. Those are specific boundaries to review with markers. A larger set can recover\n", + "weaker populations, but it can also include unwanted programs.\n", "The adjusted Rand index (ARI) measures agreement between partitions without requiring their\n", "cluster numbers to match. It does not identify which feature set is more biologically useful.\n", "Compare marker specificity and known biology instead of choosing the layout that appears most separated.\n", @@ -1197,14 +1714,14 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 16, "id": "c1c317db", "metadata": { "execution": { - "iopub.execute_input": "2026-10-21T12:15:31.670801Z", - "iopub.status.busy": "2026-10-21T12:15:31.670510Z", - "iopub.status.idle": "2026-10-21T12:15:31.770698Z", - "shell.execute_reply": "2026-10-21T12:15:31.769054Z" + "iopub.execute_input": "2026-10-22T16:53:04.741980Z", + "iopub.status.busy": "2026-10-22T16:53:04.741747Z", + "iopub.status.idle": "2026-10-22T16:53:04.806036Z", + "shell.execute_reply": "2026-10-22T16:53:04.804853Z" } }, "outputs": [ @@ -1218,20 +1735,20 @@ { "data": { "text/plain": [ - "ArtifactRef(assay='RNA', kind='feature_selection', artifact_id='4ab17ae6b719...')" + "ArtifactRef(assay='RNA', kind='feature_selection', artifact_id='b0de26009dbd...')" ] }, - "execution_count": 13, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" }, { "data": { "text/html": [ - "Started: 2026-10-21T12:15:31.670510Z | Wall time: 0.100 s" + "Started: 2026-10-22T16:53:04.741747Z | Wall time: 0.064 s" ], "text/plain": [ - "Started: 2026-10-21T12:15:31.670510Z | Wall time: 0.100 s" + "Started: 2026-10-22T16:53:04.741747Z | Wall time: 0.064 s" ] }, "metadata": { @@ -1311,7 +1828,7 @@ "\n", "## Common mistakes and limitations\n", "\n", - "- Assuming the default blacklist is a functional classification: it is a set of name patterns, so `^CCN` also removes `CCND1` and `^HIST` misses names like `H2AC1`, and supplying `blacklist=` replaces the whole default rather than adding to it. Check which names your annotation actually drops, and clear or narrow the pattern when your question needs mitochondrial, ribosomal, or sex-linked programs.\n", + "- Assuming the default blacklist is a functional classification: it is a set of name patterns, so its cyclin family also removes `CCND1`, which can mark proliferation-independent states, and supplying `blacklist=` replaces the whole default rather than adding to it. Check which names your annotation actually drops, and clear or narrow the pattern when your question needs mitochondrial, ribosomal, or sex-linked programs.\n", "- Treating the feature-set size as a neutral parameter: `top_n` changes the PCA basis and the neighbourhood graph, so clusters can split or merge when it changes. The ARI measures agreement between partitions, not biological usefulness; review changed boundaries with markers and known biology before preferring the more separated layout.\n", "- Using an external marker panel as an independent test: a graph built from the panel emphasizes exactly the identities the panel was chosen to distinguish, so it cannot validate them. Keep a genome-wide HVG selection for that check.\n" ] @@ -1319,8 +1836,8 @@ ], "metadata": { "description": "Choose informative RNA genes, understand CyteArc's default exclusions, and compare feature-set sizes.", - "executed_at": "2026-10-21T12:15:33.745795+00:00", - "executed_code_sha256": "360090d8d64a119d52e6a801c94fc2d484ada99765f793d0795271596da8c14e", + "executed_at": "2026-10-22T16:53:06.466236+00:00", + "executed_code_sha256": "2840c97c5dd5c6439250a6c5007b0d3bd101dde2d6d7c0a040194f2303e1faa6", "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", diff --git a/scripts/export_scanpy_hvg_golden.py b/scripts/export_scanpy_hvg_golden.py new file mode 100644 index 0000000..91868d7 --- /dev/null +++ b/scripts/export_scanpy_hvg_golden.py @@ -0,0 +1,175 @@ +#!/usr/bin/env python +"""Regenerate tests/scanpy_hvg_1_12_4_golden.json. + +Runs scanpy 1.12.4 with scikit-misc on the RNA counts of the active cells of +the 1k PBMC CITE-seq test fixture and writes compact reference outputs for +the seurat_v3 and pearson_residuals highly variable gene flavors, with and +without batches. The batches split the active cells into their first and +second halves. The fixture is downloaded by ``tests/download_fixtures.py``. +Run from the repository root: + + uv run --with scanpy==1.12.4 --with scikit-misc==0.5.3 \\ + python scripts/export_scanpy_hvg_golden.py +""" + +import argparse +import hashlib +import json +import tarfile +import tempfile +from importlib.metadata import version +from pathlib import Path + +import anndata +import numpy as np +import pandas as pd +import scanpy as sc +import zarr +from scipy.sparse import csr_matrix + +REPO = Path(__file__).resolve().parent.parent +FIXTURE = REPO / "tests/datasets/1K_pbmc_citeseq.zarr.tar.gz" +DEFAULT_OUTPUT = REPO / "tests/scanpy_hvg_1_12_4_golden.json" +TOP_N = 2000 +# Scores are kept for the genes that scanpy ranks first, which hold every +# selection boundary, and for every SAMPLE_STEP-th of the other scored genes. +SCORED_TOP = 2200 +SAMPLE_STEP = 50 +PEARSON_BATCH_CLIP = 20.0 + + +def parse_args() -> argparse.Namespace: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--fixture", type=Path, default=FIXTURE) + parser.add_argument("--output", type=Path, default=DEFAULT_OUTPUT) + return parser.parse_args() + + +def counts_sha256(counts: np.ndarray) -> str: + """Fingerprint counts by their CSR arrays, as tests/test_hvg_flavors.py does.""" + matrix = csr_matrix(counts.astype(np.int64)) + digest = hashlib.sha256() + for values in (matrix.indptr, matrix.indices, matrix.data): + digest.update(np.ascontiguousarray(values, dtype=" tuple[np.ndarray, int]: + with tempfile.TemporaryDirectory(prefix="cytearc-hvg-golden-") as work: + with tarfile.open(fixture, "r:gz") as archive: + archive.extractall(work, filter="data") + root = zarr.open_group(work, mode="r") + active = np.asarray(root["cellData/I"][:], dtype=bool) + counts = np.asarray(root["RNA/counts"][:])[np.flatnonzero(active)] + return counts, int(active.size) + + +def scored(scores: np.ndarray) -> dict[str, list[float] | list[int]]: + """Return the indices and scores of the top-ranked and sampled genes.""" + order = np.lexsort((np.arange(len(scores)), -scores)) + positive = order[scores[order] > 0] + keep = np.unique( + np.concatenate([positive[:SCORED_TOP], positive[SCORED_TOP::SAMPLE_STEP]]) + ) + return { + "indices": keep.tolist(), + "scores": [float(f"{value:.10g}") for value in scores[keep]], + } + + +def selection(var: pd.DataFrame, score: str, batches: bool) -> dict[str, object]: + selected = np.flatnonzero(var["highly_variable"].to_numpy()) + record: dict[str, object] = { + "selected": selected.tolist(), + **scored(var[score].to_numpy(dtype=np.float64)), + } + if batches: + record["batchCount"] = ( + var["highly_variable_nbatches"].to_numpy()[selected].astype(int).tolist() + ) + record["medianRank"] = [ + float(value) + for value in var["highly_variable_rank"].to_numpy(dtype=np.float64)[ + selected + ] + ] + return record + + +def main() -> None: + args = parse_args() + counts, n_store_cells = read_counts(args.fixture) + n_cells, n_genes = counts.shape + batch = np.where(np.arange(n_cells) < n_cells // 2, "a", "b") + adata = anndata.AnnData(csr_matrix(counts.astype(np.float64))) + adata.obs["batch"] = pd.Categorical(batch) + + outputs: dict[str, dict[str, object]] = {} + single = adata.copy() + sc.pp.highly_variable_genes(single, flavor="seurat_v3", n_top_genes=TOP_N) + outputs["seurat_v3"] = selection(single.var, "variances_norm", False) + batched = adata.copy() + sc.pp.highly_variable_genes( + batched, flavor="seurat_v3_paper", n_top_genes=TOP_N, batch_key="batch" + ) + outputs["seurat_v3_paper_batch"] = selection(batched.var, "variances_norm", True) + single = adata.copy() + sc.experimental.pp.highly_variable_genes( + single, flavor="pearson_residuals", n_top_genes=TOP_N + ) + outputs["pearson_residuals"] = selection(single.var, "residual_variances", False) + batched = adata.copy() + sc.experimental.pp.highly_variable_genes( + batched, + flavor="pearson_residuals", + n_top_genes=TOP_N, + batch_key="batch", + clip=PEARSON_BATCH_CLIP, + ) + outputs["pearson_residuals_batch"] = selection( + batched.var, "residual_variances", True + ) + + fixture = { + "provenance": { + "package": "scanpy", + "packageVersion": version("scanpy"), + "scikitMiscVersion": version("scikit-misc"), + "anndataVersion": version("anndata"), + "numpyVersion": version("numpy"), + "sourceRepository": "https://github.com/scverse/scanpy", + "dataset": "1K_pbmc_citeseq.zarr.tar.gz", + "datasetSource": "tests/download_fixtures.py", + "generator": "scripts/export_scanpy_hvg_golden.py", + "nStoreCells": n_store_cells, + "nCells": n_cells, + "nGenes": n_genes, + "topN": TOP_N, + "batches": "first and second halves of the active cells, a and b", + "pearsonBatchClip": PEARSON_BATCH_CLIP, + "scoredTop": SCORED_TOP, + "sampleStep": SAMPLE_STEP, + "calls": { + "seurat_v3": "sc.pp.highly_variable_genes(flavor='seurat_v3')", + "seurat_v3_paper_batch": ( + "sc.pp.highly_variable_genes(flavor='seurat_v3_paper', " + "batch_key='batch')" + ), + "pearson_residuals": ( + "sc.experimental.pp.highly_variable_genes(" + "flavor='pearson_residuals')" + ), + "pearson_residuals_batch": ( + "sc.experimental.pp.highly_variable_genes(" + "flavor='pearson_residuals', batch_key='batch', clip=20.0)" + ), + }, + }, + "inputs": {"countsSha256": counts_sha256(counts)}, + "scanpy": outputs, + } + args.output.write_text(json.dumps(fixture, separators=(",", ":")) + "\n") + + +if __name__ == "__main__": + main() diff --git a/skills/cytearc-single-cell/SKILL.md b/skills/cytearc-single-cell/SKILL.md index c556d0c..a7d5052 100644 --- a/skills/cytearc-single-cell/SKILL.md +++ b/skills/cytearc-single-cell/SKILL.md @@ -121,13 +121,14 @@ not thresholds. 14. **Hold out annotation columns when they will judge the result.** Do not use author labels (`cell_type`, `author_cell_type`, `cell.type.*`, `singler`, `predicted.*`, ...) to choose QC, parameters or labels. Use them only in a final, clearly separated comparison. -15. **Pass an explicit HVG blacklist.** On stores with current gene symbols the default blacklist - misses replication-dependent histones (`^HIST` matches only pre-2020 names), and its `^CCN` - family removes the CCN1-6 matricellular genes and non-cell-cycle cyclins. It also leaves Ig V/J - genes in, which can split plasma cells by light chain instead of biology. Use the species string - from `references/gene-blacklists.md` (`params={"hvg": {"blacklist": ...}}` in the pipeline). Add - the clonotype add-on only on marker evidence. A `blacklist=` string replaces the default - entirely, and changing it creates new HVG, PCA and graph artifacts. +15. **Check the HVG blacklist against the species.** The default matches pre-2020 and current + replication-dependent histone symbols and spares the CCN1-6 matricellular genes, but its + cyclin family (`^CCN[A-Z]`) also removes cyclins that are not cell-cycle markers, such as + `CCND1` and `CCNL1`, and it leaves Ig V/J genes in, which can split plasma cells by light chain + instead of biology. Pass the species string from `references/gene-blacklists.md` when those + matter (`params={"hvg": {"blacklist": ...}}` in the pipeline). Add the clonotype add-on only + on marker evidence. A `blacklist=` string replaces the default entirely, and changing it + creates new HVG, PCA and graph artifacts. ## The analysis loop diff --git a/skills/cytearc-single-cell/references/features-and-graphs.md b/skills/cytearc-single-cell/references/features-and-graphs.md index 3d02a58..f8cb673 100644 --- a/skills/cytearc-single-cell/references/features-and-graphs.md +++ b/skills/cytearc-single-cell/references/features-and-graphs.md @@ -47,6 +47,18 @@ chain of artifacts, then branch or subcluster it safely. Docs: list[str] was added. ArtifactAccessor: "6d4befabbbc91b00684038f44e0b3063905c84437587be0994c26370efa2570c", } diff --git a/tests/test_feature_operation_paths.py b/tests/test_feature_operation_paths.py index 07e3087..e544186 100644 --- a/tests/test_feature_operation_paths.py +++ b/tests/test_feature_operation_paths.py @@ -212,19 +212,27 @@ def no_summary(*_args: Any, **_kwargs: Any) -> None: assert store.features.detected(cells, min_cells=10) == first -def test_hvgs_over_few_cells_skip_the_ubiquitous_gene_filter(store: DataStore) -> None: +def test_hvgs_over_few_cells_keep_the_ubiquitous_gene_filter(store: DataStore) -> None: cells = _cells(store) - # 24 cells leave no room for max_cells = n_selected - 20 above min_cells. + # Of 24 cells, more than 99.5% is all 24: the default cutoff excludes only + # genes detected in every cell, so it is the exclusive cutoff 24. default = store.features.hvgs( cells, min_cells=5, top_n=4, n_bins=4, show_plot=False ) + assert store.artifacts.inspect(default).parameters["max_cells"] == 24 assert ( store.features.hvgs( - cells, min_cells=5, top_n=4, n_bins=4, max_cells=np.inf, show_plot=False + cells, min_cells=5, top_n=4, n_bins=4, max_cells=24, show_plot=False ) == default ) + assert ( + store.features.hvgs( + cells, min_cells=5, top_n=4, n_bins=4, max_cells=np.inf, show_plot=False + ) + != default + ) def test_hvg_plot_shows_the_saved_selection_when_computed_and_reused( diff --git a/tests/test_gene_families.py b/tests/test_gene_families.py index 132eb12..7d1e151 100644 --- a/tests/test_gene_families.py +++ b/tests/test_gene_families.py @@ -39,7 +39,9 @@ def test_default_blacklist_is_the_union_of_every_registered_family() -> None: # HVG selections record the blacklist text, so it must not drift. assert DEFAULT_HVG_BLACKLIST == ( - "^MT-|^RPS|^RPL|^MRPS|^MRPL|^CCN|^HLA-|^H2-|^HIST|" + "^MT-|^RPS|^RPL|^MRPS|^MRPL|^CCN[A-Z]|^HLA-|^H2-|" + "^HIST|^H1-[1-6]$|^H1F[1-6]$|^H2AC\\d+$|^H2BC\\d+$|^H3C\\d+$|^H4C\\d+$|" + "^H2AW$|^H3-4$|^H4-16$|" "^XIST$|^DDX3Y$|^USP9Y$|^EIF1AY$|^KDM5D$|^SRY$|^ZFY$|^UTY$|^TMSB4Y$|^NLGN4Y$" ) union = np.logical_or.reduce( diff --git a/tests/test_hvg_flavors.py b/tests/test_hvg_flavors.py new file mode 100644 index 0000000..b719897 --- /dev/null +++ b/tests/test_hvg_flavors.py @@ -0,0 +1,1658 @@ +"""HVG flavors, batch-aware selection, detection bounds, and Pearson residuals. + +The seurat_v3 and pearson_residuals flavors are checked against direct NumPy +implementations of their published formulas and against outputs of scanpy +1.12.4 with scikit-misc 0.5.3 stored in ``scanpy_hvg_1_12_4_golden.json`` +(``scripts/export_scanpy_hvg_golden.py`` regenerates it). Batch-aware +selection follows the ordering of Seurat's ``SelectIntegrationFeatures``. +""" + +import hashlib +import json +import math +import shutil +from pathlib import Path +from types import SimpleNamespace +from typing import Any + +import numpy as np +import pytest +import zarr +from scipy.sparse import csr_matrix +from scipy.stats import spearmanr + +from cytearc.assay import ATACassay, PearsonResidualNormalizer, norm_pearson_residuals +from cytearc.assay.base import Assay +from cytearc.assay.hvg_statistics import ( + grouped_clipped_squares, + grouped_moments, + grouped_pearson_residual_moments, +) +from cytearc.assay.normalization import applicable_normalization_flags +from cytearc.datastore.datastore import DataStore +from cytearc.features.variability import ( + DEFAULT_HVG_BLACKLIST, + _fit_loess_points, + _loess_vertices, + combine_batch_rankings, + default_hvg_min_cells, + default_hvg_ubiquity_limit, + fit_loess, + fit_lowess, + hvg_flavor_options, + hvg_options, + pearson_residual_clip, + pearson_residuals, + resolve_hvg_detection_bounds, + select_highly_variable_features, + seurat_v3_clip_values, + seurat_v3_expected_variance, + seurat_v3_standardized_variance, +) +from cytearc.storage.artifacts import artifact_path, inspect_artifact +from cytearc.storage.count_matrix import CountMatrixPolicy +from cytearc.storage.errors import ArtifactResolutionError +from cytearc.storage.operation_revisions import OPERATION_REVISIONS +from cytearc.storage.schema import create_cell_data, create_zarr_count_assay +from cytearc.utils.logging import logger +from cytearc.writers.counts_t import finalize_writer_counts_t +from tests.storage_helpers import finalize_test_counts, insert_nullable_cell_column + +_GOLDEN = Path(__file__).parent / "scanpy_hvg_1_12_4_golden.json" + + +def _warnings(run: Any) -> list[str]: + messages: list[str] = [] + sink = logger.add( + lambda message: messages.append(message.record["message"]), level="WARNING" + ) + try: + run() + finally: + logger.remove(sink) + return messages + + +# Local regression + + +def _reference_loess(x: np.ndarray, y: np.ndarray, span: float, degree: int): + """Weighted least squares at every point, written from Cleveland (1979).""" + q = min(len(x), max(math.floor(span * len(x)), degree + 1)) + fitted = [] + for x0 in x: + distance = np.abs(x - x0) + h = np.sort(distance)[q - 1] + weight = np.where(distance < h, (1 - (distance / h) ** 3) ** 3, 0.0) + design = np.vander(x - x0, degree + 1, increasing=True) + coefficients = np.linalg.lstsq( + design * np.sqrt(weight)[:, None], y * np.sqrt(weight), rcond=None + )[0] + fitted.append(coefficients[0]) + return np.asarray(fitted) + + +@pytest.mark.parametrize("degree", [0, 1, 2]) +@pytest.mark.parametrize("span", [0.3, 0.75, 1.0]) +def test_direct_loess_matches_weighted_least_squares(span, degree) -> None: + rng = np.random.default_rng(3) + x = rng.normal(size=150) + y = np.sin(2 * x) + rng.normal(0, 0.2, size=150) + + np.testing.assert_allclose( + fit_loess(x, y, span=span, degree=degree, surface="direct"), + _reference_loess(x, y, span, degree), + rtol=1e-9, + atol=1e-12, + ) + + +@pytest.mark.parametrize("surface", ["direct", "interpolate"]) +def test_loess_reproduces_a_quadratic_trend(surface) -> None: + x = np.random.default_rng(5).uniform(-2, 2, 300) + y = 3 * x**2 - x + 1 + + np.testing.assert_allclose(fit_loess(x, y, surface=surface), y, atol=1e-9) + + +def test_interpolated_loess_blends_vertex_fits_with_cubic_hermite_polynomials() -> None: + rng = np.random.default_rng(11) + x = np.sort(rng.uniform(0, 10, 200)) + y = np.cos(x) + rng.normal(0, 0.1, 200) + vertices = _loess_vertices(x, math.floor(200 * 0.3 * 0.2)) + values = np.empty(len(vertices)) + slopes = np.empty(len(vertices)) + _fit_loess_points(x, y, 60, 2, vertices, values, slopes) + # Each vertex carries the value and slope of the weighted least-squares + # quadratic at its position. + for vertex, value, slope in zip(vertices, values, slopes, strict=True): + distance = np.abs(x - vertex) + h = np.sort(distance)[59] + weight = np.sqrt(np.where(distance < h, (1 - (distance / h) ** 3) ** 3, 0.0)) + design = np.vander(x - vertex, 3, increasing=True) + coefficients = np.linalg.lstsq( + design * weight[:, None], y * weight, rcond=None + )[0] + assert (value, slope) == pytest.approx(tuple(coefficients[:2]), rel=1e-9) + cell = np.searchsorted(vertices, x[37], side="right") - 1 + width = vertices[cell + 1] - vertices[cell] + t = (x[37] - vertices[cell]) / width + expected = ( + (1 - t) ** 2 * (1 + 2 * t) * values[cell] + + t**2 * (3 - 2 * t) * values[cell + 1] + + (t * (1 - t) ** 2 * slopes[cell] - t**2 * (1 - t) * slopes[cell + 1]) * width + ) + + assert fit_loess(x, y)[37] == pytest.approx(expected, rel=1e-12) + # The root cell spans the data widened by 0.5% of their range, and every + # leaf holds at most 12 points; a point at a split vertex is in the lower + # cell. + assert vertices[0] == pytest.approx(x[0] - 0.005 * (x[-1] - x[0])) + assert vertices[-1] == pytest.approx(x[-1] + 0.005 * (x[-1] - x[0])) + cells = np.searchsorted(vertices, x, side="left") - 1 + assert np.bincount(cells).max() <= 12 + + +def test_loess_vertices_never_split_tied_values() -> None: + x = np.array([1.0, 1, 1, 1, 1, 1, 2, 3]) + + # The median sits inside six ties, so the split moves to the last tie; + # the cell of ties cannot be split again. + np.testing.assert_array_equal(_loess_vertices(x, 2), [0.99, 1.0, 3.01]) + + +def test_loess_handles_ties_tiny_inputs_and_empty_windows() -> None: + np.testing.assert_array_equal(fit_loess(np.empty(0), np.empty(0)), np.empty(0)) + assert fit_loess(np.array([2.0]), np.array([5.0]))[0] == pytest.approx(5.0) + # More ties than the window holds: the fit is the mean of the ties. + x = np.r_[np.zeros(8), np.arange(1.0, 3.0)] + y = np.r_[np.arange(8.0), 10.0, 20.0] + fitted = fit_loess(x, y, span=0.3, surface="direct") + np.testing.assert_allclose(fitted[:8], 3.5) + # Ties after other points: the window slides to the first tie, and the + # fit is the mean of every tied point. + x = np.r_[-2.0, -1.0, np.zeros(6), 1.0] + y = np.r_[5.0, 6.0, np.arange(6.0), 9.0] + fitted = fit_loess(x, y, span=0.3, surface="direct") + np.testing.assert_allclose(fitted[2:8], 2.5) + # A point midway between the only two points of its window gives both + # zero weight, so the fit is their mean. + values = np.empty(1) + slopes = np.empty(1) + _fit_loess_points( + np.array([0.0, 2.0]), + np.array([1.0, 3.0]), + 2, + 2, + np.array([1.0]), + values, + slopes, + ) + assert (values[0], slopes[0]) == (2.0, 0.0) + # Two distinct values cannot carry a quadratic, so the fit is linear. + x = np.array([0.0, 0.0, 1.0, 1.0]) + y = np.array([1.0, 1.0, 3.0, 3.0]) + np.testing.assert_allclose(fit_loess(x, y, span=1.0, surface="direct"), y) + + +@pytest.mark.parametrize( + ("arguments", "error", "message"), + [ + ({"x": np.ones((2, 2)), "y": np.ones((2, 2))}, ValueError, "one-dimensional"), + ({"x": np.ones(3), "y": np.ones(2)}, ValueError, "one-dimensional"), + ({"x": np.array([1.0, np.nan]), "y": np.ones(2)}, ValueError, "finite"), + ({"span": 0}, ValueError, "span must be greater than 0"), + ({"span": 1.5}, ValueError, "span must be greater than 0"), + ({"span": "0.3"}, TypeError, "span must be a real number"), + ({"degree": 3}, ValueError, "degree must be at most 2"), + ({"surface": "kd"}, ValueError, "surface must be"), + ], +) +def test_loess_rejects_invalid_arguments(arguments, error, message) -> None: + options = {"x": np.arange(5.0), "y": np.arange(5.0), **arguments} + with pytest.raises(error, match=message): + fit_loess(options.pop("x"), options.pop("y"), **options) + + +# seurat_v3 and Pearson residual formulas + + +def test_seurat_v3_standardized_variance_matches_clipped_z_scores() -> None: + rng = np.random.default_rng(17) + success = np.linspace(0.05, 0.9, 40) + counts = rng.negative_binomial(2, success, size=(60, 40)).astype(np.float64) + counts[:, 0] = 0 + counts[:, 1] = 2 + counts[7, 20] = 300 + n = len(counts) + mean = counts.mean(axis=0) + variance = counts.var(axis=0, ddof=1) + + expected = seurat_v3_expected_variance(mean, variance, span=0.3) + clips = seurat_v3_clip_values(mean, expected, n) + squares = ((np.minimum(counts, clips) - mean) ** 2).sum(axis=0) + standardized = seurat_v3_standardized_variance(squares, expected, n) + + varying = variance > 0 + np.testing.assert_allclose( + expected[varying], + 10 ** fit_loess(np.log10(mean[varying]), np.log10(variance[varying])), + ) + assert expected[0] == expected[1] == 0 + # Seurat standardizes counts, clips the z-scores at sqrt(n), and divides + # their sum of squares around 0 by n - 1. + sigma = np.sqrt(expected[varying]) + z = np.minimum((counts[:, varying] - mean[varying]) / sigma, np.sqrt(n)) + np.testing.assert_allclose( + standardized[varying], (z**2).sum(axis=0) / (n - 1), rtol=1e-12 + ) + assert standardized[0] == standardized[1] == 0 + # Only the outlier of gene 20 lies above its clip. + assert np.array_equal(np.argwhere(counts > clips), [[7, 20]]) + with pytest.raises(ValueError, match="at least two cells"): + seurat_v3_standardized_variance(squares, expected, 1) + with pytest.raises(ValueError, match="positive mean"): + seurat_v3_expected_variance(np.array([0.0, 1.0]), np.array([1.0, 1.0])) + # Without a varying feature there is no trend to fit. + np.testing.assert_array_equal( + seurat_v3_expected_variance(np.array([0.0, 2.0]), np.zeros(2)), np.zeros(2) + ) + + +def test_pearson_residuals_match_a_hand_computed_example() -> None: + counts = np.array([[0, 2], [3, 1], [0, 0]]) + totals = counts.sum(axis=1) + fractions = counts.sum(axis=0) / totals.sum() + # Expected counts are [[1, 1], [2, 2], [0, 0]] for theta=100. + first, second = 1 / np.sqrt(1.01), 1 / np.sqrt(2.04) + + np.testing.assert_allclose( + pearson_residuals(counts, totals, fractions, theta=100.0, clip=10.0), + [[-first, first], [second, -second], [0.0, 0.0]], + ) + np.testing.assert_allclose( + pearson_residuals(counts, totals, fractions, theta=100.0, clip=0.8), + [[-0.8, 0.8], [second, -second], [0.0, 0.0]], + ) + assert pearson_residual_clip(None, 49) == 7.0 + assert pearson_residual_clip(2, 49) == 2.0 + + +# Detection bounds + + +@pytest.mark.parametrize( + ("n_selected", "min_cells", "limit"), + [ + (1, 1, 0), + (2, 1, 1), + (4, 1, 3), + (10, 2, 9), + (15, 3, 14), + (41, 3, 40), + (150, 3, 149), + (300, 3, 298), + (301, 4, 299), + (892, 9, 887), + (1000, 10, 995), + (1901, 20, 1891), + (3696, 20, 3677), + (4000, 20, 3980), + (100_000, 20, 99_500), + ], +) +def test_default_detection_bounds_scale_with_the_selection( + n_selected, min_cells, limit +) -> None: + assert default_hvg_min_cells(n_selected) == min_cells + assert default_hvg_ubiquity_limit(n_selected) == limit + # A selection of two or more cells keeps a band of detection counts. + assert n_selected < 2 or min_cells <= limit + assert resolve_hvg_detection_bounds( + None, None, n_selected=n_selected, keep_bounds=False + ) == (min_cells, limit + 1) + assert resolve_hvg_detection_bounds( + None, None, n_selected=n_selected, keep_bounds=True + ) == (min_cells, limit) + + +def test_detection_bounds_of_other_flavors_and_explicit_values() -> None: + for flavor in ("seurat_v3", "pearson_residuals"): + assert resolve_hvg_detection_bounds( + None, None, n_selected=500, keep_bounds=False, flavor=flavor + ) == (0, np.inf) + assert resolve_hvg_detection_bounds( + 7, np.inf, n_selected=500, keep_bounds=False + ) == (7, np.inf) + assert resolve_hvg_detection_bounds( + 0, 250.9, n_selected=500, keep_bounds=True, flavor="seurat_v3" + ) == (0, 250) + + +# Candidate filters and ranking + + +def _select(**overrides: Any) -> np.ndarray: + options: dict[str, Any] = dict( + corrected_variance=np.array([10.0, 8.0, 6.0, 4.0, 2.0]), + normalized_cell_counts=np.full(5, 5), + mean_nonzero=np.ones(5), + active_features=np.ones(5, dtype=bool), + feature_names=np.array(["a", "b", "c", "d", "e"]), + min_cells=0, + max_cells=np.inf, + top_n=2, + min_var=-np.inf, + max_var=np.inf, + min_mean=-np.inf, + max_mean=np.inf, + blacklist="", + keep_bounds=False, + ) + options.update(overrides) + return np.asarray(select_highly_variable_features(**options)) + + +def test_variance_bounds_filter_candidates_before_top_n() -> None: + # min_var is the log2 of the bound: 2**2 = 4, and top_n still applies. + np.testing.assert_array_equal(_select(min_var=2), [True, True, False, False, False]) + # max_var removes genes before ranking, so top_n genes remain. + np.testing.assert_array_equal( + _select(max_var=math.log2(7)), [False, False, True, True, False] + ) + np.testing.assert_array_equal( + _select(max_var=math.log2(6), keep_bounds=True), + [False, False, True, True, False], + ) + # top_n=10 with max_var=2 keeps every gene below 2**2 = 4. + many = np.arange(20, 0, -1, dtype=np.float64) / 4 + selected = _select( + corrected_variance=many, + normalized_cell_counts=np.full(20, 5), + mean_nonzero=np.ones(20), + active_features=np.ones(20, dtype=bool), + feature_names=np.array([f"g{index}" for index in range(20)]), + top_n=10, + max_var=2, + ) + np.testing.assert_array_equal(np.flatnonzero(selected), np.arange(5, 15)) + + +def test_selection_with_no_candidate_names_every_filter() -> None: + with pytest.raises(ValueError) as caught: + _select(min_var=10, max_mean=1) + message = str(caught.value) + assert message.startswith("HVG selection contains no features. No features passed") + assert "min_var=10" in message and "max_mean=1" in message + + +def test_selection_warns_when_fewer_candidates_than_top_n_pass() -> None: + messages = _warnings(lambda: _select(top_n=10, min_var=2)) + assert any("Only 3 features passed" in message for message in messages) + + +def test_nan_scores_never_pass_the_candidate_filters() -> None: + selected = _select(corrected_variance=np.array([np.nan, 8.0, 6.0, 4.0, 2.0])) + np.testing.assert_array_equal(selected, [False, True, True, False, False]) + + +def test_batches_combine_by_count_then_median_rank() -> None: + scores = np.array( + [ + [5.0, 4, 3, 2, 6, 1], + [1.0, 6, 5, 4, 3, 2], + [5.0, 4, 1, 6, 2, 3], + ] + ) + ranking = combine_batch_rankings(scores, np.ones(scores.shape, dtype=bool), top_n=3) + + np.testing.assert_array_equal(ranking.batch_count, [2, 3, 1, 2, 1, 0]) + np.testing.assert_array_equal(ranking.median_rank, [1, 2, 1, 1, 0, np.nan]) + # Seurat's order: gene 1 is highly variable in three batches, then genes + # 0 and 3 in two, tied at median rank 1. Sorting by median rank first, as + # scanpy's seurat_v3 does, would pick gene 4, ranked first in one batch. + np.testing.assert_array_equal( + ranking.selected, [True, True, False, True, False, False] + ) + + +def test_one_batch_selects_the_top_scores() -> None: + scores = np.array([[3.0, 7.0, 7.0, 1.0, 5.0]]) + candidates = np.array([[True, True, True, True, False]]) + + ranking = combine_batch_rankings(scores, candidates, top_n=2) + + np.testing.assert_array_equal(ranking.selected, [False, True, True, False, False]) + np.testing.assert_array_equal(ranking.median_rank, [np.nan, 0, 1, np.nan, np.nan]) + + +def test_batch_ranking_warns_and_fails_loudly() -> None: + scores = np.array([[3.0, 2.0, 1.0], [1.0, 2.0, 3.0]]) + candidates = np.array([[True, False, False], [True, True, True]]) + messages = _warnings( + lambda: combine_batch_rankings( + scores, candidates, top_n=2, batch_names=["left", "right"] + ) + ) + assert any("Batch 'left' has 1 HVG candidates" in message for message in messages) + + messages = _warnings( + lambda: combine_batch_rankings( + scores, np.array([[True, False, False]] * 2), top_n=2 + ) + ) + assert any("Only 1 features are highly variable" in message for message in messages) + with pytest.raises(ValueError, match="in any batch"): + combine_batch_rankings(scores, np.zeros(scores.shape, dtype=bool), top_n=2) + + +def test_one_batch_ranking_warns_like_a_selection_without_batches() -> None: + # A flavor without batch ranks one batch, which a message never names. + messages = _warnings( + lambda: combine_batch_rankings( + np.array([[3.0, 2.0, 1.0]]), + np.array([[True, False, False]]), + top_n=2, + batch_names=["all"], + ) + ) + + assert messages == [ + "Only 1 features passed the HVG candidate filters, fewer than top_n=2; " + "all of them are selected" + ] + + +@pytest.mark.parametrize(("n_batches", "where"), [(1, ""), (2, " in any batch")]) +def test_batch_selection_without_candidates_names_every_filter( + n_batches, where +) -> None: + from cytearc.features.variability import select_batch_highly_variable_features + + with pytest.raises(ValueError) as caught: + select_batch_highly_variable_features( + np.ones((n_batches, 3)), + np.ones((n_batches, 3)), + np.array([5, 5, 5]), + np.array(["a", "b", "c"]), + min_cells=6, + max_cells=np.inf, + top_n=2, + min_var=-np.inf, + max_var=np.inf, + min_mean=-np.inf, + max_mean=np.inf, + blacklist="", + keep_bounds=False, + ) + + assert str(caught.value) == ( + f"HVG selection contains no features. No features passed HVG candidate " + f"filters{where} (min_cells=6, max_cells=inf, log2 bounds min_mean=-inf, " + "max_mean=inf, min_var=-inf, max_var=inf). Widen the bounds or change the " + "blacklist." + ) + + +# Options + + +def test_hvg_options_take_a_flavor_default_min_cells() -> None: + assert ( + hvg_options( + min_cells=None, + top_n=5, + n_bins=20, + lowess_frac=0.2, + keep_bounds=False, + bin_strategy="fixed", + ).min_cells + is None + ) + + +_FLAVOR_DEFAULTS: dict[str, Any] = { + "flavor": "cytearc", + "max_cells": None, + "min_mean": -np.inf, + "max_mean": np.inf, + "min_var": -np.inf, + "max_var": np.inf, + "n_bins": 200, + "lowess_frac": 0.1, + "bin_strategy": "adaptive", + "span": 0.3, + "theta": 100.0, + "clip": None, +} + + +def test_flavor_options_are_checked_and_canonical() -> None: + options = hvg_flavor_options( + **{ + **_FLAVOR_DEFAULTS, + "flavor": "pearson_residuals", + "max_cells": np.int64(40), + "theta": 10, + "clip": np.float32(4), + } + ) + assert options == ("pearson_residuals", 40.0, 0.3, 10.0, 4.0) + assert [type(value) for value in options[1:]] == [float] * 4 + assert ( + hvg_flavor_options( + **{**_FLAVOR_DEFAULTS, "flavor": "seurat_v3", "span": 1} + ).span + == 1.0 + ) + + +@pytest.mark.parametrize( + ("overrides", "error", "message"), + [ + ({"flavor": "seurat"}, ValueError, "flavor must be one of"), + ({"flavor": None}, ValueError, "flavor must be one of"), + ({"max_cells": "10"}, TypeError, "max_cells must be a number"), + ({"max_cells": True}, TypeError, "max_cells must be a number"), + ({"max_cells": -1}, ValueError, "max_cells must be at least 0"), + ({"max_cells": np.nan}, ValueError, "max_cells must be at least 0"), + ({"min_mean": "low"}, TypeError, "min_mean must be a real number"), + ({"max_var": np.nan}, ValueError, "max_var must not be NaN"), + ({"span": 0}, ValueError, "span must be greater than 0"), + ({"theta": 0}, ValueError, "theta must be greater than 0"), + ({"theta": np.inf}, ValueError, "theta must be finite"), + ({"clip": -1}, ValueError, "clip must be at least 0"), + ({"flavor": "seurat_v3", "min_var": 1}, ValueError, "min_var apply only"), + ( + {"flavor": "pearson_residuals", "n_bins": 20, "bin_strategy": "fixed"}, + ValueError, + "n_bins, bin_strategy apply only to flavor='cytearc'", + ), + ({"span": 0.5}, ValueError, "span applies only"), + ({"flavor": "seurat_v3", "theta": 5}, ValueError, "theta and clip apply only"), + ({"clip": 3}, ValueError, "theta and clip apply only"), + ], +) +def test_flavor_options_reject_invalid_and_foreign_options( + overrides, error, message +) -> None: + with pytest.raises(error, match=message): + hvg_flavor_options(**{**_FLAVOR_DEFAULTS, **overrides}) + + +# Gene families + + +def test_default_blacklist_spares_ccn_proteins_and_matches_current_histones() -> None: + from cytearc.utils.arrays import regex_match_mask + + names = np.array( + [ + "CCN1", + "CCN2", + "Ccn6", + "CCND1", + "Ccnb1", + "CCNT1", + "H2AC6", + "H2BC12", + "H3C2", + "H4C3", + "H1-2", + "H1f4", + "H2AW", + "H3-4", + "H4-16", + "HIST1H1C", + "H3-3A", + "H2AZ1", + "H1-0", + "H2BC12L", + "H2AX", + ] + ) + excluded = regex_match_mask(names, DEFAULT_HVG_BLACKLIST) + + assert set(names[excluded]) == { + "CCND1", + "Ccnb1", + "CCNT1", + "H2AC6", + "H2BC12", + "H3C2", + "H4C3", + "H1-2", + "H1f4", + "H2AW", + "H3-4", + "H4-16", + "HIST1H1C", + } + + +# Streamed per-batch statistics over a store with several cell bands + +_N_CELLS, _N_GENES = 90, 48 +_BATCHES = np.array(["x", "y", "z"], dtype=object)[np.arange(_N_CELLS) % 3] +# The batch code of each cell, in the sorted order of the batch names. +_CODES = np.arange(_N_CELLS) % 3 + + +def _banded_counts() -> np.ndarray: + rng = np.random.default_rng(23) + success = np.linspace(0.05, 0.9, _N_GENES) + counts = rng.negative_binomial(2, success, size=(_N_CELLS, _N_GENES)) + # Never detected, and constant in every cell. + counts[:, 0] = 0 + counts[:, 1] = 3 + # An outlier above its seurat_v3 clip. + counts[13, 5] = 600 + # A bimodal gene detected in 88 of 90 cells: the earlier default cap of + # 90 - 20 = 70 cells excluded it, the 99.5% cap keeps it. + counts[:, 7] = np.where(np.arange(_N_CELLS) % 2 == 0, 1, 40) + counts[[10, 50], 7] = 0 + # Detected only in batch x, so the other batches expect no counts. + counts[:, 9] = np.where(_CODES == 0, counts[:, 9] + 1, 0) + return counts + + +_COUNTS = _banded_counts() +_NAMES = np.array([f"G{index}" for index in range(_N_GENES)], dtype=object) +_NAMES[3] = "MT-CO1" + + +@pytest.fixture(scope="module") +def banded_template(tmp_path_factory) -> Path: + path = tmp_path_factory.mktemp("hvg_flavors") / "store.zarr" + root = zarr.open_group(str(path), mode="w") + ids = np.array([f"c{index}" for index in range(_N_CELLS)]) + create_cell_data(root, None, ids=ids, names=ids) + counts = create_zarr_count_assay( + root, + "RNA", + None, + _N_CELLS, + feat_ids=np.array([f"id{index}" for index in range(_N_GENES)]), + feat_names=_NAMES, + dtype="uint16", + policy=CountMatrixPolicy(unitBytes=2000, chunkBytes=400), + ) + counts[:] = _COUNTS + finalize_test_counts(counts) + finalize_writer_counts_t(root, "RNA", None) + store = DataStore( + str(path), default_assay="RNA", min_features_per_cell=-1, nthreads=2 + ) + store.cells.insert("batch", _BATCHES, overwrite=True) + return path + + +@pytest.fixture +def banded(banded_template, tmp_path) -> DataStore: + shutil.copytree(banded_template, tmp_path / "store.zarr") + return DataStore( + str(tmp_path / "store.zarr"), + default_assay="RNA", + min_features_per_cell=-1, + nthreads=2, + ) + + +def _library_size(counts: np.ndarray) -> np.ndarray: + totals = counts.sum(axis=1, keepdims=True).astype(np.float64) + return 1000 * counts / np.where(totals == 0, 1, totals) + + +def _batch_fractions(counts: np.ndarray) -> np.ndarray: + return np.stack( + [ + counts[_CODES == code].sum(axis=0) / counts[_CODES == code].sum() + for code in range(3) + ] + ) + + +def test_grouped_statistics_match_dense_numpy(banded) -> None: + rna = banded.RNA + # Twenty cells per countsT band, so every batch spans several bands. + assert rna.rawDataT.chunks[1] == 20 + cells = np.arange(_N_CELLS) + features = np.arange(_N_GENES) + counts = _COUNTS.astype(np.float64) + for library_size in (False, True): + values = _library_size(counts) if library_size else counts + moments = grouped_moments( + rna, cells, _CODES, 3, features, library_size=library_size + ) + np.testing.assert_array_equal(moments.sizes, [30, 30, 30]) + for code in range(3): + block = values[_CODES == code] + np.testing.assert_allclose( + moments.total[code], block.sum(axis=0), rtol=1e-13 + ) + np.testing.assert_array_equal( + moments.detected[code], (block > 0).sum(axis=0) + ) + np.testing.assert_allclose( + moments.m2[code], + ((block - block.mean(axis=0)) ** 2).sum(axis=0), + rtol=1e-11, + atol=1e-9, + ) + np.testing.assert_allclose( + moments.maximum[code], block.max(axis=0), rtol=1e-15 + ) + + subset = np.array([2, 5, 7, 9, 31]) + means = np.stack( + [counts[_CODES == code][:, subset].mean(axis=0) for code in range(3)] + ) + clips = means + np.array([[1.0], [2.0], [3.0]]) + squares = grouped_clipped_squares( + rna, cells, _CODES, 3, subset, means=means, clips=clips + ) + fractions = _batch_fractions(counts) + totals = counts.sum(axis=1) + residual_clips = np.array([2.0, 3.0, 4.0]) + total, m2 = grouped_pearson_residual_moments( + rna, + cells, + _CODES, + 3, + subset, + totals=totals, + fractions=fractions[:, subset], + theta=50.0, + clips=residual_clips, + ) + for code in range(3): + block = counts[_CODES == code][:, subset] + np.testing.assert_allclose( + squares[code], + ((np.minimum(block, clips[code]) - means[code]) ** 2).sum(axis=0), + rtol=1e-12, + ) + residuals = pearson_residuals( + block, + totals[_CODES == code], + fractions[code, subset], + theta=50.0, + clip=residual_clips[code], + ) + np.testing.assert_allclose(total[code], residuals.sum(axis=0), atol=1e-12) + np.testing.assert_allclose( + m2[code], + ((residuals - residuals.mean(axis=0)) ** 2).sum(axis=0), + rtol=1e-12, + ) + # Batches y and z expect no counts of gene 9, so its residuals are 0. + assert total[1, 3] == total[2, 3] == m2[1, 3] == m2[2, 3] == 0 + + +def test_grouped_statistics_check_their_batches(banded) -> None: + rna = banded.RNA + empty = grouped_moments( + rna, np.arange(4), np.zeros(4), 1, np.empty(0), library_size=False + ) + assert empty.total.shape == (1, 0) + # Statistics of no features read no bands. + no_features = np.empty(0, dtype=np.int64) + squares = grouped_clipped_squares( + rna, + np.arange(4), + np.zeros(4), + 1, + no_features, + means=np.empty((1, 0)), + clips=np.empty((1, 0)), + ) + total, m2 = grouped_pearson_residual_moments( + rna, + np.arange(4), + np.zeros(4), + 1, + no_features, + totals=np.ones(4), + fractions=np.empty((1, 0)), + theta=100.0, + clips=np.ones(1), + ) + assert squares.shape == total.shape == m2.shape == (1, 0) + with pytest.raises(ValueError, match="one batch code per selected cell"): + grouped_moments( + rna, np.arange(4), np.zeros(3), 1, np.arange(2), library_size=False + ) + with pytest.raises(ValueError, match="Batch codes must lie from 0 to 1"): + grouped_moments( + rna, np.arange(4), np.full(4, 2), 2, np.arange(2), library_size=False + ) + with pytest.raises(ValueError, match="at least two selected cells"): + rna._batch_hvg_scores( + np.arange(3), + np.array([0, 0, 1]), + 2, + flavor="seurat_v3", + n_bins=200, + lowess_frac=0.1, + bin_strategy="adaptive", + span=0.3, + theta=100.0, + clip=None, + ) + + +# The flavors as features.hvgs computes them + + +def _reference_scores(flavor: str, counts: np.ndarray, **options: Any) -> np.ndarray: + """Score genes over the rows of ``counts`` from the published formulas.""" + counts = counts.astype(np.float64) + n = len(counts) + if flavor == "cytearc": + values = _library_size(counts) + average = values.mean(axis=0) + positive = average > 0 + scores = np.zeros(counts.shape[1]) + scores[positive] = fit_lowess( + average[positive], values.var(axis=0)[positive], 200, 0.1 + ) + return scores + if flavor == "seurat_v3": + mean = counts.mean(axis=0) + variance = counts.var(axis=0, ddof=1) + varying = variance > 0 + expected = 10 ** fit_loess(np.log10(mean[varying]), np.log10(variance[varying])) + z = np.minimum( + (counts[:, varying] - mean[varying]) / np.sqrt(expected), np.sqrt(n) + ) + scores = np.zeros(counts.shape[1]) + scores[varying] = (z**2).sum(axis=0) / (n - 1) + return scores + totals = counts.sum(axis=1) + residuals = pearson_residuals( + counts, + totals, + counts.sum(axis=0) / totals.sum(), + theta=options.get("theta", 100.0), + clip=options.get("clip") or np.sqrt(n), + ) + return residuals.var(axis=0) + + +def _top(scores: np.ndarray, candidates: np.ndarray, top_n: int) -> np.ndarray: + index = np.flatnonzero(candidates) + selected = np.zeros(len(scores), dtype=bool) + selected[index[np.lexsort((index, -scores[index]))][:top_n]] = True + return selected + + +@pytest.mark.parametrize( + ("flavor", "options", "flavor_parameters"), + [ + ("seurat_v3", {}, {"flavor": "seurat_v3", "span": 0.3}), + ( + "pearson_residuals", + {}, + {"flavor": "pearson_residuals", "theta": 100.0, "clip": None}, + ), + ( + "pearson_residuals", + {"theta": 20, "clip": 2}, + {"flavor": "pearson_residuals", "theta": 20.0, "clip": 2.0}, + ), + ], +) +def test_count_flavors_match_their_formulas( + banded, flavor, options, flavor_parameters +) -> None: + cells = banded.snapshot_cell_selection() + ref = banded.features.hvgs( + cells, flavor=flavor, top_n=10, blacklist="", show_plot=False, **options + ) + + status = inspect_artifact(banded.zw, ref) + group = banded.artifacts.load(ref) + scores = _reference_scores(flavor, _COUNTS, **options) + np.testing.assert_allclose(group["corrected_variance"][:], scores, rtol=1e-10) + np.testing.assert_array_equal( + group["values"][:], _top(scores, np.ones(_N_GENES, dtype=bool), 10) + ) + detected = (_COUNTS > 0).sum(axis=0) + np.testing.assert_array_equal(group["detected"][:], detected) + np.testing.assert_allclose( + group["mean_nonzero"][:], + np.divide( + _COUNTS.sum(axis=0), detected, out=np.zeros(_N_GENES), where=detected > 0 + ), + ) + assert status.parameters == { + **flavor_parameters, + "min_cells": 0, + "max_cells": {"special_float": "inf"}, + "top_n": 10, + "blacklist": "", + "keep_bounds": False, + } + assert set(status.inputs or {}) == { + "cell_selection", + "dataset_fingerprint", + "feature_snapshot", + } + assert banded.features.resolve("RNA", ref) == ref + + +@pytest.mark.parametrize("flavor", ["cytearc", "seurat_v3", "pearson_residuals"]) +def test_batches_select_by_count_then_median_rank(banded, flavor) -> None: + cells = banded.snapshot_cell_selection() + ref = banded.features.hvgs( + cells, flavor=flavor, batch="batch", top_n=8, show_plot=False + ) + + scores = np.stack( + [_reference_scores(flavor, _COUNTS[_CODES == code]) for code in range(3)] + ) + detected = (_COUNTS > 0).sum(axis=0) + # 90 cells: min_cells 3 and the 99.5% cap 89 for cytearc, none otherwise; + # the default blacklist removes MT-CO1. + lower, upper = (3, 89) if flavor == "cytearc" else (0, _N_CELLS) + candidates = (detected >= lower) & (detected <= upper) & (_NAMES != "MT-CO1") + expected = combine_batch_rankings( + scores, np.broadcast_to(candidates, scores.shape), top_n=8 + ) + group = banded.artifacts.load(ref) + np.testing.assert_array_equal(group["values"][:], expected.selected) + np.testing.assert_array_equal(group["batch_count"][:], expected.batch_count) + np.testing.assert_array_equal(group["median_batch_rank"][:], expected.median_rank) + # The adaptive trend of the cytearc flavor is a numerical optimization, so + # rounding differences of its inputs move its result by about 1e-8. + np.testing.assert_allclose( + group["corrected_variance"][:], + scores.mean(axis=0), + rtol=1e-7 if flavor == "cytearc" else 1e-10, + atol=1e-12, + ) + status = inspect_artifact(banded.zw, ref) + assert status.parameters["batch_column"] == "batch" + assert status.input_ref("batch").kind == "metadata_snapshot" + assert banded.features.resolve("RNA", ref) == ref + # The same request reuses the selection. + assert ( + banded.features.hvgs( + cells, flavor=flavor, batch="batch", top_n=8, show_plot=False + ) + == ref + ) + + +def test_batch_labels_may_come_from_a_label_artifact(banded) -> None: + cells = banded.snapshot_cell_selection() + labels = banded.snapshot_cluster_labels("batch", cell_selection=cells) + + from_artifact = banded.features.hvgs( + cells, flavor="seurat_v3", batch=labels, top_n=8, show_plot=False + ) + from_column = banded.features.hvgs( + cells, flavor="seurat_v3", batch="batch", top_n=8, show_plot=False + ) + + status = inspect_artifact(banded.zw, from_artifact) + assert status.input_ref("batch") == labels + assert "batch_column" not in (status.parameters or {}) + for name in ("values", "batch_count", "median_batch_rank", "corrected_variance"): + np.testing.assert_array_equal( + banded.artifacts.load(from_artifact)[name][:], + banded.artifacts.load(from_column)[name][:], + ) + assert banded.features.resolve("RNA", from_artifact) == from_artifact + + +def test_cytearc_batches_with_a_custom_normalizer_summarize_each_batch( + banded, +) -> None: + from cytearc.assay.normalization import norm_dummy + + banded.RNA.normMethod = norm_dummy + cells = banded.snapshot_cell_selection() + ref = banded.features.hvgs(cells, batch="batch", top_n=8, show_plot=False) + + raw = _COUNTS.astype(np.float64) + scores = [] + for code in range(3): + block = raw[_CODES == code] + average = block.mean(axis=0) + positive = average > 0 + score = np.zeros(_N_GENES) + score[positive] = fit_lowess( + average[positive], block.var(axis=0)[positive], 200, 0.1 + ) + scores.append(score) + np.testing.assert_allclose( + banded.artifacts.load(ref)["corrected_variance"][:], + np.mean(scores, axis=0), + # Streamed moments and NumPy's two-pass variance differ in the last + # bits, which the local fits of some releases amplify to a few parts + # per billion. + rtol=1e-8, + ) + + +def _artifact_refs(store: DataStore) -> set[Any]: + return set(store.artifacts.list()) | set(store.artifacts.list(scope="datastore")) + + +@pytest.mark.parametrize( + ("batch", "error", "message"), + [ + ("absent", KeyError, "Batch column 'absent' is not in the cell metadata"), + (3, TypeError, "batch must be a cell metadata column name or an ArtifactRef"), + ], +) +def test_invalid_batches_are_refused_before_writing( + banded, batch, error, message +) -> None: + cells = banded.snapshot_cell_selection() + before = _artifact_refs(banded) + with pytest.raises(error, match=message): + banded.features.hvgs(cells, batch=batch, show_plot=False) + with pytest.raises(ValueError, match="categorical cell labels"): + banded.features.hvgs(cells, batch=cells, show_plot=False) + assert _artifact_refs(banded) == before + + +def test_batches_need_labels_and_two_cells_each(banded) -> None: + cells = banded.snapshot_cell_selection() + missing = np.zeros(_N_CELLS, dtype=bool) + missing[[4, 8]] = True + insert_nullable_cell_column(banded, "partial", _BATCHES.astype(str), missing) + with pytest.raises(ValueError, match="miss 2 selected cells"): + banded.features.hvgs(cells, batch="partial", show_plot=False) + + singles = _BATCHES.copy() + singles[0] = "lone" + banded.cells.insert("singles", singles, overwrite=True) + with pytest.raises(ValueError, match=r"these have fewer: 'lone' \(1\)"): + banded.features.hvgs( + cells, flavor="pearson_residuals", batch="singles", show_plot=False + ) + + +def test_count_flavors_need_two_selected_cells(banded) -> None: + keep = np.zeros(_N_CELLS, dtype=bool) + keep[5] = True + banded.cells.insert("one", keep, overwrite=True) + with pytest.raises(ValueError, match="needs at least two selected cells"): + banded.features.hvgs( + banded.snapshot_cell_selection("one"), flavor="seurat_v3", show_plot=False + ) + + +def test_foreign_flavor_options_are_refused_before_writing(banded) -> None: + cells = banded.snapshot_cell_selection() + before = _artifact_refs(banded) + with pytest.raises(ValueError, match="min_var apply only to flavor='cytearc'"): + banded.features.hvgs(cells, flavor="seurat_v3", min_var=1, show_plot=False) + with pytest.raises(ValueError, match="span applies only"): + banded.features.hvgs(cells, span=0.5, show_plot=False) + assert _artifact_refs(banded) == before + + +def test_count_flavor_plots_its_stored_statistics_when_computed_and_reused( + banded, monkeypatch +) -> None: + import cytearc.plotting as plotting + + plotted: list[dict[str, Any]] = [] + + def record( + *, + mean_nonzero: Any, + corrected_variance: Any, + n_cells: Any, + selected: Any, + label_size: float = 12, + show: bool = True, + ) -> None: + plotted.append({key: value for key, value in locals().items()}) + + monkeypatch.setattr(plotting, "highly_variable_features", record) + cells = banded.snapshot_cell_selection() + first = banded.features.hvgs(cells, flavor="seurat_v3", top_n=5, label_size=9) + + def no_scores(*_args: Any, **_kwargs: Any) -> None: + pytest.fail("A reused selection must not score the genes again") + + monkeypatch.setattr(type(banded.RNA), "_batch_hvg_scores", no_scores) + again = banded.features.hvgs(cells, flavor="seurat_v3", top_n=5, label_size=9) + assert again == first + + group = banded.artifacts.load(first) + assert len(plotted) == 2 + for call in plotted: + assert call["show"] is True and call["label_size"] == 9 + for keyword, name in ( + ("mean_nonzero", "mean_nonzero"), + ("corrected_variance", "corrected_variance"), + ("n_cells", "detected"), + ("selected", "values"), + ): + np.testing.assert_array_equal(call[keyword], group[name][:]) + + +def _edit_provenance(store: DataStore, ref: Any, **changes: Any) -> None: + group = zarr.open_group(store.zw.store, mode="r+", path=artifact_path(ref)) + provenance = dict(group.attrs["provenance"]) + for key, value in changes.items(): + section = {**provenance[key], **value} + provenance[key] = { + name: item for name, item in section.items() if item is not None + } + group.attrs["provenance"] = provenance + + +@pytest.mark.parametrize( + ("changes", "message"), + [ + ({"parameters": {"flavor": "seurat"}}, "HVG flavor is incompatible"), + ({"parameters": {"flavor": "cytearc"}}, "HVG flavor is incompatible"), + ({"parameters": {"batch_column": None}}, "records no batch column"), + ({"inputs": {"dataset_fingerprint": "0" * 64}}, "current prepared dataset"), + ], +) +def test_count_flavor_provenance_is_validated(banded, changes, message) -> None: + cells = banded.snapshot_cell_selection() + ref = banded.features.hvgs( + cells, flavor="seurat_v3", batch="batch", top_n=5, show_plot=False + ) + _edit_provenance(banded, ref, **changes) + with pytest.raises(ArtifactResolutionError, match=message): + banded.features.resolve("RNA", ref) + + +def test_batch_label_artifacts_must_be_complete_when_resolved(banded) -> None: + cells = banded.snapshot_cell_selection() + labels = banded.snapshot_cluster_labels("batch", cell_selection=cells) + ref = banded.features.hvgs( + cells, flavor="seurat_v3", batch=labels, top_n=5, show_plot=False + ) + group = zarr.open_group(banded.zw.store, mode="r+", path=artifact_path(labels)) + group.attrs["complete"] = False + with pytest.raises(ArtifactResolutionError, match="batch labels are missing"): + banded.features.resolve("RNA", ref) + + +# Detection bounds of the cytearc flavor + + +def test_default_cap_keeps_genes_of_homogeneous_selections(banded) -> None: + cells = banded.snapshot_cell_selection() + ref = banded.features.hvgs(cells, top_n=5, show_plot=False) + + parameters = inspect_artifact(banded.zw, ref).parameters + assert (parameters["min_cells"], parameters["max_cells"]) == (3, 90) + # Gene 7, detected in 88 of 90 cells, is among the most variable genes; + # the earlier defaults excluded it. + assert banded.artifacts.load(ref)["values"][:][7] + earlier = banded.features.hvgs( + cells, top_n=5, min_cells=20, max_cells=70, show_plot=False + ) + assert not banded.artifacts.load(earlier)["values"][:][7] + + +def test_small_selections_keep_a_band_of_detection_counts(datastore_ephemeral) -> None: + store = datastore_ephemeral + active = np.flatnonzero(np.asarray(store.cells.fetch_all("I"), dtype=bool)) + keep = np.zeros(store.cells.N, dtype=bool) + keep[active[:41]] = True + store.cells.insert("small", keep, overwrite=True) + cells = store.snapshot_cell_selection("small") + + ref = store.features.hvgs(cells, top_n=1000, show_plot=False) + + parameters = inspect_artifact(store.zw, ref).parameters + assert (parameters["min_cells"], parameters["max_cells"]) == (3, 41) + counts = np.asarray(store.RNA.rawData[active[:41], :].compute()) + detected = (counts > 0).sum(axis=0) + selected = np.asarray(store.artifacts.load(ref)["values"][:], dtype=bool) + # The earlier bounds, 20 and 41 - 20, kept only genes detected in exactly + # 20 of the 41 cells. + assert selected.sum() == 1000 + assert detected[selected].min() == 3 + assert detected[selected].max() <= 40 + assert np.unique(detected[selected]).size > 10 + + +# Pearson residual normalization + + +@pytest.mark.parametrize("renormalize_subset", [False, True]) +def test_pearson_residual_normalizer_matches_numpy(banded, renormalize_subset) -> None: + banded.RNA.normMethod = norm_pearson_residuals + cells = banded.snapshot_cell_selection() + subset = np.array([2, 5, 7, 9, 31]) + features = banded.features.snapshot(feature_indexes=subset) + + normalized = banded.features.normalize( + cells, features, renormalize_subset=renormalize_subset + ) + + counts = _COUNTS.astype(np.float64) + totals = counts[:, subset].sum(axis=1) if renormalize_subset else counts.sum(axis=1) + expected = pearson_residuals( + counts[:, subset], + totals, + counts[:, subset].sum(axis=0) / totals.sum(), + theta=100.0, + clip=np.sqrt(_N_CELLS), + ) + np.testing.assert_allclose( + banded.artifacts.load(normalized)["data"][:], expected, rtol=1e-6, atol=1e-6 + ) + parameters = inspect_artifact(banded.zw, normalized).parameters + assert parameters["normalization_method"] == { + "external_hook": True, + "identity": "cytearc.assay.pearson_residuals:theta=100.0:clip=sqrt-n", + } + assert (parameters["log_transform"], parameters["renormalize_subset"]) == ( + False, + renormalize_subset, + ) + reduction = banded.reduction.pca( + normalized, dims=2, feat_scaling=False, show_elbow_plot=False + ) + assert banded.artifacts.load(reduction)["data"].shape == (_N_CELLS, 2) + with pytest.raises(ValueError, match="does not support log_transform=True"): + banded.features.normalize(cells, features, log_transform=True) + + +def test_pearson_residual_normalizer_options(banded) -> None: + normalizer = PearsonResidualNormalizer(theta=5, clip=1.5) + assert repr(normalizer) == "PearsonResidualNormalizer(theta=5.0, clip=1.5)" + assert normalizer.artifact_identity == ( + "cytearc.assay.pearson_residuals:theta=5.0:clip=1.5" + ) + banded.RNA.normMethod = normalizer + values = np.asarray(banded.RNA.normed(feat_idx=np.array([5, 7])).compute()) + counts = _COUNTS.astype(np.float64) + totals = counts.sum(axis=1) + np.testing.assert_allclose( + values, + pearson_residuals( + counts[:, [5, 7]], + totals, + counts[:, [5, 7]].sum(axis=0) / totals.sum(), + theta=5.0, + clip=1.5, + ), + ) + assert np.abs(values).max() == 1.5 + for arguments, error, message in ( + ({"theta": 0}, ValueError, "theta must be greater than 0"), + ({"theta": "5"}, TypeError, "theta must be a real number"), + ({"clip": -1}, ValueError, "clip must be at least 0"), + ): + with pytest.raises(error, match=message): + PearsonResidualNormalizer(**arguments) + + +def test_pearson_residuals_need_totals_and_follow_the_flag_policy(banded) -> None: + counts = np.array([[0, 2], [3, 1], [0, 0]]) + totals = counts.sum(axis=1) + np.testing.assert_allclose( + norm_pearson_residuals(SimpleNamespace(scalar=totals), counts), + pearson_residuals( + counts, totals, counts.sum(axis=0) / 6, theta=100.0, clip=np.sqrt(3) + ), + ) + np.testing.assert_array_equal( + norm_pearson_residuals(SimpleNamespace(scalar=np.zeros(3)), np.zeros((3, 2))), + np.zeros((3, 2)), + ) + with pytest.raises(ValueError, match="only an RNA assay's normed provides"): + norm_pearson_residuals(SimpleNamespace(), counts) + + banded.RNA.normMethod = norm_pearson_residuals + assert applicable_normalization_flags(banded.RNA) == {"renormalize_subset"} + stub = SimpleNamespace(normMethod=norm_pearson_residuals) + assert Assay._normalization_flags(stub) == frozenset() # type: ignore[arg-type] + assert ATACassay._normalization_flags(stub) == frozenset() # type: ignore[arg-type] + # A custom ATAC normalizer still reads the term frequencies. + custom = SimpleNamespace(normMethod=lambda assay, counts: counts) + assert ATACassay._normalization_flags(custom) == { # type: ignore[arg-type] + "renormalize_subset" + } + + +# Operation revision of select_hvgs + +_BLACKLIST_BEFORE_1_3 = ( + "^MT-|^RPS|^RPL|^MRPS|^MRPL|^CCN|^HLA-|^H2-|^HIST|" + "^XIST$|^DDX3Y$|^USP9Y$|^EIF1AY$|^KDM5D$|^SRY$|^ZFY$|^UTY$|^TMSB4Y$|^NLGN4Y$" +) + + +def test_hvg_revision_selects_variance_bounds_and_earlier_defaults() -> None: + (revision,) = OPERATION_REVISIONS["select_hvgs"] + applies = revision.applies + assert (revision.revision, revision.release) == (2, "1.3.0") + assert applies is not None + unbounded = {"special_float": "-inf"} + # The parameters that 1.2 recorded for its defaults over 892 cells. + earlier = { + "min_cells": 20, + "max_cells": 872, + "top_n": 2000, + "min_var": unbounded, + "max_var": {"special_float": "inf"}, + "min_mean": unbounded, + "max_mean": {"special_float": "inf"}, + "n_bins": 200, + "lowess_frac": 0.1, + "blacklist": _BLACKLIST_BEFORE_1_3, + "keep_bounds": False, + "bin_strategy": "adaptive", + "variance_estimator": "regularized_local_quantile", + "variance_quantile": 0.25, + } + for parameters, expected in ( + (earlier, True), + ({"min_var": 1.0, "max_var": {"special_float": "inf"}}, True), + ({"min_var": unbounded, "max_var": 3}, True), + ({"min_var": unbounded, "max_var": {"special_float": "inf"}}, False), + ({"min_var": True, "max_var": "2"}, False), + # The earlier default bounds with any blacklist, such as a species one. + ({**earlier, "blacklist": ""}, True), + ({**earlier, "blacklist": DEFAULT_HVG_BLACKLIST}, True), + # The earlier default blacklist with other bounds. + ({**earlier, "min_cells": 9}, True), + ({**earlier, "min_cells": 9, "blacklist": DEFAULT_HVG_BLACKLIST}, False), + ({"min_cells": True, "blacklist": ["^MT-"]}, False), + ({}, False), + ): + assert applies("feature_selection", parameters, {}) is expected + + +def test_hvg_selection_records_its_revision_and_recomputes_earlier_ones( + banded, +) -> None: + cells = banded.snapshot_cell_selection() + options = {"min_cells": 0, "max_cells": np.inf, "top_n": 5, "blacklist": ""} + bounded = banded.features.hvgs(cells, min_var=-1, show_plot=False, **options) + assert inspect_artifact(banded.zw, bounded).revision == 2 + + # A selection of the earlier code records no revision. + group = zarr.open_group(banded.zw.store, mode="r+", path=artifact_path(bounded)) + provenance = dict(group.attrs["provenance"]) + provenance.pop("revision") + group.attrs["provenance"] = provenance + recomputed = banded.features.hvgs(cells, min_var=-1, show_plot=False, **options) + assert recomputed != bounded + earlier = inspect_artifact(banded.zw, bounded) + assert earlier.revision == 1 and not earlier.is_current + assert [entry.revision for entry in earlier.superseded_by] == [2] + + # A selection that the revision leaves out is reused. + unbounded = banded.features.hvgs(cells, show_plot=False, **options) + assert inspect_artifact(banded.zw, unbounded).revision == 1 + assert banded.features.hvgs(cells, show_plot=False, **options) == unbounded + + # The earlier defaults, requested explicitly, record the revision too. + defaults = banded.features.hvgs( + cells, + min_cells=20, + max_cells=70, + top_n=5, + blacklist=_BLACKLIST_BEFORE_1_3, + show_plot=False, + ) + assert inspect_artifact(banded.zw, defaults).revision == 2 + # So do the earlier default bounds with another blacklist. + bounds = banded.features.hvgs( + cells, min_cells=20, max_cells=70, top_n=5, blacklist="", show_plot=False + ) + assert inspect_artifact(banded.zw, bounds).revision == 2 + + +# Pipeline settings + + +def test_pipeline_hvg_settings_cover_the_flavors(banded) -> None: + from cytearc.datastore._pipeline_recipe import resolve_pipeline_recipe + + for settings in ( + {"flavor": "pearson_residuals", "batch": "batch", "theta": 50, "clip": 3.0}, + {"flavor": "seurat_v3", "span": 0.5}, + ): + recipe = resolve_pipeline_recipe( + banded, + assay=None, + label=None, + cell_key="I", + filtering=False, + harmony_batch_columns=None, + hvg_count=1000, + pca_dims=21, + neighbors_k=11, + umap=True, + leiden=True, + cell_cycle=True, + paris=True, + doublets=True, + markers=True, + snapshot_columns=(), + params={"hvg": settings}, + ) + assert recipe.params_for("hvg") == settings + for hvg, error, message in ( + ({"flavor": "bogus"}, ValueError, "flavor must be one of"), + ({"span": 0.5}, ValueError, "span applies only"), + ({"batch": 3}, TypeError, r"params\['hvg'\]\['batch'\] must be a cell"), + ({"batch": "absent"}, KeyError, "HVG batch column 'absent' was not found"), + ): + with pytest.raises(error, match=message): + banded.pipeline.run(params={"hvg": hvg}) + + +# Agreement with scanpy 1.12.4 and scikit-misc 0.5.3 + + +def _golden() -> dict[str, Any]: + return json.loads(_GOLDEN.read_text()) + + +@pytest.fixture(scope="module") +def golden_store(datastore_zarr_root, tmp_path_factory) -> DataStore: + location = tmp_path_factory.mktemp("hvg_golden") / "data.zarr" + shutil.copytree(datastore_zarr_root, location) + store = DataStore(str(location), default_assay="RNA", nthreads=2) + active = np.flatnonzero(np.asarray(store.cells.fetch_all("I"), dtype=bool)) + labels = np.full(store.cells.N, "none", dtype=object) + labels[active] = np.where(np.arange(len(active)) < len(active) // 2, "a", "b") + store.cells.insert("golden_batch", labels.astype(str), overwrite=True) + return store + + +def _golden_run(store: DataStore, flavor: str, **options: Any) -> dict[str, np.ndarray]: + ref = store.features.hvgs( + store.snapshot_cell_selection(), + flavor=flavor, + top_n=2000, + blacklist="", + show_plot=False, + **options, + ) + group = store.artifacts.load(ref) + return {name: np.asarray(group[name][:]) for name in group.array_keys()} + + +def test_golden_fixture_pins_its_inputs(golden_store) -> None: + golden = _golden() + provenance = golden["provenance"] + assert (provenance["package"], provenance["packageVersion"]) == ( + "scanpy", + "1.12.4", + ) + assert provenance["scikitMiscVersion"] == "0.5.3" + assert (provenance["nCells"], provenance["nGenes"], provenance["topN"]) == ( + 892, + 36601, + 2000, + ) + active = np.flatnonzero(np.asarray(golden_store.cells.fetch_all("I"), dtype=bool)) + matrix = csr_matrix( + np.asarray(golden_store.RNA.rawData[active, :].compute()).astype(np.int64) + ) + digest = hashlib.sha256() + for values in (matrix.indptr, matrix.indices, matrix.data): + digest.update(np.ascontiguousarray(values, dtype=" tuple[np.ndarray, np.ndarray, float]: + expected = np.zeros(len(ours["values"]), dtype=bool) + expected[reference["selected"]] = True + index = np.asarray(reference["indices"]) + rho = spearmanr(ours["corrected_variance"][index], reference["scores"]).statistic + return expected, np.flatnonzero(expected ^ ours["values"]), float(rho) + + +def test_seurat_v3_matches_scanpy(golden_store) -> None: + reference = _golden()["scanpy"]["seurat_v3"] + ours = _golden_run(golden_store, "seurat_v3") + + expected, differing, rho = _selection_agreement(ours, reference) + index = np.asarray(reference["indices"]) + # The trend matches scikit-misc's interpolated LOESS to within 1e-12 on the + # log10 scale, so the scores agree to the 10 digits the fixture keeps. + np.testing.assert_allclose( + ours["corrected_variance"][index], reference["scores"], rtol=1e-9 + ) + assert rho > 0.99999 + # Genes tied at the last selected score are ordered by index here and in + # sort order by scanpy, so only such ties may differ. + boundary = np.sort(ours["corrected_variance"][expected])[0] + np.testing.assert_allclose( + ours["corrected_variance"][differing], boundary, rtol=1e-9 + ) + assert len(differing) <= 4 + + +def test_pearson_residuals_match_scanpy(golden_store) -> None: + reference = _golden()["scanpy"]["pearson_residuals"] + ours = _golden_run(golden_store, "pearson_residuals") + + _, differing, rho = _selection_agreement(ours, reference) + index = np.asarray(reference["indices"]) + np.testing.assert_allclose( + ours["corrected_variance"][index], reference["scores"], rtol=1e-9 + ) + assert rho > 0.999999 + assert len(differing) == 0 + + +def test_batch_pearson_residuals_match_scanpy(golden_store) -> None: + # scanpy clips every batch at the square root of the first batch's cell + # count, so both use an explicit clip. + reference = _golden()["scanpy"]["pearson_residuals_batch"] + ours = _golden_run( + golden_store, "pearson_residuals", batch="golden_batch", clip=20.0 + ) + + _, differing, _ = _selection_agreement(ours, reference) + index = np.asarray(reference["indices"]) + np.testing.assert_allclose( + ours["corrected_variance"][index], reference["scores"], rtol=1e-9 + ) + assert len(differing) == 0 + selected = np.asarray(reference["selected"]) + np.testing.assert_array_equal( + ours["batch_count"][selected], reference["batchCount"] + ) + # scanpy ranks tied scores in sort order, so a median rank may differ by 1. + difference = ours["median_batch_rank"][selected] - np.asarray( + reference["medianRank"] + ) + assert np.abs(difference).max() <= 1 + + +def test_batch_seurat_v3_matches_scanpy_seurat_v3_paper(golden_store) -> None: + reference = _golden()["scanpy"]["seurat_v3_paper_batch"] + ours = _golden_run(golden_store, "seurat_v3", batch="golden_batch") + + _, differing, rho = _selection_agreement(ours, reference) + index = np.asarray(reference["indices"]) + # scanpy averages each batch's counts with Welford updates, whose last bits + # break ties between genes with equal means. The interpolated trend places + # its vertices between tied means, so scanpy's batch scores differ from + # those of the exact means used here by up to about 1e-3. + np.testing.assert_allclose( + ours["corrected_variance"][index], reference["scores"], rtol=1e-3 + ) + assert rho > 0.99999 + assert len(differing) <= 12 + + +def test_corrected_variance_of_selections_without_counts_is_zero() -> None: + from cytearc.assay.rna import _corrected_variance + + for n_selected in (0, 4): + np.testing.assert_array_equal( + _corrected_variance( + np.zeros(3), + np.zeros(3), + n_selected, + n_bins=200, + lowess_frac=0.1, + bin_strategy="adaptive", + ), + np.zeros(3), + ) + + +def test_pearson_residuals_refuse_negative_cell_totals(tmp_path) -> None: + from tests.storage_helpers import write_count_store + + counts = _COUNTS[:12, :6].astype(np.float64) + counts[2] = 0 + counts[2, :2] = [-3.0, 1.0] + write_count_store(str(tmp_path / "store.zarr"), {"RNA": counts}, "float64") + store = DataStore( + str(tmp_path / "store.zarr"), default_assay="RNA", min_features_per_cell=-1 + ) + with pytest.raises(ValueError, match="Pearson residuals require finite"): + store.features.hvgs( + store.snapshot_cell_selection(), + flavor="pearson_residuals", + show_plot=False, + ) + store.RNA.normMethod = norm_pearson_residuals + with pytest.raises(ValueError, match="negative or non-finite totals"): + store.RNA.normed() + + +def test_batch_selection_filters_each_batch_before_ranking() -> None: + from cytearc.features.variability import select_batch_highly_variable_features + + ranking = select_batch_highly_variable_features( + np.array([[4.0, 3.0, 2.0, 1.0], [1.0, 2.0, 3.0, 4.0]]), + np.array([[1.0, 1.0, 8.0, 1.0], [1.0, 1.0, 1.0, 1.0]]), + np.array([5, 5, 5, 1]), + np.array(["a", "MT-b", "c", "d"]), + min_cells=2, + max_cells=np.inf, + top_n=1, + min_var=-np.inf, + max_var=np.inf, + min_mean=-np.inf, + max_mean=2, + blacklist="^MT-", + keep_bounds=False, + ) + + # MT-b is blacklisted and d detected in one cell. Batch 0 drops c, whose + # mean over detected cells exceeds 2**2, so a leads it and c leads batch + # 1; tied in count and median rank, the lower index wins. + np.testing.assert_array_equal(ranking.batch_count, [1, 0, 1, 0]) + np.testing.assert_array_equal(ranking.median_rank, [0, np.nan, 0, np.nan]) + np.testing.assert_array_equal(ranking.selected, [True, False, False, False]) diff --git a/tests/test_hvg_kernel_parity.py b/tests/test_hvg_kernel_parity.py new file mode 100644 index 0000000..acede31 --- /dev/null +++ b/tests/test_hvg_kernel_parity.py @@ -0,0 +1,270 @@ +"""The Numba kernels of HVG flavors, compiled and as Python, against NumPy references. + +The flavor tests exercise these kernels compiled; these tests also run each +one's ``py_func`` on inputs that reach every branch, and check both against +direct NumPy statements of what the kernels' docstrings promise. +""" + +import numpy as np +import pytest + +from cytearc.assay.hvg_statistics import ( + _band_clipped_squares_kernel, + _band_moments_kernel, + _band_pearson_kernel, +) +from cytearc.features.variability import _fit_loess_points + +_KERNELS = ["jit", "python"] + + +def _kernel(kernel, mode: str): + return kernel if mode == "jit" else kernel.py_func + + +def _band() -> dict[str, np.ndarray]: + """Counts of 3 feature rows for 7 cells of 2 batches, with zeros and a gap. + + Row 2 is never read, column 6 of the values is not a selected cell, and + batch 1 has a cell without any count in row 0. + """ + values = np.array( + [ + [0, 3, 0, 5, 1, 0, 9], + [2, 0, 0, 4, 0, 7, 9], + [9, 9, 9, 9, 9, 9, 9], + ], + dtype=np.uint16, + ) + return { + "values": values, + "value_rows": np.array([1, 0], dtype=np.int64), + "local": np.array([0, 1, 2, 3, 4, 5], dtype=np.int64), + "groups": np.array([0, 0, 1, 1, 0, 1], dtype=np.int64), + # Batch sizes include selected cells outside this band of cells. + "sizes": np.array([4, 5], dtype=np.int64), + } + + +def _reference_columns(band: dict[str, np.ndarray]) -> list[np.ndarray]: + """Each written column's counts of the band's selected cells.""" + return [ + band["values"][row, band["local"]].astype(np.float64) + for row in band["value_rows"] + ] + + +@pytest.mark.parametrize("mode", _KERNELS) +def test_band_moments_kernel_matches_moments_with_implicit_zeros(mode) -> None: + band = _band() + scale = 1000.0 + inverse_totals = np.array([0.5, 0.25, 1.0, 0.125, 0.2, 0.1]) + n_groups, n_columns = 2, 2 + total = np.zeros((n_groups, n_columns)) + m2 = np.zeros((n_groups, n_columns)) + detected = np.zeros((n_groups, n_columns), dtype=np.int64) + # A maximum carried from an earlier band stays when no value exceeds it. + maximum = np.array([[0.0, 0.0], [10_000.0, 0.0]]) + means = np.zeros(n_groups) + counts = np.zeros(n_groups, dtype=np.int64) + + _kernel(_band_moments_kernel, mode)( + band["values"], + band["value_rows"], + band["local"], + band["groups"], + scale, + inverse_totals, + band["sizes"], + total, + m2, + detected, + maximum, + means, + counts, + ) + + for k, column in enumerate(_reference_columns(band)): + for group in range(n_groups): + cells = band["groups"] == group + values = scale * column[cells] * inverse_totals[cells] + stored = values[column[cells] != 0] + padded = np.concatenate( + [stored, np.zeros(band["sizes"][group] - stored.size)] + ) + assert total[group, k] == pytest.approx(stored.sum(), rel=1e-12) + assert detected[group, k] == np.count_nonzero(stored > 0) + assert m2[group, k] == pytest.approx( + ((padded - padded.mean()) ** 2).sum(), rel=1e-12 + ) + expected_maximum = max( + stored.max(initial=0.0), 10_000.0 if (group, k) == (1, 0) else 0.0 + ) + assert maximum[group, k] == expected_maximum + + +@pytest.mark.parametrize("mode", _KERNELS) +def test_band_clipped_squares_kernel_matches_clipped_deviations(mode) -> None: + band = _band() + means = np.array([[1.5, 0.5], [2.0, 1.0]]) + # A clip below some counts and one above every count. + clips = np.array([[3.0, 2.0], [100.0, 4.0]]) + out = np.zeros((2, 2)) + stored = np.zeros(2, dtype=np.int64) + + _kernel(_band_clipped_squares_kernel, mode)( + band["values"], + band["value_rows"], + band["local"], + band["groups"], + means, + clips, + band["sizes"], + out, + stored, + ) + + for k, column in enumerate(_reference_columns(band)): + for group in range(2): + counts = column[band["groups"] == group] + counts = counts[counts != 0] + clipped = np.minimum(counts, clips[group, k]) + padded = np.concatenate( + [clipped, np.zeros(band["sizes"][group] - counts.size)] + ) + assert out[group, k] == pytest.approx( + ((padded - means[group, k]) ** 2).sum(), rel=1e-12 + ) + + +@pytest.mark.parametrize("mode", _KERNELS) +def test_band_pearson_kernel_matches_clipped_residual_moments(mode) -> None: + band = _band() + totals = np.array([10.0, 4.0, 0.0, 12.0, 6.0, 8.0]) + # Batch 1 has no counts of the second written column: residuals there are 0. + fractions = np.array([[0.2, 0.3], [0.25, 0.0]]) + theta = 100.0 + clips = np.array([1.0, 50.0]) + total = np.zeros((2, 2)) + m2 = np.zeros((2, 2)) + means = np.zeros(2) + counts = np.zeros(2, dtype=np.int64) + + _kernel(_band_pearson_kernel, mode)( + band["values"], + band["value_rows"], + band["local"], + band["groups"], + totals, + fractions, + theta, + clips, + total, + m2, + means, + counts, + ) + + for k, column in enumerate(_reference_columns(band)): + for group in range(2): + cells = band["groups"] == group + expected_counts = totals[cells] * fractions[group, k] + residuals = np.zeros(expected_counts.shape) + positive = expected_counts > 0 + mu = expected_counts[positive] + residuals[positive] = np.clip( + (column[cells][positive] - mu) / np.sqrt(mu + mu * mu / theta), + -clips[group], + clips[group], + ) + assert total[group, k] == pytest.approx(residuals.sum(), abs=1e-12) + assert m2[group, k] == pytest.approx( + ((residuals - residuals.mean()) ** 2).sum(), abs=1e-12 + ) + # The clip of batch 0 binds: an unclipped residual of the band exceeds it. + column = _reference_columns(band)[1] + cells = band["groups"] == 0 + mu = totals[cells] * fractions[0, 1] + unclipped = (column[cells] - mu) / np.sqrt(mu + mu * mu / theta) + assert np.abs(unclipped).max() > clips[0] + + +def _reference_loess_point( + x: np.ndarray, y: np.ndarray, q: int, degree: int, x0: float +) -> tuple[float, float]: + """Weighted least squares of degree ``degree`` over the q nearest points.""" + order = np.argsort(np.abs(x - x0), kind="stable")[:q] + h = np.abs(x[order] - x0).max() + if h <= 0.0: + tied = x == x0 + return float(y[tied].mean()), 0.0 + ratio = np.abs(x - x0) / h + weights = np.where(ratio < 1.0, (1.0 - ratio**3) ** 3, 0.0) + window = np.zeros(x.shape, dtype=bool) + window[order] = True + weights = np.where(window, weights, 0.0) + if weights.sum() <= 0.0: + return float(y[window].mean()), 0.0 + u = (x - x0) / h + used = weights > 0 + distinct = np.unique(u[used]).size + fit_degree = min(degree, distinct - 1) + design = np.vander(u[used], fit_degree + 1, increasing=True) + sqrt_w = np.sqrt(weights[used]) + coefficients, *_ = np.linalg.lstsq( + design * sqrt_w[:, None], y[used] * sqrt_w, rcond=None + ) + slope = coefficients[1] / h if fit_degree >= 1 else 0.0 + return float(coefficients[0]), float(slope) + + +@pytest.mark.parametrize("mode", _KERNELS) +@pytest.mark.parametrize("degree", [0, 1, 2]) +def test_loess_point_kernel_matches_weighted_least_squares(mode, degree) -> None: + rng = np.random.default_rng(11) + x = np.sort(rng.normal(size=40)) + y = 1.0 + 2.0 * x - 0.5 * x**2 + rng.normal(scale=0.1, size=40) + # Repeated points reuse the previous fit; the points move the window right. + points = np.array([x[0], x[3], x[3], 0.0, x[20], x[-1]]) + values = np.empty(points.shape) + slopes = np.empty(points.shape) + + _kernel(_fit_loess_points, mode)(x, y, 12, degree, points, values, slopes) + + for i, point in enumerate(points): + value, slope = _reference_loess_point(x, y, 12, degree, point) + assert values[i] == pytest.approx(value, rel=1e-9, abs=1e-12) + assert slopes[i] == pytest.approx(slope, rel=1e-9, abs=1e-12) + + +@pytest.mark.parametrize("mode", _KERNELS) +def test_loess_point_kernel_handles_ties_and_degenerate_windows(mode) -> None: + kernel = _kernel(_fit_loess_points, mode) + + # Every point of the window sits at x0: the fit is the mean of the tie. + x = np.array([0.0, 1.0, 1.0, 1.0, 1.0, 5.0]) + y = np.array([3.0, 1.0, 2.0, 3.0, 6.0, 9.0]) + values, slopes = np.empty(1), np.empty(1) + kernel(x, y, 3, 2, np.array([1.0]), values, slopes) + assert values[0] == pytest.approx(3.0) and slopes[0] == 0.0 + + # A vertex midway between two points: both sit at distance h and weigh 0. + x = np.array([0.0, 2.0]) + y = np.array([1.0, 5.0]) + kernel(x, y, 2, 2, np.array([1.0]), values, slopes) + assert values[0] == pytest.approx(3.0) and slopes[0] == 0.0 + + # Weighted points of one distinct value cannot fit a slope: the degree + # lowers to a weighted mean, with the far point weighing zero. + x = np.array([0.0, 0.0, 0.0, 3.0]) + y = np.array([2.0, 4.0, 6.0, 100.0]) + kernel(x, y, 4, 2, np.array([0.0]), values, slopes) + assert values[0] == pytest.approx(4.0) and slopes[0] == 0.0 + + # Two distinct weighted values fit a line, and the quadratic term vanishes. + x = np.array([0.0, 0.0, 1.0, 1.0, 3.0]) + y = np.array([1.0, 1.0, 3.0, 3.0, 50.0]) + kernel(x, y, 5, 2, np.array([0.0]), values, slopes) + value, slope = _reference_loess_point(x, y, 5, 2, 0.0) + assert values[0] == pytest.approx(value, rel=1e-9) + assert slopes[0] == pytest.approx(slope, rel=1e-9) diff --git a/tests/test_hvg_plot_dependency.py b/tests/test_hvg_plot_dependency.py new file mode 100644 index 0000000..63d0de6 --- /dev/null +++ b/tests/test_hvg_plot_dependency.py @@ -0,0 +1,80 @@ +"""HVG selection on an installation without matplotlib, an optional dependency.""" + +import sys +import warnings +from pathlib import Path + +import numpy as np +import pytest + +from cytearc import DataStore +from cytearc.datastore._operations.features import _matplotlib_available +from tests.storage_helpers import write_count_store + +_MISSING = ( + "features.hvgs draws its mean-variance plot with matplotlib, which is not " + "installed, so it returns the selection without the plot; install it with " + "pip install 'cytearc[extra]', or pass show_plot=False" +) + + +def _store(tmp_path: Path) -> DataStore: + rng = np.random.default_rng(7) + counts = rng.poisson(rng.gamma(1.0, 3.0, size=24), size=(40, 24)) + zarr_loc = tmp_path / "store.zarr" + write_count_store(str(zarr_loc), {"RNA": counts}, "uint16") + return DataStore( + str(zarr_loc), default_assay="RNA", min_features_per_cell=0, nthreads=1 + ) + + +def _hvgs(store: DataStore, **options): + cells = store.snapshot_cell_selection() + settings = {"min_cells": 1, "top_n": 8, "n_bins": 4} + return store.features.hvgs(cells, **(settings | options)) + + +@pytest.fixture +def without_matplotlib(monkeypatch): + # A None entry in sys.modules makes `import matplotlib` raise ImportError. + for name in [name for name in sys.modules if name.split(".")[0] == "matplotlib"]: + monkeypatch.delitem(sys.modules, name) + monkeypatch.setitem(sys.modules, "matplotlib", None) + + +def test_matplotlib_availability_follows_the_import(): + assert _matplotlib_available() is True + + +def test_matplotlib_availability_is_false_when_its_import_fails(without_matplotlib): + assert _matplotlib_available() is False + + +def test_hvgs_without_matplotlib_warn_and_return_the_selection( + tmp_path, without_matplotlib +): + store = _store(tmp_path) + + with pytest.warns(UserWarning) as caught: + ref = _hvgs(store) + assert [str(warning.message) for warning in caught] == [_MISSING] + # The warning points at the caller, and the selection was saved once. + assert caught[0].filename == __file__ + assert ( + store.artifacts.list(kind="feature_selection", from_assay="RNA").count(ref) == 1 + ) + + # A second call reuses the saved selection instead of failing again. + with pytest.warns(UserWarning, match="returns the selection without the plot"): + assert _hvgs(store) == ref + + +def test_hvgs_without_matplotlib_and_without_a_plot_do_not_warn( + tmp_path, without_matplotlib +): + store = _store(tmp_path) + + with warnings.catch_warnings(): + warnings.simplefilter("error") + ref = _hvgs(store, show_plot=False) + assert ref.kind == "feature_selection" diff --git a/tests/test_hvg_selection.py b/tests/test_hvg_selection.py index b9eeacf..50f6262 100644 --- a/tests/test_hvg_selection.py +++ b/tests/test_hvg_selection.py @@ -315,9 +315,9 @@ def test_select_hvgs_persists_effective_default_max_cells( ) -> None: store = hvg_store n_selected = int(np.asarray(store.cells.fetch_all("I"), dtype=bool).sum()) - expected: int | float = n_selected - 20 - if expected <= 0: - expected = np.inf + # Genes detected in more than 99.5% of the selected cells are excluded, and + # the recorded cutoff is exclusive. + expected = n_selected * 199 // 200 + 1 cell_selection = store.snapshot_cell_selection() implicit = store.features.hvgs( diff --git a/tests/test_pipeline_params.py b/tests/test_pipeline_params.py index 0877f57..a90332c 100644 --- a/tests/test_pipeline_params.py +++ b/tests/test_pipeline_params.py @@ -326,10 +326,12 @@ def test_params_reject_invalid_sections_before_writing( assert _run_ids(store) == before -# Pin CyteArc HVG parameter identities for max_cells=None (selected cells - 20) -# and max_cells=np.inf (no cutoff) on this fixture with top_n=50. -_AUTO_DIGEST = "a7b0106e03dbbf7441c6b96f85b235fafcae114a2bae35120336572e35ee4e2f" -_NO_CUTOFF_DIGEST = "ec064cd0cde2532a8a0ee73070e1f3844b8042e143db85b758fced6ad818ba8c" +# Pin CyteArc HVG parameter identities for max_cells=None (genes detected in +# more than 99.5% of the selected cells excluded) and max_cells=np.inf (no +# cutoff) on this fixture with top_n=50, the default min_cells (1% of the +# selected cells, from 3 to 20), and the default blacklist of 1.3.0. +_AUTO_DIGEST = "57929bd45c563d7206838229d44deae834440b1f9b89d5244817d735215d6014" +_NO_CUTOFF_DIGEST = "efde872152049c8f582f39ad36802008276e91f0cf9a6489061be1cc13213133" def _parameter_digest(store: DataStore, ref: ArtifactRef) -> str: