oscb 0.1.0__tar.gz

oscb-0.1.0/PKG-INFO

@@ -0,0 +1,73 @@
+Metadata-Version: 2.2
+Name: oscb
+Version: 0.1.0
+Summary: OSCB aims to provide automated end-to-end single-cell analyses ML pipelines to simplify and standardize the process of single-cell data formatting, quality control, loading, model development, and model evaluation. 
+Home-page: https://github.com/cirisjl/Machine-learning-development-environment-for-single-cell-sequencing-data-analyses
+Author: Lei Jiang
+Author-email: leijiang@missouri.edu
+License: MIT
+Keywords: single-cell,benchmarks
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6, <=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: leidenalg>=0.8.10
+Requires-Dist: matplotlib>=3.5.1
+Requires-Dist: networkx>=2.6.3
+Requires-Dist: numpy>=1.26.4
+Requires-Dist: pandas>=1.3.5
+Requires-Dist: python_igraph>=0.9.9
+Requires-Dist: python_louvain>=0.16
+Requires-Dist: scanpy
+Requires-Dist: muon
+Requires-Dist: mudata
+Requires-Dist: tqdm
+Requires-Dist: requests
+Requires-Dist: scib
+Requires-Dist: zss
+Requires-Dist: grakel
+Requires-Dist: scikit_learn>=1.0.2
+Requires-Dist: scipy>=1.7.3
+Requires-Dist: umap_learn>=0.5.2
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Overview
+
+--------------------------------------------------------------------------------
+
+
+Machine learning (ML) is transforming single-cell sequencing data analysis; however, the barriers of technology complexity and biology knowledge remain challenging for the involvement of the ML community in single-cell data analysis. We present an ML development environment for single-cell sequencing data analyses with a diverse set of AI-Ready benchmark datasets. A cloud-based platform is built to dynamically scale workflows for collecting, processing, and managing various single-cell sequencing data to make them ML-ready. In addition, benchmarks for each problem formulation and a code-level and web-interface IDE for single-cell analysis method development are provided. 
+
+
+![Workflow](https://oscb.missouri.edu/assets/30e6000a-5e6f-440f-bec5-5c7ceb256c55)
+
+OSCB aims to provide automated end-to-end single-cell analyses ML pipelines to simplify and standardize the process of single-cell data formatting, quality control, loading, model development, and model evaluation. 
+
+
+**Workflows** are developed for collecting, processing, and managing diverse single-cell sequencing data to make them ML-ready and build benchmarks.
+
+**IDE** is provided for supporting partial method development.
+
+**Assessment utilities** are provided for evaluating results and report generation.
+
+This **end-to-end pipeline** transforms the traditional “static” machine Learning into **continuous learning** on extensive new data.
+
+
+By **in-depth fusing models with data**, this platform could ultimately help many single-cell sequencing researchers substantially.
+
+ 
+![Tools](https://oscb.missouri.edu/assets/c18ffb2a-814f-452c-921b-e399b99c41b4)
+
+
+OSCB is an on-going effort, and we are planning to increase our coverage in the future.

oscb-0.1.0/README.md

@@ -0,0 +1,29 @@
+# Overview
+
+--------------------------------------------------------------------------------
+
+
+Machine learning (ML) is transforming single-cell sequencing data analysis; however, the barriers of technology complexity and biology knowledge remain challenging for the involvement of the ML community in single-cell data analysis. We present an ML development environment for single-cell sequencing data analyses with a diverse set of AI-Ready benchmark datasets. A cloud-based platform is built to dynamically scale workflows for collecting, processing, and managing various single-cell sequencing data to make them ML-ready. In addition, benchmarks for each problem formulation and a code-level and web-interface IDE for single-cell analysis method development are provided. 
+
+
+![Workflow](https://oscb.missouri.edu/assets/30e6000a-5e6f-440f-bec5-5c7ceb256c55)
+
+OSCB aims to provide automated end-to-end single-cell analyses ML pipelines to simplify and standardize the process of single-cell data formatting, quality control, loading, model development, and model evaluation. 
+
+
+**Workflows** are developed for collecting, processing, and managing diverse single-cell sequencing data to make them ML-ready and build benchmarks.
+
+**IDE** is provided for supporting partial method development.
+
+**Assessment utilities** are provided for evaluating results and report generation.
+
+This **end-to-end pipeline** transforms the traditional “static” machine Learning into **continuous learning** on extensive new data.
+
+
+By **in-depth fusing models with data**, this platform could ultimately help many single-cell sequencing researchers substantially.
+
+ 
+![Tools](https://oscb.missouri.edu/assets/c18ffb2a-814f-452c-921b-e399b99c41b4)
+
+
+OSCB is an on-going effort, and we are planning to increase our coverage in the future.

oscb-0.1.0/oscb/__init__.py

@@ -0,0 +1,14 @@
+from __future__ import absolute_import
+
+from .evaluation import annotation, ccc, clustering, imputation, integration, multimodal, trajectory, annotation
+from .data import *
+from .evaluator import *
+from .utilization import *
+from .utils import *
+# from .evaluation import ccc
+# from .evaluation import clustering
+# from .evaluation import imputation
+# from .evaluation import integration
+# from .evaluation import multimodal
+# from .evaluation import trajectory
+# from .evaluation import annotation

oscb-0.1.0/oscb/data.py

@@ -0,0 +1,135 @@
+import requests
+from tqdm import tqdm
+import os
+from pathlib import Path
+import hashlib
+import re
+from muon import MuData
+import muon as mu
+import numpy as np
+import pandas as pd
+import scanpy as sc
+import anndata as ad
+import mudata as md
+from .utils import *
+
+
+
+class FileDownloader:
+    def __init__(self, chunk_size=8192):
+        self.chunk_size = chunk_size
+        self.session = requests.Session()
+
+    def get_filename_from_response(self, headers):
+        """
+        Extracts filename from Content-Disposition header or URL.
+        """
+        print(headers)
+        if "content-disposition" in headers:
+            cd = headers["content-disposition"]
+            match = re.search(r"filename\*?=['\"]?(.*?)['\"]?(?:;|$)", cd)
+            if match:
+                filename = match.group(1)
+                # Handle potential encoding if filename* is used
+                if filename.startswith("utf-8''"):
+                    filename = filename.split("''", 1)[1]
+                    filename = requests.utils.unquote(filename)
+                return filename
+        return None
+        
+    def get_file_size(self, response):
+        # response = self.session.head(url)
+        return int(response.headers.get('content-length', 0))
+    
+    def get_file_hash(self, file_path):
+        sha256_hash = hashlib.sha256()
+        with open(file_path, "rb") as f:
+            for byte_block in iter(lambda: f.read(4096), b""):
+                sha256_hash.update(byte_block)
+        return sha256_hash.hexdigest()
+    
+    def download(self, url, data_dict, data_folder='downloads/', verify_hash=None):
+        try:
+            response = self.session.post(url, json=data_dict, stream=True)
+            response.raise_for_status()  # Raise an exception for bad status codes (4xx or 5xx)
+            total_size = self.get_file_size(response)
+            file_name = self.get_filename_from_response(response.headers)
+            local_file_path = os.path.join(data_folder, file_name)
+            local_file_path = Path(local_file_path)
+            # Make dir
+            local_file_path.parent.mkdir(parents=True, exist_ok=True)
+
+            # Progress bar
+            progress = tqdm(total=total_size,
+                           unit='B',
+                           unit_scale=True,
+                           desc=local_file_path.name)
+            
+            with local_file_path.open('wb') as f:
+                for chunk in response.iter_content(chunk_size=self.chunk_size):
+                    if chunk:
+                        f.write(chunk)
+                        progress.update(len(chunk))
+            progress.close()
+            
+            # File validation
+            if verify_hash:
+                downloaded_hash = self.get_file_hash(local_file_path)
+                if downloaded_hash != verify_hash:
+                    raise ValueError("File hash verification failed.")
+                    
+            print(f"File downloaded successfully to: {local_file_path}")
+            
+            return local_file_path
+            
+        except Exception as e:
+            progress.close()
+            print(f"Download failed: {str(e)}")
+            if local_file_path.exists():
+                local_file_path.unlink()
+            return None
+
+    def download_multiple(self, url_list, data_folder):
+        results = []
+        for url in url_list:
+            filename = url.split('/')[-1]
+            local_file_path = Path(data_folder) / filename
+            success = self.download(url, local_file_path)
+            results.append({
+                'url': url,
+                'success': success,
+                'local_file_path': str(local_file_path)
+            })
+        return results
+
+
+
+def DataLoader(benchmarks_id, data_folder='downloads/', server_endpoint=server_endpoint+'download'):  
+    dataset_id, task = get_dataset_id(benchmarks_id)
+    if task is not None:
+        print(f"Downloading dataset for {task} Benchmarks.")
+    else:
+        print("Downloading dataset.")
+    data_dict = {
+        "dataset_id": dataset_id
+    }
+
+    downloader = FileDownloader()
+    adata_path = downloader.download(server_endpoint, data_dict, data_folder="downloads")
+
+    if os.path.isfile(adata_path):
+        if str(adata_path).endswith(".h5mu"):
+            mdata = muon.read_h5mu(adata_path)
+            return mdata
+        else:
+            adata = sc.read_h5ad(adata_path)
+            return adata
+    else:
+        return None
+
+
+def split_data(adata):
+    train_adata = adata[adata.obs.split_idx.str.contains('train'), :].copy()
+    test_adata = adata[adata.obs.split_idx.str.contains('test'), :].copy()
+
+    return train_adata, test_adata

oscb-0.1.0/oscb/evaluation/__init__.py

@@ -0,0 +1,10 @@
+from __future__ import absolute_import
+
+from .annotation import *
+from .ccc import *
+from .clustering import *
+from .imputation import *
+from .integration import *
+from .multimodal import *
+from .trajectory import *
+from .annotation import *

oscb-0.1.0/oscb/evaluation/annotation.py

@@ -0,0 +1,39 @@
+import numpy as np
+import sklearn.preprocessing
+from sklearn.metrics import f1_score, accuracy_score
+
+
+def annotation_metrics(labels, labels_pred):
+    print("Encode labels", flush=True)
+    labels = labels.astype('category')
+    labels_pred = labels_pred.astype('category')
+    if labels.isna().any():
+        labels = labels.cat.add_categories(['Unkown'])
+        labels = labels.fillna('Unkown')
+    if labels_pred.isna().any():
+        labels_pred = labels_pred.cat.add_categories(['Unkown'])
+        labels_pred = labels_pred.fillna('Unkown')
+    cats = list(labels.dtype.categories) + list(labels_pred.dtype.categories)
+    encoder = sklearn.preprocessing.LabelEncoder().fit(cats)
+    labels = encoder.transform(labels)
+    labels_pred = encoder.transform(labels_pred)
+
+    print("Compute prediction accuracy", flush=True)
+    accuracy = accuracy_score(labels, labels_pred)
+    accuracy = float('{:.4f}'.format(accuracy))
+
+    print("Compute F1 score", flush=True)
+    f1_macro = float('{:.4f}'.format(f1_score(
+            labels, labels_pred, 
+            average='macro'
+        )))
+    f1_micro = float('{:.4f}'.format(f1_score(
+            labels, labels_pred, 
+            average='micro'
+        )))
+    f1_weighted = float('{:.4f}'.format(f1_score(
+            labels, labels_pred, 
+            average='weighted'
+        )))
+
+    return accuracy, f1_macro, f1_micro, f1_weighted

oscb-0.1.0/oscb/evaluation/ccc.py

@@ -0,0 +1,74 @@
+from typing import Union
+
+import anndata
+import collections
+import numpy as np
+from sklearn.metrics import auc
+from sklearn.metrics import precision_recall_curve
+
+# Cell Cell Communication
+def ccc_metrics(adata, ccc_pred="ccc_pred", ccc_target="ccc_target", score="score", top_prop=0.05):
+    # Precision-recall AUC
+    gt = join_truth_and_pred(adata, ccc_pred, ccc_target, score)
+    precision, recall, _ = precision_recall_curve(
+        gt["response"], gt[score], pos_label=1
+    )
+
+    auc_score = auc(recall, precision)
+
+    # Odds Ratio
+    gt = gt.sort_values(score, ascending=False)
+    top_n = int(adata.uns[ccc_target].shape[0] * top_prop)
+
+    # assign the top rank interactions to 1
+    a = np.zeros(len(gt[score]))
+    a[0:top_n] = 1
+    gt.loc[:, ["top_n"]] = a
+
+    top = gt[gt["top_n"] == 1]
+    tp = np.sum(top.response == 1)
+    fp = np.sum(top.response == 0)
+
+    bot = gt[gt["top_n"] == 0]
+    fn = np.sum(bot.response == 1)
+    tn = np.sum(bot.response == 0)
+
+    numerator = tp * tn
+    denominator = fp * fn
+    if denominator == 0:
+        if numerator == 0:
+            # undefined
+            oddsratio_score = np.nan
+        else:
+            # perfect score
+            oddsratio_score = np.inf
+    else:
+        oddsratio_score = numerator / denominator
+        oddsratio_score = _sigmoid_transform(oddsratio_score)
+
+    return float('{:.4f}'.format(auc_score)), float('{:.4f}'.format(oddsratio_score))
+
+
+# Join predictions to target
+def join_truth_and_pred(adata, ccc_pred="ccc_pred", ccc_target="ccc_target", score="lrscore"):
+    merge_keys = list(adata.uns["merge_keys"])
+    gt = adata.uns[ccc_target].merge(adata.uns[ccc_pred], on=merge_keys, how="left")
+
+    gt.loc[gt["response"].isna(), "response"] = 0
+    gt.loc[gt[score].isna(), score] = np.nanmin(gt[score]) - np.finfo(float).eps
+
+    return gt
+
+
+def _sigmoid_transform(x):
+    return 1 - 1 / (1 + x / 2)
+
+
+def aggregate_method_scores(adata, how, ccc_pred="LIANA", score="score"):
+    merge_keys = list(adata.uns["merge_keys"])
+    return (
+        adata.uns[ccc_pred]
+        .groupby(merge_keys)
+        .agg(score=(score, how))
+        .reset_index()
+    )

oscb-0.1.0/oscb/evaluation/clustering.py

@@ -0,0 +1,20 @@
+from sklearn.metrics import adjusted_rand_score as ARI
+from sklearn.metrics import normalized_mutual_info_score as NMI
+from sklearn.metrics import silhouette_score
+from sklearn.metrics import fowlkes_mallows_score as FM
+
+def clustering_metrics(labels, labels_pred, embedding):
+    asw_score = silhouette_score(embedding, labels)
+    nmi_score = NMI(labels, labels_pred)
+    ari_score = ARI(labels, labels_pred)
+    fm_score = FM(labels, labels_pred)
+    asw_score = float('{:.4f}'.format(asw_score))
+    nmi_score = float('{:.4f}'.format(nmi_score))
+    ari_score = float('{:.4f}'.format(ari_score))
+    fm_score = float('{:.4f}'.format(fm_score))
+
+    print(
+        "Clustering Scores:\nSilhouette: %.4f\nNMI: %.4f\nARI: %.4f\nFowlkes Mallows: %.4f"
+        % (asw_score, nmi_score, ari_score, fm_score)
+    )
+    return asw_score, nmi_score, ari_score, fm_score

oscb-0.1.0/oscb/evaluation/imputation.py

@@ -0,0 +1,161 @@
+from scipy import sparse
+import importlib
+import numbers
+import anndata
+import scanpy as sc
+import sklearn.metrics
+import numpy as np
+import pandas as pd
+import re
+import warnings
+
+
+# test_data = adata.obsm["test"]
+# denoised_data = adata.obsm["denoised"]
+# train_data = adata.obsm["train"]
+def imputation_metrics(adata, denoised_layer, train='train', test='test'):
+    #Mean-squared error
+    test_adata = anndata.AnnData(X=adata.obsm[test], obs=adata.obs, var=adata.var)
+    denoised_adata = anndata.AnnData(
+        X=adata.layers[denoised_layer], obs=adata.obs, var=adata.var
+    )
+
+    # scaling and transformation
+    target_sum = 10000
+
+    sc.pp.normalize_total(test_adata, target_sum)
+    sc.pp.log1p(test_adata)
+
+    sc.pp.normalize_total(denoised_adata, target_sum)
+    sc.pp.log1p(denoised_adata)
+
+    mse = sklearn.metrics.mean_squared_error(
+        toarray(test_adata.X), toarray(denoised_adata.X)
+    )
+
+    # Poisson loss
+    test_data = adata.obsm[test]
+    denoised_data = adata.layers[denoised_layer]
+
+    # scaling
+    initial_sum = adata.obsm[train].sum()
+    target_sum = test_data.sum()
+    denoised_data = denoised_data * target_sum / initial_sum
+
+    possion = poisson_nll_loss(toarray(test_data), toarray(denoised_data))
+
+    return float('{:.4f}'.format(mse)), float('{:.4f}'.format(possion))
+
+
+def poisson_nll_loss(y_pred: np.ndarray, y_true: np.ndarray) -> float:
+    return (y_pred - y_true * np.log(y_pred + 1e-6)).mean()
+
+
+def toarray(x):
+    """Convert an array-like to a np.ndarray.
+
+    Parameters
+    ----------
+    x : array-like
+        Array-like to be converted
+    Returns
+    -------
+    x : np.ndarray
+    """
+    if is_SparseDataFrame(x):
+        x = x.to_coo().toarray()
+    elif is_SparseSeries(x):
+        x = x.to_dense().to_numpy()
+    elif isinstance(x, (pd.DataFrame, pd.Series, pd.Index)):
+        x = x.to_numpy()
+    elif isinstance(x, sparse.spmatrix):
+        x = x.toarray()
+    elif isinstance(x, np.matrix):
+        x = x.A
+    elif isinstance(x, list):
+        x_out = []
+        for xi in x:
+            try:
+                xi = toarray(xi)
+            except TypeError:
+                # recursed too far
+                pass
+            x_out.append(xi)
+        # convert x_out from list to array
+        x = np.array(x_out, dtype=_check_numpy_dtype(x_out))
+    elif isinstance(x, (np.ndarray, numbers.Number)):
+        pass
+    else:
+        raise TypeError("Expected array-like. Got {}".format(type(x)))
+    return x
+
+
+def is_SparseSeries(X):
+    with warnings.catch_warnings():
+        warnings.filterwarnings(
+            "ignore",
+            "The SparseSeries class is removed from pandas. Accessing it from the "
+            "top-level namespace will also be removed in the next version",
+            FutureWarning,
+        )
+        try:
+            return isinstance(X, pd.SparseSeries)
+        except AttributeError:
+            return False
+
+
+def is_SparseDataFrame(X):
+    with warnings.catch_warnings():
+        warnings.filterwarnings(
+            "ignore",
+            "The SparseDataFrame class is removed from pandas. Accessing it from the "
+            "top-level namespace will also be removed in the next version",
+            FutureWarning,
+        )
+        try:
+            return isinstance(X, pd.SparseDataFrame)
+        except AttributeError:
+            return False
+
+
+def is_sparse_dataframe(x):
+    if isinstance(x, pd.DataFrame) and not is_SparseDataFrame(x):
+        try:
+            x.sparse
+            return True
+        except AttributeError:
+            pass
+    return False
+
+
+def is_sparse_series(x):
+    if isinstance(x, pd.Series) and not is_SparseSeries(x):
+        try:
+            x.sparse
+            return True
+        except AttributeError:
+            pass
+    return False
+
+
+def dataframe_to_sparse(x, fill_value=0.0):
+    x = pd.DataFrame.sparse.from_spmatrix(
+        sparse.coo_matrix(x.values), index=x.index, columns=x.columns
+    )
+    x.sparse.fill_value = fill_value
+    return x
+
+
+def SparseDataFrame(X, columns=None, index=None, default_fill_value=0.0):
+    if sparse.issparse(X):
+        X = pd.DataFrame.sparse.from_spmatrix(X)
+        X.sparse.fill_value = default_fill_value
+    else:
+        if is_SparseDataFrame(X) or not isinstance(X, pd.DataFrame):
+            X = pd.DataFrame(X)
+        X = dataframe_to_sparse(X, fill_value=default_fill_value)
+    if columns is not None:
+        X.columns = columns
+    if index is not None:
+        X.index = index
+    return X

oscb-0.1.0/oscb/evaluation/integration.py

@@ -0,0 +1,60 @@
+from scib.metrics import metrics
+
+# https://github.com/theislab/scib/blob/main/scib/metrics/metrics.py
+# https://scib.readthedocs.io/en/latest/api/scib.metrics.metrics_all.html
+def integration_metrics(adata, adata_int, batch_key='batch', label_key='cell_type', species="mouse"):
+    """All metrics
+
+    :Biological conservation:
+        + HVG overlap :func:`~scib.metrics.hvg_overlap`
+        + Cell type ASW :func:`~scib.metrics.silhouette`
+        + Isolated label ASW :func:`~scib.metrics.isolated_labels`
+        + Isolated label F1 :func:`~scib.metrics.isolated_labels`
+        + NMI cluster/label :func:`~scib.metrics.nmi`
+        + ARI cluster/label :func:`~scib.metrics.ari`
+        + Cell cycle conservation :func:`~scib.metrics.cell_cycle`
+        + cLISI (cell type Local Inverse Simpson's Index) :func:`~scib.metrics.clisi_graph`
+        + Trajectory conservation :func:`~scib.metrics.trajectory_conservation`
+
+    :Batch correction:
+        + Graph connectivity :func:`~scib.metrics.graph_connectivity`
+        + Batch ASW :func:`~scib.metrics.silhouette_batch`
+        + Principal component regression :func:`~scib.metrics.pcr_comparison`
+        + kBET (k-nearest neighbour batch effect test) :func:`~scib.metrics.kBET`
+        + iLISI (integration Local Inverse Simpson's Index) :func:`~scib.metrics.ilisi_graph`
+
+    :param adata: unintegrated, preprocessed anndata object
+    :param adata_int: integrated anndata object
+    :param batch_key: name of batch column in adata.obs and adata_int.obs
+    :param label_key: name of biological label (cell type) column in adata.obs and adata_int.obs
+    :param kwargs:
+        Parameters to pass on to :func:`~scib.metrics.metrics` function:
+
+            + ``embed``
+            + ``cluster_key``
+            + ``cluster_nmi``
+            + ``nmi_method``
+            + ``nmi_dir``
+            + ``si_metric``
+            + ``organism``
+            + ``n_isolated``
+            + ``subsample``
+            + ``type_``
+    """
+
+    metrics_all = metrics(adata, adata_int, batch_key=batch_key, label_key=label_key, cluster_nmi=None, ari_=True, nmi_=True, nmi_method='arithmetic', nmi_dir=None, silhouette_=True, si_metric='euclidean', pcr_=True, cell_cycle_=True, organism=species, hvg_score_=True, isolated_labels_=True, isolated_labels_f1_=True, isolated_labels_asw_=True, n_isolated=True, graph_conn_=True, trajectory_=False, kBET_=True)
+    biological_conservation_metrics = ['NMI_cluster/label', 'ARI_cluster/label', 'ASW_label', 'cell_cycle_conservation','isolated_label_F1', 'isolated_label_silhouette', 'hvg_overlap']
+    # metrics_dict = metrics_all.dropna().to_dict()[0]
+    metrics_dict = metrics_all.fillna(0).to_dict()[0]
+
+    for key, value in metrics_dict.items():
+        metrics_dict[key] = float('{:.4f}'.format(value))
+
+    bc_total = 0
+    for key in biological_conservation_metrics:
+        bc_total += metrics_dict[key]
+    biological_conservation_score = float('{:.4f}'.format(bc_total/len(biological_conservation_metrics)))
+
+    metrics_dict['Biological Conservation'] = biological_conservation_score
+
+    return metrics_dict

oscb-0.1.0/oscb/evaluation/multimodal.py

@@ -0,0 +1,49 @@
+import numpy as np
+import pandas as pd 
+import os
+import subprocess
+import scanpy as sc
+import scipy.io
+import scib
+import muon as mu
+from muon import MuData
+
+
+def multimodal_metrics(mdata, embed, mod1='rna', batch='group', label_key='cell_type'):
+    scib_anndata = sc.AnnData(mdata.obsm[embed]).copy()
+    scib_anndata.obs = mdata.obs.copy()
+    scib_anndata.obsp["connectivities"] = mdata.obsp["connectivities"].copy()
+    scib_anndata.obsm[embed] = mdata.obsm[embed].copy()
+    scib_anndata = scib_anndata[~scib_anndata.obs[f"{mod1}:{batch}"].isna()] # Remove NaN in batch
+    scib_anndata = scib_anndata[~scib_anndata.obs[f"{mod1}:{label_key}"].isna()] # Remove NaN in cell type label
+    scib_anndata.obs[f"{mod1}:{batch}"] = scib_anndata.obs[f"{mod1}:{batch}"].astype("category")
+    scib_anndata.obs[f"{mod1}:{label_key}"] = scib_anndata.obs[f"{mod1}:{label_key}"].astype("category")
+    
+    metrics = scib.metrics.metrics(
+        scib_anndata,
+        scib_anndata,
+        batch_key=f"{mod1}:{batch}",
+        label_key=f"{mod1}:{label_key}",
+        embed=embed,
+        ari_=True,
+        nmi_=True,
+        silhouette_=True,
+        graph_conn_=True,
+        isolated_labels_asw_=True,
+    )
+
+    biological_conservation_metrics = ['NMI_cluster/label', 'ARI_cluster/label', 'ASW_label', 'cell_cycle_conservation','isolated_label_F1', 'isolated_label_silhouette', 'hvg_overlap']
+    metrics = metrics.fillna(0).to_dict()[0]
+
+    for key, value in metrics.items():
+        metrics[key] = float('{:.4f}'.format(value))
+
+    bc_total = 0
+    for key in biological_conservation_metrics:
+        bc_total += metrics[key]
+    biological_conservation_score = float('{:.4f}'.format(bc_total/len(biological_conservation_metrics)))
+
+    metrics['Biological Conservation'] = biological_conservation_score
+    scib_anndata = None
+
+    return metrics