Les bases du machine learning

(Niveau débutant)

[email protected] | +237 695994053

ESI | M2R
July 7, 2022

Contents

1 Logiciels utilisés 2

2 Introduction 2
2.1 Améliorer l'arbre de décision . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
2.2 Utiliser Pandas pour se familiariser avec vos données . . . . . . . . . . . . . . . 3
2.3 Interpréter la description des données . . . . . . . . . . . . . . . . . . . . . . . . 4
3 Mise en place de votre premier modèle d'apprentissage 4
3.1 Sélection des données pour la modélisation . . . . . . . . . . . . . . . . . . . . . 4
3.2 Sélection de la cible de prédiction . . . . . . . . . . . . . . . . . . . . . . . . . . 5
3.3 Choisir "Fonctionnalités" . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
3.4 Construire votre modèle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
4 Validation du modèle 7
4.1 Le problème avec les scores "dans l'échantillon" . . . . . . . . . . . . . . . . . . 7
4.2 Le codage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
4.3 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
5 Ajustement du modèle pour une meilleure précision 9
5.1 Expérimenter avec diérents modèles . . . . . . . . . . . . . . . . . . . . . . . . 9
5.2 Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
5.3 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
6 Modèle Les Forêts aléatoires 11
6.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
6.2 Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
6.3 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
7 Compétition kaggle 12

1
1 Logiciels utilisés

ˆ Google colab
ˆ kaggle
ˆ Jupyter (Anaconda)

2 Introduction

Nous commencerons par un aperçu du fonctionnement des modèles d'apprentissage automatique

et de leur utilisation. Cela peut sembler basique si vous avez déjà fait de la modélisation
statistique ou de l'apprentissage automatique. Ne vous inquiétez pas, nous allons bientôt
développer des modèles puissants.

Ce cours vous fera construire des modèles au fur et à mesure que vous passerez par le scénario
suivant :

Votre cousin a gagné des millions de dollars en spéculant sur l'immobilier. Il s'est proposé
de devenir un partenaire commercial avec vous en raison de votre intérêt pour la science des
données. Il fournira l'argent et vous fournirez des modèles qui prédisent la valeur de diérentes
maisons.

Il divise les maisons en seulement deux catégories. Le prix prévu pour toute maison considérée
est le prix moyen historique des maisons de la même catégorie.

Nous utilisons les données pour décider comment diviser les maisons en deux groupes, puis à
nouveau pour déterminer le prix prévu dans chaque groupe. Cette étape de capture de modèles
à partir de données est appelée ajustement ou formation du modèle. Les données utilisées pour
ajuster le modèle sont appelées les données d'apprentissage.

Les détails de l'ajustement du modèle (par exemple, comment diviser les données) sont susamment
complexes pour que nous les sauvegardions pour plus tard. Une fois le modèle ajusté, vous
pouvez l'appliquer à de nouvelles données pour prédire les prix de maisons supplémentaires.

2.1 Améliorer l'arbre de décision

Lequel des deux arbres de décision suivants est le plus susceptible de résulter de l'ajustement
des données de formation immobilière ?

2
L'arbre de décision sur la gauche (Arbre de décision 1) a probablement plus de sens, car il
capture la réalité selon laquelle les maisons avec plus de chambres ont tendance à se vendre à
des prix plus élevés que les maisons avec moins de chambres. Le plus gros défaut de ce modèle
est qu'il ne tient pas compte de la plupart des facteurs aectant le prix de l'immobilier, tels
que le nombre de salles de bains, la taille du terrain, l'emplacement, etc.

Vous pouvez capturer plus de facteurs en utilisant un arbre qui a plus de "splits". Ceux-ci sont
appelés arbres "plus profonds". Un arbre de décision qui prend également en compte la taille
totale du terrain de chaque maison pourrait ressembler à ceci :

Vous prédisez le prix de n'importe quelle maison en parcourant l'arbre de décision, en choisissant
toujours le chemin correspondant aux caractéristiques de cette maison. Le prix prévu pour la
maison est au bas de l'arbre. Le point en bas où nous faisons une prédiction s'appelle une feuille.

Les fractionnements et les valeurs au niveau des feuilles seront déterminés par les données, il
est donc temps pour vous de vérier les données avec lesquelles vous travaillerez.

2.2 Utiliser Pandas pour se familiariser avec vos données

La première étape de tout projet d'apprentissage automatique consiste à vous familiariser avec
les données. Vous utiliserez la bibliothèque Pandas pour cela.

3
Pandas est le principal outil utilisé par les data scientists pour explorer et manipuler les données.
La plupart des gens abrégent pandas dans leur code en pd. Nous le faisons avec la commande

import pandas as pd

La partie la plus importante de la bibliothèque Pandas est le DataFrame. Un DataFrame

contient le type de données que vous pourriez considérer comme une table. Ceci est similaire à
une feuille dans Excel ou à un tableau dans une base de données SQL.

Pandas dispose de méthodes puissantes pour la plupart des choses que vous voudrez faire avec
ce type de données. À titre d'exemple, nous examinerons les données sur les prix des maisons
à Melbourne, en Australie. Dans les exercices pratiques, vous appliquerez les mêmes processus
à un nouvel ensemble de données, qui contient les prix des maisons dans l'Iowa.
Les données de l'exemple (Melbourne) se trouvent dans le chemin du chier ../input/melbourne-
housing-snapshot/melbd ata.csv.
Nous chargeons et explorons les données avec les commandes suivantes :

#Sauvegarde du chemin contenant le fichier qui possède les données

melbourne_file_path = '../input/melbourne-housing-snapshot/melb_data.csv'
#Lecture du fichier CSV
melbourne_data = pd.read_csv(melbourne_file_path)
#Impression des propriétés des données
melbourne_data.describe()

2.3 Interpréter la description des données

Les résultats achent 8 chires pour chaque colonne de votre ensemble de données d'origine.
Le premier nombre, le nombre, indique combien de lignes ont des valeurs non manquantes.

Les valeurs manquantes surviennent pour de nombreuses raisons. Par exemple, la taille de
la 2ème chambre ne serait pas collectée lors de l'arpentage d'une maison 1 chambre. Nous
reviendrons sur le sujet des données manquantes. La deuxième valeur est la moyenne, qui est
la moyenne. En dessous, std est l'écart type, qui mesure l'étalement numérique des valeurs.

Pour interpréter les valeurs min, 25%, 50% , 75% et max, imaginez que vous triez chaque
colonne de la valeur la plus faible à la plus élevée. La première (la plus petite) valeur est le
min. Si vous parcourez un quart de la liste, vous trouverez un nombre supérieur à 25% des
valeurs et inférieur à 75% des valeurs.

3 Mise en place de votre premier modèle d'apprentissage

3.1 Sélection des données pour la modélisation

Votre ensemble de données comportait trop de variables pour vous faire comprendre, ou même
pour imprimer correctement. Comment pouvez-vous réduire cette quantité écrasante de données
à quelque chose que vous pouvez comprendre ?

Nous commencerons par choisir quelques variables en utilisant notre intuition. Les cours
ultérieurs vous montreront des techniques statistiques pour hiérarchiser automatiquement les

4
variables.

Pour choisir des variables/colonnes, nous aurons besoin de voir une liste de toutes les colonnes
de l'ensemble de données. Cela se fait avec la propriété columns du DataFrame (la dernière
ligne de code ci-dessous).

import pandas as pd

melbourne_file_path = '../input/melbourne-housing-snapshot/melb_data.csv'
melbourne_data = pd.read_csv(melbourne_file_path)
melbourne_data.columns

3.2 Sélection de la cible de prédiction

Vous pouvez extraire une variable avec une notation par points. Cette colonne unique est
stockée dans une série, qui ressemble globalement à un DataFrame avec une seule colonne de
données.

Nous utiliserons la notation par points pour sélectionner la colonne que nous voulons prédire,
appelée cible de prédiction. Par convention, la cible de prédiction est appelée y. Donc, le code
dont nous avons besoin pour enregistrer les prix des maisons dans les données de Melbourne
est donné par la ligne de code suivante :

y = melbourne_data.Price

3.3 Choisir "Fonctionnalités"

Les colonnes entrées dans notre modèle (et utilisées plus tard pour faire des prédictions) sont
appelées "caractéristiques". Dans notre cas, ce seraient les colonnes utilisées pour déterminer
le prix de la maison. Parfois, vous utiliserez toutes les colonnes à l'exception de la cible comme
fonctionnalités. D'autres fois, vous serez mieux avec moins de fonctionnalités.

Pour l'instant, nous allons construire un modèle avec seulement quelques fonctionnalités. Plus
tard, vous verrez comment itérer et comparer des modèles construits avec diérentes fonctionnalités.

Nous sélectionnons plusieurs fonctionnalités en fournissant une liste de noms de colonnes entre
parenthèses. Chaque élément de cette liste doit être une chaîne (avec des guillemets). Voici un
exemple:

melbourne_features = ['Rooms', 'Bathroom', 'Landsize', 'Lattitude', 'Longtitude']

Par convention ces données sont appelées X :

X = melbourne_data[melbourne_features]

Passons rapidement en revue les données que nous utiliserons pour prédire les prix des logements
à l'aide de la méthode de description et de la méthode de tête, qui ache les premières lignes.

5
#Permet d'afficher les propriétés des variables
X.describe()
#Permet d'afficher les 5 premières données
X.head()

La vérication visuelle de vos données avec ces commandes est une partie importante du travail
d'un data scientist. Vous trouverez fréquemment des surprises dans l'ensemble de données qui
méritent une inspection plus approfondie.

3.4 Construire votre modèle

Vous utiliserez la bibliothèque scikit-learn pour créer vos modèles. Lors du codage, cette
bibliothèque est écrite en tant que sklearn, comme vous le verrez dans l'exemple de code.
Scikit-learn est de loin la bibliothèque la plus populaire pour modéliser les types de données
généralement stockées dans les DataFrames.

Les étapes de création et d'utilisation d'un modèle sont les suivantes :

ˆ Dénir : de quel type de modèle s'agira-t-il ? Un arbre de décision ? Un autre type de

modèle ? Certains autres paramètres du type de modèle sont également spéciés.
ˆ Ajustement : capturez des modèles à partir des données fournies. C'est le coeur de la
modélisation.
ˆ Prédire : à quoi cela ressemble

ˆ Évaluer : déterminer la précision des prédictions du modèle.

Voici un exemple de dénition d'un modèle d'arbre de décision avec scikit-learn et de son
ajustement avec les caractéristiques et la variable cible.

from sklearn.tree import DecisionTreeRegressor

#Mise en place du modèle d'arbre binaire

melbourne_model = DecisionTreeRegressor(random_state=1)

# Fit model
melbourne_model.fit(X, y)

De nombreux modèles d'apprentissage automatique autorisent un certain caractère aléatoire

dans la formation des modèles. Spécier un nombre pour randoms tategarantitquevousobtenezlesmmesrsul

Nous avons maintenant un modèle ajusté que nous pouvons utiliser pour faire des prédictions.En
pratique, vous voudrez faire des prédictions pour les nouvelles maisons qui arrivent sur le marché
plutôt que pour les maisons pour lesquelles nous avons déjà des prix. Mais nous ferons des
prédictions pour les premières lignes des données d'apprentissage pour voir comment fonctionne
la fonction de prédiction.

6
print("Making predictions for the following 5 houses:")
print(X.head())
print("The predictions are")
print(melbourne_model.predict(X.head()))
Vous avez construit un modèle. Mais à quel point est-il bon ?

Dans cette leçon, vous apprendrez à utiliser la validation de modèle pour mesurer la qualité de
votre modèle. La mesure de la qualité des modèles est la clé de l'amélioration itérative de vos
modèles.

4 Validation du modèle

Vous voudrez évaluer presque tous les modèles que vous construisez. Dans la plupart des
applications (mais pas toutes), la mesure pertinente de la qualité du modèle est la précision
prédictive. En d'autres termes, les prédictions du modèle seront-elles proches de ce qui se passe
réellement ?

Beaucoup de gens font une énorme erreur lors de la mesure de la précision prédictive. Ils font des
prédictions avec leurs données d'entraînement et comparent ces prédictions aux valeurs cibles
dans les données d'entraînement. Vous verrez le problème avec cette approche et comment le
résoudre dans un instant, mais rééchissons d'abord à la façon dont nous ferions cela.

Vous devez d'abord résumer la qualité du modèle de manière compréhensible. Si vous comparez
les valeurs prédites et réelles de 10 000 maisons, vous trouverez probablement un mélange de
bonnes et de mauvaises prédictions. Parcourir une liste de 10 000 valeurs prédites et réelles
serait inutile. Nous devons résumer cela en une seule métrique.

Il existe de nombreuses métriques pour résumer la qualité du modèle, mais nous commencerons
par celle appelée Mean Absolute Error (également appelée MAE). Décomposons cette métrique
en commençant par le dernier mot, erreur.
L'erreur de prédiction pour chaque maison est : erreur=réelle-prédite

Donc, si une maison coûte 150 000 et que vous avez prédit qu'elle coûterait 100 000 , l'erreur est
de 50 000. Avec la métrique MAE, on prend la valeur absolue de chaque erreur. Cela convertit
chaque erreur en un nombre positif. Nous prenons ensuite la moyenne de ces erreurs absolues.
C'est notre mesure de la qualité du modèle. En langage clair, on peut dire comme En moyenne,
nos prévisions sont erronées d'environ X.

Pour calculer MAE, nous avons d'abord besoin d'un modèle. Cela est construit dans une cellule
cachée ci-dessous, que vous pouvez consulter en cliquant sur le bouton de code suivant :

from sklearn.metrics importer mean_absolute_error

predicted_home_prices = melbourne_model.predict(X)
mean_absolute_error(y, predicted_home_prices)

4.1 Le problème avec les scores "dans l'échantillon"

La mesure que nous venons de calculer peut être appelée un score "dans l'échantillon". Nous
avons utilisé un seul "échantillon" de maisons à la fois pour construire le modèle et pour

7
l'évaluer. Voici pourquoi c'est mauvais.

Imaginez que, dans le grand marché immobilier, la couleur de la porte n'ait aucun rapport
avec le prix de la maison. Cependant, dans l'échantillon de données que vous avez utilisé pour
construire le modèle, toutes les maisons avec des portes vertes étaient très chères. Le travail du
modèle est de trouver des modèles qui prédisent les prix des maisons, il verra donc ce modèle,
et il prédira toujours des prix élevés pour les maisons avec des portes vertes.

Étant donné que ce modèle a été dérivé des données de formation, le modèle apparaîtra précis
dans les données de formation. Mais si ce modèle ne tient pas lorsque le modèle voit de nouvelles
données, le modèle serait très imprécis lorsqu'il est utilisé dans la pratique.

Étant donné que la valeur pratique des modèles provient de la réalisation de prédictions sur de
nouvelles données, nous mesurons les performances sur des données qui n'ont pas été utilisées
pour construire le modèle. Le moyen le plus simple de procéder consiste à exclure certaines
données du processus de création de modèle, puis à les utiliser pour tester la précision du
modèle sur des données qu'il n'a jamais vues auparavant. Ces données sont appelées données
de validation.

4.2 Le codage
La bibliothèque scikit-learn a une fonction train_test_split pour diviser les données en deux
morceaux. Nous utiliserons certaines de ces données comme données d'entraînement pour
ajuster le modèle, et nous utiliserons les autres données comme données de validation pour
calculer mean_absolute_e rror.
Voici le code :
from sklearn.model_selection import train_test_split

train_X, val_X, train_y, val_y = train_test_split(X, y, random_state = 0)

# Definition du modèle
melbourne_model = DecisionTreeRegressor()

melbourne_model.fit(train_X, train_y)

# Mise en place de la prédiction

val_predictions = melbourne_model.predict(val_X)
print(mean_absolute_error(val_y, val_predictions))

4.3 Conclusion
Votre erreur absolue moyenne pour les données de l'échantillon était d'environ 500 dollars. Hors
échantillon c'est plus de 250 000 dollars. C'est la diérence entre un modèle qui est presque
exactement correct et un autre qui est inutilisable pour la plupart des objectifs pratiques. À
titre de référence, la valeur moyenne des maisons dans les données de validation est de 1,1
million de dollars. Ainsi, l'erreur dans les nouvelles données est d'environ un quart de la valeur
moyenne d'une maison.

Il existe de nombreuses façons d'améliorer ce modèle, comme l'expérimentation pour trouver

de meilleures fonctionnalités ou diérents types de modèles.

8
5 Ajustement du modèle pour une meilleure précision

À la n de cette étape, vous comprendrez les concepts de sous-ajustement et de surajustement,

et vous pourrez appliquer ces idées pour rendre vos modèles plus précis.

5.1 Expérimenter avec diérents modèles

Maintenant que vous disposez d'un moyen able de mesurer la précision du modèle, vous
pouvez expérimenter d'autres modèles et voir lequel donne les meilleures prédictions. Mais
quelles alternatives avez-vous pour les modèles ?

Vous pouvez voir dans la documentation de scikit-learn que le modèle d'arbre de décision a
de nombreuses options (plus que vous ne voudrez ou n'en aurez besoin pendant longtemps).
Les options les plus importantes déterminent la profondeur de l'arbre. Rappelez-vous de la
première leçon de ce cours que la profondeur d'un arbre est une mesure du nombre de divisions
qu'il fait avant d'arriver à une prédiction. C'est un arbre relativement peu profond.

En pratique, il n'est pas rare qu'un arbre ait 10 divisions entre le niveau supérieur (toutes les
maisons) et une feuille. Au fur et à mesure que l'arbre s'approfondit, l'ensemble de données est
découpé en feuilles avec moins de maisons. Si un arbre n'avait qu'une seule division, il divise
les données en 2 groupes. Si chaque groupe est à nouveau divisé, nous obtiendrons 4 groupes de
maisons. Diviser à nouveau chacun de ceux-ci créerait 8 groupes. Si nous continuons à doubler
le nombre de groupes en ajoutant plus de divisions à chaque niveau, nous aurons 2¹ groupes
de maisons au moment où nous arrivons au 10e niveau. C'est 1024 feuilles.

Lorsque nous divisons les maisons entre plusieurs feuilles, nous avons également moins de
maisons dans chaque feuille. Les feuilles avec très peu de maisons feront des prédictions assez
proches des valeurs réelles de ces maisons, mais elles peuvent faire des prédictions très peu
ables pour les nouvelles données (parce que chaque prédiction est basée sur seulement quelques
maisons).

Il s'agit d'un phénomène appelé sur ajustement, où un modèle correspond presque parfaitement
aux données d'entraînement, mais fait mal en validation et autres nouvelles données. D'un autre

9
côté, si nous rendons notre arbre très peu profond, il ne divise pas les maisons en groupes très
distincts.

À l'extrême, si un arbre divise les maisons en seulement 2 ou 4, chaque groupe a encore une
grande variété de maisons. Les prédictions qui en résultent peuvent être éloignées pour la
plupart des maisons, même dans les données de formation (et elles seront également mauvaises
en validation pour la même raison). Lorsqu'un modèle ne parvient pas à capturer des distinctions
et des modèles importants dans les données, il fonctionne donc mal même dans les données
d'apprentissage, c'est ce qu'on appelle le sous-ajustement.

Puisque nous nous soucions de la précision des nouvelles données, que nous estimons à partir
de nos données de validation, nous voulons trouver le juste milieu entre le sous-ajustement et
le sur-ajustement. Visuellement, nous voulons le point bas de la courbe de validation (rouge)
dans la gure ci-dessous.

5.2 Exemple
Il existe quelques alternatives pour contrôler la profondeur de l'arbre, et beaucoup permettent à
certains itinéraires à travers l'arbre d'avoir une plus grande profondeur que d'autres itinéraires.
Mais l'argument max_leaf_nodes fournit un moyen très sensé de contrôler le sur ajustement
par rapport au sous-ajustement. Plus nous permettons au modèle de créer de feuilles, plus
nous nous déplaçons de la zone de sous-ajustement dans le graphique ci-dessus vers la zone de
sur-ajustement.

Nous pouvons utiliser une fonction utilitaire pour aider à comparer les scores MAE à partir de
diérentes valeurs pour max_leaf_nodes :

from sklearn.metrics import mean_absolute_error

10
from sklearn.tree import DecisionTreeRegressor

def get_mae(max_leaf_nodes, train_X, val_X, train_y, val_y):

model = DecisionTreeRegressor(max_leaf_nodes=max_leaf_nodes, random_state=0)
model.fit(train_X, train_y)
preds_val = model.predict(val_X)
mae = mean_absolute_error(val_y, preds_val)
return(mae)

Les données sont chargées dans train_X, val_X, train_y et val_y en utilisant le code que vous
avez déjà vu (et que vous avez déjà écrit).

Nous pouvons utiliser une boucle for pour comparer la précision des modèles construits avec
diérentes valeurs pour max_leaf_nodes.

for max_leaf_nodes in [5, 50, 500, 5000]:

my_mae = get_mae(max_leaf_nodes, train_X, val_X, train_y, val_y)
print("Max leaf nodes: %d \t Mean Absolute Error: %d" %(max_leaf_nodes, my_mae))

5.3 Conclusion
Voici ce qu'il faut retenir : les modèles peuvent sourir de :

ˆ Sur-ajustement : capture de modèles erronés qui ne se reproduiront pas à l'avenir,

conduisant à des prédictions moins précises, ou
ˆ Sous-ajustement : ne pas capturer les modèles pertinents, ce qui conduit à nouveau à des
prédictions moins précises.

Nous utilisons des données de validation, qui ne sont pas utilisées dans la formation de modèles,
pour mesurer la précision d'un modèle candidat. Cela nous permet d'essayer de nombreux
modèles candidats et de garder le meilleur.

6 Modèle Les Forêts aléatoires

Utilisation d'un algorithme d'apprentissage automatique plus sophistiqué.

6.1 Introduction
Les arbres de décision vous laissent avec une décision dicile. Un arbre profond avec beaucoup
de feuilles sera surdimensionné car chaque prédiction provient de données historiques provenant
uniquement des quelques maisons à sa feuille. Mais un arbre peu profond avec peu de feuilles
fonctionnera mal car il ne parvient pas à capturer autant de distinctions dans les données brutes.

Même les techniques de modélisation les plus sophistiquées d'aujourd'hui sont confrontées à
cette tension entre le sous-ajustement et le sur-ajustement. Mais, de nombreux modèles ont
des idées intelligentes qui peuvent conduire à de meilleures performances. Prenons l'exemple

11
de la forêt aléatoire.

La forêt aléatoire utilise de nombreux arbres et fait une prédiction en faisant la moyenne
des prédictions de chaque arbre composant. Il a généralement une bien meilleure précision
prédictive qu'un arbre de décision unique et il fonctionne bien avec les paramètres par défaut.
Si vous continuez à modéliser, vous pouvez apprendre plus de modèles avec des performances
encore meilleures, mais beaucoup d'entre eux sont sensibles à l'obtention des bons paramètres.

6.2 Exemple
Vous avez déjà vu le code pour charger les données à quelques reprises. A la n du chargement
des données, nous avons les variables suivantes :
ˆ train_X

ˆ val_X

ˆ train_y

ˆ val_y

Nous construisons un modèle de forêt aléatoire de la même manière que nous avons construit
un arbre de décision dans scikit-learn - cette fois en utilisant la classe RandomForestRegressor
au lieu de DecisionTreeRegressor.

from sklearn.ensemble import RandomForestRegressor

from sklearn.metrics import mean_absolute_error

forest_model = RandomForestRegressor(random_state=1)
forest_model.fit(train_X, train_y)
melb_preds = forest_model.predict(val_X)
print(mean_absolute_error(val_y, melb_preds))

6.3 Conclusion
Il y a probablement place à amélioration, mais il s'agit d'une grande amélioration par rapport
à la meilleure erreur d'arbre de décision de 250 000. Certains paramètres vous permettent de
modier les performances de la forêt aléatoire de la même manière que nous avons modié la
profondeur maximale de l'arbre de décision unique. Mais l'une des meilleures caractéristiques
des modèles Random Forest est qu'ils fonctionnent généralement raisonnablement même sans
ce réglage.

7 Compétition kaggle

Nous allons travailler sur la mise en place d'un modèle de prédiction des prix des logements
pour les utilisateurs de kaggle learn.

12