expressopdnn            package:affypdnn            R Documentation

_P_o_s_i_t_i_o_n _D_e_p_e_n_d_a_n_t _N_e_a_r_e_s_t _N_e_i_g_h_b_o_r_s _m_o_d_e_l _f_o_r _a_f_f_y

_D_e_s_c_r_i_p_t_i_o_n:

     A wrapper to perform the PDNN method.

_U_s_a_g_e:

     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)

_A_r_g_u_m_e_n_t_s:

  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 'ExpressionSet-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', then an expression
          summary value is computed for everything on the chip.

 verbose: logical value. If 'TRUE' it writes out some messages.

_D_e_t_a_i_l_s:

     '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').

_V_a_l_u_e:

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

_S_e_e _A_l_s_o:

     'expresso' and 'computeExprVal.method.pdnn'

_E_x_a_m_p_l_e_s:

     ## 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)

