块递归神经网络¶
- 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, **kwargs)[源代码]¶
基类：
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 影响的神经元比例。**kwargs – 用于初始化 pytorch_lightning.Module、pytorch_lightning.Trainer 和 Darts 的
TorchForecastingModel的可选参数。loss_fn – 用于训练的 PyTorch 损失函数。如果指定了
likelihood参数，则此参数将被概率模型忽略。默认值：torch.nn.MSELoss()。likelihood – Darts 的
似然模型之一，用于概率预测。默认值：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 – 每次训练中使用的时序数量（输入和输出序列）。默认值：
32。n_epochs – 训练模型的轮数。默认值：
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 – 在评估验证损失之前等待的轮次数（如果在
fit()方法中传递了验证TimeSeries）。默认值：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的一些功能： .. highlight:: python .. code-block:: pythonrandom_state – 控制权重初始化的随机性。更多详情请查看此 链接。默认值：
None。pl_trainer_kwargs – 默认情况下，
TorchForecastingModel创建一个带有多个有用预设的 PyTorch Lightning Trainer，用于执行训练、验证和预测过程。这些预设包括自动检查点保存、TensorBoard 日志记录、设置 torch 设备等。通过pl_trainer_kwargs，您可以向 PyTorch Lightning trainer 对象的实例化添加额外的关键字参数。有关支持的关键字参数的更多信息，请查看 PL Trainer 文档。默认值：None。通过指定键"accelerator"、"devices"和"auto_select_gpus"，也可以使用pl_trainer_kwargs在 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"，您可以向 Darts 的TorchForecastingModel添加自定义或 PyTorch-Lightning 内置的回调。以下是一个为训练过程添加 EarlyStopping 的示例。如果验证损失 val_loss 未按指定条件改善，模型将提前停止训练。有关回调的更多信息，请访问：PyTorch Lightning Callbacks .. highlight:: python .. code-block:: pythonshow_warnings – 是否显示从 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 示例笔记本 展示了可以用来提高预测质量的技巧，相比于这个简单的使用示例。
属性
模型是否考虑静态协变量，如果有的话。
一个包含以下顺序的8元组：（最小目标滞后，最大目标滞后，最小过去协变量滞后，最大过去协变量滞后，最小未来协变量滞后，最大未来协变量滞后，输出偏移，最大目标滞后训练（仅适用于RNNModel））。
返回在 self.model 输出中第一个预测的索引。
训练模型的最小样本数。
定义训练系列所需的最小长度的类属性；覆盖 ForecastingModel 的默认值 3
模型一次预测的时间步数，统计模型未定义。
输出/预测开始于输入结束后的时间步数。
模型实例是否支持直接预测似然参数
模型是否在时间序列中考虑多个变量。
模型是否支持优化的历史预测
模型是否支持过去协变量
检查具有此配置的预测模型是否支持概率预测。
模型是否支持训练时的样本权重。
模型是否支持静态协变量
模型是否支持对任意输入 序列 的预测。
模型是否在拟合后使用未来协变量。
模型是否使用过去的协变量，一旦拟合。
模型是否使用静态协变量，一旦拟合。
已训练的轮数
input_chunk_length
似然性
模型创建
模型参数
方法
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, **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, ...])预测训练序列结束后的第
n个时间步，或指定序列后的第n个时间步。predict_from_dataset(n, input_series_dataset)此方法允许使用特定的
darts.utils.data.InferenceDataset实例进行预测。重置模型对象并删除所有存储的数据 - 模型、检查点、记录器和训练历史。
residuals(series[, past_covariates, ...])计算此模型在一个（或一系列）`TimeSeries` 上产生的残差。
save([path])将模型保存到给定路径下。
to_cpu()更新 PyTorch Lightning Trainer 参数，以便在下一次调用 :fun:`fit()` 或
predict()时将模型移动到 CPU。返回一个使用相同参数创建的新（未训练）模型实例。
- backtest(series, past_covariates=None, future_covariates=None, historical_forecasts=None, num_samples=1, train_length=None, start=None, start_format='value', forecast_horizon=1, stride=1, retrain=True, overlap_end=False, last_points_only=False, metric=<function mape>, reduction=<function mean>, verbose=False, show_warnings=True, metric_kwargs=None, fit_kwargs=None, predict_kwargs=None, sample_weight=None)¶
计算模型在使用于（可能多个）`series` 时会产生误差值。
如果提供了 historical_forecasts，则直接在预测值和实际值上评估指标（由 metric 函数给出）。必须传递用于生成历史预测的相同 series。否则，它会反复构建训练集：要么从 series 的开始扩展，要么以固定的 train_length 长度移动。它在训练集上训练当前模型，发出长度等于 forecast_horizon 的预测，然后将训练集的末端向前移动 stride 个时间步。然后，在预测值和实际值上评估指标。最后，该方法返回所有这些指标分数的 `reduction`（默认是平均值）。
默认情况下，此方法使用每个历史预测（整体）来计算误差分数。如果 last_points_only 设置为 True，它将仅使用每个历史预测的最后一个点。在这种情况下，不使用归约。
默认情况下，此方法总是重新在整个可用历史数据上训练模型，对应于扩展窗口策略。如果 retrain 设置为 `False`（对于训练可能耗时的模型（如深度学习模型）很有用），将直接使用已训练的模型来生成预测。
- 参数
series (
Union[TimeSeries,Sequence[TimeSeries]]) – 用于连续训练和评估历史预测的目标时间序列（或一系列时间序列）。past_covariates (
Union[TimeSeries,Sequence[TimeSeries],None]) – 可选地，一个（或一系列）过去观察到的协变量序列。这仅适用于模型支持过去协变量的情况。future_covariates (
Union[TimeSeries,Sequence[TimeSeries],None]) – 可选地，一个（或一系列）未来已知的协变量序列。这仅适用于模型支持未来协变量的情况。historical_forecasts (
Union[TimeSeries,Sequence[TimeSeries],Sequence[Sequence[TimeSeries]],None]) – 可选地，要评估的历史预测时间序列（或一系列/一系列序列）。对应于historical_forecasts()的输出。必须传递用于生成历史预测的相同 series 和 last_points_only 值。如果提供，将跳过历史预测并忽略除 series、last_points_only、metric 和 reduction 之外的所有参数。num_samples (
int) – 从概率模型中采样预测的次数。仅对概率模型使用值 >1。train_length (
Optional[int,None]) – 我们训练集中的时间步数（用于训练的回测窗口大小）。仅在 retrain 不为False时有效。默认设置为 train_length=None，此时会使用所有可用的时间步直到预测时间，否则将使用移动窗口策略。如果大于可用时间步数，则使用所有时间步直到预测时间，如同默认情况。至少需要 min_train_series_length。start (
Union[Timestamp,float,int,None]) – 可选地，计算预测的第一个时间点。此参数支持：float、int、pandas.Timestamp和None。如果是一个float，它表示时间序列中应位于第一个预测点之前的那部分的比例。如果是一个int，它要么是 series 具有 pd.DatetimeIndex 时的第一个预测点的索引位置，要么是 series 具有 pd.RangeIndex 时的索引值。后者可以通过 start_format=”position” 更改为索引位置。如果是一个pandas.Timestamp，它是第一个预测点的时间戳。如果为None，第一个预测点将自动设置为：start_format (
Literal[‘position’, ‘value’]) – 定义 start 格式。仅在 start 为整数且 series 使用 pd.RangeIndex 索引时有效。如果设置为 ‘position’，start 对应于第一个预测点的索引位置，范围可以从 (-len(series), len(series) - 1)。如果设置为 ‘value’，start 对应于第一个预测点的索引值/标签。如果该值不在 series 的索引中，将引发错误。默认值：'value'forecast_horizon (
int) – 点预测的预测范围。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())
注意：如果未向 historical_forecast 传递任何可选的 *_covariates，则会将
None传递给相应的重新训练函数参数。注意：某些模型确实需要每次都重新训练，并且不支持除 retrain=True 以外的任何内容。overlap_end (
bool) – 返回的预测是否可以超出序列的末尾。last_points_only (
bool) – 是否使用整个历史预测或仅使用每个预测的最后一点来计算误差。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 相关的警告。metric_kwargs (
Union[Dict[str,Any],List[Dict[str,Any]],None]) – 传递给 metric() 的额外参数，例如用于并行化的 ‘n_jobs’，用于减少组件指标的 ‘component_reduction’，用于缩放指标的季节性 ‘m’ 等。将单独传递每个指标的参数，并且仅当它们存在于相应指标的签名中时。缩放指标的参数 ‘insample’`（例如 `mase、rmsse 等）被忽略，因为它在内部处理。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 函数和：
historical_forecasts 生成的 last_points_only=True
使用 last_points_only=False 生成的 historical_forecasts 和使用回测 reduction
np.ndarray – 一个包含回测分数的 numpy 数组。适用于单一系列和以下之一：
一个单独的 metric 函数，使用 last_points_only=False 生成的 historical_forecasts 和 reduction=None 的回测。输出形状为 (n 个预测,)。
多个 metric 函数和使用 last_points_only=False 生成的 historical_forecasts。当使用回测 reduction 时，输出形状为 (n metrics,)，当 reduction=None 时，输出形状为 (n metrics, n forecasts)。
包括 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。
未来协变量：那么第五和第六个元素应该是 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()进行封装，为此模型构建一个默认的训练数据集。如果你需要更多控制如何对序列进行切片以进行训练，请考虑使用自定义的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 的默认训练器。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()，它将为此模型创建一个合适的默认训练数据集。训练是通过 PyTorch Lightning 的 Trainer 进行的。它使用来自预设的默认 Trainer 对象和在模型创建时使用的
pl_trainer_kwargs。您也可以使用带有可选参数trainer的自定义 Trainer。有关 PyTorch Lightning Trainers 的更多信息，请查看 此链接。这个函数可以被多次调用来进行一些额外的训练。如果指定了
epochs，模型将会被训练一些（额外的）epochs轮。- 参数
train_dataset (
TrainingDataset) – 一个与该模型类型匹配的训练数据集（例如，PastCovariatesTrainingDataset用于PastCovariatesTorchModel）。val_dataset (
Optional[TrainingDataset,None]) – 一个与该模型类型匹配的训练数据集（例如，PastCovariatesTrainingDataset用于PastCovariatesTorchModel），表示验证集（用于跟踪验证损失）。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, fit_kwargs=None, predict_kwargs=None, sample_weight=None)¶
使用网格搜索在一组给定的超参数中找到最佳的超参数。
此函数有三种操作模式：扩展窗口模式、分割模式和拟合值模式。这三种操作模式通过使用 parameters 字典中提供的每个超参数值组合实例化 model_class 子类的 ForecastingModel，来评估所有可能的超参数值组合，并根据 metric 函数返回表现最佳的模型。metric 函数应返回一个误差值，因此将选择产生最小 metric 输出的模型。
训练数据和测试数据之间的关系取决于操作模式。
扩展窗口模式（当传递 forecast_horizon 时激活）：对于每一种超参数组合，模型会在 series 的不同分割上反复训练和评估。这一过程通过使用
backtest()函数作为子程序来实现，该函数从 start 开始生成历史预测，并与 series 的真实值进行比较。请注意，模型会为每一次预测重新训练，因此这种模式较慢。拆分窗口模式（当传递 val_series 时激活）：当传递 val_series 参数时，将使用此模式。对于每一种超参数组合，模型将在 series 上训练并在 val_series 上评估。
拟合值模式（当 use_fitted_values 设置为 True 时激活）：对于每一种超参数组合，模型在 series 上进行训练，并在得到的拟合值上进行评估。并非所有模型都有拟合值，如果模型没有 fitted_values 成员，此方法会引发错误。拟合值是模型在 series 上拟合的结果。与拟合值进行比较可以是一种快速评估模型的方法，但无法看出模型是否过度拟合了 series。
派生类必须确保模型的单个实例不会与其他实例共享参数，例如，将模型保存在同一路径中。否则，在并行运行多个模型时（当
n_jobs != 1时），可能会出现意外行为。如果无法避免这种情况，则应重新定义网格搜索，强制n_jobs = 1。目前此方法仅支持确定性预测（即模型的预测结果只有一个样本）。
- 参数
model_class – 要为 ‘series’ 调整的 ForecastingModel 子类。
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，则第一个预测点将自动设置为：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，则使用与拟合值的比较。如果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，在这种情况下将忽略随机选择。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, num_samples=1, train_length=None, start=None, start_format='value', forecast_horizon=1, stride=1, retrain=True, overlap_end=False, last_points_only=True, verbose=False, show_warnings=True, predict_likelihood_parameters=False, enable_optimization=True, fit_kwargs=None, predict_kwargs=None, sample_weight=None)¶
计算此模型在（可能多个）`series` 上将获得的历史预测。
此方法反复构建训练集：要么从 series 的开头扩展，要么以固定的 train_length 长度移动。它在训练集上训练模型，发出长度等于 forecast_horizon 的预测，然后将训练集的末端向前移动 stride 时间步。
默认情况下，此方法将返回一个（或一系列）由每个历史预测的最后一个点组成的时间序列。因此，该时间序列的频率将为
series.freq * stride。如果 last_points_only 设置为 False，它将返回一个（或一系列）历史预测序列的列表。默认情况下，此方法总是重新在整个可用历史数据上训练模型，对应于扩展窗口策略。如果 retrain 设置为 False，则模型必须在此之前已经拟合过。并非所有模型都支持这一点。
- 参数
series (
Union[TimeSeries,Sequence[TimeSeries]]) – 用于连续训练和计算历史预测的目标时间序列（或一系列时间序列）。past_covariates (
Union[TimeSeries,Sequence[TimeSeries],None]) – 可选地，一个（或一系列）过去观察到的协变量序列。这仅适用于模型支持过去协变量的情况。future_covariates (
Union[TimeSeries,Sequence[TimeSeries],None]) – 可选地，一个（或一系列）未来已知的协变量序列。这仅适用于模型支持未来协变量的情况。num_samples (
int) – 从概率模型中采样预测的次数。仅对概率模型使用值 >1。train_length (
Optional[int,None]) – 我们训练集中的时间步数（用于训练的回测窗口大小）。仅在 retrain 不为False时有效。默认设置为 train_length=None，此时会使用所有可用的时间步直到预测时间，否则将使用移动窗口策略。如果大于可用时间步数，则使用所有时间步直到预测时间，如同默认情况。至少需要 min_train_series_length。start (
Union[Timestamp,float,int,None]) – 可选地，计算预测的第一个时间点。此参数支持：float、int、pandas.Timestamp和None。如果是float，它是时间序列中应位于第一个预测点之前的比例。如果是int，它是 series 具有 pd.DatetimeIndex 时的第一个预测点的索引位置，或者是 series 具有 pd.RangeIndex 时的索引值。后者可以通过 start_format=”position” 更改为索引位置。如果是pandas.Timestamp，它是第一个预测点的时间戳。如果是None，第一个预测点将自动设置为：- 如果 retrain 为False，或者 retrain 是一个可调用对象且第一个可预测点早于第一个可训练点，则为第一个可预测点。- 如果 retrain 为True或int``（给定 `train_length`），或者 `retrain` 是一个可调用对象且第一个可训练点早于第一个可预测点，则为第一个可训练点。- 否则为第一个可训练点（给定 `train_length`）。注意：如果模型使用移位输出（`output_chunk_shift > 0`），则第一个预测点也会向未来移位 `output_chunk_shift` 个点。注意：如果 `start` 产生的时间超出 `series` 的时间索引范围，则会引发 ValueError。注意：如果 `start` 超出可能的历史预测时间范围，将忽略该参数（默认行为与 ``None相同），并从第一个可训练/可预测点开始。start_format (
Literal[‘position’, ‘value’]) – 定义 start 格式。仅在 start 为整数且 series 使用 pd.RangeIndex 索引时有效。如果设置为 ‘position’，start 对应于第一个预测点的索引位置，范围可以从 (-len(series), len(series) - 1)。如果设置为 ‘value’，start 对应于第一个预测点的索引值/标签。如果该值不在 series 的索引中，将引发错误。默认值：'value'forecast_horizon (
int) – 预测的预测范围。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，则将``None``传递给相应的重新训练函数参数。注意：某些模型确实需要每次都重新训练，并且不支持除`retrain=True`以外的任何内容。overlap_end (
bool) – 返回的预测是否可以超出序列的末尾。last_points_only (
bool) – 是否仅保留每个历史预测的最后一个点。如果设置为 True，该方法返回一个包含连续点预测的TimeSeries。否则，返回一个历史TimeSeries预测的列表。verbose (
bool) – 是否打印进度。show_warnings (
bool) – 是否显示与历史预测优化相关的警告，或参数 start 和 train_length。predict_likelihood_parameters (
bool) – 如果设置为 True，模型将预测其似然参数的参数，而不是目标。仅支持具有似然性的概率模型，num_samples = 1 且 n<=output_chunk_length。默认值：Falseenable_optimization (
bool) – 是否在使用历史预测时使用优化版本（当支持并可用时）。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 对象- 返回类型
- static load(path, **kwargs)¶
从给定的文件路径加载模型。
从
RNNModel加载通用保存的示例：from darts.models import RNNModel model_loaded = RNNModel.load(path)
将保存在GPU上的
RNNModel加载到CPU的示例：from darts.models import RNNModel model_loaded = RNNModel.load(path, map_location="cpu") model_loaded.to_cpu()
- 参数
path (
str) – 加载模型的路径。如果在保存模型时未指定路径，则必须提供以“.pt”结尾的自动生成的路径。**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，将尝试恢复最佳检查点（如果best为True）或最近的检查点（如果best为False），从 ‘{work_dir}/darts_logs/{model_name}/checkpoints/’ 目录中。将保存在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 (
str) – 工作目录（包含检查点文件夹）。默认为当前工作目录。file_name (
str) – 检查点文件的名称。如果未指定，则使用最近的文件。best (
bool) – 如果设置，将检索最佳模型（根据验证损失）而不是最新的模型。只有在给出file_name时才会被忽略。**kwargs – PyTorch Lightning 的
LightningModule.load_from_checkpoint()方法的额外关键字参数，例如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()方法的额外关键字参数，例如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) – 模型的名称，用于检索检查点文件夹的名称。默认值：self.model_name。work_dir (
str) – 工作目录（包含检查点文件夹）。默认为当前工作目录。file_name (
str) – 检查点文件的名称。如果未指定，则使用最近的文件。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 的更多信息，请查看 此链接。如果 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 的默认训练器。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
- 返回
_LRFinder 对象包含 Lightning 的 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)¶
预测训练序列结束后的第
n个时间步，或指定序列后的第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的范围内）。
在处理协变量时，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 的默认训练器。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) – 可选地，使用基于神经网络的模型进行预测时启用蒙特卡洛辍学。这通过指定学习模型的隐含先验来实现贝叶斯近似。predict_likelihood_parameters (
bool) – 如果设置为 True，模型将预测其似然参数的参数，而不是目标。仅支持具有似然性的概率模型，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。预测是通过 PyTorch Lightning Trainer 执行的。它使用预设中的默认 Trainer 对象和模型创建时使用的
pl_trainer_kwargs。您也可以使用带有可选参数trainer的自定义 Trainer。有关 PyTorch Lightning Trainer 的更多信息，请查看 此链接。- 参数
n (
int) – 训练时间序列结束后，生成预测的时间步数input_series_dataset (
InferenceDataset) – 可选地，一系列或一系列序列，表示要预测其未来的目标序列的历史。如果指定，该方法返回这些序列的预测。否则，该方法返回（单个）训练序列的预测。trainer (
Optional[Trainer,None]) – 可选地，一个自定义的 PyTorch-Lightning Trainer 对象用于执行预测。使用自定义的trainer将覆盖 Darts 的默认训练器。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) – 可选地，使用基于神经网络的模型进行预测时启用蒙特卡洛辍学。这通过指定学习模型的隐含先验来实现贝叶斯近似。predict_likelihood_parameters (
bool) – 如果设置为 True，模型将预测其似然参数的参数，而不是目标。仅支持具有似然性的概率模型，num_samples = 1 且 n<=output_chunk_length。默认值：False
- 返回
返回一个或多个时间序列的预测。
- 返回类型
Sequence[TimeSeries]
- reset_model()¶
重置模型对象并删除所有存储的数据 - 模型、检查点、记录器和训练历史。
- residuals(series, past_covariates=None, future_covariates=None, historical_forecasts=None, num_samples=1, train_length=None, start=None, start_format='value', forecast_horizon=1, stride=1, retrain=True, last_points_only=True, metric=<function err>, verbose=False, show_warnings=True, metric_kwargs=None, fit_kwargs=None, predict_kwargs=None, values_only=False, sample_weight=None)¶
计算此模型在一个（或一系列）`TimeSeries` 上产生的残差。
此函数计算 series 的实际观测值与通过在 series 上训练模型（或在使用 retrain=False 的预训练模型）获得的拟合值之间的差异（或 Darts 的“每时间步长”指标之一）。并非所有模型都支持拟合值，因此我们使用历史预测作为它们的近似值。
此方法按顺序执行：
为每个序列计算历史预测或使用预计算的 historical_forecasts`（更多详情请参见 :meth:`~darts.models.forecasting.forecasting_model.ForecastingModel.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]]) – 将为其计算残差的单变量 TimeSeries 实例。past_covariates (
Union[TimeSeries,Sequence[TimeSeries],None]) – 一个或多个过去观测到的协变量时间序列。future_covariates (
Union[TimeSeries,Sequence[TimeSeries],None]) – 一个或多个未来已知协变量时间序列。forecast_horizon (
int) – 用于预测每个拟合值的预测范围。historical_forecasts (
Union[TimeSeries,Sequence[TimeSeries],Sequence[Sequence[TimeSeries]],None]) – 可选地，要评估的历史预测时间序列（或一系列/一系列序列）。对应于historical_forecasts()的输出。必须传递用于生成历史预测的相同 series 和 last_points_only 值。如果提供，将跳过历史预测并忽略除 series、last_points_only、metric 和 reduction 之外的所有参数。num_samples (
int) – 从概率模型中采样预测的次数。仅对概率模型使用值 >1。train_length (
Optional[int,None]) – 我们训练集中的时间步数（用于训练的回测窗口大小）。仅在 retrain 不为False时有效。默认设置为 train_length=None，此时会使用所有可用的时间步直到预测时间，否则将使用移动窗口策略。如果大于可用时间步数，则使用所有时间步直到预测时间，如同默认情况。至少需要 min_train_series_length。start (
Union[Timestamp,float,int,None]) – 可选地，计算预测的第一个时间点。此参数支持：float、int、pandas.Timestamp和None。如果是一个float，它表示时间序列中应位于第一个预测点之前的那部分的比例。如果是一个int，它要么是 series 具有 pd.DatetimeIndex 时的第一个预测点的索引位置，要么是 series 具有 pd.RangeIndex 时的索引值。后者可以通过 start_format=”position” 更改为索引位置。如果是一个pandas.Timestamp，它是第一个预测点的时间戳。如果为None，第一个预测点将自动设置为：start_format (
Literal[‘position’, ‘value’]) – 定义 start 格式。仅在 start 为整数且 series 使用 pd.RangeIndex 索引时有效。如果设置为 ‘position’，start 对应于第一个预测点的索引位置，范围可以从 (-len(series), len(series) - 1)。如果设置为 ‘value’，start 对应于第一个预测点的索引值/标签。如果该值不在 series 的索引中，将引发错误。默认值：'value'forecast_horizon – 点预测的预测范围。
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())
注意：如果未向 historical_forecast 传递任何可选的 *_covariates，则会将
None传递给相应的重新训练函数参数。注意：某些模型确实需要每次都重新训练，并且不支持除 retrain=True 以外的任何内容。last_points_only (
bool) – 是否使用整个历史预测或仅使用每个预测的最后一点来计算误差。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 相关的警告。metric_kwargs (
Optional[Dict[str,Any],None]) – 传递给 metric() 的额外参数，例如用于并行化的 ‘n_jobs’，用于缩放指标的 ‘m’ 等。仅在相应指标签名中存在时传递参数。忽略缩减参数 “series_reduction”, “component_reduction”, “time_reduction” 以及缩放指标的参数 ‘insample’`（例如 `mase, rmsse, …），因为它们在内部处理。fit_kwargs (
Optional[Dict[str,Any],None]) – 传递给模型 fit() 方法的额外参数。predict_kwargs (
Optional[Dict[str,Any],None]) – 传递给模型 predict() 方法的额外参数。values_only (
bool) – 是否以 np.ndarray 形式返回残差。如果为 False，则以 TimeSeries 形式返回残差。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]]]- 返回
时间序列 – 单个 series 的残差 时间序列 和使用 last_points_only=True 生成的 历史预测。
List[TimeSeries] – 一个残差 TimeSeries 列表，用于一个 series 序列（列表），且 last_points_only=True。残差列表的长度为 len(series)。
List[List[TimeSeries]] – 一个包含残差 TimeSeries 的列表的列表，用于 series 序列且 last_points_only=False。外部残差列表的长度为 len(series)。内部列表由所有可能的特定历史预测的残差组成。
- save(path=None)¶
将模型保存到给定路径下。
在
path下创建两个文件（模型对象）和path.ckpt（检查点）。保存和加载
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-Ligthning 检查点发生冲突。如果没有指定路径，模型将自动保存在"{ModelClass}_{YYYY-mm-dd_HH_MM_SS}.pt"下。例如，"RNNModel_2020-01-01_12_00_00.pt"。- 返回类型
None
- 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_transferrable_series_prediction: bool¶
模型是否支持对任意输入 序列 的预测。
- 返回类型
bool
- to_cpu()¶
更新 PyTorch Lightning Trainer 参数，以便在下一次调用 :fun:`fit()` 或
predict()时将模型移动到 CPU。
- 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, **kwargs)[源代码]¶
基类：
PLPastCovariatesModule,ABC此类允许创建自定义块RNN模块，这些模块稍后可以与Darts的
BlockRNNModel一起使用。它添加了与Darts的TorchForecastingModel和BlockRNNModel一起使用所需的主干。要创建一个新模块，请从
CustomBlockRNNModule派生子类并：在模块构造函数 (__init__()) 中定义架构
添加 forward() 方法并定义模块前向传递的逻辑
在创建新的
BlockRNNModel时，使用自定义模块类，参数为 model。
你可以使用 darts.models.forecasting.block_rnn_model._BlockRNNModule 作为例子。
- 参数
input_size (
int) – 输入时间序列的维度。hidden_dim (
int) – RNN 模块的隐藏状态 h 中的特征数量。num_layers (
int) – 循环层的数量。target_size (
int) – 输出时间序列的维度。nr_params (
int) – 似然函数的参数数量（如果没有使用似然函数，则为1）。num_layers_out_fc (
Optional[List,None]) – 包含全连接神经网络隐藏层维度的列表。该网络连接PyTorch RNN模块的最后一个隐藏层到输出。dropout (
float) – 在除最后一层外的所有RNN层中被丢弃的神经元比例。**kwargs – 所有
darts.models.forecasting.pl_forecasting_module.PLForecastingModule基类所需的参数。
属性
automatic_optimization如果设置为
False，你需要负责调用.backward()、.step()、.zero_grad()。current_epochTrainer中的当前时期，如果未附加则为 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 对象的引用。
loggers参考 Trainer 中的日志记录器列表。
on_gpu如果该模型当前位于GPU上，则返回
True。output_chunk_length模型一次预测的时间步数。
strict_loading确定 Lightning 如何使用 .load_state_dict(..., strict=model.strict_loading) 加载此模型。
设备
dtype
已训练的轮数
fabric
supports_probabilistic_prediction
训练者
方法
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()编译此模块的 forward。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()返回网络中所有模块的迭代器。
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()在拟合的最后调用。
on_fit_start()在拟合开始时调用。
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[, dataloader_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_module(name, module)别名
add_module()。register_parameter(name, param)向模块添加一个参数。
register_state_dict_pre_hook(hook)为
state_dict()方法注册一个预钩子。requires_grad_([requires_grad])更改是否应在此模块的参数上记录自动梯度操作。
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() 时重置。
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