rang importance
Un exemple est donné pour illustrer l'importance du classement.
Question : Prédire la taille d'une personne à l'âge de 20 ans, en utilisant des données à l'âge de 10 ans. Les données incluent des caractéristiques utiles (taille à 10 ans) et des caractéristiques qui ont peu de pouvoir prédictif (posséder des chaussettes).
L'importance de la permutation est calculée après l'ajustement du modèle. On ne change donc pas le modèle, ni nos prédictions pour une taille donnée, un nombre de chaussettes, etc.
Au lieu de cela, nous poserons la question suivante : si je mélange au hasard une colonne des données de validation, tout en conservant la cible et toutes les autres colonnes, comment cela affectera-t-il la précision des prédictions dans les données désormais mélangées ?
La réorganisation aléatoire de colonnes individuelles peut entraîner des prédictions moins précises, car les données résultantes ne correspondent plus à rien d'observé dans le monde réel. La précision du modèle souffre particulièrement si nous mélangeons les colonnes sur lesquelles le modèle s'appuie fortement pour ses prédictions. Dans ce cas, changer de taille à 10 ans conduit à de sombres prédictions. Si nous mélangeons inversement les chaussettes possédées, les prédictions résultantes ne seraient pas autant affectées.
donc:
- Obtenez un modèle formé.
- Mélangez les valeurs dans une seule colonne, faites des prédictions à l'aide de l'ensemble de données résultant. Utilisez ces prédictions et les vraies valeurs cibles pour calculer combien la fonction de perte a souffert du brassage. Cette détérioration des performances mesure l'importance de la variable que vous venez de mélanger.
- Remettez les données dans l'ordre d'origine (en annulant le mélange de l'étape 2). Répétez maintenant l'étape 2 avec la colonne suivante dans l'ensemble de données, jusqu'à ce que vous ayez calculé l'importance de chaque colonne.
exemple de code
Problème : Utilisez un modèle qui prédit si une équipe de football/soccer aura un "meilleur joueur" gagnant en fonction des statistiques de l'équipe. Le prix du "Meilleur joueur de la compétition" est décerné au meilleur joueur de la compétition.
Charger les données, former le modèle
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
data = pd.read_csv('../input/fifa-2018-match-statistics/FIFA 2018 Statistics.csv')
y = (data['Man of the Match'] == "Yes") # Convert from string "Yes"/"No" to binary
feature_names = [i for i in data.columns if data[i].dtype in [np.int64]]
X = data[feature_names]
train_X, val_X, train_y, val_y = train_test_split(X, y, random_state=1)
my_model = RandomForestClassifier(n_estimators=100,
random_state=0).fit(train_X, train_y)
Calculer et afficher l'importance à l'aide de la bibliothèque eli5
eli5 : une boîte à outils de visualisation utile pour déboguer les modèles d'apprentissage automatique et interpréter les prédictions qu'ils produisent.
D'autres boîtes à outils de visualisation incluent : yellowbrick, LIME, MLxtend
import eli5
from eli5.sklearn import PermutationImportance
perm = PermutationImportance(my_model, random_state=1).fit(val_X, val_y)
eli5.show_weights(perm, feature_names = val_X.columns.tolist())
Explication sur l'importance de la permutation :
les valeurs en haut sont les caractéristiques les plus importantes, tandis que les valeurs en bas ne sont pas pertinentes.
Le premier chiffre de chaque ligne indique la baisse des performances du modèle avec un brassage aléatoire (dans ce cas, en utilisant la "précision" comme métrique de performance).
L'effet du brassage des colonnes sur les performances précises est quelque peu aléatoire. Nous répétons ce processus en mélangeant le jeu plusieurs fois pour mesurer le caractère aléatoire dans les calculs d'importance de permutation. Les nombres après ± mesurent le changement de performance d'un mélange à l'autre.
Vous pouvez parfois voir des valeurs négatives pour l'importance de la permutation. Dans ces cas, les prédictions sur les données mélangées (ou bruitées) se révèlent plus précises que les données réelles. Cela se produit lorsque les caractéristiques ne sont pas importantes (l'importance doit être proche de 0), mais le hasard conduit à des prédictions plus précises sur les données mélangées. Ceci est plus courant dans les petits ensembles de données, comme celui de cet exemple, car il y a plus de chance.
La fonction la plus importante est de marquer des buts. Cela semble raisonnable. Les fans peuvent avoir une certaine intuition quant à savoir si l'ordre des autres variables est surprenant.
pratique
introduction
Vous utiliserez un échantillon de données du concours de prédiction des tarifs de taxi pour examiner et calculer l'importance des permutations.
- Télécharger les données
- Diviser le jeu de données
- Construire un modèle prédictif
- Afficher les prévisions partielles
# Loading data, dividing, modeling and EDA below
import pandas as pd
from sklearn.ensemble import RandomForestRegressor
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
data = pd.read_csv('../input/new-york-city-taxi-fare-prediction/train.csv', nrows=50000)
# Remove data with extreme outlier coordinates or negative fares
data = data.query('pickup_latitude > 40.7 and pickup_latitude < 40.8 and ' +
'dropoff_latitude > 40.7 and dropoff_latitude < 40.8 and ' +
'pickup_longitude > -74 and pickup_longitude < -73.9 and ' +
'dropoff_longitude > -74 and dropoff_longitude < -73.9 and ' +
'fare_amount > 0'
)
y = data.fare_amount
base_features = ['pickup_longitude',
'pickup_latitude',
'dropoff_longitude',
'dropoff_latitude',
'passenger_count']
X = data[base_features]
train_X, val_X, train_y, val_y = train_test_split(X, y, random_state=1)
first_model = RandomForestRegressor(n_estimators=50, random_state=1).fit(train_X, train_y)
# Environment Set-Up for feedback system.
from learntools.core import binder
binder.bind(globals())
from learntools.ml_explainability.ex2 import *
print("Setup Complete")
# show data
print("Data sample:")
data.head()
Ensuite, comprenez les valeurs dans les données d'entraînement
train_X.describe()
train_y.describe()
Afficher le nombre, la moyenne, l'intervalle interquartile, l'écart type, les valeurs min/max
Problème 1 : Le premier modèle utilise les fonctionnalités suivantes :
- ramassage_longitude
- pick_latitude
- dropoff_longitude
- dropoff_latitude
- nombre_de_passagers
Quelles variables semblent être potentiellement utiles pour prédire les tarifs des taxis avant d'exécuter un code ? Pensez-vous que l'importance de la permutation déterminerait nécessairement l'importance de ces fonctionnalités ?
R : Il serait utile de savoir si les taxis de NYC modifient les prix en fonction de l'achalandage. La plupart des endroits n'ajustent pas les tarifs en fonction du nombre de passagers. Si vous considérez que New York est la même chose, seules les 4 premières caractéristiques répertoriées sont importantes. À première vue, tout cela semble également important.
Question 2 : Créez un objet PermutationImportance appelé perm pour montrer l'importance de first_model. Associez-le aux données appropriées et affichez les poids.
répondre:
import eli5
from eli5.sklearn import PermutationImportance
perm = PermutationImportance(first_model, random_state=1).fit(val_X, val_y)
eli5.show_weights(perm, feature_names = base_features)
Question 3 : Avant de voir ces résultats, nous aurions pu nous attendre à ce que chacune des quatre caractéristiques d'orientation soit d'égale importance. Cependant, les caractéristiques de latitude sont plus importantes que les caractéristiques de longitude. Pouvez-vous faire des suppositions à ce sujet ?
répondre:
- Les déplacements peuvent avoir tendance à avoir des distances de latitude plus grandes que des distances de longitude. Si les valeurs de longitude sont généralement plus proches les unes des autres, il est moins important de les mélanger.
- Différentes parties de la ville peuvent avoir des règles de tarification différentes (par exemple, le prix par mile), et les règles de tarification peuvent varier en fonction de la latitude plutôt que de la longitude.
- Aller nord <-> sud (changement de latitude) peut avoir un péage plus élevé qu'aller est <-> ouest (changement de longitude). Par conséquent, la latitude aura un impact plus important sur la prévision car elle enregistrera le montant des péages.
Question 4 : Sans une connaissance détaillée de la ville de New York, il est difficile d'écarter la plupart des hypothèses sur les raisons pour lesquelles les caractéristiques de latitude sont plus importantes que la longitude.
Une bonne prochaine étape consiste à séparer l'effet de vivre dans certaines parties de la ville de l'effet de la distance totale parcourue.
Le code ci-dessous crée de nouvelles entités pour les distances longitudinales et de latitude. Il construit ensuite un modèle qui ajoute ces nouvelles fonctionnalités à ce que vous avez déjà.
Remplissez deux lignes de code pour calculer et afficher les pondérations d'importance pour ce nouvel ensemble de fonctionnalités.
# create new features
data['abs_lon_change'] = abs(data.dropoff_longitude - data.pickup_longitude)
data['abs_lat_change'] = abs(data.dropoff_latitude - data.pickup_latitude)
features_2 = ['pickup_longitude',
'pickup_latitude',
'dropoff_longitude',
'dropoff_latitude',
'abs_lat_change',
'abs_lon_change']
X = data[features_2]
new_train_X, new_val_X, new_train_y, new_val_y = train_test_split(X, y, random_state=1)
second_model = RandomForestRegressor(n_estimators=30, random_state=1).fit(new_train_X, new_train_y)
# Create a PermutationImportance object on second_model and fit it to new_val_X and new_val_y
# Use a random_state of 1 for reproducible results that match the expected solution.
perm2 = PermutationImportance(second_model, random_state=1).fit(new_val_X, new_val_y)
# show the weights for the permutation importance you just calculated
eli5.show_weights(perm2, feature_names = features_2)
La série de cours Kaggle fournit des descriptions textuelles, des exemples de formation et un environnement d'exploitation compilable, très adapté aux débutants. Il existe également de nombreux ensembles de données publiques et des codes open source de compétition, qui regorgent de produits secs !
Depuis que j'ai découvert ce trésor, j'ai récemment étudié les cours ci-dessus, y compris l'apprentissage automatique interprétable, l'ingénierie des fonctionnalités, etc.
De plus, le site officiel de kaggle est joint , les amis intéressés peuvent parcourir et apprendre, et communiquer entre eux si vous avez des questions !