web-dev-qa-db-fra.com

Comment obtenir l'importance des fonctionnalités dans xgboost?

J'utilise xgboost pour construire un modèle et j'essaie de trouver l'importance de chaque fonctionnalité à l'aide de get_fscore(), mais elle renvoie {}

et mon code de train est:

dtrain = xgb.DMatrix(X, label=Y)
watchlist = [(dtrain, 'train')]
param = {'max_depth': 6, 'learning_rate': 0.03}
num_round = 200
bst = xgb.train(param, dtrain, num_round, watchlist)

Y a-t-il une erreur dans mon train? Comment obtenir l'importance des fonctionnalités dans xgboost?

pythonxgboost
14
modkzs

Dans votre code, vous pouvez obtenir l'importance des fonctionnalités pour chaque fonctionnalité sous forme de dict:

bst.get_score(importance_type='gain')

>>{'ftr_col1': 77.21064539577829,
   'ftr_col2': 10.28690566363971,
   'ftr_col3': 24.225014841466294,
   'ftr_col4': 11.234086283060112}

Explication: La méthode get_score () de l'API train () est définie comme suit:

get_score (fmap = '', importance_type = 'weight')

  • fmap (str (facultatif)) - Le nom du fichier de carte d'entités.
  • type_importance
    • "Poids" - le nombre de fois où une fonction est utilisée pour diviser les données sur tous les arbres.
    • "Gain" - le gain moyen sur toutes les divisions dans lesquelles la fonction est utilisée.
    • "Couverture" - la couverture moyenne de toutes les divisions dans lesquelles la fonctionnalité est utilisée.
    • ‘Total_gain’ - le gain total sur toutes les divisions dans lesquelles la fonctionnalité est utilisée.
    • "Total_cover" - la couverture totale de toutes les divisions dans lesquelles la fonctionnalité est utilisée.

https://xgboost.readthedocs.io/en/latest/python/python_api.html

17
MLKing

En utilisant l'API sklearn et XGBoost> = 0,81:

clf.get_booster().get_score(importance_type="gain")

ou

regr.get_booster().get_score(importance_type="gain")

Pour que cela fonctionne correctement, lorsque vous appelez regr.fit (ou clf.fit), X doit être un pandas.DataFrame.

8
Sesquipedalism

Je ne sais pas comment obtenir des valeurs, certes, mais il existe un bon moyen de tracer l'importance des fonctionnalités:

model = xgb.train(params, d_train, 1000, watchlist)
fig, ax = plt.subplots(figsize=(12,18))
xgb.plot_importance(model, max_num_features=50, height=0.8, ax=ax)
plt.show()
7
Kirill Dolmatov

Essaye ça

fscore = clf.best_estimator_.booster().get_fscore()
7
koalagreener

Pour l'importance des fonctionnalités Essayez ceci:

Classification:

pd.DataFrame(bst.get_fscore().items(), columns=['feature','importance']).sort_values('importance', ascending=False)

Régression:

xgb.plot_importance(bst)
5
Roozbeh

Construisez d'abord le modèle à partir de XGboost

from xgboost import XGBClassifier, plot_importance
model = XGBClassifier()
model.fit(train, label)

cela entraînerait un tableau. Nous pouvons donc le trier par ordre décroissant

sorted_idx = np.argsort(model.feature_importances_)[::-1]

Ensuite, il est temps d'imprimer toutes les importances triées et le nom des colonnes sous forme de listes (je suppose que les données sont chargées avec Pandas)

for index in sorted_idx:
    print([train.columns[index], model.feature_importances_[index]])

De plus, nous pouvons tracer les importances avec la fonction intégrée XGboost

plot_importance(model, max_num_features = 15)
pyplot.show()

utilisation max_num_features dans plot_importance pour limiter le nombre de fonctionnalités si vous le souhaitez.

5
Steven Hu

Obtenez le tableau contenant les scores et les noms des fonctionnalités , puis tracez-le.

feature_important = model.get_score(importance_type='weight')
keys = list(feature_important.keys())
values = list(feature_important.values())

data = pd.DataFrame(data=values, index=keys, columns=["score"]).sort_values(by = "score", ascending=False)
data.plot(kind='barh')

Par exemple:

enter image description here

3
Catbuilts

Pour tous ceux qui rencontrent ce problème lors de l'utilisation de xgb.XGBRegressor(), la solution de contournement que j'utilise est de conserver les données dans un pandas.DataFrame() ou numpy.array() et non de convertir les données en dmatrix(). De plus, je devais m'assurer que le paramètre gamma n'était pas spécifié pour le XGBRegressor.

fit = alg.fit(dtrain[ft_cols].values, dtrain['y'].values)
ft_weights = pd.DataFrame(fit.feature_importances_, columns=['weights'], index=ft_cols)

Après avoir installé le régresseur fit.feature_importances_ renvoie un tableau de poids que je suis en supposant est dans le même ordre que les colonnes d'entités de la trame de données pandas.

Ma configuration actuelle est Ubuntu 16.04, distribution Anaconda, python 3.6, xgboost 0.6 et sklearn 18.1.

3
BCR
print(model.feature_importances_)

plt.bar(range(len(model.feature_importances_)), model.feature_importances_)
0
Ashish Barvaliya