所有 NeuralForecast 模型都是“全局的”，因为我们使用输入 pd.DataFrame 数据 Y_df 中的所有序列对其进行训练，但目前的优化目标是“单变量的”，因为它不考虑时间序列之间输出预测的相互作用。与 StatsForecast 库类似，core.NeuralForecast 允许您高效地探索模型集合，并包含用于方便整理输入和输出 pd.DataFrames 预测结果的函数。

首先我们加载 AirPassengers 数据集，以便您可以运行所有示例。

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

from neuralforecast.tsdataset import TimeSeriesDataset
from neuralforecast.utils import AirPassengersDF as Y_df

# Split train/test and declare time series dataset
Y_train_df = Y_df[Y_df.ds<='1959-12-31'] # 132 train
Y_test_df = Y_df[Y_df.ds>'1959-12-31']   # 12 test
dataset, *_ = TimeSeriesDataset.from_df(Y_train_df)

1. 自动预测

A. 基于 RNN 的模型

源

AutoRNN

 AutoRNN (h, loss=MAE(), valid_loss=None, config=None,
          search_alg=<ray.tune.search.basic_variant.BasicVariantGenerator
          object at 0x7f6f347e2290>, num_samples=10, refit_with_val=False,
          cpus=4, gpus=0, verbose=False, alias=None, backend='ray',
          callbacks=None)

*用于自动超参数优化的类，它基于 ray 构建，提供了多种超参数优化工具，包括经典的网格搜索、贝叶斯优化和 HyperBand 算法。

要优化的验证损失由 config['loss'] 字典值定义，config 还包含其余的超参数搜索空间。

需要注意的是，超参数优化的成功很大程度上取决于验证期和测试期之间存在强相关性。*

	类型	默认值	详情
h	int		预测范围
loss	MAE	MAE()	实例化自损失函数集合的训练损失类。
valid_loss	NoneType	None	实例化自损失函数集合的验证损失类。
config	NoneType	None	包含 ray.tune 定义的搜索空间的字典或接受 optuna trial 并返回配置字典的函数。
search_alg	BasicVariantGenerator	<ray.tune.search.basic_variant.BasicVariantGenerator object at 0x7f6f347e2290>	关于 ray，请参阅https://docs.rayai.org.cn/en/latest/tune/api_docs/suggestion.html 关于 optuna，请参阅https://docs.optuna.cn/en/stable/reference/samplers/index.html。
num_samples	int	10	超参数优化步骤/样本的数量。
refit_with_val	bool	False	最佳模型的重新训练应保留 val_size。
cpus	int	4	优化期间使用的 cpu 数量。仅与 ray tune 一起使用。
gpus	int	0	优化期间使用的 gpu 数量，默认为所有可用 gpu。仅与 ray tune 一起使用。
verbose	bool	False	跟踪进度。
alias	NoneType	None	模型的自定义名称。
backend	str	ray	用于搜索超参数空间的后端，可以是“ray”或“optuna”。
callbacks	NoneType	None	优化过程中要调用的函数列表。 ray 参考：https://docs.rayai.org.cn/en/latest/tune/tutorials/tune-metrics.html optuna 参考：https://docs.optuna.cn/en/stable/tutorial/20_recipes/007_optuna_callback.html

# Use your own config or AutoRNN.default_config
config = dict(max_steps=1, val_check_steps=1, input_size=-1, encoder_hidden_size=8)
model = AutoRNN(h=12, config=config, num_samples=1, cpus=1)

model.fit(dataset=dataset)
y_hat = model.predict(dataset=dataset)

# Optuna
model = AutoRNN(h=12, config=None, num_samples=1, cpus=1, backend='optuna')

源

AutoLSTM

 AutoLSTM (h, loss=MAE(), valid_loss=None, config=None,
           search_alg=<ray.tune.search.basic_variant.BasicVariantGenerator
           object at 0x7f6f2ed2c0d0>, num_samples=10,
           refit_with_val=False, cpus=4, gpus=0, verbose=False,
           alias=None, backend='ray', callbacks=None)

*用于自动超参数优化的类，它基于 ray 构建，提供了多种超参数优化工具，包括经典的网格搜索、贝叶斯优化和 HyperBand 算法。

要优化的验证损失由 config['loss'] 字典值定义，config 还包含其余的超参数搜索空间。

需要注意的是，超参数优化的成功很大程度上取决于验证期和测试期之间存在强相关性。*

	类型	默认值	详情
h	int		预测范围
loss	MAE	MAE()	实例化自损失函数集合的训练损失类。
valid_loss	NoneType	None	实例化自损失函数集合的验证损失类。
config	NoneType	None	包含 ray.tune 定义的搜索空间的字典或接受 optuna trial 并返回配置字典的函数。
search_alg	BasicVariantGenerator	<ray.tune.search.basic_variant.BasicVariantGenerator object at 0x7f6f2ed2c0d0>	关于 ray，请参阅https://docs.rayai.org.cn/en/latest/tune/api_docs/suggestion.html 关于 optuna，请参阅https://docs.optuna.cn/en/stable/reference/samplers/index.html。
num_samples	int	10	超参数优化步骤/样本的数量。
refit_with_val	bool	False	最佳模型的重新训练应保留 val_size。
cpus	int	4	优化期间使用的 cpu 数量。仅与 ray tune 一起使用。
gpus	int	0	优化期间使用的 gpu 数量，默认为所有可用 gpu。仅与 ray tune 一起使用。
verbose	bool	False	跟踪进度。
alias	NoneType	None	模型的自定义名称。
backend	str	ray	用于搜索超参数空间的后端，可以是“ray”或“optuna”。
callbacks	NoneType	None	优化过程中要调用的函数列表。 ray 参考：https://docs.rayai.org.cn/en/latest/tune/tutorials/tune-metrics.html optuna 参考：https://docs.optuna.cn/en/stable/tutorial/20_recipes/007_optuna_callback.html

# Use your own config or AutoLSTM.default_config
config = dict(max_steps=1, val_check_steps=1, input_size=-1, encoder_hidden_size=8)
model = AutoLSTM(h=12, config=config, num_samples=1, cpus=1)

# Fit and predict
model.fit(dataset=dataset)
y_hat = model.predict(dataset=dataset)

# Optuna
model = AutoLSTM(h=12, config=None, backend='optuna')

源

AutoGRU

 AutoGRU (h, loss=MAE(), valid_loss=None, config=None,
          search_alg=<ray.tune.search.basic_variant.BasicVariantGenerator
          object at 0x7f6f2ed134f0>, num_samples=10, refit_with_val=False,
          cpus=4, gpus=0, verbose=False, alias=None, backend='ray',
          callbacks=None)

*用于自动超参数优化的类，它基于 ray 构建，提供了多种超参数优化工具，包括经典的网格搜索、贝叶斯优化和 HyperBand 算法。

要优化的验证损失由 config['loss'] 字典值定义，config 还包含其余的超参数搜索空间。

需要注意的是，超参数优化的成功很大程度上取决于验证期和测试期之间存在强相关性。*

	类型	默认值	详情
h	int		预测范围
loss	MAE	MAE()	实例化自损失函数集合的训练损失类。
valid_loss	NoneType	None	实例化自损失函数集合的验证损失类。
config	NoneType	None	包含 ray.tune 定义的搜索空间的字典或接受 optuna trial 并返回配置字典的函数。
search_alg	BasicVariantGenerator	<ray.tune.search.basic_variant.BasicVariantGenerator object at 0x7f6f2ed134f0>	关于 ray，请参阅https://docs.rayai.org.cn/en/latest/tune/api_docs/suggestion.html 关于 optuna，请参阅https://docs.optuna.cn/en/stable/reference/samplers/index.html。
num_samples	int	10	超参数优化步骤/样本的数量。
refit_with_val	bool	False	最佳模型的重新训练应保留 val_size。
cpus	int	4	优化期间使用的 cpu 数量。仅与 ray tune 一起使用。
gpus	int	0	优化期间使用的 gpu 数量，默认为所有可用 gpu。仅与 ray tune 一起使用。
verbose	bool	False	跟踪进度。
alias	NoneType	None	模型的自定义名称。
backend	str	ray	用于搜索超参数空间的后端，可以是“ray”或“optuna”。
callbacks	NoneType	None	优化过程中要调用的函数列表。 ray 参考：https://docs.rayai.org.cn/en/latest/tune/tutorials/tune-metrics.html optuna 参考：https://docs.optuna.cn/en/stable/tutorial/20_recipes/007_optuna_callback.html

# Use your own config or AutoGRU.default_config
config = dict(max_steps=1, val_check_steps=1, input_size=-1, encoder_hidden_size=8)
model = AutoGRU(h=12, config=config, num_samples=1, cpus=1)

# Fit and predict
model.fit(dataset=dataset)
y_hat = model.predict(dataset=dataset)

# Optuna
model = AutoGRU(h=12, config=None, backend='optuna')

源

AutoTCN

 AutoTCN (h, loss=MAE(), valid_loss=None, config=None,
          search_alg=<ray.tune.search.basic_variant.BasicVariantGenerator
          object at 0x7f6f2ffe1480>, num_samples=10, refit_with_val=False,
          cpus=4, gpus=0, verbose=False, alias=None, backend='ray',
          callbacks=None)

*用于自动超参数优化的类，它基于 ray 构建，提供了多种超参数优化工具，包括经典的网格搜索、贝叶斯优化和 HyperBand 算法。

要优化的验证损失由 config['loss'] 字典值定义，config 还包含其余的超参数搜索空间。

需要注意的是，超参数优化的成功很大程度上取决于验证期和测试期之间存在强相关性。*

	类型	默认值	详情
h	int		预测范围
loss	MAE	MAE()	实例化自损失函数集合的训练损失类。
valid_loss	NoneType	None	实例化自损失函数集合的验证损失类。
config	NoneType	None	包含 ray.tune 定义的搜索空间的字典或接受 optuna trial 并返回配置字典的函数。
search_alg	BasicVariantGenerator	<ray.tune.search.basic_variant.BasicVariantGenerator object at 0x7f6f2ffe1480>	关于 ray，请参阅https://docs.rayai.org.cn/en/latest/tune/api_docs/suggestion.html 关于 optuna，请参阅https://docs.optuna.cn/en/stable/reference/samplers/index.html。
num_samples	int	10	超参数优化步骤/样本的数量。
refit_with_val	bool	False	最佳模型的重新训练应保留 val_size。
cpus	int	4	优化期间使用的 cpu 数量。仅与 ray tune 一起使用。
gpus	int	0	优化期间使用的 gpu 数量，默认为所有可用 gpu。仅与 ray tune 一起使用。
verbose	bool	False	跟踪进度。
alias	NoneType	None	模型的自定义名称。
backend	str	ray	用于搜索超参数空间的后端，可以是“ray”或“optuna”。
callbacks	NoneType	None	优化过程中要调用的函数列表。 ray 参考：https://docs.rayai.org.cn/en/latest/tune/tutorials/tune-metrics.html optuna 参考：https://docs.optuna.cn/en/stable/tutorial/20_recipes/007_optuna_callback.html

# Use your own config or AutoTCN.default_config
config = dict(max_steps=1, val_check_steps=1, input_size=-1, encoder_hidden_size=8)
model = AutoTCN(h=12, config=config, num_samples=1, cpus=1)

# Fit and predict
model.fit(dataset=dataset)
y_hat = model.predict(dataset=dataset)

# Optuna
model = AutoTCN(h=12, config=None, backend='optuna')

源

AutoDeepAR

 AutoDeepAR (h, loss=DistributionLoss(), valid_loss=MQLoss(), config=None,
             search_alg=<ray.tune.search.basic_variant.BasicVariantGenerat
             or object at 0x7f6f2ff95c90>, num_samples=10,
             refit_with_val=False, cpus=4, gpus=0, verbose=False,
             alias=None, backend='ray', callbacks=None)

*用于自动超参数优化的类，它基于 ray 构建，提供了多种超参数优化工具，包括经典的网格搜索、贝叶斯优化和 HyperBand 算法。

要优化的验证损失由 config['loss'] 字典值定义，config 还包含其余的超参数搜索空间。

需要注意的是，超参数优化的成功很大程度上取决于验证期和测试期之间存在强相关性。*

	类型	默认值	详情
h	int		预测范围
loss	DistributionLoss	DistributionLoss()	实例化自损失函数集合的训练损失类。
valid_loss	MQLoss	MQLoss()	实例化自损失函数集合的验证损失类。
config	NoneType	None	包含 ray.tune 定义的搜索空间的字典或接受 optuna trial 并返回配置字典的函数。
search_alg	BasicVariantGenerator	<ray.tune.search.basic_variant.BasicVariantGenerator object at 0x7f6f2ff95c90>	关于 ray，请参阅https://docs.rayai.org.cn/en/latest/tune/api_docs/suggestion.html 关于 optuna，请参阅https://docs.optuna.cn/en/stable/reference/samplers/index.html。
num_samples	int	10	超参数优化步骤/样本的数量。
refit_with_val	bool	False	最佳模型的重新训练应保留 val_size。
cpus	int	4	优化期间使用的 cpu 数量。仅与 ray tune 一起使用。
gpus	int	0	优化期间使用的 gpu 数量，默认为所有可用 gpu。仅与 ray tune 一起使用。
verbose	bool	False	跟踪进度。
alias	NoneType	None	模型的自定义名称。
backend	str	ray	用于搜索超参数空间的后端，可以是“ray”或“optuna”。
callbacks	NoneType	None	优化过程中要调用的函数列表。 ray 参考：https://docs.rayai.org.cn/en/latest/tune/tutorials/tune-metrics.html optuna 参考：https://docs.optuna.cn/en/stable/tutorial/20_recipes/007_optuna_callback.html

# Use your own config or AutoDeepAR.default_config
config = dict(max_steps=1, val_check_steps=1, input_size=12, lstm_hidden_size=8)
model = AutoDeepAR(h=12, config=config, num_samples=1, cpus=1)

# Fit and predict
model.fit(dataset=dataset)
y_hat = model.predict(dataset=dataset)

# Optuna
model = AutoDeepAR(h=12, config=None, backend='optuna')

源

AutoDilatedRNN

 AutoDilatedRNN (h, loss=MAE(), valid_loss=None, config=None,
                 search_alg=<ray.tune.search.basic_variant.BasicVariantGen
                 erator object at 0x7f6f2fff2230>, num_samples=10,
                 refit_with_val=False, cpus=4, gpus=0, verbose=False,
                 alias=None, backend='ray', callbacks=None)

*用于自动超参数优化的类，它基于 ray 构建，提供了多种超参数优化工具，包括经典的网格搜索、贝叶斯优化和 HyperBand 算法。

要优化的验证损失由 config['loss'] 字典值定义，config 还包含其余的超参数搜索空间。

需要注意的是，超参数优化的成功很大程度上取决于验证期和测试期之间存在强相关性。*

	类型	默认值	详情
h	int		预测范围
loss	MAE	MAE()	实例化自损失函数集合的训练损失类。
valid_loss	NoneType	None	实例化自损失函数集合的验证损失类。
config	NoneType	None	包含 ray.tune 定义的搜索空间的字典或接受 optuna trial 并返回配置字典的函数。
search_alg	BasicVariantGenerator	<ray.tune.search.basic_variant.BasicVariantGenerator object at 0x7f6f2fff2230>	关于 ray，请参阅https://docs.rayai.org.cn/en/latest/tune/api_docs/suggestion.html 关于 optuna，请参阅https://docs.optuna.cn/en/stable/reference/samplers/index.html。
num_samples	int	10	超参数优化步骤/样本的数量。
refit_with_val	bool	False	最佳模型的重新训练应保留 val_size。
cpus	int	4	优化期间使用的 cpu 数量。仅与 ray tune 一起使用。
gpus	int	0	优化期间使用的 gpu 数量，默认为所有可用 gpu。仅与 ray tune 一起使用。
verbose	bool	False	跟踪进度。
alias	NoneType	None	模型的自定义名称。
backend	str	ray	用于搜索超参数空间的后端，可以是“ray”或“optuna”。
callbacks	NoneType	None	优化过程中要调用的函数列表。 ray 参考：https://docs.rayai.org.cn/en/latest/tune/tutorials/tune-metrics.html optuna 参考：https://docs.optuna.cn/en/stable/tutorial/20_recipes/007_optuna_callback.html

# Use your own config or AutoDilatedRNN.default_config
config = dict(max_steps=1, val_check_steps=1, input_size=-1, encoder_hidden_size=8)
model = AutoDilatedRNN(h=12, config=config, num_samples=1, cpus=1)

# Fit and predict
model.fit(dataset=dataset)
y_hat = model.predict(dataset=dataset)

# Optuna
model = AutoDilatedRNN(h=12, config=None, backend='optuna')

源

AutoBiTCN

 AutoBiTCN (h, loss=MAE(), valid_loss=None, config=None,
            search_alg=<ray.tune.search.basic_variant.BasicVariantGenerato
            r object at 0x7f6f3401d870>, num_samples=10,
            refit_with_val=False, cpus=4, gpus=0, verbose=False,
            alias=None, backend='ray', callbacks=None)

*用于自动超参数优化的类，它基于 ray 构建，提供了多种超参数优化工具，包括经典的网格搜索、贝叶斯优化和 HyperBand 算法。

要优化的验证损失由 config['loss'] 字典值定义，config 还包含其余的超参数搜索空间。

需要注意的是，超参数优化的成功很大程度上取决于验证期和测试期之间存在强相关性。*

	类型	默认值	详情
h	int		预测范围
loss	MAE	MAE()	实例化自损失函数集合的训练损失类。
valid_loss	NoneType	None	实例化自损失函数集合的验证损失类。
config	NoneType	None	包含 ray.tune 定义的搜索空间的字典或接受 optuna trial 并返回配置字典的函数。
search_alg	BasicVariantGenerator	<ray.tune.search.basic_variant.BasicVariantGenerator object at 0x7f6f3401d870>	关于 ray，请参阅https://docs.rayai.org.cn/en/latest/tune/api_docs/suggestion.html 关于 optuna，请参阅https://docs.optuna.cn/en/stable/reference/samplers/index.html。
num_samples	int	10	超参数优化步骤/样本的数量。
refit_with_val	bool	False	最佳模型的重新训练应保留 val_size。
cpus	int	4	优化期间使用的 cpu 数量。仅与 ray tune 一起使用。
gpus	int	0	优化期间使用的 gpu 数量，默认为所有可用 gpu。仅与 ray tune 一起使用。
verbose	bool	False	跟踪进度。
alias	NoneType	None	模型的自定义名称。
backend	str	ray	用于搜索超参数空间的后端，可以是“ray”或“optuna”。
callbacks	NoneType	None	优化过程中要调用的函数列表。 ray 参考：https://docs.rayai.org.cn/en/latest/tune/tutorials/tune-metrics.html optuna 参考：https://docs.optuna.cn/en/stable/tutorial/20_recipes/007_optuna_callback.html

# Use your own config or AutoBiTCN.default_config
config = dict(max_steps=1, val_check_steps=1, input_size=12, hidden_size=8)
model = AutoBiTCN(h=12, config=config, num_samples=1, cpus=1)

# Fit and predict
model.fit(dataset=dataset)
y_hat = model.predict(dataset=dataset)

# Optuna
model = AutoBiTCN(h=12, config=None, backend='optuna')

B. 基于 MLP 的模型

源

AutoMLP

 AutoMLP (h, loss=MAE(), valid_loss=None, config=None,
          search_alg=<ray.tune.search.basic_variant.BasicVariantGenerator
          object at 0x7f6f2ffe1ed0>, num_samples=10, refit_with_val=False,
          cpus=4, gpus=0, verbose=False, alias=None, backend='ray',
          callbacks=None)

*用于自动超参数优化的类，它基于 ray 构建，提供了多种超参数优化工具，包括经典的网格搜索、贝叶斯优化和 HyperBand 算法。

要优化的验证损失由 config['loss'] 字典值定义，config 还包含其余的超参数搜索空间。

需要注意的是，超参数优化的成功很大程度上取决于验证期和测试期之间存在强相关性。*

	类型	默认值	详情
h	int		预测范围
loss	MAE	MAE()	实例化自损失函数集合的训练损失类。
valid_loss	NoneType	None	实例化自损失函数集合的验证损失类。
config	NoneType	None	包含 ray.tune 定义的搜索空间的字典或接受 optuna trial 并返回配置字典的函数。
search_alg	BasicVariantGenerator	<ray.tune.search.basic_variant.BasicVariantGenerator object at 0x7f6f2ffe1ed0>	关于 ray，请参阅https://docs.rayai.org.cn/en/latest/tune/api_docs/suggestion.html 关于 optuna，请参阅https://docs.optuna.cn/en/stable/reference/samplers/index.html。
num_samples	int	10	超参数优化步骤/样本的数量。
refit_with_val	bool	False	最佳模型的重新训练应保留 val_size。
cpus	int	4	优化期间使用的 cpu 数量。仅与 ray tune 一起使用。
gpus	int	0	优化期间使用的 gpu 数量，默认为所有可用 gpu。仅与 ray tune 一起使用。
verbose	bool	False	跟踪进度。
alias	NoneType	None	模型的自定义名称。
backend	str	ray	用于搜索超参数空间的后端，可以是“ray”或“optuna”。
callbacks	NoneType	None	优化过程中要调用的函数列表。 ray 参考：https://docs.rayai.org.cn/en/latest/tune/tutorials/tune-metrics.html optuna 参考：https://docs.optuna.cn/en/stable/tutorial/20_recipes/007_optuna_callback.html

# Use your own config or AutoMLP.default_config
config = dict(max_steps=1, val_check_steps=1, input_size=12, hidden_size=8)
model = AutoMLP(h=12, config=config, num_samples=1, cpus=1)

# Fit and predict
model.fit(dataset=dataset)
y_hat = model.predict(dataset=dataset)

# Optuna
model = AutoMLP(h=12, config=None, backend='optuna')

源

AutoNBEATS

 AutoNBEATS (h, loss=MAE(), valid_loss=None, config=None,
             search_alg=<ray.tune.search.basic_variant.BasicVariantGenerat
             or object at 0x7f6f2ffe2140>, num_samples=10,
             refit_with_val=False, cpus=4, gpus=0, verbose=False,
             alias=None, backend='ray', callbacks=None)

*用于自动超参数优化的类，它基于 ray 构建，提供了多种超参数优化工具，包括经典的网格搜索、贝叶斯优化和 HyperBand 算法。

要优化的验证损失由 config['loss'] 字典值定义，config 还包含其余的超参数搜索空间。

需要注意的是，超参数优化的成功很大程度上取决于验证期和测试期之间存在强相关性。*

	类型	默认值	详情
h	int		预测范围
loss	MAE	MAE()	实例化自损失函数集合的训练损失类。
valid_loss	NoneType	None	实例化自损失函数集合的验证损失类。
config	NoneType	None	包含 ray.tune 定义的搜索空间的字典或接受 optuna trial 并返回配置字典的函数。
search_alg	BasicVariantGenerator	<ray.tune.search.basic_variant.BasicVariantGenerator object at 0x7f6f2ffe2140>	关于 ray，请参阅https://docs.rayai.org.cn/en/latest/tune/api_docs/suggestion.html 关于 optuna，请参阅https://docs.optuna.cn/en/stable/reference/samplers/index.html。
num_samples	int	10	超参数优化步骤/样本的数量。
refit_with_val	bool	False	最佳模型的重新训练应保留 val_size。
cpus	int	4	优化期间使用的 cpu 数量。仅与 ray tune 一起使用。
gpus	int	0	优化期间使用的 gpu 数量，默认为所有可用 gpu。仅与 ray tune 一起使用。
verbose	bool	False	跟踪进度。
alias	NoneType	None	模型的自定义名称。
backend	str	ray	用于搜索超参数空间的后端，可以是“ray”或“optuna”。
callbacks	NoneType	None	优化过程中要调用的函数列表。 ray 参考：https://docs.rayai.org.cn/en/latest/tune/tutorials/tune-metrics.html optuna 参考：https://docs.optuna.cn/en/stable/tutorial/20_recipes/007_optuna_callback.html

# Use your own config or AutoNBEATS.default_config
config = dict(max_steps=1, val_check_steps=1, input_size=12,
              mlp_units=3*[[8, 8]])
model = AutoNBEATS(h=12, config=config, num_samples=1, cpus=1)

# Fit and predict
model.fit(dataset=dataset)
y_hat = model.predict(dataset=dataset)

# Optuna
model = AutoNBEATS(h=12, config=None, backend='optuna')

源

AutoNBEATSx

 AutoNBEATSx (h, loss=MAE(), valid_loss=None, config=None,
              search_alg=<ray.tune.search.basic_variant.BasicVariantGenera
              tor object at 0x7f6f34170a00>, num_samples=10,
              refit_with_val=False, cpus=4, gpus=0, verbose=False,
              alias=None, backend='ray', callbacks=None)

*用于自动超参数优化的类，它基于 ray 构建，提供了多种超参数优化工具，包括经典的网格搜索、贝叶斯优化和 HyperBand 算法。

要优化的验证损失由 config['loss'] 字典值定义，config 还包含其余的超参数搜索空间。

需要注意的是，超参数优化的成功很大程度上取决于验证期和测试期之间存在强相关性。*

	类型	默认值	详情
h	int		预测范围
loss	MAE	MAE()	实例化自损失函数集合的训练损失类。
valid_loss	NoneType	None	实例化自损失函数集合的验证损失类。
config	NoneType	None	包含 ray.tune 定义的搜索空间的字典或接受 optuna trial 并返回配置字典的函数。
search_alg	BasicVariantGenerator	<ray.tune.search.basic_variant.BasicVariantGenerator object at 0x7f6f34170a00>	关于 ray，请参阅https://docs.rayai.org.cn/en/latest/tune/api_docs/suggestion.html 关于 optuna，请参阅https://docs.optuna.cn/en/stable/reference/samplers/index.html。
num_samples	int	10	超参数优化步骤/样本的数量。
refit_with_val	bool	False	最佳模型的重新训练应保留 val_size。
cpus	int	4	优化期间使用的 cpu 数量。仅与 ray tune 一起使用。
gpus	int	0	优化期间使用的 gpu 数量，默认为所有可用 gpu。仅与 ray tune 一起使用。
verbose	bool	False	跟踪进度。
alias	NoneType	None	模型的自定义名称。
backend	str	ray	用于搜索超参数空间的后端，可以是“ray”或“optuna”。
callbacks	NoneType	None	优化过程中要调用的函数列表。 ray 参考：https://docs.rayai.org.cn/en/latest/tune/tutorials/tune-metrics.html optuna 参考：https://docs.optuna.cn/en/stable/tutorial/20_recipes/007_optuna_callback.html

# Use your own config or AutoNBEATSx.default_config
config = dict(max_steps=1, val_check_steps=1, input_size=12,
              mlp_units=3*[[8, 8]])
model = AutoNBEATSx(h=12, config=config, num_samples=1, cpus=1)

# Fit and predict
model.fit(dataset=dataset)
y_hat = model.predict(dataset=dataset)

# Optuna
model = AutoNBEATSx(h=12, config=None, backend='optuna')

源

AutoNHITS

 AutoNHITS (h, loss=MAE(), valid_loss=None, config=None,
            search_alg=<ray.tune.search.basic_variant.BasicVariantGenerato
            r object at 0x7f6f2ffc0af0>, num_samples=10,
            refit_with_val=False, cpus=4, gpus=0, verbose=False,
            alias=None, backend='ray', callbacks=None)

*用于自动超参数优化的类，它基于 ray 构建，提供了多种超参数优化工具，包括经典的网格搜索、贝叶斯优化和 HyperBand 算法。

要优化的验证损失由 config['loss'] 字典值定义，config 还包含其余的超参数搜索空间。

需要注意的是，超参数优化的成功很大程度上取决于验证期和测试期之间存在强相关性。*

	类型	默认值	详情
h	int		预测范围
loss	MAE	MAE()	实例化自损失函数集合的训练损失类。
valid_loss	NoneType	None	实例化自损失函数集合的验证损失类。
config	NoneType	None	包含 ray.tune 定义的搜索空间的字典或接受 optuna trial 并返回配置字典的函数。
search_alg	BasicVariantGenerator	<ray.tune.search.basic_variant.BasicVariantGenerator object at 0x7f6f2ffc0af0>	关于 ray，请参阅https://docs.rayai.org.cn/en/latest/tune/api_docs/suggestion.html 关于 optuna，请参阅https://docs.optuna.cn/en/stable/reference/samplers/index.html。
num_samples	int	10	超参数优化步骤/样本的数量。
refit_with_val	bool	False	最佳模型的重新训练应保留 val_size。
cpus	int	4	优化期间使用的 cpu 数量。仅与 ray tune 一起使用。
gpus	int	0	优化期间使用的 gpu 数量，默认为所有可用 gpu。仅与 ray tune 一起使用。
verbose	bool	False	跟踪进度。
alias	NoneType	None	模型的自定义名称。
backend	str	ray	用于搜索超参数空间的后端，可以是“ray”或“optuna”。
callbacks	NoneType	None	优化过程中要调用的函数列表。 ray 参考：https://docs.rayai.org.cn/en/latest/tune/tutorials/tune-metrics.html optuna 参考：https://docs.optuna.cn/en/stable/tutorial/20_recipes/007_optuna_callback.html

# Use your own config or AutoNHITS.default_config
config = dict(max_steps=1, val_check_steps=1, input_size=12, 
              mlp_units=3 * [[8, 8]])
model = AutoNHITS(h=12, config=config, num_samples=1, cpus=1)

# Fit and predict
model.fit(dataset=dataset)
y_hat = model.predict(dataset=dataset)

# Optuna
model = AutoNHITS(h=12, config=None, backend='optuna')

源

AutoDLinear

 AutoDLinear (h, loss=MAE(), valid_loss=None, config=None,
              search_alg=<ray.tune.search.basic_variant.BasicVariantGenera
              tor object at 0x7f6f2ff97310>, num_samples=10,
              refit_with_val=False, cpus=4, gpus=0, verbose=False,
              alias=None, backend='ray', callbacks=None)

*用于自动超参数优化的类，它基于 ray 构建，提供了多种超参数优化工具，包括经典的网格搜索、贝叶斯优化和 HyperBand 算法。

要优化的验证损失由 config['loss'] 字典值定义，config 还包含其余的超参数搜索空间。

需要注意的是，超参数优化的成功很大程度上取决于验证期和测试期之间存在强相关性。*

	类型	默认值	详情
h	int		预测范围
loss	MAE	MAE()	实例化自损失函数集合的训练损失类。
valid_loss	NoneType	None	实例化自损失函数集合的验证损失类。
config	NoneType	None	包含 ray.tune 定义的搜索空间的字典或接受 optuna trial 并返回配置字典的函数。
search_alg	BasicVariantGenerator	<ray.tune.search.basic_variant.BasicVariantGenerator object at 0x7f6f2ff97310>	关于 ray，请参阅https://docs.rayai.org.cn/en/latest/tune/api_docs/suggestion.html 关于 optuna，请参阅https://docs.optuna.cn/en/stable/reference/samplers/index.html。
num_samples	int	10	超参数优化步骤/样本的数量。
refit_with_val	bool	False	最佳模型的重新训练应保留 val_size。
cpus	int	4	优化期间使用的 cpu 数量。仅与 ray tune 一起使用。
gpus	int	0	优化期间使用的 gpu 数量，默认为所有可用 gpu。仅与 ray tune 一起使用。
verbose	bool	False	跟踪进度。
alias	NoneType	None	模型的自定义名称。
backend	str	ray	用于搜索超参数空间的后端，可以是“ray”或“optuna”。
callbacks	NoneType	None	优化过程中要调用的函数列表。 ray 参考：https://docs.rayai.org.cn/en/latest/tune/tutorials/tune-metrics.html optuna 参考：https://docs.optuna.cn/en/stable/tutorial/20_recipes/007_optuna_callback.html

# Use your own config or AutoDLinear.default_config
config = dict(max_steps=1, val_check_steps=1, input_size=12)
model = AutoDLinear(h=12, config=config, num_samples=1, cpus=1)

# Fit and predict
model.fit(dataset=dataset)
y_hat = model.predict(dataset=dataset)

# Optuna
model = AutoDLinear(h=12, config=None, backend='optuna')

源

AutoNLinear

 AutoNLinear (h, loss=MAE(), valid_loss=None, config=None,
              search_alg=<ray.tune.search.basic_variant.BasicVariantGenera
              tor object at 0x7f6f2ff234c0>, num_samples=10,
              refit_with_val=False, cpus=4, gpus=0, verbose=False,
              alias=None, backend='ray', callbacks=None)

*用于自动超参数优化的类，它基于 ray 构建，提供了多种超参数优化工具，包括经典的网格搜索、贝叶斯优化和 HyperBand 算法。

要优化的验证损失由 config['loss'] 字典值定义，config 还包含其余的超参数搜索空间。

需要注意的是，超参数优化的成功很大程度上取决于验证期和测试期之间存在强相关性。*

	类型	默认值	详情
h	int		预测范围
loss	MAE	MAE()	实例化自损失函数集合的训练损失类。
valid_loss	NoneType	None	实例化自损失函数集合的验证损失类。
config	NoneType	None	包含 ray.tune 定义的搜索空间的字典或接受 optuna trial 并返回配置字典的函数。
search_alg	BasicVariantGenerator	<ray.tune.search.basic_variant.BasicVariantGenerator object at 0x7f6f2ff234c0>	关于 ray，请参阅https://docs.rayai.org.cn/en/latest/tune/api_docs/suggestion.html 关于 optuna，请参阅https://docs.optuna.cn/en/stable/reference/samplers/index.html。
num_samples	int	10	超参数优化步骤/样本的数量。
refit_with_val	bool	False	最佳模型的重新训练应保留 val_size。
cpus	int	4	优化期间使用的 cpu 数量。仅与 ray tune 一起使用。
gpus	int	0	优化期间使用的 gpu 数量，默认为所有可用 gpu。仅与 ray tune 一起使用。
verbose	bool	False	跟踪进度。
alias	NoneType	None	模型的自定义名称。
backend	str	ray	用于搜索超参数空间的后端，可以是“ray”或“optuna”。
callbacks	NoneType	None	优化过程中要调用的函数列表。 ray 参考：https://docs.rayai.org.cn/en/latest/tune/tutorials/tune-metrics.html optuna 参考：https://docs.optuna.cn/en/stable/tutorial/20_recipes/007_optuna_callback.html

# Use your own config or AutoNLinear.default_config
config = dict(max_steps=1, val_check_steps=1, input_size=12)
model = AutoNLinear(h=12, config=config, num_samples=1, cpus=1)

# Fit and predict
model.fit(dataset=dataset)
y_hat = model.predict(dataset=dataset)

# Optuna
model = AutoNLinear(h=12, config=None, backend='optuna')

源

AutoTiDE

 AutoTiDE (h, loss=MAE(), valid_loss=None, config=None,
           search_alg=<ray.tune.search.basic_variant.BasicVariantGenerator
           object at 0x7f6f2ff85540>, num_samples=10,
           refit_with_val=False, cpus=4, gpus=0, verbose=False,
           alias=None, backend='ray', callbacks=None)

*用于自动超参数优化的类，它基于 ray 构建，提供了多种超参数优化工具，包括经典的网格搜索、贝叶斯优化和 HyperBand 算法。

要优化的验证损失由 config['loss'] 字典值定义，config 还包含其余的超参数搜索空间。

需要注意的是，超参数优化的成功很大程度上取决于验证期和测试期之间存在强相关性。*

	类型	默认值	详情
h	int		预测范围
loss	MAE	MAE()	实例化自损失函数集合的训练损失类。
valid_loss	NoneType	None	实例化自损失函数集合的验证损失类。
config	NoneType	None	包含 ray.tune 定义的搜索空间的字典或接受 optuna trial 并返回配置字典的函数。
search_alg	BasicVariantGenerator	<ray.tune.search.basic_variant.BasicVariantGenerator object at 0x7f6f2ff85540>	关于 ray，请参阅https://docs.rayai.org.cn/en/latest/tune/api_docs/suggestion.html 关于 optuna，请参阅https://docs.optuna.cn/en/stable/reference/samplers/index.html。
num_samples	int	10	超参数优化步骤/样本的数量。
refit_with_val	bool	False	最佳模型的重新训练应保留 val_size。
cpus	int	4	优化期间使用的 cpu 数量。仅与 ray tune 一起使用。
gpus	int	0	优化期间使用的 gpu 数量，默认为所有可用 gpu。仅与 ray tune 一起使用。
verbose	bool	False	跟踪进度。
alias	NoneType	None	模型的自定义名称。
backend	str	ray	用于搜索超参数空间的后端，可以是“ray”或“optuna”。
callbacks	NoneType	None	优化过程中要调用的函数列表。 ray 参考：https://docs.rayai.org.cn/en/latest/tune/tutorials/tune-metrics.html optuna 参考：https://docs.optuna.cn/en/stable/tutorial/20_recipes/007_optuna_callback.html

# Use your own config or AutoTiDE.default_config
config = dict(max_steps=1, val_check_steps=1, input_size=12)
model = AutoTiDE(h=12, config=config, num_samples=1, cpus=1)

# Fit and predict
model.fit(dataset=dataset)
y_hat = model.predict(dataset=dataset)

# Optuna
model = AutoTiDE(h=12, config=None, backend='optuna')

源

AutoDeepNPTS

 AutoDeepNPTS (h, loss=MAE(), valid_loss=None, config=None,
               search_alg=<ray.tune.search.basic_variant.BasicVariantGener
               ator object at 0x7f6f34126dd0>, num_samples=10,
               refit_with_val=False, cpus=4, gpus=0, verbose=False,
               alias=None, backend='ray', callbacks=None)

*用于自动超参数优化的类，它基于 ray 构建，提供了多种超参数优化工具，包括经典的网格搜索、贝叶斯优化和 HyperBand 算法。

要优化的验证损失由 config['loss'] 字典值定义，config 还包含其余的超参数搜索空间。

需要注意的是，超参数优化的成功很大程度上取决于验证期和测试期之间存在强相关性。*

	类型	默认值	详情
h	int		预测范围
loss	MAE	MAE()	实例化自损失函数集合的训练损失类。
valid_loss	NoneType	None	实例化自损失函数集合的验证损失类。
config	NoneType	None	包含 ray.tune 定义的搜索空间的字典或接受 optuna trial 并返回配置字典的函数。
search_alg	BasicVariantGenerator	<ray.tune.search.basic_variant.BasicVariantGenerator object at 0x7f6f34126dd0>	关于 ray，请参阅https://docs.rayai.org.cn/en/latest/tune/api_docs/suggestion.html 关于 optuna，请参阅https://docs.optuna.cn/en/stable/reference/samplers/index.html。
num_samples	int	10	超参数优化步骤/样本的数量。
refit_with_val	bool	False	最佳模型的重新训练应保留 val_size。
cpus	int	4	优化期间使用的 cpu 数量。仅与 ray tune 一起使用。
gpus	int	0	优化期间使用的 gpu 数量，默认为所有可用 gpu。仅与 ray tune 一起使用。
verbose	bool	False	跟踪进度。
alias	NoneType	None	模型的自定义名称。
backend	str	ray	用于搜索超参数空间的后端，可以是“ray”或“optuna”。
callbacks	NoneType	None	优化过程中要调用的函数列表。 ray 参考：https://docs.rayai.org.cn/en/latest/tune/tutorials/tune-metrics.html optuna 参考：https://docs.optuna.cn/en/stable/tutorial/20_recipes/007_optuna_callback.html

# Use your own config or AutoDeepNPTS.default_config
config = dict(max_steps=1, val_check_steps=1, input_size=12)
model = AutoDeepNPTS(h=12, config=config, num_samples=1, cpus=1)

# Fit and predict
model.fit(dataset=dataset)
y_hat = model.predict(dataset=dataset)

# Optuna
model = AutoDeepNPTS(h=12, config=None, backend='optuna')

C. 基于 KAN 的模型

源

AutoKAN

 AutoKAN (h, loss=MAE(), valid_loss=None, config=None,
          search_alg=<ray.tune.search.basic_variant.BasicVariantGenerator
          object at 0x7f6f2ff73a60>, num_samples=10, refit_with_val=False,
          cpus=4, gpus=0, verbose=False, alias=None, backend='ray',
          callbacks=None)

*用于自动超参数优化的类，它基于 ray 构建，提供了多种超参数优化工具，包括经典的网格搜索、贝叶斯优化和 HyperBand 算法。

要优化的验证损失由 config['loss'] 字典值定义，config 还包含其余的超参数搜索空间。

需要注意的是，超参数优化的成功很大程度上取决于验证期和测试期之间存在强相关性。*

	类型	默认值	详情
h	int		预测范围
loss	MAE	MAE()	实例化自损失函数集合的训练损失类。
valid_loss	NoneType	None	实例化自损失函数集合的验证损失类。
config	NoneType	None	包含 ray.tune 定义的搜索空间的字典或接受 optuna trial 并返回配置字典的函数。
search_alg	BasicVariantGenerator	<ray.tune.search.basic_variant.BasicVariantGenerator object at 0x7f6f2ff73a60>	关于 ray，请参阅https://docs.rayai.org.cn/en/latest/tune/api_docs/suggestion.html 关于 optuna，请参阅https://docs.optuna.cn/en/stable/reference/samplers/index.html。
num_samples	int	10	超参数优化步骤/样本的数量。
refit_with_val	bool	False	最佳模型的重新训练应保留 val_size。
cpus	int	4	优化期间使用的 cpu 数量。仅与 ray tune 一起使用。
gpus	int	0	优化期间使用的 gpu 数量，默认为所有可用 gpu。仅与 ray tune 一起使用。
verbose	bool	False	跟踪进度。
alias	NoneType	None	模型的自定义名称。
backend	str	ray	用于搜索超参数空间的后端，可以是“ray”或“optuna”。
callbacks	NoneType	None	优化过程中要调用的函数列表。 ray 参考：https://docs.rayai.org.cn/en/latest/tune/tutorials/tune-metrics.html optuna 参考：https://docs.optuna.cn/en/stable/tutorial/20_recipes/007_optuna_callback.html

# Use your own config or AutoKAN.default_config
config = dict(max_steps=1, val_check_steps=1, input_size=12)
model = AutoKAN(h=12, config=config, num_samples=1, cpus=1)

# Fit and predict
model.fit(dataset=dataset)
y_hat = model.predict(dataset=dataset)

# Optuna
model = AutoKAN(h=12, config=None, backend='optuna')

D. 基于 Transformer 的模型

源

AutoTFT

 AutoTFT (h, loss=MAE(), valid_loss=None, config=None,
          search_alg=<ray.tune.search.basic_variant.BasicVariantGenerator
          object at 0x7f6f2ff86470>, num_samples=10, refit_with_val=False,
          cpus=4, gpus=0, verbose=False, alias=None, backend='ray',
          callbacks=None)

*用于自动超参数优化的类，它基于 ray 构建，提供了多种超参数优化工具，包括经典的网格搜索、贝叶斯优化和 HyperBand 算法。

要优化的验证损失由 config['loss'] 字典值定义，config 还包含其余的超参数搜索空间。

需要注意的是，超参数优化的成功很大程度上取决于验证期和测试期之间存在强相关性。*

	类型	默认值	详情
h	int		预测范围
loss	MAE	MAE()	实例化自损失函数集合的训练损失类。
valid_loss	NoneType	None	实例化自损失函数集合的验证损失类。
config	NoneType	None	包含 ray.tune 定义的搜索空间的字典或接受 optuna trial 并返回配置字典的函数。
search_alg	BasicVariantGenerator	<ray.tune.search.basic_variant.BasicVariantGenerator object at 0x7f6f2ff86470>	关于 ray，请参阅https://docs.rayai.org.cn/en/latest/tune/api_docs/suggestion.html 关于 optuna，请参阅https://docs.optuna.cn/en/stable/reference/samplers/index.html。
num_samples	int	10	超参数优化步骤/样本的数量。
refit_with_val	bool	False	最佳模型的重新训练应保留 val_size。
cpus	int	4	优化期间使用的 cpu 数量。仅与 ray tune 一起使用。
gpus	int	0	优化期间使用的 gpu 数量，默认为所有可用 gpu。仅与 ray tune 一起使用。
verbose	bool	False	跟踪进度。
alias	NoneType	None	模型的自定义名称。
backend	str	ray	用于搜索超参数空间的后端，可以是“ray”或“optuna”。
callbacks	NoneType	None	优化过程中要调用的函数列表。 ray 参考：https://docs.rayai.org.cn/en/latest/tune/tutorials/tune-metrics.html optuna 参考：https://docs.optuna.cn/en/stable/tutorial/20_recipes/007_optuna_callback.html

# Use your own config or AutoTFT.default_config
config = dict(max_steps=1, val_check_steps=1, input_size=12, hidden_size=8)
model = AutoTFT(h=12, config=config, num_samples=1, cpus=1)

# Fit and predict
model.fit(dataset=dataset)
y_hat = model.predict(dataset=dataset)

# Optuna
model = AutoTFT(h=12, config=None, backend='optuna')

源

AutoVanillaTransformer

 AutoVanillaTransformer (h, loss=MAE(), valid_loss=None, config=None,
                         search_alg=<ray.tune.search.basic_variant.BasicVa
                         riantGenerator object at 0x7f6f34111ba0>,
                         num_samples=10, refit_with_val=False, cpus=4,
                         gpus=0, verbose=False, alias=None, backend='ray',
                         callbacks=None)

*用于自动超参数优化的类，它基于 ray 构建，提供了多种超参数优化工具，包括经典的网格搜索、贝叶斯优化和 HyperBand 算法。

要优化的验证损失由 config['loss'] 字典值定义，config 还包含其余的超参数搜索空间。

需要注意的是，超参数优化的成功很大程度上取决于验证期和测试期之间存在强相关性。*

	类型	默认值	详情
h	int		预测范围
loss	MAE	MAE()	实例化自损失函数集合的训练损失类。
valid_loss	NoneType	None	实例化自损失函数集合的验证损失类。
config	NoneType	None	包含 ray.tune 定义的搜索空间的字典或接受 optuna trial 并返回配置字典的函数。
search_alg	BasicVariantGenerator	<ray.tune.search.basic_variant.BasicVariantGenerator object at 0x7f6f34111ba0>	关于 ray，请参阅https://docs.rayai.org.cn/en/latest/tune/api_docs/suggestion.html 关于 optuna，请参阅https://docs.optuna.cn/en/stable/reference/samplers/index.html。
num_samples	int	10	超参数优化步骤/样本的数量。
refit_with_val	bool	False	最佳模型的重新训练应保留 val_size。
cpus	int	4	优化期间使用的 cpu 数量。仅与 ray tune 一起使用。
gpus	int	0	优化期间使用的 gpu 数量，默认为所有可用 gpu。仅与 ray tune 一起使用。
verbose	bool	False	跟踪进度。
alias	NoneType	None	模型的自定义名称。
backend	str	ray	用于搜索超参数空间的后端，可以是“ray”或“optuna”。
callbacks	NoneType	None	优化过程中要调用的函数列表。 ray 参考：https://docs.rayai.org.cn/en/latest/tune/tutorials/tune-metrics.html optuna 参考：https://docs.optuna.cn/en/stable/tutorial/20_recipes/007_optuna_callback.html

# Use your own config or AutoVanillaTransformer.default_config
config = dict(max_steps=1, val_check_steps=1, input_size=12, hidden_size=8)
model = AutoVanillaTransformer(h=12, config=config, num_samples=1, cpus=1)

# Fit and predict
model.fit(dataset=dataset)
y_hat = model.predict(dataset=dataset)

# Optuna
model = AutoVanillaTransformer(h=12, config=None, backend='optuna')

源

AutoInformer

 AutoInformer (h, loss=MAE(), valid_loss=None, config=None,
               search_alg=<ray.tune.search.basic_variant.BasicVariantGener
               ator object at 0x7f6f2ff4d270>, num_samples=10,
               refit_with_val=False, cpus=4, gpus=0, verbose=False,
               alias=None, backend='ray', callbacks=None)

*用于自动超参数优化的类，它基于 ray 构建，提供了多种超参数优化工具，包括经典的网格搜索、贝叶斯优化和 HyperBand 算法。

要优化的验证损失由 config['loss'] 字典值定义，config 还包含其余的超参数搜索空间。

需要注意的是，超参数优化的成功很大程度上取决于验证期和测试期之间存在强相关性。*

	类型	默认值	详情
h	int		预测范围
loss	MAE	MAE()	实例化自损失函数集合的训练损失类。
valid_loss	NoneType	None	实例化自损失函数集合的验证损失类。
config	NoneType	None	包含 ray.tune 定义的搜索空间的字典或接受 optuna trial 并返回配置字典的函数。
search_alg	BasicVariantGenerator	<ray.tune.search.basic_variant.BasicVariantGenerator object at 0x7f6f2ff4d270>	关于 ray，请参阅https://docs.rayai.org.cn/en/latest/tune/api_docs/suggestion.html 关于 optuna，请参阅https://docs.optuna.cn/en/stable/reference/samplers/index.html。
num_samples	int	10	超参数优化步骤/样本的数量。
refit_with_val	bool	False	最佳模型的重新训练应保留 val_size。
cpus	int	4	优化期间使用的 cpu 数量。仅与 ray tune 一起使用。
gpus	int	0	优化期间使用的 gpu 数量，默认为所有可用 gpu。仅与 ray tune 一起使用。
verbose	bool	False	跟踪进度。
alias	NoneType	None	模型的自定义名称。
backend	str	ray	用于搜索超参数空间的后端，可以是“ray”或“optuna”。
callbacks	NoneType	None	优化过程中要调用的函数列表。 ray 参考：https://docs.rayai.org.cn/en/latest/tune/tutorials/tune-metrics.html optuna 参考：https://docs.optuna.cn/en/stable/tutorial/20_recipes/007_optuna_callback.html

# Use your own config or AutoInformer.default_config
config = dict(max_steps=1, val_check_steps=1, input_size=12, hidden_size=8)
model = AutoInformer(h=12, config=config, num_samples=1, cpus=1)

# Fit and predict
model.fit(dataset=dataset)
y_hat = model.predict(dataset=dataset)

# Optuna
model = AutoInformer(h=12, config=None, backend='optuna')

源

AutoAutoformer

 AutoAutoformer (h, loss=MAE(), valid_loss=None, config=None,
                 search_alg=<ray.tune.search.basic_variant.BasicVariantGen
                 erator object at 0x7f6f2ff22e60>, num_samples=10,
                 refit_with_val=False, cpus=4, gpus=0, verbose=False,
                 alias=None, backend='ray', callbacks=None)

*用于自动超参数优化的类，它基于 ray 构建，提供了多种超参数优化工具，包括经典的网格搜索、贝叶斯优化和 HyperBand 算法。

要优化的验证损失由 config['loss'] 字典值定义，config 还包含其余的超参数搜索空间。

需要注意的是，超参数优化的成功很大程度上取决于验证期和测试期之间存在强相关性。*

	类型	默认值	详情
h	int		预测范围
loss	MAE	MAE()	实例化自损失函数集合的训练损失类。
valid_loss	NoneType	None	实例化自损失函数集合的验证损失类。
config	NoneType	None	包含 ray.tune 定义的搜索空间的字典或接受 optuna trial 并返回配置字典的函数。
search_alg	BasicVariantGenerator	<ray.tune.search.basic_variant.BasicVariantGenerator object at 0x7f6f2ff22e60>	关于 ray，请参阅https://docs.rayai.org.cn/en/latest/tune/api_docs/suggestion.html 关于 optuna，请参阅https://docs.optuna.cn/en/stable/reference/samplers/index.html。
num_samples	int	10	超参数优化步骤/样本的数量。
refit_with_val	bool	False	最佳模型的重新训练应保留 val_size。
cpus	int	4	优化期间使用的 cpu 数量。仅与 ray tune 一起使用。
gpus	int	0	优化期间使用的 gpu 数量，默认为所有可用 gpu。仅与 ray tune 一起使用。
verbose	bool	False	跟踪进度。
alias	NoneType	None	模型的自定义名称。
backend	str	ray	用于搜索超参数空间的后端，可以是“ray”或“optuna”。
callbacks	NoneType	None	优化过程中要调用的函数列表。 ray 参考：https://docs.rayai.org.cn/en/latest/tune/tutorials/tune-metrics.html optuna 参考：https://docs.optuna.cn/en/stable/tutorial/20_recipes/007_optuna_callback.html

# Use your own config or AutoAutoformer.default_config
config = dict(max_steps=1, val_check_steps=1, input_size=12, hidden_size=8)
model = AutoAutoformer(h=12, config=config, num_samples=1, cpus=1)

# Fit and predict
model.fit(dataset=dataset)
y_hat = model.predict(dataset=dataset)

# Optuna
model = AutoAutoformer(h=12, config=None, backend='optuna')

源

AutoFEDformer

 AutoFEDformer (h, loss=MAE(), valid_loss=None, config=None,
                search_alg=<ray.tune.search.basic_variant.BasicVariantGene
                rator object at 0x7f6f340fe2c0>, num_samples=10,
                refit_with_val=False, cpus=4, gpus=0, verbose=False,
                alias=None, backend='ray', callbacks=None)

*用于自动超参数优化的类，它基于 ray 构建，提供了多种超参数优化工具，包括经典的网格搜索、贝叶斯优化和 HyperBand 算法。

要优化的验证损失由 config['loss'] 字典值定义，config 还包含其余的超参数搜索空间。

需要注意的是，超参数优化的成功很大程度上取决于验证期和测试期之间存在强相关性。*

	类型	默认值	详情
h	int		预测范围
loss	MAE	MAE()	实例化自损失函数集合的训练损失类。
valid_loss	NoneType	None	实例化自损失函数集合的验证损失类。
config	NoneType	None	包含 ray.tune 定义的搜索空间的字典或接受 optuna trial 并返回配置字典的函数。
search_alg	BasicVariantGenerator	<ray.tune.search.basic_variant.BasicVariantGenerator object at 0x7f6f340fe2c0>	关于 ray，请参阅https://docs.rayai.org.cn/en/latest/tune/api_docs/suggestion.html 关于 optuna，请参阅https://docs.optuna.cn/en/stable/reference/samplers/index.html。
num_samples	int	10	超参数优化步骤/样本的数量。
refit_with_val	bool	False	最佳模型的重新训练应保留 val_size。
cpus	int	4	优化期间使用的 cpu 数量。仅与 ray tune 一起使用。
gpus	int	0	优化期间使用的 gpu 数量，默认为所有可用 gpu。仅与 ray tune 一起使用。
verbose	bool	False	跟踪进度。
alias	NoneType	None	模型的自定义名称。
backend	str	ray	用于搜索超参数空间的后端，可以是“ray”或“optuna”。
callbacks	NoneType	None	优化过程中要调用的函数列表。 ray 参考：https://docs.rayai.org.cn/en/latest/tune/tutorials/tune-metrics.html optuna 参考：https://docs.optuna.cn/en/stable/tutorial/20_recipes/007_optuna_callback.html

# Use your own config or AutoFEDFormer.default_config
config = dict(max_steps=1, val_check_steps=1, input_size=12, hidden_size=64)
model = AutoFEDformer(h=12, config=config, num_samples=1, cpus=1)

# Fit and predict
model.fit(dataset=dataset)
y_hat = model.predict(dataset=dataset)

# Optuna
model = AutoFEDformer(h=12, config=None, backend='optuna')

源

AutoPatchTST

 AutoPatchTST (h, loss=MAE(), valid_loss=None, config=None,
               search_alg=<ray.tune.search.basic_variant.BasicVariantGener
               ator object at 0x7f6f3416ae00>, num_samples=10,
               refit_with_val=False, cpus=4, gpus=0, verbose=False,
               alias=None, backend='ray', callbacks=None)

*用于自动超参数优化的类，它基于 ray 构建，提供了多种超参数优化工具，包括经典的网格搜索、贝叶斯优化和 HyperBand 算法。

要优化的验证损失由 config['loss'] 字典值定义，config 还包含其余的超参数搜索空间。

需要注意的是，超参数优化的成功很大程度上取决于验证期和测试期之间存在强相关性。*

	类型	默认值	详情
h	int		预测范围
loss	MAE	MAE()	实例化自损失函数集合的训练损失类。
valid_loss	NoneType	None	实例化自损失函数集合的验证损失类。
config	NoneType	None	包含 ray.tune 定义的搜索空间的字典或接受 optuna trial 并返回配置字典的函数。
search_alg	BasicVariantGenerator	<ray.tune.search.basic_variant.BasicVariantGenerator object at 0x7f6f3416ae00>	关于 ray，请参阅https://docs.rayai.org.cn/en/latest/tune/api_docs/suggestion.html 关于 optuna，请参阅https://docs.optuna.cn/en/stable/reference/samplers/index.html。
num_samples	int	10	超参数优化步骤/样本的数量。
refit_with_val	bool	False	最佳模型的重新训练应保留 val_size。
cpus	int	4	优化期间使用的 cpu 数量。仅与 ray tune 一起使用。
gpus	int	0	优化期间使用的 gpu 数量，默认为所有可用 gpu。仅与 ray tune 一起使用。
verbose	bool	False	跟踪进度。
alias	NoneType	None	模型的自定义名称。
backend	str	ray	用于搜索超参数空间的后端，可以是“ray”或“optuna”。
callbacks	NoneType	None	优化过程中要调用的函数列表。 ray 参考：https://docs.rayai.org.cn/en/latest/tune/tutorials/tune-metrics.html optuna 参考：https://docs.optuna.cn/en/stable/tutorial/20_recipes/007_optuna_callback.html

# Use your own config or AutoPatchTST.default_config
config = dict(max_steps=1, val_check_steps=1, input_size=12, hidden_size=16)
model = AutoPatchTST(h=12, config=config, num_samples=1, cpus=1)

# Fit and predict
model.fit(dataset=dataset)
y_hat = model.predict(dataset=dataset)

# Optuna
model = AutoPatchTST(h=12, config=None, backend='optuna')

源

AutoiTransformer

 AutoiTransformer (h, n_series, loss=MAE(), valid_loss=None, config=None,
                   search_alg=<ray.tune.search.basic_variant.BasicVariantG
                   enerator object at 0x7f6f3416b610>, num_samples=10,
                   refit_with_val=False, cpus=4, gpus=0, verbose=False,
                   alias=None, backend='ray', callbacks=None)

*用于自动超参数优化的类，它基于 ray 构建，提供了多种超参数优化工具，包括经典的网格搜索、贝叶斯优化和 HyperBand 算法。

要优化的验证损失由 config['loss'] 字典值定义，config 还包含其余的超参数搜索空间。

需要注意的是，超参数优化的成功很大程度上取决于验证期和测试期之间存在强相关性。*

	类型	默认值	详情
h	int		预测范围
n_series
loss	MAE	MAE()	实例化自损失函数集合的训练损失类。
valid_loss	NoneType	None	实例化自损失函数集合的验证损失类。
config	NoneType	None	包含 ray.tune 定义的搜索空间的字典或接受 optuna trial 并返回配置字典的函数。
search_alg	BasicVariantGenerator	<ray.tune.search.basic_variant.BasicVariantGenerator object at 0x7f6f3416b610>	关于 ray，请参阅https://docs.rayai.org.cn/en/latest/tune/api_docs/suggestion.html 关于 optuna，请参阅https://docs.optuna.cn/en/stable/reference/samplers/index.html。
num_samples	int	10	超参数优化步骤/样本的数量。
refit_with_val	bool	False	最佳模型的重新训练应保留 val_size。
cpus	int	4	优化期间使用的 cpu 数量。仅与 ray tune 一起使用。
gpus	int	0	优化期间使用的 gpu 数量，默认为所有可用 gpu。仅与 ray tune 一起使用。
verbose	bool	False	跟踪进度。
alias	NoneType	None	模型的自定义名称。
backend	str	ray	用于搜索超参数空间的后端，可以是“ray”或“optuna”。
callbacks	NoneType	None	优化过程中要调用的函数列表。 ray 参考：https://docs.rayai.org.cn/en/latest/tune/tutorials/tune-metrics.html optuna 参考：https://docs.optuna.cn/en/stable/tutorial/20_recipes/007_optuna_callback.html

# Use your own config or AutoiTransformer.default_config
config = dict(max_steps=1, val_check_steps=1, input_size=12, hidden_size=16)
model = AutoiTransformer(h=12, n_series=1, config=config, num_samples=1, cpus=1)

# Fit and predict
model.fit(dataset=dataset)
y_hat = model.predict(dataset=dataset)

# Optuna
model = AutoiTransformer(h=12, n_series=1, config=None, backend='optuna')

源

AutoTimeXer

 AutoTimeXer (h, n_series, loss=MAE(), valid_loss=None, config=None,
              search_alg=<ray.tune.search.basic_variant.BasicVariantGenera
              tor object at 0x7f6f340fdff0>, num_samples=10,
              refit_with_val=False, cpus=4, gpus=0, verbose=False,
              alias=None, backend='ray', callbacks=None)

*用于自动超参数优化的类，它基于 ray 构建，提供了多种超参数优化工具，包括经典的网格搜索、贝叶斯优化和 HyperBand 算法。

要优化的验证损失由 config['loss'] 字典值定义，config 还包含其余的超参数搜索空间。

需要注意的是，超参数优化的成功很大程度上取决于验证期和测试期之间存在强相关性。*

	类型	默认值	详情
h	int		预测范围
n_series
loss	MAE	MAE()	实例化自损失函数集合的训练损失类。
valid_loss	NoneType	None	实例化自损失函数集合的验证损失类。
config	NoneType	None	包含 ray.tune 定义的搜索空间的字典或接受 optuna trial 并返回配置字典的函数。
search_alg	BasicVariantGenerator	<ray.tune.search.basic_variant.BasicVariantGenerator object at 0x7f6f340fdff0>	关于 ray，请参阅https://docs.rayai.org.cn/en/latest/tune/api_docs/suggestion.html 关于 optuna，请参阅https://docs.optuna.cn/en/stable/reference/samplers/index.html。
num_samples	int	10	超参数优化步骤/样本的数量。
refit_with_val	bool	False	最佳模型的重新训练应保留 val_size。
cpus	int	4	优化期间使用的 cpu 数量。仅与 ray tune 一起使用。
gpus	int	0	优化期间使用的 gpu 数量，默认为所有可用 gpu。仅与 ray tune 一起使用。
verbose	bool	False	跟踪进度。
alias	NoneType	None	模型的自定义名称。
backend	str	ray	用于搜索超参数空间的后端，可以是“ray”或“optuna”。
callbacks	NoneType	None	优化过程中要调用的函数列表。 ray 参考：https://docs.rayai.org.cn/en/latest/tune/tutorials/tune-metrics.html optuna 参考：https://docs.optuna.cn/en/stable/tutorial/20_recipes/007_optuna_callback.html

# Use your own config or AutoTimeXer.default_config
config = dict(max_steps=1, val_check_steps=1, input_size=12, patch_len=12)
model = AutoTimeXer(h=12, n_series=1, config=config, num_samples=1, cpus=1)

# Fit and predict
model.fit(dataset=dataset)
y_hat = model.predict(dataset=dataset)

# Optuna
model = AutoTimeXer(h=12, n_series=1, config=None, backend='optuna')

E. 基于 CNN 的模型

源

AutoTimesNet

 AutoTimesNet (h, loss=MAE(), valid_loss=None, config=None,
               search_alg=<ray.tune.search.basic_variant.BasicVariantGener
               ator object at 0x7f6f340b7280>, num_samples=10,
               refit_with_val=False, cpus=4, gpus=0, verbose=False,
               alias=None, backend='ray', callbacks=None)

*用于自动超参数优化的类，它基于 ray 构建，提供了多种超参数优化工具，包括经典的网格搜索、贝叶斯优化和 HyperBand 算法。

要优化的验证损失由 config['loss'] 字典值定义，config 还包含其余的超参数搜索空间。

需要注意的是，超参数优化的成功很大程度上取决于验证期和测试期之间存在强相关性。*

	类型	默认值	详情
h	int		预测范围
loss	MAE	MAE()	实例化自损失函数集合的训练损失类。
valid_loss	NoneType	None	实例化自损失函数集合的验证损失类。
config	NoneType	None	包含 ray.tune 定义的搜索空间的字典或接受 optuna trial 并返回配置字典的函数。
search_alg	BasicVariantGenerator	<ray.tune.search.basic_variant.BasicVariantGenerator object at 0x7f6f340b7280>	关于 ray，请参阅https://docs.rayai.org.cn/en/latest/tune/api_docs/suggestion.html 关于 optuna，请参阅https://docs.optuna.cn/en/stable/reference/samplers/index.html。
num_samples	int	10	超参数优化步骤/样本的数量。
refit_with_val	bool	False	最佳模型的重新训练应保留 val_size。
cpus	int	4	优化期间使用的 cpu 数量。仅与 ray tune 一起使用。
gpus	int	0	优化期间使用的 gpu 数量，默认为所有可用 gpu。仅与 ray tune 一起使用。
verbose	bool	False	跟踪进度。
alias	NoneType	None	模型的自定义名称。
backend	str	ray	用于搜索超参数空间的后端，可以是“ray”或“optuna”。
callbacks	NoneType	None	优化过程中要调用的函数列表。 ray 参考：https://docs.rayai.org.cn/en/latest/tune/tutorials/tune-metrics.html optuna 参考：https://docs.optuna.cn/en/stable/tutorial/20_recipes/007_optuna_callback.html

# Use your own config or AutoTimesNet.default_config
config = dict(max_steps=1, val_check_steps=1, input_size=12, hidden_size=32)
model = AutoTimesNet(h=12, config=config, num_samples=1, cpus=1)

# Fit and predict
model.fit(dataset=dataset)
y_hat = model.predict(dataset=dataset)

# Optuna
model = AutoTimesNet(h=12, config=None, backend='optuna')

F. 多变量模型

源

AutoStemGNN

 AutoStemGNN (h, n_series, loss=MAE(), valid_loss=None, config=None,
              search_alg=<ray.tune.search.basic_variant.BasicVariantGenera
              tor object at 0x7f6f340f0880>, num_samples=10,
              refit_with_val=False, cpus=4, gpus=0, verbose=False,
              alias=None, backend='ray', callbacks=None)

*用于自动超参数优化的类，它基于 ray 构建，提供了多种超参数优化工具，包括经典的网格搜索、贝叶斯优化和 HyperBand 算法。

要优化的验证损失由 config['loss'] 字典值定义，config 还包含其余的超参数搜索空间。

需要注意的是，超参数优化的成功很大程度上取决于验证期和测试期之间存在强相关性。*

	类型	默认值	详情
h	int		预测范围
n_series
loss	MAE	MAE()	实例化自损失函数集合的训练损失类。
valid_loss	NoneType	None	实例化自损失函数集合的验证损失类。
config	NoneType	None	包含 ray.tune 定义的搜索空间的字典或接受 optuna trial 并返回配置字典的函数。
search_alg	BasicVariantGenerator	<ray.tune.search.basic_variant.BasicVariantGenerator object at 0x7f6f340f0880>	关于 ray，请参阅https://docs.rayai.org.cn/en/latest/tune/api_docs/suggestion.html 关于 optuna，请参阅https://docs.optuna.cn/en/stable/reference/samplers/index.html。
num_samples	int	10	超参数优化步骤/样本的数量。
refit_with_val	bool	False	最佳模型的重新训练应保留 val_size。
cpus	int	4	优化期间使用的 cpu 数量。仅与 ray tune 一起使用。
gpus	int	0	优化期间使用的 gpu 数量，默认为所有可用 gpu。仅与 ray tune 一起使用。
verbose	bool	False	跟踪进度。
alias	NoneType	None	模型的自定义名称。
backend	str	ray	用于搜索超参数空间的后端，可以是“ray”或“optuna”。
callbacks	NoneType	None	优化过程中要调用的函数列表。 ray 参考：https://docs.rayai.org.cn/en/latest/tune/tutorials/tune-metrics.html optuna 参考：https://docs.optuna.cn/en/stable/tutorial/20_recipes/007_optuna_callback.html

# Use your own config or AutoStemGNN.default_config
config = dict(max_steps=1, val_check_steps=1, input_size=12)
model = AutoStemGNN(h=12, n_series=1, config=config, num_samples=1, cpus=1)

# Fit and predict
model.fit(dataset=dataset)
y_hat = model.predict(dataset=dataset)

# Optuna
model = AutoStemGNN(h=12, n_series=1, config=None, backend='optuna')

源

AutoHINT

 AutoHINT (cls_model, h, loss, valid_loss, S, config,
           search_alg=<ray.tune.search.basic_variant.BasicVariantGenerator
           object at 0x7f6f341982e0>, num_samples=10, cpus=4, gpus=0,
           refit_with_val=False, verbose=False, alias=None, backend='ray',
           callbacks=None)

*用于自动超参数优化的类，它基于 ray 构建，提供了多种超参数优化工具，包括经典的网格搜索、贝叶斯优化和 HyperBand 算法。

要优化的验证损失由 config['loss'] 字典值定义，config 还包含其余的超参数搜索空间。

需要注意的是，超参数优化的成功很大程度上取决于验证期和测试期之间存在强相关性。*

	类型	默认值	详情
cls_model	PyTorch/PyTorchLightning 模型		请参阅这里的 `neuralforecast.models` 集合。
h	int		预测范围
loss	PyTorch 模块		实例化自损失函数集合的训练损失类。
valid_loss	PyTorch 模块		实例化自损失函数集合的验证损失类。
S
config	dict 或 callable		包含 ray.tune 定义的搜索空间的字典或接受 optuna trial 并返回配置字典的函数。
search_alg	BasicVariantGenerator	<ray.tune.search.basic_variant.BasicVariantGenerator object at 0x7f6f341982e0>	关于 ray，请参阅https://docs.rayai.org.cn/en/latest/tune/api_docs/suggestion.html 关于 optuna，请参阅https://docs.optuna.cn/en/stable/reference/samplers/index.html。
num_samples	int	10	超参数优化步骤/样本的数量。
cpus	int	4	优化期间使用的 cpu 数量。仅与 ray tune 一起使用。
gpus	int	0	优化期间使用的 gpu 数量，默认为所有可用 gpu。仅与 ray tune 一起使用。
refit_with_val	bool	False	最佳模型的重新训练应保留 val_size。
verbose	bool	False	跟踪进度。
alias	NoneType	None	模型的自定义名称。
backend	str	ray	用于搜索超参数空间的后端，可以是“ray”或“optuna”。
callbacks	NoneType	None	优化过程中要调用的函数列表。 ray 参考：https://docs.rayai.org.cn/en/latest/tune/tutorials/tune-metrics.html optuna 参考：https://docs.optuna.cn/en/stable/tutorial/20_recipes/007_optuna_callback.html

# Perform a simple hyperparameter optimization with 
# NHITS and then reconcile with HINT
from neuralforecast.losses.pytorch import GMM, sCRPS

base_config = dict(max_steps=1, val_check_steps=1, input_size=8)
base_model = AutoNHITS(h=4, loss=GMM(n_components=2, quantiles=quantiles), 
                       config=base_config, num_samples=1, cpus=1)
model = HINT(h=4, S=S_df.values,
             model=base_model,  reconciliation='MinTraceOLS')

model.fit(dataset=dataset)
y_hat = model.predict(dataset=hint_dataset)

# Perform a conjunct hyperparameter optimization with 
# NHITS + HINT reconciliation configurations
nhits_config = {
       "learning_rate": tune.choice([1e-3]),                                     # Initial Learning rate
       "max_steps": tune.choice([1]),                                            # Number of SGD steps
       "val_check_steps": tune.choice([1]),                                      # Number of steps between validation
       "input_size": tune.choice([5 * 12]),                                      # input_size = multiplier * horizon
       "batch_size": tune.choice([7]),                                           # Number of series in windows
       "windows_batch_size": tune.choice([256]),                                 # Number of windows in batch
       "n_pool_kernel_size": tune.choice([[2, 2, 2], [16, 8, 1]]),               # MaxPool's Kernelsize
       "n_freq_downsample": tune.choice([[168, 24, 1], [24, 12, 1], [1, 1, 1]]), # Interpolation expressivity ratios
       "activation": tune.choice(['ReLU']),                                      # Type of non-linear activation
       "n_blocks":  tune.choice([[1, 1, 1]]),                                    # Blocks per each 3 stacks
       "mlp_units":  tune.choice([[[512, 512], [512, 512], [512, 512]]]),        # 2 512-Layers per block for each stack
       "interpolation_mode": tune.choice(['linear']),                            # Type of multi-step interpolation
       "random_seed": tune.randint(1, 10),
       "reconciliation": tune.choice(['BottomUp', 'MinTraceOLS', 'MinTraceWLS'])
    }
model = AutoHINT(h=4, S=S_df.values,
                 cls_model=NHITS,
                 config=nhits_config,
                 loss=GMM(n_components=2, level=[80, 90]),
                 valid_loss=sCRPS(level=[80, 90]),
                 num_samples=1, cpus=1)
model.fit(dataset=dataset)
y_hat = model.predict(dataset=hint_dataset)

源

AutoTSMixer

 AutoTSMixer (h, n_series, loss=MAE(), valid_loss=None, config=None,
              search_alg=<ray.tune.search.basic_variant.BasicVariantGenera
              tor object at 0x7f6f3408db70>, num_samples=10,
              refit_with_val=False, cpus=4, gpus=0, verbose=False,
              alias=None, backend='ray', callbacks=None)

*用于自动超参数优化的类，它基于 ray 构建，提供了多种超参数优化工具，包括经典的网格搜索、贝叶斯优化和 HyperBand 算法。

要优化的验证损失由 config['loss'] 字典值定义，config 还包含其余的超参数搜索空间。

需要注意的是，超参数优化的成功很大程度上取决于验证期和测试期之间存在强相关性。*

	类型	默认值	详情
h	int		预测范围
n_series
loss	MAE	MAE()	实例化自损失函数集合的训练损失类。
valid_loss	NoneType	None	实例化自损失函数集合的验证损失类。
config	NoneType	None	包含 ray.tune 定义的搜索空间的字典或接受 optuna trial 并返回配置字典的函数。
search_alg	BasicVariantGenerator	<ray.tune.search.basic_variant.BasicVariantGenerator object at 0x7f6f3408db70>	关于 ray，请参阅https://docs.rayai.org.cn/en/latest/tune/api_docs/suggestion.html 关于 optuna，请参阅https://docs.optuna.cn/en/stable/reference/samplers/index.html。
num_samples	int	10	超参数优化步骤/样本的数量。
refit_with_val	bool	False	最佳模型的重新训练应保留 val_size。
cpus	int	4	优化期间使用的 cpu 数量。仅与 ray tune 一起使用。
gpus	int	0	优化期间使用的 gpu 数量，默认为所有可用 gpu。仅与 ray tune 一起使用。
verbose	bool	False	跟踪进度。
alias	NoneType	None	模型的自定义名称。
backend	str	ray	用于搜索超参数空间的后端，可以是“ray”或“optuna”。
callbacks	NoneType	None	优化过程中要调用的函数列表。 ray 参考：https://docs.rayai.org.cn/en/latest/tune/tutorials/tune-metrics.html optuna 参考：https://docs.optuna.cn/en/stable/tutorial/20_recipes/007_optuna_callback.html

# Use your own config or AutoTSMixer.default_config
config = dict(max_steps=1, val_check_steps=1, input_size=12)
model = AutoTSMixer(h=12, n_series=1, config=config, num_samples=1, cpus=1)

# Fit and predict
model.fit(dataset=dataset)
y_hat = model.predict(dataset=dataset)

# Optuna
model = AutoTSMixer(h=12, n_series=1, config=None, backend='optuna')

源

AutoTSMixerx

 AutoTSMixerx (h, n_series, loss=MAE(), valid_loss=None, config=None,
               search_alg=<ray.tune.search.basic_variant.BasicVariantGener
               ator object at 0x7f6f340c6b60>, num_samples=10,
               refit_with_val=False, cpus=4, gpus=0, verbose=False,
               alias=None, backend='ray', callbacks=None)

*用于自动超参数优化的类，它基于 ray 构建，提供了多种超参数优化工具，包括经典的网格搜索、贝叶斯优化和 HyperBand 算法。

要优化的验证损失由 config['loss'] 字典值定义，config 还包含其余的超参数搜索空间。

需要注意的是，超参数优化的成功很大程度上取决于验证期和测试期之间存在强相关性。*

	类型	默认值	详情
h	int		预测范围
n_series
loss	MAE	MAE()	实例化自损失函数集合的训练损失类。
valid_loss	NoneType	None	实例化自损失函数集合的验证损失类。
config	NoneType	None	包含 ray.tune 定义的搜索空间的字典或接受 optuna trial 并返回配置字典的函数。
search_alg	BasicVariantGenerator	<ray.tune.search.basic_variant.BasicVariantGenerator object at 0x7f6f340c6b60>	关于 ray，请参阅https://docs.rayai.org.cn/en/latest/tune/api_docs/suggestion.html 关于 optuna，请参阅https://docs.optuna.cn/en/stable/reference/samplers/index.html。
num_samples	int	10	超参数优化步骤/样本的数量。
refit_with_val	bool	False	最佳模型的重新训练应保留 val_size。
cpus	int	4	优化期间使用的 cpu 数量。仅与 ray tune 一起使用。
gpus	int	0	优化期间使用的 gpu 数量，默认为所有可用 gpu。仅与 ray tune 一起使用。
verbose	bool	False	跟踪进度。
alias	NoneType	None	模型的自定义名称。
backend	str	ray	用于搜索超参数空间的后端，可以是“ray”或“optuna”。
callbacks	NoneType	None	优化过程中要调用的函数列表。 ray 参考：https://docs.rayai.org.cn/en/latest/tune/tutorials/tune-metrics.html optuna 参考：https://docs.optuna.cn/en/stable/tutorial/20_recipes/007_optuna_callback.html

# Use your own config or AutoTSMixerx.default_config
config = dict(max_steps=1, val_check_steps=1, input_size=12)
model = AutoTSMixerx(h=12, n_series=1, config=config, num_samples=1, cpus=1)

# Fit and predict
model.fit(dataset=dataset)
y_hat = model.predict(dataset=dataset)

# Optuna
model = AutoTSMixerx(h=12, n_series=1, config=None, backend='optuna')

源

AutoMLPMultivariate

 AutoMLPMultivariate (h, n_series, loss=MAE(), valid_loss=None,
                      config=None, search_alg=<ray.tune.search.basic_varia
                      nt.BasicVariantGenerator object at 0x7f6f3408d900>,
                      num_samples=10, refit_with_val=False, cpus=4,
                      gpus=0, verbose=False, alias=None, backend='ray',
                      callbacks=None)

*用于自动超参数优化的类，它基于 ray 构建，提供了多种超参数优化工具，包括经典的网格搜索、贝叶斯优化和 HyperBand 算法。

要优化的验证损失由 config['loss'] 字典值定义，config 还包含其余的超参数搜索空间。

需要注意的是，超参数优化的成功很大程度上取决于验证期和测试期之间存在强相关性。*

	类型	默认值	详情
h	int		预测范围
n_series
loss	MAE	MAE()	实例化自损失函数集合的训练损失类。
valid_loss	NoneType	None	实例化自损失函数集合的验证损失类。
config	NoneType	None	包含 ray.tune 定义的搜索空间的字典或接受 optuna trial 并返回配置字典的函数。
search_alg	BasicVariantGenerator	<ray.tune.search.basic_variant.BasicVariantGenerator object at 0x7f6f3408d900>	关于 ray，请参阅https://docs.rayai.org.cn/en/latest/tune/api_docs/suggestion.html 关于 optuna，请参阅https://docs.optuna.cn/en/stable/reference/samplers/index.html。
num_samples	int	10	超参数优化步骤/样本的数量。
refit_with_val	bool	False	最佳模型的重新训练应保留 val_size。
cpus	int	4	优化期间使用的 cpu 数量。仅与 ray tune 一起使用。
gpus	int	0	优化期间使用的 gpu 数量，默认为所有可用 gpu。仅与 ray tune 一起使用。
verbose	bool	False	跟踪进度。
alias	NoneType	None	模型的自定义名称。
backend	str	ray	用于搜索超参数空间的后端，可以是“ray”或“optuna”。
callbacks	NoneType	None	优化过程中要调用的函数列表。 ray 参考：https://docs.rayai.org.cn/en/latest/tune/tutorials/tune-metrics.html optuna 参考：https://docs.optuna.cn/en/stable/tutorial/20_recipes/007_optuna_callback.html

# Use your own config or AutoMLPMultivariate.default_config
config = dict(max_steps=1, val_check_steps=1, input_size=12)
model = AutoMLPMultivariate(h=12, n_series=1, config=config, num_samples=1, cpus=1)

# Fit and predict
model.fit(dataset=dataset)
y_hat = model.predict(dataset=dataset)

# Optuna
model = AutoMLPMultivariate(h=12, n_series=1, config=None, backend='optuna')

源

AutoSOFTS

 AutoSOFTS (h, n_series, loss=MAE(), valid_loss=None, config=None,
            search_alg=<ray.tune.search.basic_variant.BasicVariantGenerato
            r object at 0x7f6f34756200>, num_samples=10,
            refit_with_val=False, cpus=4, gpus=0, verbose=False,
            alias=None, backend='ray', callbacks=None)

*用于自动超参数优化的类，它基于 ray 构建，提供了多种超参数优化工具，包括经典的网格搜索、贝叶斯优化和 HyperBand 算法。

要优化的验证损失由 config['loss'] 字典值定义，config 还包含其余的超参数搜索空间。

需要注意的是，超参数优化的成功很大程度上取决于验证期和测试期之间存在强相关性。*

	类型	默认值	详情
h	int		预测范围
n_series
loss	MAE	MAE()	实例化自损失函数集合的训练损失类。
valid_loss	NoneType	None	实例化自损失函数集合的验证损失类。
config	NoneType	None	包含 ray.tune 定义的搜索空间的字典或接受 optuna trial 并返回配置字典的函数。
search_alg	BasicVariantGenerator	<ray.tune.search.basic_variant.BasicVariantGenerator object at 0x7f6f34756200>	关于 ray，请参阅https://docs.rayai.org.cn/en/latest/tune/api_docs/suggestion.html 关于 optuna，请参阅https://docs.optuna.cn/en/stable/reference/samplers/index.html。
num_samples	int	10	超参数优化步骤/样本的数量。
refit_with_val	bool	False	最佳模型的重新训练应保留 val_size。
cpus	int	4	优化期间使用的 cpu 数量。仅与 ray tune 一起使用。
gpus	int	0	优化期间使用的 gpu 数量，默认为所有可用 gpu。仅与 ray tune 一起使用。
verbose	bool	False	跟踪进度。
alias	NoneType	None	模型的自定义名称。
backend	str	ray	用于搜索超参数空间的后端，可以是“ray”或“optuna”。
callbacks	NoneType	None	优化过程中要调用的函数列表。 ray 参考：https://docs.rayai.org.cn/en/latest/tune/tutorials/tune-metrics.html optuna 参考：https://docs.optuna.cn/en/stable/tutorial/20_recipes/007_optuna_callback.html

# Use your own config or AutoSOFTS.default_config
config = dict(max_steps=1, val_check_steps=1, input_size=12, hidden_size=16)
model = AutoSOFTS(h=12, n_series=1, config=config, num_samples=1, cpus=1)

# Fit and predict
model.fit(dataset=dataset)
y_hat = model.predict(dataset=dataset)

# Optuna
model = AutoSOFTS(h=12, n_series=1, config=None, backend='optuna')

源

AutoTimeMixer

 AutoTimeMixer (h, n_series, loss=MAE(), valid_loss=None, config=None,
                search_alg=<ray.tune.search.basic_variant.BasicVariantGene
                rator object at 0x7f6f340ef130>, num_samples=10,
                refit_with_val=False, cpus=4, gpus=0, verbose=False,
                alias=None, backend='ray', callbacks=None)

*用于自动超参数优化的类，它基于 ray 构建，提供了多种超参数优化工具，包括经典的网格搜索、贝叶斯优化和 HyperBand 算法。

要优化的验证损失由 config['loss'] 字典值定义，config 还包含其余的超参数搜索空间。

需要注意的是，超参数优化的成功很大程度上取决于验证期和测试期之间存在强相关性。*

	类型	默认值	详情
h	int		预测范围
n_series
loss	MAE	MAE()	实例化自损失函数集合的训练损失类。
valid_loss	NoneType	None	实例化自损失函数集合的验证损失类。
config	NoneType	None	包含 ray.tune 定义的搜索空间的字典或接受 optuna trial 并返回配置字典的函数。
search_alg	BasicVariantGenerator	<ray.tune.search.basic_variant.BasicVariantGenerator object at 0x7f6f340ef130>	关于 ray，请参阅https://docs.rayai.org.cn/en/latest/tune/api_docs/suggestion.html 关于 optuna，请参阅https://docs.optuna.cn/en/stable/reference/samplers/index.html。
num_samples	int	10	超参数优化步骤/样本的数量。
refit_with_val	bool	False	最佳模型的重新训练应保留 val_size。
cpus	int	4	优化期间使用的 cpu 数量。仅与 ray tune 一起使用。
gpus	int	0	优化期间使用的 gpu 数量，默认为所有可用 gpu。仅与 ray tune 一起使用。
verbose	bool	False	跟踪进度。
alias	NoneType	None	模型的自定义名称。
backend	str	ray	用于搜索超参数空间的后端，可以是“ray”或“optuna”。
callbacks	NoneType	None	优化过程中要调用的函数列表。 ray 参考：https://docs.rayai.org.cn/en/latest/tune/tutorials/tune-metrics.html optuna 参考：https://docs.optuna.cn/en/stable/tutorial/20_recipes/007_optuna_callback.html

# Use your own config or AutoTimeMixer.default_config
config = dict(max_steps=1, val_check_steps=1, input_size=12, d_model=16)
model = AutoTimeMixer(h=12, n_series=1, config=config, num_samples=1, cpus=1)

# Fit and predict
model.fit(dataset=dataset)
y_hat = model.predict(dataset=dataset)

# Optuna
model = AutoTimeMixer(h=12, n_series=1, config=None, backend='optuna')

源

AutoRMoK

 AutoRMoK (h, n_series, loss=MAE(), valid_loss=None, config=None,
           search_alg=<ray.tune.search.basic_variant.BasicVariantGenerator
           object at 0x7f6f340a34c0>, num_samples=10,
           refit_with_val=False, cpus=4, gpus=0, verbose=False,
           alias=None, backend='ray', callbacks=None)

*用于自动超参数优化的类，它基于 ray 构建，提供了多种超参数优化工具，包括经典的网格搜索、贝叶斯优化和 HyperBand 算法。

要优化的验证损失由 config['loss'] 字典值定义，config 还包含其余的超参数搜索空间。

需要注意的是，超参数优化的成功很大程度上取决于验证期和测试期之间存在强相关性。*

	类型	默认值	详情
h	int		预测范围
n_series
loss	MAE	MAE()	实例化自损失函数集合的训练损失类。
valid_loss	NoneType	None	实例化自损失函数集合的验证损失类。
config	NoneType	None	包含 ray.tune 定义的搜索空间的字典或接受 optuna trial 并返回配置字典的函数。
search_alg	BasicVariantGenerator	<ray.tune.search.basic_variant.BasicVariantGenerator object at 0x7f6f340a34c0>	关于 ray，请参阅https://docs.rayai.org.cn/en/latest/tune/api_docs/suggestion.html 关于 optuna，请参阅https://docs.optuna.cn/en/stable/reference/samplers/index.html。
num_samples	int	10	超参数优化步骤/样本的数量。
refit_with_val	bool	False	最佳模型的重新训练应保留 val_size。
cpus	int	4	优化期间使用的 cpu 数量。仅与 ray tune 一起使用。
gpus	int	0	优化期间使用的 gpu 数量，默认为所有可用 gpu。仅与 ray tune 一起使用。
verbose	bool	False	跟踪进度。
alias	NoneType	None	模型的自定义名称。
backend	str	ray	用于搜索超参数空间的后端，可以是“ray”或“optuna”。
callbacks	NoneType	None	优化过程中要调用的函数列表。 ray 参考：https://docs.rayai.org.cn/en/latest/tune/tutorials/tune-metrics.html optuna 参考：https://docs.optuna.cn/en/stable/tutorial/20_recipes/007_optuna_callback.html

# Use your own config or AutoRMoK.default_config
config = dict(max_steps=1, val_check_steps=1, input_size=12, learning_rate=1e-2)
model = AutoRMoK(h=12, n_series=1, config=config, num_samples=1, cpus=1)

# Fit and predict
model.fit(dataset=dataset)
y_hat = model.predict(dataset=dataset)

# Optuna
model = AutoRMoK(h=12, n_series=1, config=None, backend='optuna')

入门

功能

教程

用例

API 参考

​1. 自动预测

​A. 基于 RNN 的模型

​AutoRNN

​AutoLSTM

​AutoGRU

​AutoTCN

​AutoDeepAR

​AutoDilatedRNN

​AutoBiTCN

​B. 基于 MLP 的模型

​AutoMLP

​AutoNBEATS

​AutoNBEATSx

​AutoNHITS

​AutoDLinear

​AutoNLinear

​AutoTiDE

​AutoDeepNPTS

​C. 基于 KAN 的模型

​AutoKAN

​D. 基于 Transformer 的模型

​AutoTFT

​AutoVanillaTransformer

​AutoInformer

​AutoAutoformer

​AutoFEDformer

​AutoPatchTST

​AutoiTransformer

​AutoTimeXer

​E. 基于 CNN 的模型

​AutoTimesNet

​F. 多变量模型

​AutoStemGNN

​AutoHINT

​AutoTSMixer

​AutoTSMixerx

​AutoMLPMultivariate

​AutoSOFTS

​AutoTimeMixer

​AutoRMoK

​测试

1. 自动预测

A. 基于 RNN 的模型

AutoRNN

AutoLSTM

AutoGRU

AutoTCN

AutoDeepAR

AutoDilatedRNN

AutoBiTCN

B. 基于 MLP 的模型

AutoMLP

AutoNBEATS

AutoNBEATSx

AutoNHITS

AutoDLinear

AutoNLinear

AutoTiDE

AutoDeepNPTS

C. 基于 KAN 的模型

AutoKAN

D. 基于 Transformer 的模型

AutoTFT

AutoVanillaTransformer

AutoInformer

AutoAutoformer

AutoFEDformer

AutoPatchTST

AutoiTransformer

AutoTimeXer

E. 基于 CNN 的模型

AutoTimesNet

F. 多变量模型

AutoStemGNN

AutoHINT

AutoTSMixer

AutoTSMixerx

AutoMLPMultivariate

AutoSOFTS

AutoTimeMixer

AutoRMoK

测试