robustness: Robustness of ISA biclusters and PPA co-modules

Description

Robustness of ISA biclusters and PPA co-modules. The more robust biclusters/co-modules are more significant in the sense that it is less likely to see them in random data.

Usage

"robustness"(normed.data, ...)
"isa.filter.robust"(data, ...)
"ppa.filter.robust"(data, ...)

Arguments

normed.data

The normalized input data, usually calculated with isa.normalize.

data

The original, not normalized input data, a matrix for isa.filter.robust, a list of two matrices for ppa.filter.robust.

...

Additional arguments, see details below.

Value

robustness returns a numeric vector, the robustness score of each bicluster.isa.filter.robust returns a named list, the filtered isares, see the return value of isa.iterate for the structure of the list.ppa.filter.robust resturns a named list, the filtered ppares, see the return value of ppa.iterate for the structure of the list.

Details

robustness can be called as

    robustness(normed.data, row.scores, col.scores)

isa.filter.robust can be called as

    isa.filter.robust(data, normed.data, isares,
                      perms = 1, row.seeds, col.seeds)

and ppa.filter.robust can be called as

    ppa.filter.robust(data, normed.data, ppares,
                      perms = 1, row1.seeds, col1.seeds,
		      row2.seeds, col2.seeds)

These arguments are:

normed.data: The normalized input data, usually calculated with isa.normalize (for ISA) or ppa.normalize (for PPA).
row.scores: The scores of the row components of the biclusters. Usually the rows member of the result list, as returned by isa, or isa.iterate or some other ISA function.
col.scores: The scores of the columns of the biclusters, usually the columns member of the result list from isa.
data: The original, not normalized input data.
isares: The result of ISA, coming from isa or isa.iterate or any other function that return the same format.
perms: The number of permutations to perform on the input data.
row.seeds: Optionally the row seeds for the ISA run on the scrambled data. If this and col.seeds are both omitted the same number of random seeds are used as for isaresult.
col.seeds: Optionally the column seed to use for the ISA on the scrambled input matrix. If both this and row.seeds are omitted, then the same number of random (row) seeds will be used as for isares.
ppares: The result of a PPA run, the output of the ppa.iterate or the ppa.unique function (or any other function that returns the same format).
row1.seeds: Optionally, the seeds based of the rows of the first input matrix, can be given here. Otherwise random seeds are used, the same number as it was used to find the original co-modules.
col1.seeds: Optionally, the seeds based of the columns of the first input matrix, can be given here. Otherwise random seeds are used, the same number as it was used to find the original co-modules.
row2.seeds: Optionally, the seeds based of the rows of the second input matrix, can be given here. Otherwise random seeds are used, the same number as it was used to find the original co-modules.
col2.seeds: Optionally, the seeds based of the columns of the second input matrix, can be given here. Otherwise random seeds are used, the same number as it was used to find the original co-modules.

Even if you generate a matrix with uniform random noise in it, if you calculate ISA on it, you will get some biclusters, except maybe if you use very strict threshold parameters. These biclusters contain rows and columns that are correlated just by chance. The same is true for PPA. To circumvent this, you can use the so-called robustness measure of the biclusters/co-modules. The robustness of a bicluster is the function of its rows, columns and the input data, and it is a real number, usually positive. It is roughly equivalent to the principal singular value of the submatrix (of the reordered input matrix) defined by the bicluster.

robustness calculates the robustness score of a set of biclusters/co-modules, usually coming from one or more ISA/PPA iterations.

isa.filter.robust provides filtering based on the robustness measure. It reshuffles the input matrix and calculates ISA on it, with the parameters that were used to find the biclusters under evaluation. It then calculates the robustness for the modules that were found in the scrambled matrix (if there is any) and removes any modules from the data set that have a lower robustness score than at least one module in the scrambled data.

You can think of isa.filter.robust as a permutation test, but the input data is shuffled only once (at least by default), because of the relatively high computational demands of the ISA.

ppa.filter.robust does essentially the same, but for PPA co-modules.

References

Bergmann S, Ihmels J, Barkai N: Iterative signature algorithm for the analysis of large-scale gene expression data Phys Rev E Stat Nonlin Soft Matter Phys. 2003 Mar;67(3 Pt 1):031902. Epub 2003 Mar 11. Ihmels J, Friedlander G, Bergmann S, Sarig O, Ziv Y, Barkai N: Revealing modular organization in the yeast transcriptional network Nat Genet. 2002 Aug;31(4):370-7. Epub 2002 Jul 22

Ihmels J, Bergmann S, Barkai N: Defining transcription modules using large-scale gene expression data Bioinformatics 2004 Sep 1;20(13):1993-2003. Epub 2004 Mar 25.

Kutalik Z, Bergmann S, Beckmann, J: A modular approach for integrative analysis of large-scale gene-expression and drug-response data Nat Biotechnol 2008 May; 26(5) 531-9.

Examples

Run this code

## A basic ISA work flow for a single threshold combination
## In-silico data
set.seed(1)
insili <- isa.in.silico()

## Random seeds
seeds <- generate.seeds(length=nrow(insili[[1]]), count=100)

## Normalize input matrix
nm <- isa.normalize(insili[[1]])

## Do ISA
isares <- isa.iterate(nm, row.seeds=seeds, thr.row=2, thr.col=1)

## Eliminate duplicates
isares <- isa.unique(nm, isares)

## Calculate robustness
rob <- robustness(nm, isares$rows, isares$columns)
rob

## There are three robust ones and a lot of less robust ones
## Plot the three robust ones and three others
if (interactive()) {
  toplot1 <- rev(order(rob))[1:3]
  toplot2 <- sample(seq_along(rob)[-toplot1], 3)
  layout( rbind(1:3,4:6) )
  for (i in c(toplot1, toplot2)) {
    image(outer(isares$rows[,i], isares$column[,i]),
          main=round(rob[i],2))
  }
}

## Filter out not robust ones
isares2 <- isa.filter.robust(insili[[1]], nm, isares)

## Probably there are only three of them left
ncol(isares2$rows)

Run the code above in your browser using DataLab