scMultiChat 0.1.0__py3-none-any.whl

MultiChat/Analysis/Processing.py

@@ -0,0 +1,152 @@
+import pandas as pd
+import numpy as np
+from sklearn.neighbors import NearestNeighbors
+import scanpy as sc
+import os
+from tqdm import tqdm
+
+def knn_smoothing(mat, k, latent_matrix):
+    '''
+    KNN smoothing function: Smooth the input matrix using k-nearest neighbors.
+    '''
+    nbrs = NearestNeighbors(n_neighbors=k, algorithm='auto').fit(latent_matrix)
+    distances, indices = nbrs.kneighbors(latent_matrix)
+    smoothed_mat = np.zeros_like(mat)
+    for i in range(mat.shape[1]):
+        smoothed_mat[:, i] = mat[:, indices[i, :]].sum(axis=1)
+    
+    return smoothed_mat
+
+
+def Preprocess_CCC_model(base_path, lr_database, cell_rep, expmatrix):
+    '''
+    smooth the expression matrix using KNN smoothing and normalize the expression of ligands and receptors.
+    '''
+    latent_fea = cell_rep
+    mat = expmatrix.to_numpy()
+    mat_smooth = knn_smoothing(mat, k=3, latent_matrix=latent_fea)
+    expmatrix_smooth = pd.DataFrame(mat_smooth, index=expmatrix.index, columns=expmatrix.columns)
+    expmatrix_smooth.to_csv(os.path.join(base_path, "CCC/expression_smooth.txt"), sep="\t", index=True, header=True)
+
+    # adata = sc.AnnData(mat_smooth)
+    # sc.pp.scale(adata, zero_center=True, max_value=10) 
+    # data = adata.X 
+    # mat_it = np.sum(data > 0, axis=1) 
+
+    LR_ls = lr_database.apply(lambda row: f"{row['Ligand_Symbol']}->{row['Receptor_Symbol']}", axis=1).tolist()
+    ligand_exps = []
+    for ligand in lr_database['Ligand_Symbol']:
+        if '_' in ligand:
+            genes = ligand.split('_')
+            mean_expression = expmatrix_smooth.loc[genes, :].mean(axis=0)
+            ligand_exps.append(mean_expression)
+        else:
+            ligand_exps.append(expmatrix_smooth.loc[ligand, :])
+    ligand_exps = pd.DataFrame(ligand_exps, index=LR_ls, columns=expmatrix_smooth.columns)
+    receptor_exps = []
+    for receptor in lr_database['Receptor_Symbol']:
+        if '_' in receptor:
+            genes = receptor.split('_')
+            mean_expression = expmatrix_smooth.loc[genes, :].mean(axis=0)
+            receptor_exps.append(mean_expression)
+        else:
+            receptor_exps.append(expmatrix_smooth.loc[receptor, :])
+    receptor_exps = pd.DataFrame(receptor_exps, index=LR_ls, columns=expmatrix_smooth.columns)
+
+    ligand_exps_n = (ligand_exps - ligand_exps.min(axis=1).values[:, None]) / (ligand_exps.max(axis=1).values[:, None] - ligand_exps.min(axis=1).values[:, None]) 
+    receptor_exps_n = (receptor_exps - receptor_exps.min(axis=1).values[:, None]) / (receptor_exps.max(axis=1).values[:, None] - receptor_exps.min(axis=1).values[:, None])
+
+    pd.DataFrame(ligand_exps_n.T).to_csv(os.path.join(base_path, "CCC/ligands_expression.txt"), sep="\t", index=True, header=True)
+    pd.DataFrame(receptor_exps_n.T).to_csv(os.path.join(base_path, "CCC/receptors_expression.txt"), sep="\t", index=True, header=True)
+    
+    return ligand_exps_n.T, receptor_exps_n.T
+
+
+def select_peaks_by_genes_location(gene_info, hvg_genes, peaks_to_filter, scope = 250000):
+    filtered_gene_info = preprocess_gene_info(gene_info, scope)
+    gene_peaks = gene_peaks_pairs_by_location(filtered_gene_info, hvg_genes, peaks_to_filter)
+    filtered_peaks = select_peaks_from_pairs(gene_peaks)
+    
+    return filtered_peaks, gene_peaks
+
+
+def preprocess_gene_info(gene_info, scope = 250000):
+    filtered_gene_info = []
+    columns = ['id', 'chr', 'starts', 'ends', 'forward', 'backward', 'gene']
+    print("Preprocessing gene_info:")
+    for info in tqdm(gene_info.itertuples()):
+        chr = info.chr
+        starts = info.starts
+        ends = int(info.ends)
+        genes = info.genes
+        gene_info_id = chr + '-' + str(starts) + '-' + str(ends) + '-' + genes
+        forward = max(0, starts - scope)
+        backward = starts + scope
+        filtered_gene_info.append([gene_info_id, chr, starts, ends, forward, backward, genes])
+    filtered_gene_info = pd.DataFrame(filtered_gene_info, columns=columns)
+    filtered_gene_info = filtered_gene_info.drop_duplicates(subset=['id'])
+    return filtered_gene_info
+
+
+def gene_peaks_pairs_by_location(filtered_gene_info, hvg_genes, peaks_to_filter):
+    gene_peaks = {}
+    print("Search the genes-peaks correspondence based on gene_info and scope:")
+    for info in tqdm(filtered_gene_info.itertuples()):
+        if not info.gene in hvg_genes:
+            continue
+        id = info.id
+        chr = info.chr
+        starts = info.starts
+        ends = info.ends
+        forward = info.forward
+        backward = info.backward
+        gene = info.gene
+        if not gene in gene_peaks:
+            gene_peaks[gene] = set()
+        for peak in peaks_to_filter:
+            peak_chr, coordinates = peak.split(':')
+            peak_start, peak_end = coordinates.split('-')
+            if peak_chr == chr and int(peak_start) >= forward and int(peak_end) <= backward:
+                gene_peaks[gene].add(peak)
+    gene_peaks = {gene: peaks for gene, peaks in gene_peaks.items() if len(peaks) > 0}
+    return gene_peaks
+
+def select_peaks_from_pairs(gene_peaks):
+    filtered_peaks = set()
+    print("Search the filtered peaks:")
+    for key in tqdm(gene_peaks.keys()):
+        filtered_peaks.update(gene_peaks[key])
+    filtered_peaks = list(filtered_peaks)
+    print("After filtering peaks:", len(filtered_peaks))
+    return filtered_peaks
+
+def cicero_peaks_peaks(cicero_conn, peakitems, cicero_cotoff):
+    filtered_conn = cicero_conn[abs(cicero_conn['coaccess']) >= cicero_cotoff]
+    
+    result_dict = {}
+    for peakitem in tqdm(peakitems, desc="Processing peakitems"):
+        peak2_values = filtered_conn.loc[filtered_conn['Peak1'] == peakitem, 'Peak2'].tolist()
+        if peak2_values:
+            result_dict[peakitem] = peak2_values
+    
+    return result_dict
+
+def cicero_peaks_peaks_score(cicero_conn, peakitems, cicero_cotoff):
+    filtered_conn = cicero_conn[abs(cicero_conn['coaccess']) >= cicero_cotoff]
+    
+    relevant_peaks = filtered_conn[filtered_conn['Peak1'].isin(peakitems)]
+    
+    grouped = relevant_peaks.groupby('Peak1')
+    
+    peaks_lst = []
+    scores_lst = []
+    
+    for peakitem in tqdm(peakitems, desc="Processing peakitems"):
+        try:
+            group = grouped.get_group(peakitem)
+            peaks_lst.extend(group['Peak2'].tolist())
+            scores_lst.extend(group['coaccess'].tolist())
+        except KeyError:
+            continue  # No matches for this peakitem
+    
+    return peaks_lst, scores_lst

MultiChat/Analysis/__init__.py

@@ -0,0 +1,2 @@
+from . import Processing 
+from . import Intra_strength

MultiChat/Heterogeneous_g_emb/__init__.py

@@ -0,0 +1,13 @@
+"""Heterogeneous Graph Embedding Module of MultiChat"""
+
+from ._settings import settings
+from . import preprocessing as pp
+from . import tools as tl
+from . import plotting as pl
+from .readwrite import *
+from ._version import __version__
+
+
+import sys
+sys.modules.update(
+    {f'{__name__}.{m}': globals()[m] for m in ['tl', 'pp', 'pl']})

MultiChat/Heterogeneous_g_emb/_settings.py

@@ -0,0 +1,156 @@
+"""Configuration for HGE"""
+
+import os
+import seaborn as sns
+import matplotlib as mpl
+
+
+class HgeConfig:
+    """configuration class for HGE"""
+
+    def __init__(self,
+                 workdir='./result_hge',
+                 save_fig=False,
+                 n_jobs=1):
+        self.workdir = workdir
+        self.save_fig = save_fig
+        self.n_jobs = n_jobs
+        self.set_pbg_params()
+        self.graph_stats = dict()
+
+    def set_figure_params(self,
+                          context='notebook',
+                          style='white',
+                          palette='deep',
+                          font='sans-serif',
+                          font_scale=1.1,
+                          color_codes=True,
+                          dpi=80,
+                          dpi_save=150,
+                          fig_size=[5.4, 4.8],
+                          rc=None):
+        """ Set global parameters for figures. Modified from sns.set()
+
+        Parameters
+        ----------
+        context : string or dict
+            Plotting context parameters, see `seaborn.plotting_context`
+        style: `string`,optional (default: 'white')
+            Axes style parameters, see `seaborn.axes_style`
+        palette : string or sequence
+            Color palette, see `seaborn.color_palette`
+        font_scale: `float`, optional (default: 1.3)
+            Separate scaling factor to independently
+            scale the size of the font elements.
+        color_codes : `bool`, optional (default: True)
+            If ``True`` and ``palette`` is a seaborn palette,
+            remap the shorthand color codes (e.g. "b", "g", "r", etc.)
+            to the colors from this palette.
+        dpi: `int`,optional (default: 80)
+            Resolution of rendered figures.
+        dpi_save: `int`,optional (default: 150)
+            Resolution of saved figures.
+        rc: `dict`,optional (default: None)
+            rc settings properties.
+            Parameter mappings to override the values in the preset style.
+            Please see "`matplotlibrc file
+            <https://matplotlib.org/tutorials/introductory/customizing.html#a-sample-matplotlibrc-file>`__"
+        """
+        sns.set(context=context,
+                style=style,
+                palette=palette,
+                font=font,
+                font_scale=font_scale,
+                color_codes=color_codes,
+                rc={'figure.dpi': dpi,
+                    'savefig.dpi': dpi_save,
+                    'figure.figsize': fig_size,
+                    'image.cmap': 'viridis',
+                    'lines.markersize': 6,
+                    'legend.columnspacing': 0.1,
+                    'legend.borderaxespad': 0.1,
+                    'legend.handletextpad': 0.1,
+                    'pdf.fonttype': 42,
+                    })
+        if rc is not None:
+            assert isinstance(rc, dict), "rc must be dict"
+            for key, value in rc.items():
+                if key in mpl.rcParams.keys():
+                    mpl.rcParams[key] = value
+                else:
+                    raise Exception("unrecognized property '%s'" % key)
+
+    def set_workdir(self, workdir=None):
+        """Set working directory.
+
+        Parameters
+        ----------
+        workdir: `str`, optional (default: None)
+            Working directory.
+
+        Returns
+        -------
+        """
+        if workdir is None:
+            workdir = self.workdir
+            print("Using default working directory.")
+        if not os.path.exists(workdir):
+            os.makedirs(workdir)
+        self.workdir = workdir
+        self.set_pbg_params()
+        print('Saving results in: %s' % workdir)
+
+    def set_pbg_params(self, config=None):
+        """Set PBG parameters
+
+        Parameters
+        ----------
+        config : `dict`, optional (default: None)
+            PBG training configuration parameters.
+            By default it resets parameters to the default setting.
+
+        Returns
+        -------
+        """
+        if config is None:
+            config = dict(
+                # I/O data
+                entity_path="",
+                edge_paths=["", ],
+                checkpoint_path="",
+
+                # Graph structure
+                entities={},
+                relations=[],
+                dynamic_relations=False,
+
+                # Scoring model
+                dimension=50,
+                global_emb=False,
+                comparator='dot',
+
+                # Training
+                num_epochs=10,
+                workers=4,
+                num_batch_negs=50,
+                num_uniform_negs=50,
+                loss_fn='softmax',
+                lr=0.1,
+
+                early_stopping=False,
+                regularization_coef=0.0,
+                wd=0.0,
+                wd_interval=50,
+
+                # Evaluation during training
+                eval_fraction=0.05,
+                eval_num_batch_negs=50,
+                eval_num_uniform_negs=50,
+
+                checkpoint_preservation_interval=None,
+            )
+        assert isinstance(config, dict), "`config` must be dict"
+        self.pbg_params = config
+
+
+settings = HgeConfig()

MultiChat/Heterogeneous_g_emb/_utils.py

@@ -0,0 +1,143 @@
+"""Utility functions and classes"""
+
+import numpy as np
+from kneed import KneeLocator
+import tables
+from anndata import AnnData
+
+
+def locate_elbow(x, y, S=10, min_elbow=0,
+                 curve='convex', direction='decreasing', online=False,
+                 **kwargs):
+    """Detect knee points
+
+    Parameters
+    ----------
+    x : `array-like`
+        x values
+    y : `array-like`
+        y values
+    S : `float`, optional (default: 10)
+        Sensitivity
+    min_elbow: `int`, optional (default: 0)
+        The minimum elbow location
+    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
+    -------
+    elbow: `int`
+        elbow point
+    """
+    kneedle = KneeLocator(x[int(min_elbow):], y[int(min_elbow):],
+                          S=S, curve=curve,
+                          direction=direction,
+                          online=online,
+                          **kwargs,
+                          )
+    if kneedle.elbow is None:
+        elbow = len(y)
+    else:
+        elbow = int(kneedle.elbow)
+    return elbow
+
+
+# modifed from
+# scanpy https://github.com/theislab/scanpy/blob/master/scanpy/readwrite.py
+def _read_legacy_10x_h5(filename, genome=None):
+    """
+    Read hdf5 file from Cell Ranger v2 or earlier versions.
+    """
+    with tables.open_file(str(filename), 'r') as f:
+        try:
+            children = [x._v_name for x in f.list_nodes(f.root)]
+            if not genome:
+                if len(children) > 1:
+                    raise ValueError(
+                        f"'{filename}' contains more than one genome. "
+                        "For legacy 10x h5 "
+                        "files you must specify the genome "
+                        "if more than one is present. "
+                        f"Available genomes are: {children}"
+                    )
+                genome = children[0]
+            elif genome not in children:
+                raise ValueError(
+                    f"Could not find genome '{genome}' in '{filename}'. "
+                    f'Available genomes are: {children}'
+                )
+            dsets = {}
+            for node in f.walk_nodes('/' + genome, 'Array'):
+                dsets[node.name] = node.read()
+            # AnnData works with csr matrices
+            # 10x stores the transposed data, so we do the transposition
+            from scipy.sparse import csr_matrix
+
+            M, N = dsets['shape']
+            data = dsets['data']
+            if dsets['data'].dtype == np.dtype('int32'):
+                data = dsets['data'].view('float32')
+                data[:] = dsets['data']
+            matrix = csr_matrix(
+                (data, dsets['indices'], dsets['indptr']),
+                shape=(N, M),
+            )
+            # the csc matrix is automatically the transposed csr matrix
+            # as scanpy expects it, so, no need for a further transpostion
+            adata = AnnData(
+                matrix,
+                obs=dict(obs_names=dsets['barcodes'].astype(str)),
+                var=dict(
+                    var_names=dsets['gene_names'].astype(str),
+                    gene_ids=dsets['genes'].astype(str),
+                ),
+            )
+            return adata
+        except KeyError:
+            raise Exception('File is missing one or more required datasets.')
+
+
+# modifed from
+# scanpy https://github.com/theislab/scanpy/blob/master/scanpy/readwrite.py
+def _read_v3_10x_h5(filename):
+    """
+    Read hdf5 file from Cell Ranger v3 or later versions.
+    """
+    with tables.open_file(str(filename), 'r') as f:
+        try:
+            dsets = {}
+            for node in f.walk_nodes('/matrix', 'Array'):
+                dsets[node.name] = node.read()
+            from scipy.sparse import csr_matrix
+
+            M, N = dsets['shape']
+            data = dsets['data']
+            if dsets['data'].dtype == np.dtype('int32'):
+                data = dsets['data'].view('float32')
+                data[:] = dsets['data']
+            matrix = csr_matrix(
+                (data, dsets['indices'], dsets['indptr']),
+                shape=(N, M),
+            )
+            adata = AnnData(
+                matrix,
+                obs=dict(obs_names=dsets['barcodes'].astype(str)),
+                var=dict(
+                    var_names=dsets['name'].astype(str),
+                    gene_ids=dsets['id'].astype(str),
+                    feature_types=dsets['feature_type'].astype(str),
+                    genome=dsets['genome'].astype(str),
+                ),
+            )
+            return adata
+        except KeyError:
+            raise Exception('File is missing one or more required datasets.')

MultiChat/Heterogeneous_g_emb/_version.py

@@ -0,0 +1,3 @@
+"""Version information"""
+
+__version__ = "1.0"

MultiChat/Heterogeneous_g_emb/plotting/__init__.py

@@ -0,0 +1,19 @@
+"""Plotting"""
+
+from ._plot import (
+    pca_variance_ratio,
+    pcs_features,
+    variable_genes,
+    violin,
+    hist,
+    umap,
+    discretize,
+    node_similarity,
+    svd_nodes,
+)
+from ._post_training import (
+    pbg_metrics,
+    entity_metrics,
+    entity_barcode,
+    query
+)

MultiChat/Heterogeneous_g_emb/plotting/_palettes.py

@@ -0,0 +1,180 @@
+"""Color palettes in addition to matplotlib's palettes.
+This is modifed from
+scanpy palettes https://github.com/theislab/scanpy/blob/master/scanpy/plotting/palettes.py # noqa
+"""
+
+from matplotlib import cm, colors
+
+# Colorblindness adjusted vega_10
+# See https://github.com/theislab/scanpy/issues/387
+vega_10 = list(map(colors.to_hex, cm.tab10.colors))
+vega_10_scanpy = vega_10.copy()
+vega_10_scanpy[2] = "#279e68"  # green
+vega_10_scanpy[4] = "#aa40fc"  # purple
+vega_10_scanpy[8] = "#b5bd61"  # kakhi
+
+# default matplotlib 2.0 palette
+# see 'category20' on https://github.com/vega/vega/wiki/Scales#scale-range-literals # noqa
+vega_20 = list(map(colors.to_hex, cm.tab20.colors))
+
+# reorderd, some removed, some added
+vega_20_scanpy = [
+    *vega_20[0:14:2],
+    *vega_20[16::2],  # dark without grey
+    *vega_20[1:15:2],
+    *vega_20[17::2],  # light without grey
+    "#ad494a",
+    "#8c6d31",  # manual additions
+]
+vega_20_scanpy[2] = vega_10_scanpy[2]
+vega_20_scanpy[4] = vega_10_scanpy[4]
+vega_20_scanpy[7] = vega_10_scanpy[8]  # kakhi shifted by missing grey
+# TODO: also replace pale colors if necessary
+
+default_20 = vega_20_scanpy
+
+# https://graphicdesign.stackexchange.com/questions/3682/where-can-i-find-a-large-palette-set-of-contrasting-colors-for-coloring-many-d
+# update 1
+# orig reference http://epub.wu.ac.at/1692/1/document.pdf
+zeileis_28 = [
+    "#023fa5",
+    "#7d87b9",
+    "#bec1d4",
+    "#d6bcc0",
+    "#bb7784",
+    "#8e063b",
+    "#4a6fe3",
+    "#8595e1",
+    "#b5bbe3",
+    "#e6afb9",
+    "#e07b91",
+    "#d33f6a",
+    "#11c638",
+    "#8dd593",
+    "#c6dec7",
+    "#ead3c6",
+    "#f0b98d",
+    "#ef9708",
+    "#0fcfc0",
+    "#9cded6",
+    "#d5eae7",
+    "#f3e1eb",
+    "#f6c4e1",
+    "#f79cd4",
+    "#7f7f7f",
+    "#c7c7c7",
+    "#1CE6FF",
+    "#336600",  # these last ones were added,
+]
+
+default_28 = zeileis_28
+
+# from http://godsnotwheregodsnot.blogspot.de/2012/09/color-distribution-methodology.html # noqa
+godsnot_102 = [
+    # "#000000",
+    # remove the black, as often, we have black colored annotation
+    "#FFFF00",
+    "#1CE6FF",
+    "#FF34FF",
+    "#FF4A46",
+    "#008941",
+    "#006FA6",
+    "#A30059",
+    "#FFDBE5",
+    "#7A4900",
+    "#0000A6",
+    "#63FFAC",
+    "#B79762",
+    "#004D43",
+    "#8FB0FF",
+    "#997D87",
+    "#5A0007",
+    "#809693",
+    "#6A3A4C",
+    "#1B4400",
+    "#4FC601",
+    "#3B5DFF",
+    "#4A3B53",
+    "#FF2F80",
+    "#61615A",
+    "#BA0900",
+    "#6B7900",
+    "#00C2A0",
+    "#FFAA92",
+    "#FF90C9",
+    "#B903AA",
+    "#D16100",
+    "#DDEFFF",
+    "#000035",
+    "#7B4F4B",
+    "#A1C299",
+    "#300018",
+    "#0AA6D8",
+    "#013349",
+    "#00846F",
+    "#372101",
+    "#FFB500",
+    "#C2FFED",
+    "#A079BF",
+    "#CC0744",
+    "#C0B9B2",
+    "#C2FF99",
+    "#001E09",
+    "#00489C",
+    "#6F0062",
+    "#0CBD66",
+    "#EEC3FF",
+    "#456D75",
+    "#B77B68",
+    "#7A87A1",
+    "#788D66",
+    "#885578",
+    "#FAD09F",
+    "#FF8A9A",
+    "#D157A0",
+    "#BEC459",
+    "#456648",
+    "#0086ED",
+    "#886F4C",
+    "#34362D",
+    "#B4A8BD",
+    "#00A6AA",
+    "#452C2C",
+    "#636375",
+    "#A3C8C9",
+    "#FF913F",
+    "#938A81",
+    "#575329",
+    "#00FECF",
+    "#B05B6F",
+    "#8CD0FF",
+    "#3B9700",
+    "#04F757",
+    "#C8A1A1",
+    "#1E6E00",
+    "#7900D7",
+    "#A77500",
+    "#6367A9",
+    "#A05837",
+    "#6B002C",
+    "#772600",
+    "#D790FF",
+    "#9B9700",
+    "#549E79",
+    "#FFF69F",
+    "#201625",
+    "#72418F",
+    "#BC23FF",
+    "#99ADC0",
+    "#3A2465",
+    "#922329",
+    "#5B4534",
+    "#FDE8DC",
+    "#404E55",
+    "#0089A3",
+    "#CB7E98",
+    "#A4E804",
+    "#324E72",
+]
+
+default_102 = godsnot_102