Apprentissage Automatique et Réseaux Neuronaux - page 75

[MetaQuotes]

13.4.2 Importance de la permutation des fonctionnalités (L13 : sélection des fonctionnalités)

13.4.2 Importance de la permutation des fonctionnalités (L13 : sélection des fonctionnalités)

Bienvenue dans cette vidéo où nous allons approfondir le sujet de l'importance de la permutation. L'importance de la permutation fait partie des méthodes wrapper pour la sélection des fonctionnalités, dont nous avons brièvement discuté dans la vidéo précédente. Les méthodes wrapper impliquent l'utilisation d'un modèle pour effectuer la sélection des caractéristiques ou estimer l'importance des caractéristiques. Dans une conférence précédente, nous avons exploré l'élimination récursive de caractéristiques comme exemple de méthode wrapper. Maintenant, nous allons nous concentrer sur l'importance de la permutation. Dans les prochaines vidéos, nous explorerons également une autre méthode appelée sélection séquentielle de fonctionnalités.

Avant de plonger dans les moindres détails du fonctionnement de l'importance de la permutation, permettez-moi de vous donner un aperçu concis de la méthode. Essentiellement, l'importance de la permutation implique de mélanger chaque colonne de caractéristiques dans un jeu de données. Ensuite, à l'aide d'un modèle déjà formé, nous évaluons les performances du modèle sur l'ensemble de données mélangé et le comparons aux performances d'origine. En règle générale, nous observons une baisse des performances lorsqu'une colonne de caractéristiques est mélangée. Cette baisse de performance sert d'indicateur de l'importance de la fonctionnalité. Bien sûr, résumer la méthode en seulement deux étapes peut sembler un peu compliqué, donc dans les prochaines diapositives, je vous expliquerai le processus de manière plus détaillée et plus lente.

En appliquant l'importance de la permutation à chaque colonne de l'ensemble de données, nous pouvons générer un diagramme à barres illustrant l'importance de chaque caractéristique. De plus, nous pouvons éventuellement inclure l'écart type des valeurs d'importance dans le graphique. Dans la vidéo à venir, je fournirai un exemple de code sur la façon de créer un tel tracé.

Maintenant, avant de plonger dans l'explication détaillée de l'importance de la permutation et de l'algorithme qui la sous-tend, passons en revue quelques faits remarquables. L'importance de la permutation donne souvent des résultats similaires à l'importance aléatoire des caractéristiques forestières basée sur l'impureté. Cependant, l'avantage de l'importance de la permutation est qu'elle est indépendante du modèle, ce qui signifie qu'elle peut être utilisée avec n'importe quel type d'algorithme ou de modèle d'apprentissage automatique. Il est important de noter que même si l'importance de la permutation n'est pas strictement une méthode de sélection de caractéristiques, elle fournit des informations sur les caractéristiques sur lesquelles un modèle s'appuie le plus. Par conséquent, nous pouvons utiliser des mesures d'importance des caractéristiques comme base de sélection des caractéristiques.

Si vous vous souvenez de notre discussion précédente sur l'importance des caractéristiques de la forêt aléatoire, vous pouvez considérer l'importance de la permutation comme une généralisation de l'une des méthodes, en particulier la méthode B, dans cette vidéo. Cependant, au lieu d'utiliser des échantillons hors sac, l'importance de la permutation utilise l'ensemble retenu. Si vous avez besoin d'un rappel sur les exemples prêts à l'emploi, n'hésitez pas à revoir la vidéo précédente.

Maintenant, plongeons dans l'algorithme étape par étape de l'importance de la permutation. Tout d'abord, nous commençons avec un modèle qui a été adapté à l'ensemble d'apprentissage. Ce modèle peut être n'importe quel modèle ou algorithme d'apprentissage automatique. À titre d'exemple, considérons un classificateur de forêt aléatoire. Nous entraînons la forêt aléatoire sur l'ensemble d'apprentissage, ce qui est une étape standard.

Ensuite, nous estimons les performances prédictives du modèle sur un ensemble de données indépendant, tel que l'ensemble de validation ou l'ensemble de test. Nous enregistrons cette performance comme performance de base. Par exemple, disons que nous obtenons une précision de 99 % sur l'ensemble de validation en utilisant notre modèle de forêt aléatoire ajusté. Nous considérons cela comme la performance de base.

Pour chaque colonne de caractéristiques de l'ensemble de données, nous mélangeons au hasard cette colonne spécifique tout en gardant les autres colonnes et étiquettes de classe inchangées. Ce processus de brassage est illustré par un exemple de jeu de données. Supposons que nous ayons un ensemble de données avec trois colonnes de caractéristiques et quatre exemples de formation. Nous nous concentrons sur le mélange de la première colonne, représentée par une couleur différente dans l'exemple. Après le brassage, l'ordre des valeurs dans cette colonne change. Nous permutons aléatoirement les valeurs tout en conservant les valeurs d'origine dans les colonnes deux et trois.

Un autre avantage de l'importance de la permutation est qu'elle peut bien gérer les caractéristiques corrélées. Puisqu'il évalue l'importance de chaque fonctionnalité individuellement en mélangeant ses valeurs, il capture la contribution unique de chaque fonctionnalité aux performances du modèle, quelles que soient les corrélations avec d'autres fonctionnalités. Ceci est particulièrement utile dans les scénarios où il existe des ensembles de données de grande dimension avec des fonctionnalités interdépendantes.

L'importance de la permutation fournit également une mesure de l'importance des caractéristiques qui est plus fiable que l'importance inhérente des caractéristiques fournie par certains modèles. Par exemple, dans les arbres de décision ou les forêts aléatoires, l'importance d'une caractéristique est basée sur la réduction des impuretés qu'elle obtient lors du fractionnement des données. Cependant, cette mesure peut être biaisée vers les fonctionnalités avec de nombreuses divisions possibles ou celles qui apparaissent plus haut dans l'arborescence. L'importance de la permutation fournit une estimation plus directe et impartiale de l'importance des fonctionnalités en évaluant directement l'impact du mélange de chaque fonctionnalité.

En revanche, l'importance de la permutation peut être coûteuse en calcul, en particulier si le processus de formation du modèle prend du temps ou s'il existe un grand nombre de fonctionnalités. Étant donné que le processus de permutation nécessite de réévaluer les performances du modèle plusieurs fois, il peut ajouter une surcharge importante. Cependant, il existe des techniques d'optimisation et des stratégies de parallélisation qui peuvent aider à atténuer ce problème, comme l'utilisation du calcul parallèle ou la réduction du nombre de permutations.

Il convient de noter que l'importance de la permutation n'est pas une solution miracle pour la sélection des fonctionnalités ou l'interprétation du modèle. Bien qu'il fournisse des informations précieuses sur l'importance des fonctionnalités individuelles, il doit être utilisé conjointement avec d'autres techniques et connaissances du domaine. L'importance de la caractéristique seule ne garantit pas le pouvoir prédictif ou la pertinence d'une caractéristique. Il est essentiel de tenir compte du contexte, du problème spécifique et des limites du modèle.

En résumé, l'importance de la permutation est une méthode puissante et indépendante du modèle pour évaluer l'importance des fonctionnalités dans un modèle d'apprentissage automatique. En mélangeant les valeurs des caractéristiques et en comparant les performances du modèle avant et après le mélange, il fournit une mesure fiable de l'importance des caractéristiques. Il est facile à comprendre, gère bien les caractéristiques corrélées et n'est pas susceptible de surajustement. Cependant, il peut être coûteux en calcul et doit être utilisé avec d'autres techniques pour une sélection complète des caractéristiques et une interprétation du modèle.

[MetaQuotes]

13.4.3 Exemples de code d'importance de permutation de fonctionnalité (L13 : Sélection de fonctionnalité)

13.4.3 Exemples de code d'importance de permutation de fonctionnalité (L13 : Sélection de fonctionnalité)

Très bien, maintenant que nous avons couvert l'introduction de base à l'importance de la permutation, examinons quelques exemples de code pour voir comment nous pouvons utiliser l'importance de la permutation dans la pratique. Oui, et comme toujours, j'ai aussi les exemples de code dans Jupyter Notebooks liés sous la vidéo. Et aussi, contrairement à toujours, nous travaillerons à nouveau avec un ensemble de données de vent, juste pour garder les choses simples.

Ainsi, le jeu de données sur le vent, encore une fois, est un jeu de données composé de 13 colonnes. Et voici un aperçu de l'apparence des cinq premières lignes. Il y a donc trois classes, la classe un, deux et trois. Et il y a 13 colonnes, mais toutes les colonnes ne sont pas affichées ici en raison de contraintes d'espace. Mais oui, nous ne discuterons pas de cet ensemble de données de vent trop en détail, car nous l'avons vu tant de fois auparavant.

Oui, et puis aussi, comme toujours, nous diviserons l'ensemble de données en un ensemble d'entraînement et un ensemble de test. Donc ici, ce que nous faisons, c'est que nous prenons l'ensemble de données, à l'exception de la première colonne, qui est la colonne d'étiquette. Nous allons donc diviser l'ensemble de données en un ensemble d'entraînement et un ensemble de test où 30 % des données sont utilisées pour les tests et 70 % seront utilisées pour l'entraînement en conséquence. Notez ici que nous ne créons aucun ensemble de validation. Ce n'est donc que mon avis personnel. Mais je ne pense pas que nous ayons nécessairement besoin d'un ensemble de validation si nous calculons les performances de permutation car oui, nous devrions généralement garder notre ensemble de test indépendant. Mais si vous repensez au fonctionnement des performances de permutation, sur la base de la vidéo précédente, nous ne regardons ici que la baisse des performances lorsque nous permutons une colonne de fonctionnalités. Nous ne recalculons donc pas vraiment la précision du test, nous utilisons simplement l'ensemble de test pour voir dans quelle mesure les performances chuteront si nous mélangeons une colonne.

Oui, nous sommes encore dans la phase de configuration ici. Donc ici, dans cette diapositive, nous préparons notre modèle. Et en fait, ici c'est un classificateur de forêt aléatoire. Ainsi, dans la vidéo précédente, nous avons appris que l'importance de la permutation est une méthode indépendante du modèle. Cela signifie que nous pouvons calculer cela pour n'importe quel type de modèle. Cependant, nous utilisons ici une forêt aléatoire afin de pouvoir ensuite comparer l'importance de la permutation à la performance basée sur les impuretés de la forêt aléatoire, ce qui pourrait être une comparaison intéressante. Donc ici, nous mettons en place un classificateur de forêt aléatoire avec 100 arbres. Et nous l'adaptons à l'ensemble d'entraînement. Et voici juste le calcul de précision. Et nous pouvons voir que la précision de la formation est de 100 % et que la précision du test est également de 100 %, ce qui indique qu'il s'agit en fait d'un assez bon modèle, ou cela peut aussi simplement indiquer que l'ensemble de données est assez facile à classer.

Une chose que je voulais également noter ici est que lorsque nous calculons l'importance de la permutation, il est assez important d'avoir un modèle très performant si nous voulons interpréter l'importance de la caractéristique comme une importance générale de la caractéristique. Parce que si nous n'avons pas un modèle qui fonctionne bien, nous pourrions découvrir sur quelles fonctionnalités le modèle s'appuie le plus, mais cela ne nous dit pas vraiment, disons, à quel point la fonctionnalité est importante dans le contexte de la variable cible si le modèle n'est pas très précis. Donc, avant de regarder l'importance de la permutation, juste pour référence, voici à nouveau l'importance basée sur les impuretés. Il s'agit donc de l'importance aléatoire basée sur les impuretés de la forêt dont nous avons déjà discuté dans une vidéo précédente. Encore une fois, c'est juste pour référence, où nous accédons à cet attribut d'importance des fonctionnalités après avoir ajusté le modèle.

Ensuite, nous appliquons arg_sort, de sorte que nous obtenons l'ordre de tri des valeurs d'importance de la plus grande à la plus petite. Donc, du plus grand au plus petit. Et puis ce que nous faisons est de créer un graphique à barres pour visualiser l'importance basée sur les impuretés. Le diagramme à barres affichera les noms des caractéristiques sur l'axe des x et les valeurs d'importance correspondantes sur l'axe des y. En triant les valeurs d'importance par ordre décroissant, les caractéristiques les plus importantes seront tracées en premier.

Ensuite, le code passe au calcul de l'importance de la permutation. L'importance de la permutation est calculée en mélangeant de manière aléatoire les valeurs de chaque caractéristique dans l'ensemble de test et en mesurant la baisse des performances du modèle. Plus la baisse des performances est élevée, plus la fonctionnalité est considérée comme importante. Le code utilise une boucle for pour itérer sur chaque entité du jeu de données.

À l'intérieur de la boucle, les valeurs des caractéristiques de l'ensemble de test sont mélangées à l'aide de np.random.permutation(). Ensuite, l'ensemble de test mélangé est passé à travers le classificateur de forêt aléatoire formé pour obtenir les étiquettes prédites. La précision du modèle sur l'ensemble de test mélangé est calculée à l'aide de la fonction precision_score(). La différence entre la précision du test d'origine et la précision du test mélangé représente la baisse des performances causée par la permutation de la fonctionnalité.

La baisse des performances de chaque fonctionnalité est stockée dans une liste appelée importance_vals. Après avoir parcouru toutes les fonctionnalités, la liste importance_vals contient la baisse des valeurs de performances pour chaque fonctionnalité.

Enfin, un graphique à barres est créé pour visualiser l'importance de la permutation. Les noms des caractéristiques sont tracés sur l'axe des x et la baisse correspondante des valeurs de performance est tracée sur l'axe des y. Encore une fois, les valeurs d'importance sont triées par ordre décroissant pour mettre en évidence les caractéristiques les plus importantes.

Ce code fournit une comparaison entre l'importance basée sur les impuretés et l'importance de la permutation. En comparant les deux tracés, vous pouvez observer s'il existe des différences dans le classement de l'importance des caractéristiques entre les deux méthodes.

import matplotlib.pyplot as plt
import numpy as np
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_iris
from sklearn.metrics import accuracy_score

# Load the Iris dataset
iris = load_iris()
X = iris.data
y = iris.target

# Create a random forest classifier
clf = RandomForestClassifier(n_estimators= 100 , random_state= 42 )
clf.fit(X, y)

# Compute impurity-based feature importances
importances = clf.feature_importances_

# Plot impurity-based feature importances
plt.figure(figsize=( 8 , 6 ))
plt.bar(range(X.shape[ 1 ]), importances, align= 'center' )
plt.xticks(range(X.shape[ 1 ]), iris.feature_names, rotation= 90 )
plt.xlabel( 'Features' )
plt.ylabel( 'Importance' )
plt.title( 'Impurity-based Feature Importances' )
plt.show()

# Compute permutation importances
importance_vals = []
for feature in range(X.shape[ 1 ]):
    X_permuted = X.copy()
    np.random.shuffle(X_permuted[:, feature])
    y_pred = clf.predict(X_permuted)
    accuracy = accuracy_score(y, y_pred)
    drop_in_performance = accuracy_score(y, y_pred) - accuracy
    importance_vals.append(drop_in_performance)

# Plot permutation importances
plt.figure(figsize=( 8 , 6 ))
plt.bar(range(X.shape[ 1 ]), importance_vals, align= 'center' )
plt.xticks(range(X.shape[ 1 ]), iris.feature_names, rotation= 90 )
plt.xlabel( 'Features' )
plt.ylabel( 'Drop in Performance' )
plt.title( 'Permutation Importances' )
plt.show()

Ce code créera deux diagrammes à barres côte à côte. Le premier graphique montrera les importances des caractéristiques basées sur les impuretés, et le deuxième graphique montrera les importances de permutation. En examinant ces tracés, vous pouvez mieux comprendre l'importance relative des différentes caractéristiques dans le jeu de données Iris selon ces deux méthodes.

Assurez-vous d'avoir importé les bibliothèques nécessaires, telles que matplotlib, numpy, sklearn.ensemble.RandomForestClassifier, sklearn.datasets.load_iris et sklearn.metrics.accuracy_score.

import matplotlib.pyplot as plt
import numpy as np
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_iris
from sklearn.inspection import permutation_importance
from sklearn.model_selection import train_test_split

# Load the Iris dataset
iris = load_iris()
X = iris.data
y = iris.target

# Split the data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size= 0.2 , random_state= 42 )

# Create a random forest classifier
clf = RandomForestClassifier(n_estimators= 100 , random_state= 42 )
clf.fit(X_train, y_train)

# Perform permutation importances
result = permutation_importance(clf, X_test, y_test, n_repeats= 10 , random_state= 42 , n_jobs=- 1 )

# Get the feature importances and their indices
importances = result.importances_mean
indices = np.argsort(importances)

# Plot permutation importances
plt.figure(figsize=( 8 , 6 ))
plt.barh(range(X.shape[ 1 ]), importances[indices], align= 'center' )
plt.yticks(range(X.shape[ 1 ]), iris.feature_names[indices])
plt.xlabel( 'Importance' )
plt.ylabel( 'Features' )
plt.title( 'Permutation Importances' )
plt.show()

Dans ce code, nous utilisons la fonction permutation_importance du module sklearn.inspection pour calculer les importances de permutation. L'ensemble de données est divisé en ensembles d'apprentissage et de test à l'aide de train_test_split. Nous ajustons ensuite un classificateur de forêt aléatoire sur les données d'apprentissage et calculons les importances de permutation à l'aide des données de test.

Les importances de permutation résultantes sont stockées dans la variable d'importances. Nous utilisons np.argsort pour obtenir les indices qui trieraient les importances par ordre croissant. Cela aide à tracer les importances dans le bon ordre.

Enfin, nous créons un graphique à barres horizontales en utilisant plt.barh pour afficher les importances de permutation. L'axe des y représente les caractéristiques, tandis que l'axe des x représente les valeurs d'importance. Les fonctions plt.xlabel, plt.ylabel et plt.title sont utilisées pour ajouter des étiquettes et un titre au tracé.

Assurez-vous d'avoir importé les bibliothèques nécessaires, telles que matplotlib, numpy, sklearn.ensemble.RandomForestClassifier, sklearn.datasets.load_iris, sklearn.inspection.permutation_importance et sklearn.model_selection.train_test_split.

import matplotlib.pyplot as plt
import numpy as np
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_iris
from sklearn.inspection import permutation_importance
from sklearn.model_selection import train_test_split

# Load the Iris dataset
iris = load_iris()
X = iris.data
y = iris.target

# Split the data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size= 0.2 , random_state= 42 )

# Create a random forest classifier
clf = RandomForestClassifier(n_estimators= 100 , random_state= 42 )
clf.fit(X_train, y_train)

# Perform permutation importances
result = permutation_importance(clf, X_test, y_test, n_repeats= 10 , random_state= 42 , n_jobs=- 1 )

# Get the feature importances and their indices
importances = result.importances_mean
indices = np.argsort(importances)

# Plot permutation importances
plt.figure(figsize=( 8 , 6 ))
plt.barh(range(X.shape[ 1 ]), importances[indices], align= 'center' )
plt.yticks(range(X.shape[ 1 ]), iris.feature_names[indices])
plt.xlabel( 'Importance' )
plt.ylabel( 'Features' )
plt.title( 'Permutation Importances' )
plt.show()

Dans ce code, nous utilisons la fonction permutation_importance du module sklearn.inspection pour calculer les importances de permutation. L'ensemble de données est divisé en ensembles d'apprentissage et de test à l'aide de train_test_split. Nous ajustons ensuite un classificateur de forêt aléatoire sur les données d'apprentissage et calculons les importances de permutation à l'aide des données de test.

Les importances de permutation résultantes sont stockées dans la variable d'importances. Nous utilisons np.argsort pour obtenir les indices qui trieraient les importances par ordre croissant. Cela aide à tracer les importances dans le bon ordre.

Enfin, nous créons un graphique à barres horizontales en utilisant plt.barh pour afficher les importances de permutation. L'axe des y représente les caractéristiques, tandis que l'axe des x représente les valeurs d'importance. Les fonctions plt.xlabel, plt.ylabel et plt.title sont utilisées pour ajouter des étiquettes et un titre au tracé.

Assurez-vous d'avoir importé les bibliothèques nécessaires, telles que matplotlib, numpy, sklearn.ensemble.RandomForestClassifier, sklearn.datasets.load_iris, sklearn.inspection.permutation_importance et sklearn.model_selection.train_test_split.

[MetaQuotes]

13.4.3 Exemples de code d'importance de permutation de fonctionnalité (L13 : Sélection de fonctionnalité)

13.4.3 Exemples de code d'importance de permutation de fonctionnalité (L13 : Sélection de fonctionnalité)

Très bien, maintenant que nous avons couvert l'introduction de base à l'importance de la permutation, examinons quelques exemples de code pour voir comment nous pouvons utiliser l'importance de la permutation dans la pratique. Oui, et comme toujours, j'ai aussi les exemples de code dans Jupyter Notebooks liés sous la vidéo. Et aussi, contrairement à toujours, nous travaillerons à nouveau avec un ensemble de données de vent, juste pour garder les choses simples.

Ainsi, le jeu de données sur le vent, encore une fois, est un jeu de données composé de 13 colonnes. Et voici un aperçu de l'apparence des cinq premières lignes. Il y a donc trois classes, la classe un, deux et trois. Et il y a 13 colonnes, mais toutes les colonnes ne sont pas affichées ici en raison de contraintes d'espace. Mais oui, nous ne discuterons pas de cet ensemble de données de vent trop en détail, car nous l'avons vu tant de fois auparavant.

Oui, et puis aussi, comme toujours, nous diviserons l'ensemble de données en un ensemble d'entraînement et un ensemble de test. Donc ici, ce que nous faisons, c'est que nous prenons l'ensemble de données, à l'exception de la première colonne, qui est la colonne d'étiquette. Nous allons donc diviser l'ensemble de données en un ensemble d'entraînement et un ensemble de test où 30 % des données sont utilisées pour les tests et 70 % seront utilisées pour l'entraînement en conséquence. Notez ici que nous ne créons aucun ensemble de validation. Ce n'est donc que mon avis personnel. Mais je ne pense pas que nous ayons nécessairement besoin d'un ensemble de validation si nous calculons les performances de permutation car oui, nous devrions généralement garder notre ensemble de test indépendant. Mais si vous repensez au fonctionnement des performances de permutation, sur la base de la vidéo précédente, nous ne regardons ici que la baisse des performances lorsque nous permutons une colonne de fonctionnalités. Nous ne recalculons donc pas vraiment la précision du test, nous utilisons simplement l'ensemble de test pour voir dans quelle mesure les performances chuteront si nous mélangeons une colonne.

Oui, nous sommes encore dans la phase de configuration ici. Donc ici, dans cette diapositive, nous préparons notre modèle. Et en fait, ici c'est un classificateur de forêt aléatoire. Ainsi, dans la vidéo précédente, nous avons appris que l'importance de la permutation est une méthode indépendante du modèle. Cela signifie que nous pouvons calculer cela pour n'importe quel type de modèle. Cependant, nous utilisons ici une forêt aléatoire afin de pouvoir ensuite comparer l'importance de la permutation à la performance basée sur les impuretés de la forêt aléatoire, ce qui pourrait être une comparaison intéressante. Donc ici, nous mettons en place un classificateur de forêt aléatoire avec 100 arbres. Et nous l'adaptons à l'ensemble d'entraînement. Et voici juste le calcul de précision. Et nous pouvons voir que la précision de la formation est de 100 % et que la précision du test est également de 100 %, ce qui indique qu'il s'agit en fait d'un assez bon modèle, ou cela peut aussi simplement indiquer que l'ensemble de données est assez facile à classer.

Une chose que je voulais également noter ici est que lorsque nous calculons l'importance de la permutation, il est assez important d'avoir un modèle très performant si nous voulons interpréter l'importance de la caractéristique comme une importance générale de la caractéristique. Parce que si nous n'avons pas un modèle qui fonctionne bien, nous pourrions découvrir sur quelles fonctionnalités le modèle s'appuie le plus, mais cela ne nous dit pas vraiment, disons, à quel point la fonctionnalité est importante dans le contexte de la variable cible si le modèle n'est pas très précis. Donc, avant de regarder l'importance de la permutation, juste pour référence, voici à nouveau l'importance basée sur les impuretés. Il s'agit donc de l'importance aléatoire basée sur les impuretés de la forêt dont nous avons déjà discuté dans une vidéo précédente. Encore une fois, c'est juste pour référence, où nous accédons à cet attribut d'importance des fonctionnalités après avoir ajusté le modèle.

Ensuite, nous appliquons arg_sort, de sorte que nous obtenons l'ordre de tri des valeurs d'importance de la plus grande à la plus petite. Donc, du plus grand au plus petit. Et puis ce que nous faisons est de créer un graphique à barres pour visualiser l'importance basée sur les impuretés. Le diagramme à barres affichera les noms des caractéristiques sur l'axe des x et les valeurs d'importance correspondantes sur l'axe des y. En triant les valeurs d'importance par ordre décroissant, les caractéristiques les plus importantes seront tracées en premier.

Ensuite, le code passe au calcul de l'importance de la permutation. L'importance de la permutation est calculée en mélangeant de manière aléatoire les valeurs de chaque caractéristique dans l'ensemble de test et en mesurant la baisse des performances du modèle. Plus la baisse des performances est élevée, plus la fonctionnalité est considérée comme importante. Le code utilise une boucle for pour itérer sur chaque entité du jeu de données.

À l'intérieur de la boucle, les valeurs des caractéristiques de l'ensemble de test sont mélangées à l'aide de np.random.permutation(). Ensuite, l'ensemble de test mélangé est passé à travers le classificateur de forêt aléatoire formé pour obtenir les étiquettes prédites. La précision du modèle sur l'ensemble de test mélangé est calculée à l'aide de la fonction precision_score(). La différence entre la précision du test d'origine et la précision du test mélangé représente la baisse des performances causée par la permutation de la fonctionnalité.

La baisse des performances de chaque fonctionnalité est stockée dans une liste appelée importance_vals. Après avoir parcouru toutes les fonctionnalités, la liste importance_vals contient la baisse des valeurs de performances pour chaque fonctionnalité.

Enfin, un graphique à barres est créé pour visualiser l'importance de la permutation. Les noms des caractéristiques sont tracés sur l'axe des x et la baisse correspondante des valeurs de performance est tracée sur l'axe des y. Encore une fois, les valeurs d'importance sont triées par ordre décroissant pour mettre en évidence les caractéristiques les plus importantes.

Ce code fournit une comparaison entre l'importance basée sur les impuretés et l'importance de la permutation. En comparant les deux tracés, vous pouvez observer s'il existe des différences dans le classement de l'importance des caractéristiques entre les deux méthodes.

import matplotlib.pyplot as plt
import numpy as np
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_iris
from sklearn.metrics import accuracy_score

# Load the Iris dataset
iris = load_iris()
X = iris.data
y = iris.target

# Create a random forest classifier
clf = RandomForestClassifier(n_estimators= 100 , random_state= 42 )
clf.fit(X, y)

# Compute impurity-based feature importances
importances = clf.feature_importances_

# Plot impurity-based feature importances
plt.figure(figsize=( 8 , 6 ))
plt.bar(range(X.shape[ 1 ]), importances, align= 'center' )
plt.xticks(range(X.shape[ 1 ]), iris.feature_names, rotation= 90 )
plt.xlabel( 'Features' )
plt.ylabel( 'Importance' )
plt.title( 'Impurity-based Feature Importances' )
plt.show()

# Compute permutation importances
importance_vals = []
for feature in range(X.shape[ 1 ]):
    X_permuted = X.copy()
    np.random.shuffle(X_permuted[:, feature])
    y_pred = clf.predict(X_permuted)
    accuracy = accuracy_score(y, y_pred)
    drop_in_performance = accuracy_score(y, y_pred) - accuracy
    importance_vals.append(drop_in_performance)

# Plot permutation importances
plt.figure(figsize=( 8 , 6 ))
plt.bar(range(X.shape[ 1 ]), importance_vals, align= 'center' )
plt.xticks(range(X.shape[ 1 ]), iris.feature_names, rotation= 90 )
plt.xlabel( 'Features' )
plt.ylabel( 'Drop in Performance' )
plt.title( 'Permutation Importances' )
plt.show()

Ce code créera deux diagrammes à barres côte à côte. Le premier graphique montrera les importances des caractéristiques basées sur les impuretés, et le deuxième graphique montrera les importances de permutation. En examinant ces tracés, vous pouvez mieux comprendre l'importance relative des différentes caractéristiques dans le jeu de données Iris selon ces deux méthodes.

Assurez-vous d'avoir importé les bibliothèques nécessaires, telles que matplotlib, numpy, sklearn.ensemble.RandomForestClassifier, sklearn.datasets.load_iris et sklearn.metrics.accuracy_score.

import matplotlib.pyplot as plt
import numpy as np
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_iris
from sklearn.inspection import permutation_importance
from sklearn.model_selection import train_test_split

# Load the Iris dataset
iris = load_iris()
X = iris.data
y = iris.target

# Split the data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size= 0.2 , random_state= 42 )

# Create a random forest classifier
clf = RandomForestClassifier(n_estimators= 100 , random_state= 42 )
clf.fit(X_train, y_train)

# Perform permutation importances
result = permutation_importance(clf, X_test, y_test, n_repeats= 10 , random_state= 42 , n_jobs=- 1 )

# Get the feature importances and their indices
importances = result.importances_mean
indices = np.argsort(importances)

# Plot permutation importances
plt.figure(figsize=( 8 , 6 ))
plt.barh(range(X.shape[ 1 ]), importances[indices], align= 'center' )
plt.yticks(range(X.shape[ 1 ]), iris.feature_names[indices])
plt.xlabel( 'Importance' )
plt.ylabel( 'Features' )
plt.title( 'Permutation Importances' )
plt.show()

Dans ce code, nous utilisons la fonction permutation_importance du module sklearn.inspection pour calculer les importances de permutation. L'ensemble de données est divisé en ensembles d'apprentissage et de test à l'aide de train_test_split. Nous ajustons ensuite un classificateur de forêt aléatoire sur les données d'apprentissage et calculons les importances de permutation à l'aide des données de test.

Les importances de permutation résultantes sont stockées dans la variable d'importances. Nous utilisons np.argsort pour obtenir les indices qui trieraient les importances par ordre croissant. Cela aide à tracer les importances dans le bon ordre.

Enfin, nous créons un graphique à barres horizontales en utilisant plt.barh pour afficher les importances de permutation. L'axe des y représente les caractéristiques, tandis que l'axe des x représente les valeurs d'importance. Les fonctions plt.xlabel, plt.ylabel et plt.title sont utilisées pour ajouter des étiquettes et un titre au tracé.

Assurez-vous d'avoir importé les bibliothèques nécessaires, telles que matplotlib, numpy, sklearn.ensemble.RandomForestClassifier, sklearn.datasets.load_iris, sklearn.inspection.permutation_importance et sklearn.model_selection.train_test_split.

import matplotlib.pyplot as plt
import numpy as np
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_iris
from sklearn.inspection import permutation_importance
from sklearn.model_selection import train_test_split

# Load the Iris dataset
iris = load_iris()
X = iris.data
y = iris.target

# Split the data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size= 0.2 , random_state= 42 )

# Create a random forest classifier
clf = RandomForestClassifier(n_estimators= 100 , random_state= 42 )
clf.fit(X_train, y_train)

# Perform permutation importances
result = permutation_importance(clf, X_test, y_test, n_repeats= 10 , random_state= 42 , n_jobs=- 1 )

# Get the feature importances and their indices
importances = result.importances_mean
indices = np.argsort(importances)

# Plot permutation importances
plt.figure(figsize=( 8 , 6 ))
plt.barh(range(X.shape[ 1 ]), importances[indices], align= 'center' )
plt.yticks(range(X.shape[ 1 ]), iris.feature_names[indices])
plt.xlabel( 'Importance' )
plt.ylabel( 'Features' )
plt.title( 'Permutation Importances' )
plt.show()

Dans ce code, nous utilisons la fonction permutation_importance du module sklearn.inspection pour calculer les importances de permutation. L'ensemble de données est divisé en ensembles d'apprentissage et de test à l'aide de train_test_split. Nous ajustons ensuite un classificateur de forêt aléatoire sur les données d'apprentissage et calculons les importances de permutation à l'aide des données de test.

Les importances de permutation résultantes sont stockées dans la variable d'importances. Nous utilisons np.argsort pour obtenir les indices qui trieraient les importances par ordre croissant. Cela aide à tracer les importances dans le bon ordre.

Enfin, nous créons un graphique à barres horizontales en utilisant plt.barh pour afficher les importances de permutation. L'axe des y représente les caractéristiques, tandis que l'axe des x représente les valeurs d'importance. Les fonctions plt.xlabel, plt.ylabel et plt.title sont utilisées pour ajouter des étiquettes et un titre au tracé.

Assurez-vous d'avoir importé les bibliothèques nécessaires, telles que matplotlib, numpy, sklearn.ensemble.RandomForestClassifier, sklearn.datasets.load_iris, sklearn.inspection.permutation_importance et sklearn.model_selection.train_test_split.

[MetaQuotes]

13.4.4 Sélection de fonction séquentielle (L13 : sélection de fonction)

13.4.4 Sélection de fonction séquentielle (L13 : sélection de fonction)

Dans les vidéos précédentes, j'ai introduit le concept d'importance des caractéristiques en utilisant l'importance de la permutation comme technique préférée. Dans cette vidéo, je souhaite discuter d'une autre technique importante appelée sélection séquentielle de caractéristiques, qui fait également partie des méthodes d'encapsulation dont nous avons parlé précédemment.

Avant de plonger dans la sélection séquentielle des caractéristiques, récapitulons brièvement les différents types de méthodes de sélection des caractéristiques dont nous avons discuté jusqu'à présent. Nous avons commencé par les méthodes de filtrage, puis nous sommes passés aux méthodes intégrées telles que l'élimination récursive des fonctionnalités, et nous nous concentrons maintenant sur les méthodes d'encapsulation.

Les méthodes wrapper visent à trouver un sous-ensemble de fonctionnalités optimal en essayant toutes les combinaisons de fonctionnalités possibles. Cette approche est connue sous le nom de sélection exhaustive de caractéristiques. Pour comprendre comment cela fonctionne, considérons l'exemple du jeu de données Iris, qui comporte quatre caractéristiques : longueur des sépales, largeur des sépales, longueur des pétales et largeur des pétales. Pour trouver la meilleure combinaison de fonctionnalités pour notre modèle, nous aurions besoin d'essayer tous les sous-ensembles possibles, allant des fonctionnalités simples à l'ensemble complet des fonctionnalités.

Pour le jeu de données Iris, cela se traduirait par 15 combinaisons possibles, y compris des sous-ensembles d'un, deux, trois et quatre caractéristiques. Cependant, une sélection exhaustive de caractéristiques peut être coûteuse en calcul et sujette à un surajustement. Pour atténuer ces problèmes, nous pouvons utiliser un ensemble de validation ou une validation croisée K-fold pour évaluer les performances de différents sous-ensembles de fonctionnalités.

Malgré sa simplicité, la sélection exhaustive d'entités présente une limitation lorsqu'elle est appliquée à des ensembles de données comportant un grand nombre d'entités. Le nombre de sous-ensembles d'entités possibles augmente de manière exponentielle avec le nombre d'entités, ce qui le rend peu pratique pour les grands ensembles de données. Cette limitation motive l'utilisation de la sélection séquentielle de caractéristiques, qui est une technique d'approximation qui explore un sous-ensemble de combinaisons de caractéristiques au lieu d'évaluer toutes les combinaisons possibles.

La sélection séquentielle de fonctionnalités est un processus itératif qui commence par l'ensemble de fonctionnalités d'origine et sélectionne ou supprime progressivement des fonctionnalités en fonction de leurs performances. Une approche populaire est la sélection descendante séquentielle, où nous commençons avec l'ensemble complet de fonctionnalités et supprimons de manière itérative une fonctionnalité à la fois. À chaque itération, nous évaluons les performances des fonctionnalités restantes et sélectionnons le sous-ensemble avec les performances les plus élevées. Ce processus se poursuit jusqu'à ce que nous ayons un sous-ensemble avec une seule caractéristique restante.

L'algorithme de sélection descendante séquentielle peut être résumé comme suit :

1. Commencez avec l'ensemble de fonctionnalités d'origine.
2. Générez tous les sous-ensembles d'entités possibles de taille n-1 en supprimant une entité à la fois.
3. Évaluez les performances de chaque sous-ensemble candidat.
4. Sélectionnez le sous-ensemble avec les performances les plus élevées et supprimez définitivement la fonctionnalité absente de ce sous-ensemble.
5. Répétez les étapes 2 à 4 jusqu'à ce que la taille de fonction souhaitée soit atteinte (par exemple, il ne reste qu'une seule fonction).

En répétant les étapes 2 à 4, nous réduisons progressivement l'ensemble de fonctionnalités jusqu'à atteindre le sous-ensemble optimal. Le sous-ensemble final est sélectionné en fonction du score d'évaluation le plus élevé, et en cas d'égalité, le plus petit sous-ensemble est préféré pour l'efficacité de calcul. Le nombre d'itérations dans la rétrosélection séquentielle est égal au nombre de caractéristiques moins un.

La sélection séquentielle vers l'avant est une autre variante de la sélection séquentielle des fonctions. Au lieu de supprimer des fonctionnalités, la sélection vers l'avant séquentielle commence par un ensemble de fonctionnalités vide et ajoute progressivement une fonctionnalité à la fois. Le processus implique la formation d'un classificateur sur chaque caractéristique individuelle et l'évaluation de ses performances. La fonctionnalité la plus performante est sélectionnée et ajoutée au sous-ensemble. Ce processus se poursuit jusqu'à ce que le nombre maximal de fonctionnalités soit atteint.

En résumé, la sélection séquentielle de caractéristiques est une technique utile pour trouver un sous-ensemble optimal de caractéristiques. Il offre un compromis entre l'efficacité de calcul et la recherche d'une bonne combinaison de fonctionnalités. La sélection arrière séquentielle et la sélection avant séquentielle sont deux variantes courantes de la sélection de fonctionnalités séquentielles, chacune avec ses propres avantages et cas d'utilisation. Dans la vidéo suivante, nous explorerons comment implémenter la sélection séquentielle de fonctionnalités par programmation et aborderons les limites de la sélection exhaustive de fonctionnalités.

[MetaQuotes]

13.4.5 Sélection de fonction séquentielle -- Exemples de code (L13 : Sélection de fonction)

13.4.5 Sélection de fonction séquentielle -- Exemples de code (L13 : Sélection de fonction)

Bon, il est temps de conclure notre discussion sur la sélection des fonctionnalités. Dans cette vidéo, je vais montrer comment utiliser la sélection séquentielle de fonctionnalités en Python. Je vais commencer par vous montrer un exemple utilisant la bibliothèque MLxtend, qui est l'implémentation originale que j'ai développée il y a plusieurs années. Plus tard, je montrerai également comment obtenir les mêmes résultats en utilisant scikit-learn, qui offre une implémentation plus simple.

Avant de plonger dans le code, je vous encourage à consulter la documentation, qui contient des exemples supplémentaires que je ne couvrirai pas dans cette vidéo pour éviter de la rendre trop longue et accablante. Il est toujours utile de se référer à la documentation pour des informations plus détaillées.

Tout d'abord, commençons par charger le plugin "watermark" que j'ai développé pour suivre les versions de mes notebooks et bibliothèques de logiciels au fil des années. C'est une bonne pratique de s'assurer que les numéros de version correspondent à nos attentes, surtout si certaines options peuvent ne plus fonctionner en raison de divergences de version. Nous utiliserons également la bibliothèque matplotlib plus tard, alors importons-la pour nous assurer que les tracés s'affichent correctement dans le cahier.

Passons maintenant à la préparation du jeu de données pour la sélection des fonctionnalités. Comme dans les vidéos précédentes, nous utiliserons le jeu de données wine. Nous chargeons l'ensemble de données à partir du référentiel d'ensembles de données d'apprentissage automatique UCI à l'aide de Pandas. Après avoir chargé l'ensemble de données, nous imprimons quelques informations de base pour nous assurer que tout est correctement chargé. Il est également important de vérifier que les étiquettes de classe sont représentées sous forme d'entiers.

Ensuite, nous divisons l'ensemble de données en ensembles d'entraînement et de test, comme nous l'avons fait dans les vidéos précédentes. De plus, nous normalisons l'ensemble de données car nous utiliserons un classificateur K-plus proche voisin, qui est sensible à la mise à l'échelle des caractéristiques. Nous divisons l'ensemble de données en un ensemble d'apprentissage à 80 % et un ensemble de test à 20 %, et normalisons les deux ensembles.

Pour établir une ligne de base avant la sélection des fonctionnalités, nous ajustons un classificateur K-plus proche voisin sur l'ensemble de données standardisé et calculons les précisions d'apprentissage et de test. Dans cet exemple, nous choisissons arbitrairement cinq voisins pour le classificateur, mais ce paramètre pourrait être soumis à une recherche de grille pour des performances optimales. Bien que nous n'effectuions pas de recherche de grille ici pour simplifier le code et la vidéo, combiner la recherche de grille avec la sélection séquentielle de fonctionnalités est une approche courante. Vous pouvez en trouver des exemples dans la documentation.

Les résultats de base montrent que nous atteignons une précision de 98,6 % sur l'ensemble d'apprentissage et une précision de 94 % sur l'ensemble de test. Les performances sont assez bonnes en utilisant les 13 fonctionnalités de l'ensemble de données sur le vin. Cependant, il peut y avoir un surajustement en raison de la malédiction de la dimensionnalité associée aux classificateurs K plus proches voisins. Pour atténuer cela, nous pouvons sélectionner un sous-ensemble plus petit de fonctionnalités afin d'améliorer potentiellement les performances.

Maintenant, montrons comment utiliser la sélection séquentielle d'entités pour sélectionner un sous-ensemble de cinq entités. Nous importons la classe SequentialFeatureSelector de la bibliothèque MLxtend et raccourcissons le nom d'importation en sfs pour plus de commodité. Cette classe prend le modèle, la taille de sous-ensemble d'entités souhaitée et la direction de sélection (avant, arrière, flottant) comme entrée. Nous définissons la direction vers l'avant pour la sélection vers l'avant séquentielle. Le paramètre verbeux nous permet de contrôler la quantité de sortie affichée pendant l'entraînement, ce qui peut être utile pour suivre les progrès. Nous spécifions la métrique de notation comme étant la précision et utilisons une validation croisée quintuple pour évaluer les sous-ensembles de fonctionnalités. Le traitement parallèle peut être activé en définissant le paramètre n_jobs sur un entier positif ou -1 pour utiliser tous les cœurs de processeur disponibles. Dans ce cas, nous le définissons sur 8 pour une exécution plus rapide.

La sortie montre la progression du processus de sélection des fonctionnalités, en commençant par une fonctionnalité et en augmentant progressivement le nombre de fonctionnalités jusqu'à atteindre la taille de sous-ensemble souhaitée de cinq. Les performances de chaque sous-ensemble de fonctionnalités sont également affichées, indiquant une amélioration à mesure que d'autres fonctionnalités sont ajoutées.

Une fois terminé, nous pouvons accéder aux indices d'entités sélectionnés et aux noms d'entités correspondants à l'aide des attributs k_feature_idx_ et k_feature_names_, respectivement, de l'objet sfs. De plus, nous pouvons accéder à l'historique des performances des sous-ensembles de fonctionnalités à l'aide de l'attribut k_score_. Imprimons les indices d'entités sélectionnés, les noms et leurs scores correspondants :

print( 'Selected feature indices:' , sfs.k_feature_idx_)
print( 'Selected feature names:' , sfs.k_feature_names_)
print( 'Selected feature scores:' , sfs.k_score_)

La sortie affichera les indices, les noms et les scores des cinq entités sélectionnées.

Ensuite, nous pouvons recycler le classificateur K-plus proche voisin sur le sous-ensemble d'entités sélectionné. Pour ce faire, nous devons créer un nouvel ensemble d'entraînement et de test qui ne contient que les fonctionnalités sélectionnées. Nous pouvons utiliser la méthode transform de l'objet sfs pour transformer les jeux de données d'origine dans le nouvel espace de fonctionnalités :

X_train_selected = sfs.transform(X_train)
X_test_selected = sfs.transform(X_test)

Après avoir transformé les ensembles de données, nous pouvons ajuster un nouveau classificateur K-plus proche voisin sur le sous-ensemble d'entités sélectionné et calculer les précisions d'apprentissage et de test. Imprimons les résultats :

knn_selected = KNeighborsClassifier(n_neighbors= 5 )
knn_selected.fit(X_train_selected, y_train)

train_acc_selected = knn_selected.score(X_train_selected, y_train)
test_acc_selected = knn_selected.score(X_test_selected, y_test)

print( 'Training accuracy on selected features:' , train_acc_selected)
print( 'Test accuracy on selected features:' , test_acc_selected)

La sortie montrera les précisions de formation et de test obtenues en utilisant uniquement les cinq fonctionnalités sélectionnées.

En comparant les résultats avec les précisions de base, nous pouvons évaluer l'impact de la sélection des caractéristiques sur les performances du classifieur. Dans certains cas, la sélection des fonctionnalités peut conduire à une meilleure généralisation et à une amélioration des performances du modèle en réduisant le surajustement et en supprimant les fonctionnalités non pertinentes ou redondantes.

C'est tout pour la démonstration utilisant la bibliothèque MLxtend. Passons maintenant à l'utilisation de scikit-learn pour la sélection séquentielle de fonctionnalités.

Dans scikit-learn, la classe SequentialFeatureSelector est disponible dans le module feature_selection. Nous l'importons comme suit :

from sklearn.feature_selection import SequentialFeatureSelector

L'utilisation de la version scikit-learn est similaire à la version MLxtend, mais avec quelques différences mineures dans les noms de paramètres et l'accès aux attributs. La version scikit-learn offre également plus de flexibilité en termes d'utilisation de différents algorithmes de sélection de fonctionnalités et de métriques de notation.

J'espère que cette démonstration vous aidera à comprendre comment utiliser la sélection séquentielle de fonctionnalités en Python. N'oubliez pas de vous reporter à la documentation pour des exemples et des informations supplémentaires.