From 27b5d8698e06eb85da58b2f4c92d4c4bfcf377b7 Mon Sep 17 00:00:00 2001 From: Ajit Johnson Nirmal Date: Mon, 18 Mar 2024 11:08:50 -0400 Subject: [PATCH] adding correlation functions --- docs/Functions/pl/groupCorrelation.md | 5 + docs/Functions/pl/markerCorrelation.md | 5 + .../nbs/Prepare Data for SCIMAP.ipynb | 156 +++++------- ...rvised clustering to phenotype cells.ipynb | 215 +++++++++++++++- mkdocs.yml | 2 + pyproject.toml | 4 +- scimap/plotting/__init__.py | 4 +- scimap/plotting/groupCorrelation.py | 238 ++++++++++++++++++ scimap/plotting/heatmap.py | 14 +- scimap/plotting/markerCorrelation.py | 232 +++++++++++++++++ scimap/preprocessing/log1p.py | 2 + scimap/preprocessing/ngraph.py | 99 ++++++++ scimap/tools/cluster.py | 170 ++++++------- 13 files changed, 955 insertions(+), 191 deletions(-) create mode 100644 docs/Functions/pl/groupCorrelation.md create mode 100644 docs/Functions/pl/markerCorrelation.md create mode 100644 scimap/plotting/groupCorrelation.py create mode 100644 scimap/plotting/markerCorrelation.py create mode 100644 scimap/preprocessing/ngraph.py diff --git a/docs/Functions/pl/groupCorrelation.md b/docs/Functions/pl/groupCorrelation.md new file mode 100644 index 00000000..e208f6ce --- /dev/null +++ b/docs/Functions/pl/groupCorrelation.md @@ -0,0 +1,5 @@ +--- +hide: + - toc # Hide table of contents +--- +::: scimap.plotting.groupCorrelation \ No newline at end of file diff --git a/docs/Functions/pl/markerCorrelation.md b/docs/Functions/pl/markerCorrelation.md new file mode 100644 index 00000000..a22cef9a --- /dev/null +++ b/docs/Functions/pl/markerCorrelation.md @@ -0,0 +1,5 @@ +--- +hide: + - toc # Hide table of contents +--- +::: scimap.plotting.markerCorrelation \ No newline at end of file diff --git a/docs/tutorials/nbs/Prepare Data for SCIMAP.ipynb b/docs/tutorials/nbs/Prepare Data for SCIMAP.ipynb index ce79bfca..45a7d607 100644 --- a/docs/tutorials/nbs/Prepare Data for SCIMAP.ipynb +++ b/docs/tutorials/nbs/Prepare Data for SCIMAP.ipynb @@ -10,10 +10,28 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 1, "id": "dee3edb2-9621-42fe-8244-111e34945b91", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Running SCIMAP 1.3.8\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/aj/miniconda3/envs/scimap/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning:\n", + "\n", + "IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + "\n" + ] + } + ], "source": [ "# import scimap\n", "import scimap as sm" @@ -31,7 +49,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 2, "id": "e26cfe65-4bf3-4558-85e8-2d4010b2110f", "metadata": {}, "outputs": [ @@ -61,7 +79,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 3, "id": "f10e382b-02b7-40ab-9e3f-4dfd8b1ba0a5", "metadata": {}, "outputs": [ @@ -70,10 +88,11 @@ "text/plain": [ "AnnData object with n_obs × n_vars = 11201 × 9\n", " obs: 'X_centroid', 'Y_centroid', 'Area', 'MajorAxisLength', 'MinorAxisLength', 'Eccentricity', 'Solidity', 'Extent', 'Orientation', 'CellID', 'imageid'\n", - " uns: 'all_markers'" + " uns: 'all_markers'\n", + " layers: 'log'" ] }, - "execution_count": 5, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } @@ -87,7 +106,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 4, "id": "d8713803-ab13-4b31-b693-efedd4ccdae8", "metadata": {}, "outputs": [ @@ -109,7 +128,7 @@ " 6.73978032]])" ] }, - "execution_count": 8, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -122,7 +141,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 5, "id": "527582cb-7796-45f3-81eb-bccae5ef2e8a", "metadata": {}, "outputs": [ @@ -389,7 +408,7 @@ "[11201 rows x 11 columns]" ] }, - "execution_count": 9, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -401,7 +420,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 6, "id": "ea937485-6871-47a1-a308-c2e1e4b002df", "metadata": {}, "outputs": [ @@ -466,7 +485,7 @@ "Index: [ELANE, CD57, CD45, CD11B, SMA, CD16, ECAD, FOXP3, NCAM]" ] }, - "execution_count": 10, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -502,7 +521,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 7, "id": "85510c7b-a68a-40f4-86e4-b98ac54e411a", "metadata": {}, "outputs": [], @@ -539,115 +558,78 @@ }, { "cell_type": "markdown", - "id": "986db9f2-a6b5-4950-9cb5-202c391d9a82", + "id": "1bf35ced-e150-4662-aeb2-2afe35d8aa19", "metadata": {}, "source": [ - "
" + "When manually importing data without using the built-in function that automates the process, it is crucial to follow four essential steps to ensure compatibility and effective data management for further analysis:\n", + "\n", + "1. **Ensure Unique Image Identification**: Incorporate a column named `imageid` within the metadata to assign a unique identifier to each image, especially when handling datasets comprising multiple images. This facilitates the organization and retrieval of specific image data within a larger dataset.\n", + " \n", + "2. **Preserve Raw Data**: Store the unprocessed raw data in `adata.raw`. This practice retains the original state of the data for reference or baseline comparisons before any preprocessing steps are applied.\n", + "\n", + "3. **Log Transformation Layer**: Generate a layer named `log` to hold log-transformed data. Log transformation is a critical step for normalizing data and mitigating the impact of large-scale differences across measurements, enhancing the analysis's robustness and interpretability.\n", + "\n", + "4. **Marker Annotation**: Maintain a record of all markers present in the images, ensuring their order matches the layers within the image data. This annotation is instrumental when loading images to precisely identify which layer corresponds to each marker, thus streamlining the analysis process by clarifying the relationship between image layers and their respective biological markers.\n", + "\n", + "By adhering to these guidelines, researchers can ensure their manually imported datasets are well-organized and primed for comprehensive analysis, leveraging the full capabilities of their analytical platforms." ] }, { - "cell_type": "markdown", - "id": "e78346dc-3a4f-480b-8be2-345f143f4a50", + "cell_type": "code", + "execution_count": null, + "id": "cd360b8b-0d67-417b-abe1-51e3b7141119", "metadata": {}, + "outputs": [], "source": [ - "## Save the annData object" + "# preserve raw data\n", + "adata.raw = adata\n", + "\n", + "# log transform data\n", + "adata = sm.pp.log1p(adata)\n", + "\n", + "# Add marker annotation\n", + "adata.uns['all_markers'] = ['list', 'of', 'markers']" ] }, { "cell_type": "markdown", - "id": "a995eb86-1fd8-41ff-a511-d56439450f3a", - "metadata": {}, - "source": [ - "Once the AnnData object is created, it becomes the central data structure for all subsequent analyses. This is highly beneficial because it encapsulates all results within the object, eliminating the need to manage multiple related files. You can conveniently share this single file with collaborators, allowing them to continue the analysis seamlessly or resume from where you left off. Furthermore, numerous single-cell analysis tools, such as Scanpy, are built upon this framework. This integration allows for the straightforward application of functions from various packages without the necessity of data reformatting to suit each tool's specific requirements." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "cc19d2dc-66a3-4a71-817e-71650206e5be", + "id": "986db9f2-a6b5-4950-9cb5-202c391d9a82", "metadata": {}, - "outputs": [], "source": [ - "# Save the results\n", - "adata.write('/Users/aj/Dropbox (Partners HealthCare)/nirmal lab/resources/exemplarData/scimapExampleData/scimapExampleData.h5ad')" + "
" ] }, { "cell_type": "markdown", - "id": "f59b0d22-0f25-41f4-80fc-2797f3236c7a", + "id": "e78346dc-3a4f-480b-8be2-345f143f4a50", "metadata": {}, "source": [ - "\n", - "`sm.tl.cluster` function can be used for clustering cells within the dataset. It supports three popular clustering algorithms:\n", - "\n", - "- kmeans\n", - "- phenograph\n", - "- leiden\n", - " \n", - "Users are encouraged to select the clustering algorithm that best matches their data's nature and their analytical goals." + "## Save the annData object" ] }, { - "cell_type": "code", - "execution_count": 10, - "id": "75989db3-a550-4f4d-8264-d974f4a048a8", + "cell_type": "markdown", + "id": "a995eb86-1fd8-41ff-a511-d56439450f3a", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Leiden clustering\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/aj/miniconda3/envs/scimap/lib/python3.10/site-packages/scanpy/preprocessing/_pca.py:229: ImplicitModificationWarning:\n", - "\n", - "Setting element `.obsm['X_pca']` of view, initializing view as actual.\n", - "\n" - ] - } - ], "source": [ - "adata = sm.tl.cluster(adata, method='leiden', resolution=0.2)" + "Once the AnnData object is created, it becomes the central data structure for all subsequent analyses. This is highly beneficial because it encapsulates all results within the object, eliminating the need to manage multiple related files. You can conveniently share this single file with collaborators, allowing them to continue the analysis seamlessly or resume from where you left off. Furthermore, numerous single-cell analysis tools, such as Scanpy, are built upon this framework. This integration allows for the straightforward application of functions from various packages without the necessity of data reformatting to suit each tool's specific requirements." ] }, { "cell_type": "code", - "execution_count": 11, - "id": "a0606b96-85a8-470d-8259-8e3689ab2a85", + "execution_count": 9, + "id": "cc19d2dc-66a3-4a71-817e-71650206e5be", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "leiden\n", - "0 4070\n", - "1 2847\n", - "2 2658\n", - "3 1063\n", - "4 482\n", - "5 81\n", - "Name: count, dtype: int64" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "# view the results\n", - "adata.obs['leiden'].value_counts()" + "# Save the results\n", + "adata.write('/Users/aj/Dropbox (Partners HealthCare)/nirmal lab/resources/exemplarData/scimapExampleData/scimapExampleData.h5ad')" ] }, { "cell_type": "code", "execution_count": null, - "id": "410acf2b-37cf-45f8-b4f9-db477f127d0b", + "id": "de8e5905-a2b9-4b2b-a500-450ead7b741e", "metadata": {}, "outputs": [], "source": [] diff --git a/docs/tutorials/nbs/Unsupervised clustering to phenotype cells.ipynb b/docs/tutorials/nbs/Unsupervised clustering to phenotype cells.ipynb index 2824dde9..0427a4e8 100644 --- a/docs/tutorials/nbs/Unsupervised clustering to phenotype cells.ipynb +++ b/docs/tutorials/nbs/Unsupervised clustering to phenotype cells.ipynb @@ -10,10 +10,28 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 1, "id": "ffa62381-6e60-4b50-9339-d1a3aaccd201", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Running SCIMAP 1.3.8\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/aj/miniconda3/envs/scimap/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning:\n", + "\n", + "IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + "\n" + ] + } + ], "source": [ "# import packages\n", "import scimap as sm\n", @@ -22,7 +40,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 2, "id": "d426546f-614d-4ffb-b204-e2a3c0c5618f", "metadata": {}, "outputs": [], @@ -31,10 +49,199 @@ "adata = ad.read_h5ad('/Users/aj/Dropbox (Partners HealthCare)/nirmal lab/resources/exemplarData/scimapExampleData/scimapExampleData.h5ad')" ] }, + { + "cell_type": "markdown", + "id": "5fe09562-1b75-45e9-a01a-d6540e857a66", + "metadata": {}, + "source": [ + "`sm.tl.cluster` function can be used for clustering cells within the dataset. It supports three popular clustering algorithms:\n", + "\n", + "- kmeans\n", + "- phenograph\n", + "- leiden\n", + " \n", + "Users are encouraged to select the clustering algorithm that best matches their data's nature and their analytical goals." + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "f981540d-ade7-4651-8724-2c859d64f9c5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Leiden clustering\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/aj/miniconda3/envs/scimap/lib/python3.10/site-packages/scanpy/preprocessing/_pca.py:229: ImplicitModificationWarning:\n", + "\n", + "Setting element `.obsm['X_pca']` of view, initializing view as actual.\n", + "\n" + ] + } + ], + "source": [ + "adata = sm.tl.cluster(adata, method='leiden', resolution=0.3, use_raw=False, log=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "bc62e068-8922-4788-b4b2-20a95073f4f9", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "leiden\n", + "0 3895\n", + "1 2661\n", + "2 1563\n", + "3 1223\n", + "4 820\n", + "5 496\n", + "6 462\n", + "7 81\n", + "Name: count, dtype: int64" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# view the results\n", + "adata.obs['leiden'].value_counts()" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "b04227b3-13b5-4d60-907d-47548394f06c", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/aj/miniconda3/envs/scimap/lib/python3.10/site-packages/scimap/plotting/heatmap.py:318: UserWarning:\n", + "\n", + "This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n", + "\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sm.pl.heatmap(adata, groupBy='leiden', standardScale='column', figsize=(5,4), showPrevalence=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "id": "ad8ddf73-907b-4d39-9037-e165ec80b810", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Renaming 5 to tumor\n", + "Renaming 1 to tumor\n", + "Renaming 2 to myeloid\n", + "Renaming 6 to Treg\n", + "Renaming 4 to vessels\n", + "Renaming 7 to artifacts\n", + "Renaming 3 to unknown\n", + "Renaming 0 to unknown\n" + ] + } + ], + "source": [ + "\n", + "rename_dict = {'tumor': ['5','1'],\n", + " 'myeloid': ['2'],\n", + " 'Treg': ['6'],\n", + " 'vessels': ['4'],\n", + " 'artifacts': ['7'],\n", + " 'unknown': ['3','0']}\n", + "\n", + "adata = sm.hl.rename(adata, rename=rename_dict, from_column='leiden', to_column='leiden_phenotype')" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "id": "4d3ca8f0-bc90-494f-b376-7a8d9cef3d98", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/aj/miniconda3/envs/scimap/lib/python3.10/site-packages/scimap/plotting/heatmap.py:318: UserWarning:\n", + "\n", + "This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n", + "\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sm.pl.heatmap(adata, groupBy='leiden_phenotype', standardScale='column', figsize=(5,4), showPrevalence=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "id": "12757afa-964f-4ef3-820e-f49a3264d9cc", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sm.pl.spatial_scatterPlot (adata, colorBy = ['leiden_phenotype'],figsize=(3,3), s=0.7, fontsize=5, catCmap='Set1')" + ] + }, { "cell_type": "code", "execution_count": null, - "id": "de949ffe-1b67-4407-a579-9f99cc85ab51", + "id": "5a3fc2ea-93fa-410d-94c8-0b481d5ff627", "metadata": {}, "outputs": [], "source": [] diff --git a/mkdocs.yml b/mkdocs.yml index afdfb9de..9fe2b35c 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -59,6 +59,8 @@ nav: - addROI_image: 'Functions/pl/addROI_image.md' - gate_finder: 'Functions/pl/gate_finder.md' - heatmap: 'Functions/pl/heatmap.md' + - markerCorrelation: 'Functions/pl/markerCorrelation.md' + - groupCorrelation: 'Functions/pl/groupCorrelation.md' - distPlot: 'Functions/pl/distPlot.md' - densityPlot2D: 'Functions/pl/densityPlot2D.md' - cluster_plots: 'Functions/pl/cluster_plots.md' diff --git a/pyproject.toml b/pyproject.toml index 79f884fd..03609f17 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,7 +1,7 @@ [tool.poetry] name = "SCIMAP" -version = "1.3.6" +version = "1.3.9" description = "Spatial Single-Cell Analysis Toolkit" license = "MIT" @@ -23,6 +23,8 @@ classifiers = [ "Programming Language :: Python", ] +exclude = ["docs"] + [tool.poetry.dependencies] python = ">=3.9,<3.11" diff --git a/scimap/plotting/__init__.py b/scimap/plotting/__init__.py index d655099a..8f7b2c6a 100644 --- a/scimap/plotting/__init__.py +++ b/scimap/plotting/__init__.py @@ -13,4 +13,6 @@ from .densityPlot2D import densityPlot2D from .distPlot import distPlot from .spatial_scatterPlot import spatial_scatterPlot -from .heatmap import heatmap \ No newline at end of file +from .heatmap import heatmap +from .markerCorrelation import markerCorrelation +from .groupCorrelation import groupCorrelation \ No newline at end of file diff --git a/scimap/plotting/groupCorrelation.py b/scimap/plotting/groupCorrelation.py new file mode 100644 index 00000000..ba90e86a --- /dev/null +++ b/scimap/plotting/groupCorrelation.py @@ -0,0 +1,238 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +#Created on Mon Mar 18 08:48:29 2024 +#@author: Ajit Johnson Nirmal + +""" +!!! abstract "Short Description" + The `sm.pl.groupCorrelation` function calculates and visualizes the correlation between group abundances across various conditions within an `AnnData` object. Customizable features such as normalization, hierarchical clustering, and manual ordering are available. + +## Function +""" + +# lib +import numpy as np +import matplotlib.pyplot as plt +from scipy.spatial.distance import pdist +from scipy.cluster.hierarchy import linkage, dendrogram +import os +import anndata as ad +import warnings +from scipy.stats import zscore +import argparse + +# function +def groupCorrelation(adata, + groupBy, + condition, + normalize=False, + subsetGroups=None, + orderRow=None, + orderColumn=None, + clusterRows=True, + clusterColumns=True, + cmap='vlag', + figsize=None, + overlayValues=False, + fontSize=10, + fontColor='black', + fileName='groupCorrelation.pdf', + saveDir=None, + **kwargs): + + """ +Parameters: + adata (AnnData or str): + An AnnData object containing the dataset, or a string path to an AnnData file to be loaded. + + groupBy (str): + The column in `adata.obs` used for defining groups. + + condition (str): + The column in `adata.obs` that distinguishes different conditions or samples. + + normalize (bool, optional): + If True, apply z-score normalization to the group counts across conditions. + + subsetGroups (list of str, optional): + A list specifying a subset of groups to include in the analysis. If None, all groups are included. + + orderRow (list of str, optional): + Custom order for the rows in the heatmap. If None, the order is determined by clustering or the original group order. + + orderColumn (list of str, optional): + Custom order for the columns in the heatmap. + + clusterRows (bool, optional): + Whether to apply hierarchical clustering to rows. + + clusterColumns (bool, optional): + Whether to apply hierarchical clustering to columns. + + cmap (str, optional): + The colormap for the heatmap. + + figsize (tuple of float, optional): + The size of the figure to create (width, height). If None, the size is inferred. + + overlayValues (bool, optional): + If True, overlays the correlation coefficient values on the heatmap. + + fontSize (int, optional): + Font size for overlay values. + + fontColor (str, optional): + Color of the font used for overlay values. + + fileName (str, optional): + Name of the file to save the heatmap. Relevant only if `saveDir` is specified. + + saveDir (str, optional): + Directory to save the generated heatmap. If None, the heatmap is not saved. + +Returns: + plot (matplotlib): + Displays or saves a heatmap visualizing the correlation between specified groups. + +Example: + ```python + + # Basic usage with auto-detected conditions and groups + sm.pl.groupCorrelation(adata, groupBy='cell_type', condition='patient_id') + + # Normalized group counts with specific groups and custom clustering disabled + sm.pl.groupCorrelation(adata, groupBy='cell_type', condition='patient_id', normalize=True, + subsetGroups=['B cells', 'T cells'], clusterRows=False, clusterColumns=False) + + # Using custom ordering and overlaying values with specified font size and color + sm.pl.groupCorrelation(adata, groupBy='cell_type', condition='patient_id', overlayValues=True, + orderRow=['T cells', 'B cells'], fontSize=12, fontColor='blue', + saveDir='/path/to/results', fileName='customGroupCorrelation.pdf') + ``` + +""" + + # Load adata if a path is provided + if isinstance(adata, str): + adata = ad.read_h5ad(adata) + + # Calculate group counts + group_counts = adata.obs.groupby([condition, groupBy]).size().unstack(fill_value=0) + + # Subset groups if needed + if subsetGroups: + group_counts = group_counts[subsetGroups] + + # Normalize if requested + if normalize: + group_counts = group_counts.apply(zscore, axis=0) + + # Calculate correlation + corr_matrix = group_counts.corr() + + # var_names for axis labels, directly from group_counts columns + var_names = group_counts.columns.tolist() + + # Manual ordering takes precedence over clustering + if orderRow and clusterRows: + warnings.warn("Both orderRow and clusterRows were provided. Proceeding with orderRow and ignoring clusterRows.") + clusterRows = False + if orderColumn and clusterColumns: + warnings.warn("Both orderColumn and clusterColumns were provided. Proceeding with orderColumn and ignoring clusterColumns.") + clusterColumns = False + + # Apply manual ordering or clustering + if orderRow: + row_order = [var_names.index(name) for name in orderRow] + else: + row_order = range(len(var_names)) # Default order if no manual ordering + if clusterRows: + linkage_row = linkage(pdist(corr_matrix, 'euclidean'), method='average') + row_order = dendrogram(linkage_row, no_plot=True)['leaves'] + + if orderColumn: + col_order = [var_names.index(name) for name in orderColumn] + else: + col_order = range(len(var_names)) # Default order if no manual ordering + if clusterColumns: + linkage_col = linkage(pdist(corr_matrix.T, 'euclidean'), method='average') + col_order = dendrogram(linkage_col, no_plot=True)['leaves'] + + # Reorder the matrix based on row_order and col_order + corr_matrix = corr_matrix.iloc[row_order, col_order] + + # Plotting + if figsize is None: + figsize_width = max(10, len(corr_matrix.columns) * 0.5) + figsize_height = max(8, len(corr_matrix.index) * 0.5) + figsize = (figsize_width, figsize_height) + + plt.figure(figsize=figsize) + im = plt.imshow(corr_matrix, cmap=cmap, aspect='auto', **kwargs) + plt.colorbar(im) + + if overlayValues: + for i in range(len(row_order)): + for j in range(len(col_order)): + plt.text(j, i, f"{corr_matrix.iloc[i, j]:.2f}", ha="center", va="center", color=fontColor,fontsize=fontSize) + + # Set tick labels + plt.xticks(ticks=np.arange(len(col_order)), labels=[var_names[i] for i in col_order], rotation=90) + plt.yticks(ticks=np.arange(len(row_order)), labels=[var_names[i] for i in row_order]) + + plt.tight_layout() + + # Save or show the figure + if saveDir and fileName: + if not os.path.exists(saveDir): + os.makedirs(saveDir) + full_path = os.path.join(saveDir, fileName) + plt.savefig(full_path, dpi=300) + if not os.path.exists(saveDir): + os.makedirs(saveDir) + print(f"Saved heatmap to {full_path}") + else: + plt.show() + + +if __name__ == '__main__': + parser = argparse.ArgumentParser(description='Calculates and visualizes the correlation between group abundances across various conditions within an AnnData object.') + + parser.add_argument('--adata', type=str, required=True, help='Path to an AnnData object file containing the dataset to be visualized.') + parser.add_argument('--groupBy', type=str, required=True, help="The column in `adata.obs` used for defining groups.") + parser.add_argument('--condition', type=str, required=True, help="The column in `adata.obs` that distinguishes different conditions or samples.") + parser.add_argument('--normalize', action='store_true', help="Apply z-score normalization to the group counts across conditions. Defaults to False.") + parser.add_argument('--subsetGroups', type=str, nargs='+', default=None, help="A list specifying a subset of groups to include in the analysis.") + parser.add_argument('--orderRow', type=str, nargs='+', default=None, help="Custom order for the rows in the heatmap.") + parser.add_argument('--orderColumn', type=str, nargs='+', default=None, help="Custom order for the columns in the heatmap. Equivalent to `orderRow` due to the square nature of the correlation matrix but kept for consistency.") + parser.add_argument('--clusterRows', action='store_true', help="Whether to apply hierarchical clustering to rows. Defaults to True unless --no-clusterRows is specified.") + parser.add_argument('--no-clusterRows', action='store_false', dest='clusterRows', help="Do not cluster rows.") + parser.add_argument('--clusterColumns', action='store_true', help="Whether to apply hierarchical clustering to columns. Defaults to True unless --no-clusterColumns is specified.") + parser.add_argument('--no-clusterColumns', action='store_false', dest='clusterColumns', help="Do not cluster columns.") + parser.add_argument('--cmap', type=str, default='vlag', help="The colormap for the heatmap. Defaults to 'vlag'.") + parser.add_argument('--figsize', type=float, nargs=2, default=None, help="The size of the figure to create (width, height). If None, the size is inferred.") + parser.add_argument('--overlayValues', action='store_true', help="Overlay the actual correlation values on the heatmap.") + parser.add_argument('--fontSize', type=int, default=10, help="Font size for overlay values. Defaults to 10.") + parser.add_argument('--fontColor', type=str, default='black', help="Color of the font used for overlay values. Defaults to 'black'.") + parser.add_argument('--fileName', type=str, default='groupCorrelation.pdf', help="Name of the file to save the heatmap. Defaults to 'groupCorrelation.pdf'.") + parser.add_argument('--saveDir', type=str, default=None, help="Directory to save the generated heatmap. If None, the heatmap is not saved.") + + args = parser.parse_args() + + # Execute groupCorrelation with the provided arguments + groupCorrelation(adata=args.adata, + groupBy=args.groupBy, + condition=args.condition, + normalize=args.normalize, + subsetGroups=args.subsetGroups, + orderRow=args.orderRow, + orderColumn=args.orderColumn, + clusterRows=args.clusterRows, + clusterColumns=args.clusterColumns, + cmap=args.cmap, + figsize=args.figsize, + overlayValues=args.overlayValues, + fontSize=args.fontSize, + fontColor=args.fontColor, + fileName=args.fileName, + saveDir=args.saveDir) \ No newline at end of file diff --git a/scimap/plotting/heatmap.py b/scimap/plotting/heatmap.py index 9cd322fc..8028d864 100644 --- a/scimap/plotting/heatmap.py +++ b/scimap/plotting/heatmap.py @@ -127,18 +127,6 @@ def heatmap (adata, adata = ad.read_h5ad(adata) - # check for layers - if layer is not None: # Checks if only one is None - try: - # Attempt to access the 'log' layer of the adata object - log_layer = adata.layers[layer] - except KeyError: - if layer == 'log': - # If the 'log' layer is not found, raise a new informative error - raise KeyError("LOG layer not found. Please run sm.pp.log1p(adata) to generate the log layer.") - else: - raise KeyError(str(layer) + " layer not found. Please check annData.layers") - # check if the location is provided if the user wishes to save the image if (saveDir is None and fileName is not None) or (saveDir is not None and fileName is None): raise ValueError("Both 'saveDir' and 'fileName' must be provided together or not at all.") @@ -300,7 +288,7 @@ def plot_category_heatmap_vectorized(data, # Setting the tick labels ax.set_xticks(np.arange(mean_data.shape[1])) - ax.set_xticklabels(marker_names, rotation=45, ha="right") + ax.set_xticklabels(marker_names, rotation=90, ha="right") ax.set_yticks(np.arange(mean_data.shape[0])) ax.set_yticklabels(unique_categories) diff --git a/scimap/plotting/markerCorrelation.py b/scimap/plotting/markerCorrelation.py new file mode 100644 index 00000000..0416896b --- /dev/null +++ b/scimap/plotting/markerCorrelation.py @@ -0,0 +1,232 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +#Created on Mon Mar 18 08:48:29 2024 +#@author: Ajit Johnson Nirmal + + +""" +!!! abstract "Short Description" + The `sm.pl.markerCorrelation` function computes and visualizes the correlation among selected markers (genes, proteins, etc.) within an `AnnData` object. + +## Function +""" + + +import numpy as np +import matplotlib.pyplot as plt +from scipy.spatial.distance import pdist +from scipy.cluster.hierarchy import linkage, dendrogram +import os +import anndata as ad +import warnings +import argparse + +def markerCorrelation (adata, + layer='log', + subsetMarkers=None, + orderRow=None, + orderColumn=None, + clusterRows=True, + clusterColumns=True, + cmap='vlag', + figsize=None, + overlayValues=False, + fontSize=10, + fontColor='black', + fileName='markerCorrelation.pdf', + saveDir=None, + **kwargs): + """ +Parameters: + adata (AnnData or str): + An AnnData object containing the dataset, or a string path to an AnnData file to be loaded. + + layer (str, optional): + Specifies the layer of `adata` to use for the heatmap. If None, the `.X` attribute is used. If you want to plot the raw data use `raw` + + subsetMarkers (list of str, optional): + A list of marker names to include in the correlation analysis. If None, all markers are used. + + orderRow (list of str, optional): + Specifies a custom order for the rows (markers) based on their names. + + orderColumn (list of str, optional): + Specifies a custom order for the columns (markers) based on their names. + + clusterRows (bool, optional): + Whether to apply hierarchical clustering to rows. + + clusterColumns (bool, optional): + Whether to apply hierarchical clustering to columns. + + cmap (str, optional): + The colormap for the heatmap. + + figsize (tuple of float, optional): + The size of the figure to create. If None, the size is inferred based on the data. + + overlayValues (bool, optional): + If True, overlays the actual correlation values on the heatmap. + + fontSize (int, optional): + Font size for the overlay values. + + fontColor (str, optional): + Color of the font used for overlay values. + + fileName (str, optional): + Name of the file to save the heatmap. Relevant only if `saveDir` is not None. + + saveDir (str, optional): + Directory to save the generated heatmap. If None, the heatmap is not saved. + +Returns: + plot (matplotlib): + Displays or saves a heatmap visualizing the correlation between specified markers. + +Example: + ```python + + # Example 1: Basic usage with all markers and default parameters + sm.pl.markerCorrelation(adata) + + # Example 2: With subset of markers, custom clustering, and overlaying correlation values + sm.pl.markerCorrelation(adata, subsetMarkers=['Marker1', 'Marker2', 'Marker3'], clusterRows=False, overlayValues=True, fontSize=12) + + # Example 3: Saving the heatmap to a specific directory + sm.pl.markerCorrelation(adata, fileName='myHeatmap.pdf', saveDir='/path/to/save') + + ``` + """ + + # load adata + if isinstance(adata, str): + adata = ad.read_h5ad(adata) + + # subset the markers if user requests + if subsetMarkers: + subsetMarkers = [subsetMarkers] if isinstance(subsetMarkers, str) else subsetMarkers # convert to list + # isolate the data + if layer == 'raw': + matrix = adata[:, subsetMarkers].raw.X + elif layer is None: + matrix = adata[:, subsetMarkers].X + else: + matrix = adata[:, subsetMarkers].layers[layer] + else: + # take the whole data if the user does not subset anything + if layer == 'raw': + matrix = adata.raw.X + elif layer is None: + matrix = adata.X + else: + matrix = adata.layers[layer] + + + # intialize the markers to be plotted + if subsetMarkers is None: + var_names = adata.var_names.tolist() + else: + var_names = subsetMarkers + + # run correlation + corr_matrix = np.corrcoef(matrix.T) + + + row_order = np.arange(corr_matrix.shape[0]) + col_order = np.arange(corr_matrix.shape[1]) + + if orderRow: + if clusterRows: + warnings.warn("Both orderRow and clusterRows were provided. Proceeding with orderRow and ignoring clusterRows.") + clusterRows = False + row_order = [var_names.index(name) for name in orderRow] + + if orderColumn: + if clusterColumns: + warnings.warn("Both orderColumn and clusterColumns were provided. Proceeding with orderColumn and ignoring clusterColumns.") + clusterColumns = False + col_order = [var_names.index(name) for name in orderColumn] + + corr_matrix = corr_matrix[np.ix_(row_order, col_order)] + + if clusterRows: + linkage_row = linkage(pdist(corr_matrix), method='average') + row_order = dendrogram(linkage_row, no_plot=True)['leaves'] + corr_matrix = corr_matrix[row_order, :] + + if clusterColumns: + linkage_col = linkage(pdist(corr_matrix.T), method='average') + col_order = dendrogram(linkage_col, no_plot=True)['leaves'] + corr_matrix = corr_matrix[:, col_order] + + if figsize is None: + base_size = 0.5 # Base size for each cell in inches + figsize_width = max(10, len(corr_matrix) * base_size) + figsize_height = max(8, len(corr_matrix) * base_size) + figsize=(figsize_width, figsize_height) + + + plt.figure(figsize=figsize) + im = plt.imshow(corr_matrix, cmap=cmap, aspect='auto', **kwargs) + plt.colorbar(im) + + if overlayValues: + for i in range(corr_matrix.shape[0]): + for j in range(corr_matrix.shape[1]): + text = plt.text(j, i, f"{corr_matrix[i, j]:.2f}", + ha="center", va="center", color=fontColor,fontsize=fontSize) + + plt.xticks(ticks=np.arange(len(col_order)), labels=np.array(var_names)[col_order], rotation=90) + plt.yticks(ticks=np.arange(len(row_order)), labels=np.array(var_names)[row_order]) + plt.tight_layout() + + # Saving the figure if saveDir and fileName are provided + if saveDir and fileName: + if not os.path.exists(saveDir): + os.makedirs(saveDir) + full_path = os.path.join(saveDir, fileName) + plt.savefig(full_path, dpi=300) + print(f"Saved heatmap to {full_path}") + else: + plt.show() + + + +if __name__ == '__main__': + parser = argparse.ArgumentParser(description='Compute and visualize the correlation among markers within an AnnData object.') + + parser.add_argument('--adata', type=str, required=True, help='Path to an AnnData object file containing the dataset to be visualized.') + parser.add_argument('--layer', type=str, default='log', help="Specifies the layer of `adata` to use for the correlation analysis. Defaults to 'log'.") + parser.add_argument('--subsetMarkers', type=str, nargs='+', default=None, help="A list of marker genes or features to include in the correlation analysis.") + parser.add_argument('--orderRow', type=str, nargs='+', default=None, help="Custom order for the rows based on marker names.") + parser.add_argument('--orderColumn', type=str, nargs='+', default=None, help="Custom order for the columns based on marker names.") + parser.add_argument('--clusterRows', action='store_true', help="Whether to cluster rows. Defaults to True unless --no-clusterRows is specified.") + parser.add_argument('--no-clusterRows', action='store_false', dest='clusterRows', help="Do not cluster rows.") + parser.add_argument('--clusterColumns', action='store_true', help="Whether to cluster columns. Defaults to True unless --no-clusterColumns is specified.") + parser.add_argument('--no-clusterColumns', action='store_false', dest='clusterColumns', help="Do not cluster columns.") + parser.add_argument('--cmap', type=str, default='vlag', help="The colormap for the heatmap. Defaults to 'vlag'.") + parser.add_argument('--figsize', type=float, nargs=2, default=None, help="The size of the figure to create. Specify width and height.") + parser.add_argument('--overlayValues', action='store_true', help="Overlay the actual correlation values on the heatmap.") + parser.add_argument('--fontSize', type=int, default=10, help="Font size for the overlay values. Defaults to 10.") + parser.add_argument('--fontColor', type=str, default='black', help="Color of the font used for overlay values. Defaults to 'black'.") + parser.add_argument('--fileName', type=str, default='markerCorrelation.pdf', help="Name of the file to save the heatmap. Defaults to 'markerCorrelation.pdf'.") + parser.add_argument('--saveDir', type=str, default=None, help="Directory to save the generated heatmap. If None, the heatmap is not saved.") + + args = parser.parse_args() + + # Execute markerCorrelation with the provided arguments + markerCorrelation(adata=args.adata, + layer=args.layer, + subsetMarkers=args.subsetMarkers, + orderRow=args.orderRow, + orderColumn=args.orderColumn, + clusterRows=args.clusterRows, + clusterColumns=args.clusterColumns, + cmap=args.cmap, + figsize=args.figsize, + overlayValues=args.overlayValues, + fontSize=args.fontSize, + fontColor=args.fontColor, + fileName=args.fileName, + saveDir=args.saveDir) \ No newline at end of file diff --git a/scimap/preprocessing/log1p.py b/scimap/preprocessing/log1p.py index f32bbd8a..05b8e299 100644 --- a/scimap/preprocessing/log1p.py +++ b/scimap/preprocessing/log1p.py @@ -62,6 +62,8 @@ def log1p (adata, if not adata_path.exists(): raise FileNotFoundError(f"The file {adata} does not exist.") adata = ad.read_h5ad(adata_path) + else: + adata_path = None if layer in adata.layers: diff --git a/scimap/preprocessing/ngraph.py b/scimap/preprocessing/ngraph.py new file mode 100644 index 00000000..f56ae7e3 --- /dev/null +++ b/scimap/preprocessing/ngraph.py @@ -0,0 +1,99 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +#Created on Sun Mar 17 16:09:22 2024 +#@author: Ajit Johnson Nirmal +#Create a neighbourhood graph + +""" +!!! abstract "Short Description" + `sm.pp.nGraph` constructs a k-neighbors graph from single-cell data contained within an AnnData object. It offers options for data preprocessing such as standard scaling and principal component analysis (PCA) before graph construction. The resulting graph is stored in the `.obsp['connectivities']` of the AnnData object. The function accommodates data from the raw layer, a specified layer, or the default data layer (`adata.X`), and allows for specifying the number of neighbors to define connectivity. + +## Function +""" + + +# lib +from sklearn.neighbors import kneighbors_graph +from sklearn.preprocessing import StandardScaler +from sklearn.decomposition import PCA +import numpy as np +import igraph as ig + + +# function + +def nGraph (adata, + layer='raw', + standardScale=False, + runPCA=False, + k_neighbors=15): + + """ +Generates a k-neighbors graph from high-dimensional single-cell data, with options for preprocessing steps +such as standard scaling and principal component analysis (PCA). + +Parameters: + adata (AnnData): + An AnnData object containing single-cell data. Must have `.X` for data matrix, `.raw.X` for raw data, + and `.layers` for additional data layers. + + layer (str, optional): + Specifies which layer of the `adata` to use for graph construction. The default is 'raw', indicating + that `adata.raw.X` will be used. If `None`, `adata.X` will be utilized. Otherwise, specifies the key + to use data from `adata.layers`. + + standardScale (bool, optional): + If `True`, applies standard scaling to the data, making the mean of each feature 0 and the variance 1. + + runPCA (bool, optional): + If `True`, performs principal component analysis on the data and uses the principal components for + graph construction. This is often done to reduce dimensionality and noise. + + k_neighbors (int, optional): + The number of neighbors to use for k-neighbors graph construction. This parameter determines the + connectivity of the graph. Defaults to 15. + +Returns: + adata (annData): + The input `adata` object is returned after adding the k-neighbors graph to `.obsp['connectivities']`. + +Examples: + ```python + + # Example 1: Basic usage with raw layer data and default settings + adata = sm.pp.nGraph(adata) + + # Example 2: Using data from default layer, with standard scaling and PCA applied, specifying k_neighbors + adata = sm.pp.nGraph(adata, layer=None, standardScale=True, runPCA=True, k_neighbors=20) + ``` +""" + + # prepare data + if layer == 'raw': + data = adata.raw.X.copy() + elif layer is None: + data = adata.X.copy() + else: + data = adata.layers[layer].copy() + + if standardScale: + scaler = StandardScaler() + data = scaler.fit_transform(data) + + if runPCA: + # Initialize PCA object + pca = PCA(n_components=None) # 'None' to obtain all PCs + # Fit PCA on the data + pca.fit(data.T) + # Transform the data + X_pca = pca.transform(data.T) + # X_pca now contains the principal components + data = pca.components_.T + + + # Generate a k-neighbors graph from the data + graph = kneighbors_graph(X=data, n_neighbors=k_neighbors, mode='connectivity') + adata.obsp['connectivities'] = graph + + # return graph + return adata diff --git a/scimap/tools/cluster.py b/scimap/tools/cluster.py index 28812e03..56eb410a 100644 --- a/scimap/tools/cluster.py +++ b/scimap/tools/cluster.py @@ -29,90 +29,9 @@ import pathlib -#Command line compatible -def main(argv=sys.argv): - parser = argparse.ArgumentParser( - description='This function allows users to cluster the dataset. The function supports three clustering algorithm (kmeans, phenograph and leiden).' - ) - parser.add_argument( - '--adata', required=True, - help='AnnData object loaded into memory or path to AnnData object.' - ) - parser.add_argument( - '--method', type=str, required=False, default='kmeans', - help='Clustering method to be used- Implemented methods- kmeans, phenograph and leiden.' - ) - parser.add_argument( - '--subset_genes', type=list, required=False, default=None, - help='Pass a list of genes [`CD3D`, `CD20`, `KI67`] that should be included for the purpose of clustering. By default the algorithm uses all genes in the dataset.' - ) - parser.add_argument( - '--sub_cluster', type=bool, required=False, default=False, - help='If the user has already performed clustering or phenotyping previously and would like to sub-cluster within a particular cluster/phenotype, this option can be used.' - ) - parser.add_argument( - '--sub_cluster_column', type=str, required=False, default='phenotype', - help='The column name that contains the cluster/phenotype information to be sub-clustered. This is only required when sub_cluster is set to True.' - ) - parser.add_argument( - '--sub_cluster_group', type=list, required=False, default=None, - help='By default the program will sub-cluster all groups within column passed through the argument sub_cluster_column. If user wants to sub cluster only a subset of phenotypes/clusters this option can be used. Pass them as list e.g. ["tumor", "b cells"].' - ) - parser.add_argument( - '--k', type=int, required=False, default=10, - help='Number of clusters to return when using K-Means clustering.' - ) - parser.add_argument( - '--n_pcs', type=int, required=False, default=None, - help='Number of PCs to be used in leiden clustering. By default it uses all PCs.' - ) - parser.add_argument( - '--resolution', type=float, required=False, default=1, - help='A parameter value controlling the coarseness of the clustering. Higher values lead to more clusters.' - ) - parser.add_argument( - '--phenograph_clustering_metric', type=str, required=False, default='euclidean', - help='Distance metric to define nearest neighbors. Note that performance will be slower for correlation and cosine. Available methods- cityblock’, ‘cosine’, ‘euclidean’, ‘manhattan’, braycurtis’, ‘canberra’, ‘chebyshev’, ‘correlation’, ‘dice’, ‘hamming’, ‘jaccard’, ‘kulsinski’, ‘mahalanobis’, ‘minkowski’, ‘rogerstanimoto’, ‘russellrao’, ‘seuclidean’, ‘sokalmichener’, ‘sokalsneath’, ‘sqeuclidean’, ‘yule’' - ) - parser.add_argument( - '--nearest_neighbors', type=int, required=False, default=30, - help='Number of nearest neighbors to use in first step of graph construction. This parameter is used both in leiden and phenograph clustering.' - ) - parser.add_argument( - '--use_raw', type=bool, required=False, default=True, - help='If True, raw data will be used for clustering. If False, normalized/scaled data within `adata.X` will be used.' - ) - parser.add_argument( - '--log', type=bool, required=False, default=True, - help='If `True`, the log of raw data is used. Set use_raw = `True` for this to take effect. ' - ) - parser.add_argument( - '--random_state', type=int, required=False, default=0, - help='Change the initialization of the optimization.' - ) - parser.add_argument( - '--collapse_labels', type=bool, required=False, default=False, - help='While sub clustering only a few phenotypes/clusters, this argument helps to group all the other phenotypes/clusters into a single category- Helps in visualisation.' - ) - parser.add_argument( - '--label', type=str, required=False, default=None, - help='Key or optional column name for the returned data, stored in `adata.obs`. The default is adata.obs [method used].' - ) - parser.add_argument( - '--verbose', required=False, default=True, - help='The function will print detailed messages about its progress.' - ) - parser.add_argument( - '--output_dir', type=str, required=False, default=None, - help='Path to output directory.' - ) - args = parser.parse_args(argv[1:]) - print(vars(args)) - cluster(**vars(args)) - - - -def cluster (adata, method='kmeans', +def cluster (adata, + method='kmeans', + layer='log', subset_genes=None, sub_cluster=False, sub_cluster_column='phenotype', @@ -213,7 +132,7 @@ def cluster (adata, method='kmeans', # Load the andata object if isinstance(adata, str): imid = str(adata.rsplit('/', 1)[-1]) - adata = anndata.read(adata) + adata = anndata.read_h5ad(adata) else: adata = adata @@ -433,3 +352,84 @@ def phenograph_clustering (pheno, adata, primary_metric, nearest_neighbors): # Return data return adata + +#Command line compatible +def main(argv=sys.argv): + parser = argparse.ArgumentParser( + description='This function allows users to cluster the dataset. The function supports three clustering algorithm (kmeans, phenograph and leiden).' + ) + parser.add_argument( + '--adata', required=True, + help='AnnData object loaded into memory or path to AnnData object.' + ) + parser.add_argument( + '--method', type=str, required=False, default='kmeans', + help='Clustering method to be used- Implemented methods- kmeans, phenograph and leiden.' + ) + parser.add_argument( + '--subset_genes', type=list, required=False, default=None, + help='Pass a list of genes [`CD3D`, `CD20`, `KI67`] that should be included for the purpose of clustering. By default the algorithm uses all genes in the dataset.' + ) + parser.add_argument( + '--sub_cluster', type=bool, required=False, default=False, + help='If the user has already performed clustering or phenotyping previously and would like to sub-cluster within a particular cluster/phenotype, this option can be used.' + ) + parser.add_argument( + '--sub_cluster_column', type=str, required=False, default='phenotype', + help='The column name that contains the cluster/phenotype information to be sub-clustered. This is only required when sub_cluster is set to True.' + ) + parser.add_argument( + '--sub_cluster_group', type=list, required=False, default=None, + help='By default the program will sub-cluster all groups within column passed through the argument sub_cluster_column. If user wants to sub cluster only a subset of phenotypes/clusters this option can be used. Pass them as list e.g. ["tumor", "b cells"].' + ) + parser.add_argument( + '--k', type=int, required=False, default=10, + help='Number of clusters to return when using K-Means clustering.' + ) + parser.add_argument( + '--n_pcs', type=int, required=False, default=None, + help='Number of PCs to be used in leiden clustering. By default it uses all PCs.' + ) + parser.add_argument( + '--resolution', type=float, required=False, default=1, + help='A parameter value controlling the coarseness of the clustering. Higher values lead to more clusters.' + ) + parser.add_argument( + '--phenograph_clustering_metric', type=str, required=False, default='euclidean', + help='Distance metric to define nearest neighbors. Note that performance will be slower for correlation and cosine. Available methods- cityblock’, ‘cosine’, ‘euclidean’, ‘manhattan’, braycurtis’, ‘canberra’, ‘chebyshev’, ‘correlation’, ‘dice’, ‘hamming’, ‘jaccard’, ‘kulsinski’, ‘mahalanobis’, ‘minkowski’, ‘rogerstanimoto’, ‘russellrao’, ‘seuclidean’, ‘sokalmichener’, ‘sokalsneath’, ‘sqeuclidean’, ‘yule’' + ) + parser.add_argument( + '--nearest_neighbors', type=int, required=False, default=30, + help='Number of nearest neighbors to use in first step of graph construction. This parameter is used both in leiden and phenograph clustering.' + ) + parser.add_argument( + '--use_raw', type=bool, required=False, default=True, + help='If True, raw data will be used for clustering. If False, normalized/scaled data within `adata.X` will be used.' + ) + parser.add_argument( + '--log', type=bool, required=False, default=True, + help='If `True`, the log of raw data is used. Set use_raw = `True` for this to take effect. ' + ) + parser.add_argument( + '--random_state', type=int, required=False, default=0, + help='Change the initialization of the optimization.' + ) + parser.add_argument( + '--collapse_labels', type=bool, required=False, default=False, + help='While sub clustering only a few phenotypes/clusters, this argument helps to group all the other phenotypes/clusters into a single category- Helps in visualisation.' + ) + parser.add_argument( + '--label', type=str, required=False, default=None, + help='Key or optional column name for the returned data, stored in `adata.obs`. The default is adata.obs [method used].' + ) + parser.add_argument( + '--verbose', required=False, default=True, + help='The function will print detailed messages about its progress.' + ) + parser.add_argument( + '--output_dir', type=str, required=False, default=None, + help='Path to output directory.' + ) + args = parser.parse_args(argv[1:]) + print(vars(args)) + cluster(**vars(args))