StatsForecast 提供了多种模型，分组如下：

自动预测 (Auto Forecast): 自动预测工具会搜索最佳参数，并为一系列时间序列选择最合适的模型。这些工具对于大量单变量时间序列非常有用。包括以下模型的自动版本：Arima、ETS、Theta、CES。
指数平滑 (Exponential Smoothing): 使用所有过去观测值的加权平均，其中权重随时间呈指数衰减。适用于具有明显趋势和/或季节性的数据。对于没有明显趋势或季节性的数据，使用 SimpleExponential 系列模型。示例：SES, Holt’s Winters, SSO。
基准模型 (Benchmark models): 用于建立基线的经典模型。示例：Mean, Naive, Random Walk
间歇性或稀疏模型 (Intermittent or Sparse models): 适用于非零观测值非常少的时间序列。示例：CROSTON, ADIDA, IMAPA
多重季节性 (Multiple Seasonalities): 适用于具有多个明显季节性的信号。对于电力和日志等低频数据很有用。示例：MSTL 和 TBATS。
Theta 模型 (Theta Models): 对去季节化的时间序列拟合两条 theta 线，使用不同的技术获取并结合这两条 theta 线来生成最终预测。示例：Theta, DynamicTheta
GARCH 模型 (GARCH Model): 适用于建模随时间表现出非恒定波动性的时间序列。常用于金融领域，建模股票价格、汇率、利率及其他金融工具。ARCH 模型是 GARCH 的一种特殊情况。

自动预测

AutoARIMA

 AutoARIMA (d:Optional[int]=None, D:Optional[int]=None, max_p:int=5,
            max_q:int=5, max_P:int=2, max_Q:int=2, max_order:int=5,
            max_d:int=2, max_D:int=1, start_p:int=2, start_q:int=2,
            start_P:int=1, start_Q:int=1, stationary:bool=False,
            seasonal:bool=True, ic:str='aicc', stepwise:bool=True,
            nmodels:int=94, trace:bool=False,
            approximation:Optional[bool]=False, method:Optional[str]=None,
            truncate:Optional[bool]=None, test:str='kpss',
            test_kwargs:Optional[str]=None, seasonal_test:str='seas',
            seasonal_test_kwargs:Optional[Dict]=None,
            allowdrift:bool=True, allowmean:bool=True,
            blambda:Optional[float]=None, biasadj:bool=False,
            season_length:int=1, alias:str='AutoARIMA', prediction_interva
            ls:Optional[statsforecast.utils.ConformalIntervals]=None)

*AutoARIMA 模型。

自动使用信息准则选择最佳 ARIMA（自回归积分滑动平均）模型。默认为 Akaike 信息准则 (AICc)。*

	类型	默认值	详情
d	可选	无	一阶差分阶数。
D	可选	无	季节差分阶数。
max_p	int	5	最大自回归 p。
max_q	int	5	最大滑动平均 q。
max_P	int	2	最大季节性自回归 P。
max_Q	int	2	最大季节性滑动平均 Q。
max_order	int	5	如果不是逐步选择，则为最大 p+q+P+Q 值。
max_d	int	2	最大非季节差分。
max_D	int	1	最大季节差分。
start_p	int	2	逐步过程中 p 的起始值。
start_q	int	2	逐步过程中 q 的起始值。
start_P	int	1	逐步过程中 P 的起始值。
start_Q	int	1	逐步过程中 Q 的起始值。
stationary	bool	False	如果为 True，则将搜索限制在平稳模型。
seasonal	bool	True	如果为 False，则将搜索限制在非季节性模型。
ic	str	aicc	模型选择中使用的信息准则。
stepwise	bool	True	如果为 True，将进行逐步选择（更快）。
nmodels	int	94	逐步搜索中考虑的模型数量。
trace	bool	False	如果为 True，将报告搜索到的 ARIMA 模型。
approximation	可选	False	如果为 True，使用条件平方和估计，最终 MLE。
method	可选	无	最大似然法或平方和最小化之间的拟合方法。
truncate	可选	无	模型选择中使用的截断序列观测值。
test	str	kpss	使用的单位根检验。详见 `ndiffs`。
test_kwargs	可选	无	单位根检验附加参数。
seasonal_test	str	seas	季节差分选择方法。
seasonal_test_kwargs	可选	无	季节单位根检验参数。
allowdrift	bool	True	如果为 True，考虑漂移模型项。
allowmean	bool	True	如果为 True，考虑非零均值模型。
blambda	可选	无	Box-Cox 变换参数。
biasadj	bool	False	使用调整后的反变换 Box-Cox 均值。
season_length	int	1	每单位时间的观测值数量。例如：24小时数据。
alias	str	AutoARIMA	模型的自定义名称。
prediction_intervals	可选	无	计算保形预测区间的信息。默认情况下，模型将计算原生预测区间。

来源

AutoARIMA.fit

 AutoARIMA.fit (y:numpy.ndarray, X:Optional[numpy.ndarray]=None)

*拟合 AutoARIMA 模型。

将 AutoARIMA 模型拟合到时间序列（numpy 数组）y 和可选的外生变量（numpy 数组）X。*

	类型	默认值	详情
y	ndarray		形状为 (t, ) 的干净时间序列。
X	可选	无	形状为 (t, n_x) 的可选外生变量。
返回值			已拟合的 AutoARIMA 模型。

来源

AutoARIMA.predict

 AutoARIMA.predict (h:int, X:Optional[numpy.ndarray]=None,
                    level:Optional[List[int]]=None)

使用已拟合的 AutoArima 进行预测。

	类型	默认值	详情
h	int		预测范围。
X	可选	无	形状为 (h, n_x) 的可选外生变量。
level	可选	无	预测区间的置信水平 (0-100)。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

来源

AutoARIMA.predict_in_sample

 AutoARIMA.predict_in_sample (level:Optional[List[int]]=None)

访问已拟合 AutoArima 的样本内预测。

	类型	默认值	详情
level	可选	无	预测区间的置信水平 (0-100)。
返回值	dict		*字典，包含用于点预测的 `fitted` 条目和用于概率预测的 `level_` 条目。**

来源

AutoARIMA.forecast

 AutoARIMA.forecast (y:numpy.ndarray, h:int,
                     X:Optional[numpy.ndarray]=None,
                     X_future:Optional[numpy.ndarray]=None,
                     level:Optional[List[int]]=None, fitted:bool=False)

*内存高效的 AutoARIMA 预测。

此方法避免了对象存储带来的内存负担。它类似于 fit_predict 但不存储信息。它假设您提前知道预测范围。*

	类型	默认值	详情
y	ndarray		形状为 (n, ) 的干净时间序列。
h	int		预测范围。
X	可选	无	形状为 (t, n_x) 的可选样本内外部变量。
X_future	可选	无	形状为 (h, n_x) 的可选外部变量。
level	可选	无	预测区间的置信水平 (0-100)。
fitted	bool	False	是否返回样本内预测。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

来源

AutoARIMA.forward

 AutoARIMA.forward (y:numpy.ndarray, h:int,
                    X:Optional[numpy.ndarray]=None,
                    X_future:Optional[numpy.ndarray]=None,
                    level:Optional[List[int]]=None, fitted:bool=False)

将已拟合的 ARIMA 模型应用于新的时间序列。

	类型	默认值	详情
y	ndarray		形状为 (n, ) 的干净时间序列。
h	int		预测范围。
X	可选	无	形状为 (t, n_x) 的可选样本内外部变量。
X_future	可选	无	形状为 (h, n_x) 的可选外生变量。
level	可选	无	预测区间的置信水平。
fitted	bool	False	是否返回样本内预测。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

from statsforecast.models import AutoARIMA
from statsforecast.utils import AirPassengers as ap

# AutoARIMA's usage example
arima = AutoARIMA(season_length=4)
arima = arima.fit(y=ap)
y_hat_dict = arima.predict(h=4, level=[80])
y_hat_dict

AutoETS

来源

AutoETS

 AutoETS (season_length:int=1, model:str='ZZZ',
          damped:Optional[bool]=None, phi:Optional[float]=None,
          alias:str='AutoETS', prediction_intervals:Optional[statsforecast
          .utils.ConformalIntervals]=None)

*自动指数平滑模型。

自动使用信息准则选择最佳 ETS（误差、趋势、季节性）模型。默认为 Akaike 信息准则 (AICc)，特定模型使用最大似然法估计。状态空间方程可以根据其 $M$ 乘法、 $A$ 加法、 $Z$ 优化或 $N$ 省略的分量确定。model 字符串参数定义了 ETS 方程：E 在 [ $M, A, Z$ ] 中，T 在 [ $N, A, M, Z$ ] 中，S 在 [ $N, A, M, Z$ ] 中。

例如，当 model='ANN'（加法误差，无趋势，无季节性）时，ETS 将只探索简单的指数平滑。

如果分量被选为 'Z'，它将作为一个占位符，让 AutoETS 模型找出最佳参数。*

	类型	默认值	详情
season_length	int	1	每单位时间的观测值数量。例如：24小时数据。
model	str	ZZZ	控制状态空间方程。
damped	可选	无	“抑制”趋势的参数。
phi	可选	无	用于趋势抑制的平滑参数。仅在 `damped=True` 时使用。
alias	str	AutoETS	模型的自定义名称。
prediction_intervals	可选	无	计算保形预测区间的信息。默认情况下，模型将计算原生预测区间。

来源

AutoETS.fit

 AutoETS.fit (y:numpy.ndarray, X:Optional[numpy.ndarray]=None)

*拟合指数平滑模型。

将指数平滑模型拟合到时间序列（numpy 数组）y 和可选的外生变量（numpy 数组）X。*

	类型	默认值	详情
y	ndarray		形状为 (t, ) 的干净时间序列。
X	可选	无	形状为 (t, n_x) 的可选外生变量。
返回值			已拟合的指数平滑模型。

来源

AutoETS.predict

 AutoETS.predict (h:int, X:Optional[numpy.ndarray]=None,
                  level:Optional[List[int]]=None)

使用已拟合的指数平滑模型进行预测。

	类型	默认值	详情
h	int		预测范围。
X	可选	无	形状为 (h, n_x) 的可选外生变量。
level	可选	无	预测区间的置信水平 (0-100)。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

来源

AutoETS.predict_in_sample

 AutoETS.predict_in_sample (level:Optional[List[int]]=None)

访问已拟合指数平滑模型的样本内预测。

	类型	默认值	详情
level	可选	无	预测区间的置信水平 (0-100)。
返回值	dict		*字典，包含用于点预测的 `fitted` 条目和用于概率预测的 `level_` 条目。**

来源

AutoETS.forecast

 AutoETS.forecast (y:numpy.ndarray, h:int, X:Optional[numpy.ndarray]=None,
                   X_future:Optional[numpy.ndarray]=None,
                   level:Optional[List[int]]=None, fitted:bool=False)

*内存高效的指数平滑预测。

此方法避免了对象存储带来的内存负担。它类似于 fit_predict 但不存储信息。它假设您提前知道预测范围。*

	类型	默认值	详情
y	ndarray		形状为 (n, ) 的干净时间序列。
h	int		预测范围。
X	可选	无	形状为 (t, n_x) 的可选样本内外部变量。
X_future	可选	无	形状为 (h, n_x) 的可选外生变量。
level	可选	无	预测区间的置信水平 (0-100)。
fitted	bool	False	是否返回样本内预测。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

来源

AutoETS.forward

 AutoETS.forward (y:numpy.ndarray, h:int, X:Optional[numpy.ndarray]=None,
                  X_future:Optional[numpy.ndarray]=None,
                  level:Optional[List[int]]=None, fitted:bool=False)

将已拟合的指数平滑模型应用于新的时间序列。

	类型	默认值	详情
y	ndarray		形状为 (n, ) 的干净时间序列。
h	int		预测范围。
X	可选	无	形状为 (t, n_x) 的可选样本内外部变量。
X_future	可选	无	形状为 (h, n_x) 的可选外生变量。
level	可选	无	预测区间的置信水平。
fitted	bool	False	是否返回样本内预测。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

from statsforecast.models import AutoETS
from statsforecast.utils import AirPassengers as ap

# AutoETS' usage example
# Multiplicative trend, optimal error and seasonality
autoets = AutoETS(model='ZMZ', season_length=4)
autoets = autoets.fit(y=ap)
y_hat_dict = autoets.predict(h=4)
y_hat_dict

AutoCES

来源

AutoCES

 AutoCES (season_length:int=1, model:str='Z', alias:str='CES', prediction_
          intervals:Optional[statsforecast.utils.ConformalIntervals]=None)

*复杂指数平滑模型。

自动使用信息准则选择最佳复杂指数平滑模型。默认为 Akaike 信息准则 (AICc)，特定模型使用最大似然法估计。状态空间方程可以根据其 $S$ 简单、 $P$ 部分、 $Z$ 优化或 $N$ 省略的分量确定。model 字符串参数定义了 CES 模型的类型： $N$ 表示简单 CES（无季节性）， $S$ 表示简单季节性（滞后 CES）， $P$ 表示部分季节性（无复杂部分）， $F$ 表示完全季节性（具有实部和复数季节部分的滞后 CES）。

如果分量被选为 'Z'，它将作为一个占位符，让 AutoCES 模型找出最佳参数。*

	类型	默认值	详情
season_length	int	1	每单位时间的观测值数量。例如：24小时数据。
model	str	Z	控制状态空间方程。
alias	str	CES	模型的自定义名称。
prediction_intervals	可选	无	计算保形预测区间的信息。默认情况下，模型将计算原生预测区间。

来源

AutoCES.fit

 AutoCES.fit (y:numpy.ndarray, X:Optional[numpy.ndarray]=None)

*拟合复杂指数平滑模型。

将复杂指数平滑模型拟合到时间序列（numpy 数组）y 和可选的外生变量（numpy 数组）X。*

	类型	默认值	详情
y	ndarray		形状为 (t, ) 的干净时间序列。
X	可选	无	形状为 (t, n_x) 的可选外生变量。
返回值			已拟合的复杂指数平滑模型。

来源

AutoCES.predict

 AutoCES.predict (h:int, X:Optional[numpy.ndarray]=None,
                  level:Optional[List[int]]=None)

使用已拟合的指数平滑模型进行预测。

	类型	默认值	详情
h	int		预测范围。
X	可选	无	形状为 (h, n_x) 的可选外生变量。
level	可选	无
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

来源

AutoCES.predict_in_sample

 AutoCES.predict_in_sample (level:Optional[List[int]]=None)

访问已拟合指数平滑模型的样本内预测。

	类型	默认值	详情
level	可选	无	预测区间的置信水平 (0-100)。
返回值	dict		*字典，包含用于点预测的 `fitted` 条目和用于概率预测的 `level_` 条目。**

来源

AutoCES.forecast

 AutoCES.forecast (y:numpy.ndarray, h:int, X:Optional[numpy.ndarray]=None,
                   X_future:Optional[numpy.ndarray]=None,
                   level:Optional[List[int]]=None, fitted:bool=False)

*内存高效的复杂指数平滑预测。

此方法避免了对象存储带来的内存负担。它类似于 fit_predict 但不存储信息。它假设您提前知道预测范围。*

	类型	默认值	详情
y	ndarray		形状为 (n, ) 的干净时间序列。
h	int		预测范围。
X	可选	无	形状为 (t, n_x) 的可选样本内外部变量。
X_future	可选	无	形状为 (h, n_x) 的可选外生变量。
level	可选	无
fitted	bool	False	是否返回样本内预测。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

来源

AutoCES.forward

 AutoCES.forward (y:numpy.ndarray, h:int, X:Optional[numpy.ndarray]=None,
                  X_future:Optional[numpy.ndarray]=None,
                  level:Optional[List[int]]=None, fitted:bool=False)

将已拟合的复杂指数平滑模型应用于新的时间序列。

	类型	默认值	详情
y	ndarray		形状为 (n, ) 的干净时间序列。
h	int		预测范围。
X	可选	无	形状为 (t, n_x) 的可选样本内外部变量。
X_future	可选	无	形状为 (h, n_x) 的可选外生变量。
level	可选	无
fitted	bool	False	是否返回样本内预测。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

from statsforecast.models import AutoCES
from statsforecast.utils import AirPassengers as ap

# CES' usage example
# Multiplicative trend, optimal error and seasonality
ces = AutoCES(model='Z',  
              season_length=4)
ces = ces.fit(y=ap)
y_hat_dict = ces.predict(h=4)
y_hat_dict

AutoTheta

来源

AutoTheta

 AutoTheta (season_length:int=1, decomposition_type:str='multiplicative',
            model:Optional[str]=None, alias:str='AutoTheta', prediction_in
            tervals:Optional[statsforecast.utils.ConformalIntervals]=None)

*AutoTheta 模型。

自动使用 mse 选择最佳 Theta 模型（标准 Theta 模型 (‘STM’)、优化 Theta 模型 (‘OTM’)、动态标准 Theta 模型 (‘DSTM’)、动态优化 Theta 模型 (‘DOTM’)）。*

	类型	默认值	详情
season_length	int	1	每单位时间的观测值数量。例如：24小时数据。
decomposition_type	str	multiplicative	季节分解类型，'multiplicative'（默认）或 'additive'。
model	可选	无	控制 Theta 模型。默认搜索最佳模型。
alias	str	AutoTheta	模型的自定义名称。
prediction_intervals	可选	无	计算保形预测区间的信息。默认情况下，模型将计算原生预测区间。

来源

AutoTheta.fit

 AutoTheta.fit (y:numpy.ndarray, X:Optional[numpy.ndarray]=None)

*拟合 AutoTheta 模型。

将 AutoTheta 模型拟合到时间序列（numpy 数组）y 和可选的外生变量（numpy 数组）X。*

	类型	默认值	详情
y	ndarray		形状为 (t, ) 的干净时间序列。
X	可选	无	形状为 (t, n_x) 的可选外生变量。
返回值			已拟合的 AutoTheta 模型。

来源

AutoTheta.predict

 AutoTheta.predict (h:int, X:Optional[numpy.ndarray]=None,
                    level:Optional[List[int]]=None)

使用已拟合的 AutoTheta 进行预测。

	类型	默认值	详情
h	int		预测范围。
X	可选	无	形状为 (h, n_x) 的可选外生变量。
level	可选	无	预测区间的置信水平 (0-100)。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

来源

AutoTheta.predict_in_sample

 AutoTheta.predict_in_sample (level:Optional[List[int]]=None)

访问已拟合 AutoTheta 的样本内预测。

	类型	默认值	详情
level	可选	无	预测区间的置信水平 (0-100)。
返回值	dict		*字典，包含用于点预测的 `fitted` 条目和用于概率预测的 `level_` 条目。**

来源

AutoTheta.forecast

 AutoTheta.forecast (y:numpy.ndarray, h:int,
                     X:Optional[numpy.ndarray]=None,
                     X_future:Optional[numpy.ndarray]=None,
                     level:Optional[List[int]]=None, fitted:bool=False)

*内存高效的 AutoTheta 预测。

此方法避免了对象存储带来的内存负担。它类似于 fit_predict 但不存储信息。它假设您提前知道预测范围。*

	类型	默认值	详情
y	ndarray		形状为 (n, ) 的干净时间序列。
h	int		预测范围。
X	可选	无	形状为 (t, n_x) 的可选样本内外部变量。
X_future	可选	无	形状为 (h, n_x) 的可选外生变量。
level	可选	无	预测区间的置信水平 (0-100)。
fitted	bool	False	是否返回样本内预测。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

来源

AutoTheta.forward

 AutoTheta.forward (y:numpy.ndarray, h:int,
                    X:Optional[numpy.ndarray]=None,
                    X_future:Optional[numpy.ndarray]=None,
                    level:Optional[List[int]]=None, fitted:bool=False)

将已拟合的 AutoTheta 模型应用于新的时间序列。

	类型	默认值	详情
y	ndarray		形状为 (n, ) 的干净时间序列。
h	int		预测范围。
X	可选	无	形状为 (t, n_x) 的可选样本内外部变量。
X_future	可选	无	形状为 (h, n_x) 的可选外生变量。
level	可选	无	预测区间的置信水平 (0-100)。
fitted	bool	False	是否返回样本内预测。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

from statsforecast.models import AutoTheta
from statsforecast.utils import AirPassengers as ap

# AutoTheta's usage example
theta = AutoTheta(season_length=4)
theta = theta.fit(y=ap)
y_hat_dict = theta.predict(h=4)
y_hat_dict

AutoMFLES

来源

AutoMFLES

 AutoMFLES (test_size:int,
            season_length:Union[int,List[int],NoneType]=None,
            n_windows:int=2, config:Optional[Dict[str,Any]]=None,
            step_size:Optional[int]=None, metric:str='smape',
            verbose:bool=False, prediction_intervals:Optional[statsforecas
            t.utils.ConformalIntervals]=None, alias:str='AutoMFLES')

AutoMFLES

	类型	默认值	详情
test_size	int		交叉验证期间使用的预测范围。
season_length	Union	无	每单位时间的观测值数量。例如：24小时数据。
n_windows	int	2	用于交叉验证的窗口数量。
config	可选	无	参数名称（来自 MFLES 的初始化参数）到要尝试的值列表的映射。如果为 `None`，将使用默认值。
step_size	可选	无	每个交叉验证窗口之间的步长。如果为 `None`，将设置为 test_size。
metric	str	smape	用于选择最佳模型的指标。可能的选项包括：‘smape’、‘mape’、‘mse’ 和 ‘mae’。
verbose	bool	False	打印调试信息。
prediction_intervals	可选	无	计算保形预测区间的信息。这是生成未来预测区间所需的。
alias	str	AutoMFLES	模型的自定义名称。

来源

AutoMFLES.fit

 AutoMFLES.fit (y:numpy.ndarray, X:Optional[numpy.ndarray]=None)

拟合模型

	类型	默认值	详情
y	ndarray		形状为 (t, ) 的干净时间序列。
X	可选	无	形状为 (t, n_x) 的外部变量。
返回值	AutoMFLES		已拟合的 AutoMFLES 对象。

来源

AutoMFLES.predict

 AutoMFLES.predict (h:int, X:Optional[numpy.ndarray]=None,
                    level:Optional[List[int]]=None)

使用已拟合的 AutoMFLES 进行预测。

	类型	默认值	详情
h	int		预测范围。
X	可选	无	形状为 (h, n_x) 的外部变量。
level	可选	无
返回值	Dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

来源

AutoMFLES.predict_in_sample

 AutoMFLES.predict_in_sample (level:Optional[List[int]]=None)

访问已拟合 AutoMFLES 的样本内预测。

	类型	默认值	详情
level	可选	无	预测区间的置信水平 (0-100)。
返回值	Dict		*字典，包含用于点预测的 `fitted` 条目和用于概率预测的 `level_` 条目。**

来源

AutoMFLES.forecast

 AutoMFLES.forecast (y:numpy.ndarray, h:int,
                     X:Optional[numpy.ndarray]=None,
                     X_future:Optional[numpy.ndarray]=None,
                     level:Optional[List[int]]=None, fitted:bool=False)

*内存高效的 AutoMFLES 预测。

此方法避免了对象存储带来的内存负担。它类似于 fit_predict 但不存储信息。它假设您提前知道预测范围。*

	类型	默认值	详情
y	ndarray		形状为 (t, ) 的干净时间序列。
h	int		预测范围。
X	可选	无	形状为 (t, n_x) 的样本内外部变量。
X_future	可选	无	形状为 (h, n_x) 的外部变量。
level	可选	无	预测区间的置信水平 (0-100)。
fitted	bool	False	是否返回样本内预测。
返回值	Dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

AutoTBATS

来源

AutoTBATS

 AutoTBATS (season_length:Union[int,List[int]],
            use_boxcox:Optional[bool]=None, bc_lower_bound:float=0.0,
            bc_upper_bound:float=1.0, use_trend:Optional[bool]=None,
            use_damped_trend:Optional[bool]=None,
            use_arma_errors:bool=True, alias:str='AutoTBATS')

*AutoTBATS 模型。

自动从参数 use_boxcox, use_trend, use_damped_trend 和 use_arma_errors 的所有可行组合中选择最佳 TBATS 模型。选择使用 AIC 进行。use_arma_errors 的默认值为 True，因为它允许评估有无 ARMA 误差的模型。*

	类型	默认值	详情
season_length	Union
use_boxcox	可选	无	是否使用 Box-Cox 变换。默认尝试两者。
bc_lower_bound	float	0.0	Box-Cox 变换的下限。
bc_upper_bound	float	1.0	Box-Cox 变换的上限。
use_trend	可选	无	是否使用趋势分量。默认尝试两者。
use_damped_trend	可选	无	是否抑制趋势分量。默认尝试两者。
use_arma_errors	bool	True	是否使用 ARMA 误差。默认值为 True，这将评估两种模型。
alias	str	AutoTBATS	模型的自定义名称。

来源

AutoTBATS.fit

 AutoTBATS.fit (y:numpy.ndarray, X:Optional[numpy.ndarray]=None)

*拟合 TBATS 模型。

将 TBATS 模型拟合到时间序列（numpy 数组）y。*

	类型	默认值	详情
y	ndarray		形状为 (t, ) 的干净时间序列。
X	可选	无	忽略
返回值			TBATS 模型。

来源

AutoTBATS.predict

 AutoTBATS.predict (h:int, X:Optional[numpy.ndarray]=None,
                    level:Optional[List[int]]=None)

使用已拟合的 TBATS 模型进行预测。

	类型	默认值	详情
h	int		预测范围。
X	可选	无
level	可选	无	预测区间的置信水平 (0-100)。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

来源

AutoTBATS.predict_in_sample

 AutoTBATS.predict_in_sample (level:Optional[Tuple[int]]=None)

访问已拟合 TBATS 模型的预测。

	类型	默认值	详情
level	可选	无	预测区间的置信水平 (0-100)。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

来源

AutoTBATS.forecast

 AutoTBATS.forecast (y:numpy.ndarray, h:int,
                     X:Optional[numpy.ndarray]=None,
                     X_future:Optional[numpy.ndarray]=None,
                     level:Optional[List[int]]=None, fitted:bool=False)

*内存高效的 TBATS 模型。

此方法避免了对象存储带来的内存负担。它类似于 fit_predict 但不存储信息。它假设您提前知道预测范围。*

	类型	默认值	详情
y	ndarray		形状为 (n, ) 的干净时间序列。
h	int		预测范围。
X	可选	无
X_future	可选	无
level	可选	无	预测区间的置信水平 (0-100)。
fitted	bool	False	是否返回样本内预测。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

ARIMA 系列

ARIMA

来源

ARIMA

 ARIMA (order:Tuple[int,int,int]=(0, 0, 0), season_length:int=1,
        seasonal_order:Tuple[int,int,int]=(0, 0, 0),
        include_mean:bool=True, include_drift:bool=False,
        include_constant:Optional[bool]=None,
        blambda:Optional[float]=None, biasadj:bool=False, method:str='CSS-
        ML', fixed:Optional[dict]=None, alias:str='ARIMA', prediction_inte
        rvals:Optional[statsforecast.utils.ConformalIntervals]=None)

*ARIMA 模型。

自回归积分滑动平均模型。*

	类型	默认值	详情
order	Tuple	(0, 0, 0)	ARIMA 模型非季节部分的规格：三个分量 (p, d, q) 分别是 AR 阶数、差分阶数和 MA 阶数。
season_length	int	1	每单位时间的观测值数量。例如：24小时数据。
seasonal_order	Tuple	(0, 0, 0)	ARIMA 模型季节部分的规格。 (P, D, Q) 分别代表 AR 阶数、差分阶数、MA 阶数。
include_mean	bool	True	ARIMA 模型是否应包含均值项？对于未差分序列，默认值为 True；对于已差分序列，默认值为 False（此时均值不会影响拟合或预测）。
include_drift	bool	False	ARIMA 模型是否应包含线性漂移项？（即，拟合一个具有 ARIMA 误差的线性回归。）
include_constant	可选	无	如果为 True，则对于未差分序列，includ_mean 被设置为 True；对于已差分序列，include_drift 被设置为 True。请注意，如果进行多于一阶的差分，无论此参数的值如何，都不包含常数项。这是有意为之的，否则会引入二次或更高阶的多项式趋势。
blambda	可选	无	Box-Cox 变换参数。
biasadj	bool	False	使用调整后的反变换 Box-Cox 均值。
method	str	CSS-ML	拟合方法：最大似然法或最小化条件平方和。默认（除非存在缺失值）是使用条件平方和找到起始值，然后使用最大似然法。
fixed	可选	无	包含 ARIMA 模型固定系数的字典。示例：`{'ar1': 0.5, 'ma2': 0.75}`。对于自回归项，使用 `ar{i}` 键。对于其季节性版本，使用 `sar{i}`。对于滑动平均项，使用 `ma{i}` 键。对于其季节性版本，使用 `sma{i}`。对于截距和漂移，使用 `intercept` 和 `drift` 键。对于外生变量，使用 `ex_{i}` 键。
alias	str	ARIMA	模型的自定义名称。
prediction_intervals	可选	无	计算保形预测区间的信息。默认情况下，模型将计算原生预测区间。

来源

ARIMA.fit

 ARIMA.fit (y:numpy.ndarray, X:Optional[numpy.ndarray]=None)

将模型拟合到时间序列（numpy 数组）y 和可选的外生变量（numpy 数组）X。

	类型	默认值	详情
y	ndarray		形状为 (t, ) 的干净时间序列。
X	可选	无	形状为 (t, n_x) 的可选外生变量。
返回值			已拟合的模型。

来源

ARIMA.predict

 ARIMA.predict (h:int, X:Optional[numpy.ndarray]=None,
                level:Optional[List[int]]=None)

使用已拟合的模型进行预测。

	类型	默认值	详情
h	int		预测范围。
X	可选	无	形状为 (h, n_x) 的可选外生变量。
level	可选	无	预测区间的置信水平 (0-100)。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

来源

ARIMA.predict_in_sample

 ARIMA.predict_in_sample (level:Optional[List[int]]=None)

访问已拟合的样本内预测。

	类型	默认值	详情
level	可选	无	预测区间的置信水平 (0-100)。
返回值	dict		*字典，包含用于点预测的 `fitted` 条目和用于概率预测的 `level_` 条目。**

来源

ARIMA.forecast

 ARIMA.forecast (y:numpy.ndarray, h:int, X:Optional[numpy.ndarray]=None,
                 X_future:Optional[numpy.ndarray]=None,
                 level:Optional[List[int]]=None, fitted:bool=False)

*内存高效预测。

此方法避免了对象存储带来的内存负担。它类似于 fit_predict 但不存储信息。它假设您提前知道预测范围。*

	类型	默认值	详情
y	ndarray		形状为 (n, ) 的干净时间序列。
h	int		预测范围。
X	可选	无	形状为 (t, n_x) 的可选样本内外部变量。
X_future	可选	无	形状为 (h, n_x) 的可选外部变量。
level	可选	无	预测区间的置信水平 (0-100)。
fitted	bool	False	是否返回样本内预测。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

来源

ARIMA.forward

 ARIMA.forward (y:numpy.ndarray, h:int, X:Optional[numpy.ndarray]=None,
                X_future:Optional[numpy.ndarray]=None,
                level:Optional[List[int]]=None, fitted:bool=False)

将已拟合的模型应用于新的时间序列。

	类型	默认值	详情
y	ndarray		形状为 (n, ) 的干净时间序列。
h	int		预测范围。
X	可选	无	形状为 (t, n_x) 的可选样本内外部变量。
X_future	可选	无	形状为 (h, n_x) 的可选外生变量。
level	可选	无	预测区间的置信水平。
fitted	bool	False	是否返回样本内预测。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

from statsforecast.models import ARIMA
from statsforecast.utils import AirPassengers as ap

# ARIMA's usage example
arima = ARIMA(order=(1, 0, 0), season_length=12)
arima = arima.fit(y=ap)
y_hat_dict = arima.predict(h=4, level=[80])
y_hat_dict

自回归模型

来源

自回归模型

 AutoRegressive (lags:Tuple[int,List], include_mean:bool=True,
                 include_drift:bool=False, blambda:Optional[float]=None,
                 biasadj:bool=False, method:str='CSS-ML',
                 fixed:Optional[dict]=None, alias:str='AutoRegressive', pr
                 ediction_intervals:Optional[statsforecast.utils.Conformal
                 Intervals]=None)

简单自回归模型。

	类型	默认值	详情
lags	Tuple		模型中包含的滞后数量。如果传入 int，则考虑直到 `lags` 的所有滞后。如果传入列表，则只考虑列表中的元素作为滞后。
include_mean	bool	True	自回归模型是否应包含均值项？对于未差分序列，默认值为 True；对于已差分序列，默认值为 False（此时均值不会影响拟合或预测）。
include_drift	bool	False	自回归模型是否应包含线性漂移项？（即，拟合一个具有自回归误差的线性回归。）
blambda	可选	无	Box-Cox 变换参数。
biasadj	bool	False	使用调整后的反变换 Box-Cox 均值。
method	str	CSS-ML	拟合方法：最大似然法或最小化条件平方和。默认（除非存在缺失值）是使用条件平方和找到起始值，然后使用最大似然法。
fixed	可选	无	包含自回归模型固定系数的字典。示例：`{'ar1': 0.5, 'ar5': 0.75}`。对于自回归项，使用 `ar{i}` 键。
alias	str	自回归模型	模型的自定义名称。
prediction_intervals	可选	无	计算保形预测区间的信息。默认情况下，模型将计算原生预测区间。

来源

AutoRegressive.fit

 AutoRegressive.fit (y:numpy.ndarray, X:Optional[numpy.ndarray]=None)

将模型拟合到时间序列（numpy 数组）y 和可选的外生变量（numpy 数组）X。

	类型	默认值	详情
y	ndarray		形状为 (t, ) 的干净时间序列。
X	可选	无	形状为 (t, n_x) 的可选外生变量。
返回值			已拟合的模型。

来源

AutoRegressive.predict

 AutoRegressive.predict (h:int, X:Optional[numpy.ndarray]=None,
                         level:Optional[List[int]]=None)

使用已拟合的模型进行预测。

	类型	默认值	详情
h	int		预测范围。
X	可选	无	形状为 (h, n_x) 的可选外生变量。
level	可选	无	预测区间的置信水平 (0-100)。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

来源

AutoRegressive.predict_in_sample

 AutoRegressive.predict_in_sample (level:Optional[List[int]]=None)

访问已拟合的样本内预测。

	类型	默认值	详情
level	可选	无	预测区间的置信水平 (0-100)。
返回值	dict		*字典，包含用于点预测的 `fitted` 条目和用于概率预测的 `level_` 条目。**

来源

AutoRegressive.forecast

 AutoRegressive.forecast (y:numpy.ndarray, h:int,
                          X:Optional[numpy.ndarray]=None,
                          X_future:Optional[numpy.ndarray]=None,
                          level:Optional[List[int]]=None,
                          fitted:bool=False)

*内存高效预测。

此方法避免了对象存储带来的内存负担。它类似于 fit_predict 但不存储信息。它假设您提前知道预测范围。*

	类型	默认值	详情
y	ndarray		形状为 (n, ) 的干净时间序列。
h	int		预测范围。
X	可选	无	形状为 (t, n_x) 的可选样本内外部变量。
X_future	可选	无	形状为 (h, n_x) 的可选外部变量。
level	可选	无	预测区间的置信水平 (0-100)。
fitted	bool	False	是否返回样本内预测。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

来源

AutoRegressive.forward

 AutoRegressive.forward (y:numpy.ndarray, h:int,
                         X:Optional[numpy.ndarray]=None,
                         X_future:Optional[numpy.ndarray]=None,
                         level:Optional[List[int]]=None,
                         fitted:bool=False)

将已拟合的模型应用于新的时间序列。

	类型	默认值	详情
y	ndarray		形状为 (n, ) 的干净时间序列。
h	int		预测范围。
X	可选	无	形状为 (t, n_x) 的可选样本内外部变量。
X_future	可选	无	形状为 (h, n_x) 的可选外生变量。
level	可选	无	预测区间的置信水平。
fitted	bool	False	是否返回样本内预测。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

from statsforecast.models import AutoRegressive
from statsforecast.utils import AirPassengers as ap

# AutoRegressive's usage example
ar = AutoRegressive(lags=[12])
ar = ar.fit(y=ap)
y_hat_dict = ar.predict(h=4, level=[80])
y_hat_dict

指数平滑模型

SimpleSmooth

来源

简单指数平滑模型

 SimpleExponentialSmoothing (alpha:float, alias:str='SES', prediction_inte
                             rvals:Optional[statsforecast.utils.ConformalI
                             ntervals]=None)

*简单指数平滑模型。

使用所有过去观测值的加权平均，其中权重随时间呈指数衰减。适用于没有明显趋势或季节性的数据。假设有 $t$ 个观测值，一步预测由下式给出： $\hat{y}_{t+1} = \alpha y_t + (1-\alpha) \hat{y}_{t-1}$

权重衰减的速率 $0 \leq \alpha \leq 1$ 称为平滑参数。当 $\alpha = 1$ 时，SES 等同于朴素方法。*

	类型	默认值	详情
alpha	float		平滑参数。
alias	str	SES	模型的自定义名称。
prediction_intervals	可选	无	计算保形预测区间的信息。默认情况下，模型将计算原生预测区间。

来源

SimpleExponentialSmoothing.forecast

 SimpleExponentialSmoothing.forecast (y:numpy.ndarray, h:int,
                                      X:Optional[numpy.ndarray]=None, X_fu
                                      ture:Optional[numpy.ndarray]=None,
                                      level:Optional[List[int]]=None,
                                      fitted:bool=False)

*内存高效的简单指数平滑预测。

此方法避免了对象存储带来的内存负担。它类似于 fit_predict 但不存储信息。它假设您提前知道预测范围。*

	类型	默认值	详情
y	ndarray		形状为 (n, ) 的干净时间序列。
h	int		预测范围。
X	可选	无	形状为 (t, n_x) 的可选样本内外部变量。
X_future	可选	无	形状为 (h, n_x) 的可选外生变量。
level	可选	无	预测区间的置信水平 (0-100)。
fitted	bool	False	是否返回样本内预测。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

来源

SimpleExponentialSmoothing.fit

 SimpleExponentialSmoothing.fit (y:numpy.ndarray,
                                 X:Optional[numpy.ndarray]=None)

*拟合简单指数平滑模型。

将简单指数平滑模型拟合到时间序列（numpy 数组）y 和可选的外生变量（numpy 数组）X。*

	类型	默认值	详情
y	ndarray		形状为 (t, ) 的干净时间序列。
X	可选	无	形状为 (t, n_x) 的可选外生变量。
返回值			已拟合的简单指数平滑模型。

来源

SimpleExponentialSmoothing.predict

 SimpleExponentialSmoothing.predict (h:int,
                                     X:Optional[numpy.ndarray]=None,
                                     level:Optional[List[int]]=None)

使用已拟合的简单指数平滑模型进行预测。

	类型	默认值	详情
h	int		预测范围。
X	可选	无	形状为 (t, n_x) 的可选样本内外部变量。
level	可选	无	预测区间的置信水平 (0-100)。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

来源

SimpleExponentialSmoothing.predict_in_sample

 SimpleExponentialSmoothing.predict_in_sample ()

访问已拟合简单指数平滑模型的样本内预测。

from statsforecast.models import SimpleExponentialSmoothing
from statsforecast.utils import AirPassengers as ap

# SimpleExponentialSmoothing's usage example
ses = SimpleExponentialSmoothing(alpha=0.5)
ses = ses.fit(y=ap)
y_hat_dict = ses.predict(h=4)
y_hat_dict

SimpleSmoothOptimized

来源

简单指数平滑优化模型

 SimpleExponentialSmoothingOptimized (alias:str='SESOpt', prediction_inter
                                      vals:Optional[statsforecast.utils.Co
                                      nformalIntervals]=None)

*简单指数平滑模型。

平滑参数 $\alpha^*$ 通过最小化平方误差进行优化。*

	类型	默认值	详情
alias	str	SESOpt
prediction_intervals	可选	无	计算保形预测区间的信息。这是生成未来预测区间所需的。

来源

SimpleExponentialSmoothingOptimized.fit

 SimpleExponentialSmoothingOptimized.fit (y:numpy.ndarray,
                                          X:Optional[numpy.ndarray]=None)

*拟合简单指数平滑优化模型。

将简单指数平滑优化模型拟合到时间序列（numpy 数组）y 和可选的外生变量（numpy 数组）X。*

	类型	默认值	详情
y	ndarray		形状为 (t, ) 的干净时间序列。
X	可选	无	形状为 (t, n_x) 的可选外生变量。
返回值			已拟合的简单指数平滑优化模型。

来源

SimpleExponentialSmoothingOptimized.predict

 SimpleExponentialSmoothingOptimized.predict (h:int,
                                              X:Optional[numpy.ndarray]=No
                                              ne, level:Optional[List[int]
                                              ]=None)

使用已拟合的简单指数平滑优化模型进行预测。

	类型	默认值	详情
h	int		预测范围。
X	可选	无	形状为 (t, n_x) 的可选样本内外部变量。
level	可选	无	预测区间的置信水平 (0-100)。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

来源

SimpleExponentialSmoothingOptimized.predict_in_sample

 SimpleExponentialSmoothingOptimized.predict_in_sample ()

访问已拟合简单指数平滑优化模型的样本内预测。

来源

SimpleExponentialSmoothingOptimized.forecast

 SimpleExponentialSmoothingOptimized.forecast (y:numpy.ndarray, h:int,
                                               X:Optional[numpy.ndarray]=N
                                               one, X_future:Optional[nump
                                               y.ndarray]=None, level:Opti
                                               onal[List[int]]=None,
                                               fitted:bool=False)

*内存高效的简单指数平滑优化预测。

此方法避免了对象存储带来的内存负担。它类似于 fit_predict 但不存储信息。它假设您提前知道预测范围。*

	类型	默认值	详情
y	ndarray		形状为 (n, ) 的干净时间序列。
h	int		预测范围。
X	可选	无	形状为 (t, n_x) 的可选样本内外部变量。
X_future	可选	无	形状为 (h, n_x) 的可选外生变量。
level	可选	无	预测区间的置信水平 (0-100)。
fitted	bool	False	是否返回样本内预测。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

from statsforecast.models import SimpleExponentialSmoothingOptimized
from statsforecast.utils import AirPassengers as ap

# SimpleExponentialSmoothingOptimized's usage example
seso = SimpleExponentialSmoothingOptimized()
seso = seso.fit(y=ap)
y_hat_dict = seso.predict(h=4)
y_hat_dict

SeasonalSmooth

plt.plot(np.concatenate([ap[6:], seas_es.forecast(ap[6:], h=12)['mean']]))

来源

季节性指数平滑模型

 SeasonalExponentialSmoothing (season_length:int, alpha:float,
                               alias:str='SeasonalES', prediction_interval
                               s:Optional[statsforecast.utils.ConformalInt
                               ervals]=None)

*季节性指数平滑模型。

使用所有过去观测值的加权平均，其中权重随时间呈指数衰减。适用于没有明显趋势或季节性的数据。假设有 $t$ 个观测值和季节 $s$ ，一步预测由下式给出： $\hat{y}_{t+1,s} = \alpha y_t + (1-\alpha) \hat{y}_{t-1,s}$ *

	类型	默认值	详情
season_length	int		每单位时间的观测值数量。例如：24小时数据。
alpha	float		平滑参数。
alias	str	SeasonalES	模型的自定义名称。
prediction_intervals	可选	无	计算保形预测区间的信息。这是生成未来预测区间所需的。

来源

SeasonalExponentialSmoothing.fit

 SeasonalExponentialSmoothing.fit (y:numpy.ndarray,
                                   X:Optional[numpy.ndarray]=None)

*拟合季节性指数平滑模型。

将季节性指数平滑模型拟合到时间序列（numpy 数组）y 和可选的外生变量（numpy 数组）X。*

	类型	默认值	详情
y	ndarray		形状为 (t, ) 的干净时间序列。
X	可选	无	形状为 (t, n_x) 的可选外生变量。
返回值			已拟合的季节性指数平滑模型。

来源

SeasonalExponentialSmoothing.predict

 SeasonalExponentialSmoothing.predict (h:int,
                                       X:Optional[numpy.ndarray]=None,
                                       level:Optional[List[int]]=None)

使用已拟合的季节性指数平滑模型进行预测。

	类型	默认值	详情
h	int		预测范围。
X	可选	无	形状为 (t, n_x) 的可选样本内外部变量。
level	可选	无	预测区间的置信水平 (0-100)。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

来源

SeasonalExponentialSmoothing.predict_in_sample

 SeasonalExponentialSmoothing.predict_in_sample ()

访问已拟合季节性指数平滑模型的样本内预测。

来源

SeasonalExponentialSmoothing.forecast

 SeasonalExponentialSmoothing.forecast (y:numpy.ndarray, h:int,
                                        X:Optional[numpy.ndarray]=None, X_
                                        future:Optional[numpy.ndarray]=Non
                                        e, level:Optional[List[int]]=None,
                                        fitted:bool=False)

*内存高效的季节性指数平滑预测。

此方法避免了对象存储带来的内存负担。它类似于 fit_predict 但不存储信息。它假设您提前知道预测范围。*

	类型	默认值	详情
y	ndarray		形状为 (n, ) 的干净时间序列。
h	int		预测范围。
X	可选	无	形状为 (t, n_x) 的可选样本内外部变量。
X_future	可选	无	形状为 (h, n_x) 的可选外生变量。
level	可选	无	预测区间的置信水平 (0-100)。
fitted	bool	False	是否返回样本内预测。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

from statsforecast.models import SeasonalExponentialSmoothing
from statsforecast.utils import AirPassengers as ap

# SeasonalExponentialSmoothing's usage example
model = SeasonalExponentialSmoothing(alpha=0.5, season_length=12)
model = model.fit(y=ap)
y_hat_dict = model.predict(h=4)
y_hat_dict

SeasonalSmoothOptimized

来源

季节性指数平滑优化模型

 SeasonalExponentialSmoothingOptimized (season_length:int,
                                        alias:str='SeasESOpt', prediction_
                                        intervals:Optional[statsforecast.u
                                        tils.ConformalIntervals]=None)

*季节性指数平滑优化模型。

平滑参数 $\alpha^*$ 通过最小化平方误差进行优化。*

	类型	默认值	详情
season_length	int		每单位时间的观测值数量。例如：24小时数据。
alias	str	SeasESOpt	模型的自定义名称。
prediction_intervals	可选	无	计算保形预测区间的信息。这是生成未来预测区间所需的。

来源

SeasonalExponentialSmoothingOptimized.forecast

 SeasonalExponentialSmoothingOptimized.forecast (y:numpy.ndarray, h:int,
                                                 X:Optional[numpy.ndarray]
                                                 =None, X_future:Optional[
                                                 numpy.ndarray]=None, leve
                                                 l:Optional[List[int]]=Non
                                                 e, fitted:bool=False)

*内存高效的季节性指数平滑优化预测。

此方法避免了对象存储带来的内存负担。它类似于 fit_predict 但不存储信息。它假设您提前知道预测范围。*

	类型	默认值	详情
y	ndarray		形状为 (n, ) 的干净时间序列。
h	int		预测范围。
X	可选	无	形状为 (t, n_x) 的可选样本内外部变量。
X_future	可选	无	形状为 (h, n_x) 的可选外生变量。
level	可选	无	预测区间的置信水平 (0-100)。
fitted	bool	False	是否返回样本内预测。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

来源

SeasonalExponentialSmoothingOptimized.fit

 SeasonalExponentialSmoothingOptimized.fit (y:numpy.ndarray,
                                            X:Optional[numpy.ndarray]=None
                                            )

*拟合季节性指数平滑优化模型。

将季节性指数平滑优化模型拟合到时间序列（numpy 数组）y 和可选的外生变量（numpy 数组）X。*

	类型	默认值	详情
y	ndarray		形状为 (t, ) 的干净时间序列。
X	可选	无	形状为 (t, n_x) 的可选外生变量。
返回值			已拟合的季节性指数平滑优化模型。

来源

SeasonalExponentialSmoothingOptimized.predict

 SeasonalExponentialSmoothingOptimized.predict (h:int,
                                                X:Optional[numpy.ndarray]=
                                                None, level:Optional[List[
                                                int]]=None)

使用已拟合的季节性指数平滑优化模型进行预测。

	类型	默认值	详情
h	int		预测范围。
X	可选	无	形状为 (t, n_x) 的可选样本内外部变量。
level	可选	无	预测区间的置信水平 (0-100)。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

来源

SeasonalExponentialSmoothingOptimized.predict_in_sample

 SeasonalExponentialSmoothingOptimized.predict_in_sample ()

访问已拟合季节性指数平滑优化模型的样本内预测。

from statsforecast.models import SeasonalExponentialSmoothingOptimized
from statsforecast.utils import AirPassengers as ap

# SeasonalExponentialSmoothingOptimized's usage example
model = SeasonalExponentialSmoothingOptimized(season_length=12)
model = model.fit(y=ap)
y_hat_dict = model.predict(h=4)
y_hat_dict

Holt 方法

来源

Holt

 Holt (season_length:int=1, error_type:str='A', alias:str='Holt', predicti
       on_intervals:Optional[statsforecast.utils.ConformalIntervals]=None)

*Holt 方法。

也称为双指数平滑，Holt 方法是指数平滑的扩展，适用于具有趋势的序列。此实现返回相应的具有加法 (A) 或乘法 (M) 误差的 ETS 模型（即 'AAN' 或 'MAN'）。*

	类型	默认值	详情
season_length	int	1	每单位时间的观测值数量。例如：12 月度数据。
error_type	str	A	ETS 模型的误差类型。可以是加法 (A) 或乘法 (M)。
alias	str	Holt	模型的自定义名称。
prediction_intervals	可选	无	计算保形预测区间的信息。默认情况下，模型将计算原生预测区间。

来源

Holt.forecast

 Holt.forecast (y:numpy.ndarray, h:int, X:Optional[numpy.ndarray]=None,
                X_future:Optional[numpy.ndarray]=None,
                level:Optional[List[int]]=None, fitted:bool=False)

*内存高效的指数平滑预测。

此方法避免了对象存储带来的内存负担。它类似于 fit_predict 但不存储信息。它假设您提前知道预测范围。*

	类型	默认值	详情
y	ndarray		形状为 (n, ) 的干净时间序列。
h	int		预测范围。
X	可选	无	形状为 (t, n_x) 的可选样本内外部变量。
X_future	可选	无	形状为 (h, n_x) 的可选外生变量。
level	可选	无	预测区间的置信水平 (0-100)。
fitted	bool	False	是否返回样本内预测。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

来源

Holt.fit

 Holt.fit (y:numpy.ndarray, X:Optional[numpy.ndarray]=None)

*拟合指数平滑模型。

将指数平滑模型拟合到时间序列（numpy 数组）y 和可选的外生变量（numpy 数组）X。*

	类型	默认值	详情
y	ndarray		形状为 (t, ) 的干净时间序列。
X	可选	无	形状为 (t, n_x) 的可选外生变量。
返回值			已拟合的指数平滑模型。

来源

Holt.predict

 Holt.predict (h:int, X:Optional[numpy.ndarray]=None,
               level:Optional[List[int]]=None)

使用已拟合的指数平滑模型进行预测。

	类型	默认值	详情
h	int		预测范围。
X	可选	无	形状为 (h, n_x) 的可选外生变量。
level	可选	无	预测区间的置信水平 (0-100)。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

来源

Holt.predict_in_sample

 Holt.predict_in_sample (level:Optional[List[int]]=None)

访问已拟合指数平滑模型的样本内预测。

	类型	默认值	详情
level	可选	无	预测区间的置信水平 (0-100)。
返回值	dict		*字典，包含用于点预测的 `fitted` 条目和用于概率预测的 `level_` 条目。**

来源

Holt.forward

 Holt.forward (y:numpy.ndarray, h:int, X:Optional[numpy.ndarray]=None,
               X_future:Optional[numpy.ndarray]=None,
               level:Optional[List[int]]=None, fitted:bool=False)

将已拟合的指数平滑模型应用于新的时间序列。

	类型	默认值	详情
y	ndarray		形状为 (n, ) 的干净时间序列。
h	int		预测范围。
X	可选	无	形状为 (t, n_x) 的可选样本内外部变量。
X_future	可选	无	形状为 (h, n_x) 的可选外生变量。
level	可选	无	预测区间的置信水平。
fitted	bool	False	是否返回样本内预测。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

from statsforecast.models import Holt
from statsforecast.utils import AirPassengers as ap

# Holt's usage example
model = Holt(season_length=12, error_type='A')
model = model.fit(y=ap)
y_hat_dict = model.predict(h=4)
y_hat_dict

Holt-Winters 方法

来源

HoltWinters

 HoltWinters (season_length:int=1, error_type:str='A',
              alias:str='HoltWinters', prediction_intervals:Optional[stats
              forecast.utils.ConformalIntervals]=None)

*Holt-Winters 方法。

也称为三指数平滑，Holt-Winters 方法是指数平滑的扩展，适用于同时包含趋势和季节性的序列。此实现返回相应的具有加法 (A) 或乘法 (M) 误差的 ETS 模型（即 'AAA' 或 'MAM'）。*

	类型	默认值	详情
season_length	int	1	季节长度
error_type	str	A	误差类型
alias	str	HoltWinters	模型的自定义名称。
prediction_intervals	可选	无	计算保形预测区间的信息。默认情况下，模型将计算原生预测区间。

来源

HoltWinters.forecast

 HoltWinters.forecast (y:numpy.ndarray, h:int,
                       X:Optional[numpy.ndarray]=None,
                       X_future:Optional[numpy.ndarray]=None,
                       level:Optional[List[int]]=None, fitted:bool=False)

*内存高效的指数平滑预测。

此方法避免了对象存储带来的内存负担。它类似于 fit_predict 但不存储信息。它假设您提前知道预测范围。*

	类型	默认值	详情
y	ndarray		形状为 (n, ) 的干净时间序列。
h	int		预测范围。
X	可选	无	形状为 (t, n_x) 的可选样本内外部变量。
X_future	可选	无	形状为 (h, n_x) 的可选外生变量。
level	可选	无	预测区间的置信水平 (0-100)。
fitted	bool	False	是否返回样本内预测。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

来源

HoltWinters.fit

 HoltWinters.fit (y:numpy.ndarray, X:Optional[numpy.ndarray]=None)

*拟合指数平滑模型。

将指数平滑模型拟合到时间序列（numpy 数组）y 和可选的外生变量（numpy 数组）X。*

	类型	默认值	详情
y	ndarray		形状为 (t, ) 的干净时间序列。
X	可选	无	形状为 (t, n_x) 的可选外生变量。
返回值			已拟合的指数平滑模型。

来源

HoltWinters.predict

 HoltWinters.predict (h:int, X:Optional[numpy.ndarray]=None,
                      level:Optional[List[int]]=None)

使用已拟合的指数平滑模型进行预测。

	类型	默认值	详情
h	int		预测范围。
X	可选	无	形状为 (h, n_x) 的可选外生变量。
level	可选	无	预测区间的置信水平 (0-100)。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

来源

HoltWinters.predict_in_sample

 HoltWinters.predict_in_sample (level:Optional[List[int]]=None)

访问已拟合指数平滑模型的样本内预测。

	类型	默认值	详情
level	可选	无	预测区间的置信水平 (0-100)。
返回值	dict		*字典，包含用于点预测的 `fitted` 条目和用于概率预测的 `level_` 条目。**

来源

HoltWinters.forward

 HoltWinters.forward (y:numpy.ndarray, h:int,
                      X:Optional[numpy.ndarray]=None,
                      X_future:Optional[numpy.ndarray]=None,
                      level:Optional[List[int]]=None, fitted:bool=False)

将已拟合的指数平滑模型应用于新的时间序列。

	类型	默认值	详情
y	ndarray		形状为 (n, ) 的干净时间序列。
h	int		预测范围。
X	可选	无	形状为 (t, n_x) 的可选样本内外部变量。
X_future	可选	无	形状为 (h, n_x) 的可选外生变量。
level	可选	无	预测区间的置信水平。
fitted	bool	False	是否返回样本内预测。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

from statsforecast.models import HoltWinters
from statsforecast.utils import AirPassengers as ap

# Holt-Winters' usage example
model = HoltWinters(season_length=12, error_type='A')
model = model.fit(y=ap)
y_hat_dict = model.predict(h=4)
y_hat_dict

基线模型

HistoricAverage

来源

HistoricAverage

 HistoricAverage (alias:str='HistoricAverage', prediction_intervals:Option
                  al[statsforecast.utils.ConformalIntervals]=None)

*HistoricAverage 模型。

也称为均值方法。使用所有过去观测值的简单平均值。假设有 $t$ 个观测值，一步预测由下式给出： $\hat{y}_{t+1} = \frac{1}{t} \sum_{j=1}^t y_j$ *

	类型	默认值	详情
alias	str	HistoricAverage
prediction_intervals	可选	无	计算保形预测区间的信息。默认情况下，模型将计算原生预测区间。

来源

HistoricAverage.forecast

 HistoricAverage.forecast (y:numpy.ndarray, h:int,
                           X:Optional[numpy.ndarray]=None,
                           X_future:Optional[numpy.ndarray]=None,
                           level:Optional[List[int]]=None,
                           fitted:bool=False)

*内存高效的 HistoricAverage 预测。

此方法避免了对象存储带来的内存负担。它类似于 fit_predict 但不存储信息。它假设您提前知道预测范围。*

	类型	默认值	详情
y	ndarray		形状为 (n, ) 的干净时间序列。
h	int		预测范围。
X	可选	无	形状为 (t, n_x) 的可选样本内外部变量。
X_future	可选	无	形状为 (h, n_x) 的可选外生变量。
level	可选	无	预测区间的置信水平 (0-100)。
fitted	bool	False	是否返回样本内预测。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

来源

HistoricAverage.fit

 HistoricAverage.fit (y:numpy.ndarray, X:Optional[numpy.ndarray]=None)

*拟合 HistoricAverage 模型。

将 HistoricAverage 模型拟合到时间序列（numpy 数组）y。*

	类型	默认值	详情
y	ndarray		形状为 (t, ) 的干净时间序列。
X	可选	无	形状为 (t, n_x) 的可选外生变量。
返回值	self		已拟合的 HistoricAverage 模型。

来源

HistoricAverage.predict

 HistoricAverage.predict (h:int, X:Optional[numpy.ndarray]=None,
                          level:Optional[List[int]]=None)

使用已拟合的 HistoricAverage 进行预测。

	类型	默认值	详情
h	int		预测范围。
X	可选	无	形状为 (h, n_x) 的可选外生变量。
level	可选	无	预测区间的置信水平 (0-100)。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

来源

HistoricAverage.predict_in_sample

 HistoricAverage.predict_in_sample (level:Optional[List[int]]=None)

访问已拟合 HistoricAverage 的样本内预测。

	类型	默认值	详情
level	可选	无	预测区间的置信水平 (0-100)。
返回值	dict		字典，包含用于点预测的 `fitted` 条目。

from statsforecast.models import HistoricAverage
from statsforecast.utils import AirPassengers as ap

# HistoricAverage's usage example
model = HistoricAverage()
model = model.fit(y=ap)
y_hat_dict = model.predict(h=4)
y_hat_dict

Naive

来源

Naive

 Naive (alias:str='Naive', prediction_intervals:Optional[statsforecast.uti
        ls.ConformalIntervals]=None)

*朴素模型。

所有预测值都是最后一个观测值
$\hat{y}_{t+1} = y_t$ 对于所有 $t$ *

	类型	默认值	详情
alias	str	Naive
prediction_intervals	可选	无	计算保形预测区间的信息。默认情况下，模型将计算原生预测区间。

来源

Naive.forecast

 Naive.forecast (y:numpy.ndarray, h:int, X:Optional[numpy.ndarray]=None,
                 X_future:Optional[numpy.ndarray]=None,
                 level:Optional[List[int]]=None, fitted:bool=False)

*内存高效的 Naive 预测。

此方法避免了对象存储带来的内存负担。它类似于 fit_predict 但不存储信息。它假设您提前知道预测范围。*

	类型	默认值	详情
y	ndarray		形状为 (n,) 的干净时间序列。
h	int
X	可选	无	形状为 (t, n_x) 的可选样本内外部变量。
X_future	可选	无	形状为 (h, n_x) 的可选外生变量。
level	可选	无	预测区间的置信水平 (0-100)。
fitted	bool	False	是否返回样本内预测。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

来源

Naive.fit

 Naive.fit (y:numpy.ndarray, X:Optional[numpy.ndarray]=None)

*拟合 Naive 模型。

将 Naive 模型拟合到时间序列（numpy.array）y。*

	类型	默认值	详情
y	ndarray		形状为 (t, ) 的干净时间序列。
X	可选	无	形状为 (t, n_x) 的可选外生变量。
返回值	self		已拟合的 Naive 模型。

来源

Naive.predict

 Naive.predict (h:int, X:Optional[numpy.ndarray]=None,
                level:Optional[List[int]]=None)

使用已拟合的 Naive 进行预测。

	类型	默认值	详情
h	int		预测范围
X	可选	无	外生回归变量
level	可选	无	置信水平
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

来源

Naive.predict_in_sample

 Naive.predict_in_sample (level:Optional[List[int]]=None)

访问已拟合 Naive 的样本内预测。

	类型	默认值	详情
level	可选	无	预测区间的置信水平 (0-100)。
返回值	dict		字典，包含用于点预测的 `fitted` 条目。

from statsforecast.models import Naive
from statsforecast.utils import AirPassengers as ap

# Naive's usage example
model = Naive()
model = model.fit(y=ap)
y_hat_dict = model.predict(h=4)
y_hat_dict

带漂移的随机游走

来源

带漂移的随机游走

 RandomWalkWithDrift (alias:str='RWD', prediction_intervals:Optional[stats
                      forecast.utils.ConformalIntervals]=None)

*带漂移的随机游走模型。

朴素方法的一种变体，允许预测随时间变化。变化量称为漂移，它是历史数据中观察到的平均变化量。

$\hat{y}_{t+1} = y_t+\frac{1}{t-1}\sum_{j=1}^t (y_j-y_{j-1}) = y_t+ \frac{y_t-y_1}{t-1}$

从上式可以看出，这等同于在第一个和最后一个观测值之间进行直线外推。*

	类型	默认值	详情
alias	str	RWD	模型的自定义名称。
prediction_intervals	可选	无	计算保形预测区间的信息。默认情况下，模型将计算原生预测区间。

来源

RandomWalkWithDrift.forecast

 RandomWalkWithDrift.forecast (y:numpy.ndarray, h:int,
                               X:Optional[numpy.ndarray]=None,
                               X_future:Optional[numpy.ndarray]=None,
                               level:Optional[List[int]]=None,
                               fitted:bool=False)

*内存高效的带漂移随机游走预测。

此方法避免了对象存储带来的内存负担。它类似于 fit_predict 但不存储信息。它假设您提前知道预测范围。*

	类型	默认值	详情
y	ndarray		形状为 (n,) 的干净时间序列。
h	int		预测范围。
X	可选	无	形状为 (t, n_x) 的可选样本内外部变量。
X_future	可选	无	形状为 (h, n_x) 的可选外生变量。
level	可选	无	预测区间的置信水平 (0-100)。
fitted	bool	False	是否返回样本内预测。
返回值	forecasts: dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

来源

RandomWalkWithDrift.fit

 RandomWalkWithDrift.fit (y:numpy.ndarray, X:Optional[numpy.ndarray]=None)

*拟合带漂移的随机游走模型。

将带漂移的随机游走模型拟合到时间序列（numpy 数组）y。*

	类型	默认值	详情
y	ndarray
X	可选	无
返回值			已拟合的带漂移的随机游走模型。

来源

RandomWalkWithDrift.predict

 RandomWalkWithDrift.predict (h:int, X:Optional[numpy.ndarray]=None,
                              level:Optional[List[int]]=None)

使用已拟合的带漂移的随机游走模型进行预测。

	类型	默认值	详情
h	int		预测范围。
X	可选	无	形状为 (h, n_x) 的可选外生变量。
level	可选	无	预测区间的置信水平 (0-100)。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

来源

RandomWalkWithDrift.predict_in_sample

 RandomWalkWithDrift.predict_in_sample (level:Optional[List[int]]=None)

访问已拟合带漂移随机游走模型的样本内预测。

	类型	默认值	详情
level	可选	无	预测区间的置信水平 (0-100)。
返回值	dict		*字典，包含用于点预测的 `fitted` 条目和用于概率预测的 `level_` 条目。**

from statsforecast.models import RandomWalkWithDrift
from statsforecast.utils import AirPassengers as ap

# RandomWalkWithDrift's usage example
model = RandomWalkWithDrift()
model = model.fit(y=ap)
y_hat_dict = model.predict(h=4)
y_hat_dict

季节性朴素模型

来源

季节性朴素模型

 SeasonalNaive (season_length:int, alias:str='SeasonalNaive', prediction_i
                ntervals:Optional[statsforecast.utils.ConformalIntervals]=
                None)

*季节性朴素模型。

类似于朴素方法，但使用同一时期（例如，前一年的同月）的最后一个已知观测值，以便捕捉季节性变化。*

	类型	默认值	详情
season_length	int		每单位时间的观测值数量。例如：24小时数据。
alias	str	季节性朴素模型	模型的自定义名称。
prediction_intervals	可选	无	计算保形预测区间的信息。默认情况下，模型将计算原生预测区间。

来源

SeasonalNaive.forecast

 SeasonalNaive.forecast (y:numpy.ndarray, h:int,
                         X:Optional[numpy.ndarray]=None,
                         X_future:Optional[numpy.ndarray]=None,
                         level:Optional[List[int]]=None,
                         fitted:bool=False)

*内存高效的季节性朴素预测。

此方法避免了对象存储带来的内存负担。它类似于 fit_predict 但不存储信息。它假设您提前知道预测范围。*

	类型	默认值	详情
y	ndarray		形状为 (n, ) 的干净时间序列。
h	int		预测范围。
X	可选	无	形状为 (t, n_x) 的可选样本内外部变量。
X_future	可选	无	形状为 (h, n_x) 的可选外生变量。
level	可选	无	预测区间的置信水平 (0-100)。
fitted	bool	False	是否返回样本内预测。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

来源

SeasonalNaive.fit

 SeasonalNaive.fit (y:numpy.ndarray, X:Optional[numpy.ndarray]=None)

*拟合季节性朴素模型。

将季节性朴素模型拟合到时间序列（numpy 数组）y。*

	类型	默认值	详情
y	ndarray		形状为 (t, ) 的干净时间序列。
X	可选	无
返回值			已拟合的季节性朴素模型。

来源

SeasonalNaive.predict

 SeasonalNaive.predict (h:int, X:Optional[numpy.ndarray]=None,
                        level:Optional[List[int]]=None)

使用已拟合的 Naive 进行预测。

	类型	默认值	详情
h	int		预测范围。
X	可选	无
level	可选	无
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

来源

SeasonalNaive.predict_in_sample

 SeasonalNaive.predict_in_sample (level:Optional[List[int]]=None)

访问已拟合季节性朴素模型的样本内预测。

	类型	默认值	详情
level	可选	无	预测区间的置信水平 (0-100)。
返回值	dict		*字典，包含用于点预测的 `fitted` 条目和用于概率预测的 `level_` 条目。**

from statsforecast.models import SeasonalNaive
from statsforecast.utils import AirPassengers as ap

# SeasonalNaive's usage example
model = SeasonalNaive(season_length=12)
model = model.fit(y=ap)
y_hat_dict = model.predict(h=4)
y_hat_dict

窗口平均模型

来源

窗口平均模型

 WindowAverage (window_size:int, alias:str='WindowAverage', prediction_int
                ervals:Optional[statsforecast.utils.ConformalIntervals]=No
                ne)

*窗口平均模型。

使用最后 $k$ 个观测值的平均值，其中 $k$ 是窗口长度。更宽的窗口将捕捉全局趋势，而窄窗口将揭示局部趋势。选择的窗口长度应考虑过去观测值的重要性以及序列变化的快慢。*

	类型	默认值	详情
window_size	int		用于估计平均值的截断序列的大小。
alias	str	窗口平均模型	模型的自定义名称。
prediction_intervals	可选	无	计算保形预测区间的信息。这是生成未来预测区间所需的。

来源

WindowAverage.forecast

 WindowAverage.forecast (y:numpy.ndarray, h:int,
                         X:Optional[numpy.ndarray]=None,
                         X_future:Optional[numpy.ndarray]=None,
                         level:Optional[List[int]]=None,
                         fitted:bool=False)

*内存高效的窗口平均预测。

此方法避免了对象存储带来的内存负担。它类似于 fit_predict 但不存储信息。它假设您提前知道预测范围。*

	类型	默认值	详情
y	ndarray		形状为 (n, ) 的干净时间序列。
h	int		预测范围。
X	可选	无	形状为 (t, n_x) 的可选样本内外部变量。
X_future	可选	无	形状为 (h, n_x) 的可选外生变量。
level	可选	无	预测区间的置信水平 (0-100)。
fitted	bool	False	是否返回样本内预测。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

来源

WindowAverage.fit

 WindowAverage.fit (y:numpy.ndarray, X:Optional[numpy.ndarray]=None)

*拟合窗口平均模型。

将窗口平均模型拟合到时间序列（numpy 数组）y 和可选的外生变量（numpy 数组）X。*

	类型	默认值	详情
y	ndarray		形状为 (t, ) 的干净时间序列。
X	可选	无	形状为 (t, n_x) 的可选外生变量。
返回值			已拟合的窗口平均模型。

来源

WindowAverage.predict

 WindowAverage.predict (h:int, X:Optional[numpy.ndarray]=None,
                        level:Optional[List[int]]=None)

使用已拟合的窗口平均模型进行预测。

	类型	默认值	详情
h	int		预测范围。
X	可选	无	形状为 (h, n_x) 的可选外生变量。
level	可选	无	预测区间的置信水平 (0-100)。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

from statsforecast.models import WindowAverage
from statsforecast.utils import AirPassengers as ap

# WindowAverage's usage example
model = WindowAverage(window_size=12*4)
model = model.fit(y=ap)
y_hat_dict = model.predict(h=4)
y_hat_dict

季节性窗口平均模型

来源

季节性窗口平均模型

 SeasonalWindowAverage (season_length:int, window_size:int,
                        alias:str='SeasWA', prediction_intervals:Optional[
                        statsforecast.utils.ConformalIntervals]=None)

*季节性窗口平均模型。

同一时期最后 $k$ 个观测值的平均值，其中 $k$ 是窗口长度。*

	类型	默认值	详情
season_length	int
window_size	int		用于估计平均值的截断序列的大小。
alias	str	SeasWA	模型的自定义名称。
prediction_intervals	可选	无	计算保形预测区间的信息。这是生成未来预测区间所需的。

来源

SeasonalWindowAverage.forecast

 SeasonalWindowAverage.forecast (y:numpy.ndarray, h:int,
                                 X:Optional[numpy.ndarray]=None,
                                 X_future:Optional[numpy.ndarray]=None,
                                 level:Optional[List[int]]=None,
                                 fitted:bool=False)

*内存高效的季节性窗口平均预测。

此方法避免了对象存储带来的内存负担。它类似于 fit_predict 但不存储信息。它假设您提前知道预测范围。*

	类型	默认值	详情
y	ndarray		形状为 (n,) 的干净时间序列。
h	int		预测范围。
X	可选	无	形状为 (t, n_x) 的可选样本内外部变量。
X_future	可选	无	形状为 (h, n_x) 的可选外生变量。
level	可选	无	预测区间的置信水平。
fitted	bool	False	是否返回样本内预测。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

来源

SeasonalWindowAverage.fit

 SeasonalWindowAverage.fit (y:numpy.ndarray,
                            X:Optional[numpy.ndarray]=None)

*拟合季节性窗口平均模型。

将季节性窗口平均模型拟合到时间序列（numpy 数组）y 和可选的外生变量（numpy 数组）X。*

	类型	默认值	详情
y	ndarray		形状为 (t, ) 的干净时间序列。
X	可选	无	形状为 (t, n_x) 的可选外生变量。
返回值			已拟合的季节性窗口平均模型。

来源

SeasonalWindowAverage.predict

 SeasonalWindowAverage.predict (h:int, X:Optional[numpy.ndarray]=None,
                                level:Optional[List[int]]=None)

使用已拟合的季节性窗口平均模型进行预测。

	类型	默认值	详情
h	int		预测范围。
X	可选	无	形状为 (t, n_x) 的可选样本内外部变量。
level	可选	无	预测区间的置信水平 (0-100)。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

from statsforecast.models import SeasonalWindowAverage
from statsforecast.utils import AirPassengers as ap

# SeasonalWindowAverage's usage example
model = SeasonalWindowAverage(season_length=12, window_size=4)
model = model.fit(y=ap)
y_hat_dict = model.predict(h=4)
y_hat_dict

稀疏或间歇性模型

ADIDA

来源

ADIDA

 ADIDA (alias:str='ADIDA', prediction_intervals:Optional[statsforecast.uti
        ls.ConformalIntervals]=None)

*ADIDA 模型。

聚合-分解间歇需求方法 (Aggregate-Dissagregate Intermittent Demand Approach): 使用时间聚合来减少零观测值的数量。数据聚合后，它使用优化 SES 在新级别生成预测。然后使用等权重将预测分解到原始级别。

ADIDA 专注于稀疏或间歇性序列，即非零观测值非常少的序列。这些序列预测起来非常困难，因此开发了专门针对它们的不同方法。*

	类型	默认值	详情
alias	str	ADIDA	模型的自定义名称。
prediction_intervals	可选	无	计算保形预测区间的信息。默认情况下，模型将计算原生预测区间。

来源

ADIDA.forecast

 ADIDA.forecast (y:numpy.ndarray, h:int, X:Optional[numpy.ndarray]=None,
                 X_future:Optional[numpy.ndarray]=None,
                 level:Optional[List[int]]=None, fitted:bool=False)

*内存高效的 ADIDA 预测。

此方法避免了对象存储带来的内存负担。它类似于 fit_predict 但不存储信息。它假设您提前知道预测范围。*

	类型	默认值	详情
y	ndarray		形状为 (n,) 的干净时间序列。
h	int		预测范围。
X	可选	无	形状为 (t, n_x) 的可选样本内外部变量。
X_future	可选	无	形状为 (h, n_x) 的可选外生变量。
level	可选	无	预测区间的置信水平 (0-100)。
fitted	bool	False	是否返回样本内预测。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

来源

ADIDA.fit

 ADIDA.fit (y:numpy.ndarray, X:Optional[numpy.ndarray]=None)

*拟合 ADIDA 模型。

将 ADIDA 模型拟合到时间序列（numpy 数组）y。*

	类型	默认值	详情
y	ndarray		形状为 (t, ) 的干净时间序列。
X	可选	无
返回值			ADIDA 拟合模型。

来源

ADIDA.predict

 ADIDA.predict (h:int, X:Optional[numpy.ndarray]=None,
                level:Optional[List[int]]=None)

使用拟合的 ADIDA 进行预测。

	类型	默认值	详情
h	int		预测范围。
X	可选	无	形状为 (h, n_x) 的可选外生变量。
level	可选	无	预测区间的置信水平 (0-100)。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

from statsforecast.models import ADIDA
from statsforecast.utils import AirPassengers as ap

# ADIDA's usage example
model = ADIDA()
model = model.fit(y=ap)
y_hat_dict = model.predict(h=4)
y_hat_dict

CrostonClassic

来源

CrostonClassic

 CrostonClassic (alias:str='CrostonClassic', prediction_intervals:Optional
                 [statsforecast.utils.ConformalIntervals]=None)

*CrostonClassic 模型。

一种用于预测间歇性需求时间序列的方法。它将原始时间序列分解为非零需求量 $z_t$ 和需求间隔 $p_t$ 。预测结果由以下公式给出： $\hat{y}_t = \frac{\hat{z}_t}{\hat{p}_t}$

其中 $\hat{z}_t$ 和 $\hat{p}_t$ 使用 SES 进行预测。两个分量的平滑参数都设置为 0.1*

	类型	默认值	详情
alias	str	CrostonClassic	模型的自定义名称。
prediction_intervals	可选	无	计算保形预测区间的信息。默认情况下，模型将计算原生预测区间。

来源

CrostonClassic.forecast

 CrostonClassic.forecast (y:numpy.ndarray, h:int,
                          X:Optional[numpy.ndarray]=None,
                          X_future:Optional[numpy.ndarray]=None,
                          level:Optional[List[int]]=None,
                          fitted:bool=False)

*内存高效的 CrostonClassic 预测。

此方法避免了对象存储带来的内存负担。它类似于 fit_predict 但不存储信息。它假设您提前知道预测范围。*

	类型	默认值	详情
y	ndarray		形状为 (n, ) 的干净时间序列。
h	int		预测范围。
X	可选	无	形状为 (t, n_x) 的可选样本内外部变量。
X_future	可选	无	形状为 (h, n_x) 的可选外生变量。
level	可选	无	预测区间的置信水平 (0-100)。
fitted	bool	False	是否返回样本内预测。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

来源

CrostonClassic.fit

 CrostonClassic.fit (y:numpy.ndarray, X:Optional[numpy.ndarray]=None)

*拟合 CrostonClassic 模型。

将 CrostonClassic 模型拟合到时间序列（numpy 数组）y。*

	类型	默认值	详情
y	ndarray		形状为 (t, ) 的干净时间序列。
X	可选	无
返回值			CrostonClassic 拟合模型。

来源

CrostonClassic.predict

 CrostonClassic.predict (h:int, X:Optional[numpy.ndarray]=None,
                         level:Optional[List[int]]=None)

使用拟合的 CrostonClassic 进行预测。

	类型	默认值	详情
h	int		预测范围。
X	可选	无	形状为 (h, n_x) 的可选外生变量。
level	可选	无	预测区间的置信水平 (0-100)。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

from statsforecast.models import CrostonClassic
from statsforecast.utils import AirPassengers as ap

# CrostonClassic's usage example
model = CrostonClassic()
model = model.fit(y=ap)
y_hat_dict = model.predict(h=4)
y_hat_dict

CrostonOptimized

来源

CrostonOptimized

 CrostonOptimized (alias:str='CrostonOptimized', prediction_intervals:Opti
                   onal[statsforecast.utils.ConformalIntervals]=None)

*CrostonOptimized 模型。

经典 Croston 方法的一个变体，其中平滑参数从范围 $[0.1,0.3]$ 中最优选择。非零需求量 $z_t$ 和需求间隔 $p_t$ 都分别进行平滑处理，因此它们的平滑参数可以不同。*

	类型	默认值	详情
alias	str	CrostonOptimized	模型的自定义名称。
prediction_intervals	可选	无	计算保形预测区间的信息。这是生成未来预测区间所需的。

来源

CrostonOptimized.forecast

 CrostonOptimized.forecast (y:numpy.ndarray, h:int,
                            X:Optional[numpy.ndarray]=None,
                            X_future:Optional[numpy.ndarray]=None,
                            level:Optional[List[int]]=None,
                            fitted:bool=False)

*内存高效的 CrostonOptimized 预测。

此方法避免了对象存储带来的内存负担。它类似于 fit_predict 但不存储信息。它假设您提前知道预测范围。*

	类型	默认值	详情
y	ndarray		形状为 (n, ) 的干净时间序列。
h	int		预测范围。
X	可选	无	形状为 (t, n_x) 的可选样本内外部变量。
X_future	可选	无	形状为 (h, n_x) 的可选外生变量。
level	可选	无
fitted	bool	False	是否返回样本内预测。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

来源

CrostonOptimized.fit

 CrostonOptimized.fit (y:numpy.ndarray, X:Optional[numpy.ndarray]=None)

*拟合 CrostonOptimized 模型。

将 CrostonOptimized 模型拟合到时间序列（numpy 数组）y。*

	类型	默认值	详情
y	ndarray		形状为 (t, ) 的干净时间序列。
X	可选	无
返回值			CrostonOptimized 拟合模型。

来源

CrostonOptimized.predict

 CrostonOptimized.predict (h:int, X:Optional[numpy.ndarray]=None,
                           level:Optional[List[int]]=None)

使用拟合的 CrostonOptimized 进行预测。

	类型	默认值	详情
h	int		预测范围。
X	可选	无	形状为 (t, n_x) 的可选样本内外部变量。
level	可选	无	预测区间的置信水平 (0-100)。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

from statsforecast.models import CrostonOptimized
from statsforecast.utils import AirPassengers as ap

# CrostonOptimized's usage example
model = CrostonOptimized()
model = model.fit(y=ap)
y_hat_dict = model.predict(h=4)
y_hat_dict

CrostonSBA

来源

CrostonSBA

 CrostonSBA (alias:str='CrostonSBA', prediction_intervals:Optional[statsfo
             recast.utils.ConformalIntervals]=None)

*CrostonSBA 模型。

经典 Croston 方法的一个变体，使用了去偏差因子，因此预测结果由以下公式给出： $\hat{y}_t = 0.95 \frac{\hat{z}_t}{\hat{p}_t}$ *

	类型	默认值	详情
alias	str	CrostonSBA	模型的自定义名称。
prediction_intervals	可选	无	计算保形预测区间的信息。默认情况下，模型将计算原生预测区间。

来源

CrostonSBA.forecast

 CrostonSBA.forecast (y:numpy.ndarray, h:int,
                      X:Optional[numpy.ndarray]=None,
                      X_future:Optional[numpy.ndarray]=None,
                      level:Optional[List[int]]=None, fitted:bool=False)

*内存高效的 CrostonSBA 预测。

此方法避免了对象存储带来的内存负担。它类似于 fit_predict 但不存储信息。它假设您提前知道预测范围。*

	类型	默认值	详情
y	ndarray		形状为 (n, ) 的干净时间序列。
h	int		预测范围。
X	可选	无	形状为 (t, n_x) 的可选样本内外部变量。
X_future	可选	无	形状为 (h, n_x) 的可选外生变量。
level	可选	无	预测区间的置信水平 (0-100)。
fitted	bool	False	是否返回样本内预测。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

来源

CrostonSBA.fit

 CrostonSBA.fit (y:numpy.ndarray, X:Optional[numpy.ndarray]=None)

*拟合 CrostonSBA 模型。

将 CrostonSBA 模型拟合到时间序列（numpy 数组）y。*

	类型	默认值	详情
y	ndarray		形状为 (t, ) 的干净时间序列。
X	可选	无
返回值			CrostonSBA 拟合模型。

来源

CrostonSBA.predict

 CrostonSBA.predict (h:int, X:Optional[numpy.ndarray]=None,
                     level:Optional[List[int]]=None)

使用拟合的 CrostonSBA 进行预测。

	类型	默认值	详情
h	int		预测范围。
X	可选	无	形状为 (h, n_x) 的可选外生变量。
level	可选	无	预测区间的置信水平 (0-100)。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

from statsforecast.models import CrostonSBA
from statsforecast.utils import AirPassengers as ap

# CrostonSBA's usage example
model = CrostonSBA()
model = model.fit(y=ap)
y_hat_dict = model.predict(h=4)
y_hat_dict

IMAPA

来源

IMAPA

 IMAPA (alias:str='IMAPA', prediction_intervals:Optional[statsforecast.uti
        ls.ConformalIntervals]=None)

*IMAPA 模型。

间歇性多重聚合预测算法：类似于 ADIDA，但不是使用单一聚合级别，而是考虑多个级别以捕获数据的不同动态。使用优化后的 SES 在新级别生成预测，然后使用简单平均值进行组合。*

	类型	默认值	详情
alias	str	IMAPA	模型的自定义名称。
prediction_intervals	可选	无	计算保形预测区间的信息。默认情况下，模型将计算原生预测区间。

来源

IMAPA.forecast

 IMAPA.forecast (y:numpy.ndarray, h:int, X:Optional[numpy.ndarray]=None,
                 X_future:Optional[numpy.ndarray]=None,
                 level:Optional[List[int]]=None, fitted:bool=False)

*内存高效的 IMAPA 预测。

此方法避免了对象存储带来的内存负担。它类似于 fit_predict 但不存储信息。它假设您提前知道预测范围。*

	类型	默认值	详情
y	ndarray		形状为 (n, ) 的干净时间序列。
h	int		预测范围。
X	可选	无	形状为 (t, n_x) 的可选样本内外部变量。
X_future	可选	无	形状为 (h, n_x) 的可选外生变量。
level	可选	无	预测区间的置信水平 (0-100)。
fitted	bool	False	是否返回样本内预测。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

来源

IMAPA.fit

 IMAPA.fit (y:numpy.ndarray, X:Optional[numpy.ndarray]=None)

*拟合 IMAPA 模型。

将 IMAPA 模型拟合到时间序列（numpy 数组）y。*

	类型	默认值	详情
y	ndarray		形状为 (t, ) 的干净时间序列。
X	可选	无
返回值			IMAPA 拟合模型。

来源

IMAPA.predict

 IMAPA.predict (h:int, X:Optional[numpy.ndarray]=None,
                level:Optional[List[int]]=None)

使用拟合的 IMAPA 进行预测。

	类型	默认值	详情
h	int		预测范围。
X	可选	无
level	可选	无
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

from statsforecast.models import IMAPA
from statsforecast.utils import AirPassengers as ap

# IMAPA's usage example
model = IMAPA()
model = model.fit(y=ap)
y_hat_dict = model.predict(h=4)
y_hat_dict

TSB

来源

TSB

 TSB (alpha_d:float, alpha_p:float, alias:str='TSB', prediction_intervals:
      Optional[statsforecast.utils.ConformalIntervals]=None)

*TSB 模型。

Teunter-Syntetos-Babai：Croston 方法的一个修改版，用需求概率 $d_t$ 替换了需求间隔，定义如下。

d_t = \begin{cases} 1 & \text{if demand occurs at time t} \\ 0 & \text{otherwise.} \end{cases}

因此，预测结果由以下公式给出

$\hat{y}_t= \hat{d}_t\hat{z_t}$

其中 $d_t$ 和 $z_t$ 都使用 SES 进行预测。它们的平滑参数可以不同，类似于优化后的 Croston 方法。*

	类型	默认值	详情
alpha_d	float		需求平滑参数。
alpha_p	float		概率平滑参数。
alias	str	TSB	模型的自定义名称。
prediction_intervals	可选	无	计算保形预测区间的信息。这是生成未来预测区间所需的。

来源

TSB.forecast

 TSB.forecast (y:numpy.ndarray, h:int, X:Optional[numpy.ndarray]=None,
               X_future:Optional[numpy.ndarray]=None,
               level:Optional[List[int]]=None, fitted:bool=False)

*内存高效的 TSB 预测。

此方法避免了对象存储带来的内存负担。它类似于 fit_predict 但不存储信息。它假设您提前知道预测范围。*

	类型	默认值	详情
y	ndarray		形状为 (n, ) 的干净时间序列。
h	int		预测范围。
X	可选	无	形状为 (t, n_x) 的可选样本内外部变量。
X_future	可选	无	形状为 (h, n_x) 的可选外生变量。
level	可选	无
fitted	bool	False	是否返回样本内预测。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

来源

TSB.fit

 TSB.fit (y:numpy.ndarray, X:Optional[numpy.ndarray]=None)

*拟合 TSB 模型。

将 TSB 模型拟合到时间序列（numpy 数组）y。*

	类型	默认值	详情
y	ndarray		形状为 (t, ) 的干净时间序列。
X	可选	无
返回值			TSB 拟合模型。

来源

TSB.predict

 TSB.predict (h:int, X:Optional[numpy.ndarray]=None,
              level:Optional[List[int]]=None)

使用拟合的 TSB 进行预测。

	类型	默认值	详情
h	int		预测范围。
X	可选	无
level	可选	无	预测区间的置信水平 (0-100)。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

from statsforecast.models import TSB
from statsforecast.utils import AirPassengers as ap

# TSB's usage example
model = TSB(alpha_d=0.5, alpha_p=0.5)
model = model.fit(y=ap)
y_hat_dict = model.predict(h=4)
y_hat_dict

多重季节性

MSTL

来源

MSTL

 MSTL (season_length:Union[int,List[int]], trend_forecaster=AutoETS,
       stl_kwargs:Optional[Dict]=None, alias:str='MSTL', prediction_interv
       als:Optional[statsforecast.utils.ConformalIntervals]=None)

*MSTL 模型。

MSTL（使用 LOESS 的多重季节-趋势分解）使用 LOESS 将时间序列分解为多个季节性分量。然后使用自定义非季节模型预测趋势，并使用 SeasonalNaive 模型预测每个季节性分量。*

	类型	默认值	详情
season_length	Union		每个时间单位的观测数量。对于多重季节性，请使用列表。
trend_forecaster	AutoETS	AutoETS	用于预测趋势分量的 StatsForecast 模型。
stl_kwargs	可选	无	传递给 `statsmodels.tsa.seasonal.STL` 的额外参数。参数 `period` 和 `seasonal` 是保留的。
alias	str	MSTL	模型的自定义名称。
prediction_intervals	可选	无	计算保形预测区间的信息。默认情况下，模型将计算原生预测区间。

来源

MSTL.fit

 MSTL.fit (y:numpy.ndarray, X:Optional[numpy.ndarray]=None)

*拟合 MSTL 模型。

将 MSTL 模型拟合到时间序列（numpy 数组）y。*

	类型	默认值	详情
y	ndarray		形状为 (t, ) 的干净时间序列。
X	可选	无
返回值			MSTL 拟合模型。

来源

MSTL.predict

 MSTL.predict (h:int, X:Optional[numpy.ndarray]=None,
               level:Optional[List[int]]=None)

使用拟合的 MSTL 进行预测。

	类型	默认值	详情
h	int		预测范围。
X	可选	无	形状为 (h, n_x) 的可选外生变量。
level	可选	无	预测区间的置信水平 (0-100)。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

来源

MSTL.predict_in_sample

 MSTL.predict_in_sample (level:Optional[List[int]]=None)

访问拟合 MSTL 的样本内预测。

	类型	默认值	详情
level	可选	无	预测区间的置信水平 (0-100)。
返回值	dict		*字典，包含用于点预测的 `fitted` 条目和用于概率预测的 `level_` 条目。**

来源

MSTL.forecast

 MSTL.forecast (y:numpy.ndarray, h:int, X:Optional[numpy.ndarray]=None,
                X_future:Optional[numpy.ndarray]=None,
                level:Optional[List[int]]=None, fitted:bool=False)

*内存高效的 MSTL 预测。

此方法避免了对象存储带来的内存负担。它类似于 fit_predict 但不存储信息。它假设您提前知道预测范围。*

	类型	默认值	详情
y	ndarray		形状为 (n, ) 的干净时间序列。
h	int		预测范围。
X	可选	无	形状为 (t, n_x) 的可选样本内外部变量。
X_future	可选	无	形状为 (h, n_x) 的可选外生变量。
level	可选	无	预测区间的置信水平 (0-100)。
fitted	bool	False	是否返回样本内预测。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

来源

MSTL.forward

 MSTL.forward (y:numpy.ndarray, h:int, X:Optional[numpy.ndarray]=None,
               X_future:Optional[numpy.ndarray]=None,
               level:Optional[List[int]]=None, fitted:bool=False)

将拟合的 MSTL 模型应用于新的时间序列。

	类型	默认值	详情
y	ndarray		形状为 (n, ) 的干净时间序列。
h	int		预测范围。
X	可选	无	形状为 (t, n_x) 的可选样本内外部变量。
X_future	可选	无	形状为 (h, n_x) 的可选外生变量。
level	可选	无	预测区间的置信水平 (0-100)。
fitted	bool	False	是否返回样本内预测。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

from statsforecast.models import MSTL
from statsforecast.utils import AirPassengers as ap

# MSTL's usage example
mstl_model = MSTL(season_length=[3, 12], trend_forecaster=AutoARIMA(prediction_intervals=ConformalIntervals(h=4, n_windows=2)))
mstl_model = mstl_model.fit(y=ap)
y_hat_dict = mstl_model.predict(h=4, level=[80])
y_hat_dict

MFLES

来源

MFLES

 MFLES (season_length:Union[int,List[int],NoneType]=None,
        fourier_order:Optional[int]=None, max_rounds:int=50,
        ma:Optional[int]=None, alpha:float=1.0, decay:float=-1.0,
        changepoints:bool=True, n_changepoints:Union[float,int]=0.25,
        seasonal_lr:float=0.9, trend_lr:float=0.9, exogenous_lr:float=1.0,
        residuals_lr:float=1.0, cov_threshold:float=0.7,
        moving_medians:bool=False, min_alpha:float=0.05,
        max_alpha:float=1.0, trend_penalty:bool=True,
        multiplicative:Optional[bool]=None, smoother:bool=False,
        robust:Optional[bool]=None, verbose:bool=False, prediction_interva
        ls:Optional[statsforecast.utils.ConformalIntervals]=None,
        alias:str='MFLES')

*MFLES 模型。

一种基于梯度提升时间序列分解的时间序列预测方法，将传统分解作为提升过程中的基础估计器。与普通梯度提升不同，对分量级别（趋势/季节性/外生变量）应用较小的学习率。

该方法得名于可用于提升过程的一些基础估计器，具体包括：简单的中位数、用于季节性的傅里叶函数、简单/分段线性趋势和指数平滑。*

	类型	默认值	详情
season_length	Union	无	每单位时间的观测值数量。例如：24小时数据。
fourier_order	可选	无	要创建多少对傅里叶正弦/余弦项，数字越大，可以拟合的季节模式越复杂。数字越小，结果越平滑。这会根据 seasonal_period 自动设置。
max_rounds	int	50	最大提升轮数。提升过程会自动停止，但根据 rs_lr 等其他参数，您可能需要更多轮次。通常，更多轮次意味着更平滑的拟合。
ma	可选	无	要使用的移动平均阶数，这会根据内部逻辑自动设置。传递 4 将在残差分量上拟合 4 周期移动平均值。
alpha	float	1.0	在使用分段函数时，用于拟合底层 LASSO 的 alpha 值。
decay	float	-1.0	影响分段线性基函数的斜率。
changepoints	bool	True	如果所有其他逻辑都允许，是否拟合变化点。如果设置为 False，MFLES 将永远不会拟合分段趋势。
n_changepoints	Union	0.25	要放置的变化点结点的数量（如果是 int）或比例（如果是 float）。默认值 0.25 将放置 0.25 * (序列长度) 个结点。
seasonal_lr	float	0.9	一个收缩参数 (0 < seasonal_lr <= 1)，用于惩罚季节性拟合。值为 0.9 将在每个提升轮次中直接将季节性拟合乘以 0.9，这可用于将更多信号传递给外生分量。
trend_lr	float	0.9	一个收缩参数 (0 < trend_lr <= 1)，用于惩罚线性趋势拟合值为 0.9 将在每个提升轮次中直接将线性拟合乘以 0.9，这可用于将更多信号传递给季节性或外生分量。
exogenous_lr	float	1.0	收缩参数 (0 < exogenous_lr <= 1)，控制外生信号有多少传递到下一轮次。
residuals_lr	float	1.0	一个收缩参数 (0 < residuals_lr <= 1)，用于惩罚残差平滑。值为 0.9 将在每个提升轮次中直接将残差拟合乘以 0.9，这可用于将更多信号传递给季节性或线性分量。
cov_threshold	float	0.7	去季节化协方差用于自动设置某些逻辑，降低 cov_threshold 会导致更简单、复杂性更低的残差平滑。如果传入 1000 之类的数值，将不会应用任何保护措施。
moving_medians	bool	False	默认行为是将初始中位数拟合到时间序列。如果设置为 True，则会对每个季节周期拟合一个中位数。
min_alpha	float	0.05	SES 集成的最小 alpha 值。
max_alpha	float	1.0	SES 集成的最大 alpha 值。
trend_penalty	bool	True	是否对线性趋势分量应用简单惩罚，这对于处理潜在危险的分段趋势非常有用。
multiplicative	可选	无	根据内部逻辑自动设置。如果设置为 True，则会简单地取时间序列的对数。
smoother	bool	False	如果设置为 True，则将使用简单的指数集成而不是自动设置。
robust	可选	无	如果设置为 True，则 MFLES 将使用更保守的方法进行拟合，即不使用分段趋势或移动平均残差平滑器。根据内部逻辑自动设置。
verbose	bool	False	打印调试信息。
prediction_intervals	可选	无	计算保形预测区间的信息。这是生成未来预测区间所需的。
alias	str	MFLES	模型的自定义名称。

来源

MFLES.fit

 MFLES.fit (y:numpy.ndarray, X:Optional[numpy.ndarray]=None)

拟合模型

	类型	默认值	详情
y	ndarray		形状为 (t, ) 的干净时间序列。
X	可选	无	形状为 (t, n_x) 的外部变量。
返回值	MFLES		拟合的 MFLES 对象。

来源

MFLES.predict

 MFLES.predict (h:int, X:Optional[numpy.ndarray]=None,
                level:Optional[List[int]]=None)

使用拟合的 MFLES 进行预测。

	类型	默认值	详情
h	int		预测范围。
X	可选	无	形状为 (h, n_x) 的外部变量。
level	可选	无
返回值	Dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

来源

MFLES.predict_in_sample

 MFLES.predict_in_sample (level:Optional[List[int]]=None)

访问拟合 SklearnModel 的样本内预测。

	类型	默认值	详情
level	可选	无	预测区间的置信水平 (0-100)。
返回值	Dict		*字典，包含用于点预测的 `fitted` 条目和用于概率预测的 `level_` 条目。**

来源

MFLES.forecast

 MFLES.forecast (y:numpy.ndarray, h:int, X:Optional[numpy.ndarray]=None,
                 X_future:Optional[numpy.ndarray]=None,
                 level:Optional[List[int]]=None, fitted:bool=False)

*内存高效的 MFLES 预测。

此方法避免了对象存储带来的内存负担。它类似于 fit_predict 但不存储信息。它假设您提前知道预测范围。*

	类型	默认值	详情
y	ndarray		形状为 (t, ) 的干净时间序列。
h	int		预测范围。
X	可选	无	形状为 (t, n_x) 的样本内外部变量。
X_future	可选	无	形状为 (h, n_x) 的外部变量。
level	可选	无	预测区间的置信水平 (0-100)。
fitted	bool	False	是否返回样本内预测。
返回值	Dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

TBATS

来源

TBATS

 TBATS (season_length:Union[int,List[int]],
        use_boxcox:Optional[bool]=True, bc_lower_bound:float=0.0,
        bc_upper_bound:float=1.0, use_trend:Optional[bool]=True,
        use_damped_trend:Optional[bool]=False, use_arma_errors:bool=False,
        alias:str='TBATS')

*三角 Box-Cox 变换、ARMA 误差、趋势和季节性分量 (TBATS) 模型。

TBATS 是一种创新状态空间模型框架，用于预测具有多重季节性的时间序列。它使用 Box-Cox 变换、ARMA 误差以及基于傅里叶级数的季节模式的三角表示。

TBATS 这个名称是该模型关键特征的首字母缩写：三角 (Trigonometric)、Box-Cox 变换 (Box-Cox transform)、ARMA 误差 (ARMA errors)、趋势 (Trend) 和季节性分量 (Seasonal components)。*

	类型	默认值	详情
season_length	Union		每单位时间的观测值数量。例如：24小时数据。
use_boxcox	可选	True	是否使用 Box-Cox 变换。
bc_lower_bound	float	0.0	Box-Cox 变换的下限。
bc_upper_bound	float	1.0	Box-Cox 变换的上限。
use_trend	可选	True	是否使用趋势分量。
use_damped_trend	可选	False	是否抑制趋势分量。
use_arma_errors	bool	False	是否使用 ARMA 误差。
alias	str	TBATS	模型的自定义名称。

来源

TBATS.fit

 TBATS.fit (y:numpy.ndarray, X:Optional[numpy.ndarray]=None)

*拟合 TBATS 模型。

将 TBATS 模型拟合到时间序列（numpy 数组）y。*

	类型	默认值	详情
y	ndarray		形状为 (t, ) 的干净时间序列。
X	可选	无	忽略
返回值			TBATS 模型。

来源

TBATS.predict

 TBATS.predict (h:int, X:Optional[numpy.ndarray]=None,
                level:Optional[List[int]]=None)

使用已拟合的 TBATS 模型进行预测。

	类型	默认值	详情
h	int		预测范围。
X	可选	无
level	可选	无	预测区间的置信水平 (0-100)。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

来源

TBATS.predict_in_sample

 TBATS.predict_in_sample (level:Optional[Tuple[int]]=None)

访问已拟合 TBATS 模型的预测。

	类型	默认值	详情
level	可选	无	预测区间的置信水平 (0-100)。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

来源

TBATS.forecast

 TBATS.forecast (y:numpy.ndarray, h:int, X:Optional[numpy.ndarray]=None,
                 X_future:Optional[numpy.ndarray]=None,
                 level:Optional[List[int]]=None, fitted:bool=False)

*内存高效的 TBATS 模型。

此方法避免了对象存储带来的内存负担。它类似于 fit_predict 但不存储信息。它假设您提前知道预测范围。*

	类型	默认值	详情
y	ndarray		形状为 (n, ) 的干净时间序列。
h	int		预测范围。
X	可选	无
X_future	可选	无
level	可选	无	预测区间的置信水平 (0-100)。
fitted	bool	False	是否返回样本内预测。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

Theta 系列

标准 Theta 方法

来源

Theta

 Theta (season_length:int=1, decomposition_type:str='multiplicative',
        alias:str='Theta', prediction_intervals:Optional[statsforecast.uti
        ls.ConformalIntervals]=None)

标准 Theta 方法。

	类型	默认值	详情
season_length	int	1	每单位时间的观测值数量。例如：24小时数据。
decomposition_type	str	multiplicative	季节分解类型，'multiplicative'（默认）或 'additive'。
alias	str	Theta	模型的自定义名称。
prediction_intervals	可选	无	计算保形预测区间的信息。默认情况下，模型将计算原生预测区间。

来源

Theta.forecast

 Theta.forecast (y:numpy.ndarray, h:int, X:Optional[numpy.ndarray]=None,
                 X_future:Optional[numpy.ndarray]=None,
                 level:Optional[List[int]]=None, fitted:bool=False)

*内存高效的 AutoTheta 预测。

此方法避免了对象存储带来的内存负担。它类似于 fit_predict 但不存储信息。它假设您提前知道预测范围。*

	类型	默认值	详情
y	ndarray		形状为 (n, ) 的干净时间序列。
h	int		预测范围。
X	可选	无	形状为 (t, n_x) 的可选样本内外部变量。
X_future	可选	无	形状为 (h, n_x) 的可选外生变量。
level	可选	无	预测区间的置信水平 (0-100)。
fitted	bool	False	是否返回样本内预测。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

来源

Theta.fit

 Theta.fit (y:numpy.ndarray, X:Optional[numpy.ndarray]=None)

*拟合 AutoTheta 模型。

将 AutoTheta 模型拟合到时间序列（numpy 数组）y 和可选的外生变量（numpy 数组）X。*

	类型	默认值	详情
y	ndarray		形状为 (t, ) 的干净时间序列。
X	可选	无	形状为 (t, n_x) 的可选外生变量。
返回值			已拟合的 AutoTheta 模型。

来源

Theta.predict

 Theta.predict (h:int, X:Optional[numpy.ndarray]=None,
                level:Optional[List[int]]=None)

使用已拟合的 AutoTheta 进行预测。

	类型	默认值	详情
h	int		预测范围。
X	可选	无	形状为 (h, n_x) 的可选外生变量。
level	可选	无	预测区间的置信水平 (0-100)。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

来源

Theta.predict_in_sample

 Theta.predict_in_sample (level:Optional[List[int]]=None)

访问已拟合 AutoTheta 的样本内预测。

	类型	默认值	详情
level	可选	无	预测区间的置信水平 (0-100)。
返回值	dict		*字典，包含用于点预测的 `fitted` 条目和用于概率预测的 `level_` 条目。**

来源

Theta.forward

 Theta.forward (y:numpy.ndarray, h:int, X:Optional[numpy.ndarray]=None,
                X_future:Optional[numpy.ndarray]=None,
                level:Optional[List[int]]=None, fitted:bool=False)

将已拟合的 AutoTheta 模型应用于新的时间序列。

	类型	默认值	详情
y	ndarray		形状为 (n, ) 的干净时间序列。
h	int		预测范围。
X	可选	无	形状为 (t, n_x) 的可选样本内外部变量。
X_future	可选	无	形状为 (h, n_x) 的可选外生变量。
level	可选	无	预测区间的置信水平 (0-100)。
fitted	bool	False	是否返回样本内预测。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

from statsforecast.models import Theta
from statsforecast.utils import AirPassengers as ap

# Theta's usage example
model = Theta(season_length=12)
model = model.fit(y=ap)
y_hat_dict = model.predict(h=4)
y_hat_dict

优化 Theta 方法

来源

OptimizedTheta

 OptimizedTheta (season_length:int=1,
                 decomposition_type:str='multiplicative',
                 alias:str='OptimizedTheta', prediction_intervals:Optional
                 [statsforecast.utils.ConformalIntervals]=None)

优化 Theta 方法。

	类型	默认值	详情
season_length	int	1	每单位时间的观测值数量。例如：24小时数据。
decomposition_type	str	multiplicative	季节分解类型，'multiplicative'（默认）或 'additive'。
alias	str	OptimizedTheta	模型的自定义名称。默认值为 `OptimizedTheta`。
prediction_intervals	可选	无	计算保形预测区间的信息。默认情况下，模型将计算原生预测区间。

来源

OptimizedTheta.forecast

 OptimizedTheta.forecast (y:numpy.ndarray, h:int,
                          X:Optional[numpy.ndarray]=None,
                          X_future:Optional[numpy.ndarray]=None,
                          level:Optional[List[int]]=None,
                          fitted:bool=False)

*内存高效的 AutoTheta 预测。

此方法避免了对象存储带来的内存负担。它类似于 fit_predict 但不存储信息。它假设您提前知道预测范围。*

	类型	默认值	详情
y	ndarray		形状为 (n, ) 的干净时间序列。
h	int		预测范围。
X	可选	无	形状为 (t, n_x) 的可选样本内外部变量。
X_future	可选	无	形状为 (h, n_x) 的可选外生变量。
level	可选	无	预测区间的置信水平 (0-100)。
fitted	bool	False	是否返回样本内预测。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

来源

OptimizedTheta.fit

 OptimizedTheta.fit (y:numpy.ndarray, X:Optional[numpy.ndarray]=None)

*拟合 AutoTheta 模型。

将 AutoTheta 模型拟合到时间序列（numpy 数组）y 和可选的外生变量（numpy 数组）X。*

	类型	默认值	详情
y	ndarray		形状为 (t, ) 的干净时间序列。
X	可选	无	形状为 (t, n_x) 的可选外生变量。
返回值			已拟合的 AutoTheta 模型。

来源

OptimizedTheta.predict

 OptimizedTheta.predict (h:int, X:Optional[numpy.ndarray]=None,
                         level:Optional[List[int]]=None)

使用已拟合的 AutoTheta 进行预测。

	类型	默认值	详情
h	int		预测范围。
X	可选	无	形状为 (h, n_x) 的可选外生变量。
level	可选	无	预测区间的置信水平 (0-100)。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

来源

OptimizedTheta.predict_in_sample

 OptimizedTheta.predict_in_sample (level:Optional[List[int]]=None)

访问已拟合 AutoTheta 的样本内预测。

	类型	默认值	详情
level	可选	无	预测区间的置信水平 (0-100)。
返回值	dict		*字典，包含用于点预测的 `fitted` 条目和用于概率预测的 `level_` 条目。**

来源

OptimizedTheta.forward

 OptimizedTheta.forward (y:numpy.ndarray, h:int,
                         X:Optional[numpy.ndarray]=None,
                         X_future:Optional[numpy.ndarray]=None,
                         level:Optional[List[int]]=None,
                         fitted:bool=False)

将已拟合的 AutoTheta 模型应用于新的时间序列。

	类型	默认值	详情
y	ndarray		形状为 (n, ) 的干净时间序列。
h	int		预测范围。
X	可选	无	形状为 (t, n_x) 的可选样本内外部变量。
X_future	可选	无	形状为 (h, n_x) 的可选外生变量。
level	可选	无	预测区间的置信水平 (0-100)。
fitted	bool	False	是否返回样本内预测。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

from statsforecast.models import OptimizedTheta
from statsforecast.utils import AirPassengers as ap

# OptimzedThetA's usage example
model = OptimizedTheta(season_length=12)
model = model.fit(y=ap)
y_hat_dict = model.predict(h=4)
y_hat_dict

动态标准 Theta 方法

来源

DynamicTheta

 DynamicTheta (season_length:int=1,
               decomposition_type:str='multiplicative',
               alias:str='DynamicTheta', prediction_intervals:Optional[sta
               tsforecast.utils.ConformalIntervals]=None)

动态标准 Theta 方法。

	类型	默认值	详情
season_length	int	1	每单位时间的观测值数量。例如：24小时数据。
decomposition_type	str	multiplicative	季节分解类型，'multiplicative'（默认）或 'additive'。
alias	str	DynamicTheta	模型的自定义名称。
prediction_intervals	可选	无	计算保形预测区间的信息。默认情况下，模型将计算原生预测区间。

来源

DynamicTheta.forecast

 DynamicTheta.forecast (y:numpy.ndarray, h:int,
                        X:Optional[numpy.ndarray]=None,
                        X_future:Optional[numpy.ndarray]=None,
                        level:Optional[List[int]]=None, fitted:bool=False)

*内存高效的 AutoTheta 预测。

此方法避免了对象存储带来的内存负担。它类似于 fit_predict 但不存储信息。它假设您提前知道预测范围。*

	类型	默认值	详情
y	ndarray		形状为 (n, ) 的干净时间序列。
h	int		预测范围。
X	可选	无	形状为 (t, n_x) 的可选样本内外部变量。
X_future	可选	无	形状为 (h, n_x) 的可选外生变量。
level	可选	无	预测区间的置信水平 (0-100)。
fitted	bool	False	是否返回样本内预测。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

来源

DynamicTheta.fit

 DynamicTheta.fit (y:numpy.ndarray, X:Optional[numpy.ndarray]=None)

*拟合 AutoTheta 模型。

将 AutoTheta 模型拟合到时间序列（numpy 数组）y 和可选的外生变量（numpy 数组）X。*

	类型	默认值	详情
y	ndarray		形状为 (t, ) 的干净时间序列。
X	可选	无	形状为 (t, n_x) 的可选外生变量。
返回值			已拟合的 AutoTheta 模型。

来源

DynamicTheta.predict

 DynamicTheta.predict (h:int, X:Optional[numpy.ndarray]=None,
                       level:Optional[List[int]]=None)

使用已拟合的 AutoTheta 进行预测。

	类型	默认值	详情
h	int		预测范围。
X	可选	无	形状为 (h, n_x) 的可选外生变量。
level	可选	无	预测区间的置信水平 (0-100)。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

来源

DynamicTheta.predict_in_sample

 DynamicTheta.predict_in_sample (level:Optional[List[int]]=None)

访问已拟合 AutoTheta 的样本内预测。

	类型	默认值	详情
level	可选	无	预测区间的置信水平 (0-100)。
返回值	dict		*字典，包含用于点预测的 `fitted` 条目和用于概率预测的 `level_` 条目。**

来源

DynamicTheta.forward

 DynamicTheta.forward (y:numpy.ndarray, h:int,
                       X:Optional[numpy.ndarray]=None,
                       X_future:Optional[numpy.ndarray]=None,
                       level:Optional[List[int]]=None, fitted:bool=False)

将已拟合的 AutoTheta 模型应用于新的时间序列。

	类型	默认值	详情
y	ndarray		形状为 (n, ) 的干净时间序列。
h	int		预测范围。
X	可选	无	形状为 (t, n_x) 的可选样本内外部变量。
X_future	可选	无	形状为 (h, n_x) 的可选外生变量。
level	可选	无	预测区间的置信水平 (0-100)。
fitted	bool	False	是否返回样本内预测。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

from statsforecast.models import DynamicTheta
from statsforecast.utils import AirPassengers as ap

# DynStandardThetaMethod's usage example
model = DynamicTheta(season_length=12)
model = model.fit(y=ap)
y_hat_dict = model.predict(h=4)
y_hat_dict

动态优化 Theta 方法

来源

DynamicOptimizedTheta

 DynamicOptimizedTheta (season_length:int=1,
                        decomposition_type:str='multiplicative',
                        alias:str='DynamicOptimizedTheta', prediction_inte
                        rvals:Optional[statsforecast.utils.ConformalInterv
                        als]=None)

动态优化 Theta 方法。

	类型	默认值	详情
season_length	int	1	每单位时间的观测值数量。例如：24小时数据。
decomposition_type	str	multiplicative	季节分解类型，'multiplicative'（默认）或 'additive'。
alias	str	DynamicOptimizedTheta	模型的自定义名称。
prediction_intervals	可选	无	计算保形预测区间的信息。默认情况下，模型将计算原生预测区间。

来源

DynamicOptimizedTheta.forecast

 DynamicOptimizedTheta.forecast (y:numpy.ndarray, h:int,
                                 X:Optional[numpy.ndarray]=None,
                                 X_future:Optional[numpy.ndarray]=None,
                                 level:Optional[List[int]]=None,
                                 fitted:bool=False)

*内存高效的 AutoTheta 预测。

此方法避免了对象存储带来的内存负担。它类似于 fit_predict 但不存储信息。它假设您提前知道预测范围。*

	类型	默认值	详情
y	ndarray		形状为 (n, ) 的干净时间序列。
h	int		预测范围。
X	可选	无	形状为 (t, n_x) 的可选样本内外部变量。
X_future	可选	无	形状为 (h, n_x) 的可选外生变量。
level	可选	无	预测区间的置信水平 (0-100)。
fitted	bool	False	是否返回样本内预测。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

来源

DynamicOptimizedTheta.fit

 DynamicOptimizedTheta.fit (y:numpy.ndarray,
                            X:Optional[numpy.ndarray]=None)

*拟合 AutoTheta 模型。

将 AutoTheta 模型拟合到时间序列（numpy 数组）y 和可选的外生变量（numpy 数组）X。*

	类型	默认值	详情
y	ndarray		形状为 (t, ) 的干净时间序列。
X	可选	无	形状为 (t, n_x) 的可选外生变量。
返回值			已拟合的 AutoTheta 模型。

来源

DynamicOptimizedTheta.predict

 DynamicOptimizedTheta.predict (h:int, X:Optional[numpy.ndarray]=None,
                                level:Optional[List[int]]=None)

使用已拟合的 AutoTheta 进行预测。

	类型	默认值	详情
h	int		预测范围。
X	可选	无	形状为 (h, n_x) 的可选外生变量。
level	可选	无	预测区间的置信水平 (0-100)。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

来源

DynamicOptimizedTheta.predict_in_sample

 DynamicOptimizedTheta.predict_in_sample (level:Optional[List[int]]=None)

访问已拟合 AutoTheta 的样本内预测。

	类型	默认值	详情
level	可选	无	预测区间的置信水平 (0-100)。
返回值	dict		*字典，包含用于点预测的 `fitted` 条目和用于概率预测的 `level_` 条目。**

来源

DynamicOptimizedTheta.forward

 DynamicOptimizedTheta.forward (y:numpy.ndarray, h:int,
                                X:Optional[numpy.ndarray]=None,
                                X_future:Optional[numpy.ndarray]=None,
                                level:Optional[List[int]]=None,
                                fitted:bool=False)

将已拟合的 AutoTheta 模型应用于新的时间序列。

	类型	默认值	详情
y	ndarray		形状为 (n, ) 的干净时间序列。
h	int		预测范围。
X	可选	无	形状为 (t, n_x) 的可选样本内外部变量。
X_future	可选	无	形状为 (h, n_x) 的可选外生变量。
level	可选	无	预测区间的置信水平 (0-100)。
fitted	bool	False	是否返回样本内预测。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

from statsforecast.models import DynamicOptimizedTheta
from statsforecast.utils import AirPassengers as ap

# OptimzedThetaMethod's usage example
model = DynamicOptimizedTheta(season_length=12)
model = model.fit(y=ap)
y_hat_dict = model.predict(h=4)
y_hat_dict

ARCH 系列

GARCH 模型

来源

GARCH

 GARCH (p:int=1, q:int=1, alias:str='GARCH', prediction_intervals:Optional
        [statsforecast.utils.ConformalIntervals]=None)

*广义自回归条件异方差 (GARCH) 模型。

一种用于建模随时间表现出非恒定波动性的时间序列的方法。GARCH 模型假设在时间 $t$ ， $y_t$ 由以下公式给出

$y_t = v_t \sigma_t$

其中

$\sigma_t^2 = w + \sum_{i=1}^p a_i y_{t-i}^2 + \sum_{j=1}^q b_j \sigma_{t-j}^2$ .

其中 $v_t$ 是一系列均值为零、方差为单位方差的独立同分布随机变量。系数 $w$ ， $a_i$ ， $i=1,...,p$ ，和 $b_j$ ， $j=1,...,q$ 必须满足以下条件

$w > 0$ 且 $a_i, b_j \geq 0$ 对所有 $i$ 和 $j$ 成立。
$\sum_{k=1}^{max(p,q)} a_k + b_k < 1$ 。这里假定 $a_i=0$ 对 $i>p$ 成立，且 $b_j=0$ 对 $j>q$ 成立。*

ARCH 模型是 GARCH 模型当 $q=0$ 时的特例。*

	类型	默认值	详情
p	int	1	序列的滞后版本数量。
q	int	1
alias	str	GARCH	模型的自定义名称。
prediction_intervals	可选	无	计算保形预测区间的信息。默认情况下，模型将计算原生预测区间。

来源

GARCH.fit

 GARCH.fit (y:numpy.ndarray, X:Optional[numpy.ndarray]=None)

*拟合 GARCH 模型。

将 GARCH 模型拟合到时间序列（numpy 数组）y。*

	类型	默认值	详情
y	ndarray		形状为 (t, ) 的干净时间序列。
X	可选	无
返回值			GARCH 模型。

来源

GARCH.predict

 GARCH.predict (h:int, X:Optional[numpy.ndarray]=None,
                level:Optional[List[int]]=None)

使用拟合的 GARCH 模型进行预测。

	类型	默认值	详情
h	int		预测范围。
X	可选	无	形状为 (h, n_x) 的可选外生变量。
level	可选	无	预测区间的置信水平 (0-100)。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

来源

GARCH.predict_in_sample

 GARCH.predict_in_sample (level:Optional[List[int]]=None)

访问拟合 GARCH 模型的预测。

	类型	默认值	详情
level	可选	无	预测区间的置信水平 (0-100)。
返回值	dict		*字典，包含用于点预测的 `fitted` 条目和用于概率预测的 `level_` 条目。**

来源

GARCH.forecast

 GARCH.forecast (y:numpy.ndarray, h:int, X:Optional[numpy.ndarray]=None,
                 X_future:Optional[numpy.ndarray]=None,
                 level:Optional[List[int]]=None, fitted:bool=False)

*内存高效的 GARCH 模型。

此方法避免了对象存储带来的内存负担。它类似于 fit_predict 但不存储信息。它假设您提前知道预测范围。*

	类型	默认值	详情
y	ndarray		形状为 (n, ) 的干净时间序列。
h	int		预测范围。
X	可选	无
X_future	可选	无
level	可选	无	预测区间的置信水平 (0-100)。
fitted	bool	False	是否返回样本内预测。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

ARCH 模型

来源

ARCH

 ARCH (p:int=1, alias:str='ARCH', prediction_intervals:Optional[statsforec
       ast.utils.ConformalIntervals]=None)

*自回归条件异方差 (ARCH) 模型。

GARCH(p,q) 模型的一种特殊情况，其中 $q=0$ 。它假设在时间 $t$ ， $y_t$ 由以下公式给出

$y_t = \epsilon_t \sigma_t$

其中

$\sigma_t^2 = w0 + \sum_{i=1}^p a_i y_{t-i}^2$ .

其中 $\epsilon_t$ 是一系列均值为零、方差为单位方差的独立同分布随机变量。系数 $w$ 和 $a_i$ ， $i=1,...,p$ 必须是非负的，且 $\sum_{k=1}^p a_k < 1$ 。*

	类型	默认值	详情
p	int	1	序列的滞后版本数量。
alias	str	ARCH	模型的自定义名称。
prediction_intervals	可选	无	计算保形预测区间的信息。默认情况下，模型将计算原生预测区间。

来源

ARCH.fit

 ARCH.fit (y:numpy.ndarray, X:Optional[numpy.ndarray]=None)

*拟合 GARCH 模型。

将 GARCH 模型拟合到时间序列（numpy 数组）y。*

	类型	默认值	详情
y	ndarray		形状为 (t, ) 的干净时间序列。
X	可选	无
返回值			GARCH 模型。

来源

ARCH.predict

 ARCH.predict (h:int, X:Optional[numpy.ndarray]=None,
               level:Optional[List[int]]=None)

使用拟合的 GARCH 模型进行预测。

	类型	默认值	详情
h	int		预测范围。
X	可选	无	形状为 (h, n_x) 的可选外生变量。
level	可选	无	预测区间的置信水平 (0-100)。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

来源

ARCH.predict_in_sample

 ARCH.predict_in_sample (level:Optional[List[int]]=None)

访问拟合 GARCH 模型的预测。

	类型	默认值	详情
level	可选	无	预测区间的置信水平 (0-100)。
返回值	dict		*字典，包含用于点预测的 `fitted` 条目和用于概率预测的 `level_` 条目。**

来源

ARCH.forecast

 ARCH.forecast (y:numpy.ndarray, h:int, X:Optional[numpy.ndarray]=None,
                X_future:Optional[numpy.ndarray]=None,
                level:Optional[List[int]]=None, fitted:bool=False)

*内存高效的 GARCH 模型。

此方法避免了对象存储带来的内存负担。它类似于 fit_predict 但不存储信息。它假设您提前知道预测范围。*

	类型	默认值	详情
y	ndarray		形状为 (n, ) 的干净时间序列。
h	int		预测范围。
X	可选	无
X_future	可选	无
level	可选	无	预测区间的置信水平 (0-100)。
fitted	bool	False	是否返回样本内预测。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

机器学习模型

SklearnModel

来源

SklearnModel

 SklearnModel (model, prediction_intervals:Optional[statsforecast.utils.Co
               nformalIntervals]=None, alias:Optional[str]=None)

scikit-learn 模型封装器

	类型	默认值	详情
model	sklearn.base.BaseEstimator		scikit-learn 估计器
prediction_intervals	可选	无	计算保形预测区间的信息。这是生成未来预测区间所需的。
alias	可选	无	模型的自定义名称。如果为 `None`，将使用模型的类名。

来源

SklearnModel.fit

 SklearnModel.fit (y:numpy.ndarray, X:numpy.ndarray)

拟合模型。

	类型	详情
y	ndarray	形状为 (t, ) 的干净时间序列。
X	ndarray	形状为 (t, n_x) 的外部变量。
返回值	SklearnModel	拟合的 SklearnModel 对象。

来源

SklearnModel.predict

 SklearnModel.predict (h:int, X:numpy.ndarray,
                       level:Optional[List[int]]=None)

使用拟合的 SklearnModel 进行预测。

	类型	默认值	详情
h	int		预测范围。
X	ndarray		形状为 (h, n_x) 的外部变量。
level	可选	无
返回值	Dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

来源

SklearnModel.predict_in_sample

 SklearnModel.predict_in_sample (level:Optional[List[int]]=None)

访问拟合 SklearnModel 的样本内预测。

	类型	默认值	详情
level	可选	无	预测区间的置信水平 (0-100)。
返回值	Dict		*字典，包含用于点预测的 `fitted` 条目和用于概率预测的 `level_` 条目。**

来源

SklearnModel.forecast

 SklearnModel.forecast (y:numpy.ndarray, h:int, X:numpy.ndarray,
                        X_future:numpy.ndarray,
                        level:Optional[List[int]]=None, fitted:bool=False)

*内存高效的 SklearnModel 预测。

此方法避免了对象存储带来的内存负担。它类似于 fit_predict 但不存储信息。它假设您提前知道预测范围。*

	类型	默认值	详情
y	ndarray		形状为 (t, ) 的干净时间序列。
h	int		预测范围。
X	ndarray		形状为 (t, n_x) 的样本内外部变量。
X_future	ndarray		形状为 (h, n_x) 的外部变量。
level	可选	无	预测区间的置信水平 (0-100)。
fitted	bool	False	是否返回样本内预测。
返回值	Dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

备用模型

ConstantModel

来源

ConstantModel

 ConstantModel (constant:float, alias:str='ConstantModel')

*常数模型。

返回常数值。*

来源

ConstantModel.forecast

 ConstantModel.forecast (y:numpy.ndarray, h:int,
                         X:Optional[numpy.ndarray]=None,
                         X_future:Optional[numpy.ndarray]=None,
                         level:Optional[List[int]]=None,
                         fitted:bool=False)

*内存高效的常数模型预测。

此方法避免了对象存储带来的内存负担。它类似于 fit_predict 但不存储信息。它假设您提前知道预测范围。*

	类型	默认值	详情
y	ndarray		形状为 (n,) 的干净时间序列。
h	int
X	可选	无	形状为 (t, n_x) 的可选样本内外部变量。
X_future	可选	无	形状为 (h, n_x) 的可选外生变量。
level	可选	无	预测区间的置信水平 (0-100)。
fitted	bool	False	是否返回样本内预测。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

来源

ConstantModel.fit

 ConstantModel.fit (y:numpy.ndarray, X:Optional[numpy.ndarray]=None)

*拟合常数模型。

将常数模型拟合到时间序列（numpy.array）y。*

	类型	默认值	详情
y	ndarray		形状为 (t, ) 的干净时间序列。
X	可选	无	形状为 (t, n_x) 的可选外生变量。
返回值	self		常数拟合模型。

来源

ConstantModel.predict

 ConstantModel.predict (h:int, X:Optional[numpy.ndarray]=None,
                        level:Optional[List[int]]=None)

使用拟合的 ConstantModel 进行预测。

	类型	默认值	详情
h	int		预测范围
X	可选	无	外生回归变量
level	可选	无	置信水平
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

来源

ConstantModel.predict_in_sample

 ConstantModel.predict_in_sample (level:Optional[List[int]]=None)

访问拟合常数模型的样本内预测。

	类型	默认值	详情
level	可选	无	预测区间的置信水平 (0-100)。
返回值	dict		*字典，包含用于点预测的 `fitted` 条目和用于概率预测的 `level_` 条目。**

来源

ConstantModel.forward

 ConstantModel.forward (y:numpy.ndarray, h:int,
                        X:Optional[numpy.ndarray]=None,
                        X_future:Optional[numpy.ndarray]=None,
                        level:Optional[List[int]]=None, fitted:bool=False)

将常数模型预测应用于新的/更新的时间序列。

	类型	默认值	详情
y	ndarray		形状为 (n, ) 的干净时间序列。
h	int		预测范围。
X	可选	无	形状为 (t, n_x) 的可选样本内外部变量。
X_future	可选	无	形状为 (h, n_x) 的可选外生变量。
level	可选	无	预测区间的置信水平。
fitted	bool	False	是否返回样本内预测。
返回值	dict		*一个字典，包含用于点预测的 `constant` 条目和用于概率预测的 `level_` 条目。**

from statsforecast.models import ConstantModel
from statsforecast.utils import AirPassengers as ap

# ConstantModel's usage example
model = ConstantModel(1)
model = model.fit(y=ap)
y_hat_dict = model.predict(h=4)
y_hat_dict

ZeroModel

来源

ZeroModel

 ZeroModel (alias:str='ZeroModel')

*返回零预测值。

返回零值。*

来源

ZeroModel.forecast

 ZeroModel.forecast (y:numpy.ndarray, h:int,
                     X:Optional[numpy.ndarray]=None,
                     X_future:Optional[numpy.ndarray]=None,
                     level:Optional[List[int]]=None, fitted:bool=False)

*内存高效的常数模型预测。

此方法避免了对象存储带来的内存负担。它类似于 fit_predict 但不存储信息。它假设您提前知道预测范围。*

	类型	默认值	详情
y	ndarray		形状为 (n,) 的干净时间序列。
h	int
X	可选	无	形状为 (t, n_x) 的可选样本内外部变量。
X_future	可选	无	形状为 (h, n_x) 的可选外生变量。
level	可选	无	预测区间的置信水平 (0-100)。
fitted	bool	False	是否返回样本内预测。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

来源

ZeroModel.fit

 ZeroModel.fit (y:numpy.ndarray, X:Optional[numpy.ndarray]=None)

*拟合常数模型。

将常数模型拟合到时间序列（numpy.array）y。*

	类型	默认值	详情
y	ndarray		形状为 (t, ) 的干净时间序列。
X	可选	无	形状为 (t, n_x) 的可选外生变量。
返回值	self		常数拟合模型。

来源

ZeroModel.predict

 ZeroModel.predict (h:int, X:Optional[numpy.ndarray]=None,
                    level:Optional[List[int]]=None)

使用拟合的 ConstantModel 进行预测。

	类型	默认值	详情
h	int		预测范围
X	可选	无	外生回归变量
level	可选	无	置信水平
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

来源

ZeroModel.predict_in_sample

 ZeroModel.predict_in_sample (level:Optional[List[int]]=None)

访问拟合常数模型的样本内预测。

	类型	默认值	详情
level	可选	无	预测区间的置信水平 (0-100)。
返回值	dict		*字典，包含用于点预测的 `fitted` 条目和用于概率预测的 `level_` 条目。**

来源

ZeroModel.forward

 ZeroModel.forward (y:numpy.ndarray, h:int,
                    X:Optional[numpy.ndarray]=None,
                    X_future:Optional[numpy.ndarray]=None,
                    level:Optional[List[int]]=None, fitted:bool=False)

将常数模型预测应用于新的/更新的时间序列。

	类型	默认值	详情
y	ndarray		形状为 (n, ) 的干净时间序列。
h	int		预测范围。
X	可选	无	形状为 (t, n_x) 的可选样本内外部变量。
X_future	可选	无	形状为 (h, n_x) 的可选外生变量。
level	可选	无	预测区间的置信水平。
fitted	bool	False	是否返回样本内预测。
返回值	dict		*一个字典，包含用于点预测的 `constant` 条目和用于概率预测的 `level_` 条目。**

from statsforecast.models import ZeroModel
from statsforecast.utils import AirPassengers as ap

# NanModel's usage example
model = ZeroModel()
model = model.fit(y=ap)
y_hat_dict = model.predict(h=4)
y_hat_dict

NaNModel

来源

NaNModel

 NaNModel (alias:str='NaNModel')

*NaN 模型。

返回 NaN 值。*

来源

NaNModel.forecast

 NaNModel.forecast (y:numpy.ndarray, h:int,
                    X:Optional[numpy.ndarray]=None,
                    X_future:Optional[numpy.ndarray]=None,
                    level:Optional[List[int]]=None, fitted:bool=False)

*内存高效的常数模型预测。

此方法避免了对象存储带来的内存负担。它类似于 fit_predict 但不存储信息。它假设您提前知道预测范围。*

	类型	默认值	详情
y	ndarray		形状为 (n,) 的干净时间序列。
h	int
X	可选	无	形状为 (t, n_x) 的可选样本内外部变量。
X_future	可选	无	形状为 (h, n_x) 的可选外生变量。
level	可选	无	预测区间的置信水平 (0-100)。
fitted	bool	False	是否返回样本内预测。
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

来源

NaNModel.fit

 NaNModel.fit (y:numpy.ndarray, X:Optional[numpy.ndarray]=None)

*拟合常数模型。

将常数模型拟合到时间序列（numpy.array）y。*

	类型	默认值	详情
y	ndarray		形状为 (t, ) 的干净时间序列。
X	可选	无	形状为 (t, n_x) 的可选外生变量。
返回值	self		常数拟合模型。

来源

NaNModel.predict

 NaNModel.predict (h:int, X:Optional[numpy.ndarray]=None,
                   level:Optional[List[int]]=None)

使用拟合的 ConstantModel 进行预测。

	类型	默认值	详情
h	int		预测范围
X	可选	无	外生回归变量
level	可选	无	置信水平
返回值	dict		*字典，包含用于点预测的 `mean` 条目和用于概率预测的 `level_` 条目。**

来源

NaNModel.predict_in_sample

 NaNModel.predict_in_sample (level:Optional[List[int]]=None)

访问拟合常数模型的样本内预测。

	类型	默认值	详情
level	可选	无	预测区间的置信水平 (0-100)。
返回值	dict		*字典，包含用于点预测的 `fitted` 条目和用于概率预测的 `level_` 条目。**

from statsforecast.models import NaNModel
from statsforecast.utils import AirPassengers as ap

# NanModel's usage example
model = NaNModel()
model = model.fit(y=ap)
y_hat_dict = model.predict(h=4)
y_hat_dict

参考文献

通用

自动预测

Rob J. Hyndman, Yeasmin Khandakar (2008). “Automatic Time Series Forecasting: The forecast package for R”.

指数平滑

简单方法

Rob J. Hyndman and George Athanasopoulos (2018). “Forecasting principles and practice, Simple Methods”.

稀疏间歇性

多重季节性

Bandara, Kasun & Hyndman, Rob & Bergmeir, Christoph. (2021). “MSTL: A Seasonal-Trend Decomposition Algorithm for Time Series with Multiple Seasonal Patterns”.

Theta 系列

Jose A. Fiorucci, Tiago R. Pellegrini, Francisco Louzada, Fotios Petropoulos, Anne B. Koehler (2016). “Models for optimising the theta method and their relationship to state space models”. International Journal of Forecasting.

GARCH 模型

TBATS 模型

FugueBackend StatsForecast 模型

在本页

自动预测
AutoARIMA
AutoARIMA
AutoARIMA.fit
AutoARIMA.predict
AutoARIMA.predict_in_sample
AutoARIMA.forecast
AutoARIMA.forward
AutoETS
AutoETS
AutoETS.fit
AutoETS.predict
AutoETS.predict_in_sample
AutoETS.forecast
AutoETS.forward
AutoCES
AutoCES
AutoCES.fit
AutoCES.predict
AutoCES.predict_in_sample
AutoCES.forecast
AutoCES.forward
AutoTheta
AutoTheta
AutoTheta.fit
AutoTheta.predict
AutoTheta.predict_in_sample
AutoTheta.forecast
AutoTheta.forward
AutoMFLES
AutoMFLES
AutoMFLES.fit
AutoMFLES.predict
AutoMFLES.predict_in_sample
AutoMFLES.forecast
AutoTBATS
AutoTBATS
AutoTBATS.fit
AutoTBATS.predict
AutoTBATS.predict_in_sample
AutoTBATS.forecast
ARIMA 系列
ARIMA
ARIMA
ARIMA.fit
ARIMA.predict
ARIMA.predict_in_sample
ARIMA.forecast
ARIMA.forward
自回归模型
自回归模型
AutoRegressive.fit
AutoRegressive.predict
AutoRegressive.predict_in_sample
AutoRegressive.forecast
AutoRegressive.forward
指数平滑模型
SimpleSmooth
简单指数平滑模型
SimpleExponentialSmoothing.forecast
SimpleExponentialSmoothing.fit
SimpleExponentialSmoothing.predict
SimpleExponentialSmoothing.predict_in_sample
SimpleSmoothOptimized
简单指数平滑优化模型
SimpleExponentialSmoothingOptimized.fit
SimpleExponentialSmoothingOptimized.predict
SimpleExponentialSmoothingOptimized.predict_in_sample
SimpleExponentialSmoothingOptimized.forecast
SeasonalSmooth
季节性指数平滑模型
SeasonalExponentialSmoothing.fit
SeasonalExponentialSmoothing.predict
SeasonalExponentialSmoothing.predict_in_sample
SeasonalExponentialSmoothing.forecast
SeasonalSmoothOptimized
季节性指数平滑优化模型
SeasonalExponentialSmoothingOptimized.forecast
SeasonalExponentialSmoothingOptimized.fit
SeasonalExponentialSmoothingOptimized.predict
SeasonalExponentialSmoothingOptimized.predict_in_sample
Holt 方法
Holt
Holt.forecast
Holt.fit
Holt.predict
Holt.predict_in_sample
Holt.forward
Holt-Winters 方法
HoltWinters
HoltWinters.forecast
HoltWinters.fit
HoltWinters.predict
HoltWinters.predict_in_sample
HoltWinters.forward
基线模型
HistoricAverage
HistoricAverage
HistoricAverage.forecast
HistoricAverage.fit
HistoricAverage.predict
HistoricAverage.predict_in_sample
Naive
Naive
Naive.forecast
Naive.fit
Naive.predict
Naive.predict_in_sample
带漂移的随机游走
带漂移的随机游走
RandomWalkWithDrift.forecast
RandomWalkWithDrift.fit
RandomWalkWithDrift.predict
RandomWalkWithDrift.predict_in_sample
季节性朴素模型
季节性朴素模型
SeasonalNaive.forecast
SeasonalNaive.fit
SeasonalNaive.predict
SeasonalNaive.predict_in_sample
窗口平均模型
窗口平均模型
WindowAverage.forecast
WindowAverage.fit
WindowAverage.predict
季节性窗口平均模型
季节性窗口平均模型
SeasonalWindowAverage.forecast
SeasonalWindowAverage.fit
SeasonalWindowAverage.predict
稀疏或间歇性模型
ADIDA
ADIDA
ADIDA.forecast
ADIDA.fit
ADIDA.predict
CrostonClassic
CrostonClassic
CrostonClassic.forecast
CrostonClassic.fit
CrostonClassic.predict
CrostonOptimized
CrostonOptimized
CrostonOptimized.forecast
CrostonOptimized.fit
CrostonOptimized.predict
CrostonSBA
CrostonSBA
CrostonSBA.forecast
CrostonSBA.fit
CrostonSBA.predict
IMAPA
IMAPA
IMAPA.forecast
IMAPA.fit
IMAPA.predict
TSB
TSB
TSB.forecast
TSB.fit
TSB.predict
多重季节性
MSTL
MSTL
MSTL.fit
MSTL.predict
MSTL.predict_in_sample
MSTL.forecast
MSTL.forward
MFLES
MFLES
MFLES.fit
MFLES.predict
MFLES.predict_in_sample
MFLES.forecast
TBATS
TBATS
TBATS.fit
TBATS.predict
TBATS.predict_in_sample
TBATS.forecast
Theta 系列
标准 Theta 方法
Theta
Theta.forecast
Theta.fit
Theta.predict
Theta.predict_in_sample
Theta.forward
优化 Theta 方法
OptimizedTheta
OptimizedTheta.forecast
OptimizedTheta.fit
OptimizedTheta.predict
OptimizedTheta.predict_in_sample
OptimizedTheta.forward
动态标准 Theta 方法
DynamicTheta
DynamicTheta.forecast
DynamicTheta.fit
DynamicTheta.predict
DynamicTheta.predict_in_sample
DynamicTheta.forward
动态优化 Theta 方法
DynamicOptimizedTheta
DynamicOptimizedTheta.forecast
DynamicOptimizedTheta.fit
DynamicOptimizedTheta.predict
DynamicOptimizedTheta.predict_in_sample
DynamicOptimizedTheta.forward
ARCH 系列
GARCH 模型
GARCH
GARCH.fit
GARCH.predict
GARCH.predict_in_sample
GARCH.forecast
ARCH 模型
ARCH
ARCH.fit
ARCH.predict
ARCH.predict_in_sample
ARCH.forecast
机器学习模型
SklearnModel
SklearnModel
SklearnModel.fit
SklearnModel.predict
SklearnModel.predict_in_sample
SklearnModel.forecast
备用模型
ConstantModel
ConstantModel
ConstantModel.forecast
ConstantModel.fit
ConstantModel.predict
ConstantModel.predict_in_sample
ConstantModel.forward
ZeroModel
ZeroModel
ZeroModel.forecast
ZeroModel.fit
ZeroModel.predict
ZeroModel.predict_in_sample
ZeroModel.forward
NaNModel
NaNModel
NaNModel.forecast
NaNModel.fit
NaNModel.predict
NaNModel.predict_in_sample
参考文献
通用
自动预测
指数平滑
简单方法
稀疏间歇性
多重季节性
Theta 系列
GARCH 模型
TBATS 模型

入门

教程

操作指南

分布式

实验

模型参考

API参考

贡献

​自动预测

​AutoARIMA

​AutoARIMA

​AutoARIMA.fit

​AutoARIMA.predict

​AutoARIMA.predict_in_sample

​AutoARIMA.forecast

​AutoARIMA.forward

​AutoETS

​AutoETS

​AutoETS.fit

​AutoETS.predict

​AutoETS.predict_in_sample

​AutoETS.forecast

​AutoETS.forward

​AutoCES

​AutoCES

​AutoCES.fit

​AutoCES.predict

​AutoCES.predict_in_sample

​AutoCES.forecast

​AutoCES.forward

​AutoTheta

​AutoTheta

​AutoTheta.fit

​AutoTheta.predict

​AutoTheta.predict_in_sample

​AutoTheta.forecast

​AutoTheta.forward

​AutoMFLES

​AutoMFLES

​AutoMFLES.fit

​AutoMFLES.predict

​AutoMFLES.predict_in_sample

​AutoMFLES.forecast

​AutoTBATS

​AutoTBATS

​AutoTBATS.fit

​AutoTBATS.predict

​AutoTBATS.predict_in_sample

​AutoTBATS.forecast

​ARIMA 系列

​ARIMA

​ARIMA

​ARIMA.fit

​ARIMA.predict

​ARIMA.predict_in_sample

​ARIMA.forecast

​ARIMA.forward

​自回归模型

​自回归模型

​AutoRegressive.fit

​AutoRegressive.predict

​AutoRegressive.predict_in_sample

​AutoRegressive.forecast

​AutoRegressive.forward

​指数平滑模型

​SimpleSmooth

​简单指数平滑模型

​SimpleExponentialSmoothing.forecast

​SimpleExponentialSmoothing.fit

​SimpleExponentialSmoothing.predict

​SimpleExponentialSmoothing.predict_in_sample

​SimpleSmoothOptimized

​简单指数平滑优化模型

​SimpleExponentialSmoothingOptimized.fit

​SimpleExponentialSmoothingOptimized.predict

​SimpleExponentialSmoothingOptimized.predict_in_sample

​SimpleExponentialSmoothingOptimized.forecast

​SeasonalSmooth

​季节性指数平滑模型

​SeasonalExponentialSmoothing.fit

自动预测

AutoARIMA

AutoARIMA

AutoARIMA.fit

AutoARIMA.predict

AutoARIMA.predict_in_sample

AutoARIMA.forecast

AutoARIMA.forward

AutoETS

AutoETS

AutoETS.fit

AutoETS.predict

AutoETS.predict_in_sample

AutoETS.forecast

AutoETS.forward

AutoCES

AutoCES

AutoCES.fit

AutoCES.predict

AutoCES.predict_in_sample

AutoCES.forecast

AutoCES.forward

AutoTheta

AutoTheta

AutoTheta.fit

AutoTheta.predict

AutoTheta.predict_in_sample

AutoTheta.forecast

AutoTheta.forward

AutoMFLES

AutoMFLES

AutoMFLES.fit

AutoMFLES.predict

AutoMFLES.predict_in_sample

AutoMFLES.forecast

AutoTBATS

AutoTBATS

AutoTBATS.fit

AutoTBATS.predict

AutoTBATS.predict_in_sample

AutoTBATS.forecast

ARIMA 系列

ARIMA

ARIMA

ARIMA.fit

ARIMA.predict

ARIMA.predict_in_sample

ARIMA.forecast

ARIMA.forward

自回归模型

自回归模型

AutoRegressive.fit

AutoRegressive.predict

AutoRegressive.predict_in_sample

AutoRegressive.forecast

AutoRegressive.forward

指数平滑模型

SimpleSmooth

简单指数平滑模型

SimpleExponentialSmoothing.forecast

SimpleExponentialSmoothing.fit

SimpleExponentialSmoothing.predict

SimpleExponentialSmoothing.predict_in_sample

SimpleSmoothOptimized

简单指数平滑优化模型

SimpleExponentialSmoothingOptimized.fit

SimpleExponentialSmoothingOptimized.predict

SimpleExponentialSmoothingOptimized.predict_in_sample

SimpleExponentialSmoothingOptimized.forecast

SeasonalSmooth

季节性指数平滑模型

SeasonalExponentialSmoothing.fit

SeasonalExponentialSmoothing.predict

SeasonalExponentialSmoothing.predict_in_sample

SeasonalExponentialSmoothing.forecast

SeasonalSmoothOptimized

季节性指数平滑优化模型

SeasonalExponentialSmoothingOptimized.forecast

SeasonalExponentialSmoothingOptimized.fit

SeasonalExponentialSmoothingOptimized.predict