2 stablelearner
2.1 Growing a random forest in stablelearner
In our first approach, we want to grow a random forest directly in stablelearner. This is possible using conditional inference trees (Hothorn, Hornik, and Zeileis 2006) as base learners relying on the function ctree() of the partykit package. This procedure results in a forest similar to a random forest fitted via cforest() (see ?partykit::cforest).
To achieve this, we do have to make sure that our initial ctree, that will be repeatedly refitted on the resampled data, is specified correctly with respect to the resampling method and the number of feature variables randomly sampled as candidates at each node of a tree (argument mtry). By default, partykit::cforest() uses subsampling with a fraction of 0.632 and sets mtry = ceiling(sqrt(nvar)). In our GermanCredit example, this would be 5, as this dataset includes 20 feature variables. Note that setting mtry equal to the number of all feature variables available would result in bagging. In a real analysis mtry should be tune by means of, e.g., cross-validation.
We now fit our initial tree, mimicking the defaults of partykit::cforest() (see ?partykit::cforest and ?partykit::ctree_control for a description of the arguments teststat, testtype, mincriterion and saveinfo). The formula credit_risk ~ . simply indicates that we use all remaining variables of dat as feature variables to predict the credit_risk of a person.
set.seed(2906)
ct_partykit <- partykit::ctree(credit_risk ~ ., data = dat,
control = partykit::ctree_control(mtry = 5, teststat = "quadratic",
testtype = "Univariate", mincriterion = 0, saveinfo = FALSE))We can now proceed to grow our forest based on this initial tree, using stablelearner::stabletree(). We use subsampling with a fraction of v = 0.632 and grow B = 100 trees. We set savetrees = TRUE, to be able to extract the individual trees later:
set.seed(2907)
cf_stablelearner <- stablelearner::stabletree(ct_partykit, sampler = stablelearner::subsampling,
savetrees = TRUE, B = 100, v = 0.632)Internally, stablelearner::stabletree() does the following: For each of the 100 trees to be generated, the dataset is resampled according to the resampling method specified (in our case subsampling with a fraction of v = 0.632) and the function call of our initial tree (which we labeled ct_partykit) is updated with respect to this resampled data and reevaluated resulting in a new tree. All the 100 trees together then build the forest.
2.2 Gaining insight into the forest
The following summary prints the variable selection frequency (freq) as well as the average number of splits in each variable (mean) over all 100 trees. As we do not want to focus on our initial tree (remember that we just grew a forest, where all trees are of equal interest), we set original = FALSE as already mentioned in the introduction:
##
## Call:
## partykit::ctree(formula = credit_risk ~ ., data = dat, control = partykit::ctree_control(mtry = 5,
## teststat = "quadratic", testtype = "Univariate", mincriterion = 0,
## saveinfo = FALSE))
##
## Sampler:
## B = 100
## Method = Subsampling with 63.2% data
##
## Variable selection overview:
##
## freq mean
## status 1.00 2.79
## duration 0.91 1.90
## credit_history 0.90 1.68
## employment_duration 0.88 1.66
## savings 0.79 1.09
## age 0.77 1.33
## purpose 0.76 1.27
## installment_rate 0.73 1.23
## housing 0.73 1.09
## property 0.70 1.05
## job 0.68 1.01
## telephone 0.67 0.99
## personal_status_sex 0.65 0.92
## amount 0.62 0.89
## present_residence 0.62 0.94
## other_installment_plans 0.59 0.70
## number_credits 0.57 0.79
## other_debtors 0.52 0.61
## people_liable 0.24 0.26
## foreign_worker 0.06 0.06I.e., looking at the status variable (status of the existing checking account of a person) this variable was selected in all 100 trees (freq = 1.00). Moreover, this variable was often selected more than a single time for a split because the average number of splits is at around 2.50.
Plotting the variable selection frequency is achieved via the following (note that cex.names allows us to specify the relative font size of the x-axis labels):
To get a more detailed view, we can also inspect the variable selections partitioned for each tree. The following plot shows us for each variable whether it was selected (colored in darkgrey) in each of the 100 trees within the forest, where the variables are ordered on the x-axis so that top ranking ones come first:
This may allow for interesting observations, i.e., we observe that whenever duration was not selected, both credit_history and employment_duration were almost always selected as splitting variables.
Finally, the plot() function allows us to inspect the cutpoints and resulting partitions for each variable over all 100 trees. Here we focus on the variables status, employment_duration, and duration:
Looking at the variable status (unordered categorical variable), we are given a so called image plot visualizing the partition of this variable. We observe that the most frequent partition is ... < 0 DM and 0 <= ... < 200 DM vs. ... >= 200 DM / salary for at least 1 year and no checking account. The light gray color is used when a category was no more represented by the observations left for partitioning in the particular node.
For ordered categorical variables such as employment_duration, a barplot is given showing the frequency of all possible cutpoints sorted on the x-axis in their natural order. Here, the cutpoint between 1 <= ... < 4 years and 4 <= ... < 7 years is selected more than 80 times.
Lastly, for numerical variables a histogram is given, showing the distribution of cutpoints. We observe that most cutpoints for the variable duration occurred between 0 and 30, however there appears to be high variance.
For a more detailed explanation of the different kinds of plots, Section 3 of Philipp, Zeileis, and Strobl (2016) is very helpful.
Concluding, the summary and different plots helped us to gain better insight into the variable and cutpoint selection of the 100 trees within our forest. Finally, in case we want to extract individual trees, i.e., the first tree, we can do this via:
It should be noted that from a technical and performance-wise aspect, there is little reason to grow a forest directly in stablelearner as the cforest() implementations in partykit and especially in party are more efficient. Nevertheless, it should be noted that the approach of growing a forest directly in stablelearner allows us to be more flexible with respect to, e.g., the resampling method, as we could specify any method we want, e.g., bootstrap, subsampling, samplesplitting, jackknife, splithalf or even custom samplers. For a discussion why subsampling should be preferred over bootstrap sampling, see Strobl et al. (2007).
