时间序列混合器 (TSMixer)¶

class darts.models.forecasting.tsmixer_model.TSMixerModel(input_chunk_length, output_chunk_length, output_chunk_shift=0, hidden_size=64, ff_size=64, num_blocks=2, activation='ReLU', dropout=0.1, norm_type='LayerNorm', normalize_before=False, use_static_covariates=True, **kwargs)[源代码]¶

基类：MixedCovariatesTorchModel

时间序列混合器 (TSMixer): 一种全MLP架构的时间序列。

这是 TSMixer 架构的一个实现，如 [1] 中所述。架构的主要部分采用了这个 PyTorch 实现。为了提高模型性能和效率，还应用了额外的更改。

TSMixer 通过整合历史时间序列数据、未来已知输入和静态上下文信息来预测时间序列数据。它使用条件特征混合和混合层组合来处理和结合这些不同类型的数据，以实现有效的预测。

该模型支持过去协变量（在预测时间之前已知的 input_chunk_length 点）、未来协变量（在预测时间之后已知的 output_chunk_length 点）、静态协变量，以及概率预测。

参数

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）。
hidden_size (int) – 特征混合 MLP 中隐藏状态大小 / 第二前馈层的大小。
ff_size (int) – 特征混合多层感知器中第一个前馈层的尺寸。
num_blocks (int) – 模型中混频器块的数量。混频器包括第一个块和所有后续块。
activation (str) – 在混合层中使用的激活函数的名称。默认值：”ReLU”。必须是以下之一：”ReLU”, “RReLU”, “PReLU”, “ELU”, “Softplus”, “Tanh”, “SELU”, “LeakyReLU”, “Sigmoid”, “GELU”。
dropout (float) – 受dropout影响的神经元比例。这兼容于在推理时使用蒙特卡洛dropout进行模型不确定性估计（在预测时通过``mc_dropout=True``启用）。
norm_type (Union[str, Module]) – 要使用的 LayerNorm 变体的类型。默认值：”LayerNorm”。如果是一个字符串，必须是 “LayerNormNoBias”、”LayerNorm”、”TimeBatchNorm2d” 之一。否则，必须是一个自定义的 nn.Module。
normalize_before (bool) – 是否在混合层之前或之后应用层归一化。
use_static_covariates (bool) – 模型是否应在输入 series 传递给 fit() 时使用静态协变量信息。如果为 True，并且在拟合时提供了静态协变量，将强制所有目标 series 在 fit() 和 predict() 中具有相同的静态协变量维度。
**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 来对抗分布偏移，如 [3]_ 所示。它仅应用于目标序列的特征，而不应用于协变量。
batch_size – 每次训练中使用的时序数量（输入和输出序列）。默认值：32。
n_epochs – 训练模型的轮数。默认值：100。
model_name – 模型的名称。用于创建检查点和保存 torch.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 – 工作目录的路径，用于保存检查点和 torch.Tensorboard 摘要。默认：当前工作目录。
log_torch.Tensorboard – 如果设置，使用 torch.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:: python
random_state – 控制权重初始化的随机性。更多详情请查看此链接。默认值：None。
pl_trainer_kwargs – 默认情况下，TorchForecastingModel 创建一个带有多个有用预设的 PyTorch Lightning Trainer，用于执行训练、验证和预测过程。这些预设包括自动检查点保存、torch.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]} 仅使用 GPU i``（``i 必须为整数）， - {"accelerator": "gpu", "devices": -1, "auto_select_gpus": True} 使用所有可用的 GPU。有关更多信息，请参见：https://pytorch-lightning.readthedocs.io/en/stable/common/trainer.html#trainer-flags 和 https://pytorch-lightning.readthedocs.io/en/stable/accelerators/gpu_basic.html#train-on-multiple-gpus 通过参数 "callbacks"，您可以向 Darts 的 TorchForecastingModel 添加自定义或 PyTorch-Lightning 内置的回调。以下是一个为训练过程添加 EarlyStopping 的示例。如果验证损失 val_loss 未按指定条件改善，模型将提前停止训练。有关回调的更多信息，请访问：PyTorch Lightning Callbacks .. highlight:: python .. code-block:: python
show_warnings – 是否显示从 PyTorch Lightning 引发的警告。有助于检测您的预测用例中的潜在问题。默认值：False。

引用

1: https://arxiv.org/abs/2303.06053

实际案例

>>> from darts.datasets import WeatherDataset
>>> from darts.models import TSMixerModel
>>> series = WeatherDataset().load()
>>> # predicting temperatures
>>> target = series['T (degC)'][:100]
>>> # optionally, use past observed rainfall (pretending to be unknown beyond index 100)
>>> past_cov = series['rain (mm)'][:100]
>>> # optionally, use future atmospheric pressure (pretending this component is a forecast)
>>> future_cov = series['p (mbar)'][:106]
>>> model = TSMixerModel(
>>>     input_chunk_length=6,
>>>     output_chunk_length=6,
>>>     use_reversible_instance_norm=True,
>>>     n_epochs=20
>>> )
>>> model.fit(target, past_covariates=past_cov, future_covariates=future_cov)
>>> pred = model.predict(6)
>>> pred.values()
array([[3.92519848],
    [4.05650312],
    [4.21781987],
    [4.29394973],
    [4.4122863 ],
    [4.42762751]])

属性

`considers_static_covariates`	模型是否考虑静态协变量，如果有的话。
`extreme_lags`	一个包含以下顺序的8元组：（最小目标滞后，最大目标滞后，最小过去协变量滞后，最大过去协变量滞后，最小未来协变量滞后，最大未来协变量滞后，输出偏移，最大目标滞后训练（仅适用于RNNModel））。
`min_train_samples`	训练模型的最小样本数。
`output_chunk_length`	模型一次预测的时间步数，统计模型未定义。
`output_chunk_shift`	输出/预测开始于输入结束后的时间步数。
`supports_future_covariates`	模型是否支持未来协变量
`supports_likelihood_parameter_prediction`	模型实例是否支持直接预测似然参数
`supports_multivariate`	模型是否在时间序列中考虑多个变量。
`supports_optimized_historical_forecasts`	模型是否支持优化的历史预测
`supports_past_covariates`	模型是否支持过去协变量
`supports_probabilistic_prediction`	检查具有此配置的预测模型是否支持概率预测。
`supports_sample_weight`	模型是否支持训练时的样本权重。
`supports_static_covariates`	模型是否支持静态协变量
`supports_transferrable_series_prediction`	模型是否支持对任意输入序列的预测。
`uses_future_covariates`	模型是否在拟合后使用未来协变量。
`uses_past_covariates`	模型是否使用过去的协变量，一旦拟合。
`uses_static_covariates`	模型是否使用静态协变量，一旦拟合。

已训练的轮数
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` 上将获得的历史预测。
`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` 实例进行预测。
`reset_model`()	重置模型对象并删除所有存储的数据 - 模型、检查点、记录器和训练历史。
`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 epochs_trained: int¶

返回类型: int

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]]

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()，它将为此模型创建一个合适的默认训练数据集。

这个函数可以被多次调用来进行一些额外的训练。如果指定了 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，第一个预测点将自动设置为：
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。默认值：False
enable_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。外层列表遍历输入序列中的每个序列，内层列表包含每个序列的历史预测。

property input_chunk_length: int¶

返回类型: int

property likelihood: Optional[Likelihood]¶

返回类型: Optional[Likelihood, None]

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

返回

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

返回类型

lr_finder

property min_train_samples: int¶

训练模型的最小样本数。

返回类型: int

property model_created: bool¶

返回类型: bool

property model_params: dict¶

返回类型: dict

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 的horizon值，这些模型

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

此外（对于 DualCovariatesTorchModel 和 MixedCovariatesTorchModel），它们也

需要这些未来协变量的“历史”值（在过去 input_chunk_length 的范围内）。

参数

n (int) – 训练时间序列结束后，生成预测的时间步数
series (Union[TimeSeries, Sequence[TimeSeries], None]) – 可选地，一系列或一系列的序列，表示要预测其未来的目标序列的历史。如果指定，该方法返回这些序列的预测。否则，该方法返回（单一）训练序列的预测。
past_covariates (Union[TimeSeries, Sequence[TimeSeries], None]) – 可选地，过去观察到的协变量序列，作为模型的输入。它们在维度上必须与训练时使用的协变量匹配。
future_covariates (Union[TimeSeries, Sequence[TimeSeries], None]) – 可选地，模型所需的已知未来协变量序列作为输入。它们在维度上必须与用于训练的协变量匹配。
trainer (Optional[Trainer, None]) – 可选地，一个自定义的 PyTorch-Lightning Trainer 对象用于执行预测。使用自定义的 trainer 将覆盖 Darts 的默认训练器。
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) – 可选地，使用基于神经网络的模型进行预测时启用蒙特卡罗 dropout。这通过在学习的模型上指定一个隐含的先验来实现贝叶斯近似。
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。

参数

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) – 可选地，使用基于神经网络的模型进行预测时启用蒙特卡罗 dropout。这通过在学习的模型上指定一个隐含的先验来实现贝叶斯近似。
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_future_covariates: bool¶

模型是否支持未来协变量

返回类型: bool

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。

property uses_future_covariates: bool¶

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

返回类型: bool

property uses_past_covariates: bool¶

模型是否使用过去的协变量，一旦拟合。

返回类型: bool

property uses_static_covariates: bool¶

模型是否使用静态协变量，一旦拟合。

返回类型: bool

class darts.models.forecasting.tsmixer_model.TimeBatchNorm2d(*args, **kwargs)[源代码]¶

基类：BatchNorm2d

一个对张量的最后两个维度进行标准化的批量归一化层。

方法

`add_module`(name, module)	将一个子模块添加到当前模块。
`apply`(fn)	递归地将 `fn` 应用于每个子模块（由 `.children()` 返回）以及自身。
`bfloat16`()	将所有浮点参数和缓冲区转换为 `bfloat16` 数据类型。
`buffers`([recurse])	返回一个遍历模块缓冲区的迭代器。
`children`()	返回一个遍历直接子模块的迭代器。
`compile`(args, *kwargs)	使用 `torch.compile()` 编译此模块的 forward。
`cpu`()	将所有模型参数和缓冲区移动到CPU。
`cuda`([device])	将所有模型参数和缓冲区移动到GPU。
`double`()	将所有浮点型参数和缓冲区转换为 `double` 数据类型。
`eval`()	将模块设置为评估模式。
`extra_repr`()	设置模块的额外表示。
`float`()	将所有浮点型参数和缓冲区转换为 `float` 数据类型。
`forward`(x)	定义每次调用时执行的计算。
`get_buffer`(target)	如果 `target` 指定的缓冲区存在，则返回该缓冲区，否则抛出错误。
`get_extra_state`()	返回要包含在模块的 state_dict 中的任何额外状态。
`get_parameter`(target)	如果存在，则返回由 `target` 给出的参数，否则抛出错误。
`get_submodule`(target)	如果存在，返回由 `target` 指定的子模块，否则抛出错误。
`half`()	将所有浮点型参数和缓冲区转换为 `half` 数据类型。
`ipu`([device])	将所有模型参数和缓冲区移动到 IPU。
`load_state_dict`(state_dict[, strict, assign])	将参数和缓冲区从 `state_dict` 复制到此模块及其后代中。
`modules`()	返回网络中所有模块的迭代器。
`named_buffers`([prefix, recurse, ...])	返回一个模块缓冲区的迭代器，同时生成缓冲区的名称和缓冲区本身。
`named_children`()	返回一个遍历直接子模块的迭代器，生成模块的名称以及模块本身。
`named_modules`([memo, prefix, remove_duplicate])	返回一个遍历网络中所有模块的迭代器，同时生成模块的名称和模块本身。
`named_parameters`([prefix, recurse, ...])	返回一个模块参数的迭代器，同时生成参数的名称和参数本身。
`parameters`([recurse])	返回一个遍历模块参数的迭代器。
`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])	更改是否应在此模块的参数上记录自动梯度操作。
`set_extra_state`(state)	设置包含在加载的 state_dict 中的额外状态。
`share_memory`()	参见 `torch.Tensor.share_memory_()`。
`state_dict`(*args[, destination, prefix, ...])	返回一个包含模块整体状态引用的字典。
`to`(args, *kwargs)	移动和/或转换参数和缓冲区。
`to_empty`(*, device[, recurse])	将参数和缓冲区移动到指定设备，而不复制存储。
`train`([mode])	设置模块为训练模式。
`type`(dst_type)	将所有参数和缓冲区转换为 `dst_type`。
`xpu`([device])	将所有模型参数和缓冲区移动到XPU。
`zero_grad`([set_to_none])	重置所有模型参数的梯度。

__call__
重置参数
重置运行统计

T_destination¶: TypeVar(‘T_destination’, bound=Dict[str, Any]) 的别名

add_module(name, module)¶

将一个子模块添加到当前模块。

可以通过给定的名称将模块作为属性访问。

参数

name (str) – 子模块的名称。可以使用给定的名称从此模块访问子模块。
module (Module) – 要添加到模块中的子模块。

返回类型

None

affine: bool¶

apply(fn)¶

递归地将 fn 应用于每个子模块（由 .children() 返回）以及自身。

典型用途包括初始化模型的参数（另见 nn-init-doc）。

参数: fn (Module -> None) – 要应用于每个子模块的函数
返回: 自己
返回类型: Module

示例:

>>> @torch.no_grad()
>>> def init_weights(m):
>>>     print(m)
>>>     if type(m) == nn.Linear:
>>>         m.weight.fill_(1.0)
>>>         print(m.weight)
>>> net = nn.Sequential(nn.Linear(2, 2), nn.Linear(2, 2))
>>> net.apply(init_weights)
Linear(in_features=2, out_features=2, bias=True)
Parameter containing:
tensor([[1., 1.],
        [1., 1.]], requires_grad=True)
Linear(in_features=2, out_features=2, bias=True)
Parameter containing:
tensor([[1., 1.],
        [1., 1.]], requires_grad=True)
Sequential(
  (0): Linear(in_features=2, out_features=2, bias=True)
  (1): Linear(in_features=2, out_features=2, bias=True)
)

bfloat16()¶

将所有浮点参数和缓冲区转换为 bfloat16 数据类型。

备注

此方法就地修改模块。

返回: 自己
返回类型: Module

buffers(recurse=True)¶

返回一个遍历模块缓冲区的迭代器。

参数: recurse (bool) – 如果为真，则生成此模块及其所有子模块的缓冲区。否则，仅生成此模块的直接成员缓冲区。
生成器: torch.Tensor – 模块缓冲区

示例:

>>> # xdoctest: +SKIP("undefined vars")
>>> for buf in model.buffers():
>>>     print(type(buf), buf.size())
<class 'torch.Tensor'> (20L,)
<class 'torch.Tensor'> (20L, 1L, 5L, 5L)

返回类型: Iterator[Tensor]

call_super_init: bool = False¶

children()¶

返回一个遍历直接子模块的迭代器。

生成器: 模块 – 子模块
返回类型: Iterator[Module]

compile(*args, **kwargs)¶

使用 torch.compile() 编译此模块的 forward。

此模块的 __call__ 方法被编译，所有参数都按原样传递给 torch.compile()。

有关此函数的参数详情，请参阅 torch.compile()。

cpu()¶

将所有模型参数和缓冲区移动到CPU。

备注

此方法就地修改模块。

返回: 自己
返回类型: Module

cuda(device=None)¶

将所有模型参数和缓冲区移动到GPU。

这也会使关联的参数和缓冲区成为不同的对象。因此，如果模块将在GPU上进行优化时存在，则应在构造优化器之前调用它。

备注

此方法就地修改模块。

参数: device (int, optional) – 如果指定，所有参数将被复制到该设备
返回: 自己
返回类型: Module

double()¶

将所有浮点型参数和缓冲区转换为 double 数据类型。

备注

此方法就地修改模块。

返回: 自己
返回类型: Module

dump_patches: bool = False¶

eps: float¶

eval()¶

将模块设置为评估模式。

这仅对某些模块有影响。如果受到影响，请参阅特定模块的文档以了解其在训练/评估模式下的行为详情，例如 Dropout, BatchNorm 等。

这等同于 self.train(False)。

请参阅 locally-disable-grad-doc 以比较 .eval() 和几个可能与之混淆的类似机制。

返回: 自己
返回类型: Module

extra_repr()¶

设置模块的额外表示。

要打印自定义的额外信息，您应该在您自己的模块中重新实现此方法。单行和多行字符串都是可接受的。

float()¶

将所有浮点型参数和缓冲区转换为 float 数据类型。

备注

此方法就地修改模块。

返回: 自己
返回类型: Module

forward(x)[源代码]¶

定义每次调用时执行的计算。

应由所有子类重写。

备注

尽管前向传递的配方需要在此函数内定义，但应调用 Module 实例，而不是此函数，因为前者负责运行已注册的钩子，而后者则默默地忽略它们。

返回类型: Tensor

get_buffer(target)¶

如果 target 指定的缓冲区存在，则返回该缓冲区，否则抛出错误。

有关此方法功能的更详细说明以及如何正确指定 target，请参阅 get_submodule 的文档字符串。

参数: target (str) – 要查找的缓冲区的完全限定字符串名称。（有关如何指定完全限定字符串，请参见 get_submodule。）
返回: target 引用的缓冲区
返回类型: torch.Tensor
引发: AttributeError – 如果目标字符串引用了一个无效的路径或解析为不是缓冲区的内容

get_extra_state()¶

返回要包含在模块的 state_dict 中的任何额外状态。

如果需要存储额外状态，请在你的模块中实现此功能以及相应的 set_extra_state()。此函数在构建模块的 state_dict() 时被调用。

请注意，额外的状态应该是可pickle的，以确保state_dict的序列化工作。我们仅对序列化张量提供向后兼容性保证；如果其他对象的序列化pickle形式发生变化，它们可能会破坏向后兼容性。

返回: 模块的 state_dict 中存储的任何额外状态
返回类型: object

get_parameter(target)¶

如果存在，则返回由 target 给出的参数，否则抛出错误。

有关此方法功能的更详细说明以及如何正确指定 target，请参阅 get_submodule 的文档字符串。

参数: target (str) – 要查找的参数的全限定字符串名称。（关于如何指定全限定字符串，请参见 get_submodule。）
返回: target 引用的参数
返回类型: torch.nn.Parameter
引发: AttributeError – 如果目标字符串引用了一个无效的路径或解析为不是 nn.Parameter 的内容

get_submodule(target)¶

如果存在，返回由 target 指定的子模块，否则抛出错误。

例如，假设你有一个 nn.Module A ，它看起来像这样：

A(
    (net_b): Module(
        (net_c): Module(
            (conv): Conv2d(16, 33, kernel_size=(3, 3), stride=(2, 2))
        )
        (linear): Linear(in_features=100, out_features=200, bias=True)
    )
)

(该图展示了一个 nn.Module A。A 有一个嵌套的子模块 net_b，它本身有两个子模块 net_c 和 linear。net_c 然后有一个子模块 conv。)

要检查我们是否拥有 linear 子模块，我们会调用 get_submodule("net_b.linear")。要检查我们是否拥有 conv 子模块，我们会调用 get_submodule("net_b.net_c.conv")。

get_submodule 的运行时间受限于 target 中的模块嵌套程度。对 named_modules 的查询可以实现相同的结果，但它是 O(N) 的，其中 N 是传递模块的数量。因此，对于检查某个子模块是否存在的简单检查，应始终使用 get_submodule。

参数: target (str) – 要查找的子模块的完全限定字符串名称。（请参见上面的示例，了解如何指定完全限定的字符串。）
返回: 由 target 引用的子模块
返回类型: torch.nn.Module
引发: AttributeError – 如果目标字符串引用了一个无效的路径或解析为不是 nn.Module 的内容

half()¶

将所有浮点型参数和缓冲区转换为 half 数据类型。

备注

此方法就地修改模块。

返回: 自己
返回类型: Module

ipu(device=None)¶

将所有模型参数和缓冲区移动到 IPU。

这也会使关联的参数和缓冲区成为不同的对象。因此，如果模块将在IPU上进行优化，则应在构建优化器之前调用此方法。

备注

此方法就地修改模块。

参数: device (int, optional) – 如果指定，所有参数将被复制到该设备
返回: 自己
返回类型: Module

load_state_dict(state_dict, strict=True, assign=False)¶

将参数和缓冲区从 state_dict 复制到此模块及其后代中。

如果 strict 是 True，那么 state_dict 的键必须与该模块的 state_dict() 函数返回的键完全匹配。

警告

如果 assign 是 True，优化器必须在调用 load_state_dict 之后创建，除非 get_swap_module_params_on_conversion() 是 True。

参数

state_dict (dict) – 包含参数和持久缓冲区的字典。
strict (bool, optional) – 是否严格要求 state_dict 中的键与该模块的 state_dict() 函数返回的键匹配。默认值：True
assign (bool, optional) – 当 False 时，当前模块中张量的属性会被保留，而当 True 时，状态字典中张量的属性会被保留。唯一的例外是 Parameter 的 requires_grad 字段，该字段的值会从模块中保留。默认值：False

返回

missing_keys 是一个包含任何预期键的 str 列表
此模块中存在但未在提供的 state_dict 中出现的。
unexpected_keys 是一个包含未预料到的键的 str 列表。
此模块预期但未在提供的 state_dict 中出现。

返回类型

带有 missing_keys 和 unexpected_keys 字段的 NamedTuple

备注

如果一个参数或缓冲区被注册为 None ，并且其对应的键存在于 state_dict 中，load_state_dict() 将引发一个 RuntimeError 。

modules()¶

返回网络中所有模块的迭代器。

生成器: 模块 – 网络中的一个模块

备注

重复的模块只会返回一次。在下面的例子中，l 只会返回一次。

示例:

>>> l = nn.Linear(2, 2)
>>> net = nn.Sequential(l, l)
>>> for idx, m in enumerate(net.modules()):
...     print(idx, '->', m)

0 -> Sequential(
  (0): Linear(in_features=2, out_features=2, bias=True)
  (1): Linear(in_features=2, out_features=2, bias=True)
)
1 -> Linear(in_features=2, out_features=2, bias=True)

返回类型: Iterator[Module]

momentum: Optional[float]¶

named_buffers(prefix='', recurse=True, remove_duplicate=True)¶

返回一个模块缓冲区的迭代器，同时生成缓冲区的名称和缓冲区本身。

参数

prefix (str) – 要添加到所有缓冲区名称的前缀。
recurse (bool, optional) – 如果为 True，则生成此模块及其所有子模块的缓冲区。否则，仅生成此模块的直接成员缓冲区。默认为 True。
remove_duplicate (bool, optional) – 是否在结果中移除重复的缓冲区。默认为 True。

生成器

(str, torch.Tensor) – 包含名称和缓冲区的元组

示例:

>>> # xdoctest: +SKIP("undefined vars")
>>> for name, buf in self.named_buffers():
>>>     if name in ['running_var']:
>>>         print(buf.size())

返回类型: Iterator[Tuple[str, Tensor]]

named_children()¶

返回一个遍历直接子模块的迭代器，生成模块的名称以及模块本身。

生成器: (str, Module) – 包含名称和子模块的元组

示例:

>>> # xdoctest: +SKIP("undefined vars")
>>> for name, module in model.named_children():
>>>     if name in ['conv4', 'conv5']:
>>>         print(module)

返回类型: Iterator[Tuple[str, Module]]

named_modules(memo=None, prefix='', remove_duplicate=True)¶

返回一个遍历网络中所有模块的迭代器，同时生成模块的名称和模块本身。

参数

memo (Optional[Set[Module], None]) – 一个备忘录，用于存储已添加到结果中的模块集合
prefix (str) – 一个将添加到模块名称前的前缀
remove_duplicate (bool) – 是否在结果中移除重复的模块实例

生成器

(str, Module) – 名称和模块的元组

备注

重复的模块只会返回一次。在下面的例子中，l 只会返回一次。

示例:

>>> l = nn.Linear(2, 2)
>>> net = nn.Sequential(l, l)
>>> for idx, m in enumerate(net.named_modules()):
...     print(idx, '->', m)

0 -> ('', Sequential(
  (0): Linear(in_features=2, out_features=2, bias=True)
  (1): Linear(in_features=2, out_features=2, bias=True)
))
1 -> ('0', Linear(in_features=2, out_features=2, bias=True))

named_parameters(prefix='', recurse=True, remove_duplicate=True)¶

返回一个模块参数的迭代器，同时生成参数的名称和参数本身。

参数

prefix (str) – 要添加到所有参数名称前的前缀。
recurse (bool) – 如果为真，则生成此模块及其所有子模块的参数。否则，仅生成此模块的直接成员参数。
remove_duplicate (bool, optional) – 是否在结果中移除重复的参数。默认为 True。

生成器

(str, Parameter) – 包含名称和参数的元组

示例:

>>> # xdoctest: +SKIP("undefined vars")
>>> for name, param in self.named_parameters():
>>>     if name in ['bias']:
>>>         print(param.size())

返回类型: Iterator[Tuple[str, Parameter]]

num_features: int¶

parameters(recurse=True)¶

返回一个遍历模块参数的迭代器。

这通常传递给一个优化器。

参数: recurse (bool) – 如果为真，则生成此模块及其所有子模块的参数。否则，仅生成此模块的直接成员参数。
生成器: 参数 – 模块参数

示例:

>>> # xdoctest: +SKIP("undefined vars")
>>> for param in model.parameters():
>>>     print(type(param), param.size())
<class 'torch.Tensor'> (20L,)
<class 'torch.Tensor'> (20L, 1L, 5L, 5L)

返回类型: Iterator[Parameter]

register_backward_hook(hook)¶

在模块上注册一个反向钩子。

此函数已被 register_full_backward_hook() 取代，并且此函数的行为将在未来版本中发生变化。

返回: 一个可以通过调用 handle.remove() 来移除添加的钩子的句柄
返回类型: torch.utils.hooks.RemovableHandle

register_buffer(name, tensor, persistent=True)¶

向模块添加一个缓冲区。

这通常用于注册一个不应被视为模型参数的缓冲区。例如，BatchNorm 的 running_mean 不是参数，而是模块状态的一部分。缓冲区默认是持久的，并将与参数一起保存。可以通过将 persistent 设置为 False 来改变此行为。持久缓冲区和非持久缓冲区之间的唯一区别是后者不会成为此模块的 state_dict 的一部分。

缓冲区可以通过给定的名称作为属性访问。

参数

name (str) – 缓冲区的名称。可以通过给定的名称从此模块访问缓冲区。
tensor (Tensor or None) – 要注册的缓冲区。如果为 None ，则运行在缓冲区上的操作，例如 cuda ，将被忽略。如果为 None ，该缓冲区将不包含在模块的 state_dict 中。
persistent (bool) – 缓冲区是否是此模块的 state_dict 的一部分。

示例:

>>> # xdoctest: +SKIP("undefined vars")
>>> self.register_buffer('running_mean', torch.zeros(num_features))

返回类型: None

register_forward_hook(hook, *, prepend=False, with_kwargs=False, always_call=False)¶

在模块上注册一个前向钩子。

钩子将在每次 forward() 计算输出后被调用。

如果 with_kwargs 是 False 或未指定，输入仅包含传递给模块的位置参数。关键字参数不会传递给钩子，只会传递给 forward 。钩子可以修改输出。它可以就地修改输入，但这不会影响前向传播，因为这是在调用 forward() 之后调用的。钩子应具有以下签名:

hook(module, args, output) -> None or modified output

如果 with_kwargs 是 True，前向钩子将被传递给前向函数的 kwargs，并期望返回可能被修改的输出。钩子应具有以下签名:

hook(module, args, kwargs, output) -> None or modified output

参数

hook (Callable) – 要注册的用户定义钩子。
prepend (bool) – 如果 True，提供的 hook 将在该 torch.nn.modules.Module 上的所有现有 forward 钩子之前触发。否则，提供的 hook 将在该 torch.nn.modules.Module 上的所有现有 forward 钩子之后触发。请注意，使用 register_module_forward_hook() 注册的全局 forward 钩子将在通过此方法注册的所有钩子之前触发。默认值：False
with_kwargs (bool) – 如果 True，hook 将会传递给 forward 函数的 kwargs。默认值：False
always_call (bool) – 如果 True ，无论在调用模块时是否引发异常，都将运行 hook 。默认值： False

返回

一个可以通过调用 handle.remove() 来移除添加的钩子的句柄

返回类型

torch.utils.hooks.RemovableHandle

register_forward_pre_hook(hook, *, prepend=False, with_kwargs=False)¶

在模块上注册一个前向预钩子。

钩子将在每次调用 forward() 之前被调用。

如果 with_kwargs 为假或未指定，输入仅包含传递给模块的位置参数。关键字参数不会传递给钩子，只会传递给 forward。钩子可以修改输入。用户可以在钩子中返回一个元组或单个修改后的值。如果返回单个值（除非该值已经是元组），我们将把该值包装成一个元组。钩子应具有以下签名:

hook(module, args) -> None or modified input

如果 with_kwargs 为真，前向预钩子将传递给前向函数的 kwargs。如果钩子修改了输入，则应返回 args 和 kwargs。钩子应具有以下签名:

hook(module, args, kwargs) -> None or a tuple of modified input and kwargs

参数

hook (Callable) – 要注册的用户定义钩子。
prepend (bool) – 如果为真，提供的 hook 将在该 torch.nn.modules.Module 上所有现有的 forward_pre 钩子之前触发。否则，提供的 hook 将在该 torch.nn.modules.Module 上所有现有的 forward_pre 钩子之后触发。请注意，通过 register_module_forward_pre_hook() 注册的全局 forward_pre 钩子将在所有通过此方法注册的钩子之前触发。默认值：False
with_kwargs (bool) – 如果为真，hook 将被传递给 forward 函数的 kwargs。默认值：False

返回

一个可以通过调用 handle.remove() 来移除添加的钩子的句柄

返回类型

torch.utils.hooks.RemovableHandle

register_full_backward_hook(hook, prepend=False)¶

在模块上注册一个反向钩子。

每次计算与模块相关的梯度时，钩子都会被调用，即当且仅当计算与模块输出相关的梯度时，钩子才会执行。钩子应具有以下签名:

hook(module, grad_input, grad_output) -> tuple(Tensor) or None

The grad_input 和 grad_output 是包含相对于输入和输出的梯度的元组。钩子不应修改其参数，但可以选择返回一个新的相对于输入的梯度，该梯度将用于替代 grad_input 在后续计算中。grad_input 将仅对应于作为位置参数给出的输入，所有 kwarg 参数都将被忽略。grad_input 和 grad_output 中的条目将为 None 用于所有非 Tensor 参数。

出于技术原因，当此钩子应用于模块时，其前向函数将接收传递给模块的每个张量的视图。同样，调用者将接收模块前向函数返回的每个张量的视图。

警告

在使用反向钩子时，不允许就地修改输入或输出，否则将引发错误。

参数

hook (Callable) – 要注册的用户定义钩子。
prepend (bool) – 如果为真，提供的 hook 将在该 torch.nn.modules.Module 上所有现有的 backward 钩子之前触发。否则，提供的 hook 将在该 torch.nn.modules.Module 上所有现有的 backward 钩子之后触发。请注意，通过 register_module_full_backward_hook() 注册的全局 backward 钩子将在通过此方法注册的所有钩子之前触发。

返回

一个可以通过调用 handle.remove() 来移除添加的钩子的句柄

返回类型

torch.utils.hooks.RemovableHandle

register_full_backward_pre_hook(hook, prepend=False)¶

在模块上注册一个反向预钩子。

每次计算模块的梯度时，都会调用该钩子。钩子应具有以下签名:

hook(module, grad_output) -> tuple[Tensor] or None

The grad_output 是一个元组。钩子不应修改其参数，但它可以选择返回一个新的相对于输出的梯度，该梯度将用于替代 grad_output 在后续计算中。grad_output 中的条目对于所有非 Tensor 参数将为 None。

出于技术原因，当此钩子应用于模块时，其前向函数将接收传递给模块的每个张量的视图。同样，调用者将接收模块前向函数返回的每个张量的视图。

警告

在使用反向钩子时，不允许就地修改输入，否则将引发错误。

参数

hook (Callable) – 要注册的用户定义钩子。
prepend (bool) – 如果为真，提供的 hook 将在该 torch.nn.modules.Module 上的所有现有 backward_pre 钩子之前触发。否则，提供的 hook 将在该 torch.nn.modules.Module 上的所有现有 backward_pre 钩子之后触发。请注意，通过 register_module_full_backward_pre_hook() 注册的全局 backward_pre 钩子将在通过此方法注册的所有钩子之前触发。

返回

一个可以通过调用 handle.remove() 来移除添加的钩子的句柄

返回类型

torch.utils.hooks.RemovableHandle

register_load_state_dict_post_hook(hook)¶

注册一个在模块的 load_state_dict 调用后运行的后置钩子。

它应该有以下签名:: hook(module, incompatible_keys) -> None

module 参数是当前注册此钩子的模块，而 incompatible_keys 参数是一个由属性 missing_keys 和 unexpected_keys 组成的 NamedTuple。missing_keys 是一个包含缺失键的 str 的 list，而 unexpected_keys 是一个包含意外键的 str 的 list。

如果需要，可以就地修改给定的 incompatible_keys。

请注意，当使用 strict=True 调用 load_state_dict() 时执行的检查会受到钩子对 missing_keys 或 unexpected_keys 所做修改的影响，这是预期的。对任一组键的添加将导致在 strict=True 时抛出错误，而清除掉缺失和意外的键将避免错误。

返回: 一个可以通过调用 handle.remove() 来移除添加的钩子的句柄
返回类型: torch.utils.hooks.RemovableHandle

register_module(name, module)¶

别名 add_module()。

返回类型: None

register_parameter(name, param)¶

向模块添加一个参数。

该参数可以通过给定的名称作为属性访问。

参数

name (str) – 参数的名称。可以使用给定的名称从此模块访问该参数。
param (Parameter or None) – 要添加到模块的参数。如果为 None ，则运行在参数上的操作，例如 cuda ，将被忽略。如果为 None ，该参数将不包含在模块的 state_dict 中。

返回类型

None

register_state_dict_pre_hook(hook)¶

为 state_dict() 方法注册一个预钩子。

这些钩子将在调用 self 上的 state_dict 之前，使用参数 self、prefix 和 keep_vars 进行调用。注册的钩子可以用于在调用 state_dict 之前执行预处理。

requires_grad_(requires_grad=True)¶

更改是否应在此模块的参数上记录自动梯度操作。

此方法就地设置参数的 requires_grad 属性。

这种方法有助于冻结模块的一部分以进行微调或单独训练模型的一部分（例如，GAN训练）。

请参阅 locally-disable-grad-doc 以比较 .requires_grad_() 和几个可能与之混淆的类似机制。

参数: requires_grad (bool) – 是否应在此模块的参数上记录自动求导操作。默认值：True。
返回: 自己
返回类型: Module

reset_parameters()¶

返回类型: None

reset_running_stats()¶

返回类型: None

set_extra_state(state)¶

设置包含在加载的 state_dict 中的额外状态。

此函数从 load_state_dict() 调用，以处理在 state_dict 中找到的任何额外状态。如果你的模块需要在 state_dict 中存储额外状态，请实现此函数以及相应的 get_extra_state()。

参数: state (dict) – 来自 state_dict 的额外状态
返回类型: None

share_memory()¶

参见 torch.Tensor.share_memory_()。

返回类型: ~T

state_dict(*args, destination=None, prefix='', keep_vars=False)¶

返回一个包含模块整体状态引用的字典。

参数和持久缓冲区（例如运行平均值）都包含在内。键是对应的参数和缓冲区名称。设置为 None 的参数和缓冲区不包含在内。

备注

返回的对象是一个浅拷贝。它包含对模块参数和缓冲区的引用。

警告

目前，state_dict() 也按顺序接受 destination、prefix 和 keep_vars 的位置参数。然而，这正在被弃用，未来版本将强制使用关键字参数。

警告

请避免使用参数 destination，因为它不是为最终用户设计的。

参数

destination (dict, optional) – 如果提供了，模块的状态将被更新到字典中，并返回相同的对象。否则，将创建并返回一个 OrderedDict。默认值：None。
prefix (str, optional) – 在 state_dict 中组合键时添加到参数和缓冲区名称的前缀。默认值：''。
keep_vars (bool, optional) – 默认情况下，状态字典中返回的 Tensor 是与自动求导分离的。如果设置为 True，则不会执行分离操作。默认值：False。

返回

包含模块整个状态的字典

返回类型

dict

示例:

>>> # xdoctest: +SKIP("undefined vars")
>>> module.state_dict().keys()
['bias', 'weight']

to(*args, **kwargs)¶

移动和/或转换参数和缓冲区。

这可以被称为

to(device=None, dtype=None, non_blocking=False)

to(dtype, non_blocking=False)

to(tensor, non_blocking=False)

to(memory_format=torch.channels_last)

它的签名类似于 torch.Tensor.to() ，但只接受浮点数或复数的 dtype 。此外，此方法只会将浮点数或复数参数和缓冲区转换为 dtype （如果给出）。整数参数和缓冲区将被移动到 device ，如果给出，但数据类型保持不变。当 non_blocking 被设置时，它会尝试尽可能地异步转换/移动，例如，将具有固定内存的CPU张量移动到CUDA设备。

请参见以下示例。

备注

此方法就地修改模块。

参数

device (torch.device) – 此模块中参数和缓冲区的所需设备
dtype (torch.dtype) – 此模块中参数和缓冲区的所需浮点数或复数数据类型
tensor (torch.Tensor) – 张量的dtype和设备是此模块中所有参数和缓冲区的期望dtype和设备
memory_format (torch.memory_format) – 此模块中4D参数和缓冲区的所需内存格式（仅关键字参数）

返回

自己

返回类型

Module

示例:

>>> # xdoctest: +IGNORE_WANT("non-deterministic")
>>> linear = nn.Linear(2, 2)
>>> linear.weight
Parameter containing:
tensor([[ 0.1913, -0.3420],
        [-0.5113, -0.2325]])
>>> linear.to(torch.double)
Linear(in_features=2, out_features=2, bias=True)
>>> linear.weight
Parameter containing:
tensor([[ 0.1913, -0.3420],
        [-0.5113, -0.2325]], dtype=torch.float64)
>>> # xdoctest: +REQUIRES(env:TORCH_DOCTEST_CUDA1)
>>> gpu1 = torch.device("cuda:1")
>>> linear.to(gpu1, dtype=torch.half, non_blocking=True)
Linear(in_features=2, out_features=2, bias=True)
>>> linear.weight
Parameter containing:
tensor([[ 0.1914, -0.3420],
        [-0.5112, -0.2324]], dtype=torch.float16, device='cuda:1')
>>> cpu = torch.device("cpu")
>>> linear.to(cpu)
Linear(in_features=2, out_features=2, bias=True)
>>> linear.weight
Parameter containing:
tensor([[ 0.1914, -0.3420],
        [-0.5112, -0.2324]], dtype=torch.float16)

>>> linear = nn.Linear(2, 2, bias=None).to(torch.cdouble)
>>> linear.weight
Parameter containing:
tensor([[ 0.3741+0.j,  0.2382+0.j],
        [ 0.5593+0.j, -0.4443+0.j]], dtype=torch.complex128)
>>> linear(torch.ones(3, 2, dtype=torch.cdouble))
tensor([[0.6122+0.j, 0.1150+0.j],
        [0.6122+0.j, 0.1150+0.j],
        [0.6122+0.j, 0.1150+0.j]], dtype=torch.complex128)

to_empty(*, device, recurse=True)¶

将参数和缓冲区移动到指定设备，而不复制存储。

参数

device (torch.device) – 此模块中参数和缓冲区的所需设备。
recurse (bool) – 子模块的参数和缓冲区是否应递归地移动到指定设备。

返回

自己

返回类型

Module

track_running_stats: bool¶

train(mode=True)¶

设置模块为训练模式。

这仅对某些模块有影响。如果受到影响，请参阅特定模块的文档以了解其在训练/评估模式下的行为详情，例如 Dropout, BatchNorm 等。

参数: mode (bool) – 是否设置训练模式（True）或评估模式（False）。默认值：True。
返回: 自己
返回类型: Module

training: bool¶

type(dst_type)¶

将所有参数和缓冲区转换为 dst_type。

备注

此方法就地修改模块。

参数: dst_type (type or string) – 所需类型
返回: 自己
返回类型: Module

xpu(device=None)¶

将所有模型参数和缓冲区移动到XPU。

这也会使关联的参数和缓冲区成为不同的对象。因此，如果模块将在 XPU 上进行优化，则应在构建优化器之前调用此方法。

备注

此方法就地修改模块。

参数: device (int, optional) – 如果指定，所有参数将被复制到该设备
返回: 自己
返回类型: Module

zero_grad(set_to_none=True)¶

重置所有模型参数的梯度。

更多上下文请参见 torch.optim.Optimizer 下的类似函数。

参数: set_to_none (bool) – 而不是设置为零，将梯度设置为 None。详情请参阅 torch.optim.Optimizer.zero_grad()。
返回类型: None

Transformer 模型

VARIMA