expressopdnn {affypdnn} | R Documentation

## Position Dependant Nearest Neighbors model for affy

### Description

a wrapper to perform the PDNN method.

### Usage

    pdnn.scalevalue.exprSet(eset, scale.to=500)
    expressopdnn(abatch,
          # background correction
                 bg.correct = FALSE,
                 bgcorrect.method = NULL,
                 bgcorrect.param = list(),
          # normalize
                 normalize = FALSE,
                 normalize.method = NULL,
                 normalize.param = list(),
                  pmcorrect.method = c("pdnn", "pdnnpredict"),
          # pdnn
                 findparams.param = list(),
          # expression values
                 summary.subset = NULL,
          # PDNN expression values scaling
                 eset.normalize = TRUE,
                 scale.to = 500,
          # misc.
                 verbose = TRUE)

### Arguments

`abatch` | object of `AffyBatch-class`
`bg.correct` | a boolean to express whether background correction is wanted or not.
`bgcorrect.method` | the name of the background adjustment method
`bgcorrect.param` | a list of parameters for bgcorrect.method (if needed/wanted)
`eset` | An object of `exprSet-class`
`normalize` | normalization step wished or not.
`normalize.method` | the normalization method to use
`normalize.param` | a list of parameters to be passed to the normalization method (if wanted).
`pmcorrect.method` | the name of the PM adjustement method (only two choices here, default to 'pdnn').
`findparams.param` | a list of parameters to be passed to `find.params.pdnn`
`eset.normalize` | is any normalization step on expression values to be performed
`scale.to` | a value to scale against.
`summary.subset` | a list of 'affyids'. If `NULL`, a expression summary value is computed for everything on the chip.
`verbose` | logical value. If `TRUE` it writes out some messages.

### Details

`expressopdnn` is very similar to `expresso`. It is mainly a wrapper around the pre-processing steps `background correction', `normalization', `perfect match correction' and the PDNN method to compute expression values (see the first reference for more details about the preprocessing steps and and the second reference for further details about the PDNN method).

The wrapper `expresso` has no way to handle easily the computation of chip-wide results that have to be used during the `computeExprSet` step. An easy way to overcome this was to write this simple wrapper.

`pdnn.scalevalue` is performed after the expression values have computed to somehow `normalize' the values between different chips. When setting `normalize` to `TRUE` this step might be considered unnecessary (and the `eset.normalize` set to `FALSE`).

### Value

An object of `exprsSet-class`, with an attribute `pps.warnings` as returned by the method `computeExprSet`.

### See Also

`expresso` and `computeExprVal.method.pdnn`

### Examples

    ## load pre-computed parameters
    data(hgu95av2.pdnn.params)

    library(affydata)
    data(Dilution)

    ## one CEL to go faster
    afbatch <- Dilution[, 1]

    ## Take only few IDs (the 10 first)
    ids <- ls(getCdfInfo(afbatch))[1:10]
    eset <- expressopdnn(afbatch, bg.correct=FALSE,
                         normalize=FALSE,
                         findparams.param=list(params.chiptype=hgu95av2.pdnn.params,
                                               give.warnings=FALSE),
                         summary.subset=ids)

[Package affypdnn version 1.12.0 Index]