pertpy 0.6.0__py3-none-any.whl → 0.8.0__py3-none-any.whl

pertpy/tools/_differential_gene_expression/_statsmodels.py

@@ -0,0 +1,72 @@
+import numpy as np
+import pandas as pd
+import scanpy as sc
+import statsmodels
+import statsmodels.api as sm
+from tqdm.auto import tqdm
+
+from ._base import LinearModelBase
+from ._checks import check_is_integer_matrix
+
+
+class Statsmodels(LinearModelBase):
+    """Differential expression test using a statsmodels linear regression"""
+
+    def _check_counts(self):
+        check_is_integer_matrix(self.data)
+
+    def fit(
+        self,
+        regression_model: type[sm.OLS] | type[sm.GLM] = sm.OLS,
+        **kwargs,
+    ) -> None:
+        """Fit the specified regression model.
+
+        Args:
+            regression_model: A statsmodels regression model class, either OLS or GLM.
+            **kwargs: Additional arguments for fitting the specific method. In particular, this
+                is where you can specify the family for GLM.
+
+        Examples:
+            >>> import statsmodels.api as sm
+            >>> import pertpy as pt
+            >>> model = pt.tl.Statsmodels(adata, design="~condition")
+            >>> model.fit(sm.GLM, family=sm.families.NegativeBinomial(link=sm.families.links.Log()))
+            >>> results = model.test_contrasts(np.array([0, 1]))
+        """
+        self.models = []
+        for var in tqdm(self.adata.var_names):
+            mod = regression_model(
+                sc.get.obs_df(self.adata, keys=[var], layer=self.layer)[var],
+                self.design,
+                **kwargs,
+            )
+            mod = mod.fit()
+            self.models.append(mod)
+
+    def _test_single_contrast(self, contrast, **kwargs) -> pd.DataFrame:
+        res = []
+        for var, mod in zip(tqdm(self.adata.var_names), self.models, strict=False):
+            t_test = mod.t_test(contrast)
+            res.append(
+                {
+                    "variable": var,
+                    "p_value": t_test.pvalue,
+                    "t_value": t_test.tvalue.item(),
+                    "sd": t_test.sd.item(),
+                    "log_fc": t_test.effect.item(),
+                    "adj_p_value": statsmodels.stats.multitest.fdrcorrection(np.array([t_test.pvalue]))[1].item(),
+                }
+            )
+        return pd.DataFrame(res).sort_values("p_value")
+
+    def contrast(self, column: str, baseline: str, group_to_compare: str) -> np.ndarray:
+        """Build a simple contrast for pairwise comparisons.
+
+        This is equivalent to
+
+        ```
+        model.cond(<column> = baseline) - model.cond(<column> = group_to_compare)
+        ```
+        """
+        return self.cond(**{column: baseline}) - self.cond(**{column: group_to_compare})

pertpy/tools/_distances/_distance_tests.py

@@ -23,22 +23,22 @@ class DistanceTest:
 
     Args:
         metric: Distance metric to use between groups of cells.
-        n_perms: Number of permutations to run. Defaults to 1000.
+        n_perms: Number of permutations to run.
         layer_key: Name of the counts layer containing raw counts to calculate distances for.
                    Mutually exclusive with 'obsm_key'.
-                   Defaults to None and is then not used.
+                   If equal to `None` the parameter is ignored.
         obsm_key: Name of embedding in adata.obsm to use.
                   Mutually exclusive with 'counts_layer_key'.
                   Defaults to None, but is set to "X_pca" if not set explicitly internally.
-        alpha: Significance level. Defaults to 0.05.
-        correction: Multiple testing correction method. Defaults to 'holm-sidak'.
-        cell_wise_metric: Metric to use between single cells. Defaults to "euclidean".
+        alpha: Significance level.
+        correction: Multiple testing correction method.
+        cell_wise_metric: Metric to use between single cells.
 
     Examples:
         >>> import pertpy as pt
-        >>> adata = pt.dt.distance_example_data()
-        >>> distance_test = pt.tl.DistanceTest('edistance', n_perms=1000)
-        >>> tab = distance_test(adata, groupby='perturbation', contrast='control')
+        >>> adata = pt.dt.distance_example()
+        >>> distance_test = pt.tl.DistanceTest("edistance", n_perms=1000)
+        >>> tab = distance_test(adata, groupby="perturbation", contrast="control")
     """
 
     def __init__(
@@ -66,11 +66,14 @@ class DistanceTest:
         self.alpha = alpha
         self.correction = correction
         self.cell_wise_metric = (
-            cell_wise_metric if cell_wise_metric else Distance(self.metric, self.obsm_key).cell_wise_metric
+            cell_wise_metric if cell_wise_metric else Distance(self.metric, obsm_key=self.obsm_key).cell_wise_metric
         )
 
         self.distance = Distance(
-            self.metric, layer_key=self.layer_key, obsm_key=self.obsm_key, cell_wise_metric=self.cell_wise_metric
+            self.metric,
+            layer_key=self.layer_key,
+            obsm_key=self.obsm_key,
+            cell_wise_metric=self.cell_wise_metric,
         )
 
     def __call__(
@@ -87,7 +90,7 @@ class DistanceTest:
             adata: Annotated data matrix.
             groupby: Key in adata.obs for grouping cells.
             contrast: Name of the contrast group.
-            show_progressbar: Whether to print progress. Defaults to True.
+            show_progressbar: Whether to print progress.
 
         Returns:
             pandas.DataFrame: Results of the permutation test, with columns:
@@ -99,9 +102,9 @@ class DistanceTest:
 
         Examples:
             >>> import pertpy as pt
-            >>> adata = pt.dt.distance_example_data()
-            >>> distance_test = pt.tl.DistanceTest('edistance', n_perms=1000)
-            >>> tab = distance_test(adata, groupby='perturbation', contrast='control')
+            >>> adata = pt.dt.distance_example()
+            >>> distance_test = pt.tl.DistanceTest("edistance", n_perms=1000)
+            >>> tab = distance_test(adata, groupby="perturbation", contrast="control")
         """
         if self.distance.metric_fct.accepts_precomputed:
             # Much faster if the metric can be called on the precomputed
@@ -121,7 +124,7 @@ class DistanceTest:
             adata: Annotated data matrix.
             groupby: Key in adata.obs for grouping cells.
             contrast: Name of the contrast group.
-            show_progressbar: Whether to print progress. Defaults to True.
+            show_progressbar: Whether to print progress.
 
         Returns:
             pandas.DataFrame: Results of the permutation test, with columns:
@@ -133,9 +136,9 @@ class DistanceTest:
 
         Examples:
             >>> import pertpy as pt
-            >>> adata = pt.dt.distance_example_data()
-            >>> distance_test = pt.tl.DistanceTest('edistance', n_perms=1000)
-            >>> test_results = distance_test.test_xy(adata, groupby='perturbation', contrast='control')
+            >>> adata = pt.dt.distance_example()
+            >>> distance_test = pt.tl.DistanceTest("edistance", n_perms=1000)
+            >>> test_results = distance_test.test_xy(adata, groupby="perturbation", contrast="control")
         """
         groups = adata.obs[groupby].unique()
         if contrast not in groups:
@@ -176,7 +179,8 @@ class DistanceTest:
         # Evaluate the test
         # count times shuffling resulted in larger distance
         comparison_results = np.array(
-            pd.concat([r["distance"] - df["distance"] for r in results], axis=1) > 0, dtype=int
+            pd.concat([r["distance"] - df["distance"] for r in results], axis=1) > 0,
+            dtype=int,
         )
         n_failures = pd.Series(np.clip(np.sum(comparison_results, axis=1), 1, np.inf), index=df.index)
         pvalues = n_failures / self.n_perms
@@ -213,7 +217,7 @@ class DistanceTest:
             groupby: Key in adata.obs for grouping cells.
             contrast: Name of the contrast group.
             cell_wise_metric: Metric to use for pairwise distances.
-            verbose: Whether to print progress. Defaults to True.
+            verbose: Whether to print progress.
 
         Returns:
             pandas.DataFrame: Results of the permutation test, with columns:
@@ -225,9 +229,9 @@ class DistanceTest:
 
         Examples:
             >>> import pertpy as pt
-            >>> adata = pt.dt.distance_example_data()
-            >>> distance_test = pt.tl.DistanceTest('edistance', n_perms=1000)
-            >>> test_results = distance_test.test_precomputed(adata, groupby='perturbation', contrast='control')
+            >>> adata = pt.dt.distance_example()
+            >>> distance_test = pt.tl.DistanceTest("edistance", n_perms=1000)
+            >>> test_results = distance_test.test_precomputed(adata, groupby="perturbation", contrast="control")
         """
         if not self.distance.metric_fct.accepts_precomputed:
             raise ValueError(f"Metric {self.metric} does not accept precomputed distances.")
@@ -284,7 +288,8 @@ class DistanceTest:
         # Evaluate the test
         # count times shuffling resulted in larger distance
         comparison_results = np.array(
-            pd.concat([r["distance"] - df["distance"] for r in results], axis=1) > 0, dtype=int
+            pd.concat([r["distance"] - df["distance"] for r in results], axis=1) > 0,
+            dtype=int,
         )
         n_failures = pd.Series(np.clip(np.sum(comparison_results, axis=1), 1, np.inf), index=df.index)
         pvalues = n_failures / self.n_perms