Réglage des hyperparamètres à l’aide de la recherche de grille avec Python
Cet article montre comment automatiser le réglage du modèle en Python à l’aide de la technique de recherche par grille. Les data scientists passent souvent une grande partie de leur temps à ajuster les paramètres de leurs modèles de prédiction dans le but de trouver l’ensemble optimal de paramètres. Ce processus est appelé réglage des hyperparamètres. Cependant, le réglage d’hyperparamètres exécuté manuellement peut prendre du temps, car chaque configuration de modèle doit être configurée, entraînée et évaluée. Après avoir lu cet article, vous saurez comment automatiser le processus de recherche des hyperparamètres optimaux.
Le reste de cet article est structuré comme suit. Tout d’abord, nous allons plonger dans le sujet de la recherche d’hyperparamètres optimaux. Ensuite, nous développerons une forêt de décision aléatoire exemplaire qui prédit la survie des passagers du Titanic. Enfin, nous utiliserons la technique de recherche de grille pour tester automatiquement et de manière exhaustive un ensemble de valeurs de paramètres et identifier le modèle qui offre les meilleures performances.
Réglage automatisé des hyperparamètres à l’aide de la technique de recherche de grille
Une manière courante de rechercher automatiquement une configuration de paramètre optimale consiste à utiliser une recherche de grille. La recherche de grille est une technique de recherche exhaustive dans laquelle toutes les permutations possibles d’une grille de paramètres sont testées étape par étape. Nous pouvons appliquer la recherche de grille aux modèles d’apprentissage automatique et tester automatiquement différentes configurations de modèle. En conséquence, nous obtenons un classement des modèles en fonction de leurs performances. Pour que cela fonctionne, nous devons fournir à la grille de recherche les informations suivantes:
- Les hyperparamètres que nous voulons tester
- Pour chaque hyperparamètre une plage de valeurs
- Une métrique de performance pour que l’algorithme sache comment mesurer les performances
Le nombre de modèles créés par la grille de recherche peut être calculé en multipliant le nombre de valeurs définies dans chaque plage de paramètres. Plus loin dans ce didacticiel, nous définirons la grille de recherche pour régler les hyperparamètres d’une forêt de décision aléatoire:
- n_estimateurs, qui détermine le nombre d’arbres de décision,
- profondeur max, qui définit le nombre maximum de branches dans chaque arbre de décision
Fonctionnement de la technique de recherche par grille
Nous spécifions une gamme de [16, 32, and 64] pour n_estimators et une plage de [8, 16, and 32] pour max_depth. De plus, nous spécifions la précision comme métrique pour mesurer les performances. En conséquence, la grille de recherche entraînera et testera un total de neuf (3 x 3 = 9) modèles forestiers aléatoires différents. Ensuite, nous pouvons exécuter l’algorithme de recherche de grille et pendant que nous pouvons nous détendre, la grille de recherche fait tout le travail et détermine la meilleure configuration.
Une grille de recherche avec deux paramètres et trois valeurs de paramètres
Implémentation d’une forêt de décision aléatoire en Python et comment l’optimiser à l’aide de la technique de recherche par grille
Dans ce qui suit, ce didacticiel montre comment optimiser une forêt aléatoire à l’aide d’une grille de recherche en utilisant le jeu de données Titanic comme exemple.
L’exemple couvre les étapes suivantes:
- Chargement des données Titanic
- Prétraitement et exploration des données
- Diviser les données
- Formation d’un seul modèle de forêt aléatoire
- Réglage du modèle à l’aide de la recherche de grille
Conditions préalables
Avant de commencer la partie de codage, assurez-vous que vous avez configuré votre Python 3 environnement et packages requis. Si vous n’avez pas encore configuré d’environnement, vous pouvez suivre ce didacticiel pour configurer le Environnement Anaconda.
Assurez-vous également d’installer tous les packages requis. Dans ce didacticiel, nous travaillerons avec les packages standard suivants:
De plus, nous utiliserons la bibliothèque d’apprentissage automatique Scikit-learn.
Vous pouvez installer des packages à l’aide des commandes de la console:
- installation de pip
- installation de conda
(si vous utilisez le gestionnaire de paquets anaconda)
Étape # 1 Chargement des données Titanic
Nous commençons par charger ensemble de données titanesques du site Web de Kaggle – l’un des ensembles de données les plus connus pour démontrer la classification. Une fois le téléchargement terminé, placez l’ensemble de données sous le chemin du fichier de votre choix. Cependant, n’oubliez pas d’ajuster le chemin du fichier dans le code. Si vous travaillez avec l’environnement Kaggle Python, vous pouvez également enregistrer directement l’ensemble de données dans votre projet Kaggle.
L’ensemble de données titanic contient les informations suivantes sur les passagers du titanic:
- Survie: Survie 0 = Non, 1 = Oui (étiquette de prédiction)
- Pclasse: Classe de billets 1 = 1er, 2 = 2ème, 3 = 3ème
- Sexe: Sexe
- Âge: Age en années
- SibSp: # de frères et sœurs / conjoints à bord du Titanic
- Dessécher: # de parents / enfants à bord du Titanic
- Billet: Numéro de billet
- Tarif: Tarif passager
- Cabine: Numéro de cabine
- Embarqué: Port d’embarquement C = Cherbourg, Q = Queenstown, S = Southampton
La colonne «Survie» contient l’étiquette de prédiction, qui indique si un passager a survécu au naufrage ou non. Nous pouvons utiliser ces données pour former un classificateur qui prédit les passagers qui survivront au naufrage et ceux qui ne survivront pas. Le code suivant chargera les données dans notre projet python.
import math import numpy as np import pandas as pd import matplotlib.pyplot as plt from sklearn.metrics import confusion_matrix from sklearn.model_selection import GridSearchCV from sklearn.ensemble import RandomForestClassifier import seaborn as sns from pandas.plotting import register_matplotlib_converters # set file path filepath = "data/titanic-grid-search/" # Load train and test datasets titanic_train_df = pd.read_csv(filepath + 'titanic-train.csv') titanic_test_df = pd.read_csv(filepath + 'titanic-test.csv') titanic_train_df.head()
Étape # 2 Prétraitement et exploration des données
Avant de pouvoir entraîner un modèle, nous devons d’abord prétraiter les données. Cela nécessitera plusieurs étapes: Premièrement, nous nettoyons les valeurs manquantes dans les données et les remplaçons par la moyenne. Deuxièmement, nous transformerons les caractéristiques catégorielles (Embarqué et Sexe) en valeurs numériques. De plus, nous supprimerons certaines colonnes pour réduire la complexité du modèle. Enfin, nous supprimerons l’étiquette de prédiction de l’ensemble de données d’entraînement et le placerons dans un ensemble de données distinct nommé y_df.
# Define a preprocessing function
def preprocess(dfx):
df = dfx.copy()
# Deleting some columns from the data
new_df = df[df.columns[~df.columns.isin(['Survived', 'Cabin', 'PassengerId', 'Name', 'Ticket'])]]
# Replace missing values
new_df.fillna(df.mean(), inplace=True)
new_df['Embarked'].fillna('C', inplace=True)
# Convert categorical values to integer
new_df_b = new_df.copy()
new_df_b['Sex'] = np.where(new_df_b['Sex']=='male', 0, 1)
new_df_b['Embarked'].mask(new_df_b['Embarked']=='S', '1', inplace=True)
new_df_b['Embarked'].mask(new_df_b['Embarked']=='Q', '2', inplace=True)
new_df_b['Embarked'].mask(new_df_b['Embarked']=='C', '3', inplace=True)
return new_df_b
# Create train_df & test_df
x_df = preprocess(titanic_train_df).copy()
y_df = titanic_train_df['Survived'].copy()
x_df.head()
Examinons rapidement les données en créant des histogrammes pour les colonnes de notre ensemble de données.
# Histograms for each column
register_matplotlib_converters()
nrows = 2; ncols = int(round(x_df.shape[1] / nrows, 0))
fig, ax = plt.subplots(nrows=nrows, ncols=ncols, sharex=False, figsize=(16, 10))
fig.subplots_adjust(hspace=0.2, wspace=0.2)
columns = x_df.columns
f = 0
for i in range(nrows):
for j in range(ncols):
if f <= x_df.shape[1]-1:
assetname = columns[f]
y = x_df[assetname]
ax[i, j].hist(y, color='#039dfc', label=assetname, bins='auto')
#ax[i, j].set_xlim([y.max(), y.min()])
f += 1
ax[i, j].set_title(assetname)
plt.show()
Les histogrammes nous disent diverses choses. Par exemple, nous constatons que la plupart des passagers avaient entre 25 et 35 ans. De plus, nous pouvons voir que la plupart des passagers avaient des billets à bas prix, tandis que certains passagers avaient des billets beaucoup plus chers. Cela semble logique, puisque la plupart des passagers ont des billets de 3ème classe.
Étape # 3 Fractionnement des données
Ensuite, nous diviserons l'ensemble de données en données d'entraînement (x_train, y_train) et en données de test (x_test, y_test) en utilisant un rapport de division de 70/30.
# Split the data into x_train and y_train data sets x_train, x_test, y_train, y_test = train_test_split(x_df, y_df, train_size=0.7, random_state=0)
Étape # 4 Construction d'un modèle de forêt aléatoire unique
Maintenant que nous avons terminé le prétraitement, nous pouvons former un premier modèle. Le modèle que nous allons entraîner utilise une forêt aléatoire
4.1 À propos de l'algorithme de forêt aléatoire
Une forêt aléatoire est un puissant algorithme d'apprentissage automatique qui peut être utilisé pour les tâches de classification et de régression. Contrairement à un arbre de décision, la forêt de décision est un modèle d'ensemble qui combine les résultats de nombreux arbres de décision différents pour prendre les meilleures décisions possibles. L'algorithme entraîne de nombreux arbres de décision et chaque arbre a un vote sur le résultat global de la prédiction.
Un modèle de forêt aléatoire a une large gamme d'hyperparamètres avec lesquels nous pouvons contrôler les caractéristiques des arbres de décision et du modèle d'ensemble. Cependant, par souci de simplicité, nous n'en contrôlerons que deux et utiliserons la valeur par défaut pour tous les autres paramètres:
- Le nombre d'estimateurs dans le modèle d'ensemble (n_estimators)
- La profondeur maximale de l'arbre de décision de recherche dans le modèle d'ensemble (max_depth)
4.2 Mise en œuvre d'un modèle de forêt aléatoire
Le code suivant entraînera d'abord le modèle de forêt aléatoire, puis effectuera une prédiction de test avec le jeu de données x_test, et enfin visualisera les performances du modèle dans une matrice de confusion:
# Train a single random forest classifier
clf = RandomForestClassifier(max_depth=2, random_state=0, n_estimators = 100)
clf.fit(x_train, y_train)
y_pred = clf.predict(x_test)
# Create a confusion matrix
cnf_matrix = confusion_matrix(y_test, y_pred)
# Create heatmap from the confusion matrix
%matplotlib inline
class_names=[False, True] # name of classes
fig, ax = plt.subplots(figsize=(7, 6))
sns.heatmap(pd.DataFrame(cnf_matrix), annot=True, cmap="YlGnBu", fmt='g')
ax.xaxis.set_label_position("top")
plt.tight_layout()
plt.title('Confusion matrix')
plt.ylabel('Actual label')
plt.xlabel('Predicted label')
tick_marks = [0.5, 1.5]
plt.xticks(tick_marks, class_names)
plt.yticks(tick_marks, class_names)
Le nombre de cas correctement classés par notre modèle est indiqué dans les carrés en haut à gauche et en bas à droite de la matrice. Notre modèle de meilleure estimation a correctement prédit que 151 passagers ne survivraient pas et que 64 survivraient au naufrage. Dans 53 cas, le modèle était erroné. Au total, ces résultats correspondent à une précision du modèle de 80%. Étant donné que le choix des paramètres n'était qu'une meilleure estimation, ces résultats sont étonnamment bons. Cependant, en utilisant le réglage automatisé des hyperparamètres, nous devrions être en mesure d'identifier un modèle qui surpasse ces résultats.
Étape # 5 Réglage des hyperparamètres à l'aide de la technique de recherche de grille
Voyons si nous pouvons battre les résultats de notre meilleur modèle de supposition en utilisant la recherche par grille. Tout d'abord, nous allons définir une plage de paramètres, puis demander au modèle de forêt aléatoire de tester toute combinaison de paramètres.
# Define Parameters
max_depth=[2, 8, 16]
n_estimators = [64, 128, 256]
param_grid = dict(max_depth=max_depth, n_estimators=n_estimators)
# Build the gridsearch
dfrst = RandomForestClassifier(n_estimators=n_estimators, max_depth=max_depth)
grid = GridSearchCV(estimator=dfrst, param_grid=param_grid, cv = 5)
grid_results = grid.fit(x_train, y_train)
# Summarize the results in a readable format
print("Best: {0}, using {1}".format(grid_results.cv_results_['mean_test_score'], grid_results.best_params_))
results_df = pd.DataFrame(grid_results.cv_results_)
results_df
La liste ci-dessus est un aperçu des modèles testés, classés en fonction de leurs scores de prédiction. Le modèle numéro cinq a obtenu les meilleurs résultats. Les paramètres de ce modèle sont une profondeur maximale de 8 et un nombre d'estimateurs de 256.
Ensuite, nous sélectionnerons le meilleur modèle et l'utiliserons pour faire une prédiction sur l'ensemble de données de test. Ensuite, nous visualiserons les résultats dans une autre matrice de confusion que nous pourrons comparer au modèle initial.
# Extract the best decision forest
best_clf = grid_results.best_estimator_
y_pred = best_clf.predict(x_test)
# Create a confusion matrix
cnf_matrix = confusion_matrix(y_test, y_pred)
# Create heatmap from the confusion matrix
%matplotlib inline
class_names=[False, True] # name of classes
fig, ax = plt.subplots(figsize=(7, 6))
sns.heatmap(pd.DataFrame(cnf_matrix), annot=True, cmap="YlGnBu", fmt='g')
ax.xaxis.set_label_position("top")
plt.tight_layout()
plt.title('Confusion matrix')
plt.ylabel('Actual label')
plt.xlabel('Predicted label')
tick_marks = [0.5, 1.5]
plt.xticks(tick_marks, class_names)
plt.yticks(tick_marks, class_names)
La matrice de confusion montre les résultats de notre modèle que nous avons optimisé avec la technique de recherche de grille. Nous pouvons voir que notre modèle a correctement classé que 148 passagers ne survivraient pas et que 76 passagers survivraient. Dans 44 cas, le modèle était erroné. Cela se traduit par une précision globale du modèle de 83,5% et démontre que les performances du meilleur modèle de recherche de grille surpassent clairement notre modèle initial de meilleure estimation.
Résumé
Dans ce didacticiel, vous avez appris à automatiser le processus de réglage des hyperparamètres d'un modèle d'apprentissage automatique. Nous avons démontré que la recherche par grille est une méthode utile qui peut être appliquée pour optimiser presque tous les modèles d'apprentissage automatique. Donc, si vous comprenez le processus, vous pouvez rendre le développement de modèles beaucoup plus efficace. Plus précisément, vous avez appris à définir une grille de paramètres et à l'utiliser pour trouver l'ensemble optimal de paramètres pour une forêt de décision aléatoire qui prédit la survie des passagers du Titanic. Nous avons vu que la technique de recherche par grille était facilement capable de trouver un modèle qui surpasse notre meilleur modèle de supposition.
J'espère que vous avez trouvé ce tutoriel utile. Si vous avez des questions ou des suggestions, n'hésitez pas à me le faire savoir dans les commentaires.
Source de l'article
