循环神经网络¶
- class darts.models.forecasting.rnn_model.RNNModel(input_chunk_length, model='RNN', hidden_dim=25, n_rnn_layers=1, dropout=0.0, training_length=24, **kwargs)[source]¶
基础：
DualCovariatesTorchModel循环神经网络模型 (RNNs)。
此类提供三种变体的 RNN 模型
Vanilla RNN
LSTM
GRU
RNNModel 在预测时是完全循环的，输出使用以下输入计算：
先前的目标值，对于第一次预测，这将设置为最后一个已知目标值，对于所有其他预测，将设置为先前的预测（以自回归方式），
先前的隐藏状态，
用于预测时间 t 的目标的时间 t 的协变量（如果模型使用协变量进行训练），
此模型支持未来协变量；它要求这些协变量在过去和未来都延伸得足够远（它是一个所谓的“双协变量”模型，因为未来协变量必须在过去和未来都提供）。如果提供的 future_covariates 序列没有适当的时间跨度，模型将报错。
对于仅使用 RNN 模型作为编码器并支持过去协变量的块版本，请查看 BlockRNNModel。
- 参数
input_chunk_length (
int) – 在预测时馈送到预测模块的过去时间步数。model (
Union[str,type[CustomRNNModule]]) – 指定 RNN 模块类型的字符串（“RNN”、“LSTM”或“GRU”），或是带有自定义逻辑的CustomRNNModule的子类（类本身，而非类的对象）。hidden_dim (
int) – 每个隐藏 RNN 层的特征图大小 (\(h_n\))。n_rnn_layers (
int) – 循环层的数量。dropout (
float) – 受 Dropout 影响的神经元比例。training_length (
int) – 训练期间使用的输入（目标和协变量）和输出（目标）时间序列的长度。其值必须大于 input_chunk_length，否则在训练期间 RNN 运行的迭代次数将永远不会达到推理时的次数。有关此参数的更多信息，请参见 darts.utils.data.ShiftedDataset。**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。batch_size – 每次训练中使用的时序（输入和输出序列）数量。默认值：
32。n_epochs – 训练模型的 epoch 数量。默认值：
100。model_name – 模型名称。用于创建检查点和保存 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 – 工作目录路径，用于保存检查点和 Tensorboard 摘要。默认值：当前工作目录。
log_tensorboard – 如果设置，则使用 Tensorboard 记录不同的参数。日志将位于：
"{work_dir}/darts_logs/{model_name}/logs/"。默认值：False。nr_epochs_val_period – 在评估验证损失之前等待的 epoch 数量（如果将验证
TimeSeries传递给fit()方法）。默认值：1。force_reset – 如果设置为
True，则具有相同名称的任何先前存在的模型都将被重置（所有检查点都将被丢弃）。默认值：False。save_checkpoints – 是否自动保存未经训练的模型和训练检查点。要从检查点加载模型，请调用
MyModelClass.load_from_checkpoint()，其中MyModelClass是使用的TorchForecastingModel类（例如TFTModel、NBEATSModel等）。如果设置为False，仍然可以使用save()手动保存模型，并使用load()加载。默认值：False。add_encoders –
可以使用 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 – 控制权重初始化的随机性。有关更多详细信息，请查看此链接。默认值：
None。pl_trainer_kwargs –
默认情况下，
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]}用于仅使用 GPUi（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 Callbacksfrom 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]}
请注意，您还可以使用自定义 PyTorch Lightning Trainer 进行训练和预测，这通过在
fit()和predict()中使用可选参数trainer实现。show_warnings – 是否显示 PyTorch Lightning 发出的警告。有助于检测预测用例的潜在问题。默认值：
False。
示例
>>> from darts.datasets import WeatherDataset >>> from darts.models import RNNModel >>> series = WeatherDataset().load() >>> # predicting atmospheric pressure >>> target = series['p (mbar)'][:100] >>> # optionally, use future temperatures (pretending this component is a forecast) >>> future_cov = series['T (degC)'][:106] >>> # `training_length` > `input_chunk_length` to mimic inference constraints >>> model = RNNModel( >>> model="RNN", >>> input_chunk_length=6, >>> training_length=18, >>> n_epochs=20, >>> ) >>> model.fit(target, future_covariates=future_cov) >>> pred = model.predict(6) >>> pred.values() array([[ 3.18922903], [ 1.17791019], [ 0.39992814], [ 0.13277921], [ 0.02523252], [-0.01829086]])
注意
RNN 示例 Notebook 介绍了可以用来提高预测质量的技术，与此简单的用法示例相比。
属性
如果存在静态协变量，模型是否考虑它们。
一个 8 元组，依次包含：（最小目标滞后，最大目标滞后，最小过去协变量滞后，最大过去协变量滞后，最小未来协变量滞后，最大未来协变量滞后，输出偏移，最大目标训练滞后（仅限 RNNModel））。
first_prediction_index
likelihood
min_train_samples
min_train_series_length
output_chunk_length
output_chunk_shift
supports_future_covariates
supports_likelihood_parameter_prediction
supports_multivariate
supports_optimized_historical_forecasts
supports_probabilistic_prediction
supports_sample_weight
supports_static_covariates
supports_transferable_series_prediction
uses_future_covariates
uses_past_covariates
uses_static_covariates
模型在拟合后是否使用静态协变量。
epochs_trained
input_chunk_length
model_created
model_params
方法
backtest(series[, past_covariates, ...]) 计算模型对（可能多个）series 的历史预测产生的误差值。fit(series[, past_covariates, ...]) 在一个或多个序列上拟合/训练模型。fit_from_dataset(train_dataset[, ...]) 使用特定的darts.utils.data.TrainingDataset实例训练模型。generate_fit_encodings(series[, ...]) 生成用于模型拟合的协变量编码，并返回一个包含过去和未来协变量序列的元组，其中包含原始和编码后的协变量堆叠在一起。generate_fit_predict_encodings(n, series[, ...]) 生成用于训练和推理/预测的协变量编码，并返回一个包含过去和未来协变量序列的元组，其中包含原始和编码后的协变量堆叠在一起。generate_predict_encodings(n, series[, ...]) 生成用于推理/预测集的协变量编码，并返回一个包含过去和未来协变量序列的元组，其中包含原始和编码后的协变量堆叠在一起。gridsearch(parameters, series[, ...]) 使用网格搜索在给定集合中找到最佳超参数。historical_forecasts(series[, ...]) 通过模拟在提供的（可能多个）series 的整个历史中的各个时间点进行预测来生成历史预测。initialize_encoders([default]) 根据 self._model_encoder_settings 和模型创建时使用的参数add_encoders实例化 SequentialEncoder 对象load(path[, pl_trainer_kwargs]) 从给定文件路径加载模型。load_from_checkpoint(model_name[, work_dir, ...]) 从 '{work_dir}/darts_logs/{model_name}/checkpoints/' 下自动保存的检查点加载模型。load_weights(path[, load_encoders, skip_checks]) 从手动保存的模型（使用save()保存）加载权重。load_weights_from_checkpoint([model_name, ...]) 仅从 '{work_dir}/darts_logs/{model_name}/ checkpoints/' 下自动保存的检查点加载权重。lr_find(series[, past_covariates, ...]) PyTorch Lightning 的 Tuner.lr_find() 的包装器。predict(n[, series, past_covariates, ...]) 预测训练序列或指定series结束后的n个时间步。predict_from_dataset(n, input_series_dataset) 此方法允许使用特定的darts.utils.data.InferenceDataset实例进行预测。reset_model 重置模型对象并删除所有存储的数据 - 模型、检查点、日志记录器和训练历史。
residuals(series[, past_covariates, ...]) 计算模型对（可能多个）series 的历史预测产生的残差。save([path, clean]) 将模型保存到给定路径下。to_cpu 更新 PyTorch Lightning Trainer 参数，以便下次调用 :fun:`fit()` 或
predict()时将模型移动到 CPU。to_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)¶
如果提供了 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) – 预测的预测水平。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 是可调用对象且第一个可预测点早于第一个可训练点，则为第一个可预测点。如果 retrain 为
True> 或int（给定 train_length），或者 retrain 是可调用对象且第一个可训练点早于第一个可预测点，则为第一个可训练点。注意：如果 start 不在可训练/可预测点范围内，则使用最接近有效的开始点，该点
是 stride 的整数倍，位于 start 之前。如果不存在有效的开始点，则引发 ValueError。
注意：如果模型使用偏移输出（output_chunk_shift > 0），则第一个预测点也
注意：如果 start 超出可能的历史预测时间，将忽略该参数
-
（
None的默认行为），并从第一个可训练/可预测点开始。 backtest(series[, past_covariates, ...]) 计算模型对（可能多个）series 的历史预测产生的误差值。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 的过去协变量序列
future_covariates (TimeSeries)：直到 min(pred_time + series.freq * forecast_horizon, series.end_time()) 的未来协变量序列
注意：如果未将任何可选的 *_covariates 传递给 historical_forecast，则将向相应的 retrain 函数参数传递
None。注意：某些模型要求每次都重新训练，并且不支持除 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 的单个 backtest 分数
使用 last_points_only=False 生成的历史预测并使用 backtest reduction
np.ndarray – backtest 分数的 numpy 数组。对于单个序列和以下情况之一：
单个 metric 函数，使用 last_points_only=False 和 backtest reduction=None 生成的历史预测。输出形状为 (n forecasts, *)。
多个 metric 函数和使用 last_points_only=False 生成的历史预测。使用 backtest 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。
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¶
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 Trainers 的更多信息，请查看此链接。此函数可以多次调用以进行额外的训练。如果指定了
epochs，模型将额外训练epochs个周期。下面记录了所有可能的参数，但并非所有模型都支持所有参数。例如，所有
PastCovariatesTorchModel仅支持past_covariates而不支持future_covariates。如果您尝试使用错误的协变量参数拟合模型，Darts 将报错。
List[float] – 与 float 类型相同，但适用于序列列表。返回的度量列表长度为 len(series)，其中包含每个输入 series 的 float 度量值。
List[np.ndarray] – 与 np.ndarray 类型相同，但适用于序列列表。返回的度量列表长度为 len(series)，其中包含每个输入 series 的 np.ndarray 度量值。
- 属性 considers_static_covariates: bool¶
如果存在静态协变量，模型是否考虑它们。
- 注意
bool
- 属性 extreme_lags: tuple[Optional[int], Optional[int], Optional[int], Optional[int], Optional[int], Optional[int], int, Optional[int]]¶
一个包含以下内容的 8 元组（按顺序）：(最小目标滞后, 最大目标滞后, 最小过去协变量滞后, 最大过去协变量滞后, 最小未来协变量滞后, 最大未来协变量滞后, 输出偏移, 最大目标滞后训练 (仅适用于 RNNModel))。如果 0 是第一个预测的索引，则所有滞后都相对于此索引。
请参阅下面的示例。
- 如果模型拟合时未提供
target (仅适用于 RegressionModels): 则第一个元素应为 None。
past covariates: 则第三个和第四个元素应为 None。
future covariates: 则第五个和第六个元素应为 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]]
- 属性 first_prediction_index: int¶
first_prediction_index
- 注意
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(train_dataset[, ...]) 使用特定的darts.utils.data.TrainingDataset实例训练模型。此方法封装了
fit_from_dataset()，为本模型构建了一个默认的训练数据集。如果您需要更精细地控制如何对序列进行切片以进行训练，请考虑使用自定义的darts.utils.data.TrainingDataset调用fit_from_dataset()。训练使用 PyTorch Lightning Trainer 进行。它使用预设中的默认 Trainer 对象以及模型创建时使用的
pl_trainer_kwargs。您也可以使用可选参数trainer指定自定义的 Trainer。有关 PyTorch Lightning Trainers 的更多信息，请查看 此链接。此函数可以多次调用以进行额外的训练。如果指定了
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]) – 是否打印训练进度。如果在 ProgressBar 中存在 pl_trainer_kwargs 回调，则忽略此参数。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 相同，但用于评估数据集。
tuple[Optional[int,None],Optional[int,None],Optional[int,None],Optional[int,None],Optional[int,None],Optional[int,None],int,Optional[int,None]]已拟合的模型。
- 注意
self
- fit_from_dataset(train_dataset, val_dataset=None, trainer=None, verbose=None, epochs=0, dataloader_kwargs=None)¶
使用特定的
darts.utils.data.TrainingDataset实例训练模型。这些数据集实现了 PyTorchDataset，并指定了如何对目标和协变量进行切片以进行训练。如果您不确定使用哪种训练数据集，请考虑调用fit()，它将为本模型创建一个默认的训练数据集。训练使用 PyTorch Lightning Trainer 进行。它使用预设中的默认 Trainer 对象以及模型创建时使用的
pl_trainer_kwargs。您也可以使用可选参数trainer指定自定义的 Trainer。有关 PyTorch Lightning Trainers 的更多信息，请查看 此链接。此函数可以多次调用以进行额外的训练。如果指定了
epochs，模型将额外训练指定的epochs轮次。- 参数
train_dataset (
TrainingDataset) – 类型与本模型匹配的训练数据集（例如，适用于PastCovariatesTorchModel的PastCovariatesTrainingDataset）。val_dataset (
Optional[TrainingDataset,None]) – 类型与本模型匹配的训练数据集（例如，适用于PastCovariatesTorchModel的PastCovariatesTrainingDataset），表示验证集（用于跟踪验证损失）。trainer (
Optional[Trainer,None]) – 可选参数，自定义的 PyTorch-Lightning Trainer 对象，用于执行训练。使用自定义的 trainer 将覆盖 Darts 的默认 Trainer。verbose (
Optional[bool,None]) – 是否打印训练进度。如果在 ProgressBar 中存在 pl_trainer_kwargs 回调，则忽略此参数。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”）以实现无缝预测。更改这些参数时应小心，以免出现意外行为。
tuple[Optional[int,None],Optional[int,None],Optional[int,None],Optional[int,None],Optional[int,None],Optional[int,None],int,Optional[int,None]]已拟合的模型。
- 注意
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[Optional[int,None],Optional[int,None],Optional[int,None],Optional[int,None],Optional[int,None],Optional[int,None],int,Optional[int,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[Optional[int,None],Optional[int,None],Optional[int,None],Optional[int,None],Optional[int,None],Optional[int,None],int,Optional[int,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[Optional[int,None],Optional[int,None],Optional[int,None],Optional[int,None],Optional[int,None],Optional[int,None],int,Optional[int,None]]一个 (过去协变量, 未来协变量) 的元组。每个协变量都包含原始协变量以及编码后的协变量。
- 注意
Tuple[Union[TimeSeries, Sequence[TimeSeries]], Union[TimeSeries, Sequence[TimeSeries]]]
- 类方法 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)¶
load_weights_from_checkpoint([model_name, ...]) 仅从 '{work_dir}/darts_logs/{model_name}/ checkpoints/' 下自动保存的检查点加载权重。此函数有 3 种操作模式：扩展窗口模式、分割模式和拟合值模式。这三种操作模式通过使用 parameters 字典中提供的每个超参数值的组合来实例化 ForecastingModel 的 model_class 子类，并根据 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 – 要针对 ‘series’ 进行调优的 ForecastingModel 子类。
parameters (
dict) – 一个字典，其键为超参数名称，值为对应超参数的值列表。series (
TimeSeries) – 用作训练的输入和目标的序列。past_covariates (
Optional[TimeSeries,None]) – 可选参数，过去观察到的协变量序列。仅当模型支持过去协变量时适用。future_covariates (
Optional[TimeSeries,None]) – 可选参数，未来已知的协变量序列。仅当模型支持未来协变量时适用。forecast_horizon (
Optional[int,None]) – 预测范围（forecast horizon）的整数值。激活扩展窗口模式。stride (
int) – 仅在扩展窗口模式下使用。两次连续预测之间的时间步长数。overlap_end (
bool) – 返回的预测是否可以超出序列的末尾。仅在扩展窗口模式下使用。可选参数，计算第一个预测的时间点。此参数支持：
float、int、pandas.Timestamp和None。如果为float，则表示时间序列中位于第一个预测点之前的部分占总长度的比例。如果为int，则对于具有 pd.DatetimeIndex 的 series，它是第一个预测点的索引位置；对于具有 pd.RangeIndex 的 series，它是索引值。后一种情况可以通过 start_format=”position” 更改为索引位置。如果为pandas.Timestamp，则它是第一个预测点的时间戳。如果为None，则第一个预测点将自动设置为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()并返回度量得分的自定义度量。如果 retrain 为
True或int（给定 train_length），则为第一个可训练点；或者如果 retrain 是一个 Callable 且第一个可训练点早于第一个可预测点，则为第一个可训练点。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，数据转换器在每个历史预测步骤在训练数据上重新拟合。
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]) – 在分割模式下用于验证的 TimeSeries 实例。如果提供，此序列必须紧接在 series 结尾之后开始；以便进行适当的预测比较。use_fitted_values (
bool) – 如果为 True，则使用与拟合值的比较。如果 model_class 没有fitted_values属性，则引发错误。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，此时将忽略随机选择。bool
property extreme_lags: tuple[Optional[int], Optional[int], Optional[int], Optional[int], Optional[int], Optional[int], int, Optional[int]]¶
一个 8 元组，依次包含：（最小目标滞后，最大目标滞后，最小过去协变量滞后，最大过去协变量滞后，最小未来协变量滞后，最大未来协变量滞后，输出偏移，最大目标训练滞后（仅限 RNNModel））。如果 0 是第一次预测的索引，则所有滞后都相对于此索引。
参见下面的示例。
拟合后的转换器用于在训练和预测期间转换输入。如果转换是可逆的，预测将进行逆变换。
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” 衰减——过去越远，权重越低。
tuple[Optional[int,None],Optional[int,None],Optional[int,None],Optional[int,None],Optional[int,None],Optional[int,None],int,Optional[int,None]]一个元组，包含使用最佳超参数创建的未训练的 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。
- 参数
是否以及/或在什么条件下在预测之前重新训练模型。此参数支持 3 种不同的类型：
bool、正整数 (int) 和可调用对象 (Callable，返回bool)。如果为bool：每一步都重新训练模型（True），或从不重新训练模型（False）。如果为int：模型每 retrain 次迭代重新训练。如果为Callable：当可调用对象返回 True 时，模型重新训练。可调用对象必须具有以下位置参数：counter (int)：当前 retrain 迭代次数
pred_time (pd.Timestamp 或 int)：预测时间（训练序列结束）的时间戳
past_covariates (TimeSeries)：直到 pred_time 的过去协变量序列
future_covariates (TimeSeries)：直到 min(pred_time + series.freq * forecast_horizon, series.end_time()) 的未来协变量序列
注意：如果未将任何可选的 *_covariates 传递给 historical_forecast，则将向相应的 retrain 函数参数传递
None。注意：某些模型要求每次都重新训练，并且不支持除 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 的单个 backtest 分数
使用 last_points_only=False 生成的历史预测并使用 backtest reduction
np.ndarray – backtest 分数的 numpy 数组。对于单个序列和以下情况之一：
包括 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 是第一次预测的索引，则所有滞后都相对于此索引。
参见下面的示例。
拟合后的转换器用于在训练和预测期间转换输入。如果转换是可逆的，预测将进行逆变换。
过去协变量：则第三和第四个元素应为 None。
未来协变量：则第五和第六个元素应为 None。
应被使用过去或未来协变量的模型以及/或最小目标滞后和最大目标滞后可能不同于 -1 和 0 的模型覆盖。
- 注意
Union[TimeSeries,list[TimeSeries],list[list[TimeSeries]]]tuple[Optional[int,None],Optional[int,None],Optional[int,None],Optional[int,None],Optional[int,None],Optional[int,None],int,Optional[int,None]]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)¶
reset_model 重置模型对象并删除所有存储的数据 - 模型、检查点、日志记录器和训练历史。
- 属性 likelihood: Optional[TorchLikelihood]¶
likelihood
- 注意
Optional[TorchLikelihood,None]
- 静态方法 load(path, pl_trainer_kwargs=None, **kwargs)¶
save([path, clean]) 将模型保存到给定路径下。加载从
RNNModel保存的通用文件的示例from darts.models import RNNModel model_loaded = RNNModel.load(path)
将一个在 CPU 上训练的
RNNModel加载到 GPU 的示例from darts.models import RNNModel model_loaded = RNNModel.load(path, pl_trainer_kwargs={"accelerator": "gpu"})
将一个在 GPU 上保存的
RNNModel加载到 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
- 静态方法 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()方法的附加关键字参数，例如map_location，用于将模型加载到与保存时不同的设备上。有关更多信息，请阅读 官方文档。
tuple[Optional[int,None],Optional[int,None],Optional[int,None],Optional[int,None],Optional[int,None],Optional[int,None],int,Optional[int,None]]对应的已训练的
TorchForecastingModel。- 注意
TorchForecastingModel
- load_weights(path, load_encoders=True, skip_checks=False, **kwargs)¶
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)¶
注意：此方法需要能够访问 darts 模型检查点 (.pt) 文件，以便加载编码器并对模型参数执行健全性检查。
- 参数
path (
str) – 加载模型权重的路径。如果在保存模型时未指定路径，则必须提供以 “.pt” 结尾的自动生成路径。load_encoders (
bool) – 如果设置，将从模型中加载编码器，以便直接调用 fit() 或 predict()。默认值：True。skip_checks (
bool) – 如果设置，将禁用编码器的加载和对模型参数的健全性检查（不推荐）。不能与 load_encoders=True 一起使用。默认值：False。**kwargs –
PyTorch 的
load()方法的附加关键字参数，例如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()，它也会重新加载训练器、优化器和学习率调度器的状态。对于手动保存的模型，请考虑改用
load()或load_weights()。注意：此方法需要能够访问 darts 模型检查点 (.pt) 文件，以便加载编码器并对模型参数执行健全性检查。
- 参数
model_name (
可选[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()方法的附加关键字参数，例如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 的更多信息，请参阅此链接。如果调优器未给出令人满意的结果，建议增加 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]) – 是否打印训练进度。如果在 ProgressBar 中存在 pl_trainer_kwargs 回调，则忽略此参数。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
tuple[Optional[int,None],Optional[int,None],Optional[int,None],Optional[int,None],Optional[int,None],Optional[int,None],int,Optional[int,None]]Lightning 的 _LRFinder 对象，包含 LR 扫描的结果。
- 注意
lr_finder
- 属性 min_train_samples: int¶
min_train_samples
- 注意
int
- 属性 min_train_series_length: int¶
min_train_series_length
- 注意
int
- 属性 output_chunk_length: int¶
output_chunk_length
- 注意
int
- 属性 output_chunk_shift: int¶
output_chunk_shift
- 注意
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)¶
future_covariates (
Union[TimeSeries,Sequence[TimeSeries],None]) – 可选地，series 中每个输入时间序列的（序列）未来已知的协变量时间序列。仅适用于支持未来协变量的模型。预测使用 PyTorch Lightning Trainer 执行。它使用预设和模型创建时使用的
pl_trainer_kwargs中的默认 Trainer 对象。您还可以使用可选参数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的时间跨度内）。
处理协变量时，Darts 将尝试使用目标和协变量的时间轴来确定正确的时间切片。因此，协变量可以比实际需要更长；只要时间轴正确，Darts 就会正确处理它们。如果它们的时间跨度不足，Darts 也会报错。
- 参数
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]) – 是否打印训练进度。如果在 ProgressBar 中存在 pl_trainer_kwargs 回调，则忽略此参数。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) – 可选，为使用基于神经网络的模型进行预测启用蒙特卡洛 Dropout。这允许通过指定学习模型的隐式先验来进行贝叶斯近似。List[np.ndarray] – 与 np.ndarray 类型相同，但适用于序列的序列。返回的度量列表长度为 len(series)，其中包含每个输入 series 的 np.ndarray 度量。
show_warnings (
bool) – 可选，控制是否显示警告。并非对所有模型都有效。
tuple[Optional[int,None],Optional[int,None],Optional[int,None],Optional[int,None],Optional[int,None],Optional[int,None],int,Optional[int,None]]一个或多个时间序列，包含对
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实例进行预测。这些数据集实现了 PyTorchDataset，并指定了目标和协变量如何为推理进行切片。在大多数情况下，您可能更希望调用predict()，它将为您创建一个合适的InferenceDataset。预测使用 PyTorch Lightning Trainer 执行。它使用预设和模型创建时使用的
pl_trainer_kwargs中的默认 Trainer 对象。您还可以使用可选参数trainer来使用自定义 Trainer。有关 PyTorch Lightning Trainer 的更多信息，请参阅此链接。- 参数
n (
int) – 在训练时间序列结束之后需要产生预测的时间步数input_series_dataset (
InferenceDataset) – 可选，一个时间序列数据集或一系列时间序列数据集，代表要预测其未来的目标时间序列的历史。如果指定，此方法返回这些时间序列的预测。否则，此方法返回（单个）训练时间序列的预测。trainer (
Optional[Trainer,None]) – 可选，用于执行预测的自定义 PyTorch-Lightning Trainer 对象。使用自定义trainer将覆盖 Darts 的默认 trainer。batch_size (
可选[int,None]) – 预测期间的批次大小。默认为模型的batch_size值。verbose (
Optional[bool,None]) – 是否打印训练进度。如果在 ProgressBar 中存在 pl_trainer_kwargs 回调，则忽略此参数。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) – 可选，为使用基于神经网络的模型进行预测启用蒙特卡洛 Dropout。这允许通过指定学习模型的隐式先验来进行贝叶斯近似。predict_likelihood_parameters (
bool) – 如果设置为 True，模型将预测其 likelihood 的参数而不是目标。仅支持具有似然函数的概率模型，且要求 num_samples = 1 和 n<=output_chunk_length。默认值：False
tuple[Optional[int,None],Optional[int,None],Optional[int,None],Optional[int,None],Optional[int,None],Optional[int,None],int,Optional[int,None]]返回一个或多个时间序列的预测结果。
- 注意
Sequence[TimeSeries]
- reset_model()¶
train_length (
Optional[int,None]) – 可选地，对于每个构建的训练集（滑动窗口模式），使用固定长度/时间步数。仅当 retrain 不为False时有效。默认值为None，此时使用直到预测时间的所有时间步（扩展窗口模式）。如果大于可用时间步数，则使用扩展模式。至少需要 min_train_series_length。
- 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)¶
可选地，计算预测的第一个时间点。此参数支持：
float、int、pandas.Timestamp和None。如果为float，则为第一个预测点之前应包含的时间序列比例。如果为int，则对于具有 pd.DatetimeIndex 的 series，它是第一个预测点的索引位置，或者对于具有 pd.RangeIndex 的 series，它是索引值。后者可以使用 start_format=”position” 更改为索引位置。如果为pandas.Timestamp，则为第一个预测点的时间戳。如果为None，第一个预测点将自动设置为此函数计算来自 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()(error) 作为 metric。创建并返回一个具有历史预测时间索引和每个成分和时间步的度量值的 TimeSeries（或仅当 values_only=True 时返回一个 np.ndarray）。
此方法适用于单个或多个单变量或多变量时间序列。它使用中位数预测（处理随机预测时）。
- 参数
是否以及/或在什么条件下在预测之前重新训练模型。此参数支持 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 的过去协变量序列
future_covariates (TimeSeries)：直到 min(pred_time + series.freq * forecast_horizon, series.end_time()) 的未来协变量序列
注意：如果未将任何可选的 *_covariates 传递给 historical_forecast，则将向相应的 retrain 函数参数传递
None。注意：某些模型要求每次都重新训练，并且不支持除 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 的单个 backtest 分数
使用 last_points_only=False 生成的历史预测并使用 backtest reduction
np.ndarray – backtest 分数的 numpy 数组。对于单个序列和以下情况之一：
metric (
Callable[…,Union[float,list[float],ndarray,list[ndarray]]]) –可以是 Darts 的“每时间步”度量之一（参阅此处），也可以是与 Darts 的“每时间步”度量具有相同签名的自定义度量，该度量使用装饰器
multi_ts_support()和multi_ts_support()，并为每个时间步返回一个值。包括 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 是第一次预测的索引，则所有滞后都相对于此索引。
参见下面的示例。
如果模型未拟合
metric_kwargs (
可选[dict[str,Any],None]) – 传递给 metric() 的额外参数，例如用于并行化的 ‘n_jobs’，用于比例度量的 ‘m’ 等。仅当参数存在于相应的度量签名中时才会传递。忽略用于缩减的参数 “series_reduction”、“component_reduction”、“time_reduction” 和用于比例度量（例如 mase、rmsse 等）的参数 ‘insample’，因为它们在内部处理。过去协变量：则第三和第四个元素应为 None。
未来协变量：则第五和第六个元素应为 None。
应被使用过去或未来协变量的模型以及/或最小目标滞后和最大目标滞后可能不同于 -1 和 0 的模型覆盖。
values_only (
bool) – 是否将残差作为 np.ndarray 返回。如果为 False，则将残差作为 TimeSeries 返回。
- 注意
Union[TimeSeries,list[TimeSeries],list[list[TimeSeries]]]tuple[Optional[int,None],Optional[int,None],Optional[int,None],Optional[int,None],Optional[int,None],Optional[int,None],int,Optional[int,None]]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)¶
如果 retrain 为
True> 或int（给定 train_length），或者 retrain 是可调用对象且第一个可训练点早于第一个可预测点，则为第一个可训练点。在
path下创建两个文件：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 (
可选[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 存储的模型后，必须将 series 传递给 ‘predict()’、historical_forecasts() 和其他预测方法。
- 注意
None
- 属性 supports_future_covariates: bool¶
supports_future_covariates
- 注意
bool
- 属性 supports_likelihood_parameter_prediction: bool¶
supports_likelihood_parameter_prediction
- 注意
bool
- 属性 supports_multivariate: bool¶
supports_multivariate
- 注意
bool
- 属性 supports_optimized_historical_forecasts: bool¶
supports_optimized_historical_forecasts
- 注意
bool
- 属性 supports_probabilistic_prediction: bool¶
supports_probabilistic_prediction
默认情况下返回 False。需要由支持概率预测的模型覆盖。
- 注意
bool
- 属性 supports_sample_weight: bool¶
supports_sample_weight
- 注意
bool
- 属性 supports_static_covariates: bool¶
supports_static_covariates
- 注意
bool
- 属性 supports_transferable_series_prediction: bool¶
supports_transferable_series_prediction
- 注意
bool
- to_cpu()¶
更新 PyTorch Lightning Trainer 参数，以便下次调用 :fun:`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 (
可选[str,None]) – 保存模型当前状态的路径。如果未指定路径，模型将自动保存为"{ModelClass}_{YYYY-mm-dd_HH_MM_SS}.onnx"。**kwargs –
PyTorch
torch.onnx.export()方法的额外关键字参数（不包括参数file_path、input_sample、input_name>）。欲了解更多信息，请阅读官方文档。
- untrained_model()¶
注意：如果 start 超出可能的历史预测时间，将忽略该参数
- 属性 uses_future_covariates: bool¶
uses_future_covariates
- 注意
bool
- 属性 uses_past_covariates: bool¶
uses_past_covariates
- 注意
bool
- 属性 uses_static_covariates: bool¶
uses_static_covariates
- 注意
bool
- class darts.models.forecasting.rnn_model.CustomRNNModule(input_size, hidden_dim, num_layers, target_size, nr_params, dropout=0.0, **kwargs)[源代码]¶
基类:
PLDualCovariatesModule,ABC此类允许创建可稍后与 Darts 的
RNNModel一起使用的自定义 RNN 模块。它添加了与 Darts 的TorchForecastingModel和RNNModel一起使用所需的核心骨架。要创建新模块，请从
CustomRNNModule创建子类并在模块构造函数 (__init__()) 中定义架构
添加 forward() 方法并定义模块正向传播的逻辑
使用参数 model 创建新的
RNNModel时，使用自定义模块类。
您可以使用 darts.models.forecasting.rnn_model._RNNModule 作为示例。
- 参数
input_size (
int) – 输入时间序列的维度。hidden_dim (
int) – RNN 模块隐藏状态 h 中的特征数量。num_layers (
int) – 循环层的数量。target_size (
int) – 输出时间序列的维度。nr_params (
int) – 似然函数参数的数量（如果未使用似然函数则为 1）。dropout (
float) – 除最后一层外的所有 RNN 层中被丢弃的神经元比例。**kwargs –
darts.models.forecasting.pl_forecasting_module.PLForecastingModule基类所需的所有参数。
属性
automatic_optimization如果设置为
False，则您负责调用.backward()、.step()、.zero_grad()。current_epochTrainer中的当前 epoch，如果未附加则为 0。device_mesh诸如
ModelParallelStrategy等策略将创建设备网格，可在configure_model()钩子中访问该网格以并行化 LightningModule。example_input_array示例输入数组是对模块在
forward()方法中可消耗的内容的规范。global_rank当前进程在所有节点和设备中的索引。
global_step所有 epoch 中看到的训练批次总数。
hparams使用
save_hyperparameters()保存的超参数集合。hparams_initial使用
save_hyperparameters()保存的超参数集合。local_rank当前进程在单个节点内的索引。
loggerTrainer 中 logger 对象的引用。
loggersTrainer 中 logger 列表的引用。
on_gpu如果此模型当前位于 GPU 上，则返回
True。定义训练序列所需最小长度的类属性；覆盖 ForecastingModel 的默认值 3模型一次预测的时间步数。
strict_loading确定 Lightning 如何使用 .load_state_dict(..., strict=model.strict_loading) 加载此模型。
device
dtype
模型在拟合后是否使用静态协变量。
fabric
模型是否支持优化的历史预测
trainer
model_params
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[, h])RNN 模块的前向传播。
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, batch_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()在训练结束前、日志实验关闭后调用。
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)执行预测步骤
prepare_data()使用此方法下载和准备数据。
print(*args, **kwargs)仅从进程 0 打印。
register_backward_hook(hook)在模块上注册一个反向钩子。
register_buffer(name, tensor[, persistent])向模块添加一个缓冲区。
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)注册一个 pre-hook，在模块的
load_state_dict()方法被调用之前运行。register_module(name, module)add_module()的别名。register_parameter(name, param)向模块添加一个参数。
register_state_dict_post_hook(hook)为
state_dict()方法注册一个 post-hook。register_state_dict_pre_hook(hook)为
state_dict()方法注册一个 pre-hook。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（训练 + 验证）、验证、测试或预测的开始时调用。
share_memory()参见
torch.Tensor.share_memory_()。state_dict(*args[, destination, prefix, ...])返回一个字典，其中包含对模块整个状态的引用。
teardown(stage)在 fit（训练 + 验证）、验证、测试或预测的结束时调用。
test_dataloader()指定测试样本的可迭代对象或可迭代对象集合。
test_step(*args, **kwargs)在测试集的一个批次数据上进行操作。
to(*args, **kwargs)参见
torch.nn.Module.to()。to_dtype(dtype)将模块精度（默认为 float32）转换为另一种精度。
to_empty(*, device[, recurse])将参数和缓冲区移动到指定设备，而不复制存储。
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])将所有模型参数和缓冲区移动到 XPU。
zero_grad([set_to_none])重置所有模型参数的梯度。
__call__
set_mc_dropout
- abstract forward(x_in, h=None)[source]¶
RNN 模块的前向传播。
- 参数
x_in (
tuple) – 包含输入序列特征的张量元组。该元组包含 (过去的目标、历史未来协变量、未来协变量、静态协变量) 等元素。过去的目标的形状为 (batch_size, input_length, input_size)。h (
Optional[Tensor,None]) – 可选地，隐藏状态。
tuple[Optional[int,None],Optional[int,None],Optional[int,None],Optional[int,None],Optional[int,None],Optional[int,None],int,Optional[int,None]]包含 (RNN 输出, 隐藏状态) 元素的张量元组。RNN 输出张量的形状为 (batch_size, output_chunk_length, target_size, nr_params)。它包含输入序列中每个时间步的输出。在训练期间，整个张量用作输出，而在预测期间，我们只使用 y[:, -1, :]。但是，此模块始终返回整个张量。
- 注意
Tuple[torch.Tensor, torch.Tensor]