scib-metrics 0.5.5__py3-none-any.whl → 0.5.6__py3-none-any.whl

scib_metrics/benchmark/_core.py

@@ -42,6 +42,7 @@ metric_name_cleaner = {
     "clisi_knn": "cLISI",
     "ilisi_knn": "iLISI",
     "kbet_per_label": "KBET",
+    "bras": "BRAS",
     "graph_connectivity": "Graph connectivity",
     "pcr_comparison": "PCR comparison",
 }
@@ -72,7 +73,7 @@ class BatchCorrection:
     parameters, such as `X` or `labels`.
     """
 
-    silhouette_batch: MetricType = True
+    bras: MetricType = True
     ilisi_knn: MetricType = True
     kbet_per_label: MetricType = True
     graph_connectivity: MetricType = True
@@ -88,7 +89,7 @@ class MetricAnnDataAPI(Enum):
     silhouette_label = lambda ad, fn: fn(ad.X, ad.obs[_LABELS])
     clisi_knn = lambda ad, fn: fn(ad.uns["90_neighbor_res"], ad.obs[_LABELS])
     graph_connectivity = lambda ad, fn: fn(ad.uns["15_neighbor_res"], ad.obs[_LABELS])
-    silhouette_batch = lambda ad, fn: fn(ad.X, ad.obs[_LABELS], ad.obs[_BATCH])
+    bras = lambda ad, fn: fn(ad.X, ad.obs[_LABELS], ad.obs[_BATCH])
     pcr_comparison = lambda ad, fn: fn(ad.obsm[_X_PRE], ad.X, ad.obs[_BATCH], categorical=True)
     ilisi_knn = lambda ad, fn: fn(ad.uns["90_neighbor_res"], ad.obs[_BATCH])
     kbet_per_label = lambda ad, fn: fn(ad.uns["50_neighbor_res"], ad.obs[_BATCH], ad.obs[_LABELS])
@@ -156,6 +157,7 @@ class Benchmarker:
         self._label_key = label_key
         self._n_jobs = n_jobs
         self._progress_bar = progress_bar
+        self._compute_neighbors = True
 
         if self._bio_conservation_metrics is None and self._batch_correction_metrics is None:
             raise ValueError("Either batch or bio metrics must be defined.")
@@ -191,19 +193,25 @@ class Benchmarker:
             self._emb_adatas[emb_key].obsm[_X_PRE] = self._adata.obsm[self._pre_integrated_embedding_obsm_key]
 
         # Compute neighbors
-        progress = self._emb_adatas.values()
-        if self._progress_bar:
-            progress = tqdm(progress, desc="Computing neighbors")
-
-        for ad in progress:
-            if neighbor_computer is not None:
-                neigh_result = neighbor_computer(ad.X, max(self._neighbor_values))
-            else:
-                neigh_result = pynndescent(
-                    ad.X, n_neighbors=max(self._neighbor_values), random_state=0, n_jobs=self._n_jobs
-                )
-            for n in self._neighbor_values:
-                ad.uns[f"{n}_neighbor_res"] = neigh_result.subset_neighbors(n=n)
+        if self._compute_neighbors:
+            progress = self._emb_adatas.values()
+            if self._progress_bar:
+                progress = tqdm(progress, desc="Computing neighbors")
+
+            for ad in progress:
+                if neighbor_computer is not None:
+                    neigh_result = neighbor_computer(ad.X, max(self._neighbor_values))
+                else:
+                    neigh_result = pynndescent(
+                        ad.X, n_neighbors=max(self._neighbor_values), random_state=0, n_jobs=self._n_jobs
+                    )
+                for n in self._neighbor_values:
+                    ad.uns[f"{n}_neighbor_res"] = neigh_result.subset_neighbors(n=n)
+        else:
+            warnings.warn(
+                "Computing Neighbors Skipped",
+                UserWarning,
+            )
 
         self._prepared = True
 
@@ -251,7 +259,7 @@ class Benchmarker:
 
         self._benchmarked = True
 
-    def get_results(self, min_max_scale: bool = True, clean_names: bool = True) -> pd.DataFrame:
+    def get_results(self, min_max_scale: bool = False, clean_names: bool = True) -> pd.DataFrame:
         """Return the benchmarking results.
 
         Parameters
@@ -291,7 +299,7 @@ class Benchmarker:
         df.loc[_METRIC_TYPE, per_class_score.columns] = _AGGREGATE_SCORE
         return df
 
-    def plot_results_table(self, min_max_scale: bool = True, show: bool = True, save_dir: str | None = None) -> Table:
+    def plot_results_table(self, min_max_scale: bool = False, show: bool = True, save_dir: str | None = None) -> Table:
         """Plot the benchmarking results.
 
         Parameters

scib_metrics/metrics/_kbet.py

@@ -138,14 +138,8 @@ def kbet_per_label(
     conn_graph = X.knn_graph_connectivities
 
     # prepare call of kBET per cluster
-    clusters = []
-    clusters, counts = np.unique(labels, return_counts=True)
-    skipped = clusters[counts > 10]
-    clusters = clusters[counts <= 10]
-    kbet_scores = {"cluster": list(skipped), "kBET": [np.nan] * len(skipped)}
-    logger.info(f"{len(skipped)} clusters consist of a single batch or are too small. Skip.")
-
-    for clus in clusters:
+    kbet_scores = {"cluster": [], "kBET": []}
+    for clus in np.unique(labels):
         # subset by label
         mask = labels == clus
         conn_graph_sub = conn_graph[mask, :][:, mask]
@@ -153,55 +147,60 @@ def kbet_per_label(
         n_obs = conn_graph_sub.shape[0]
         batches_sub = batches[mask]
 
-        quarter_mean = np.floor(np.mean(pd.Series(batches_sub).value_counts()) / 4).astype("int")
-        k0 = np.min([70, np.max([10, quarter_mean])])
-        # check k0 for reasonability
-        if k0 * n_obs >= size_max:
-            k0 = np.floor(size_max / n_obs).astype("int")
-
-        n_comp, labs = scipy.sparse.csgraph.connected_components(conn_graph_sub, connection="strong")
-
-        if n_comp == 1:  # a single component to compute kBET on
-            try:
-                diffusion_n_comps = np.min([diffusion_n_comps, n_obs - 1])
-                nn_graph_sub = diffusion_nn(conn_graph_sub, k=k0, n_comps=diffusion_n_comps)
-                # call kBET
-                score, _, _ = kbet(
-                    nn_graph_sub,
-                    batches=batches_sub,
-                    alpha=alpha,
-                )
-            except ValueError:
-                logger.info("Diffusion distance failed. Skip.")
-                score = 0  # i.e. 100% rejection
-
+        # check if neighborhood size too small or only one batch in subset
+        if np.logical_or(n_obs < 10, len(np.unique(batches_sub)) == 1):
+            logger.info(f"{clus} consists of a single batch or is too small. Skip.")
+            score = np.nan
         else:
-            # check the number of components where kBET can be computed upon
-            comp_size = pd.Series(labs).value_counts()
-            # check which components are small
-            comp_size_thresh = 3 * k0
-            idx_nonan = np.flatnonzero(np.in1d(labs, comp_size[comp_size >= comp_size_thresh].index))
-
-            # check if 75% of all cells can be used for kBET run
-            if len(idx_nonan) / len(labs) >= 0.75:
-                # create another subset of components, assume they are not visited in a diffusion process
-                conn_graph_sub_sub = conn_graph_sub[idx_nonan, :][:, idx_nonan]
-                conn_graph_sub_sub.sort_indices()
+            quarter_mean = np.floor(np.mean(pd.Series(batches_sub).value_counts()) / 4).astype("int")
+            k0 = np.min([70, np.max([10, quarter_mean])])
+            # check k0 for reasonability
+            if k0 * n_obs >= size_max:
+                k0 = np.floor(size_max / n_obs).astype("int")
+
+            n_comp, labs = scipy.sparse.csgraph.connected_components(conn_graph_sub, connection="strong")
 
+            if n_comp == 1:  # a single component to compute kBET on
                 try:
-                    diffusion_n_comps = np.min([diffusion_n_comps, conn_graph_sub_sub.shape[0] - 1])
-                    nn_results_sub_sub = diffusion_nn(conn_graph_sub_sub, k=k0, n_comps=diffusion_n_comps)
+                    diffusion_n_comps = np.min([diffusion_n_comps, n_obs - 1])
+                    nn_graph_sub = diffusion_nn(conn_graph_sub, k=k0, n_comps=diffusion_n_comps)
                     # call kBET
                     score, _, _ = kbet(
-                        nn_results_sub_sub,
-                        batches=batches_sub[idx_nonan],
+                        nn_graph_sub,
+                        batches=batches_sub,
                         alpha=alpha,
                     )
                 except ValueError:
                     logger.info("Diffusion distance failed. Skip.")
                     score = 0  # i.e. 100% rejection
-            else:  # if there are too many too small connected components, set kBET score to 0
-                score = 0  # i.e. 100% rejection
+
+            else:
+                # check the number of components where kBET can be computed upon
+                comp_size = pd.Series(labs).value_counts()
+                # check which components are small
+                comp_size_thresh = 3 * k0
+                idx_nonan = np.flatnonzero(np.in1d(labs, comp_size[comp_size >= comp_size_thresh].index))
+
+                # check if 75% of all cells can be used for kBET run
+                if len(idx_nonan) / len(labs) >= 0.75:
+                    # create another subset of components, assume they are not visited in a diffusion process
+                    conn_graph_sub_sub = conn_graph_sub[idx_nonan, :][:, idx_nonan]
+                    conn_graph_sub_sub.sort_indices()
+
+                    try:
+                        diffusion_n_comps = np.min([diffusion_n_comps, conn_graph_sub_sub.shape[0] - 1])
+                        nn_results_sub_sub = diffusion_nn(conn_graph_sub_sub, k=k0, n_comps=diffusion_n_comps)
+                        # call kBET
+                        score, _, _ = kbet(
+                            nn_results_sub_sub,
+                            batches=batches_sub[idx_nonan],
+                            alpha=alpha,
+                        )
+                    except ValueError:
+                        logger.info("Diffusion distance failed. Skip.")
+                        score = 0  # i.e. 100% rejection
+                else:  # if there are too many too small connected components, set kBET score to 0
+                    score = 0  # i.e. 100% rejection
 
         kbet_scores["cluster"].append(clus)
         kbet_scores["kBET"].append(score)

{scib_metrics-0.5.5.dist-info → scib_metrics-0.5.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scib-metrics
-Version: 0.5.5
+Version: 0.5.6
 Summary: Accelerated and Python-only scIB metrics
 Project-URL: Documentation, https://scib-metrics.readthedocs.io/
 Project-URL: Source, https://github.com/yoseflab/scib-metrics

{scib_metrics-0.5.5.dist-info → scib_metrics-0.5.6.dist-info}/RECORD

@@ -2,11 +2,11 @@ scib_metrics/__init__.py,sha256=Vejvv3Nhi8fTlIKij3CAMe484URT9quMUD9MlwVvZBg,971
 scib_metrics/_settings.py,sha256=Rd4ymmbFoNTOfxnB87TU2-CFfQ4OJDZ94mJxhJTyS6A,4261
 scib_metrics/_types.py,sha256=yp76iBm1XjWhTmU_cbufJwrgiwUz4-L3J7DV3imiAhk,201
 scib_metrics/benchmark/__init__.py,sha256=HVUERJlRrEZV7BhpKJIsmOd1D_4XPoG2bp48AMlR3wY,130
-scib_metrics/benchmark/_core.py,sha256=HOI9gG-TGt1nSadtdSgK9oRz0ZKel_iCrUfskwV03nk,16253
+scib_metrics/benchmark/_core.py,sha256=lEGxUZnjTrWHrz2T5i4txO222soTKCd5aqYbHH30rG4,16505
 scib_metrics/metrics/__init__.py,sha256=coYlfeP21IrXdB4KG9T5K4i8C3WTl_uyX2ANu23sIkg,685
 scib_metrics/metrics/_graph_connectivity.py,sha256=jFc10EINB4AohbgAjV7-m1SGfAgu5tBeUk9ZcuoaSwY,1076
 scib_metrics/metrics/_isolated_labels.py,sha256=HkZKRop-I561rm_2H_23hsLFgCT36BHIyEWjzq2GYOc,2457
-scib_metrics/metrics/_kbet.py,sha256=fgVMO0RbevGvtR0hOSIWyrr4aw93qCCNcFVf_7PFIuE,8241
+scib_metrics/metrics/_kbet.py,sha256=JAmudHHv2EZ8l09fVTgFL_mgs99lgwHidx3zmKMEMvU,8419
 scib_metrics/metrics/_lisi.py,sha256=Le-1qCeJP_O1gnFgxaNXhirJU6QcK1j6km4nb28Oa7k,3503
 scib_metrics/metrics/_nmi_ari.py,sha256=kNKxPeEJKPVQXpMHFrENCTQdHLH84zdthq84xslsecg,4683
 scib_metrics/metrics/_pcr_comparison.py,sha256=dxj8uKhsMMmD-GrryfVgJyTlzhdRu08kujd8-e9SC8g,1983
@@ -24,7 +24,7 @@ scib_metrics/utils/_pca.py,sha256=uXYwX9gZkA1bCKGpOtbe6aKgnfMoL-SK3u5q7CACXWA,42
 scib_metrics/utils/_pcr.py,sha256=wORbVtZrStbhFHWNMuY5F6qajyn3jnESoc5oTT9sjXI,2466
 scib_metrics/utils/_silhouette.py,sha256=JlxlEDW55KgrlxJSCYCukg1MBnILnFFludcjQyn9Z7Q,6644
 scib_metrics/utils/_utils.py,sha256=CRzgQykQPK0XTM46Ukpr7nI2yE5_rIAgZbotj5ZqDJs,1999
-scib_metrics-0.5.5.dist-info/METADATA,sha256=BYZZUQNVwbadSvUdD_KfdxdDURI4999mh81cSYmp6b8,8210
-scib_metrics-0.5.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-scib_metrics-0.5.5.dist-info/licenses/LICENSE,sha256=GRRQaq9hdMbxLTKedbegvvcbeF-Vh8UeHYIXoYUXXKM,1519
-scib_metrics-0.5.5.dist-info/RECORD,,
+scib_metrics-0.5.6.dist-info/METADATA,sha256=F_rf6lsKCIN25eA0anYEprtCbMJOSvoSTZOKFAi-uKw,8210
+scib_metrics-0.5.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+scib_metrics-0.5.6.dist-info/licenses/LICENSE,sha256=GRRQaq9hdMbxLTKedbegvvcbeF-Vh8UeHYIXoYUXXKM,1519
+scib_metrics-0.5.6.dist-info/RECORD,,