AMF: Aggregated Mondrian Forests for Online Learning

TL;DR

AMF introduces an online random forest method based on Mondrian Forests that efficiently aggregates all prunings, enabling adaptive, parameter-free learning suitable for classification tasks.

Contribution

It presents a novel online aggregation technique for Mondrian Forests, making them fully online, adaptive, and competitive without parameter tuning.

Findings

AMF performs competitively on multiple datasets.

It is truly online and parameter-free.

The method adapts to unknown regularity of the target function.

Abstract

Random Forests (RF) is one of the algorithms of choice in many supervised learning applications, be it classification or regression. The appeal of such tree-ensemble methods comes from a combination of several characteristics: a remarkable accuracy in a variety of tasks, a small number of parameters to tune, robustness with respect to features scaling, a reasonable computational cost for training and prediction, and their suitability in high-dimensional settings. The most commonly used RF variants however are "offline" algorithms, which require the availability of the whole dataset at once. In this paper, we introduce AMF, an online random forest algorithm based on Mondrian Forests. Using a variant of the Context Tree Weighting algorithm, we show that it is possible to efficiently perform an exact aggregation over all prunings of the trees; in particular, this enables to obtain a truly online parameter-free algorithm which is competitive with the optimal pruning of the Mondrian tree, and thus adaptive to the unknown regularity of the regression function. Numerical experiments show that AMF is competitive with respect to several strong baselines on a large number of datasets for multi-class classification.

Equations

$${\hat{f}}_t(\cdot ,{\mathbf{\Pi }}_t,{\mathcal{D}}_t):[0,1{]}^d\to \hat{\mathcal{Y}},$$

$${\hat{f}}_t^{(M)}(x,{\mathbf{\Pi }}_t^{(M)})=\frac{1}{M}\sum _{m=1}^M{\hat{f}}_t(x,{\Pi }_t^{(m)}),$$

$$C_{\mathbf{v}0}:=\{x\in C_{\mathbf{v}}:x_{j_{\mathbf{v}}}⩽s_{j_{\mathbf{v}}}\}\text{and}{C}_{\mathbf{v}1}:=C_{\mathbf{v}}\setminus C_{\mathbf{v}0}.$$

$${\hat{y}}_{\mathbf{v},t}=h((y_s{)}_{1⩽s⩽t-1:x_s\in C_{\mathbf{v}}})\text{mbox}and{L}_{\mathbf{v},t}=\sum _{1⩽s⩽t:x_s\in C_{\mathbf{v}}}\ell ({\hat{y}}_{\mathbf{v},s},y_s)$$

$${\hat{y}}_{\mathcal{T},t}(x)={\hat{y}}_{{\mathbf{v}}_{\mathcal{T}}(x),t},$$

$$L_t(\mathcal{T})=\sum _{s=1}^t\ell ({\hat{y}}_{\mathcal{T},s}(x_s),y_s).$$

$${\hat{y}}_{\mathbf{v},t}=\frac{1}{n_{\mathbf{v},t-1}}\sum _{1⩽s⩽t-1:x_s\in C_{\mathbf{v}}}{y}_s,$$

$${\hat{y}}_{\mathbf{v},t}(y)=\frac{n_{\mathbf{v},t-1}(y)+1/2}{t-1+|\mathcal{Y}|/2},$$

$${\hat{f}}_t(x)=\frac{{\sum }_{\mathcal{T}}\pi (\mathcal{T})e^{-\eta L_{t-1}(\mathcal{T})}{\hat{y}}_{\mathcal{T},t}(x)}{{\sum }_{\mathcal{T}}\pi (\mathcal{T})e^{-\eta L_{t-1}(\mathcal{T})}},$$

$$\pi (\mathcal{T})=2^{-|\mathcal{T}|},$$

$${\overline{w}}_{\mathbf{v},t+1}=\frac{1}{2}{w}_{\mathbf{v},t+1}+\frac{1}{2}{\overline{w}}_{\mathbf{v}0,t+1}{\overline{w}}_{\mathbf{v}1,t+1};$$

$${\sigma }_{\mathbf{v}}=(j_{\mathbf{v}},s_{\mathbf{v}},{\hat{y}}_{\mathbf{v}},w_{\mathbf{v}},{\overline{w}}_{\mathbf{v}},x_{\mathbf{v}}),$$

$${\tilde{y}}_{\mathbf{v}}=\frac{1}{2}\frac{w_{\mathbf{v}}}{{\overline{w}}_{\mathbf{v}}}{\hat{y}}_{\mathbf{v}}+\frac{1}{2}\frac{{\overline{w}}_{\mathbf{v}0}{\overline{w}}_{\mathbf{v}1}}{{\overline{w}}_{\mathbf{v}}}{\tilde{y}}_{\mathbf{v}a}.$$

$$\sum _{t=1}^n\ell ({\hat{f}}_t(x_t),y_t)-\sum _{t=1}^n\ell ({\hat{y}}_{\mathcal{T},t}(x_t),y_t)⩽\frac{1}{\eta }|\mathcal{T}|\log 2,$$

$$\sum _{t=1}^n\ell ({\hat{f}}_t(x_t),y_t)-\sum _{t=1}^n\ell (g_{\mathcal{T}}(x_t),y_t)⩽|\mathcal{T}|\log 2+\frac{(|\mathcal{T}|+1)(|\mathcal{Y}|-1)}{4}\log (4n)$$

$$\sum _{t=1}^n\ell ({\hat{f}}_t(x_t),y_t)-\sum _{t=1}^n\ell (g_{\mathcal{T}}(x_t),y_t)⩽4B^2(|\mathcal{T}|+1)\log n$$

$$\mathbb{E}\bigg{[}\sum_{t=1}^{n}\ell(\widehat{f}_{t}(x_{t}),y_{t})\bigg{]}\leqslant\mathbb{E}\bigg{[}\inf_{g}\sum_{t=1}^{n}\ell(g(x_{t}),y_{t})\bigg{]}+8B^{2}(1+\lambda)^{d}\log n\,,$$

$$\alpha (1+d_{\mathbf{v}}{)}^{-\beta }$$

$$R(g)=\mathbb{E}[\ell (g(x),y)].$$

$$\mathbb{E}[R(\widetilde{f}_{n})]-R(g)=\frac{1}{n}\mathbb{E}\Big{[}\sum_{t=1}^{n}\big{(}\ell(\widehat{f}_{t}(x_{t}),y_{t})-\ell(g(x_{t}),y_{t})\big{)}\Big{]},$$

$$\mathbb{E}[R({\tilde{f}}_n)]-\mathbb{E}[R(g_{\lambda })]⩽8B^2(1+\lambda {)}^d\frac{\log n}{n}.$$

$$\mathbb{E}[(\widetilde{f}_{n}(x)-f^{*}(x))^{2}]=O\Big{(}\Big{(}\frac{\log n}{n}\Big{)}^{2\beta/(d+2\beta)}\Big{)},$$

$${\sigma }_{\mathbf{v}}=(j_{\mathbf{v}},s_{\mathbf{v}},{\tau }_{\mathbf{v}},{\hat{y}}_{\mathbf{v}},w_{\mathbf{v}},{\overline{w}}_{\mathbf{v}},R_{\mathbf{v}}),$$

$$R_{\mathbf{v}}=\prod _{j=1}^d[a_{\mathbf{v}}^j,b_{\mathbf{v}}^j]$$

$$\frac{p(x^{\prime })}{p(x^{\prime \prime })}⩽M.$$

$$\mathbb{E}[D_n^{\Pi }(x)]⩽\frac{\log n}{\log [(2M)/(2M-1)]}+2M.$$

$$\mathrm{wdepth}(x)=\sum _{\mathcal{T}}w(\mathcal{T}){\mathrm{depth}}_{\mathcal{T}}(x)\text{ with }w(\mathcal{T})=\frac{\pi (\mathcal{T})e^{-\eta L_{t-1}(\mathcal{T})}}{{\sum }_{{\mathcal{T}}^{\prime }}\pi ({\mathcal{T}}^{\prime })e^{-\eta L_{t-1}({\mathcal{T}}^{\prime })}},$$

$${\hat{f}}_t(x)=\frac{{\sum }_{\mathcal{T}\subset {\mathcal{T}}^{\Pi }}\pi (\mathcal{T})e^{-\eta L_{t-1}(\mathcal{T})}{\hat{y}}_{\mathcal{T},t}(x)}{{\sum }_{\mathcal{T}\subset {\mathcal{T}}^{\Pi }}\pi (\mathcal{T})e^{-\eta L_{t-1}(\mathcal{T})}},$$

$$\sum _{{\mathcal{T}}^{\prime }:{\mathcal{T}}^{\prime }{|}_{\mathbf{T}}=\mathcal{T}}\pi ({\mathcal{T}}^{\prime })=2^{-\Vert \mathcal{T}\Vert }=:{\pi }_{\mathbf{T}}(\mathcal{T}),$$

$${\hat{f}}_t(x)$$

Full text

Keywords. Online regression trees, Online learning, Adaptive regression, Nonparametric methods

1 Introduction

In this paper, we consider the online supervised learning problem in which we assume that the dataset is not fixed in advance. In this scenario, we are given an i.i.d. sequence $(x_{1},y_{1}),$ $(x_{2},y_{2}),\dots$ of $[0,1]^{d}\times\mathcal{Y}$-valued random variables that come sequentially, such that each $(x_{t},y_{t})$ has the same distribution as a generic pair $(x,y)$. Our aim is to design an online algorithm that can be updated “on the fly” given new sample points, that is, at each step $t\geqslant 1$, a randomized prediction function

[TABLE]

where $\mathscr{D}_{t}=\{(x_{1},y_{1}),\dots,(x_{t},y_{t})\}$ is the dataset available at step $t$, where $\boldsymbol{\Pi}_{t}$ is a random variable that accounts for the randomization procedure and $\widehat{\mathcal{Y}}$ is a prediction space. In the rest of the paper, we omit the explicit dependence in $\mathscr{D}_{t}$.

This paper introduces the AMF algorithm (Aggregated Mondrian Forests), the main contributions of the paper and the main advantages of the AMF algorithm, are as follows:

• •

AMF maintains and updates at each step (each time a new sample is available) a fixed number of decision trees in an online fashion. The predictions of each tree is computed as a weighted average of all the predictions given by all the prunings of this tree. These predictions are then averaged over all trees to obtain the final prediction of AMF. This makes the algorithm purely online and therefore better than repeated calls to batch methods on ever increasing samples. An open source implementation of AMF is available in the onelearn Python package, available on GitHub and as a PyPi repository, together with a documentation which explains, among other things, how the experiments from the paper can be reproduced111The source code of onelearn is available at https://github.com/onelearn/onelearn and it can be easily installed by typing pip install onelearn in a terminal. The documentation of onelearn is available at https://onelearn.readthedocs.io..

• •

The online training of AMF and the computations involved in its predictions are exact, in the sense that no approximation is required. We are able to compute exactly the posterior distribution thanks to a particular choice of prior, combined with an adaptation of Context Tree Weighting (Willems et al., 1995; Willems, 1998; Helmbold and Schapire, 1997; Catoni, 2004), commonly used in lossless compression to aggregate all subtrees of a prespecified tree, which is both computationally efficient and theoretically sound. Our approach is, therefore, drastically different from Bayesian trees (Chipman et al., 1998; Denison et al., 1998; Taddy et al., 2011) and from BART (Chipman et al., 2010) which implement MCMC methods to approximate posterior distributions on trees. It departs also from hierarchical Bayesian smoothing involved in Lakshminarayanan et al. (2014) for instance, which requires also approximations.

• •

This paper provides strong theoretical guarantees for AMF, that are valid for any dimension $d$, and minimax optimal, while previous theoretical guarantees for Random Forest type of algorithms propose only suboptimal convergence rates, see for instance (Wager and Walther, 2015; Duroux and Scornet, 2018). In a batch setting, adaptive minimax rates are obtained in Mourtada et al. (2018) in arbitrary dimension for the batch Mondrian Forests algorithm. This paper provides similar results in an online setting, together with control on the online regret.

1.1 Random Forests

We let $\widehat{f}_{t}(x,\Pi_{t}^{(1)}),\dots,\widehat{f}_{t}(x,\Pi_{t}^{(M)})$ be randomized tree predictors at a point $x\in[0,1]^{d}$ at time $t$, associated to the random tree partitions $(\Pi_{t}^{(m)})_{1\leqslant m\leqslant M}$ of $[0,1]^{d}$, where $\Pi_{t}^{(1)},\ldots,\Pi_{t}^{(M)}$ are i.i.d.. Setting $\boldsymbol{\Pi}_{t}^{(M)}=(\Pi_{t}^{(1)},\dots,\Pi_{t}^{(M)})$, the random forest estimate $\widehat{f}_{t}^{(M)}(x,\boldsymbol{\Pi}_{t}^{(M)})$ is then defined by

[TABLE]

namely taking the average over all tree predictions $\widehat{f}_{t}(x,\Pi_{t}^{(m)})$. The online training of each tree can be done in parallel, since they are fully independent of each other, and each of them follow the exact same randomized construction. Therefore, we describe only the construction of a single tree (and its associated random partition and prediction function) and omit from now on the dependence on $m=1,\ldots,M$. An illustration of the decision functions of $M=10$ trees and the corresponding forest is provided in Figure 1.

Random tree partitions are given by $\Pi_{t}=(\mathcal{T}_{t},\Sigma_{t})$, where $\mathcal{T}_{t}$ is a binary tree and $\Sigma_{t}$ contains information about each node in $\mathcal{T}_{t}$ (such as splits). These objects are introduced in Section 1.2 and Section 1.3, in which, for simplicity, we assume that $t$ is fixed, and remove the explicit dependence on $t$.

1.2 Random tree partitions

Let $C=\prod_{j=1}^{d}[a_{j},b_{j}]\subseteq[0,1]^{d}$ be a hyper-rectangular box. A tree partition (or $k$d tree, guillotine partition) of $C$ is a pair $(\mathcal{T},\Sigma)$, where $\mathcal{T}$ is a finite ordered binary tree and $\Sigma$ is a family of splits at the interior nodes of $\mathcal{T}$.

Finite ordered binary trees.

A finite ordered binary tree $\mathcal{T}$ is represented as a finite subset of the set $\{0,1\}^{*}=\bigcup_{n\geqslant 0}\{0,1\}^{n}$ of all finite words on $\{0,1\}$. The set $\{0,1\}^{*}$ is endowed with a tree structure (and called the complete binary tree): the empty word $\epsilon$ is the root, and for any $\mathbf{v}\in\{0,1\}^{*}$, the left (resp. right) child of $\mathbf{v}$ is $\mathbf{v}0$ (resp. $\mathbf{v}1$), obtained by adding a [math] (resp. $1$) at the end of $\mathbf{v}$. We denote by $\mathcal{N}^{\circ}(\mathcal{T})=\{\mathbf{v}\in\mathcal{T}:\mathbf{v}0,\mathbf{v}1\in\mathcal{T}\}$ the set of its interior nodes and by $\mathcal{L}(\mathcal{T})=\{\mathbf{v}\in\mathcal{T}:\mathbf{v}0,\mathbf{v}1\not\in\mathcal{T}\}$ the set of its leaves, which are disjoint by definition.

Family of splits.

Each split $\sigma_{\mathbf{v}}=(j_{\mathbf{v}},s_{\mathbf{v}})$ in the family $\Sigma=(\sigma_{\mathbf{v}})_{\mathbf{v}\in\mathcal{N}^{\circ}(\mathcal{T})}$ of splits is characterized by its split dimension $j_{\mathbf{v}}\in\{1,\dots,d\}$ and its threshold $s_{\mathbf{v}}\in[0,1]$.

One can associate to $(\mathcal{T},\Sigma)$ a partition $(C_{\mathbf{v}})_{\mathbf{v}\in\mathcal{L}(\mathcal{T})}$ of $[0,1]^{d}$ as follows. For each node $\mathbf{v}\in\mathcal{T}$, its cell $C_{\mathbf{v}}$ is a hyper-rectangular region $C_{\mathbf{v}}\subseteq[0,1]^{d}$ defined recursively: the cell associated to the root $\epsilon$ of $\mathcal{T}$ is $[0,1]^{d}$, and, for each $\mathbf{v}\in\mathcal{N}^{\circ}(\mathcal{T})$, we define

[TABLE]

Then, the leaf cells $(C_{\mathbf{v}})_{\mathbf{v}\in\mathcal{L}(\mathcal{T})}$ form a partition of $[0,1]^{d}$ by construction. We consider a random partition given by the Mondrian process (Roy and Teh, 2009), following the construction of Mondrian forests (Lakshminarayanan et al., 2014).

1.3 Mondrian random partitions

Mondrian random partitions are a specific family of random tree partitions. An infinite Mondrian partition $\Pi$ of $[0,1]^{d}$ can be sampled from the infinite Mondrian process, denoted $\mathop{\mathsf{MP}}$ from now on, using the procedure $\mathtt{SampleMondrian}([0,1]^{d},\tau=0)$ described in Algorithm 1. If $C=\prod_{j=1}^{d}C^{j}$ with intervals $C^{j}=[a_{j},b_{j}]$, we denote $|C^{j}|=b_{j}-a_{j}$ and $|C|=\sum_{j=1}^{d}|C^{j}|$. We denote by $\mathsf{Exp}(\lambda)$ the exponential distribution with intensity $\lambda>0$ and by $\mathcal{U}([a,b])$ the uniform distribution on a finite interval $[a,b]$.

The call to $\mathtt{SampleMondrian}([0,1]^{d},\tau=0)$ corresponds to a call starting at the root node $\mathbf{v}=\epsilon$, since $C_{\epsilon}=[0,1]^{d}$ and the birth time of $\epsilon$ is $\tau_{\epsilon}=0$. This random partition is built by iteratively splitting cells at some random time, which depends on the linear dimension $C_{\mathbf{v}}$ of the input cell $C_{\mathbf{v}}$. The split coordinate $j_{\mathbf{v}}$ is chosen at random, with a probability of sampling $j$ which is proportional to the side length $|C_{\mathbf{v}}^{j}|/|C_{\mathbf{v}}|$ of the cell, and the split threshold is sampled uniformly in $C_{\mathbf{v}}^{j}$. The number of recursions in this procedure is infinite, the Mondrian process $\mathop{\mathsf{MP}}$ is a distribution on infinite tree partitions of $[0,1]^{d}$, see Roy and Teh (2009) and Roy (2011) for a rigorous construction.

The birth times $\tau_{\mathbf{v}}$ are not used in Algorithm 1 but will be used to define time prunings of a Mondrian partition in Section 3.2 below, a notion which is necessary to prove that AMF has adaptation capabilities to the optimal time pruning. Moreover, the birth times are used in the practical implementation of AMF described in Section 4, since it is required to build restricted Mondrian partitions, following Lakshminarayanan et al. (2014). Figure 2 below shows an illustration of a truncated Mondrian tree (where nodes with birth times larger than $\lambda$ have been removed), and its corresponding partition.

1.4 Aggregation with exponential weights and prediction functions

The prediction function of a tree in AMF is an aggregation of the predictions given by all finite subtrees of the infinite Mondrian partition $\mathop{\mathsf{MP}}$. This aggregation step is performed in a purely online fashion, using an aggregation algorithm based on exponential weights, with a branching process prior over the subtrees. This weighting scheme gives more importance to subtrees with a good predictive performance.

Node and subtree prediction.

Let us assume that the realization of an infinite Mondrian partition $\Pi=(\mathcal{T}^{\Pi},\Sigma^{\Pi})\sim\mathop{\mathsf{MP}}$ is available between steps $t-1$ and $t$ (in the sense that the $t-1$-th sample has been revealed but not the $t$-th). This partition is denoted $\Pi_{t}$, and is, by construction, independent of the observation $(x_{t},y_{t})$. We will argue in Section 2.1 that it suffices to store a finite partition $\Pi_{t}$, and show how to update it. The definition of the prediction function used in AMF requires the notion of node and subtree prediction. Given $\Pi=(\mathcal{T}^{\Pi},\Sigma^{\Pi})\sim\mathop{\mathsf{MP}}$, we define

[TABLE]

for each node $\mathbf{v}\in\mathcal{T}^{\Pi}$ (which defines a cell $C_{\mathbf{v}}\subseteq[0,1]^{d}$ following Equation (2)) and each $t\geqslant 1$, where $h:\bigcup_{t\geqslant 0}\mathcal{Y}^{t}\to\widehat{\mathcal{Y}}$ is a prediction algorithm used in each cell, with $\widehat{\mathcal{Y}}$ its prediction space and $\ell:\widehat{\mathcal{Y}}\times\mathcal{Y}\to\mathbf{R}$ a generic loss function. The prediction between steps $t-1$ and $t$ of a finite subtree $\mathcal{T}\subset\mathcal{T}^{\Pi}$ associated to some features vector $x\in[0,1]^{d}$ is defined by

[TABLE]

where $\mathbf{v}_{\mathcal{T}}(x)$ is the leaf of $\mathcal{T}$ that contains $x$. Once again, note that the prediction $\widehat{y}_{\mathcal{T},t}$ uses samples from steps $1,\ldots,t-1$ but not $(x_{t},y_{t})$. We define the cumulative loss of $\mathcal{T}$ at step $t$ as

[TABLE]

Note that the loss term $\ell(\widehat{y}_{\mathcal{T},s}(x_{s}),y_{s})$ is evaluated at the sample $(x_{s},y_{s})$, which is not used by the tree predictor $\widehat{y}_{\mathcal{T},s}$. For regression problems, we use empirical mean forecasters

[TABLE]

where $n_{\mathbf{v},t}=|\{1\leqslant s\leqslant t\;:\;x_{s}\in C_{\mathbf{v}}\}|$, and where we simply put $\widehat{y}_{\mathbf{v},t}=0$ if $\mathbf{v}$ is empty (namely, $C_{\mathbf{v}}$ contains no data point). The loss is the quadratic loss $\ell(\widehat{y},y)=(\widehat{y}-y)^{2}$ for any $y\in\mathcal{Y}$ and $\widehat{y}\in\widehat{\mathcal{Y}}$ where $\widehat{\mathcal{Y}}=\mathcal{Y}=\mathbf{R}$.

For multi-class classification, we have labels $y_{t}\in\mathcal{Y}$ where $\mathcal{Y}$ is a finite set of label modalities (such as $\mathcal{Y}=\{1,\ldots,K\}$) and predictions are in $\widehat{\mathcal{Y}}=\mathcal{P}(\mathcal{Y})$, the set of probability distributions on $\mathcal{Y}$. We use the Krichevsky-Trofimov (KT) forecaster (see Tjalkens et al., 1993) in each node $\mathbf{v}$, which predicts

[TABLE]

for any $y\in\mathcal{Y}$, where $n_{\mathbf{v},t}(y)=|\{1\leqslant s\leqslant t:x_{s}\in C_{\mathbf{v}},y_{s}=y\}|$. For an empty $\mathbf{v}$, we use the uniform distribution on $\mathcal{Y}$. We consider the logarithmic loss (also called cross-entropy or self-information loss) $\ell(\widehat{y},y)=-\log\widehat{y}(y)$, where $\widehat{y}(y)=\widehat{y}(\{y\})\in[0,1]$.

Remark 1**.**

The Krichevsky-Trofimov forecaster coincides with the Bayes predictive posterior with a prior on $\mathcal{P}(\mathcal{Y})$ equal to the Dirichlet distribution $\mathsf{Dir}(\frac{1}{2},\dots,\frac{1}{2})$,* namely the Jeffreys prior on the multinomial model $\mathcal{P}(\mathcal{Y})$.*

The prediction function of AMF.

Let $t\geqslant 1$ and $x\in[0,1]^{d}$. The prediction function $\widehat{f}_{t}$ of AMF at step $t$ is given by

[TABLE]

where the sum is over all subtrees $\mathcal{T}$ of $\mathcal{T}^{\Pi}$ and where the prior $\pi$ on subtrees is the probability distribution defined by

[TABLE]

where $|\mathcal{T}|$ is the number of nodes in $\mathcal{T}$ and $\eta>0$ is a parameter called learning rate. Note that $\pi$ is the distribution of the branching process with branching probability $1/2$ at each node of $\mathcal{T}^{\Pi}$, with exactly two children when it branches; this branching process gives finite subtrees almost surely. The learning rate $\eta$ can be optimally tuned following theoretical guarantees from Section 3, see in particular Corollaries 1 and 2. This aggregation procedure is a non-greedy way to prune trees: the weights do not depend only on the quality of one single split but rather on the performance of each subsequent split. An example of aggregated trees is provided in Figure 3.

Let us stress that computing $\widehat{f}_{t}$ from Equation (6) seems computationally infeasible in practice as tree grows, since it involves a sum over all subtrees of $\mathcal{T}^{\Pi}$. Besides, it requires to keep in memory one weight $e^{-\eta L_{t-1}(\mathcal{T})}$ for all subtrees $\mathcal{T}$, which seems prohibitive as well. Indeed, the number of subtrees of the minimal tree that separates $n$ points is exponential in the number of nodes, and hence exponential in $n$. However, it turns out that one can compute exactly and very efficiently $\widehat{f}_{t}$ using the prior choice from Equation (7) together with an adaptation of Context Tree Weighting (Willems et al., 1995; Willems, 1998; Helmbold and Schapire, 1997; Catoni, 2004). This will be detailed in Section 2 below.

1.5 Related previous works

Introduced by Breiman (2001), Random Forests (RF) is one of the algorithms of choice in many supervised learning applications. The appeal of these methods comes from their remarkable accuracy in a variety of tasks, their reasonable computational cost at training and prediction time, and their suitability in high-dimensional settings (Díaz-Uriarte and De Andres, 2006; Chen and Ishwaran, 2012).

Online Random Forests.

Most commonly used RF algorithms, such as the original random forest procedure (Breiman, 2001), extra-trees (Geurts et al., 2006), or conditional inference forest (Hothorn et al., 2010) are batch algorithms, that require the whole dataset to be available at once. Several online random forests variants have been proposed to overcome this issue and handle data that come sequentially. Utgoff (1989) was the first to extend Quinlan’s ID3 batch decision tree algorithm (see Quinlan, 1986) to an online setting. Later on, Domingos and Hulten (2000) introduce Hoeffding Trees that can be easily updated: since observations are available sequentially, a cell is split when $(i)$ enough observations have fallen into this cell, $(ii)$ the best split in the cell is statistically relevant (a generic Hoeffding inequality being used to assess the quality of the best split). Since random forests are known to exhibit better empirical performances than individual decision trees, online random forests have been proposed (see, e.g., Saffari et al., 2009; Denil et al., 2013). These procedures aggregate several trees by computing the mean of the tree predictions (regression setting) or the majority vote among trees (classification setting). The tree construction differs from one forest to another but share similarities with Hoeffding trees: a cell is to be split if $(i)$ and $(ii)$ are verified.

Mondrian Forests.

One forest of particular interest for this paper is the Mondrian Forest (Lakshminarayanan et al., 2014) based on the Mondrian process (Roy and Teh, 2009). Their construction differs from the construction described above since each new observation modifies the tree structure: instead of waiting for enough observations to fall into a cell in order to split it, the properties of the Mondrian process allow to update the Mondrian tree partition each time a sample is collected. Once a Mondrian tree is built, its prediction function uses a hierarchical prior on all subtrees and the average of predictions on all subtrees is computed with respect to this hierarchical prior using an approximation algorithm.

Context Tree Weighting.

The Context Tree Weighting algorithm has been applied to regression trees by Blanchard (1999) in the case of a fixed-design tree, in which splits are prespecified. This requires to split the dataset into two parts (using the first part to select the best splits and the second to compute the posterior distribution) and to have access to the whole dataset, since the tree structure needs to be fixed in advance.

1.6 Organization of the paper

Section 2 provides a precise construction of the AMF algorithm. A theoretical analysis of AMF is given in Section 3, where we establish regret bounds for AMF together with a minimax adaptive upper bound. Section 4 introduces a modification of AMF which is used in all the numerical experiments of the paper, together with a guarantee and a discussion on its computational complexity. Numerical experiments are provided in Section 5, in order to provide numerical insights on AMF, and to compare it with several strong baselines on many datasets. Our conclusions are provided in Section 6, while proofs are gathered in Section 7.

2 AMF: Aggregated Mondrian Forests

In an online setting, the number of sample points increases over time, allowing one to capture more details on the distribution of $y$ conditionally on $x$. This means that the complexity of the decision trees should increase as samples are revealed as well. We will therefore need to consider not just an individual, fixed tree partition $\Pi$, but a sequence $(\Pi_{t})_{t\geqslant 1}$, indexed by “time steps” $t$ corresponding to the availability time of each new sample. Furthermore, AMF uses the aggregated prediction function from Equation (6), independently within each tree $\Pi_{t}^{(1)},\ldots,\Pi_{t}^{(M)}$ from the forest, see Equation (1). When a new sample point $(x_{t},y_{t})$ becomes available, the algorithm does two things, in the following order:

• •

Partition update (Section 2.1). Using $x_{t}$, update the decision tree structure from $\Pi_{t}=(\mathcal{T}_{t},\Sigma_{t})$ to $\Pi_{t+1}=(\mathcal{T}_{t+1},\Sigma_{t+1})$, i.e. sample new splits in order to ensure that each leaf in the tree contains at most one point among $\{x_{1},\dots,x_{t}\}$. This update uses the recursive properties of Mondrian partitions;

• •

Prediction function update (Section 2.2). Using $(x_{t},y_{t})$, update the prediction functions $\widehat{y}_{\mathbf{v},t}$ and weights $w_{\mathbf{v},t}$ and $\overline{w}_{\mathbf{v},t}$ defined in Table 1, that will allow us to compute $\widehat{f}_{t}$ from Equation (6), thanks to a variant of Context Tree Weighting. These updates are local, since they are performed only along the path of nodes leading to the leaf containing $x_{t}$, and are efficient.

Both updates can be implemented on the fly in a purely sequential manner. Training over a sequence $(x_{1},y_{1}),\ldots,(x_{t},y_{t})$ means using each sample once for training, and both updates are exact and do not rely on an approximate sampling scheme. Partition and prediction updates are precisely described in Algorithm 2 below and illustrated in Figure 4. The exact procedure computing the prediction after both updates have been performed is detailed in Algorithm 3 in Section 2.3. In order to ease the reading of this technical part of the paper, we gather in Table 1 notations that are used in this Section.

2.1 Partition update

Before seeing the point $(x_{t},y_{t})$, the algorithm maintains a partition $\Pi_{t}=(\mathcal{T}_{t},\Sigma_{t})$, which corresponds to the minimal subtree of the infinite Mondrian partition $\Pi\sim\mathop{\mathsf{MP}}$ that separates all distinct sample points in $\{x_{1},\dots,x_{t-1}\}$. This corresponds to the tree obtained from the infinite tree $\Pi$ by removing all splits of “empty” cells (that do not contain any point among $\{x_{1},\dots,x_{t-1}\}$). As $x_{t}$ becomes available, this tree is updated as follows (see lines 2–11 in Algorithm 2 below):

• •

find the leaf in $\Pi_{t}$ that contains $x_{t}$; it contains at most one point among $\{x_{1},\dots,x_{t-1}\}$;

• •

if the leaf contains no point $x_{s}\neq x_{t}$, then let $\Pi_{t+1}=\Pi_{t}$. Otherwise, let $x_{s}$ be the unique point among $\{x_{1},\dots,x_{t-1}\}$ (distinct from $x_{t}$) in this cell. Splits of the cell containing $\{x_{s},x_{t}\}$ are successively sampled (following the recursive definition of the Mondrian distribution, see Section 1.3), until a split separates $x_{s}$ and $x_{t}$.

2.2 Prediction function update

The algorithm maintains weights $w_{\mathbf{v},t}$ and $\overline{w}_{\mathbf{v},t}$ and predictions $\widehat{y}_{\mathbf{v},t}$ in order to compute the aggregation over the tree structure (lines 12–18 in Algorithm 2). Namely, after round $t-1$ (after seeing sample $(x_{t-1},y_{t-1}$)), each node $\mathbf{v}\in\mathcal{T}_{t}$ has the following quantities in memory:

• •

the weight $w_{\mathbf{v},t}=\exp(-\eta L_{\mathbf{v},t-1})$, where $L_{\mathbf{v},t}:=\sum_{1\leqslant s\leqslant t\;:\;x_{s}\in C_{\mathbf{v}}}\ell(\widehat{y}_{\mathbf{v},s},y_{s})$;

• •

the averaged weight $\overline{w}_{\mathbf{v},t}=\sum_{\mathcal{T}_{\mathbf{v}}}2^{-|\mathcal{T}_{\mathbf{v}}|}\prod_{\mathbf{v}^{\prime}\in\mathcal{L}(\mathcal{T}_{\mathbf{v}})}w_{\mathbf{v}^{\prime},t}$, where the sum ranges over all subtrees $\mathcal{T}_{\mathbf{v}}$ rooted at $\mathbf{v}$;

• •

the forecast $\widehat{y}_{\mathbf{v},t}$ in node $\mathbf{v}$ at time $t$.

Now, given a new sample point $(x_{t},y_{t})$, the update is performed as follows: we find the leaf $\mathbf{v}_{t}=\mathbf{v}_{\Pi_{t+1}}(x_{t})$ containing $x_{t}$ in $\Pi_{t+1}$ (the partition has been updated with $x_{t}$ already, since the partition update is performed before the prediction function update). Then, we update the values of $w_{\mathbf{v},t},\overline{w}_{\mathbf{v},t},\widehat{y}_{\mathbf{v},t}$ for each $\mathbf{v}$ along an upwards recursion from $\mathbf{v}_{t}$ to the root, while the values of nodes outside of the path are kept unchanged:

• •

$w_{\mathbf{v},t+1}=w_{\mathbf{v},t}\exp(-\eta\ell(\widehat{y}_{\mathbf{v},t},y_{t}))$;

• •

if $\mathbf{v}=\mathbf{v}_{t}$ then $\overline{w}_{\mathbf{v},t+1}=w_{\mathbf{v},t+1}$, otherwise

[TABLE]

• •

$\widehat{y}_{\mathbf{v},t+1}=h((y_{s})_{1\leqslant s\leqslant t\;:\;x_{s}\in C_{\mathbf{v}}})$ using the prediction algorithm $h:\bigcup_{t\geqslant 0}\mathcal{Y}^{t}\to\widehat{\mathcal{Y}}$, see Section 1.4. Note that the prediction algorithms given in Equation (4) and (5) can be updated online using $y_{t}$ only and do not require to look back at the sequence $y_{1},\ldots,y_{t-1}$.

The partition update and prediction function update correspond to the $\mathtt{AmfUpdate}(x,y)$ procedure described in Algorithm 2 below.

Training AMF over a sequence $(x_{1},y_{1}),\ldots,(x_{t},y_{t})$ means using successive calls to $\mathtt{AmfUpdate}(x_{1},y_{1}),\ldots,\mathtt{AmfUpdate}(x_{t},y_{t})$. The procedure $\mathtt{AmfUpdate}$ $(x,y)$ maintains in memory the current state of the Mondrian partition $\Pi=(\mathcal{T},\Sigma)$. The tree $\mathcal{T}$ contains the parent and children relations between all nodes $\mathbf{v}\in\mathcal{T}$, while each $\sigma_{\mathbf{v}}\in\Sigma$ can contain

[TABLE]

namely the split coordinate $j_{\mathbf{v}}\in\{1,\ldots,d\}$ and split threshold $s_{\mathbf{v}}\in[0,1]$ (only if $\mathbf{v}\in\mathcal{N}^{\circ}(\mathcal{T})$), the prediction function $\widehat{y}_{\mathbf{v}}\in\widehat{\mathcal{Y}}$, aggregation weights $w_{\mathbf{v}},\overline{w}_{\mathbf{v}}\in(0,+\infty)$ and a vector $x_{\mathbf{v}}\in[0,1]^{d}$ if $\mathbf{v}\in\mathcal{L}(\mathcal{T})$. An illustration of Algorithm 2 is given in Figure 4 below.

2.3 Prediction

At any point in time, one can ask AMF to perform prediction for an arbitrary features vector $x\in[0,1]^{d}$. Let us assume that AMF did already $t$ training steps on the $M$ trees it contains and let us recall that the prediction produced by AMF is the average of their predictions, see Equation (1), where the prediction $\widehat{f}_{t}(x,\Pi_{t}^{(m)})$ of each decision tree $m=1,\ldots,M$ is computed in parallel following Equation (6).

The prediction of a decision tree is performed through a call to the procedure $\mathtt{AmfPredict}(x)$ described in Algorithm 3 below. First, we perform a temporary partition update of $\Pi$ using $x$, following Lines 2–10 of Algorithm 2, so that we find or create a new leaf node $\mathbf{v}(x)$ such that $x\in C_{\mathbf{v}(x)}$. Let us stress that this update of $\Pi$ using $x$ is discarded once the prediction for $x$ is produced, so that the decision function of AMF does not change after producing predictions. The prediction is then computed recursively, along an upwards recursion going from $\mathbf{v}(x)$ to the root $\epsilon$, in the following way:

• •

if $\mathbf{v}=\mathbf{v}(x)$ we set $\widetilde{y}_{\mathbf{v}}=\widehat{y}_{\mathbf{v}}$;

• •

if $\mathbf{v}\neq\mathbf{v}(x)$ (it is an interior node such that $x\in C_{\mathbf{v}}$), then assuming that $\mathbf{v}a$ ($a\in\{0,1\}$) is the child of $\mathbf{v}$ such that $x\in C_{\mathbf{v}a}$, we set

[TABLE]

The prediction $\widehat{f}_{t}(x)$ of the tree is given by $\widetilde{y}_{\epsilon}$, which is the last value obtained in this recursion. Let us recall that this computes the aggregation with exponential weights of all the decision functions produced by all the prunings of the current Mondrian tree, as described in Equation (6) and stated in Proposition 1 above. The prediction procedure is summarized in Algorithm 3 below.

2.4 AMF is efficient and exact

As explained above, the aggregated predictions of all subtrees weighted by the prior $\pi$ from Equation (6) can be computed exactly using Algorithm 3.

Proposition 1**.**

Let $t\geqslant 1$ and $x\in[0,1]^{d}$. The value $\widehat{f}_{t}(x)$ from Equation (6) can be computed exactly via the $\mathtt{AmfPredict}$ procedure (see Algorithms 2 and 3).

The proof of Proposition 1 is given in Section 7. This prior choice enables to bypass the need to maintain one weight per subtree, and leads to the “collapsed” implementation described in Algorithms 2 and 3 that only requires to maintain one weight per node (which is exponentially smaller). Note that this algorithm is exact, in the sense that it does not require any approximation scheme. Moreover, this online algorithm corresponds to its batch counterpart, in the sense that there is no loss of information coming from the online (or streaming) setting versus the batch setting (where the whole dataset is available at once).

The proof of Proposition 1 relies on some standard identities that enable to efficiently compute sums of products over tree structures in a recursive fashion (from Helmbold and Schapire, 1997), recalled in Lemma 3 in Section 7. Such identities are at the core of the Context Tree Weighting algorithm (CTW), which our online algorithm implements (albeit over an evolving tree structure), and which constitutes an efficient way to perform Bayesian mixtures of contextual tree models under a branching process prior. The CTW algorithm, based on a sum-product factorization, is a state-of-the art algorithm used in lossless coding and compression. We use a variant of the Tree Expert algorithm (Helmbold and Schapire, 1997; Cesa-Bianchi and Lugosi, 2006), which is closely linked to CTW (Willems et al., 1995; Willems, 1998; Catoni, 2004). We note that several extensions of CTW have been proposed in the framework of compression, to allow for bigger classes of models Veness et al. (2012) and leverage on the presence of irrelevant variables Bellemare et al. (2014) just to name but a few.

Remark 2**.**

The complexity of $\mathtt{AmfUpdate}(x,y)$ is twice the depth of the tree at the moment it is called,* since it requires to follow a downwards path to a leaf*,* and to go back upwards to the root. As explained in Proposition 2 from Section 4 below*,* the depth of the Mondrian tree used in AMF is $\Theta(\log n)$ in expectation at step $n$ of training, which leads to a complexity $\Theta(\log n)$ both for Algorithms 2 and 3, where $\Theta(1)$ corresponds to the update complexity of a single node*,* while the original MF algorithm uses an update with complexity that is linear in the number of leaves in the tree (which is typically exponentially larger). These complexities are summarized in Table 2.*

3 Theoretical guarantees

In addition to being efficiently implementable in a streaming fashion, AMF is amenable to a thorough end-to-end theoretical analysis. This relies on two main ingredients: $(i)$ a precise control of the geometric properties of the Mondrian partitions and $(ii)$ a regret analysis of the aggregation procedure (exponentially weighted aggregation of all finite prunings of the infinite Mondrian) which in turn yields excess risk bounds and adaptive minimax rates. The guarantees provided below hold for a single tree in the Forest, but hold also for the average of several trees (used in by the forest) provided that the loss is convex.

3.1 Related works on theoretical guarantees for Random Forests

The consistency of stylized RF algorithms was first established by Biau et al. (2008), and later obtained for more sophisticated variants in Denil et al. (2013); Scornet et al. (2015). Note that consistency results do not provide rates of convergence, and hence only offer limited guidance on how to properly tune the parameters of the algorithm. Starting with Biau (2012); Genuer (2012), some recent work has thus sought to quantify the speed of convergence of some stylized variants of RF. Minimax optimal nonparametric rates were first obtained by Arlot and Genuer (2014) in dimension $1$ for the Purely Uniformly Random Forests (PURF) algorithm, in conjunction with suboptimal rates in arbitrary dimension (the number of features exceeds $1$).

Several recent works (Wager and Walther, 2015; Duroux and Scornet, 2018) also established rates of convergence for variants of RF that essentially amount to some form of Median Forests, where each node contains at least a fixed fraction of observations of its parent. While valid in arbitrary dimension, the established rates are suboptimal. More recently, adaptive minimax optimal rates were obtained by Mourtada et al. (2018) in arbitrary dimension for the batch Mondrian Forests algorithm. Our proposed online algorithm, AMF, also achieves minimax rates in an adaptive fashion, namely without knowing the smoothness of the regression function.

As noted by Rockova and van der Pas (2017), the theoretical study of Bayesian methods on trees (Chipman et al., 1998; Denison et al., 1998) or sum of trees (Chipman et al., 2010) is less developed. Rockova and van der Pas (2017) analyzes some variant of Bayesian regression trees and sum of trees; they obtain near minimax optimal posterior concentration rates. Likewise, Linero and Yang (2018) analyze Bayesian sums of soft decision trees models, and establish minimax rates of posterior concentration for the resulting SBART procedure. While these frameworks differ from ours (herein results are posterior concentration rates as opposed to regret bounds and excess risk bounds, and the design is fixed), their approach differs from ours primarily in the chosen trade-off between computational complexity and adaptivity of the method: these procedures involve approximate posterior sampling over large functional spaces through MCMC methods, and it is unclear whether the considered priors allow for reasonably efficient posterior computations. In particular, the prior used in Rockova and van der Pas (2017) is taken over all subsets of variables, which is exponentially large in the number of features.

3.2 Regret bounds

For now, the sequence $(x_{1},y_{1}),\dots,(x_{n},y_{n})\in[0,1]^{d}\times\mathcal{Y}$ is arbitrary, and is in particular not required to be i.i.d. Let us recall that at step $t$, we have a realization $\Pi_{t}=(\mathcal{T}_{t},\Sigma_{t})$ of a finite Mondrian tree, which is the minimal subtree of the infinite Mondrian partition $\Pi=(\mathcal{T}^{\Pi},\Sigma^{\Pi})$ that separates all distinct sample points in $\{x_{1},\dots,x_{t}\}$. Let us recall also that $\widehat{y}_{\mathcal{T},t}:[0,1]^{d}\to\widehat{\mathcal{Y}}$ are the tree forecasters from Section 1.4, where $\mathcal{T}$ is some subtree of $\mathcal{T}^{\Pi}$. We need the following

Definition 1**.**

Let $\eta>0$. A loss function $\ell:\widehat{\mathcal{Y}}\times\mathcal{Y}\to\mathbf{R}$ is said to be $\eta$-exp-concave if the function $\exp(-\eta\,\ell(\cdot,y)):\widehat{\mathcal{Y}}\to\mathbf{R}$ is concave for each $y\in\mathcal{Y}$.

The following loss functions are $\eta$-exp-concave:

• •

The logarithmic loss $\ell(\widehat{y},y)=-\log\widehat{y}(y)$, with $\mathcal{Y}$ a finite set and $\widehat{\mathcal{Y}}=\mathcal{P}(\mathcal{Y})$, with $\eta=1$;

• •

The quadratic loss $\ell(\widehat{y},y)=(\widehat{y}-y)^{2}$ on $\mathcal{Y}=\widehat{\mathcal{Y}}=[-B,B]\subset\mathbf{R}$, with $\eta={1}/(8B^{2})$.

We start with Lemma 1, which states that the prediction function used in AMF (see Equation (6)) satisfies a regret bound where the regret is computed with respect to any pruning $\mathcal{T}$ of $\mathcal{T}^{\Pi}$.

Lemma 1**.**

Consider a $\eta$-exp-concave loss function $\ell$. Fix a realization $\Pi=(\mathcal{T}^{\Pi},\Sigma^{\Pi})\sim\mathop{\mathsf{MP}}$ and let $\mathcal{T}\subset\mathcal{T}^{\Pi}$ be a finite subtree. For every sequence $(x_{1},y_{1}),\dots,(x_{n},y_{n})$, the prediction functions $\widehat{f}_{1},\dots,\widehat{f}_{n}$ based on $\Pi$ and computed by AMF satisfy

[TABLE]

where we recall that $|\mathcal{T}|$ is the number of nodes in $\mathcal{T}$.

Lemma 1 is a direct consequence of a standard regret bound for the exponential weights algorithm (see Lemma 4 from Section 7), together with the fact that the Context Tree Weighting algorithm performed in Algorithms 2 and 3 computes it exactly, as stated in Proposition 1. By combining Lemma 1 with regret bounds for the online algorithms used in each node, both for the logarithmic loss and the quadratic loss, we obtain the following regret bounds with respect to any pruning $\mathcal{T}$ of $\mathcal{T}^{\Pi}$.

Corollary 1** (Classification).**

Fix $\Pi=(\mathcal{T}^{\Pi},\Sigma^{\Pi})$ as in Lemma 1 and consider the classification setting described in Section 1.4. For any finite subtree $\mathcal{T}$ of $\mathcal{T}^{\Pi}$ and every sequence $(x_{1},y_{1}),\dots,(x_{n},y_{n})$, the prediction functions $\widehat{f}_{1},\dots,\widehat{f}_{n}$ based on $\Pi$ computed by AMF with $\eta=1$ satisfy

[TABLE]

for any function $g_{\mathcal{T}}:[0,1]^{d}\to\mathcal{P}(\mathcal{Y})$ which is constant on the leaves of $\mathcal{T}$.

Corollary 2** (Regression).**

Fix $\Pi=(\mathcal{T}^{\Pi},\Sigma^{\Pi})$ as in Lemma 1 and consider the regression setting described in Section 1.4 with $\mathcal{Y}=[-B,B]$. For every finite subtree $\mathcal{T}$ of $\mathcal{T}^{\Pi}$ and every sequence $(x_{1},y_{1}),\dots,(x_{n},y_{n})$, the prediction functions $\widehat{f}_{1},\dots,\widehat{f}_{n}$ based on $\Pi$ computed by AMF with $\eta=1/(8B^{2})$ satisfy

[TABLE]

for any function $g_{\mathcal{T}}:[0,1]^{d}\to\mathcal{Y}$ which is constant on the leaves of $\mathcal{T}$.

The proofs of Corollaries 1 and 2 are given in Section 7, and rely in particular on Lemmas 5 and 6 that provide regret bounds for the online predictors $\widehat{y}_{\mathbf{v},t}$ considered in the nodes. Corollaries 1 and 2 that control the regret with respect to any pruning of $\mathcal{T}^{\Pi}$ imply in particular regret bounds with respect to any time pruning of $\mathop{\mathsf{MP}}$.

Definition 2** (Time pruning).**

For $\lambda>0$, the time pruning $\Pi_{\lambda}$ of $\Pi$ at time $\lambda$ is obtained by removing any node $\mathbf{v}$ whose creation time $\tau_{\mathbf{v}}$ satisfies $\tau_{\mathbf{v}}>\lambda$. We denote by $\mathop{\mathsf{MP}}(\lambda)$ the distribution of the tree partition $\Pi_{\lambda}$ of $[0,1]^{d}$.

The parameter $\lambda$ corresponds to a complexity parameter, allowing to choose a subtree of $\mathcal{T}^{\Pi}$ where all leaves have a creation time not larger than $\lambda$. We obtain the following regret bound for the regression setting (a similar statement holds for the classification setting), where the regret is with respect to any time pruning $\Pi_{\lambda}$ of $\Pi$.

Corollary 3**.**

Consider the same regression setting as in Corollary 2. Then, AMF with $\eta=1/(8B^{2})$ satisfies

[TABLE]

where the expectations on both sides are over the random sampling of the partition $\Pi_{\lambda}\sim\mathop{\mathsf{MP}}(\lambda)$, and the infimum is taken over all functions $g:[0,1]^{d}\to\mathbf{R}$ that are constant on the cells of $\Pi_{\lambda}$.

Corollary 3 controls the regret of AMF with respect to a time pruned Mondrian partition $\Pi_{\lambda}\sim\mathop{\mathsf{MP}}(\lambda)$ for any $\lambda>0$. This result is one of the main ingredients allowing to prove that AMF is able to adapt to the unknown smoothness of the regression function, as stated in Theorem 2 below. The proof of Corollary 3 is given in Section 7, and mostly relies on a previous result from Mourtada et al. (2018) which proves that $\mathbb{E}[|\mathcal{L}(\Pi_{\lambda})|]=(1+\lambda)^{d}$ whenever $\Pi_{\lambda}\sim\mathop{\mathsf{MP}}(\lambda)$, where $|\mathcal{L}(\Pi_{\lambda})|$ stands for the number of leaves in the partition $\Pi_{\lambda}$. Let us pause for a minute and discuss the choice of the prior used in AMF, compared to what is done in literature with Bayesian approaches for instance.

Prior choice.

The use of a branching process prior on prunings of large trees is common in literature on Bayesian regression trees. Indeed, Chipman et al. (1998) choose a branching process prior on subtrees, with a splitting probability of each node $\mathbf{v}$ of the form

[TABLE]

for some $\alpha\in(0,1)$ and $\beta\geqslant 0$, where $d_{\mathbf{v}}$ is the depth of note $\mathbf{v}$. Note that the locations of the splits themselves are also parameters of the Bayesian model, which enables more flexible estimation, but prevents efficient closed-form computations. The same prior on subtrees is used in the BART algorithm (Chipman et al., 2010), which considers sums of trees. We note that several values are proposed for the parameters $(\alpha,\beta)$, although there does not appear to be any definitive choice or criterion (Chipman et al. 1998 considers several examples with $\beta\in[\frac{1}{2},2]$, while Chipman et al. 2010 suggest $(\alpha,\beta)=(0.95,2)$ for BART). The prior $\pi$ considered in this paper (see Equation (7)) has a splitting probability $1/2$ for each node, so that $(\alpha,\beta)=(1/2,0)$. One appeal of the regret bounds stated above is that it offers guidance on the choice of parameters. Indeed, it follows as a by-product of our analysis that the regret of AMF (with any prior $\pi$) with respect to a subtree $\mathcal{T}$ is $O(\log\pi(\mathcal{T})^{-1})$. This suggests to choose $\pi$ in AMF as flat as possible, namely $(\alpha,\beta)=(1/2,0)$.

3.3 Adaptive minimax rates through online to batch conversion

In this Section, we show how to turn the algorithm described in Section 2 into a supervised learning algorithm with generalization guarantees that entail as a by-product adaptive minimax rates for nonparametric estimation. Namely, this section is concerned with bounds on the risk (expected prediction error on unseen data) rather than the regret of the sequence of prediction functions that was studied in Section 3.2. Therefore, we assume in this Section that the sequence $(x_{1},y_{1}),(x_{2},y_{2}),\dots$ consists of i.i.d. random variables in $[0,1]^{d}\times\mathcal{Y}$, such that each $(x_{t},y_{t})$ that comes sequentially is distributed as some generic pair $(x,y)$. The quality of a prediction function $g:[0,1]^{d}\to\mathcal{Y}$ is measured by its risk defined as

[TABLE]

Online to batch conversion.

Our supervised learning algorithm remains online (it does not require the knowledge of a fixed number of points $n$ in advance). It is also virtually parameter-free, the only parameter being the learning rate $\eta$ (set to $1$ for the log-loss). In order to obtain a supervised learning algorithm with provable guarantees, we use online to batch conversion from Cesa-Bianchi et al. (2004), which turns any regret bound for an online algorithm into an excess risk bound for the average or a randomization of the past values of the online algorithm. As explained below, it enables to obtain fast rates for the excess risk, provided that the online procedure admits appropriate regret guarantees.

Lemma 2** (Online to batch conversion).**

Assume that the loss function $\ell:\widehat{\mathcal{Y}}\times\mathcal{Y}\to\mathbf{R}^{+}$ is measurable, with $\widehat{\mathcal{Y}}$ a measurable space, and let $\mathscr{G}$ be a class of measurable functions $[0,1]^{d}\rightarrow\widehat{\mathcal{Y}}$. Given $f_{1},\dots,f_{n}$ where $f_{t}:([0,1]^{d}\times\mathcal{Y})^{t-1}\to\widehat{\mathcal{Y}}^{[0,1]^{d}}$,* we denote $\widehat{f}_{t}=f_{t}((x_{1},y_{1}),$ $\dots,(x_{t-1},y_{t-1}))$. Let $\widetilde{f}_{n}=\widehat{f}_{I_{n}}$ with $I_{n}$ a random variable uniformly distributed on $\{1,\dots,n\}$. Then, we have*

[TABLE]

which entails that the expected excess risk of $\widetilde{f}_{n}$ with respect to any $g\in\mathscr{G}$ is equal to the expected per-round regret of $\widehat{f}_{1},\dots,\widehat{f}_{n}$ with respect to $g$.

Although this result is well-known (Cesa-Bianchi et al., 2004), we provide for completeness a proof of this specific formulation in Section 7. In our case, $\mathscr{G}$ will be the (random) family of functions that are constant on the leaves of some pruning of an infinite Mondrian partition $\Pi$, and $\widehat{f}_{1},\dots,\widehat{f}_{n}$ will be the sequence of prediction functions of AMF. Note that, when conditioning on $\Pi$ which is used to define both the class $\mathscr{G}$ and the algorithm, both $\mathscr{G}$ and the maps $f_{1},\dots,f_{n}$ become deterministic, so that we can apply Lemma 2 conditionally on $\Pi$. In what follows, we denote by $\widetilde{f}_{n}$ the outcome of online to batch conversion applied to our online procedure.

Oracle inequality and minimax rates.

Let us show now that $\widetilde{f}_{n}$ achieves adaptive minimax rates under nonparametric assumptions, which complements and improves previous results (Mourtada et al., 2017, 2018). Indeed, AMF addresses the practical issue of optimally tuning the complexity parameter $\lambda$ of Mondrian trees, while remaining a very efficient online procedure. As the next result shows, the procedure $\widetilde{f}_{n}$, which is virtually parameter-free, performs at least almost as well as the Mondrian tree with the best $\lambda$ chosen with hindsight. For the sake of conciseness, Theorems 1 and 2 are stated only in the regression setting, although a similar result holds for the log-loss.

Theorem 1**.**

Consider the same setting as in Corollary 2,* the only difference being the fact that the sequence $(x_{1},y_{1}),\ldots,(x_{n},y_{n})$ is i.i.d. and consider the online to batch conversion $\widetilde{f}_{n}$ from Lemma 2 applied to AMF. For every $\lambda>0$ and every function $g_{\lambda}$ which is constant on the cells of a random partition $\Pi_{\lambda}\sim\mathop{\mathsf{MP}}(\lambda)$, we have*

[TABLE]

The proof of Theorem 1 is given in Section 7. It provides an oracle bound which is distribution-free, since it requires no assumption on the joint distribution of $(x,y)$ apart from $\mathcal{Y}=[-B,B]$. Combined with previous results on Mondrian partitions (Mourtada et al., 2018), which enable to control the approximation properties of Mondrian trees, Theorem 1 implies that $\widetilde{f}_{n}$ is adaptive with respect to the smoothness of the regression function, as shown in Theorem 2.

Theorem 2**.**

Consider the same setting as in Theorem 1 and assume that the regression function $f^{*}(\cdot)=\mathbb{E}[y|x=\cdot]$ is $\beta$-Hölder with $\beta\in(0,1]$ unknown. Then,* we have*

[TABLE]

which is (up to the $\log n$ term) the minimax optimal rate of estimation over the class of $\beta$-Hölder functions.

The proof of Theorem 2 is given in Section 7. Theorem 2 states that the online to batch conversion $\widetilde{f}_{n}$ of AMF is adaptive to the unknown Hölder smoothness $\beta\in(0,1]$ of the regression function since it achieves, up to the $\log n$ term, the minimax rate $n^{-2\beta/(d+2\beta)}$, see Stone (1982). It would be theoretically possible to modify the procedure in order to ensure adaptivity to higher regularities (say, up to some order $\bar{\beta}\in\mathbf{N}\setminus\{0\}$), by replacing the constant estimates inside each node by polynomials (of order $\bar{\beta}-1$). However, this would lead to a numerically involved procedure, that is beyond the scope of the paper. In addition, it is known that averaging can reduce the bias of individual randomized tree estimators for twice differentiable functions, see Arlot and Genuer (2014) and Mourtada et al. (2018) for Mondrian Forests. Such results cannot be applied to AMF, since its decision function involves a more complicated process of aggregation over all subtrees.

4 Practical implementation of AMF

This section describes a modification of AMF that we use in practice, in particular for all the numerical experiments performed in the paper. Because of extra technicalities involved with the modified version described below, we are not able to provide theoretical guarantees similar to what is done in Section 3. Indeed, the procedure described in this section exhibits a more intricate behaviour: new splits may be inserted above previous splits, which affects the underlying tree structure as well as the underlying prior over subtrees. This section mainly modifies the procedures described in Algorithms 2 and 3 so that splits are sampled only within the range of the features seen in each node, see Section 4.1, with motivations to do so described below. Moreover, we provide in Section 4.2 a guarantee on the average computational complexity of AMF through a control of the expected depth of the Mondrian partition.

4.1 Restriction to splits within the range of sample points

Algorithm 2 from Section 2.2 samples successive splits on the whole domain $[0,1]^{d}$. In particular, when a new features vector $x_{t}$ is available, it samples splits of the leaf $\mathbf{v}_{t}$ containing $x_{t}$ until a split successfully separates $x_{t}$ from the other point $x_{s}\neq x_{t}$ contained in $\mathbf{v}_{t}$ (unless $\mathbf{v}_{t}$ was empty). In the process, several splits outside of the box containing $x_{s}$ and $x_{t}$ can be performed. These splits are somewhat superfluous, since they induce empty leaves and delay the split that separates these two points. Removing those splits is critical to the performance of the method, in particular when the ambient dimension of the features is not small. In such cases, many splits may be needed to separate the feature points. On the other hand, only keeping those splits that are necessary to separate the sample points may yield a more adaptive partition, which can better adapt to a possible low-dimensional structure of the distribution of $x$.

We describe below a modified algorithm that samples splits in the range of the features vectors seen in each cell, exactly as in the original Mondrian Forest algorithm (Lakshminarayanan et al., 2014). In particular, each leaf will contain exactly one sample point by construction (possibly with repetition if $x_{s}=x_{t}$ for some $s\neq t$) and no empty leaves. Formally, this procedure amounts to considering the restriction of the Mondrian partition to the finite set of points $\{x_{1},\dots,x_{t}\}$ (Lakshminarayanan et al., 2014), where it is shown that such a restricted Mondrian partition can be updated efficiently in an online fashion, thanks to properties of the Mondrian process. This update exploits the creation time $\tau_{\mathbf{v}}$ of each node, as well as the range of the features vectors $R_{\mathbf{v}}$ seen inside each node (as opposed to only leaves). Moreover, this procedure can possibly split an interior node and not only a leaf. The algorithm considered here is a modification of the procedure $\mathtt{ExtendMondrianTree}(\mathcal{T},\lambda,(x_{t},y_{t}))$ described in Lakshminarayanan et al. (2014), where we use $\lambda=+\infty$ and where we perform the exponentially weighted aggregation of subtrees described in Sections 1 and 2.

We call the former partition (from Section 2.2) an unrestricted Mondrian partition, while the one described here will be referred to as a restricted Mondrian partition. The difference between the two is illustrated in Figure 5. The tree $\mathcal{T}$ contains, as before, parent and children relations between all nodes $\mathbf{v}\in\mathcal{T}$, while each $\sigma_{\mathbf{v}}\in\Sigma$ contains

[TABLE]

which differs from Equation (8) since we keep in memory the creation time $\tau_{\mathbf{v}}$ of $\mathbf{v}$, and the range

[TABLE]

of features vectors in $C_{\mathbf{v}}$ instead of $x_{\mathbf{v}}$ (a past sample point). Another advantage of the restricted Mondrian partition is that the algorithm is range-free, since it does not require to assume that all features vectors are in $[0,1]^{d}$ (we simply use as initial root cell $C_{\epsilon}=\mathbf{R}^{d}$).

Algorithms 4 and 5 below implement AMF with a restricted Mondrian partition, and are used instead of the previous Algorithm 2 in our numerical experiments. These algorithms, together with Algorithm 6 below for prediction, maintain in memory, as in Section 2, the current state of the Mondrian partition $\Pi=(\mathcal{T},\Sigma)$, which contains the tree structure $\mathcal{T}$ (containing parent/child relationships between nodes) and data $\sigma_{\mathbf{v}}\in\Sigma$ for all nodes, see Equation (18). An illustration of Algorithms 4 and 5 is provided in Figure 6. We use the notation $x_{+}=\max(x,0)$ for any $x\in\mathbf{R}$.

In algorithm 4, Line 3 initializes the tree the first time $\mathtt{AmfUpdate}$ is called, otherwise the recursive procedure $\mathtt{NodeUpdate}$ is used to update the restricted Mondrian partition, starting at the root $\epsilon$. Lines 7–14 perform the update of the aggregation weights in the same way as what we did in Section 2.2.

In Algorithm 5, Line 2 computes the range extension of $x$ with respect to $R_{\mathbf{v}}$. In particular, if $x\in R_{\mathbf{v}}$, then no split will be performed and we go directly to Line 15. Otherwise, if $x$ is outside of $R_{\mathbf{v}}$, a split of $\mathbf{v}$ is performed whenever $\tau_{\mathbf{v}}+E<\tau_{\mathbf{v}0}$ (a new node created at time $\tau_{\mathbf{v}}+E$ can be inserted before the creation time $\tau_{\mathbf{v}0}$ of the current child $\mathbf{v}0$ of $\mathbf{v}$). In this case, we sample the split coordinate $j$ proportionally to $\Delta_{j}$ (coordinates with the largest extension are more likely to be used to split $\mathbf{v}$) and we sample the split threshold uniformly at random within the corresponding extension (Line 7 or Line 9). Now, at Line 11, we move downwards the whole tree rooted at $\mathbf{v}$: any node at index $\mathbf{v}\mathbf{v}^{\prime}$ for any $\mathbf{v}^{\prime}\in\mathcal{T}_{\mathbf{v}}$ is renamed as $\mathbf{v}(1-a)\mathbf{v}^{\prime}$. For instance, if $a=0$ (Line 7, the extension is on the left of the current range), the node $\mathbf{v}0$ is renamed as $\mathbf{v}10$, the node $\mathbf{v}1$ as $\mathbf{v}11$, etc. Then, at Line 12, new nodes $\mathbf{v}0$ and $\mathbf{v}1$ are created, where $\mathbf{v}a$ is a new leaf containing $x$ and $\mathbf{v}(1-a)$ is a new node which is the root of the subtree we moved downwards at Line 11. Line 12 also initializes $\sigma_{\mathbf{v}a}$ and copies $\sigma_{\mathbf{v}}$ into $\sigma_{\mathbf{v}(1-a)}$. The process performed in Lines 11–12 therefore simply inserts two new nodes below $\mathbf{v}$ (since we just split node $\mathbf{v}$): a leaf containing $x$, and another node rooting the tree that was rooted at $\mathbf{v}$ before the split. Line 13 updates the range of $\mathbf{v}$ using $x$ and exits the procedure. If no split is performed, Line 15 updates the range of $\mathbf{v}$ using $x$ and calls $\mathtt{NodeUpdate}$ on the child of $\mathbf{v}$ containing $x$.

The prediction algorithm described in Algorithm 6 below is a modification of Algorithm 3, where we use $\mathtt{NodeUpdate}$ instead of Algorithm 2. Finally, the algorithm used in our experiments do not use the online to batch conversion from Section 3.3: it simply uses the current tree, namely the most recent updated Mondrian tree partition $\Pi_{t+1}=(\mathcal{T}_{t+1},\Sigma_{t+1})$ after calling $\mathtt{AmfUpdate}(x_{1},y_{1}),\ldots,\mathtt{AmfUpdate}(x_{t},y_{t})$, where $(x_{t},y_{t})$ is the last sample seen.

4.2 Computational complexity

The next Proposition provides a bound on the average depth of a Mondrian tree. This is of importance, since the computational complexities of $\mathtt{AmfUpdate}$ and $\mathtt{AmfPredict}$ are linear with respect to this depth, see below for a discussion.

Proposition 2**.**

Assume that $x$ has a density $p$ satisfying the following property:* there exists a constant $M>0$ such that, for every $x^{\prime},x^{\prime\prime}\in[0,1]^{d}$ which only differ by one coordinate*,**

[TABLE]

Then,* the depth $D_{n}^{\Pi}(x)$ of the leaf containing a random point $x$ in the Mondrian tree restricted to the observations $x_{1},\dots,x_{n},x$ satisfies*

[TABLE]

Assumption (19) is satisfied when $p$ is upper and lower bounded: $c\leqslant p\leqslant C$ with $M=C/c$, but this assumption is weaker: for instance, it only implies that $M^{-d}\leqslant p\leqslant M^{d}$, which is a milder property when the dimension $d$ is large. The proof of Proposition 2 is given in Section 7. Since the lower bound is also trivially $\Omega(\log n)$ (a binary tree with $n$ nodes has at least a depth $\log_{2}n$), Proposition 2 entails that $\mathbb{E}[D_{n}^{\Pi}]=\Theta(\log n)$. If the number of features is $d$, then the update complexity of a single tree is $\Theta(d\log n)$, which makes full online training time $\Theta(nd\log n)$ over a dataset of size $n$. Prediction is $\Theta(\log n)$ since it requires a downwards and upwards path on the tree (see Algorithms 3 and 6).

5 Numerical experiments

The aim of this section is two-fold. First, Section 5.1 gathers some insights about AMF based on numerical evidence obtained with simulated and real datasets, that confirm our theoretical findings. Second, it proposes in Section 5.2 a thorough comparison of AMF with several baselines on several datasets for multi-class classification.

An open source implementation of AMF (AMF with restricted Mondrian partitions described in Algorithms 4 and 6) is available in the onelearn Python package, where algorithms for multi-class classification and regression are available, respectively, in the AMFClassifier and AMFRegressor classes. The source code of onelearn is available at https://github.com/onelearn/onelearn and can be installed easily through the PyPi repository by typing pip install onelearn in a terminal. The documentation of onelearn is available at https://onelearn.readthedocs.io, which contains extra experiments and explains, among other things, how the experiments from the paper can be reproduced. The onelearn package is fully implemented in Python, but is heavily accelerated thanks to numba222http://numba.pydata.org and follows API conventions from scikit-learn, see Pedregosa et al. (2011).

5.1 Main insights about AMF

First, let us provide some key observations about AMF.

A purely online algorithm.

AMF is a purely online algorithm, as illustrated in Figure 7 on a simulated binary classification problem. Herein, we see that the decision function of AMF evolves smoothly along the learning steps, leading to a correct AUC even in the early stages. This is confirmed from a theoretical point of view in Section 3, which provides regret bounds and minimax rates, but also from a computational point of view in Table 2 from Section 2, where we show that at each step, both learning and prediction have $\Theta(\log n)$ complexity, where $n$ stands for the number of samples currently available.

AMF is adaptive.

We know from Section 3 that a tree in AMF controls its regret with respect to the best pruning of a Mondrian partition and is consequently adaptive to the unknown smoothness of the regression function.

This fact is confirmed by Figure 8, where we consider two examples of one-dimensional ($d=1$) regression problems with Gaussian noise.

In both displays, we compute the local weighted depths denoted $\mathrm{wdepth}(x)$ of each tree in the forest as

[TABLE]

where the sum is over all subtrees $\mathcal{T}$ of the considered tree, where the prior $\pi$ is given by (7), where $x\in[0,1]^{d}$ and where $\mathrm{depth}_{\mathcal{T}}(x)$ stands for the depth of each subtree $\mathcal{T}$ met along the path leading to the leaf containing $x$. Note that the aggregation weights $w(\mathcal{T})$ are the same as in the aggregated estimator from Equation (6). When the aggregation weight $w(\mathcal{T})$ of a tree $\mathcal{T}$ is large ($w(\mathcal{T})\approx 1$), it carries most of the prediction computed by (6), and $\mathrm{wdepth}(x)\approx\mathrm{depth}_{\mathcal{T}}(x)$. In such a case, by displaying $\mathrm{wdepth}(x)$ along $x\in[0,1]^{d}$, we can visualize the local complexities (measured by the weighted depth) used internally by AMF. This leads to the displays of Figure 8, where we can observe that AMF adapts to the local smoothness of the regression functions. We see that the weighted depth increases at points $x\in[0,1]$ where the signal is unsmooth. This means that AMF tends to use deeper trees at such points, with deeper leaves, containing less samples points, leading to prediction based on narrow averages. On the contrary, AMF decreases the weighted depth where the signal is smooth, leading to tree predictions with leaves containing more samples, hence wider averages.

Aggregation prevents overfitting.

Thanks to the aggregation algorithm, each tree in AMF is adaptive and leads to smooth decision functions for classification. We display in Figure 9 the decision functions of AMF, Mondrian Forest (MF), Breiman’s batch random forest (RF) and batch Extra Trees (ET) on simulated datasets for binary classification (see Section 5.2 for a precise description of the implementations used for each algorithm).

We observe that AMF produces a smooth decision function in all cases, while all the other algorithms display rather non-smooth decision functions, which suggests that the underlying probability estimates are not well-calibrated. Note also that, thanks to the aggregation algorithm, AMF obtains typically good performances with a small number of trees, as illustrated in Figure 12 from Section 5.2.

These numerical insights are confirmed in the next Section, where we propose a thorough comparison of AMF with several baselines on real datasets, and where we can observe that AMF compares favorably with respect to the considered baselines.

5.2 Comparison of AMF with several baselines on real datasets

We describe all the considered algorithms in Section 5.2.1, including both online methods and batch methods. A comparison of the average losses (assessing the online performance of algorithms) on several datasets is given in Section 5.2.3 for online methods only. Batch and online methods are compared in Section 5.2.4 and an experiment comparing the sensitivity of all methods with respect to the number of trees used is given in Section 5.2.5. All these experiments are performed for multi-class classification problems, using datasets described in Section 5.2.2.

5.2.1 Algorithms

In this Section, we describe precisely the procedures considered in our experiments for online and batch classification problems.

AMF. We use AMFClassifier from the onelearn library, with all default parameters: we use $10$ trees, a learning rate $\eta=1$, we don’t split nodes containing only a single class of labels.

Dummy. We consider a dummy baseline that only estimates the distribution of the labels (without taking into account the features) in an online manner, using OnlineDummyClassifier from onelearn. At step $t+1$, it simply computes the Krichevsky-Trofimov forecaster (see Equation (5)) $\widehat{y}_{t+1}(k)=(n_{t}(k)+1/2)/(t+K/2)$ of the classes $k=1,\ldots,K$, where $n_{t}(k)=\sum_{s=1}^{t}\mathbf{1}(y_{s}=k)$.

MF (Mondrian Forest). The Mondrian Forest algorithm from Lakshminarayanan et al. (2014, 2016) proposed in the scikit-garden library333https://github.com/scikit-garden/scikit-garden. We use MondrianForestClassifier in our experiments, with the default settings proposed with the method: $10$ trees are used, no depth restriction is used on the trees, all trees are trained using the entire dataset (no bootstrap).

SGD (Stochastic Gradient Descent). This is logistic regression trained with a single pass of stochastic gradient descent. We use SGDClassifier from the scikit-learn library444https://scikit-learn.org, see Pedregosa et al. (2011). We use a constant learning rate $0.1$ and the default choice of ridge penalization with strength $0.0001$, since it provides good results on all the datasets.

RF (Random Forests). This is Random Forest (Breiman, 2001) for classification. We use the implementation available in the scikit-learn library, namely RandomForestClassifer from the sklearn.ensemble module. This is a reference implementation, which is highly optimized and among the fastest implementations available in the open-source community. Details on this implementation are available in Louppe (2014). Note that this is a batch algorithm, that cannot be trained sequentially, which requires a large number of passes through the data to optimize some impurity criterion (default is the Gini index). We use the default parameters of the procedure, with 10 trees.

ET (Extra Trees). This is the Extra Trees algorithm (Geurts et al., 2006). Once-again, we use the implementation available in the scikit-learn library, namely ExtraTreesClassifier from the sklearn.ensemble module. As for RF, it is a reference implementation from the open source community. We use the default parameters of the procedure, with 10 trees.

5.2.2 Considered datasets

The datasets used in this paper are from the UCI Machine Learning repository, see Dua and Graff (2017) and are described in Table 3.

5.2.3 Online learning: comparison of averaged losses

We compare the curves of averaged losses over time of all the considered online algorithms. At each round $t$, we reveal a new sample $(x_{t},y_{t})$ and update all algorithms using this new sample. Then, we ask all algorithms to give a prediction $\widehat{y}_{t+1}$ of the label $y_{t+1}$ associated to $x_{t+1}$, and compute the log-loss $\ell(\widehat{y}_{t+1},y_{t+1})$ incurred by all algorithms. Along the rounds $t=1,\ldots,n-1$ when the considered data has sample size $n$, we compute the average loss $\frac{1}{t-1}\sum_{s=1}^{t-1}\ell(\widehat{y}_{s+1},y_{s+1})$. This is what is displayed in Figure 10 below, on 10 datasets for the online procedures AMF, Dummy, SGD and MF.

On most datasets, AMF exhibits the smallest average loss, and is always competitive with respect to the considered baselines. As a comparison, the performance of SGD and MF strongly varies depending on the dataset: the “robustness” of AMF comes from the aggregation algorithm it uses, which always produces a non-overfitting and smooth decision function, as illustrated in Figure 9 above, even in the early iterations. This is confirmed by the early values of the average losses observed in all displays in Figure 10, where we see that it is always the smallest compared to all the baselines.

5.2.4 Online versus Batch learning

In this Section, we consider a “batch” setting, where we hold out a test dataset (containing $30\%$ of the whole data), and we consider only binary classification problems, in which all methods are assessed using the area under the ROC curve (AUC) on the test dataset. We consider the datasets adult, bank, default, spambase and all the methods (online and batch) described in Section 5.2.1. The performances of batch methods (RF and ET) are assessed only once using the test set, since these methods are not trained in an online fashion, but rather at once. Therefore, the test AUCs of these batch methods are displayed in Figure 11 as a constant horizontal line along the iterations. Online methods (AMF, Dummy, SGD and MF) are tested every $100$ iterations: each time $100$ samples are revealed, we produce predictions on the full test dataset, and report the corresponding test AUCs in Figure 11. We observe that, as more samples are revealed, the online methods improve their test AUCs.

We observe that the batch methods RF and ET generally perform best; this ought to be expected, since their splits are optimized using training data, while those of AMF and MF are chosen on-the-fly. However, the performance of AMF is very competitive against all baselines. In particular, it performs better than MF and even improves upon ET and RF on the default_cv dataset.

5.2.5 Sensitivity to the number of trees

The aim of this Section is to exhibit another positive effect of the aggregation algorithm used in AMF. Indeed, we illustrate in Figure 12 below the fact that AMF can achieve good performances using less trees than MF, RF and ET. This comes from the fact that even a single tree in AMF can be a good classifier, since the aggregation algorithm used in it (see Section 1.4) aggregates all the prunings of the Mondrian tree. This allows to avoid overfitting, even when a single tree is used, as opposed to the other tree-based methods considered here. We consider in Figure 12 the same experimental setting as in Section 5.2.4, and compare the test AUCs obtained on four binary classification problems for an increasing number of trees in all methods. The test AUCs obtained by all algorithms with $1,2,5,10,20$ and $50$ trees are displayed in Figure 12, where the $x$-axis corresponds to the number of trees and the $y$-axis corresponds to the test AUC.

We observe that when using one or two trees, AMF performs better than all the baselines. The performance of RF strongly increases with an increasing number of trees, and ends up with the best performances with 50 trees. The performance of AMF also improves when more trees are used (averaging over several realizations of the Mondrian partition certainly helps prediction), but the aggregation algorithm makes AMF somehow less sensitive to the number of trees in the forest.

6 Conclusion

In this paper we introduced AMF, an online random forest algorithm based on a combination of Mondrian forests and an efficient implementation of an aggregation algorithm over all the prunings of the Mondrian partition. This algorithm is almost parameter-free, and has strong theoretical guarantees expressed in terms of regret with respect to the optimal time-pruning of the Mondrian partition, and in terms of adaptation with respect to the smoothness of the regression function. We illustrated on a large number of datasets the performances of AMF compared to strong baselines, where AMF appears as an interesting procedure for online learning.

A limitation of AMF, however, is that it does not perform feature selection. It would be interesting to develop an online feature selection procedure that could indicate along which coordinates the splits should be sampled in Mondrian trees, and prove that such a procedure performs dimension reduction in some sense. This is a challenging question in the context of online learning which deserves future investigations.

7 Proofs

This Section gathers the proofs of all the results of the paper, following their order of appearance, namely the proofs of Proposition 1, Lemma 1, Corollaries 1, 2 and 3, Lemma 2 and Theorems 1 and 2.

7.1 Proof of Proposition 1

Consider a realization $\Pi=(\mathcal{T}^{\Pi},\Sigma^{\Pi})\sim\mathop{\mathsf{MP}}$ of the infinite Mondrian partition, and assume that we are at step $t\geqslant 1$, namely we observed $(x_{1},y_{1}),\ldots,(x_{t-1},y_{t-1})$ and performed the updates described in Algorithm 2 on each sample. Given $x\in[0,1]^{d}$, we want to predict the label (or its distribution) using

[TABLE]

where we recall that $\pi(\mathcal{T})=2^{-|\mathcal{T}|}$ with $|\mathcal{T}|$ the number of nodes in $\mathcal{T}$ and where we recall that the sum in (20) is an infinite sum over all subtrees $\mathcal{T}$ of $\mathcal{T}^{\Pi}$.

Reduction to a finite sum.

Let $\mathbf{T}$ denote the minimal subtree of $\mathcal{T}^{\Pi}$ that separates the elements of $\{x_{1},\dots,x_{t-1},x\}$ (if $x=x_{t}$ then $\mathbf{T}=\mathcal{T}_{t+1}$). Also, for every finite tree $\mathcal{T}$, denote $\mathcal{T}|_{\mathbf{T}}:=\mathcal{T}\cap\mathbf{T}$. For any subtree $\mathcal{T}$ of $\mathbf{T}$, we have

[TABLE]

where $\|\mathcal{T}\|$ denotes the number of nodes of $\mathcal{T}$ which are not leaves of $\mathbf{T}$; note that $\pi_{\mathbf{T}}$ is a probability distribution on the subtrees of $\mathbf{T}$, since $\pi$ is a probability distribution on finite subtrees of $\{0,1\}^{*}$. To see why Equation (21) is true, consider the following representation of $\pi$: let $(B_{\mathbf{v}})_{\mathbf{v}\in\{0,1\}^{*}}$ be an i.i.d. family of Bernoulli random variables with parameter $1/2$; a node $\mathbf{v}$ is said to be open if $B_{\mathbf{v}}=1$, and closed otherwise. Then, denote $\mathcal{T}^{\prime}$ the subtree of $\{0,1\}^{*}$ all of whose interior nodes are open, and all of whose leaves are closed; clearly, $\mathcal{T}^{\prime}\sim\pi$. Now, $\mathcal{T}^{\prime}|_{\mathbf{T}}=\mathcal{T}$ if and only if all interior nodes of $\mathcal{T}$ are open and all leaves of $\mathcal{T}$ except leaves of $\mathbf{T}$ are closed. By independence of the $B_{\mathbf{v}}$, this happens with probability $2^{-\|\mathcal{T}\|}$.

In addition, note that if $\mathcal{T}^{\prime}$ is a finite subtree of $\{0,1\}^{*}$ and $\mathcal{T}=\mathcal{T}^{\prime}|_{\mathbf{T}}$, then $\widehat{y}_{\mathcal{T}^{\prime},t}(x)=\widehat{y}_{\mathcal{T},t}(x)$. Indeed, let $\mathbf{v}_{\mathcal{T}^{\prime}}(x)$ be the leaf of $\mathcal{T}^{\prime}$ that contains $x$; if $\mathbf{v}_{\mathcal{T}^{\prime}}(x)\in\mathbf{T}$, then $\mathbf{v}_{\mathcal{T}^{\prime}}(x)=\mathbf{v}_{\mathcal{T}}(x)$ and hence $\widehat{y}_{\mathcal{T}^{\prime},t}(x)=\widehat{y}_{\mathbf{v}_{\mathcal{T}^{\prime}}(x),t}=\widehat{y}_{\mathbf{v}_{\mathcal{T}}(x),t}=\widehat{y}_{\mathcal{T},t}(x)$; otherwise, by definition of $\mathbf{T}$, both $\mathbf{v}_{\mathcal{T}^{\prime}}(x)$ and $\mathbf{v}_{\mathcal{T}}(x)$ only contain the $x_{s}$ ($s\leqslant t-1$) such that $x_{s}=x$, so that again $\widehat{y}_{\mathbf{v}_{\mathcal{T}^{\prime}}(x),t}=\widehat{y}_{\mathbf{v}_{\mathcal{T}}(x),t}$. Similarly, this result for $x=x_{t}$ also holds for $x_{s}$, $s\leqslant t-1$, so that $L_{t-1}(\mathcal{T}^{\prime})=L_{t-1}(\mathcal{T})$. From the points above, it follows that

[TABLE]

Computation for the finite tree $\mathbf{T}$.

The expression in Equation (7.1) involves finite sums, over all subtrees of $\mathbf{T}$ (involving an exponential in the number of leaves of $\mathbf{T}$, namely $t$, terms). However, it can be computed efficiently because of the specific choice of the prior $\pi$. More precisely, we will use the following lemma (Helmbold and Schapire, 1997, Lemma 1) several times to efficiently compute sums of products. Let us recall that $\mathcal{N}(\mathbf{T})$ stands for the set of nodes of $\mathbf{T}$.

Lemma 3**.**

Let $g:\mathcal{N}(\mathbf{T})\to\mathbf{R}$ be an arbitrary function and define $G:\mathcal{N}(\mathbf{T})\to\mathbf{R}$ as

[TABLE]

where the sum is over all subtrees $\mathcal{T}_{\mathbf{v}}$ of $\mathbf{T}$ rooted at $\mathbf{v}$. Then,* $G(\mathbf{v})$ can be computed recursively as follows*:**

[TABLE]

for each node $\mathbf{v}\in\mathcal{N}(\mathbf{T})$.

Let us introduce

[TABLE]

so that Equation (20) writes

[TABLE]

where the sums hold over all subtrees $\mathcal{T}$ of $\mathbf{T}$. We will show how to efficiently compute and update the numerator and denominator in Equation (24). Note that $w_{t}(\mathcal{T})$ may be written as

[TABLE]

with $w_{\mathbf{v},t}=\exp(-\eta L_{\mathbf{v},t-1})$, where $L_{\mathbf{v},t}:=\sum_{s\leqslant t\;:\;X_{t}\in C_{\mathbf{v}}}\ell(\widehat{y}_{\mathbf{v},s},y_{s})$.

Denominator of Equation (24).

For each node $\mathbf{v}\in\mathcal{N}(\mathbf{T})$ and every $t\geqslant 1$, denote

[TABLE]

so that (25) entails

[TABLE]

Using Equation (26), the weights $\overline{w}_{\mathbf{v},t}$ can be computed recursively using Lemma 3. We denote by $\mathtt{path}(x_{t})$ the path from $\epsilon$ to $\mathbf{v}_{\mathbf{T}}(x_{t})$ (from the root to the leaf containing $x_{t}$). Note that, by definition of $w_{\mathbf{v},t}$, if $\mathbf{v}\not\in\mathtt{path}(x_{t})$ (namely $x_{t}\not\in C_{\mathbf{v}}$), we have $w_{\mathbf{v},t+1}=w_{\mathbf{v},t}$. In addition, if $\mathbf{v}\not\in\mathtt{path}(x_{t})$, so are all its descendants, so that (by induction, and using the above recursive formula) $\overline{w}_{\mathbf{v},t+1}=\overline{w}_{\mathbf{v},t}$. In other words, only the nodes of $\mathtt{path}(x_{t})$ have updated weights.

As a result, at each round $t\geqslant 1$, after seeing $(x_{t},y_{t})\in[0,1]^{d}\times\mathcal{Y}$, the weights $w_{\mathbf{v},t}$ and $\overline{w}_{\mathbf{v},t}$ are updated for $\mathbf{v}\in\mathtt{path}(x_{t})$ as follows (note that they are all initialized at $w_{\mathbf{v},1}=\overline{w}_{\mathbf{v},1}=1$):

• •

for every $\mathbf{v}\not\in\mathtt{path}(x_{t})$, $w_{\mathbf{v},t+1}=w_{\mathbf{v},t}$ and $\overline{w}_{\mathbf{v},t+1}=\overline{w}_{\mathbf{v},t}$;

• •

for every $\mathbf{v}\in\mathtt{path}(x_{t})$, $w_{\mathbf{v},t+1}=w_{\mathbf{v},t}\exp(-\eta\ell(\widehat{y}_{\mathbf{v},t},y_{t}))$;

• •

for every $\mathbf{v}\in\mathtt{path}(x_{t})$, we have

[TABLE]

The weights $w_{\mathbf{v},t},\overline{w}_{\mathbf{v},t}$ as well as the predictions $\widehat{y}_{\mathbf{v},t}$ are updated recursively in an “upwards” traversal of $\mathtt{path}(x_{t})$ in $\mathbf{T}$ (from $\mathbf{v}_{\mathbf{T}}(x_{t})$ to $\epsilon$), as indicated in Algorithm 2.

Note that when updating the structure of the tree, the weights $w_{\mathbf{v},t+1},\overline{w}_{\mathbf{v},t+1}$ and predictions $\widehat{y}_{\mathbf{v},t+1}$ for the newly created nodes in $\mathcal{T}_{t+1}\setminus\mathcal{T}_{t}$ (which are offsprings of $\mathbf{v}_{\mathcal{T}_{t}}(x_{t})$ created from the splits necessary to separate $x_{t}$ from the other point $x_{s}\in C_{\mathbf{v}_{\mathcal{T}_{t}}(x_{t})}$) can be set depending on whether these nodes contain $x_{s}$ or $x_{t}$. This does not affect the values of $w_{\mathbf{v},t}$ and $\widehat{y}_{\mathbf{v},t}$ at other nodes, but only the values of $\overline{w}_{\mathbf{v},t}$ for $\mathbf{v}\in\mathtt{path}(x_{t})$ that are computed in the upwards recursion.

Numerator of Equation (24).

The numerator of Equation (24) can be computed in the same fashion as the denominator. Let $w^{\prime}_{\mathbf{v},t}=w_{\mathbf{v},t}\widehat{y}_{\mathbf{v},t}$ if $\mathbf{v}\in\mathtt{path}(x)$, and $w^{\prime}_{\mathbf{v},t}=w_{\mathbf{v},t}$ otherwise. Additionally, let

[TABLE]

Note that we have

[TABLE]

Lemma 3 with $g(\mathbf{v})=w^{\prime}_{\mathbf{v},t}$ (so that $G(\mathbf{v})=\widehat{w}_{\mathbf{v},t}$) enables to recursively compute $\widehat{w}_{\mathbf{v},t}$ from $w^{\prime}_{\mathbf{v},t}$. First, note that $w^{\prime}_{\mathbf{v},t}=w_{\mathbf{v},t}$ for every $\mathbf{v}\not\in\mathtt{path}(x)$. Since every descendant $\mathbf{v}^{\prime}$ of $\mathbf{v}$ is also outside of $\mathtt{path}(x)$, it follows by induction that $\widehat{w}_{\mathbf{v},t}=\overline{w}_{\mathbf{v},t}$ for every $\mathbf{v}\not\in\mathtt{path}(x)$. It then remains to show how to compute $\widehat{w}_{\mathbf{v},t}$ for $\mathbf{v}\in\mathtt{path}(x)$. This is done again recursively, starting from the leaf $\mathbf{v}_{\mathbf{T}}(x)$ up to the root $\epsilon$:

[TABLE]

Finally, we define

[TABLE]

for each node $\mathbf{v}\in\mathbf{T}$. It follows from Equations (24), (27) and (28) that $\widehat{f}_{t}(x)=\widetilde{y}_{\epsilon,t}(x)$. Additionally, the recursive expression for $\overline{w}_{\mathbf{v},t}$ and $\widehat{w}_{\mathbf{v},t}$ imply that $\widetilde{y}_{\mathbf{v},t}$ can be computed recursively as well, in the upwards traversal from $\mathbf{v}_{\mathbf{T}}(x)$ to $\epsilon$: we set

[TABLE]

for $\mathbf{v}=\mathbf{v}_{\mathbf{T}}(x)$, otherwise we set

[TABLE]

where $a\in\{0,1\}$ is such that $\mathbf{v}a\in\mathtt{path}(x)$. The recursions constructed above are precisely the ones describing AMF in Algorithms 2 and 3, so that this concludes the proof of Proposition 1. $\hfill\square$

7.2 Proofs of Lemma 1, Corollaries 1, 2, 3, Lemma 2, Theorems 1, 2 and Proposition 2

We start with some well-known lemmas that are used to bound the regret: Lemma 4 controls the regret with respect to each tree forecaster, while Lemmas 5 and 6 bound the regret of each tree forecaster with respect to the optimal labeling of its leaves.

Lemma 4** (Vovk, 1998).**

Let $\mathcal{E}$ be a countable set of experts and $\pi=(\pi_{i})_{i\in\mathcal{E}}$ be a probability measure on $\mathcal{E}$. Assume that $\ell$ is $\eta$-exp-concave. For every $t\geqslant 1$,* let $y_{t}\in\mathcal{Y}$, $\widehat{y}_{i,t}\in\widehat{\mathcal{Y}}$ be the prediction of expert $i\in\mathcal{E}$ and $L_{i,t}=\sum_{s=1}^{t}\ell(\widehat{y}_{i,s},y_{s})$ be its cumulative loss. Consider the predictions defined as*

[TABLE]

Then,* irrespective of the values of $y_{t}\in\mathcal{Y}$ and $\widehat{y}_{i,t}\in\widehat{\mathcal{Y}},$ we have the following regret bound*

[TABLE]

for each $i\in\mathcal{E}$ and $n\geqslant 1$.

Lemma 5** **(Tjalkens

et al., 1993).

Let $\ell$ be the logarithmic loss on the finite set $\mathcal{Y},$ and let $y_{t}\in\mathcal{Y}$ for every $t\geqslant 1$. The Krichevsky-Trofimov (KT) forecaster,* which predicts*

[TABLE]

with $n_{t-1}(y)=|\{1\leqslant s\leqslant t-1:y_{s}=y\}|,$ satisfies the following regret bound with respect to the class $\mathcal{P}(\mathcal{Y})$ of constant experts (which always predict the same probability distribution on $\mathcal{Y}$):

[TABLE]

for each $n\geqslant 1.$

Lemma 6** **(Cesa-Bianchi and

Lugosi, 2006, p. 43).

Consider the square loss $\ell(\widehat{y},y)=(\widehat{y}-y)^{2}$ on $\mathcal{Y}=\widehat{\mathcal{Y}}=[-B,B],$ with $B>0$. For every $t\geqslant 1,$ let $y_{t}\in[-B,B]$. Consider the strategy defined by $\widehat{y}_{1}=0$, and for each $t\geqslant 2,$

[TABLE]

The regret of this strategy with respect to the class of constant experts (which always predict some $b\in[-B,B]$) is upper bounded as follows:**

[TABLE]

for each $n\geqslant 1.$

Lemma 1.

This follows from Proposition 1 and Lemma 4. ∎

Corollary 1.

Since the logarithmic loss is $1$-exp-concave, Lemma 1 implies

[TABLE]

for every subtree $\mathcal{T}$. It now remains to bound the regret of the tree forecaster $\mathcal{T}$ with respect to the optimal labeling of its leaves. By Lemma 5, for every leaf $\mathbf{v}$ of $\mathcal{T}$,

[TABLE]

where $N_{\mathbf{v},n}=|\{1\leqslant t\leqslant n:x_{t}\in C_{\mathbf{v}}\}|$ (assuming that $N_{\mathbf{v},n}\geqslant 1$). Summing the above inequality over the leaves $\mathbf{v}$ of $\mathcal{T}$ such that $N_{\mathbf{v},n}\geqslant 1$ yields

[TABLE]

where $g_{\mathcal{T}}$ is any function constant on the leaves of $\mathcal{T}$. Now, letting $L=|\{\mathbf{v}\in\mathcal{L}(\mathcal{T}):N_{\mathbf{v},n}\geqslant 1\}|\leqslant|\mathcal{L}(\mathcal{T})|=\frac{|\mathcal{T}|+1}{2}$, we have by concavity of the $\log$

[TABLE]

Plugging this in (36) and combining with Equation (35) leads to the desired bound (10). ∎

Corollary 2.

The proof proceeds similarly to that of Corollary 1, by combining Lemmas 1 and 6 and using the fact that the square loss is $\eta=1/(8B^{2})$-exp-concave on $[-B,B]$. ∎

Corollary 3.

First, we reason conditionally on the Mondrian process $\Pi$. By applying Corollary 2 to $\mathcal{T}=\Pi_{\lambda}$, we obtain, since the number of nodes of $\Pi_{\lambda}$ is $2|\mathcal{L}(\Pi_{\lambda})|-1$:

[TABLE]

where the infimum spans over all functions $g:[0,1]^{d}\to\widehat{\mathcal{Y}}$ which are constant on the cells of $\Pi_{\lambda}$. Corollary 3 follows by taking the expectation over $\Pi$ and using the fact that $\Pi_{\lambda}\sim\mathop{\mathsf{MP}}(\lambda)$ implies $\mathbb{E}[|\mathcal{L}(\Pi_{\lambda})|]=(1+\lambda)^{d}$ (Mourtada et al., 2018, Corollary 1). ∎

Lemma 2.

For every $t=1,\dots,n$, $\widehat{f}_{t}$ is $\mathscr{F}_{t-1}:=\sigma(x_{1},y_{1},\dots,x_{t-1},y_{t-1})$-measurable and since $(x_{t},y_{t})$ is independent of $\mathscr{F}_{t}$:

[TABLE]

so that, for every $g\in\mathscr{G}$,

[TABLE]

∎

Theorem 1.

This is a direct consequence of Lemma 2 and Corollary 2. ∎

Theorem 2.

Recall that the sequence $(x_{1},y_{1}),\ldots,(x_{n},y_{n})$ is i.i.d and distributed as a generic pair $(x,y)\in[0,1]^{d}\times\mathcal{Y}$. Since $f^{*}(\cdot)=\mathbb{E}[y\,|\,x=\cdot]$, we have

[TABLE]

for every function $f:[0,1]^{d}\to\mathbf{R}$. Now, let $\lambda>0$ be arbitrary. Consider the estimator $\widetilde{f}_{n}$ defined in Lemma 2, and the function $h_{\lambda}^{*}$ constant on the cells of a random partition $\Pi_{\lambda}\sim\mathop{\mathsf{MP}}(\lambda)$, with optimal predictions on the leaves given by $h^{*}_{\lambda}(u)=\mathbb{E}[y|x\in C_{\mathbf{v}}]$ for $u\in C_{\mathbf{v}}$, for every leaf $\mathbf{v}$ of $\Pi_{\lambda}$. Since $R(\widetilde{f}_{n})-R(f^{*})=R(\widetilde{f}_{n})-R(h^{*}_{\lambda})+R(h^{*}_{\lambda})-R(f^{*})$, Equation (38) gives, after taking the expectation over the random sampling of the Mondrian process $\Pi_{\lambda}$,

[TABLE]

Let $D_{\lambda}(u)$ denote the diameter of the cell $C_{\lambda}(u)$ of $u\in[0,1]^{d}$ in the Mondrian partition $\Pi_{\lambda}$ used to define $h^{*}_{\lambda}$. Assume that $f^{*}$ is $\beta$-Holder with constant $L>0$, namely $|f^{*}(u)-f^{*}(v)|\leqslant L|u-v|^{\beta}$ for any $u,v\in[0,1]^{d}$. Since $h_{\lambda}^{*}(u)=\mathbb{E}[f^{*}(x)|x\in C_{\lambda}(u)]$, we have $|h^{*}_{\lambda}(u)-f^{*}(u)|\leqslant LD_{\lambda}(u)^{\beta}$, so that

[TABLE]

Now, since $u\mapsto u^{\beta}$ is concave,

[TABLE]

where the last inequality comes from Proposition 1 in Mourtada et al. (2018). Integrating with the distribution of $x$ and using (40) gives $\mathbb{E}[(h^{*}_{\lambda}(x)-f^{*}(x))^{2}]\leqslant(4d)^{\beta}L^{2}/\lambda^{2\beta}$. In addition, Theorem 1 gives $\mathbb{E}[R(\widetilde{f}_{n})]-\mathbb{E}[R(h^{*}_{\lambda})]\leqslant 8B^{2}(1+\lambda)^{d}{(\log n)}/{n}$. Combining these inequalities with (39) leads to

[TABLE]

Note that the bound (42) holds for every value of $\lambda>0$. In particular, for $\lambda\asymp(n/\log n)^{1/(d+2\beta)}$, it yields the O\big{(}(\log(n)/n)^{2\beta/(d+2\beta)}\big{)} bound on the estimation risk of Theorem 2. ∎

Proposition 2.

First, we reason conditionally on the realization of an infinite Mondrian partition $\Pi$, by considering the randomness with respect to the sampling of the feature points $x_{1},\dots,x_{n},x$. For every depth $j\geqslant 0$, denote by $N_{j}$ the number of points among $x_{1},\dots,x_{n}$ that belong to the cell of depth $j$ of the unrestricted Mondrian partition containing $x$, and $\mathbf{v}_{j}\in\{0,1\}^{j}$ the corresponding node. In addition, for every $\mathbf{v}\in\{0,1\}^{*}$, denote $p_{\mathbf{v}}=\mathbb{P}(x\in C_{\mathbf{v}0}\,|\,x\in C_{\mathbf{v}})$. In addition, for $j\geqslant 0$, since conditionally on $C_{\mathbf{v}_{j}},N_{j}$, the points $x$ and $\{x_{i}:x_{i}\in C_{\mathbf{v}_{j}}\}$ are distributed i.i.d. following the conditional distribution of $x$ given $\{x\in C_{\mathbf{v}_{j}}\}$:

[TABLE]

Now, note that $p_{\mathbf{v}_{j}}(1-p_{\mathbf{v}_{j}})$ is determined by $C_{\mathbf{v}_{j}}$ and its split in $\Pi$, while $N_{j}$ is determined by $C_{\mathbf{v}_{j}}$ and $x_{1},\dots,x_{n}$. Now, let $U_{j}$ be the ratio of the volume of $C_{\mathbf{v}_{j}0}$ by that of $C_{\mathbf{v}_{j}}$; by construction of the Mondrian process, $U_{j}\sim\mathcal{U}([0,1])$ conditionally on $C_{\mathbf{v}_{j}}$. In addition, the assumption (19) implies (by integrating over the coordinate of the split, fixing the other coordinates) that $p_{\mathbf{v}_{j}}\geqslant M^{-1}U_{j}$, $1-p_{\mathbf{v}_{j}}\geqslant M^{-1}(1-U_{j})$. It follows that

[TABLE]

so that

[TABLE]

Using the fact that $N_{j}$ and $p_{\mathbf{v}_{j}}$ are independent conditionally on $C_{\mathbf{v}_{j}}$, it follows from (43) that

[TABLE]

By induction on $k\geqslant 0$, using the fact that by definition $N_{0}=n$,

[TABLE]

Now, note that if $N_{k}=0$, then the depth $D_{n}^{\Pi}(x)$ of $x$ in the Mondrian partition $\Pi$ restricted to $x_{1},\dots,x_{n},x$ is at most $k$. Thus, inequality (44) implies:

[TABLE]

Now, let $k_{0}$ be the smallest $k\geqslant 1$ such that $n(1-{1}/(2M))^{k_{0}}\leqslant 1$. We have

[TABLE]

so that $k_{0}-1\leqslant\log(n)/\log\{(2M)/(2M-1)\}$. Hence, inequality (45) becomes:

[TABLE]

which establishes Proposition 2. ∎