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)

