XGBoost原理及应用
XGBOST原理
XGBoost是使用梯度提升框架实现的高效、灵活、可移植的机器学习库，全称是EXtreme Gradient Boosting.
XGBoost算法原理
其实算法的原理就是在一颗决策树的基础上不断地加树，比如在n-1颗树地基础上加一棵树变成n颗树的同时算法的精确率不断提高、效果提升。
基础理解:
- 损失函数: l(yi,yi^) = (yi-yi^)**2 【这里损失函数先以方差损失作为示例、因为比较好算和符号表达毕竟这个也很不错；当然损失函数可以更改】
- 如何最优化的求解？ ： F*(x) = argmin E(x,y)(L(y,F(x)))
- 最终，集成算法的表示：yi^ = sum(fk(xi)) ; 其中，k=1~K;fk属于F
- yi0^ = 0
- yi1^ = f1(xi) = yi0^+f1(xi)
- yi2^ = f1(xi)+f2(xi) = yi1^+f2(xi)
- …
- yin^ = sum(fk(xi)) = yi{n-1}^ + fn(xi) ；其中，k=1~n。
推导过程:
-
在样本中着手计算，样本的真实值yi,预测值yi^。
-
目标: Obj{t} = sum(l(yi,yi^{t-1}+ft(xi)))+U(ft)+c 其中、c为常数，i=1~n，
U(ft)为L2正则化的惩罚函数 （说白了就是L2正则项:qT+lambad* 1/2*
sum(wj**2);其中j=1~T;qT是某个常数,T为叶子节点个数） -
知识补充：
泰勒展开: f(x+▲x) ~ f(x)+▲x* f(x)的一阶导 + ▲xf(x)的二阶导 定义:gi = G{y{t-1}^}
l(yi,y{t-1}^); hi = H{y{t-1}^}2 * l(yi,y{t-1}^) ; gi是一阶导、hi是二阶导。
所以，目标函数变换得到：Obj{t} ~ sum(l(yi,yi{t-1}^)+gi ft{xi}+1/2 hi*
ft(xi)**2) ;其中，i=1~n。其实l(yi,yi{t-1}^)相当于一个常数值，因为它从未改变，收敛于某个具体的常数。 -
再次变换：得到Obj{t} ~ sum(gi* ft(xi)+1/2* hi* ft(xi)**2)+U(ft) ;其中，i=1~n。
-
将样本上的遍历计算转换为在叶子节点上的遍历计算： Obj{t} = sum((sum(gi,i属于Ij)*
wj+1/2*(sum(hi,i属于Ij)+lambad)* wj**2))+qT,其中，j=1~T。 -
最终目标函数简化为: Obj{t} = sum(Gj* wj+1/2*(Hj+lambad)* wj**2) +
qT;其中Gj=sum(gi,i属于Ij)，Hj=sum(hi,i属于Ij)。 -
求解最终的目标函数：一贯操作：求偏导、令偏导为0、代
-
入原函数；
J(ft)对wj求偏导 = Gj+(Hj+lambad)* wj=0 wj = -(Gj/Hj+lambad)
将wj带回原Obj{t}最终目标函数得到：Obj = -1/2* sum(Gj**2/(Hj+lambad),j=1~T)+qT;
代入数据计算得出的分数越小代表这个树的结构越好,也就是损失值越小越好。 加入新节点的时候的模型复杂度代价:Gain =1/2*(G{L}**2/(H{L}+lambad)+G{R}**2/(H{R}+lambad)-(G{L}+G{R})**2/(H{L}+H{R}+lambad))-q
XGBoost的思路总结:
1.根据数据集初始化一棵树；
2.确定损失函数；
3.拿出一棵树来作为推导“样本上的遍历计算”这个过程，然后通过函数变换得到“叶子节点上的遍历计算”这个过程，之后求解模型。
4.还可以根据计算得到的模型复杂度设置复杂度阈值、毕竟计算资源的代价太大的话也不是很好。
xgboost模块的XGBClassifier类是解决分类问题、XGBRegressor类是解决回归问题。
- xgboost.XGBClassifier(max_depth=3,learning_rate=0.1,n_estimators=100,silent=True,objective=‘binary:logistic’)
- xgboost.XGBRegressor(max_depth=3,learning_rate=0.1,n_estimators=100,silent=True,objective=‘binary:linear’,booster=‘gbtree’)
参数解释：
-
max_depth用于指定每个基础模型所包含的最大深度、默认为3层。
-
learning_rate用于指定模型迭代的学习率(步长)、默认为0.1；【与前面的提升树模型、梯度提升树模型含义相同】
-
n_estimators用于指定基础模型的数量、默认为100个。
-
silent：bool类型参数，是否输出算法运行过程中的日志信息，默认为True。
-
objective用于指定目标函数中的损失函数类型，1.对于分类类型的XGBoost算法、默认损失函数为二分类的Logistic损失(模型返回概率值)函数，也可以是’multi:softmax’表示处理多分类的损失函数(模型返回类别值)、还可以是’multi:softprob’处理多分类(模型返回各类别对应的概率值)。
2.对于预测型的XGBoost算法，默认损失函数为线性回归损失’binary:linear’。
基于XGBOST预测毒蘑菇
数据处理（稀疏数据）：
1、12.agaricus.txt 毒蘑菇的126个特征
2、12.agaricus_test.txt 测试数据，第一列为1，显示哪些特征为1
3、12.agaricus_train.txt 训练数据
导包
import xgboost as xgb
import numpy as np
导入数据
# 1、xgBoost的基本使用
# 2、自定义损失函数的梯度和二阶导
# 3、binary:logistic/logitraw
# 定义f: theta * x
def log_reg(y_hat, y):
p = 1.0 / (1.0 + np.exp(-y_hat))
g = p - y.get_label()
h = p * (1.0-p)
return g, h
def error_rate(y_hat, y):
return 'error', float(sum(y.get_label() != (y_hat > 0.5))) / len(y_hat)
if __name__ == "__main__":
# 读取数据
data_train = xgb.DMatrix('D:\\data\\xgboost\\12.agaricus_train.txt')
data_test = xgb.DMatrix('D:\\data\\xgboost\\12.agaricus_test.txt')
设置参数
param = {'max_depth': 3, 'eta': 1, 'silent': 1, 'objective': 'binary:logitraw'} # logitraw
# 'max_depth': 树的最大深度，2指1-2-4-8这种。
#'eta': 防止过拟合参数, 'silent': 树生成过程中的过程输出, 'objective': 'reg:logistic' 回归
watchlist = [(data_test, 'eval'), (data_train, 'train')]
n_round = 3 #做几次计算
bst = xgb.train(param, data_train, num_boost_round=n_round, evals=watchlist, obj=log_reg, feval=error_rate)
计算错误率
y_hat = bst.predict(data_test) #做预测
y = data_test.get_label() #获取标记
print( y_hat) #我们的估计值
print (y)
error = sum(y != (y_hat > 0.5))
error_rate = float(error) / len(y_hat) #错误率
print ('样本总数：\t', len(y_hat))
print ('错误数目：\t%4d' % error)
print ('错误率：\t%.5f%%' % (100*error_rate))
logistics回归
def show_accuracy(a, b, tip):
acc = a.ravel() == b.ravel()
print (acc)
print (tip + '正确率：\t', float(acc.sum()) / a.size)
if __name__ == '__main__':
x, y = read_data('D:\\data\\xgboost\\12.agaricus_train.txt')
x_train, x_test, y_train, y_test = train_test_split(x, y, random_state=1, train_size=0.6)
# Logistic回归
lr = LogisticRegression(penalty='l2')
lr.fit(x_train, y_train.ravel())
y_hat = lr.predict(x_test)
show_accuracy(y_hat, y_test, 'Logistic回归 ')
# XGBoost
y_train[y_train == 3] = 0
y_test[y_test == 3] = 0
data_train = xgb.DMatrix(x_train, label=y_train)
data_test = xgb.DMatrix(x_test, label=y_test)
watch_list = [(data_test, 'eval'), (data_train, 'train')]
param = {'max_depth': 3, 'eta': 1, 'silent': 0, 'objective': 'multi:softmax', 'num_class': 3}
bst = xgb.train(param, data_train, num_boost_round=4, evals=watch_list)
y_hat = bst.predict(data_test)
show_accuracy(y_hat, y_test, 'XGBoost ')
基于XGBOST做鸢尾花预测
测量数据：花瓣的长度和宽度，花萼的长度和宽度，所测量结果都以厘米为单位。这一类花有三个品种：setosa,versicolor,virginnica。我们的目标是建立一个基础的机器学习的模型预测鸢尾花的品种。这是最基础的三分类问题，数据集中每朵鸢尾花叫做一个数据点，它的品种叫做它的标签。
导包
import xgboost as xgb
import numpy as np
from sklearn.model_selection import train_test_split # cross_validation
导入数据
if __name__ == "__main__":
path = u'D:\\data\\xgboost\\8.iris.data' # 数据文件路径
data = np.loadtxt(path, dtype=float, delimiter=',', converters={4: iris_type})
x, y = np.split(data, (4,), axis=1)
x_train, x_test, y_train, y_test = train_test_split(x, y, random_state=1, test_size=50)
建立模型
data_train = xgb.DMatrix(x_train, label=y_train)
data_test = xgb.DMatrix(x_test, label=y_test)
watch_list = [(data_test, 'eval'), (data_train, 'train')]
param = {'max_depth': 2, 'eta': 0.3, 'silent': 1, 'objective': 'multi:softmax', 'num_class': 3}
bst = xgb.train(param, data_train, num_boost_round=6, evals=watch_list)
y_hat = bst.predict(data_test)
print(y_hat)
result = y_test.reshape(1, -1) == y_hat
print ('正确率:\t', float(np.sum(result)) / len(y_hat))
print ('END.....\n')
结论：正确率: 0.98
利用XGBoost预测泰坦尼克号乘客是否生还。
评判标准：以乘客是否生还和模型预测情况做对比，得到模型准确率。
数据：
数据清洗：1、年龄：随机森林填充缺失值 2、岭回归 3、出发地点：one-hot编码
导包
import xgboost as xgb
import numpy as np
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestRegressor
from sklearn.ensemble import RandomForestClassifier
import pandas as pd
import csv
缺失值处理：
def show_accuracy(a, b, tip):
acc = a.ravel() == b.ravel()
acc_rate = 100 * float(acc.sum()) / a.size
# print '%s正确率：%.3f%%' % (tip, acc_rate)
return acc_rate
def load_data(file_name, is_train):
data = pd.read_csv(file_name) # 数据文件路径
print (data.describe())
# 性别
data['Sex'] = data['Sex'].map({'female': 0, 'male': 1}).astype(int)
# 补齐船票价格缺失值中位数
if len(data.Fare[data.Fare.isnull()]) > 0:
fare = np.zeros(3)
for f in range(0, 3):
fare[f] = data[data.Pclass == f + 1]['Fare'].dropna().median()
for f in range(0, 3): # loop 0 to 2
data.loc[(data.Fare.isnull()) & (data.Pclass == f + 1), 'Fare'] = fare[f]
# 年龄：使用均值代替缺失值
# mean_age = data['Age'].dropna().mean()
# data.loc[(data.Age.isnull()), 'Age'] = mean_age
if is_train:
# 年龄：使用随机森林预测年龄缺失值
print ('随机森林预测缺失年龄：--start--')
data_for_age = data[['Age', 'Survived', 'Fare', 'Parch', 'SibSp', 'Pclass']]
age_exist = data_for_age.loc[(data.Age.notnull())] # 年龄不缺失的数据
age_null = data_for_age.loc[(data.Age.isnull())]
# print age_exist
x = age_exist.values[:, 1:]
y = age_exist.values[:, 0]
rfr = RandomForestRegressor(n_estimators=1000)
rfr.fit(x, y)
age_hat = rfr.predict(age_null.values[:, 1:])
# print age_hat
data.loc[(data.Age.isnull()), 'Age'] = age_hat
print ('随机森林预测缺失年龄：--over--')
else:
print ('随机森林预测缺失年龄2：--start--')
data_for_age = data[['Age', 'Fare', 'Parch', 'SibSp', 'Pclass']]
age_exist = data_for_age.loc[(data.Age.notnull())] # 年龄不缺失的数据
age_null = data_for_age.loc[(data.Age.isnull())]
# print age_exist
x = age_exist.values[:, 1:]
y = age_exist.values[:, 0]
rfr = RandomForestRegressor(n_estimators=1000)
rfr.fit(x, y)
age_hat = rfr.predict(age_null.values[:, 1:])
# print age_hat
data.loc[(data.Age.isnull()), 'Age'] = age_hat
print ('随机森林预测缺失年龄2：--over--')
# 起始城市
data.loc[(data.Embarked.isnull()), 'Embarked'] = 'S' # 保留缺失出发城市
# data['Embarked'] = data['Embarked'].map({'S': 0, 'C': 1, 'Q': 2, 'U': 0}).astype(int)
# print data['Embarked']
embarked_data = pd.get_dummies(data.Embarked)
# print embarked_data
# embarked_data = embarked_data.rename(columns={'S': 'Southampton', 'C': 'Cherbourg', 'Q': 'Queenstown', 'U': 'UnknownCity'})
embarked_data = embarked_data.rename(columns=lambda x: 'Embarked_' + str(x))
data = pd.concat([data, embarked_data], axis=1)
print (data.describe())
data.to_csv('New_Data.csv')
导入数据
x = data[['Pclass', 'Sex', 'Age', 'SibSp', 'Parch', 'Fare', 'Embarked_C', 'Embarked_Q', 'Embarked_S']]
# x = data[['Pclass', 'Sex', 'Age', 'SibSp', 'Parch', 'Fare', 'Embarked']]
y = None
if 'Survived' in data:
y = data['Survived']
x = np.array(x)
y = np.array(y)
# 思考：这样做，其实发生了什么？
x = np.tile(x, (5, 1))
y = np.tile(y, (5, ))
if is_train:
return x, y
return x, data['PassengerId']
def write_result(c, c_type):
file_name = 'D:\\data\\xgboost\\12.Titanic.test.csv'
x, passenger_id = load_data(file_name, False)
if type == 3:
x = xgb.DMatrix(x)
y = c.predict(x)
y[y > 0.5] = 1
y[~(y > 0.5)] = 0
predictions_file = open("Prediction_%d.csv" % c_type, "wb")
open_file_object = csv.writer(predictions_file)
open_file_object.writerow(["PassengerId", "Survived"])
open_file_object.writerows(zip(passenger_id, y))
predictions_file.close()
模型处理
if __name__ == "__main__":
x, y = load_data('D:\\data\\xgboost\\12.Titanic.train.csv', True)
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.5, random_state=1)
lr = LogisticRegression(penalty='l2')
lr.fit(x_train, y_train)
y_hat = lr.predict(x_test)
lr_rate = show_accuracy(y_hat, y_test, 'Logistic回归 ')
# write_result(lr, 1)
rfc = RandomForestClassifier(n_estimators=100)
rfc.fit(x_train, y_train)
y_hat = rfc.predict(x_test)
rfc_rate = show_accuracy(y_hat, y_test, '随机森林 ')
# write_result(rfc, 2)
# XGBoost
data_train = xgb.DMatrix(x_train, label=y_train)
data_test = xgb.DMatrix(x_test, label=y_test)
watch_list = [(data_test, 'eval'), (data_train, 'train')]
param = {'max_depth': 3, 'eta': 0.1, 'silent': 1, 'objective': 'binary:logistic'}
# 'subsample': 1, 'alpha': 0, 'lambda': 0, 'min_child_weight': 1}
bst = xgb.train(param, data_train, num_boost_round=100, evals=watch_list)
y_hat = bst.predict(data_test)
# write_result(bst, 3)
y_hat[y_hat > 0.5] = 1
y_hat[~(y_hat > 0.5)] = 0
xgb_rate = show_accuracy(y_hat, y_test, 'XGBoost ')
print ('Logistic回归：%.3f%%' % lr_rate)
print ('随机森林：%.3f%%' % rfc_rate)
print ('XGBoost：%.3f%%' % xgb_rate)
模型结论：
Logistic回归：78.770%
随机森林：97.935%
XGBoost：85.458%