diff --git a/Question_reunion_cadrage.md b/Question_reunion_cadrage.md index 2f416cf..192c3ab 100644 --- a/Question_reunion_cadrage.md +++ b/Question_reunion_cadrage.md @@ -4,7 +4,7 @@ ### Démarche -- Que pensez-vous l'approche à deux niveaux de lecture (aperçu intuitif, puis présentation plus formalisée)? +- Que pensez-vous l'approche à trois niveaux de lecture (aperçu intuitif, puis présentation plus formalisée, puis guide d'entraînement pratique)? - Que pensez-vous de séparer la présentation des méthodes elles-mêmes, et leur usage? ### Présentation des algorithmes diff --git a/chapters/chapter1/1-survol.qmd b/chapters/chapter1/1-survol.qmd index d5c2138..b1b0fe3 100644 --- a/chapters/chapter1/1-survol.qmd +++ b/chapters/chapter1/1-survol.qmd @@ -1,16 +1,21 @@ # Aperçu des méthodes ensemblistes -__Principe__: cette partie propose une présentation intuitive des méthodes ensemblistes à destination des lecteurs souhaitant un aperçu du fonctionnement et des cas d'utilisation de ces méthodes. Elle ne contient aucun formalisme mathématique. +__Principe__: Cette section propose une introduction intuitive aux méthodes ensemblistes. Elle s'adresse aux lecteurs qui souhaitent acquérir une compréhension générale du fonctionnement de ces techniques et identifier rapidement les situations concrètes dans lesquelles elles peuvent être utiles. L'objectif est d'en expliciter les principes-clés sans recourir au formalisme mathématique, afin de rendre le contenu accessible sans prérequis. + ## Que sont les méthodes ensemblistes? -Les approches ensemblistes désignent un ensemble d'algorithmes de _machine learning_ supervisé développés depuis le début des années 1990, c'est-à-dire des méthodes statistiques permettant de prédire une variable-cible $y$ (appelée _target_) à partir d'un ensemble de variables $\mathbf{X}$ (appelées _features_). Elles peuvent par exemple être utilisées pour prédire le salaire d'un salarié, la probabilité de réponse dans une enquête, le niveau de diplôme... Au-delà de leur diversité, ces approches se définissent par un point commun: plutôt que de tenter de construire d'emblée un unique modèle très complexe et très performant, elles visent à obtenir un modèle très performant en combinant intelligemment un ensemble de modèles peu performants, appelés "apprenants faibles" (_weak learner_ ou _base learner_). Le choix de ces modèles de base (des arbres de décision dans la plupart des cas) et la manière dont leurs prédictions sont combinées sont des facteurs déterminants pour la performance de ces approches. Le présent document se concentre sur les méthodes ensemblistes à base d'arbres de décisions qui sont parmi les plus utilisées en pratique. +Les méthodes ensemblistes sont des techniques d'apprentissage supervisé en _machine learning_ développées depuis le début des années 1990. Leur objectif est de prédire une variable-cible $y$ (appelée _target_) à partir d'un ensemble de variables prédictives $\mathbf{X}$ (appelées _features_), que ce soit pour des tâches de classification (prédire une catégorie) ou de régression (prédire une valeur numérique). Elles peuvent par exemple être utilisées pour prédire le salaire d'un salarié, la probabilité de réponse dans une enquête, le niveau de diplôme... + +Plutôt que de s'appuyer sur un seul modèle complexe, les méthodes ensemblistes se caractérisent par la combinaison des prédictions de plusieurs modèles plus simples, appelés "apprenants faibles" (_weak learner_ ou _base learner_), pour créer un modèle performant, dit "apprenant fort" (_strong learner_). + +Le choix de ces modèles de base, ainsi que la manière dont leurs prédictions sont combinées, sont des facteurs déterminants de la performance finale. Le présent document se concentre sur les méthodes à base d'**arbres de décisions**, qui sont parmi les plus utilisées en pratique. Nous allons examiner les fondements de ces méthodes, leurs avantages et inconvénients, ainsi que les algorithmes les plus populaires. + -On distingue **deux grandes familles de méthodes ensemblistes** à base d'arbres de décisions, selon qu'elles s'appuient sur des modèles de base entraînés en parallèle indépendamment les uns des autres, ou au contraire entraînés de façon séquentielle. Lorsque les modèles sont _entrainés en parallèle, indépendamment les uns des autres_, on parle de _bagging_ ou de forêt aléatoire (_random forest_). Les implémentations les plus courantes des forêts aléatoires sont les _packages_ `ranger` en `R` et `scikit-learn` en Python. Lorsque les modèles de base sont _entraînés de manière séquentielle_, chaque modèle de base visant à améliorer la prédiction proposée par l'ensemble des modèles de base précédents, on parle de _boosting_. Ce document aborde essentiellement le _gradient boosting_, qui est l'approche de _boosting_ la plus utilisée actuellement. Les implémentations les plus courantes du _gradient boosting_ sont actuellement `XGBoost`, `CatBoost` et `LightGBM`. ## Pourquoi utiliser des méthodes ensemblistes? -Les méthodes ensemblistes sont particulièrement bien adaptées à de nombreux cas d'usage de la statistique publique, pour deux raisons. D'une, elles sont conçues pour s'appliquer à des _données tabulaires_ (enregistrements en lignes, variables en colonnes), structure de données omniprésente dans la statistique publique. D'autre part, elles peuvent être mobilisées dans toutes les situations où le statisticien mobilise une régression linéaire ou une régression logistisque (imputation, repondération...). +Les méthodes ensemblistes sont particulièrement bien adaptées à de nombreux cas d'usage de la statistique publique, pour deux raisons. D'une part, elles sont conçues pour s'appliquer à des _données tabulaires_ (enregistrements en lignes, variables en colonnes), structure de données omniprésente dans la statistique publique. D'autre part, elles peuvent être mobilisées dans toutes les situations où le statisticien mobilise une régression linéaire ou une régression logistisque (imputation, repondération...). Les méthodes ensemblistes présentent trois avantages par rapport aux méthodes économétriques traditionnelles (régression linéaire et régression logistique): @@ -26,24 +31,33 @@ Elles présentent par ailleurs deux inconvénients rapport aux méthodes économ Si les approches de _deep learning_ sont sans conteste très performantes pour le traitement du langage naturel, des images et du son, leur supériorité n'est pas établie pour les applications reposant sur des données tabulaires. Les comparaisons disponibles dans la littérature concluent en effet que les méthodes ensemblistes à base d'arbres sont soit plus performantes que les approches de _deep learning_ (@grinsztajn2022tree, @shwartz2022tabular), soit font jeu égal avec elles (@mcelfresh2024neural). Ces études ont identifié trois avantages des méthodes ensemblistes: elles sont peu sensibles aux variables explicatives non pertinentes, robustes aux valeurs extrêmes des variables explicatives, et capables d'approximer des fonctions très irrégulières. De plus, dans la pratique les méthodes ensemblistes sont souvent plus rapides à entraîner et moins gourmandes en ressources informatiques, et l'optimisation des hyperparamètres s'avère souvent moins complexe (@shwartz2022tabular). ::: + + ## Comment fonctionnent les méthodes ensemblistes? -Ce paragraphe présente d'abord le modèle de base sur lesquelles sont construites les méthodes ensemblistes à base d'arbres: l'arbre de classification et de régression (@sec-cart-intuition). Elle introduit ensuite les deux grandes familles de méthodes ensemblistes couvertes dans ce document: le _bagging_ et les forêts aléatoires (@sec-rf-intuition), puis le _gradient boosting_ (@sec-gb-intuition). +Ce paragraphe présente d'abord le modèle de base sur lesquelles sont construites les méthodes ensemblistes à base d'arbres: l'arbre de classification et de régression (CART) (@sec-cart-intuition). Bien que simples et intuitifs, les arbres CART sont souvent insuffisants en termes de performance lorsqu'ils sont utilisés isolément. + +Elle introduit ensuite les **deux grandes familles de méthodes ensemblistes** décrites dans ce document: le _bagging_ et les forêts aléatoires (@sec-rf-intuition), et le _gradient boosting_ (@sec-gb-intuition). + ### Le modèle de base: l'arbre de classification et de régression {#sec-cart-intuition} #### Qu'est-ce qu'un arbre CART? -Le modèle de base des méthodes ensemblistes est le plus souvent un arbre de classification et de régression (CART, @breiman1984cart). Un arbre CART est un algorithme prédictif assez simple avec trois caractéristiques essentielles: +Le modèle de base des méthodes ensemblistes est souvent un arbre de classification et de régression (CART, @breiman1984cart). Un arbre CART est un algorithme prédictif qui traite un problème de prédiction complexe en le décomposant en une série de décisions simples, organisées de manière hiérarchique. Ces décisions permettent de segmenter progressivement les données en régions homogènes au sein desquelles il est plus simple de faire des prédictions. Il s'agit d'un outil puissant pour explorer les relations entre les variables explicatives et la variable cible, sans recourir à des hypothèses _a priori_ sur la forme de cette relation. -- L'arbre partitionne l'espace des variables explicatives $X$ en régions (appelées feuilles ou _leaves_) les plus homogènes possible, au sens d'une certaine mesure de l'hétérogénéité; -- Chaque région est définie par un ensemble de conditions, appelées régles de décision (_splitting rules_), qui portent sur les valeurs des variables explicatives (par exemple, une région peut être définie par la condition: $age > 40 \text{ et } statut = 'Cadre'$); -- Une fois l'arbre construit, les prédictions de l'arbre pour chaque région se déduisent des données d'entraînement de façon intuitive: il s'agira de la classe la plus fréquente parmi les observations situées dans cette région dans le cas d'une classification, et de la moyenne des observations situées dans cette région dans le cas d'une régression. -La structure de cet algorithme a deux conséquences importantes: +Trois caractéristiques essentielles définissent un arbre CART : + +- L'arbre partitionne l'espace des variables explicatives $X$ en régions (appelées feuilles ou _leaves_) les plus homogènes possible, au sens d'une mesure de l'hétérogénéité (par exemple, l'entropie ou l'erreur quadratique moyenne). Ces divisions vont permettre de regrouper des observations similaires pour faciliter la prédiction; +- Chaque région est définie par un ensemble de conditions, appelées régles de décision (_splitting rules_), appliquées successivement sur les variables explicatives. Par exemple, une première règle pourrait poser la question : "L'individu est-il en emploi ?", et subdiviser les données en deux groupes (oui/non). Une deuxième règle pourrait alors affiner la segmentation en posant la question : "L'individu est-il diplômé du supérieur ?". Une région spécifique serait ainsi définie par la condition combinée : "l'individu est en emploi et est diplômé du supérieur". +- Une fois l’arbre construit, chaque feuille produit une prédiction en se basant sur les données de la région correspondante. En classification, la prédiction est généralement la classe la plus fréquente parmi les observations de la région. En régression, la prédiction est souvent la moyenne des valeurs observées dans la région. + + +Deux conséquences importantes découlent de cette construction : +- L'algorithme CART ne fait **aucune hypothèse _a priori_** sur la relation entre les variables explicatives $\mathbf{X}$ et la variable cible $y$. C'est une différence majeure avec les modèles économétriques standard, tels que la régression linéaire qui suppose une relation linéaire de la forme $E(y) = \mathbf{X \beta}$. +- **L'arbre final est une fonction constante par morceaux**: la prédiction est **la même** pour toutes les observations situées dans la même région ; elle ne peut varier qu'entre régions. -- L'algorithme CART ne fait **aucune hypothèse _a priori_ sur la relation entre $X$ et $y$** et se laisse au contraire guider par les données. Par exemple, on ne suppose pas qu'il existe une relation linéaire de type $y = \mathbf{X \beta}$. -- **L'arbre final est une fonction constante par morceaux**: la prédiction est identique pour toutes les observations situées dans la même région, et ne varie que d'une région à l'autre. Illustration, et représentation graphique (sous forme d'arbre et de graphique). @@ -62,17 +76,23 @@ Troisième difficulté: à quel moment faut-il s'arrêter? => critère d'arrêt, Les arbres CART présentent plusieurs avantages: leur principe est simple, ils sont aisément interprétables et peuvent faire l'objet de représentations graphiques intuitives. Par ailleurs, la flexibilité offerte par le partitionnement récursif assure que les arbres obtenus reflètent les corrélations observées dans les données d'entraînement. -Ils souffrent néanmoins de deux limites. D'une part, les arbres CART ont souvent un __pouvoir prédictif faible__ qui en limite l'usage. D'autre part, ils sont __peu robustes et instables__: on dit qu'ils présentent une __variance élevée__. Ainsi, un léger changement dans les données (par exemple l'ajout ou la suppression de quelques observations) peut entraîner des modifications significatives dans la structure de l'arbre et dans la définition des feuilles. Les arbres CART sont notamment sensibles aux valeurs extrêmes, aux points aberrants et au bruit statistique. De plus, les prédictions des arbres CART sont sensibles à de petites fluctuations des données: celles-ci peuvent aboutir à ce qu'une partie des observations change brutalement de feuille et donc de valeur prédite. +Ils souffrent néanmoins de deux limites. D'une part, les arbres CART ont souvent un __pouvoir prédictif faible__ qui en limite l'usage. D'autre part, ils sont __peu robustes et instables__: on dit qu'ils présentent une __variance élevée__. Ainsi, un léger changement dans les données (par exemple l'ajout ou la suppression de quelques observations) peut entraîner des modifications significatives dans la structure de l'arbre et dans la définition des régions utilisées pour la prédiction (feuilles). Les arbres CART sont notamment sensibles aux valeurs extrêmes, aux points aberrants et au bruit statistique. De plus, les prédictions des arbres CART sont sensibles à de petites fluctuations des données d'échantillonnage: celles-ci peuvent aboutir à ce qu'une partie des observations change brutalement de feuille et donc de valeur prédite. -Les deux familles de méthodes ensemblistes présentées ci-dessous (_bagging_, _random forests_ et _gradient boosting_) combinent un grand nombre d'arbres de décision pour en surmonter les deux limites: il s'agit d'obtenir un modèle dont le pouvoir prédictif est élevé et dont les prédictions sont stables. La différence essentielle entre ces deux familles portent sur la façon dont les arbres sont entraînés. +Ces limites motivent l'utilisation des deux familles de méthodes ensemblistes présentées dans la suite (le _bagging_, dont la _random forests_, et le _gradient boosting_), qui s’appuient sur un grand nombre d’arbres pour accroître à la fois la précision et la stabilité des prédictions. La différence essentielle entre ces deux familles portent sur la façon dont les arbres sont entraînés. -### Le _bagging_ (Bootstrap Aggregating) et les forêts aléatoires {#sec-rf-intuition} -Le _bagging_ (Bootstrap Aggregating) et les forêts aléatoires constituent une famille de méthodes ensemblistes dont le point commun est de combiner des modèles de bases qui ont été entraînés indépendamment les uns des autres. +::: {.callout-note title="Les familles de méthodes ensemblistes"} +Les méthodes ensemblistes basées sur des arbres de décision se répartissent en **deux grandes familles**, qui se distinguent selon la manière dont les modèles de base sont construits. Lorsque les modèles de base sont entraînés en parallèle et indépendamment les uns des autres, on parle de _bagging_ (_Bootstrap Aggregating_). La _forêt aléatoire_ (_random forest_) est une variante particulièrement performante du _bagging_. Lorsque les modèles de base sont _entraînés de manière séquentielle_, chaque modèle visant à corriger les erreurs des modèles précédents, on parle de _boosting_. Ce document aborde essentiellement le _gradient boosting_, qui est l'approche de _boosting_ la plus utilisée actuellement. +::: + + +### Le _bagging_ (Bootstrap Aggregating) et les forêts aléatoires {#sec-rf-intuition} #### Le _bagging_ -Le _bagging_, ou _Bootstrap Aggregating_ (@breiman1996bagging), est une méthode ensembliste qui comporte trois étapes principales: +Le _bagging_ (Bootstrap Aggregating) est une méthode ensembliste qui repose sur l’agrégation des prédictions de plusieurs modèles individuels, entraînés indépendamment les uns des autres, pour construire un modèle global plus performant (@breiman1996bagging). Cette approche constitue également le socle des forêts aléatoires, qui en sont une version améliorée. + +Le bagging offre deux avantages majeurs par rapport aux arbres de décision CART : une meilleure capacité prédictive et une plus grande stabilité des prédictions. Cette amélioration découle de la stratégie d'entraînement. Au lieu d'entraîner un seul modèle sur l'ensemble des données, le bagging procède en trois étapes principales: - __Tirage de sous-échantillons aléatoires__: À partir du jeu de données initial, plusieurs sous-échantillons sont générés par échantillonnage aléatoire avec remise (_bootstrapping_). Chaque sous-échantillon a la même taille que le jeu de données original, mais peut contenir des observations répétées, tandis que d'autres peuvent être omises. - __Entraînement parallèle__: Un arbre est entraîné sur chaque sous-échantillon de manière indépendante. Ces arbres sont habituellement assez complexes et profonds. @@ -80,25 +100,40 @@ Le _bagging_, ou _Bootstrap Aggregating_ (@breiman1996bagging), est une méthode ![Représentation schématique d'un algorithme de _bagging_](/figures/bagging.svg){#fig-bagging} -La figure @fig-bagging propose une représentation schématique du _bagging_: tout d'abord, on tire des sous-échantillons aléatoires des données d'entraînement. Ensuite, un arbre est entraîné sur chaque sous-échantillon. Enfin, les arbres sont combinés de façon à obtenir la prédiction finale. +La @fig-bagging propose une représentation schématique du _bagging_: d'abord, des sous-échantillons sont générés aléatoires avec remise à partir du jeu de données d'entraînement. Ensuite, des arbres de décision sont entraînés indépendamment sur ces sous-échantillons. Enfin, leurs prédictions sont agrégées pour obtenir les prédictions finales. On procède généralement au vote majoritaire (la classe prédite majoritairement par les arbres) dans un problème de classification, et à la moyenne dans un problème de régression. + +L'efficacité du _bagging_ provient de la réduction de la variance qui est permise par l'agrégation des prédictions. Chaque arbre est entraîné sur un sous-échantillon légèrement différent, sujet à des fluctuations aléatoires. L'agrégation des prédictions (par moyenne ou vote majoritaire) de tous les arbres réduit la sensibilité du modèle final aux fluctuations des données d’entraînement. Le modèle final est ainsi plus robuste et plus précis que chacun des arbres pris individuellement. + - Illustration avec un cas d'usage de classification en deux dimensions. -L'intuition qui explique l'efficacité du _bagging_ est la suivante: en diversifiant les données d'entraînement par le tirage d'échantillons aléatoires, on obtient un grand nombre d'arbres différents les uns des autres et qui, pris dans leur ensemble, constituent un modèle plus prédictif et plus stable que chaque arbre pris isolément. Une image fréquemment employée pour décrire le _bagging_ est celle d'un collège de juges. Chaque juge a sa propre façon de juger, qui est imparfaite et qui dépend des cas qu'il a déjà rencontrés. Il peut donc rendre une décision complètement erronée dans telle ou telle situation, rendant son verdict instable et peu fiable. Mais si le verdict repose sur l'opinion majoritaire d'un ensemble de juges différents les uns des autres, il est probable que le jugement sera plus robuste et plus fiable. +Malgré ses avantages, le _bagging_ souffre d'une limite importante qui provient de la **corrélation entre les arbres**. En effet, malgré le tirage aléatoire des sous-échantillons, les arbres présentent souvent des structures similaires, car les règles de décision sous-jacentes restent généralement assez proches. Cette corrélation réduit l’efficacité de l’agrégation et limite les gains en performance. + +Pour réduire cette corrélation entre arbres, les forêts aléatoires introduisent une étape supplémentaire de randomisation. Leur supériorité prédictive explique pourquoi le _bagging_ seul est rarement utilisé en pratique. Néanmoins, les forêts aléatoires tirent leur efficacité des principes fondamentaux du _bagging_. + + -Le _bagging_ présente donc deux avantages par rapport aux arbres CART: un pouvoir prédictif plus élevé et des prédictions plus stables. L'inconvénient du _bagging_ réside dans la corrélation des arbres entre eux: malgré l'échantillonnage des données, les arbres ont souvent une structure similaire car les relations entre variables restent à peu près les mêmes dans les différents sous-échantillons. Ce phénomène de corrélation entre arbres est le principal frein à la puissance prédictive du _bagging_, et c'est pour surmonter (ou au moins minimiser) ce problème que les forêts aléatoires ont été mises au point. Le pouvoir prédictif plus élevé des forêts aléatoires explique pourquoi le _bagging_ est très peu utilisé en pratique aujourd'hui. -#### Les _random forests_ +#### Les forêts aléatoires (_random forests_) + +Les forêts aléatoires (_random forests_, @breiman2001random) sont une variante du _bagging_ qui vise à produire des modèles très performants en conciliant deux objectifs: maximiser le pouvoir prédictif des arbres pris isolément, et minimiser la corrélation entre ces arbres (le problème inhérent au _bagging_). + +Pour atteindre ce second objectif, la forêt aléatoire introduit une nouvelle source de randomisation: la **sélection aléatoire de variables**. Lors de la construction de chaque arbre, au lieu d'utiliser toutes les variables disponibles pour déterminer la meilleure séparation à chaque nœud, un sous-ensemble aléatoire de variables est sélectionné. En limitant la quantité d’information à laquelle chaque arbre a accès au moment de chaque nouvelle division, cette étape supplémentaire contraint mécaniquement les arbres à être plus diversifiés (car deux arbres ne pourront plus nécessairement choisir les mêmes variables pour les mêmes séparations). Cela réduit significativement la corrélation entre les arbres, améliorant ainsi l'efficacité de l'agrégation. L'ensemble des prédictions devient ainsi plus précis et moins sujet aux fluctuations aléatoires. -Les forêts aléatoires (_random forests_, @breiman2001random) sont une variante du _bagging_ qui vise à produire des modèles très performants en conciliant deux objectifs: maximiser le pouvoir prédictif des arbres pris isolément, et minimiser la corrélation entre ces arbres (le problème inhérent au _bagging_). Pour atteindre ce second objectif, la forêt aléatoire introduit une nouvelle source de variation aléatoire dans la construction des arbres: au moment de choisir une règle de décision pour diviser une région en deux sous-régions, la procédure d'entraînement ne considère qu'**un sous-ensemble de variables sélectionnées aléatoirement**, et non toutes les variables. Cette randomisation supplémentaire a pour effet mécanique d'aboutir à des arbres plus diversifiés (parce que des arbres différents ne peuvent pas mobiliser les mêmes variables au même moment) et donc de **réduire la corrélation entre arbres**, ce qui permet d'améliorer la performance et la stabilité du modèle agrégé. Un enjeu important de l'entraînement d'une forêt aléatoire est l'arbitrage entre puissance prédictive des arbres et corrélation entre arbres. ![Représentation schématique d'un algorithme de forêt aléatoire](/figures/rf.svg){#fig-rf} -La figure @fig-rf propose une représentation schématique d'une forêt aléatoire. La logique d'ensemble est identique à celle du _bagging_: combinés de façon à obtenir la prédiction finale. La seule différence est que la liste des variables utilisables pour construire des règles de décision varie à chaque étape de l'entraînement. Cette restriction de la liste des variables considérées permet de réduire l'utilisation des variables les plus prédictives et de mieux mobiliser l'information disponible dans les variables peu corrélées avec $y$. +La figure @fig-rf propose une représentation schématique d'une forêt aléatoire. La logique d'ensemble reste la même que celle du _bagging_. L'échantillonnage _bootstrap_ est inchangé, mais l'étape de construction de chaque arbre est modifiée pour n'utiliser, à chaque nouvelle division, qu'un sous-ensemble aléatoire de variables. L'agrégation des prédictions se fait ensuite de la même manière que pour le _bagging_. + + + +Le principal enjeu de l'entraînement d'une forêt aléatoire est de trouver le bon arbitrage entre puissance prédictive des arbres individuels (que l'on souhaite maximiser) et corrélation entre les arbres (que l'on souhaite minimiser). L'optimisation des hyper-paramètres des forêts aléatoires (dont le plus important est le nombre de variables sélectionnées à chaque noeud) vise précisément à choisir le meilleur compromis possible entre pouvoir prédictif invividuel et diversité des arbres. -Contrairement au _bagging_, les forêts aléatoires sont un algorithme qui est très largement employé pour plusieurs raisons: les forêts aléatoires ont un faible nombre d'hyperparamètres, sont généralement peu sensibles aux valeurs de ces hyperparamètres et proposent de bonnes performances avec les valeurs par défaut. Les forêts aléatoires sont toutefois sujettes au problème de surapprentissage (voir encadré), bien que dans une mesure moindre que le _gradient boosting_. +Les forêts aléatoires sont très populaires car elles sont faciles à implémenter, peu sensibles aux hyperparamètres (elles fonctionnent bien avec les valeurs par défaut de la plupart des implémentations proposées en `R` ou en Python), et offrent de très bonnes performances dans de nombreux cas. Cependant, comme toute méthode d'apprentissage automatique, elles restent sujettes au surapprentissage (voir encadré), bien que dans une moindre mesure par rapport à d'autres techniques comme le _gradient boosting_. -Les forêts aléatoires présentent également un avantage de taille: __il est possible d'évaluer la qualité d'une forêt aléatoire en utilisant les données sur lesquelles elle a été entraînée__, sans avoir besoin d'un jeu de test séparé. En effet, lors de la construction de chaque arbre, l'échantillonnage aléatoire implique que certaines observations ne sont pas utilisées pour entraîner cet arbre; ces observations sont dites _out-of-bag_. On peut donc construire pour chaque observation une prédiction qui agrège uniquement les arbres pour lesquels cette observation est _out-of-bag_; cette prédiction n'est pas affectée par le surapprentissage. De cette façon, il est possible d'évaluer correctement la performance de la forêt aléatoire. + + + ::: {.callout-note title="Qu'est-ce que le surapprentissage?"} Le surapprentissage (_overfitting_) est un phénomène fréquent en _machine learning_ où un modèle apprend non seulement les relations sous-jacentes entre la variable cible et les variables explicatives, mais également le bruit présent dans les données d'entraînement. En capturant ces fluctuations aléatoires plutôt que les tendances générales, le modèle affiche une performance excellente mais trompeuse sur les données d'entraînement, et s'avère médiocre sur des données nouvelles ou de test, car il ne parvient pas à généraliser efficacement. @@ -110,7 +145,9 @@ Le surapprentissage (_overfitting_) est un phénomène fréquent en _machine lea ### Le _gradient boosting_ {#sec-gb-intuition} -Alors que les forêts aléatoires construisent un ensemble d'arbres complexes et indépendants les uns des autres, le _gradient boosting_ adopte une autre approche, dans laquelle les arbres sont peu complexes et entraînés de façon séquentielle, chaque arbre essayant d'améliorer la prédiction proposée par l'ensemble des arbres précédents. Bien qu'elles ressemblent fortement aux forêts aléatoires en apparence, il est important de noter que les approches de _boosting_ reposent sur des fondements théoriques très différents. La logique du *gradient boosting* est illustrée par la figure @fig-gb: +Contrairement aux forêts aléatoires qui combinent des arbres de décision complexes et indépendants, le _gradient boosting_ construit un ensemble d'arbres plus simples et entraînés de manière séquentielle. Chaque arbre vise à corriger les erreurs commises par les arbres précédents, améliorant progressivement la précision du modèle global. Cette approche repose sur des fondements théoriques très différents de ceux du _bagging_. + +La logique du *gradient boosting* est illustrée par la figure @fig-gb: ![Représentation schématique d'un algorithme de _gradient boosting_](/figures/gb.svg){#fig-gb} @@ -119,8 +156,8 @@ Alors que les forêts aléatoires construisent un ensemble d'arbres complexes et - Ce processus est répété en ajoutant des modèles simples, chaque modèle corrigeant les erreurs commises par l'ensemble des modèles précédents; - Tous ces modèles sont finalement combinés (souvent par une somme pondérée) pour obtenir un modèle complexe et performant. -Il s'avère que le _gradient boosting_ offre des performances prédictives particulièrement élevées. Toutefois, cet avantage incontestable ne doit pas masquer les sérieux inconvénients de cette approche: les algorithmes de _gradient boosting_ comprennent un nombre élevé d'hyperparamètres et sont plus sensibles que les forêts aléatoires aux valeurs de ces hyperparamètres. Par ailleurs, ces algorithmes se caractérisent par un risque élevé de surapprentissage, et sont assez sensibles au bruit statistique et aux éventuelles erreurs sur la variable-cible. Par conséquent, l'usage de ces algorithmes est plus délicat, et l'optimisation de leurs hyperparamètres est une étape importante qui peut prendre un certain temps et demande une bonne connaissance des algorithmes. Enfin, il est indispensable de disposer d'un jeu de données de test (non utilisées pendant l'entraînement) pour évaluer la qualité d'un modèle de _boosting_. +Le _gradient boosting_ offre des performances élevées mais exige une attention particulière portée sur la configuration des hyperparamètres et sur la prévention du surapprentissage. En particulier, les hyperparamètres sont nombreux et, contrairement aux forêts aléatoires, nécessitent un ajustement minutieux pour obtenir des résultats optimaux. Une mauvaise configuration peut conduire à des performances médiocres ou à un surapprentissage. L'utilisation du _gradient boosting_ nécessite donc une bonne connaissance du fonctionnement des algorithmes. En outre, les algorithmes de _gradient boosting_ peuvent être sensibles au bruit dans les données et aux erreurs dans la variable cible. Un prétraitement rigoureux des données est donc essentiel. Enfin, une validation rigoureuse sur un jeu de données de test indépendant (non utilisé pendant l'entraînement) est indispensable pour évaluer la qualité du modèle obtenu par _gradient boosting_. diff --git a/chapters/chapter2/3-random_forest.qmd b/chapters/chapter2/3-random_forest.qmd index 2b02c7f..0ebd635 100644 --- a/chapters/chapter2/3-random_forest.qmd +++ b/chapters/chapter2/3-random_forest.qmd @@ -129,7 +129,7 @@ Bien qu'elle s'avèrent très performantes en pratique, __il n'est pas prouvé Par ailleurs, une propriété importante des forêts aléatoires démontrée par @breiman2001random est que leur erreur de généralisation, c'est-à-dire l'écart entre les prédictions du modèle et les résultats attendus sur des données jamais vues (donc hors de l'échantillon d'entraînement), diminue à mesure que le nombre d'arbres augmente et converge vers une valeur constante. Autrement dit, __la forêt aléatoire ne souffre pas d'un surapprentissage croissant avec le nombre d'arbres__. La conséquence pratique de ce résultat est qu'inclure un (trop) grand nombre d'arbres dans le modèle n'en dégrade pas la qualité, ce qui contribue à la rendre particulièrement robuste. En revanche, une forêt aléatoire peut souffrir de surapprentissage si ses autres hyperparamètres sont mal choisis (des arbres trop profonds par exemple). -### Facteurs influençant l'erreur de généralisation +### Facteurs influençant l'erreur de généralisation {#sec-facteur-perf-rf} L'erreur de généralisation des forêts aléatoires est influencée par deux facteurs principaux : @@ -172,14 +172,14 @@ L'objectif de l'entraînement des forêts aléatoires est donc de minimiser la c ## Evaluation des performances par l'erreur _Out-of-Bag_ (OOB) {#sec-rf-oob} -La forêt aléatoire présente une particularité intéressante et très utile en pratique: __il est possible d'évaluer les performances d'une forêt aléatoire directement à partir des données d'entraînement__, grâce à l'estimation de l'erreur _Out-of-Bag_ (OOB). Cette technique repose sur le fait que chaque arbre est construit à partir d'un échantillon _bootstrap_, c'est-à-dire un échantillon tiré avec remise. Cela implique qu'une part conséquente des observations ne sont pas utilisées pour entraîner un arbre donné. Ces observations laissées de côté forment un **échantillon dit _out-of-bag_**, que l'on peut utiliser pour évaluer la performance de chaque arbre. On peut donc construire pour chaque observation du jeu d'entraînement une prédiction qui agrège uniquement les prédictions des arbres pour lesquels cette observation est _out-of-bag_; cette prédiction n'est pas affectée par le surapprentissage (puisque cette observation n'a jamais été utilisée pour entraîner ces arbres). De cette façon, il est possible d'évaluer correctement la performance de la forêt aléatoire. +La forêt aléatoire présente une particularité intéressante et très utile en pratique: __il est possible d'évaluer les performances d'une forêt aléatoire directement à partir des données d'entraînement__, grâce à l'estimation de l'erreur _Out-of-Bag_ (OOB). Cette technique repose sur le fait que chaque arbre est construit à partir d'un échantillon _bootstrap_, c'est-à-dire un échantillon tiré avec remise. Cela implique qu'une part conséquente des observations ne sont pas utilisées pour entraîner un arbre donné. Ces observations laissées de côté forment un **échantillon dit _out-of-bag_**, que l'on peut utiliser pour évaluer la performance de chaque arbre. On peut donc construire pour chaque observation du jeu d'entraînement une prédiction qui agrège uniquement les prédictions des arbres pour lesquels cette observation est _out-of-bag_; cette prédiction n'est pas affectée par le surapprentissage (puisque cette observation n'a jamais été utilisée pour entraîner ces arbres). De cette façon, il est possible d'évaluer correctement la performance de la forêt aléatoire en comparant ces prédictions avec la variable-cible à l'aide d'une métrique bien choisie. La procédure d'estimation de l'erreur OOB se déroule comme ceci: 1. **Entraînement de la forêt aléatoire**: la forêt aléatoire est entraînée sur les données d'entraînement selon la procédure détaillée ci-dessus. 2. **Prédiction _out-of-bag_** : Pour chaque observation $(x_i, y_i)$ des données d'entraînement, on calcule la prédiction de tous les arbres pour lesquels elle fait partie de l'échantillon _out-of-bag_. 3. **Agrégation des prédictions** : La prédiction finale est obtenue en agrégeant les prédictions selon la procédure standard détaillée ci-dessus (moyenne pour la régression, vote majoritaire pour la classification). -4. **Calcul de l'erreur OOB** : L'erreur OOB est ensuite calculée en calculant une métrique (précision, rappel, AUC, erreur quadratique moyenne...) qui compare les prédictions avec la variable-cible $y$ sur toutes les observations. +4. **Calcul de l'erreur OOB** : L'erreur OOB est ensuite calculée en comparant les prédictions avec la variable-cible $y$ sur toutes les observations, à l'aide d'une métrique (précision, rappel, AUC, erreur quadratique moyenne, score de Brier...). L'utilisation de l'erreur OOB présente de multiples avantages: diff --git a/chapters/chapter3/1-preparation_donnees.qmd b/chapters/chapter3/1-preparation_donnees.qmd index cda0f5d..421ba44 100644 --- a/chapters/chapter3/1-preparation_donnees.qmd +++ b/chapters/chapter3/1-preparation_donnees.qmd @@ -9,12 +9,12 @@ - **Échelle des Variables** : Pas nécessaire de normaliser, les arbres sont invariants aux transformations monotones. -### Process: utiliser les pipelines +### Process: utiliser les pipelines scikit, pour expliciter la structure du modèle complet et réduire les risques d'erreur ### Train-test -Pas indispensable pour RF, mais faisable. Indispensable pour GB. +Pas indispensable pour RF, mais souhaitable. Indispensable pour GB. ## Evaluation des performances du modèle et optimisation des hyper-paramètres diff --git a/chapters/chapter3/2-guide_usage_RF.qmd b/chapters/chapter3/2-guide_usage_RF.qmd index 2c7a61e..0fb7da9 100644 --- a/chapters/chapter3/2-guide_usage_RF.qmd +++ b/chapters/chapter3/2-guide_usage_RF.qmd @@ -1,8 +1,7 @@ -# Guide d'entraînement des forêts aléatoires {#sec-guide-rf} - -Ce guide d'entraînement des forêts aléatoires rassemble et synthétise des recommandations sur l'entraînement des forêts aléatoires disponibles dans la littérature, en particulier dans @probst2019hyperparameters. Ce guide comporte un certain nombre de choix méthodologiques forts, comme les implémentations recommandées ou la procédure d'entraînement proposée, et d'autres choix sont évidemment possibles. Les recommandations de ce guide doivent donc être considérées comme un point de départ raisonnable, pas comme un ensemble de règles devant être respectées à tout prix. +# Guide d'usage des forêts aléatoires {#sec-guide-rf} +Ce guide d'entraînement des forêts aléatoires rassemble et synthétise des recommandations sur l'entraînement des forêts aléatoires disponibles dans la littérature, en particulier dans @probst2019hyperparameters. Ce guide comporte un certain nombre de choix méthodologiques forts, comme les implémentations recommandées ou la procédure d'entraînement proposée, et d'autres choix pertinents sont évidemment possibles. C'est pourquoi les recommandations de ce guide doivent être considérées comme un point de départ raisonnable, pas comme un ensemble de règles devant être respectées à tout prix. ## Quelles implémentations utiliser? {#sec-implementation-rf} @@ -10,7 +9,7 @@ Il existe de multiples implémentations des forêts aléatoires. Le présent doc ## Les hyperparamètres clés des forêts aléatoires {#sec-hyperparam-rf} -Cette section décrit en détail les principaux hyperparamètres des forêts aléatoires listés dans le tableau `@tbl-hyp-rf`{=typst}. Les noms des hyperparamètres utilisés sont ceux figurant dans le _package_ `R` `ranger`, et dans le _package_ `Python` `scikit-learn`. Il arrive qu'ils portent un nom différent dans d'autres implémentations des _random forests_, mais il est généralement facile de s'y retrouver en lisant attentivement la documentation. +Cette section décrit en détail les principaux hyperparamètres des forêts aléatoires listés dans le tableau `@tbl-hyp-rf`{=typst}. Les noms des hyperparamètres utilisés sont ceux figurant dans le _package_ `R` `ranger`, et dans le _package_ `Python` `scikit-learn`. Il arrive qu'ils portent un nom différent dans d'autres implémentations des forêts aléatoires, mais il est généralement facile de s'y retrouver en lisant attentivement la documentation. ::: {.content-visible unless-format="html"} @@ -18,7 +17,7 @@ Cette section décrit en détail les principaux hyperparamètres des forêts al #figure( table( - columns: (3fr, 3fr, 6fr,), + columns: (3fr, 3fr, 5fr,), // align: (center, center, center), table.header( table.cell(colspan: 2)[ @@ -28,14 +27,15 @@ Cette section décrit en détail les principaux hyperparamètres des forêts al ], [Description] ), + [ `num.trees` ], [ `n_estimators` ], [Le nombre d'arbres ], [ `mtry` ], [ `max_features` ], [Le nombre de variables candidates à chaque noeud ], - [ `replacement` ], [ ], [L'échantillonnage des données se fait-il avec ou sans remise? ], [ `sample.fraction` ], [ `max_samples` ], [Le taux d'échantillonnage des données ], + [ `replacement` ], [ ], [L'échantillonnage des données se fait-il avec ou sans remise? ], [ `min.node.size` ], [ `min_samples_leaf` ], [Nombre minimal d'observations nécessaire pour qu'un noeud puisse être partagé ], - [ `num.trees` ], [ `n_estimators` ], [Le nombre d'arbres ], - [ `splitrule` ], [ `criterion` ], [Le critère de choix de la règle de division des noeuds intermédiaires ], [ `min.bucket` ], [ `min_samples_split` ], [Nombre minimal d'observations dans les noeuds terminaux ], [ `max.depth` ], [ `max_depth` ], [Profondeur maximale des arbres ], + [ `splitrule` ], [ `criterion` ], [Le critère de choix de la règle de division des noeuds intermédiaires ], + [ `oob.error` ], [ `oob_score` ], [Calculer la performance de la forêt par l'erreur OOB (et choix de la métrique pour `scikit`) ], ), caption: [ Les principaux hyperparamètres des forêts aléatoires], ) @@ -61,14 +61,10 @@ Cette section décrit en détail les principaux hyperparamètres des forêts al ::: -- Le __nombre d'arbres__ par défaut varie selon les implémentations (500 dans `ranger`, 100 dans `scikit-learn`). Il s'agit d'un hyperparamètre particulier car il n'est associé à aucun arbitrage en matière de performance: la performance de la forêt aléatoire croît avec le nombre d'arbres, puis se stabilise. Le nombre optimal d'arbres est celui à partir duquel la performance de la forêt ne croît plus (ce point est détaillé plus bas) où à partir duquel l'ajout d'arbres supplémentaires génère des gains marginaux. Il est important de noter que ce nombre optimal dépend des autres hyperparamètres. Par exemple, un taux d'échantillonnage faible et un nombre faible de variables candidates à chaque noeud aboutissent à des arbres peu corrélés, mais peu performants, ce qui requiert probablement un plus grand nombre d'arbres. L'utilisation de mesures comme le score de Brier est recommandée pour évaluer la convergence plutôt que le taux d'erreur. - +- Le __nombre d'arbres__ par défaut varie selon les implémentations (500 dans `ranger`, 100 dans `scikit-learn`). Il s'agit d'un hyperparamètre particulier car il n'est associé à aucun arbitrage en matière de performance: la performance de la forêt aléatoire croît avec le nombre d'arbres, puis se stabilise. Le nombre optimal d'arbres est celui à partir duquel la performance de la forêt ne croît plus (ce point est détaillé plus bas) où à partir duquel l'ajout d'arbres supplémentaires génère des gains marginaux. Il est important de noter que ce nombre optimal dépend des autres hyperparamètres. Par exemple, un taux d'échantillonnage faible et un nombre faible de variables candidates à chaque noeud aboutissent à des arbres peu corrélés, mais peu performants, ce qui requiert probablement un plus grand nombre d'arbres. Dans le cas d'une classification, l'utilisation de mesures comme le score de Brier ou la fonction de perte logarithmique est recommandée pour évaluer la convergence plutôt que la précision (métrique par défaut de `ranger` et `scikit-learn`). -- Le __nombre (ou la part) de variables candidates à chaque noeud__ (souvent appelé `mtry`) est un hyperparamètre fondamental qui détermine le nombre de variables prédictives sélectionnées aléatoirement à chaque nœud lors de la construction des arbres. Ce paramètre exerce la plus forte influence sur les performances du modèle. -Un nombre plus faible de variables candidates conduit à des arbres moins performants mais plus diversifiés et donc moins corrélés entre eux. À l'inverse, un nombre plus élevé de variables candidates améliore la précision des arbres individuels mais accroît leur corrélation (les mêmes variables ayant tendance à être sélectionnées dans tous les arbres), limitant ainsi les bénéfices de l'agrégation en termes de réduction de variance. Un compromis doit être trouvé et le choix optimal dépend du nombre de variables réellement pertinentes dans les données. Une faible valeur de `mtry` est préférable lorsque la plupart des variables sont pertinentes, tandis qu'une valeur élevé est meilleure lorsqu'il y a peu de variables pertinentes parmi l'ensemble des variables considérées. Par ailleurs, une valeur élevée de `mtry` est préférable si les données comprennent un grand nombre de variables binaires issues du _one-hot-encoding_ des variables catégorielles (LIEN AVEC LA PARTIE PREPROCESSING). - -Par défaut, cette valeur est fréquemment fixée à $\sqrt{p}$ pour les problèmes de classification et à $p/3$ pour les problèmes de régression, où $p$ représente le nombre total de variables prédictives disponibles. Ces choix par défaut reposent sur des heuristiques empiriques qui offrent généralement un bon compromis entre la précision des prédictions et la diversité des arbres. +- Le __nombre (ou la part) de variables candidates à chaque noeud__ (souvent appelé `mtry`) est un hyperparamètre essentiel qui détermine le nombre de variables prédictives sélectionnées aléatoirement à chaque nœud lors de la construction des arbres. Ce paramètre exerce la plus forte influence sur les performances du modèle, et un compromis doit être trouvé entre puissance prédictive des arbres et corrélation entre arbres. Une faible valeur de `mtry` conduit à des arbres moins performants mais plus diversifiés et donc moins corrélés entre eux. Inversement, une valeur plus élevée améliore la précision des arbres individuels mais accroît leur corrélation (les mêmes variables ayant tendance à être sélectionnées dans tous les arbres). La valeur optimale de `mtry` dépend du nombre de variables réellement pertinentes dans les données: elle est plus faible lorsque la plupart des variables sont pertinentes, et plus élevée lorsqu'il y a peu de variables pertinentes. Par ailleurs, une valeur élevée de `mtry` est préférable si les données comprennent un grand nombre de variables binaires issues du _one-hot-encoding_ des variables catégorielles (LIEN AVEC LA PARTIE PREPROCESSING). Par défaut, cette valeur est fréquemment fixée à $\sqrt{p}$ pour les problèmes de classification et à $p/3$ pour les problèmes de régression, où $p$ représente le nombre total de variables prédictives disponibles. - Le __taux d'échantillonnage__ et le __mode de tirage__ contrôlent le plan d'échantillonnage des données d'entraînement. Les valeurs par défaut varient d'une implémentation à l'autre; dans le cas de `ranger`, le taux d'échantillonnage est de 63,2% sans remise, et de 100% avec remise. L'implémentation `scikit-learn` ne propose pas le tirage sans remise. Ces hyperparamètres ont des effets sur la performance similaires à ceux du nombre de variables candidates, mais d'une moindre ampleur. Un taux d'échantillonnage plus faible aboutit à des arbres plus diversifiés et donc moins corrélés (car ils sont entraînés sur des échantillons très différents), mais ces arbres peuvent être peu performants car ils sont entraînés sur des échantillons de petite taille. Inversement, un taux d'échantillonnage élevé aboutit à des arbres plus performants mais plus corrélés. Les effets de l'échantillonnage avec ou sans remise sur la performance de la forêt aléatoire sont moins clairs et ne font pas consensus. Les travaux les plus récents semblent toutefois suggérer qu'il est préférable d'échantillonner sans remise (@probst2019hyperparameters). @@ -82,22 +78,22 @@ Par défaut, cette valeur est fréquemment fixée à $\sqrt{p}$ pour les problè ## Comment entraîner une forêt aléatoire? {#sec-procedure-training-rf} -Les forêts aléatoires nécessitent généralement moins d’optimisation que d’autres modèles de _machine learning_, car leurs performances varient relativement peu en fonction des hyperparamètres. Les valeurs par défaut fournissent souvent des résultats satisfaisants, ce qui réduit le besoin d'optimisation intensive. Cependant, un ajustement précis des hyperparamètres peut apporter des gains de performance, notamment sur des jeux de données complexes. - -Comme indiqué dans la partie __REFERENCE A AJOUTER__, la performance prédictive d'une forêt aléatoire varie en fonction de deux critères essentiels: elle croît avec le pouvoir prédictif des arbres, et décroît avec la corrélation des arbres entre eux. L'entraînement d'une forêt aléatoire implique de trouver un équilibre optimal où les arbres sont suffisamment puissants pour être prédictifs, tout en étant suffisamment diversifiés pour que leurs erreurs ne soient pas trop corrélées. Cet arbitrage s'opère en ajustant certains hyperparamètres clés comme le nombre de variables candidates à chaque division, la taille de l'échantillon ou encore la taille minimale des feuilles. L'ajustement du nombre d'arbre relève plutôt d'un arbitrage entre performance et temps de calcul. Il est recommandé de fixer le nombre d'arbre à une valeur au-delà de laquelle les gains de performance peuvent être considérés comme marginaux. +Les forêts aléatoires nécessitent généralement moins d'optimisation que d’autres modèles de _machine learning_, car leurs performances varient relativement peu en fonction des hyperparamètres. Les valeurs par défaut fournissent souvent des résultats satisfaisants, ce qui réduit le besoin d'optimisation intensive. Cependant, un ajustement précis des hyperparamètres peut apporter des gains de performance, notamment sur des jeux de données complexes. -Il existe plusieurs méthodes permettant d'optimiser simultanément plusieurs hyperparamètres: la recherche par grille, la recherche aléatoire et l'optimisation basée sur modèle séquentiel (SMBO). +Comme indiqué dans la partie @sec-facteur-perf-rf, la performance prédictive d'une forêt aléatoire varie en fonction de deux critères essentiels: elle croît avec le pouvoir prédictif des arbres, et décroît avec la corrélation des arbres entre eux. L'optimisation des hyperparamètres d'une forêt aléatoire vise donc à trouver un équilibre optimal où les arbres sont suffisamment puissants pour être prédictifs, tout en étant suffisamment diversifiés pour que leurs erreurs ne soient pas trop corrélées. +La littérature propose de multiples approches pour optimiser simultanément plusieurs hyperparamètres: la recherche par grille (_grid search_), la recherche aléatoire (_random search_) et l'optimisation basée sur modèle séquentiel (SMBO), et il peut être difficile de savoir quelle approche adopter. Ce guide propose donc une première approche délibérément simple, avant de présenter les approches plus avancées. -### Première approche exploratoire +### Approche simple -Voici une procédure simple pour entraîner une forêt aléatoire. Elle ne garantit pas l'obtention d'un modèle optimal, mais elle est lisible et permet d'obtenir rapidement un modèle raisonnablement performant. +Voici une procédure simple pour entraîner une forêt aléatoire. Elle ne garantit pas l'obtention d'un modèle optimal, mais elle est lisible et permet d'obtenir rapidement un modèle raisonnablement performant. -- __Commencer par entraîner une forêt aléatoire avec les valeurs des hyperparamètres par défaut__. Ce premier modèle servira de point de comparaison pour la suite. -- __Ajuster le nombre d’arbres__: entraîner une forêt aléatoire avec les hyperparamètres par défaut en augmentant progressivement le nombre d'arbres, puis déterminer à partir de quel nombre d'arbres la performance se stabilise. Fixer le nombre d'arbres à cette valeur par la suite. -- __Ajuster le nombre minimal d'observations dans les noeuds terminaux__: optimiser cet hyperparamètre grâce à une méthode de _grid search_ évaluée par une approche de validation-croisée. Ce n'est pas l'hyperparamètre le plus important, mais il est utile de vérifier s'il est possible de le fixer à une valeur plus élevée que la valeur par défaut sans perte de performance, car cela permet d'accélérer le reste de la procédure. -- __Ajuster le nombre de variables candidates et le taux d'échantillonnage__: optimiser ces deux hyperparamètres grâce à une méthode de _grid search_ évaluée par une approche de validation-croisée. -- __Evaluation du modèle final__: mesurer la performance du modèle final soit avec l'approche Out-of-Bag (OOB), soit avec un ensemble de test. Il est souvent instructif de comparer les performances du modèle final et du modèle entraîné avec les valeurs des hyperparamètres par défaut. +- __Entraîner une forêt aléatoire avec les valeurs des hyperparamètres par défaut__. Ce premier modèle servira de point de comparaison pour la suite. +- __Ajuster le nombre d’arbres__: entraîner une forêt aléatoire avec les hyperparamètres par défaut en augmentant progressivement le nombre d'arbres, puis déterminer à partir de quel nombre d'arbres la performance se stabilise (en mesurant la performance avec l'erreur OOB avec pour métrique le [score de Brier](https://scikit-learn.org/dev/modules/model_evaluation.html#brier-score-loss)). Fixer le nombre d'arbres à cette valeur par la suite. +- __Ajuster le nombre de variables candidates et le taux d'échantillonnage__: optimiser ces deux hyperparamètres grâce à une méthode de _grid search_ évaluée par une approche de validation-croisée, ou par une approche reposant sur l'erreur OOB. +- __Ajuster le nombre minimal d'observations dans les noeuds terminaux__: optimiser cet hyperparamètre grâce à une méthode de _grid search_ évaluée par une approche de validation-croisée, ou par une approche reposant sur l'erreur OOB. Ce n'est pas l'hyperparamètre le plus important, mais s'il est possible de le fixer à une valeur plus élevée que la valeur par défaut sans perte de performance, cela permet d'accélérer le reste de la procédure. +- __Entraîner du modèle final__: entraîner une forêt aléatoire avec les hyperparamètres optimisés déduits des étapes précédentes. +- __Évaluer du modèle final__: mesurer la performance du modèle final soit avec l'approche _out-of-bag_ (OOB), soit avec un ensemble de test. Il est souvent instructif de comparer les performances du modèle final et du modèle entraîné avec les valeurs des hyperparamètres par défaut (parfois pour se rendre compte que ce dernier était déjà suffisamment performant...). ### Approches plus avancées @@ -122,11 +118,11 @@ En pratique, il est recommandé d'utiliser des méthodes d'importance des variab On conseille l'utilisation de trois implémentations pour comparer l'importances des variables d'une forêt aléatoire: -- Pour la MDI: l'algorithme CIF proposé par @strobl2007bias et implémenté en R +- Pour la MDI: l'algorithme CIF proposé par @strobl2007bias et implémenté en `R` -- Pour la MDA: l'algorithme Sobol-MDA proposé par @benard2022mda et implémenté en R +- Pour la MDA: l'algorithme Sobol-MDA proposé par @benard2022mda et implémenté en `R` -- Pour les valeurs de shapley : l'alogrithme SHAFF proposé par @benard2022shaff et implémenté en R +- Pour les valeurs de Shapley : l'alogrithme SHAFF proposé par @benard2022shaff et implémenté en `R` Enfin, nous recommandons de combiner plusieurs méthodes pour une analyse plus robuste et de tenir compte des prétraitements des données afin de minimiser les biais potentiels.