块状循环神经网络¶

class darts.models.forecasting.block_rnn_model.BlockRNNModel(input_chunk_length, output_chunk_length, output_chunk_shift=0, model='RNN', hidden_dim=25, n_rnn_layers=1, hidden_fc_sizes=None, dropout=0.0, activation='ReLU', **kwargs)[source]¶

基类: PastCovariatesTorchModel

块状循环神经网络模型 (RNNs)。

这是一种神经网络模型，它使用 RNN 编码器对固定长度的输入块进行编码，并使用全连接网络生成固定长度的输出。

该模型支持过去协变量（预测时间前 input_chunk_length 点已知）。

此类提供三种 RNN 变体：

普通 RNN
LSTM
GRU

参数

input_chunk_length (int) – 作为模型输入（每块）的过去时间步数。适用于目标序列以及过去和/或未来协变量（如果模型支持）。
output_chunk_length (int) – 内部模型一次（每块）预测的时间步数。如果模型支持未来协变量，也表示未来协变量中用于模型输入的未来值数量。它与 predict() 中使用的预测范围 n 不同，后者是使用一次性预测或自回归预测生成的所需预测点数量。设置 n <= output_chunk_length 可防止自回归。这在协变量未充分延伸到未来时非常有用，或根据模型的协变量支持禁止模型使用过去和/或未来协变量的未来值进行预测。
output_chunk_shift (int) – 可选参数，表示将输出块的起始点向未来移动（相对于输入块结束点）的步数。这将在输入和输出之间创建一个间隔。如果模型支持 future_covariates，则从偏移的输出块中提取未来值。预测将在目标 series 结束后 output_chunk_shift 步开始。如果设置了 output_chunk_shift，模型无法生成自回归预测（n > output_chunk_length）。
model (Union[str, type[CustomBlockRNNModule]]) – 指定 RNN 模块类型（“RNN”、“LSTM”或“GRU”）的字符串，或者具有自定义逻辑的 CustomBlockRNNModule 的子类（类本身，而不是类对象）。
hidden_dim (int) – 每个隐藏 RNN 层特征图的尺寸（\(h_n\)）。在 Darts 版本 <= 0.21 中，hidden_dim 被称为 hidden_size。
n_rnn_layers (int) – RNN 模块中的层数。
hidden_fc_sizes (Optional[list, None]) – 连接 RNN 模块最后一个隐藏层到输出的隐藏层尺寸（如果有）。
dropout (float) – 受 Dropout 影响的神经元比例。
activation (str) – 应用于全连接网络层之间的 torch.nn 激活函数名称。默认值：“ReLU”。
**kwargs – 初始化 pytorch_lightning.Module、pytorch_lightning.Trainer 和 Darts 的 TorchForecastingModel 的可选参数。
loss_fn – 用于训练的 PyTorch 损失函数。如果指定了 likelihood 参数，概率模型将忽略此参数。默认值：torch.nn.MSELoss()。
likelihood – Darts 的 Likelihood 模型之一，用于概率预测。默认值：None。
torch_metrics – 用于评估的 torch 指标或 MetricCollection。可用指标的完整列表可在 https://torchmetrics.readthedocs.io/en/latest/ 查看。默认值：None。
optimizer_cls – 要使用的 PyTorch 优化器类。默认值：torch.optim.Adam。
optimizer_kwargs – 可选参数，为 PyTorch 优化器提供一些关键字参数（例如，指定学习率的 {'lr': 1e-3}）。否则将使用选定 optimizer_cls 的默认值。默认值：None。
lr_scheduler_cls – 可选参数，要使用的 PyTorch 学习率调度器类。指定 None 对应于使用固定学习率。默认值：None。
lr_scheduler_kwargs – 可选参数，为 PyTorch 学习率调度器提供一些关键字参数。默认值：None。
use_reversible_instance_norm – 是否使用可逆实例归一化 RINorm 来应对分布变化，如 [1] 中所示。它仅应用于目标序列的特征，而不应用于协变量。
batch_size (int) – 每个训练批次中使用的时序数量（输入和输出序列）。默认值：32。
n_epochs (int) – 训练模型的 epoch 数。默认值：100。
model_name (Optional[str, None]) – 模型名称。用于创建检查点和保存 tensorboard 数据。如果未指定，默认值为以下字符串 "YYYY-mm-dd_HH_MM_SS_torch_model_run_PID"，其中名称的开头部分使用本地日期和时间格式化，而 PID 是进程 ID（防止由不同进程同时生成的模型共享相同的 model_name）。例如，"2021-06-14_09_53_32_torch_model_run_44607"。
work_dir (Optional[str, None]) – 工作目录路径，用于保存检查点和 Tensorboard 摘要。默认值：当前工作目录。
log_tensorboard (bool) – 如果设置，使用 Tensorboard 记录不同的参数。日志将位于："{work_dir}/darts_logs/{model_name}/logs/"。默认值：False。
nr_epochs_val_period (int) – 评估验证损失前等待的 epoch 数（如果将验证 TimeSeries 传递给 fit() 方法）。默认值：1。
force_reset (bool) – 如果设置为 True，任何先前存在的同名模型将被重置（所有检查点将被丢弃）。默认值：False。
save_checkpoints (bool) – 是否自动保存未经训练的模型和训练中的检查点。要从检查点加载模型，调用 MyModelClass.load_from_checkpoint()，其中 MyModelClass 是使用的 TorchForecastingModel 类（例如 TFTModel、NBEATSModel 等）。如果设置为 False，模型仍然可以使用 save() 手动保存，并使用 load() 加载。默认值：False。
add_encoders (Optional[dict[str, Union[IndexEncoder, Sequence[IndexEncoder], Pipeline, Callable]], None]) –
可以使用 add_encoders 自动生成大量的过去和未来协变量。这可以通过添加多个预定义索引编码器和/或用作索引编码器的自定义用户函数来实现。此外，还可以添加一个转换器，例如 Darts 的 Scaler，来转换生成的协变量。所有这些都在一个框架下发生，只需在模型创建时指定。阅读 SequentialEncoder 了解更多关于 add_encoders 的信息。默认值：None。以下是展示 add_encoders 部分功能的示例
```
def encode_year(idx):
    return (idx.year - 1950) / 50

add_encoders={
    'cyclic': {'future': ['month']},
    'datetime_attribute': {'future': ['hour', 'dayofweek']},
    'position': {'past': ['relative'], 'future': ['relative']},
    'custom': {'past': [encode_year]},
    'transformer': Scaler(),
    'tz': 'CET'
}
```
random_state (Optional[Union[RandomState, int], None]) – 控制权重初始化的随机性。更多详情请查看此链接。默认值：None。
pl_trainer_kwargs (Optional[dict[str, Any], None]) –
默认情况下，TorchForecastingModel 会创建一个 PyTorch Lightning Trainer，其中包含一些有用的预设，用于执行训练、验证和预测过程。这些预设包括自动检查点、tensorboard 日志记录、设置 torch 设备等。pl_trainer_kwargs 可以用于添加额外的关键字参数来实例化 PyTorch Lightning trainer 对象。有关支持的关键字参数的更多信息，请查看 PL Trainer 文档。默认值：None。还可以使用 pl_trainer_kwargs 通过指定键 "accelerator", "devices", and "auto_select_gpus" 在 GPU 上运行。以下是在 pl_trainer_kwargs 字典中设置设备的一些示例：
- {"accelerator": "cpu"} 用于 CPU，
- {"accelerator": "gpu", "devices": [i]} 仅使用 GPU i（i 必须是整数），
- {"accelerator": "gpu", "devices": -1, "auto_select_gpus": True} 使用所有可用的 GPU。
更多信息，请参见此处：https://pytorch-lightning.readthedocs.io/en/stable/common/trainer.html#trainer-flags 和 https://pytorch-lightning.readthedocs.io/en/stable/accelerators/gpu_basic.html#train-on-multiple-gpus

使用参数 "callbacks"，你可以将自定义或 PyTorch-Lightning 内置的回调添加到 Darts 的 TorchForecastingModel。以下是将 EarlyStopping 添加到训练过程的示例。如果验证损失 val_loss 未能按规范改进，模型将提前停止训练。有关回调的更多信息，请访问：PyTorch Lightning Callbacks
```
from pytorch_lightning.callbacks.early_stopping import EarlyStopping

# stop training when validation loss does not decrease more than 0.05 (`min_delta`) over
# a period of 5 epochs (`patience`)
my_stopper = EarlyStopping(
    monitor="val_loss",
    patience=5,
    min_delta=0.05,
    mode='min',
)

pl_trainer_kwargs={"callbacks": [my_stopper]}
```
注意，你还可以使用可选参数 trainer 在 fit() 和 predict() 中使用自定义的 PyTorch Lightning Trainer 进行训练和预测。
show_warnings (bool) – 是否显示 PyTorch Lightning 发出的警告。这有助于检测预测用例中的潜在问题。默认值：False。

参考文献

1: T. Kim et al. “Reversible Instance Normalization for Accurate Time-Series Forecasting against Distribution Shift”, https://openreview.net/forum?id=cGDAkQo1C0p

示例

>>> from darts.datasets import WeatherDataset
>>> from darts.models import BlockRNNModel
>>> series = WeatherDataset().load()
>>> # predicting atmospheric pressure
>>> target = series['p (mbar)'][:100]
>>> # optionally, use past observed rainfall (pretending to be unknown beyond index 100)
>>> past_cov = series['rain (mm)'][:100]
>>> # predict 6 pressure values using the 12 past values of pressure and rainfall, as well as the 6 temperature
>>> model = BlockRNNModel(
>>>     input_chunk_length=12,
>>>     output_chunk_length=6,
>>>     n_rnn_layers=2,
>>>     n_epochs=50,
>>> )
>>> model.fit(target, past_covariates=past_cov)
>>> pred = model.predict(6)
>>> pred.values()
array([[4.97979827],
       [3.9707572 ],
       [5.27869295],
       [5.19697244],
       [5.28424783],
       [5.22497681]])

注意

RNN 示例 Notebook 介绍了可用于提高预测质量的技术，与此简单使用示例相比。

属性

`considers_static_covariates`	如果存在静态协变量，模型是否考虑它们。
`extreme_lags`	一个 8 元组，按顺序包含：（最小目标滞后、最大目标滞后、最小过去协变量滞后、最大过去协变量滞后、最小未来协变量滞后、最大未来协变量滞后、输出偏移、最大训练目标滞后（仅适用于 RNNModel））。
`first_prediction_index`	返回 self.model 输出中第一个预测的索引。
`likelihood`	返回模型用于概率预测的似然函数（如果有）。
`min_train_samples`	训练模型的最小样本数。
`min_train_series_length`	类属性，定义训练序列所需的最小长度；覆盖 ForecastingModel 的默认值 3
`output_chunk_length`	模型一次预测的时间步数，未为统计模型定义。
`output_chunk_shift`	输出/预测在输入结束后开始的时间步数。
`supports_likelihood_parameter_prediction`	模型实例是否支持直接预测似然参数
`supports_multivariate`	模型是否考虑时间序列中的多个变量。
`supports_optimized_historical_forecasts`	模型是否支持优化的历史预测
`supports_past_covariates`	模型是否支持过去协变量
`supports_probabilistic_prediction`	检查此配置的预测模型是否支持概率预测。
`supports_sample_weight`	模型是否支持训练样本权重。
`supports_static_covariates`	模型是否支持静态协变量
`supports_transferable_series_prediction`	模型是否支持对任何输入 series 进行预测。
`uses_future_covariates`	模型拟合后是否使用未来协变量。
`uses_past_covariates`	模型拟合后是否使用过去协变量。
`uses_static_covariates`	模型拟合后是否使用静态协变量。

epochs_trained
input_chunk_length
model_created
model_params

方法

`回测`(series[, past_covariates, ...])	计算模型对（可能多个）series 进行历史预测时产生的误差值。
`拟合`(series[, past_covariates, ...])	在单个或多个序列上拟合/训练模型。
`从数据集拟合`(train_dataset[, ...])	使用特定的 `darts.utils.data.TrainingDataset` 实例训练模型。
`生成拟合编码`(series[, ...])	生成用于拟合模型的协变量编码，并返回一个元组，包含过去和未来协变量序列，其中原始协变量和编码后的协变量堆叠在一起。
`生成拟合预测编码`(n, series[, ...])	为训练和推断/预测生成协变量编码，并返回一个元组，包含过去和未来协变量序列，其中原始协变量和编码后的协变量堆叠在一起。
`生成预测编码`(n, series[, ...])	为推断/预测集生成协变量编码，并返回一个元组，包含过去和未来协变量序列，其中原始协变量和编码后的协变量堆叠在一起。
`网格搜索`(parameters, series[, ...])	使用网格搜索在给定集合中查找最佳超参数。
`历史预测`(series[, ...])	通过模拟在提供的（可能多个）series 的整个历史中各个时间点的预测来生成历史预测。
`初始化编码器`([default])	根据 self._model_encoder_settings 和模型创建时使用的参数 `add_encoders` 实例化 SequentialEncoder 对象
`加载`(path[, pl_trainer_kwargs])	从给定文件路径加载模型。
`从检查点加载`(model_name[, work_dir, ...])	从自动保存在 '{work_dir}/darts_logs/{model_name}/checkpoints/' 下的检查点加载模型。
`加载权重`(path[, load_encoders, skip_checks])	从手动保存的模型加载权重（使用 `save()` 保存）。
`从检查点加载权重`([model_name, ...])	仅从自动保存在 '{work_dir}/darts_logs/{model_name}/ checkpoints/' 下的检查点加载权重。
`lr_find`(series[, past_covariates, ...])	PyTorch Lightning 的 Tuner.lr_find() 的包装器。
`预测`(n[, series, past_covariates, ...])	预测训练序列或指定 `series` 结束后 `n` 个时间步。
`从数据集预测`(n, input_series_dataset)	此方法允许使用特定的 `darts.utils.data.InferenceDataset` 实例进行预测。
`reset_model`()	重置模型对象并移除所有存储的数据 - 模型、检查点、日志记录器和训练历史。
`残差`(series[, past_covariates, ...])	计算模型对（可能多个）series 进行历史预测时产生的残差。
`保存`([path, clean])	将模型保存到给定路径下。
`to_cpu`()	更新 PyTorch Lightning Trainer 参数，以便下次调用 :fun:`fit()` 或 `predict()` 时将模型移至 CPU。
`导出到 ONNX`([path])	将模型导出为 ONNX 格式以进行优化推理，包装了 PyTorch Lightning 的 `torch.onnx.export()` 方法（官方文档）。
`untrained_model`()	返回使用相同参数创建的新的（未经训练的）模型实例。

backtest(series, past_covariates=None, future_covariates=None, historical_forecasts=None, forecast_horizon=1, num_samples=1, train_length=None, start=None, start_format='value', stride=1, retrain=True, overlap_end=False, last_points_only=False, metric=<function mape>, reduction=<function mean>, verbose=False, show_warnings=True, predict_likelihood_parameters=False, enable_optimization=True, data_transformers=None, metric_kwargs=None, fit_kwargs=None, predict_kwargs=None, sample_weight=None)¶

计算模型对（可能多个）series 进行历史预测时产生的误差值。

如果提供了 historical_forecasts，则直接在所有预测和实际值上评估度量（由 metric 函数给出）。必须传递用于生成历史预测的相同 series 和 last_points_only 值。最后，该方法返回所有这些度量分数的可选 reduction（默认为平均值）。

如果 historical_forecasts 为 None，则首先使用下面给定的参数生成历史预测（更多信息请参阅 ForecastingModel.historical_forecasts()），然后按上述方法进行评估。

可以使用 metric_kwargs 进一步自定义度量指标（例如，控制对组件、时间步、多个序列的聚合，以及分位数指标所需的其他参数，如 q 等）。

参数

series (Union[TimeSeries, Sequence[TimeSeries]]) – 用于依次训练（如果 retrain 不是 False）和计算历史预测的（序列）目标时间序列。
past_covariates (Union[TimeSeries, Sequence[TimeSeries], None]) – 可选参数，为 series 中的每个输入时间序列提供（序列）过去观察到的协变量时间序列。仅当模型支持过去协变量时适用。
future_covariates (Union[TimeSeries, Sequence[TimeSeries], None]) – 可选参数，为 series 中的每个输入时间序列提供（序列）未来已知的协变量时间序列。仅当模型支持未来协变量时适用。
historical_forecasts (Union[TimeSeries, Sequence[TimeSeries], Sequence[Sequence[TimeSeries]], None]) – 可选参数，要评估的（或序列/序列的序列）历史预测时间序列。对应于 historical_forecasts() 的输出。必须传递用于生成历史预测的相同 series 和 last_points_only 值。如果提供，将跳过历史预测并忽略除 series、last_points_only、metric 和 reduction 之外的所有参数。
forecast_horizon (int) – 预测的预测范围。
num_samples (int) – 从概率模型中采样预测的次数。仅对概率模型使用 >1 的值。
train_length (Optional[int, None]) – 可选参数，为每个构建的训练集使用固定的长度/时间步数（滚动窗口模式）。仅当 retrain 不是 False 时有效。默认值是 None，在这种情况下，它使用直到预测时间的所有时间步（扩展窗口模式）。如果大于可用时间步数，则使用扩展模式。至少需要 min_train_series_length。
start (Union[Timestamp, float, int, None]) –
可选参数，计算预测的第一个时间点。此参数支持：float、int、pandas.Timestamp 和 None。如果是 float，则是时间序列中小于第一个预测点的时间比例。如果是 int，则对于带有 pd.DatetimeIndex 的 series 来说是第一个预测点的索引位置，对于带有 pd.RangeIndex 的 series 来说是索引值。后者可以使用 start_format=”position” 更改为索引位置。如果是 pandas.Timestamp，则是第一个预测点的时间戳。如果为 None，则第一个预测点将自动设置为
- 如果 retrain 为 False，或者 retrain 是一个 Callable 且第一个可预测点早于第一个可训练点，则设置为第一个可预测点。
- 如果 retrain 为 True 或 int（给定 train_length），或者 retrain 是一个 Callable 且第一个可训练点早于第一个可预测点，则设置为第一个可训练点。
- 否则设置为第一个可训练点（给定 train_length）
注意：如果 start 不在可训练/可预测点范围内，则使用最接近的有效起始点，该点
是 start 前面 stride 的整数倍。如果不存在有效的起始点，则引发 ValueError。

注意：如果模型使用偏移输出（output_chunk_shift > 0），则第一个预测点也会
向未来偏移 output_chunk_shift 个点。

注意：如果 start 超出可能的历史预测时间范围，将忽略该参数
（None 时的默认行为）并从第一个可训练/可预测点开始。
start_format (Literal[‘position’, ‘value’]) – 定义 start 的格式。如果设置为 'position'，start 对应于第一个预测点的索引位置，范围为 (-len(series), len(series) - 1)。如果设置为 'value'，start 对应于第一个预测点的索引值/标签。如果该值不在 series 的索引中，则会引发错误。默认值：'value'。
stride (int) – 两次连续预测之间的时间步数。
retrain (Union[bool, int, Callable[…, bool]]) –
在预测前是否以及/或在何种条件下重新训练模型。此参数支持 3 种不同类型：bool、(正) int 和 Callable（返回 bool）。如果是 bool：在每个步骤重新训练模型（True），或从不重新训练模型（False）。如果是 int：模型每 retrain 次迭代重新训练一次。如果是 Callable：只要可调用对象返回 True，模型就会重新训练。可调用对象必须具有以下位置参数
- counter (int)：当前的 retrain 迭代次数
- pred_time (pd.Timestamp 或 int)：预测时间戳（训练序列结束时）
- train_series (TimeSeries)：直到 pred_time 的训练序列
- past_covariates (TimeSeries)：直到 pred_time 的 past_covariates 序列
- future_covariates (TimeSeries)：直到 min(pred_time + series.freq * forecast_horizon, series.end_time()) 的 future_covariates 序列
注意：如果任何可选的 *_covariates 未传递给 historical_forecast，则 None 将传递给相应的 retrain 函数参数。注意：某些模型需要每次重新训练，并且除了 retrain=True 之外不支持任何其他值。注意：这也控制 data_transformers 的重新训练。
overlap_end (bool) – 返回的预测是否可以超出序列的结束点。
last_points_only (bool) – 是否只返回每个历史预测的最后一个点。如果设置为 True，该方法将返回一个包含连续点预测的单个 TimeSeries（对于 series 中的每个时间序列）。否则，返回一个历史 TimeSeries 预测列表。
metric (Union[Callable[…, Union[float, list[float], ndarray, list[ndarray]]], list[Callable[…, Union[float, list[float], ndarray, list[ndarray]]]]]) – 度量函数或度量函数列表。每个度量必须是 Darts 度量（参见此处），或具有与 Darts 度量相同签名、使用装饰器 multi_ts_support() 和 multi_ts_support() 并返回度量分数的自定义度量。
reduction (Optional[Callable[…, float], None]) – 用于组合当 last_points_only 设置为 False 时获得的各个误差分数的函数。提供多个度量函数时，函数将接收参数 axis = 1 以获得每个度量函数的单个值。如果显式设置为 None，该方法将返回各个误差分数列表。默认为 np.mean。
verbose (bool) – 是否打印进度。
show_warnings (bool) – 是否显示与历史预测优化或参数 start 和 train_length 相关的警告。
predict_likelihood_parameters (bool) – 如果设置为 True，模型将预测其 likelihood 的参数而不是目标。仅支持带有似然函数、num_samples = 1 且 n<=output_chunk_length 的概率模型。默认值：False。
enable_optimization (bool) – 在支持和可用时是否使用优化的 historical_forecasts 版本。默认值：True。
data_transformers (Optional[dict[str, Union[BaseDataTransformer, Pipeline]], None]) –
可选参数，一个 BaseDataTransformer 或 Pipeline 字典，应用于相应的序列（可能的键：“series”、“past_covariates”、“future_covariates”）。如果提供，所有输入序列必须处于未转换空间中。对于可拟合的转换器/管道
- 如果 retrain=True，数据转换器在每个历史预测步骤重新拟合训练数据。
- 如果 retrain=False，数据转换器在所有预测之前对序列进行一次转换。
拟合后的转换器用于在训练和预测期间转换输入。如果转换是可逆的，则预测将被逆向转换。仅当 historical_forecasts=None 时有效。
metric_kwargs (Union[dict[str, Any], list[dict[str, Any]], None]) – 传递给 metric() 的附加参数，例如用于并行化的 ‘n_jobs’，用于减少组件级别指标的 ‘component_reduction’，用于缩放指标的季节性参数 ‘m’ 等。将参数单独传递给每个指标，并且仅当它们存在于相应的指标签名中时。缩放指标（例如 mase、rmsse 等）的参数 ‘insample’ 被忽略，因为它在内部处理。
fit_kwargs (Optional[dict[str, Any], None]) – 可选参数，传递给模型 fit() 方法的一些额外参数。
predict_kwargs (Optional[dict[str, Any], None]) – 可选参数，传递给模型 predict() 方法的一些额外参数。
sample_weight (Union[TimeSeries, Sequence[TimeSeries], str, None]) – 可选参数，应用于训练目标 series 标签的一些样本权重。仅当 retrain 不是 False 时有效。它们按观测值、按标签（output_chunk_length 中的每一步）和按组件应用。如果是一个或一系列序列，则使用这些权重。如果权重序列只有一个组件/列，则权重全局应用于 series 中的所有组件。否则，对于组件特定权重，组件数量必须与 series 的组件数量匹配。如果是字符串，则使用内置权重函数生成权重。可用选项是 “linear” 或 “exponential” 衰减 - 过去越远，权重越低。权重是按时间 series 计算的。

返回类型

Union[float, ndarray, list[float], list[ndarray]]

返回值

float – 单个单/多变量序列、单个 metric 函数和
- 使用 last_points_only=True 生成的 historical_forecasts 的单个回测分数
- 使用 last_points_only=False 并使用回测 reduction 生成的 historical_forecasts 的单个回测分数
np.ndarray – 回测分数的一个 numpy 数组。对于单个序列以及以下之一：
- 单个 metric 函数，使用 last_points_only=False 且回测 reduction=None 生成的 historical_forecasts。输出形状为 (n forecasts, *)。
- 多个 metric 函数，使用 last_points_only=False 生成的 historical_forecasts。使用回测 reduction 时，输出形状为 (*, n metrics)，当 reduction=None 时，输出形状为 (n forecasts, *, n metrics)
- 多个单/多变量序列，包括 series_reduction 以及至少一个 component_reduction=None 或 time_reduction=None，用于“每个时间步的指标”
List[float] – 与 float 类型相同，但适用于序列的序列。返回的指标列表长度为 len(series)，包含每个输入 series 的 float 指标。
List[np.ndarray] – 与 np.ndarray 类型相同，但适用于序列的序列。返回的指标列表长度为 len(series)，包含每个输入 series 的 np.ndarray 指标。

property considers_static_covariates: bool¶

如果存在静态协变量，模型是否考虑它们。

返回类型: bool

property extreme_lags: tuple[Optional[int], Optional[int], Optional[int], Optional[int], Optional[int], Optional[int], int, Optional[int]]¶

一个 8 元组，按顺序包含：（最小目标滞后、最大目标滞后、最小过去协变量滞后、最大过去协变量滞后、最小未来协变量滞后、最大未来协变量滞后、输出偏移、最大训练目标滞后（仅适用于 RNNModel））。如果 0 是第一个预测的索引，则所有滞后都相对于此索引。

参见下面的示例。

如果模型没有拟合以下内容：

目标（仅涉及 RegressionModels）：则第一个元素应为 None。
过去协变量：则第三和第四个元素应为 None。
未来协变量：则第五和第六个元素应为 None。

应由使用过去或未来协变量的模型以及/或其最小目标滞后和最大目标滞后可能与 -1 和 0 不同的模型覆盖。

注意

最大目标滞后（第二个值）不能为 None，并且总是大于或等于 0。

示例

>>> model = LinearRegressionModel(lags=3, output_chunk_length=2)
>>> model.fit(train_series)
>>> model.extreme_lags
(-3, 1, None, None, None, None, 0, None)
>>> model = LinearRegressionModel(lags=3, output_chunk_length=2, output_chunk_shift=2)
>>> model.fit(train_series)
>>> model.extreme_lags
(-3, 1, None, None, None, None, 2, None)
>>> model = LinearRegressionModel(lags=[-3, -5], lags_past_covariates = 4, output_chunk_length=7)
>>> model.fit(train_series, past_covariates=past_covariates)
>>> model.extreme_lags
(-5, 6, -4, -1,  None, None, 0, None)
>>> model = LinearRegressionModel(lags=[3, 5], lags_future_covariates = [4, 6], output_chunk_length=7)
>>> model.fit(train_series, future_covariates=future_covariates)
>>> model.extreme_lags
(-5, 6, None, None, 4, 6, 0, None)
>>> model = NBEATSModel(input_chunk_length=10, output_chunk_length=7)
>>> model.fit(train_series)
>>> model.extreme_lags
(-10, 6, None, None, None, None, 0, None)
>>> model = NBEATSModel(input_chunk_length=10, output_chunk_length=7, lags_future_covariates=[4, 6])
>>> model.fit(train_series, future_covariates)
>>> model.extreme_lags
(-10, 6, None, None, 4, 6, 0, None)

返回类型: tuple[Optional[int, None], Optional[int, None], Optional[int, None], Optional[int, None], Optional[int, None], Optional[int, None], int, Optional[int, None]]

property first_prediction_index: int¶

返回 self.model 输出中第一个预测的索引。

返回类型: int

fit(series, past_covariates=None, future_covariates=None, val_series=None, val_past_covariates=None, val_future_covariates=None, trainer=None, verbose=None, epochs=0, max_samples_per_ts=None, dataloader_kwargs=None, sample_weight=None, val_sample_weight=None)¶

在单个或多个序列上拟合/训练模型。

此方法是对 fit_from_dataset() 的封装，它为该模型构建一个默认的训练数据集。如果您需要更精细地控制用于训练的时间序列如何切片，请考虑调用 fit_from_dataset() 并传入一个自定义的 darts.utils.data.TrainingDataset。

训练使用 PyTorch Lightning Trainer 进行。它使用预设和模型创建时使用的 pl_trainer_kwargs 中的默认 Trainer 对象。您也可以通过可选参数 trainer 使用自定义 Trainer。有关 PyTorch Lightning Trainer 的更多信息，请查阅此链接。

此函数可以多次调用以进行额外的训练。如果指定了 epochs，模型将进行一些（额外）的 epochs 轮训练。

下面列出了所有可能的参数，但并非所有模型都支持所有参数。例如，所有 PastCovariatesTorchModel 只支持 past_covariates 而不支持 future_covariates。如果您尝试使用错误的协变量参数来拟合模型，Darts 将会报错。

在处理协变量时，Darts 将尝试使用目标和协变量的时间轴来确定正确的时间切片。因此，协变量可以比所需的更长；只要时间轴正确，Darts 就会正确处理它们。如果它们的时跨不够，Darts 也会报错。

参数

series (Union[TimeSeries, Sequence[TimeSeries]]) – 用作目标的序列或序列列表（即模型将训练预测的内容）
past_covariates (Union[TimeSeries, Sequence[TimeSeries], None]) – 可选的，指定过去观测到的协变量的序列或序列列表
future_covariates (Union[TimeSeries, Sequence[TimeSeries], None]) – 可选的，指定未来已知的协变量的序列或序列列表
val_series (Union[TimeSeries, Sequence[TimeSeries], None]) – 可选的，一个或一系列验证目标序列，将在整个训练过程中用于计算验证损失并跟踪表现最佳的模型。
val_past_covariates (Union[TimeSeries, Sequence[TimeSeries], None]) – 可选的，对应于验证序列的过去协变量（必须与 covariates 匹配）
val_future_covariates (Union[TimeSeries, Sequence[TimeSeries], None]) – 可选的，对应于验证序列的未来协变量（必须与 covariates 匹配）
val_sample_weight (Union[TimeSeries, Sequence[TimeSeries], str, None]) – 与 sample_weight 相同，但用于评估数据集。
trainer (Optional[Trainer, None]) – 可选的，用于执行训练的自定义 PyTorch-Lightning Trainer 对象。使用自定义的 trainer 将覆盖 Darts 的默认 trainer。
verbose (Optional[bool, None]) – 是否打印进度。如果在 pl_trainer_kwargs 中有 ProgressBar 回调，则忽略此参数。
epochs (int) – 如果指定，模型将额外训练 epochs 轮，无论模型构造函数中提供了什么 n_epochs 值。
max_samples_per_ts (Optional[int, None]) – 可选的，每个时间序列使用的最大样本数。模型通过构建 (输入, 输出) 示例切片以监督方式训练。在长时间序列上，这可能导致训练样本数量过大。此参数限制每个时间序列的训练样本数量（只取每个序列中最新的样本）。设置为 None 则不应用任何上限。
dataloader_kwargs (Optional[dict[str, Any], None]) –
可选的，用于创建训练和验证数据集的 PyTorch DataLoader 实例的关键字参数字典。有关 DataLoader 的更多信息，请查阅此链接。默认情况下，Darts 会配置参数（“batch_size”、“shuffle”、“drop_last”、“collate_fn”、“pin_memory”）以实现无缝预测。更改这些参数时应谨慎，以免出现意外行为。
sample_weight (Union[TimeSeries, Sequence[TimeSeries], str, None]) – 可选的，应用于目标 series 标签的一些样本权重。它们应用于每个观测值、每个标签（output_chunk_length 中的每个步骤）和每个组件。如果是一个序列或序列列表，则使用这些权重。如果权重序列只有一个组件/列，则权重全局应用于 series 中的所有组件。否则，对于特定组件的权重，组件数量必须与 series 的数量匹配。如果是一个字符串，则使用内置的权重函数生成权重。可用的选项是 “linear” 或 “exponential” 衰减 - 过去越远，权重越低。权重是根据 series 中最长序列的长度全局计算的。然后对于每个序列，权重从全局权重的末尾提取。这为所有序列提供了共同的时间加权。
val_sample_weight – 与 sample_weight 相同，但用于评估数据集。

返回值

拟合的模型。

返回类型

self

fit_from_dataset(train_dataset, val_dataset=None, trainer=None, verbose=None, epochs=0, dataloader_kwargs=None)¶

使用特定的 darts.utils.data.TrainingDataset 实例训练模型。这些数据集实现了 PyTorch Dataset，并指定了目标和协变量如何切片用于训练。如果您不确定使用哪种训练数据集，可以考虑调用 fit()，它将为该模型创建一个适当的默认训练数据集。

此函数可以多次调用以进行额外的训练。如果指定了 epochs，模型将进行一些（额外）的 epochs 轮训练。

参数

train_dataset (TrainingDataset) – 与此模型类型匹配的训练数据集（例如，PastCovariatesTrainingDataset 用于 PastCovariatesTorchModel）。
val_dataset (Optional[TrainingDataset, None]) – 与此模型类型匹配的训练数据集（例如，PastCovariatesTrainingDataset 用于 :class:`PastCovariatesTorchModel`s），表示验证集（用于跟踪验证损失）。
trainer (Optional[Trainer, None]) – 可选的，用于执行预测的自定义 PyTorch-Lightning Trainer 对象。使用自定义的 trainer 将覆盖 Darts 的默认 trainer。
verbose (Optional[bool, None]) – 是否打印进度。如果在 pl_trainer_kwargs 中有 ProgressBar 回调，则忽略此参数。
epochs (int) – 如果指定，模型将额外训练 epochs 轮，无论模型构造函数中提供了什么 n_epochs 值。
dataloader_kwargs (Optional[dict[str, Any], None]) –
可选的，用于创建训练和验证数据集的 PyTorch DataLoader 实例的关键字参数字典。有关 DataLoader 的更多信息，请查阅此链接。默认情况下，Darts 会配置参数（“batch_size”、“shuffle”、“drop_last”、“collate_fn”、“pin_memory”）以实现无缝预测。更改这些参数时应谨慎，以免出现意外行为。

返回值

拟合的模型。

返回类型

self

generate_fit_encodings(series, past_covariates=None, future_covariates=None)¶

生成用于拟合模型时使用/生成的协变量编码，并返回一个过去协变量序列和未来协变量序列的元组，其中包含原始和编码后的协变量叠加在一起。编码是由模型创建时参数 add_encoders 定义的编码器生成的。传入与训练/拟合模型时使用的相同的 series、past_covariates 和 future_covariates。

参数

series (Union[TimeSeries, Sequence[TimeSeries]]) – 训练模型时使用的带有目标值的序列或序列列表。
past_covariates (Union[TimeSeries, Sequence[TimeSeries], None]) – 可选的，训练模型时使用的带有过去观测到的协变量的序列或序列列表。
future_covariates (Union[TimeSeries, Sequence[TimeSeries], None]) – 可选的，训练模型时使用的带有未来已知的协变量的序列或序列列表。

返回值

一个包含 (过去协变量, 未来协变量) 的元组。每个协变量包含原始协变量以及编码后的协变量。

返回类型

Tuple[Union[TimeSeries, Sequence[TimeSeries]], Union[TimeSeries, Sequence[TimeSeries]]]

generate_fit_predict_encodings(n, series, past_covariates=None, future_covariates=None)¶

生成用于训练和推断/预测的协变量编码，并返回一个过去协变量序列和未来协变量序列的元组，其中包含原始和编码后的协变量叠加在一起。编码是由模型创建时参数 add_encoders 定义的编码器生成的。传入您打算用于训练和预测的相同的 series、past_covariates 和 future_covariates。

参数

n (int) – 打算用于预测的在 series 结束后预测的时间步数。
series (Union[TimeSeries, Sequence[TimeSeries]]) – 打算用于训练和预测的带有目标值的序列或序列列表。
past_covariates (Union[TimeSeries, Sequence[TimeSeries], None]) – 可选的，打算用于训练和预测的过去观测到的协变量序列。维度必须与用于训练的协变量维度匹配。
future_covariates (Union[TimeSeries, Sequence[TimeSeries], None]) – 可选的，打算用于预测的未来已知协变量序列。维度必须与用于训练的协变量维度匹配。

返回值

一个包含 (过去协变量, 未来协变量) 的元组。每个协变量包含原始协变量以及编码后的协变量。

返回类型

Tuple[Union[TimeSeries, Sequence[TimeSeries]], Union[TimeSeries, Sequence[TimeSeries]]]

generate_predict_encodings(n, series, past_covariates=None, future_covariates=None)¶

生成用于推断/预测集的协变量编码，并返回一个过去协变量序列和未来协变量序列的元组，其中包含原始和编码后的协变量叠加在一起。编码是由模型创建时参数 add_encoders 定义的编码器生成的。传入您打算用于预测的相同的 series、past_covariates 和 future_covariates。

参数

n (int) – 打算用于预测的在 series 结束后预测的时间步数。
series (Union[TimeSeries, Sequence[TimeSeries]]) – 打算用于预测的带有目标值的序列或序列列表。
past_covariates (Union[TimeSeries, Sequence[TimeSeries], None]) – 可选的，打算用于预测的过去观测到的协变量序列。维度必须与用于训练的协变量维度匹配。
future_covariates (Union[TimeSeries, Sequence[TimeSeries], None]) – 可选的，打算用于预测的未来已知协变量序列。维度必须与用于训练的协变量维度匹配。

返回值

一个包含 (过去协变量, 未来协变量) 的元组。每个协变量包含原始协变量以及编码后的协变量。

返回类型

Tuple[Union[TimeSeries, Sequence[TimeSeries]], Union[TimeSeries, Sequence[TimeSeries]]]

classmethod gridsearch(parameters, series, past_covariates=None, future_covariates=None, forecast_horizon=None, stride=1, start=None, start_format='value', last_points_only=False, show_warnings=True, val_series=None, use_fitted_values=False, metric=<function mape>, reduction=<function mean>, verbose=False, n_jobs=1, n_random_samples=None, data_transformers=None, fit_kwargs=None, predict_kwargs=None, sample_weight=None)¶

使用网格搜索在给定集合中查找最佳超参数。

此函数有 3 种操作模式：扩展窗口模式、分割模式和拟合值模式。这三种操作模式通过实例化 ForecastingModel 的 model_class 子类并结合 parameters 字典中提供的每种超参数值组合来评估每种可能的组合，并返回针对 metric 函数表现最佳的模型。metric 函数应返回一个误差值，因此将选择产生最小 metric 输出的模型。

训练数据和测试数据的关系取决于操作模式。

扩展窗口模式（当传入 forecast_horizon 时激活）：对于每种超参数组合，模型在 series 的不同分割上重复训练和评估。此过程通过使用 backtest() 函数作为子程序，生成从 start 开始的历史预测，并将其与 series 的真实值进行比较。请注意，对于每一次预测，模型都会重新训练，因此此模式较慢。

分割窗口模式（当传入 val_series 时激活）：当传入 val_series 参数时，将使用此模式。对于每种超参数组合，模型在 series 上训练并在 val_series 上评估。

拟合值模式（当 use_fitted_values 设置为 True 时激活）：对于每种超参数组合，模型在 series 上训练，并评估其产生的拟合值。并非所有模型都有拟合值，如果模型没有 fitted_values 成员，此方法将引发错误。拟合值是模型在 series 上拟合的结果。与拟合值比较是一种快速评估模型的方法，但无法看出模型是否过拟合了序列。

派生类必须确保模型的单个实例不会与其他实例共享参数，例如，保存模型到同一路径。否则，当并行运行多个模型（当 n_jobs != 1 时）时，可能会出现意外行为。如果无法避免，则应重新定义 gridsearch，强制 n_jobs = 1。

目前，此方法仅支持确定性预测（即模型的预测只有 1 个样本）。

参数

model_class – ForecastingModel 子类，将针对 'series' 进行调优。
parameters (dict) – 一个字典，其键是超参数名称，值是相应超参数的值列表。
series (TimeSeries) – 用作训练的输入和目标的目标序列。
past_covariates (Optional[TimeSeries, None]) – 可选的，一个过去观测到的协变量序列。仅当模型支持过去协变量时适用。
future_covariates (Optional[TimeSeries, None]) – 可选的，一个未来已知的协变量序列。仅当模型支持未来协变量时适用。
forecast_horizon (Optional[int, None]) – 预测范围的整数值。激活扩展窗口模式。
stride (int) – 仅在扩展窗口模式下使用。两次连续预测之间的时间步数。
start (Union[Timestamp, float, int, None]) –
仅在扩展窗口模式下使用。可选的，计算第一个预测点的时间点。此参数支持：float、int、pandas.Timestamp 和 None。如果为 float，则表示时间序列中应位于第一个预测点之前的部分。如果为 int，则对于带有 pd.DatetimeIndex 的 series，它是第一个预测点的索引位置；对于带有 pd.RangeIndex 的 series，它是索引值。后者可以通过 start_format=”position” 更改为索引位置。如果为 pandas.Timestamp，则它是第一个预测点的时间戳。如果为 None，则第一个预测点将自动设置为
- 如果 retrain 为 False，或者 retrain 是一个 Callable 且第一个可预测点早于第一个可训练点，则设置为第一个可预测点。
- 如果 retrain 是 True 或 int（给定 train_length），则为第一个可训练点，或者如果 retrain 是可调用对象且第一个可训练点早于第一个可预测点。
- 否则设置为第一个可训练点（给定 train_length）
注意：如果 start 不在可训练/可预测点范围内，则使用最接近的有效起始点，该点
是 start 前面 stride 的整数倍。如果不存在有效的起始点，则引发 ValueError。

注意：如果模型使用偏移输出（output_chunk_shift > 0），则第一个预测点也会
向未来偏移 output_chunk_shift 个点。

注意：如果 start 超出可能的历史预测时间范围，将忽略该参数
（None 时的默认行为）并从第一个可训练/可预测点开始。
start_format (Literal[‘position’, ‘value’]) – 仅在扩展窗口模式下使用。定义 start 的格式。仅当 start 为整数且 series 使用 pd.RangeIndex 索引时生效。如果设置为 'position'，start 对应于第一个预测点的索引位置，范围为 (-len(series), len(series) - 1)。如果设置为 'value'，start 对应于第一个预测点的索引值/标签。如果该值不在 series 的索引中，将引发错误。默认为 'value'。
last_points_only (bool) – 仅在扩展窗口模式下使用。是否只使用每个预测的最后一个点来计算误差，而不是整个预测。
show_warnings (bool) – 仅在扩展窗口模式下使用。是否显示与 start 参数相关的警告。
val_series (Optional[TimeSeries, None]) – 在分割模式下用于验证的时间序列实例。如果提供，此序列必须紧接在 series 的末尾之后开始；以便可以进行适当的预测比较。
use_fitted_values (bool) – 如果为 True，则使用与拟合值的比较。如果 fitted_values 不是 model_class 的属性，则引发错误。
metric (Callable[[TimeSeries, TimeSeries], float]) –
一个度量函数，返回两个 TimeSeries 之间的误差作为浮点值。必须是 Darts 的“时间聚合”度量之一（参见此处），或者一个自定义度量，其输入为两个 TimeSeries 并返回误差。
reduction (Callable[[ndarray], float]) – 一个归约函数（将数组映射到浮点数），描述在回测时如何聚合在不同验证序列上获得的误差。默认情况下，它将计算误差的平均值。
verbose – 是否打印进度。
n_jobs (int) – 并行运行的作业数。仅当有两个或更多参数组合需要评估时才会创建并行作业。每个作业将实例化、训练和评估模型的不同实例。默认为 1（顺序执行）。将参数设置为 -1 表示使用所有可用的核心。
n_random_samples (Union[int, float, None]) – 从完整参数网格中选择的超参数组合的数量/比例。这将执行随机搜索而不是使用完整的网格。如果是整数，n_random_samples 是从完整网格中选择的参数组合数量，必须介于 0 和参数组合总数之间。如果是浮点数，n_random_samples 是从完整网格中选择的参数组合比例，必须介于 0 和 1 之间。默认为 None，此时将忽略随机选择。
data_transformers (Optional[dict[str, Union[BaseDataTransformer, Pipeline]], None]) –
可选参数，一个 BaseDataTransformer 或 Pipeline 字典，应用于相应的序列（可能的键：“series”、“past_covariates”、“future_covariates”）。如果提供，所有输入序列必须处于未转换空间中。对于可拟合的转换器/管道
- 如果 retrain=True，数据转换器在每个历史预测步骤重新拟合训练数据。
- 如果 retrain=False，数据转换器在所有预测之前对序列进行一次转换。
拟合的转换器用于在训练和预测期间转换输入。如果转换器是可逆的，预测结果将被逆转换。
fit_kwargs (Optional[dict[str, Any], None]) – 传递给模型 fit() 方法的额外参数。
predict_kwargs (Optional[dict[str, Any], None]) – 传递给模型 predict() 方法的额外参数。
sample_weight (Union[TimeSeries, str, None]) – 可选的，应用于训练目标 series 标签的一些样本权重。仅当 retrain 不为 False 时有效。它们应用于每个观测值、每个标签（output_chunk_length 中的每个步骤）和每个组件。如果是一个序列，则使用这些权重。如果权重序列只有一个组件/列，则权重全局应用于 series 中的所有组件。否则，对于特定组件的权重，组件数量必须与 series 的数量匹配。如果是一个字符串，则使用内置的权重函数生成权重。可用的选项是 “linear” 或 “exponential” 衰减 - 过去越远，权重越低。

返回值

一个元组，包含一个从未训练过的 model_class 实例（使用表现最佳的超参数创建）、一个包含这些最佳超参数的字典以及最佳超参数的度量分数。

返回类型

ForecastingModel, Dict, float

historical_forecasts(series, past_covariates=None, future_covariates=None, forecast_horizon=1, num_samples=1, train_length=None, start=None, start_format='value', stride=1, retrain=True, overlap_end=False, last_points_only=True, verbose=False, show_warnings=True, predict_likelihood_parameters=False, enable_optimization=True, data_transformers=None, fit_kwargs=None, predict_kwargs=None, sample_weight=None)¶

通过模拟在提供的（可能是多个）series 历史中不同时间点的预测来生成历史预测。此过程涉及追溯性地将模型应用于不同的时间步长，就像那些时刻进行了实时预测一样。这允许在整个序列持续时间内评估模型的性能，从而深入了解其在不同历史时期的预测准确性和鲁棒性。

此方法有两种主要模式：

再训练模式（默认，retrain=True）：在模拟的每一步重新训练模型，并使用更新后的模型生成预测。对于多个序列的情况，模型会独立地在每个序列上重新训练（尚不支持全局训练）。
预训练模式（retrain=False）：在模拟的每一步生成预测，而无需重新训练。仅支持预训练的全局预测模型。此模式明显更快，因为它跳过了再训练步骤。

通过选择合适的模式，您可以在计算效率和需要最新模型训练之间进行平衡。

再训练模式： 此模式通过从 series 的开头扩展或使用固定长度的 train_length 来重复构建训练集（起始点也可以通过 start 和 start_format 配置）。然后模型在此训练集上进行训练，并生成长度为 forecast_horizon 的预测。随后，训练集的结束点向前移动 stride 个时间步长，并重复此过程。

预训练模式： 此模式仅支持预训练的全局预测模型。它使用与 *再训练模式* 相同的模拟步骤（忽略 train_length），但直接生成预测而无需重新训练。

默认情况下，当 last_points_only=True 时，此方法返回单个时间序列（或时间序列列表），该序列由每个历史预测的最后一个点组成。因此，此时间序列的频率为 series.freq * stride。如果 last_points_only=False，它将改为返回完整历史预测序列的列表（或列表的列表），每个序列的频率为 series.freq。

参数

series (Union[TimeSeries, Sequence[TimeSeries]]) – 用于依次训练（如果 retrain 不是 False）和计算历史预测的（序列）目标时间序列。
past_covariates (Union[TimeSeries, Sequence[TimeSeries], None]) – 可选参数，为 series 中的每个输入时间序列提供（序列）过去观察到的协变量时间序列。仅当模型支持过去协变量时适用。
future_covariates (Union[TimeSeries, Sequence[TimeSeries], None]) – 可选参数，为 series 中的每个输入时间序列提供（序列）未来已知的协变量时间序列。仅当模型支持未来协变量时适用。
forecast_horizon (int) – 预测的预测范围。
num_samples (int) – 从概率模型中采样预测的次数。仅对概率模型使用 >1 的值。
train_length (Optional[int, None]) – 可选参数，为每个构建的训练集使用固定的长度/时间步数（滚动窗口模式）。仅当 retrain 不是 False 时有效。默认值是 None，在这种情况下，它使用直到预测时间的所有时间步（扩展窗口模式）。如果大于可用时间步数，则使用扩展模式。至少需要 min_train_series_length。
start (Union[Timestamp, float, int, None]) –
可选参数，计算预测的第一个时间点。此参数支持：float、int、pandas.Timestamp 和 None。如果是 float，则是时间序列中小于第一个预测点的时间比例。如果是 int，则对于带有 pd.DatetimeIndex 的 series 来说是第一个预测点的索引位置，对于带有 pd.RangeIndex 的 series 来说是索引值。后者可以使用 start_format=”position” 更改为索引位置。如果是 pandas.Timestamp，则是第一个预测点的时间戳。如果为 None，则第一个预测点将自动设置为
- 如果 retrain 为 False，或者 retrain 是一个 Callable 且第一个可预测点早于第一个可训练点，则设置为第一个可预测点。
- 如果 retrain 为 True 或 int（给定 train_length），或者 retrain 是一个 Callable 且第一个可训练点早于第一个可预测点，则设置为第一个可训练点。
- 否则设置为第一个可训练点（给定 train_length）
注意：如果 start 不在可训练/可预测点范围内，则使用最接近的有效起始点，该点
是 start 前面 stride 的整数倍。如果不存在有效的起始点，则引发 ValueError。

注意：如果模型使用偏移输出（output_chunk_shift > 0），则第一个预测点也会
向未来偏移 output_chunk_shift 个点。

注意：如果 start 超出可能的历史预测时间范围，将忽略该参数
（None 时的默认行为）并从第一个可训练/可预测点开始。
start_format (Literal[‘position’, ‘value’]) – 定义 start 的格式。如果设置为 'position'，start 对应于第一个预测点的索引位置，范围为 (-len(series), len(series) - 1)。如果设置为 'value'，start 对应于第一个预测点的索引值/标签。如果该值不在 series 的索引中，则会引发错误。默认值：'value'。
stride (int) – 两次连续预测之间的时间步数。
retrain (Union[bool, int, Callable[…, bool]]) –
在预测前是否以及/或在何种条件下重新训练模型。此参数支持 3 种不同类型：bool、(正) int 和 Callable（返回 bool）。如果是 bool：在每个步骤重新训练模型（True），或从不重新训练模型（False）。如果是 int：模型每 retrain 次迭代重新训练一次。如果是 Callable：只要可调用对象返回 True，模型就会重新训练。可调用对象必须具有以下位置参数
- counter (int)：当前的 retrain 迭代次数
- pred_time (pd.Timestamp 或 int)：预测时间戳（训练序列结束时）
- train_series (TimeSeries)：直到 pred_time 的训练序列
- past_covariates (TimeSeries)：直到 pred_time 的 past_covariates 序列
- future_covariates (TimeSeries)：直到 min(pred_time + series.freq * forecast_horizon, series.end_time()) 的 future_covariates 序列
注意：如果任何可选的 *_covariates 未传递给 historical_forecast，则 None 将传递给相应的 retrain 函数参数。注意：某些模型需要每次重新训练，并且除了 retrain=True 之外不支持任何其他值。注意：这也控制 data_transformers 的重新训练。
overlap_end (bool) – 返回的预测是否可以超出序列的结束点。
last_points_only (bool) – 是否只返回每个历史预测的最后一个点。如果设置为 True，该方法将返回一个包含连续点预测的单个 TimeSeries（对于 series 中的每个时间序列）。否则，返回一个历史 TimeSeries 预测列表。
verbose (bool) – 是否打印进度。
show_warnings (bool) – 是否显示与历史预测优化或参数 start 和 train_length 相关的警告。
predict_likelihood_parameters (bool) – 如果设置为 True，模型将预测其 likelihood 的参数而不是目标。仅支持带有似然函数、num_samples = 1 且 n<=output_chunk_length 的概率模型。默认值：False。
enable_optimization (bool) – 在支持和可用时是否使用优化的 historical_forecasts 版本。默认值：True。
data_transformers (Optional[dict[str, Union[BaseDataTransformer, Pipeline]], None]) –
可选参数，一个 BaseDataTransformer 或 Pipeline 字典，应用于相应的序列（可能的键：“series”、“past_covariates”、“future_covariates”）。如果提供，所有输入序列必须处于未转换空间中。对于可拟合的转换器/管道
- 如果 retrain=True，数据转换器在每个历史预测步骤重新拟合训练数据。
- 如果 retrain=False，数据转换器在所有预测之前对序列进行一次转换。
拟合的转换器用于在训练和预测期间转换输入。如果转换器是可逆的，预测结果将被逆转换。
fit_kwargs (Optional[dict[str, Any], None]) – 可选参数，传递给模型 fit() 方法的一些额外参数。
predict_kwargs (Optional[dict[str, Any], None]) – 可选参数，传递给模型 predict() 方法的一些额外参数。
sample_weight (Union[TimeSeries, Sequence[TimeSeries], str, None]) – 可选参数，应用于训练目标 series 标签的一些样本权重。仅当 retrain 不是 False 时有效。它们按观测值、按标签（output_chunk_length 中的每一步）和按组件应用。如果是一个或一系列序列，则使用这些权重。如果权重序列只有一个组件/列，则权重全局应用于 series 中的所有组件。否则，对于组件特定权重，组件数量必须与 series 的组件数量匹配。如果是字符串，则使用内置权重函数生成权重。可用选项是 “linear” 或 “exponential” 衰减 - 过去越远，权重越低。权重是按时间 series 计算的。

返回类型

Union[TimeSeries, list[TimeSeries], list[list[TimeSeries]]]

返回值

TimeSeries – 单个 series 和 last_points_only=True 时的单个历史预测：它只包含所有历史预测中步骤 forecast_horizon 的预测。
List[TimeSeries] – 历史预测列表，用于
- series 的序列（列表）和 last_points_only=True：对于每个序列，它只包含所有历史预测中步骤 forecast_horizon 的预测。
- 单个 series 和 last_points_only=False：对于每个历史预测，它包含完整的 forecast_horizon 范围。
List[List[TimeSeries]] – series 序列和 last_points_only=False 时的历史预测列表的列表。对于每个序列和历史预测，它包含完整的 forecast_horizon 范围。外层列表对应于输入序列中提供的序列，内层列表包含每个序列的历史预测。

initialize_encoders(default=False)¶

根据 self._model_encoder_settings 和模型创建时使用的参数 add_encoders 实例化 SequentialEncoder 对象

返回类型: SequentialEncoder

property likelihood: Optional[TorchLikelihood]¶

返回模型用于概率预测的似然函数（如果有）。

返回类型: Optional[TorchLikelihood, None]

static load(path, pl_trainer_kwargs=None, **kwargs)¶

从给定文件路径加载模型。

RNNModel 的通用加载示例

from darts.models import RNNModel

model_loaded = RNNModel.load(path)

RNNModel 从 CPU 训练加载到 GPU 的示例

from darts.models import RNNModel

model_loaded = RNNModel.load(path, pl_trainer_kwargs={"accelerator": "gpu"})

RNNModel 从 GPU 保存加载到 CPU 的示例

from darts.models import RNNModel

model_loaded = RNNModel.load(path, map_location="cpu", pl_trainer_kwargs={"accelerator": "gpu"})

参数

path (str) – 从中加载模型的路径。如果在保存模型时未指定路径，则必须提供自动生成的以 “.pt” 结尾的路径。
pl_trainer_kwargs (Optional[dict, None]) – 可选的，一组关键字参数，用于创建一个新的 Lightning Trainer，以配置模型进行下游任务（例如预测）。示例包括指定批量大小或将模型移至 CPU/GPU。请查阅 Lightning Trainer 文档获取更多关于支持的关键字参数的信息。
**kwargs –
PyTorch Lightning 的 LightningModule.load_from_checkpoint() 方法的额外关键字参数，例如 map_location，用于将模型加载到与保存时不同的设备上。有关更多信息，请阅读官方文档。

返回类型

TorchForecastingModel

static load_from_checkpoint(model_name, work_dir=None, file_name=None, best=True, **kwargs)¶

从“{work_dir}/darts_logs/{model_name}/checkpoints/”下的自动保存的检查点加载模型。此方法用于使用 save_checkpoints=True 创建的模型。

如果您手动保存了模型，请考虑使用 load()。

从检查点加载 RNNModel 的示例（model_name 是模型创建时使用的 model_name）

from darts.models import RNNModel

model_loaded = RNNModel.load_from_checkpoint(model_name, best=True)

如果提供了 file_name，则返回保存在“{work_dir}/darts_logs/{model_name}/checkpoints/{file_name}”下的模型。

如果未提供 file_name，将尝试从“{work_dir}/darts_logs/{model_name}/checkpoints/”恢复最佳检查点（如果 best 为 True）或最新检查点（如果 best 为 False）。

将保存在 GPU 上的 RNNModel 检查点加载到 CPU 的示例

from darts.models import RNNModel

model_loaded = RNNModel.load_from_checkpoint(model_name, best=True, map_location="cpu")
model_loaded.to_cpu()

参数

model_name (str) – 模型名称，用于检索检查点文件夹的名称。
work_dir (Optional[str, None]) – 工作目录（包含检查点文件夹）。默认为当前工作目录。
file_name (Optional[str, None]) – 检查点文件名。如果未指定，则使用最新的检查点。
best (bool) – 如果设置，将检索最佳模型（根据验证损失），而不是最新的模型。仅当提供了 file_name 时才忽略此参数。
**kwargs –
PyTorch Lightning 的 LightningModule.load_from_checkpoint() 方法的附加 kwargs，例如 map_location，用于将模型加载到与保存时不同的设备上。更多信息请阅读官方文档。

返回值

相应的训练好的 TorchForecastingModel。

返回类型

TorchForecastingModel

load_weights(path, load_encoders=True, skip_checks=False, **kwargs)¶

从手动保存的模型加载权重（使用 save() 保存）。

注意：此方法需要能够访问 darts 模型检查点 (.pt)，以便加载编码器并对模型参数执行完整性检查。

参数

path (str) – 加载模型权重的路径。如果在保存模型时未指定路径，则必须提供以“.pt”结尾的自动生成路径。
load_encoders (bool) – 如果设置，将从模型中加载编码器，以直接调用 fit() 或 predict() 方法。默认值：True。
skip_checks (bool) – 如果设置，将禁用加载编码器和对模型参数的完整性检查（不推荐）。不能与 load_encoders=True 一起使用。默认值：False。
**kwargs –
PyTorch 的 load() 方法的附加 kwargs，例如 map_location，用于将模型加载到与保存时不同的设备上。更多信息请阅读官方文档。

load_weights_from_checkpoint(model_name=None, work_dir=None, file_name=None, best=True, strict=True, load_encoders=True, skip_checks=False, **kwargs)¶

仅从自动保存在“{work_dir}/darts_logs/{model_name}/ checkpoints/”下的检查点加载权重。此方法用于使用 save_checkpoints=True 创建的模型，这些模型需要使用不同的优化器或学习率调度器进行重新训练或微调。但是，它也可以用于加载权重进行推理。

要恢复中断的训练，请考虑使用 load_from_checkpoint()，它也会重新加载 trainer、optimizer 和 learning rate scheduler 的状态。

对于手动保存的模型，请考虑改用 load() 或 load_weights()。

注意：此方法需要能够访问 darts 模型检查点 (.pt)，以便加载编码器并对模型参数执行完整性检查。

参数

model_name (Optional[str, None]) – 模型的名称，用于检索检查点文件夹的名称。默认值：self.model_name。
work_dir (Optional[str, None]) – 工作目录（包含检查点文件夹）。默认为当前工作目录。
file_name (Optional[str, None]) – 检查点文件名。如果未指定，则使用最新的检查点。
best (bool) – 如果设置，将检索最佳模型（根据验证损失），而不是最近的模型。仅当给定 file_name 时忽略此参数。默认值：True。
strict (bool) –
如果设置，将严格执行 state_dict 中的键与此模块的 state_dict() 返回的键匹配。默认值：True。更多信息请阅读官方文档。
load_encoders (bool) – 如果设置，将从模型中加载编码器，以直接调用 fit() 或 predict() 方法。默认值：True。
skip_checks (bool) – 如果设置，将禁用加载编码器和对模型参数的完整性检查（不推荐）。不能与 load_encoders=True 一起使用。默认值：False。
**kwargs –
PyTorch 的 load() 方法的附加 kwargs，例如 map_location，用于将模型加载到与保存时不同的设备上。更多信息请阅读官方文档。

lr_find(series, past_covariates=None, future_covariates=None, val_series=None, val_past_covariates=None, val_future_covariates=None, sample_weight=None, val_sample_weight=None, trainer=None, verbose=None, epochs=0, max_samples_per_ts=None, dataloader_kwargs=None, min_lr=1e-08, max_lr=1, num_training=100, mode='exponential', early_stop_threshold=4.0)¶

PyTorch Lightning 的 Tuner.lr_find() 的包装器。执行良好初始学习率的范围测试，以减少选择良好起始学习率的猜测量。有关 PyTorch Lightning Tuner 的更多信息，请查看此链接。如果 tuner 未给出令人满意的结果，建议增加 epochs 的数量。考虑使用建议的学习率创建一个新的模型对象，例如使用模型创建参数 optimizer_cls、optimizer_kwargs、lr_scheduler_cls 和 lr_scheduler_kwargs。

使用 RNNModel 的示例

import torch
from darts.datasets import AirPassengersDataset
from darts.models import NBEATSModel

series = AirPassengersDataset().load()
train, val = series[:-18], series[-18:]
model = NBEATSModel(input_chunk_length=12, output_chunk_length=6, random_state=42)
# run the learning rate tuner
results = model.lr_find(series=train, val_series=val)
# plot the results
results.plot(suggest=True, show=True)
# create a new model with the suggested learning rate
model = NBEATSModel(
    input_chunk_length=12,
    output_chunk_length=6,
    random_state=42,
    optimizer_cls=torch.optim.Adam,
    optimizer_kwargs={"lr": results.suggestion()}
)

参数

series (Union[TimeSeries, Sequence[TimeSeries]]) – 用作目标的序列或序列列表（即模型将训练预测的内容）
past_covariates (Union[TimeSeries, Sequence[TimeSeries], None]) – 可选的，指定过去观测到的协变量的序列或序列列表
future_covariates (Union[TimeSeries, Sequence[TimeSeries], None]) – 可选的，指定未来已知的协变量的序列或序列列表
val_series (Union[TimeSeries, Sequence[TimeSeries], None]) – 可选的，一个或一系列验证目标序列，将在整个训练过程中用于计算验证损失并跟踪表现最佳的模型。
val_past_covariates (Union[TimeSeries, Sequence[TimeSeries], None]) – 可选的，对应于验证序列的过去协变量（必须与 covariates 匹配）
val_future_covariates (Union[TimeSeries, Sequence[TimeSeries], None]) – 可选的，对应于验证序列的未来协变量（必须与 covariates 匹配）
sample_weight (Union[TimeSeries, Sequence[TimeSeries], str, None]) – 可选的，应用于目标 series 标签的一些样本权重。它们应用于每个观测值、每个标签（output_chunk_length 中的每个步骤）和每个组件。如果是一个序列或序列列表，则使用这些权重。如果权重序列只有一个组件/列，则权重全局应用于 series 中的所有组件。否则，对于特定组件的权重，组件数量必须与 series 的数量匹配。如果是一个字符串，则使用内置的权重函数生成权重。可用的选项是 “linear” 或 “exponential” 衰减 - 过去越远，权重越低。权重是根据 series 中最长序列的长度全局计算的。然后对于每个序列，权重从全局权重的末尾提取。这为所有序列提供了共同的时间加权。
val_sample_weight (Union[TimeSeries, Sequence[TimeSeries], str, None]) – 与 sample_weight 相同，但用于评估数据集。
trainer (Optional[Trainer, None]) – 可选的，用于执行训练的自定义 PyTorch-Lightning Trainer 对象。使用自定义的 trainer 将覆盖 Darts 的默认 trainer。
verbose (Optional[bool, None]) – 是否打印进度。如果在 pl_trainer_kwargs 中有 ProgressBar 回调，则忽略此参数。
epochs (int) – 如果指定，模型将额外训练 epochs 轮，无论模型构造函数中提供了什么 n_epochs 值。
max_samples_per_ts (Optional[int, None]) – 可选的，每个时间序列使用的最大样本数。模型通过构建 (输入, 输出) 示例切片以监督方式训练。在长时间序列上，这可能导致训练样本数量过大。此参数限制每个时间序列的训练样本数量（只取每个序列中最新的样本）。设置为 None 则不应用任何上限。
dataloader_kwargs (Optional[dict[str, Any], None]) –
可选的，用于创建训练和验证数据集的 PyTorch DataLoader 实例的关键字参数字典。有关 DataLoader 的更多信息，请查阅此链接。默认情况下，Darts 会配置参数（“batch_size”、“shuffle”、“drop_last”、“collate_fn”、“pin_memory”）以实现无缝预测。更改这些参数时应谨慎，以免出现意外行为。
min_lr (float) – 要研究的最小学习率
max_lr (float) – 要研究的最大学习率
num_training (int) – 要测试的学习率数量
mode (str) – 每批次后更新学习率的搜索策略：“exponential”：指数增加学习率。“linear”：线性增加学习率。
early_stop_threshold (float) – 停止搜索的阈值。如果在任何时候损失大于 early_stop_threshold*best_loss，则停止搜索。要禁用，设置为 None。

返回值

Lightning 的 _LRFinder 对象，包含 LR 扫描的结果。

返回类型

lr_finder

property min_train_samples: int¶

训练模型的最小样本数。

返回类型: int

property min_train_series_length: int¶

类属性，定义训练序列所需的最小长度；覆盖 ForecastingModel 的默认值 3

返回类型: int

property output_chunk_length: int¶

模型一次预测的时间步数，未为统计模型定义。

返回类型: int

property output_chunk_shift: int¶

输出/预测在输入结束后开始的时间步数。

返回类型: int

predict(n, series=None, past_covariates=None, future_covariates=None, trainer=None, batch_size=None, verbose=None, n_jobs=1, roll_size=None, num_samples=1, dataloader_kwargs=None, mc_dropout=False, predict_likelihood_parameters=False, show_warnings=True)¶

预测训练序列或指定 series 结束后 n 个时间步。

预测使用 PyTorch Lightning Trainer 执行。它使用预设中的默认 Trainer 对象以及模型创建时使用的 pl_trainer_kwargs。您也可以使用带有可选参数 trainer 的自定义 Trainer。有关 PyTorch Lightning Trainer 的更多信息，请查看此链接。

下面记录了所有可能的参数，但并非所有模型都支持所有参数。例如，所有 PastCovariatesTorchModel 只支持 past_covariates，不支持 future_covariates。如果您尝试在带有错误协变量参数的模型上调用 predict()，Darts 将会报错。

如果提供的协变量没有足够的时间跨度，Darts 也会报错。一般来说，并非所有模型都需要相同的协变量时间跨度。

依赖于历史协变量的模型需要在预测时知道 past_covariates 的最后 input_chunk_length

个点。对于预测范围 n > output_chunk_length，这些模型

也需要知道至少接下来的 n - output_chunk_length 个未来值。
依赖于未来协变量的模型需要知道接下来的 n 个值。

此外（对于 DualCovariatesTorchModel 和 MixedCovariatesTorchModel），它们还需要

这些未来协变量的“历史”值（跨越过去的 input_chunk_length）。

参数

n (int) – 在训练时间序列结束之后要生成预测的时间步长数量。
series (Union[TimeSeries, Sequence[TimeSeries], None]) – 可选参数，一个或多个时间序列，表示要预测其未来的目标序列的历史。如果指定，该方法返回这些序列的预测。否则，该方法返回（单个）训练序列的预测。
past_covariates (Union[TimeSeries, Sequence[TimeSeries], None]) – 可选参数，作为模型输入所需的过去观测协变量序列。它们在维度上必须与训练时使用的协变量匹配。
future_covariates (Union[TimeSeries, Sequence[TimeSeries], None]) – 可选参数，作为模型输入所需的未来已知协变量序列。它们在维度上必须与训练时使用的协变量匹配。
trainer (Optional[Trainer, None]) – 可选参数，用于执行预测的自定义 PyTorch-Lightning Trainer 对象。使用自定义的 trainer 将覆盖 Darts 的默认 trainer。
batch_size (Optional[int, None]) – 预测期间的批量大小。默认为模型训练时的 batch_size 值。
verbose (Optional[bool, None]) – 是否打印进度。如果在 pl_trainer_kwargs 中有 ProgressBar 回调，则忽略此参数。
n_jobs (int) – 并行运行的作业数量。-1 表示使用所有处理器。默认值：1。
roll_size (Optional[int, None]) – 对于自消耗预测，即 n > output_chunk_length，确定在每次将预测目标（以及可选的未来协变量）反馈回模型时，模型的多少输出被反馈回模型。如果未提供此参数，默认将设置为 output_chunk_length。
num_samples (int) – 从概率模型中采样预测的次数。对于确定性模型必须为 1。
dataloader_kwargs (Optional[dict[str, Any], None]) –
可选参数，用于为推理/预测数据集创建 PyTorch DataLoader 实例的关键字参数字典。有关 DataLoader 的更多信息，请查看此链接。默认情况下，Darts 为无缝预测配置参数（“batch_size”、“shuffle”、“drop_last”、“collate_fn”、“pin_memory”）。更改这些参数应谨慎进行，以避免意外行为。
mc_dropout (bool) – 可选参数，对基于神经网络的模型启用 Monte Carlo dropout 进行预测。这允许通过指定学习模型的隐式先验进行贝叶斯近似。
predict_likelihood_parameters (bool) – 如果设置为 True，模型将预测其 likelihood 的参数而不是目标。仅支持带有似然函数、num_samples = 1 且 n<=output_chunk_length 的概率模型。默认值：False。
show_warnings (bool) – 可选参数，控制是否显示警告。并非对所有模型都有效。

返回值

一个或多个包含 series 预测的时间序列，如果未指定 series 并且模型在单个序列上进行了训练，则返回训练序列的预测。

返回类型

Union[TimeSeries, Sequence[TimeSeries]]

predict_from_dataset(n, input_series_dataset, trainer=None, batch_size=None, verbose=None, n_jobs=1, roll_size=None, num_samples=1, dataloader_kwargs=None, mc_dropout=False, predict_likelihood_parameters=False)¶

此方法允许使用特定的 darts.utils.data.InferenceDataset 实例进行预测。这些数据集实现了 PyTorch Dataset，并指定了如何在推理时切分目标和协变量。在大多数情况下，您更愿意调用 predict()，它将为您创建一个合适的 InferenceDataset。

参数

n (int) – 在训练时间序列结束之后要生成预测的时间步长数量。
input_series_dataset (InferenceDataset) – 可选参数，一个或多个时间序列，表示要预测其未来的目标序列的历史。如果指定，该方法返回这些序列的预测。否则，该方法返回（单个）训练序列的预测。
trainer (Optional[Trainer, None]) – 可选参数，用于执行预测的自定义 PyTorch-Lightning Trainer 对象。使用自定义的 trainer 将覆盖 Darts 的默认 trainer。
batch_size (Optional[int, None]) – 预测期间的批量大小。默认为模型的 batch_size 值。
verbose (Optional[bool, None]) – 是否打印进度。如果在 pl_trainer_kwargs 中有 ProgressBar 回调，则忽略此参数。
n_jobs (int) – 并行运行的作业数量。-1 表示使用所有处理器。默认值：1。
roll_size (Optional[int, None]) – 对于自消耗预测，即 n > output_chunk_length，确定在每次将预测目标（以及可选的未来协变量）反馈回模型时，模型的多少输出被反馈回模型。如果未提供此参数，默认将设置为 output_chunk_length。
num_samples (int) – 从概率模型中采样预测的次数。对于确定性模型必须为 1。
dataloader_kwargs (Optional[dict[str, Any], None]) –
可选参数，用于为推理/预测数据集创建 PyTorch DataLoader 实例的关键字参数字典。有关 DataLoader 的更多信息，请查看此链接。默认情况下，Darts 为无缝预测配置参数（“batch_size”、“shuffle”、“drop_last”、“collate_fn”、“pin_memory”）。更改这些参数应谨慎进行，以避免意外行为。
mc_dropout (bool) – 可选参数，对基于神经网络的模型启用 Monte Carlo dropout 进行预测。这允许通过指定学习模型的隐式先验进行贝叶斯近似。
predict_likelihood_parameters (bool) – 如果设置为 True，模型预测其 likelihood 的参数而不是目标。仅支持具有 likelihood 的概率模型，且 num_samples = 1 和 n<=output_chunk_length。默认值：False。

返回值

返回一个或多个时间序列的预测。

返回类型

Sequence[TimeSeries]

reset_model()¶: 重置模型对象并移除所有存储的数据 - 模型、检查点、日志记录器和训练历史。

residuals(series, past_covariates=None, future_covariates=None, historical_forecasts=None, forecast_horizon=1, num_samples=1, train_length=None, start=None, start_format='value', stride=1, retrain=True, overlap_end=False, last_points_only=True, metric=<function err>, verbose=False, show_warnings=True, predict_likelihood_parameters=False, enable_optimization=True, data_transformers=None, metric_kwargs=None, fit_kwargs=None, predict_kwargs=None, sample_weight=None, values_only=False)¶

计算模型对（可能多个）series 进行历史预测时产生的残差。

此函数计算 series 的实际观测值与通过在 series 上训练模型（或使用 retrain=False 的预训练模型）获得的拟合值之间的差值（或 Darts 的“每时间步”指标之一）。并非所有模型都支持拟合值，因此我们使用历史预测作为其近似值。

按顺序，此方法执行：

使用预先计算的 historical_forecasts 或计算每个序列的历史预测（详见 historical_forecasts()）。可以通过参数 num_samples、train_length、start、start_format、forecast_horizon、stride、retrain、last_points_only、fit_kwargs 和 predict_kwargs 配置历史预测的生成方式。
使用“每时间步” metric 计算历史预测与 series 之间的回测，按组件/列和时间步（详见 backtest()）。默认情况下，使用残差 err() (误差) 作为 metric。
创建并返回带有历史预测时间索引以及按组件和时间步计算的指标值的 TimeSeries（或当 values_only=True 时仅返回 np.ndarray）。

此方法适用于单个或多个单变量或多变量序列。它使用中位数预测（处理随机预测时）。

参数

series (Union[TimeSeries, Sequence[TimeSeries]]) – 用于依次训练（如果 retrain 不是 False）和计算历史预测的（序列）目标时间序列。
past_covariates (Union[TimeSeries, Sequence[TimeSeries], None]) – 可选参数，为 series 中的每个输入时间序列提供（序列）过去观察到的协变量时间序列。仅当模型支持过去协变量时适用。
future_covariates (Union[TimeSeries, Sequence[TimeSeries], None]) – 可选参数，为 series 中的每个输入时间序列提供（序列）未来已知的协变量时间序列。仅当模型支持未来协变量时适用。
historical_forecasts (Union[TimeSeries, Sequence[TimeSeries], Sequence[Sequence[TimeSeries]], None]) – 可选参数，要评估的（或序列/序列的序列）历史预测时间序列。对应于 historical_forecasts() 的输出。必须传递用于生成历史预测的相同 series 和 last_points_only 值。如果提供，将跳过历史预测并忽略除 series、last_points_only、metric 和 reduction 之外的所有参数。
forecast_horizon (int) – 预测的预测范围。
num_samples (int) – 从概率模型中采样预测的次数。仅对概率模型使用 >1 的值。
train_length (Optional[int, None]) – 可选参数，为每个构建的训练集使用固定的长度/时间步数（滚动窗口模式）。仅当 retrain 不是 False 时有效。默认值是 None，在这种情况下，它使用直到预测时间的所有时间步（扩展窗口模式）。如果大于可用时间步数，则使用扩展模式。至少需要 min_train_series_length。
start (Union[Timestamp, float, int, None]) –
可选参数，计算预测的第一个时间点。此参数支持：float、int、pandas.Timestamp 和 None。如果是 float，则是时间序列中小于第一个预测点的时间比例。如果是 int，则对于带有 pd.DatetimeIndex 的 series 来说是第一个预测点的索引位置，对于带有 pd.RangeIndex 的 series 来说是索引值。后者可以使用 start_format=”position” 更改为索引位置。如果是 pandas.Timestamp，则是第一个预测点的时间戳。如果为 None，则第一个预测点将自动设置为
- 如果 retrain 为 False，或者 retrain 是一个 Callable 且第一个可预测点早于第一个可训练点，则设置为第一个可预测点。
- 如果 retrain 为 True 或 int（给定 train_length），或者 retrain 是一个 Callable 且第一个可训练点早于第一个可预测点，则设置为第一个可训练点。
- 否则设置为第一个可训练点（给定 train_length）
注意：如果 start 不在可训练/可预测点范围内，则使用最接近的有效起始点，该点
是 start 前面 stride 的整数倍。如果不存在有效的起始点，则引发 ValueError。

注意：如果模型使用偏移输出（output_chunk_shift > 0），则第一个预测点也会
向未来偏移 output_chunk_shift 个点。

注意：如果 start 超出可能的历史预测时间范围，将忽略该参数
（None 时的默认行为）并从第一个可训练/可预测点开始。
start_format (Literal[‘position’, ‘value’]) – 定义 start 的格式。如果设置为 'position'，start 对应于第一个预测点的索引位置，范围为 (-len(series), len(series) - 1)。如果设置为 'value'，start 对应于第一个预测点的索引值/标签。如果该值不在 series 的索引中，则会引发错误。默认值：'value'。
stride (int) – 两次连续预测之间的时间步数。
retrain (Union[bool, int, Callable[…, bool]]) –
在预测前是否以及/或在何种条件下重新训练模型。此参数支持 3 种不同类型：bool、(正) int 和 Callable（返回 bool）。如果是 bool：在每个步骤重新训练模型（True），或从不重新训练模型（False）。如果是 int：模型每 retrain 次迭代重新训练一次。如果是 Callable：只要可调用对象返回 True，模型就会重新训练。可调用对象必须具有以下位置参数
- counter (int)：当前的 retrain 迭代次数
- pred_time (pd.Timestamp 或 int)：预测时间戳（训练序列结束时）
- train_series (TimeSeries)：直到 pred_time 的训练序列
- past_covariates (TimeSeries)：直到 pred_time 的 past_covariates 序列
- future_covariates (TimeSeries)：直到 min(pred_time + series.freq * forecast_horizon, series.end_time()) 的 future_covariates 序列
注意：如果任何可选的 *_covariates 未传递给 historical_forecast，则 None 将传递给相应的 retrain 函数参数。注意：某些模型需要每次重新训练，并且除了 retrain=True 之外不支持任何其他值。注意：这也控制 data_transformers 的重新训练。
overlap_end (bool) – 返回的预测是否可以超出序列的结束点。
last_points_only (bool) – 是否只返回每个历史预测的最后一个点。如果设置为 True，该方法将返回一个包含连续点预测的单个 TimeSeries（对于 series 中的每个时间序列）。否则，返回一个历史 TimeSeries 预测列表。
metric (Callable[…, Union[float, list[float], ndarray, list[ndarray]]]) –
可以是 Darts 的“每时间步”指标之一（见这里），也可以是具有与 Darts“每时间步”指标相同签名的自定义指标，使用装饰器 multi_ts_support() 和 multi_ts_support()，并返回每个时间步一个值。
verbose (bool) – 是否打印进度。
show_warnings (bool) – 是否显示与历史预测优化或参数 start 和 train_length 相关的警告。
predict_likelihood_parameters (bool) – 如果设置为 True，模型将预测其 likelihood 的参数而不是目标。仅支持带有似然函数、num_samples = 1 且 n<=output_chunk_length 的概率模型。默认值：False。
enable_optimization (bool) – 在支持和可用时是否使用优化的 historical_forecasts 版本。默认值：True。
data_transformers (Optional[dict[str, Union[BaseDataTransformer, Pipeline]], None]) –
可选参数，一个 BaseDataTransformer 或 Pipeline 字典，应用于相应的序列（可能的键：“series”、“past_covariates”、“future_covariates”）。如果提供，所有输入序列必须处于未转换空间中。对于可拟合的转换器/管道
- 如果 retrain=True，数据转换器在每个历史预测步骤重新拟合训练数据。
- 如果 retrain=False，数据转换器在所有预测之前对序列进行一次转换。
拟合后的转换器用于在训练和预测期间转换输入。如果转换是可逆的，则预测将被逆向转换。仅当 historical_forecasts=None 时有效。
metric_kwargs (Optional[dict[str, Any], None]) – 传递给 metric() 的附加参数，例如用于并行的 ‘n_jobs’，用于缩放指标的 ‘m’ 等。仅当参数存在于相应的指标签名中时才会传递。忽略归约参数 “series_reduction”, “component_reduction”, “time_reduction” 以及缩放指标（例如 mase`、`rmsse` 等）的参数 ‘insample’，因为它们在内部处理。
fit_kwargs (Optional[dict[str, Any], None]) – 可选参数，传递给模型 fit() 方法的一些额外参数。
predict_kwargs (Optional[dict[str, Any], None]) – 可选参数，传递给模型 predict() 方法的一些额外参数。
sample_weight (Union[TimeSeries, Sequence[TimeSeries], str, None]) – 可选参数，应用于训练目标 series 标签的一些样本权重。仅当 retrain 不是 False 时有效。它们按观测值、按标签（output_chunk_length 中的每一步）和按组件应用。如果是一个或一系列序列，则使用这些权重。如果权重序列只有一个组件/列，则权重全局应用于 series 中的所有组件。否则，对于组件特定权重，组件数量必须与 series 的组件数量匹配。如果是字符串，则使用内置权重函数生成权重。可用选项是 “linear” 或 “exponential” 衰减 - 过去越远，权重越低。权重是按时间 series 计算的。
values_only (bool) – 是否将残差作为 np.ndarray 返回。如果为 False，则将残差作为 TimeSeries 返回。

返回类型

Union[TimeSeries, list[TimeSeries], list[list[TimeSeries]]]

返回值

TimeSeries – 当 last_points_only=True 时，单个 series 和 historical_forecasts 生成的残差 TimeSeries。
List[TimeSeries] – 当 last_points_only=True 时，针对 series 序列（列表）的残差 TimeSeries 列表。残差列表的长度为 len(series)。
List[List[TimeSeries]] – 当 last_points_only=False 时，针对 series 序列的残差 TimeSeries 列表的列表。外部残差列表的长度为 len(series)。内部列表包含所有可能的序列特定历史预测的残差。

save(path=None, clean=False)¶

将模型保存到给定路径下。

在 path 下创建两个文件（模型对象）和 path.ckpt（检查点）。

注意：使用自定义类保存模型时可能会出现 Pickle 错误。在这种情况下，请考虑使用 clean 标志从保存的模型中剥离与训练相关的属性。

保存和加载 RNNModel 的示例

from darts.models import RNNModel

model = RNNModel(input_chunk_length=4)

model.save("my_model.pt")
model_loaded = RNNModel.load("my_model.pt")

参数

path (Optional[str, None]) – 保存模型当前状态的路径。请避免使用以“last-”或“best-”开头的路径，以免与 Pytorch-Lightning 检查点冲突。如果未指定路径，模型将自动保存为 "{ModelClass}_{YYYY-mm-dd_HH_MM_SS}.pt"。例如，“RNNModel_2020-01-01_12_00_00.pt”。
clean (bool) –
是否存储模型的清理版本。如果为 True，则移除训练序列和协变量。此外，移除所有与 Lightning Trainer 相关的参数（在模型创建时通过 pl_trainer_kwargs 传递）。

注意：加载使用 clean=True 存储的模型后，必须向 ‘predict()’、historical_forecasts() 和其他预测方法传递 series 参数。

返回类型

无

property supports_likelihood_parameter_prediction: bool¶

模型实例是否支持直接预测似然参数

返回类型: bool

property supports_multivariate: bool¶

模型是否考虑时间序列中的多个变量。

返回类型: bool

property supports_optimized_historical_forecasts: bool¶

模型是否支持优化的历史预测

返回类型: bool

property supports_past_covariates: bool¶

模型是否支持过去协变量

返回类型: bool

property supports_probabilistic_prediction: bool¶

检查此配置的预测模型是否支持概率预测。

默认返回 False。需要由支持概率预测的模型覆盖。

返回类型: bool

property supports_sample_weight: bool¶

模型是否支持训练样本权重。

返回类型: bool

property supports_static_covariates: bool¶

模型是否支持静态协变量

返回类型: bool

property supports_transferable_series_prediction: bool¶

模型是否支持对任何输入 series 进行预测。

返回类型: bool

to_cpu()¶: 更新 PyTorch Lightning Trainer 参数，以便下次调用 `fit()` 或 predict() 时将模型移动到 CPU。

to_onnx(path=None, **kwargs)¶

将模型导出为 ONNX 格式以进行优化推理，它是 PyTorch Lightning 的 torch.onnx.export() 方法的包装器（官方文档）。

注意：需要安装 onnx 库（可选依赖项）。

导出 DLinearModel 的示例

from darts.datasets import AirPassengersDataset
from darts.models import DLinearModel

series = AirPassengersDataset().load()
model = DLinearModel(input_chunk_length=4, output_chunk_length=1)
model.fit(series, epochs=1)
model.to_onnx("my_model.onnx")

参数

path (Optional[str, None]) – 保存模型当前状态的路径。如果未指定路径，模型将自动保存为 "{ModelClass}_{YYYY-mm-dd_HH_MM_SS}.onnx"。
**kwargs –
PyTorch 的 torch.onnx.export() 方法的附加 kwargs（除了参数 file_path、input_sample、input_name）。更多信息请阅读官方文档。

untrained_model()¶: 返回使用相同参数创建的新的（未经训练的）模型实例。

property uses_future_covariates: bool¶

模型拟合后是否使用未来协变量。

返回类型: bool

property uses_past_covariates: bool¶

模型拟合后是否使用过去协变量。

返回类型: bool

property uses_static_covariates: bool¶

模型拟合后是否使用静态协变量。

返回类型: bool

class darts.models.forecasting.block_rnn_model.CustomBlockRNNModule(input_size, hidden_dim, num_layers, target_size, nr_params, num_layers_out_fc=None, dropout=0.0, activation='ReLU', **kwargs)[源码]¶

基类：PLPastCovariatesModule, ABC

此类允许创建自定义的 Block RNN 模块，这些模块稍后可与 Darts 的 BlockRNNModel 一起使用。它添加了与 Darts 的 TorchForecastingModel 和 BlockRNNModel 一起使用所需的骨干结构。

要创建新模块，请继承 CustomBlockRNNModule 类并：

在模块构造函数 (__init__()) 中定义架构
添加 forward() 方法并定义模块前向传递的逻辑
使用参数 model 创建新的 BlockRNNModel 时，使用自定义模块类。

您可以使用 darts.models.forecasting.block_rnn_model._BlockRNNModule 作为示例。

参数

input_size (int) – 输入时间序列的维度。
hidden_dim (int) – RNN 模块隐藏状态 h 中的特征数量。
num_layers (int) – 循环层的数量。
target_size (int) – 输出时间序列的维度。
nr_params (int) – likelihood 的参数数量（如果未使用 likelihood 则为 1）。
num_layers_out_fc (Optional[list, None]) – 包含全连接网络隐藏层维度的列表。此网络将 PyTorch RNN 模块的最后一个隐藏层连接到输出。
dropout (float) – 在除最后一层外的所有 RNN 层中丢弃的神经元比例。
activation (str) – 应用于全连接网络层之间的激活函数的名称。
\*\*kwargs – darts.models.forecasting.pl_forecasting_module.PLForecastingModule 基类所需的所有参数。

属性

`automatic_optimization`	如果设置为 `False`，则您负责调用 `.backward()`、`.step()`、`.zero_grad()`。
`current_epoch`	`Trainer` 中的当前 epoch，如果未连接则为 0。
`device_mesh`	`ModelParallelStrategy` 等策略将创建一个设备网格，可以在 `configure_model()` 钩子中访问该网格以并行化 LightningModule。
`example_input_array`	example input array 是模块在 `forward()` 方法中可以接受的输入规范。
`global_rank`	当前进程在所有节点和设备上的索引。
`global_step`	所有 epoch 中见到的总训练批次数。
`hparams`	使用 `save_hyperparameters()` 保存的超参数集合。
`hparams_initial`	使用 `save_hyperparameters()` 保存的超参数集合。
`local_rank`	当前进程在单个节点内的索引。
`logger`	Trainer 中 logger 对象的引用。
`loggers`	Trainer 中 loggers 列表的引用。
`on_gpu`	如果此模型当前位于 GPU 上，则返回 `True`。
`output_chunk_length`	模型一次预测的时间步长数量。
`strict_loading`	确定 Lightning 如何使用 .load_state_dict(..., strict=model.strict_loading) 加载此模型。

device
dtype
epochs_trained
fabric
supports_probabilistic_prediction
trainer

方法

`add_module`(name, module)	向当前模块添加子模块。
`all_gather`(data[, group, sync_grads])	从多个进程收集张量或张量集合。
`apply`(fn)	将 `fn` 递归地应用于每个子模块（由 `.children()` 返回）以及自身。
`backward`(loss, args, *kwargs)	用于在 `training_step()` 中返回的损失上执行反向传播。
`bfloat16`()	将所有浮点参数和缓冲区转换为 `bfloat16` 数据类型。
`buffers`([recurse])	返回模块缓冲区上的迭代器。
`children`()	返回直接子模块上的迭代器。
`clip_gradients`(optimizer[, ...])	内部处理梯度裁剪。
`compile`(args, *kwargs)	使用 `torch.compile()` 编译此模块的前向传递。
`configure_callbacks`()	配置模型特定的回调。
`configure_gradient_clipping`(optimizer[, ...])	对优化器参数执行梯度裁剪。
`configure_model`()	在策略和精度感知上下文中创建模块的钩子。
`configure_optimizers`()	配置优化器和学习率调度器以优化模型。
`configure_sharded_model`()	已弃用。
`configure_torch_metrics`(torch_metrics)	处理 torch_metrics 参数。
`cpu`()	参见 `torch.nn.Module.cpu()`。
`cuda`([device])	将所有模型参数和缓冲区移动到 GPU。
`double`()	参见 `torch.nn.Module.double()`。
`eval`()	将模块设置为评估模式。
`extra_repr`()	返回模块的额外表示。
`float`()	参见 `torch.nn.Module.float()`。
`forward`(x_in)	BlockRNN 模块的前向传递。
`freeze`()	冻结所有参数以进行推理。
`get_buffer`(target)	如果存在，返回由 `target` 给定的缓冲区，否则抛出错误。
`get_extra_state`()	返回要包含在模块 state_dict 中的任何额外状态。
`get_parameter`(target)	如果存在，返回由 `target` 给定的参数，否则抛出错误。
`get_submodule`(target)	如果存在，返回由 `target` 给定的子模块，否则抛出错误。
`half`()	参见 `torch.nn.Module.half()`。
`ipu`([device])	将所有模型参数和缓冲区移动到 IPU。
`load_from_checkpoint`(checkpoint_path[, ...])	从检查点加载模型的主要方式。
`load_state_dict`(state_dict[, strict, assign])	将参数和缓冲区从 `state_dict` 复制到此模块及其后代中。
`log`(name, value[, prog_bar, logger, ...])	记录一个键值对。
`log_dict`(dictionary[, prog_bar, logger, ...])	一次记录一个值字典。
`lr_scheduler_step`(scheduler, metric)	覆盖此方法以调整 `Trainer` 调用每个调度器的默认方式。
`lr_schedulers`()	返回训练期间使用的学习率调度器。
`manual_backward`(loss, args, *kwargs)	手动进行优化时，直接从您的 `training_step()` 中调用此方法。
`modules`()	返回网络中所有模块上的迭代器。
`mtia`([device])	将所有模型参数和缓冲区移动到 MTIA。
`named_buffers`([prefix, recurse, ...])	返回模块缓冲区上的迭代器，同时产生缓冲区的名称和缓冲区本身。
`named_children`()	返回直接子模块上的迭代器，同时产生模块的名称和模块本身。
`named_modules`([memo, prefix, remove_duplicate])	返回网络中所有模块上的迭代器，同时产生模块的名称和模块本身。
`named_parameters`([prefix, recurse, ...])	返回模块参数上的迭代器，同时产生参数的名称和参数本身。
`on_after_backward`()	在 `loss.backward()` 之后且在优化器执行步骤之前调用。
`on_after_batch_transfer`(batch, dataloader_idx)	覆盖此方法以在批次转移到设备后修改或应用批次增强。
`on_before_backward`(loss)	在 `loss.backward()` 之前调用。
`on_before_batch_transfer`(batch, dataloader_idx)	覆盖此方法以在批次转移到设备之前修改或应用批次增强。
`on_before_optimizer_step`(optimizer)	在 `optimizer.step()` 之前调用。
`on_before_zero_grad`(optimizer)	在 `training_step()` 之后且在 `optimizer.zero_grad()` 之前调用。
`on_fit_end`()	在 fit 的最后调用。
`on_fit_start`()	在 fit 的最初调用。
`on_load_checkpoint`(checkpoint)	由 Lightning 调用以恢复您的模型。
`on_predict_batch_end`(outputs, batch, batch_idx)	在预测循环中，批次处理后调用。
`on_predict_batch_start`(batch, batch_idx[, ...])	在预测循环中，该批次处理开始前调用。
`on_predict_end`()	在预测结束时调用。
`on_predict_epoch_end`()	在预测结束时调用。
`on_predict_epoch_start`()	在预测开始时调用。
`on_predict_model_eval`()	在预测循环开始时调用。
`on_predict_start`()	在预测开始时调用。
`on_save_checkpoint`(checkpoint)	Lightning 在保存检查点时调用，让您有机会存储可能想要保存的任何其他内容。
`on_test_batch_end`(outputs, batch, batch_idx)	在测试循环中，批次处理后调用。
`on_test_batch_start`(batch, batch_idx[, ...])	在测试循环中，该批次处理开始前调用。
`on_test_end`()	在测试结束时调用。
`on_test_epoch_end`()	在测试循环中，epoch 的最后调用。
`on_test_epoch_start`()	在测试循环中，epoch 的最初调用。
`on_test_model_eval`()	在测试循环开始时调用。
`on_test_model_train`()	在测试循环结束时调用。
`on_test_start`()	在测试开始时调用。
`on_train_batch_end`(outputs, batch, batch_idx)	在训练循环中，批次处理后调用。
`on_train_batch_start`(batch, batch_idx)	在训练循环中，该批次处理开始前调用。
`on_train_end`()	在训练结束、logger experiment 关闭之前调用。
`on_train_epoch_end`()	在训练循环中，epoch 的最后调用。
`on_train_epoch_start`()	在训练循环中，epoch 的最初调用。
`on_train_start`()	在完整性检查后、训练开始时调用。
`on_validation_batch_end`(outputs, batch, ...)	在验证循环中，批次处理后调用。
`on_validation_batch_start`(batch, batch_idx)	在验证循环中，该批次处理开始前调用。
`on_validation_end`()	在验证结束时调用。
`on_validation_epoch_end`()	在验证循环中，epoch 的最后调用。
`on_validation_epoch_start`()	在验证循环中，在 epoch 的最开始调用。
`on_validation_model_eval`()	在验证循环开始时调用。
`on_validation_model_train`()	在验证循环结束时调用。
`on_validation_model_zero_grad`()	在训练循环中调用，用于在进入验证循环之前释放梯度。
`on_validation_start`()	在验证开始时调用。
`optimizer_step`(epoch, batch_idx, optimizer)	重写此方法以调整 `Trainer` 调用优化器的默认方式。
`optimizer_zero_grad`(epoch, batch_idx, optimizer)	重写此方法以更改 `optimizer.zero_grad()` 的默认行为。
`optimizers`([use_pl_optimizer])	返回训练期间使用的优化器。
`parameters`([recurse])	返回模块参数的迭代器。
`predict_dataloader`()	指定预测样本的可迭代对象或可迭代对象的集合。
`predict_step`(batch, batch_idx[, dataloader_idx])	执行预测步骤
`prepare_data`()	用于下载和准备数据。
`print`(args, *kwargs)	只从进程 0 打印。
`register_backward_hook`(hook)	在模块上注册一个反向钩子。
`register_buffer`(name, tensor[, persistent])	向模块添加一个 buffer。
`register_forward_hook`(hook, *[, prepend, ...])	在模块上注册一个前向钩子。
`register_forward_pre_hook`(hook, *[, ...])	在模块上注册一个前向预钩子。
`register_full_backward_hook`(hook[, prepend])	在模块上注册一个反向钩子。
`register_full_backward_pre_hook`(hook[, prepend])	在模块上注册一个反向预钩子。
`register_load_state_dict_post_hook`(hook)	注册一个后钩子，在模块的 `load_state_dict()` 调用后运行。
`register_load_state_dict_pre_hook`(hook)	注册一个预钩子，在模块的 `load_state_dict()` 调用前运行。
`register_module`(name, module)	`add_module()` 的别名。
`register_parameter`(name, param)	向模块添加一个参数。
`register_state_dict_post_hook`(hook)	为 `state_dict()` 方法注册一个后钩子。
`register_state_dict_pre_hook`(hook)	为 `state_dict()` 方法注册一个预钩子。
`requires_grad_`([requires_grad])	更改 autograd 是否应该记录此模块参数上的操作。
`save_hyperparameters`(*args[, ignore, frame, ...])	将参数保存到 `hparams` 属性。
`set_extra_state`(state)	设置加载的 state_dict 中包含的额外状态。
`set_predict_parameters`(n, num_samples, ...)	在调用 trainer.predict() 之前由 TorchForecastingModel 设置，并在 self.on_predict_end() 重置。
`set_submodule`(target, module)	如果存在，则设置 `target` 指定的子模块，否则抛出错误。
`setup`(stage)	在 fit（训练 + 验证）、validate、test 或 predict 开始时调用。
`share_memory`()	参见 `torch.Tensor.share_memory_()`。
`state_dict`(*args[, destination, prefix, ...])	返回一个字典，其中包含模块完整状态的引用。
`teardown`(stage)	在 fit（训练 + 验证）、validate、test 或 predict 结束时调用。
`test_dataloader`()	指定测试样本的可迭代对象或可迭代对象的集合。
`test_step`(args, *kwargs)	对测试集中的单个批次数据进行操作。
`to`(args, *kwargs)	参见 `torch.nn.Module.to()`。
`to_dtype`(dtype)	将模块精度（默认为 float32）转换为其他精度。
`to_empty`(*, device[, recurse])	在不复制存储的情况下，将参数和 buffer 移动到指定的设备。
`to_onnx`(file_path[, input_sample])	以 ONNX 格式保存模型。
`to_torchscript`([file_path, method, ...])	默认将整个模型编译为 `ScriptModule`。
`toggle_optimizer`(optimizer)	确保在训练步骤中只计算当前优化器参数的梯度，以防止在多优化器设置中出现悬挂梯度。
`train`([mode])	将模块设置为训练模式。
`train_dataloader`()	指定训练样本的可迭代对象或可迭代对象的集合。
`training_step`(train_batch, batch_idx)	执行训练步骤
`transfer_batch_to_device`(batch, device, ...)	如果你的 `DataLoader` 返回包装在自定义数据结构中的张量，则重写此钩子。
`type`(dst_type)	参见 `torch.nn.Module.type()`。
`unfreeze`()	解冻所有参数以进行训练。
`untoggle_optimizer`(optimizer)	重置通过 `toggle_optimizer()` 切换的所需梯度的状态。
`val_dataloader`()	指定验证样本的可迭代对象或可迭代对象的集合。
`validation_step`(val_batch, batch_idx)	执行验证步骤
`xpu`([device])	将所有模型参数和 buffer 移动到 XPU。
`zero_grad`([set_to_none])	重置所有模型参数的梯度。

__call__
set_mc_dropout

abstract forward(x_in)[源代码]¶

BlockRNN 模块的前向传递。

参数: x_in (tuple) – 包含输入序列特征的张量元组。元组包含以下元素：(过去的 target, 历史未来协变量, 未来协变量, 静态协变量)。过去的 target 的形状为 (batch_size, input_length, input_size)。
返回值: BlockRNN 的输出张量，形状为 (batch_size, output_chunk_length, target_size, nr_params)。它包含序列最后一个时间步的预测。
返回类型: torch.Tensor

基线模型

CatBoost 模型