# 如何在 Python 中进行时间序列预测的网格搜索三次指数平滑
> 原文： [https://machinelearningmastery.com/how-to-grid-search-triple-exponential-smoothing-for-time-series-forecasting-in-python/](https://machinelearningmastery.com/how-to-grid-search-triple-exponential-smoothing-for-time-series-forecasting-in-python/)
指数平滑是单变量数据的时间序列预测方法，可以扩展为支持具有系统趋势或季节性成分的数据。
通常的做法是使用优化过程来查找模型超参数，这些参数导致指数平滑模型具有给定时间序列数据集的最佳表现。此实践仅适用于模型用于描述水平，趋势和季节性的指数结构的系数。
还可以自动优化指数平滑模型的其他超参数，例如是否对趋势和季节性分量建模，如果是，是否使用加法或乘法方法对它们进行建模。
在本教程中，您将了解如何开发一个框架，用于网格搜索所有指数平滑模型超参数，以进行单变量时间序列预测。
完成本教程后，您将了解：
* 如何使用前向验证从头开始开发网格搜索 ETS 模型的框架。
* 如何为女性出生日常时间序列数据网格搜索 ETS 模型超参数。
* 如何针对洗发水销售，汽车销售和温度的月度时间序列数据网格搜索 ETS 模型超参数。
让我们开始吧。
* **Oct8 / 2018** ：更新了 ETS 模型的拟合，以使用 NumPy 阵列修复乘法趋势/季节性问题（感谢 Amit Amola）。
如何在 Python 中进行时间序列预测的网格搜索三次指数平滑
照片由 [john mcsporran](https://www.flickr.com/photos/127130111@N06/16375806988/) 拍摄，保留一些权利。
## 教程概述
本教程分为六个部分;他们是：
1. 时间序列预测的指数平滑
2. 开发网格搜索框架
3. 案例研究 1：没有趋势或季节性
4. 案例研究 2：趋势
5. 案例研究 3：季节性
6. 案例研究 4：趋势和季节性
## 时间序列预测的指数平滑
指数平滑是单变量数据的时间序列预测方法。
像 Box-Jenkins ARIMA 系列方法这样的时间序列方法开发了一种模型，其中预测是近期过去观察或滞后的加权线性和。
指数平滑预测方法的类似之处在于预测是过去观察的加权和，但模型明确地使用指数减小的权重用于过去的观察。
具体而言，过去的观察以几何减小的比率加权。
> 使用指数平滑方法产生的预测是过去观测的加权平均值，随着观测结果的变化，权重呈指数衰减。换句话说，观察越近，相关重量越高。
- 第 171 页，[预测：原则和实践](https://amzn.to/2xlJsfV)，2013。
指数平滑方法可以被视为对等，并且是流行的 Box-Jenkins ARIMA 类时间序列预测方法的替代方法。
总的来说，这些方法有时被称为 ETS 模型，参考 _ 错误 _，_ 趋势 _ 和 _ 季节性 _ 的显式建模。
指数平滑有三种类型;他们是：
* **单指数平滑**或 SES，用于没有趋势或季节性的单变量数据。
* **双指数平滑**用于支持趋势的单变量数据。
* **三重指数平滑**，或 Holt-Winters 指数平滑，支持趋势和季节性。
三指数平滑模型通过趋势性质（加法，乘法或无）的性质和季节性的性质（加法，乘法或无）来表示单指数和双指数平滑，以及任何阻尼趋势。
## 开发网格搜索框架
在本节中，我们将为给定的单变量时间序列预测问题开发一个网格搜索指数平滑模型超参数的框架。
我们将使用 statsmodels 库提供的 [Holt-Winters 指数平滑](http://www.statsmodels.org/dev/generated/statsmodels.tsa.holtwinters.ExponentialSmoothing.html)的实现。
该模型具有超参数，可控制为系列，趋势和季节性执行的指数的性质，具体为：
* **smoothing_level** （ _alpha_ ）：该级别的平滑系数。
* **smoothing_slope** （ _beta_ ）：趋势的平滑系数。
* **smoothing_seasonal** （ _gamma_ ）：季节性成分的平滑系数。
* **damping_slope** （ _phi_ ）：阻尼趋势的系数。
在定义模型时，可以指定所有这四个超参数。如果未指定它们，库将自动调整模型并找到这些超参数的最佳值（例如 _optimized = True_ ）。
还有其他超参数，模型不会自动调整您可能想要指定的;他们是：
* **趋势**：趋势分量的类型，作为加法的“_ 加 _”或乘法的“ _mul_ ”。可以通过将趋势设置为“无”来禁用对趋势建模。
* **阻尼**：趋势分量是否应该被阻尼，无论是真还是假。
* **季节性**：季节性成分的类型，为“_ 添加 _”为添加剂或“ _mul_ ”为乘法。可以通过将季节性组件设置为“无”来禁用它。
* **seasonal_periods** ：季节性时间段内的时间步数，例如在一年一度的季节性结构中 12 个月 12 个月。
* **use_boxcox** ：是否执行系列的幂变换（True / False）或指定变换的 lambda。
如果您对问题了解得足以指定其中一个或多个参数，则应指定它们。如果没有，您可以尝试网格搜索这些参数。
我们可以通过定义一个适合具有给定配置的模型的函数来开始，并进行一步预测。
下面的 _exp_smoothing_forecast（）_ 实现了这种行为。
该函数采用连续先前观察的数组或列表以及用于配置模型的配置参数列表。
配置参数依次为：趋势类型，阻尼类型，季节性类型，季节周期，是否使用 Box-Cox 变换，以及在拟合模型时是否消除偏差。
```py
# one-step Holt Winter's Exponential Smoothing forecast
def exp_smoothing_forecast(history, config):
t,d,s,p,b,r = config
# define model model
history = array(history)
model = ExponentialSmoothing(history, trend=t, damped=d, seasonal=s, seasonal_periods=p)
# fit model
model_fit = model.fit(optimized=True, use_boxcox=b, remove_bias=r)
# make one step forecast
yhat = model_fit.predict(len(history), len(history))
return yhat[0]
```
接下来，我们需要建立一些函数，通过[前向验证](https://machinelearningmastery.com/backtest-machine-learning-models-time-series-forecasting/)重复拟合和评估模型，包括将数据集拆分为训练和测试集并评估一步预测。
我们可以使用给定指定大小的分割的切片来分割列表或 NumPy 数据数组，例如，从测试集中的数据中使用的时间步数。
下面的 _train_test_split（）_ 函数为提供的数据集和要在测试集中使用的指定数量的时间步骤实现此功能。
```py
# split a univariate dataset into train/test sets
def train_test_split(data, n_test):
return data[:-n_test], data[-n_test:]
```
在对测试数据集中的每个步骤进行预测之后，需要将它们与测试集进行比较以计算错误分数。
时间序列预测有许多流行的错误分数。在这种情况下，我们将使用均方根误差（RMSE），但您可以将其更改为您的首选度量，例如 MAPE，MAE 等
下面的 _measure_rmse（）_ 函数将根据实际（测试集）和预测值列表计算 RMSE。
```py
# root mean squared error or rmse
def measure_rmse(actual, predicted):
return sqrt(mean_squared_error(actual, predicted))
```
我们现在可以实现前向验证方案。这是评估尊重观测时间顺序的时间序列预测模型的标准方法。
首先，使用 _train_test_split（）_ 函数将提供的单变量时间序列数据集分成训练集和测试集。然后枚举测试集中的观察数。对于每一个，我们在所有历史记录中拟合模型并进行一步预测。然后将对时间步骤的真实观察添加到历史中，并重复该过程。调用 _exp_smoothing_forecast（）_ 函数以适合模型并进行预测。最后，通过调用 _measure_rmse（）_ 函数，将所有一步预测与实际测试集进行比较，计算错误分数。
下面的 _walk_forward_validation（）_ 函数实现了这一点，采用了单变量时间序列，在测试集中使用的一些时间步骤，以及一组模型配置。
```py
# walk-forward validation for univariate data
def walk_forward_validation(data, n_test, cfg):
predictions = list()
# split dataset
train, test = train_test_split(data, n_test)
# seed history with training dataset
history = [x for x in train]
# step over each time-step in the test set
for i in range(len(test)):
# fit model and make forecast for history
yhat = exp_smoothing_forecast(history, cfg)
# store forecast in list of predictions
predictions.append(yhat)
# add actual observation to history for the next loop
history.append(test[i])
# estimate prediction error
error = measure_rmse(test, predictions)
return error
```
如果您对进行多步预测感兴趣，可以在 _exp_smoothing_forecast（）_ 函数中更改 _predict（）_ 的调用，并更改 _ 中的错误计算 measure_rmse（）_ 功能。
我们可以使用不同的模型配置列表重复调用 _walk_forward_validation（）_。
一个可能的问题是，可能不会为模型调用模型配置的某些组合，并且会抛出异常，例如，指定数据中季节性结构的一些但不是所有方面。
此外，某些型号还可能会对某些数据发出警告，例如：来自 statsmodels 库调用的线性代数库。
我们可以在网格搜索期间捕获异常并忽略警告，方法是将所有调用包含在 _walk_forward_validation（）_ 中，并使用 try-except 和 block 来忽略警告。我们还可以添加调试支持来禁用这些保护，以防我们想要查看实际情况。最后，如果确实发生错误，我们可以返回 _ 无 _ 结果;否则，我们可以打印一些关于评估的每个模型的技能的信息。当评估大量模型时，这很有用。
下面的 _score_model（）_ 函数实现了这个并返回（键和结果）的元组，其中键是测试模型配置的字符串版本。
```py
# score a model, return None on failure
def score_model(data, n_test, cfg, debug=False):
result = None
# convert config to a key
key = str(cfg)
# show all warnings and fail on exception if debugging
if debug:
result = walk_forward_validation(data, n_test, cfg)
else:
# one failure during model validation suggests an unstable config
try:
# never show warnings when grid searching, too noisy
with catch_warnings():
filterwarnings("ignore")
result = walk_forward_validation(data, n_test, cfg)
except:
error = None
# check for an interesting result
if result is not None:
print(' > Model[%s] %.3f' % (key, result))
return (key, result)
```
接下来，我们需要一个循环来测试不同模型配置的列表。
这是驱动网格搜索过程的主要功能，并将为每个模型配置调用 _score_model（）_ 函数。
通过并行评估模型配置，我们可以大大加快网格搜索过程。一种方法是使用 [Joblib 库](https://pythonhosted.org/joblib/)。
我们可以定义一个 _Parallel_ 对象，其中包含要使用的核心数，并将其设置为硬件中检测到的 CPU 核心数。
```py
executor = Parallel(n_jobs=cpu_count(), backend='multiprocessing')
```
然后我们可以创建一个并行执行的任务列表，这将是对我们拥有的每个模型配置的 _score_model（）_ 函数的一次调用。
```py
tasks = (delayed(score_model)(data, n_test, cfg) for cfg in cfg_list)
```
最后，我们可以使用 _Parallel_ 对象并行执行任务列表。
```py
scores = executor(tasks)
```
而已。
我们还可以提供评估所有模型配置的非并行版本，以防我们想要调试某些内容。
```py
scores = [score_model(data, n_test, cfg) for cfg in cfg_list]
```
评估配置列表的结果将是元组列表，每个元组都有一个名称，该名称总结了特定的模型配置，并且使用该配置评估的模型的错误为 RMSE，如果出现错误则为 None。
我们可以使用“无”过滤掉所有分数。
```py
scores = [r for r in scores if r[1] != None]
```
然后我们可以按照升序排列列表中的所有元组（最好是第一个），然后返回此分数列表以供审阅。
给定单变量时间序列数据集，模型配置列表（列表列表）以及在测试集中使用的时间步数，下面的 _grid_search（）_ 函数实现此行为。可选的并行参数允许对所有内核的模型进行开启或关闭调整，默认情况下处于打开状态。
```py
# grid search configs
def grid_search(data, cfg_list, n_test, parallel=True):
scores = None
if parallel:
# execute configs in parallel
executor = Parallel(n_jobs=cpu_count(), backend='multiprocessing')
tasks = (delayed(score_model)(data, n_test, cfg) for cfg in cfg_list)
scores = executor(tasks)
else:
scores = [score_model(data, n_test, cfg) for cfg in cfg_list]
# remove empty results
scores = [r for r in scores if r[1] != None]
# sort configs by error, asc
scores.sort(key=lambda tup: tup[1])
return scores
```
我们差不多完成了。
剩下要做的唯一事情是定义模型配置列表以尝试数据集。
我们可以一般地定义它。我们可能想要指定的唯一参数是系列中季节性组件的周期性（如果存在）。默认情况下，我们假设没有季节性组件。
下面的 _exp_smoothing_configs（）_ 函数将创建要评估的模型配置列表。
可以指定季节性时段的可选列表，您甚至可以更改该功能以指定您可能了解的有关时间序列的其他元素。
从理论上讲，有 72 种可能的模型配置需要评估，但在实践中，许多模型配置无效并会导致我们将陷入和忽略的错误。
```py
# create a set of exponential smoothing configs to try
def exp_smoothing_configs(seasonal=[None]):
models = list()
# define config lists
t_params = ['add', 'mul', None]
d_params = [True, False]
s_params = ['add', 'mul', None]
p_params = seasonal
b_params = [True, False]
r_params = [True, False]
# create config instances
for t in t_params:
for d in d_params:
for s in s_params:
for p in p_params:
for b in b_params:
for r in r_params:
cfg = [t,d,s,p,b,r]
models.append(cfg)
return models
```
我们现在有一个网格搜索三重指数平滑模型超参数的框架，通过一步前进验证。
它是通用的，适用于作为列表或 NumPy 数组提供的任何内存中单变量时间序列。
我们可以通过在人为设计的 10 步数据集上进行测试来确保所有部分协同工作。
下面列出了完整的示例。
```py
# grid search holt winter's exponential smoothing
from math import sqrt
from multiprocessing import cpu_count
from joblib import Parallel
from joblib import delayed
from warnings import catch_warnings
from warnings import filterwarnings
from statsmodels.tsa.holtwinters import ExponentialSmoothing
from sklearn.metrics import mean_squared_error
from numpy import array
# one-step Holt Winter’s Exponential Smoothing forecast
def exp_smoothing_forecast(history, config):
t,d,s,p,b,r = config
# define model
history = array(history)
model = ExponentialSmoothing(history, trend=t, damped=d, seasonal=s, seasonal_periods=p)
# fit model
model_fit = model.fit(optimized=True, use_boxcox=b, remove_bias=r)
# make one step forecast
yhat = model_fit.predict(len(history), len(history))
return yhat[0]
# root mean squared error or rmse
def measure_rmse(actual, predicted):
return sqrt(mean_squared_error(actual, predicted))
# split a univariate dataset into train/test sets
def train_test_split(data, n_test):
return data[:-n_test], data[-n_test:]
# walk-forward validation for univariate data
def walk_forward_validation(data, n_test, cfg):
predictions = list()
# split dataset
train, test = train_test_split(data, n_test)
# seed history with training dataset
history = [x for x in train]
# step over each time-step in the test set
for i in range(len(test)):
# fit model and make forecast for history
yhat = exp_smoothing_forecast(history, cfg)
# store forecast in list of predictions
predictions.append(yhat)
# add actual observation to history for the next loop
history.append(test[i])
# estimate prediction error
error = measure_rmse(test, predictions)
return error
# score a model, return None on failure
def score_model(data, n_test, cfg, debug=False):
result = None
# convert config to a key
key = str(cfg)
# show all warnings and fail on exception if debugging
if debug:
result = walk_forward_validation(data, n_test, cfg)
else:
# one failure during model validation suggests an unstable config
try:
# never show warnings when grid searching, too noisy
with catch_warnings():
filterwarnings("ignore")
result = walk_forward_validation(data, n_test, cfg)
except:
error = None
# check for an interesting result
if result is not None:
print(' > Model[%s] %.3f' % (key, result))
return (key, result)
# grid search configs
def grid_search(data, cfg_list, n_test, parallel=True):
scores = None
if parallel:
# execute configs in parallel
executor = Parallel(n_jobs=cpu_count(), backend='multiprocessing')
tasks = (delayed(score_model)(data, n_test, cfg) for cfg in cfg_list)
scores = executor(tasks)
else:
scores = [score_model(data, n_test, cfg) for cfg in cfg_list]
# remove empty results
scores = [r for r in scores if r[1] != None]
# sort configs by error, asc
scores.sort(key=lambda tup: tup[1])
return scores
# create a set of exponential smoothing configs to try
def exp_smoothing_configs(seasonal=[None]):
models = list()
# define config lists
t_params = ['add', 'mul', None]
d_params = [True, False]
s_params = ['add', 'mul', None]
p_params = seasonal
b_params = [True, False]
r_params = [True, False]
# create config instances
for t in t_params:
for d in d_params:
for s in s_params:
for p in p_params:
for b in b_params:
for r in r_params:
cfg = [t,d,s,p,b,r]
models.append(cfg)
return models
if __name__ == '__main__':
# define dataset
data = [10.0, 20.0, 30.0, 40.0, 50.0, 60.0, 70.0, 80.0, 90.0, 100.0]
print(data)
# data split
n_test = 4
# model configs
cfg_list = exp_smoothing_configs()
# grid search
scores = grid_search(data, cfg_list, n_test)
print('done')
# list top 3 configs
for cfg, error in scores[:3]:
print(cfg, error)
```
首先运行该示例打印设计的时间序列数据集。
接下来，在评估模型配置及其错误时报告它们。
最后，报告前三种配置的配置和错误。
```py
[10.0, 20.0, 30.0, 40.0, 50.0, 60.0, 70.0, 80.0, 90.0, 100.0]
> Model[[None, False, None, None, True, True]] 1.380
> Model[[None, False, None, None, True, False]] 10.000
> Model[[None, False, None, None, False, True]] 2.563
> Model[[None, False, None, None, False, False]] 10.000
done
[None, False, None, None, True, True] 1.379824445857423
[None, False, None, None, False, True] 2.5628662672606612
[None, False, None, None, False, False] 10.0
```
我们不报告模型本身优化的模型参数。假设您可以通过指定更广泛的超参数来再次获得相同的结果，并允许库找到相同的内部参数。
您可以通过重新配置具有相同配置的独立模型并在模型拟合上打印' _params_ '属性的内容来访问这些内部参数;例如：
```py
print(model_fit.params)
```
现在我们有了一个强大的网格搜索框架来搜索 ETS 模型超参数，让我们在一套标准的单变量时间序列数据集上进行测试。
选择数据集用于演示目的;我并不是说 ETS 模型是每个数据集的最佳方法，在某些情况下，SARIMA 或其他东西可能更合适。
## 案例研究 1：没有趋势或季节性
“每日女性分娩”数据集总结了 1959 年美国加利福尼亚州每日女性总分娩数。
数据集没有明显的趋势或季节性成分。
每日女性出生数据集的线图
您可以从 [DataMarket](https://datamarket.com/data/set/235k/daily-total-female-births-in-california-1959#!ds=235k&display=line) 了解有关数据集的更多信息。
直接从这里下载数据集：
* [每日总数 - 女性分娩.sv](https://raw.githubusercontent.com/jbrownlee/Datasets/master/daily-total-female-births.csv)
在当前工作目录中使用文件名“ _daily-total-female-births.csv_ ”保存文件。
我们可以使用函数 _read_csv（）_ 将此数据集作为 Pandas 系列加载。
```py
series = read_csv('daily-total-female-births.csv', header=0, index_col=0)
```
数据集有一年或 365 个观测值。我们将使用前 200 个进行训练，将剩余的 165 个作为测试集。
下面列出了搜索每日女性单变量时间序列预测问题的完整示例网格。
```py
# grid search ets models for daily female births
from math import sqrt
from multiprocessing import cpu_count
from joblib import Parallel
from joblib import delayed
from warnings import catch_warnings
from warnings import filterwarnings
from statsmodels.tsa.holtwinters import ExponentialSmoothing
from sklearn.metrics import mean_squared_error
from pandas import read_csv
from numpy import array
# one-step Holt Winter’s Exponential Smoothing forecast
def exp_smoothing_forecast(history, config):
t,d,s,p,b,r = config
# define model
history = array(history)
model = ExponentialSmoothing(history, trend=t, damped=d, seasonal=s, seasonal_periods=p)
# fit model
model_fit = model.fit(optimized=True, use_boxcox=b, remove_bias=r)
# make one step forecast
yhat = model_fit.predict(len(history), len(history))
return yhat[0]
# root mean squared error or rmse
def measure_rmse(actual, predicted):
return sqrt(mean_squared_error(actual, predicted))
# split a univariate dataset into train/test sets
def train_test_split(data, n_test):
return data[:-n_test], data[-n_test:]
# walk-forward validation for univariate data
def walk_forward_validation(data, n_test, cfg):
predictions = list()
# split dataset
train, test = train_test_split(data, n_test)
# seed history with training dataset
history = [x for x in train]
# step over each time-step in the test set
for i in range(len(test)):
# fit model and make forecast for history
yhat = exp_smoothing_forecast(history, cfg)
# store forecast in list of predictions
predictions.append(yhat)
# add actual observation to history for the next loop
history.append(test[i])
# estimate prediction error
error = measure_rmse(test, predictions)
return error
# score a model, return None on failure
def score_model(data, n_test, cfg, debug=False):
result = None
# convert config to a key
key = str(cfg)
# show all warnings and fail on exception if debugging
if debug:
result = walk_forward_validation(data, n_test, cfg)
else:
# one failure during model validation suggests an unstable config
try:
# never show warnings when grid searching, too noisy
with catch_warnings():
filterwarnings("ignore")
result = walk_forward_validation(data, n_test, cfg)
except:
error = None
# check for an interesting result
if result is not None:
print(' > Model[%s] %.3f' % (key, result))
return (key, result)
# grid search configs
def grid_search(data, cfg_list, n_test, parallel=True):
scores = None
if parallel:
# execute configs in parallel
executor = Parallel(n_jobs=cpu_count(), backend='multiprocessing')
tasks = (delayed(score_model)(data, n_test, cfg) for cfg in cfg_list)
scores = executor(tasks)
else:
scores = [score_model(data, n_test, cfg) for cfg in cfg_list]
# remove empty results
scores = [r for r in scores if r[1] != None]
# sort configs by error, asc
scores.sort(key=lambda tup: tup[1])
return scores
# create a set of exponential smoothing configs to try
def exp_smoothing_configs(seasonal=[None]):
models = list()
# define config lists
t_params = ['add', 'mul', None]
d_params = [True, False]
s_params = ['add', 'mul', None]
p_params = seasonal
b_params = [True, False]
r_params = [True, False]
# create config instances
for t in t_params:
for d in d_params:
for s in s_params:
for p in p_params:
for b in b_params:
for r in r_params:
cfg = [t,d,s,p,b,r]
models.append(cfg)
return models
if __name__ == '__main__':
# load dataset
series = read_csv('daily-total-female-births.csv', header=0, index_col=0)
data = series.values
# data split
n_test = 165
# model configs
cfg_list = exp_smoothing_configs()
# grid search
scores = grid_search(data[:,0], cfg_list, n_test)
print('done')
# list top 3 configs
for cfg, error in scores[:3]:
print(cfg, error)
```
运行该示例可能需要几分钟，因为在现代硬件上安装每个 ETS 模型大约需要一分钟。
在评估模型时打印模型配置和 RMSE 在运行结束时报告前三个模型配置及其错误。
我们可以看到最好的结果是大约 6.96 个出生的 RMSE，具有以下配置：
* **趋势**：乘法
* **阻尼**：错误
* **季节性**：无
* **季节性时期**：无
* **Box-Cox 变换**：是的
* **删除偏差**：是的
令人惊讶的是，假设乘法趋势的模型比不具有乘法趋势的模型表现得更好。
除非我们抛弃假设和网格搜索模型，否则我们不会知道情况就是这样。
```py
> Model[['add', False, None, None, True, True]] 7.081
> Model[['add', False, None, None, True, False]] 7.113
> Model[['add', False, None, None, False, True]] 7.112
> Model[['add', False, None, None, False, False]] 7.115
> Model[['add', True, None, None, True, True]] 7.118
> Model[['add', True, None, None, True, False]] 7.170
> Model[['add', True, None, None, False, True]] 7.113
> Model[['add', True, None, None, False, False]] 7.126
> Model[['mul', True, None, None, True, True]] 7.118
> Model[['mul', True, None, None, True, False]] 7.170
> Model[['mul', True, None, None, False, True]] 7.113
> Model[['mul', True, None, None, False, False]] 7.126
> Model[['mul', False, None, None, True, True]] 6.961
> Model[['mul', False, None, None, True, False]] 6.985
> Model[[None, False, None, None, True, True]] 7.169
> Model[[None, False, None, None, True, False]] 7.212
> Model[[None, False, None, None, False, True]] 7.117
> Model[[None, False, None, None, False, False]] 7.126
done
['mul', False, None, None, True, True] 6.960703917145126
['mul', False, None, None, True, False] 6.984513598720297
['add', False, None, None, True, True] 7.081359856193836
```
## 案例研究 2：趋势
“洗发水”数据集总结了三年内洗发水的月销售额。
数据集包含明显的趋势，但没有明显的季节性成分。
月度洗发水销售数据集的线图
您可以从 [DataMarket](https://datamarket.com/data/set/22r0/sales-of-shampoo-over-a-three-year-period#!ds=22r0&display=line) 了解有关数据集的更多信息。
直接从这里下载数据集：
* [shampoo.csv](https://raw.githubusercontent.com/jbrownlee/Datasets/master/shampoo.csv)
在当前工作目录中使用文件名“shampoo.csv”保存文件。
我们可以使用函数 _read_csv（）_ 将此数据集作为 Pandas 系列加载。
```py
# parse dates
def custom_parser(x):
return datetime.strptime('195'+x, '%Y-%m')
# load dataset
series = read_csv('shampoo.csv', header=0, index_col=0, date_parser=custom_parser)
```
数据集有三年，或 36 个观测值。我们将使用前 24 个用于训练，其余 12 个用作测试集。
下面列出了搜索洗发水销售单变量时间序列预测问题的完整示例网格。
```py
# grid search ets models for monthly shampoo sales
from math import sqrt
from multiprocessing import cpu_count
from joblib import Parallel
from joblib import delayed
from warnings import catch_warnings
from warnings import filterwarnings
from statsmodels.tsa.holtwinters import ExponentialSmoothing
from sklearn.metrics import mean_squared_error
from pandas import read_csv
from numpy import array
# one-step Holt Winter’s Exponential Smoothing forecast
def exp_smoothing_forecast(history, config):
t,d,s,p,b,r = config
# define model
history = array(history)
model = ExponentialSmoothing(history, trend=t, damped=d, seasonal=s, seasonal_periods=p)
# fit model
model_fit = model.fit(optimized=True, use_boxcox=b, remove_bias=r)
# make one step forecast
yhat = model_fit.predict(len(history), len(history))
return yhat[0]
# root mean squared error or rmse
def measure_rmse(actual, predicted):
return sqrt(mean_squared_error(actual, predicted))
# split a univariate dataset into train/test sets
def train_test_split(data, n_test):
return data[:-n_test], data[-n_test:]
# walk-forward validation for univariate data
def walk_forward_validation(data, n_test, cfg):
predictions = list()
# split dataset
train, test = train_test_split(data, n_test)
# seed history with training dataset
history = [x for x in train]
# step over each time-step in the test set
for i in range(len(test)):
# fit model and make forecast for history
yhat = exp_smoothing_forecast(history, cfg)
# store forecast in list of predictions
predictions.append(yhat)
# add actual observation to history for the next loop
history.append(test[i])
# estimate prediction error
error = measure_rmse(test, predictions)
return error
# score a model, return None on failure
def score_model(data, n_test, cfg, debug=False):
result = None
# convert config to a key
key = str(cfg)
# show all warnings and fail on exception if debugging
if debug:
result = walk_forward_validation(data, n_test, cfg)
else:
# one failure during model validation suggests an unstable config
try:
# never show warnings when grid searching, too noisy
with catch_warnings():
filterwarnings("ignore")
result = walk_forward_validation(data, n_test, cfg)
except:
error = None
# check for an interesting result
if result is not None:
print(' > Model[%s] %.3f' % (key, result))
return (key, result)
# grid search configs
def grid_search(data, cfg_list, n_test, parallel=True):
scores = None
if parallel:
# execute configs in parallel
executor = Parallel(n_jobs=cpu_count(), backend='multiprocessing')
tasks = (delayed(score_model)(data, n_test, cfg) for cfg in cfg_list)
scores = executor(tasks)
else:
scores = [score_model(data, n_test, cfg) for cfg in cfg_list]
# remove empty results
scores = [r for r in scores if r[1] != None]
# sort configs by error, asc
scores.sort(key=lambda tup: tup[1])
return scores
# create a set of exponential smoothing configs to try
def exp_smoothing_configs(seasonal=[None]):
models = list()
# define config lists
t_params = ['add', 'mul', None]
d_params = [True, False]
s_params = ['add', 'mul', None]
p_params = seasonal
b_params = [True, False]
r_params = [True, False]
# create config instances
for t in t_params:
for d in d_params:
for s in s_params:
for p in p_params:
for b in b_params:
for r in r_params:
cfg = [t,d,s,p,b,r]
models.append(cfg)
return models
if __name__ == '__main__':
# load dataset
series = read_csv('shampoo.csv', header=0, index_col=0)
data = series.values
# data split
n_test = 12
# model configs
cfg_list = exp_smoothing_configs()
# grid search
scores = grid_search(data[:,0], cfg_list, n_test)
print('done')
# list top 3 configs
for cfg, error in scores[:3]:
print(cfg, error)
```
鉴于存在少量观察，运行该示例很快。
在评估模型时打印模型配置和 RMSE。在运行结束时报告前三个模型配置及其错误。
我们可以看到最好的结果是 RMSE 约为 83.74 销售，具有以下配置：
* **趋势**：乘法
* **阻尼**：错误
* **季节性**：无
* **季节性时期**：无
* **Box-Cox 变换**：错误
* **删除偏差**：错误
```py
> Model[['add', False, None, None, False, True]] 106.431
> Model[['add', False, None, None, False, False]] 104.874
> Model[['add', True, None, None, False, False]] 103.069
> Model[['add', True, None, None, False, True]] 97.918
> Model[['mul', True, None, None, False, True]] 95.337
> Model[['mul', True, None, None, False, False]] 102.152
> Model[['mul', False, None, None, False, True]] 86.406
> Model[['mul', False, None, None, False, False]] 83.747
> Model[[None, False, None, None, False, True]] 99.416
> Model[[None, False, None, None, False, False]] 108.031
done
['mul', False, None, None, False, False] 83.74666940175238
['mul', False, None, None, False, True] 86.40648953786152
['mul', True, None, None, False, True] 95.33737598817238
```
## 案例研究 3：季节性
“月平均温度”数据集总结了 1920 至 1939 年华氏诺丁汉城堡的月平均气温，以华氏度为单位。
数据集具有明显的季节性成分，没有明显的趋势。
月平均气温数据集的线图
您可以从 [DataMarket](https://datamarket.com/data/set/22li/mean-monthly-air-temperature-deg-f-nottingham-castle-1920-1939#!ds=22li&display=line) 了解有关数据集的更多信息。
直接从这里下载数据集：
* [monthly-mean-temp.csv](https://raw.githubusercontent.com/jbrownlee/Datasets/master/monthly-mean-temp.csv)
在当前工作目录中使用文件名“monthly-mean-temp.csv”保存文件。
我们可以使用函数 _read_csv（）_ 将此数据集作为 Pandas 系列加载。
```py
series = read_csv('monthly-mean-temp.csv', header=0, index_col=0)
```
数据集有 20 年，或 240 个观测值。
我们将数据集修剪为过去五年的数据（60 个观测值），以加快模型评估过程，并使用去年或 12 个观测值来测试集。
```py
# trim dataset to 5 years
data = data[-(5*12):]
```
季节性成分的周期约为一年，或 12 个观测值。
在准备模型配置时，我们将此作为调用 _exp_smoothing_configs（）_ 函数的季节性时段。
```py
# model configs
cfg_list = exp_smoothing_configs(seasonal=[0, 12])
```
下面列出了搜索月平均温度时间序列预测问题的完整示例网格。
```py
# grid search ets hyperparameters for monthly mean temp dataset
from math import sqrt
from multiprocessing import cpu_count
from joblib import Parallel
from joblib import delayed
from warnings import catch_warnings
from warnings import filterwarnings
from statsmodels.tsa.holtwinters import ExponentialSmoothing
from sklearn.metrics import mean_squared_error
from pandas import read_csv
from numpy import array
# one-step Holt Winter’s Exponential Smoothing forecast
def exp_smoothing_forecast(history, config):
t,d,s,p,b,r = config
# define model
history = array(history)
model = ExponentialSmoothing(history, trend=t, damped=d, seasonal=s, seasonal_periods=p)
# fit model
model_fit = model.fit(optimized=True, use_boxcox=b, remove_bias=r)
# make one step forecast
yhat = model_fit.predict(len(history), len(history))
return yhat[0]
# root mean squared error or rmse
def measure_rmse(actual, predicted):
return sqrt(mean_squared_error(actual, predicted))
# split a univariate dataset into train/test sets
def train_test_split(data, n_test):
return data[:-n_test], data[-n_test:]
# walk-forward validation for univariate data
def walk_forward_validation(data, n_test, cfg):
predictions = list()
# split dataset
train, test = train_test_split(data, n_test)
# seed history with training dataset
history = [x for x in train]
# step over each time-step in the test set
for i in range(len(test)):
# fit model and make forecast for history
yhat = exp_smoothing_forecast(history, cfg)
# store forecast in list of predictions
predictions.append(yhat)
# add actual observation to history for the next loop
history.append(test[i])
# estimate prediction error
error = measure_rmse(test, predictions)
return error
# score a model, return None on failure
def score_model(data, n_test, cfg, debug=False):
result = None
# convert config to a key
key = str(cfg)
# show all warnings and fail on exception if debugging
if debug:
result = walk_forward_validation(data, n_test, cfg)
else:
# one failure during model validation suggests an unstable config
try:
# never show warnings when grid searching, too noisy
with catch_warnings():
filterwarnings("ignore")
result = walk_forward_validation(data, n_test, cfg)
except:
error = None
# check for an interesting result
if result is not None:
print(' > Model[%s] %.3f' % (key, result))
return (key, result)
# grid search configs
def grid_search(data, cfg_list, n_test, parallel=True):
scores = None
if parallel:
# execute configs in parallel
executor = Parallel(n_jobs=cpu_count(), backend='multiprocessing')
tasks = (delayed(score_model)(data, n_test, cfg) for cfg in cfg_list)
scores = executor(tasks)
else:
scores = [score_model(data, n_test, cfg) for cfg in cfg_list]
# remove empty results
scores = [r for r in scores if r[1] != None]
# sort configs by error, asc
scores.sort(key=lambda tup: tup[1])
return scores
# create a set of exponential smoothing configs to try
def exp_smoothing_configs(seasonal=[None]):
models = list()
# define config lists
t_params = ['add', 'mul', None]
d_params = [True, False]
s_params = ['add', 'mul', None]
p_params = seasonal
b_params = [True, False]
r_params = [True, False]
# create config instances
for t in t_params:
for d in d_params:
for s in s_params:
for p in p_params:
for b in b_params:
for r in r_params:
cfg = [t,d,s,p,b,r]
models.append(cfg)
return models
if __name__ == '__main__':
# load dataset
series = read_csv('monthly-mean-temp.csv', header=0, index_col=0)
data = series.values
# trim dataset to 5 years
data = data[-(5*12):]
# data split
n_test = 12
# model configs
cfg_list = exp_smoothing_configs(seasonal=[0,12])
# grid search
scores = grid_search(data[:,0], cfg_list, n_test)
print('done')
# list top 3 configs
for cfg, error in scores[:3]:
print(cfg, error)
```
鉴于大量数据，运行示例相对较慢。
在评估模型时打印模型配置和 RMSE。在运行结束时报告前三个模型配置及其错误。
我们可以看到最好的结果是大约 1.50 度的 RMSE，具有以下配置：
* **趋势**：无
* **阻尼**：错误
* **季节性**：添加剂
* **季节性时期**：12
* **Box-Cox 变换**：错误
* **删除偏差**：错误
```py
> Model[['add', True, 'mul', 12, True, False]] 1.659
> Model[['add', True, 'mul', 12, True, True]] 1.663
> Model[['add', True, 'mul', 12, False, True]] 1.603
> Model[['add', True, 'mul', 12, False, False]] 1.609
> Model[['mul', False, None, 0, True, True]] 4.920
> Model[['mul', False, None, 0, True, False]] 4.881
> Model[['mul', False, None, 0, False, True]] 4.838
> Model[['mul', False, None, 0, False, False]] 4.813
> Model[['add', True, 'add', 12, False, True]] 1.568
> Model[['mul', False, None, 12, True, True]] 4.920
> Model[['add', True, 'add', 12, False, False]] 1.555
> Model[['add', True, 'add', 12, True, False]] 1.638
> Model[['add', True, 'add', 12, True, True]] 1.646
> Model[['mul', False, None, 12, True, False]] 4.881
> Model[['mul', False, None, 12, False, True]] 4.838
> Model[['mul', False, None, 12, False, False]] 4.813
> Model[['add', True, None, 0, True, True]] 4.654
> Model[[None, False, 'add', 12, True, True]] 1.508
> Model[['add', True, None, 0, True, False]] 4.597
> Model[['add', True, None, 0, False, True]] 4.800
> Model[[None, False, 'add', 12, True, False]] 1.507
> Model[['add', True, None, 0, False, False]] 4.760
> Model[[None, False, 'add', 12, False, True]] 1.502
> Model[['add', True, None, 12, True, True]] 4.654
> Model[[None, False, 'add', 12, False, False]] 1.502
> Model[['add', True, None, 12, True, False]] 4.597
> Model[[None, False, 'mul', 12, True, True]] 1.507
> Model[['add', True, None, 12, False, True]] 4.800
> Model[[None, False, 'mul', 12, True, False]] 1.507
> Model[['add', True, None, 12, False, False]] 4.760
> Model[[None, False, 'mul', 12, False, True]] 1.502
> Model[['add', False, 'add', 12, True, True]] 1.859
> Model[[None, False, 'mul', 12, False, False]] 1.502
> Model[[None, False, None, 0, True, True]] 5.188
> Model[[None, False, None, 0, True, False]] 5.143
> Model[[None, False, None, 0, False, True]] 5.187
> Model[[None, False, None, 0, False, False]] 5.143
> Model[[None, False, None, 12, True, True]] 5.188
> Model[[None, False, None, 12, True, False]] 5.143
> Model[[None, False, None, 12, False, True]] 5.187
> Model[[None, False, None, 12, False, False]] 5.143
> Model[['add', False, 'add', 12, True, False]] 1.825
> Model[['add', False, 'add', 12, False, True]] 1.706
> Model[['add', False, 'add', 12, False, False]] 1.710
> Model[['add', False, 'mul', 12, True, True]] 1.882
> Model[['add', False, 'mul', 12, True, False]] 1.739
> Model[['add', False, 'mul', 12, False, True]] 1.580
> Model[['add', False, 'mul', 12, False, False]] 1.581
> Model[['add', False, None, 0, True, True]] 4.980
> Model[['add', False, None, 0, True, False]] 4.900
> Model[['add', False, None, 0, False, True]] 5.203
> Model[['add', False, None, 0, False, False]] 5.151
> Model[['add', False, None, 12, True, True]] 4.980
> Model[['add', False, None, 12, True, False]] 4.900
> Model[['add', False, None, 12, False, True]] 5.203
> Model[['add', False, None, 12, False, False]] 5.151
> Model[['mul', True, 'add', 12, True, True]] 19.353
> Model[['mul', True, 'add', 12, True, False]] 9.807
> Model[['mul', True, 'add', 12, False, True]] 11.696
> Model[['mul', True, 'add', 12, False, False]] 2.847
> Model[['mul', True, None, 0, True, True]] 4.607
> Model[['mul', True, None, 0, True, False]] 4.570
> Model[['mul', True, None, 0, False, True]] 4.630
> Model[['mul', True, None, 0, False, False]] 4.596
> Model[['mul', True, None, 12, True, True]] 4.607
> Model[['mul', True, None, 12, True, False]] 4.570
> Model[['mul', True, None, 12, False, True]] 4.630
> Model[['mul', True, None, 12, False, False]] 4.593
> Model[['mul', False, 'add', 12, True, True]] 4.230
> Model[['mul', False, 'add', 12, True, False]] 4.157
> Model[['mul', False, 'add', 12, False, True]] 1.538
> Model[['mul', False, 'add', 12, False, False]] 1.520
done
[None, False, 'add', 12, False, False] 1.5015527325330889
[None, False, 'add', 12, False, True] 1.5015531225114707
[None, False, 'mul', 12, False, False] 1.501561363221282
```
## 案例研究 4：趋势和季节性
“月度汽车销售”数据集总结了 1960 年至 1968 年间加拿大魁北克省的月度汽车销量。
数据集具有明显的趋势和季节性成分。
月度汽车销售数据集的线图
您可以从 [DataMarket](https://datamarket.com/data/set/22n4/monthly-car-sales-in-quebec-1960-1968#!ds=22n4&display=line) 了解有关数据集的更多信息。
直接从这里下载数据集：
* [month-car-sales.csv](https://raw.githubusercontent.com/jbrownlee/Datasets/master/monthly-car-sales.csv)
在当前工作目录中使用文件名“monthly-car-sales.csv”保存文件。
我们可以使用函数 _read_csv（）_ 将此数据集作为 Pandas 系列加载。
```py
series = read_csv('monthly-car-sales.csv', header=0, index_col=0)
```
数据集有九年，或 108 个观测值。我们将使用去年或 12 个观测值作为测试集。
季节性成分的期限可能是六个月或 12 个月。在准备模型配置时，我们将尝试将两者作为调用 _exp_smoothing_configs（）_ 函数的季节性时段。
```py
# model configs
cfg_list = exp_smoothing_configs(seasonal=[0,6,12])
```
下面列出了搜索月度汽车销售时间序列预测问题的完整示例网格。
```py
# grid search ets models for monthly car sales
from math import sqrt
from multiprocessing import cpu_count
from joblib import Parallel
from joblib import delayed
from warnings import catch_warnings
from warnings import filterwarnings
from statsmodels.tsa.holtwinters import ExponentialSmoothing
from sklearn.metrics import mean_squared_error
from pandas import read_csv
from numpy import array
# one-step Holt Winter’s Exponential Smoothing forecast
def exp_smoothing_forecast(history, config):
t,d,s,p,b,r = config
# define model
history = array(history)
model = ExponentialSmoothing(history, trend=t, damped=d, seasonal=s, seasonal_periods=p)
# fit model
model_fit = model.fit(optimized=True, use_boxcox=b, remove_bias=r)
# make one step forecast
yhat = model_fit.predict(len(history), len(history))
return yhat[0]
# root mean squared error or rmse
def measure_rmse(actual, predicted):
return sqrt(mean_squared_error(actual, predicted))
# split a univariate dataset into train/test sets
def train_test_split(data, n_test):
return data[:-n_test], data[-n_test:]
# walk-forward validation for univariate data
def walk_forward_validation(data, n_test, cfg):
predictions = list()
# split dataset
train, test = train_test_split(data, n_test)
# seed history with training dataset
history = [x for x in train]
# step over each time-step in the test set
for i in range(len(test)):
# fit model and make forecast for history
yhat = exp_smoothing_forecast(history, cfg)
# store forecast in list of predictions
predictions.append(yhat)
# add actual observation to history for the next loop
history.append(test[i])
# estimate prediction error
error = measure_rmse(test, predictions)
return error
# score a model, return None on failure
def score_model(data, n_test, cfg, debug=False):
result = None
# convert config to a key
key = str(cfg)
# show all warnings and fail on exception if debugging
if debug:
result = walk_forward_validation(data, n_test, cfg)
else:
# one failure during model validation suggests an unstable config
try:
# never show warnings when grid searching, too noisy
with catch_warnings():
filterwarnings("ignore")
result = walk_forward_validation(data, n_test, cfg)
except:
error = None
# check for an interesting result
if result is not None:
print(' > Model[%s] %.3f' % (key, result))
return (key, result)
# grid search configs
def grid_search(data, cfg_list, n_test, parallel=True):
scores = None
if parallel:
# execute configs in parallel
executor = Parallel(n_jobs=cpu_count(), backend='multiprocessing')
tasks = (delayed(score_model)(data, n_test, cfg) for cfg in cfg_list)
scores = executor(tasks)
else:
scores = [score_model(data, n_test, cfg) for cfg in cfg_list]
# remove empty results
scores = [r for r in scores if r[1] != None]
# sort configs by error, asc
scores.sort(key=lambda tup: tup[1])
return scores
# create a set of exponential smoothing configs to try
def exp_smoothing_configs(seasonal=[None]):
models = list()
# define config lists
t_params = ['add', 'mul', None]
d_params = [True, False]
s_params = ['add', 'mul', None]
p_params = seasonal
b_params = [True, False]
r_params = [True, False]
# create config instances
for t in t_params:
for d in d_params:
for s in s_params:
for p in p_params:
for b in b_params:
for r in r_params:
cfg = [t,d,s,p,b,r]
models.append(cfg)
return models
if __name__ == '__main__':
# load dataset
series = read_csv('monthly-car-sales.csv', header=0, index_col=0)
data = series.values
# data split
n_test = 12
# model configs
cfg_list = exp_smoothing_configs(seasonal=[0,6,12])
# grid search
scores = grid_search(data[:,0], cfg_list, n_test)
print('done')
# list top 3 configs
for cfg, error in scores[:3]:
print(cfg, error)
```
鉴于大量数据，运行示例很慢。
在评估模型时打印模型配置和 RMSE。在运行结束时报告前三个模型配置及其错误。
我们可以看到最好的结果是具有以下配置的约 1,672 销售额的 RMSE：
* **趋势**：添加剂
* **阻尼**：错误
* **季节性**：添加剂
* **季节性时期**：12
* **Box-Cox 变换**：错误
* **删除偏差**：是的
这有点令人惊讶，因为我猜想六个月的季节性模型将是首选方法。
```py
> Model[['add', True, 'add', 6, False, True]] 3240.433
> Model[['add', True, 'add', 6, False, False]] 3226.384
> Model[['add', True, 'add', 6, True, False]] 2836.535
> Model[['add', True, 'add', 6, True, True]] 2784.852
> Model[['add', True, 'add', 12, False, False]] 1696.173
> Model[['add', True, 'add', 12, False, True]] 1721.746
> Model[[None, False, 'add', 6, True, True]] 3204.874
> Model[['add', True, 'add', 12, True, False]] 2064.937
> Model[['add', True, 'add', 12, True, True]] 2098.844
> Model[[None, False, 'add', 6, True, False]] 3190.972
> Model[[None, False, 'add', 6, False, True]] 3147.623
> Model[[None, False, 'add', 6, False, False]] 3126.527
> Model[[None, False, 'add', 12, True, True]] 1834.910
> Model[[None, False, 'add', 12, True, False]] 1872.081
> Model[[None, False, 'add', 12, False, True]] 1736.264
> Model[[None, False, 'add', 12, False, False]] 1807.325
> Model[[None, False, 'mul', 6, True, True]] 2993.566
> Model[[None, False, 'mul', 6, True, False]] 2979.123
> Model[[None, False, 'mul', 6, False, True]] 3025.876
> Model[[None, False, 'mul', 6, False, False]] 3009.999
> Model[['add', True, 'mul', 6, True, True]] 2956.728
> Model[[None, False, 'mul', 12, True, True]] 1972.547
> Model[[None, False, 'mul', 12, True, False]] 1989.234
> Model[[None, False, 'mul', 12, False, True]] 1925.010
> Model[[None, False, 'mul', 12, False, False]] 1941.217
> Model[[None, False, None, 0, True, True]] 3801.741
> Model[[None, False, None, 0, True, False]] 3783.966
> Model[[None, False, None, 0, False, True]] 3801.560
> Model[[None, False, None, 0, False, False]] 3783.966
> Model[[None, False, None, 6, True, True]] 3801.741
> Model[[None, False, None, 6, True, False]] 3783.966
> Model[[None, False, None, 6, False, True]] 3801.560
> Model[[None, False, None, 6, False, False]] 3783.966
> Model[[None, False, None, 12, True, True]] 3801.741
> Model[[None, False, None, 12, True, False]] 3783.966
> Model[[None, False, None, 12, False, True]] 3801.560
> Model[[None, False, None, 12, False, False]] 3783.966
> Model[['add', True, 'mul', 6, True, False]] 2932.827
> Model[['mul', True, 'mul', 12, True, True]] 1953.405
> Model[['add', True, 'mul', 6, False, True]] 2997.259
> Model[['mul', True, 'mul', 12, True, False]] 1960.242
> Model[['add', True, 'mul', 6, False, False]] 2979.248
> Model[['mul', True, 'mul', 12, False, True]] 1907.792
> Model[['add', True, 'mul', 12, True, True]] 1972.550
> Model[['add', True, 'mul', 12, True, False]] 1989.236
> Model[['mul', True, None, 0, True, True]] 3951.024
> Model[['mul', True, None, 0, True, False]] 3930.394
> Model[['mul', True, None, 0, False, True]] 3947.281
> Model[['mul', True, None, 0, False, False]] 3926.082
> Model[['mul', True, None, 6, True, True]] 3951.026
> Model[['mul', True, None, 6, True, False]] 3930.389
> Model[['mul', True, None, 6, False, True]] 3946.654
> Model[['mul', True, None, 6, False, False]] 3926.026
> Model[['mul', True, None, 12, True, True]] 3951.027
> Model[['mul', True, None, 12, True, False]] 3930.368
> Model[['mul', True, None, 12, False, True]] 3942.037
> Model[['mul', True, None, 12, False, False]] 3920.756
> Model[['add', True, 'mul', 12, False, True]] 1750.480
> Model[['mul', False, 'add', 6, True, False]] 5043.557
> Model[['mul', False, 'add', 6, False, True]] 7425.711
> Model[['mul', False, 'add', 6, False, False]] 7448.455
> Model[['mul', False, 'add', 12, True, True]] 2160.794
> Model[['mul', False, 'add', 12, True, False]] 2346.478
> Model[['mul', False, 'add', 12, False, True]] 16303.868
> Model[['mul', False, 'add', 12, False, False]] 10268.636
> Model[['mul', False, 'mul', 12, True, True]] 3012.036
> Model[['mul', False, 'mul', 12, True, False]] 3005.824
> Model[['add', True, 'mul', 12, False, False]] 1774.636
> Model[['mul', False, 'mul', 12, False, True]] 14676.476
> Model[['add', True, None, 0, True, True]] 3935.674
> Model[['mul', False, 'mul', 12, False, False]] 13988.754
> Model[['mul', False, None, 0, True, True]] 3804.906
> Model[['mul', False, None, 0, True, False]] 3805.342
> Model[['mul', False, None, 0, False, True]] 3778.444
> Model[['mul', False, None, 0, False, False]] 3798.003
> Model[['mul', False, None, 6, True, True]] 3804.906
> Model[['mul', False, None, 6, True, False]] 3805.342
> Model[['mul', False, None, 6, False, True]] 3778.456
> Model[['mul', False, None, 6, False, False]] 3798.007
> Model[['add', True, None, 0, True, False]] 3915.499
> Model[['mul', False, None, 12, True, True]] 3804.906
> Model[['mul', False, None, 12, True, False]] 3805.342
> Model[['mul', False, None, 12, False, True]] 3778.457
> Model[['mul', False, None, 12, False, False]] 3797.989
> Model[['add', True, None, 0, False, True]] 3924.442
> Model[['add', True, None, 0, False, False]] 3905.627
> Model[['add', True, None, 6, True, True]] 3935.658
> Model[['add', True, None, 6, True, False]] 3913.420
> Model[['add', True, None, 6, False, True]] 3924.287
> Model[['add', True, None, 6, False, False]] 3913.618
> Model[['add', True, None, 12, True, True]] 3935.673
> Model[['add', True, None, 12, True, False]] 3913.428
> Model[['add', True, None, 12, False, True]] 3924.487
> Model[['add', True, None, 12, False, False]] 3913.529
> Model[['add', False, 'add', 6, True, True]] 3220.532
> Model[['add', False, 'add', 6, True, False]] 3199.766
> Model[['add', False, 'add', 6, False, True]] 3243.478
> Model[['add', False, 'add', 6, False, False]] 3226.955
> Model[['add', False, 'add', 12, True, True]] 1833.481
> Model[['add', False, 'add', 12, True, False]] 1833.511
> Model[['add', False, 'add', 12, False, True]] 1672.554
> Model[['add', False, 'add', 12, False, False]] 1680.845
> Model[['add', False, 'mul', 6, True, True]] 3014.447
> Model[['add', False, 'mul', 6, True, False]] 3016.207
> Model[['add', False, 'mul', 6, False, True]] 3025.870
> Model[['add', False, 'mul', 6, False, False]] 3010.015
> Model[['add', False, 'mul', 12, True, True]] 1982.087
> Model[['add', False, 'mul', 12, True, False]] 1981.089
> Model[['add', False, 'mul', 12, False, True]] 1898.045
> Model[['add', False, 'mul', 12, False, False]] 1894.397
> Model[['add', False, None, 0, True, True]] 3815.765
> Model[['add', False, None, 0, True, False]] 3813.234
> Model[['add', False, None, 0, False, True]] 3805.649
> Model[['add', False, None, 0, False, False]] 3809.864
> Model[['add', False, None, 6, True, True]] 3815.765
> Model[['add', False, None, 6, True, False]] 3813.234
> Model[['add', False, None, 6, False, True]] 3805.619
> Model[['add', False, None, 6, False, False]] 3809.846
> Model[['add', False, None, 12, True, True]] 3815.765
> Model[['add', False, None, 12, True, False]] 3813.234
> Model[['add', False, None, 12, False, True]] 3805.638
> Model[['add', False, None, 12, False, False]] 3809.837
> Model[['mul', True, 'add', 6, True, False]] 4099.032
> Model[['mul', True, 'add', 6, False, True]] 3818.567
> Model[['mul', True, 'add', 6, False, False]] 3745.142
> Model[['mul', True, 'add', 12, True, True]] 2203.354
> Model[['mul', True, 'add', 12, True, False]] 2284.172
> Model[['mul', True, 'add', 12, False, True]] 2842.605
> Model[['mul', True, 'add', 12, False, False]] 2086.899
done
['add', False, 'add', 12, False, True] 1672.5539372356582
['add', False, 'add', 12, False, False] 1680.845043013083
['add', True, 'add', 12, False, False] 1696.1734099400082
```
## 扩展
本节列出了一些扩展您可能希望探索的教程的想法。
* **数据转换**。更新框架以支持可配置的数据转换，例如规范化和标准化。
* **地块预测**。更新框架以重新拟合具有最佳配置的模型并预测整个测试数据集，然后将预测与测试集中的实际观察值进行比较。
* **调整历史数量**。更新框架以调整用于拟合模型的历史数据量（例如，在 10 年最高温度数据的情况下）。
如果你探索任何这些扩展，我很想知道。
## 进一步阅读
如果您希望深入了解，本节将提供有关该主题的更多资源。
### 图书
* 第 7 章指数平滑，[预测：原则和实践](https://amzn.to/2xlJsfV)，2013。
* 第 6.4 节。时间序列分析简介，[工程统计手册](https://www.itl.nist.gov/div898/handbook/)，2012。
* [实际时间序列预测与 R](https://amzn.to/2LGKzKm) ，2016 年。
### 蜜蜂
* [statsmodels.tsa.holtwinters.ExponentialSmoothing API](http://www.statsmodels.org/dev/generated/statsmodels.tsa.holtwinters.ExponentialSmoothing.html)
* [statsmodels.tsa.holtwinters.HoltWintersResults API](http://www.statsmodels.org/dev/generated/statsmodels.tsa.holtwinters.HoltWintersResults.html)
* [Joblib：运行 Python 函数作为管道作业](https://pythonhosted.org/joblib/)
### 用品
* [维基百科上的指数平滑](https://en.wikipedia.org/wiki/Exponential_smoothing)
## 摘要
在本教程中，您了解了如何开发一个框架，用于网格搜索所有指数平滑模型超参数，以进行单变量时间序列预测。
具体来说，你学到了：
* 如何使用前向验证从头开始开发网格搜索 ETS 模型的框架。
* 如何为出生日常时间序列数据网格搜索 ETS 模型超参数。
* 如何为洗发水销售，汽车销售和温度的月度时间序列数据网格搜索 ETS 模型超参数。
你有任何问题吗？
在下面的评论中提出您的问题，我会尽力回答。
- Machine Learning Mastery 应用机器学习教程
- 5竞争机器学习的好处
- 过度拟合的简单直觉，或者为什么测试训练数据是一个坏主意
- 特征选择简介
- 应用机器学习作为一个搜索问题的温和介绍
- 为什么应用机器学习很难
- 为什么我的结果不如我想的那么好？你可能过度拟合了
- 用ROC曲线评估和比较分类器表现
- BigML评论：发现本机学习即服务平台的聪明功能
- BigML教程：开发您的第一个决策树并进行预测
- 构建生产机器学习基础设施
- 分类准确性不够：可以使用更多表现测量
- 一种预测模型的巧妙应用
- 机器学习项目中常见的陷阱
- 数据清理：将凌乱的数据转换为整洁的数据
- 机器学习中的数据泄漏
- 数据，学习和建模
- 数据管理至关重要以及为什么需要认真对待它
- 将预测模型部署到生产中
- 参数和超参数之间有什么区别？
- 测试和验证数据集之间有什么区别？
- 发现特征工程，如何设计特征以及如何获得它
- 如何开始使用Kaggle
- 超越预测
- 如何在评估机器学习算法时选择正确的测试选项
- 如何定义机器学习问题
- 如何评估机器学习算法
- 如何获得基线结果及其重要性
- 如何充分利用机器学习数据
- 如何识别数据中的异常值
- 如何提高机器学习效果
- 如何在竞争机器学习中踢屁股
- 如何知道您的机器学习模型是否具有良好的表现
- 如何布局和管理您的机器学习项目
- 如何为机器学习准备数据
- 如何减少最终机器学习模型中的方差
- 如何使用机器学习结果
- 如何解决像数据科学家这样的问题
- 通过数据预处理提高模型精度
- 处理机器学习的大数据文件的7种方法
- 建立机器学习系统的经验教训
- 如何使用机器学习清单可靠地获得准确的预测（即使您是初学者）
- 机器学习模型运行期间要做什么
- 机器学习表现改进备忘单
- 来自世界级从业者的机器学习技巧：Phil Brierley
- 模型预测精度与机器学习中的解释
- 竞争机器学习的模型选择技巧
- 机器学习需要多少训练数据？
- 如何系统地规划和运行机器学习实验
- 应用机器学习过程
- 默认情况下可重现的机器学习结果
- 10个实践应用机器学习的标准数据集
- 简单的三步法到最佳机器学习算法
- 打击机器学习数据集中不平衡类的8种策略
- 模型表现不匹配问题（以及如何处理）
- 黑箱机器学习的诱惑陷阱
- 如何培养最终的机器学习模型
- 使用探索性数据分析了解您的问题并获得更好的结果
- 什么是数据挖掘和KDD
- 为什么One-Hot在机器学习中编码数据？
- 为什么你应该在你的机器学习问题上进行抽样检查算法
- 所以，你正在研究机器学习问题......
- Machine Learning Mastery Keras 深度学习教程
- Keras 中神经网络模型的 5 步生命周期
- 在 Python 迷你课程中应用深度学习
- Keras 深度学习库的二元分类教程
- 如何用 Keras 构建多层感知器神经网络模型
- 如何在 Keras 中检查深度学习模型
- 10 个用于 Amazon Web Services 深度学习的命令行秘籍
- 机器学习卷积神经网络的速成课程
- 如何在 Python 中使用 Keras 进行深度学习的度量
- 深度学习书籍
- 深度学习课程
- 你所知道的深度学习是一种谎言
- 如何设置 Amazon AWS EC2 GPU 以训练 Keras 深度学习模型（分步）
- 神经网络中批量和迭代之间的区别是什么？
- 在 Keras 展示深度学习模型训练历史
- 基于 Keras 的深度学习模型中的dropout正则化
- 评估 Keras 中深度学习模型的表现
- 如何评价深度学习模型的技巧
- 小批量梯度下降的简要介绍以及如何配置批量大小
- 在 Keras 中获得深度学习帮助的 9 种方法
- 如何使用 Keras 在 Python 中网格搜索深度学习模型的超参数
- 用 Keras 在 Python 中使用卷积神经网络进行手写数字识别
- 如何用 Keras 进行预测
- 用 Keras 进行深度学习的图像增强
- 8 个深度学习的鼓舞人心的应用
- Python 深度学习库 Keras 简介
- Python 深度学习库 TensorFlow 简介
- Python 深度学习库 Theano 简介
- 如何使用 Keras 函数式 API 进行深度学习
- Keras 深度学习库的多类分类教程
- 多层感知器神经网络速成课程
- 基于卷积神经网络的 Keras 深度学习库中的目标识别
- 流行的深度学习库
- 用深度学习预测电影评论的情感
- Python 中的 Keras 深度学习库的回归教程
- 如何使用 Keras 获得可重现的结果
- 如何在 Linux 服务器上运行深度学习实验
- 保存并加载您的 Keras 深度学习模型
- 用 Keras 逐步开发 Python 中的第一个神经网络
- 用 Keras 理解 Python 中的有状态 LSTM 循环神经网络
- 在 Python 中使用 Keras 深度学习模型和 Scikit-Learn
- 如何使用预训练的 VGG 模型对照片中的物体进行分类
- 在 Python 和 Keras 中对深度学习模型使用学习率调度
- 如何在 Keras 中可视化深度学习神经网络模型
- 什么是深度学习？
- 何时使用 MLP，CNN 和 RNN 神经网络
- 为什么用随机权重初始化神经网络？
- Machine Learning Mastery 深度学习 NLP 教程
- 深度学习在自然语言处理中的 7 个应用
- 如何实现自然语言处理的波束搜索解码器
- 深度学习文档分类的最佳实践
- 关于自然语言处理的热门书籍
- 在 Python 中计算文本 BLEU 分数的温和介绍
- 使用编码器 - 解码器模型的用于字幕生成的注入和合并架构
- 如何用 Python 清理机器学习的文本
- 如何配置神经机器翻译的编码器 - 解码器模型
- 如何开始深度学习自然语言处理（7 天迷你课程）
- 自然语言处理的数据集
- 如何开发一种深度学习的词袋模型来预测电影评论情感
- 深度学习字幕生成模型的温和介绍
- 如何在 Keras 中定义神经机器翻译的编码器 - 解码器序列 - 序列模型
- 如何利用小实验在 Keras 中开发字幕生成模型
- 如何从头开发深度学习图片标题生成器
- 如何在 Keras 中开发基于字符的神经语言模型
- 如何开发用于情感分析的 N-gram 多通道卷积神经网络
- 如何从零开始开发神经机器翻译系统
- 如何在 Python 中用 Keras 开发基于单词的神经语言模型
- 如何开发一种预测电影评论情感的词嵌入模型
- 如何使用 Gensim 在 Python 中开发词嵌入
- 用于文本摘要的编码器 - 解码器深度学习模型
- Keras 中文本摘要的编码器 - 解码器模型
- 用于神经机器翻译的编码器 - 解码器循环神经网络模型
- 浅谈词袋模型
- 文本摘要的温和介绍
- 编码器 - 解码器循环神经网络中的注意力如何工作
- 如何利用深度学习自动生成照片的文本描述
- 如何开发一个单词级神经语言模型并用它来生成文本
- 浅谈神经机器翻译
- 什么是自然语言处理？
- 牛津自然语言处理深度学习课程
- 如何为机器翻译准备法语到英语的数据集
- 如何为情感分析准备电影评论数据
- 如何为文本摘要准备新闻文章
- 如何准备照片标题数据集以训练深度学习模型
- 如何使用 Keras 为深度学习准备文本数据
- 如何使用 scikit-learn 为机器学习准备文本数据
- 自然语言处理神经网络模型入门
- 对自然语言处理的深度学习的承诺
- 在 Python 中用 Keras 进行 LSTM 循环神经网络的序列分类
- 斯坦福自然语言处理深度学习课程评价
- 统计语言建模和神经语言模型的简要介绍
- 使用 Keras 在 Python 中进行 LSTM 循环神经网络的文本生成
- 浅谈机器学习中的转换
- 如何使用 Keras 将词嵌入层用于深度学习
- 什么是用于文本的词嵌入
- Machine Learning Mastery 深度学习时间序列教程
- 如何开发人类活动识别的一维卷积神经网络模型
- 人类活动识别的深度学习模型
- 如何评估人类活动识别的机器学习算法
- 时间序列预测的多层感知器网络探索性配置
- 比较经典和机器学习方法进行时间序列预测的结果
- 如何通过深度学习快速获得时间序列预测的结果
- 如何利用 Python 处理序列预测问题中的缺失时间步长
- 如何建立预测大气污染日的概率预测模型
- 如何开发一种熟练的机器学习时间序列预测模型
- 如何构建家庭用电自回归预测模型
- 如何开发多步空气污染时间序列预测的自回归预测模型
- 如何制定多站点多元空气污染时间序列预测的基线预测
- 如何开发时间序列预测的卷积神经网络模型
- 如何开发卷积神经网络用于多步时间序列预测
- 如何开发单变量时间序列预测的深度学习模型
- 如何开发 LSTM 模型用于家庭用电的多步时间序列预测
- 如何开发 LSTM 模型进行时间序列预测
- 如何开发多元多步空气污染时间序列预测的机器学习模型
- 如何开发多层感知器模型进行时间序列预测
- 如何开发人类活动识别时间序列分类的 RNN 模型
- 如何开始深度学习的时间序列预测（7 天迷你课程）
- 如何网格搜索深度学习模型进行时间序列预测
- 如何对单变量时间序列预测的网格搜索朴素方法
- 如何在 Python 中搜索 SARIMA 模型超参数用于时间序列预测
- 如何在 Python 中进行时间序列预测的网格搜索三次指数平滑
- 一个标准的人类活动识别问题的温和介绍
- 如何加载和探索家庭用电数据
- 如何加载，可视化和探索复杂的多变量多步时间序列预测数据集
- 如何从智能手机数据模拟人类活动
- 如何根据环境因素预测房间占用率
- 如何使用脑波预测人眼是开放还是闭合
- 如何在 Python 中扩展长短期内存网络的数据
- 如何使用 TimeseriesGenerator 进行 Keras 中的时间序列预测
- 基于机器学习算法的室内运动时间序列分类
- 用于时间序列预测的状态 LSTM 在线学习的不稳定性
- 用于罕见事件时间序列预测的 LSTM 模型体系结构
- 用于时间序列预测的 4 种通用机器学习数据变换
- Python 中长短期记忆网络的多步时间序列预测
- 家庭用电机器学习的多步时间序列预测
- Keras 中 LSTM 的多变量时间序列预测
- 如何开发和评估朴素的家庭用电量预测方法
- 如何为长短期记忆网络准备单变量时间序列数据
- 循环神经网络在时间序列预测中的应用
- 如何在 Python 中使用差异变换删除趋势和季节性
- 如何在 LSTM 中种子状态用于 Python 中的时间序列预测
- 使用 Python 进行时间序列预测的有状态和无状态 LSTM
- 长短时记忆网络在时间序列预测中的适用性
- 时间序列预测问题的分类
- Python 中长短期记忆网络的时间序列预测
- 基于 Keras 的 Python 中 LSTM 循环神经网络的时间序列预测
- Keras 中深度学习的时间序列预测
- 如何用 Keras 调整 LSTM 超参数进行时间序列预测
- 如何在时间序列预测训练期间更新 LSTM 网络
- 如何使用 LSTM 网络的 Dropout 进行时间序列预测
- 如何使用 LSTM 网络中的特征进行时间序列预测
- 如何在 LSTM 网络中使用时间序列进行时间序列预测
- 如何利用 LSTM 网络进行权重正则化进行时间序列预测
- Machine Learning Mastery 线性代数教程
- 机器学习数学符号的基础知识
- 用 NumPy 阵列轻松介绍广播
- 如何从 Python 中的 Scratch 计算主成分分析（PCA）
- 用于编码器审查的计算线性代数
- 10 机器学习中的线性代数示例
- 线性代数的温和介绍
- 用 NumPy 轻松介绍 Python 中的 N 维数组
- 机器学习向量的温和介绍
- 如何在 Python 中为机器学习索引，切片和重塑 NumPy 数组
- 机器学习的矩阵和矩阵算法简介
- 温和地介绍机器学习的特征分解，特征值和特征向量
- NumPy 对预期价值，方差和协方差的简要介绍
- 机器学习矩阵分解的温和介绍
- 用 NumPy 轻松介绍机器学习的张量
- 用于机器学习的线性代数中的矩阵类型简介
- 用于机器学习的线性代数备忘单
- 线性代数的深度学习
- 用于机器学习的线性代数（7 天迷你课程）
- 机器学习的线性代数
- 机器学习矩阵运算的温和介绍
- 线性代数评论没有废话指南
- 学习机器学习线性代数的主要资源
- 浅谈机器学习的奇异值分解
- 如何用线性代数求解线性回归
- 用于机器学习的稀疏矩阵的温和介绍
- 机器学习中向量规范的温和介绍
- 学习线性代数用于机器学习的 5 个理由
- Machine Learning Mastery LSTM 教程
- Keras中长短期记忆模型的5步生命周期
- 长短时记忆循环神经网络的注意事项
- CNN长短期记忆网络
- 逆向神经网络中的深度学习速成课程
- 可变长度输入序列的数据准备
- 如何用Keras开发用于Python序列分类的双向LSTM
- 如何开发Keras序列到序列预测的编码器 - 解码器模型
- 如何诊断LSTM模型的过度拟合和欠拟合
- 如何开发一种编码器 - 解码器模型，注重Keras中的序列到序列预测
- 编码器 - 解码器长短期存储器网络
- 神经网络中爆炸梯度的温和介绍
- 对时间反向传播的温和介绍
- 生成长短期记忆网络的温和介绍
- 专家对长短期记忆网络的简要介绍
- 在序列预测问题上充分利用LSTM
- 编辑器 - 解码器循环神经网络全局注意的温和介绍
- 如何利用长短时记忆循环神经网络处理很长的序列
- 如何在Python中对一个热编码序列数据
- 如何使用编码器 - 解码器LSTM来回显随机整数序列
- 具有注意力的编码器 - 解码器RNN体系结构的实现模式
- 学习使用编码器解码器LSTM循环神经网络添加数字
- 如何学习长短时记忆循环神经网络回声随机整数
- 具有Keras的长短期记忆循环神经网络的迷你课程
- LSTM自动编码器的温和介绍
- 如何用Keras中的长短期记忆模型进行预测
- 用Python中的长短期内存网络演示内存
- 基于循环神经网络的序列预测模型的简要介绍
- 深度学习的循环神经网络算法之旅
- 如何重塑Keras中长短期存储网络的输入数据
- 了解Keras中LSTM的返回序列和返回状态之间的差异
- RNN展开的温和介绍
- 5学习LSTM循环神经网络的简单序列预测问题的例子
- 使用序列进行预测
- 堆叠长短期内存网络
- 什么是教师强制循环神经网络？
- 如何在Python中使用TimeDistributed Layer for Long Short-Term Memory Networks
- 如何准备Keras中截断反向传播的序列预测
- 如何在使用LSTM进行训练和预测时使用不同的批量大小
- Machine Learning Mastery 机器学习算法教程
- 机器学习算法之旅
- 用于机器学习的装袋和随机森林集合算法
- 从头开始实施机器学习算法的好处
- 更好的朴素贝叶斯：从朴素贝叶斯算法中获取最多的12个技巧
- 机器学习的提升和AdaBoost
- 选择机器学习算法：Microsoft Azure的经验教训
- 机器学习的分类和回归树
- 什么是机器学习中的混淆矩阵
- 如何使用Python从头开始创建算法测试工具
- 通过创建机器学习算法的目标列表来控制
- 从头开始停止编码机器学习算法
- 在实现机器学习算法时，不要从开源代码开始
- 不要使用随机猜测作为基线分类器
- 浅谈机器学习中的概念漂移
- 温和介绍机器学习中的偏差 - 方差权衡
- 机器学习的梯度下降
- 机器学习算法如何工作（他们学习输入到输出的映射）
- 如何建立机器学习算法的直觉
- 如何实现机器学习算法
- 如何研究机器学习算法行为
- 如何学习机器学习算法
- 如何研究机器学习算法
- 如何研究机器学习算法
- 如何在Python中从头开始实现反向传播算法
- 如何用Python从头开始实现Bagging
- 如何用Python从头开始实现基线机器学习算法
- 如何在Python中从头开始实现决策树算法
- 如何用Python从头开始实现学习向量量化
- 如何利用Python从头开始随机梯度下降实现线性回归
- 如何利用Python从头开始随机梯度下降实现Logistic回归
- 如何用Python从头开始实现机器学习算法表现指标
- 如何在Python中从头开始实现感知器算法
- 如何在Python中从零开始实现随机森林
- 如何在Python中从头开始实现重采样方法
- 如何用Python从头开始实现简单线性回归
- 如何用Python从头开始实现堆栈泛化（Stacking）
- K-Nearest Neighbors for Machine Learning
- 学习机器学习的向量量化
- 机器学习的线性判别分析
- 机器学习的线性回归
- 使用梯度下降进行机器学习的线性回归教程
- 如何在Python中从头开始加载机器学习数据
- 机器学习的Logistic回归
- 机器学习的Logistic回归教程
- 机器学习算法迷你课程
- 如何在Python中从头开始实现朴素贝叶斯
- 朴素贝叶斯机器学习
- 朴素贝叶斯机器学习教程
- 机器学习算法的过拟合和欠拟合
- 参数化和非参数机器学习算法
- 理解任何机器学习算法的6个问题
- 在机器学习中拥抱随机性
- 如何使用Python从头开始扩展机器学习数据
- 机器学习的简单线性回归教程
- 有监督和无监督的机器学习算法
- 用于机器学习的支持向量机
- 在没有数学背景的情况下理解机器学习算法的5种技术
- 最好的机器学习算法
- 教程从头开始在Python中实现k-Nearest Neighbors
- 通过从零开始实现它们来理解机器学习算法（以及绕过坏代码的策略）
- 使用随机森林：在121个数据集上测试179个分类器
- 为什么从零开始实现机器学习算法
- Machine Learning Mastery 机器学习入门教程
- 机器学习入门的四个步骤：初学者入门与实践的自上而下策略
- 你应该培养的 5 个机器学习领域
- 一种选择机器学习算法的数据驱动方法
- 机器学习中的分析与数值解
- 应用机器学习是一种精英政治
- 机器学习的基本概念
- 如何成为数据科学家
- 初学者如何在机器学习中弄错
- 机器学习的最佳编程语言
- 构建机器学习组合
- 机器学习中分类与回归的区别
- 评估自己作为数据科学家并利用结果建立惊人的数据科学团队
- 探索 Kaggle 大师的方法论和心态：对 Diogo Ferreira 的采访
- 扩展机器学习工具并展示掌握
- 通过寻找地标开始机器学习
- 温和地介绍预测建模
- 通过提供结果在机器学习中获得梦想的工作
- 如何开始机器学习：自学蓝图
- 开始并在机器学习方面取得进展
- 应用机器学习的 Hello World
- 初学者如何使用小型项目开始机器学习并在 Kaggle 上进行竞争
- 我如何开始机器学习？ （简短版）
- 我是如何开始机器学习的
- 如何在机器学习中取得更好的成绩
- 如何从在银行工作到担任 Target 的高级数据科学家
- 如何学习任何机器学习工具
- 使用小型目标项目深入了解机器学习工具
- 获得付费申请机器学习
- 映射机器学习工具的景观
- 机器学习开发环境
- 机器学习金钱
- 程序员的机器学习
- 机器学习很有意思
- 机器学习是 Kaggle 比赛
- 机器学习现在很受欢迎
- 机器学习掌握方法
- 机器学习很重要
- 机器学习 Q＆amp; A：概念漂移，更好的结果和学习更快
- 缺乏自学机器学习的路线图
- 机器学习很重要
- 快速了解任何机器学习工具（即使您是初学者）
- 机器学习工具
- 找到你的机器学习部落
- 机器学习在一年
- 通过竞争一致的大师 Kaggle
- 5 程序员在机器学习中开始犯错误
- 哲学毕业生到机器学习从业者（Brian Thomas 采访）
- 机器学习入门的实用建议
- 实用机器学习问题
- 使用来自 UCI 机器学习库的数据集练习机器学习
- 使用秘籍的任何机器学习工具快速启动
- 程序员可以进入机器学习
- 程序员应该进入机器学习
- 项目焦点：Shashank Singh 的人脸识别
- 项目焦点：使用 Mahout 和 Konstantin Slisenko 进行堆栈交换群集
- 机器学习自学指南
- 4 个自学机器学习项目
- ÁlvaroLemos 如何在数据科学团队中获得机器学习实习
- 如何思考机器学习
- 现实世界机器学习问题之旅
- 有关机器学习的有用知识
- 如果我没有学位怎么办？
- 如果我不是一个优秀的程序员怎么办？
- 如果我不擅长数学怎么办？
- 为什么机器学习算法会处理以前从未见过的数据？
- 是什么阻碍了你的机器学习目标？
- 什么是机器学习？
- 机器学习适合哪里？
- 为什么要进入机器学习？
- 研究对您来说很重要的机器学习问题
- 你这样做是错的。为什么机器学习不必如此困难
- Machine Learning Mastery Sklearn 教程
- Scikit-Learn 的温和介绍：Python 机器学习库
- 使用 Python 管道和 scikit-learn 自动化机器学习工作流程
- 如何以及何时使用带有 scikit-learn 的校准分类模型
- 如何比较 Python 中的机器学习算法与 scikit-learn
- 用于机器学习开发人员的 Python 崩溃课程
- 用 scikit-learn 在 Python 中集成机器学习算法
- 使用重采样评估 Python 中机器学习算法的表现
- 使用 Scikit-Learn 在 Python 中进行特征选择
- Python 中机器学习的特征选择
- 如何使用 scikit-learn 在 Python 中生成测试数据集
- scikit-learn 中的机器学习算法秘籍
- 如何使用 Python 处理丢失的数据
- 如何开始使用 Python 进行机器学习
- 如何使用 Scikit-Learn 在 Python 中加载数据
- Python 中概率评分方法的简要介绍
- 如何用 Scikit-Learn 调整算法参数
- 如何在 Mac OS X 上安装 Python 3 环境以进行机器学习和深度学习
- 使用 scikit-learn 进行机器学习简介
- 从 shell 到一本带有 Fernando Perez 单一工具的书的 IPython
- 如何使用 Python 3 为机器学习开发创建 Linux 虚拟机
- 如何在 Python 中加载机器学习数据
- 您在 Python 中的第一个机器学习项目循序渐进
- 如何使用 scikit-learn 进行预测
- 用于评估 Python 中机器学习算法的度量标准
- 使用 Pandas 为 Python 中的机器学习准备数据
- 如何使用 Scikit-Learn 为 Python 机器学习准备数据
- 项目焦点：使用 Artem Yankov 在 Python 中进行事件推荐
- 用于机器学习的 Python 生态系统
- Python 是应用机器学习的成长平台
- Python 机器学习书籍
- Python 机器学习迷你课程
- 使用 Pandas 快速和肮脏的数据分析
- 使用 Scikit-Learn 重新调整 Python 中的机器学习数据
- 如何以及何时使用 ROC 曲线和精确调用曲线进行 Python 分类
- 使用 scikit-learn 在 Python 中保存和加载机器学习模型
- scikit-learn Cookbook 书评
- 如何使用 Anaconda 为机器学习和深度学习设置 Python 环境
- 使用 scikit-learn 在 Python 中进行 Spot-Check 分类机器学习算法
- 如何在 Python 中开发可重复使用的抽样检查算法框架
- 使用 scikit-learn 在 Python 中进行 Spot-Check 回归机器学习算法
- 使用 Python 中的描述性统计来了解您的机器学习数据
- 使用 OpenCV，Python 和模板匹配来播放“哪里是 Waldo？”
- 使用 Pandas 在 Python 中可视化机器学习数据
- Machine Learning Mastery 统计学教程
- 浅谈计算正态汇总统计量
- 非参数统计的温和介绍
- Python中常态测试的温和介绍
- 浅谈Bootstrap方法
- 浅谈机器学习的中心极限定理
- 浅谈机器学习中的大数定律
- 机器学习的所有统计数据
- 如何计算Python中机器学习结果的Bootstrap置信区间
- 浅谈机器学习的Chi-Squared测试
- 机器学习的置信区间
- 随机化在机器学习中解决混杂变量的作用
- 机器学习中的受控实验
- 机器学习统计学速成班
- 统计假设检验的关键值以及如何在Python中计算它们
- 如何在机器学习中谈论数据（统计学和计算机科学术语）
- Python中数据可视化方法的简要介绍
- Python中效果大小度量的温和介绍
- 估计随机机器学习算法的实验重复次数
- 机器学习评估统计的温和介绍
- 如何计算Python中的非参数秩相关性
- 如何在Python中计算数据的5位数摘要
- 如何在Python中从头开始编写学生t检验
- 如何在Python中生成随机数
- 如何转换数据以更好地拟合正态分布
- 如何使用相关来理解变量之间的关系
- 如何使用统计信息识别数据中的异常值
- 用于Python机器学习的随机数生成器简介
- k-fold交叉验证的温和介绍
- 如何计算McNemar的比较两种机器学习量词的测试
- Python中非参数统计显着性测试简介
- 如何在Python中使用参数统计显着性测试
- 机器学习的预测间隔
- 应用统计学与机器学习的密切关系
- 如何使用置信区间报告分类器表现
- 统计数据分布的简要介绍
- 15 Python中的统计假设检验（备忘单）
- 统计假设检验的温和介绍
- 10如何在机器学习项目中使用统计方法的示例
- Python中统计功效和功耗分析的简要介绍
- 统计抽样和重新抽样的简要介绍
- 比较机器学习算法的统计显着性检验
- 机器学习中统计容差区间的温和介绍
- 机器学习统计书籍
- 评估机器学习模型的统计数据
- 机器学习统计（7天迷你课程）
- 用于机器学习的简明英语统计
- 如何使用统计显着性检验来解释机器学习结果
- 什么是统计（为什么它在机器学习中很重要）？
- Machine Learning Mastery 时间序列入门教程
- 如何在 Python 中为时间序列预测创建 ARIMA 模型
- 用 Python 进行时间序列预测的自回归模型
- 如何回溯机器学习模型的时间序列预测
- Python 中基于时间序列数据的基本特征工程
- R 的时间序列预测热门书籍
- 10 挑战机器学习时间序列预测问题
- 如何将时间序列转换为 Python 中的监督学习问题
- 如何将时间序列数据分解为趋势和季节性
- 如何用 ARCH 和 GARCH 模拟波动率进行时间序列预测
- 如何将时间序列数据集与 Python 区分开来
- Python 中时间序列预测的指数平滑的温和介绍
- 用 Python 进行时间序列预测的特征选择
- 浅谈自相关和部分自相关
- 时间序列预测的 Box-Jenkins 方法简介
- 用 Python 简要介绍时间序列的时间序列预测
- 如何使用 Python 网格搜索 ARIMA 模型超参数
- 如何在 Python 中加载和探索时间序列数据
- 如何使用 Python 对 ARIMA 模型进行手动预测
- 如何用 Python 进行时间序列预测的预测
- 如何使用 Python 中的 ARIMA 进行样本外预测
- 如何利用 Python 模拟残差错误来纠正时间序列预测
- 使用 Python 进行数据准备，特征工程和时间序列预测的移动平均平滑
- 多步时间序列预测的 4 种策略
- 如何在 Python 中规范化和标准化时间序列数据
- 如何利用 Python 进行时间序列预测的基线预测
- 如何使用 Python 对时间序列预测数据进行功率变换
- 用于时间序列预测的 Python 环境
- 如何重构时间序列预测问题
- 如何使用 Python 重新采样和插值您的时间序列数据
- 用 Python 编写 SARIMA 时间序列预测
- 如何在 Python 中保存 ARIMA 时间序列预测模型
- 使用 Python 进行季节性持久性预测
- 基于 ARIMA 的 Python 历史规模敏感性预测技巧分析
- 简单的时间序列预测模型进行测试，这样你就不会欺骗自己
- 标准多变量，多步骤和多站点时间序列预测问题
- 如何使用 Python 检查时间序列数据是否是固定的
- 使用 Python 进行时间序列数据可视化
- 7 个机器学习的时间序列数据集
- 时间序列预测案例研究与 Python：波士顿每月武装抢劫案
- Python 的时间序列预测案例研究：巴尔的摩的年度用水量
- 使用 Python 进行时间序列预测研究：法国香槟的月销售额
- 使用 Python 的置信区间理解时间序列预测不确定性
- 11 Python 中的经典时间序列预测方法（备忘单）
- 使用 Python 进行时间序列预测表现测量
- 使用 Python 7 天迷你课程进行时间序列预测
- 时间序列预测作为监督学习
- 什么是时间序列预测？
- 如何使用 Python 识别和删除时间序列数据的季节性
- 如何在 Python 中使用和删除时间序列数据中的趋势信息
- 如何在 Python 中调整 ARIMA 参数
- 如何用 Python 可视化时间序列残差预测错误
- 白噪声时间序列与 Python
- 如何通过时间序列预测项目
- Machine Learning Mastery XGBoost 教程
- 通过在 Python 中使用 XGBoost 提前停止来避免过度拟合
- 如何在 Python 中调优 XGBoost 的多线程支持
- 如何配置梯度提升算法
- 在 Python 中使用 XGBoost 进行梯度提升的数据准备
- 如何使用 scikit-learn 在 Python 中开发您的第一个 XGBoost 模型
- 如何在 Python 中使用 XGBoost 评估梯度提升模型
- 在 Python 中使用 XGBoost 的特征重要性和特征选择
- 浅谈机器学习的梯度提升算法
- 应用机器学习的 XGBoost 简介
- 如何在 macOS 上为 Python 安装 XGBoost
- 如何在 Python 中使用 XGBoost 保存梯度提升模型
- 从梯度提升开始，比较 165 个数据集上的 13 种算法
- 在 Python 中使用 XGBoost 和 scikit-learn 进行随机梯度提升
- 如何使用 Amazon Web Services 在云中训练 XGBoost 模型
- 在 Python 中使用 XGBoost 调整梯度提升的学习率
- 如何在 Python 中使用 XGBoost 调整决策树的数量和大小
- 如何在 Python 中使用 XGBoost 可视化梯度提升决策树
- 在 Python 中开始使用 XGBoost 的 7 步迷你课程