scikit-learn 梯度提高树(GBDT)调参小结

时间  2019-12-07
标签 scikit learn 梯度 高树 gbdt 小结 繁體版
原文   原文链接

　　在梯度提高树(GBDT)原理小结中，咱们对GBDT的原理作了总结，本文咱们就从scikit-learn里GBDT的类库使用方法做一个总结，主要会关注调参中的一些要点。html

1. scikit-learn GBDT类库概述

　　　　在sacikit-learn中，GradientBoostingClassifier为GBDT的分类类， 而GradientBoostingRegressor为GBDT的回归类。二者的参数类型彻底相同，固然有些参数好比损失函数loss的可选择项并不相同。这些参数中，相似于Adaboost，咱们把重要参数分为两类，第一类是Boosting框架的重要参数，第二类是弱学习器即CART回归树的重要参数。node

　　　　下面咱们就从这两个方面来介绍这些参数的使用。git

2. GBDT类库boosting框架参数

　　　　首先，咱们来看boosting框架相关的重要参数。因为GradientBoostingClassifier和GradientBoostingRegressor的参数绝大部分相同，咱们下面会一块儿来说，不一样点会单独指出。github

　　　　1) n_estimators: 也就是弱学习器的最大迭代次数，或者说最大的弱学习器的个数。通常来讲n_estimators过小，容易欠拟合，n_estimators太大，又容易过拟合，通常选择一个适中的数值。默认是100。在实际调参的过程当中，咱们经常将n_estimators和下面介绍的参数learning_rate一块儿考虑。算法

　　　　2) learning_rate: 即每一个弱学习器的权重缩减系数νν，也称做步长，在原理篇的正则化章节咱们也讲到了，加上了正则化项，咱们的强学习器的迭代公式为fk(x)=fk−1(x)+νhk(x)fk(x)=fk−1(x)+νhk(x)。νν的取值范围为0<ν≤10<ν≤1。对于一样的训练集拟合效果，较小的νν意味着咱们须要更多的弱学习器的迭代次数。一般咱们用步长和迭代最大次数一块儿来决定算法的拟合效果。因此这两个参数n_estimators和learning_rate要一块儿调参。通常来讲，能够从一个小一点的νν开始调参，默认是1。框架

　　　　3) subsample: 即咱们在原理篇的正则化章节讲到的子采样，取值为(0,1]。注意这里的子采样和随机森林不同，随机森林使用的是放回抽样，而这里是不放回抽样。若是取值为1，则所有样本都使用，等于没有使用子采样。若是取值小于1，则只有一部分样本会去作GBDT的决策树拟合。选择小于1的比例能够减小方差，即防止过拟合，可是会增长样本拟合的误差，所以取值不能过低。推荐在[0.5, 0.8]之间，默认是1.0，即不使用子采样。dom

　　　　4) init: 即咱们的初始化的时候的弱学习器，拟合对应原理篇里面的f0(x)f0(x)，若是不输入，则用训练集样原本作样本集的初始化分类回归预测。不然用init参数提供的学习器作初始化分类回归预测。通常用在咱们对数据有先验知识，或者以前作过一些拟合的时候，若是没有的话就不用管这个参数了。函数

　　　　5) loss: 即咱们GBDT算法中的损失函数。分类模型和回归模型的损失函数是不同的。post

　　　　　　对于分类模型，有对数似然损失函数"deviance"和指数损失函数"exponential"二者输入选择。默认是对数似然损失函数"deviance"。在原理篇中对这些分类损失函数有详细的介绍。通常来讲，推荐使用默认的"deviance"。它对二元分离和多元分类各自都有比较好的优化。而指数损失函数等于把咱们带到了Adaboost算法。学习

　　　　　　对于回归模型，有均方差"ls", 绝对损失"lad", Huber损失"huber"和分位数损失“quantile”。默认是均方差"ls"。通常来讲，若是数据的噪音点很少，用默认的均方差"ls"比较好。若是是噪音点较多，则推荐用抗噪音的损失函数"huber"。而若是咱们须要对训练集进行分段预测的时候，则采用“quantile”。

　　　　6) alpha：这个参数只有GradientBoostingRegressor有，当咱们使用Huber损失"huber"和分位数损失“quantile”时，须要指定分位数的值。默认是0.9，若是噪音点较多，能够适当下降这个分位数的值。

3. GBDT类库弱学习器参数

　　　　这里咱们再对GBDT的类库弱学习器的重要参数作一个总结。因为GBDT使用了CART回归决策树，所以它的参数基原本源于决策树类，也就是说，和DecisionTreeClassifier和DecisionTreeRegressor的参数基本相似。若是你已经很熟悉决策树算法的调参，那么这一节基本能够跳过。不熟悉的朋友能够继续看下去。

　　　　1) 划分时考虑的最大特征数max_features: 可使用不少种类型的值，默认是"None",意味着划分时考虑全部的特征数；若是是"log2"意味着划分时最多考虑log2Nlog2N个特征；若是是"sqrt"或者"auto"意味着划分时最多考虑N−−√N个特征。若是是整数，表明考虑的特征绝对数。若是是浮点数，表明考虑特征百分比，即考虑（百分比xN）取整后的特征数。其中N为样本总特征数。通常来讲，若是样本特征数很少，好比小于50，咱们用默认的"None"就能够了，若是特征数很是多，咱们能够灵活使用刚才描述的其余取值来控制划分时考虑的最大特征数，以控制决策树的生成时间。

　　　　2) 决策树最大深度max_depth: 默承认以不输入，若是不输入的话，决策树在创建子树的时候不会限制子树的深度。通常来讲，数据少或者特征少的时候能够无论这个值。若是模型样本量多，特征也多的状况下，推荐限制这个最大深度，具体的取值取决于数据的分布。经常使用的能够取值10-100之间。

　　　　3) 内部节点再划分所需最小样本数min_samples_split: 这个值限制了子树继续划分的条件，若是某节点的样本数少于min_samples_split，则不会继续再尝试选择最优特征来进行划分。 默认是2.若是样本量不大，不须要管这个值。若是样本量数量级很是大，则推荐增大这个值。

　　　　4) 叶子节点最少样本数min_samples_leaf: 这个值限制了叶子节点最少的样本数，若是某叶子节点数目小于样本数，则会和兄弟节点一块儿被剪枝。 默认是1,能够输入最少的样本数的整数，或者最少样本数占样本总数的百分比。若是样本量不大，不须要管这个值。若是样本量数量级很是大，则推荐增大这个值。

　　　　5）叶子节点最小的样本权重和min_weight_fraction_leaf：这个值限制了叶子节点全部样本权重和的最小值，若是小于这个值，则会和兄弟节点一块儿被剪枝。 默认是0，就是不考虑权重问题。通常来讲，若是咱们有较多样本有缺失值，或者分类树样本的分布类别误差很大，就会引入样本权重，这时咱们就要注意这个值了。

　　　　6) 最大叶子节点数max_leaf_nodes: 经过限制最大叶子节点数，能够防止过拟合，默认是"None”，即不限制最大的叶子节点数。若是加了限制，算法会创建在最大叶子节点数内最优的决策树。若是特征很少，能够不考虑这个值，可是若是特征分红多的话，能够加以限制，具体的值能够经过交叉验证获得。

　　　　7) 节点划分最小不纯度min_impurity_split:  这个值限制了决策树的增加，若是某节点的不纯度(基于基尼系数，均方差)小于这个阈值，则该节点再也不生成子节点。即为叶子节点 。通常不推荐改动默认值1e-7。

4. GBDT调参实例

　　　　这里咱们用一个二元分类的例子来说解下GBDT的调参。这部分参考了这个Github上的数据调参过程Parameter_Tuning_GBM_with_Example。这个例子的数据有87000多行，单机跑会比较慢，下面的例子我只选择了它的前面20000行，我将其打包后，下载地址在这。

　　　　首先，咱们载入须要的类库：　　　

复制代码 
import pandas as pd
import numpy as np
from sklearn.ensemble import GradientBoostingClassifier
from sklearn import cross_validation, metrics
from sklearn.grid_search import GridSearchCV

import matplotlib.pylab as plt
%matplotlib inline
复制代码

　　　　接着，咱们把解压的数据用下面的代码载入，顺便看看数据的类别分布。

train = pd.read_csv('train_modified.csv')
target='Disbursed' # Disbursed的值就是二元分类的输出
IDcol = 'ID'
train['Disbursed'].value_counts()

 　　　　能够看到类别输出以下，也就是类别0的占大多数。

0    19680
1      320
Name: Disbursed, dtype: int64

　　　　如今咱们获得咱们的训练集。最后一列Disbursed是分类输出。前面的全部列（不考虑ID列）都是样本特征。

x_columns = [x for x in train.columns if x not in [target, IDcol]]
X = train[x_columns]
y = train['Disbursed']

　　　　无论任何参数，都用默认的，咱们拟合下数据看看：

复制代码 
gbm0 = GradientBoostingClassifier(random_state=10)
gbm0.fit(X,y)
y_pred = gbm0.predict(X)
y_predprob = gbm0.predict_proba(X)[:,1]
print "Accuracy : %.4g" % metrics.accuracy_score(y.values, y_pred)
print "AUC Score (Train): %f" % metrics.roc_auc_score(y, y_predprob)
复制代码

　　　 输出以下，可见拟合还能够，咱们下面看看怎么经过调参提升模型的泛化能力。

Accuracy : 0.9852
AUC Score (Train): 0.900531

　　　首先咱们从步长(learning rate)和迭代次数(n_estimators)入手。通常来讲,开始选择一个较小的步长来网格搜索最好的迭代次数。这里，咱们将步长初始值设置为0.1。对于迭代次数进行网格搜索以下：

复制代码 
param_test1 = {'n_estimators':range(20,81,10)}
gsearch1 = GridSearchCV(estimator = GradientBoostingClassifier(learning_rate=0.1, min_samples_split=300,
                                  min_samples_leaf=20,max_depth=8,max_features='sqrt', subsample=0.8,random_state=10), 
                       param_grid = param_test1, scoring='roc_auc',iid=False,cv=5)
gsearch1.fit(X,y)
gsearch1.grid_scores_, gsearch1.best_params_, gsearch1.best_score_
复制代码

　　　　输出以下，可见最好的迭代次数是60。

([mean: 0.81285, std: 0.01967, params: {'n_estimators': 20},
  mean: 0.81438, std: 0.01947, params: {'n_estimators': 30},
  mean: 0.81451, std: 0.01933, params: {'n_estimators': 40},
  mean: 0.81618, std: 0.01848, params: {'n_estimators': 50},
  mean: 0.81751, std: 0.01736, params: {'n_estimators': 60},
  mean: 0.81547, std: 0.01900, params: {'n_estimators': 70},
  mean: 0.81299, std: 0.01860, params: {'n_estimators': 80}],
 {'n_estimators': 60},
 0.8175146087398375)

　　　　找到了一个合适的迭代次数，如今咱们开始对决策树进行调参。首先咱们对决策树最大深度max_depth和内部节点再划分所需最小样本数min_samples_split进行网格搜索。

复制代码 
param_test2 = {'max_depth':range(3,14,2), 'min_samples_split':range(100,801,200)}
gsearch2 = GridSearchCV(estimator = GradientBoostingClassifier(learning_rate=0.1, n_estimators=60, min_samples_leaf=20, 
      max_features='sqrt', subsample=0.8, random_state=10), 
   param_grid = param_test2, scoring='roc_auc',iid=False, cv=5)
gsearch2.fit(X,y)
gsearch2.grid_scores_, gsearch2.best_params_, gsearch2.best_score_
复制代码

　　　　输出以下，可见最好的最大树深度是7，内部节点再划分所需最小样本数是300。

([mean: 0.81199, std: 0.02073, params: {'min_samples_split': 100, 'max_depth': 3},
  mean: 0.81267, std: 0.01985, params: {'min_samples_split': 300, 'max_depth': 3},
  mean: 0.81238, std: 0.01937, params: {'min_samples_split': 500, 'max_depth': 3},
  mean: 0.80925, std: 0.02051, params: {'min_samples_split': 700, 'max_depth': 3},
  mean: 0.81846, std: 0.01843, params: {'min_samples_split': 100, 'max_depth': 5},
  mean: 0.81630, std: 0.01810, params: {'min_samples_split': 300, 'max_depth': 5},
  mean: 0.81315, std: 0.01898, params: {'min_samples_split': 500, 'max_depth': 5},
  mean: 0.81262, std: 0.02090, params: {'min_samples_split': 700, 'max_depth': 5},
  mean: 0.81807, std: 0.02004, params: {'min_samples_split': 100, 'max_depth': 7},
  mean: 0.82137, std: 0.01733, params: {'min_samples_split': 300, 'max_depth': 7},
  mean: 0.81703, std: 0.01773, params: {'min_samples_split': 500, 'max_depth': 7},
  mean: 0.81383, std: 0.02327, params: {'min_samples_split': 700, 'max_depth': 7},
  mean: 0.81107, std: 0.02178, params: {'min_samples_split': 100, 'max_depth': 9},
  mean: 0.80944, std: 0.02612, params: {'min_samples_split': 300, 'max_depth': 9},
  mean: 0.81476, std: 0.01973, params: {'min_samples_split': 500, 'max_depth': 9},
  mean: 0.81601, std: 0.02576, params: {'min_samples_split': 700, 'max_depth': 9},
  mean: 0.81091, std: 0.02227, params: {'min_samples_split': 100, 'max_depth': 11},
  mean: 0.81309, std: 0.02696, params: {'min_samples_split': 300, 'max_depth': 11},
  mean: 0.81713, std: 0.02379, params: {'min_samples_split': 500, 'max_depth': 11},
  mean: 0.81347, std: 0.02702, params: {'min_samples_split': 700, 'max_depth': 11},
  mean: 0.81444, std: 0.01813, params: {'min_samples_split': 100, 'max_depth': 13},
  mean: 0.80825, std: 0.02291, params: {'min_samples_split': 300, 'max_depth': 13},
  mean: 0.81923, std: 0.01693, params: {'min_samples_split': 500, 'max_depth': 13},
  mean: 0.81382, std: 0.02258, params: {'min_samples_split': 700, 'max_depth': 13}],
 {'max_depth': 7, 'min_samples_split': 300},
 0.8213724275914632)
　　　

　　　　因为决策树深度7是一个比较合理的值，咱们把它定下来，对于内部节点再划分所需最小样本数min_samples_split，咱们暂时不能一块儿定下来，由于这个还和决策树其余的参数存在关联。下面咱们再对内部节点再划分所需最小样本数min_samples_split和叶子节点最少样本数min_samples_leaf一块儿调参。

复制代码 
param_test3 = {'min_samples_split':range(800,1900,200), 'min_samples_leaf':range(60,101,10)}
gsearch3 = GridSearchCV(estimator = GradientBoostingClassifier(learning_rate=0.1, n_estimators=60,max_depth=7,
                                     max_features='sqrt', subsample=0.8, random_state=10), 
                       param_grid = param_test3, scoring='roc_auc',iid=False, cv=5)
gsearch3.fit(X,y)
gsearch3.grid_scores_, gsearch3.best_params_, gsearch3.best_score_
复制代码

输出结果以下，可见这个min_samples_split在边界值，还有进一步调试小于边界60的必要。因为这里只是例子，因此你们能够本身下来用包含小于60的网格搜索来寻找合适的值。

([mean: 0.81828, std: 0.02251, params: {'min_samples_split': 800, 'min_samples_leaf': 60},
  mean: 0.81731, std: 0.02344, params: {'min_samples_split': 1000, 'min_samples_leaf': 60},
  mean: 0.82220, std: 0.02250, params: {'min_samples_split': 1200, 'min_samples_leaf': 60},
  mean: 0.81447, std: 0.02125, params: {'min_samples_split': 1400, 'min_samples_leaf': 60},
  mean: 0.81495, std: 0.01626, params: {'min_samples_split': 1600, 'min_samples_leaf': 60},
  mean: 0.81528, std: 0.02140, params: {'min_samples_split': 1800, 'min_samples_leaf': 60},
  mean: 0.81590, std: 0.02517, params: {'min_samples_split': 800, 'min_samples_leaf': 70},
  mean: 0.81573, std: 0.02207, params: {'min_samples_split': 1000, 'min_samples_leaf': 70},
  mean: 0.82021, std: 0.02521, params: {'min_samples_split': 1200, 'min_samples_leaf': 70},
  mean: 0.81512, std: 0.01995, params: {'min_samples_split': 1400, 'min_samples_leaf': 70},
  mean: 0.81395, std: 0.02081, params: {'min_samples_split': 1600, 'min_samples_leaf': 70},
  mean: 0.81587, std: 0.02082, params: {'min_samples_split': 1800, 'min_samples_leaf': 70},
  mean: 0.82064, std: 0.02698, params: {'min_samples_split': 800, 'min_samples_leaf': 80},
  mean: 0.81490, std: 0.02475, params: {'min_samples_split': 1000, 'min_samples_leaf': 80},
  mean: 0.82009, std: 0.02568, params: {'min_samples_split': 1200, 'min_samples_leaf': 80},
  mean: 0.81850, std: 0.02226, params: {'min_samples_split': 1400, 'min_samples_leaf': 80},
  mean: 0.81855, std: 0.02099, params: {'min_samples_split': 1600, 'min_samples_leaf': 80},
  mean: 0.81666, std: 0.02249, params: {'min_samples_split': 1800, 'min_samples_leaf': 80},
  mean: 0.81960, std: 0.02437, params: {'min_samples_split': 800, 'min_samples_leaf': 90},
  mean: 0.81560, std: 0.02235, params: {'min_samples_split': 1000, 'min_samples_leaf': 90},
  mean: 0.81936, std: 0.02542, params: {'min_samples_split': 1200, 'min_samples_leaf': 90},
  mean: 0.81362, std: 0.02254, params: {'min_samples_split': 1400, 'min_samples_leaf': 90},
  mean: 0.81429, std: 0.02417, params: {'min_samples_split': 1600, 'min_samples_leaf': 90},
  mean: 0.81299, std: 0.02262, params: {'min_samples_split': 1800, 'min_samples_leaf': 90},
  mean: 0.82000, std: 0.02511, params: {'min_samples_split': 800, 'min_samples_leaf': 100},
  mean: 0.82209, std: 0.01816, params: {'min_samples_split': 1000, 'min_samples_leaf': 100},
  mean: 0.81821, std: 0.02337, params: {'min_samples_split': 1200, 'min_samples_leaf': 100},
  mean: 0.81922, std: 0.02377, params: {'min_samples_split': 1400, 'min_samples_leaf': 100},
  mean: 0.81545, std: 0.02221, params: {'min_samples_split': 1600, 'min_samples_leaf': 100},
  mean: 0.81704, std: 0.02509, params: {'min_samples_split': 1800, 'min_samples_leaf': 100}],
 {'min_samples_leaf': 60, 'min_samples_split': 1200},
 0.8222032996697154)

　　　　咱们调了这么多参数了，终于能够都放到GBDT类里面去看看效果了。如今咱们用新参数拟合数据：

复制代码 
gbm1 = GradientBoostingClassifier(learning_rate=0.1, n_estimators=60,max_depth=7, min_samples_leaf =60, 
               min_samples_split =1200, max_features='sqrt', subsample=0.8, random_state=10)
gbm1.fit(X,y)
y_pred = gbm1.predict(X)
y_predprob = gbm1.predict_proba(X)[:,1]
print "Accuracy : %.4g" % metrics.accuracy_score(y.values, y_pred)
print "AUC Score (Train): %f" % metrics.roc_auc_score(y, y_predprob)
复制代码

　　　　输出以下：

Accuracy : 0.984
AUC Score (Train): 0.908099

　　　　对比咱们最开始彻底不调参的拟合效果，可见精确度稍有降低，主要原理是咱们使用了0.8的子采样，20%的数据没有参与拟合。

　　　　如今咱们再对最大特征数max_features进行网格搜索。

复制代码 
param_test4 = {'max_features':range(7,20,2)}
gsearch4 = GridSearchCV(estimator = GradientBoostingClassifier(learning_rate=0.1, n_estimators=60,max_depth=7, min_samples_leaf =60, 
               min_samples_split =1200, subsample=0.8, random_state=10), 
                       param_grid = param_test4, scoring='roc_auc',iid=False, cv=5)
gsearch4.fit(X,y)
gsearch4.grid_scores_, gsearch4.best_params_, gsearch4.best_score_
复制代码

　　　　输出以下：

([mean: 0.82220, std: 0.02250, params: {'max_features': 7},
  mean: 0.82241, std: 0.02421, params: {'max_features': 9},
  mean: 0.82108, std: 0.02302, params: {'max_features': 11},
  mean: 0.82064, std: 0.01900, params: {'max_features': 13},
  mean: 0.82198, std: 0.01514, params: {'max_features': 15},
  mean: 0.81355, std: 0.02053, params: {'max_features': 17},
  mean: 0.81877, std: 0.01863, params: {'max_features': 19}],
 {'max_features': 9},
 0.822412506351626)

　　　　如今咱们再对子采样的比例进行网格搜索：

复制代码 
param_test5 = {'subsample':[0.6,0.7,0.75,0.8,0.85,0.9]}
gsearch5 = GridSearchCV(estimator = GradientBoostingClassifier(learning_rate=0.1, n_estimators=60,max_depth=7, min_samples_leaf =60, 
               min_samples_split =1200, max_features=9, random_state=10), 
                       param_grid = param_test5, scoring='roc_auc',iid=False, cv=5)
gsearch5.fit(X,y)
gsearch5.grid_scores_, gsearch5.best_params_, gsearch5.best_score_
复制代码

　　　　输出以下：

([mean: 0.81828, std: 0.02392, params: {'subsample': 0.6},
  mean: 0.82344, std: 0.02708, params: {'subsample': 0.7},
  mean: 0.81673, std: 0.02196, params: {'subsample': 0.75},
  mean: 0.82241, std: 0.02421, params: {'subsample': 0.8},
  mean: 0.82285, std: 0.02446, params: {'subsample': 0.85},
  mean: 0.81738, std: 0.02236, params: {'subsample': 0.9}],
 {'subsample': 0.7},
 0.8234378969766262)

　　　　如今咱们基本已经获得咱们全部调优的参数结果了。这时咱们能够减半步长，最大迭代次数加倍来增长咱们模型的泛化能力。再次拟合咱们的模型：

复制代码 
gbm2 = GradientBoostingClassifier(learning_rate=0.05, n_estimators=120,max_depth=7, min_samples_leaf =60, 
               min_samples_split =1200, max_features=9, subsample=0.7, random_state=10)
gbm2.fit(X,y)
y_pred = gbm2.predict(X)
y_predprob = gbm2.predict_proba(X)[:,1]
print "Accuracy : %.4g" % metrics.accuracy_score(y.values, y_pred)
print "AUC Score (Train): %f" % metrics.roc_auc_score(y, y_predprob)
复制代码

　　　　输出以下：

Accuracy : 0.984
AUC Score (Train): 0.905324

　　　　能够看到AUC分数比起以前的版本稍有降低，这个缘由是咱们为了增长模型泛化能力，为防止过拟合而减半步长，最大迭代次数加倍，同时减少了子采样的比例，从而减小了训练集的拟合程度。

　　　　下面咱们继续将步长缩小5倍，最大迭代次数增长5倍，继续拟合咱们的模型：

复制代码 
gbm3 = GradientBoostingClassifier(learning_rate=0.01, n_estimators=600,max_depth=7, min_samples_leaf =60, 
               min_samples_split =1200, max_features=9, subsample=0.7, random_state=10)
gbm3.fit(X,y)
y_pred = gbm3.predict(X)
y_predprob = gbm3.predict_proba(X)[:,1]
print "Accuracy : %.4g" % metrics.accuracy_score(y.values, y_pred)
print "AUC Score (Train): %f" % metrics.roc_auc_score(y, y_predprob)
复制代码

　　　　输出以下，可见减少步长增长迭代次数能够在保证泛化能力的基础上增长一些拟合程度。

Accuracy : 0.984
AUC Score (Train): 0.908581

　　　　最后咱们继续步长缩小一半，最大迭代次数增长2倍，拟合咱们的模型：

复制代码 
gbm4 = GradientBoostingClassifier(learning_rate=0.005, n_estimators=1200,max_depth=7, min_samples_leaf =60, 
               min_samples_split =1200, max_features=9, subsample=0.7, random_state=10)
gbm4.fit(X,y)
y_pred = gbm4.predict(X)
y_predprob = gbm4.predict_proba(X)[:,1]
print "Accuracy : %.4g" % metrics.accuracy_score(y.values, y_pred)
print "AUC Score (Train): %f" % metrics.roc_auc_score(y, y_predprob)
复制代码

　　　　输出以下，此时因为步长实在过小，致使拟合效果反而变差，也就是说，步长不能设置的太小。

Accuracy : 0.984
AUC Score (Train): 0.908232

　　　　

　　　　以上就是GBDT调参的一个总结，但愿能够帮到朋友们。

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程