b06-0-Pipeline-class: Class "Pipeline"

In PreProcess: Basic Functions for Pre-Processing Microarrays

Description

A Pipeline represents a standard multi-step procedure for processing microarray data. A Pipeline represents a series of Processors that should be applied in order. You can think of a pipeline as a completely defined (and reusable) set of transformations that is applied uniformly to every microarray in a data set.

Usage

## S4 method for signature 'ANY,Pipeline'
process(object, action, parameter=NULL)
## S4 method for signature 'Pipeline'
summary(object, ...)
makeDefaultPipeline(ef = PROC.SIGNAL, ep = 0,
                    nf = PROC.GLOBAL.NORMALIZATION, np = 0,
                    tf = PROC.THRESHOLD, tp = 25,
                    lf = PROC.LOG.TRANSFORM, lp = 2,
                    name = "standard pipe",
                    description = "my method")

Arguments

object	In the process method, any object appropriate for the input to the Pipeline. In the summary method, a Pipeline object.
action	A Pipeline object used to process an object.
parameter	Irrelevant, since the Pipeline ignores the parameter when process is invoked.
...	Additional arguments are as in the underlying generic methods.
ef	“Extractor function”: First Processor in the Pipeline, typically a method that extracts a single kind of raw measurement from a microarray
ep	Default parameter value for ef
nf	“Normalization function” : Second Processor in the Pipeline, typically a normalization step.
np	Default parameter value for nf
tf	“Threshold function” : Third Processor in the Pipeline, typically a step that truncates data below at some threshold.
tp	Default parameter value for tf
lf	“Log function” : Fourth Processor in the Pipeline, typically a log transformation.
lp	Default parameter value for lf
name	A string; the name of the pipeline
description	A string; a longer description of the pipeline

Details

A key feature of a Pipeline is that it is supposed to represent a standard algorithm that is applied to all objects when processing a microarray data set. For that reason, the parameter that can be passed to the process function is ignored, ensuring that the same parameter values are used to process all objects. By contrast, each Processor that is inserted into a Pipeline allows the user to supply a parameter that overrides its default value.

We provide a single constructor, makeDefaultPipeline to build a specialized kind of Pipeline, tailored to the analysis of fluorescently labeled single channels in a microarray experiment. More general Pipelines can be constructed using new.

Value

The return value of the generic function process is always an object related to its input, which keeps a record of its history. The precise class of the result depends on the functions used to create the Pipeline.

Slots

proclist:

A list of Processor objects.

name:

A string containing the name of the object

description:

A string containing a longer description of the object

Methods

process(object, action, parameter)

Apply the series of functions represented by the Pipeline action to the object, updating its history appropriately. The parameter is ignored, since the Pipeline always uses its default values.

summary(object, ...)

Write out a summary of the object.

Pre-defined Pipelines

The library comes with two Pipeline objects already defined

PIPELINE.STANDARD

Takes a Channel object as input. Performs global normalization by rescaling the 75th percentile to 1000, truncates below at 25, then performs log (base-two) transformation.

PIPELINE.MDACC.DEFAULT

Takes a CompleteChannel as input, extracts the raw signal intensity, and then performs the same processing as PIPELINE.STANDARD.

Author(s)

Kevin R. Coombes [e-mail]

See Also

Channel, CompleteChannel, process

Examples

showClass("Pipeline")

## simulate a moderately realistic looking microarray
nc <- 100
nr <- 100
v <- rexp(nc*nr, 1/1000)
b <- rnorm(nc*nr, 80, 10)
s <- sapply(v-b, max, 1)
ct <- ChannelType('user', 'random', nc, nr,  'fake')
subbed <- Channel(name='fraud', parent='', type=ct, vec=s)
rm(ct, nc, nr, v, b, s)		# clean some stuff

## example of standard data processing
processed <- process(subbed, PIPELINE.STANDARD)

summary(processed)

par(mfrow=c(2,1))
plot(processed)
hist(processed)

par(mfrow=c(1,1))
image(processed)

rm(subbed, processed)

Example output

Loading required package: oompaBase
Class "Pipeline" [package "PreProcess"]

Slots:
                                          
Name:     proclist        name description
Class:        list   character   character
log normalized fraud, a microarray channel object
Parent object: NA 
Microarray type: user random 
Labeled with: fake 
Design size: 100 by 100 
Design information object:  
History:
	 Channel(parent = "", name = "fraud", type = ct, vec = s) 
	 Default channel processing (using pipeline: PIPELINE.STANDARD) 
	 Global normalization (using object: proc) with parameter = 0 
	 Truncated below (using object: proc) with parameter = 0 
	 Log transformation (using object: proc) with parameter = 2 

   Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
-0.3619  7.3084  8.8428  8.0298  9.9658 12.7408 

PreProcess documentation built on May 3, 2019, 1:24 p.m.