======

deseq2

======

.. currentmodule:: inmoose.deseq2

This module is a partial port of the R Bioconductor `DESeq2 package

<https://bioconductor.org/packages/release/bioc/html/DESeq2.html>`_ [Love2014]_.

.. repl::

   from inmoose.deseq2 import *

   import patsy

   import numpy as np

   import matplotlib.pyplot as plt

   import pandas as pd

   import scipy

.. repl-quiet::

   pd.options.display.max_columns = 10

   from matplotlib import rcParams

   # repl default config replaces '.' by '-' in the savefig.directory :/

   rcParams['savefig.directory'] = rcParams['savefig.directory'].replace("readthedocs-org", "readthedocs.org")

Quick start

===========

Here we show the most basic steps for a differential expression analysis. There

are a variety of steps upstream of DESeq2 that result in the generation of

counts or estimated counts for each sample, which we will discuss in the

sections below. This code chunk assumes that you have a count matrix called

:code:`cts` and a table of sample information called :code:`coldata`.  The

:code:`design` indicates how to model the samples, here, that we want to measure

the effect of the condition, controlling for batch differences. The two factor

variables :code:`batch` and :code:`condition` should  be columns of

:code:`coldata`:

>>> dds = DESeqDataSet(countData = cts,

...                    clinicalData = coldata,

...                    design = "~ batch + condition")

>>> dds = DESeq(dds)

>>> # list the coefficients

>>> dds.resultsNames()

>>> res = dds.results(name = "condition_trt_vs_untrt")

>>> # or to shrink the log fold changes association with condition

>>> res = dds.lfcShrink(coef = "condition_trt_vs_untrt", type = "apeglm")

Input data

==========

Why un-normalized counts?

-------------------------

As input, the DESeq2 package expects count data as obtained, *e.g.* from RNA-seq

or another high-throughput sequencing experiment, in the form of a matrix of

integer values. The value in the :math:`i`-th row and the :math:`j`-th column of

the matrix tells how many reads can be assigned to gene :math:`i` in sample

:math:`j`.  Analogously, for other types of assays, the rows of the matrix might

correspond *e.g.* to binding regions (with ChIP-Seq) or peptide sequences (with

quantitative mass spectrometry). We will list method for obtaining count

matrices in sections below.

The values in the matrix should be un-normalized counts or estimated counts of

sequencing reads (for single-end RNA-seq) or fragments (for paired-end RNA-seq).

The `RNA-seq workflow <http://www.bioconductor.org/help/workflows/rnaseqGene/>`_

describes multiple techniques for preparing such count matrices.  It is

important to provide count matrices as input for DESeq2's statistical model

[Love2014]_ to hold, as only the count values allow assessing the measurement

precision correctly. The DESeq2 model internally corrects for library size, so

transformed or normalized values such as counts scaled by library size should

not be used as input.

The DESeqDataSet

----------------

The object class used by the DESeq2 package to store the read counts and the

intermediate estimated quantities during statistical analysis is the

:class:`~DESeqDataSet.DESeqDataSet`, which will usually be represented in the

code here as an object :code:`dds`.

A technical detail is that the :class:`~DESeqDataSet.DESeqDataSet` class extends

the :class:`AnnData` class of the `anndata

<https://github.com/scverse/anndata>`_ package.

A :class:`~DESeqDataSet.DESeqDataSet` object must have an associated **design

matrix**.  The design matrix expresses the variables which will be used in

modeling. The matrix is built from a formula starting with a tilde (~) followed

by the variables with plus signs between them (it will be coerced into a formula

if it is not already). The design can be changed later, however then all

differential analysis steps should be repeated, as the design formula is used to

estimate the dispersions and to estimate the log2 fold changes of the model.

.. note::

   In order to benefit from the default settings of the package, you should put

   the variable of interest at the end of the formula and make sure the control

   level is the first level.

We will now show 2 ways of constructing a :class:`~DESeqDataSet.DESeqDataSet`,

depending on what pipeline was used upstream of DESeq2 to generated counts or

estimated counts:

  1. From a count matrix :ref:`countmat`

  2. From an :class:`AnnData` object :ref:`ad`

.. note::

   The original R package allows to build a :class:`~DESeqDataSet.DESeqDataSet`

   from transcript abundance files and htseq count files, but those features

   have not yet been ported into `inmoose`.

.. _countmat:

Count matrix input

------------------

The constructor :meth:`.DESeqDataSet.__init__` can be used if you already have a

matrix of read counts prepared from another source. Another method for quickly

producing count matrices from alignment files is the :code:`featureCounts`

function [Liao2013]_ in the `Rsubread

<http://bioconductor.org/packages/Rsubread>`_ package.  To use the constructor

of :meth:`.DESeqDataSet.__init__`, the user should provide the counts matrix,

the information about the samples (the rows of the count matrix) as a data

frame, and the design formula.

To demonstrate the construction of :class:`~DESeqDataSet.DESeqDataSet` from a

count matrix, we will read in count data from the `pasilla

<http://bioconductor.org/packages/pasilla>`_ package, available in `inmoose`. We

read in a count matrix, which we will name :code:`cts`, and the sample

information table, which we will name :code:`sample_data`.  Further below we

describe how to extract these objects from, *e.g.* :code:`featureCounts`

output:

.. repl::

   import importlib.resources

   from inmoose.utils import Factor

   data_dir = importlib.resources.files("inmoose.data.pasilla")

   pasCts = data_dir.joinpath("pasilla_gene_counts.tsv")

   pasAnno = data_dir.joinpath("pasilla_sample_annotation.csv")

   cts = pd.read_csv(pasCts, sep='\t', index_col=0)

   sample_data = pd.read_csv(pasAnno, index_col=0)

   sample_data = sample_data[["condition", "type"]]

   sample_data["condition"] = Factor(sample_data["condition"])

   sample_data["type"] = Factor(sample_data["type"])

We examine the count matrix and sample data to see if they are consistent in

terms of sample order:

.. repl::

   cts.head(2)

   sample_data

Note that these are not in the same order with respect to samples!

It is absolutely critical that the rows of the count matrix and the rows of

the sample data (information about samples) are in the same order.  DESeq2 will

not make guesses as to which row of the count matrix belongs to which row of

the sample data, these must be provided to DESeq2 already in consistent order.

As they are not in the correct order as given, we need to re-arrange one or the

other so that they are consistent in terms of sample order (if we do not, later

functions would produce an error). We additionally need to chop off the `"fb"`

of the row names of :code:`sample_data`, so the naming is consistent:

.. repl::

   sample_data.index = [i[:-2] for i in sample_data.index]

   all(sample_data.index.isin(cts.columns))

   all(sample_data.index == cts.columns)

   sample_data = sample_data.reindex(cts.columns)

   all(sample_data.index == cts.columns)

If you have used the :code:`featureCounts` function [Liao2013]_ in the `Rsubread

<http://bioconductor.org/packages/Rsubread>`_ package, the matrix of read counts

can be directly provided from the `"counts"` element in the list output.  The

count matrix and sample data can typically be read into Python from flat files

using import functions from :code:`pandas` or :code:`numpy`.

With the count matrix, :code:`cts`, and the sample information,

:code:`sample_data`, we can construct a :class:`~DESeqDataSet.DESeqDataSet`:

.. repl::

   dds = DESeqDataSet(countData = cts.T,

                      clinicalData = sample_data,

                      design = "~ condition")

   dds

If you have additional feature data, it can be added to the

:class:`~DESeqDataSet.DESeqDataSet` by adding to the metadata columns of a newly

constructed object. (Here we add redundant data just for demonstration, as the

gene names are already the rownames of the :code:`dds`.):

.. repl::

   featureData = dds.var.index

   dds.var["featureData"] = featureData

   dds.var.head()

.. _ad:

:class:`AnnData` input

----------------------

If one has already created or obtained an :class:`AnnData`, it can be easily

input into DESeq2 as follows. First we load the module containing the `airway`

dataset:

.. repl::

   from inmoose.data.airway import airway

   ad = airway()

The constructor function below shows the generation of a

:class:`~DESeqDataSet.DESeqDataSet` from an :class:`AnnData` :code:`ad`:

.. repl::

   ddsAD = DESeqDataSet(ad, design = "~ cell + dex")

   ddsAD

Pre-filtering

-------------

While it is not necessary to pre-filter low count genes before running the

DESeq2 functions, there are two reasons which make pre-filtering useful: by

removing rows in which there are very few reads, we reduce the memory size of

the :code:`dds` data object, and we increase the speed of the transformation and

testing functions within DESeq2. It can also improve visualizations, as features

with no information for differential expression are not plotted.

Here we perform a minimal pre-filtering to keep only rows that have at least 10

reads total. Note that more strict filtering to increase power is

*automatically* applied via :ref:`independent filtering<indfilt>` on the mean of

normalized counts within the :meth:`.DESeqDataSet.results` function:

.. repl::

   keep = dds.counts().sum(axis=1) >= 10

   dds = dds[keep,:]

Alternatively, a popular filter is to ensure at least :code:`X` samples with a

count of 10 or more, where :code:`X` can be chosen as the sample size of the

smallest group of samples:

>>> keep = (dds.counts() >= 10).sum(axis=1) >= X

>>> dds = dds[keep,:]

.. _factorLevels:

Note on factor levels

---------------------

By default, Python will choose a *reference level* for factors based on

alphabetical order, it chooses the first value as the reference. Then, if you 

never tell the DESeq2 functions which level you want to compare against 

(*e.g.* which level represents the control group), the comparisons will 

be based on the alphabetical order of the levels. There are two

solutions: you can either explicitly tell :meth:`.DESeqDataSet.results` which

comparison to make using the :code:`contrast` argument (this will be shown

later), or you can explicitly set the factors levels by specifying the desired 

reference value first. In order to see the change of reference levels reflected 

in the results names, you need to either run :func:`DESeq` or 

:func:`nbinomWaldTest` / :func:`nbinomLRT` after the re-leveling operation.  

Setting the factor levels can be done with the:code:`reorder_categories` function:

.. repl::

   dds.obs["condition"] = dds.obs["condition"].cat.reorder_categories(["untreated", "treated"])

If you need to subset the columns of a :class:`~DESeqDataSet.DESeqDataSet`,

*i.e.* when removing certain samples from the analysis, it is possible that all

the samples for one or more levels of a variable in the design formula would be

removed. In this case, the :code:`remove_unused_categories` function can be used

to remove those levels which do not have samples in the current

:class:`~DESeqDataSet.DESeqDataSet`:

.. repl::

   dds.obs["condition"] = dds.obs["condition"].cat.remove_unused_categories()

Collapsing technical replicates

-------------------------------

DESeq2 provides a function :func:`collapseReplicates` which can assist in

combining the counts from technical replicates into single columns of the count

matrix. The term *technical replicate* implies multiple sequencing runs of the

same library.  You should not collapse biological replicates using this

function.  See the manual page for an example of the use of

:func:`collapseReplicates`.

About the pasilla dataset

-------------------------

We continue with the :doc:`/pasilla` data constructed from the count matrix

method above. This data set is from an experiment on *Drosophila melanogaster*

cell cultures and investigated the effect of RNAi knock-down of the splicing

factor *pasilla* [Brooks2011]_.  The detailed transcript of the production of

the `pasilla <http://bioconductor.org/packages/pasilla>`_ data is provided in

the vignette of the data package `pasilla

<http://bioconductor.org/packages/pasilla>`_.

.. _de:

Differential expression analysis

================================

The standard differential expression analysis steps are wrapped into a single

function :func:`DESeq`. The estimation steps performed by this function are

described :ref:`below<theory>`, in the manual page for :func:`DESeq` and in the

Methods section of the DESeq2 publication [Love2014]_.

Results tables are generated using the function :meth:`.DESeqDataSet.results`,

which extracts a results table with log2 fold changes, *p*-values and adjusted

*p*-values. With no additional arguments to :meth:`.DESeqDataSet.results`, the

log2 fold change and Wald test *p*-value will be for the **last variable** in

the design formula, and if this is a factor, the comparison will be the **last

level** of this variable over the **reference level** (see previous :ref:`note

on factor levels<factorlevels>`).  However, the order of the variables of the

design does not matter so long as the user specifies the comparison to build a

results table for, using the :code:`name` or :code:`contrast` arguments of

:meth:`.DESeqDataSet.results`.

Details about the comparison are printed to the console, directly above the

results table. The text, `condition treated vs untreated`, tells you that the

estimates are of the logarithmic fold change log2(treated/untreated):

.. repl::

   dds.design = "~ condition"

   dds = DESeq(dds)

   res = dds.results()

   res.head()

Note that we could have specified the coefficient or contrast we want to build a

results table for, using either of the following equivalent commands:

>>> res = dds.results(name="condition_treated_vs_untreated")

>>> res = dds.results(contrast=["condition","treated","untreated"])

One exception to the equivalence of these two commands, is that, using

:code:`contrast` will additionally set to 0 the estimated LFC in a comparison of

two groups, where all of the counts in the two groups are equal to 0 (while

other groups have positive counts). As this may be a desired feature to have the

LFC in these cases set to 0, one can use :code:`contrast` to build these results

tables.  More information about extracting specific coefficients from a fitted

:class:`~DESeqDataSet.DESeqDataSet` object can be found in the help page

:meth:`.DESeqDataSet.results`.  The use of the :code:`contrast` argument is also

further discussed :ref:`below<contrasts>`.

.. _lfcShrink:

Log fold change shrinkage for visualization and ranking

-------------------------------------------------------

Shrinkage of effect size (LFC estimates) is useful for visualization and ranking

of genes. To shrink the LFC, we pass the :code:`dds` object to the function

:func:`lfcShrink`. Below we specify to use the :code:`apeglm` method for effect

size shrinkage [Zhu2018]_, which improves on the previous estimator.

We provide the :code:`dds` object and the name or number of the coefficient we

want to shrink, where the number refers to the order of the coefficient as it

appears in :code:`dds.resultsNames()`:

>>> dds.resultsNames()

>>> resLFC = dds.lfcShrink(coef="condition_treated_vs_untreated", type="apeglm")

>>> resLFC

Shrinkage estimation is discussed more in a :ref:`later section<shrink>`.

*p*-values and adjusted *p*-values

----------------------------------

We can order our results table by the smallest *p*-value:

.. repl::

   resOrdered = res.sort_values(by="pvalue")

We can summarize some basic tallies using the :meth:`.DESeqResults.summary`

function:

.. repl::

   print(res.summary())

How many adjusted *p*-values were less than 0.1:

.. repl::

   (res.padj < 0.1).sum()

The :meth:`.DESeqDataSet.results` function contains a number of arguments to

customize the results table which is generated. You can read about these

arguments by looking up the documentation of :meth:`.DESeqDataSet.results`.

Note that the :meth:`.DESeqDataSet.results` function automatically performs

independent filtering based on the mean of normalized counts for each gene,

optimizing the number of genes which will have an adjusted *p*-value below a

given FDR cutoff, :code:`alpha`.  Independent filtering is further discussed

:ref:`below<indfilt>`.  By default the argument :code:`alpha` is set to 0.1.  If

the adjusted *p*-value cutoff will be a value other than 0.1, :code:`alpha`

should be set to that value:

.. repl::

   res05 = dds.results(alpha=0.05)

   print(res05.summary())

   (res05.padj < 0.05).sum()

.. _IHW:

..

  Independent hypothesis weighting

  --------------------------------

  A generalization of the idea of *p*-value filtering is to *weight* hypotheses to

  optimize power. A Bioconductor package, `IHW

  <http://bioconductor.org/packages/IHW>`_, is available that implements the

  method of *Independent Hypothesis Weighting* [Ignatiadis2016]_.  Here we show

  the use of *IHW* for *p*-value adjustment of DESeq2 results.  For more details,

  please see the vignette of the `IHW <http://bioconductor.org/packages/IHW>`_

  package. The *IHW* result object is stored in the metadata::

    # (unevaluated code chunk)

    library("IHW")

    resIHW <- results(dds, filterFun=ihw)

    summary(resIHW)

    sum(resIHW$padj < 0.1, na.rm=TRUE)

    metadata(resIHW)$ihwResult

  .. note::

     If the results of independent hypothesis weighting are used in published

     research, please cite:

      Ignatiadis, N., Klaus, B., Zaugg, J.B., Huber, W. (2016)

      Data-driven hypothesis weighting increases detection power in genome-scale multiple testing.

      *Nature Methods*, **13**:7.

      :doi:`http://dx.doi.org/10.1038/nmeth.3885`

  For advanced users, note that all the values calculated by the DESeq2 package

  are stored in the :class:`~DESeqDataSet.DESeqDataSet` object or the

  :class:`DESeqResults` object, and access to these values is discussed

  :ref:`below<access>`.

Exploring and exporting results

===============================

MA-plot

-------

In DESeq2, the function :meth:`.DESeqResults.plotMA` shows the log2 fold changes

attributable to a given variable over the mean of normalized counts for all the

samples in the :class:`~DESeqDataSet.DESeqDataSet`.  Points will be colored red

if the adjusted *p*-value is less than 0.1.  Points which fall out of the window

are plotted as open triangles pointing either up or down:

.. repl::

   res.plotMA(ylim=[-2,2])

   plt.show()

It is more useful visualize the MA-plot for the shrunken log2 fold changes,

which remove the noise associated with log2 fold changes from low count genes

without requiring arbitrary filtering thresholds:

.. repl::

   resLFC.plotMA(ylim=[-2,2])

   plt.show()

..

  After calling :meth:`.DESeqResults.plotMA`, one can use the function

  :func:`identify` to interactively detect the row number of individual genes by

  clicking on the plot.  One can then recover the gene identifiers by saving the

  resulting indices::

    idx = identify(res.baseMean, res.log2FoldChange)

    res.index[idx]

.. _shrink:

Alternative shrinkage estimators

--------------------------------

The moderated log fold changes proposed by [Love2014]_ use a normal prior

distribution, centered on zero and with a scale that is fit to the data. The

shrunken log fold changes are useful for ranking and visualization, without the

need for arbitrary filters on low count genes. The normal prior can sometimes

produce too strong of shrinkage for certain datasets. In DESeq2 version 1.18, we

include two additional adaptive shrinkage estimators, available via the

:code:`type` argument of :func:`lfcShrink`.

The options for :code:`type` are:

* :code:`apeglm` is the adaptive t prior shrinkage estimator from the `apeglm

  <http://bioconductor.org/packages/apeglm>`_ package [Zhu2018]_. As of version

  1.28.0, it is the default estimator.

* :code:`ashr` is the adaptive shrinkage estimator from the `ashr

  <https://github.com/stephens999/ashr>`_ package [Stephens2016]_.  Here DESeq2

  uses the ashr option to fit a mixture of Normal distributions to form the

  prior, with :code:`method="shrinkage"`.

* :code:`normal`: is the the original DESeq2 shrinkage estimator, an adaptive

  Normal distribution as prior.

If the shrinkage estimator :code:`apeglm` is used in published research, please

cite [Zhu2018]_.

If the shrinkage estimator :code:`ashr` is used in published research, please

cite [Stephens2016]_.

In the LFC shrinkage code above, we specified

:code:`coef="condition_treated_vs_untreated"`. We can also just specify the

coefficient by the order that it appears in :code:`dds.resultsNames()`, in this

case :code:`coef=2`. For more details explaining how the shrinkage estimators

differ, and what kinds of designs, contrasts and output is provided by each, see

the :ref:`extended section on shrinkage estimators<moreshrink>`:

>>> dds.resultsNames()

>>> # because we are interested in treated vs untreated, we set 'coef=2'

>>> resNorm = dds.lfcShrink(coef=2, type="normal")

>>> resAsh = dds.lfcShrink(coef=2, type="ashr")

..

  ```{r fig.width=8, fig.height=3}

  par(mfrow=c(1,3), mar=c(4,4,2,1))

  xlim <- c(1,1e5); ylim <- c(-3,3)

  plotMA(resLFC, xlim=xlim, ylim=ylim, main="apeglm")

  plotMA(resNorm, xlim=xlim, ylim=ylim, main="normal")

  plotMA(resAsh, xlim=xlim, ylim=ylim, main="ashr")

  ```

..

  .. note::

     We have sped up the :code:`apeglm` method so it takes roughly about the same

     amount of time as :code:`normal`, e.g. ~5 seconds for the :code:`pasilla`

     dataset of ~10,000 genes and 7 samples.  If fast shrinkage estimation of LFC

     is needed, **but the posterior standard deviation is not needed**, setting

     :code:`apeMethod="nbinomC"` will produce a ~10x speedup, but the

     :code:`lfcSE` column will be returned with :code:`NA`.  A variant of this

     fast method, :code:`apeMethod="nbinomC*"` includes random starts.

.. note::

   If there is unwanted variation present in the data (*e.g.* batch effects) it

   is always recommended to correct for this, which can be accommodated in

   DESeq2 by including in the design any known batch variables or by using

   functions/packages such as :func:`.pycombat_seq`, :code:`svaseq` in `sva

   <http://bioconductor.org/packages/sva>`_ [Leek2014]_ or the :code:`RUV`

   functions in `RUVSeq <http://bioconductor.org/packages/RUVSeq>`_ [Risso2014]_

   to estimate variables that capture the unwanted variation.  In addition, the

   ashr developers have a `specific method <https://github.com/dcgerard/vicar>`_

   for accounting for unwanted variation in combination with ashr [Gerard2020]_.

..

  Plot counts

  -----------

  It can also be useful to examine the counts of reads for a single gene across

  the groups. A simple function for making this plot is :func:`plotCounts`, which

  normalizes counts by the estimated size factors (or normalization factors if

  these were used) and adds a pseudocount of 1/2 to allow for log scale plotting.

  The counts are grouped by the variables in :code:`intgroup`, where more than one

  variable can be specified. Here we specify the gene which had the smallest

  *p*-value from the results table created above. You can select the gene to plot

  by rowname or by numeric index::

    plotCounts(dds, gene=which.min(res$padj), intgroup="condition")

  For customized plotting, an argument :code:`returnData` specifies that the

  function should only return a data frame for plotting with :code:`ggplot`::

    d <- plotCounts(dds, gene=which.min(res$padj), intgroup="condition",

                    returnData=TRUE)

    library("ggplot2")

    ggplot(d, aes(x=condition, y=count)) +

      geom_point(position=position_jitter(w=0.1,h=0)) +

      scale_y_log10(breaks=c(25,100,400))

More information on results columns

-----------------------------------

Information about which variables and tests were used can be found by inspecting

the attribute :code:`description` on the :class:`~results.DESeqResults` object:

.. repl::

   res.description

For a particular gene, a log2 fold change of -1 for :code:`condition treated vs

untreated` means that the treatment induces a multiplicative change in observed

gene expression level of :math:`2^{-1} = 0.5` compared to the untreated

condition. If the variable of interest is continuous-valued, then the reported

log2 fold change is per unit of change of that variable.

.. _pvaluesNA:

.. admonition:: Note on *p*-values set to :code:`NA`

   Some values in the results table can be set to :code:`NA` for one of the

   following reasons:

   * If within a row, all samples have zero counts, the :code:`baseMean` column

     will be zero, and the log2 fold change estimates, *p*-value and adjusted

     *p*-value will all be set to :code:`NA`.

   * If a row contains a sample with an extreme count outlier then the *p*-value

     and adjusted *p*-value will be set to :code:`NA`.  These outlier counts are

     detected by Cook's distance.  Customization of this outlier filtering and

     description of functionality for replacement of outlier counts and

     refitting is described :ref:`below<outlier>`.

   * If a row is filtered by automatic independent filtering, for having a low

     mean normalized count, then only the adjusted *p*-value will be set to

     :code:`NA`.  Description and customization of independent filtering is

     described :ref:`below<indfilt>`.

..

  Rich visualization and reporting of results

  -------------------------------------------

  **ReportingTools** An HTML report of the results with plots and

  sortable/filterable columns can be generated using the `ReportingTools

  <http://bioconductor.org/packages/ReportingTools>`_ package on a

  :class:`~DESeqDataSet.DESeqDataSet` that has been processed by the :func:`DESeq`

  function.  For a code example, see the *RNA-seq differential expression*

  vignette at the `ReportingTools

  <http://bioconductor.org/packages/ReportingTools>`_ page, or the manual page for

  the :meth:`publish` method for the :class:`~DESeqDataSet.DESeqDataSet` class.

  **regionReport** An HTML and PDF summary of the results with plots can also be

  generated using the `regionReport

  <http://bioconductor.org/packages/regionReport>`_ package. The

  :func:`DESeq2Report` function should be run on a

  :class:`~DESeqDataSet.DESeqDataSet` that has been processed by the :func:`DESeq`

  function.  For more details see the manual page for :func:`DESeq2Report` and an

  example vignette in the `regionReport

  <http://bioconductor.org/packages/regionReport>`_ package.

  **Glimma** Interactive visualization of DESeq2 output, including MA-plots (also

  called MD-plot) can be generated using the `Glimma

  <http://bioconductor.org/packages/Glimma>`_ package. See the manual page for

  *glMDPlot.DESeqResults*.

  **pcaExplorer** Interactive visualization of DESeq2 output, including PCA plots,

  boxplots of counts and other useful summaries can be generated using the

  `pcaExplorer <http://bioconductor.org/packages/pcaExplorer>`_ package. See the

  *Launching the application* section of the package vignette.

  **iSEE** Provides functions for creating an interactive Shiny-based graphical

  user interface for exploring data stored in SummarizedExperiment objects,

  including row- and column-level metadata. Particular attention is given to

  single-cell data in a SingleCellExperiment object with visualization of

  dimensionality reduction results.  `iSEE

  <https://bioconductor.org/packages/iSEE>`_ is on Bioconductor.  An example

  wrapper function for converting a :class:`~DESeqDataSet.DESeqDataSet` to a

  SingleCellExperiment object for use with *iSEE* can be found at the following

  gist, written by Federico Marini:

  * <https://gist.github.com/federicomarini/4a543eebc7e7091d9169111f76d59de1>

  **DEvis** DEvis is a powerful, integrated solution for the analysis of

  differential expression data. This package includes an array of tools for

  manipulating and aggregating data, as well as a wide range of customizable

  visualizations, and project management functionality that simplify RNA-Seq

  analysis and provide a variety of ways of exploring and analyzing data.  *DEvis*

  can be found on `CRAN <https://cran.r-project.org/package=DEVis>` and `GitHub

  <https://github.com/price0416/DEvis>`.

Exporting results to CSV files

------------------------------

A plain-text file of the results can be exported using the method

:meth:`.DESeqResults.to_csv`. We suggest using a descriptive file name

indicating the variable and level which were tested:

.. repl::

   resOrdered.to_csv("condition_treated_results.csv")

Exporting only the results which pass an adjusted *p*-value threshold can be

accomplished by subsetting the results:

.. repl::

   resSig = resOrdered[resOrdered.padj < 0.1]

   resSig.head()

Multi-factor designs

====================

Experiments with more than one factor influencing the counts can be analyzed

using design formula that include the additional variables.  In fact, DESeq2 can

analyze any possible experimental design that can be expressed with fixed

effects terms (multiple factors, designs with interactions, designs with

continuous variables, splines, and so on are all possible).

By adding variables to the design, one can control for additional variation in

the counts. For example, if the condition samples are balanced across

experimental batches, by including the :code:`batch` factor to the design, one

can increase the sensitivity for finding differences due to :code:`condition`.

There are multiple ways to analyze experiments when the additional variables are

of interest and not just controlling factors (see :ref:`section on

interactions<interactions>`).

**Experiments with many samples**: in experiments with many samples (e.g. 50,

100, etc.) it is highly likely that there will be technical variation affecting

the observed counts. Failing to model this additional technical variation will

lead to spurious results. Many methods exist that can be used to model technical

variation, which can be easily included in the DESeq2 design to control for

technical variation which estimating effects of interest. See the `RNA-seq

workflow <http://www.bioconductor.org/help/workflows/rnaseqGene>`_ for examples

of using RUV or SVA in combination with DESeq2.  For more details on why it is

important to control for technical variation in large sample experiments, see

the following `thread

<https://twitter.com/mikelove/status/1513468597288452097>`_, also archived `here

<https://htmlpreview.github.io/?https://github.com/frederikziebell/science_tweetorials/blob/master/DESeq2_many_samples.html>`_

by Frederik Ziebell.

The data in the :doc:`/pasilla` module have a condition of interest (the column

:code:`condition`), as well as information on the type of sequencing which was

performed (the column :code:`type`), as we can see below:

.. repl::

   dds.obs

We create a copy of the :class:`~DESeqDataSet.DESeqDataSet`, so that we can

rerun the analysis using a multi-factor design:

.. repl::

   ddsMF = dds.copy()

We change the categories of :code:`type` so it only contains letters.  Be

careful when changing level names to use the same order as the current

categories:

.. repl::

   import re

   dds.obs["type"].cat.categories

   dds.obs["type"].cat.rename_categories([re.sub("-.*", "", c) for c in dds.obs["type"].cat.categories])

   dds.obs["type"].dtype.categories

We can account for the different types of sequencing, and get a clearer picture

of the differences attributable to the treatment.  As :code:`condition` is the

variable of interest, we put it at the end of the formula. Thus the

:meth:`.DESeqDataSet.results` function will by default pull the

:code:`condition` results unless :code:`contrast` or :code:`name` arguments are

specified.

Then we can re-run :func:`DESeq`:

.. repl::

   ddsMF.design = "~ type + condition"

   ddsMF = DESeq(ddsMF)

Again, we access the results using the :meth:`.DESeqDataSet.results` function:

.. repl::

   resMF = ddsMF.results()

   resMF.head()

It is also possible to retrieve the log2 fold changes, *p*-values and adjusted

*p*-values of variables other than the last one in the design.  While in this

case, :code:`type` is not biologically interesting as it indicates differences

across sequencing protocols, for other hypothetical designs, such as

:code:`~genotype + condition + genotype:condition`, we may actually be

interested in the difference in baseline expression across genotype, which is

not the last variable in the design.

In any case, the :code:`contrast` argument of the function

:meth:`.DESeqDataSet.results` takes a string list of length three: the name of

the variable, the name of the factor level for the numerator of the log2 ratio,

and the name of the factor level for the denominator.  The :code:`contrast`

argument can also take other forms, as described in the help page for

:meth:`.DESeqDataSet.results` and :ref:`below<contrasts>`:

.. repl::

   resMFType = ddsMF.results(contrast=("type", "single", "paired"))

   resMFType.head()

If the variable is continuous or an interaction term (see :ref:`section on

interactions<interactions>`) then the results can be extracted using the

:code:`name` argument to :meth:`.DESeqDataSet.results`, where the name is one of

elements returned by :code:`dds.resultsNames()`.

.. _transform:

..

  Data transformations and visualization

  ======================================

  Count data transformations

  --------------------------

  In order to test for differential expression, we operate on raw counts and use

  discrete distributions as described in the previous section on differential

  expression.  However for other downstream analyses -- *e.g.* for visualization

  or clustering -- it might be useful to work with transformed versions of the

  count data.

  Maybe the most obvious choice of transformation is the logarithm.  Since count

  values for a gene can be zero in some conditions (and non-zero in others), some

  advocate the use of *pseudocounts*, i.e. transformations of the form :math:`y =

  \log(n + n_0)`, where :math:`n` represents the count values and :math:`n_0` is a

  positive constant.

  In this section, we discuss two alternative approaches that offer more

  theoretical justification and a rational way of choosing parameters equivalent

  to :math:`n_0` above.  One makes use of the concept of variance stabilizing

  transformations (VST) [Tibshirani1988]_ [sagmb2003]_ [Anders2010]_, and the

  other is the *regularized logarithm* or *rlog*, which incorporates a prior on

  the sample differences [Love2014]_.  Both transformations produce transformed

  data on the log2 scale which has been normalized with respect to library size or

  other normalization factors.

  The point of these two transformations, the VST and the rlog, is to remove the

  dependence of the variance on the mean, particularly the high variance of the

  logarithm of count data when the mean is low. Both VST and rlog use the

  experiment-wide trend of variance over mean, in order to transform the data to

  remove the experiment-wide trend. Note that we do not require or desire that all

  the genes have *exactly* the same variance after transformation. Indeed, in a

  figure below, you will see that after the transformations the genes with the

  same mean do not have exactly the same standard deviations, but that the

  experiment-wide trend has flattened. It is those genes with row variance above

  the trend which will allow us to cluster samples into interesting groups.

  .. admonition:: Note on running time:

     If you have many samples (*e.g.* 100s), the :func:`rlog` function might take

     too long, and so the :func:`vst` function will be a faster choice.  The rlog

     and VST have similar properties, but the rlog requires fitting a shrinkage

     term for each sample and each gene which takes time. See the DESeq2 paper for

     more discussion on the differences [Love2014]_.

  Blind dispersion estimation

  ^^^^^^^^^^^^^^^^^^^^^^^^^^^

  The two functions, :func:`vst` and :func:`rlog`: have an argument :code:`blind`,

  for whether the transformation should be blind to the sample information

  specified by the design formula. When :code:`blind` equals :code:`True` (the

  default), the functions will re-estimate the dispersions using only an

  intercept.  This setting should be used in order to compare samples in a manner

  wholly unbiased by the information about experimental groups, for example to

  perform sample QA (quality assurance) as demonstrated below.

  However, blind dispersion estimation is not the appropriate choice if one

  expects that many or the majority of genes will have large differences in counts

  which are explainable by the experimental design, and one wishes to transform

  the data for downstream analysis. In this case, using blind dispersion

  estimation will lead to large estimates of dispersion, as it attributes

  differences due to experimental design as unwanted *noise*, and will result in

  overly shrinking the transformed values towards each other.  By setting

  :code:`blind` to :code:`False`, the dispersions already estimated will be used

  to perform transformations, or if not present, they will be estimated using the

  current design formula. Note that only the fitted dispersion estimates from

  mean-dispersion trend line are used in the transformation (the global dependence

  of dispersion on mean for the entire experiment).  So setting :code:`blind` to

  :code:`False` is still for the most part not using the information about which

  samples were in which experimental group in applying the transformation.

  Extracting transformed values

  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

  These transformation functions return an object of class :class:`DESeqTransform`

  which is a subclass of :class:`AnnData`.  For ~20 samples, running on a newly

  created :class:`~DESeqDataSet.DESeqDataSet`, :func:`rlog` may take 30 seconds,

  while :func:`vst` takes less than 1 second.  The running times are shorter when

  using `blind=False` and if the function :func:`DESeq` has already been run,

  because then it is not necessary to re-estimate the dispersion values.  The

  matrix of normalized values is stored in the :attr:`X` attribute:

  >>> vsd = vst(dds, blind=FALSE)

  >>> rld = rlog(dds, blind=FALSE)

  >>> vsd.X.head(3)

  Variance stabilizing transformation

  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

  Above, we used a parametric fit for the dispersion. In this case, the

  closed-form expression for the variance stabilizing transformation is used by

  the :func:`vst` function. If a local fit is used (option

  :code:`fitType="locfit"` to :meth:`.DESeqDataSet.estimateDispersions`) a

  numerical integration is used instead. The transformed data should be

  approximated variance stabilized and also includes correction for size factors

  or normalization factors. The transformed data is on the log2 scale for large

  counts.

  Regularized log transformation

  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

  The function :func:`rlog`, stands for *regularized log*, transforming the

  original count data to the log2 scale by fitting a model with a term for each

  sample and a prior distribution on the coefficients which is estimated from the

  data. This is the same kind of shrinkage (sometimes referred to as

  regularization, or moderation) of log fold changes used by :func:`DESeq` and

  :func:`nbinomWaldTest`. The resulting data contains elements defined as:

  .. math::

     \log_2(q_{ij}) = \beta_{i0} + \beta_{ij}

  where :math:`q_{ij}` is a parameter proportional to the expected true

  concentration of fragments for gene :math:`i` and sample :math:`j` (see formula

  :ref:`below<theory>`), :math:`\beta_{i0}` is an intercept which does not undergo

  shrinkage, and :math:`\beta_{ij}` is the sample-specific effect which is shrunk

  toward zero based on the dispersion-mean trend over the entire dataset. The

  trend typically captures high dispersions for low counts, and therefore these

  genes exhibit higher shrinkage from the :func:`rlog`.

  Note that, as :math:`q_{ij}` represents the part of the mean value

  :math:`\mu_{ij}` after the size factor :math:`s_j` has been divided out, it is

  clear that the rlog transformation inherently accounts for differences in

  sequencing depth. Without priors, this design matrix would lead to a non-unique

  solution, however the addition of a prior on non-intercept betas allows for a

  unique solution to be found.

  Effects of transformations on the variance

  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

  The figure below plots the standard deviation of the transformed data, across

  samples, against the mean, using the shifted logarithm transformation, the

  regularized log transformation and the variance stabilizing transformation.  The

  shifted logarithm has elevated standard deviation in the lower count range, and

  the regularized log to a lesser extent, while for the variance stabilized data

  the standard deviation is roughly constant along the whole dynamic range.

  Note that the vertical axis in such plots is the square root of the variance

  over all samples, so including the variance due to the experimental conditions.

  While a flat curve of the square root of variance over the mean may seem like

  the goal of such transformations, this may be unreasonable in the case of

  datasets with many true differences due to the experimental conditions.

  ..

    ```{r meansd}

    # this gives log2(n + 1)

    ntd <- normTransform(dds)

    library("vsn")

    meanSdPlot(assay(ntd))

    meanSdPlot(assay(vsd))

    meanSdPlot(assay(rld))

    ```

  Data quality assessment by sample clustering and visualization

  --------------------------------------------------------------

  Data quality assessment and quality control (*i.e.* the removal of

  insufficiently good data) are essential steps of any data analysis. These steps

  should typically be performed very early in the analysis of a new data set,

  preceding or in parallel to the differential expression testing.

  We define the term *quality* as *fitness for purpose*.  Our purpose is the

  detection of differentially expressed genes, and we are looking in particular

  for samples whose experimental treatment suffered from an anormality that

  renders the data points obtained from these particular samples detrimental to

  our purpose.

  Heatmap of the count matrix

  ^^^^^^^^^^^^^^^^^^^^^^^^^^^

  To explore a count matrix, it is often instructive to look at it as a heatmap.

  Below we show how to produce such a heatmap for various transformations of the

  data.

  TODO use clustermap instead of pheatmap

  .. repl::

     from seaborn import clustermap

     select = np.sort(dds.counts(normalized=True).mean(axis=0))[::-1][:20]

     df = dds.obs[["condition", "type"]]

  ..

    ```{r heatmap}

    library("pheatmap")

    select <- order(rowMeans(counts(dds,normalized=TRUE)),

                    decreasing=TRUE)[1:20]

    df <- as.data.frame(colData(dds)[,c("condition","type")])

    pheatmap(assay(ntd)[select,], cluster_rows=FALSE, show_rownames=FALSE,

             cluster_cols=FALSE, annotation_col=df)

    pheatmap(assay(vsd)[select,], cluster_rows=FALSE, show_rownames=FALSE,

             cluster_cols=FALSE, annotation_col=df)

    pheatmap(assay(rld)[select,], cluster_rows=FALSE, show_rownames=FALSE,

             cluster_cols=FALSE, annotation_col=df)

    ```

  Heatmap of the sample-to-sample distances

  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

  Another use of the transformed data is sample clustering. Here, we apply the

  :func:`dist` function to the transpose of the transformed count matrix to get

  sample-to-sample distances::

    sampleDists = dist(vsd.layers.T)

  A heatmap of this distance matrix gives us an overview over similarities and

  dissimilarities between samples.  We have to provide a hierarchical clustering

  :code:`hc` to the heatmap function based on the sample distances, or else the

  heatmap function would calculate a clustering based on the distances between the

  rows/columns of the distance matrix.

  TODO

  ..

    ```{r figHeatmapSamples, fig.height=4, fig.width=6}

    library("RColorBrewer")

    sampleDistMatrix <- as.matrix(sampleDists)

    rownames(sampleDistMatrix) <- paste(vsd$condition, vsd$type, sep="-")

    colnames(sampleDistMatrix) <- NULL

    colors <- colorRampPalette( rev(brewer.pal(9, "Blues")) )(255)

    pheatmap(sampleDistMatrix,

             clustering_distance_rows=sampleDists,

             clustering_distance_cols=sampleDists,

             col=colors)

    ```

  Principal component plot of the samples

  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

  Related to the distance matrix is the PCA plot, which shows the samples in the

  2D plane spanned by their first two principal components. This type of plot is

  useful for visualizing the overall effect of experimental covariates and batch

  effects.

  TODO

  ..

    ```{r figPCA}

    plotPCA(vsd, intgroup=c("condition", "type"))

    ```

  It is also possible to customize the PCA plot using the

  *ggplot* function.

  TODO

  ..

    ```{r figPCA2}

    pcaData <- plotPCA(vsd, intgroup=c("condition", "type"), returnData=TRUE)

    percentVar <- round(100 * attr(pcaData, "percentVar"))

    ggplot(pcaData, aes(PC1, PC2, color=condition, shape=type)) +

      geom_point(size=3) +

      xlab(paste0("PC1: ",percentVar[1],"% variance")) +

      ylab(paste0("PC2: ",percentVar[2],"% variance")) +

      coord_fixed()

    ```

Variations to the standard workflow

===================================

Wald test individual steps

--------------------------

The function :func:`DESeq` runs the following functions in order:

>>> dds = dds.estimateSizeFactors()

>>> dds = dds.estimateDispersions(dds)

>>> dds = nbinomWaldTest(dds)

Control features for estimating size factors

--------------------------------------------

In some experiments, it may not be appropriate to assume that a minority of

features (genes) are affected greatly by the condition, such that the standard

median-ratio method for estimating the size factors will not provide correct

inference (the log fold changes for features that were truly un-changing will

not centered on zero). This is a difficult inference problem for any method, but

there is an important feature that can be used: the :code:`controlGenes`

argument of :meth:`.DESeqDataSet.estimateSizeFactors`. If there is any prior

information about features (genes) that should not be changing with respect to

the condition, providing this set of features to :code:`controlGenes` will

ensure that the log fold changes for these features will be centered around 0.

The paradigm then becomes:

>>> dds = dds.estimateSizeFactors(controlGenes=ctrlGenes)

>>> dds = DESeq(dds)

.. _contrasts:

Contrasts

---------

A contrast is a linear combination of estimated log2 fold changes, which can be

used to test if differences between groups are equal to zero.  The simplest use

case for contrasts is an experimental design containing a factor with three

levels, say A, B and C.  Contrasts enable the user to generate results for all 3

possible differences: log2 fold change of B vs A, of C vs A, and of C vs B.  The

:code:`contrast` argument of :meth:`.DESeqDataSet.results` function is used to

extract test results of log2 fold changes of interest, for example:

>>> dds.results(contrast=["condition","C","B"])

Log2 fold changes can also be added and subtracted by providing a list to the

:code:`contrast` argument which has two elements: the names of the log2 fold

changes to add, and the names of the log2 fold changes to subtract. The names

used in the list should come from :code:`dds.resultsNames()`.  Alternatively, a

numeric vector of the length of :code:`dds.resultsNames()` can be provided, for

manually specifying the linear combination of terms. A `tutorial

<https://github.com/tavareshugo/tutorial_DESeq2_contrasts>`_ describing the use

of numeric contrasts for DESeq2 explains a general approach to comparing across

groups of samples.  Demonstrations of the use of contrasts for various designs

can be found in the examples section of the help page

:meth:`.DESeqDataSet.results`.  The mathematical formula that is used to

generate the contrasts can be found :ref:`below<theory>`.

.. _interactions:

Interactions

------------

Interaction terms can be added to the design formula, in order to test, for

example, if the log2 fold change attributable to a given condition is

*different* based on another factor, for example if the condition effect differs

across genotype.

Preliminary remarks

^^^^^^^^^^^^^^^^^^^

Many users begin to add interaction terms to the design formula, when in fact a

much simpler approach would give all the results tables that are desired.  We

will explain this approach first, because it is much simpler to perform.  If the

comparisons of interest are, for example, the effect of a condition for

different sets of samples, a simpler approach than adding interaction terms

explicitly to the design formula is to perform the following steps:

  * combine the factors of interest into a single factor with all

    combinations of the original factors

  * change the design to include just this factor, *e.g.* :code:`"~ group"`

Using this design is similar to adding an interaction term, in that it models

multiple condition effects which can be easily extracted with

:meth:`.DESeqDataSet.results`.  Suppose we have two factors :code:`genotype`

(with values I, II, and III) and :code:`condition` (with values A and B), and we

want to extract the condition effect specifically for each genotype. We could

use the following approach to obtain, *e.g.* the condition effect for genotype

I:

>>> dds.obs["group"] = Factor([f"{g}{c}" for (g,c) in zip(dds.obs["genotype"], dds.obs["condition"])])

>>> dds.design = "~ group"

>>> dds = DESeq(dds)

>>> dds.resultsNames()

>>> dds.results(contrast=["group", "IB", "IA"])

Adding interactions to the design

^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

The following two plots diagram genotype-specific condition effects, which could

be modeled with interaction terms by using a design of :code:`~genotype +