# Recursive Partytioning A class for representing decision trees and corresponding accessor functions. ```r 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. ## Returns 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 ```r ### 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) ```

party function