From ece32b26ae423e0c22e952a4416637875a78917e Mon Sep 17 00:00:00 2001 From: Mario Kanetscheider Date: Fri, 9 Aug 2024 16:48:12 +0200 Subject: [PATCH 1/7] Added hill diversity profile and function to convert Hill numbers into other popular alpha indices --- src/scirpy/tl/__init__.py | 2 +- src/scirpy/tl/_diversity.py | 127 ++++++++++++++++++++++++++++++++++-- 2 files changed, 123 insertions(+), 6 deletions(-) diff --git a/src/scirpy/tl/__init__.py b/src/scirpy/tl/__init__.py index 5941ebdcd..b40fea854 100644 --- a/src/scirpy/tl/__init__.py +++ b/src/scirpy/tl/__init__.py @@ -4,7 +4,7 @@ from ._clonotype_modularity import clonotype_modularity from ._clonotypes import clonotype_network, clonotype_network_igraph, define_clonotype_clusters, define_clonotypes from ._convergence import clonotype_convergence -from ._diversity import alpha_diversity +from ._diversity import alpha_diversity, hill_diversity_profile, convert_hill_table from ._group_abundance import group_abundance from ._ir_query import ir_query, ir_query_annotate, ir_query_annotate_df from ._repertoire_overlap import repertoire_overlap diff --git a/src/scirpy/tl/_diversity.py b/src/scirpy/tl/_diversity.py index 47c5481a2..ddd84d166 100644 --- a/src/scirpy/tl/_diversity.py +++ b/src/scirpy/tl/_diversity.py @@ -1,4 +1,4 @@ -from typing import Callable, Optional, Union, cast +from typing import Callable, Optional, Union, Literal, cast import numpy as np import pandas as pd @@ -41,6 +41,120 @@ def _dxx(counts: np.ndarray, *, percentage: int): return i / len(freqs) * 100 +def Hill_diversity(counts: np.ndarray, q): + if q == 0: + return len(counts) + if q == 1: + p_i = (counts / sum(counts)) + return np.exp(np.sum(-p_i * np.log(p_i))) + else: + p_i = (counts / sum(counts)) + return np.power(np.sum(np.power(p_i, q)), 1 / (1 - q)) + +def hill_diversity_profile( + adata: DataHandler.TYPE, + groupby: str, + target_col: str = "clone_id", + airr_mod: str = "airr", + q_min = 0, + q_max = 2, + q_step = 1 + ) -> pd.DataFrame: + """\ + Calculates a Hill based diversity profile for a given diversity order (`q`) range + + Parameters + ---------- + {adata} + groupby + Group by this column from `obs`. E.g, sample, or group. + target_col + Column containing the clonotype annoatation + {airr_mod} + q_min + Specify lowest diversity order + q_max + Specify highest diversity order + q_step + Specify the fineness of diversity order calculation + + Returns + ---------- + Returns a pd.DataFrame where columns are groups specified by groupby and rows represent + all calculated diversity orders -> allows seamlessly potting with seaborn + """ + params = DataHandler(adata, airr_mod) + ir_obs = params.get_obs([target_col, groupby]) + ir_obs = ir_obs.loc[~_is_na(ir_obs[target_col]), :] + clono_counts = ir_obs.groupby([groupby, target_col], observed=True).size().reset_index(name="count") + diversity= {} + + for q in np.arange(q_min, q_max+q_step, q_step): + for k in sorted(ir_obs[groupby].dropna().unique()): + tmp_counts = cast( + np.ndarray, + cast(pd.Series, clono_counts.loc[clono_counts[groupby] == k, "count"]).values, + ) + if k in diversity: + diversity[k].append(Hill_diversity(tmp_counts,q)) + else: + diversity[k] = [Hill_diversity(tmp_counts,q)] + df = pd.DataFrame.from_dict(diversity, orient="index", columns=list(np.arange(q_min, q_max+q_step, q_step))) + df.index.name = groupby + return df.T + +def convert_hill_table(diversity_profile: pd.DataFrame, + convert_to: Literal["diversity", "evenness_factor", + "relative_evenness"] = "diversity", + ) ->pd.DataFrame: + """ + Converts pd.DataFrame generated by scipry.tl.hill_diversity_profile into other relevant alpha indices + + Parameters + ---------- + diversity_profile + pd.DataFrame generated by scipry.tl.hill_diversity_profile + convert_to + specify which conversion is desired: + diversity -- infer respective indices from Hill numbers + evenness_factor -- calculates EF for each diversity order as specified previously + relative_evenness -- calculates RLE for each diversity order as specified previously + + for more information regarding alpha diversity see https://academic.oup.com/bib/article/19/4/679/2871295 + + Returns + ---------- + pd.DataFrame, where rows are indices/diversity orders and columns are groups (i.e. severity) + """ + if convert_to == "diversity": + df = pd.DataFrame(columns= diversity_profile.columns, index= ["Observed richness", "Shannon entropy", "Inverse Simpson", "Gini-Simpson"]) + + df.loc["Observed richness"] = diversity_profile.loc[0] + df.loc["Shannon entropy"] = [np.log(x) for x in diversity_profile.loc[1]] + df.loc["Inverse Simpson"] = diversity_profile.loc[2] + df.loc["Gini-Simpson"] = [(1 - (1/x)) for x in diversity_profile.loc[2]] + return df + + elif convert_to == "evenness_factor": + df = diversity_profile.copy() + observed_richeness = diversity_profile.loc[0] + for _index, row in df.iterrows(): + for i in range(len(row)): + row.iloc[i] = (row.iloc[i]/observed_richeness.iloc[i]) + return df + + elif convert_to == "relative_evenness": + df = diversity_profile.copy() + observed_richeness = diversity_profile.loc[0] + for index, row in df.iterrows(): + for i in range(len(row)): + row.iloc[i] = (np.log(row.iloc[i])/np.log(observed_richeness.iloc[i])) + return df + + else: + raise Exception("Invalid input. Please check your input to the convert_to argument!") + + @DataHandler.inject_param_docs() def alpha_diversity( @@ -68,12 +182,15 @@ def alpha_diversity( `normalized to group size `__. D50: - D50 is a measure of the minimum number of distinct clonotypes totalling greater than 50% of total clonotype - counts in a given group, as a percentage out of the total number of clonotypes. - Adapted from ``__. + The diversity index (D50) is a measure of the diversity of an immune repertoire of J individual cells + (the total number of CDR3s) composed of S distinct CDR3s in a ranked dominance configuration where ri + is the abundance of the ith most abundant CDR3, r1 is the abundance of the most abundant CDR3, r2 is the + abundance of the second most abundant CDR3, and so on. C is the minimum number of distinct CDR3s, + amounting to >50% of the total sequencing reads. D50 therefore is given by C/S x 100. + ``__. DXX: - Similar to D50 where XX indicates the percentage of total clonotype counts threshold. + Similar to D50 where XX indicates the percent of J (the total number of CDR3s). Requires to pass the `percentage` keyword argument which can be within 0 and 100. From e47305c7db844548b40750713dbe43408dab2372 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Fri, 9 Aug 2024 14:52:54 +0000 Subject: [PATCH 2/7] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- src/scirpy/tl/__init__.py | 2 +- src/scirpy/tl/_diversity.py | 121 +++++++++++++++++++----------------- 2 files changed, 64 insertions(+), 59 deletions(-) diff --git a/src/scirpy/tl/__init__.py b/src/scirpy/tl/__init__.py index b40fea854..df50ca102 100644 --- a/src/scirpy/tl/__init__.py +++ b/src/scirpy/tl/__init__.py @@ -4,7 +4,7 @@ from ._clonotype_modularity import clonotype_modularity from ._clonotypes import clonotype_network, clonotype_network_igraph, define_clonotype_clusters, define_clonotypes from ._convergence import clonotype_convergence -from ._diversity import alpha_diversity, hill_diversity_profile, convert_hill_table +from ._diversity import alpha_diversity, convert_hill_table, hill_diversity_profile from ._group_abundance import group_abundance from ._ir_query import ir_query, ir_query_annotate, ir_query_annotate_df from ._repertoire_overlap import repertoire_overlap diff --git a/src/scirpy/tl/_diversity.py b/src/scirpy/tl/_diversity.py index ddd84d166..932737bd0 100644 --- a/src/scirpy/tl/_diversity.py +++ b/src/scirpy/tl/_diversity.py @@ -1,4 +1,4 @@ -from typing import Callable, Optional, Union, Literal, cast +from typing import Callable, Literal, Optional, Union, cast import numpy as np import pandas as pd @@ -41,25 +41,27 @@ def _dxx(counts: np.ndarray, *, percentage: int): return i / len(freqs) * 100 + def Hill_diversity(counts: np.ndarray, q): if q == 0: return len(counts) if q == 1: - p_i = (counts / sum(counts)) + p_i = counts / sum(counts) return np.exp(np.sum(-p_i * np.log(p_i))) else: - p_i = (counts / sum(counts)) + p_i = counts / sum(counts) return np.power(np.sum(np.power(p_i, q)), 1 / (1 - q)) - + + def hill_diversity_profile( - adata: DataHandler.TYPE, - groupby: str, - target_col: str = "clone_id", - airr_mod: str = "airr", - q_min = 0, - q_max = 2, - q_step = 1 - ) -> pd.DataFrame: + adata: DataHandler.TYPE, + groupby: str, + target_col: str = "clone_id", + airr_mod: str = "airr", + q_min=0, + q_max=2, + q_step=1, +) -> pd.DataFrame: """\ Calculates a Hill based diversity profile for a given diversity order (`q`) range @@ -77,9 +79,9 @@ def hill_diversity_profile( Specify highest diversity order q_step Specify the fineness of diversity order calculation - + Returns - ---------- + ------- Returns a pd.DataFrame where columns are groups specified by groupby and rows represent all calculated diversity orders -> allows seamlessly potting with seaborn """ @@ -87,73 +89,76 @@ def hill_diversity_profile( ir_obs = params.get_obs([target_col, groupby]) ir_obs = ir_obs.loc[~_is_na(ir_obs[target_col]), :] clono_counts = ir_obs.groupby([groupby, target_col], observed=True).size().reset_index(name="count") - diversity= {} + diversity = {} - for q in np.arange(q_min, q_max+q_step, q_step): - for k in sorted(ir_obs[groupby].dropna().unique()): + for q in np.arange(q_min, q_max + q_step, q_step): + for k in sorted(ir_obs[groupby].dropna().unique()): tmp_counts = cast( - np.ndarray, - cast(pd.Series, clono_counts.loc[clono_counts[groupby] == k, "count"]).values, + np.ndarray, + cast(pd.Series, clono_counts.loc[clono_counts[groupby] == k, "count"]).values, ) if k in diversity: - diversity[k].append(Hill_diversity(tmp_counts,q)) + diversity[k].append(Hill_diversity(tmp_counts, q)) else: - diversity[k] = [Hill_diversity(tmp_counts,q)] - df = pd.DataFrame.from_dict(diversity, orient="index", columns=list(np.arange(q_min, q_max+q_step, q_step))) + diversity[k] = [Hill_diversity(tmp_counts, q)] + df = pd.DataFrame.from_dict(diversity, orient="index", columns=list(np.arange(q_min, q_max + q_step, q_step))) df.index.name = groupby return df.T - -def convert_hill_table(diversity_profile: pd.DataFrame, - convert_to: Literal["diversity", "evenness_factor", - "relative_evenness"] = "diversity", - ) ->pd.DataFrame: - """ - Converts pd.DataFrame generated by scipry.tl.hill_diversity_profile into other relevant alpha indices - - Parameters + + +def convert_hill_table( + diversity_profile: pd.DataFrame, + convert_to: Literal["diversity", "evenness_factor", "relative_evenness"] = "diversity", +) -> pd.DataFrame: + """ + Converts pd.DataFrame generated by scipry.tl.hill_diversity_profile into other relevant alpha indices + + Parameters ---------- - diversity_profile - pd.DataFrame generated by scipry.tl.hill_diversity_profile - convert_to - specify which conversion is desired: - diversity -- infer respective indices from Hill numbers - evenness_factor -- calculates EF for each diversity order as specified previously - relative_evenness -- calculates RLE for each diversity order as specified previously - - for more information regarding alpha diversity see https://academic.oup.com/bib/article/19/4/679/2871295 - - Returns - ---------- - pd.DataFrame, where rows are indices/diversity orders and columns are groups (i.e. severity) - """ - if convert_to == "diversity": - df = pd.DataFrame(columns= diversity_profile.columns, index= ["Observed richness", "Shannon entropy", "Inverse Simpson", "Gini-Simpson"]) - + diversity_profile + pd.DataFrame generated by scipry.tl.hill_diversity_profile + convert_to + specify which conversion is desired: + diversity -- infer respective indices from Hill numbers + evenness_factor -- calculates EF for each diversity order as specified previously + relative_evenness -- calculates RLE for each diversity order as specified previously + + for more information regarding alpha diversity see https://academic.oup.com/bib/article/19/4/679/2871295 + + Returns + ------- + pd.DataFrame, where rows are indices/diversity orders and columns are groups (i.e. severity) + """ + if convert_to == "diversity": + df = pd.DataFrame( + columns=diversity_profile.columns, + index=["Observed richness", "Shannon entropy", "Inverse Simpson", "Gini-Simpson"], + ) + df.loc["Observed richness"] = diversity_profile.loc[0] df.loc["Shannon entropy"] = [np.log(x) for x in diversity_profile.loc[1]] df.loc["Inverse Simpson"] = diversity_profile.loc[2] - df.loc["Gini-Simpson"] = [(1 - (1/x)) for x in diversity_profile.loc[2]] + df.loc["Gini-Simpson"] = [(1 - (1 / x)) for x in diversity_profile.loc[2]] return df - - elif convert_to == "evenness_factor": + + elif convert_to == "evenness_factor": df = diversity_profile.copy() observed_richeness = diversity_profile.loc[0] for _index, row in df.iterrows(): for i in range(len(row)): - row.iloc[i] = (row.iloc[i]/observed_richeness.iloc[i]) + row.iloc[i] = row.iloc[i] / observed_richeness.iloc[i] return df - - elif convert_to == "relative_evenness": + + elif convert_to == "relative_evenness": df = diversity_profile.copy() observed_richeness = diversity_profile.loc[0] for index, row in df.iterrows(): for i in range(len(row)): - row.iloc[i] = (np.log(row.iloc[i])/np.log(observed_richeness.iloc[i])) + row.iloc[i] = np.log(row.iloc[i]) / np.log(observed_richeness.iloc[i]) return df - - else: - raise Exception("Invalid input. Please check your input to the convert_to argument!") + else: + raise Exception("Invalid input. Please check your input to the convert_to argument!") @DataHandler.inject_param_docs() From b908cc0d2191813b292069335a9d66320dff10db Mon Sep 17 00:00:00 2001 From: Mario Kanetscheider Date: Fri, 9 Aug 2024 17:08:59 +0200 Subject: [PATCH 3/7] Fixed issue with pre-commit --- src/scirpy/tl/_diversity.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/scirpy/tl/_diversity.py b/src/scirpy/tl/_diversity.py index 932737bd0..8edcae69b 100644 --- a/src/scirpy/tl/_diversity.py +++ b/src/scirpy/tl/_diversity.py @@ -152,7 +152,7 @@ def convert_hill_table( elif convert_to == "relative_evenness": df = diversity_profile.copy() observed_richeness = diversity_profile.loc[0] - for index, row in df.iterrows(): + for _index, row in df.iterrows(): for i in range(len(row)): row.iloc[i] = np.log(row.iloc[i]) / np.log(observed_richeness.iloc[i]) return df From 351142d5544363508af13868a4a987c05c3d2161 Mon Sep 17 00:00:00 2001 From: Mario Kanetscheider Date: Mon, 19 Aug 2024 13:29:19 +0200 Subject: [PATCH 4/7] Included API documentation --- docs/api.rst | 2 ++ src/scirpy/tl/_diversity.py | 12 ++++++------ 2 files changed, 8 insertions(+), 6 deletions(-) diff --git a/docs/api.rst b/docs/api.rst index 1c4a41282..d0bca514f 100644 --- a/docs/api.rst +++ b/docs/api.rst @@ -148,6 +148,8 @@ Analyse clonal diversity tl.clonal_expansion tl.summarize_clonal_expansion tl.alpha_diversity + tl.hill_diversity_profile + tl.convert_hill_table tl.repertoire_overlap tl.clonotype_modularity tl.clonotype_imbalance diff --git a/src/scirpy/tl/_diversity.py b/src/scirpy/tl/_diversity.py index 8edcae69b..78507f1c2 100644 --- a/src/scirpy/tl/_diversity.py +++ b/src/scirpy/tl/_diversity.py @@ -63,7 +63,7 @@ def hill_diversity_profile( q_step=1, ) -> pd.DataFrame: """\ - Calculates a Hill based diversity profile for a given diversity order (`q`) range + Calculates a Hill based diversity profile for a given range of diversity order (`q`) Parameters ---------- @@ -74,16 +74,16 @@ def hill_diversity_profile( Column containing the clonotype annoatation {airr_mod} q_min - Specify lowest diversity order + Specify lowest (start) diversity order q_max - Specify highest diversity order + Specify highest (end) diversity order q_step - Specify the fineness of diversity order calculation + Specify the fineness (steps) of diversity order calculation Returns ------- - Returns a pd.DataFrame where columns are groups specified by groupby and rows represent - all calculated diversity orders -> allows seamlessly potting with seaborn + Returns a pd.DataFrame where columns are groups (specified by groupby) and row indices indicate each + all calculated diversity order => allows seamless plotting with e.g. seaborn """ params = DataHandler(adata, airr_mod) ir_obs = params.get_obs([target_col, groupby]) From e22334da41818352cb9f81258103e2e6b7738405 Mon Sep 17 00:00:00 2001 From: Mario Kanetscheider Date: Mon, 19 Aug 2024 13:43:26 +0200 Subject: [PATCH 5/7] Hotfix of failing read the docs build --- src/scirpy/tl/_diversity.py | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/src/scirpy/tl/_diversity.py b/src/scirpy/tl/_diversity.py index 78507f1c2..04288bcce 100644 --- a/src/scirpy/tl/_diversity.py +++ b/src/scirpy/tl/_diversity.py @@ -83,7 +83,7 @@ def hill_diversity_profile( Returns ------- Returns a pd.DataFrame where columns are groups (specified by groupby) and row indices indicate each - all calculated diversity order => allows seamless plotting with e.g. seaborn + all calculated diversity order -> allows seamless plotting with e.g. seaborn """ params = DataHandler(adata, airr_mod) ir_obs = params.get_obs([target_col, groupby]) @@ -110,8 +110,10 @@ def convert_hill_table( diversity_profile: pd.DataFrame, convert_to: Literal["diversity", "evenness_factor", "relative_evenness"] = "diversity", ) -> pd.DataFrame: - """ + """\ Converts pd.DataFrame generated by scipry.tl.hill_diversity_profile into other relevant alpha indices + for more information regarding alpha diversity indices see https://academic.oup.com/bib/article/19/4/679/2871295 + Parameters ---------- @@ -119,12 +121,10 @@ def convert_hill_table( pd.DataFrame generated by scipry.tl.hill_diversity_profile convert_to specify which conversion is desired: - diversity -- infer respective indices from Hill numbers - evenness_factor -- calculates EF for each diversity order as specified previously - relative_evenness -- calculates RLE for each diversity order as specified previously - - for more information regarding alpha diversity see https://academic.oup.com/bib/article/19/4/679/2871295 - + * `"diversity"` - infer respective indices from Hill numbers + * `"evenness_factor"` - calculates EF for each diversity order as specified previously + * `"relative_evenness"` - calculates RLE for each diversity order as specified previously + Returns ------- pd.DataFrame, where rows are indices/diversity orders and columns are groups (i.e. severity) From 8a81679635aba22a527435dbf684d567e7a2bb05 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Mon, 19 Aug 2024 11:44:08 +0000 Subject: [PATCH 6/7] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- src/scirpy/tl/_diversity.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/scirpy/tl/_diversity.py b/src/scirpy/tl/_diversity.py index 04288bcce..d10aa5229 100644 --- a/src/scirpy/tl/_diversity.py +++ b/src/scirpy/tl/_diversity.py @@ -124,7 +124,7 @@ def convert_hill_table( * `"diversity"` - infer respective indices from Hill numbers * `"evenness_factor"` - calculates EF for each diversity order as specified previously * `"relative_evenness"` - calculates RLE for each diversity order as specified previously - + Returns ------- pd.DataFrame, where rows are indices/diversity orders and columns are groups (i.e. severity) From 578d20bf21ff256de1fb8fcca39f38528c174179 Mon Sep 17 00:00:00 2001 From: Gregor Sturm Date: Thu, 17 Oct 2024 21:48:35 +0200 Subject: [PATCH 7/7] Add tutorial section about clonotype diversity --- docs/tutorials/tutorial_5k_bcr.ipynb | 477 +++++++++++++++++++++++++++ 1 file changed, 477 insertions(+) create mode 100644 docs/tutorials/tutorial_5k_bcr.ipynb diff --git a/docs/tutorials/tutorial_5k_bcr.ipynb b/docs/tutorials/tutorial_5k_bcr.ipynb new file mode 100644 index 000000000..92c05bbcc --- /dev/null +++ b/docs/tutorials/tutorial_5k_bcr.ipynb @@ -0,0 +1,477 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "385249d2", + "metadata": {}, + "source": [ + "### Clonotype Diversity\n", + ":::{note}\n", + "Clonotype diversity is a rather complicated subject and different approaches work with different assumptions. In sc-AIRR analysis the term \"population\" can be defined in different ways depending on the scientific question (i.e. individuals, patient groups, clonotype cluster). Further, many different alpha diversity indices for many different applications have been developed and may come with different pitfalls {cite}`Finotello.2016`. We recommend to consult a combination of different indices as each index provides different information {cite}`Pelissier.2023`\n", + ":::\n", + "\n", + "Scirpy provides ({func}`scirpy.tl.alpha_diversity`) to calculate alpha diversity and a corresponding visualization function ({func}`scirpy.pl.alpha_diversity`), which can utilize any diversity index implemented into the python package [`scikit-bio`](https://scikit.bio/docs/latest/generated/skbio.diversity.alpha.html#module-skbio.diversity.alpha) However, `scikit-bio` is not an initial requirement for `Scirpy` and needs to be installed and imported separately." + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "7155fd28", + "metadata": {}, + "outputs": [], + "source": [ + "#!pip install scikit-bio" + ] + }, + { + "cell_type": "markdown", + "id": "eef02b21", + "metadata": {}, + "source": [ + "Alpha diversity indices are often applied in sc-AIRR studies to study differences between clonotype cluster distributions of distinct groups (e.g. treatment, disease, etc.). Calling {func}`scirpy.pl.alpha_diversity` with appropriate inputs to `groupby`, `metric` and `target_col` will result into an easily investigable bar plot. As an example, we can see below that `moderate` and `severe` patients might have a slightly reduced diversity (`D50`) compared to other groups." + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "035075f6", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 339, + "width": 645 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "ir.pl.alpha_diversity(\n", + " mdata,\n", + " metric=\"D50\",\n", + " groupby=\"gex:Status_on_day_collection_summary\",\n", + " target_col=\"clone_id_85_similarity\",\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "92eb04e4", + "metadata": {}, + "source": [ + "Rather than plotting/calculating many different indices individually, we can build a so-called diversity profile using Hill's unified diversity framework {cite}[Hill.1973]. This is done with calling `scirpy.tl.hill_diversity_profile`, which will finally return a dataframe, where each column represents a distinct group (defined by `groupby`) and rows are the range of calculated diversity orders based on the input to `target_col`. The range of diversity order *q* can be customized by setting `q_min`, `q_max` and `q_step`, respectively. " + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "6dbe4d7e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
gex:Status_on_day_collection_summaryAsymptomaticCriticalMildModerateSevere
0.0450.000000935.0000001147.0000001039.0000001203.000000
0.5448.997653929.3158331145.957328980.2306451172.145639
1.0447.757636919.3154991144.569348852.8347621116.833749
1.5446.219087900.9433421142.693897600.5781251013.542627
2.0444.307692866.7959581140.123711317.852037837.850505
\n", + "
" + ], + "text/plain": [ + "gex:Status_on_day_collection_summary Asymptomatic Critical Mild \\\n", + "0.0 450.000000 935.000000 1147.000000 \n", + "0.5 448.997653 929.315833 1145.957328 \n", + "1.0 447.757636 919.315499 1144.569348 \n", + "1.5 446.219087 900.943342 1142.693897 \n", + "2.0 444.307692 866.795958 1140.123711 \n", + "\n", + "gex:Status_on_day_collection_summary Moderate Severe \n", + "0.0 1039.000000 1203.000000 \n", + "0.5 980.230645 1172.145639 \n", + "1.0 852.834762 1116.833749 \n", + "1.5 600.578125 1013.542627 \n", + "2.0 317.852037 837.850505 " + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "diversity_profile_status = ir.tl.hill_diversity_profile(\n", + " mdata,\n", + " target_col=\"airr:clone_id_85_similarity\",\n", + " groupby=\"gex:Status_on_day_collection_summary\",\n", + " q_min=0,\n", + " q_max=10,\n", + " q_step=0.5,\n", + ")\n", + "diversity_profile_status.head(5)" + ] + }, + { + "cell_type": "markdown", + "id": "7f45772b-0337-4bbb-89cc-16cdd4a2e1d5", + "metadata": {}, + "source": [ + "The dataframe can be easily visualized using common python plotting packages like *Seaborn*. The more uneven the relative abundances per category, the more steeply its respective curve will decline. This is actually consistent with alpha diversity loss and thus its magnitude can be inferred by\n", + "inspecting the slope of each line {cite}`Chao.2014` \n", + "\n", + "Overall, the diversity profile below is consistent with the previous analysis and suggests that expansion took place preferential in all annotated celltypes except for immature and switched memory b cells. " + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "56696159", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 536, + "width": 556 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "# manual customization of the resulting plot required\n", + "pl.figure(figsize=(8, 8))\n", + "sns.set_context(\"paper\")\n", + "sns.lineplot(data=diversity_profile_status)\n", + "pl.xlabel(\"Diversity order $q$\")\n", + "pl.ylabel(\"Hill's diverisity $^qD$\")\n", + "pl.yscale(\"log\")" + ] + }, + { + "cell_type": "markdown", + "id": "fe8c6610-448e-4e04-83f9-5dfd74ace148", + "metadata": {}, + "source": [ + "Maybe the biggest advantage of using Hill numbers is that some diversity orders *q* are related to other common diversity indices like species richness ($^0D$), Shannon entropy (log($^1D$), Simpson index ($\\frac{1}{^2D}$) and Berger-Parker dominance index ($\\frac{1}{^{\\infty}D}$).\n", + "\n", + "Calling `scirpy.tl.convert_hill_table`, with the output of `scirpy.tl.hill_diversity_profile` and `convert_to = \"diversity\"` will automatically resolve those relations shown above and calculate each metric accordingly." + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "a5335206-5ad2-46ac-82a2-7d7fdccdd112", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
gex:Status_on_day_collection_summaryAsymptomaticCriticalMildModerateSevere
Observed richness450.0935.01147.01039.01203.0
Shannon entropy6.1042526.8236297.0427846.7485667.018253
Inverse Simpson444.307692866.7959581140.123711317.852037837.850505
Gini-Simpson0.9977490.9988460.9991230.9968540.998806
\n", + "
" + ], + "text/plain": [ + "gex:Status_on_day_collection_summary Asymptomatic Critical Mild \\\n", + "Observed richness 450.0 935.0 1147.0 \n", + "Shannon entropy 6.104252 6.823629 7.042784 \n", + "Inverse Simpson 444.307692 866.795958 1140.123711 \n", + "Gini-Simpson 0.997749 0.998846 0.999123 \n", + "\n", + "gex:Status_on_day_collection_summary Moderate Severe \n", + "Observed richness 1039.0 1203.0 \n", + "Shannon entropy 6.748566 7.018253 \n", + "Inverse Simpson 317.852037 837.850505 \n", + "Gini-Simpson 0.996854 0.998806 " + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ir.tl.convert_hill_table(diversity_profile_status, convert_to=\"diversity\")" + ] + }, + { + "cell_type": "markdown", + "id": "d22794e9-651f-4cb5-96a7-e4f772271afd", + "metadata": {}, + "source": [ + "If the research question at hand requires knowledge about (clonotype) evenness, this function can also be used to transform Hill numbers into evenness factor (`convert_to = \"evenness_factor\"`) and relative evenness (`convert_to = \"relative_evenness\"`) defined by {cite}`Jost.2010`" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "id": "9e115d22-dce3-406c-a4e9-48c1dc872711", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
gex:Status_on_day_collection_summaryAsymptomaticCriticalMildModerateSevere
0.01.0000001.0000001.0000001.0000001.000000
0.50.9977730.9939210.9990910.9434370.974352
1.00.9950170.9832250.9978810.8208230.928374
1.50.9915980.9635760.9962460.5780350.842513
2.00.9873500.9270550.9940050.3059210.696468
\n", + "
" + ], + "text/plain": [ + "gex:Status_on_day_collection_summary Asymptomatic Critical Mild \\\n", + "0.0 1.000000 1.000000 1.000000 \n", + "0.5 0.997773 0.993921 0.999091 \n", + "1.0 0.995017 0.983225 0.997881 \n", + "1.5 0.991598 0.963576 0.996246 \n", + "2.0 0.987350 0.927055 0.994005 \n", + "\n", + "gex:Status_on_day_collection_summary Moderate Severe \n", + "0.0 1.000000 1.000000 \n", + "0.5 0.943437 0.974352 \n", + "1.0 0.820823 0.928374 \n", + "1.5 0.578035 0.842513 \n", + "2.0 0.305921 0.696468 " + ] + }, + "execution_count": 43, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ir.tl.convert_hill_table(diversity_profile_status, convert_to=\"evenness_factor\").head(5)\n", + "# ir.tl.convert_hill_table(diversity_profile_status, convert_to = \"relative_evenness\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "BCR", + "language": "python", + "name": "bcr" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.14" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}