时间序列混合器 (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)[source]¶

基类: 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) – 特征混合 MLP 中第一个前馈层的大小。
num_blocks (int) – 模型中混合器块的数量。该数量包括第一个块和所有后续块。
activation (str) – 在混合器层中使用的激活函数（默认为=’ReLU’）。支持的激活函数：[‘ReLU’, ‘RReLU’, ‘PReLU’, ‘ELU’, ‘Softplus’, ‘Tanh’, ‘SELU’, ‘LeakyReLU’, ‘Sigmoid’, ‘GELU’]
dropout (float) – 受 dropout 影响的神经元比例。这与推理时的 Monte Carlo dropout 兼容，用于模型不确定性估计（在预测时使用 mc_dropout=True 启用）。
norm_type (Union[str, Module]) – 要使用的 LayerNorm 变体类型。默认值：“LayerNorm”。如果为字符串，必须是 “LayerNormNoBias”, “LayerNorm”, “TimeBatchNorm2d” 之一。否则，必须是自定义 nn.Module。
normalize_before (bool) – 是否在混合器层之前或之后应用层归一化。
use_static_covariates (bool) – 在传递给 fit() 的输入 series 包含静态协变量的情况下，模型是否应使用静态协变量信息。如果为 True，且在拟合时静态协变量可用，则会强制所有目标 series 在 fit() 和 predict() 中具有相同的静态协变量维度。
**kwargs – 用于初始化 pytorch_lightning.Module, pytorch_lightning.Trainer 和 Darts’ TorchForecastingModel 的可选参数。
loss_fn – 用于训练的 PyTorch 损失函数。如果指定了 likelihood 参数，则对于概率模型将忽略此参数。默认值：torch.nn.MSELoss()。
likelihood – Darts’ Likelihood 模型之一，用于概率预测。默认值：None。
torch_metrics – 用于评估的 torch 指标或 MetricCollection。可用的完整指标列表可在 https://torchmetrics.readthedocs.io/en/latest/ 找到。默认值：None。
optimizer_cls – 要使用的 PyTorch 优化器类。默认值：torch.optim.Adam。
optimizer_kwargs – 可选地，PyTorch 优化器的一些关键字参数（例如，{'lr': 1e-3} 用于指定学习率）。否则，将使用所选 optimizer_cls 的默认值。默认值：None。
lr_scheduler_cls – 可选地，要使用的 PyTorch 学习率调度器类。指定 None 对应于使用恒定的学习率。默认值：None。
lr_scheduler_kwargs – 可选地，PyTorch 学习率调度器的一些关键字参数。默认值：None。
use_reversible_instance_norm – 是否使用可逆实例归一化 RINorm 来应对分布偏移，如 [3]_ 中所示。它仅应用于目标系列的特征，而不应用于协变量。
batch_size – 每次训练中使用的（输入和输出序列）时间序列数量。默认值：32。
n_epochs – 训练模型的 epoch 数。默认值：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 – 在评估验证损失之前等待的 epoch 数（如果将验证 TimeSeries 传递给 fit() 方法）。默认值：1。
force_reset – 如果设置为 True，任何先前存在的同名模型将被重置（所有检查点将被丢弃）。默认值：False。
save_checkpoints – 是否自动保存未训练的模型和训练检查点。要从检查点加载模型，请调用 MyModelClass.load_from_checkpoint()，其中 MyModelClass 是使用的 TorchForecastingModel 类（例如 TFTModel, NBEATSModel 等）。如果设置为 False，仍可以使用 save() 手动保存模型，并使用 load() 加载。默认值：False。
add_encoders –
可以使用 add_encoders 自动生成大量过去和未来协变量。这可以通过添加多个预定义的索引编码器和/或将用作索引编码器的自定义用户生成函数来完成。此外，可以添加 Darts’ Scaler 等转换器来转换生成的协变量。这一切都在一个框架下发生，只需在创建模型时指定。阅读 SequentialEncoder 以了解更多关于 add_encoders 的信息。默认值：None。显示 add_encoders 某些功能的一个示例
```
def encode_year(idx):
    return (idx.year - 1950) / 50

add_encoders={
    'cyclic': {'future': ['month']},
    'datetime_attribute': {'future': ['hour', 'dayofweek']},
    'position': {'past': ['relative'], 'future': ['relative']},
    'custom': {'past': [encode_year]},
    'transformer': Scaler(),
    'tz': 'CET'
}
```
random_state – 控制权重初始化的随机性。查看此链接获取更多详细信息。默认值：None。
pl_trainer_kwargs –
默认情况下 TorchForecastingModel 使用 PyTorch Lightning Trainer 创建一个具有多个有用预设的训练器，执行训练、验证和预测过程。这些预设包括自动检查点、torch.Tensorboard 日志记录、设置 torch 设备等。使用 pl_trainer_kwargs，您可以添加额外的 kwargs 来实例化 PyTorch Lightning 训练器对象。查看 PL Trainer 文档了解有关支持的 kwargs 的更多信息。默认值：None。通过指定键 "accelerator", "devices", and "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
```
from pytorch_lightning.callbacks.early_stopping import EarlyStopping

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

pl_trainer_kwargs={"callbacks": [my_stopper]}
```
请注意，您也可以在 fit() 和 predict() 中使用可选参数 trainer 来使用自定义 PyTorch Lightning Trainer 进行训练和预测。
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 元组：(min target lag, max target lag, min past covariate lag, max past covariate lag, min future covariate lag, max future covariate lag, output shift, max target lag train (仅适用于 RNNModel))。
`likelihood`	返回模型用于概率预测的似然函数（如果存在）。
`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_transferable_series_prediction`	模型是否支持对任何输入 series 进行预测。
`uses_future_covariates`	模型拟合后是否使用未来协变量。
`uses_past_covariates`	模型拟合后是否使用过去协变量。
`uses_static_covariates`	模型拟合后是否使用静态协变量。

epochs_trained
input_chunk_length
model_created
model_params

方法

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

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

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

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

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

可以使用 metric_kwargs 进一步自定义指标（例如，控制跨组件、时间步、多个 series 的聚合，其他必需参数如分位数指标的 q，…）。

参数

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

向未来偏移 output_chunk_shift 个点。
注意：如果 start 超出可能进行历史预测的时间范围，则将忽略该参数

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

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

返回值

float – 单个单变量/多变量 series、单个 metric 函数和

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

bool

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

Union[float, ndarray, list[float], list[ndarray]]: property epochs_trained: int¶

int

Union[float, ndarray, list[float], list[ndarray]]: property extreme_lags: tuple[Optional[int], Optional[int], Optional[int], Optional[int], Optional[int], Optional[int], int, Optional[int]]¶

一个包含按顺序的 8 元组：(min target lag, max target lag, min past covariate lag, max past covariate lag, min future covariate lag, max future covariate lag, output shift, max target lag train (仅适用于 RNNModel))。如果 0 是第一个预测的索引，则所有滞后都相对于此索引。

参见下面的示例。

如果模型未拟合以下内容：

目标（仅针对 RegressionModels）：则第一个元素应为 None。

过去协变量：则第三和第四个元素应为 None。
未来协变量：则第五和第六个元素应为 None。
应由使用过去或未来协变量的模型，和/或最小目标滞后和最大目标滞后可能与 -1 和 0 不同的模型覆盖。

注意

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

tuple[Optional[int, None], Optional[int, None], Optional[int, None], Optional[int, None], Optional[int, None], Optional[int, None], int, Optional[int, None]]

示例

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

Union[float, ndarray, list[float], list[ndarray]]: 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() 的包装器，为本模型构建一个默认的训练数据集。如果您需要更多地控制如何切分 series 进行训练，请考虑使用自定义的 darts.utils.data.TrainingDataset 调用 fit_from_dataset()。

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

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

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

可以多次调用此函数以进行额外的训练。如果指定了 epochs，则模型将额外训练 epochs 个 epoch。

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

在处理协变量时，Darts 会尝试使用目标序列和协变量的时间轴来生成正确的时间切片。因此，协变量可以比实际需要更长；只要时间轴正确，Darts 就能正确处理它们。如果它们的时间跨度不足，Darts 也会报错。

参数

series (Union[TimeSeries, Sequence[TimeSeries]]) – 用作目标的序列或序列列表（即模型将训练预测的内容）
past_covariates (Union[TimeSeries, Sequence[TimeSeries], None]) – 可选参数，指定历史观测协变量的序列或序列列表
future_covariates (Union[TimeSeries, Sequence[TimeSeries], None]) – 可选参数，指定未来已知协变量的序列或序列列表
val_series (Union[TimeSeries, Sequence[TimeSeries], None]) – 可选参数，一个或一组验证目标序列，用于在训练期间计算验证损失并跟踪表现最佳的模型。
val_past_covariates (Union[TimeSeries, Sequence[TimeSeries], None]) – 可选参数，与验证序列对应的历史协变量（必须与 covariates 匹配）
val_future_covariates (Union[TimeSeries, Sequence[TimeSeries], None]) – 可选参数，与验证序列对应的未来协变量（必须与 covariates 匹配）
val_sample_weight (Union[TimeSeries, Sequence[TimeSeries], str, None]) – 与 sample_weight 相同，但用于评估数据集。
trainer (Optional[Trainer, None]) – 可选参数，用于执行训练的自定义 PyTorch-Lightning Trainer 对象。使用自定义 trainer 将覆盖 Darts 的默认 trainer。
verbose (Optional[bool, None]) – 是否打印训练进度。如果 pl_trainer_kwargs 中存在 ProgressBar 回调，则忽略此参数。
epochs (int) – 如果指定，将训练模型 epochs 个（额外）epoch，无论在模型构造函数中提供了什么 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 相同，但用于评估数据集。

float – 单个单变量/多变量 series、单个 metric 函数和

已拟合的模型。

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

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 个 epoch。

参数

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

float – 单个单变量/多变量 series、单个 metric 函数和

已拟合的模型。

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

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]) – 可选参数，拟合模型时使用的未来已知协变量的序列或序列列表。

float – 单个单变量/多变量 series、单个 metric 函数和

一个元组，包含（历史协变量，未来协变量）。每个协变量都包含原始协变量和编码后的协变量。

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

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]) – 可选参数，打算用于预测的未来已知协变量序列。维度必须与用于训练的协变量匹配。

float – 单个单变量/多变量 series、单个 metric 函数和

一个元组，包含（历史协变量，未来协变量）。每个协变量都包含原始协变量和编码后的协变量。

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

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]) – 可选参数，打算用于预测的未来已知协变量序列。维度必须与用于训练的协变量匹配。

float – 单个单变量/多变量 series、单个 metric 函数和

一个元组，包含（历史协变量，未来协变量）。每个协变量都包含原始协变量和编码后的协变量。

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

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

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

使用网格搜索在一组给定参数中找到最佳超参数。

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

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

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

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

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

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

目前此方法仅支持确定性预测（即模型预测仅包含 1 个样本）。

参数

model_class – 要为 '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，第一个预测点将自动设置为
- 第一个可预测点（如果 retrain 为 False，或者 retrain 是一个 Callable 且第一个可预测点早于第一个可训练点）。
- 如果 retrain 为 True 或 int（给定 train_length），则为第一个可训练点；如果 retrain 是一个可调用对象且第一个可训练点早于第一个可预测点，则为第一个可训练点。
- 否则为第一个可训练点 (给定 train_length)。
注意：如果 start 不在可训练/可预测点范围内，将使用距离 start 最近的、是 stride 整倍数的有效起始点。如果不存在有效起始点，则引发 ValueError。
注意：如果模型使用偏移输出（output_chunk_shift > 0），则第一个预测点也会

向未来偏移 output_chunk_shift 个点。
注意：如果 start 超出可能进行历史预测的时间范围，则将忽略该参数

（使用 None 时的默认行为），并从第一个可训练/可预测点开始。
start_format (Literal[‘position’, ‘value’]) – 定义 start 的格式。如果设置为 'position'，则 start 对应于第一个预测点的索引位置，范围从 (-len(series), len(series) - 1)。如果设置为 'value'，则 start 对应于第一个预测点的索引值/标签。如果该值不在 series 的索引中，将引发错误。默认值：'value'。
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，此时将忽略随机选择。
可选地，一个 BaseDataTransformer 或 Pipeline 字典，用于应用于相应的 series（可能的键：“series”、“past_covariates”、“future_covariates”）。如果提供，所有输入 series 必须位于未转换的空间中。对于可拟合的转换器/流水线
如果 retrain=True，则在每个历史预测步骤中重新拟合数据转换器。
- 如果 retrain=False，则数据转换器在所有预测之前转换 series 一次。
- 拟合的转换器用于在训练和预测期间转换输入。如果转换可逆，则预测将被反向转换。仅当 historical_forecasts=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” 衰减 - 越远的过去，权重越低。

float – 单个单变量/多变量 series、单个 metric 函数和

一个元组，包含由最佳超参数创建的未训练 model_class 实例、包含这些最佳超参数的字典，以及最佳超参数的度量分数。

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

ForecastingModel, Dict, float

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

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

此方法有两种主要模式：

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

通过选择适当的模式，可以在计算效率和更新模型训练的需求之间取得平衡。

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

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

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

参数

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

向未来偏移 output_chunk_shift 个点。
注意：如果 start 超出可能进行历史预测的时间范围，则将忽略该参数

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

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

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

float – 单个单变量/多变量 series、单个 metric 函数和

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¶

Union[float, ndarray, list[float], list[ndarray]]: property extreme_lags: tuple[Optional[int], Optional[int], Optional[int], Optional[int], Optional[int], Optional[int], int, Optional[int]]¶

property likelihood: Optional[TorchLikelihood]¶

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

Union[float, ndarray, list[float], list[ndarray]]: Optional[TorchLikelihood, None]

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

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

RNNModel 的通用加载示例

from darts.models import RNNModel

model_loaded = RNNModel.load(path)

将 CPU 上训练的 RNNModel 加载到 GPU 的示例

from darts.models import RNNModel

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

将 GPU 上保存的 RNNModel 加载到 CPU 的示例

from darts.models import RNNModel

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

参数

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

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

TorchForecastingModel

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

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

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

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

from darts.models import RNNModel

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

如果给定了 file_name，则返回保存在‘{work_dir}/darts_logs/{model_name}/checkpoints/{file_name}’下的模型。

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

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

from darts.models import RNNModel

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

参数

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

float – 单个单变量/多变量 series、单个 metric 函数和

相应的已训练 TorchForecastingModel。

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

TorchForecastingModel

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

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

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

参数

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

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

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

要恢复中断的训练，请考虑使用 load_from_checkpoint()，它也会重新加载 trainer、优化器和学习率调度器的状态。

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

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

参数

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

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

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

使用 RNNModel 的示例

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

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

参数

series (Union[TimeSeries, Sequence[TimeSeries]]) – 用作目标的序列或序列列表（即模型将训练预测的内容）
past_covariates (Union[TimeSeries, Sequence[TimeSeries], None]) – 可选参数，指定历史观测协变量的序列或序列列表
future_covariates (Union[TimeSeries, Sequence[TimeSeries], None]) – 可选参数，指定未来已知协变量的序列或序列列表
val_series (Union[TimeSeries, Sequence[TimeSeries], None]) – 可选参数，一个或一组验证目标序列，用于在训练期间计算验证损失并跟踪表现最佳的模型。
val_past_covariates (Union[TimeSeries, Sequence[TimeSeries], None]) – 可选参数，与验证序列对应的历史协变量（必须与 covariates 匹配）
val_future_covariates (Union[TimeSeries, Sequence[TimeSeries], None]) – 可选参数，与验证序列对应的未来协变量（必须与 covariates 匹配）
sample_weight (Union[TimeSeries, Sequence[TimeSeries], str, None]) – 可选参数，应用于目标 series 标签的样本权重。它们应用于每个观测、每个标签（output_chunk_length 中的每一步）和每个组件。如果是一个序列或序列列表，则使用这些权重。如果权重序列只有一个组件/列，则权重全局应用于 series 中的所有组件。否则，对于组件特定权重，组件数量必须与 series 匹配。如果是一个字符串，则使用内置的权重函数生成权重。可用选项是 “linear” 或 “exponential” 衰减 - 越远的过去，权重越低。权重基于 series 中最长序列的长度全局计算。然后对于每个序列，从全局权重的末尾提取权重。这为所有序列提供了共同的时间权重。
val_sample_weight (Union[TimeSeries, Sequence[TimeSeries], str, None]) – 与 sample_weight 相同，但用于评估数据集。
trainer (Optional[Trainer, None]) – 可选参数，用于执行训练的自定义 PyTorch-Lightning Trainer 对象。使用自定义 trainer 将覆盖 Darts 的默认 trainer。
verbose (Optional[bool, None]) – 是否打印训练进度。如果 pl_trainer_kwargs 中存在 ProgressBar 回调，则忽略此参数。
epochs (int) – 如果指定，将训练模型 epochs 个（额外）epoch，无论在模型构造函数中提供了什么 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

float – 单个单变量/多变量 series、单个 metric 函数和

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

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

lr_finder

property min_train_samples: int¶

训练模型所需的最小样本数。

Union[float, ndarray, list[float], list[ndarray]]: property extreme_lags: tuple[Optional[int], Optional[int], Optional[int], Optional[int], Optional[int], Optional[int], int, Optional[int]]¶

property model_created: bool¶

Union[float, ndarray, list[float], list[ndarray]]: property epochs_trained: int¶

property model_params: dict¶

Union[float, ndarray, list[float], list[ndarray]]: dict

property output_chunk_length: int¶

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

Union[float, ndarray, list[float], list[ndarray]]: property extreme_lags: tuple[Optional[int], Optional[int], Optional[int], Optional[int], Optional[int], Optional[int], int, Optional[int]]¶

property output_chunk_shift: int¶

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

Union[float, ndarray, list[float], list[ndarray]]: property extreme_lags: tuple[Optional[int], Optional[int], Optional[int], Optional[int], Optional[int], Optional[int], int, Optional[int]]¶

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

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

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

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

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

依赖过去协变量的模型在预测时需要知道 past_covariates 的最后 input_chunk_length 个

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

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

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

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

参数

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

float – 单个单变量/多变量 series、单个 metric 函数和

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

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

Union[TimeSeries, Sequence[TimeSeries]]

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

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

参数

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

float – 单个单变量/多变量 series、单个 metric 函数和

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

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

Sequence[TimeSeries]

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

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

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

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

按顺序，此方法执行

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

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

参数

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

向未来偏移 output_chunk_shift 个点。
注意：如果 start 超出可能进行历史预测的时间范围，则将忽略该参数

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

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

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

float – 单个单变量/多变量 series、单个 metric 函数和

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

save(path=None, clean=False)¶

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

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

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

保存和加载 RNNModel 的示例

from darts.models import RNNModel

model = RNNModel(input_chunk_length=4)

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

参数

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

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

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

None

property supports_future_covariates: bool¶

模型是否支持未来协变量

Union[float, ndarray, list[float], list[ndarray]]: property epochs_trained: int¶

property supports_likelihood_parameter_prediction: bool¶

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

Union[float, ndarray, list[float], list[ndarray]]: property epochs_trained: int¶

property supports_multivariate: bool¶

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

Union[float, ndarray, list[float], list[ndarray]]: property epochs_trained: int¶

property supports_optimized_historical_forecasts: bool¶

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

Union[float, ndarray, list[float], list[ndarray]]: property epochs_trained: int¶

property supports_past_covariates: bool¶

模型是否支持过去协变量

Union[float, ndarray, list[float], list[ndarray]]: property epochs_trained: int¶

property supports_probabilistic_prediction: bool¶

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

默认返回 `False`。需要支持概率预测的模型覆盖此方法。

Union[float, ndarray, list[float], list[ndarray]]: property epochs_trained: int¶

property supports_sample_weight: bool¶

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

Union[float, ndarray, list[float], list[ndarray]]: property epochs_trained: int¶

property supports_static_covariates: bool¶

模型是否支持静态协变量

Union[float, ndarray, list[float], list[ndarray]]: property epochs_trained: int¶

property supports_transferable_series_prediction: bool¶

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

Union[float, ndarray, list[float], list[ndarray]]: property epochs_trained: int¶

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

to_onnx(path=None, **kwargs)¶

将模型导出到 ONNX 格式以优化推理，封装了 PyTorch Lightning 的 torch.onnx.export() 方法（官方文档）。

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

导出 DLinearModel 的示例

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

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

参数

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

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

property uses_future_covariates: bool¶

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

Union[float, ndarray, list[float], list[ndarray]]: property epochs_trained: int¶

property uses_past_covariates: bool¶

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

Union[float, ndarray, list[float], list[ndarray]]: property epochs_trained: int¶

property uses_static_covariates: bool¶

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

Union[float, ndarray, list[float], list[ndarray]]: property epochs_trained: int¶

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

基类：BatchNorm2d

一个批归一化层，对 Tensor 的最后两个维度进行归一化。

方法

`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`()	返回网络中所有模块的迭代器。
`mtia`([device])	将所有模型参数和缓冲区移至 MTIA。
`named_buffers`([prefix, recurse, ...])	返回模块缓冲区的迭代器，同时产生缓冲区的名称和缓冲区本身。
`named_children`()	返回直接子模块的迭代器，同时产生模块的名称和模块本身。
`named_modules`([memo, prefix, remove_duplicate])	返回网络中所有模块的迭代器，同时产生模块的名称和模块本身。
`named_parameters`([prefix, recurse, ...])	返回模块参数的迭代器，同时产生参数的名称和参数本身。
`parameters`([recurse])	返回模块参数的迭代器。
`register_backward_hook`(hook)	在模块上注册一个后向 hook。
`register_buffer`(name, tensor[, persistent])	向模块添加一个缓冲区。
`register_forward_hook`(hook, *[, prepend, ...])	在模块上注册一个前向 hook。
`register_forward_pre_hook`(hook, *[, ...])	在模块上注册一个前向 pre-hook。
`register_full_backward_hook`(hook[, prepend])	在模块上注册一个后向 hook。
`register_full_backward_pre_hook`(hook[, prepend])	在模块上注册一个后向 pre-hook。
`register_load_state_dict_post_hook`(hook)	注册一个 post-hook，用于在调用模块的 `load_state_dict()` 之后运行。
`register_load_state_dict_pre_hook`(hook)	注册一个 pre-hook，用于在调用模块的 `load_state_dict()` 之前运行。
`register_module`(name, module)	`add_module()` 的别名。
`register_parameter`(name, param)	向模块添加一个参数。
`register_state_dict_post_hook`(hook)	为 `state_dict()` 方法注册一个 post-hook。
`register_state_dict_pre_hook`(hook)	为 `state_dict()` 方法注册一个 pre-hook。
`requires_grad_`([requires_grad])	更改 autograd 是否应在此模块的参数上记录操作。
`set_extra_state`(state)	设置加载的 state_dict 中包含的额外状态。
`set_submodule`(target, module)	如果存在由 `target` 给定的子模块，则设置该子模块，否则抛出错误。
`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__
reset_parameters
reset_running_stats

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

add_module(name, module)¶

向当前模块添加一个子模块。

可以使用给定名称作为属性访问模块。

参数

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

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

None

affine: bool¶

apply(fn)¶

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

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

参数: fn (Module -> None) – 要应用于每个子模块的函数
float – 单个单变量/多变量 series、单个 metric 函数和: self
Union[float, ndarray, list[float], list[ndarray]]: 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 数据类型。

注意

此方法会修改模块本身。

float – 单个单变量/多变量 series、单个 metric 函数和: self
Union[float, ndarray, list[float], list[ndarray]]: Module

buffers(recurse=True)¶

返回模块缓冲区的迭代器。

参数: recurse (bool) – 如果为 True，则产生此模块和所有子模块的缓冲区。否则，仅产生此模块的直接成员缓冲区。
产生: 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)

Union[float, ndarray, list[float], list[ndarray]]: Iterator[Tensor]

call_super_init: bool = False¶

children()¶

返回直接子模块的迭代器。

产生: Module – 一个子模块
Union[float, ndarray, list[float], list[ndarray]]: Iterator[Module]

compile(*args, **kwargs)¶

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

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

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

cpu()¶

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

注意

此方法会修改模块本身。

float – 单个单变量/多变量 series、单个 metric 函数和: self
Union[float, ndarray, list[float], list[ndarray]]: Module

cuda(device=None)¶

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

这也会使相关的参数和缓冲区成为不同的对象。因此，如果模块在优化时位于 GPU 上，则应在构造优化器之前调用此方法。

注意

此方法会修改模块本身。

参数: device (int, optional) – 如果指定，所有参数将被复制到该设备
float – 单个单变量/多变量 series、单个 metric 函数和: self
Union[float, ndarray, list[float], list[ndarray]]: Module

double()¶

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

注意

此方法会修改模块本身。

float – 单个单变量/多变量 series、单个 metric 函数和: self
Union[float, ndarray, list[float], list[ndarray]]: Module

dump_patches: bool = False¶

eps: float¶

eval()¶

将模块设置为评估模式。

这仅对某些模块有效。有关它们在训练/评估模式下的行为详情（即是否受影响，例如 Dropout、BatchNorm 等），请参阅特定模块的文档。

这相当于 self.train(False)。

有关 .eval() 与可能与之混淆的几种类似机制之间的比较，请参阅 locally-disable-grad-doc。

float – 单个单变量/多变量 series、单个 metric 函数和: self
Union[float, ndarray, list[float], list[ndarray]]: Module

extra_repr()¶

返回模块的额外表示。

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

float()¶

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

注意

此方法会修改模块本身。

float – 单个单变量/多变量 series、单个 metric 函数和: self
Union[float, ndarray, list[float], list[ndarray]]: Module

forward(x)[source]¶

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

应由所有子类覆盖。

注意

尽管 forward pass 的实现需要在函数内部定义，但之后应调用 Module 实例而不是此函数，因为前者负责运行已注册的 hook，而后者会静默忽略它们。

Union[float, ndarray, list[float], list[ndarray]]: Tensor

get_buffer(target)¶

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

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

参数: target (str) – 要查找的缓冲区的完全限定字符串名称。（有关如何指定完全限定字符串，请参阅 get_submodule。）
float – 单个单变量/多变量 series、单个 metric 函数和: 由 target 引用的缓冲区
Union[float, ndarray, list[float], list[ndarray]]: torch.Tensor
引发: AttributeError – 如果目标字符串引用了无效路径或解析为不是缓冲区的对象

get_extra_state()¶

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

如果您需要存储额外状态，请为您的模块实现此方法和相应的 set_extra_state()。在构建模块的 state_dict() 时会调用此函数。

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

float – 单个单变量/多变量 series、单个 metric 函数和: 要存储在模块 state_dict 中的任何额外状态
Union[float, ndarray, list[float], list[ndarray]]: object

get_parameter(target)¶

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

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

参数: target (str) – 要查找的 Parameter 的完全限定字符串名称。（有关如何指定完全限定字符串，请参阅 get_submodule。）
float – 单个单变量/多变量 series、单个 metric 函数和: 由 target 引用的 Parameter
Union[float, ndarray, list[float], list[ndarray]]: 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 的查询也能达到相同的结果，但它是模块数量 N 的 O(N)。因此，对于简单检查某个子模块是否存在，应始终使用 get_submodule。

参数: target (str) – 要查找的子模块的完全限定字符串名称。（有关如何指定完全限定字符串，请参阅上面的示例。）
float – 单个单变量/多变量 series、单个 metric 函数和: 由 target 引用的子模块。
Union[float, ndarray, list[float], list[ndarray]]: torch.nn.Module
引发: AttributeError – 如果目标字符串引用了无效路径或解析为不是 nn.Module 的对象

half()¶

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

注意

此方法会修改模块本身。

float – 单个单变量/多变量 series、单个 metric 函数和: self
Union[float, ndarray, list[float], list[ndarray]]: Module

ipu(device=None)¶

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

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

注意

此方法会修改模块本身。

参数: device (int, optional) – 如果指定，所有参数将被复制到该设备
float – 单个单变量/多变量 series、单个 metric 函数和: self
Union[float, ndarray, list[float], list[ndarray]]: 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 时，当前模块中 tensor 的属性被保留，而设置为 True 则保留 state dict 中 Tensor 的属性。唯一的例外是 requires_grad 字段。默认值：False。

float – 单个单变量/多变量 series、单个 metric 函数和

missing_keys 是一个包含预期
但缺少于提供的 state_dict 中的任何键的字符串列表。
unexpected_keys 是一个包含未
此模块不预期存在但在提供的 state_dict 中存在的键。

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

NamedTuple 带有 missing_keys 和 unexpected_keys 字段

注意

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

modules()¶

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

产生: Module – 网络中的一个模块

注意

重复的模块只返回一次。在以下示例中，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)

Union[float, ndarray, list[float], list[ndarray]]: Iterator[Module]

momentum: Optional[float]¶

mtia(device=None)¶

将所有模型参数和缓冲区移至 MTIA。

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

注意

此方法会修改模块本身。

参数: device (int, optional) – 如果指定，所有参数将被复制到该设备
float – 单个单变量/多变量 series、单个 metric 函数和: self
Union[float, ndarray, list[float], list[ndarray]]: Module

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

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

参数

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

产生

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

示例

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

Union[float, ndarray, list[float], list[ndarray]]: 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)

Union[float, ndarray, list[float], list[ndarray]]: 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) – 如果为 True，则生成此模块及其所有子模块的参数。否则，仅生成此模块直接成员的参数。
remove_duplicate (bool, *可选*) – 是否移除结果中的重复参数。默认为 True。

产生

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

示例

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

Union[float, ndarray, list[float], list[ndarray]]: Iterator[Tuple[str, Parameter]]

num_features: int¶

parameters(recurse=True)¶

返回模块参数的迭代器。

这通常会传递给优化器。

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

示例

>>> # 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)

Union[float, ndarray, list[float], list[ndarray]]: Iterator[Parameter]

register_backward_hook(hook)¶

在模块上注册一个后向 hook。

此函数已被弃用，推荐使用 register_full_backward_hook()，并且此函数的行为将在未来版本中更改。

float – 单个单变量/多变量 series、单个 metric 函数和: 一个句柄，可以通过调用 handle.remove() 来移除添加的钩子
Union[float, ndarray, list[float], list[ndarray]]: torch.utils.hooks.RemovableHandle

register_buffer(name, tensor, persistent=True)¶

向模块添加一个缓冲区。

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

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

参数

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

示例

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

Union[float, ndarray, list[float], list[ndarray]]: None

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

在模块上注册一个前向 hook。

每次 forward() 计算出输出后都会调用此钩子。

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

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

如果 with_kwargs 为 True，则 forward 钩子将传递给 forward 函数的 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，则将 forward 函数的 kwargs 传递给 hook。默认值：False
always_call (bool) – 如果为 True，则无论在调用模块时是否引发异常，都会运行 hook。默认值：False

float – 单个单变量/多变量 series、单个 metric 函数和

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

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

torch.utils.hooks.RemovableHandle

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

在模块上注册一个前向 pre-hook。

每次调用 forward() 之前都会调用此钩子。

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

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

如果 with_kwargs 为 true，则 forward pre-hook 将传递给 forward 函数的 kwargs。如果钩子修改了输入，则应返回 args 和 kwargs。该钩子应具有以下签名

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

参数

hook (Callable) – 要注册的用户定义钩子。
prepend (bool) – 如果为 true，则提供的 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) – 如果为 true，则将 forward 函数的 kwargs 传递给 hook。默认值：False

float – 单个单变量/多变量 series、单个 metric 函数和

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

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

torch.utils.hooks.RemovableHandle

register_full_backward_hook(hook, prepend=False)¶

在模块上注册一个后向 hook。

每次计算模块的梯度时都会调用此钩子，也就是说，只有在计算模块输出的梯度时，钩子才会执行。该钩子应具有以下签名

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

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

出于技术原因，当此钩子应用于模块时，其 forward 函数将接收传递给模块的每个 Tensor 的视图。类似地，调用者将接收模块 forward 函数返回的每个 Tensor 的视图。

警告

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

参数

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

float – 单个单变量/多变量 series、单个 metric 函数和

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

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

torch.utils.hooks.RemovableHandle

register_full_backward_pre_hook(hook, prepend=False)¶

在模块上注册一个后向 pre-hook。

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

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

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

警告

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

参数

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

float – 单个单变量/多变量 series、单个 metric 函数和

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

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

torch.utils.hooks.RemovableHandle

register_load_state_dict_post_hook(hook)¶

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

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

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

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

请注意，当调用 load_state_dict() 并设置 strict=True 时执行的检查会受到钩子对 missing_keys 或 unexpected_keys 所做修改的影响，这符合预期。向任何一个键集添加内容都会在 strict=True 时导致抛出错误，而清除所有缺失和意外键则会避免错误。

float – 单个单变量/多变量 series、单个 metric 函数和: 一个句柄，可以通过调用 handle.remove() 来移除添加的钩子
Union[float, ndarray, list[float], list[ndarray]]: torch.utils.hooks.RemovableHandle

register_load_state_dict_pre_hook(hook)¶

注册一个前置钩子，在调用模块的 load_state_dict() 之前运行。

它应该具有以下签名：: hook(module, state_dict, prefix, local_metadata, strict, missing_keys, unexpected_keys, error_msgs) -> None # noqa: B950

参数: hook (Callable) – 在加载 state dict 之前将调用的可调用钩子。

register_module(name, module)¶

add_module() 的别名。

Union[float, ndarray, list[float], list[ndarray]]: None

register_parameter(name, param)¶

向模块添加一个参数。

参数可以使用给定的名称作为属性访问。

参数

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

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

None

register_state_dict_post_hook(hook)¶

为 state_dict() 方法注册一个 post-hook。

它应该具有以下签名：: hook(module, state_dict, prefix, local_metadata) -> None

注册的钩子可以就地修改 state_dict。

register_state_dict_pre_hook(hook)¶

为 state_dict() 方法注册一个 pre-hook。

它应该具有以下签名：: hook(module, prefix, keep_vars) -> None

注册的钩子可用于在调用 state_dict 之前执行预处理。

requires_grad_(requires_grad=True)¶

更改 autograd 是否应在此模块的参数上记录操作。

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

此方法有助于冻结模块的一部分用于微调，或单独训练模型的各个部分（例如，GAN 训练）。

请参阅 locally-disable-grad-doc，了解 .requires_grad_() 与可能与之混淆的几种类似机制之间的比较。

参数: requires_grad (bool) – 是否应该由 autograd 记录在此模块中参数上的操作。默认值：True。
float – 单个单变量/多变量 series、单个 metric 函数和: self
Union[float, ndarray, list[float], list[ndarray]]: Module

reset_parameters()¶

Union[float, ndarray, list[float], list[ndarray]]: None

reset_running_stats()¶

Union[float, ndarray, list[float], list[ndarray]]: None

set_extra_state(state)¶

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

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

参数: state (dict) – 来自 state_dict 的额外状态
Union[float, ndarray, list[float], list[ndarray]]: None

set_submodule(target, module)¶

如果存在由 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_b 又包含两个子模块 net_c 和 linear。然后 net_c 包含一个子模块 conv。）

要用新的子模块 Linear 覆盖 Conv2d，您可以调用 set_submodule("net_b.net_c.conv", nn.Linear(33, 16))。

参数

target (str) – 要查找的子模块的完全限定字符串名称。（有关如何指定完全限定字符串，请参阅上面的示例。）
module (Module) – 要设置为子模块的模块。

引发

ValueError – 如果目标字符串为空
AttributeError – 如果目标字符串引用了无效路径或解析为不是 nn.Module 的对象

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

None

share_memory()¶

参见 torch.Tensor.share_memory_()。

Union[float, ndarray, list[float], list[ndarray]]: ~T

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

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

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

注意

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

警告

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

警告

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

参数

destination (dict, *可选*) – 如果提供，模块的状态将更新到该 dict 中并返回相同的对象。否则，将创建并返回一个 OrderedDict。默认值：None。
prefix (str, *可选*) – 添加到参数和缓冲区名称前的自定义前缀，用于在 state_dict 中构成键。默认值：''。
keep_vars (bool, *可选*) – 默认情况下，在 state dict 中返回的 Tensor 与 autograd 分离。如果设置为 True，则不会执行分离。默认值：False。

float – 单个单变量/多变量 series、单个 metric 函数和

包含模块整个状态的字典

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

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 时，如果可能，它会尝试与主机异步进行转换/移动，例如，将具有锁定内存 (pinned memory) 的 CPU Tensor 移动到 CUDA 设备。

请参见下方示例。

注意

此方法会修改模块本身。

参数

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

float – 单个单变量/多变量 series、单个 metric 函数和

self

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

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) – 子模块的参数和缓冲区是否应递归移动到指定的设备。

float – 单个单变量/多变量 series、单个 metric 函数和

self

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

Module

track_running_stats: bool¶

train(mode=True)¶

将模块设置为训练模式。

这仅对某些模块有效。请参阅特定模块的文档，了解它们在训练/评估模式下的行为详情，即它们是否受影响，例如 Dropout、BatchNorm 等。

参数: mode (bool) – 是否设置为训练模式 (True) 或评估模式 (False)。默认值：True。
float – 单个单变量/多变量 series、单个 metric 函数和: self
Union[float, ndarray, list[float], list[ndarray]]: Module

training: bool¶

type(dst_type)¶

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

注意

此方法会修改模块本身。

参数: dst_type (type 或 string) – 所需的类型
float – 单个单变量/多变量 series、单个 metric 函数和: self
Union[float, ndarray, list[float], list[ndarray]]: Module

xpu(device=None)¶

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

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

注意

此方法会修改模块本身。

参数: device (int, optional) – 如果指定，所有参数将被复制到该设备
float – 单个单变量/多变量 series、单个 metric 函数和: self
Union[float, ndarray, list[float], list[ndarray]]: Module

zero_grad(set_to_none=True)¶

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

有关更多背景信息，请参阅 torch.optim.Optimizer 下的类似函数。

参数: set_to_none (bool) – 不设置为零，而是将梯度设置为 None。有关详情，请参阅 torch.optim.Optimizer.zero_grad()。
Union[float, ndarray, list[float], list[ndarray]]: None

Transformer 模型

VARIMA