XGBoost算法—Python实现

XGBoost（eXtreme Gradient Boosting）是一个优化的分布式梯度增强库，旨在实现高效、灵活和便携的机器学习算法。以下是关于XGBoost的详细解析：

一、定义与背景

  • 定义：XGBoost是一个在梯度提升（Gradient Boosting）框架下实现的机器学习算法库，是GBDT（Gradient Boosting Decision Tree）的一种高效实现。
  • 开发：由Tianqi Chen等人在2014年开发，旨在提升梯度提升决策树的计算效率和预测性能。
  • 特点：XGBoost提供了并行树提升功能，能够快速准确地解决许多数据科学问题，并且支持在多种分布式环境（如Hadoop、SGE、MPI）上运行。

二、基本原理

  • 梯度提升

  • XGBoost基于梯度提升算法，通过逐步改进模型的预测能力来最小化损失函数。在每次迭代中，都会训练一个新的弱学习器（通常是决策树），并通过负梯度方向来最小化当前的损失函数。

  • 二阶导数优化

  • 与传统的梯度提升算法不同，XGBoost不仅利用损失函数的一阶导数（梯度），还利用了二阶导数（Hessian矩阵）来加速收敛，提高模型的精度。

  • 正则化处理

  • 为了防止模型过拟合，XGBoost在目标函数中加入了正则化项，用于控制模型的复杂度。

三、优点与缺点

优点

  1. 准确性高：XGBoost在处理结构化数据和非结构化数据方面表现出色，通常能够获得比其他算法更高的准确性。
  2. 鲁棒性强：XGBoost具有较强的鲁棒性，能够处理缺失值和异常值等数据问题。
  3. 计算效率高：XGBoost采用了并行计算技术，在处理大规模数据时具有较高的计算效率。
  4. 可解释性强：XGBoost基于决策树集成，具有较好的可解释性，能够输出每个特征的重要性程度。

缺点

  1. 参数调节复杂：XGBoost有许多参数需要调节，对于不同的数据集需要进行不同的参数调节，这增加了使用难度。
  2. 容易过拟合：在处理小样本数据时，XGBoost容易出现过拟合问题，需要进行正则化等处理。
  3. 对异常值敏感：XGBoost对于异常值比较敏感，需要进行异常值处理以提高模型的鲁棒性。

四、应用场景

XGBoost的应用场景非常广泛，包括但不限于以下几个方面：

  • 分类任务

  • 如垃圾邮件检测、图像分类、客户流失预测等。

  • 回归任务

  • 如房价预测、销量预测等。

  • 排序任务

  • 如搜索引擎的结果排序、推荐系统中的物品排序等。

  • 异常检测

  • 如网络入侵检测、金融欺诈检测等。

五、安装与实现

XGBoost可以在多种编程环境中安装和使用，如Python、R等。在Python中，可以通过pip命令直接安装XGBoost库，或者使用conda进行安装。安装完成后，可以使用XGBoost提供的API进行模型训练和预测。

六、总结

XGBoost作为一种强大的集成学习算法，通过一系列优化技术和正则化方法，显著提升了梯度提升决策树的性能。其高效性和高准确性使其在多个数据竞赛中表现出色，并被广泛应用于各种机器学习任务。随着计算资源的不断提升和算法的进一步改进，XGBoost将在更多领域发挥重要作用。

七、波士顿房价预测(XGBoost)

from xgboost import XGBRegressor as XGBR
from sklearn.ensemble import RandomForestRegressor as RFR
from sklearn.linear_model import LinearRegression as LinearR
from sklearn.model_selection import KFold, cross_val_score as CVS, train_test_split as TTS
from sklearn.metrics import mean_squared_error as MSE
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from time import time
import datetime
#%%
data_url = "http://lib.stat.cmu.edu/datasets/boston"
raw_df = pd.read_csv(data_url, sep="\s+", skiprows=22, header=None)
data = np.hstack([raw_df.values[::2, :], raw_df.values[1::2, :2]])
target = raw_df.values[1::2, 2]
data=pd.DataFrame(data,columns=["CRIM","ZN","INDUS","CHAS","NOX","RM","AGE","DIS","RAD","TAX","PTRATIO","B","LSTAT"])
#波士顿数据集非常简单，但它所涉及到的问题却很多
#%%
data
#%%
X = data
y = target
#%%
X.shape
#%%
y.shape
#%%
y
#%%
Xtrain,Xtest,Ytrain,Ytest = TTS(X,y,test_size=0.3,random_state=420)
#%%
reg = XGBR(n_estimators=100).fit(Xtrain,Ytrain) #训练
#%%
reg.predict(Xtest) #传统接口predict
#%%
reg.score(Xtest,Ytest) #你能想出这里应该返回什么模型评估指标么？利用shift+Tab可以知道，R^2评估指标
#%%
y.mean()
#%%
MSE(Ytest,reg.predict(Xtest))#可以看出均方误差是平均值y.mean()的1/3左右，结果不算好也不算坏
#%%
reg.feature_importances_ #树模型的优势之一：能够查看模型的重要性分数，可以使用嵌入法(SelectFromModel)进行特征选择
#xgboost可以使用嵌入法进行特征选择
#%%
reg = XGBR(n_estimators=100) #交叉验证中导入的没有经过训练的模型
#%%
CVS(reg,Xtrain,Ytrain,cv=5).mean()
#这里应该返回什么模型评估指标，还记得么？ 返回的是与reg.score相同的评估指标R^2（回归），准确率（分类）
#%%
#严谨的交叉验证与不严谨的交叉验证之间的讨论：训练集 or 全数据？
#%%
#严谨 vs 不严谨
#%%
CVS(reg,Xtrain,Ytrain,cv=5,scoring='neg_mean_squared_error').mean()
#%%
#来查看一下sklearn中所有的模型评估指标
import sklearn
sorted(sklearn.metrics.SCORERS.keys())
#%%
#使用随机森林和线性回归进行一个对比
rfr = RFR(n_estimators=100)
CVS(rfr,Xtrain,Ytrain,cv=5).mean()#0.7975497480638329
#%%
CVS(rfr,Xtrain,Ytrain,cv=5,scoring='neg_mean_squared_error').mean()#-16.998723616338033
#%%
lr = LinearR()
CVS(lr,Xtrain,Ytrain,cv=5).mean()#0.6835070597278085
#%%
CVS(lr,Xtrain,Ytrain,cv=5,scoring='neg_mean_squared_error').mean()#-25.34950749364844
#%%
#如果开启参数slient：在数据巨大，预料到算法运行会非常缓慢的时候可以使用这个参数来监控模型的训练进度
reg = XGBR(n_estimators=10,silent=True)#xgboost库silent=True不会打印训练进程，只返回运行结果，默认是False会打印训练进程
#sklearn库中的xgbsoost的默认为silent=True不会打印训练进程，想打印需要手动设置为False
CVS(reg,Xtrain,Ytrain,cv=5,scoring='neg_mean_squared_error').mean()#-92.67865836936579
#%%
def plot_learning_curve(estimator,title, X, y, ax=None, #选择子图ylim=None, #设置纵坐标的取值范围cv=None, #交叉验证n_jobs=None #设定索要使用的线程):from sklearn.model_selection import learning_curveimport matplotlib.pyplot as pltimport numpy as nptrain_sizes, train_scores, test_scores = learning_curve(estimator, X, y,shuffle=True,cv=cv,random_state=420,n_jobs=n_jobs)      if ax == None:ax = plt.gca()else:ax = plt.figure()ax.set_title(title)if ylim is not None:ax.set_ylim(*ylim)ax.set_xlabel("Training examples")ax.set_ylabel("Score")ax.grid() #绘制网格，不是必须ax.plot(train_sizes, np.mean(train_scores, axis=1), 'o-', color="r",label="Training score")ax.plot(train_sizes, np.mean(test_scores, axis=1), 'o-', color="g",label="Test score")ax.legend(loc="best")return ax
#%%
cv = KFold(n_splits=5, shuffle = True, random_state=42) #交叉验证模式
#%%
plot_learning_curve(XGBR(n_estimators=100,random_state=420),"XGB",Xtrain,Ytrain,ax=None,cv=cv)
plt.show()
#%%
#=====【TIME WARNING：25 seconds】=====#axisx = range(10,1010,50)
rs = []
for i in axisx:reg = XGBR(n_estimators=i,random_state=420)rs.append(CVS(reg,Xtrain,Ytrain,cv=cv).mean())
print(axisx[rs.index(max(rs))],max(rs))
plt.figure(figsize=(20,5))
plt.plot(axisx,rs,c="red",label="XGB")
plt.legend()
plt.show()
#%%
#选出来的n_estimators非常不寻常，我们是否要选择准确率最高的n_estimators值呢？
#%%
#======【TIME WARNING: 20s】=======#
axisx = range(50,1050,50)
rs = []
var = []
ge = []
for i in axisx:reg = XGBR(n_estimators=i,random_state=420)cvresult = CVS(reg,Xtrain,Ytrain,cv=cv)#记录1-偏差rs.append(cvresult.mean())#记录方差var.append(cvresult.var())#计算泛化误差的可控部分ge.append((1 - cvresult.mean())**2+cvresult.var())
#打印R2最高所对应的参数取值，并打印这个参数下的方差
print(axisx[rs.index(max(rs))],max(rs),var[rs.index(max(rs))])
#打印方差最低时对应的参数取值，并打印这个参数下的R2
print(axisx[var.index(min(var))],rs[var.index(min(var))],min(var))
#打印泛化误差可控部分的参数取值，并打印这个参数下的R2，方差以及泛化误差的可控部分
print(axisx[ge.index(min(ge))],rs[ge.index(min(ge))],var[ge.index(min(ge))],min(ge))
plt.figure(figsize=(20,5))
plt.plot(axisx,rs,c="red",label="XGB")
plt.legend()
plt.show()
#%%
axisx = range(100,300,10)
rs = []
var = []
ge = []
for i in axisx:reg = XGBR(n_estimators=i,random_state=420)cvresult = CVS(reg,Xtrain,Ytrain,cv=cv)rs.append(cvresult.mean())var.append(cvresult.var())ge.append((1 - cvresult.mean())**2+cvresult.var())
print(axisx[rs.index(max(rs))],max(rs),var[rs.index(max(rs))])
print(axisx[var.index(min(var))],rs[var.index(min(var))],min(var))
print(axisx[ge.index(min(ge))],rs[ge.index(min(ge))],var[ge.index(min(ge))],min(ge))
rs = np.array(rs)
var = np.array(var)*0.01
plt.figure(figsize=(20,5))
plt.plot(axisx,rs,c="black",label="XGB")
#添加方差线
plt.plot(axisx,rs+var,c="red",linestyle='-.')
plt.plot(axisx,rs-var,c="red",linestyle='-.')
plt.legend()
plt.show()
#%%
#看看泛化误差的可控部分如何？
plt.figure(figsize=(20,5))
plt.plot(axisx,ge,c="gray",linestyle='-.')
plt.show()
#%%
#验证模型效果是否提高了？
time0 = time()
print(XGBR(n_estimators=100,random_state=420).fit(Xtrain,Ytrain).score(Xtest,Ytest))
print(time()-time0)
#%%
time0 = time()
print(XGBR(n_estimators=660,random_state=420).fit(Xtrain,Ytrain).score(Xtest,Ytest))
print(time()-time0)
#%%
time0 = time()
print(XGBR(n_estimators=180,random_state=420).fit(Xtrain,Ytrain).score(Xtest,Ytest))
print(time()-time0)
#%%
axisx = np.linspace(0,1,20)
rs = []
for i in axisx:reg = XGBR(n_estimators=180,subsample=i,random_state=420)rs.append(CVS(reg,Xtrain,Ytrain,cv=cv).mean())
print(axisx[rs.index(max(rs))],max(rs))
plt.figure(figsize=(20,5))
plt.plot(axisx,rs,c="green",label="XGB")
plt.legend()
plt.show()
#%%
#继续细化学习曲线
axisx = np.linspace(0.05,1,20)
rs = []
var = []
ge = []
for i in axisx:reg = XGBR(n_estimators=180,subsample=i,random_state=420)cvresult = CVS(reg,Xtrain,Ytrain,cv=cv)rs.append(cvresult.mean())var.append(cvresult.var())ge.append((1 - cvresult.mean())**2+cvresult.var())
print(axisx[rs.index(max(rs))],max(rs),var[rs.index(max(rs))])
print(axisx[var.index(min(var))],rs[var.index(min(var))],min(var))
print(axisx[ge.index(min(ge))],rs[ge.index(min(ge))],var[ge.index(min(ge))],min(ge))
rs = np.array(rs)
var = np.array(var)
plt.figure(figsize=(20,5))
plt.plot(axisx,rs,c="black",label="XGB")
plt.plot(axisx,rs+var,c="red",linestyle='-.')
plt.plot(axisx,rs-var,c="red",linestyle='-.')
plt.legend()
plt.show()
#%%
#细化学习曲线
axisx = np.linspace(0.75,1,25)
rs = []
var = []
ge = []
for i in axisx:reg = XGBR(n_estimators=180,subsample=i,random_state=420)cvresult = CVS(reg,Xtrain,Ytrain,cv=cv)rs.append(cvresult.mean())var.append(cvresult.var())ge.append((1 - cvresult.mean())**2+cvresult.var())
print(axisx[rs.index(max(rs))],max(rs),var[rs.index(max(rs))])
print(axisx[var.index(min(var))],rs[var.index(min(var))],min(var))
print(axisx[ge.index(min(ge))],rs[ge.index(min(ge))],var[ge.index(min(ge))],min(ge))
rs = np.array(rs)
var = np.array(var)
plt.figure(figsize=(20,5))
plt.plot(axisx,rs,c="black",label="XGB")
plt.plot(axisx,rs+var,c="red",linestyle='-.')
plt.plot(axisx,rs-var,c="red",linestyle='-.')
plt.legend()
plt.show()
#%%
reg = XGBR(n_estimators=180#  ,subsample=0.7708333333333334,random_state=420).fit(Xtrain,Ytrain)
reg.score(Xtest,Ytest)
#%%
MSE(Ytest,reg.predict(Xtest))
#%%
#首先我们先来定义一个评分函数，这个评分函数能够帮助我们直接打印Xtrain上的交叉验证结果
def regassess(reg,Xtrain,Ytrain,cv,scoring = ["r2"],show=True):score = []for i in range(len(scoring)):if show:print("{}:{:.2f}".format(scoring[i] #模型评估指标的名字,CVS(reg,Xtrain,Ytrain,cv=cv,scoring=scoring[i]).mean()))score.append(CVS(reg,Xtrain,Ytrain,cv=cv,scoring=scoring[i]).mean())return score
#%%
reg = XGBR(n_estimators=180,random_state=420)
#%%
regassess(reg,Xtrain,Ytrain,cv,scoring = ["r2","neg_mean_squared_error"])
#%%
regassess(reg,Xtrain,Ytrain,cv,scoring = ["r2","neg_mean_squared_error"],show=False)
#%%
from time import time
import datetimefor i in [0,0.2,0.5,1]:time0=time()reg = XGBR(n_estimators=180,random_state=420,learning_rate=i)print("learning_rate = {}".format(i))regassess(reg,Xtrain,Ytrain,cv,scoring = ["r2","neg_mean_squared_error"])print(datetime.datetime.fromtimestamp(time()-time0).strftime("%M:%S:%f"))print("\t")
#%%
axisx = np.arange(0.05,1,0.05)
rs = []
te = []
for i in axisx:reg = XGBR(n_estimators=180,random_state=420,learning_rate=i)score = regassess(reg,Xtrain,Ytrain,cv,scoring = ["r2","neg_mean_squared_error"],show=False)test = reg.fit(Xtrain,Ytrain).score(Xtest,Ytest)rs.append(score[0])te.append(test)
print(axisx[rs.index(max(rs))],max(rs))
plt.figure(figsize=(20,5))
plt.plot(axisx,te,c="gray",label="test")
plt.plot(axisx,rs,c="green",label="train")
plt.legend()
plt.show()
#%%
for booster in ["gbtree","gblinear","dart"]:reg = XGBR(n_estimators=180,learning_rate=0.1,random_state=420,booster=booster).fit(Xtrain,Ytrain)print(booster)print(reg.score(Xtest,Ytest))
#%%
#默认reg:linear
reg = XGBR(n_estimators=180,random_state=420).fit(Xtrain,Ytrain)
reg.score(Xtest, Ytest)
#%%
MSE(Ytest,reg.predict(Xtest))
#%%
#xgb实现法
import xgboost as xgb
#%%
#使用类DMatrix读取数据
dtrain = xgb.DMatrix(Xtrain,Ytrain) #特征矩阵和标签都进行一个传入
dtest = xgb.DMatrix(Xtest,Ytest)
#%%
#非常遗憾无法打开来查看，所以通常都是先读到pandas里面查看之后再放到DMatrix中
dtrain
#%%
import pandas as pd
#%%
pd.DataFrame(Xtrain)
#%%
#忽略警告
#写明参数
param = {'silent':True #默认为False，通常要手动把它关闭掉,'objective':'reg:linear',"eta":0.1}
num_round = 180 #n_estimators
#%%
# -*- coding: utf-8 -*-
import warnings
def foo():warnings.warn("Deprecated", DeprecationWarning)
if __name__ == '__main__':foo()
# 方式一
import warnings
warnings.filterwarnings("ignore")
foo()
#类train，可以直接导入的参数是训练数据，树的数量，其他参数都需要通过params来导入
bst = xgb.train(param, dtrain, num_round)
#%%
#接口predict
preds = bst.predict(dtest)
#%%
preds
#%%
from sklearn.metrics import r2_score
r2_score(Ytest,preds)
#%%
MSE(Ytest,preds)
#%%
import xgboost as xgb#为了便捷，使用全数据
dfull = xgb.DMatrix(X,y)
#%%
#设定参数
param1 = {'silent':True,'obj':'reg:linear',"gamma":0}
num_round = 100
n_fold=5 #sklearn - KFold
#%%
#使用类xgb.cv
time0 = time()
cvresult1 = xgb.cv(param1, dfull, num_round,n_fold)
print(datetime.datetime.fromtimestamp(time()-time0).strftime("%M:%S:%f"))
#%%
#看看类xgb.cv生成了什么结果？
cvresult1 #随着树不断增加，我们的模型的效果如何变化
#%%
plt.figure(figsize=(20,5))
plt.grid()
plt.plot(range(1,101),cvresult1.iloc[:,0],c="red",label="train,gamma=0")
plt.plot(range(1,101),cvresult1.iloc[:,2],c="orange",label="test,gamma=0")
plt.legend()
plt.show()#从这个图中，我们可以看出什么？
#怎样从图中观察模型的泛化能力？
#从这个图的角度来说，模型的调参目标是什么？
#%%
#xgboost中回归模型的默认模型评估指标是什么？
#%%
param1 = {'silent':True,'obj':'reg:linear',"gamma":0,"eval_metric":"mae"}
cvresult1 = xgb.cv(param1, dfull, num_round,n_fold)plt.figure(figsize=(20,5))
plt.grid()
plt.plot(range(1,181),cvresult1.iloc[:,0],c="red",label="train,gamma=0")
plt.plot(range(1,181),cvresult1.iloc[:,2],c="orange",label="test,gamma=0")
plt.legend()
plt.show()
#%%
param1 = {'silent':True,'obj':'reg:linear',"gamma":0}
param2 = {'silent':True,'obj':'reg:linear',"gamma":20}
num_round = 180
n_fold=5time0 = time()
cvresult1 = xgb.cv(param1, dfull, num_round,n_fold)
print(datetime.datetime.fromtimestamp(time()-time0).strftime("%M:%S:%f"))
#%%
time0 = time()
cvresult2 = xgb.cv(param2, dfull, num_round,n_fold)
print(datetime.datetime.fromtimestamp(time()-time0).strftime("%M:%S:%f"))
#%%
plt.figure(figsize=(20,5))
plt.grid()
plt.plot(range(1,181),cvresult1.iloc[:,0],c="red",label="train,gamma=0")
plt.plot(range(1,181),cvresult1.iloc[:,2],c="orange",label="test,gamma=0")
plt.plot(range(1,181),cvresult2.iloc[:,0],c="green",label="train,gamma=20")
plt.plot(range(1,181),cvresult2.iloc[:,2],c="blue",label="test,gamma=20")
plt.legend()
plt.show()#从这里，你看出gamma是如何控制过拟合了吗？控制训练集上的训练 - 降低训练集上的表现
#%%
import xgboost as xgb
import matplotlib.pyplot as plt
from time import time
import datetime
#%%
from sklearn.datasets import load_breast_cancer
data2 = load_breast_cancer()x2 = data2.data
y2 = data2.targetdfull2 = xgb.DMatrix(x2,y2)param1 = {'silent':True,'obj':'binary:logistic',"gamma":0,"nfold":5,"eval_metrics":"error"}
param2 = {'silent':True,'obj':'binary:logistic',"gamma":1,"nfold":5}
num_round = 100
#%%
time0 = time()
cvresult1 = xgb.cv(param1, dfull2, num_round,metrics=("error"))
print(datetime.datetime.fromtimestamp(time()-time0).strftime("%M:%S:%f"))
#%%
time0 = time()
cvresult2 = xgb.cv(param2, dfull2, num_round,metrics=("error")) 
print(datetime.datetime.fromtimestamp(time()-time0).strftime("%M:%S:%f"))
#%%
plt.figure(figsize=(20,5))
plt.grid()
plt.plot(range(1,101),cvresult1.iloc[:,0],c="red",label="train,gamma=0")
plt.plot(range(1,101),cvresult1.iloc[:,2],c="orange",label="test,gamma=0")
plt.plot(range(1,101),cvresult2.iloc[:,0],c="green",label="train,gamma=1")
plt.plot(range(1,101),cvresult2.iloc[:,2],c="blue",label="test,gamma=1")
plt.legend()
plt.show()
#%%
dfull = xgb.DMatrix(X,y)param1 = {'silent':True,'obj':'reg:linear',"subsample":1,"max_depth":6,"eta":0.3,"gamma":0,"lambda":1,"alpha":0,"colsample_bytree":1,"colsample_bylevel":1,"colsample_bynode":1,"nfold":5}
num_round = 200
#%%
time0 = time()
cvresult1 = xgb.cv(param1, dfull, num_round)
print(datetime.datetime.fromtimestamp(time()-time0).strftime("%M:%S:%f"))fig,ax = plt.subplots(1,figsize=(15,8))
ax.set_ylim(top=5)
ax.grid()
ax.plot(range(1,201),cvresult1.iloc[:,0],c="red",label="train,original")
ax.plot(range(1,201),cvresult1.iloc[:,2],c="orange",label="test,original")
ax.legend(fontsize="xx-large")
plt.show()
#%%
param1 = {'silent':True,'obj':'reg:linear',"subsample":1,"max_depth":6,"eta":0.3,"gamma":0,"lambda":1,"alpha":0,"colsample_bytree":1,"colsample_bylevel":1,"colsample_bynode":1,"nfold":5}
num_round = 200time0 = time()
cvresult1 = xgb.cv(param1, dfull, num_round)
print(datetime.datetime.fromtimestamp(time()-time0).strftime("%M:%S:%f"))fig,ax = plt.subplots(1,figsize=(15,8))
ax.set_ylim(top=5)
ax.grid()
ax.plot(range(1,201),cvresult1.iloc[:,0],c="red",label="train,original")
ax.plot(range(1,201),cvresult1.iloc[:,2],c="orange",label="test,original")param2 = {'silent':True,'obj':'reg:linear',"max_depth":2,"eta":0.05,"gamma":0,"lambda":1,"alpha":0,"colsample_bytree":1,"colsample_bylevel":0.4,"colsample_bynode":1,"nfold":5}param3 = {'silent':True,'obj':'reg:linear',"subsample":1,"eta":0.05,"gamma":20,"lambda":3.5,"alpha":0.2,"max_depth":4,"colsample_bytree":0.4,"colsample_bylevel":0.6,"colsample_bynode":1,"nfold":5}time0 = time()
cvresult2 = xgb.cv(param2, dfull, num_round)
print(datetime.datetime.fromtimestamp(time()-time0).strftime("%M:%S:%f"))time0 = time()
cvresult3 = xgb.cv(param3, dfull, num_round)
print(datetime.datetime.fromtimestamp(time()-time0).strftime("%M:%S:%f"))ax.plot(range(1,201),cvresult2.iloc[:,0],c="green",label="train,last")
ax.plot(range(1,201),cvresult2.iloc[:,2],c="blue",label="test,last")
ax.plot(range(1,201),cvresult3.iloc[:,0],c="gray",label="train,this")
ax.plot(range(1,201),cvresult3.iloc[:,2],c="pink",label="test,this")
ax.legend(fontsize="xx-large")
plt.show()
#%%
import pickle
#%%
dtrain = xgb.DMatrix(Xtrain,Ytrain)#设定参数，对模型进行训练
param = {'silent':True,'obj':'reg:linear',"subsample":1,"eta":0.05,"gamma":20,"lambda":3.5,"alpha":0.2,"max_depth":4,"colsample_bytree":0.4,"colsample_bylevel":0.6,"colsample_bynode":1}
num_round = 180bst = xgb.train(param, dtrain, num_round)
#%%
#保存模型
pickle.dump(bst, open("xgboostonboston.dat","wb"))#注意，open中我们往往使用w或者r作为读取的模式，但其实w与r只能用于文本文件 - txt
#当我们希望导入的不是文本文件，而是模型本身的时候，我们使用"wb"和"rb"作为读取的模式
#其中wb表示以二进制写入，rb表示以二进制读入，使用open进行保存的这个文件中是一个可以进行读取或者调用的模型
#%%
#看看模型被保存到了哪里？
import sys
sys.path
#%%
#重新打开jupyter lab
from sklearn.model_selection import train_test_split as TTS
from sklearn.metrics import mean_squared_error as MSE
import pickle
import xgboost as xgb
data_url = "http://lib.stat.cmu.edu/datasets/boston"
raw_df = pd.read_csv(data_url, sep="\s+", skiprows=22, header=None)
data = np.hstack([raw_df.values[::2, :], raw_df.values[1::2, :2]])
target = raw_df.values[1::2, 2]
X = data
y = target
Xtrain,Xtest,Ytrain,Ytest = TTS(X,y,test_size=0.3,random_state=420)
#%%
#注意，如果我们保存的模型是xgboost库中建立的模型，则导入的数据类型也必须是xgboost库中的数据类型
dtest = xgb.DMatrix(Xtest,Ytest)
#%%
#导入模型
loaded_model = pickle.load(open("xgboostonboston.dat", "rb"))
print("Loaded model from: xgboostonboston.dat")
#%%
#做预测，直接调用接口predictypreds = loaded_model.predict(dtest)
#%%
ypreds
#%%
from sklearn.metrics import mean_squared_error as MSE, r2_score
MSE(Ytest,ypreds)
#%%
r2_score(Ytest,ypreds)
#%%
bst = xgb.train(param, dtrain, num_round)
#%%
import joblib#同样可以看看模型被保存到了哪里
joblib.dump(bst,"xgboost-boston.dat")
#%%
loaded_model = joblib.load("xgboost-boston.dat")
#%%
dtest = xgb.DMatrix(Xtest,Ytest)
ypreds = loaded_model.predict(dtest)
#%%
ypreds
#%%
MSE(Ytest, ypreds)
#%%
r2_score(Ytest,ypreds)
#%%
#使用sklearn中的模型
from xgboost import XGBRegressor as XGBRbst = XGBR(n_estimators=200,eta=0.05,gamma=20,reg_lambda=3.5,reg_alpha=0.2,max_depth=4,colsample_bytree=0.4,colsample_bylevel=0.6).fit(Xtrain,Ytrain) #训练完毕
#%%
joblib.dump(bst,"xgboost-boston-sklearn.dat")
#%%
loaded_model = joblib.load("xgboost-boston-sklearn.dat")
#%%
#则这里可以直接导入Xtest,直接是我们的numpy
ypreds = loaded_model.predict(Xtest)
#%%
Xtest
#%%
dtest
#%%
ypreds
#%%
MSE(Ytest, ypreds)
#%%
r2_score(Ytest,ypreds)
#%%
import numpy as np
import xgboost as xgb
import matplotlib.pyplot as plt
from xgboost import XGBClassifier as XGBC
from sklearn.datasets import make_blobs #自创数据集
from sklearn.model_selection import train_test_split as TTS
from sklearn.metrics import confusion_matrix as cm, recall_score as recall, roc_auc_score as auc
#%%
class_1 = 500 #类别1有500个样本
class_2 = 50 #类别2只有50个
centers = [[0.0, 0.0], [2.0, 2.0]] #设定两个类别的中心
clusters_std = [1.5, 0.5] #设定两个类别的方差，通常来说，样本量比较大的类别会更加松散
X, y = make_blobs(n_samples=[class_1, class_2],centers=centers,cluster_std=clusters_std,random_state=0, shuffle=False)
#%%
X.shape
#%%
y
#%%
(y == 1).sum() / y.shape[0] #9%
#%%
Xtrain, Xtest, Ytrain, Ytest = TTS(X,y,test_size=0.3,random_state=420)
#%%
#在sklearn下建模#clf = XGBC().fit(Xtrain,Ytrain)
ypred = clf.predict(Xtest)
#%%
ypred
#%%
clf.score(Xtest,Ytest) #默认模型评估指标 - 准确率
#%%
cm(Ytest,ypred,labels=[1,0]) #少数类写在前面
#%%
recall(Ytest,ypred)
#%%
auc(Ytest,clf.predict_proba(Xtest)[:,1])
#%%
#负/正样本比例
clf_ = XGBC(scale_pos_weight=10).fit(Xtrain,Ytrain)
ypred_ = clf_.predict(Xtest)
clf_.score(Xtest,Ytest)cm(Ytest,ypred_,labels=[1,0])recall(Ytest,ypred_)auc(Ytest,clf_.predict_proba(Xtest)[:,1])
#%%
#随着样本权重逐渐增加，模型的recall,auc和准确率如何变化？
for i in [1,5,10,20,30]:clf_ = XGBC(scale_pos_weight=i).fit(Xtrain,Ytrain)ypred_ = clf_.predict(Xtest)print(i)print("\tAccuracy:{}".format(clf_.score(Xtest,Ytest)))print("\tRecall:{}".format(recall(Ytest,ypred_)))print("\tAUC:{}".format(auc(Ytest,clf_.predict_proba(Xtest)[:,1])))
#%%
#负/正样本比例
clf_ = XGBC(scale_pos_weight=20).fit(Xtrain,Ytrain)
ypred_ = clf_.predict(Xtest)
clf_.score(Xtest,Ytest)
#%%
cm(Ytest,ypred_,labels=[1,0])
#%%
recall(Ytest,ypred_)
#%%
auc(Ytest,clf_.predict_proba(Xtest)[:,1])
#%%
dtrain = xgb.DMatrix(Xtrain,Ytrain)
dtest = xgb.DMatrix(Xtest,Ytest)
#%%
#看看xgboost库自带的predict接口
param = {'silent':True,'objective':'binary:logistic',"eta":0.1,"scale_pos_weight":1}
num_round = 100
#%%
bst = xgb.train(param, dtrain, num_round)
#%%
preds = bst.predict(dtest)
#%%
#看看preds返回了什么？
preds
#%%
#自己设定阈值
ypred = preds.copy()
#%%
ypred[preds > 0.5] = 1
#%%
ypred
#%%
ypred[ypred != 1] = 0
#%%
#写明参数
scale_pos_weight = [1,5,10]
names = ["negative vs positive: 1","negative vs positive: 5","negative vs positive: 10"]
#%%
[*zip(names,scale_pos_weight)]
#%%
#导入模型评估指标
from sklearn.metrics import accuracy_score as accuracy, recall_score as recall, roc_auc_score as aucfor name,i in zip(names,scale_pos_weight):param = {'silent':True,'objective':'binary:logistic',"eta":0.1,"scale_pos_weight":i}num_round = 100clf = xgb.train(param, dtrain, num_round)preds = clf.predict(dtest)ypred = preds.copy()ypred[preds > 0.5] = 1ypred[ypred != 1] = 0print(name)print("\tAccuracy:{}".format(accuracy(Ytest,ypred)))print("\tRecall:{}".format(recall(Ytest,ypred)))print("\tAUC:{}".format(auc(Ytest,preds)))
#%%
#当然我们也可以尝试不同的阈值
for name,i in zip(names,scale_pos_weight):for thres in [0.3,0.5,0.7,0.9]:param= {'silent':True,'objective':'binary:logistic',"eta":0.1,"scale_pos_weight":i}clf = xgb.train(param, dtrain, num_round)preds = clf.predict(dtest)ypred = preds.copy()ypred[preds > thres] = 1ypred[ypred != 1] = 0print("{},thresholds:{}".format(name,thres))print("\tAccuracy:{}".format(accuracy(Ytest,ypred)))print("\tRecall:{}".format(recall(Ytest,ypred)))print("\tAUC:{}".format(auc(Ytest,preds)))

八、部分图像 

 

 

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/bicheng/48816.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

【Linux网络】套接字编程

【Linux网络】套接字编程

本篇博客整理了 socket 套接字编程的相关内容，包括 socket 网络通信原理、socket 相关的系统调用接口等，分别演示了基于UDP协议、TCP协议的 socket 网络编程，旨在让读者更加深入理解网络通信原理和设计，对网络编程有初步的认识和掌…
阅读更多...
OpenAI发布“最具性价比”模型 GPT-4o mini，GPT-3.5 Turbo 已成过去式

OpenAI发布“最具性价比”模型 GPT-4o mini，GPT-3.5 Turbo 已成过去式

GPT-4o mini 相较于 GPT 3.5 在多个方面实现了显著的性能提升： 得分率提升：GPT-4o mini 在 MMLU（一个涉及多种语言理解任务的基准测试）上的得分率为 82%，优于 GPT-4，并且明显高于 GPT-3.5 2。 成本效益&am…
阅读更多...
SpringBoot3 + Vue3 学习 Day 1

SpringBoot3 + Vue3 学习 Day 1

springboot 基础 和 注册接口的开发 学习视频基础SpringBoot 概述快速启动配置文件基本使用① application.properties② application.yml （更好） yml 配置信息的书写和获取yml 配置信息书写与获取 1 - Valueyml 配置信息书写与获取 2 - ConfigurationPr…
阅读更多...
docker的学习（二）：docker常用的高级技术总结

docker的学习（二）：docker常用的高级技术总结

简介 docker的一些知识点的总结 UnionFS 分层，轻量级，高性能的文件系统，支持一层层的叠加功能来修改文件系统。 一次同时加载多个文件系统，把各层文件系统叠加起来，最终文件系统会包含所有底层的文件和目录&#xf…
阅读更多...
大数据-38 Redis 高并发下的分布式缓存 Redis简介 缓存场景 读写模式 旁路模式 穿透模式 缓存模式 基本概念等

大数据-38 Redis 高并发下的分布式缓存 Redis简介 缓存场景 读写模式 旁路模式 穿透模式 缓存模式 基本概念等

点一下关注吧！！！非常感谢！！持续更新！！！ 目前已经更新到了： HadoopHDFSMapReduceHiveFlumeSqoopZookeeperHBaseRedis 章节内容 上一节我们完成了： HBase …
阅读更多...
独立看门狗IWDG

独立看门狗IWDG

一，独立看门狗的讲述 独立看门狗（Independent Watchdog，通常缩写为IWDG）主要作用是主要用于检测外界电磁干扰，或硬件异常导致的程序跑飞问题。 1.1 IWDG本质上是一个12位的递减计数器。当计数器的值从某个初始…
阅读更多...
C语言编译报错：error: expected declaration or statement at end of input（缺了括号）

C语言编译报错：error: expected declaration or statement at end of input（缺了括号）

文章目录 报错信息分析解决步骤： 排查 报错信息 /userdata/testOtherPrj/20240715_box_circuit_breaker/test/external/modbus_vendorA/src/vendor_a_modbus.c: In function ‘VendorA_PowerStop’: /userdata/testOtherPrj/20240715_box_circuit_breaker/test/exte…
阅读更多...
PyQT6---环境搭建

PyQT6---环境搭建

1、虚拟环境搭建 创建虚拟环境 create -n pyqt6_39 python3.9 切换虚拟环境 conda activate pyqt6_39 2、安装pyqt6 安装pyqt6和pyqt6-tools pip install PyQt6 -i https://pypi.tuna.tsinghua.edu.cn/simplepip install pyqt6-tools -i https://pypi.tuna.tsinghua.edu.cn/…
阅读更多...
【视语】XR轻量级开发视语(DZRT)技术

【视语】XR轻量级开发视语(DZRT)技术

视语（DZRT）技术介绍目录 视语（DZRT）介绍 智慧变焦技术 射线追踪技术 一、基本原理 二、实现步骤 三、优化技术 智能框架技术 一、智能框架技术概述 二、智能框架技术的特点 三、应用前景 网格碰撞体优化 1. 使用合适的…
阅读更多...
如何采集1688店铺联系方式？

如何采集1688店铺联系方式？

如何获取1688采集店铺联系方式？用大镜山阿里1688商家数据采集软件，打开如下图的窗口，输入采集的关键词，再点“开始采集”和“获取手机”即可。 等待采集完成即可！ 点”导出“，即可把采集结果导出。 如果需…
阅读更多...
策划人如何写一个好的活动策划？

策划人如何写一个好的活动策划？

在营销界摸爬滚打十多年，我深刻体会到，策划一场成功的活动就像是烹饪一道美味的大餐。 你需要精心挑选食材（活动元素）、掌握火候（时间控制）、调配佐料（创意和细节），最终…
阅读更多...
Vue3+.NET6前后端分离式管理后台实战(三十)

Vue3+.NET6前后端分离式管理后台实战(三十)

1，Vue3.NET6前后端分离式管理后台实战(三十)
阅读更多...
2024年软考复习策略

2024年软考复习策略

针对考试的难点，我们应该如何有效应对？面对这种通过率低、知识覆盖广的考试，选择合适的复习策略和优秀的老师至关重要。 以下是一些建议： 首先，在选择教师方面，推荐选择那些实战经验丰富、能精准把握重点…
阅读更多...
NVidia 的 gpu 开源 Linux Kernel Module Driver 编译 安装 使用

NVidia 的 gpu 开源 Linux Kernel Module Driver 编译 安装 使用

见面礼，动态查看gpu使用情况，每隔2秒钟自动执行一次 nvidia-smi $ watch -n 2 nvidia-smi 1，找一台nv kmd列表中支持的 GPU 的电脑，安装ubuntu22.04 列表见 github of the kmd source code。 因为 cuda sdk 12.3支持最高到 ubu…
阅读更多...
双向链表＜数据结构 C版＞

双向链表＜数据结构 C版＞

目录 关于链表的分类 双向链表结构体 初始化 尾插 头插 打印 判断是否为空 尾删 头删 查找 指定位置之后的插入 指定位置的删除 销毁 关于链表的分类 根据链表的三大特性，单向or双向、带头or不带头、循环or不循环，可将链表分为2*2*2&#xf…
阅读更多...
《昇思25天学习打卡营第23天|RNN实现情感分类》

《昇思25天学习打卡营第23天|RNN实现情感分类》

使用RNN进行情感分类：基于IMDB数据集的LSTM应用 引言 情感分析是自然语言处理（NLP）中的一个重要应用，广泛用于电影评论、社交媒体等文本数据的情感分类任务。本文将介绍如何使用递归神经网络（RNN）实现情感…
阅读更多...
人工智能与社交变革：探索Facebook如何领导智能化社交平台

人工智能与社交变革：探索Facebook如何领导智能化社交平台

在过去十年中，人工智能（AI）技术迅猛发展，彻底改变了我们与数字世界互动的方式。Facebook作为全球最大的社交媒体平台之一，充分利用AI技术，不断推动社交平台的智能化，提升用户体验。本文将深入探…
阅读更多...
昇思25天学习打卡营第02天|张量Tensor

昇思25天学习打卡营第02天|张量Tensor

这节学习的张量（Tensor）的内容进行总结 ： 1、张量的概念：张量是一种多线性函数，可以表示矢量、标量和其他张量之间的线性关系。张量是MindSpore网络运算中的基本数据结构，类似于数组和矩阵。 2、可以通过直…
阅读更多...
基于SpringBoot+Vue的校园疫情防控系统(带1w+文档)

基于SpringBoot+Vue的校园疫情防控系统(带1w+文档)

基于SpringBootVue的校园疫情防控系统(带1w文档) 基于SpringBootVue的校园疫情防控系统(带1w文档) 主要对首页、个人中心、学生管理、疫情动态管理、知识信息管理、防疫教育管理、健康打卡管理、请假申请管理、出校登记管理、入校登记管理、核酸报告管理、交流论坛、系统管理的…
阅读更多...
PHP 高性能框架 Workerman 凭什么能硬刚 Swoole ？

PHP 高性能框架 Workerman 凭什么能硬刚 Swoole ？

大家好，我是码农先森。 一次偶然看到了国外某机构针对 PHP 周边生态框架及扩展的性能测试排行榜，看到 Workerman 竟遥遥领先 Swoole。在我们 PHP 程序员现有的认知里，Swoole 作为一个基于 C/C 语言编写的扩展程序，性能居然落后了…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023