scMultiChat 0.1.0__py3-none-any.whl

MultiChat/Heterogeneous_g_emb/plotting/_utils.py

@@ -0,0 +1,103 @@
+"""Utility functions and classes"""
+
+import numpy as np
+import pandas as pd
+from pandas.api.types import (
+    is_numeric_dtype,
+    is_string_dtype,
+    is_categorical_dtype,
+)
+import matplotlib as mpl
+
+from ._palettes import (
+    default_20,
+    default_28,
+    default_102
+)
+
+
+def get_colors(arr,
+               vmin=None,
+               vmax=None,
+               clip=False):
+    """Generate a list of colors for a given array
+    """
+
+    if not isinstance(arr, (pd.Series, np.ndarray)):
+        raise TypeError("`arr` must be pd.Series or np.ndarray")
+    colors = []
+    if is_numeric_dtype(arr):
+        image_cmap = mpl.rcParams['image.cmap']
+        cm = mpl.cm.get_cmap(image_cmap, 512)
+        if vmin is None:
+            vmin = min(arr)
+        if vmax is None:
+            vmax = max(arr)
+        norm = mpl.colors.Normalize(vmin=vmin, vmax=vmax, clip=clip)
+        colors = [mpl.colors.to_hex(cm(norm(x))) for x in arr]
+    elif is_string_dtype(arr) or is_categorical_dtype(arr):
+        categories = np.unique(arr)
+        length = len(categories)
+        # check if default matplotlib palette has enough colors
+        # mpl.style.use('default')
+        if len(mpl.rcParams['axes.prop_cycle'].by_key()['color']) >= length:
+            cc = mpl.rcParams['axes.prop_cycle']()
+            palette = [mpl.colors.rgb2hex(next(cc)['color'])
+                       for _ in range(length)]
+        else:
+            if length <= 20:
+                palette = default_20
+            elif length <= 28:
+                palette = default_28
+            elif length <= len(default_102):  # 103 colors
+                palette = default_102
+            else:
+                rgb_rainbow = mpl.cm.rainbow(np.linspace(0, 1, length))
+                palette = [mpl.colors.rgb2hex(rgb_rainbow[i, :-1])
+                           for i in range(length)]
+        colors = pd.Series(['']*len(arr))
+        for i, x in enumerate(categories):
+            ids = np.where(arr == x)[0]
+            colors[ids] = palette[i]
+        colors = list(colors)
+    else:
+        raise TypeError("unsupported data type for `arr`")
+    return colors
+
+
+def generate_palette(arr):
+    """Generate a color palette for a given array
+    """
+
+    if not isinstance(arr, (pd.Series, np.ndarray)):
+        raise TypeError("`arr` must be pd.Series or np.ndarray")
+    colors = []
+    if is_string_dtype(arr) or is_categorical_dtype(arr):
+        categories = np.unique(arr)
+        length = len(categories)
+        # check if default matplotlib palette has enough colors
+        # mpl.style.use('default')
+        if len(mpl.rcParams['axes.prop_cycle'].by_key()['color']) >= length:
+            cc = mpl.rcParams['axes.prop_cycle']()
+            palette = [mpl.colors.rgb2hex(next(cc)['color'])
+                       for _ in range(length)]
+        else:
+            if length <= 20:
+                palette = default_20
+            elif length <= 28:
+                palette = default_28
+            elif length <= len(default_102):  # 103 colors
+                palette = default_102
+            else:
+                rgb_rainbow = mpl.cm.rainbow(np.linspace(0, 1, length))
+                palette = [mpl.colors.rgb2hex(rgb_rainbow[i, :-1])
+                           for i in range(length)]
+        colors = pd.Series(['']*len(arr))
+        for i, x in enumerate(categories):
+            ids = np.where(arr == x)[0]
+            colors[ids] = palette[i]
+        colors = list(colors)
+    else:
+        raise TypeError("unsupported data type for `arr`")
+    dict_palette = dict(zip(arr, colors))
+    return dict_palette

MultiChat/Heterogeneous_g_emb/preprocessing/__init__.py

@@ -0,0 +1,26 @@
+"""Preprocessing"""
+
+from ._general import (
+    log_transform,
+    normalize,
+    binarize
+)
+from ._qc import (
+    cal_qc,
+    cal_qc_rna,
+    cal_qc_atac,
+    filter_samples,
+    filter_cells_rna,
+    filter_cells_atac,
+    filter_features,
+    filter_genes,
+    filter_peaks,
+)
+from ._pca import (
+    pca,
+    select_pcs,
+    select_pcs_features,
+)
+from ._variable_genes import (
+    select_variable_genes
+)

MultiChat/Heterogeneous_g_emb/preprocessing/_general.py

@@ -0,0 +1,91 @@
+"""General preprocessing functions"""
+
+import numpy as np
+from sklearn.utils import sparsefuncs
+from sklearn import preprocessing
+from ._utils import (
+    cal_tf_idf
+)
+from scipy.sparse import (
+    issparse,
+    csr_matrix,
+)
+
+
+def log_transform(adata):
+    """Return the natural logarithm of one plus the input array, element-wise.
+
+    Parameters
+    ----------
+    adata: AnnData
+        Annotated data matrix.
+
+    Returns
+    -------
+    updates `adata` with the following fields.
+    X: `numpy.ndarray` (`adata.X`)
+        Store #observations × #var_genes logarithmized data matrix.
+    """
+    if not issparse(adata.X):
+        adata.X = csr_matrix(adata.X)
+    adata.X = np.log1p(adata.X)
+    return None
+
+
+def binarize(adata,
+             threshold=1e-5):
+    """Binarize an array.
+    Parameters
+    ----------
+    adata: AnnData
+        Annotated data matrix.
+    threshold: `float`, optional (default: 1e-5)
+        Values below or equal to this are replaced by 0, above it by 1.
+
+    Returns
+    -------
+    updates `adata` with the following fields.
+    X: `numpy.ndarray` (`adata.X`)
+        Store #observations × #var_genes binarized data matrix.
+    """
+    if not issparse(adata.X):
+        adata.X = csr_matrix(adata.X)
+    adata.X = preprocessing.binarize(adata.X,
+                                     threshold=threshold,
+                                     copy=True)
+
+
+def normalize(adata,
+              method='lib_size',
+              scale_factor=1e4,
+              save_raw=True):
+    """Normalize count matrix.
+
+    Parameters
+    ----------
+    adata: AnnData
+        Annotated data matrix.
+    method: `str`, optional (default: 'lib_size')
+        Choose from {{'lib_size','tf_idf'}}
+        Method used for dimension reduction.
+        'lib_size': Total-count normalize (library-size correct)
+        'tf_idf': TF-IDF (term frequency–inverse document frequency)
+        transformation
+
+    Returns
+    -------
+    updates `adata` with the following fields.
+    X: `numpy.ndarray` (`adata.X`)
+        Store #observations × #var_genes normalized data matrix.
+    """
+    if method not in ['lib_size', 'tf_idf']:
+        raise ValueError("unrecognized method '%s'" % method)
+    if not issparse(adata.X):
+        adata.X = csr_matrix(adata.X)
+    if save_raw:
+        adata.layers['raw'] = adata.X.copy()
+    if method == 'lib_size':
+        sparsefuncs.inplace_row_scale(adata.X, 1/adata.X.sum(axis=1).A)
+        adata.X = adata.X*scale_factor
+    if method == 'tf_idf':
+        adata.X = cal_tf_idf(adata.X)

MultiChat/Heterogeneous_g_emb/preprocessing/_pca.py

@@ -0,0 +1,182 @@
+"""Principal component analysis"""
+
+import numpy as np
+from sklearn.decomposition import TruncatedSVD
+from ._utils import (
+    locate_elbow,
+)
+
+
+def pca(adata,
+        n_components=50,
+        algorithm='randomized',
+        n_iter=5,
+        random_state=2021,
+        tol=0.0,
+        feature=None,
+        **kwargs,
+        ):
+    """perform Principal Component Analysis (PCA)
+
+    Parameters
+    ----------
+    adata: AnnData
+        Annotated data matrix.
+    n_components: `int`, optional (default: 50)
+        Desired dimensionality of output data
+    algorithm: `str`, optional (default: 'randomized')
+        SVD solver to use. Choose from {'arpack', 'randomized'}.
+    n_iter: `int`, optional (default: '5')
+        Number of iterations for randomized SVD solver.
+        Not used by ARPACK.
+    tol: `float`, optional (default: 0)
+        Tolerance for ARPACK. 0 means machine precision.
+        Ignored by randomized SVD solver.
+    feature: `str`, optional (default: None)
+        Feature used to perform PCA.
+        The data type of `.var[feature]` needs to be `bool`
+        If None, adata.X will be used.
+    kwargs:
+        Other keyword arguments are passed down to `TruncatedSVD()`
+
+    Returns
+    -------
+    updates `adata` with the following fields:
+    `.obsm['X_pca']` : `array`
+        PCA transformed X.
+    `.uns['pca']['PCs']` : `array`
+        Principal components in feature space,
+        representing the directions of maximum variance in the data.
+    `.uns['pca']['variance']` : `array`
+        The variance of the training samples transformed by a
+        projection to each component.
+    `.uns['pca']['variance_ratio']` : `array`
+        Percentage of variance explained by each of the selected components.
+    """
+    if feature is None:
+        X = adata.X.copy()
+    else:
+        mask = adata.var[feature]
+        X = adata[:, mask].X.copy()
+    svd = TruncatedSVD(n_components=n_components,
+                       algorithm=algorithm,
+                       n_iter=n_iter,
+                       random_state=random_state,
+                       tol=tol,
+                       **kwargs)
+    svd.fit(X)
+    adata.obsm['X_pca'] = svd.transform(X)
+    adata.uns['pca'] = dict()
+    adata.uns['pca']['n_pcs'] = n_components
+    adata.uns['pca']['PCs'] = svd.components_.T
+    adata.uns['pca']['variance'] = svd.explained_variance_
+    adata.uns['pca']['variance_ratio'] = svd.explained_variance_ratio_
+
+
+def select_pcs(adata,
+               n_pcs=None,
+               S=1,
+               curve='convex',
+               direction='decreasing',
+               online=False,
+               min_elbow=None,
+               **kwargs):
+    """select top PCs based on variance_ratio
+
+    Parameters
+    ----------
+    n_pcs: `int`, optional (default: None)
+        If n_pcs is None,
+        the number of PCs will be automatically selected with "`kneed
+        <https://kneed.readthedocs.io/>`__"
+    S : `float`, optional (default: 1)
+        Sensitivity
+    min_elbow: `int`, optional (default: None)
+        The minimum elbow location
+        By default, it is n_components/10
+    curve: `str`, optional (default: 'convex')
+        Choose from {'convex','concave'}
+        If 'concave', algorithm will detect knees,
+        If 'convex', algorithm will detect elbows.
+    direction: `str`, optional (default: 'decreasing')
+        Choose from {'decreasing','increasing'}
+    online: `bool`, optional (default: False)
+        kneed will correct old knee points if True,
+        kneed will return first knee if False.
+    **kwargs: `dict`, optional
+        Extra arguments to KneeLocator.
+    Returns
+
+    """
+    if n_pcs is None:
+        n_components = adata.obsm['X_pca'].shape[1]
+        if min_elbow is None:
+            min_elbow = n_components/10
+        n_pcs = locate_elbow(range(n_components),
+                             adata.uns['pca']['variance_ratio'],
+                             S=S,
+                             curve=curve,
+                             min_elbow=min_elbow,
+                             direction=direction,
+                             online=online,
+                             **kwargs)
+        adata.uns['pca']['n_pcs'] = n_pcs
+    else:
+        adata.uns['pca']['n_pcs'] = n_pcs
+
+
+def select_pcs_features(adata,
+                        S=1,
+                        curve='convex',
+                        direction='decreasing',
+                        online=False,
+                        min_elbow=None,
+                        **kwargs):
+    """select features that contribute to the top PCs
+
+    Parameters
+    ----------
+    S : `float`, optional (default: 10)
+        Sensitivity
+    min_elbow: `int`, optional (default: None)
+        The minimum elbow location.
+        By default, it is #features/6
+    curve: `str`, optional (default: 'convex')
+        Choose from {'convex','concave'}
+        If 'concave', algorithm will detect knees,
+        If 'convex', algorithm will detect elbows.
+    direction: `str`, optional (default: 'decreasing')
+        Choose from {'decreasing','increasing'}
+    online: `bool`, optional (default: False)
+        kneed will correct old knee points if True,
+        kneed will return first knee if False.
+    **kwargs: `dict`, optional
+        Extra arguments to KneeLocator.
+    Returns
+    -------
+    """
+    n_pcs = adata.uns['pca']['n_pcs']
+    n_features = adata.uns['pca']['PCs'].shape[0]
+    if min_elbow is None:
+        min_elbow = n_features/6
+    adata.uns['pca']['features'] = dict()
+    ids_features = list()
+    for i in range(n_pcs):
+        elbow = locate_elbow(range(n_features),
+                             np.sort(
+                                 np.abs(adata.uns['pca']['PCs'][:, i],))[::-1],
+                             S=S,
+                             min_elbow=min_elbow,
+                             curve=curve,
+                             direction=direction,
+                             online=online,
+                             **kwargs)
+        ids_features_i = \
+            list(np.argsort(np.abs(
+                adata.uns['pca']['PCs'][:, i],))[::-1][:elbow])
+        adata.uns['pca']['features'][f'pc_{i}'] = ids_features_i
+        ids_features = ids_features + ids_features_i
+        print(f'#features selected from PC {i}: {len(ids_features_i)}')
+    adata.var['top_pcs'] = False
+    adata.var.loc[adata.var_names[np.unique(ids_features)], 'top_pcs'] = True
+    print(f'#features in total: {adata.var["top_pcs"].sum()}')