您的位置: 首页  >  文章  >  GBDT+LR

GBDT+LR

分类: 文章 • 2025-04-14 15:21:16

利用GBDT对特征进行变换

https://wenku.baidu.com/view/7319fc2c960590c69ec376c0.html


https://blog.****.net/shine19930820/article/details/71713680/


http://scikit-learn.org/stable/auto_examples/ensemble/plot_feature_transformation.html#example-ensemble-plot-feature-transformation-py


xgboost + LR

来源：https://blog.****.net/asdfghjkl1993/article/details/78606268

[python] view plain copy
  1. #!/usr/bin python  
  2. #-*- coding:utf-8 -*-  
  3.   
  4. import numpy as np  
  5. import matplotlib.pyplot as plt  
  6. from sklearn.datasets import make_classification  
  7. from sklearn.linear_model import LogisticRegression  
  8. from sklearn.ensemble import (RandomTreesEmbedding, RandomForestClassifier,  
  9.                               GradientBoostingClassifier)  
  10. from sklearn.preprocessing import OneHotEncoder  
  11. from sklearn.model_selection import train_test_split  
  12. from sklearn.metrics import roc_curve, roc_auc_score  
  13. from sklearn.pipeline import make_pipeline  
  14. import xgboost as xgb  
  15. from xgboost.sklearn import XGBClassifier  
  16.   
  17. np.random.seed(10)  
  18. n_estimator = 10  
  19.   
  20. X, y = make_classification(n_samples=80000)  
  21. X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.5)  
  22. #To avoid overfitting  
  23. X_train, X_train_lr, y_train, y_train_lr = train_test_split(X_train, y_train, test_size=0.5)  
  24.   
  25. def RandomForestLR():  
  26.     rf = RandomForestClassifier(max_depth=3, n_estimators=n_estimator)  
  27.     rf_enc = OneHotEncoder()  
  28.     rf_lr = LogisticRegression()  
  29.     rf.fit(X_train, y_train)  
  30.     rf_enc.fit(rf.apply(X_train))  
  31.     rf_lr.fit(rf_enc.transform(rf.apply(X_train_lr)), y_train_lr)  
  32.     y_pred_rf_lr = rf_lr.predict_proba(rf_enc.transform(rf.apply(X_test)))[:, 1]  
  33.     fpr_rf_lr, tpr_rf_lr, _ = roc_curve(y_test, y_pred_rf_lr)  
  34.     auc = roc_auc_score(y_test, y_pred_rf_lr)  
  35.     print("RF+LR:", auc)  
  36.     return fpr_rf_lr, tpr_rf_lr  
  37.   
  38. def GdbtLR():  
  39.     grd = GradientBoostingClassifier(n_estimators=n_estimator)  
  40.     grd_enc = OneHotEncoder()  
  41.     grd_lr = LogisticRegression()  
  42.     grd.fit(X_train, y_train)  
  43.     grd_enc.fit(grd.apply(X_train)[:, :, 0])  
  44.     grd_lr.fit(grd_enc.transform(grd.apply(X_train_lr)[:, :, 0]), y_train_lr)  
  45.     y_pred_grd_lr = grd_lr.predict_proba(grd_enc.transform(grd.apply(X_test)[:, :, 0]))[:, 1]  
  46.     fpr_grd_lr, tpr_grd_lr, _ = roc_curve(y_test, y_pred_grd_lr)  
  47.     auc = roc_auc_score(y_test, y_pred_grd_lr)   
  48.     print("GDBT+LR:", auc)  
  49.     return fpr_grd_lr, tpr_grd_lr  
  50.   
  51. def Xgboost():  
  52.     xgboost = xgb.XGBClassifier(nthread=4, learning_rate=0.08,\  
  53.             n_estimators=50, max_depth=5, gamma=0, subsample=0.9, colsample_bytree=0.5)  
  54.     xgboost.fit(X_train, y_train)  
  55.     y_xgboost_test = xgboost.predict_proba(X_test)[:, 1]  
  56.     fpr_xgboost, tpr_xgboost, _ = roc_curve(y_test, y_xgboost_test)  
  57.     auc = roc_auc_score(y_test, y_xgboost_test)  
  58.     print("Xgboost:", auc)  
  59.     return fpr_xgboost, tpr_xgboost  
  60.   
  61. def Lr():  
  62.     lm = LogisticRegression(n_jobs=4, C=0.1, penalty='l1')  
  63.     lm.fit(X_train, y_train)  
  64.     y_lr_test = lm.predict_proba(X_test)[:, 1]  
  65.     fpr_lr, tpr_lr, _ = roc_curve(y_test, y_lr_test)  
  66.     auc = roc_auc_score(y_test, y_lr_test)  
  67.     print("LR:", auc)  
  68.     return fpr_lr, tpr_lr  
  69.   
  70. def XgboostLr():  
  71.     xgboost = xgb.XGBClassifier(nthread=4, learning_rate=0.08,\  
  72.                                 n_estimators=50, max_depth=5, gamma=0, subsample=0.9, colsample_bytree=0.5)  
  73.     xgb_enc = OneHotEncoder()  
  74.     xgb_lr = LogisticRegression(n_jobs=4, C=0.1, penalty='l1')  
  75.     xgboost.fit(X_train, y_train)  
  76.   
  77.     xgb_enc.fit(xgboost.apply(X_train)[:, :])  
  78.     xgb_lr.fit(xgb_enc.transform(xgboost.apply(X_train_lr)[:, :]), y_train_lr)  
  79.     y_xgb_lr_test = xgb_lr.predict_proba(xgb_enc.transform(xgboost.apply(X_test)[:,:]))[:, 1]  
  80.     fpr_xgb_lr, tpr_xgb_lr, _ = roc_curve(y_test, y_xgb_lr_test)  
  81.     auc = roc_auc_score(y_test, y_xgb_lr_test)  
  82.     print("Xgboost + LR:", auc)  
  83.     return fpr_xgb_lr, tpr_xgb_lr  
  84.   
  85. if __name__ == '__main__':  
  86.     fpr_rf_lr, tpr_rf_lr = RandomForestLR()  
  87.     fpr_grd_lr, tpr_grd_lr = GdbtLR()  
  88.     fpr_xgboost, tpr_xgboost = Xgboost()  
  89.     fpr_lr, tpr_lr = Lr()  
  90.     fpr_xgb_lr, tpr_xgb_lr = XgboostLr()  
  91.   
  92.     plt.figure(1)  
  93.     plt.plot([0, 1], [0, 1], 'k--')  
  94.     plt.plot(fpr_rf_lr, tpr_rf_lr, label='RF + LR')  
  95.     plt.plot(fpr_grd_lr, tpr_grd_lr, label='GBT + LR')  
  96.     plt.plot(fpr_xgboost, tpr_xgboost, label='XGB')  
  97.     plt.plot(fpr_lr, tpr_lr, label='LR')  
  98.     plt.plot(fpr_xgb_lr, tpr_xgb_lr, label='XGB + LR')  
  99.     plt.xlabel('False positive rate')  
  100.     plt.ylabel('True positive rate')  
  101.     plt.title('ROC curve')  
  102.     plt.legend(loc='best')  
  103.     plt.show()  
  104.   
  105.     plt.figure(2)  
  106.     plt.xlim(0, 0.2)  
  107.     plt.ylim(0.8, 1)  
  108.     plt.plot([0, 1], [0, 1], 'k--')  
  109.     plt.plot(fpr_rf_lr, tpr_rf_lr, label='RF + LR')  
  110.     plt.plot(fpr_grd_lr, tpr_grd_lr, label='GBT + LR')  
  111.     plt.plot(fpr_xgboost, tpr_xgboost, label='XGB')  
  112.     plt.plot(fpr_lr, tpr_lr, label='LR')  
  113.     plt.plot(fpr_xgb_lr, tpr_xgb_lr, label='XGB + LR')  
  114.     plt.xlabel('False positive rate')  
  115.     plt.ylabel('True positive rate')  
  116.     plt.title('ROC curve (zoomed in at top left)')  
  117.     plt.legend(loc='best')  
  118.     plt.show()  

GBDT+LR

相关推荐