时间序列的异常检测与预测方法总结_时序预测数据异常怎么处理

前言

最近做了一个时序数据的异常检测和预测项目，总结了几种常见的方法，针对的数据类型主要有两种，有周期特征和无周期特征的两种数据。对于没有周期特征的数据，可以直接使用基于统计学的3sigma方法，针对有周期特征的数据可以使用SARIMA、Prophet、XGBoost方法。下面针对每种方法进行逐个讲解，讲述一下如何运用以及效果展示。

一、基于统计学的3sigma方法

3 Sigma方法，又称为3倍标准差法，是一种基于统计学的质量控制方法。它是在正态分布假设下，通过统计数据的变异程度来判断数据是否合格的一种方法。在3 Sigma方法中，以平均值为中心，向两侧范围扩展3个标准差的距离，形成了一个带状区间。如果样本数据点落在这个带状区间内，就认为数据正常；如果落在带状区间外部，就认为数据异常。

下面是一个案例，用来检测时序数据的异常值：

import pandas as pd
import matplotlib.pyplot as plt

# 读取数据
df = pd.read_csv('data.csv', encoding='gb2312')  # 这里我的字段名是汉字，所以用了encoding='gb2312'
# 将日期转换为Pandas日期格式
df['时间'] = pd.to_datetime(df['时间'])
# 设置日期为索引
df.set_index('时间', inplace=True)
plt.figure(figsize=(10, 4), dpi=150)  # 设置画板的大小和分辨率
columns = ['字段1', '字段2', '字段3', '字段4', '字段5']
for column in columns:  # 对每个字段逐个进行异常值检测
    # 计算标准差和平均值
    std = df[column].std()
    mean = df[column].mean()
    # 定义异常数据的条件
    condition = (df[column] > mean + 3 * std) | (df[column] < mean - 3 * std)
    # 筛选出异常数据的行
    anomalies = df.loc[condition][column]
    # 绘制时序图
    plt.plot(df.index, df[column], label='Normal value')
    # 标记异常点
    plt.scatter(anomalies.index, anomalies, color='red', label='Outliers')
    # 添加标题和标签
    plt.title('Sequence Diagram of ' + column)
    plt.xlabel('Date')
    plt.ylabel('Value')
    # 图像保存
    plt.legend(loc='best')
    plt.savefig('results/' + column + '.png', bbox_inches='tight', pad_inches=0.1)
    plt.clf()  # 清空画板
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

异常检测效果如下：

可以看出，3sigma对于异常值检测效果还是不错的，但是如果有周期，比如上面这张图，那个大大的黑色的点按理来说也是异常值，但是3sigma是对整体数据设置一个阈值上下限，这就没办法检测出这个异常值了，所以下面看一下能处理具有周期特征的方法。

二、基于SARIMA的时序数据异常检测和预测

SARIMA是一种时间序列分析模型，也称为季节性自回归滑动平均模型（Seasonal Autoregressive Integrated Moving Average model）。它是ARIMA模型的扩展，用于处理具有明显季节性周期的时间序列数据，比如月度、季度、年度数据。
SARIMA模型分为三部分，包括：季节性差分、非季节性差分和ARMA模型。其中季节性差分和非季节性差分用于使时间序列数据平稳化，ARMA模型则用于描述时间序列数据的自相关和移动平均性质。
SARIMA模型的参数比较复杂，包括p、d、q和P、D、Q、s。其中，p、d、q表示非季节性差分的阶数、自回归项的阶数和移动平均项的阶数；P、D、Q表示季节性差分的阶数、自回归项的阶数和移动平均项的阶数；s表示季节周期的长度。
SARIMA模型可以用于时间序列数据的预测和异常检测，对于需要考虑季节性周期因素的数据分析具有很好的效果。

下面讲述一下利用SARIMA进行建模的过程，先给出代码，然后进行分析：

import pandas as pd
from statsmodels.tsa.seasonal import seasonal_decompose
from statsmodels.tsa.stattools import adfuller
import matplotlib.pyplot as plt
from statsmodels.stats.diagnostic import acorr_ljungbox
from statsmodels.tsa.statespace.sarimax import SARIMAX
import tqdm
import itertools
import statsmodels.tsa.stattools as ts
import numpy as np
import warnings

warnings.filterwarnings('ignore')

# 加载数据
df = pd.read_csv('data.csv', encoding='gb2312', index_col=['时间'], parse_dates=['时间'])
# 参数设置
plt.rcParams['font.sans-serif'] = ['Microsoft YaHei']  # 定义画图的时候使其正常显示中文字体黑体
plt.rcParams['axes.unicode_minus'] = False  # 用来正常显示表示负号

columns =['字段1', '字段2', '字段3', '字段4', '字段5']
for column in columns:
    data = df[column]  # 读取列数据并去掉空值
    # 画出时序图
    plt.figure(figsize=[15, 7], dpi=300)
    data.plot()
    plt.show()

    p_pingwen = adfuller(data)[1]  #  检验平稳性，p值小于0.05说明是平稳的
    p_baizaosheng = acorr_ljungbox(data, lags=1)['lb_pvalue'].values[0]  # #  检验是否为白噪声序列，p值小于0.05说明是非白噪声的

    # 对数据进行差分后得到 自相关图和 偏相关图
    diff = False  # 如果数据平稳的话就不需要进行差分了
    if diff:
        D_data = data.diff().dropna()
        D_data.columns = [column]
        D_data.plot()  # 画出差分后的时序图
        plt.show()
        p_pingwen = adfuller(D_data)[1]
        p_baizaosheng = acorr_ljungbox(D_data, lags=1)['lb_pvalue'].values[0]

    # 季节性分解
    decomposition = seasonal_decompose(data, period=24)  # 以一天为周期，以小时为粒度，所以周期是24
    trend = decomposition.trend
    seasonal = decomposition.seasonal
    residual = decomposition.resid

    plt.figure(figsize=[15, 7])
    decomposition.plot()
    print("test: p={}".format(ts.adfuller(seasonal)[1]))
    plt.show()

    # 对模型进行定阶
    def optimize_ARIMA(order_list, exog):
        results = []

        for order in tqdm.tqdm(order_list):
            try:
                model = SARIMAX(exog, order=order).fit(disp=-1)
            except:
                continue

            aic = model.aic
            results.append([order, aic])

        result_df = pd.DataFrame(results)
        result_df.columns = ['(p, d, q)', 'AIC']
        # Sort in ascending order, lower AIC is better
        result_df = result_df.sort_values(by='AIC', ascending=True).reset_index(drop=True)

        return result_df


    ps = range(0, 8, 1)  # 我们将尝试所有阶数 (p,q) 从 0 到 8 的组合，但保持差分阶数等于 1。
    qs = range(0, 8, 1)
    parameters = itertools.product(ps, qs)  # Create a list with all possible combination of parameters
    parameters_list = list(parameters)
    order_list = []
    for each in parameters_list:
        each = list(each)
        each.insert(1, 1)  # 元组中第二个1是指差分的阶数，一般都是1，差分太多了就会导致过差分
        each = tuple(each)
        order_list.append(each)

    result_df = optimize_ARIMA(order_list, exog=data)  # 得到的AIC最小的参数就是模型的最佳参数

    # 通过网格搜索对seasonal_order进行定阶
    def get_ARIMA_params(data, pdq, m=24):
        p = d = q = range(0, 2)
        seasonal_pdq = [(x[0], x[1], x[2], m) for x in list(itertools.product(p, d, q))]
        score_aic = 1000000.0
        warnings.filterwarnings("ignore")  # specify to ignore warning messages
        for param_seasonal in tqdm.tqdm(seasonal_pdq):
            mod = SARIMAX(data,
                          order=pdq,
                          seasonal_order=param_seasonal,
                          enforce_stationarity=False,
                          enforce_invertibility=False)
            results = mod.fit()
            print('x{}12 - AIC:{}'.format(param_seasonal, results.aic))
            if results.aic < score_aic:
                score_aic = results.aic
                params = param_seasonal, score_aic
        param_seasonal, aic = params
        print('x{}12 - AIC:{}'.format(param_seasonal, aic))
        return param_seasonal, aic
    order = result_df.iloc[0, :].values[0]  # 这个order是ARIMA模型的参数，也就是前面result_df确定的最佳参数
    result_seasonal, aic = get_ARIMA_params(data, order, m=24)

    # 模型拟合
    pred_num = 12
    best_model = SARIMAX(data[:-pred_num], order=result_df.iloc[0, :].values[0],  seasonal_order=result_seasonal).fit()  # 留出最后pred_num条数据不进行拟合，这是因为后面要对这pred_num条数据进行预测

    # 模型拟合效果检查
    print(best_model.summary().tables[1])
    best_model.plot_diagnostics(figsize=(15, 12))
    plt.show()

    # 对拟合值的阈值上下限和真实值作图，并计算RMSE值作为评估参数
    predict_ts = best_model.predict(tpy='levels', start=len(data) - 500, end=len(data)-pred_num)[1:]  # 由于数据太长，这里只拟合最后500条数据的时序图；留出pred_num条数据，这是因为我们后面要进行预测，
    myts = data[-500:-pred_num]
    predict_ts.index = myts.index
    predict_lower = best_model.get_prediction(tpy='levels', start=len(data)-500, end=len(data)-pred_num).conf_int()[1:]['lower ' + column]  # 这里得到拟合值的阈值下限
    predict_upper = best_model.get_prediction(tpy='levels', start=len(data)-500, end=len(data)-pred_num).conf_int()[1:]['upper ' + column]
    predict_lower.index = myts.index
    predict_upper.index = myts.index
    outliers = myts[(myts < predict_lower) | (myts > predict_upper)]  # 找出异常值
    outliers.plot(color='red', label='异常值', figsize=(12, 8), marker='o', linestyle='', linewidth=2)
    # predict_ts.plot(color='blue', label='拟合值', figsize=(12, 8), linestyle='-', linewidth=2)
    myts.plot(color='blue', label='真实值', figsize=(12, 8), linestyle='-', linewidth=2)
    predict_lower.plot(color='green', label='阈值下限', figsize=(12, 8), linestyle='--', linewidth=2)
    predict_upper.plot(color='green', label='阈值上限', figsize=(12, 8), linestyle='--', linewidth=2)
    plt.legend(loc='best')
    plt.title(column + '拟合原始数据平均误差为: %.4f' % np.sqrt(sum((predict_ts - myts) ** 2) / myts.size))
    plt.savefig('model_fitting_effect/' + column + '.png', bbox_inches='tight', pad_inches=0.1)  # 放在model_fitting_effect文件下
    plt.clf()

    # 向后做pred_num个步长的预测
    forecast_ts = best_model.forecast(pred_num)
    myts_fore = data[-pred_num:]
    forecast_lower = best_model.get_forecast(pred_num, alpha=0.05).conf_int()['lower '+column]
    forecast_upper = best_model.get_forecast(pred_num, alpha=0.05).conf_int()['upper '+column]
    forecast_ts.index, forecast_lower.index, forecast_upper.index = myts_fore.index, myts_fore.index, myts_fore.index  # 索引对齐
    outliers = myts_fore[(myts_fore < forecast_lower) | (myts_fore > forecast_upper)]
    outliers.plot(color='red', label='异常值', figsize=(12, 8), marker='o', linestyle='', linewidth=2)
    forecast_ts.plot(color='blue', label='预测值', figsize=(12, 8), linestyle='-', linewidth=2)
    myts_fore.plot(color='green', label='真实值', figsize=(12, 8), linestyle='-', linewidth=2)
    forecast_lower.plot(color='black', label='阈值下限', figsize=(12, 8), linestyle='--', linewidth=2)
    forecast_upper.plot(color='black', label='阈值上限', figsize=(12, 8), linestyle='--', linewidth=2)
    plt.legend(loc='best')
    plt.title(column + '预测' + str(pred_num) + '期数据平均误差为: %.4f' % np.sqrt(sum((forecast_ts - myts_fore) ** 2) / myts_fore.size))
    plt.savefig('model_forecast_effect/' + column + '.png', bbox_inches='tight', pad_inches=0.1)
    plt.clf()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

1. 画出时序图看一下序列的特征，有没有周期和趋势的特征，对序列有一个大致的了解。然后就要检验序列的平稳性和纯随机性，这里我直接使用单位根检验序列平稳性，用LB检验来判断序列是否为白噪声。这里没有用自相关图和偏自相关图，是因为这两个图看起来是有门槛的，并不适合所有人。如果不是平稳的需要进行差分，一般差分后就平稳了。如果序列通过了平稳性和纯随机性的检验，就可以继续分析了，如果没通过那就无法进行建模了。其实也好理解，如果一个序列完全没有规律，就是完全随机产生的，这是没办法建模的。
2. 然后进行季节性分解，这张图有四个子图，分别代表原始序列时序图、趋势图、周期特征图、残差图。通过周期特征图可以明显看出数据具有周期特征。
   
3. 前面的预分析阶段结束了，下面就是建模阶段了。首先需要对SARIMA模型非季节性差分的阶数的进行定阶，这里直接用网格搜索的方法，利用计算机计算速度快的特点，一个一个的试，直接找到模型拟合效果最好的参数。这里也没有选择根据自相关图和偏自相关图进行定阶，除了看图具有门槛，而且还具有一定的主观性。然后对季节性差分的阶数的进行定阶，同样通过网格搜索的方法进行定阶，这里可能速度比较慢，尤其是周期大的时候，速度更是慢的不行。
4. 参数定下来之后，接下来就是模型的拟合，这里没啥好说的，直接一键拟合。
5. 下面分析模型的拟合效果，下面第一张图是模型的参数检验，coef 列显示每个特征的权重（即重要性）以及每个特征如何影响时间序列。而P>|z|列是对每个特征重要性的检验，每个权重的 p 值都低于0.05，因此在我们的模型中保留所有权重是合理的。第二张图有四个子图，分别表示：模型的残差是不相关的且符合正态分布，而且近似白噪声序列，所以模型对序列的信息已经提取完了；红色的KDE线紧跟N（0,1）线，其中N（0,1）是均值0和标准偏差为1的正态分布的标准表示法。这很好地表明了残差是正态分布的；残差（蓝色点）的有序分布遵循从具有N（0，1）的标准正态分布获取的样本的线性趋势。同样，这也表明残差是正态分布的；该图表明时间序列残差与自身的滞后值具有较低的相关性。
   
   
6. 当我们训练好模型之后，并且模型拟合效果还不错，这时候我们就要进行时序预测了。这里我做了两种预测，一个是对历史数据的预测（图中用拟合值表示），一个是对未来数据的预测。在预测的同时得到一个置信区间，如果真实值不在这个区间内就为异常值，反之为正常值。下图分别是对历史数据的预测和对未来数据的预测效果图，为了展示效果，分别用了两个不同的字段，并预测未来48小时的数据。
   
   

三、基于Prophet的时序数据异常检测和预测

Prophet是Facebook开发的一种用于时间序列预测的开源库。它基于加法模型（additive model）和分解（decomposition）方法，可以对具有季节性、趋势性和节假日效应的时间序列数据进行准确的预测。Prophet库提供了简单而强大的API，使得时间序列的建模和预测变得非常方便。以下是安装Prophet库的一般步骤：

# 安装pystan
conda install pystan

# 安装prophet
sudo pip install fbprophet
1
2
3
4
5

老样子，先把代码贴出来，下面再详细讲解：

from fbprophet import Prophet
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

# 参数设置
plt.rcParams['font.sans-serif'] = ['Microsoft YaHei']  # 定义使其正常显示中文字体黑体
plt.rcParams['axes.unicode_minus'] = False  # 用来正常显示表示负号

datas = pd.read_csv('data.csv', encoding='gb2312')

columns = ['时间', '字段1', '字段2']
for idx, column in enumerate(columns):
    # 读取数据
    datadf = pd.DataFrame(columns=['ds', 'y'])  # 初始化一个列名为ds和y的dataframe变量，这是因为模型默认数据的列名都是ds和y
    data, datatime = datas[column], datas['时间']
    datadf['ds'], datadf['y'] = pd.to_datetime(datatime), data  # 读取数据

    # 初始化一个模型
    np.random.seed(1234)  ## 设置随机数种子
    pred_num = 48
    confidence_interval = 0.95
    model = Prophet(growth="linear", daily_seasonality=True,
                    weekly_seasonality=False,
                    seasonality_mode='multiplicative',
                    interval_width=confidence_interval,  # 获取95%的置信区间
                    )

    # 训练模型
    model = model.fit(datadf)  # 使用数据拟合模型  [:-pred_num]
    
    # 预测未来数据和预测历史数据，prophet一步完成对历史数据和未来数据的预测
    future = model.make_future_dataframe(periods=pred_num, freq='H')  # periods 表示需要预测的步数，freq 表示时间序列的频率。
    forecast = model.predict(future)  # 使用模型对数据进行预测,interval_width默认为0.8，即80%的置信区间
    forecast["y"] = datadf["y"].reset_index(drop=True)  

    # 根据模型预测值的置信区间"yhat_lower"和"yhat_upper"判断样本是否为异常值
    def outlier_detection(forecast):
        index = np.where((forecast["y"] <= forecast["yhat_lower"]) |
                         (forecast["y"] >= forecast["yhat_upper"]), True, False)
        return index

    outlier_index = outlier_detection(forecast)
    outlier_df = datadf[outlier_index]

    # 可视化异常值的结果
    fig, ax = plt.subplots()
    forecast[-pred_num:].plot(x="ds", y="yhat", style="b--", figsize=(18, 8), label="预测值", ax=ax, linewidth=2)  
    forecast[:-pred_num].plot(x="ds", y="yhat", style="b-", figsize=(18, 8), label="拟合值", ax=ax, linewidth=2)  
    ax.fill_between(forecast["ds"].values, forecast["yhat_lower"], forecast["yhat_upper"], color='green', alpha=.2, label=str(int(confidence_interval*100))+"%置信区间")  ## 可视化出置信区间,alpha=.2表示透明度为0.2
    forecast.plot(kind="scatter", x="ds", y="y", c="k", s=20, label="原始数据", ax=ax)  # 原始数据散点图表示
    outlier_df.plot(x="ds", y="y", style="ro", ax=ax, label="异常值")  ## 可视化出异常值的点，"ro"表示红色圆点，‘rs’表示红色方块
    plt.legend(loc='best')
    plt.grid()
    rmse = np.sqrt(sum(((forecast["y"][-pred_num:] - forecast["yhat"][-pred_num:]).dropna()) ** 2) / pred_num)
    plt.title(column + '_模型拟合效果图_异常值检测效果图_预测未来' + str(int(pred_num)) + '小时数据效果图_预测均方根误差为: %.4f' % rmse)
    plt.savefig('Prophet/Hour/model_effect/' + column + '.png', bbox_inches='tight', pad_inches=0.1, dpi=300)
    plt.clf()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

1. 在建模之前对数据做一个预分析，比如画出时序图看看，检验一下平稳性和纯随机性，心里有一定的了解，下面继续建模
2. prophet建模还是很方便的，直接调包，先初始化一个模型，这里解释一下常用的参数，
   growth：指定趋势函数的类型。默认为’linear’（线性），也可以设置为’logistic’（逻辑斯蒂）
   daily_seasonality：用于控制每日季节性的建模方式。它决定了是否考虑每天的季节性效应。当然，可以根据数据的季节性特征自行设定
   changepoints：变化点列表，用于检测时间序列中的趋势突变。可以手动指定一组时间点，也可以使用自动检测算法
   seasonality_mode：指定季节性模式的类型。默认为’additive’（加法模式），也可以设置为’multiplicative’（乘法模式）
   seasonality_prior_scale：控制季节性项的平滑程度。较大的值表示较强的季节性效应，较小的值表示较弱的季节性效应
   holidays：节假日效应列表。可以传递一个包含节假日日期和名称的DataFrame，以考虑节假日对模型的影响
   changepoint_prior_scale：控制变化点的灵活性。较大的值表示更灵活的模型，较小的值表示更严格的模型
   interval_width：预测区间的宽度，用于计算置信区间。默认为0.8，表示80%的置信区间
3. 然后就是训模型并进行预测，如果不想预测未来数据，可以将future = model.make_future_dataframe(periods=pred_num, freq=‘H’) 中的periods设置为0
4. 找出异常点，将结果进行可视化并保存，下面分别给出了分钟粒度和小时粒度的可视化结果，具体时间粒度根据自己的数据特征设置：
   
   
   为了少贴一些图，我将多个信息都展示在一张图上了，具体可以根据自己的需求来设置。

四、基于XGBoost的时序数据异常检测和预测

XGBoost（eXtreme Gradient Boosting）是一种基于梯度提升树的机器学习算法，它通过迭代训练多个决策树模型来逐步提升整体模型的性能。具有梯度提升的优势，XGBoost在处理分类和回归问题时表现出色，并且具备高效性、灵活性和可解释性等特点，被广泛应用于数据挖掘、预测建模和特征选择等领域。

下面贴出代码：

import xgboost as xgb
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

# 导入数据
df = pd.read_csv('data.csv', encoding='gb2312', index_col=['时间'], parse_dates=['时间'])

plt.rcParams['font.sans-serif'] = ['Microsoft YaHei']  # 定义使其正常显示中文字体黑体
plt.rcParams['axes.unicode_minus'] = False  # 用来正常显示表示负号

# 按时间顺序排序
df.sort_index(inplace=True)

# 将时间序列按时间窗口切割成多个样本
def create_dataset(dataset, look_back=1):
    dataX, dataY = [], []
    for i in range(len(dataset)-look_back-1):
        a = dataset[i:(i+look_back)]
        dataX.append(a)
        dataY.append(dataset[i + look_back])
    return np.array(dataX), np.array(dataY)
columns = ['时间', '字段1', '字段2']
for column in columns:
    # 数据预处理
    dataset = df[column]   # 如果有空值需要先进行填充或者删除
    train_size = int(len(dataset) * 0.7)  # 划分训练集和测试集
    test_size = len(dataset) - train_size
    train, test = dataset[0:train_size], dataset[train_size:len(dataset)]

    # 创建数据集
    look_back = 3
    trainX, trainY = create_dataset(train, look_back)
    testX, testY = create_dataset(test, look_back)

    # 定义模型
    model = xgb.XGBRegressor()

    # 拟合模型并预测
    model.fit(trainX, trainY)
    trainPredict = model.predict(trainX)  # 拟合值
    testPredict = model.predict(testX)  # 预测值

    # 将得到的数据存入dataframe中
    true_value = pd.DataFrame(columns=['x', 'y'])
    true_value_x = np.concatenate((train[look_back:-1].index, test[look_back:-1].index), axis=-1)
    true_value_y = np.concatenate((trainY, testY), axis=-1)
    true_value['x'] = true_value_x
    true_value['y'] = true_value_y
    fitting_value = pd.DataFrame(columns=['x', 'y'])
    fitting_value['x'] = train[look_back:-1].index
    fitting_value['y'] = trainPredict
    pred_value = pd.DataFrame(columns=['x', 'y'])
    pred_value['x'] = test[look_back:-1].index
    pred_value['y'] = testPredict
    a = pred_value['y']
    b = true_value['y'][-len(testX):]
    b.index = a.index
    c = np.sqrt(sum(((a - b).dropna()) ** 2) / len(testX))
    print(column + '  小时数据效果图_预测均方根误差为: %.4f' % c)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

上面就是利用XGBoost的建模过程了，只是输出了模型的评估效果，具体的效果展示与前面介绍的方法一模一样，把前面随便哪一个方法的代码搞懂，XGBoost效果展示也很容易实现了。
从最后输出的评估结果来看，XGBoost取得了最好的预测效果，不得不说，XGBoost是真的牛。

总结

以上就是全部内容了，如有问题，欢迎评论区一起交流。