From 331d50aead52131bea21ea904c2c1d1a43c77a54 Mon Sep 17 00:00:00 2001 From: oliviermeslin Date: Wed, 13 Nov 2024 16:39:21 +0000 Subject: [PATCH] Enlever mitex --- chapters/chapter1/survol.qmd | 2 +- chapters/chapter2/bagging.qmd | 18 ++-- chapters/chapter2/boosting.qmd | 148 +++++++++++---------------------- plan_DT.qmd | 2 +- 4 files changed, 57 insertions(+), 113 deletions(-) diff --git a/chapters/chapter1/survol.qmd b/chapters/chapter1/survol.qmd index 5f4b758..9c5d873 100644 --- a/chapters/chapter1/survol.qmd +++ b/chapters/chapter1/survol.qmd @@ -28,7 +28,7 @@ Les méthodes ensemblistes sont particulièrement bien adaptées à de nombreux Les méthodes ensemblistes présentent trois avantages par rapport aux méthodes économétriques traditionnelles (régression linéaire et régression logistique): -- Elles ont une __puissance prédictive supérieure__: alors que les méthodes traditionnelles supposent fréquemment l'existence d'une relation linéaire ou log-linéaire entre $y$ et `#mi("$\mathbf{X}$")`{=typst}, les méthodes ensemblistes ne font quasiment aucune hypothèse sur la relation entre $y$ et `#mi("$\mathbf{X}$")`{=typst}, et se contentent d'approximer le mieux possible cette relation à partir des données disponibles. En particulier, les modèles ensemblistes peuvent facilement modéliser des __non-linéarités__ de la relation entre $y$ et `#mi("$\mathbf{X}$")`{=typst} et des __interactions__ entre variables explicatives _sans avoir à les spécifier explicitement_ au préalable, alors que les méthodes traditionnelles supposent fréquemment l'existence d'une relation linéaire ou log-linéaire entre $y$ et `#mi("$\mathbf{X}$")`{=typst}. +- Elles ont une __puissance prédictive supérieure__: alors que les méthodes traditionnelles supposent fréquemment l'existence d'une relation linéaire ou log-linéaire entre $y$ et $\mathbf{X}$, les méthodes ensemblistes ne font quasiment aucune hypothèse sur la relation entre $y$ et $\mathbf{X}$, et se contentent d'approximer le mieux possible cette relation à partir des données disponibles. En particulier, les modèles ensemblistes peuvent facilement modéliser des __non-linéarités__ de la relation entre $y$ et $\mathbf{X}$ et des __interactions__ entre variables explicatives _sans avoir à les spécifier explicitement_ au préalable, alors que les méthodes traditionnelles supposent fréquemment l'existence d'une relation linéaire ou log-linéaire entre $y$ et $\mathbf{X}$. - Elles nécessitent __moins de préparation des données__: elles ne requièrent pas de normalisation des variables explicatives et peuvent s'accommoder des valeurs manquantes (selon des techniques variables selon les algorithmes). diff --git a/chapters/chapter2/bagging.qmd b/chapters/chapter2/bagging.qmd index 743f8b6..911208c 100644 --- a/chapters/chapter2/bagging.qmd +++ b/chapters/chapter2/bagging.qmd @@ -35,7 +35,7 @@ Dans le contexte de la **régression**, l'objectif est de prédire une valeur nu Dans le cas de la régression, le **prédicteur agrégé** est défini comme suit : -$$\phi_A(x) = E_L[\phi(x, L)]$$ +$ \phi_A(x) = E_L[\phi(x, L)] $ où $\phi_A(x)$ représente la prédiction agrégée, $E_L[.]$ correspond à l'espérance prise sur tous les échantillons d'apprentissage possibles $L$, chacun étant tiré selon la même distribution que le jeu de données initial, et $\phi(x, L)$ correspond à la prédiction du modèle construit sur l'échantillon d'apprentissage $L$. @@ -44,12 +44,7 @@ où $\phi_A(x)$ représente la prédiction agrégée, $E_L[.]$ correspond à l'e Pour mieux comprendre comment l'agrégation améliore la performance globale d'un modèle individuel $\phi(x, L)$, revenons à la **décomposition biais-variance** de l'erreur quadratique moyenne (il s'agit de la mesure de performance classiquement considérée dans un problème de régression): -```{=typst} -#mitex(` -$E_L[\left(Y - \phi(x, L)\right)^2] = \underbrace{ -\left(E_L\left[\phi(x, L) - Y\right]\right)^2}_{\text{Biais}^2} + \underbrace{E_L[\left(\phi(x, L) - E_L[\phi(x, L)]\right)^2]}_{\text{Variance}}$ -`) -``` +$$E_L[\left(Y - \phi(x, L)\right)^2] = \underbrace{\left(E_L\left[\phi(x, L) - Y\right]\right)^2}_{\text{Biais}^2} + \underbrace{E_L[\left(\phi(x, L) - E_L[\phi(x, L)]\right)^2]}_{\text{Variance}}$$ {#eq-decompo-biais-variance} - Le **biais** est la différence entre la valeur observée $Y$ que l'on souhaite prédire et la prédiction moyenne $E_L[\phi(x, L)]$. Si le modèle est sous-ajusté, le biais sera élevé. @@ -57,7 +52,7 @@ $E_L[\left(Y - \phi(x, L)\right)^2] = \underbrace{ - La **variance** est la variabilité des prédictions ($\phi(x, L)$) autour de leur moyenne ($E_L[\phi(x, L)]$). Un modèle avec une variance élevée est très sensible aux fluctuations au sein des données d'entraînement: ses prédictions varient beaucoup lorsque les données d'entraînement se modifient. -L'équation `@decompo_biais_variance`{=typst} illustre l'__arbitrage biais-variance__ qui est omniprésent en _machine learning_: plus la complexité d'un modèle s'accroît (exemple: la profondeur d'un arbre), plus son biais sera plus faible (car ses prédictions seront de plus en plus proches des données d'entraînement), et plus sa variance sera élevée (car ses prédictions, étant très proches des données d'entraînement, auront tendance à varier fortement d'un jeu d'entraînement à l'autre). +L'équation @eq-decompo-biais-variance illustre l'__arbitrage biais-variance__ qui est omniprésent en _machine learning_: plus la complexité d'un modèle s'accroît (exemple: la profondeur d'un arbre), plus son biais sera plus faible (car ses prédictions seront de plus en plus proches des données d'entraînement), et plus sa variance sera élevée (car ses prédictions, étant très proches des données d'entraînement, auront tendance à varier fortement d'un jeu d'entraînement à l'autre). #### L'inégalité de Breiman (1996) @@ -65,11 +60,8 @@ L'équation `@decompo_biais_variance`{=typst} illustre l'__arbitrage biais-varia -```{=typst} -#mitex(` -$(Y - \phi_A(x))^2 \leq E_L[(Y - \phi(x, L))^2]$ -`) -``` + +$$ (Y - \phi_A(x))^2 \leq E_L[(Y - \phi(x, L))^2]$$ {#eq-inegalite-breiman1996} - Le terme $(Y - \phi_A(x))^2$ représente l'erreur quadratique du **prédicteur agrégé** $\phi_A(x)$; diff --git a/chapters/chapter2/boosting.qmd b/chapters/chapter2/boosting.qmd index f6efb79..0801825 100644 --- a/chapters/chapter2/boosting.qmd +++ b/chapters/chapter2/boosting.qmd @@ -13,37 +13,15 @@ S'il existe plusieurs variantes, les algorithmes de *boosting* suivent la même En termes plus techniques, les algorithmes de *boosting* partagent trois caractéristiques communes: -- Ils visent à **trouver une approximation** `#mi("$\hat{F}$")`{=typst} d'une fonction inconnue `#mi("$F*: \mathbf{x} \mapsto y$")`{=typst} à partir d'un ensemble d'entraînement `#mi("$(y_i, \mathbf{x_i})_{i= 1,\dots,n}$")`{=typst}; +- Ils visent à **trouver une approximation** $\hat{F}$")`{=typst} d'une fonction inconnue $F*: \mathbf{x} \mapsto y$ à partir d'un ensemble d'entraînement $(y_i, \mathbf{x_i})_{i= 1,\dots,n}$; - Ils supposent que la fonction $F*$ peut être approchée par une **somme pondérée de modèles simples** $f$ de paramètres $\theta$: -```{=typst} -#mitex(` -$F\left(\mathbf{x}\right) = \sum_{m=1}^M \beta_m f\left(\mathbf{x}, \mathbf{\theta}_m\right)$ -`) -``` +$$ F\left(\mathbf{x}\right) = \sum_{m=1}^M \beta_m f\left(\mathbf{x}, \mathbf{\theta}_m\right) $$ + - ils reposent sur une **modélisation additive par étapes**, qui décompose l'entraînement de ce modèle complexe en une **séquence d'entraînements de petits modèles**. Chaque étape de l'entraînement cherche le modèle simple $f$ qui améliore la puissance prédictive du modèle complet, sans modifier les modèles précédents, puis l'ajoute de façon incrémentale à ces derniers: -```{=typst} -#mitex(` -$F_m(\mathbf{x}) = F_{m-1}(\mathbf{x}) + \hat{\beta}_m f(\mathbf{x}_i, \mathbf{\hat{\theta}_m})$ -`) -``` -````{=html} - -```` +$$ F_m(\mathbf{x}) = F_{m-1}(\mathbf{x}) + \hat{\beta}_m f(\mathbf{x}_i, \mathbf{\hat{\theta}_m}) $$ + -```` +$$ \mathcal{L}(\phi) = \underbrace{\sum_i l(\hat{y}_{i}, y_{i})}_{\substack{\text{Perte sur les} \\ \text{observations}}} + \underbrace{\sum_k \Omega(f_{k})}_{\substack{\text{Fonction de} \\ \text{régularisation}}}\text{avec}\Omega(f) = \gamma T + \frac{1}{2} \lambda \sum_{t=1}^T w_j^2 $$ {#eq-fct-obj-initial} - +### Isoler le $k$-ième arbre - +La fonction-objectif introduite précédemment est très complexe et ne peut être utilisée directement pour entraîner le modèle, car il faudrait entraîner tous les arbres en même temps. On va donc reformuler donc cette fonction objectif de façon à isoler le $k$-ième arbre, qui pourra ensuite être entraîné seul, une fois que les $k-1$ arbres précédents auront été entraînés. Pour cela, on note $\hat{y}_i^{(k)}$ la prédiction à l'issue de l'étape $k$: $\hat{y}_i^{(k)} = \sum_{j=1}^t f_j(\mathbf{x}_i)$, et on $1 la fonction-objectif $\mathcal{L}^{(k)}$ au moment de l'entraînement du $k$-ième arbre: -### Isoler le $k$-ième arbre +$$ +\begin{aligned} +\mathcal{L}^{(t)} +&= \sum_{i=1}^{n} l(y_i, \hat{y}_{i}^{(t)}) + \sum_{k=1}^t\Omega(f_k) \\ +&= \sum_{i=1}^{n} l\left(y_i, \hat{y}_{i}^{(t-1)} + f_{t}(\mathbf{x}_i)\right) + \Omega(f_t) + constant +\end{aligned} +$$ -La fonction-objectif introduite précédemment est très complexe et ne peut être utilisée directement pour entraîner le modèle, car il faudrait entraîner tous les arbres en même temps. On va donc reformuler donc cette fonction objectif de façon à isoler le $k$-ième arbre, qui pourra ensuite être entraîné seul, une fois que les $k-1$ arbres précédents auront été entraînés. Pour cela, on note `#mi("$\hat{y}_i^{(k)}$")`{=typst} la prédiction à l'issue de l'étape $k$: `#mi("$\hat{y}_i^{(k)} = \sum_{j=1}^t f_j(\mathbf{x}_i)$")`{=typst}, et on écrit la fonction-objectif `#mi("\mathcal{L}^{(k)}")`{=typst} au moment de l'entraînement du $k$-ième arbre: -```{=typst} -#mitex(` -$\begin{align*} -\mathcal{L}^{(k)} -&= \sum_{i=1}^{n} l(y_i, \hat{y}_{i}^{(k)}) & + \sum_{j=1}^k\Omega(f_j) \\ -&= \sum_{i=1}^{n} l\biggl(y_i, \hat{y}_{i}^{(k-1)} + \underbrace{f_{k}(\mathbf{x}_i)}_{\text{\(k\)-ième arbre}}\biggr) & + \sum_{j=1}^{k-1}\Omega(f_j) + \Omega(f_k) -\end{align*}$ -`) -``` ### Faire apparaître le gradient Une fois isolé le $k$-ième arbre, on fait un développement limité d'ordre 2 de $l(y_i, \hat{y}_{i}^{(k-1)} + f_{k}(\mathbf{x}_i))$ au voisinage de $\hat{y}_{i}^{(k-1)}$, en considérant que la prédiction du $k$-ième arbre $f_{k}(\mathbf{x}_i)$ est -```{=typst} -#mitex(` -$\mathcal{L}^{(k)} \approx \sum_{i=1}^{n} [\underbrace{l(y_i, \hat{y}_{i}^{(k-1)})}_{\text{(A)}} + g_i f_k(\mathbf{x}_i)+ \frac{1}{2} h_i f^2_t(\mathbf{x}_i)] + \underbrace{\sum_{j=1}^{k-1}\Omega(f_j)}_{\text{(B)}} + \Omega(f_k)$ -`) -``` -```{=typst} -#mitex(` -$\text{avec}\hspace{4mm} -g_i = \frac{\partial l(y_i, \hat{y}_i^{(k-1)})}{\partial\hat{y}_i^{(k-1)}} \hspace{4mm}\text{et}\hspace{4mm} -h_i = \frac{\partial^2 l(y_i, \hat{y}_i^{(k-1)})}{\partial \left(\hat{y}_i^{(k-1)}\right)^2}$ -`) -``` -Les termes $g_i$ et $h_i$ désignent respectivement la dérivée première (le gradient) et la dérivée seconde (la hessienne) de la fonction de perte par rapport à la variable prédite. Il est important de noter que les termes (A) et (B) sont constants car les $k-1$ arbres précédents ont déjà été entraînés et ne sont pas modifiés par l'entraînement du $k$-ième arbre. On peut donc retirer ces termes pour obtenir la fonction-objectif simplifiée qui sera utilisée pour l'entraînement du $k$-ième arbre. +$$ \mathcal{L}^{(t)} \approx \sum_{i=1}^{n} [l(y_i, \hat{y}_{i}^{(t-1)}) + g_i f_t(\mathbf{x}_i)+ \frac{1}{2} h_i f^2_t(\mathbf{x}_i)] + \Omega(f_t) $$ -```{=typst} -#mitex(` -$\mathcal{\tilde{L}}^{(k)} = \sum_{i=1}^{n} [g_i f_k(\mathbf{x}_i)+ \frac{1}{2} h_i f^2_k(\mathbf{x}_i)] + \gamma T + \frac{1}{2} \lambda \sum_{j=1}^T w_j^2$ -`) -``` -Cette expression est importante car elle montre qu'on est passé d'un problème complexe où il fallait entraîner un grand nombre d'arbres simultanément (équation `@fct_obj_initial`{=typst}) à un problème beaucoup plus simple dans lequel il n'y a qu'un seul arbre à entraîner. + +avec + +$$ g_i = \frac{\partial l(y_i, \hat{y}_i^{(t-1)})}{\partial\hat{y}_i^{(t-1)}} \text{et} h_i = \frac{\partial^2 l(y_i, \hat{y}_i^{(t-1)})}{{\partial \hat{y}_i^{(t-1)}}^2} $$ + + +Les termes $g_i$ et $h_i$ désignent respectivement la dérivée première (le gradient) et la dérivée seconde (la hessienne) de la fonction de perte par rapport à la variable prédite. Il est important de noter que les termes (A) et (B) sont constants car les $k-1$ arbres précédents ont déjà été entraînés et ne sont pas modifiés par l'entraînement du $k$-ième arbre. On peut donc retirer ces termes pour obtenir la fonction-objectif simplifiée qui sera utilisée pour l'entraînement du $k$-ième arbre. + +$$ \mathcal{\tilde{L}}^{(t)} = \sum_{i=1}^{n} [g_i f_t(\mathbf{x}_i)+ \frac{1}{2} h_i f^2_t(\mathbf{x}_i)] + \gamma T + \frac{1}{2} \lambda \sum_{j=1}^T w_i^2 $$ + +Cette expression est importante car elle montre qu'on est passé d'un problème complexe où il fallait entraîner un grand nombre d'arbres simultanément (équation @eq-fct-obj-initial) à un problème beaucoup plus simple dans lequel il n'y a qu'un seul arbre à entraîner. ### Calculer les poids optimaux A partir de l'expression précédente, il est possible de faire apparaître les poids $w_j$ du $k$-ième arbre. Pour une structure d'arbre donnée ($q: \mathbb{R}^m \rightarrow \{1, \dots, T\}$), on définit $I_j = \{ i | q(\mathbf{x}_i) = j \}$ l'ensemble des observations situées sur la feuille $j$ puis on réorganise $\mathcal{\tilde{L}}^{(k)}$: -```{=typst} -#mitex(` -$\begin{align*} -\mathcal{\tilde{L}}^{(k)} - &= \sum_{j=1}^{T} \sum_{i\in I_j} \Bigl[g_i f_k(\mathbf{x}_i) &+ \frac{1}{2} h_i f^2_k(\mathbf{x}_i)\Bigr] &+ \gamma T + \frac{1}{2} \lambda \sum_{j=1}^T w_j^2 \\ - &= \sum_{j=1}^{T} \sum_{i\in I_j} \Bigl[g_i w_j &+ \frac{1}{2} h_i w_j^2\Bigl] &+ \gamma T + \frac{1}{2} \lambda \sum_{j=1}^T w_j^2 \\ - &= \sum^T_{j=1} \Bigl[w_j\Bigl(\sum_{i\in I_j} g_i\Bigr) &+ \frac{1}{2} w_j^2 \Bigl(\sum_{i\in I_j} h_i + \lambda\Bigr) \Bigr] &+ \gamma T \label{eq:dudu} -\end{align*}$ -`) -``` +$$ +\begin{align*} + \mathcal{\tilde{L}}^{(t)} =& \sum_{j=1}^{T} \sum_{i\in I_{j}} \bigg[g_i f_t(\mathbf{x}_i)\phantom{\frac{1}{2}} &+ \frac{1}{2} h_i f^2_t(\mathbf{x}_i)\bigg]&+ \gamma T + \frac{1}{2} \lambda \sum_{j=1}^T w_i^2 \\ + &= \sum_{j=1}^{T} \sum_{i\in I_{j}} \bigg[g_i w_j &+ \frac{1}{2} h_i w_j^2\bigg] &+ \gamma T + \frac{1}{2} \lambda \sum_{j=1}^T w_i^2 \\ + &= \sum^T_{j=1} \bigg[w_j\sum_{i\in I_{j}} g_i &+ \frac{1}{2} w_j^2 \sum_{i \in I_{j}} h_i + \lambda \bigg] &+ \gamma T +\end{align*} +$$ + + Dans la dernière expression, on voit que la fonction de perte simplifiée se reformule comme une combinaison quadratique des poids $w_j$, dans laquelle les dérivées première et seconde de la fonction de perte interviennent sous forme de pondérations. Tout l'enjeu de l'entraînement devient donc de trouver les poids optimaux $w_j$ qui minimiseront cette fonction de perte, compte tenu de ces opérations. -Il se trouve que le calculs de ces poids optimaux est très simple: pour une structure d'arbre donnée ($q: \mathbb{R}^m \rightarrow \{1, \dots, T\}$), le poids optimal `#mi("w_j^{\ast}")`{=typst} de la feuille $j$ est donné par l'équation: +Il se trouve que le calculs de ces poids optimaux est très simple: pour une structure d'arbre donnée ($q: \mathbb{R}^m \rightarrow \{1, \dots, T\}$), le poids optimal w_j^{\ast} de la feuille $j$ est donné par l'équation: ```{=typst} $ w_j^* = -frac(sum_(i in I_j) g_i, sum_(i in I_j) h_i + lambda) $ ``` Par conséquent, la valeur optimale de la fonction objectif pour l'arbre $q$ est égale à -```{=typst} -#mitex(` -$\mathcal{\tilde{L}}^{(k)}(q) = -\frac{1}{2} \sum_{j=1}^T \frac{\left(\sum_{i\in I_j} g_i\right)^2}{\sum_{i\in I_j} h_i+\lambda} + \gamma T$ -`) -``` +$$\mathcal{\tilde{L}}^{(t)}(q) = -\frac{1}{2} \sum_{j=1}^T \frac{\left(\sum_{i\in I_j} g_i\right)^2}{\sum_{i\in I_j} h_i+\lambda} + \gamma T$$ {#eq-fct-obj-optimal} + Cette équation est utile car elle permet de comparer simplement la qualité de deux arbres, et de déterminer lequel est le meilleur. ### Construire le $k$-ième arbre -Dans la mesure où elle permet de comparer des arbres, on pourrait penser que l'équation `@fct_obj_optimal`{=typst} est suffisante pour choisir directement le $k$-ième arbre: il suffirait d'énumérer les arbres possibles, de calculer la qualité de chacun d'entre eux, et de retenir le meilleur. Bien que cette approche soit possible théoriquement, elle est inemployable en pratique car le nombre d'arbres possibles est extrêmement élevé. Par conséquent, le $k$-ième arbre n'est pas défini en une fois, mais construit de façon gloutonne: +Dans la mesure où elle permet de comparer des arbres, on pourrait penser que l'équation @eq-fct-obj-optimal est suffisante pour choisir directement le $k$-ième arbre: il suffirait d'énumérer les arbres possibles, de calculer la qualité de chacun d'entre eux, et de retenir le meilleur. Bien que cette approche soit possible théoriquement, elle est inemployable en pratique car le nombre d'arbres possibles est extrêmement élevé. Par conséquent, le $k$-ième arbre n'est pas défini en une fois, mais construit de façon gloutonne: **REFERENCE A LA PARTIE CART/RF?** - on commence par le noeud racine et on cherche le *split* qui réduit au maximum la perte en séparant les données d'entraînement entre les deux noeuds-enfants. - pour chaque noeud enfant, on cherche le *split* qui réduit au maximum la perte en séparant en deux la population de chacun de ces noeuds. -- Cette procédure recommence jusqu'à que l'arbre ait atteint sa taille maximale (définie par une combinaison d'hyperparamètres décrits dans la partie **référence à ajouter**). +- Cette procédure recommence jusqu'à que l'arbre ait atteint sa taille maximale (définie par une combinaison d'hyperparamètres d$1s dans la partie **référence à ajouter**). ### Choisir les *splits* **Traduire split par critère de partition?** -Reste à comprendre comment le critère de partition optimal est choisi à chaque étape de la construction de l'arbre. Imaginons qu'on envisage de décomposer la feuille $I$ en deux nouvelles feuilles $I_L$ et $I_R$ (avec $I = I_L \cup I_R$), selon une condition logique reposant sur une variable et une valeur de cette variable (exemple: $x_6 > 11$). Par application de l'équation `@fct_obj_optimal`{=typst}, le gain potentiel induit par ce critère de partition est égal à: +Reste à comprendre comment le critère de partition optimal est choisi à chaque étape de la construction de l'arbre. Imaginons qu'on envisage de décomposer la feuille $I$ en deux nouvelles feuilles $I_L$ et $I_R$ (avec $I = I_L \cup I_R$), selon une condition logique reposant sur une variable et une valeur de cette variable (exemple: $x_6 > 11$). Par application de l'équation @eq-fct-obj-optimal, le gain potentiel induit par ce critère de partition est égal à: -```{=typst} -#mitex(` -$\text{Gain}_{\text{split}} = \frac{1}{2} \left[\frac{\left(\sum_{i\in I_L} g_i\right)^2}{\sum_{i\in I_L} h_i+\lambda}+\frac{\left(\sum_{i\in I_R} g_i\right)^2}{\sum_{i\in I_R} h_i+\lambda}-\frac{\left(\sum_{i\in I} g_i\right)^2}{\sum_{i\in I} h_i+\lambda}\right] - \gamma$ -`) -``` -Cette dernière équation est au coeur de la mécanique du *gradient boosting* car elle permet de comparer les critères de partition possibles. Plus précisément, l'algorithme de détermination des critère de partition (*split finding algorithm*) consiste en une double boucle sur les variables et les valeurs prises par ces variables, qui énumère un grand nombre de critères de partition et mesure le gain associé à chacun d'entre eux avec l'équation `@fct_eval_split`{=typst}. Le critère de partition retenu est simplement celui dont le gain est le plus élevé. +$$ Gain = \frac{1}{2} \left[\frac{G_L^2}{H_L+\lambda}+\frac{G_R^2}{H_R+\lambda}-\frac{(G_L+G_R)^2}{H_L+H_R+\lambda}\right] - \gamma $$ {#eq-fct-eval-split} + + + + + +Cette dernière équation est au coeur de la mécanique du *gradient boosting* car elle permet de comparer les critères de partition possibles. Plus précisément, l'algorithme de détermination des critère de partition (*split finding algorithm*) consiste en une double boucle sur les variables et les valeurs prises par ces variables, qui énumère un grand nombre de critères de partition et mesure le gain associé à chacun d'entre eux avec l'équation @eq-fct-eval-split. Le critère de partition retenu est simplement celui dont le gain est le plus élevé. L'algorithme qui détermine les critère de partition est un enjeu de performance essentiel dans le *gradient boosting*. En effet, utiliser l'algorithme le plus simple (énumérer tous les critères de partition possibles, en balayant toutes les valeurs de toutes les variables) s'avère très coûteux dès lors que les données contiennent soit un grand nombre de variables, soit des variables continues prenant un grand nombre de valeurs. C'est pourquoi les algorithmes de détermination des critère de partition ont fait l'objet de multiples améliorations et optimisations visant à réduire leur coût computationnel sans dégrader la qualité des critères de partition. diff --git a/plan_DT.qmd b/plan_DT.qmd index 6fb1ace..8067bcc 100644 --- a/plan_DT.qmd +++ b/plan_DT.qmd @@ -76,7 +76,7 @@ Présenter _decision tree_ et _regression tree_. Reprendre des éléments du cha Principes d'un arbre: - partition de l'espace des _features_; -- fonction constante par morceaux; +- fonction constante par morceaux, avec une valeur unique par feuille; - un arbre mobilise notamment les interactions entre variables. Illustration, et représentation graphique (sous forme d'arbre et de graphique).