{'fraction_non_alphanumeric': 0.03722460184111508, 'fraction_numerical': 0.014648460610076438, 'mean_word_length': 4.505211047420532, 'pattern_counts': {'":': 0, '<': 6, '<?xml version=': 0, '>': 2, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
Slow-Growing Trees

Random Forest's performance can be matched by a single slow-growing tree (SGT), which uses a learning rate to tame CART's greedy algorithm. SGT exploits the view that CART is an extreme case of an iterative weighted least square procedure. Moreover, a unifying view of Boosted Trees (BT) and Random Forests (RF) is presented. Greedy ML algorithms' outcomes can be improved using either"slow learning"or diversification. SGT applies the former to estimate a single deep tree, and Booging (bagging stochastic BT with a high learning rate) uses the latter with additive shallow trees. The performance of this tree ensemble quaternity (Booging, BT, SGT, RF) is assessed on simulated and real regression tasks.


Introduction
Suppose you are a terrible golfer invited to play a twisted form of golf. Rules are as follows. You are allowed 20 strokes. Performance is evaluated by a distance between a reported position and the hole. Two radically different strategies are available to the dismal golfer. The first is to try a hole in one 20 times and report the average position of the ball. By unbiasedness (despite high variance), the average shot should be close to the hole. A less flamboyant strategy is to do 20 small yet precise strokes (perhaps with the putter) and report the final position of the ball. The hole is the conditional mean, the golfer is a greedy algorithm, the first strategy is in the spirit of Random Forest (RF, Breiman 2001), while the second is based on Boosted Trees (BT, Freund et al. 1996;Friedman 2001). This paper proposes a unified view of BT and RF by adopting a simple taxonomy. The two algorithms differ in two main aspects: model structure (additive shallow trees vs one deep tree) and how they tame the imperfect greedy optimization path (small learning rate vs randomization/diversification). The first means that the space of potential predictive functions depends on the underlying model-building algorithm (e.g., additive vs multiplicative). The second is picking a strategy to successfully explore that space.
The base tree models contrasted in this paper are the one deep tree and shallow additive trees.
The first refer to fitting a single tree until there is little or nothing left to partition, making depth dependent on the sample size N. The second refer to sequentially (and additively) combining many trees of limited and fixed depth, usually from 1 ("stumps") to 10.
Model/regularization pairs are well known. BT fits an additive model and uses slow learning via its small learning rate ν. RF performs fast but randomized learning of one deep tree, and gets the conditional mean right on average. To re-emphasize, the model-building path of additive shallow trees is traditionally regularized in one way, and that of one deep tree in another.
Yet, there is no ex-ante reason for these strict associations: additive shallow trees could well be regularized by randomization/diversification and the one deep tree's variance could be reduced by constructing it slowly. While the former was already proposed in Goulet Coulombe (2020b) for other purposes, the latter remained until now a conceptual curiosity. This paper makes it operational by developing the missing corner in Table 1: a Slow-Growing Tree (SGT). SGT works by recognizing that CART (Breiman et al., 1984) can be seen as an extreme case of an iterative weighted least square procedure. More precisely, when splitting a sample into two subsamples, it gives a weight of one to observations that satisfy the splitting rule, and 0 to others. Then, calculations determining the next split for that particular node are carried using observations with a weight of 1. SGT introduces a learning rate η such that observations not satisfying the splitting rule are allocated a weight of 1 − η rather than 0. In Figure 1, SGT's splitting rule is contrasted with that of CART and Soft Trees (Jordan and Jacobs, 1994;Irsoy et al., 2012). Thus, unlike the two included alternatives, whenever η < 1, observations at the far left are not completely discarded -or at least, not by a single sweep of the greedy algorithm. 1 Trivially, SGT collapses to CART for η = 1. Furthermore, it is easy to see how naturally shrinkage operates. A decreasing learning rate means that the children nodes' current average will be shrunk to its parent node's -by allowing the other children's observations to enter subsequent calculations with a non-negligible weight. This paper's contributions are threefold. First, SGT helps in showing how two famous algorithms (BT and RF) are linked through a tree taxonomy. A greedy algorithm tamed by randomization (RF) or slow learning (SGT) gives nearly identical results when they estimate the same model (the one deep tree). Without SGT, we cannot hope to empirically demonstrate this equivalence because yes, BT uses slow learning, but it also fits a different model (additive shallow trees). By introducing SGT and Booging, which fill the missing corners of the tree ensemble quaternity, it is possible to distinguish the benefits of different regularizer vs different models.
Second, SGT helps us understand RF, which frequent great performance is still not fully understood. RF tame the imperfect optimization of a one deep tree problem with randomization (bagging + model perturbation). The introduction of SGT shows that randomization in itself is not the key, but it is only one way of regularizing the optimization path of one deep tree.
Further, SGT is shown to behave like l 1 penalized kernel regression. This understanding of RF "by pieces" is useful for future model development as it shows that a successful "one deep tree" does not necessitate Bagging or feature randomization, which until now were indissociable.
Third, SGT is interesting in itself by potentially providing gains on small data sets. When faced with 200 observations, RF inevitably relies on trees of limited depth, giving a certain impor-tance to early splits, which can be of disputable quality Friedman et al. (2001). In such situations, better results may be obtained from slow learning -the choice of regularizer mattering more for small N. A prominent example is macroeconomic forecasting, where (pertinent) recorded history starts in the 1960s and is (at best) at the monthly frequency. 2 The new algorithm is evaluated against standard alternatives on simulated and real data sets.
SGT behaves very similarly to RF, with sometimes marginally better/worse performance, supporting a slow tree hypothesis (SLOTH) to explain RF.. That is, under a tree data-generating process, SGT and RF coincides, and SGT can be seen as computationally feasible version of an extremely high-dimensional Lasso where regressors are interacted dummies constituting potential tree structures. More generally, this observation is in line with the conjecture that the two regularization strategies (diversification vs slow learning) are largely interchangeable, and the best choice will depend on the data set. Hence, the development of SGT is conceptually interesting per se since it permits to single out the effect of different regularization strategies on the same model -as highlighted in Table 1.
Empirically backing the SLOTH, it is found that when the true DGP is a tree, SGT, and RF performances match. This observation helps link back RF to arguments that certain boosting procedures with infinitesimal learning rates approximate the Lasso path Rosset et al., 2004) -i.e., a global solution to a high-dimensional problem. When it comes to SGT (and RF), the high-dimensional space of generated regressors just got wider, and which corners of it that get to be explored depend on the previous greedy steps. Finally, Booging (bagging stochastic gradient boosted trees with a high learning rate) can deliver gains over BT, challenging slow-learning as the de facto regularization choice for additive trees. This paper is organized as follows. In section 2, I detail the main conceptual insights, present the SGT algorithm and discuss practical aspects. Sections 3 and Section 4 report results on simulated and real data sets, respectively. Section 5 concludes.

Ensembling Trees Revisited
BT is a greedy algorithm sequentially combining trees to minimize a loss function. The resulting νT s (X i ) 2 Using trees on time series data can seem odd at first glance. It is fine with stationary data, which is true after applying standard econometric transformations. A new literature shows that tree ensembles are proficient at macro forecasting (Chen et al., 2019;Medeiros et al., 2019;Goulet Coulombe et al., 2019). where y i ∈ IR is a target variable, X i ∈ IR K are predictors, ν is a learning rate, and S, the number of steps (and trees), is a tuning parameter governing early stopping. Intuitively, its range of candidate values depends directly on ν -smaller values of ν's typically necessitate higher values of S. In practice, it is customary to tune both (Friedman, 2002). Very often, the lower ν gets, the better generalization is (Friedman, 2001). Inspired by the above, I propose an algorithm estimating (slowly) a single tree that can match (and sometimes beat) RF's performance. While the utilization of a learning rate comes very naturally in a Boosting context (or in a deep learning one, see Goodfellow et al. 2016), it is less clear how it should materialize when fitting a single deep tree. A useful observation is that CART is an extreme form of an iterative weighted least squares (WLS) procedure. The proposed implementation leverages the WLS analogy to develop a less "radical" tree-building algorithm.
Consider the deceptively simple tree below, which is obtained after one recursion of CART.

Full Sample
The subsequent problem to grow the tree on the A side is where ω A i = I(i ∈ A). This can be generalized to where η ∈ (0, 1] is a learning rate. Trivially, those new weights collapse to those of CART when η = 1. Like ν in Boosting, η < 1 shrinks the new problem to the old one. This partial rejection of the greedy algorithm's proposed split desirably moderates the chosen optimization direction.
This can also be seen as softly pruning the tree at each step s: with a decreasing η the mean in the current children node is shrunk back to full sample mean, partly annulling the earlier split. Of course, the idea here, like in Boosting, is that there will be many more such s's than when η = 1, allowing SGT to build a deeper tree where each specific "split" matters less on its own.
Algorithm 1 outlines SGT's recursive procedure. A few remarks are in order. First, a typical stopping rule for CART is either the minimal size of the node before attempting a last split, or a minimal size of the terminal nodes. Anyway this is set up, it is customary that tree constituents in RF are approximately fully grown with leaves containing between 1 and 5 observations. By construction, all nodes of SGT, no matter how deep within the tree they appear, all incorporate

Algorithm 1 Slow-Growing Tree
Input: Training data [y i X i ], test set predictors X j , learning rate η ∈ (0, 1], maximal concentration indexH N observations. The barometer of in-sample learning is an increasingly unequal distribution of ω l i 's, where ω l i is the weight of observation i in a given leaf l. Thus, the stopping rule shall be formulated in terms of the imbalance of ω l i . I use an upper boundH on the Herfindhal index which is a widely used measure of industry (FTC/DOJ, 2010), labor market (Azar et al., 2020), and portfolio (Ávila et al., 2013) concentration. That bound is set between 0.2 or 0.3 in practice, which is extremely high (that is, the distribution is highly unequal with only a few observations having a noticeable weight) and is thought of approximating what a fully grown (overfitting) tree would be in this new environment. More precisely, in a standard tree, if a terminal node includes 5 observations, then its H l = 5 × ( 1 /5) 2 + (N − 5) × 0 2 = 0.2. Considering smallerH's (like 0.05 or 0.1) is a form of early stopping which will be shown to pay off in low signal-to-noise environments in section 3.
Weights for a given terminal node is the product of all filters applied to get from the top of the tree to that particular leaf. This is, again, a generalization of the usual tree weights where filters (splitting rules) have the additional property of setting part of the weights directly to 0. In that spirit, the mean of that terminal node is a weighted average with weights ω l i . Finally, since the hard separation embedded in CART (observations go on to A or B but not both) is no more, a new data point j will almost surely fall in more than one leaf (depending on its X j ). Those within-leaf weighted averages (∑ N i=1 ω l i y i ) must be combined to get the final prediction. Taking naively the simple average would fail as leaves where j has a very small ω l j would get the same preponderance as those where ω l j dominates. w l j (X j ) = ω l j (X j )/∑ L l=1 ω l j (X j ) adjusts for that. It is easy to see that is the η = 1 case where weights are dichotomous (and thus leaves do not overlap) that w l j (X j ) = 1 for a single leaf and zero for all others. Lastly, a very technical, yet necessary, consideration. The fact that a split can be invoked twice (or as often as needed, really) gives rise to a particular situation that would not arise in CART: the distribution of ω i in a node can revert back to the initial (flat) one. For instance, if we "split" using x i < 0 in a node which unique previous split was based on x i < 0, we get two new children nodes. The first is not problematic -we simply get twice the discriminating action of x i < 0, that is, a weight of 1 for observations that satisfy the rule, and (1 − η) 2 for those that do not. However, the second child node will have a flat distribution of weights because some observations got down weighted once by (1 − η) in the first split, and all the remaining children get down weighted once (1 − η) by the second split. Hence, they all have a weight of (1 − η), which, after normalization, are the initialization weights. If left unattended, this creates an infinite loop of a tree within a tree. The solution is simple: such dead branches are trimmed out. Note that this is not problematic in SGT as the assigned observations are appearing elsewhere anyway (in CART, this would create a hole in the predicting function).

What is SGT estimating?
I start by reviewing a popular interpretation of what a low learning rate does to a linear boosting (or forward stagewise regression) problem. Then, I leverage that knowledge to propose an explanation of what SGT is estimating 2.1.1 Boosting as a l 1 -regularized Problem Friedman et al. (2001) observe that a simpler form of boosting (without trees and observations reweighting) delivers coefficients paths indistinguishable to that of Lasso (Tibshirani, 1996).
More precisely, provided a small enough learning rate, plotting coefficients as functions of decreasing regularization strength -i.e.,β Boosting (s) against an increasing s andβ Lasso (λ) for a decreasing λ -gives rise to identical figures. This relationship is further explored in Rosset et al. (2004) where boosting is argued to be a computationally convenient approach to solve a (very) high-dimensional regression with l 1 regularization. 3 This exact equivalence hinges onβ Lasso (λ) paths being monotone since Boosting solves a monotone Lasso problem where coefficients are penalized according to their "arc-length" (Hastie et al., 2007). 4 Schapire (2013) nuances those claims by pointing out that the l 1 argument applies to a very specific variant of Adaboost, and that the Lasso analogy is hard to reconcile with the frequent observation that a very large S will not substantially damage out-of-sample performance -which would certainly not happen for Lasso in a classic setup when letting λ → 0. On the other hand, (Kobak et al., 2020) show that the optimal λ (for ridge) can be either negative or 0 in extremely high dimensions -which is where BT operates. This provides an avenue to conciliate the l 1 "explanation" of boosting and the empirical observation that the generalization sometimes does not decrease in s. 5

SGT Estimates the True Latent Tree
Like CART, SGT minimizes the empirical loss by creating more and more bins that are increasingly discriminatory. The key difference is that SGT's path towards highly polarized bins is constituted of many splits that are only mildly potent by themselves. But there is more. As a last building block behind the SLOTH, SGT can be cast as a peculiar Boosting problem. Then, we can exploit Rosset et al. (2004) and (Hastie et al., 2007)'s arguments that Boosting, under certain conditions, performs a high-dimensional Lasso -i.e., solving a global problem.
A symmetric 2-layers tree's prediction can be written aŝ where γ's and α's are within-node mean parameters. x, z and q are predictors. Define d + x,i = I(x i > 0) as a regressor and the rest accordingly. Note that SGT can be obtained by letting (2) is also an additive modelŷ with "polynomials" of order 2. A tree with 3-layers would extend (3) to 8 polynomials of order 3. Finally, one can rewrite (3) using the identity d + z,i = 1 − d − z,i (and similarly for q) to obtain As in (3), (4) is additive but now, it is explicit that "earlier" basis functions are not ejected from the model. Hence, the deep tree can also be cast within Rosset et al. (2004) and Hastie et al.
H is the fixed space of all possible basis expansions for the one deep tree, and it is significantly larger than what additive shallow trees can allow for. The exploration of H is made possible by relying on the past steps of the greedy algorithm to guide its search through higher-order polynomials. That is, as an implication of the tree structure, some part of "later" basis expansions is already fixed.
Using this representation, the intuition provided in Rosset et al. (2004) directly applies, provided β's are monotone. This can be obtained by designing new basis functions using a rule which follows from a series of casual observations. First, it is noticed that one sweep of SGT's greedy algorithm updates two β's -that of the older basis expansion (like d + x,i ) and that of the newly added one (d + x,i d + z,i ). Second, it does not matter for the span of the model whether we ex- Third, given that those specific basis expansions amount to splitting a mean into two means, by construction, one of them will always be at least as high (in absolute value) as the parent node's mean. Thus, we can choose to use d + x,i (which is already in the active set of regressors) satisfies monotonicity. As a result of the above, SGT is a high-dimensional l 1 regularized regression with an extremely large H which is explored at each s in a particular way. Naturally, that space is the space of trees of a certain dimension (bounded by the size of the data set). SGT is a computationally cheaper way of estimating the true latent tree, whose direct global optimization would be an extremely high-dimensional Lasso problem. Moreover, l 1 regularization in SGT's context can be straightforwardly interpreted as pruning: shrinking β 2 completely to 0 prunes the x i > 0 side of the tree. Selecting both β 2 and β 4 to 0 prunes the 2-layers tree a single layer one. Additionally, early stopping takes a similar meaning.
Since RF is yet another way of taming CART, this understanding of SGT is transferable to RF.
In Goulet Coulombe (2020b), it is argued, by an analogy to forecasting with nonlinear (recursive) time series models, that bagging brings an imperfect greedy procedure to extract the true conditional mean. The deeper reason is that taking an expectation over a series of nonlinear recursions gives a very different outcome from that of a series of recursions that take expectations as inputs. The former is what we hope CART would do, and the latter is what it actually does.
Bagging allows simulating the right expectation (Goulet Coulombe, 2020b). The SLOTH is that this performs the same role as what we expect from the learning rate. A conjecture as to why a low η deliver similar results is that, by shrinking the children weights to those of the parents, this pushes the "updating" mapping towards the identity mapping, which is linear, making the expectation in recursion problem much milder. Simulations will back the SLOTH by showing that when the true DGP is a tree, SGT and RF provide near-identical performance.

Interpretation?
In RF, the visual inspection of underlying trees is doomed because there are usually 500 of them and they are all of substantial size. The former problem remains for BT, whereas the latter vanishes since trees are typically shallow. However, unlike RF, all those trees are fitted to a different target (the pseudo-residuals at step s), a new complication. Thus, it is customary to attempt the understanding of such models using variable importance measure, partial dependence plots and surrogate models (Molnar, 2019). Yet, none of those options provide the enviable clarity of inspecting a single tree.
SGT provides a single tree. However, the utilization of the learning rate means giving up hard-thresolding, which implies that a single observation can belong at varying degrees to different leaves. Also, η < 1 allows for splitting rules to be invoked more than once. This gives rise to "hierarchy" of splits: some on which the greedy algorithm really insists, and those that it may have merely stumbled upon along the way. None of those complications prevents from plotting the corresponding tree. For instance, the fact that some observations are shared across leaves can be simply thought as tree obtained on an artificially augmented data set (N-wise). Rather, the core roadblock is that the resulting SGT is very large, making human inspection daunting.
In sum, SGT opens new avenues for the interpretation of a highly performing model (matching in many ways RF), but exploring those is non-trivial and is kept for future work.

Hyperparameters and Computational Aspects
Like any tree-based model, computational demand increases in N and K. It depends highly on η: a smaller η necessarily increase the depth of SGTs, the same way ν necessitate a higher S. Hence, computational burden behaves similarly to that of fitting a deep tree on a very large data set (N-wise). Additionally, since we are recursively solving WLS problems rather than assigning 0-1 weights (à la CART), the size of samples used to pick (k * l , c * l ) at the lowest layers of the SGT is the same as those of upper layers. Finally, with a lowerH acting as an early-stopping rule, computations decrease inH. To accelerate computations -which can be demanding for large N data sets, I let η increase marginally with depth so the algorithm avoid languishing with many leaves with a H l slightly belowH. The rule of thumb is starting at η = 0.1 and increasing it by 0.01 with depth (that is, how many splits led to the current node) until an imposed plateau of 0.5 is reached. To further increase speed and add mild regularization à la stochastic gradient descent (Friedman, 2002), mtry =0.75 is used throughout.
The bias-variance trade-off within SGT operates like in Boosting. Deeper trees (as controlled byH) will decrease bias at the expense of variance (like adding more trees in BT). Also, as it is often found for BT (and originally documented in Friedman 2001,) the best learning rate for SGT is almost always the smallest one and there is little benefit in early-stopping.

Related Works
Related to SGTs are soft trees (Irsoy et al., 2012). They differ from SGT in many ways -goals and results. They consist in changing the hard-threshold rule of CART by a sigmoid function which will still allocate 0 and 1 weights to observations in the tails, but will have less drastic weight change around c * . Hence, some observations will still be completely discarded on the basis of a single split on a single variable, and as a result, soft trees still suffer from most of the CART ailments -except that of not attaining a global optimum since it can be estimated by gradient descent. The "optimality" concern has been the subject of recent work (Bertsimas and Dunn, 2017;Hu et al., 2019;Norouzi et al., 2015;Blanquero et al., 2020) where recursive partitioning is retired in favor of global optimization techniques. While those methods will almost always beat CART, their performance usually lags behind that of RF in a sizable way (see Bertsimas and Dunn (2017)  SGT's relationship with Soft Trees can benefit from further discussion. Despite appearances, SGT has little to do with Soft Trees in motivation, implementation, and outcomes. That also applies to fuzzy trees or probabilistic versions of CART where smoothness also emerges. Figure   1 showcases the difference in splitting rules. A single SGT sweep does not assign probabilities to the nodes as Soft Trees would. They key element is rather the learning rate which shrinks the orange line (CART) to a flat line at 1 (no learning). The blue and black lines separate observations 1 to 30 and 70 to 100, and there is no turning back. As is clear from Figure 1, the red one does not separate "forever" and rather use the greedy algorithm as suggestive of how weights should be adjusted. As a result, many SGT iterations are necessary for the data to be really split. Of course, this is the "one deep tree" version of Boosted Trees (BT) adding the next best tree (found greedily) but shrinking it severely to zero.
If there were a single regressor to split on, and the true split is smooth and with respect to X, then we would expect SGT to reproduce the soft tree split as a sum of many slow splits in different positions along the x-axis. RF could do the same (see Bühlmann et al. (2002)) by relying on averaging fast-learning rules. But these are very special circumstances. In an environment where different regressors could be used for the split and the smoothness of the split is unknown, SGT and Soft Trees will radically differ. An advantage of SGT and RF over Soft Trees and CART is that by construction, splits need not be made of a single variable (both SGT and RF are "ensembling" in their own way) while Soft Trees still make large learning leaps by fully splitting on a single variable.
A more general question emerges. Given the popularity of neural networks, is there any use for another greedy algorithm -which does not reap the well-document benefits of gradient descent? The answer is yes. While Soft Trees and their variant may be estimable by gradient descent, some more subtle advantages of greedy algorithms (especially for small tabular data) are lost in the process. First, automatic feature selection (which RF and BT excel at) is often ejected from the process Arik and Pfister (2019), a globally-optimized model needing to be globally specified first. 6 In contrast, in greedy methods, model building and estimation happen simultaneously. Second, greedy methods appear more apt at dealing with noisy labels.
Goulet Coulombe (2020b) makes that point that RF performs implicit optimal early stopping outof-sample and Wyner et al. (2017) discuss potential sources of the incredible robustness of BT. As a result of those observations (and likely others), BT reigns over many Kaggle competitions involving tabular data, and RF is becoming an inevitable benchmark for economic/financial data Goulet Coulombe (2020b).

Booging
Booging (for Bagging Boosting) is the application diversification-based regularization to additive shallow tree structure. It was originally proposed in Goulet Coulombe (2020b) to show that any randomized greedy algorithm (beyond RF) can be self-regularized, that is, perform implicit early stopping. In this paper's simulations and empirical work, it will be used again to show how Booging can rival BT with tuned learning rates -further demonstrating the virtues of the championed tree ensemble quaternity.
Booging consists of running BT with a relatively high learning rate (like ν = 0.25) on many bootstrap samples. Clearly, Bagging is only useful here because each BT run becomes increasingly unstable with high ν's. Moreover, each run is perturbed by using Stochastic Gradient Boosting Friedman (2002) with a certain fraction (often 0.3 or 0.5) of randomly selected observations being used to construct trees. To reinforce diversification potential (especially when regressors are scarce), the Booging also uses data augmentation (i.e., include noisy carbon copies of X). For all implementation details, see Goulet Coulombe (2020b).

Simulations
I use simulated data from five standard data generating processes (DGPs) to evaluate when SGTs and Booging outperforms their counterparts relying on their traditionally associated regularization scheme.
Five versions of the two classic tree models (one deep tree, additive shallow trees) are considered. In Figure 2, each model is a row facet. Both are constructed in five different ways, each with their own associated color. First, we have the bagged and perturbed version, which corresponds to RF for one deep tree, and Booging for additive shallow trees. For RF, both mtry and the minimal node size are tuned by cross-validation. The "plain" versions of the two structures are CART (with a tuned depth) and BT with a high ν (0.25) and a tuned number of trees. Third, I consider 3 versions with varying learning rates with one of them additionally incorporating early stopping.

Perturbed and Bagged
Plain Medium Learning Rate Low Learning Rate Low Learning Rate + Early Stopping Figure 2: This plots the hold-out sample R 2 between the prediction and the true conditional mean. The level of noise is decreasing along the x-axis. Column facets are DGPs and row facets are "models". The y-axis is cut at -1 to favor readability because a few models go largely below it for the lowest signal-to-noise ratio case. Note that negative R 2 's mean the evaluated model does worse than the sample mean on the test set.
additive trees, this is standard BT with ν ∈ {0.1, 0.001, 0.001} and S ∈ {1500, 1500, 750}. 7 The five DGPs are identical to that of Goulet Coulombe (2020b). First, we have the "Tree" DGP which is generated using a CART algorithm's prediction function as a "new" conditional mean function from which to simulate. The depth of the tree is set by fixing the minimal node size so that true terminal nodes contain about 1 /8 of the sample on average. Then, we have Friedman 1, 2 and 3 (Friedman, 1991) as well as a linear model. The latter's conditional mean is the sum of five mutually orthogonal and normally distributed regressors. Each model is fed 10 predictors with the fraction of truly useful ones varying across DGPs (but is usually around 50%). In Figure   2, DGPs are column facets.
Finally, it is expected that the performance differential between the two regularization schemes depends not only on the DGP but also the signal-to-noise ratio. To explore such dependence, the performance is reported for "true" R 2 's ranging (on Figure 2's x-axis) between 0.1 and 0.99. For all simulations, N = 100 and the test set also has 100 observations. 8 The reported performance statistic is the mean R 2 between hold-out sample predictions and the true conditional mean for 30 simulations. Similarly to Gu et al. (2020), R 2 are used here and in the 7 As for other standard hyperparameters of Boosting-based models, the fraction of randomly selected observations to build trees at each step is 0.5, and the interaction depth of those trees is 5. ν is set to 0.25 for Booging. 8 Relative performance results are close to identical when bumping N to 400. empirical section because (i) the focus is on regression, (ii) they deliver a ranking identical to that of RMSEs, (iii) they are in comparable (and intelligible) units from one simulation/data set to another, and (iv) carry pertinent information about the complexity of underlying task and the signal-to-noise ratio.
First, let us focus on the "Tree" column of Figure 2. The blue line of RF is visually absent, because it is perfectly matched by SGT(η = 0.1,H = 0.05) (light green) up until the true R 2 is about 0.45, and by SGT(η = 0.1,H = 0.25) (red) afterwards. 9 This simply means that when it comes to estimating a conditional mean corresponding to a true tree, SGT and RF coincidesas the SLOTH suggests. That is, slow learning and diversification are equally valid methods to tame CART's greedy algorithm.
In line with common wisdom for ν in BT (Friedman, 2001;Rosset et al., 2004), the SGT(η = 0.1,H = 0.25) line is strictly above that of (η = 0.5,H = 0.25) (dark green). The strict dominance of a lower η is also verified for the remaining four DGPs. Finally, CART (light orange) is noticeably inferior to any SGTs, providedH would be tuned appropriately. In fact, it is interesting to notice how parallel are the light green and orange lines for all DGPs, with the latter always below the former by a sizable constant margin.
For DGPs Friedman 1,2 and 3, RF has a small edge over SGTs which is mostly apparent for high signal-to-noise ratio environments -RF performance is generally matched by SGT(η = 0.1,H = 0.05) for noisier setups. In the case of the linear DGP, RF performance is almost exactly matched by SGT(η = 0.1,H = 0.05) for all noise levels.
For the additive tree row, it is clearly visible that Booging implicitly performs early stopping, as the blue line closely follows the orange one, being marginally better or worse at times. Bringing ν down to 0.01 helps marginally, especially in the high true R 2 scenarios, whereas decreasing it even further to 0.001 pays off mostly when the true R 2 is low. As expected, the additive shallow trees, mostly underperforms with respect to the one deep tree when the true DGP is a tree.
Another takeaway is that Booging, by using diversification with a high learning rate, is often comparable to a lower learning rate version of BT.

Empirics
I consider data sets that are standard in the literature (all from UCI repository or Kaggle) as well as 12 data sets representing different macroeconomic forecasting tasks. 10 The latter contrast sharply with the traditionally considered regression examples: it is time series data, the number of features is extremely high, the number of observations is low, and the signal-to-noise ratio 9 It is understood that tuningH would simply generate a line close to the upper envelope of SGT(η = 0.1,H = 0.05) and SGT(η = 0.1,H = 0.25), and thus (tuned) RF. 10 For California Housing, a subset of 2000 observations is used.
is low when the data is properly transformed to induce stationarity. In short, it is a hostile environment where alternative regularization may yield much needed improvements.
The first 6 of those economic datasets are quarterly US data based on McCracken and Ng (2020)  Most data sets can be considered "small data". Those applications empirically motivates the development of SGT -beyond that it is a surrogate tool to understand RF. The reason is simple: the choice of regularizer matters more for small N. SGT and RF precisely differ in that aspect.
The models of interest are the four members of the tree ensemble quaternity, i.e., BT, RF, Booging and SGT(η = 0.1,H = 0.25). BT, CART, Lasso, and RF are tuned (which also includes ν for BT) via k-fold cross-validation. 12 "Benchmarks" include Lasso and CART. 13 For the macro data sets, they additionally include an autoregressive model of order 2 (AR), which is often very hard to beat (Kotchoni et al., 2019). I keep 70% of observations for training (and optimizing hyperparameters if needed) and use the remaining 30% to evaluate performance. For crosssectional data sets, those observations are chosen randomly. For time series applications, the first 70% × N observations are the training set. Table 2 report results. First, for standard data sets, RF and BT clearly dominates, which lend empirical support for the usual regularization/model pairs. A natural first question is whether SGT can closely match the RF stellar record. The answer is yes, SGT -with a single greedily optimized tree -trails behind by 0 to 7 points of R 2 percentages. Sometimes that difference is statistically significant (like for Red Wine, a 5% gap significant at the 1% level), sometimes it is not (like for Boston, Fish Toxicity and Ohio Housing). Note that SGT is miles ahead of CART for 11 The features set varies because of a mild screening rule. 12 Note that using tree-based methods on time series is appropriate with stationary data, which is true after applying standard econometric transformations. A growing literature shows that tree ensembles are very hard beat when it comes to macroeconomic forecasting (Chen et al., 2019;Medeiros et al., 2019;Goulet Coulombe et al., 2019). 13 CART is pruned according to CV. Lasso's λ is a also tuned by CV. Notes: This table reports out-of-sample R 2 's for 24 data sets and different models, either standard or introduced in the text. For macroeconomic targets (the last 14 data sets), the set of benchmark models additionally includes an autoregressive model (AR) of order 2 for quarterly data and of order 6 for monthly data. Numbers in bold identify the best predictive performance among tree ensembles. Numbers in blue are the best performances over all models. For tree ensembles, t-test (and Diebold and Mariano (2002) tests for time series data) are performed to evaluate the statistical significance of the accuracy differential between the "standard" versions (either RF or BT) and the alternative regularization versions (SGT or Booging) . '*', '**' and '***' respectively refer to p-values below 10%, 5% and 1%. every of those 10 data sets. Hence, unlike "optimal" trees (Bertsimas and Dunn, 2017;Blanquero et al., 2020), SGT results are in the ballpark of RF rather than merely improving upon CART.
Another interesting question is whether successes are mostly driven by the choice of regularizer or rather by that of the inherent model. The answer largely depends on the case under study.
Results of NBA Salary, Red Wine, and Fish Toxicity are indicative of the one deep tree being more appropriate than shallow additive trees for those data sets (RF Booging and SGT BT). In contrast, results for California Housing suggest that opting for diversification over slow learning is the game changer (RF SGT and Booging BT).
The difficulties evoked earlier for macro data sets are clearly visible, with most R 2 's being rather low. A first observation is that RF is never the best among all models, nor tree ensembles.
Nevertheless, it still offers highly competitive results. When it comes to US-GDP at 1 quarter ahead, all tree ensembles are alike with a small edge for those based on diversification. When it comes to unemployment rate (UR) at horizon 1, Booging supplants all models. At horizon 2, it still dominates, but is now ex-aequo with BT. For UR at horizon 1, it is interesting to notice how diversification-based tree ensembles supplant all slow learning-based variants. For inflation (INF) at horizon 1, all tree ensembles give similar performance, with SGT lagging behind in a non-statistically significant fashion. However, those performances are narrowly eclipsed by Lasso. At horizon 2, Booging improves over BT by 15%, which is significant at the 1% level. SGT strongly improves over RF for the 2-quarter ahead forecast (17%, which is significant at the 5% level) and is the best by far among tree ensembles. In terms of MSE, it is matched by CART, but SGT has a mean absolute error that is lower by 7%. Thus, SGT generates the best 2-quarters ahead inflation forecasts overall.  good inflation forecast at such a range is a reliable estimate of the lower frequency movements of inflation, which is in itself a notoriously hard problem Stock and Watson (2008).
SGT clearly provides that. While RF mostly overshoots, SGT matches nicely the slowly decreasing then increasing trend of inflation up to 2008. Moreover, the forecast is immune to the "missing disinflation puzzle" following the Great Recession. That is, unlike many macroeconomic and econometric models (Coibion and Gorodnichenko, 2015;Lindé and Trabandt, 2019), SGT does not wrongfully predict an overly large decrease in inflation following 2008. Finally, SGT is more resilient than RF when it comes to the "missing inflation puzzle" occurring in the last years of the sample.
In the noisy environment of monthly time series, many gains are not statistically significant.
There are exceptions. SGT's (R 2 =25%) gain over RF (R 2 =08%) for inflation one month ahead is statistically significant at the 5% level. However, this is far from being enough to capture UK inflation dynamics: SGT, BT and Booging all trail behind the more appropriate AR by a large margin. 14 There are less dismal cases -like that of hours worked 3 months ahead where SGT is the best model overall. This points out that SGT may be a potent tool to extract the faint signal out notoriously noisy series depicting real economic activity. Finally, Booging provides the best forecast for employment at both horizons, and hours worked at horizon 1. For EMP at the 3 months horizon, diversification clearly does better than slow learning with RF SGT and Booging BT. The edge of Booging over BT is statistically significant at the 1% level.

Conclusion
This paper proposes a tree ensemble taxonomy which ultimately helps understand what RF is doing. To make that claim, Slow-Growing Trees are introduced. It is shown that learning a single SGT delivers results often similar to that of RF. SGT allows linking back RF to boosting theory where the latter is argued to be similar to a very high-dimensional l 1 -regularized regression problem. Simulations confirm that SGT and RF coincide when the true DGP is a tree.
Applications to real data sets show that both SGT and Booging (additive trees regularized via diversification rather than a low learning rate) can provide gains over both BT and RF in difficult learning environments. Thus, for tree ensembles, regularization swapping can be beneficial.