最重要的训练信号是预测误差，它是在时间 $y_{\tau}$ 处观测值 $y_{\tau}$ 和预测值 $\hat{y}_{\tau}$ 之间的差异。

$e_{\tau} = y_{\tau}-\hat{y}_{\tau} \qquad \qquad \tau \in \{t+1,\dots,t+H \}$

训练损失总结了不同训练优化目标中的预测误差。

所有损失都是 torch.nn.modules，这有助于使用 Pytorch Lightning 自动将它们跨 CPU/GPU/TPU 设备移动。

BasePointLoss

 BasePointLoss (horizon_weight=None, outputsize_multiplier=None,
                output_names=None)

*点损失函数的基础类。

参数
horizon_weight: 大小为 h 的张量，用于预测窗口中每个时间戳的权重。
outputsize_multiplier: 输出大小的乘数。
output_names: 输出名称。
*

1. 与尺度相关的误差

这些指标与数据具有相同的尺度。

平均绝对误差 (MAE)

来源

MAE.init

 MAE.__init__ (horizon_weight=None)

*平均绝对误差

计算 y 和 y_hat 之间的平均绝对误差。MAE 通过计算给定时间预测值和真实值之间的偏差，并将这些偏差在序列长度上平均，来衡量预测方法的相对预测准确性。

$\mathrm{MAE}(\mathbf{y}_{\tau}, \mathbf{\hat{y}}_{\tau}) = \frac{1}{H} \sum^{t+H}_{\tau=t+1} |y_{\tau} - \hat{y}_{\tau}|$

参数
horizon_weight: 大小为 h 的张量，用于预测窗口中每个时间戳的权重。
*

来源

MAE.call

 MAE.__call__ (y:torch.Tensor, y_hat:torch.Tensor,
               mask:Optional[torch.Tensor]=None,
               y_insample:Optional[torch.Tensor]=None)

*参数：
y: 张量，实际值。
y_hat: 张量，预测值。
mask: 张量，指定损失中要考虑的数据点。

返回
mae: 张量（单个值）。*

均方误差 (MSE)

来源

MSE.init

 MSE.__init__ (horizon_weight=None)

*均方误差

计算 y 和 y_hat 之间的均方误差。MSE 通过计算给定时间预测值和真实值之间平方偏差，并将这些偏差在序列长度上平均，来衡量预测方法的相对预测准确性。

$\mathrm{MSE}(\mathbf{y}_{\tau}, \mathbf{\hat{y}}_{\tau}) = \frac{1}{H} \sum^{t+H}_{\tau=t+1} (y_{\tau} - \hat{y}_{\tau})^{2}$

参数
horizon_weight: 大小为 h 的张量，用于预测窗口中每个时间戳的权重。
*

来源

MSE.call

 MSE.__call__ (y:torch.Tensor, y_hat:torch.Tensor,
               y_insample:torch.Tensor, mask:Optional[torch.Tensor]=None)

*参数：
y: 张量，实际值。
y_hat: 张量，预测值。
mask: 张量，指定损失中要考虑的数据点。

返回
mse: 张量（单个值）。*

均方根误差 (RMSE)

来源

RMSE.init

 RMSE.__init__ (horizon_weight=None)

*均方根误差

计算 y 和 y_hat 之间的均方根误差。RMSE 通过计算给定时间预测值和观测值之间平方偏差，并将这些偏差在序列长度上平均，来衡量预测方法的相对预测准确性。最终，RMSE 将与原始时间序列处于相同的尺度，因此只有当其他序列共享共同尺度时才能进行比较。RMSE 与 L2 范数有直接联系。

$\mathrm{RMSE}(\mathbf{y}_{\tau}, \mathbf{\hat{y}}_{\tau}) = \sqrt{\frac{1}{H} \sum^{t+H}_{\tau=t+1} (y_{\tau} - \hat{y}_{\tau})^{2}}$

参数
horizon_weight: 大小为 h 的张量，用于预测窗口中每个时间戳的权重。
*

来源

RMSE.call

 RMSE.__call__ (y:torch.Tensor, y_hat:torch.Tensor,
                mask:Optional[torch.Tensor]=None,
                y_insample:Optional[torch.Tensor]=None)

*参数：
y: 张量，实际值。
y_hat: 张量，预测值。
mask: 张量，指定损失中要考虑的数据点。

返回
rmse: 张量（单个值）。*

2. 百分比误差

这些指标是无单位的，适用于跨序列比较。

平均绝对百分比误差 (MAPE)

来源

MAPE.init

 MAPE.__init__ (horizon_weight=None)

*平均绝对百分比误差

计算 y 和 y_hat 之间的平均绝对百分比误差。MAPE 通过计算给定时间预测值和观测值之间的百分比偏差，并将这些偏差在序列长度上平均，来衡量预测方法的相对预测准确性。观测值越接近零，MAPE 损失对相应误差施加的惩罚越大。

$\mathrm{MAPE}(\mathbf{y}_{\tau}, \mathbf{\hat{y}}_{\tau}) = \frac{1}{H} \sum^{t+H}_{\tau=t+1} \frac{|y_{\tau}-\hat{y}_{\tau}|}{|y_{\tau}|}$

参数
horizon_weight: 大小为 h 的张量，用于预测窗口中每个时间戳的权重。

参考文献
Makridakis S., “准确性衡量：理论和实践问题”。*

来源

MAPE.call

 MAPE.__call__ (y:torch.Tensor, y_hat:torch.Tensor,
                y_insample:torch.Tensor, mask:Optional[torch.Tensor]=None)

*参数：
y: 张量，实际值。
y_hat: 张量，预测值。
mask: 张量，指定每个序列中要在损失中考虑的时间戳。

返回
mape: 张量（单个值）。*

对称平均绝对百分比误差 (sMAPE)

来源

SMAPE.init

 SMAPE.__init__ (horizon_weight=None)

*对称平均绝对百分比误差

计算 y 和 y_hat 之间的对称平均绝对百分比误差。sMAPE 通过计算给定时间预测值和观测值之间相对于预测值和观测值绝对值之和的相对偏差，并将这些偏差在序列长度上平均，来衡量预测方法的相对预测准确性。这使得 sMAPE 的范围在 0% 到 200% 之间，这比当目标值为零时可能不确定的普通 MAPE 更可取。

$\mathrm{sMAPE}_{2}(\mathbf{y}_{\tau}, \mathbf{\hat{y}}_{\tau}) = \frac{1}{H} \sum^{t+H}_{\tau=t+1} \frac{|y_{\tau}-\hat{y}_{\tau}|}{|y_{\tau}|+|\hat{y}_{\tau}|}$

参数
horizon_weight: 大小为 h 的张量，用于预测窗口中每个时间戳的权重。

参考文献
Makridakis S., “准确性衡量：理论和实践问题”。*

来源

SMAPE.call

 SMAPE.__call__ (y:torch.Tensor, y_hat:torch.Tensor,
                 mask:Optional[torch.Tensor]=None,
                 y_insample:Optional[torch.Tensor]=None)

*参数：
y: 张量，实际值。
y_hat: 张量，预测值。
mask: 张量，指定每个序列中要在损失中考虑的时间戳。

返回
smape: 张量（单个值）。*

3. 与尺度无关的误差

这些指标衡量相对于基准模型的相对改进。

平均绝对缩放误差 (MASE)

来源

MASE.init

 MASE.__init__ (seasonality:int, horizon_weight=None)

*平均绝对缩放误差计算 y 和 y_hat 之间的平均绝对缩放误差。MASE 通过将预测值和观测值的平均绝对误差与季节性朴素模型的平均绝对误差进行比较，来衡量预测方法的相对预测准确性。MASE 部分构成了 M4 竞赛中使用的整体加权平均 (OWA)。

$\mathrm{MASE}(\mathbf{y}_{\tau}, \mathbf{\hat{y}}_{\tau}, \mathbf{\hat{y}}^{season}_{\tau}) = \frac{1}{H} \sum^{t+H}_{\tau=t+1} \frac{|y_{\tau}-\hat{y}_{\tau}|}{\mathrm{MAE}(\mathbf{y}_{\tau}, \mathbf{\hat{y}}^{season}_{\tau})}$

参数
seasonality: int。时间序列的主要频率；每小时 24，每天 7，每周 52，每月 12，每季度 4，每年 1。horizon_weight: 大小为 h 的张量，用于预测窗口中每个时间戳的权重。

参考文献
Rob J. Hyndman, & Koehler, A. B. “再看预测准确性衡量指标”。
Spyros Makridakis, Evangelos Spiliotis, Vassilios Assimakopoulos, “M4 竞赛：100,000 条时间序列和 61 种预测方法”。*

来源

MASE.call

 MASE.__call__ (y:torch.Tensor, y_hat:torch.Tensor,
                y_insample:torch.Tensor, mask:Optional[torch.Tensor]=None)

*参数：
y: 张量 (batch_size, output_size)，实际值。
y_hat: 张量 (batch_size, output_size))，预测值。
y_insample: 张量 (batch_size, input_size)，实际样本内值。
mask: 张量，指定每个序列中要在损失中考虑的时间戳。

返回
mase: 张量（单个值）。*

相对均方误差 (relMSE)

来源

relMSE.init

 relMSE.__init__ (y_train=None, horizon_weight=None)

*相对均方误差计算相对均方误差 (relMSE)，由 Hyndman & Koehler (2006) 提出作为百分比误差的替代方法，以避免度量不稳定性。

\mathrm{relMSE}(\mathbf{y}, \mathbf{\hat{y}}, \mathbf{\hat{y}}^{benchmark}) = \frac{\mathrm{MSE}(\mathbf{y}, \mathbf{\hat{y}})}{\mathrm{MSE}(\mathbf{y}, \mathbf{\hat{y}}^{benchmark})}

参数
y_train: numpy 数组，已弃用。
horizon_weight: 大小为 h 的张量，用于预测窗口中每个时间戳的权重。

参考文献
- Hyndman, R. J and Koehler, A. B. (2006)。“再看预测准确性衡量指标”，《国际预测杂志》，第 22 卷，第 4 期。
- Kin G. Olivares, O. Nganba Meetei, Ruijun Ma, Rohan Reddy, Mengfei Cao, Lee Dicker. “基于深度泊松混合的概率分层预测。已提交至《国际预测期刊》，工作论文可在arxiv查阅。*

来源

relMSE.call

 relMSE.__call__ (y:torch.Tensor, y_hat:torch.Tensor,
                  y_benchmark:torch.Tensor,
                  mask:Optional[torch.Tensor]=None)

*参数：
y: 张量 (batch_size, output_size)，实际值。
y_hat: 张量 (batch_size, output_size))，预测值。
y_benchmark: 张量 (batch_size, output_size)，基准预测值。
mask: 张量，指定每个序列中要在损失中考虑的时间戳。

返回
relMSE: 张量 (单个值)。*

4. 概率误差

这些方法使用统计方法，利用观测数据估计未知概率分布。

最大似然估计（Maximum likelihood estimation）旨在找到使似然函数最大化的参数值，似然函数衡量了在给定参数值下获得观测数据的概率。在满足特定假设的情况下，MLE 具有良好的理论性质和效率。

在非参数方法中，分位数回归（quantile regression）衡量非对称偏差，产生低估或高估的情况。

分位数损失

来源

QuantileLoss.init

 QuantileLoss.__init__ (q, horizon_weight=None)

*分位数损失

计算 y 和 y_hat 之间的分位数损失。QL 衡量分位数预测的偏差。通过非对称加权绝对偏差，该损失函数更关注低估或高估的情况。对于偏离中位数 (Pinball loss)，q 的常用值为 0.5。

$\mathrm{QL}(\mathbf{y}_{\tau}, \mathbf{\hat{y}}^{(q)}_{\tau}) = \frac{1}{H} \sum^{t+H}_{\tau=t+1} \Big( (1-q)\,( \hat{y}^{(q)}_{\tau} - y_{\tau} )_{+} + q\,( y_{\tau} - \hat{y}^{(q)}_{\tau} )_{+} \Big)$

参数
q: 浮点数，介于 0 和 1 之间。分位数损失的斜率，在分位数回归的上下文中，q 决定了条件分位数水平。
horizon_weight: 大小为 h 的张量，用于预测窗口中每个时间戳的权重。

参考文献
Roger Koenker 和 Gilbert Bassett, Jr.，“分位数回归”（Regression Quantiles）。*

来源

QuantileLoss.call

 QuantileLoss.__call__ (y:torch.Tensor, y_hat:torch.Tensor,
                        y_insample:torch.Tensor,
                        mask:Optional[torch.Tensor]=None)

*参数：
y: 张量，实际值。
y_hat: 张量，预测值。
mask: 张量，指定损失中要考虑的数据点。

返回
quantile_loss: 张量 (单个值)。*

多重分位数损失 (MQLoss)

来源

MQLoss.init

 MQLoss.__init__ (level=[80, 90], quantiles=None, horizon_weight=None)

*多重分位数损失

计算 y 和 y_hat 之间的多重分位数损失 (MQL)。MQL 根据预测分位数与观测值之间的绝对差值，计算给定分位数集下的平均多重分位数损失。

$\mathrm{MQL}(\mathbf{y}_{\tau},[\mathbf{\hat{y}}^{(q_{1})}_{\tau}, ... ,\hat{y}^{(q_{n})}_{\tau}]) = \frac{1}{n} \sum_{q_{i}} \mathrm{QL}(\mathbf{y}_{\tau}, \mathbf{\hat{y}}^{(q_{i})}_{\tau})$

MQL 的极限行为允许使用连续排序概率得分 (CRPS) 来衡量完整预测分布 $\mathbf{\hat{F}}_{\tau}$ 的准确性。这可以通过数值积分技术实现，该技术将分位数离散化，并使用左黎曼近似法处理 CRPS 积分，然后对均匀间隔的分位数进行平均。

$\mathrm{CRPS}(y_{\tau}, \mathbf{\hat{F}}_{\tau}) = \int^{1}_{0} \mathrm{QL}(y_{\tau}, \hat{y}^{(q)}_{\tau}) dq$

参数
level: 整型列表 [0,100]。预测区间的概率水平（默认为中位数）。quantiles: 浮点型列表 [0., 1.]。level 的替代方案，从 y 分布估计的分位数。horizon_weight: 大小为 h 的张量，表示预测窗口中每个时间戳的权重。

参考文献
Roger Koenker 和 Gilbert Bassett, Jr.，“分位数回归”（Regression Quantiles）。
James E. Matheson 和 Robert L. Winkler，“连续概率分布的评分规则”（Scoring Rules for Continuous Probability Distributions）。*

来源

MQLoss.call

 MQLoss.__call__ (y:torch.Tensor, y_hat:torch.Tensor,
                  y_insample:torch.Tensor,
                  mask:Optional[torch.Tensor]=None)

*参数：
y: 张量，实际值。
y_hat: 张量，预测值。
mask: 张量，指定每个序列中要在损失中考虑的时间戳。

返回
mqloss: 张量 (单个值)。*

隐式分位数损失 (IQLoss)

来源

QuantileLayer

 QuantileLayer (num_output:int, cos_embedding_dim:int=128)

*来自 Dabney 等人 2018 年论文 `IQN for Distributional Reinforcement Learning` (https://arxiv.org/abs/1806.06923) 中的隐式分位数层。

代码来源 GluonTS: https://github.com/awslabs/gluonts/blob/61133ef6e2d88177b32ace4afc6843ab9a7bc8cd/src/gluonts/torch/distributions/implicit_quantile_network.py\*

来源

IQLoss.init

 IQLoss.__init__ (cos_embedding_dim=64, concentration0=1.0,
                  concentration1=1.0, horizon_weight=None)

*隐式分位数损失

计算 y 和 y_hat 之间的分位数损失，其中分位数 q 作为网络的输入提供。IQL 衡量分位数预测的偏差。通过非对称加权绝对偏差，该损失函数更关注低估或高估的情况。

参数
quantile_sampling: 字符串，默认值为 'uniform'，训练期间用于采样分位数的采样分布。可选项包括 ['uniform', 'beta']。
horizon_weight: 大小为 h 的张量，用于预测窗口中每个时间戳的权重。

参考文献
Gouttes, Adèle, Kashif Rasul, Mateusz Koren, Johannes Stephan, 和 Tofigh Naghibi，“使用隐式分位数网络的概率时间序列预测”（Probabilistic Time Series Forecasting with Implicit Quantile Networks）。*

来源

IQLoss.call

 IQLoss.__call__ (y:torch.Tensor, y_hat:torch.Tensor,
                  y_insample:torch.Tensor,
                  mask:Optional[torch.Tensor]=None)

*参数：
y: 张量，实际值。
y_hat: 张量，预测值。
mask: 张量，指定损失中要考虑的数据点。

返回
quantile_loss: 张量 (单个值)。*

DistributionLoss

来源

DistributionLoss.init

 DistributionLoss.__init__ (distribution, level=[80, 90], quantiles=None,
                            num_samples=1000, return_params=False,
                            horizon_weight=None, **distribution_kwargs)

*分布损失

这个 PyTorch 模块封装了 torch.distribution 类，使其能够与 NeuralForecast 模型模块化地交互。它使用负对数似然作为优化目标，并提供一个采样方法，根据 level 列表生成经验分位数。

此外，它还实现了分布变换，将依赖于尺度的似然参数分解为基础尺度和乘数，这些参数可以在网络的非线性操作范围内有效地学习。

可用分布
- 泊松分布
- 正态分布
- 学生 T 分布
- 负二项分布
- Tweedie 分布
- 伯努利分布 (时间分类器)
- ISQF (增量样条分位数函数)

参数
distribution: 字符串，torch.distributions.Distribution 类的标识符。
level: 浮点型列表 [0,100]，预测区间的置信水平。
quantiles: 浮点型列表 [0,1]，level 列表的替代方案，目标分位数。
num_samples: 整型，默认值为 500，用于经验分位数的样本数量。
return_params: 布尔型，默认值为 False，是否返回分布参数。
horizon_weight: 大小为 h 的张量，用于预测窗口中每个时间戳的权重。

参考文献
- PyTorch 概率分布包：学生 T 分布（StudentT）。
- David Salinas, Valentin Flunkert, Jan Gasthaus, Tim Januschowski (2020)。“DeepAR：基于自回归循环网络的概率预测”（DeepAR: Probabilistic forecasting with autoregressive recurrent networks）。《国际预测期刊》。
- Park, Youngsuk, Danielle Maddix, François-Xavier Aubet, Kelvin Kan, Jan Gasthaus, 和 Yuyang Wang (2022)。“学习无分位数交叉的分位数函数用于无分布时间序列预测”（Learning Quantile Functions without Quantile Crossing for Distribution-free Time Series Forecasting）。*

来源

DistributionLoss.sample

 DistributionLoss.sample (distr_args:torch.Tensor,
                          num_samples:Optional[int]=None)

*从估计的分布中构建经验分位数，独立地采样 num_samples 次。

参数
distr_args: 底层分布类型的构造函数参数。
num_samples: 整型，覆盖用于经验分位数的样本数量。

返回
samples: 张量，形状为 [B,H,num_samples]。
quantiles: 张量，由 levels 定义的经验分位数。
*

来源

DistributionLoss.call

 DistributionLoss.__call__ (y:torch.Tensor, distr_args:torch.Tensor,
                            mask:Optional[torch.Tensor]=None)

*计算负对数似然目标函数。用于估计以下预测分布

$\mathrm{P}(\mathbf{y}_{\tau}\,|\,\theta) \quad \mathrm{and} \quad -\log(\mathrm{P}(\mathbf{y}_{\tau}\,|\,\theta))$

其中 $\theta$ 表示分布的参数。它还使用 mask 张量通过加权平均总结目标信号。

参数
y: 张量，实际值。
distr_args: 底层分布类型的构造函数参数。
loc: 可选张量，与结果分布的 batch_shape + event_shape 具有相同的形状。
scale: 可选张量，与结果分布的 batch_shape+event_shape 具有相同的形状。
mask: 张量，指定每个序列中要在损失中考虑的时间戳。

返回
loss: 标量，将对其执行反向传播的加权损失函数。
*

泊松混合网 (PMM)

来源

PMM.init

 PMM.__init__ (n_components=10, level=[80, 90], quantiles=None,
               num_samples=1000, return_params=False,
               batch_correlation=False, horizon_correlation=False,
               weighted=False)

*泊松混合网

这个泊松混合统计模型假设数据组 $\mathcal{G}=\{[g_{i}]\}$ 之间相互独立，并估计组内的关系。

\mathrm{P}\left(\mathbf{y}_{[b][t+1:t+H]}\right) = \prod_{ [g_{i}] \in \mathcal{G}} \mathrm{P} \left(\mathbf{y}_{[g_{i}][\tau]} \right) = \prod_{\beta\in[g_{i}]} \left(\sum_{k=1}^{K} w_k \prod_{(\beta,\tau) \in [g_i][t+1:t+H]} \mathrm{Poisson}(y_{\beta,\tau}, \hat{\lambda}_{\beta,\tau,k}) \right)

参数
n_components: 整型，默认值为 10，混合成分的数量。
level: 浮点型列表 [0,100]，预测区间的置信水平。
quantiles: 浮点型列表 [0,1]，level 列表的替代方案，目标分位数。
return_params: 布尔型，默认值为 False，是否返回分布参数。
batch_correlation: 布尔型，默认值为 False，是否对批量相关性进行建模。
horizon_correlation: 布尔型，默认值为 False，是否对预测期相关性进行建模。

参考文献
Kin G. Olivares, O. Nganba Meetei, Ruijun Ma, Rohan Reddy, Mengfei Cao, Lee Dicker. 基于深度泊松混合的概率分层预测。已提交至《国际预测期刊》，工作论文可在arxiv查阅。*

来源

PMM.sample

 PMM.sample (distr_args:torch.Tensor, num_samples:Optional[int]=None)

*从估计的分布中构建经验分位数，独立地采样 num_samples 次。

参数
distr_args: 底层分布类型的构造函数参数。
num_samples: 整型，覆盖用于经验分位数的样本数量。

返回
samples: 张量，形状为 [B,H,num_samples]。
quantiles: 张量，由 levels 定义的经验分位数。
*

来源

PMM.call

 PMM.__call__ (y:torch.Tensor, distr_args:torch.Tensor,
               mask:Optional[torch.Tensor]=None)

*计算负对数似然目标函数。用于估计以下预测分布

$\mathrm{P}(\mathbf{y}_{\tau}\,|\,\theta) \quad \mathrm{and} \quad -\log(\mathrm{P}(\mathbf{y}_{\tau}\,|\,\theta))$

其中 $\theta$ 表示分布的参数。它还使用 mask 张量通过加权平均总结目标信号。

参数
y: 张量，实际值。
distr_args: 底层分布类型的构造函数参数。
mask: 张量，指定每个序列中要在损失中考虑的时间戳。

返回
loss: 标量，将对其执行反向传播的加权损失函数。
*

高斯混合网 (GMM)

来源

GMM.init

 GMM.__init__ (n_components=1, level=[80, 90], quantiles=None,
               num_samples=1000, return_params=False,
               batch_correlation=False, horizon_correlation=False,
               weighted=False)

*高斯混合网

这个高斯混合统计模型假设数据组 $\mathcal{G}=\{[g_{i}]\}$ 之间相互独立，并估计组内的关系。

\mathrm{P}\left(\mathbf{y}_{[b][t+1:t+H]}\right) = \prod_{ [g_{i}] \in \mathcal{G}} \mathrm{P}\left(\mathbf{y}_{[g_{i}][\tau]}\right)= \prod_{\beta\in[g_{i}]} \left(\sum_{k=1}^{K} w_k \prod_{(\beta,\tau) \in [g_i][t+1:t+H]} \mathrm{Gaussian}(y_{\beta,\tau}, \hat{\mu}_{\beta,\tau,k}, \sigma_{\beta,\tau,k})\right)

来源

GMM.sample

 GMM.sample (distr_args:torch.Tensor, num_samples:Optional[int]=None)

*从估计的分布中构建经验分位数，独立地采样 num_samples 次。

参数
distr_args: 底层分布类型的构造函数参数。
num_samples: 整型，覆盖用于经验分位数的样本数量。

返回
samples: 张量，形状为 [B,H,num_samples]。
quantiles: 张量，由 levels 定义的经验分位数。
*

来源

GMM.call

 GMM.__call__ (y:torch.Tensor, distr_args:torch.Tensor,
               mask:Optional[torch.Tensor]=None)

*计算负对数似然目标函数。用于估计以下预测分布

$\mathrm{P}(\mathbf{y}_{\tau}\,|\,\theta) \quad \mathrm{and} \quad -\log(\mathrm{P}(\mathbf{y}_{\tau}\,|\,\theta))$

其中 $\theta$ 表示分布的参数。它还使用 mask 张量通过加权平均总结目标信号。

参数
y: 张量，实际值。
distr_args: 底层分布类型的构造函数参数。
mask: 张量，指定每个序列中要在损失中考虑的时间戳。

返回
loss: 标量，将对其执行反向传播的加权损失函数。
*

负二项式混合网格 (NBMM)

来源

NBMM.init

 NBMM.__init__ (n_components=1, level=[80, 90], quantiles=None,
                num_samples=1000, return_params=False, weighted=False)

*负二项式混合网格

这种负二项式混合统计模型假设数据组 $\mathcal{G}=\{[g_{i}]\}$ 之间相互独立，并估计组内的关系。

\mathrm{P}\left(\mathbf{y}_{[b][t+1:t+H]}\right) = \prod_{ [g_{i}] \in \mathcal{G}} \mathrm{P}\left(\mathbf{y}_{[g_{i}][\tau]}\right)= \prod_{\beta\in[g_{i}]} \left(\sum_{k=1}^{K} w_k \prod_{(\beta,\tau) \in [g_i][t+1:t+H]} \mathrm{NBinomial}(y_{\beta,\tau}, \hat{r}_{\beta,\tau,k}, \hat{p}_{\beta,\tau,k})\right)

参数
n_components: 整型，默认值为 10，混合成分的数量。
level: 浮点型列表 [0,100]，预测区间的置信水平。
quantiles: 浮点型列表 [0,1]，level 列表的替代方案，目标分位数。
return_params: 布尔型，默认值为 False，是否返回分布参数。

来源

NBMM.sample

 NBMM.sample (distr_args:torch.Tensor, num_samples:Optional[int]=None)

*从估计的分布中构建经验分位数，独立地采样 num_samples 次。

参数
distr_args: 底层分布类型的构造函数参数。
num_samples: 整型，覆盖用于经验分位数的样本数量。

返回
samples: 张量，形状为 [B,H,num_samples]。
quantiles: 张量，由 levels 定义的经验分位数。
*

来源

NBMM.call

 NBMM.__call__ (y:torch.Tensor, distr_args:torch.Tensor,
                mask:Optional[torch.Tensor]=None)

*计算负对数似然目标函数。用于估计以下预测分布

$\mathrm{P}(\mathbf{y}_{\tau}\,|\,\theta) \quad \mathrm{and} \quad -\log(\mathrm{P}(\mathbf{y}_{\tau}\,|\,\theta))$

其中 $\theta$ 表示分布的参数。它还使用 mask 张量通过加权平均总结目标信号。

参数
y: 张量，实际值。
distr_args: 底层分布类型的构造函数参数。
mask: 张量，指定每个序列中要在损失中考虑的时间戳。

返回
loss: 标量，将对其执行反向传播的加权损失函数。
*

5. 稳健误差

这类来自稳健统计学的误差侧重于对离群值和假设违背具有抵抗力的方法，提供可靠的估计和推断。使用稳健估计量来减少离群值的影响，从而提供更稳定的结果。

Huber损失

来源

HuberLoss.init

 HuberLoss.__init__ (delta:float=1.0, horizon_weight=None)

*Huber损失

Huber损失用于稳健回归，与平方误差损失相比，它对数据中的离群值表现出较低的敏感性。该函数也称作 SmoothL1。

Huber损失函数对于小误差是二次的，对于大误差是线性的，在两个点处，其不同部分的值和斜率相等，其中 $(y_{\tau}-\hat{y}_{\tau})^{2}$ = $|y_{\tau}-\hat{y}_{\tau}|$ 。

L_{\delta}(y_{\tau},\; \hat{y}_{\tau}) =\begin{cases}{\frac{1}{2}}(y_{\tau}-\hat{y}_{\tau})^{2}\;{\text{for }}|y_{\tau}-\hat{y}_{\tau}|\leq \delta \\ \delta \ \cdot \left(|y_{\tau}-\hat{y}_{\tau}|-{\frac {1}{2}}\delta \right),\;{\text{otherwise.}}\end{cases}

其中 $\delta$ 是一个阈值参数，它决定了损失从二次过渡到线性的点，并且可以调整它，以控制预测中在稳健性与准确性之间的权衡。

参数
delta: float=1.0, 指定在 delta 缩放的 L1 损失和 L2 损失之间切换的阈值。 horizon_weight: 大小为 h 的 Tensor，预测窗口中每个时间戳的权重。

参考文献
Huber Peter, J (1964). “Robust Estimation of a Location Parameter”. Annals of Statistics*

来源

HuberLoss.call

 HuberLoss.__call__ (y:torch.Tensor, y_hat:torch.Tensor,
                     y_insample:torch.Tensor,
                     mask:Optional[torch.Tensor]=None)

*参数：
y: 张量，实际值。
y_hat: 张量，预测值。
mask: 张量，指定每个序列中要在损失中考虑的时间戳。

返回
huber_loss: tensor (单个值).*

Tukey损失

来源

TukeyLoss.init

 TukeyLoss.__init__ (c:float=4.685, normalize:bool=True)

*Tukey损失

Tukey损失函数，也称为 Tukey 双权函数，是一种用于稳健统计学的稳健统计损失函数。Tukey损失在原点附近表现出二次行为，类似于 Huber 损失；然而，它对离群值甚至更稳健，因为对于大残差的损失保持恒定，而不是线性缩放。

Tukey 损失中的参数 $c$ 决定了函数的“饱和”点： $c$ 较高的值增强敏感性，而较低的值则增加对离群值的抵抗力。

L_{c}(y_{\tau},\; \hat{y}_{\tau}) =\begin{cases}{ \frac{c^{2}}{6}} \left[1-(\frac{y_{\tau}-\hat{y}_{\tau}}{c})^{2} \right]^{3} \;\text{for } |y_{\tau}-\hat{y}_{\tau}|\leq c \\ \frac{c^{2}}{6} \qquad \text{otherwise.} \end{cases}

请注意，Tukey损失函数假设数据事先是平稳的或已归一化。如果误差值过大，算法在优化过程中可能难以收敛。建议使用小的学习率。

参数
c: float=4.685, 指定 Tukey 损失的阈值，超过该阈值的残差不再被考虑。
normalize: bool=True, 是否在 Tukey 损失计算中执行归一化。

参考文献
Beaton, A. E., and Tukey, J. W. (1974). “The Fitting of Power Series, Meaning Polynomials, Illustrated on Band-Spectroscopic Data.”*

来源

TukeyLoss.call

 TukeyLoss.__call__ (y:torch.Tensor, y_hat:torch.Tensor,
                     y_insample:torch.Tensor,
                     mask:Optional[torch.Tensor]=None)

*参数：
y: 张量，实际值。
y_hat: 张量，预测值。
mask: 张量，指定每个序列中要在损失中考虑的时间戳。

返回
tukey_loss: tensor (单个值).*

Huber化分位数损失

来源

HuberQLoss.init

 HuberQLoss.__init__ (q, delta:float=1.0, horizon_weight=None)

*Huber化分位数损失

Huber化分位数损失是分位数损失函数的修改版本，它结合了分位数损失和 Huber 损失的优点。它常用于回归任务中，特别是在处理包含离群值或重尾的数据时。

y 和 y_hat 之间的 Huber化分位数损失以非对称方式衡量 Huber 损失。该损失取决于分位数参数 $q$ ，更关注低估/高估；并通过参数 $delta$ 控制预测中在稳健性与准确性之间的权衡。

\mathrm{HuberQL}(\mathbf{y}_{\tau}, \mathbf{\hat{y}}^{(q)}_{\tau}) = (1-q)\, L_{\delta}(y_{\tau},\; \hat{y}^{(q)}_{\tau}) \mathbb{1}\{ \hat{y}^{(q)}_{\tau} \geq y_{\tau} \} + q\, L_{\delta}(y_{\tau},\; \hat{y}^{(q)}_{\tau}) \mathbb{1}\{ \hat{y}^{(q)}_{\tau} < y_{\tau} \}

参数
delta: float=1.0，指定Delta缩放的L1和L2损失之间的切换阈值。
q: 浮点数，介于 0 和 1 之间。分位数损失的斜率，在分位数回归的上下文中，q 决定了条件分位数水平。
horizon_weight: 大小为 h 的张量，用于预测窗口中每个时间戳的权重。

参考文献
Huber Peter, J (1964). “Robust Estimation of a Location Parameter”. Annals of Statistics
Roger Koenker 和 Gilbert Bassett, Jr.，“分位数回归”（Regression Quantiles）。*

来源

HuberQLoss.call

 HuberQLoss.__call__ (y:torch.Tensor, y_hat:torch.Tensor,
                      y_insample:torch.Tensor,
                      mask:Optional[torch.Tensor]=None)

*参数：
y: 张量，实际值。
y_hat: 张量，预测值。
mask: 张量，指定损失中要考虑的数据点。

返回
huber_qloss: 张量（单个值）。*

Huber化多分位数损失

来源

HuberMQLoss.init

 HuberMQLoss.__init__ (level=[80, 90], quantiles=None, delta:float=1.0,
                       horizon_weight=None)

*Huber化多分位数损失

Huber化多分位数损失（HuberMQL）是多分位数损失函数的修改版本，结合了分位数损失和Huber损失的优点。HuberMQL常用于回归任务，特别是在处理包含异常值或厚尾的数据时。损失函数根据分位数列表 $[q_{1},q_{2},\dots]$ 参数，根据低估/高估给予不同的权重。它使用参数 $\delta$ 来控制鲁棒性和预测准确性之间的权衡。

\mathrm{HuberMQL}_{\delta}(\mathbf{y}_{\tau},[\mathbf{\hat{y}}^{(q_{1})}_{\tau}, ... ,\hat{y}^{(q_{n})}_{\tau}]) = \frac{1}{n} \sum_{q_{i}} \mathrm{HuberQL}_{\delta}(\mathbf{y}_{\tau}, \mathbf{\hat{y}}^{(q_{i})}_{\tau})

参数
level: int list [0,100]。预测区间的概率水平（默认为中位数）。 quantiles: float list [0., 1.]。Level的替代方案，从y分布估计的分位数。 delta: float=1.0，指定Delta缩放的L1和L2损失之间的切换阈值。

horizon_weight: 大小为 h 的张量，用于预测窗口中每个时间戳的权重。

来源

HuberMQLoss.call

 HuberMQLoss.__call__ (y:torch.Tensor, y_hat:torch.Tensor,
                       y_insample:torch.Tensor,
                       mask:Optional[torch.Tensor]=None)

*参数：
y: 张量，实际值。
y_hat: 张量，预测值。
mask: 张量，指定每个序列中要在损失中考虑的时间戳。

返回
hmqloss: 张量（单个值）。*

6. 其他

准确率

来源

Accuracy.init

 Accuracy.__init__ ()

*准确率

计算分类y和y_hat之间的准确率。此评估指标仅用于评估，因为它是不可微的。

$\mathrm{Accuracy}(\mathbf{y}_{\tau}, \mathbf{\hat{y}}_{\tau}) = \frac{1}{H} \sum^{t+H}_{\tau=t+1} \mathrm{1}\{\mathbf{y}_{\tau}==\mathbf{\hat{y}}_{\tau}\}$ *

来源

Accuracy.call

 Accuracy.__call__ (y:torch.Tensor, y_hat:torch.Tensor,
                    y_insample:torch.Tensor,
                    mask:Optional[torch.Tensor]=None)

*参数：
y: 张量，实际值。
y_hat: 张量，预测值。
mask: 张量，指定每个序列中要在损失中考虑的时间戳。

返回
accuracy: 张量（单个值）。*

缩放的连续分级概率得分 (sCRPS)

来源

sCRPS.init

 sCRPS.__init__ (level=[80, 90], quantiles=None)

*缩放的连续分级概率得分

计算CRPS的缩放变体，如Rangapuram (2021)所提出，用于衡量预测分位数y_hat与观测值y之间的准确性。

此指标平均计算由分位数损失定义的按百分比加权的绝对偏差。

\mathrm{sCRPS}(\mathbf{\hat{y}}^{(q)}_{\tau}, \mathbf{y}_{\tau}) = \frac{2}{N} \sum_{i} \int^{1}_{0} \frac{\mathrm{QL}(\mathbf{\hat{y}}^{(q}_{\tau} y_{i,\tau})_{q}}{\sum_{i} | y_{i,\tau} |} dq

其中 $\mathbf{\hat{y}}^{(q}_{\tau}$ 是估计的分位数，而 $y_{i,\tau}$ 是目标变量的实现值。

参数
level: int list [0,100]。预测区间的概率水平（默认为中位数）。 quantiles: float list [0., 1.]。Level的替代方案，从y分布估计的分位数。

参考文献
- Gneiting, Tilmann. (2011). “Quantiles as optimal point forecasts”. International Journal of Forecasting.
- Spyros Makridakis, Evangelos Spiliotis, Vassilios Assimakopoulos, Zhi Chen, Anil Gaba, Ilia Tsetlin, Robert L. Winkler. (2022). “The M5 uncertainty competition: Results, findings and conclusions”. International Journal of Forecasting.
- Syama Sundar Rangapuram, Lucien D Werner, Konstantinos Benidis, Pedro Mercado, Jan Gasthaus, Tim Januschowski. (2021). “End-to-End Learning of Coherent Probabilistic Forecasts for Hierarchical Time Series”. Proceedings of the 38th International Conference on Machine Learning (ICML).*

来源

sCRPS.call

 sCRPS.__call__ (y:torch.Tensor, y_hat:torch.Tensor,
                 y_insample:torch.Tensor,
                 mask:Optional[torch.Tensor]=None)

*参数：
y: 张量，实际值。
y_hat: 张量，预测值。
mask: 张量，指定每条序列在计算损失时要考虑的时间戳。

返回
scrps: 张量（单个值）。*

AutoModels NumPy 评估

在本页上

BasePointLoss
1. 与尺度相关的误差
平均绝对误差 (MAE)
MAE.__init__
MAE.__call__
均方误差 (MSE)
MSE.__init__
MSE.__call__
均方根误差 (RMSE)
RMSE.__init__
RMSE.__call__
2. 百分比误差
平均绝对百分比误差 (MAPE)
MAPE.__init__
MAPE.__call__
对称平均绝对百分比误差 (sMAPE)
SMAPE.__init__
SMAPE.__call__
3. 与尺度无关的误差
平均绝对缩放误差 (MASE)
MASE.__init__
MASE.__call__
相对均方误差 (relMSE)
relMSE.__init__
relMSE.__call__
4. 概率误差
分位数损失
QuantileLoss.__init__
QuantileLoss.__call__
多重分位数损失 (MQLoss)
MQLoss.__init__
MQLoss.__call__
隐式分位数损失 (IQLoss)
QuantileLayer
IQLoss.__init__
IQLoss.__call__
DistributionLoss
DistributionLoss.__init__
DistributionLoss.sample
DistributionLoss.__call__
泊松混合网 (PMM)
PMM.__init__
PMM.sample
PMM.__call__
高斯混合网 (GMM)
GMM.__init__
GMM.sample
GMM.__call__
负二项式混合网格 (NBMM)
NBMM.__init__
NBMM.sample
NBMM.__call__
5. 稳健误差
Huber损失
HuberLoss.__init__
HuberLoss.__call__
Tukey损失
TukeyLoss.__init__
TukeyLoss.__call__
Huber化分位数损失
HuberQLoss.__init__
HuberQLoss.__call__
Huber化多分位数损失
HuberMQLoss.__init__
HuberMQLoss.__call__
6. 其他
准确率
Accuracy.__init__
Accuracy.__call__
缩放的连续分级概率得分 (sCRPS)
sCRPS.__init__
sCRPS.__call__

入门指南

功能

教程

应用场景

API 参考

​BasePointLoss

​1. 与尺度相关的误差

​平均绝对误差 (MAE)

​MAE.__init__

​MAE.__call__

​均方误差 (MSE)

​MSE.__init__

​MSE.__call__

​均方根误差 (RMSE)

​RMSE.__init__

​RMSE.__call__

​2. 百分比误差

​平均绝对百分比误差 (MAPE)

​MAPE.__init__

​MAPE.__call__

​对称平均绝对百分比误差 (sMAPE)

​SMAPE.__init__

​SMAPE.__call__

​3. 与尺度无关的误差

​平均绝对缩放误差 (MASE)

​MASE.__init__

​MASE.__call__

​相对均方误差 (relMSE)

​relMSE.__init__

​relMSE.__call__

​4. 概率误差

​分位数损失

​QuantileLoss.__init__

​QuantileLoss.__call__

​多重分位数损失 (MQLoss)

​MQLoss.__init__

​MQLoss.__call__

​隐式分位数损失 (IQLoss)

​QuantileLayer

​IQLoss.__init__

​IQLoss.__call__

​DistributionLoss

​DistributionLoss.__init__

​DistributionLoss.sample

​DistributionLoss.__call__

​泊松混合网 (PMM)

​PMM.__init__

​PMM.sample

​PMM.__call__

​高斯混合网 (GMM)

​GMM.__init__

​GMM.sample

​GMM.__call__

​负二项式混合网格 (NBMM)

​NBMM.__init__

​NBMM.sample

​NBMM.__call__

​5. 稳健误差

​Huber损失

​HuberLoss.__init__

​HuberLoss.__call__

​Tukey损失

​TukeyLoss.__init__

​TukeyLoss.__call__

​Huber化分位数损失

​HuberQLoss.__init__

​HuberQLoss.__call__

​Huber化多分位数损失

​HuberMQLoss.__init__

​HuberMQLoss.__call__

​6. 其他

​准确率

​Accuracy.__init__

​Accuracy.__call__

​缩放的连续分级概率得分 (sCRPS)

​sCRPS.__init__

​sCRPS.__call__

BasePointLoss

1. 与尺度相关的误差

平均绝对误差 (MAE)

MAE.init

MAE.call

均方误差 (MSE)

MSE.init

MSE.call

均方根误差 (RMSE)

RMSE.init

RMSE.call

2. 百分比误差

平均绝对百分比误差 (MAPE)

MAPE.init

MAPE.call

对称平均绝对百分比误差 (sMAPE)

SMAPE.init

SMAPE.call

3. 与尺度无关的误差

平均绝对缩放误差 (MASE)

MASE.init

MASE.call

相对均方误差 (relMSE)

relMSE.init

relMSE.call

4. 概率误差

分位数损失

QuantileLoss.init

QuantileLoss.call

多重分位数损失 (MQLoss)

MQLoss.init

MQLoss.call

隐式分位数损失 (IQLoss)

QuantileLayer

IQLoss.init

IQLoss.call

DistributionLoss

DistributionLoss.init

DistributionLoss.sample

DistributionLoss.call

泊松混合网 (PMM)

PMM.init

PMM.sample

PMM.call

高斯混合网 (GMM)

GMM.init

GMM.sample

GMM.call

负二项式混合网格 (NBMM)

NBMM.init

NBMM.sample

NBMM.call

5. 稳健误差

Huber损失

HuberLoss.init

HuberLoss.call

Tukey损失

TukeyLoss.init

TukeyLoss.call

Huber化分位数损失

HuberQLoss.init

HuberQLoss.call

Huber化多分位数损失

HuberMQLoss.init

HuberMQLoss.call

6. 其他

准确率

Accuracy.init

Accuracy.call

缩放的连续分级概率得分 (sCRPS)

sCRPS.init

sCRPS.call