Forêts aléatoires

Dans Arbres de décision, nous avons construit des arbres de décision et abordé certaines méthodes, telles que l'élagage, qui permettent d'améliorer la fiabilité des prédictions de l'arbre de décision. Pour chaque problème de classification, un arbre est créé et sert de modèle pour toutes les utilisations ultérieures. Cependant, quel que soit le soin apporté à la création et à l'élagage d'un arbre de décision, il s'agit en fin de compte d'un modèle unique dont la structure même peut comporter un certain biais en raison des variations du jeu d'entraînement. Si nous avions utilisé un jeu d'entraînement différent, notre arbre de décision aurait pu être sensiblement différent.

Dans le monde réel, obtenir une quantité suffisante de données pour entraîner un modèle d'apprentissage automatique peut être difficile, long et coûteux. Il n'est pas toujours envisageable de chercher de nouveaux jeux d'entraînement simplement pour créer et évaluer divers arbres de décision. Une forêt aléatoire (random forest), un algorithme de classification qui utilise plusieurs arbres de décision, permet de contourner cette difficulté. Tout comme nous l'avons fait pour les régressions linéaires dans L'apprentissage automatique dans l'analyse de régression, la méthode d'agrégation bootstrapping est employée. Dans ce contexte, l'agrégation bootstrapping (bagging) (bootstrapping aggregating (bagging)) consiste à rééchantillonner plusieurs fois à partir du même jeu de données de test, en créant un nouvel arbre de décision à chaque fois. Les arbres de décision individuels qui composent un modèle de forêt aléatoire sont appelés des apprenants faibles (weak learners). Afin d'accroître la diversité de ces apprenants faibles, une sélection aléatoire des variables explicatives est appliquée, ce qui signifie que chaque arbre est construit en utilisant un sous-ensemble sélectionné aléatoirement parmi les variables de caractéristiques. Par exemple, si nous cherchons à prédire la présence d'une maladie cardiaque chez un patient en utilisant l'âge, le poids et le taux de cholestérol, le modèle de forêt aléatoire sera constitué de divers arbres de décision, dont certains n'utiliseront que l'âge et le poids, d'autres l'âge et le taux de cholestérol, et d'autres encore uniquement le poids. Lors de la classification de nouvelles données, la prédiction finale de la forêt aléatoire est déterminée par un « vote à la majorité » parmi les arbres de décision individuels. De plus, le fait que les arbres de décision individuels n'utilisent qu'un sous-ensemble de caractéristiques permet de déduire l'importance de chaque variable explicative en observant l'exactitude des arbres qui l'utilisent.

En raison de la complexité de cette méthode, les forêts aléatoires sont illustrées au moyen du bloc de code Python suivant.

Supposons que vous construisiez un modèle prédisant les températures quotidiennes en fonction de facteurs tels que la température d'hier et d'avant-hier, ainsi que de prévisions provenant de sources multiples, à partir du jeu de données temps.csv. Comme il y a un grand nombre de variables explicatives en entrée, il ne sera pas possible de visualiser les données. De plus, certaines variables ne contribueront probablement pas beaucoup aux prédictions. Comment faire le tri ? Un modèle de forêt aléatoire pourrait être l'outil idéal. La bibliothèque Python sklearn propose un module appelé sklearn.ensemble qui permet de créer le modèle de forêt aléatoire.

Code Python

      # Import libraries
      import pandas as pd  ## for dataset management
      from sklearn.model_selection import train_test_split
      import sklearn.ensemble as ens
      
      # Read input file
      features = pd.read_csv('temps.csv').dropna()
      
      # Use 'actual' as the response variable
      labels = features['actual']
      
      # Convert text data into numerical values
      # This is called "one-hot" encoding
      features = pd.get_dummies(features)
      
      # The other columns are used as features
      features = features.drop('actual', axis=1)
      feature_list = list(features.columns)
      
      # Split data into training and testing sets
      train_features, test_features, train_labels, test_labels = train_test_split(features, labels, test_size=0.25)
      
      # Create random forest model
      rf = ens.RandomForestRegressor(n_estimators=1000)
      rf.fit(train_features, train_labels)
    

La sortie obtenue ressemble à ceci :

Le code Python précédent charge le jeu de données temps.csv, en désignant la colonne « actual » (les températures réelles de chaque jour) comme variable à prédire. Toutes les autres colonnes sont considérées comme des caractéristiques. Étant donné que la colonne « week » contient des données catégorielles (textuelles), elle doit être convertie en valeurs numériques avant de pouvoir élaborer le moindre modèle. La méthode de l'encodage one-hot permet de résoudre ce problème. Dans l'encodage one-hot (one-hot encoding), chaque catégorie est associée à un vecteur contenant un seul 1 correspondant à cette catégorie, tandis que toutes les autres catégories sont mises à 0. Dans notre exemple, chaque jour de la semaine est représenté par un vecteur à sept dimensions comme suit :

• Lundi : [1, 0, 0, 0, 0, 0, 0]
• Mardi : [0, 1, 0, 0, 0, 0, 0]
• Mercredi : [0, 0, 1, 0, 0, 0, 0]
• Jeudi : [0, 0, 0, 1, 0, 0, 0]
• Vendredi : [0, 0, 0, 0, 1, 0, 0]
• Samedi : [0, 0, 0, 0, 0, 1, 0]
• Dimanche : [0, 0, 0, 0, 0, 0, 1]

Le jeu de données est divisé en ensemble d'entraînement (75 %) et ensemble de test (25 %), et le modèle de forêt aléatoire est entraîné sur l'ensemble d'entraînement, comme le montre ce bloc de code Python :

      import statistics as stats # to compute the mean

      # Get predictions and compute average error
      predictions = rf.predict(test_features)
      errors = abs(predictions - test_labels)
      round(np.mean(errors),2)
    

3.91

Avec une erreur absolue moyenne de seulement 3,91, les températures prédites ne s'écartent que d'environ 4 °F en moyenne ; la forêt aléatoire semble donc donner de très bons résultats sur l'ensemble de test, d'autant plus qu'il est notoirement difficile de prédire des données météorologiques qui présentent habituellement une forte variance. Voyons maintenant quelles caractéristiques se sont révélées les plus importantes pour formuler les prédictions, information stockée dans rf.feature_importances_. Remarquez le nombre de commandes Python utilisées uniquement pour le tri et le formatage des résultats, qui peuvent être ignorées sans inconvénient dans cet extrait de code.

    # Find the importance of each feature
    importances = list(rf.feature_importances_)
    feature_importances = [(feature, round(importance,2)) for feature, importance in zip(feature_list, importances)]
    feature_importances = sorted(feature_importances, key=lambda x: x[1], reverse=True)
    [print('Variable: {:20} Importance: {}'.format(*pair)) for pair in feature_importances];
    

Variable: temp_1               Importance: 0.62
Variable: average              Importance: 0.19
Variable: forecast_acc         Importance: 0.06
Variable: forecast_noaa        Importance: 0.04
Variable: day                  Importance: 0.02
Variable: temp_2               Importance: 0.02
Variable: forecast_under       Importance: 0.02
Variable: friend               Importance: 0.02
Variable: month                Importance: 0.01
Variable: year                 Importance: 0.0
Variable: week_Fri             Importance: 0.0
Variable: week_Mon             Importance: 0.0
Variable: week_Sat             Importance: 0.0
Variable: week_Sun             Importance: 0.0
Variable: week_Thurs           Importance: 0.0
Variable: week_Tues            Importance: 0.0
Variable: week_Wed             Importance: 0.0

Comme nous pouvons le constater, le meilleur prédicteur des températures quotidiennes est la température de la veille (« temp_1 »), suivie de la température moyenne observée ce même jour au cours des années précédentes (« average »). Les prévisions de la NOAA et d'ACC ne présentent qu'une importance secondaire, tandis que toutes les autres variables de caractéristiques se sont révélées relativement inutiles pour prédire la température actuelle. Il n'est guère surprenant que le jour de la semaine (lundi, mardi, etc.) ne joue aucun rôle significatif dans la prévision des températures.

Classifieurs naïfs bayésiens multinomiaux

Une méthode pour classifier des données consiste à rechercher des caractéristiques fréquentes permettant de distinguer un point de données d'un autre. Par exemple, imaginez que vous disposiez d'une vaste collection d'articles de presse et que vous souhaitiez les catégoriser automatiquement par thèmes tels que le sport, la politique, l'économie, le divertissement et la technologie. Vous avez peut-être remarqué certains schémas récurrents : les articles de sport ont tendance à mentionner des noms d'équipes et des scores chiffrés, tandis que les articles de politique contiennent assez souvent les mots « démocrate » et « républicain ». Les articles économiques peuvent employer des termes tels que « perspectives » et « ralentissement » bien plus souvent que les articles sur le divertissement ou la technologie. La classification naïve bayésienne multinomiale peut être appliquée pour classer ces articles en fonction de la fréquence et de la distribution des mots habituellement rencontrés dans chaque type d'article.

L'algorithme de classification naïve bayésienne (naïve Bayes classification) multinomiale repose sur le théorème de Bayes, en exploitant les probabilités a priori et ce théorème pour prédire la classe ou l'étiquette de nouvelles données. (Voir Distributions de probabilité continues normales pour plus de détails.) L'algorithme du classifieur naïf bayésien est un outil puissant pour déterminer la probabilité d'événements à partir de connaissances préalables. Rappelons que la notation $P\left(A\right|B)$ désigne la probabilité conditionnelle que l'événement $A$ se produise sachant que l'événement $B$ est connu pour s'être produit (ou s'est déjà produit ou est supposé se produire). Dans sa version la plus simple, le théorème de Bayes s'écrit sous la forme

Ici, nous considérons $A$ comme un événement que nous souhaitons prédire et $B$ comme une information qui nous est fournie (éventuellement sous la forme d'une variable explicative d'un jeu de données). La probabilité conditionnelle $P\left(B\right|A)$ représente la vraisemblance connue d'observer l'événement $B$ dans le cas où A se réalise, qui est généralement calculée à partir des données d'entraînement. La valeur de $P\left(A\right)$ est également calculée ou estimée à partir des données d'entraînement et est désignée sous le nom de probabilité a priori (prior probability).

En pratique, il existe souvent une multitude de caractéristiques, notées $B_1,B_2,B_3,\dots B_n$, où chaque caractéristique peut correspondre à l'événement qu'un mot particulier apparaisse dans un message, et nous cherchons à classer le message dans une catégorie donnée en fonction de ces événements. En d'autres termes, nous souhaitons estimer $P\left(A\right|B_1,B_2,B_3,\dots ,B_n)$, c'est-à-dire la probabilité que l'événement A se produise sachant que les événements $B_1,B_2,B_3,\dots B_n$ sont survenus. En réalité, notre objectif principal est de distinguer l'événement $A$ de $A\prime$ plutôt que d'obtenir un calcul exact des probabilités, ce qui nous permet d'effectuer de simples comparaisons pour tirer une conclusion. Un exemple permet de mieux illustrer cette procédure.

Remarque : la classification naïve bayésienne repose sur l'hypothèse que toutes les caractéristiques des données sont indépendantes. Bien que cette condition ne soit pas systématiquement vérifiée dans les jeux de données réels, le modèle de Bayes naïf peut néanmoins offrir de très bonnes performances dans des situations concrètes. De plus, il s'agit d'un algorithme particulièrement simple et efficace, ce qui en fait souvent la méthode de premier choix pour aborder un problème de classification avant de recourir à des modèles plus sophistiqués.

Bayes naïf gaussien pour les probabilités continues

Le modèle de Bayes naïf gaussien (Gaussian naïve Bayes) est une variante de l'algorithme de classification naïve bayésienne spécialement conçue pour les données présentant des caractéristiques continues. Contrairement au modèle naïf bayésien standard (multinomial), qui est couramment employé pour classifier des données textuelles comportant des variables discrètes, le modèle de Bayes naïf gaussien est adapté aux jeux de données dont les variables suivent une distribution gaussienne (normale) (vous pouvez vous remémorer la discussion sur la distribution normale dans Distributions de probabilité discrètes et continues). Il se révèle particulièrement utile pour traiter des problèmes portant sur des données continues à valeurs réelles, dans lesquelles les variables explicatives sont relativement indépendantes.

Dans cet exemple, nous travaillerons avec un jeu de données volumineux, cirrhosis.csv, qui comprend de nombreuses caractéristiques, tant catégorielles que numériques. Ce jeu de données (ainsi que bien d'autres !) peut être téléchargé gratuitement sur Kaggle.com. Nous n'utiliserons que quatre colonnes numériques comme caractéristiques. La variable réponse est « Status », qui peut prendre les valeurs $D$ pour le décès, $C$ pour censuré (ce qui signifie que le patient n'est pas décédé pendant la période d'observation) et CL pour censuré en raison d'une greffe du foie.

      # Import libraries
      import pandas as pd  ## for dataset management
      from sklearn.model_selection import train_test_split
      from sklearn.naive_bayes import GaussianNB
      from sklearn.metrics import accuracy_score, confusion_matrix, classification_report
      
      # Load the dataset
      data = pd.read_csv('cirrhosis.csv').dropna()
      
      # Choose feature columns and target labels
      X = data[['Bilirubin','Cholesterol','Albumin','Copper']]
      y = data['Status']
      
      # Split the dataset into training and testing sets (80% training, 20% testing)
      X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
      
      # Initialize and train the Gaussian naive Bayes classifier
      gnb_classifier = GaussianNB()
      gnb_classifier.fit(X_train, y_train)
      
      # Predict labels for the test set
      y_pred = gnb_classifier.predict(X_test)
      
      # Evaluate the classifier's performance
      accuracy = accuracy_score(y_test, y_pred)
      confusion = confusion_matrix(y_test, y_pred, labels=['D','C','CL'])
      report = classification_report(y_test, y_pred)
      
      print(f"Accuracy: {accuracy:.2f}")
      print("Confusion matrix with label order D, C, CL:\n", confusion)
    

Accuracy: 0.71
Confusion matrix with label order D, C, CL:
[[10 14  2]
[ 0 30  0]
[ 0  0  0]]

Le score d'exactitude de 0,71 indique que les étiquettes correctes ont été attribuées dans 71 % des cas. Nous constatons que 10 décès ($D$) et 30 non-décès ($C$ ou $CL$) ont été correctement prédits. En revanche, 16 prédictions de décès correspondaient en fait à des cas sans décès. Il s'agit d'une erreur bien plus tolérable que l'inverse (prédire l'absence de décès alors que le patient va décéder) ; le modèle semble donc adéquat pour la tâche de prédiction de la mortalité liée à la cirrhose.

Travailler avec les mégadonnées

Dans le paysage en constante évolution de l'apprentissage automatique, la question des mégadonnées occupe une place centrale. Comme nous l'avons vu dans Gestion des grands jeux de données, les ensembles de données de grande taille, souvent appelés mégadonnées (big data), désignent des jeux de données extrêmement volumineux et complexes dont le traitement, la gestion et l'analyse dépassent les capacités des outils traditionnels. Les mégadonnées se caractérisent par la règle des « trois V » :

• Volume : Les mégadonnées impliquent des volumes considérables, allant souvent de téraoctets ($2^{40}\approx {10}^{12}$ octets) jusqu'à des pétaoctets ($2^{50}\approx {10}^{15}$ octets), voire davantage. D'où provient une telle quantité de données ? Un exemple remarquable est le jeu de données Common Crawl, qui contient des pétaoctets de données constituées de contenus bruts de pages web, de métadonnées et d'autres informations recueillies sur Internet. Il est fort probable que des jeux de données atteignant des exaoctets ($2^{60}\approx {10}^{18}$ octets) fassent leur apparition dans un avenir proche.
• Vélocité : Dans certaines applications concrètes de première importance, les données sont générées et recueillies à une vitesse fulgurante. Ce flux continu peut être diffusé en continu en temps réel ou stocké dans d'immenses bases de données pour une analyse ultérieure. On peut citer en exemple le domaine de la vidéo très haute définition, dont les données peuvent être capturées, enregistrées et analysées à un débit de plusieurs gigabits par heure.
• Variété : Les mégadonnées englobent également une grande diversité de types de données, comprenant des données structurées (par exemple des bases de données), des données non structurées (textes, images, vidéos) et toutes les formes intermédiaires. Cette variété complexifie considérablement la gestion et l'analyse des données. Songez à l'ensemble des sources possibles et à quel point elles diffèrent tant pour leur transmission que pour leur stockage. Des interactions sur les réseaux sociaux aux transactions de commerce électronique, en passant par les relevés de capteurs issus d'appareils de l'Internet des objets (IoT), les données affluent à un rythme, à une échelle et avec une diversité inédits. De surcroît, bien malin qui pourra prédire les méthodes entièrement nouvelles selon lesquelles les données seront collectées et exploitées à l'avenir !