DeConveil 0.1.0__tar.gz → 0.1.1__tar.gz

{deconveil-0.1.0 → deconveil-0.1.1}/DeConveil.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: DeConveil
-Version: 0.1.0
+Version: 0.1.1
 Summary: An extension of PyDESeq2/DESeq2 designed to account for genome aneuploidy
 Home-page: https://github.com/caravagnalab/DeConveil
 Author: Katsiaryna Davydzenka
@@ -29,6 +29,7 @@ Dynamic: author
 Dynamic: author-email
 Dynamic: home-page
 Dynamic: license
+Dynamic: license-file
 Dynamic: provides-extra
 Dynamic: requires-dist
 Dynamic: requires-python

deconveil-0.1.1/DeConveil.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+LICENSE
+README.md
+setup.py
+DeConveil.egg-info/PKG-INFO
+DeConveil.egg-info/SOURCES.txt
+DeConveil.egg-info/dependency_links.txt
+DeConveil.egg-info/requires.txt
+DeConveil.egg-info/top_level.txt
+deconveil/__init__.py
+deconveil/dds.py
+deconveil/default_inference.py
+deconveil/ds.py
+deconveil/grid_search.py
+deconveil/inference.py
+deconveil/utils_clustering.py
+deconveil/utils_fit.py
+deconveil/utils_plot.py
+deconveil/utils_processing.py

deconveil-0.1.1/DeConveil.egg-info/top_level.txt

@@ -0,0 +1 @@
+deconveil

{deconveil-0.1.0 → deconveil-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: DeConveil
-Version: 0.1.0
+Version: 0.1.1
 Summary: An extension of PyDESeq2/DESeq2 designed to account for genome aneuploidy
 Home-page: https://github.com/caravagnalab/DeConveil
 Author: Katsiaryna Davydzenka
@@ -29,6 +29,7 @@ Dynamic: author
 Dynamic: author-email
 Dynamic: home-page
 Dynamic: license
+Dynamic: license-file
 Dynamic: provides-extra
 Dynamic: requires-dist
 Dynamic: requires-python

deconveil-0.1.1/README.md

@@ -0,0 +1,64 @@
+# DeConveil <a href="caravagnalab.github.io/DeConveil"><img src="docs/deconveil_logo.png" align="right" height="150" /></a>
+
+The goal of *DeConveil* is the extension of Differential Gene Expression testing by accounting for genome aneuploidy.
+This computational framework extends traditional DGE analysis by integrating DNA Copy Number Variation (CNV) data.
+This approach adjusts for dosage effects and categorizes genes as *dosage-sensitive (DSG)*, *dosage-insensitive (DIG)*, and *dosage-compensated (DCG)*, separating the expression changes caused by CNVs from other alterations in transcriptional regulation.
+To perform this gene separation we need to carry out DGE testing using both *PyDESeq2 (CN-naive)* and *DeConveil (CN-aware)* methods.
+
+You can download the results of our analysis from [deconveilCaseStudies](https://github.com/kdavydzenka/deconveilCaseStudies)
+
+
+### Installation
+
+**Pre-required installations before running DeConveil**
+
+Python libraries are required to be installed: *pydeseq2*
+
+`pip install pydeseq2`
+
+`pip install DeConveil`
+
+or `git clone https://github.com/caravagnalab/DeConveil.git`
+
+
+**Input data**
+
+DeConveil requires the following input matrices: 
+
+    - matched mRNA read counts (normal and tumor samples) and absolute CN values (for normal diploid samples we assign CN=2), structured as NxG matrix, where N represents the number of samples and G represents the number of genes;
+    
+    - a design matrix structured as an N × F matrix, where N is the number of samples and F is the number of features or covariates.
+    
+Example of CN data for a given gene *g*:
+CN = [1, 2, 3, 4, 5, 6].
+
+An example of the input data can be found in the *test_deconveil* Jupyter Notebook.
+
+
+**Output data**
+
+`res_CNnaive.csv` (for *PyDESeq2* method) and `res_CNaware.csv` (for *DeConveil*) data frames reporting *log2FC* and *p.adjust* values for both methods.
+
+These data frames are further processed to separate gene groups using `define_gene_groups()` function included in DeConveil framework.
+
+A tutorial of the analysis workflow is available in `test_deconveil.ipynb`
+
+
+#### Citation
+
+[![](http://img.shields.io/badge/doi-10.1101/2025.03.29.646108-red.svg)](https://doi.org/10.1101/2025.03.29.646108)
+
+If you use `DeConveil`, cite:
+
+K. Davydzenka, G. Caravagna, G. Sanguinetti. Extending differential gene expression testing to handle genome aneuploidy in cancer. [bioRxiv preprint](https://doi.org/10.1101/2025.03.29.646108), 2025.
+
+
+#### Copyright and contacts
+
+Katsiaryna Davydzenka, Cancer Data Science (CDS) Laboratory.
+
+[![](https://img.shields.io/badge/CDS%20Lab%20Github-caravagnalab-seagreen.svg)](https://github.com/caravagnalab)
+[![](https://img.shields.io/badge/CDS%20Lab%20webpage-https://www.caravagnalab.org/-red.svg)](https://www.caravagnalab.org/)
+
+
+

{deconveil-0.1.0/DeConveil → deconveil-0.1.1/deconveil}/dds.py

@@ -1,11 +1,7 @@
 import sys
 import time
 import warnings
-from typing import List
-from typing import Literal
-from typing import Optional
-from typing import Union
-from typing import cast
+from typing import List, Literal, Optional, Union, cast
 
 import numpy as np
 import pandas as pd
@@ -16,11 +12,11 @@ from scipy.stats import trim_mean  # type: ignore
 
 from deconveil.default_inference import DefInference                              
 from deconveil.inference import Inference                                     
-from deconveil import utils_CNaware
-from deconveil.utils_CNaware import fit_rough_dispersions
-from deconveil.utils_CNaware import fit_moments_dispersions2
-from deconveil.utils_CNaware import grid_fit_beta
-from deconveil.utils_CNaware import irls_glm
+from deconveil import utils_fit
+from deconveil.utils_fit import fit_rough_dispersions
+from deconveil.utils_fit import fit_moments_dispersions2
+from deconveil.utils_fit import grid_fit_beta
+from deconveil.utils_fit import irls_glm
 
 from pydeseq2.preprocessing import deseq2_norm_fit
 from pydeseq2.preprocessing import deseq2_norm_transform

{deconveil-0.1.0/DeConveil → deconveil-0.1.1/deconveil}/default_inference.py

@@ -1,17 +1,13 @@
-from typing import Literal
-from typing import Optional
-from typing import Tuple
+from typing import Literal, Optional, Tuple
 
 import numpy as np
 import pandas as pd
-from joblib import Parallel  # type: ignore
-from joblib import delayed
-from joblib import parallel_backend
+from joblib import Parallel, delayed, parallel_backend  # type: ignore
 from scipy.optimize import minimize  # type: ignore
 
 from deconveil import inference
-from deconveil import utils_CNaware 
-from deconveil.utils_CNaware import fit_lin_mu
+from deconveil import utils_fit 
+from deconveil.utils_fit import fit_lin_mu
 
 from pydeseq2 import utils
 from pydeseq2.utils import get_num_processes
@@ -42,8 +38,8 @@ class DefInference(inference.Inference):
         Joblib backend.
     """
     
-    fit_rough_dispersions = staticmethod(utils_CNaware.fit_rough_dispersions)  # type: ignore
-    fit_moments_dispersions2 = staticmethod(utils_CNaware.fit_moments_dispersions2)  # type: ignore
+    fit_rough_dispersions = staticmethod(utils_fit.fit_rough_dispersions)  # type: ignore
+    fit_moments_dispersions2 = staticmethod(utils_fit.fit_moments_dispersions2)  # type: ignore
     
     def __init__(
         self,
@@ -79,7 +75,7 @@ class DefInference(inference.Inference):
                     verbose=self._joblib_verbosity,
                     batch_size=self._batch_size,
                 )(
-                    delayed(utils_CNaware.fit_lin_mu)(
+                    delayed(utils_fit.fit_lin_mu)(
                         counts=counts[:, i],
                         size_factors=size_factors,
                         design_matrix=design_matrix,
@@ -110,7 +106,7 @@ class DefInference(inference.Inference):
                 verbose=self._joblib_verbosity,
                 batch_size=self._batch_size,
             )(
-                delayed(utils_CNaware.irls_glm)(
+                delayed(utils_fit.irls_glm)(
                     counts=counts[:, i],
                     size_factors=size_factors,
                     design_matrix=design_matrix,
@@ -262,7 +258,7 @@ class DefInference(inference.Inference):
                 verbose=self._joblib_verbosity,
                 batch_size=self._batch_size,
             )(
-                delayed(utils_CNaware.nbinomGLM)(
+                delayed(utils_fit.nbinomGLM)(
                     design_matrix=design_matrix,
                     counts=counts[:, i],
                     cnv=cnv[:, i],
@@ -278,7 +274,3 @@ class DefInference(inference.Inference):
         res = zip(*res)
         lfcs, inv_hessians, l_bfgs_b_converged_ = (np.array(m) for m in res)
         return lfcs, inv_hessians, l_bfgs_b_converged_
-
-
-
-

{deconveil-0.1.0/DeConveil → deconveil-0.1.1/deconveil}/ds.py

@@ -1,8 +1,6 @@
 import sys
 import time
-from typing import List
-from typing import Literal
-from typing import Optional
+from typing import List, Literal, Optional
 
 import numpy as np
 import pandas as pd

{deconveil-0.1.0/DeConveil → deconveil-0.1.1/deconveil}/grid_search.py

@@ -3,7 +3,7 @@ from typing import Optional
 import numpy as np
 from scipy.special import gammaln  # type: ignore
 
-from deconveil import utils_CNaware
+from deconveil import utils_fit
 
 
 def grid_fit_beta(
@@ -156,7 +156,7 @@ def grid_fit_shrink_beta(
     def loss(beta: np.ndarray) -> float:
         # closure to minimize
         return (
-            utils_CNaware.nbinomFn(
+            utils_fit.nbinomFn(
                 beta,
                 design_matrix,
                 counts,

{deconveil-0.1.0/DeConveil → deconveil-0.1.1/deconveil}/inference.py

@@ -1,8 +1,6 @@
 from abc import ABC
 from abc import abstractmethod
-from typing import Literal
-from typing import Optional
-from typing import Tuple
+from typing import Literal, Optional, Tuple
 
 import numpy as np
 import pandas as pd
@@ -365,9 +363,4 @@ class Inference(ABC):
         converged: ndarray
             Whether L-BFGS-B converged for each optimization problem.
         """
-        
-    
-
-     
-
-
+        

deconveil-0.1.1/deconveil/utils_clustering.py

@@ -0,0 +1,201 @@
+import numpy as np
+import pandas as pd
+from sklearn.decomposition import PCA
+from sklearn.cluster import KMeans, AgglomerativeClustering
+from sklearn.metrics import silhouette_score
+from scipy.spatial.distance import pdist, squareform
+import random
+
+import matplotlib.pyplot as plt
+import seaborn as sns
+
+
+def pca_cluster_cn(
+    gene_cn: pd.DataFrame,
+    n_components: int = 20,
+    k: int = 2,
+    method: str = "kmeans",
+    random_state: int = 0,
+) -> dict:
+    """
+    Perform PCA on gene-level CN and cluster patients in PCA space.
+
+    Parameters
+    ----------
+    gene_cn : DataFrame
+        Gene x Sample matrix of CN values (log2 ratios).
+    n_components : int
+        Number of PCA components to keep.
+    k : int
+        Number of clusters.
+    method : str
+        'kmeans' or 'hierarchical'.
+    random_state : int
+        For reproducibility.
+
+    Returns
+    -------
+    dict with:
+        - labels: pd.Series (sample -> cluster)
+        - pca_coords: DataFrame of PCA coords
+        - explained_var: explained variance ratios
+    """
+    X = gene_cn.fillna(0).T  # samples × genes
+    pca = PCA(n_components=min(n_components, X.shape[1]))
+    coords = pca.fit_transform(X)
+    coords_df = pd.DataFrame(
+        coords, index=X.index, columns=[f"PC{i+1}" for i in range(coords.shape[1])]
+    )
+
+    if method == "kmeans":
+        model = KMeans(n_clusters=k, n_init=20, random_state=random_state)
+        labels = model.fit_predict(coords)
+    elif method == "hierarchical":
+        model = AgglomerativeClustering(n_clusters=k)
+        labels = model.fit_predict(coords)
+    else:
+        raise ValueError("method must be 'kmeans' or 'hierarchical'")
+
+    labels = pd.Series(labels, index=X.index, name="cluster")
+    return {
+        "labels": labels,
+        "pca_coords": coords_df,
+        "explained_var": pca.explained_variance_ratio_,
+    }
+
+
+def consensus_cluster_cn(
+    gene_cn: pd.DataFrame,
+    k: int = 2,
+    n_resamples: int = 50,
+    sample_fraction: float = 0.8,
+    feature_fraction: float = 0.8,
+    top_genes: int = 2000,
+    random_state: int = 0,
+) -> dict:
+    """
+    Consensus clustering of patients based on CN profiles.
+
+    Parameters
+    ----------
+    gene_cn : DataFrame
+        Gene x Sample CN matrix.
+    k : int
+        Number of clusters.
+    n_resamples : int
+        Number of resampling iterations.
+    sample_fraction : float
+        Fraction of patients sampled each iteration.
+    feature_fraction : float
+        Fraction of genes sampled each iteration.
+    top_genes : int
+        Use top variable genes only.
+    random_state : int
+        For reproducibility.
+
+    Returns
+    -------
+    dict with:
+        - labels: pd.Series (sample -> cluster) from consensus
+        - consensus_matrix: DataFrame (samples × samples) with co-clustering frequencies
+    """
+    rng = np.random.RandomState(random_state)
+
+    # Select top variable genes
+    var_genes = gene_cn.var(axis=1).sort_values(ascending=False).index[:top_genes]
+    data = gene_cn.loc[var_genes].fillna(0).values  # genes × samples
+    samples = gene_cn.columns.tolist()
+    n = len(samples)
+
+    co_mat = np.zeros((n, n))
+    counts = np.zeros((n, n))
+
+    for r in range(n_resamples):
+        samp_idx = rng.choice(n, size=int(sample_fraction * n), replace=False)
+        feat_idx = rng.choice(
+            data.shape[0], size=int(feature_fraction * data.shape[0]), replace=False
+        )
+        X = data[feat_idx][:, samp_idx].T  # subsampled patients × genes
+
+        # k-means in subsample
+        km = KMeans(n_clusters=k, n_init=10, random_state=rng).fit(X)
+        labels_sub = km.labels_
+
+        # update co-occurrence
+        for i, si in enumerate(samp_idx):
+            for j, sj in enumerate(samp_idx):
+                counts[si, sj] += 1
+                if labels_sub[i] == labels_sub[j]:
+                    co_mat[si, sj] += 1
+
+    consensus = np.divide(co_mat, counts, out=np.zeros_like(co_mat), where=counts > 0)
+    consensus_df = pd.DataFrame(consensus, index=samples, columns=samples)
+
+    # Cluster consensus matrix
+    dist = 1 - consensus
+    agg = AgglomerativeClustering(n_clusters=k, affinity="precomputed", linkage="average")
+    labels = agg.fit_predict(dist)
+    labels = pd.Series(labels, index=samples, name="cluster")
+
+    return {"labels": labels, "consensus_matrix": consensus_df}
+
+
+def consensus_cdf_range(
+    gene_cn, k_values=(2,3,4,5,6),
+    n_resamples=50, sample_fraction=0.8, feature_fraction=0.8,
+    top_genes=2000, random_state=0
+):
+    """
+    Run consensus clustering across multiple k and plot CDFs.
+
+    Parameters
+    ----------
+    gene_cn : DataFrame
+        Gene × Sample CN matrix.
+    k_values : list/tuple
+        Range of k to test.
+    n_resamples, sample_fraction, feature_fraction, top_genes, random_state
+        Passed to consensus_cluster_cn().
+
+    Returns
+    -------
+    dict
+        {k: {"labels", "consensus_matrix", "auc"}}
+    """
+    results = {}
+
+    plt.figure(figsize=(7,5))
+
+    for k in k_values:
+        res = consensus_cluster_cn(
+            gene_cn, k=k,
+            n_resamples=n_resamples,
+            sample_fraction=sample_fraction,
+            feature_fraction=feature_fraction,
+            top_genes=top_genes,
+            random_state=random_state
+        )
+
+        mat = res["consensus_matrix"].values
+        mask = ~np.eye(mat.shape[0], dtype=bool)
+        vals = mat[mask]
+
+        sorted_vals = np.sort(vals)
+        cdf = np.arange(1, len(sorted_vals)+1) / len(sorted_vals)
+
+        # Compute area under CDF (AUC)
+        auc = np.trapz(cdf, sorted_vals)
+        res["auc"] = auc
+        results[k] = res
+
+        plt.plot(sorted_vals, cdf, lw=2, label=f"k={k} (AUC={auc:.3f})")
+
+    plt.xlabel("Consensus value")
+    plt.ylabel("Cumulative fraction")
+    plt.title("Consensus CDF across k", fontsize=14)
+    plt.legend()
+    plt.grid(True, alpha=0.3)
+    plt.tight_layout()
+    plt.show()
+
+    return results

deconveil-0.1.0/DeConveil/utils_CNaware.py → deconveil-0.1.1/deconveil/utils_fit.py

@@ -1,30 +1,20 @@
 import os
 import multiprocessing
 import warnings
-from math import ceil
-from math import floor
+from math import ceil, floor
 from pathlib import Path
-from typing import List
-from typing import Literal
-from typing import Optional
-from typing import Tuple
-from typing import Union
-from typing import cast
+from typing import List, Literal, Optional, Tuple, Union, cast, Dict, Any
 
 import numpy as np
 import pandas as pd
-from matplotlib import pyplot as plt
 from scipy.linalg import solve  # type: ignore
 from scipy.optimize import minimize  # type: ignore
 from scipy.special import gammaln  # type: ignore
 from scipy.special import polygamma  # type: ignore
 from scipy.stats import norm  # type: ignore
 from sklearn.linear_model import LinearRegression  # type: ignore
-import matplotlib.pyplot as plt
-import seaborn as sns
 
 from deconveil.grid_search import grid_fit_beta
-
 from pydeseq2.utils import fit_alpha_mle
 from pydeseq2.utils import get_num_processes
 from pydeseq2.grid_search import grid_fit_alpha
@@ -209,7 +199,6 @@ def fit_rough_dispersions(
     return np.maximum(alpha_rde, 0)
 
 
-
 def fit_moments_dispersions2(
     normed_counts: np.ndarray, size_factors: np.ndarray
 ) -> np.ndarray:
@@ -470,6 +459,7 @@ def nbinomGLM(
     inv_hessian = np.linalg.inv(ddf(beta, 1))
 
     return beta, inv_hessian, converged
+    
 
 def nbinomFn(
     beta: np.ndarray,
@@ -533,277 +523,3 @@ def nbinomFn(
     ).sum(0)
 
     return prior - nll
-
-
-
-def process_results(file_path, method, lfc_cut = 1.0, pval_cut = 0.05):
-    df = pd.read_csv(file_path, index_col=0)
-    df['isDE'] = (np.abs(df['log2FoldChange']) >= lfc_cut) & (df['padj'] <= pval_cut)
-    df['DEtype'] = np.where(
-        ~df['isDE'], 
-        "n.s.", 
-        np.where(df['log2FoldChange'] > 0, "Up-reg", "Down-reg")
-    )
-    df['method'] = method
-    return df[['log2FoldChange', 'padj', 'isDE', 'DEtype', 'method']]
-    
-
-def define_gene_groups(res_joint):
-    DSGs = res_joint[
-        ((res_joint['DEtype_naive'] == "Up-reg") & (res_joint['DEtype_aware'] == "n.s.")) |
-        ((res_joint['DEtype_naive'] == "Down-reg") & (res_joint['DEtype_aware'] == "n.s."))
-    ].assign(gene_category='DSGs')
-    
-    DIGs = res_joint[
-        ((res_joint['DEtype_naive'] == "Up-reg") & (res_joint['DEtype_aware'] == "Up-reg")) |
-        ((res_joint['DEtype_naive'] == "Down-reg") & (res_joint['DEtype_aware'] == "Down-reg"))
-    ].assign(gene_category='DIGs')
-             
-    DCGs = res_joint[
-        ((res_joint['DEtype_naive'] == "n.s.") & (res_joint['DEtype_aware'] == "Up-reg")) |
-        ((res_joint['DEtype_naive'] == "n.s.") & (res_joint['DEtype_aware'] == "Down-reg"))
-    ].assign(gene_category='DCGs')
-             
-    non_DEGs = res_joint[
-        (res_joint['DEtype_naive'] == "n.s.") & (res_joint['DEtype_aware'] == "n.s.")
-    ].assign(gene_category='non-DEGs')
-             
-    return {
-        "DSGs": DSGs,
-        "DIGs": DIGs,
-        "DCGs": DCGs,
-        "non_DEGs": non_DEGs
-    }
-
-
-def generate_volcano_plot(plot_data, lfc_cut=1.0, pval_cut=0.05, xlim=None, ylim=None):
-    plot_data['gene_group'] = plot_data['gene_group'].astype('category')
-    
-    # Define gene group colors
-    gene_group_colors = {
-        "DIGs": "#8F3931FF",
-        "DSGs": "#FFB977",
-        "DCGs": "#FFC300"
-    }
-
-    # Create a FacetGrid for faceted plots
-    g = sns.FacetGrid(
-        plot_data, 
-        col="method", 
-        margin_titles=True, 
-        hue="gene_group", 
-        palette=gene_group_colors, 
-        sharey=False, 
-        sharex=True
-    )
-
-    
-    # Add points for "DIGs" 
-    g.map_dataframe(
-        sns.scatterplot, 
-        x="log2FC", 
-        y="-log10(padj)", 
-        alpha=0.1, 
-        size=0.5, 
-        legend=False, 
-        data=plot_data[plot_data['gene_group'].isin(["DIGs"])]
-    )
-
-    # Add points for "DSGs" and "DCGs"
-    g.map_dataframe(
-        sns.scatterplot, 
-        x="log2FC", 
-        y="-log10(padj)", 
-        alpha=1.0, 
-        size=3.0, 
-        legend=False, 
-        data=plot_data[plot_data['gene_group'].isin(["DSGs", "DCGs"])]
-    )
-    
-    # Add vertical and horizontal dashed lines
-    for ax in g.axes.flat:
-        ax.axvline(x=-lfc_cut, color="gray", linestyle="dashed")
-        ax.axvline(x=lfc_cut, color="gray", linestyle="dashed")
-        ax.axhline(y=-np.log10(pval_cut), color="gray", linestyle="dashed")
-        
-        if xlim:
-            ax.set_xlim(xlim)
-        if ylim:
-            ax.set_ylim(ylim)
-    
-    # Set axis labels
-    g.set_axis_labels("Log2 FC", "-Log10 P-value")
-    
-    # Add titles, legends, and customize
-    g.add_legend(title="Gene category")
-    g.set_titles(row_template="{row_name}", col_template="{col_name}")
-    g.tight_layout()
-    
-    # Adjust font sizes for better readability
-    for ax in g.axes.flat:
-        ax.tick_params(axis='both', labelsize=12)
-        ax.set_xlabel("Log2 FC", fontsize=14)
-        ax.set_ylabel("-Log10 P-value", fontsize=14)
-    
-    # Save or display the plot
-    plt.show()
-
-
-def plot_cnv_hist(cnv_mean, binwidth=0.2):
-    """
-    Plots a histogram of the CNV mean distribution.
-
-    Parameters:
-        cnv_mean (pd.Series or list): The CNV mean values to plot.
-        binwidth (float): The bin width for the histogram.
-    """
-    # Convert to a DataFrame if it's not already
-    if isinstance(cnv_mean, list):
-        cnv_mean = pd.DataFrame({'cnv_mean': cnv_mean})
-    elif isinstance(cnv_mean, pd.Series):
-        cnv_mean = cnv_mean.to_frame(name='cnv_mean')
-
-    # Create the histogram plot
-    plt.figure(figsize=(5, 5))
-    sns.histplot(
-        cnv_mean['cnv_mean'],
-        bins=int((cnv_mean['cnv_mean'].max() - cnv_mean['cnv_mean'].min()) / binwidth),
-        kde=False,
-        color="#F39B7F",
-        edgecolor="black",
-        alpha=0.7
-    )
-
-    # Add labels and titles
-    plt.title("", fontsize=14)
-    plt.xlabel("CN state", fontsize=14, labelpad=8)
-    plt.ylabel("Frequency", fontsize=14, labelpad=8)
-
-    # Customize the appearance of axes
-    plt.xticks(fontsize=12, color="black", rotation=45, ha="right")
-    plt.yticks(fontsize=12, color="black")
-    plt.gca().spines["top"].set_visible(False)
-    plt.gca().spines["right"].set_visible(False)
-    plt.gca().spines["left"].set_linewidth(1)
-    plt.gca().spines["bottom"].set_linewidth(1)
-
-    # Add a grid
-    plt.grid(visible=False)
-
-    # Show the plot
-    plt.tight_layout()
-    plt.show()
-
-
-def plot_stacked_bar(combined_data):
-    """
-    Creates a stacked bar plot of gene counts by CNV group for each tumor type.
-    
-    Parameters:
-    - combined_data: DataFrame containing the data to plot.
-    """
-    # Define CNV colors inside the function
-    cnv_colors = {
-        "loss": "#0000FF",
-        "neutral": "#808080",
-        "gain": "#00FF00",
-         "amplification": "#FF0000"
-    }
-    
-    tumor_types = combined_data['tumor_type'].unique()
-    
-    # Create subplots for each tumor type
-    fig, axes = plt.subplots(1, len(tumor_types), figsize=(5, 5), sharey=True)
-    
-    # If there's only one tumor type, axes will not be an array, so we convert it into a list
-    if len(tumor_types) == 1:
-        axes = [axes]
-    
-    for idx, tumor_type in enumerate(tumor_types):
-        ax = axes[idx]
-        tumor_data = combined_data[combined_data['tumor_type'] == tumor_type]
-        
-        # Create a table of counts for CNV group vs gene group
-        counts = pd.crosstab(tumor_data['gene_group'], tumor_data['cnv_group'])
-        
-        # Plot stacked bars
-        counts.plot(kind='bar', stacked=True, ax=ax, color=[cnv_colors[group] for group in counts.columns], width=0.6)
-
-        ax.set_title(tumor_type, fontsize=16)
-        ax.set_xlabel("")
-        ax.set_ylabel("Gene Counts", fontsize=16)
-        
-        # Customize axis labels and tick marks
-        ax.tick_params(axis='x', labelsize=16, labelcolor="black")
-        ax.tick_params(axis='y', labelsize=16, labelcolor="black")
-    
-    # Overall settings for layout and labels
-    plt.xticks(fontsize=12, color="black", rotation=45, ha="right")
-    plt.tight_layout()
-    plt.show()
-    
-
-def plot_percentage_bar(barplot_data):
-    """
-    Creates a bar plot showing the percentage of genes for each gene group across tumor types.
-    
-    Parameters:
-    - barplot_data: DataFrame containing 'gene_group', 'percentage', and 'Count' columns.
-    """
-    # Define the gene group colors inside the function
-    gene_group_colors = {
-        "DIGs": "#8F3931FF",
-        "DSGs": "#FFB977",
-        "DCGs": "#FFC300"
-    }
-
-    tumor_types = barplot_data['tumor_type'].unique()
-    
-    plt.figure(figsize=(5, 5))
-    sns.set(style="whitegrid")
-
-    # Create subplots for each tumor type
-    fig, axes = plt.subplots(1, len(tumor_types), figsize=(5, 5), sharey=True)
-    
-    # If only one tumor type, ensure axes is a list
-    if len(tumor_types) == 1:
-        axes = [axes]
-    
-    for idx, tumor_type in enumerate(tumor_types):
-        ax = axes[idx]
-        tumor_data = barplot_data[barplot_data['tumor_type'] == tumor_type]
-        
-        # Plot the percentage bar plot
-        sns.barplot(data=tumor_data, x="gene_group", y="percentage", hue="gene_group",
-                    palette=gene_group_colors, ax=ax, width=0.6)
-
-        # Add counts and percentages as labels
-        for p in ax.patches:
-            height = p.get_height()
-            gene_group = p.get_x() + p.get_width() / 2  # Get the x position of the patch (bar)
-
-            # Find the gene_group in the data based on its position
-            group_name = tumor_data.iloc[int(gene_group)]['gene_group']
-            count = tumor_data.loc[tumor_data['gene_group'] == group_name, 'Count'].values[0]
-            percentage = tumor_data.loc[tumor_data['gene_group'] == group_name, 'percentage'].values[0]
-
-            # Position the labels slightly above the bars
-            ax.text(p.get_x() + p.get_width() / 2, height + 0.5, f'{count} ({round(percentage, 1)}%)', 
-                    ha='center', va='bottom', fontsize=12, color="black")
-        
-        ax.set_title(tumor_type, fontsize=16)
-        ax.set_xlabel("")
-        ax.set_ylabel("Percentage of Genes", fontsize=16)
-
-        # Customize axis labels and tick marks
-        ax.tick_params(axis='x', labelsize=16, labelcolor="black", rotation=45)
-        ax.tick_params(axis='y', labelsize=16, labelcolor="black")
-
-        # Explicitly set the x-tick labels with proper rotation and alignment
-        for tick in ax.get_xticklabels():
-            tick.set_horizontalalignment('right')  # This ensures proper alignment for x-ticks
-            tick.set_rotation(45)
-
-    # Overall settings for layout and labels
-    plt.tight_layout()
-    plt.show()

deconveil-0.1.1/deconveil/utils_plot.py

@@ -0,0 +1,308 @@
+import numpy as np
+import pandas as pd
+
+import matplotlib.pyplot as plt
+import seaborn as sns
+
+
+def plot_volcano(plot_data, lfc_cut=1.0, pval_cut=0.05, xlim=None, ylim=None):
+    plot_data['gene_group'] = plot_data['gene_group'].astype('category')
+    
+    # Define gene group colors
+    gene_group_colors = {
+        "DIGs": "#8F3931FF",
+        "DSGs": "#FFB977",
+        "DCGs": "#FFC300"
+    }
+
+    # Create a FacetGrid for faceted plots
+    g = sns.FacetGrid(
+        plot_data, 
+        col="method", 
+        margin_titles=True, 
+        hue="gene_group", 
+        palette=gene_group_colors, 
+        sharey=False, 
+        sharex=True
+    )
+
+    
+    # Add points for "DIGs" 
+    g.map_dataframe(
+        sns.scatterplot, 
+        x="log2FC", 
+        y="-log10(padj)", 
+        alpha=0.2, 
+        size=0.5, 
+        legend=False, 
+        data=plot_data[plot_data['gene_group'] == "DIGs"]
+    )
+
+    # Add points for "DSGs" and "DCGs
+    g.map_dataframe(
+        sns.scatterplot, 
+        x="log2FC", 
+        y="-log10(padj)", 
+        alpha=0.8, 
+        s=3.0, 
+        legend=False, 
+        data=plot_data[plot_data['gene_group'] == "DSGs"]
+    )
+
+    g.map_dataframe(
+        sns.scatterplot, 
+        x="log2FC", 
+        y="-log10(padj)", 
+        alpha=1.0, 
+        s=3.0, 
+        legend=False, 
+        data=plot_data[plot_data['gene_group'] == "DCGs"],
+        zorder=5              # force to front
+    )
+    
+    # Threshold lines
+    for ax in g.axes.flat:
+        ax.axvline(x=-lfc_cut, color="gray", linestyle="dashed")
+        ax.axvline(x=lfc_cut, color="gray", linestyle="dashed")
+        ax.axhline(y=-np.log10(pval_cut), color="gray", linestyle="dashed")
+        
+        if xlim:
+            ax.set_xlim(xlim)
+        if ylim:
+            ax.set_ylim(ylim)
+    
+    # Labels and legend
+    g.set_axis_labels("Log2 FC", "-Log10 P-value")
+    g.add_legend(title="Gene category")
+    g.set_titles(row_template="{row_name}", col_template="{col_name}")
+    g.tight_layout()
+    
+    # Axis formatting
+    for ax in g.axes.flat:
+        ax.tick_params(axis='both', labelsize=12)
+        ax.set_xlabel("Log2 FC", fontsize=14)
+        ax.set_ylabel("-Log10 P-value", fontsize=14)
+    
+    # Save or display the plot
+    plt.show()
+
+
+def plot_cnv_hist(cnv_mean, binwidth=0.2, title="CNV Mean Distribution"):
+    """
+    Plots a histogram of the CNV mean distribution.
+
+    Parameters:
+        cnv_mean (pd.Series or list): The CNV mean values to plot.
+        binwidth (float): The bin width for the histogram.
+        title (str): The title of the plot.
+    """
+    # Convert to a DataFrame if it's not already
+    if isinstance(cnv_mean, list):
+        cnv_mean = pd.DataFrame({'cnv_mean': cnv_mean})
+    elif isinstance(cnv_mean, pd.Series):
+        cnv_mean = cnv_mean.to_frame(name='cnv_mean')
+
+    # Create the histogram plot
+    plt.figure(figsize=(5, 5))
+    sns.histplot(
+        cnv_mean['cnv_mean'],
+        bins=int((cnv_mean['cnv_mean'].max() - cnv_mean['cnv_mean'].min()) / binwidth),
+        kde=False,
+        color="#F39B7F",
+        edgecolor="black",
+        alpha=0.7
+    )
+
+    # Add labels and titles
+    plt.title(title, fontsize=14, pad=12)
+    plt.xlabel("CN state", fontsize=14, labelpad=8)
+    plt.ylabel("Frequency", fontsize=14, labelpad=8)
+
+    # Customize the appearance of axes
+    plt.xticks(fontsize=12, color="black", rotation=45, ha="right")
+    plt.yticks(fontsize=12, color="black")
+    plt.gca().spines["top"].set_visible(False)
+    plt.gca().spines["right"].set_visible(False)
+    plt.gca().spines["left"].set_linewidth(1)
+    plt.gca().spines["bottom"].set_linewidth(1)
+
+    # Add a grid
+    plt.grid(visible=False)
+
+    # Show the plot
+    plt.tight_layout()
+    plt.show()
+
+
+def plot_stacked_bar(combined_data):
+    """
+    Creates a stacked bar plot of gene counts by CNV group for each tumor type.
+    
+    Parameters:
+    - combined_data: DataFrame containing the data to plot.
+    """
+    # Define CNV colors inside the function
+    cnv_colors = {
+        "loss": "dodgerblue",
+        "neutral": "gray",
+        "gain": "yellowgreen",
+         "amplification": "coral"
+    }
+    
+    tumor_types = combined_data['tumor_type'].unique()
+    
+    # Create subplots for each tumor type
+    fig, axes = plt.subplots(1, len(tumor_types), figsize=(5, 5), sharey=True)
+    
+    # If there's only one tumor type, axes will not be an array, so we convert it into a list
+    if len(tumor_types) == 1:
+        axes = [axes]
+    
+    for idx, tumor_type in enumerate(tumor_types):
+        ax = axes[idx]
+        tumor_data = combined_data[combined_data['tumor_type'] == tumor_type]
+        
+        # Create a table of counts for CNV group vs gene group
+        counts = pd.crosstab(tumor_data['gene_group'], tumor_data['cnv_group'])
+        
+        # Plot stacked bars
+        counts.plot(kind='bar', stacked=True, ax=ax, color=[cnv_colors[group] for group in counts.columns], width=0.6)
+
+        ax.set_title(tumor_type, fontsize=16)
+        ax.set_xlabel("")
+        ax.set_ylabel("Gene Counts", fontsize=16)
+        
+        # Customize axis labels and tick marks
+        ax.tick_params(axis='x', labelsize=16, labelcolor="black")
+        ax.tick_params(axis='y', labelsize=16, labelcolor="black")
+    
+    # Overall settings for layout and labels
+    plt.xticks(fontsize=12, color="black", rotation=45, ha="right")
+    plt.tight_layout()
+    plt.show()
+    
+
+def plot_percentage_bar(barplot_data):
+    """
+    Creates a bar plot showing the percentage of genes for each gene group across tumor types.
+    
+    Parameters:
+    - barplot_data: DataFrame containing 'gene_group', 'percentage', and 'Count' columns.
+    """
+    # Define the gene group colors inside the function
+    gene_group_colors = {
+        "DIGs": "#8F3931FF",
+        "DSGs": "#FFB977",
+        "DCGs": "#FFC300"
+    }
+
+    tumor_types = barplot_data['tumor_type'].unique()
+    
+    plt.figure(figsize=(5, 5))
+    sns.set(style="whitegrid")
+
+    # Create subplots for each tumor type
+    fig, axes = plt.subplots(1, len(tumor_types), figsize=(5, 5), sharey=True)
+    
+    # If only one tumor type, ensure axes is a list
+    if len(tumor_types) == 1:
+        axes = [axes]
+    
+    for idx, tumor_type in enumerate(tumor_types):
+        ax = axes[idx]
+        tumor_data = barplot_data[barplot_data['tumor_type'] == tumor_type]
+        
+        # Plot the percentage bar plot
+        sns.barplot(data=tumor_data, x="gene_group", y="percentage", hue="gene_group",
+                    palette=gene_group_colors, ax=ax, width=0.6)
+
+        # Add counts and percentages as labels
+        for p in ax.patches:
+            height = p.get_height()
+            gene_group = p.get_x() + p.get_width() / 2  # Get the x position of the patch (bar)
+
+            # Find the gene_group in the data based on its position
+            group_name = tumor_data.iloc[int(gene_group)]['gene_group']
+            count = tumor_data.loc[tumor_data['gene_group'] == group_name, 'Count'].values[0]
+            percentage = tumor_data.loc[tumor_data['gene_group'] == group_name, 'percentage'].values[0]
+
+            # Position the labels slightly above the bars
+            ax.text(p.get_x() + p.get_width() / 2, height + 0.5, f'{count} ({round(percentage, 1)}%)', 
+                    ha='center', va='bottom', fontsize=12, color="black")
+        
+        ax.set_title(tumor_type, fontsize=16)
+        ax.set_xlabel("")
+        ax.set_ylabel("Percentage of Genes", fontsize=16)
+
+        # Customize axis labels and tick marks
+        ax.tick_params(axis='x', labelsize=16, labelcolor="black", rotation=45)
+        ax.tick_params(axis='y', labelsize=16, labelcolor="black")
+
+        # Explicitly set the x-tick labels with proper rotation and alignment
+        for tick in ax.get_xticklabels():
+            tick.set_horizontalalignment('right')  # This ensures proper alignment for x-ticks
+            tick.set_rotation(45)
+
+    # Overall settings for layout and labels
+    plt.tight_layout()
+    plt.show()
+
+
+def plot_pca_clusters(pca_coords, labels, explained_var, title="PCA Clustering"):
+    """
+    Scatterplot of first 2 PCs with cluster colors, showing variance explained.
+
+    Parameters
+    ----------
+    pca_coords : DataFrame
+        PCA coordinates (samples × PCs), from pca_cluster_cn().
+    labels : pd.Series
+        Cluster assignments (index must match pca_coords).
+    explained_var : array-like
+        Explained variance ratio for each PC.
+    title : str
+        Plot title.
+    """
+    df_plot = pca_coords.copy()
+    df_plot["cluster"] = labels.astype(str)
+
+    plt.figure(figsize=(7,6))
+    sns.scatterplot(
+        x="PC1", y="PC2", hue="cluster",
+        data=df_plot, palette="Set2", s=70, alpha=0.9, edgecolor="k"
+    )
+
+    # Format axis labels with variance %
+    pc1_var = explained_var[0] * 100
+    pc2_var = explained_var[1] * 100
+    plt.xlabel(f"PC1 ({pc1_var:.1f}% variance)")
+    plt.ylabel(f"PC2 ({pc2_var:.1f}% variance)")
+
+    plt.title(title, fontsize=14)
+    plt.legend(title="Cluster", bbox_to_anchor=(1.05, 1), loc="upper left")
+    plt.tight_layout()
+    plt.show()
+
+
+def plot_consensus_matrix(consensus_matrix, labels, title="Consensus Matrix"):
+    """
+    Heatmap of consensus matrix with samples ordered by cluster.
+    
+    Parameters
+    ----------
+    consensus_matrix : pd.DataFrame
+        Sample × Sample consensus values.
+    labels : pd.Series
+        Final cluster assignments (same sample index).
+    """
+    # Order samples by cluster
+    ordered_samples = labels.sort_values().index
+    mat = consensus_matrix.loc[ordered_samples, ordered_samples]
+
+    plt.figure(figsize=(7,6))
+    sns.heatmap(mat, cmap="viridis", square=True, cbar_kws={"label": "Consensus"})
+    plt.title(title, fontsize=14)
+    plt.xlabel("Samples")
+    plt.ylabel("Samples")
+    plt.tight_layout()
+    plt.show()

deconveil-0.1.1/deconveil/utils_processing.py

@@ -0,0 +1,132 @@
+import os
+import warnings
+from math import ceil, floor
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+from typing import List, Literal, Optional, Dict, Any, cast
+
+
+
+def filter_low_count_genes(
+    df: pd.DataFrame,
+    other_dfs: Optional[List[pd.DataFrame]] = None,
+    min_count: int = 10,
+    min_samples: Optional[int] = 3,
+    min_frac: Optional[float] = None,
+    return_mask: bool = False
+) -> Dict[str, Any]:
+    """
+    Filter genes (columns) by expression thresholds.
+
+    Parameters
+    ----------
+    df : pd.DataFrame
+        Main dataframe (genes as columns, samples as rows).
+    other_dfs : list of pd.DataFrame, optional
+        Other dataframes with the same columns to filter in parallel.
+    min_count : int, default=10
+        Minimum expression/count threshold.
+    min_samples : int, default=3
+        Minimum number of samples meeting the threshold.
+    min_frac : float, optional
+        Fraction of samples that must meet the threshold.
+        If provided, overrides min_samples.
+    return_mask : bool, default=False
+        If True, also return the boolean mask of kept genes.
+
+    Returns
+    -------
+    result : dict
+        {
+            "filtered_df": pd.DataFrame,
+            "other_filtered": list[pd.DataFrame] or None,
+            "mask": pd.Series (if return_mask),
+            "stats": dict with counts
+        }
+    """
+    # compute required min_samples
+    if min_frac is not None:
+        min_samples = max(1, int(round(min_frac * df.shape[0])))
+
+    # gene-wise filter mask
+    mask = (df >= min_count).sum(axis=0) >= min_samples
+
+    # apply mask
+    filtered_df = df.loc[:, mask]
+    filtered_others = [odf.loc[:, mask] for odf in other_dfs] if other_dfs else None
+
+    # collect stats
+    stats = {
+        "n_total": df.shape[1],
+        "n_kept": int(mask.sum()),
+        "n_removed": int((~mask).sum()),
+        "min_count": min_count,
+        "min_samples": min_samples,
+    }
+
+    result = {
+        "filtered_df": filtered_df,
+        "other_filtered": filtered_others,
+        "stats": stats,
+    }
+    if return_mask:
+        result["mask"] = mask
+
+    return result
+
+
+def process_results(file_path, method, lfc_cut = 1.0, pval_cut = 0.05):
+    df = pd.read_csv(file_path, index_col=0)
+    df['isDE'] = (np.abs(df['log2FoldChange']) >= lfc_cut) & (df['padj'] <= pval_cut)
+    df['DEtype'] = np.where(
+        ~df['isDE'], 
+        "n.s.", 
+        np.where(df['log2FoldChange'] > 0, "Up-reg", "Down-reg")
+    )
+    df['method'] = method
+    return df[['log2FoldChange', 'padj', 'isDE', 'DEtype', 'method']]
+    
+
+def define_gene_groups(res_joint):
+    DSGs = res_joint[
+        ((res_joint['DEtype_naive'] == "Up-reg") & (res_joint['DEtype_aware'] == "n.s.")) |
+        ((res_joint['DEtype_naive'] == "Down-reg") & (res_joint['DEtype_aware'] == "n.s."))
+    ].assign(gene_category='DSGs')
+    
+    DIGs = res_joint[
+        ((res_joint['DEtype_naive'] == "Up-reg") & (res_joint['DEtype_aware'] == "Up-reg")) |
+        ((res_joint['DEtype_naive'] == "Down-reg") & (res_joint['DEtype_aware'] == "Down-reg"))
+    ].assign(gene_category='DIGs')
+             
+    DCGs = res_joint[
+        ((res_joint['DEtype_naive'] == "n.s.") & (res_joint['DEtype_aware'] == "Up-reg")) |
+        ((res_joint['DEtype_naive'] == "n.s.") & (res_joint['DEtype_aware'] == "Down-reg"))
+    ].assign(gene_category='DCGs')
+             
+    non_DEGs = res_joint[
+        (res_joint['DEtype_naive'] == "n.s.") & (res_joint['DEtype_aware'] == "n.s.")
+    ].assign(gene_category='non-DEGs')
+             
+    return {
+        "DSGs": DSGs,
+        "DIGs": DIGs,
+        "DCGs": DCGs,
+        "non_DEGs": non_DEGs
+    }
+
+
+def clean_gene_group(df, mode="naive"):
+    """Rename and subset a gene group dataframe for a given mode."""
+    suffix = f"_{mode}"
+    rename_map = {
+        f"logFC{suffix}": "log2FC",
+        f"padj{suffix}": "padj",
+        f"isDE{suffix}": "isDE",
+        f"DEtype{suffix}": "DEtype",
+        f"method{suffix}": "method",
+        "gene_category": "gene_group"
+    }
+    return df.rename(columns=rename_map)[["log2FC", "padj", "isDE", "DEtype", "method", "gene_group"]]

{deconveil-0.1.0 → deconveil-0.1.1}/setup.py

@@ -6,13 +6,13 @@ long_description = (this_directory / "README.md").read_text()
 
 setup(
     name="DeConveil",
-    version="0.1.0",
+    version="0.1.1",
     description="An extension of PyDESeq2/DESeq2 designed to account for genome aneuploidy",
     url="https://github.com/caravagnalab/DeConveil",
     author="Katsiaryna Davydzenka",
     author_email="katiasen89@gmail.com",
     license="MIT",
-    packages=["DeConveil"],
+    packages=["deconveil"],
     python_requires=">=3.10.0",  
     install_requires=[
         "anndata>=0.8.0",

deconveil-0.1.0/DeConveil.egg-info/SOURCES.txt

@@ -1,15 +0,0 @@
-LICENSE
-README.md
-setup.py
-DeConveil/__init__.py
-DeConveil/dds.py
-DeConveil/default_inference.py
-DeConveil/ds.py
-DeConveil/grid_search.py
-DeConveil/inference.py
-DeConveil/utils_CNaware.py
-DeConveil.egg-info/PKG-INFO
-DeConveil.egg-info/SOURCES.txt
-DeConveil.egg-info/dependency_links.txt
-DeConveil.egg-info/requires.txt
-DeConveil.egg-info/top_level.txt

deconveil-0.1.0/DeConveil.egg-info/top_level.txt

@@ -1 +0,0 @@
-DeConveil

deconveil-0.1.0/README.md

@@ -1,40 +0,0 @@
-# DeConveil
-
-The goal of *DeConveil* is the extension of Differential Gene Expression testing by accounting for genome aneuploidy.
-This computational framework extends traditional DGE analysis by integrating Copy Number Variation (CNV) data.
-This approach adjusts for dosage effects and categorizes genes as *dosage-sensitive (DSG)*, *dosage-insensitive (DIG)*, and *dosage-compensated (DCG)*, separating the expression changes caused by CNVs from other alterations in transcriptional regulation.
-To perform this gene separation we need to perform DGE testing using both PyDESeq2 (CN-naive) and DeConveil (CN-aware) methods.
-
-**Pre-required installations before running DeConveil** 
-
-Python libraries are required to be installed: *pydeseq2*
-
-`pip install pydeseq2`
-
-
-**How to install DeConveil**
-
-`git clone https://github.com/caravagnalab/DeConveil.git`
-
-
-**Input data**
-
-DeConveil requires the following input matrices: matched mRNA read counts (normal and tumor samples) and absolute CN values (for normal diploid samples we assign CN 2), and design matrix. Example of CN data for a given gene *g*: [1,2,3,4,5,6]. Each value of CN we divide by 2: CN/2. Example of input data is shown in *test_deconveil* Jupyter Notebook.
-
-
-**Output data**
-
-`res_CNnaive.csv` (for *PyDESeq2* method) and `res_CNaware.csv` (for *DeConveil*) data frames reporting *log2FC* and *p.adjust* for both methods.
-These data are further processed to separate gene groups using `define_gene_groups()` function included in DeConveil framework.
-
-The tutorial of the analysis workflow is shown in `test_deconveil.ipynb`
-
-
-
-### References
-
-1. Michael I Love, Wolfgang Huber, and Simon Anders. Moderated estimation of fold change and dispersion for rna-seq data with deseq2. Genome biology, 15(12):1–21, 2014. doi:10.1186/s13059-014-0550-8.
-
-2. Boris Muzellec, Maria Telenczuk, Vincent Cabeli, and Mathieu Andreux. Pydeseq2: a python package for bulk rna-seq differential expression analysis. bioRxiv, pages 2022–12, 2022. doi:10.1101/2022.12.14.520412.
-
-3. Anqi Zhu, Joseph G Ibrahim, and Michael I Love. Heavy-tailed prior distributions for sequence count data: removing the noise and preserving large differences. Bioinformatics, 35(12):2084–2092, 2019. doi:10.1093/bioinformatics/bty895.