R: Recursive Partytioning

party {partykit} | R Documentation

## Recursive Partytioning

### Description

A class for representing decision trees and corresponding accessor functions.

### Usage

    party(node, data, fitted = NULL, terms = NULL, names = NULL,
        info = NULL)
    ## S3 method for class 'party'
    names(x)
    ## S3 replacement method for class 'party'
    names(x) <- value
    data_party(party, id = 1L)
    ## Default S3 method:
    data_party(party, id = 1L)
    node_party(party)
    is.constparty(party)
    is.simpleparty(party)

### Arguments

`node` | an object of class `partynode`.
`data` | a (potentially empty) `data.frame`.
`fitted` | an optional `data.frame` with `nrow(data)` rows (only if `nrow(data) != 0` and containing at least the fitted terminal node identifiers as element `(fitted)`. In addition, weights may be contained as element `(weights)` and responses as `(response)`.
`terms` | an optional `terms` object.
`names` | an optional vector of names to be assigned to each node of `node`.
`info` | additional information.
`x` | an object of class `party`.
`party` | an object of class `party`.
`value` | a character vector of up to the same length as `x`, or `NULL`.
`id` | a node identifier.

### Details

Objects of class `party` basically consist of a `partynode` object representing the tree structure in a recursive way and data. The `data` argument takes a `data.frame` which, however, might have zero columns. Optionally, a `data.frame` with at least one variable `(fitted)` containing the terminal node numbers of data used for fitting the tree may be specified along with a `terms` object or any additional (currently unstructured) information as `info`. Argument `names` defines names for all nodes in `node`.

Method `names` can be used to extract or alter names for nodes. Function `node_party` returns the `node` element of a `party` object. Further methods for `party` objects are documented in `party-methods` and `party-predict`. Trees of various flavors can be coerced to `party`, see `party-coercion`.

Two classes inherit from class `party` and impose additional assumptions on the structure of this object: Class `constparty` requires that the `fitted` slot contains a partitioning of the learning sample as a factor `("fitted")` and the response values of all observations in the learning sample as `("response")`. This structure is most flexible and allows for graphical display of the response values in terminal nodes as well as for computing predictions based on arbitrary summary statistics.

Class `simpleparty` assumes that certain pre-computed information about the distribution of the response variable is contained in the `info` slot nodes. At the moment, no formal class is used to describe this information.

### Value

The constructor returns an object of class `party`:

`node` | an object of class `partynode`.
`data` | a (potentially empty) `data.frame`.
`fitted` | an optional `data.frame` with `nrow(data)` rows (only if `nrow(data) != 0` and containing at least the fitted terminal node identifiers as element `(fitted)`. In addition, weights may be contained as element `(weights)` and responses as `(response)`.
`terms` | an optional `terms` object.
`names` | an optional vector of names to be assigned to each node of `node`.
`info` | additional information.

`names` can be used to set and retrieve names of nodes and `node_party` returns an object of class `partynode`. `data_party` returns a data frame with observations contained in node `id`.

### References

Hothorn T, Zeileis A (2015). partykit: A Modular Toolkit for Recursive Partytioning in R. Journal of Machine Learning Research, 16, 3905–3909.

### Examples

    ### data ###
    ## artificial WeatherPlay data
    data("WeatherPlay", package = "partykit")
    str(WeatherPlay)

    ### splits ###
    ## split in overcast, humidity, and windy
    sp_o <- partysplit(1L, index = 1:3)
    sp_h <- partysplit(3L, breaks = 75)
    sp_w <- partysplit(4L, index = 1:2)

    ## query labels
    character_split(sp_o)

    ### nodes ###
    ## set up partynode structure
    pn <- partynode(1L, split = sp_o, kids = list(
      partynode(2L, split = sp_h, kids = list(
        partynode(3L, info = "yes"),
        partynode(4L, info = "no"))),
      partynode(5L, info = "yes"),
      partynode(6L, split = sp_w, kids = list(
        partynode(7L, info = "yes"),
        partynode(8L, info = "no")))))
    pn

    ### tree ###
    ## party: associate recursive partynode structure with data
    py <- party(pn, WeatherPlay)
    py
    plot(py)

    ### variations ###
    ## tree stump
    n1 <- partynode(id = 1L, split = sp_o, kids = lapply(2L:4L, partynode))
    print(n1, data = WeatherPlay)

    ## query fitted nodes and kids ids
    fitted_node(n1, data = WeatherPlay)
    kidids_node(n1, data = WeatherPlay)

    ## tree with full data sets
    t1 <- party(n1, data = WeatherPlay)

    ## tree with empty data set
    party(n1, data = WeatherPlay[0, ])

    ## constant-fit tree
    t2 <- party(n1,
      data = WeatherPlay,
      fitted = data.frame(
        "(fitted)" = fitted_node(n1, data = WeatherPlay),
        "(response)" = WeatherPlay$play,
        check.names = FALSE),
      terms = terms(play ~ ., data = WeatherPlay),
    )
    t2 <- as.constparty(t2)
    t2
    plot(t2)

[Package partykit version 1.2-7 Index]