Machine Learning Mastery 时间序列入门教程（七）

原文：Machine Learning Mastery

协议：CC BY-NC-SA 4.0

使用 Python 和预测区间理解时间序列预测的不确定性

原文： machinelearningmastery.com/time-series-forecast-uncertainty-using-confidence-intervals-python/

时间序列预测模型既可以做出预测，也可以为这些预测提供置信区间。

置信区间为真实观察提供了较高和较低的期望。这些对于评估预测的实际可能结果的范围以及更好地理解模型的技能非常有用

在本教程中，您将了解如何使用 Python 计算和解释时间序列预测的置信区间。

具体来说，您将学到：

• 如何使用 ARIMA 模型做出预测并收集预测诊断信息。
• 如何解释预测的置信区间并配置不同的间隔。
• 如何在最近观察的背景下绘制置信区间。

让我们潜入。

使用 Python 的置信区间来理解时间序列预测不确定性
照片由 Bernard Spragg 撰写。 NZ ，保留一些权利。

ARIMA 预测

statsmodels Python 库中的 ARIMA 实现可用于拟合 ARIMA 模型。

它返回一个 ARIMAResults 对象。该对象提供 forecast（）函数，该函数可用于对未来时间步骤做出预测，并默认在训练数据结束后的下一个时间步骤预测值。

假设我们只预测下一个时间步，那么 forecast（）方法返回三个值：

• 预测。以训练时间序列为单位的预测值。
• 标准错误。模型的标准误差。
• 置信区间。预测的 95％置信区间。

在本教程中，我们将更好地理解 ARIMA 预测提供的置信区间。

在我们深入研究之前，让我们首先看一下我们将用作本教程上下文的 Daily Female Births 数据集。

每日女性出生数据集

该数据集描述了 1959 年加利福尼亚州每日女性出生人数。

单位是计数，有 365 个观测值。数据集的来源归功于 Newton（1988）。

您可以从数据市场网站了解更多信息并下载数据集。

下载数据集并将其保存在当前工作目录中，文件名为“ daily-total-female-births.csv ”。

下面的示例加载并绘制数据集。

from pandas import Series
from matplotlib import pyplot
series = Series.from_csv('daily-total-female-births.csv', header=0)
series.plot()
pyplot.show()

运行该示例将加载数据集并将其绘制为线图。

每日女性出生数据集

预测置信区间

在本节中，我们将训练 ARIMA 模型，使用它做出预测，并检查置信区间。

首先，我们将训练数据集拆分为训练和测试数据集。几乎所有观测都将用于训练，我们将最后一次观测作为测试数据集，我们将对其做出预测。

训练 ARIMA（5,1,1）模型。这不是这个问题的最佳模型，只是一个很好的模型用于演示目的。

然后使用训练的模型通过调用forecast()函数做出预测。然后打印预测结果。

下面列出了完整的示例。

from pandas import Series
from statsmodels.tsa.arima_model import ARIMA
series = Series.from_csv('daily-total-female-births.csv', header=0)
X = series.values
X = X.astype('float32')
size = len(X) - 1
train, test = X[0:size], X[size:]
model = ARIMA(train, order=(5,1,1))
model_fit = model.fit(disp=False)
forecast, stderr, conf = model_fit.forecast()
print('Expected: %.3f' % test[0])
print('Forecast: %.3f' % forecast)
print('Standard Error: %.3f' % stderr)
print('95%% Confidence Interval: %.3f to %.3f' % (conf[0][0], conf[0][1]))

运行该示例将打印测试集中的预期值，后跟预测值的预测值，标准误差和置信区间。

Expected: 50.000
Forecast: 45.878
Standard Error: 6.996
95% Confidence Interval: 32.167 to 59.590

解释置信区间

forecast()函数允许指定置信区间。

forecast()函数的alpha参数指定置信度。它默认设置为 alpha = 0.05，这是 95％的置信区间。这是一个明智且广泛使用的置信区间。

α为 0.05 意味着 ARIMA 模型将估计预测周围的上限值和下限值，其中实际值不会在该范围内的可能性仅为 5％。

换句话说，95％置信区间表明真实观察很可能在该范围内。

在上面的例子中，预测值为 45.878。 95％置信区间表明真实观察结果很可能落在 32.167 和 59.590 之间的值范围内。

真实的观察结果是 50.0 并且在这个范围内。

我们可以通过几种方式收紧可能值的范围：

• 我们可以要求范围更窄但是增加实际观察的统计可能性超出范围。
• 我们可以开发出具有更强预测能力的模型，从而进行更准确的预测。

此外，置信区间也受到模型所做的假设的限制，例如由模型拟合的误差分布拟合具有零均值（例如白噪声）的高斯分布。

扩展上面的例子，我们可以用一些不同的常用置信区间报告我们的预测，即 80％，90％，95％和 99％。

下面列出了完整的示例。

from pandas import Series
from statsmodels.tsa.arima_model import ARIMA
series = Series.from_csv('daily-total-female-births.csv', header=0)
X = series.values
X = X.astype('float32')
size = len(X) - 1
train, test = X[0:size], X[size:]
model = ARIMA(train, order=(5,1,1))
model_fit = model.fit(disp=False)
intervals = [0.2, 0.1, 0.05, 0.01]
for a in intervals:
	forecast, stderr, conf = model_fit.forecast(alpha=a)
	print('%.1f%% Confidence Interval: %.3f between %.3f and %.3f' % ((1-a)*100, forecast, conf[0][0], conf[0][1]))

运行该示例将打印每个alpha值的预测和置信区间。

我们可以看到，我们每次都获得相同的预测值，并且随着我们对“更安全”间隔的需求增加而扩展的间隔。我们可以看到，在这种特定情况下，80％可以很好地捕获我们的实际值。

80.0% Confidence Interval: 45.878 between 36.913 and 54.844
90.0% Confidence Interval: 45.878 between 34.371 and 57.386
95.0% Confidence Interval: 45.878 between 32.167 and 59.590
99.0% Confidence Interval: 45.878 between 27.858 and 63.898

绘制置信区间

置信区间可以直接绘制。

ARIMAResults 对象提供 plot_predict（）函数，可用于做出预测并绘制显示最近观察结果，预测和置信区间的结果。

与forecast()函数一样，可以通过指定alpha参数来配置置信区间。默认值为 0.05（95％置信度），这是一个合理的默认值。

以下示例显示使用此函数绘制的相同预测。

from pandas import Series
from matplotlib import pyplot
from statsmodels.tsa.arima_model import ARIMA
series = Series.from_csv('daily-total-female-births.csv', header=0)
X = series.values
X = X.astype('float32')
size = len(X) - 1
train, test = X[0:size], X[size:]
model = ARIMA(train, order=(5,1,1))
model_fit = model.fit(disp=False)
model_fit.plot_predict(len(train)-10, len(train)+1)
pyplot.show()

如果预测间隔覆盖训练数据，plot_predict()将绘制观察到的y值。

在这种情况下，我们预测前 10 天和下一天。这对于查看从样本到样本时间索引（蓝色）的预测是有用的。这与过去 10 天（绿色）的实际观察结果一致。

最后，我们可以将置信区间视为围绕预测值的灰色圆锥。这对于获得下一时间步骤中的观察可能采用的可能值范围的空间感觉是有用的。

绘制置信区间

摘要

在本教程中，您了解了如何使用 Python 计算和解释时间序列预测的置信区间。

具体来说，你学到了：

• 如何在进行点预测时报告预测诊断统计量。
• 如何解释和配置时间序列预测的置信区间。
• 如何在最近观察的背景下绘制预测和置信区间。

您对预测置信区间或本教程有任何疑问吗？
在下面的评论中提出您的问题，我会尽力回答。

11 个 Python 中的经典时间序列预测方法（备忘单）

原文： machinelearningmastery.com/time-series-forecasting-methods-in-python-cheat-sheet/

机器学习方法可用于分类和预测时间序列问题。

在探索时间序列的机器学习方法之前，最好确保使用经典的线性时间序列预测方法。经典时间序列预测方法可能侧重于线性关系，然而，它们是复杂的并且在广泛的问题上表现良好，假设您的数据已经适当准备并且方法配置良好。

在这篇文章中，您将发现一套用于时间序列预测的经典方法，您可以在探索机器学习方法之前测试您的预测问题。

该帖子被构造为一个备忘单，为您提供有关每个方法的足够信息，以便开始使用工作代码示例以及在何处查看有关该方法的更多信息。

所有代码示例都在 Python 中并使用 Statsmodels 库。这个库的 API 对于初学者来说可能很棘手（相信我！），因此以一个工作代码示例作为起点将大大加快您的进度。

这是一个很大的帖子;你可能想要为它添加书签。

让我们开始吧。

11 Python 中的经典时间序列预测方法（备忘单）
Ron Reiring 的照片，保留一些权利。

概观

该备忘单演示了 11 种不同的经典时间序列预测方法;他们是：

1. 自回归（AR）
2. 移动平均线（MA）
3. 自回归移动平均线（ARMA）
4. 自回归综合移动平均线（ARIMA）
5. 季节性自回归整合移动平均线（SARIMA）
6. 具有外生回归量的季节性自回归整合移动平均线（SARIMAX）
7. 向量自回归（VAR）
8. 向量自回归移动平均值（VARMA）
9. 具有外源回归量的向量自回归移动平均值（VARMAX）
10. 简单指数平滑（SES）
11. 霍尔特·温特的指数平滑（HWES）

我错过了您最喜欢的古典时间序列预测方法吗？
请在下面的评论中告诉我。

每种方法都以一致的方式呈现。

这包括：

• 说明。对该技术的简短而精确的描述。
• Python 代码。一个简短的工作示例，用于拟合模型并在 Python 中做出预测。
• 更多信息。 API 和算法的参考。

每个代码示例都在一个简单的人为数据集上进行演示，该数据集可能适合或不适合该方法。用您的数据替换人为的数据集以测试方法。

请记住：每种方法都需要调整您的具体问题。在很多情况下，我已经有了如何在博客上配置甚至网格搜索参数的示例，请尝试搜索功能。

如果您发现此备忘单有用，请在下面的评论中告诉我。

自回归（AR）

自回归（AR）方法将序列中的下一步建模为先前时间步骤的观察的线性函数。

该模型的符号涉及指定模型 p 的顺序作为 AR 函数的参数，例如， AR（P）。例如，AR（1）是一阶自回归模型。

该方法适用于没有趋势和季节性成分的单变量时间序列。

Python 代码

# AR example
from statsmodels.tsa.ar_model import AR
from random import random
# contrived dataset
data = [x + random() for x in range(1, 100)]
# fit model
model = AR(data)
model_fit = model.fit()
# make prediction
yhat = model_fit.predict(len(data), len(data))
print(yhat)

更多信息

• statsmodels.tsa.ar_model.AR API
• statsmodels.tsa.ar_model.ARResults API
• 维基百科上的自回归模型

移动平均线（MA）

移动平均（MA）方法将序列中的下一步建模为来自先前时间步骤的平均过程的残余误差的线性函数。

移动平均模型与计算时间序列的移动平均值不同。

该模型的表示法涉及将模型 q 的顺序指定为 MA 函数的参数，例如， MA（Q）。例如，MA（1）是一阶移动平均模型。

该方法适用于没有趋势和季节性成分的单变量时间序列。

Python 代码

我们可以使用 ARMA 类创建 MA 模型并设置零阶 AR 模型。我们必须在 order 参数中指定 MA 模型的顺序。

# MA example
from statsmodels.tsa.arima_model import ARMA
from random import random
# contrived dataset
data = [x + random() for x in range(1, 100)]
# fit model
model = ARMA(data, order=(0, 1))
model_fit = model.fit(disp=False)
# make prediction
yhat = model_fit.predict(len(data), len(data))
print(yhat)

更多信息

• statsmodels.tsa.arima_model.ARMA API
• statsmodels.tsa.arima_model.ARMAResults API
• 维基百科上的移动平均模型

自回归移动平均线（ARMA）

自回归移动平均（ARMA）方法将序列中的下一步建模为先前时间步骤的观测和再造误差的线性函数。

它结合了自回归（AR）和移动平均（MA）模型。

该模型的表示法涉及将 AR（p）和 MA（q）模型的顺序指定为 ARMA 函数的参数，例如，ARMA 函数的参数。 ARMA（p，q）。 ARIMA 模型可用于开发 AR 或 MA 模型。

该方法适用于没有趋势和季节性成分的单变量时间序列。

Python 代码

# ARMA example
from statsmodels.tsa.arima_model import ARMA
from random import random
# contrived dataset
data = [random() for x in range(1, 100)]
# fit model
model = ARMA(data, order=(2, 1))
model_fit = model.fit(disp=False)
# make prediction
yhat = model_fit.predict(len(data), len(data))
print(yhat)

更多信息

• statsmodels.tsa.arima_model.ARMA API
• statsmodels.tsa.arima_model.ARMAResults API
• 维基百科上的自回归移动平均模型

自回归综合移动平均线（ARIMA）

自回归整合移动平均（ARIMA）方法将序列中的下一步建模为先前时间步长的差异观测值和残差误差的线性函数。

它结合了自回归（AR）和移动平均（MA）模型以及序列的差分预处理步骤，使序列静止，称为积分（I）。

该模型的表示法涉及将 AR（p），I（d）和 MA（q）模型的顺序指定为 ARIMA 函数的参数，例如 ARIMA 函数的参数。 ARIMA（p，d，q）。 ARIMA 模型也可用于开发 AR，MA 和 ARMA 模型。

该方法适用于具有趋势且没有季节性成分的单变量时间序列。

Python 代码

# ARIMA example
from statsmodels.tsa.arima_model import ARIMA
from random import random
# contrived dataset
data = [x + random() for x in range(1, 100)]
# fit model
model = ARIMA(data, order=(1, 1, 1))
model_fit = model.fit(disp=False)
# make prediction
yhat = model_fit.predict(len(data), len(data), typ='levels')
print(yhat)

更多信息

• statsmodels.tsa.arima_model.ARIMA API
• statsmodels.tsa.arima_model.ARIMAResults API
• 维基百科上的自回归综合移动平均线

季节性自回归整合移动平均线（SARIMA）

季节性自回归综合移动平均线（SARIMA）方法将序列中的下一步建模为差异观测值，误差，差异季节观测值和先前时间步长的季节误差的线性函数。

它结合了 ARIMA 模型，能够在季节性水平上执行相同的自回归，差分和移动平均建模。

该模型的表示法涉及指定 AR（p），I（d）和 MA（q）模型的顺序作为 ARIMA 函数和 AR（P），I（D），MA（Q）和 m 的参数。季节性参数，例如 SARIMA（p，d，q）（P，D，Q）m 其中“m”是每个季节（季节性时期）的时间步数。 SARIMA 模型可用于开发 AR，MA，ARMA 和 ARIMA 模型。

该方法适用于具有趋势和/或季节性分量的单变量时间序列。

Python 代码

# SARIMA example
from statsmodels.tsa.statespace.sarimax import SARIMAX
from random import random
# contrived dataset
data = [x + random() for x in range(1, 100)]
# fit model
model = SARIMAX(data, order=(1, 1, 1), seasonal_order=(1, 1, 1, 1))
model_fit = model.fit(disp=False)
# make prediction
yhat = model_fit.predict(len(data), len(data))
print(yhat)

更多信息

• statsmodels.tsa.statespace.sarimax.SARIMAX API
• statsmodels.tsa.statespace.sarimax.SARIMAXResults API
• 维基百科上的自回归综合移动平均线

具有外生回归量的季节性自回归整合移动平均线（SARIMAX）

具有外源回归量的季节性自回归整合移动平均值（SARIMAX）是 SARIMA 模型的扩展，其还包括外生变量的建模。

外生变量也称为协变量，可以被认为是并行输入序列，其在与原始序列相同的时间步骤中具有观察结果。初级系列可以称为内源性数据，以将其与外源序列进行对比。对于外源变量的观察结果直接在每个时间步骤包括在模型中，并且不以与主要内源序列相同的方式建模（例如作为 AR，MA 等过程）。

SARIMAX 方法还可用于使用外生变量对包含的模型进行建模，例如 ARX，MAX，ARMAX 和 ARIMAX。

该方法适用于具有趋势和/或季节性成分和外生变量的单变量时间序列。

Python 代码

# SARIMAX example
from statsmodels.tsa.statespace.sarimax import SARIMAX
from random import random
# contrived dataset
data1 = [x + random() for x in range(1, 100)]
data2 = [x + random() for x in range(101, 200)]
# fit model
model = SARIMAX(data1, exog=data2, order=(1, 1, 1), seasonal_order=(0, 0, 0, 0))
model_fit = model.fit(disp=False)
# make prediction
exog2 = [200 + random()]
yhat = model_fit.predict(len(data1), len(data1), exog=[exog2])
print(yhat)

更多信息

• statsmodels.tsa.statespace.sarimax.SARIMAX API
• statsmodels.tsa.statespace.sarimax.SARIMAXResults API
• 维基百科上的自回归综合移动平均线

向量自回归（VAR）

向量自回归（VAR）方法使用 AR 模型模拟每个时间序列中的下一步。 AR 是多个并行时间序列的推广，例如，多变量时间序列。

该模型的表示法涉及将 AR（p）模型的顺序指定为 VAR 函数的参数，例如， VAR（P）。

该方法适用于没有趋势和季节性成分的多变量时间序列。

Python 代码

# VAR example
from statsmodels.tsa.vector_ar.var_model import VAR
from random import random
# contrived dataset with dependency
data = list()
for i in range(100):
v1 = i + random()
v2 = v1 + random()
row = [v1, v2]
data.append(row)
# fit model
model = VAR(data)
model_fit = model.fit()
# make prediction
yhat = model_fit.forecast(model_fit.y, steps=1)
print(yhat)

更多信息

• statsmodels.tsa.vector_ar.var_model.VAR API
• statsmodels.tsa.vector_ar.var_model.VARResults API
• 维基百科上的向量自回归

向量自回归移动平均值（VARMA）

向量自回归移动平均（VARMA）方法使用 ARMA 模型对每个时间序列中的下一步进行建模。这是 ARMA 对多个并行时间序列的推广，例如多变量时间序列。

该模型的表示法涉及将 AR（p）和 MA（q）模型的顺序指定为 VARMA 函数的参数，例如， VARMA（p，q）。 VARMA 模型也可用于开发 VAR 或 VMA 模型。

该方法适用于没有趋势和季节性成分的多变量时间序列。

Python 代码

# VARMA example
from statsmodels.tsa.statespace.varmax import VARMAX
from random import random
# contrived dataset with dependency
data = list()
for i in range(100):
v1 = random()
v2 = v1 + random()
row = [v1, v2]
data.append(row)
# fit model
model = VARMAX(data, order=(1, 1))
model_fit = model.fit(disp=False)
# make prediction
yhat = model_fit.forecast()
print(yhat)

更多信息

• statsmodels.tsa.statespace.varmax.VARMAX API
• statsmodels.tsa.statespace.varmax.VARMAXResults
• 维基百科上的向量自回归

具有外源回归量的向量自回归移动平均值（VARMAX）

具有外源回归量的向量自回归移动平均值（VARMAX）是 VARMA 模型的扩展，其还包括外生变量的建模。它是 ARMAX 方法的多变量版本。

外生变量也称为协变量，可以被认为是并行输入序列，其在与原始序列相同的时间步骤中具有观察结果。初级系列被称为内源性数据，以将其与外源序列进行对比。对于外源变量的观察结果直接在每个时间步骤包括在模型中，并且不以与主要内源序列相同的方式建模（例如作为 AR，MA 等过程）。

VARMAX 方法还可用于使用外生变量（如 VARX 和 VMAX）对包含的模型进行建模。

该方法适用于没有趋势和季节性成分以及外生变量的多变量时间序列。

Python 代码

# VARMAX example
from statsmodels.tsa.statespace.varmax import VARMAX
from random import random
# contrived dataset with dependency
data = list()
for i in range(100):
v1 = random()
v2 = v1 + random()
row = [v1, v2]
data.append(row)
data_exog = [x + random() for x in range(100)]
# fit model
model = VARMAX(data, exog=data_exog, order=(1, 1))
model_fit = model.fit(disp=False)
# make prediction
data_exog2 = [[100]]
yhat = model_fit.forecast(exog=data_exog2)
print(yhat)

更多信息

• statsmodels.tsa.statespace.varmax.VARMAX API
• statsmodels.tsa.statespace.varmax.VARMAXResults
• 维基百科上的向量自回归

简单指数平滑（SES）

简单指数平滑（SES）方法将下一个时间步长建模为先前时间步长的观测值的指数加权线性函数。

该方法适用于没有趋势和季节性成分的单变量时间序列。

Python 代码

# SES example
from statsmodels.tsa.holtwinters import SimpleExpSmoothing
from random import random
# contrived dataset
data = [x + random() for x in range(1, 100)]
# fit model
model = SimpleExpSmoothing(data)
model_fit = model.fit()
# make prediction
yhat = model_fit.predict(len(data), len(data))
print(yhat)

更多信息

• statsmodels.tsa.holtwinters.SimpleExpSmoothing API
• statsmodels.tsa.holtwinters.HoltWintersResults API
• 维基百科上的指数平滑

霍尔特·温特的指数平滑（HWES）

Holt Winter 的指数平滑（HWES）也称为三次指数平滑方法，将下一个时间步长建模为先前时间步长的观测值的指数加权线性函数，并考虑趋势和季节性。

该方法适用于具有趋势和/或季节性分量的单变量时间序列。

Python 代码

# HWES example
from statsmodels.tsa.holtwinters import ExponentialSmoothing
from random import random
# contrived dataset
data = [x + random() for x in range(1, 100)]
# fit model
model = ExponentialSmoothing(data)
model_fit = model.fit()
# make prediction
yhat = model_fit.predict(len(data), len(data))
print(yhat)

更多信息

• statsmodels.tsa.holtwinters.ExponentialSmoothing API
• statsmodels.tsa.holtwinters.HoltWintersResults API
• 维基百科上的指数平滑

进一步阅读

如果您希望深入了解，本节将提供有关该主题的更多资源。

• Statsmodels：时间序列分析 API
• Statsmodels：状态空间方法的时间序列分析

摘要

在这篇文章中，您发现了一套经典的时间序列预测方法，您可以测试和调整时间序列数据集。

我错过了您最喜欢的古典时间序列预测方法吗？
请在下面的评论中告诉我。

您是否在数据集上尝试了这些方法？
请在评论中告诉我你的发现。

你有任何问题吗？
在下面的评论中提出您的问题，我会尽力回答。

将 Python 用于时间序列预测表现测量

原文： machinelearningmastery.com/time-series-forecasting-performance-measures-with-python/

时间序列预测表现度量提供了做出预测的预测模型的技能和能力的总结。

有许多不同的绩效指标可供选择。知道使用哪种措施以及如何解释结果可能会令人困惑。

在本教程中，您将发现使用 Python 评估时间序列预测的表现度量。

时间序列通常关注实际值的预测，称为回归问题。因此，本教程中的表现度量将侧重于评估实值预测的方法。

完成本教程后，您将了解：

• 预测绩效的基本衡量指标，包括残差预测误差和预测偏差。
• 时间序列预测误差计算与预期结果具有相同的单位，例如平均绝对误差。
• 广泛使用的错误计算可以惩罚大的错误，例如均方误差和均方根误差。

让我们开始吧。

时间序列预测表现测量与 Python
照片由汤姆霍尔，保留一些权利。

预测误差（或残差预测误差）

预测误差被计算为期望值减去预测值。

这称为预测的残差。

forecast_error = expected_value - predicted_value

可以为每个预测计算预测误差，提供预测误差的时间序列。

下面的示例演示了如何计算一系列 5 个预测与 5 个预期值相比的预测误差。这个例子是出于演示目的而设计的。

expected = [0.0, 0.5, 0.0, 0.5, 0.0]
predictions = [0.2, 0.4, 0.1, 0.6, 0.2]
forecast_errors = [expected[i]-predictions[i] for i in range(len(expected))]
print('Forecast Errors: %s' % forecast_errors)

运行该示例计算 5 个预测中每个预测的预测误差。然后打印预测错误列表。

Forecast Errors: [-0.2, 0.09999999999999998, -0.1, -0.09999999999999998, -0.2]

预测误差的单位与预测的单位相同。预测误差为零表示没有错误或该预测的完美技能。

平均预测误差（或预测偏差）

平均预测误差计算为预测误差值的平均值。

mean_forecast_error = mean(forecast_error)

预测错误可能是积极的和消极的。这意味着当计算这些值的平均值时，理想的平均预测误差将为零。

除零以外的平均预测误差值表明模型倾向于过度预测（正误差）或低于预测（负误差）。因此，平均预测误差也称为预测偏差。

预测误差可以直接计算为预测值的平均值。下面的示例演示了如何手动计算预测误差的平均值。

expected = [0.0, 0.5, 0.0, 0.5, 0.0]
predictions = [0.2, 0.4, 0.1, 0.6, 0.2]
forecast_errors = [expected[i]-predictions[i] for i in range(len(expected))]
bias = sum(forecast_errors) * 1.0/len(expected)
print('Bias: %f' % bias)

运行该示例将打印平均预测误差，也称为预测偏差。

Bias: -0.100000

预测偏差的单位与预测的单位相同。零预测偏差或接近零的非常小的数字表示无偏模型。

平均绝对误差

平均绝对误差或 MAE 计算为预测误差值的平均值，其中所有预测值都被强制为正值。

强制值为正值称为绝对值。这由绝对函数abs()表示，或者在数学上显示为值周围的两个管道字符： | value | 。

mean_absolute_error = mean( abs(forecast_error) )

其中abs()使值为正，forecast_error是一个或一系列预测误差，mean()计算平均值。

我们可以使用 scikit-learn 库中的 mean_absolute_error（）函数来计算预测列表的平均绝对误差。以下示例演示了此功能。

from sklearn.metrics import mean_absolute_error
expected = [0.0, 0.5, 0.0, 0.5, 0.0]
predictions = [0.2, 0.4, 0.1, 0.6, 0.2]
mae = mean_absolute_error(expected, predictions)
print('MAE: %f' % mae)

运行该示例计算并打印 5 个预期值和预测值的列表的平均绝对误差。

MAE: 0.140000

这些误差值以预测值的原始单位表示。平均绝对误差为零表示没有错误。

均方误差

均方误差或 MSE 计算为平方预测误差值的平均值。平方预测误差值迫使它们为正;它还具有加重大错误的效果。

非常大或异常的预测误差是平方的，这反过来又具有拖动平方预测误差的平均值的效果，导致更大的均方误差分数。实际上，得分会给那些做出大错误预测的模型带来更差的表现。

mean_squared_error = mean(forecast_error²)

我们可以使用 scikit-learn 中的 mean_squared_error（）函数来计算预测列表的均方误差。以下示例演示了此功能。

from sklearn.metrics import mean_squared_error
expected = [0.0, 0.5, 0.0, 0.5, 0.0]
predictions = [0.2, 0.4, 0.1, 0.6, 0.2]
mse = mean_squared_error(expected, predictions)
print('MSE: %f' % mse)

运行该示例计算并打印预期值和预测值列表的均方误差。

MSE: 0.022000

误差值以预测值的平方单位表示。均方误差为零表示技能完美，或没有错误。

均方根误差

上述均方误差是预测的平方单位。

通过取平均误差分数的平方根，可以将其转换回预测的原始单位。这称为均方根误差或 RMSE。

rmse = sqrt(mean_squared_error)

这可以通过使用sqrt()数学函数计算平均误差，使用mean_squared_error()scikit-learn 函数计算得出。

from sklearn.metrics import mean_squared_error
from math import sqrt
expected = [0.0, 0.5, 0.0, 0.5, 0.0]
predictions = [0.2, 0.4, 0.1, 0.6, 0.2]
mse = mean_squared_error(expected, predictions)
rmse = sqrt(mse)
print('RMSE: %f' % rmse)

运行该示例计算均方根误差。

RMSE: 0.148324

RMES 错误值与预测的单位相同。与均方误差一样，RMSE 为零表示没有错误。

进一步阅读

以下是有关进一步阅读时间序列预测误差测量的一些参考资料。

• 第 3.3 节测量预测准确度，实际时间序列预测与 R：动手指南。
• 第 2.5 节评估预测准确度，预测：原则和实践
• scikit-learn Metrics API
• 第 3.3.4 节。 回归指标，scikit-learn API 指南

摘要

在本教程中，您在 Python 中发现了一套 5 个标准时间序列表现度量。

具体来说，你学到了：

• 如何计算预测残差以及如何估计预测列表中的偏差。
• 如何计算平均绝对预测误差，以与预测相同的单位描述误差。
• 如何计算预测的广泛使用的均方误差和均方根误差。

您对时间序列预测表现指标或本教程有任何疑问
请在下面的评论中提出您的问题，我会尽力回答。

Python 中的时间序列预测的 7 天迷你课程

原文： machinelearningmastery.com/time-series-forecasting-python-mini-course/

从开发人员到 7 天的时间序列预测。

Python 是应用机器学习增长最快的平台之一。

在这个迷你课程中，您将了解如何入门，构建准确的模型，并在 7 天内使用 Python 自信地完成预测性建模时间序列预测项目。

这是一个重要且重要的帖子。您可能想要将其加入书签。

让我们开始吧。

使用 Python 7 天迷你课程进行时间序列预测
摄影： Raquel M ，保留一些权利。

这个迷你课程是谁？

在我们开始之前，让我们确保您在正确的位置。

以下列表提供了有关本课程设计对象的一般指导原则。

如果你没有完全匹配这些点，请不要惊慌，你可能只需要在一个或另一个区域刷新以跟上。

• 你是开发人员：这是开发人员的课程。你是某种开发者。您知道如何读写代码。您知道如何开发和调试程序。
• 你知道 Python ：这是 Python 人的课程。你知道 Python 编程语言，或者你是一个熟练的开发人员，你可以随时随地学习它。
• 你知道一些机器学习：这是新手机器学习从业者的课程。你知道一些基本的实用机器学习，或者你可以快速搞清楚。

这个迷你课程既不是关于 Python 的教科书，也不是关于时间序列预测的教科书。

它将把你从一个了解一点机器学习的开发人员带到一个开发人员，他可以使用 Python 生态系统获得时间序列预测结果，这是一个不断上升的专业机器学习平台。

注意：这个迷你课程假设你有一个有效的 Python 2 或 3 SciPy 环境，至少安装了 NumPy，Pandas，scikit-learn 和 statsmodels。

迷你课程概述

这个迷你课程分为 7 课。

你可以每天完成一节课（_ 推荐 ）或者在一天内完成所有课程（ 硬核 _）。这取决于你有空的时间和你的热情程度。

以下 7 个课程将通过 Python 中的机器学习帮助您开始并提高工作效率：

• 第 01 课：时间序列作为监督学习。
• 第 02 课：加载时间序列数据。
• 第 03 课：数据可视化。
• 第 04 课：持久性预测模型。
• 第 05 课：自回归预测模型。
• 第 06 课：ARIMA 预测模型。
• 第 07 课：Hello World 端到端项目。

每节课可能需要 60 秒或 30 分钟。花点时间，按照自己的进度完成课程。在下面的评论中提出问题甚至发布结果。

课程期望你去学习如何做事。我会给你提示，但每节课的部分内容是强迫你学习去寻找有关时间序列的 Python 平台的帮助（提示，我直接在这个博客上得到了所有的答案，使用搜索功能）。

我确实在早期课程中提供了更多帮助，因为我希望你建立一些自信和惯性。

在评论中发布您的结果，我会为你欢呼！

挂在那里，不要放弃。

第 01 课：时间序列作为监督学习

时间序列问题与传统预测问题不同。

时间的增加为必须保留的观测添加了一个顺序，并且可以为学习算法提供额外的信息。

时间序列数据集可能如下所示：

Time, Observation
day1, obs1
day2, obs2
day3, obs3

我们可以将这些数据重新设置为监督学习问题，并预测输入和输出。例如：

Input,	Output
?,		obs1
obs1,	obs2
obs2,	obs3
obs3,	?

您可以看到重构意味着我们必须丢弃一些缺少数据的行。

一旦重新构建，我们就可以应用所有我们喜欢的学习算法，如 K 最近邻 和 Random Forest。

如需更多帮助，请参阅帖子：

• 时间序列预测作为监督学习

课程 02：加载时间序列数据

在开发预测模型之前，必须加载并使用时间序列数据。

Pandas 提供了以 CSV 格式加载数据的工具。

在本课程中，您将下载标准时间序列数据集，将其加载到 Pandas 中并进行探索。

从 DataMarket 以 CSV 格式下载每日女性出生数据集，并以文件名“ daily-births.csv ”保存。

您可以将时间序列数据集作为 Pandas Series 加载，并在第 0 行指定标题行，如下所示：

from pandas import Series
series = Series.from_csv('daily-births.csv', header=0)

习惯于在 Python 中探索加载的时间序列数据：

• 使用head()功能打印前几行。
• 使用size属性打印数据集的尺寸。
• 使用日期时间字符串查询数据集。
• 打印观察的摘要统计。

如需更多帮助，请参阅帖子：

• 如何在 Python 中加载和探索时间序列数据

第 03 课：数据可视化

数据可视化是时间序列预测的重要组成部分。

随着时间的推移观察的线图很受欢迎，但是您可以使用一套其他图来了解有关您的问题的更多信息。

在本课程中，您必须下载标准时间序列数据集并创建 6 种不同类型的图。

从 DataMarket 以 CSV 格式下载月度洗发水销售数据集，并使用文件名“ shampoo-sales.csv ”保存。

现在创建以下 6 种类型的图：

1. 线图。
2. 直方图和密度图。
3. 盒子和晶须地块按年或季度。
4. 热图。
5. 滞后图或散点图。
6. 自相关图。

下面是一个简单的线图的示例，可以帮助您入门：

from pandas import Series
from matplotlib import pyplot
series = Series.from_csv('shampoo-sales.csv', header=0)
series.plot()
pyplot.show()

如需更多帮助，请参阅帖子：

• 使用 Python 进行时间序列数据可视化

课 04：持久性预测模型

建立基线预测非常重要。

您可以做的最简单的预测是使用当前观测值（t）来预测下一时间步（t + 1）的观测值。

这称为朴素预测或持久性预测，可能是某些时间序列预测问题的最佳模型。

在本课程中，您将对标准时间序列预测问题进行持久性预测。

从 DataMarket 以 CSV 格式下载每日女性出生数据集，并以文件名“ daily-births.csv ”保存。

您可以将持久性预测实现为单行函数，如下所示：

# persistence model
def model_persistence(x):
	return x

编写代码以加载数据集并使用持久性预测对数据集中的每个时间步做出预测。请注意，您将无法对数据集中的第一个步骤做出预测，因为之前没有使用过的观察。

将所有预测存储在列表中。与实际观察结果相比，您可以计算预测的均方根误差（RMSE），如下所示：

from sklearn.metrics import mean_squared_error
from math import sqrt
predictions = []
actual = series.values[1:]
rmse = sqrt(mean_squared_error(actual, predictions))

如需更多帮助，请参阅帖子：

• 如何使用 Python 进行时间序列预测的基线预测

第 05 课：自回归预测模型

自回归意味着开发一种线性模型，该模型使用先前时间步骤的观察来预测未来时间步骤的观察结果（“自动”意味着古希腊语中的自我）。

自回归是一种快速而有效的时间序列预测方法。

statsmodels Python 库在 AR 类中提供自动回归模型。

在本课程中，您将为标准时间序列数据集开发自回归预测模型。

从 DataMarket 以 CSV 格式下载月度洗发水销售数据集，并使用文件名“ shampoo-sales.csv ”保存。

您可以按如下方式安装 AR 模型：

model = AR(dataset)
model_fit = model.fit()

您可以使用拟合 AR 模型预测下一次样本观察，如下所示：

prediction = model_fit.predict(start=len(dataset), end=len(dataset))

您可能希望通过在半数数据集上拟合模型并预测系列的后半部分中的一个或多个来进行实验，然后将预测与实际观察结果进行比较。

如需更多帮助，请参阅帖子：

• 使用 Python 进行时间序列预测的自回归模型

第 06 课：ARIMA 预测模型

ARIMA 是时间序列预测的经典线性模型。

它结合了自回归模型（AR），差异去除趋势和季节性，称为积分（I）和移动平均模型（MA），它是一个旧名称，用于预测误差的模型，用于纠正预测。

statsmodels Python 库提供了 ARIMA 类。

在本课程中，您将为标准时间序列数据集开发 ARIMA 模型。

从 DataMarket 以 CSV 格式下载月度洗发水销售数据集，并使用文件名“ shampoo-sales.csv ”保存。

ARIMA 类需要一个顺序（p，d，q），其由 AR 滞后的三个参数 p，d 和 q 组成，差异数和 MA 滞后。

您可以按如下方式拟合 ARIMA 模型：

model = ARIMA(dataset, order=(0,1,0))
model_fit = model.fit()

您可以为适合的 ARIMA 模型进行一步式样本外预测，如下所示：

outcome = model_fit.forecast()[0]

洗发水数据集有一个趋势所以我建议 d 值为 1.尝试不同的 p 和 q 值并评估结果模型的预测。

如需更多帮助，请参阅帖子：

• 如何使用 Python 创建用于时间序列预测的 ARIMA 模型

第 07 课：Hello World 端到端项目

您现在可以使用工具来解决时间序列问题并开发一个简单的预测模型。

在本课程中，您将使用从所有先前课程中学到的技能来处理新的时间序列预测问题。

从 DataMarket 以 CSV 格式下载季度 S＆amp; P 500 指数，1900-1996 数据集，并以文件名“sp500.csv”保存。

拆分数据，可能会将最后 4 或 8 个季度提取到单独的文件中。解决问题并为缺失的数据制定预测，包括：

1. 加载并浏览数据集。
2. 可视化数据集。
3. 开发持久性模型。
4. 开发自回归模型。
5. 开发 ARIMA 模型。
6. 可视化预测并总结预测误差。

有关完成项目的示例，请参阅帖子：

• Python 时间序列预测研究：法国香槟月销量[H​​TG1]

结束！

（看你有多远）

你做到了。做得好！

花点时间回顾一下你到底有多远。

你发现：

• 如何将时间序列预测问题构建为监督学习。
• 如何使用 Pandas 加载和探索时间序列数据。
• 如何以多种不同方式绘制和可视化时间序列数据。
• 如何开发一种称为持久性模型作为基线的朴素预测。
• 如何使用滞后观测开发自回归预测模型。
• 如何开发 ARIMA 模型，包括自回归，积分和移动平均元素。
• 如何将所有这些元素组合到一个端到端项目中。

不要轻视这一点，你在很短的时间内走了很长的路。

这只是您使用 Python 进行时间序列预测之旅的开始。继续练习和发展你的技能。

摘要

你是如何使用迷你课程的？
你喜欢这个迷你课吗？

你有任何问题吗？有没有任何问题？
让我知道。在下面发表评论。

作为监督学习的时间序列预测

原文： machinelearningmastery.com/time-series-forecasting-supervised-learning/

时间序列预测可以被视为监督学习问题。

通过重新构建时间序列数据，您可以访问针对问题的标准线性和非线性机器学习算法套件。

在这篇文章中，您将了解如何重新构建时间序列问题，作为机器学习的监督学习问题。阅读这篇文章后，你会知道：

• 什么是监督学习，以及它是如何成为所有预测性建模机器学习算法的基础。
• 用于构建时间序列数据集的滑动窗口方法以及如何使用它。
• 如何使用滑动窗口进行多变量数据和多步预测。

让我们开始吧。

时间序列预测作为监督学习
照片由JeroenLooyé，保留一些权利。

监督机器学习

大多数实际机器学习使用监督学习。

监督学习是输入变量（ X ）和输出变量（ y ）的地方，您可以使用算法来学习从输入到输出的映射函数。

Y = f(X)

目标是近似真实的底层映射，以便当您有新的输入数据（ X ）时，您可以预测该数据的输出变量（ y ）。

下面是监督学习数据集的设计示例，其中每行是由一个输入变量（ X ）和一个要预测的输出变量（ y ）组成的观察。

X, y
5, 0.9
4, 0.8
5, 1.0
3, 0.7
4, 0.9

它被称为监督学习，因为从训练数据集学习算法的过程可以被认为是监督学习过程的教师。

我们知道正确的答案;该算法迭代地对训练数据做出预测，并通过进行更新来纠正。当算法达到可接受的表现水平时，学习停止。

监督学习问题可以进一步分为回归和分类问题。

• 分类：分类问题是输出变量是一个类别，例如“red”和“blue”或“_ 疾病 _ “和”_ 没有疾病 _。“
• 回归：回归问题是当输出变量是实际值时，例如“_ 美元 ”或“ 权重 _。”上面的人为举例是回归问题。

时间序列数据的滑动窗口

时间序列数据可以表达为监督学习。

给定时间序列数据集的数字序列，我们可以将数据重组为看起来像监督学习问题。我们可以使用前面的时间步长作为输入变量，并使用下一个时间步作为输出变量。

让我们以一个例子来具体化。想象一下，我们有一个时间序列如下：

time, measure
1, 100
2, 110
3, 108
4, 115
5, 120

我们可以通过使用前一时间步的值来预测下一个时间步的值，将此时间序列数据集重组为监督学习问题。以这种方式重新组织时间序列数据集，数据看起来如下：

X, y
?, 100
100, 110
110, 108
108, 115
115, 120
120, ?

查看上面转换的数据集并将其与原始时间序列进行比较。以下是一些观察结果：

• 我们可以看到前一个时间步长是输入（ X ），下一个时间步长是我们监督学习问题中的输出（ y ）。
• 我们可以看到观察之间的顺序被保留，并且在使用该数据集训练监督模型时必须继续保留。
• 我们可以看到，我们没有先前的值可以用来预测序列中的第一个值。我们将删除此行，因为我们无法使用它。
• 我们还可以看到，我们没有已知的下一个值来预测序列中的最后一个值。我们可能还希望在训练我们的监督模型时删除此值。

使用先前时间步骤来预测下一个时间步骤称为滑动窗口方法。简而言之，在一些文献中它可以被称为窗口方法。在统计和时间序列分析中，这称为滞后或滞后方法。

先前时间步数称为窗口宽度或滞后大小。

这个滑动窗口是我们如何将任何时间序列数据集转换为监督学习问题的基础。从这个简单的例子中，我们可以注意到一些事情：

• 我们可以看到这可以如何将时间序列转换为回归或分类监督学习问题，用于实值或标记的时间序列值。
• 我们可以看到，一旦按照这种方式准备时间序列数据集，可以应用任何标准线性和非线性机器学习算法，只要保留行的顺序即可。
• 我们可以看到如何增加宽度滑动窗口以包括更多的先前时间步长。
• 我们可以看到滑动窗口方法如何用于具有多个值的时间序列，或所谓的多变量时间序列。

我们将探讨滑动窗口的一些使用，接下来开始使用它来处理时间序列，在每个时间步骤有多个观察点，称为多变量时间序列。

具有多变量时间序列数据的滑动窗口

在时间序列数据集中记录的给定时间的观测数量很重要。

传统上，使用不同的名称：

• 单变量时间序列：这些数据集中每次只观察到一个变量，例如每小时的温度。上一节中的示例是单变量时间序列数据集。
• 多变量时间序列：这些是每次观察到两个或多个变量的数据集。

大多数时间序列分析方法，甚至关于该主题的书籍，都集中在单变量数据上。这是因为它是最容易理解和使用的。多变量数据通常更难以使用。模型更难，而且许多经典方法往往表现不佳。

多变量时间序列分析同时考虑多个时间序列。 …总的来说，它比单变量时间序列分析复杂得多

• 第 1 页，多变量时间序列分析：R 和金融应用。

使用机器学习时间序列的最佳位置是经典方法的落后。这可能是复杂的单变量时间序列，并且考虑到额外的复杂性，更可能是多变量时间序列。

下面是另一个工作示例，使滑动窗口方法具体为多变量时间序列。

假设我们有下面设想的多变量时间序列数据集，每个时间步都有两个观察结果。我们还假设我们只关注预测 measure2 。

time, measure1, measure2
1, 0.2, 88
2, 0.5, 89
3, 0.7, 87
4, 0.4, 88
5, 1.0, 90

我们可以将此时间序列数据集重新构建为窗口宽度为 1 的监督学习问题。

这意味着我们将使用 measure1 和 measure2 的先前时间步长值。我们还将为 measure1 提供下一个时间步长值。然后我们将预测 measure2 的下一个时间步长值。

这将为我们提供 3 个输入要素和一个输出值，以预测每种训练模式。

X1, X2, X3, y
?, ?, 0.2 , 88
0.2, 88, 0.5, 89
0.5, 89, 0.7, 87
0.7, 87, 0.4, 88
0.4, 88, 1.0, 90
1.0, 90, ?, ?

我们可以看到，就像上面的单变量时间序列示例一样，我们可能需要删除第一行和最后一行以训练我们的监督学习模型。

这个例子提出了一个问题，如果我们想要预测下一个时间步的 measure1 和 measure2 怎么办？

在这种情况下也可以使用滑动窗口方法。

使用上面相同的时间序列数据集，我们可以将其称为监督学习问题，其中我们预测 measure1 和 measure2 具有相同的窗口宽度 1，如下所示。

X1, X2, y1, y2
?, ?, 0.2, 88
0.2, 88, 0.5, 89
0.5, 89, 0.7, 87
0.7, 87, 0.4, 88
0.4, 88, 1.0, 90
1.0, 90, ?, ?

没有多少监督学习方法可以处理多个输出值的预测而无需修改，但是一些方法，如人工神经网络，几乎没有什么问题。

我们可以考虑预测多个值作为预测序列。在这种情况下，我们预测了两个不同的输出变量，但我们可能想要预测一个输出变量之前的多个时间步长。

这称为多步预测，将在下一节中介绍。

具有多步预测的滑动窗口

预测的时间步数很重要。

同样，根据预测的时间步数，传统的问题是使用不同的名称：

• 一步预测：这是预测下一个时间步（t + 1）的地方。
• 多步预测：这是预测两个或更多未来时间步长的地方。

到目前为止，我们所看到的所有例子都是一步预测。

有许多方法可以将多步预测性建模为监督学习问题。我们将在以后的文章中介绍其中一些替代方法。

目前，我们正专注于使用滑动窗口方法构建多步预测。

考虑来自上面第一个滑动窗口示例的相同的单变量时间序列数据集：

time, measure
1, 100
2, 110
3, 108
4, 115
5, 120

我们可以将这个时间序列构建为一个两步预测数据集，用于监督学习，窗口宽度为 1，如下所示：

X1, y1, y2
? 100, 110
100, 110, 108
110, 108, 115
108, 115, 120
115, 120, ?
120, ?, ?

我们可以看到第一行和最后两行不能用于训练监督模型。

这也是显示输入变量负担的一个很好的例子。具体而言，监督模型仅使用 X1 来预测 y1 和 y2 。

您的问题需要仔细考虑和实验才能找到导致模型表现可接受的窗口宽度。

进一步阅读

如果您正在寻找有关如何使用时间序列数据作为机器学习问题的更多资源，请参阅以下两篇论文：

• 顺序数据机器学习：回顾（2002）[PDF]
• 时间序列预测的机器学习策略（2013）（也幻灯片 PDF）

有关如何执行此操作的 Python 代码，请参阅帖子：

• 如何将时间序列转换为 Python 中的监督学习问题

摘要

在这篇文章中，您了解了如何将时间序列预测问题重新构建为用于机器学习方法的监督学习问题。

具体来说，你学到了：

• 监督学习是将机器学习问题框定为输入和输出观察的最流行方式。
• 滑动窗口是将时间序列数据集重组为监督学习问题的方法。
• 多变量和多步预测时间序列也可以使用滑动窗口方法构建为监督学习。

您对滑动窗口方法或此帖子有任何疑问吗？
在下面的评论中提出您的问题，我会尽力回答。

Python 中使用 Prophet 的时间序列预测

原文：https://machinelearningmastery.com/time-series-forecasting-with-prophet-in-python/

时间序列预测可能具有挑战性，因为有许多不同的方法可以使用，而且每种方法都有许多不同的超参数。

Prophet 库是一个开源库，设计用于对单变量时间序列数据集进行预测。它易于使用，旨在自动为模型找到一组好的超参数，以便对默认情况下具有趋势和季节结构的数据进行熟练的预测。

在本教程中，您将发现如何使用脸书 Prophet 库进行时间序列预测。

完成本教程后，您将知道:

• Prophet 是一个由脸书开发的开源库，设计用于单变量时间序列数据的自动预测。
• 如何拟合预言家模型并使用它们进行样本内和样本外预测。
• 如何在搁置数据集上评估 Prophet 模型。

我们开始吧。

时间序列预测与 Python 中的 Prophet
图片由里纳尔多·伍尔格利茨提供，保留部分权利。

教程概述

本教程分为三个部分；它们是:

1. Prophet 预测图书馆
2. 汽车销售数据集
   1. 加载和汇总数据集
   2. 加载和绘制数据集
3. Prophet 预测汽车销量
   1. 适合 Prophet 模型
   2. 进行抽样预测
   3. 进行样本外预测
   4. 手动评估预测模型

Prophet 预测图书馆

预言家，或“脸书预言家”，是脸书开发的单变量(单变量)时间序列预测的开源库。

预言家实现了他们所称的加性时间序列预测模型，该实现支持趋势、季节性和节假日。

实施基于加法模型预测时间序列数据的程序，其中非线性趋势与年度、每周和每日季节性以及假日影响相匹配

——包裹‘Prophet’，2019 年。

它被设计成简单和完全自动的，例如，以时间序列为点，得到一个预测。因此，它旨在供公司内部使用，如预测销售、产能等。

有关预言家及其能力的概述，请参阅帖子:

• 预言家:规模预测，2017 年。

该库提供了两个接口，包括 R 和 Python。在本教程中，我们将重点关注 Python 接口。

第一步是使用 Pip 安装 Prophet 库，如下所示:

sudo pip install fbprophet

接下来，我们可以确认库安装正确。

为此，我们可以导入库，并用 Python 打印版本号。下面列出了完整的示例。

# check prophet version
import fbprophet
# print version number
print('Prophet %s' % fbprophet.__version__)

运行该示例会打印 Prophet 的安装版本。

你应该有相同或更高的版本。

Prophet 0.5

现在我们已经安装了 Prophet，让我们选择一个数据集，我们可以使用该库来探索。

汽车销售数据集

我们将使用每月汽车销量数据集。

这是一个包含趋势和季节性的标准单变量时间序列数据集。该数据集有 108 个月的数据，天真的持久性预测可以实现大约 3，235 次销售的平均绝对误差，提供了较低的误差限制。

不需要下载数据集，因为我们将在每个示例中自动下载它。

• 月度汽车销量数据集(csv)
• 月度汽车销量数据集描述

加载和汇总数据集

首先，让我们加载并总结数据集。

预言家要求数据在熊猫数据框中。因此，我们将使用熊猫加载和汇总数据。

我们可以通过调用 read_csv() Pandas 函数直接从 URL 加载数据，然后汇总数据的形状(行数和列数)并查看前几行数据。

下面列出了完整的示例。

# load the car sales dataset
from pandas import read_csv
# load data
path = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/monthly-car-sales.csv'
df = read_csv(path, header=0)
# summarize shape
print(df.shape)
# show first few rows
print(df.head())

运行该示例首先报告行数和列数，然后列出前五行数据。

我们可以看到，正如我们所料，有价值 108 个月的数据和两列。第一列是日期，第二列是销售数量。

请注意，输出中的第一列是行索引，不是数据集的一部分，只是 Pandas 用来排序行的一个有用工具。

(108, 2)
     Month  Sales
0  1960-01   6550
1  1960-02   8728
2  1960-03  12026
3  1960-04  14395
4  1960-05  14587

加载和绘制数据集

时间序列数据集在我们绘制之前对我们没有意义。

绘制时间序列有助于我们实际查看是否存在趋势、季节性周期、异常值等等。它让我们对数据有了感觉。

我们可以通过调用数据框上的*绘图()*函数，在熊猫中轻松绘制数据。

下面列出了完整的示例。

# load and plot the car sales dataset
from pandas import read_csv
from matplotlib import pyplot
# load data
path = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/monthly-car-sales.csv'
df = read_csv(path, header=0)
# plot the time series
df.plot()
pyplot.show()

运行该示例会创建一个时间序列图。

我们可以清楚地看到一段时间内的销售趋势和每月的销售季节性模式。这些是我们期望预测模型考虑到的模式。

汽车销售数据集的线图

现在我们已经熟悉了数据集，让我们探索如何使用 Prophet 库进行预测。

Prophet 预测汽车销量

在本节中，我们将探索使用预言家来预测汽车销售数据集。

让我们从在数据集上拟合模型开始

适合 Prophet 模型

要使用 Prophet 进行预测，首先定义并配置一个 Prophet() 对象，然后通过调用 fit() 函数并传递数据来拟合数据集。

Prophet() 对象接受参数来配置您想要的模型类型，例如增长类型、季节性类型等等。默认情况下，模型会努力自动计算出几乎所有的事情。

fit() 函数获取时间序列数据的数据帧。数据框必须有特定的格式。第一列必须有名称“ ds ，并包含日期时间。第二列必须有名称“ y ，并包含观察值。

这意味着我们要更改数据集中的列名。它还要求将第一列转换为日期时间对象，如果它们还没有的话(例如，这可以作为加载数据集的一部分，将正确的参数设置为 read_csv )。

例如，我们可以修改加载的汽车销售数据集，使其具有如下预期结构:

...
# prepare expected column names
df.columns = ['ds', 'y']
df['ds']= to_datetime(df['ds'])

下面列出了在汽车销售数据集中拟合 Prophet 模型的完整示例。

# fit prophet model on the car sales dataset
from pandas import read_csv
from pandas import to_datetime
from fbprophet import Prophet
# load data
path = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/monthly-car-sales.csv'
df = read_csv(path, header=0)
# prepare expected column names
df.columns = ['ds', 'y']
df['ds']= to_datetime(df['ds'])
# define the model
model = Prophet()
# fit the model
model.fit(df)

运行该示例将加载数据集，以预期的格式准备数据帧，并适合 Prophet 模型。

默认情况下，在拟合过程中，库会提供大量详细的输出。我认为这是一个坏主意，因为它训练开发人员忽略输出。

然而，输出总结了模型拟合过程中发生的事情，特别是运行的优化过程。

INFO:fbprophet:Disabling weekly seasonality. Run prophet with weekly_seasonality=True to override this.
INFO:fbprophet:Disabling daily seasonality. Run prophet with daily_seasonality=True to override this.
Initial log joint probability = -4.39613
    Iter      log prob        ||dx||      ||grad||       alpha      alpha0  # evals  Notes
      99       270.121    0.00413718       75.7289           1           1      120
    Iter      log prob        ||dx||      ||grad||       alpha      alpha0  # evals  Notes
     179       270.265    0.00019681       84.1622   2.169e-06       0.001      273  LS failed, Hessian reset
     199       270.283   1.38947e-05       87.8642      0.3402           1      299
    Iter      log prob        ||dx||      ||grad||       alpha      alpha0  # evals  Notes
     240       270.296    1.6343e-05       89.9117   1.953e-07       0.001      381  LS failed, Hessian reset
     299         270.3   4.73573e-08       74.9719      0.3914           1      455
    Iter      log prob        ||dx||      ||grad||       alpha      alpha0  # evals  Notes
     300         270.3   8.25604e-09       74.4478      0.3522      0.3522      456
Optimization terminated normally:
  Convergence detected: absolute parameter change was below tolerance

当我们适合这个模型时，我不会在后面的章节中重复这个输出。

接下来，让我们做一个预测。

进行抽样预测

对历史数据进行预测可能是有用的。

也就是说，我们可以对用作训练模型输入的数据进行预测。理想情况下，该模型之前已经看到了数据，并将做出完美的预测。

然而，情况并非如此，因为模型试图对数据中的所有情况进行归纳。

这被称为进行样本内(在训练集样本中)预测，检查结果可以洞察模型有多好。也就是它对训练数据的学习程度。

通过调用 predict() 函数并传递一个数据帧来进行预测，该数据帧包含一个名为“ ds 的列和带有所有要预测的时间间隔的日期时间的行。

有很多方法可以创建这个“预测”数据框。在这种情况下，我们将循环一年的日期，例如数据集中的最后 12 个月，并为每个月创建一个字符串。然后，我们将把日期列表转换成一个数据帧，并将字符串值转换成日期时间对象。

...
# define the period for which we want a prediction
future = list()
for i in range(1, 13):
	date = '1968-%02d' % i
	future.append([date])
future = DataFrame(future)
future.columns = ['ds']
future['ds']= to_datetime(future['ds'])

该数据帧然后可以被提供给*预测()*功能以计算预测。

predict()函数的结果是一个包含许多列的数据帧。最重要的列可能是预测日期时间(’ T2 ’ ds)、预测值(’ T4 ’ yhat)以及预测值的下限和上限(’ T6 ’ yhat _ lower’和’(T8)yhat _ upper’)，它们提供了预测的不确定性。

例如，我们可以将前几个预测打印如下:

...
# summarize the forecast
print(forecast[['ds', 'yhat', 'yhat_lower', 'yhat_upper']].head())

Prophet 还提供了一个内置工具，用于在训练数据集的上下文中可视化预测。

这可以通过在模型上调用 plot() 函数并向其传递结果数据帧来实现。它将创建训练数据集的图，并用预测日期的上限和下限覆盖预测。

...
print(forecast[['ds', 'yhat', 'yhat_lower', 'yhat_upper']].head())
# plot forecast
model.plot(forecast)
pyplot.show()

将所有这些结合起来，下面列出了一个完整的样本内预测示例。

# make an in-sample forecast
from pandas import read_csv
from pandas import to_datetime
from pandas import DataFrame
from fbprophet import Prophet
from matplotlib import pyplot
# load data
path = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/monthly-car-sales.csv'
df = read_csv(path, header=0)
# prepare expected column names
df.columns = ['ds', 'y']
df['ds']= to_datetime(df['ds'])
# define the model
model = Prophet()
# fit the model
model.fit(df)
# define the period for which we want a prediction
future = list()
for i in range(1, 13):
	date = '1968-%02d' % i
	future.append([date])
future = DataFrame(future)
future.columns = ['ds']
future['ds']= to_datetime(future['ds'])
# use the model to make a forecast
forecast = model.predict(future)
# summarize the forecast
print(forecast[['ds', 'yhat', 'yhat_lower', 'yhat_upper']].head())
# plot forecast
model.plot(forecast)
pyplot.show()

运行该示例可以预测数据集的最后 12 个月。

报告了预测的前五个月，我们可以看到这些值与数据集中的实际销售值没有太大差异。

          ds          yhat    yhat_lower    yhat_upper
0 1968-01-01  14364.866157  12816.266184  15956.555409
1 1968-02-01  14940.687225  13299.473640  16463.811658
2 1968-03-01  20858.282598  19439.403787  22345.747821
3 1968-04-01  22893.610396  21417.399440  24454.642588
4 1968-05-01  24212.079727  22667.146433  25816.191457

接下来，创建一个图。我们可以看到训练数据被表示为黑点，预测是一条蓝色线，在蓝色阴影区域有上下限。

我们可以看到，预测的 12 个月与实际观测值非常吻合，尤其是考虑到界限的时候。

时间序列图和带预测器的样本内预测

进行样本外预测

在实践中，我们确实希望预测模型能够在训练数据之外做出预测。

这被称为样本外预测。

我们可以通过与样本内预测相同的方式实现这一点，只需指定不同的预测期。

在这种情况下，是从 1969-01 年开始的训练数据集结束后的一段时间。

...
# define the period for which we want a prediction
future = list()
for i in range(1, 13):
	date = '1969-%02d' % i
	future.append([date])
future = DataFrame(future)
future.columns = ['ds']
future['ds']= to_datetime(future['ds'])

将这些联系在一起，完整的示例如下所示。

# make an out-of-sample forecast
from pandas import read_csv
from pandas import to_datetime
from pandas import DataFrame
from fbprophet import Prophet
from matplotlib import pyplot
# load data
path = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/monthly-car-sales.csv'
df = read_csv(path, header=0)
# prepare expected column names
df.columns = ['ds', 'y']
df['ds']= to_datetime(df['ds'])
# define the model
model = Prophet()
# fit the model
model.fit(df)
# define the period for which we want a prediction
future = list()
for i in range(1, 13):
	date = '1969-%02d' % i
	future.append([date])
future = DataFrame(future)
future.columns = ['ds']
future['ds']= to_datetime(future['ds'])
# use the model to make a forecast
forecast = model.predict(future)
# summarize the forecast
print(forecast[['ds', 'yhat', 'yhat_lower', 'yhat_upper']].head())
# plot forecast
model.plot(forecast)
pyplot.show()

运行该示例可以对汽车销售数据进行样本外预测。

预测的前五行被打印出来，尽管很难知道它们是否明智。

          ds          yhat    yhat_lower    yhat_upper
0 1969-01-01  15406.401318  13751.534121  16789.969780
1 1969-02-01  16165.737458  14486.887740  17634.953132
2 1969-03-01  21384.120631  19738.950363  22926.857539
3 1969-04-01  23512.464086  21939.204670  25105.341478
4 1969-05-01  25026.039276  23544.081762  26718.820580

创建一个图来帮助我们在训练数据的上下文中评估预测。

新的一年预测看起来确实是合理的，至少从表面上看是如此。

时间序列图和带预测器的样本外预测

手动评估预测模型

对预测模型的表现进行客观评估至关重要。

这可以通过保留模型中的一些数据来实现，例如最近 12 个月的数据。然后，将模型拟合到数据的第一部分，使用它来对保持包部分进行预测，并计算误差度量，例如预测的平均绝对误差。例如模拟的样本外预测。

该分数给出了在进行样本外预测时，我们对模型平均表现的预期。

我们可以通过创建一个新的数据框架来处理样本数据，并删除过去 12 个月的数据。

...
# create test dataset, remove last 12 months
train = df.drop(df.index[-12:])
print(train.tail())

然后可以对过去 12 个月的日期时间进行预测。

然后，我们可以从原始数据集中检索预测值和期望值，并使用 Sklearn 库计算平均绝对误差度量。

...
# calculate MAE between expected and predicted values for december
y_true = df['y'][-12:].values
y_pred = forecast['yhat'].values
mae = mean_absolute_error(y_true, y_pred)
print('MAE: %.3f' % mae)

绘制预期值与预测值的关系图也有助于了解样本外预测与已知值的匹配程度。

...
# plot expected vs actual
pyplot.plot(y_true, label='Actual')
pyplot.plot(y_pred, label='Predicted')
pyplot.legend()
pyplot.show()

将这些联系在一起，下面的例子演示了如何在一个搁置的数据集上评估一个预言家模型。

# evaluate prophet time series forecasting model on hold out dataset
from pandas import read_csv
from pandas import to_datetime
from pandas import DataFrame
from fbprophet import Prophet
from sklearn.metrics import mean_absolute_error
from matplotlib import pyplot
# load data
path = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/monthly-car-sales.csv'
df = read_csv(path, header=0)
# prepare expected column names
df.columns = ['ds', 'y']
df['ds']= to_datetime(df['ds'])
# create test dataset, remove last 12 months
train = df.drop(df.index[-12:])
print(train.tail())
# define the model
model = Prophet()
# fit the model
model.fit(train)
# define the period for which we want a prediction
future = list()
for i in range(1, 13):
	date = '1968-%02d' % i
	future.append([date])
future = DataFrame(future)
future.columns = ['ds']
future['ds'] = to_datetime(future['ds'])
# use the model to make a forecast
forecast = model.predict(future)
# calculate MAE between expected and predicted values for december
y_true = df['y'][-12:].values
y_pred = forecast['yhat'].values
mae = mean_absolute_error(y_true, y_pred)
print('MAE: %.3f' % mae)
# plot expected vs actual
pyplot.plot(y_true, label='Actual')
pyplot.plot(y_pred, label='Predicted')
pyplot.legend()
pyplot.show()

运行该示例首先报告训练数据集的最后几行。

它确认训练在 1967 年的最后一个月结束，1968 年将被用作暂停数据集。

           ds      y
91 1967-08-01  13434
92 1967-09-01  13598
93 1967-10-01  17187
94 1967-11-01  16119
95 1967-12-01  13713

接下来，计算预测期间的平均绝对误差。

在这种情况下，我们可以看到误差约为 1，336 次销售，这比同期实现 3，235 次销售误差的简单持久性模型低得多(更好)。

MAE: 1336.814

最后，绘制实际值与预测值的对比图。在这种情况下，我们可以看到预测非常吻合。这个模型有技巧和预测，看起来很合理。

过去 12 个月汽车销量的实际值与预测值图

Prophet 库还提供了自动评估模型和绘制结果的工具，尽管这些工具对于分辨率超过一天的数据似乎不能很好地工作。

进一步阅读

如果您想更深入地了解这个主题，本节将提供更多资源。

• Prophet 主页。
• Prophet GitHub 项目。
• 预言家 API 文档。
• 预言家:规模预测，2017 年。
• 规模预测，2017 年。
• 汽车销量数据集。
• 包装‘Prophet’，R 文件。

摘要

在本教程中，您发现了如何使用脸书 Prophet 库进行时间序列预测。

具体来说，您了解到:

• Prophet 是一个由脸书开发的开源库，设计用于单变量时间序列数据的自动预测。
• 如何拟合预言家模型并使用它们进行样本内和样本外预测。
• 如何在搁置数据集上评估 Prophet 模型。

你有什么问题吗？
在下面的评论中提问，我会尽力回答。

什么是时间序列预测？

原文： machinelearningmastery.com/time-series-forecasting/

时间序列预测是机器学习的一个重要领域，往往被忽视。

这很重要，因为有很多涉及时间成分的预测问题。这些问题被忽略了，因为正是这个时间组件使得时间序列问题更难以处理。

在这篇文章中，您将发现时间序列预测。

阅读这篇文章后，你会知道：

• 时间序列，时间序列分析和时间序列预测的标准定义。
• 时间序列数据中要考虑的重要组成部分。
• 时间序列的例子，使您的理解具体化。

让我们开始吧。

什么是时间序列预测？
照片由 Dennis Kleine 拍摄，保留一些权利。

时间序列

普通机器学习数据集是观察的集合。

例如：

observation #1
observation #2
observation #3

时间确实在普通机器学习数据集中发挥作用。

当在未来某个日期之前可能不知道实际结果时，对新数据做出预测。未来正在被预测，但所有先前的观察几乎总是被平等对待。也许用一些非常小的时间动力来克服“_ 概念漂移 _”的想法，例如仅使用去年的观测而不是所有可用的数据。

时间序列数据集是不同的。

时间序列在观察之间增加了明确的顺序依赖：时间维度。

此附加维度既是约束，也是提供附加信息源的结构。

时间序列是按时间顺序进行的一系列观察。

• 第 1 页，时间序列分析：预测和控制。

例如：

Time #1, observation
Time #2, observation
Time #3, observation

描述与预测

根据我们是否有兴趣了解数据集或做出预测，我们有不同的目标。

了解一个名为 _ 时间序列分析 _ 的数据集可以帮助做出更好的预测，但不是必需的，并且可能导致大量的技术投资在时间和专业知识上与预期结果没有直接对应，这预测了未来。

在描述性建模或时间序列分析中，时间序列被建模以根据季节性模式，趋势，与外部因素的关系等来确定其组成部分。 …相比之下，时间序列预测使用时间序列中的信息（可能包含其他信息）来预测该系列的未来值

• 第 18-19 页， R 实用时间序列预测：动手指南。

时间序列分析

使用经典统计时，主要关注的是时间序列的分析。

时间序列分析涉及开发最能捕获或描述观察到的时间序列的模型，以便了解根本原因。该研究领域寻求时间序列数据集背后的“_ 为什么 _”。

这通常涉及对数据形式进行假设并将时间序列分解为构成组件。

描述性模型的质量取决于它描述所有可用数据的程度以及它为更好地通知问题域提供的解释。

时间序列分析的主要目标是开发数学模型，从样本数据中提供合理的描述

• 第 11 页，时间序列分析及其应用：R 实例

时间序列预测

对时间做出预测称为时间序列数据的经典统计处理中的外推。

更多现代领域专注于该主题，并将其称为时间序列预测。

预测涉及使模型适合历史数据并使用它们来预测未来的观测。

描述性模型可以借用未来（即平滑或消除噪声），它们只是寻求最好地描述数据。

预测中的一个重要区别是，未来完全不可用，只能根据已经发生的事情进行估算。

时间序列分析的目的通常是双重的：理解或模拟产生观测序列的随机机制，并根据该序列的历史预测或预测序列的未来值

• 第 1 页，时间序列分析：应用于 R 。

时间序列预测模型的技能取决于其在预测未来方面的表现。这通常是以能够解释为什么进行特定预测，置信区间甚至更好地理解问题背后的根本原因为代价的。

时间序列的组成部分

时间序列分析提供了一系列技术来更好地理解数据集。

也许最有用的是将时间序列分解为 4 个组成部分：

1. 等级。系列的基线值，如果它是一条直线。
2. 趋势。随着时间的推移，系列的可选且通常线性增加或减少的行为。
3. 季节性。随时间变化的可选重复模式或行为周期。
4. 噪音。观测中的可选可变性，无法通过模型解释。

所有时间序列都有一个级别，大多数都有噪音，趋势和季节性是可选的。

许多时间序列的主要特征是趋势和季节变化…大多数时间序列的另一个重要特征是在时间上紧密相连的观察往往是相关的（依赖于序列）

• 第 2 页， R 入门时间序列

可以认为这些组成成分以某种方式组合以提供观察到的时间序列。例如，它们可以一起添加以形成如下模型：

y = level + trend + seasonality + noise

可以在行为和组合方式上对这些组件做出假设，这允许使用传统的统计方法对它们进行建模。

这些组件也可能是预测未来价值的最有效方式，但并非总是如此。

在这些经典方法不能产生有效表现的情况下，这些组件可能仍然是有用的概念，甚至是替代方法的输入。

关注预测

在预测时，了解您的目标非常重要。

使用苏格拉底方法并提出许多问题来帮助您放大预测性建模问题的具体细节。例如：

1. 你有多少数据，你可以一起收集这些数据吗？ 更多数据通常更有帮助，为探索性数据分析，模型测试和调整以及模型保真度提供了更多机会。
2. 预测所需的时间范围是多少？短期，中期还是长期？ 更短的时间范围通常更容易预测，信心更高。
3. 预测可以随时间更新，还是必须进行一次并保持静态？ 在新信息可用时更新预测通常可以获得更准确的预测。
4. 需要预测的时间频率是多少？ 通常可以在较低或较高频率下做出预测，从而可以利用下采样和数据上采样，从而在建模时提供优势。

时间序列数据通常需要清理，缩放甚至转换。

例如：

• 频率。也许数据的提供频率太高而无法建模，或者在某些模型中需要重采样的时间间隔不均匀。
• 异常值。也许存在需要识别和处理的腐败或极端异常值。
• 缺少。也许存在需要插补或估算的间隙或缺失数据。

通常，时间序列问题是实时的，不断为预测提供新的机会。这为时间序列预测增添了诚实，可以快速排除错误假设，建模错误以及我们可能欺骗自己的所有其他方式。

时间序列预测的例子

时间序列预测问题几乎无穷无尽。

以下是一系列行业的 10 个例子，使时间序列分析和预测的概念更加具体。

• 每年按州预测玉米产量。
• 预测几秒钟内的脑电图迹线是否表明患者是否癫痫发作。
• 每天预测股票的收盘价。
• 每年预测一个城市所有医院的出生率。
• 预测商店每天销售的产品销售额。
• 每天预测通过训练站的乘客数量。
• 每个季度预测一个州的失业率。
• 每小时预测服务器上的利用率需求。
• 预测每个繁殖季节的兔子种群数量。
• 每天预测一个城市的汽油平均价格。

我希望您能够将这些示例中的一个或多个与您自己的时间序列相关联，预测您想要解决的问题。

摘要

在这篇文章中，您发现了时间序列预测。

具体来说，你学到了：

• 关于时间序列数据以及时间序列分析和时间序列预测之间的差异。
• 在执行分析时可以将时间序列分解成的组成部分。
• 时间序列预测问题的例子，使这些想法具体化。

您对时间序列预测或此帖有任何疑问吗？
在下面的评论中提出您的问题。

如何使用 Python 识别和删除时间序列数据的季节性

原文： machinelearningmastery.com/time-series-seasonality-with-python/

时间序列数据集可以包含季节性组件。

这是一个循环，随着时间的推移重复，如每月或每年。这种重复循环可能会模糊我们希望在预测时建模的信号，进而可能为我们的预测模型提供强有力的信号。

在本教程中，您将了解如何使用 Python 识别和更正时间序列数据中的季节性。

完成本教程后，您将了解：

• 时间序列中季节性的定义以及它为机器学习方法预测提供的机会。
• 如何使用差异法创建季节性调整的日常温度数据时间序列。
• 如何直接对季节性成分进行建模，并从观测中明确地减去它。

让我们开始吧。

如何使用 Python 识别和删除时间序列数据的季节性
照片来自 naturalflow ，保留一些权利。

时间序列的季节性

时间序列数据可能包含季节性变化。

季节性变化或季节性是随着时间的推移而定期重复的循环。

每年内的重复模式称为季节变化，尽管该术语更普遍地应用于任何固定时期内的重复模式。

• 第 6 页， R 入门时间序列

时间序列中的循环结构可能是季节性的，也可能不是季节性的。如果它以相同的频率一致地重复，则它是季节性的，否则它不是季节性的并且被称为循环。

机器学习的好处

了解时间序列中的季节性组件可以提高机器学习建模的表现。

这可以通过两种主要方式实现：

• 更清晰的信号：从时间序列中识别和删除季节性成分可以使输入和输出变量之间的关系更加清晰。
• 更多信息：有关时间序列的季节性组件的其他信息可以提供新信息以提高模型表现。

这两种方法都可能对项目有用。在数据清理和准备期间，可能会出现季节性建模并将其从时间序列中删除。

在特征提取和特征工程活动期间，可以直接或以摘要形式提取季节性信息并将其作为输入要素提供。

季节性的类型

季节性有很多种;例如：

• 一天的时间。
• 日常。
• 每周。
• 每月。
• 每年。

因此，确定时间序列问题中是否存在季节性因素是主观的。

确定是否存在季节性方面的最简单方法是绘制和检查您的数据，可能是在不同的尺度和添加趋势线。

消除季节性

一旦确定了季节性，就可以对其进行建模。

季节性模型可以从时间序列中删除。此过程称为季节性调整，或称为延长期。

删除季节性成分的时间序列称为季节性静止。具有明确季节性成分的时间序列被称为非平稳的。

在时间序列分析领域，有时间序列研究和提取季节性的复杂方法。由于我们主要对预测性建模和时间序列预测感兴趣，因此我们仅限于可以根据历史数据开发并在对新数据做出预测时可用的方法。

在本教程中，我们将介绍两种方法，用于对具有强附加季节性成分的日常温度的经典气象类型问题进行季节性调整。接下来，让我们看一下我们将在本教程中使用的数据集。

最低每日温度数据集

该数据集描述了澳大利亚墨尔本市 10 年（1981-1990）的最低日常温度。

单位为摄氏度，有 3,650 个观测值。数据来源被称为澳大利亚气象局。

下面是前 5 行数据的示例，包括标题行。

"Date","Temperature"
"1981-01-01",20.7
"1981-01-02",17.9
"1981-01-03",18.8
"1981-01-04",14.6
"1981-01-05",15.8

下面是从数据市场中获取的整个数据集的图表，您可以在其中下载数据集并了解有关它的更多信息。

最低每日温度

该数据集显示了一个强大的季节性组件，并具有良好，细粒度的细节。

加载最低每日温度数据集

下载最低每日温度数据集并将其放在当前工作目录中，文件名为“ daily-minimum-Temperats.sv ”。

注意：下载的文件包含一些问号（“？”）字符，必须先将其删除才能使用数据集。在文本编辑器中打开文件并删除“？”字符。同时删除文件中的任何页脚信息。

下面的代码将加载并绘制数据集。

from pandas import Series
from matplotlib import pyplot
series = Series.from_csv('daily-minimum-temperatures.csv', header=0)
series.plot()
pyplot.show()

运行该示例将创建以下数据集图。

最低每日温度数据集

具有差异的季节性调整

校正季节性组件的一种简单方法是使用差分。

如果在一周的水平上存在季节性成分，那么我们今天可以通过减去上周的值来删除它。

在最低每日温度数据集的情况下，看起来我们每年都有季节性成分显示从夏季到冬季的秋千。

我们可以减去去年同一天的每日最低温度来纠正季节性。这需要在闰年 2 月 29 日进行特殊处理，这意味着第一年的数据无法用于建模。

下面是在 Python 中对日常数据使用差异方法的示例。

from pandas import Series
from matplotlib import pyplot
series = Series.from_csv('daily-minimum-temperatures.csv', header=0)
X = series.values
diff = list()
days_in_year = 365
for i in range(days_in_year, len(X)):
	value = X[i] - X[i - days_in_year]
	diff.append(value)
pyplot.plot(diff)
pyplot.show()

运行此示例将创建一个新的季节性调整数据集并绘制结果。

区分季节调整的最低日常温度

我们的数据集（1984 年和 1988 年）有两个闰年。他们没有明确处理;这意味着 1984 年 3 月以来的观察结果偏差是错误的一天，而在 1988 年 3 月之后，抵消错误了两天。

一种选择是将代码示例更新为闰日。

另一种选择是考虑一年中任何给定时期内的温度可能稳定。也许过了几个星期。我们可以简化这个想法，并考虑一个日历月内的所有温度都是稳定的。

改进的模型可以是从前一年的相同日历月而不是同一天减去平均温度。

我们可以从数据集重采样到月平均最低温度开始。

from pandas import Series
from matplotlib import pyplot
series = Series.from_csv('daily-minimum-temperatures.csv', header=0)
resample = series.resample('M')
monthly_mean = resample.mean()
print(monthly_mean.head(13))
monthly_mean.plot()
pyplot.show()

运行此示例打印前 13 个月的平均每月最低温度。

Date
1981-01-31 17.712903
1981-02-28 17.678571
1981-03-31 13.500000
1981-04-30 12.356667
1981-05-31 9.490323
1981-06-30 7.306667
1981-07-31 7.577419
1981-08-31 7.238710
1981-09-30 10.143333
1981-10-31 10.087097
1981-11-30 11.890000
1981-12-31 13.680645
1982-01-31 16.567742

它还绘制了月度数据，清楚地显示了数据集的季节性。

最低月度温度数据集

我们可以在月度数据上测试相同的差分方法，并确认经季节性调整的数据集确实消除了年度周期。

from pandas import Series
from matplotlib import pyplot
series = Series.from_csv('daily-minimum-temperatures.csv', header=0)
resample = series.resample('M')
monthly_mean = resample.mean()
X = series.values
diff = list()
months_in_year = 12
for i in range(months_in_year, len(monthly_mean)):
	value = monthly_mean[i] - monthly_mean[i - months_in_year]
	diff.append(value)
pyplot.plot(diff)
pyplot.show()

运行该示例将创建一个新的季节性调整月度最低温度数据集，跳过第一年的数据以创建调整。然后绘制调整后的数据集。

季节性调整的最低月度温度数据集

接下来，我们可以使用上一年同月的月平均最低温度来调整每日最低温度数据集。

同样，我们只是跳过第一年的数据，但使用每月数据而不是每日数据进行更正可能是一种更稳定的方法。

from pandas import Series
from matplotlib import pyplot
series = Series.from_csv('daily-minimum-temperatures.csv', header=0)
X = series.values
diff = list()
days_in_year = 365
for i in range(days_in_year, len(X)):
	month_str = str(series.index[i].year-1)+'-'+str(series.index[i].month)
	month_mean_last_year = series[month_str].mean()
	value = X[i] - month_mean_last_year
	diff.append(value)
pyplot.plot(diff)
pyplot.show()

再次运行该示例将创建经季节性调整的数据集并绘制结果。

这个例子对前一年的每日波动很有抵抗力，并抵消了因闰年 2 月 29 日而导致的误差。

更稳定的季节性调整最低月度温度数据集

日历月的边缘提供了对温度数据可能没有意义的硬边界。

采用更灵活的方法，可以采用上一年同一天任一周的平均值，这可能是一种更好的方法。

此外，可能存在多个尺度的温度数据的季节性，可以直接或间接地进行校正，例如：

• 日级别。
• 多天等级，例如一周或几周。
• 多个周级别，例如一个月。
• 多个月级别，例如四分之一或季节。

季节性调整与建模

我们可以直接对季节性成分进行建模，然后从观测中减去它。

给定时间序列中的季节性分量可能是在一般固定的周期和幅度上的正弦波。这可以使用曲线拟合方法容易地近似。

可以构造数据集，其中正弦波的时间索引作为输入或 x 轴，并且观察作为输出或 y 轴。

例如：

Time Index, Observation
1, obs1
2, obs2
3, obs3
4, obs4
5, obs5

适合后，该模型可用于计算任何时间索引的季节性分量。

在温度数据的情况下，时间指数将是一年中的某一天。然后，我们可以估算出任何历史观测值或未来任何新观测值的一年中的季节性因素。

然后，曲线可以用作使用监督学习算法建模的新输入，或者从观察中减去以创建季节性调整的系列。

让我们首先将曲线拟合到最低每日温度数据集。 NumPy 库提供 polyfit（）函数，可用于将所选顺序的多项式拟合到数据集。

首先，我们可以创建一个时间索引（在这种情况下是一天）的数据集来观察。我们可以采用一年的数据或所有年份。理想情况下，我们会尝试两者，看看哪种模型更适合。我们还可以使用以每个值为中心的移动平均值来平滑观察。这也可能导致模型具有更好的拟合。

准备好数据集后，我们可以通过调用 polyfit（）函数来传递 x 轴值（一年中的整数日），y 轴值（温度观测值）和多项式的阶数来创建拟合。该顺序控制术语的数量，进而控制用于拟合数据的曲线的复杂性。

理想情况下，我们需要最简单的曲线来描述数据集的季节性。对于一致的正弦波式季节性，四阶或五阶多项式就足够了。

在这种情况下，我通过反复试验选择了 4 的订单。生成的模型采用以下形式：

y = x⁴*b1 + x³*b2 + x²*b3 + x¹*b4 + b5

其中y是拟合值，x是时间指数（一年中的某一天），b1到b5是系数通过曲线拟合优化算法找到。

一旦适合，我们将有一组代表我们模型的系数。然后，我们可以使用此模型计算一个观测值，一年观测值或整个数据集的曲线。

下面列出了完整的示例。

from pandas import Series
from matplotlib import pyplot
from numpy import polyfit
series = Series.from_csv('daily-minimum-temperatures.csv', header=0)
# fit polynomial: x²*b1 + x*b2 + ... + bn
X = [i%365 for i in range(0, len(series))]
y = series.values
degree = 4
coef = polyfit(X, y, degree)
print('Coefficients: %s' % coef)
# create curve
curve = list()
for i in range(len(X)):
	value = coef[-1]
	for d in range(degree):
		value += X[i]**(degree-d) * coef[d]
	curve.append(value)
# plot curve over original data
pyplot.plot(series.values)
pyplot.plot(curve, color='red', linewidth=3)
pyplot.show()

运行该示例将创建数据集，拟合曲线，预测数据集中每天的值，然后将生成的季节性模型（红色）绘制在原始数据集的顶部（蓝色）。

该模型的一个限制是它没有考虑闰日，增加了小的偏移噪声，可以通过更新方法轻松纠正。

例如，我们可以在创建季节性模型时从数据集中删除 2 月 29 日的两个观测值。

曲线拟合日最低温度的季节模型

该曲线似乎非常适合数据集中的季节性结构。

我们现在可以使用此模型创建季节性调整的数据集版本。

下面列出了完整的示例。

from pandas import Series
from matplotlib import pyplot
from numpy import polyfit
series = Series.from_csv('daily-minimum-temperatures.csv', header=0)
# fit polynomial: x²*b1 + x*b2 + ... + bn
X = [i%365 for i in range(0, len(series))]
y = series.values
degree = 4
coef = polyfit(X, y, degree)
print('Coefficients: %s' % coef)
# create curve
curve = list()
for i in range(len(X)):
	value = coef[-1]
	for d in range(degree):
		value += X[i]**(degree-d) * coef[d]
	curve.append(value)
# create seasonally adjusted
values = series.values
diff = list()
for i in range(len(values)):
	value = values[i] - curve[i]
	diff.append(value)
pyplot.plot(diff)
pyplot.show()

运行该示例从原始观察中减去季节性模型预测的值。该

然后绘制经季节性调整的数据集。

曲线拟合季节调整的每日最低温度

摘要

在本教程中，您了解了如何在 Python 中创建经季节性调整的时间序列数据集。

具体来说，你学到了：

• 时间序列中季节性的重要性以及它提供的数据准备和特征工程的机会。
• 如何使用差异方法创建季节性调整的时间序列。
• 如何直接对季节性成分进行建模并从观测中减去它。

您对延迟时间序列或关于这篇文章有任何疑问吗？
在下面的评论中提出您的问题，我会尽力回答。