Add new method: CellMapper (#31)

* Add basic CellMapper implementation

* Add more parameters and hvg computation

* Add cellmapper to workflow files (clean)

* Update Changelog

* Add normalization method choice

* Fix typos and improve description

* Add me as contributor

Author: Marius1311

CHANGELOG.md

@@ -1,5 +1,6 @@
 # denoising devel
 
+* Add new method: CellMapper (PR #31)
 * Update scPRINT, including a new default model (PR #26)
 
 # denoising v1.0.0

_viash.yaml

@@ -75,6 +75,11 @@ authors:
     info:
       github: jkobject
       orcid: "0000-0002-2818-9728"
+  - name: Marius Lange
+    roles: [ contributor ]
+    info:
+      github: marius1311
+      orcid: 0000-0002-4846-1266
 repositories:
   - name: core
     type: github

src/methods/cellmapper/config.vsh.yaml

@@ -0,0 +1,61 @@
+__merge__: ../../api/comp_method.yaml
+name: cellmapper
+label: CellMapper
+summary: "CellMapper is a general framework for k-NN based mapping tasks in single-cell and spatial genomics"
+description: |
+  k-NN-based mapping of cells across representations to transfer labels, embeddings and expression values. 
+  Works for millions of cells, on CPU and GPU, across molecular modalities, between spatial and non-spatial data, 
+  for arbitrary query and reference datasets. We treat data denoising as self-mapping, where the query and reference datasets are the same. 
+  Based on some joint representation (here: PCA), CellMapper computes a k-NN graph and applies a kernel function to compute edge weights. Here,
+  we use a kernel based on Jaccard similarity (as e.g. in HNOCA-tools) or UMAP's `fuzzy_simplicial_set` (as in scanpy). Given the row-normalized 
+  weighted adjacency matrix, we simulate a t-step random walk to smooth the data, similar to MAGIC. For large t-values, we also provide a spectral 
+  approximation of the application of the t-step transition matrix to the data (not used here). 
+
+references:
+  doi: 
+    - 10.5281/zenodo.15683594
+links:
+  documentation: https://cellmapper.readthedocs.io/en/latest/
+  repository: https://github.com/quadbio/cellmapper
+info:
+  preferred_normalization: counts
+  variants: 
+    cellmapper_jaccard_log:
+      kernel_method: jaccard
+      norm: log
+    cellmapper_umap_log:
+      kernel_method: umap
+      norm: log
+    cellmapper_umap_sqrt:
+      kernel_method: umap
+      norm: sqrt
+arguments:
+  - name: "--kernel_method"
+    type: "string"
+    choices: ["jaccard", "umap"]
+    default: "umap"
+    description: Kernel function to compute k-NN edge weights. 
+  - name: "--t"
+    type: "integer"
+    default: 3
+    description: Number of steps for data smoothing.
+  - name: "--norm"
+    type: string
+    choices: ["sqrt", "log"]
+    default: "log"
+    description: Normalization method
+resources:
+  - type: python_script
+    path: script.py
+engines:
+  - type: docker
+    image: openproblems/base_python:1
+    setup:
+      - type: python
+        packages: 
+          - cellmapper>=0.2.1
+runners:
+  - type: executable
+  - type: nextflow
+    directives:
+      label: [midtime,midmem,midcpu]

src/methods/cellmapper/script.py

@@ -0,0 +1,75 @@
+import anndata as ad
+import numpy as np
+import scanpy as sc
+from scipy.sparse import issparse
+import cellmapper as cm
+
+## VIASH START
+# Note: this section is auto-generated by viash at runtime. To edit it, make changes
+# in config.vsh.yaml and then run `viash config inject config.vsh.yaml`.
+par = {
+  'input_train': 'resources_test/task_denoising/cxg_immune_cell_atlas/train.h5ad',
+  'output': 'output_cellmapper.h5ad',
+  'kernel_method': 'umap',
+  'norm': 'log',
+  't': 3
+}
+meta = {
+  'name': 'cellmapper'
+}
+## VIASH END
+
+print(f'CellMapper version: {cm.__version__}', flush=True)
+
+print('Reading input files', flush=True)
+input_train = ad.read_h5ad(par['input_train'])
+
+print('Prepare the AnnData object', flush=True)
+
+# Let's make sure we have counts in .X
+input_train.X = input_train.layers["counts"].copy()
+
+print('Preprocess the data', flush=True)
+sc.pp.normalize_total(input_train, target_sum=1e4)
+
+if par['norm'] == 'sqrt':
+    # Safe square root for both sparse and dense matrices
+    if issparse(input_train.X):
+        input_train.X.data = np.sqrt(input_train.X.data)
+    else:
+        input_train.X = np.sqrt(input_train.X)
+elif par['norm'] == 'log':
+    sc.pp.log1p(input_train)
+else:
+    raise ValueError(f"Unknown normalization method: {par['norm']}")
+
+sc.pp.highly_variable_genes(input_train)
+sc.pp.pca(input_train)
+
+print('Setup and prepare CellMapper', flush=True)
+
+# Initialize CellMapper with the AnnData object, compute k-NN graph and mapping matrix
+cmap = cm.CellMapper(input_train)
+cmap.compute_neighbors(use_rep="X_pca")
+cmap.compute_mapping_matrix(kernel_method=par['kernel_method'])
+
+print('Run data smoothing', flush=True)
+
+# run t-step smoothing and write back to input 
+cmap.map_layers(key="counts", t=par['t'])
+
+print("Write output AnnData to file", flush=True)
+
+# Create output AnnData object without X to avoid encoding issues
+output = ad.AnnData(
+    obs=input_train.obs[[]],
+    var=input_train.var[[]],
+    uns={
+        "dataset_id": input_train.uns["dataset_id"],
+        "method_id": meta["name"]
+    }
+)
+# Set the denoised layer directly from the imputed data
+output.layers["denoised"] = cmap.query_imputed.X
+
+output.write_h5ad(par['output'], compression='gzip')

src/workflows/run_benchmark/config.vsh.yaml

@@ -72,6 +72,7 @@ dependencies:
   - name: control_methods/no_denoising
   - name: control_methods/perfect_denoising
   - name: methods/alra
+  - name: methods/cellmapper
   - name: methods/dca
   - name: methods/knn_smoothing
   - name: methods/magic

src/workflows/run_benchmark/main.nf

@@ -18,6 +18,7 @@ workflow run_wf {
     no_denoising,
     perfect_denoising,
     alra,
+    cellmapper,
     dca,
     knn_smoothing,
     magic,