Modeling a scenario with an input and an output. Plotting the frontier
EAT()
The EAT function is the centerpiece of the
eat library. EAT performs a regression tree
based on CART methodology under a new approach that guarantees obtaining
a frontier as an estimator that fulfills the property of free
disposability. This new technique has been baptized as Efficiency
Analysis Trees. The development of the functions contained in the
eat library has been designed so that even true R novices
can use the library easily. The minimum arguments of the function are
the data (data) containing the study variables, the indexes
of the predictor variables or inputs (x) and the indexes of
the predicted variables or outputs (y). Additionally, the
numStop, fold, max.depth and
max.leaves arguments are included for those more
experienced users in the fields of machine learning and tree-based
models. Modifying these four allows obtaining different frontiers and
therefore selecting the one that best suits the needs of the
analysis.
numStoprefers to the minimum number of observations in a node to be divided and is directly related to the size of the tree. The higher the value ofnumStop, the smaller the size of the tree.foldrefers to the number of parts in which the dataset is divided to apply the cross-validation technique. Variations in thefoldargument are not directly related to the size of the tree.max.depthlimits the number of nodes between the root node and the furthest leaf node (root not included). When this argument is introduced, the typical process of growth-pruning is not carried out. In this case, the tree is allowed to grow to the required depth.max.leavesdetermines the maximum number of leaf nodes. As inmax.depth, the process of growth-pruning is not performed. In this respect, the tree grows until the required number of leaf nodes is reached, and then, the tree is returned.
Note that including the arguments max.depth or
max.leaves hyperparameters reduce the computation time by
eliminating the pruning procedure. If both are included at the same
time, a warning message is displayed and only max.depth is
used.
The error of a given node \(t\) is measured as the prediction error at the node \(t\) over the total number of observations:
\[\begin{equation} R(t) = \frac{n(t)}{N} \cdot MSE(t) = \frac{1}{N} \cdot \sum_{(x_i,y_i)\in t}(y_i - \hat{y}(t))^2 \end{equation}\]
The impurity of a tree \(T\) is measured as the sum of the impurities for each leaf node:
\[\begin{equation} R(T) = \sum_{i = 1}^{\widetilde{T}}R(t_i), \end{equation}\]
where \(\widetilde{T}\) is the set of leaf nodes for the tree \(T\).
The function returns an EAT object.
EAT(data, x, y,
fold = 5,
numStop = 5,
max.depth = NULL,
max.leaves = NULL,
na.rm = TRUE)- Example 1:
M_PISA ~ PFC
single_model <- EAT(data = PISAindex,
x = 15, # input
y = 3) # outputprint() returns the tree structure for an
EAT object where:
y: vector of predictions.R: error at the node.n(t): number of DMUs at the node.input name < / >= srepresents the division of the space.<*>indicates a leaf node.
print(single_model) [1] y: [ 551 ] || R: 11507.5 n(t): 72
| [2] PFC < 77.2 --> y: [ 478 ] || R: 2324.47 n(t): 34
| | [4] PFC < 65.45 --> y: [ 428 ] <*> || R: 390.17 n(t): 16
| | [5] PFC >= 65.45 --> y: [ 478 ] <*> || R: 637.08 n(t): 18
| [3] PFC >= 77.2 --> y: [ 551 ] <*> || R: 2452.83 n(t): 38
<*> is a leaf nodesummary() returns the following information of an
EAT object:
Formula: outputs ~ inputsSummary for leaf nodeswhere:id: leaf node index.n(t): number of DMUs at the leaf node.%: proportion of DMUs at the leaf node.- As many columns as
output nameswith the corresponding predictions for the leaf nodes. R(t): error at the leaf node.
Treewhere:Interior nodes: number of interior nodes.Leaf nodes: number of leaf nodes.Total nodes: total number of nodes (interior nodes + leaf nodes).R(T): error at the model.numStop: numStop hyperparameter value.fold: fold hyperparameter value.max.depth: max.depth hyperparameter value.max.leaves: max.leaves hyperparameter value.
Primary & surrogate splitswhere:Node A --> {B, C}indicates that the node A is split into the left child node B and the right child node C.variable --> {R: , s: }represents the division of the space with its error and threshold.Surrogate splitsindicates the best possible split for each variable that has not been used to divide the node. This is expressed asvariable --> {R: , s: }whereRis the error at the node andsthe threshold. Results are displayed in descending order by theirRvalue. In the case of a single input, the surrogate splits do not appear.
summary(single_model)
Formula: S_PISA ~ PFC
# ========================== #
# Summary for leaf nodes #
# ========================== #
id n(t) % S_PISA R(t)
3 38 53 551 2452.83
4 16 22 428 390.17
5 18 25 478 637.08
# ========================== #
# Tree #
# ========================== #
Interior nodes: 2
Leaf nodes: 3
Total nodes: 5
R(T): 3480.08
numStop: 5
fold: 5
max.depth:
max.leaves:
# ========================== #
# Primary & surrogate splits #
# ========================== #
Node 1 --> {2,3} || PFC --> {R: 4777.31, s: 77.2}
Node 2 --> {4,5} || PFC --> {R: 1027.25, s: 65.45}EAT_size() returns the number of leaf nodes of an
EAT model:
EAT_size(single_model)The number of leaf nodes of the EAT model is: 3[1] 3EAT_frontier_levels() returns the frontier levels of the
outputs at the leaf nodes:
EAT_frontier_levels(single_model)The frontier levels of the outputs at the leaf nodes are: S_PISA
1 551
2 428
3 478EAT_leaf_stats() returns a descriptive summary
statistics table for each output variable calculated from the leaf nodes
observations of an Efficiency Analysis Trees model. In multioutput
scenarios, the measurements are shown for each output. Specifically, it
computes:
Node: node index.n(t): number of DMUs.%: proportion of DMUs.mean: mean.var: variance.sd: standard deviation.min: minimum.Q1: first quantile.median: median.Q3: third quantile.max: maximum.RMSE: root mean square error.
EAT_leaf_stats(single_model) Node n(t) % mean var sd min Q1 median Q3 max RMSE
1 1 72 100 455.06 2334.59 48.32 336 416.75 466.0 495.25 551 107.27
2 2 34 47 416.88 1223.02 34.97 336 397.25 415.5 435.75 478 70.16
3 3 38 53 489.21 851.95 29.19 419 478.00 494.0 504.50 551 68.17
4 4 16 22 394.62 684.65 26.17 336 381.50 398.0 414.00 428 41.90
5 5 18 25 436.67 889.29 29.82 386 415.25 433.5 468.00 478 50.48Additionally, EAT_object[["tree"]][[id_node]] or
EAT_object$tree[[id_node]] returns a list that
allows knowing the characteristics of a given node in greater detail.
The elements that define a node are the following:
id: node index.F: father node index.SL: left child node index.SR: right child node index.index: set of indexes corresponding to the observations in a node.varInfo: list containing the error of the left node, the error of the right node and the threshold of the best split for each input.R: error at the node.xi: index of the variable that produces the split in a node.s: threshold of the variablexiby which the split takes place.y: value(s) of the predicted variable(s) in a node.a: lower bound of the given node.b: upper bound of the given node.
Note that:
- The node with index 1 has a value of -1 in
Fsince it has no parent node. - A leaf node has a value of -1 in
SL,SR,sandxisince it is not divided.
single_model[["tree"]][[5]]$id
[1] 5
$F
[1] 2
$SL
[1] -1
$SR
[1] -1
$index
[1] 26 27 34 36 38 39 41 42 43 45 47 48 49 58 59 65 66 68
$varInfo
$varInfo[[1]]
$varInfo[[1]][[1]]
[1] 363.2778
$varInfo[[1]][[2]]
[1] 759.8056
$varInfo[[1]][[3]]
[1] 64.32
$R
[1] 637.0833
$xi
[1] -1
$s
[1] -1
$y
$y[[1]]
[1] 478
$a
[1] 65.45
$b
[1] 77.2Categorical variables
The types of variables accepted by the EAT function are
the following:
| Variable | Integer | Numeric | Factor | Ordered.factor |
|---|---|---|---|---|
| Independent variables (inputs) | x | x | x | |
| Dependent variables (outputs) | x | x |
The Efficiency Analysis Trees methodology does not allow categorical
variables. At this time, only ordinal factors can be entered. It is
important to note that order = True must be included in the
factor construction so as not to produce an error.
- Factor (not ordered)
# Transform Continent to Factor
PISAindex_factor_Continent <- PISAindex
PISAindex_factor_Continent$Continent <- as.factor(PISAindex_factor_Continent$Continent)error_model <- EAT(data = PISAindex_factor_Continent,
x = c(2, 15),
y = 3) Error in preProcess(data = data, x = x, y = y, numStop = numStop, fold = fold, : Continent is not a numeric, integer or ordered vector- Factor ordered
# Cateogirze GDP_PPP into 4 groups: Low, Medium, High, Very High.
PISAindex_GDP_PPP_cat <- PISAindex
PISAindex_GDP_PPP_cat$GDP_PPP_cat <- cut(PISAindex_GDP_PPP_cat$GDP_PPP,
breaks = c(0, 16.686, 31.419, 47.745, Inf),
include.lowest = T,
labels = c("Low", "Medium", "High", "Very high"))
class(PISAindex_GDP_PPP_cat$GDP_PPP_cat) # "factor" --> error[1] "factor"# It is necessary to indicate order = TRUE, before applying the EAT function
PISAindex_GDP_PPP_cat$GDP_PPP_cat <- factor(PISAindex_GDP_PPP_cat$GDP_PPP_cat,
order = TRUE)
class(PISAindex_GDP_PPP_cat$GDP_PPP_cat) # "ordered" "factor" --> correct[1] "ordered" "factor" categorized_model <- EAT(data = PISAindex_GDP_PPP_cat,
x = c(15, 19),
y = 3) frontier()
The frontier function displays the frontier estimated by
the EAT function through a plot from ggplot2.
The frontier estimated by FDH can also be plotted if
FDH = TRUE. Observed DMUs can be showed by a scatterplot if
observed.data = TRUE and its color, shape and size can be
modified with observed.color, pch and
size respectively. Finally, rownames can be included with
rwn = TRUE.
frontier(object,
FDH = FALSE,
observed.data = FALSE,
observed.color = "black",
pch = 19,
size = 1,
rwn = FALSE,
max.overlaps = 10)To continue, the frontier of the previous model is displayed. It can
be seen how the frontier obtained by the EAT function
generalizes the results of the frontier obtained through FDH, thus
avoiding overfitting. The boundary estimated through Efficiency Analysis
Trees generates 3 steps corresponding to the 3 leaf nodes (nodes 3, 4
and 5) obtained with the EAT function. For each of these
steps, a frontier level in terms of the output is given with respect to
the amount of input used (in this case level of PFC). In
addition, we can appreciate 6 DMUs on the frontier: ALB (Albania), MDA
(Moldova), SRB (Serbia), RUS (Russia), HUN (Hungary) and SGP
(Singapore). Note that the first vertical plane of the frontier does not
appear, but if it did, ALB would be on it. These DMUs are efficient and
the rest of the DMUs below their specific step should increase the
amount of output obtained or reduce the amount of input utilized until
reaching the boundary to be efficient.
frontier <- frontier(object = single_model,
FDH = TRUE,
observed.data = TRUE,
rwn = TRUE)
plot(frontier)
- Is the number of steps on the frontier always the same as the number of leaf nodes?
The answer is no. Note that there may be situations where the estimation of two or more nodes is identical. This is necessary to ensure the estimation of an increasing monotonic frontier. In this case, the number of leaf nodes is 5, however the predictions for nodes 4 and 5 are the same and therefore the border only has 4 steps.
single_model_md <- EAT(data = PISAindex,
x = 15,
y = 3,
max.leaves = 5) EAT_size(single_model_md)The number of leaf nodes of the EAT model is: 5[1] 5single_model_md[["model"]][["y"]] [,1]
[1,] 551
[2,] 478
[3,] 428
[4,] 417
[5,] 417frontier_md <- frontier(object = single_model_md,
observed.data = TRUE)
plot(frontier_md)
