`module` `neuralforecast.auto`

`class` `AutoRNN`

`method` `init`

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

Auto RNN Parameters:

`property` automatic_optimization

If set to False you are responsible for calling .backward(), .step(), .zero_grad().

`property` current_epoch

The current epoch in the Trainer, or 0 if not attached.

`property` device

`property` device_mesh

Strategies like ModelParallelStrategy will create a device mesh that can be accessed in the :meth:~pytorch_lightning.core.hooks.ModelHooks.configure_model hook to parallelize the LightningModule.

`property` dtype

`property` example_input_array

The example input array is a specification of what the module can consume in the :meth:forward method. The return type is interpreted as follows:

Single tensor: It is assumed the model takes a single argument, i.e., model.forward(model.example_input_array)
Tuple: The input array should be interpreted as a sequence of positional arguments, i.e., model.forward(*model.example_input_array)
Dict: The input array represents named keyword arguments, i.e., model.forward(**model.example_input_array)

`property` fabric

`property` global_rank

The index of the current process across all nodes and devices.

`property` global_step

Total training batches seen across all epochs. If no Trainer is attached, this property is 0.

`property` hparams

The collection of hyperparameters saved with :meth:save_hyperparameters. It is mutable by the user. For the frozen set of initial hyperparameters, use :attr:hparams_initial. Returns: Mutable hyperparameters dictionary

`property` hparams_initial

The collection of hyperparameters saved with :meth:save_hyperparameters. These contents are read-only. Manual updates to the saved hyperparameters can instead be performed through :attr:hparams. Returns:

AttributeDict: immutable initial hyperparameters

`property` local_rank

The index of the current process within a single node.

`property` logger

Reference to the logger object in the Trainer.

`property` loggers

Reference to the list of loggers in the Trainer.

`property` on_gpu

Returns True if this model is currently located on a GPU. Useful to set flags around the LightningModule for different CPU vs GPU behavior.

`property` strict_loading

Determines how Lightning loads this model using .load_state_dict(..., strict=model.strict_loading).

`property` trainer

`classmethod` `get_default_config`

get_default_config(h, backend, n_series=None)

`class` `AutoLSTM`

`method` `init`

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

`property` automatic_optimization

If set to False you are responsible for calling .backward(), .step(), .zero_grad().

`property` current_epoch

The current epoch in the Trainer, or 0 if not attached.

`property` device

`property` device_mesh

Strategies like ModelParallelStrategy will create a device mesh that can be accessed in the :meth:~pytorch_lightning.core.hooks.ModelHooks.configure_model hook to parallelize the LightningModule.

`property` dtype

`property` example_input_array

The example input array is a specification of what the module can consume in the :meth:forward method. The return type is interpreted as follows:

Single tensor: It is assumed the model takes a single argument, i.e., model.forward(model.example_input_array)
Tuple: The input array should be interpreted as a sequence of positional arguments, i.e., model.forward(*model.example_input_array)
Dict: The input array represents named keyword arguments, i.e., model.forward(**model.example_input_array)

`property` fabric

`property` global_rank

The index of the current process across all nodes and devices.

`property` global_step

Total training batches seen across all epochs. If no Trainer is attached, this property is 0.

`property` hparams

`property` hparams_initial

AttributeDict: immutable initial hyperparameters

`property` local_rank

The index of the current process within a single node.

`property` logger

Reference to the logger object in the Trainer.

`property` loggers

Reference to the list of loggers in the Trainer.

`property` on_gpu

Returns True if this model is currently located on a GPU. Useful to set flags around the LightningModule for different CPU vs GPU behavior.

`property` strict_loading

Determines how Lightning loads this model using .load_state_dict(..., strict=model.strict_loading).

`property` trainer

`classmethod` `get_default_config`

get_default_config(h, backend, n_series=None)

`class` `AutoGRU`

`method` `init`

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

`property` automatic_optimization

If set to False you are responsible for calling .backward(), .step(), .zero_grad().

`property` current_epoch

The current epoch in the Trainer, or 0 if not attached.

`property` device

`property` device_mesh

Strategies like ModelParallelStrategy will create a device mesh that can be accessed in the :meth:~pytorch_lightning.core.hooks.ModelHooks.configure_model hook to parallelize the LightningModule.

`property` dtype

`property` example_input_array

The example input array is a specification of what the module can consume in the :meth:forward method. The return type is interpreted as follows:

Single tensor: It is assumed the model takes a single argument, i.e., model.forward(model.example_input_array)
Tuple: The input array should be interpreted as a sequence of positional arguments, i.e., model.forward(*model.example_input_array)
Dict: The input array represents named keyword arguments, i.e., model.forward(**model.example_input_array)

`property` fabric

`property` global_rank

The index of the current process across all nodes and devices.

`property` global_step

Total training batches seen across all epochs. If no Trainer is attached, this property is 0.

`property` hparams

`property` hparams_initial

AttributeDict: immutable initial hyperparameters

`property` local_rank

The index of the current process within a single node.

`property` logger

Reference to the logger object in the Trainer.

`property` loggers

Reference to the list of loggers in the Trainer.

`property` on_gpu

Returns True if this model is currently located on a GPU. Useful to set flags around the LightningModule for different CPU vs GPU behavior.

`property` strict_loading

Determines how Lightning loads this model using .load_state_dict(..., strict=model.strict_loading).

`property` trainer

`classmethod` `get_default_config`

get_default_config(h, backend, n_series=None)

`class` `AutoTCN`

`method` `init`

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

`property` automatic_optimization

If set to False you are responsible for calling .backward(), .step(), .zero_grad().

`property` current_epoch

The current epoch in the Trainer, or 0 if not attached.

`property` device

`property` device_mesh

Strategies like ModelParallelStrategy will create a device mesh that can be accessed in the :meth:~pytorch_lightning.core.hooks.ModelHooks.configure_model hook to parallelize the LightningModule.

`property` dtype

`property` example_input_array

The example input array is a specification of what the module can consume in the :meth:forward method. The return type is interpreted as follows:

Single tensor: It is assumed the model takes a single argument, i.e., model.forward(model.example_input_array)
Tuple: The input array should be interpreted as a sequence of positional arguments, i.e., model.forward(*model.example_input_array)
Dict: The input array represents named keyword arguments, i.e., model.forward(**model.example_input_array)

`property` fabric

`property` global_rank

The index of the current process across all nodes and devices.

`property` global_step

Total training batches seen across all epochs. If no Trainer is attached, this property is 0.

`property` hparams

`property` hparams_initial

AttributeDict: immutable initial hyperparameters

`property` local_rank

The index of the current process within a single node.

`property` logger

Reference to the logger object in the Trainer.

`property` loggers

Reference to the list of loggers in the Trainer.

`property` on_gpu

Returns True if this model is currently located on a GPU. Useful to set flags around the LightningModule for different CPU vs GPU behavior.

`property` strict_loading

Determines how Lightning loads this model using .load_state_dict(..., strict=model.strict_loading).

`property` trainer

`classmethod` `get_default_config`

get_default_config(h, backend, n_series=None)

`class` `AutoDeepAR`

`method` `init`

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

`property` automatic_optimization

If set to False you are responsible for calling .backward(), .step(), .zero_grad().

`property` current_epoch

The current epoch in the Trainer, or 0 if not attached.

`property` device

`property` device_mesh

Strategies like ModelParallelStrategy will create a device mesh that can be accessed in the :meth:~pytorch_lightning.core.hooks.ModelHooks.configure_model hook to parallelize the LightningModule.

`property` dtype

`property` example_input_array

The example input array is a specification of what the module can consume in the :meth:forward method. The return type is interpreted as follows:

Single tensor: It is assumed the model takes a single argument, i.e., model.forward(model.example_input_array)
Tuple: The input array should be interpreted as a sequence of positional arguments, i.e., model.forward(*model.example_input_array)
Dict: The input array represents named keyword arguments, i.e., model.forward(**model.example_input_array)

`property` fabric

`property` global_rank

The index of the current process across all nodes and devices.

`property` global_step

Total training batches seen across all epochs. If no Trainer is attached, this property is 0.

`property` hparams

`property` hparams_initial

AttributeDict: immutable initial hyperparameters

`property` local_rank

The index of the current process within a single node.

`property` logger

Reference to the logger object in the Trainer.

`property` loggers

Reference to the list of loggers in the Trainer.

`property` on_gpu

Returns True if this model is currently located on a GPU. Useful to set flags around the LightningModule for different CPU vs GPU behavior.

`property` strict_loading

Determines how Lightning loads this model using .load_state_dict(..., strict=model.strict_loading).

`property` trainer

`classmethod` `get_default_config`

get_default_config(h, backend, n_series=None)

`class` `AutoDilatedRNN`

`method` `init`

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

`property` automatic_optimization

If set to False you are responsible for calling .backward(), .step(), .zero_grad().

`property` current_epoch

The current epoch in the Trainer, or 0 if not attached.

`property` device

`property` device_mesh

Strategies like ModelParallelStrategy will create a device mesh that can be accessed in the :meth:~pytorch_lightning.core.hooks.ModelHooks.configure_model hook to parallelize the LightningModule.

`property` dtype

`property` example_input_array

The example input array is a specification of what the module can consume in the :meth:forward method. The return type is interpreted as follows:

Single tensor: It is assumed the model takes a single argument, i.e., model.forward(model.example_input_array)
Tuple: The input array should be interpreted as a sequence of positional arguments, i.e., model.forward(*model.example_input_array)
Dict: The input array represents named keyword arguments, i.e., model.forward(**model.example_input_array)

`property` fabric

`property` global_rank

The index of the current process across all nodes and devices.

`property` global_step

Total training batches seen across all epochs. If no Trainer is attached, this property is 0.

`property` hparams

`property` hparams_initial

AttributeDict: immutable initial hyperparameters

`property` local_rank

The index of the current process within a single node.

`property` logger

Reference to the logger object in the Trainer.

`property` loggers

Reference to the list of loggers in the Trainer.

`property` on_gpu

Returns True if this model is currently located on a GPU. Useful to set flags around the LightningModule for different CPU vs GPU behavior.

`property` strict_loading

Determines how Lightning loads this model using .load_state_dict(..., strict=model.strict_loading).

`property` trainer

`classmethod` `get_default_config`

get_default_config(h, backend, n_series=None)

`class` `AutoBiTCN`

`method` `init`

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

`property` automatic_optimization

If set to False you are responsible for calling .backward(), .step(), .zero_grad().

`property` current_epoch

The current epoch in the Trainer, or 0 if not attached.

`property` device

`property` device_mesh

Strategies like ModelParallelStrategy will create a device mesh that can be accessed in the :meth:~pytorch_lightning.core.hooks.ModelHooks.configure_model hook to parallelize the LightningModule.

`property` dtype

`property` example_input_array

The example input array is a specification of what the module can consume in the :meth:forward method. The return type is interpreted as follows:

Single tensor: It is assumed the model takes a single argument, i.e., model.forward(model.example_input_array)
Tuple: The input array should be interpreted as a sequence of positional arguments, i.e., model.forward(*model.example_input_array)
Dict: The input array represents named keyword arguments, i.e., model.forward(**model.example_input_array)

`property` fabric

`property` global_rank

The index of the current process across all nodes and devices.

`property` global_step

Total training batches seen across all epochs. If no Trainer is attached, this property is 0.

`property` hparams

`property` hparams_initial

AttributeDict: immutable initial hyperparameters

`property` local_rank

The index of the current process within a single node.

`property` logger

Reference to the logger object in the Trainer.

`property` loggers

Reference to the list of loggers in the Trainer.

`property` on_gpu

Returns True if this model is currently located on a GPU. Useful to set flags around the LightningModule for different CPU vs GPU behavior.

`property` strict_loading

Determines how Lightning loads this model using .load_state_dict(..., strict=model.strict_loading).

`property` trainer

`classmethod` `get_default_config`

get_default_config(h, backend, n_series=None)

`class` `AutoxLSTM`

`method` `init`

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

`property` automatic_optimization

If set to False you are responsible for calling .backward(), .step(), .zero_grad().

`property` current_epoch

The current epoch in the Trainer, or 0 if not attached.

`property` device

`property` device_mesh

Strategies like ModelParallelStrategy will create a device mesh that can be accessed in the :meth:~pytorch_lightning.core.hooks.ModelHooks.configure_model hook to parallelize the LightningModule.

`property` dtype

`property` example_input_array

The example input array is a specification of what the module can consume in the :meth:forward method. The return type is interpreted as follows:

Single tensor: It is assumed the model takes a single argument, i.e., model.forward(model.example_input_array)
Tuple: The input array should be interpreted as a sequence of positional arguments, i.e., model.forward(*model.example_input_array)
Dict: The input array represents named keyword arguments, i.e., model.forward(**model.example_input_array)

`property` fabric

`property` global_rank

The index of the current process across all nodes and devices.

`property` global_step

Total training batches seen across all epochs. If no Trainer is attached, this property is 0.

`property` hparams

`property` hparams_initial

AttributeDict: immutable initial hyperparameters

`property` local_rank

The index of the current process within a single node.

`property` logger

Reference to the logger object in the Trainer.

`property` loggers

Reference to the list of loggers in the Trainer.

`property` on_gpu

Returns True if this model is currently located on a GPU. Useful to set flags around the LightningModule for different CPU vs GPU behavior.

`property` strict_loading

Determines how Lightning loads this model using .load_state_dict(..., strict=model.strict_loading).

`property` trainer

`classmethod` `get_default_config`

get_default_config(h, backend, n_series=None)

`class` `AutoMLP`

`method` `init`

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

`property` automatic_optimization

If set to False you are responsible for calling .backward(), .step(), .zero_grad().

`property` current_epoch

The current epoch in the Trainer, or 0 if not attached.

`property` device

`property` device_mesh

Strategies like ModelParallelStrategy will create a device mesh that can be accessed in the :meth:~pytorch_lightning.core.hooks.ModelHooks.configure_model hook to parallelize the LightningModule.

`property` dtype

`property` example_input_array

The example input array is a specification of what the module can consume in the :meth:forward method. The return type is interpreted as follows:

Single tensor: It is assumed the model takes a single argument, i.e., model.forward(model.example_input_array)
Tuple: The input array should be interpreted as a sequence of positional arguments, i.e., model.forward(*model.example_input_array)
Dict: The input array represents named keyword arguments, i.e., model.forward(**model.example_input_array)

`property` fabric

`property` global_rank

The index of the current process across all nodes and devices.

`property` global_step

Total training batches seen across all epochs. If no Trainer is attached, this property is 0.

`property` hparams

`property` hparams_initial

AttributeDict: immutable initial hyperparameters

`property` local_rank

The index of the current process within a single node.

`property` logger

Reference to the logger object in the Trainer.

`property` loggers

Reference to the list of loggers in the Trainer.

`property` on_gpu

Returns True if this model is currently located on a GPU. Useful to set flags around the LightningModule for different CPU vs GPU behavior.

`property` strict_loading

Determines how Lightning loads this model using .load_state_dict(..., strict=model.strict_loading).

`property` trainer

`classmethod` `get_default_config`

get_default_config(h, backend, n_series=None)

`class` `AutoNBEATS`

`method` `init`

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

`property` automatic_optimization

If set to False you are responsible for calling .backward(), .step(), .zero_grad().

`property` current_epoch

The current epoch in the Trainer, or 0 if not attached.

`property` device

`property` device_mesh

Strategies like ModelParallelStrategy will create a device mesh that can be accessed in the :meth:~pytorch_lightning.core.hooks.ModelHooks.configure_model hook to parallelize the LightningModule.

`property` dtype

`property` example_input_array

The example input array is a specification of what the module can consume in the :meth:forward method. The return type is interpreted as follows:

Single tensor: It is assumed the model takes a single argument, i.e., model.forward(model.example_input_array)
Tuple: The input array should be interpreted as a sequence of positional arguments, i.e., model.forward(*model.example_input_array)
Dict: The input array represents named keyword arguments, i.e., model.forward(**model.example_input_array)

`property` fabric

`property` global_rank

The index of the current process across all nodes and devices.

`property` global_step

Total training batches seen across all epochs. If no Trainer is attached, this property is 0.

`property` hparams

`property` hparams_initial

AttributeDict: immutable initial hyperparameters

`property` local_rank

The index of the current process within a single node.

`property` logger

Reference to the logger object in the Trainer.

`property` loggers

Reference to the list of loggers in the Trainer.

`property` on_gpu

Returns True if this model is currently located on a GPU. Useful to set flags around the LightningModule for different CPU vs GPU behavior.

`property` strict_loading

Determines how Lightning loads this model using .load_state_dict(..., strict=model.strict_loading).

`property` trainer

`classmethod` `get_default_config`

get_default_config(h, backend, n_series=None)

`class` `AutoNBEATSx`

`method` `init`

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

`property` automatic_optimization

If set to False you are responsible for calling .backward(), .step(), .zero_grad().

`property` current_epoch

The current epoch in the Trainer, or 0 if not attached.

`property` device

`property` device_mesh

Strategies like ModelParallelStrategy will create a device mesh that can be accessed in the :meth:~pytorch_lightning.core.hooks.ModelHooks.configure_model hook to parallelize the LightningModule.

`property` dtype

`property` example_input_array

The example input array is a specification of what the module can consume in the :meth:forward method. The return type is interpreted as follows:

Single tensor: It is assumed the model takes a single argument, i.e., model.forward(model.example_input_array)
Tuple: The input array should be interpreted as a sequence of positional arguments, i.e., model.forward(*model.example_input_array)
Dict: The input array represents named keyword arguments, i.e., model.forward(**model.example_input_array)

`property` fabric

`property` global_rank

The index of the current process across all nodes and devices.

`property` global_step

Total training batches seen across all epochs. If no Trainer is attached, this property is 0.

`property` hparams

`property` hparams_initial

AttributeDict: immutable initial hyperparameters

`property` local_rank

The index of the current process within a single node.

`property` logger

Reference to the logger object in the Trainer.

`property` loggers

Reference to the list of loggers in the Trainer.

`property` on_gpu

Returns True if this model is currently located on a GPU. Useful to set flags around the LightningModule for different CPU vs GPU behavior.

`property` strict_loading

Determines how Lightning loads this model using .load_state_dict(..., strict=model.strict_loading).

`property` trainer

`classmethod` `get_default_config`

get_default_config(h, backend, n_series=None)

`class` `AutoNHITS`

`method` `init`

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

`property` automatic_optimization

If set to False you are responsible for calling .backward(), .step(), .zero_grad().

`property` current_epoch

The current epoch in the Trainer, or 0 if not attached.

`property` device

`property` device_mesh

Strategies like ModelParallelStrategy will create a device mesh that can be accessed in the :meth:~pytorch_lightning.core.hooks.ModelHooks.configure_model hook to parallelize the LightningModule.

`property` dtype

`property` example_input_array

The example input array is a specification of what the module can consume in the :meth:forward method. The return type is interpreted as follows:

Single tensor: It is assumed the model takes a single argument, i.e., model.forward(model.example_input_array)
Tuple: The input array should be interpreted as a sequence of positional arguments, i.e., model.forward(*model.example_input_array)
Dict: The input array represents named keyword arguments, i.e., model.forward(**model.example_input_array)

`property` fabric

`property` global_rank

The index of the current process across all nodes and devices.

`property` global_step

Total training batches seen across all epochs. If no Trainer is attached, this property is 0.

`property` hparams

`property` hparams_initial

AttributeDict: immutable initial hyperparameters

`property` local_rank

The index of the current process within a single node.

`property` logger

Reference to the logger object in the Trainer.

`property` loggers

Reference to the list of loggers in the Trainer.

`property` on_gpu

Returns True if this model is currently located on a GPU. Useful to set flags around the LightningModule for different CPU vs GPU behavior.

`property` strict_loading

Determines how Lightning loads this model using .load_state_dict(..., strict=model.strict_loading).

`property` trainer

`classmethod` `get_default_config`

get_default_config(h, backend, n_series=None)

`class` `AutoDLinear`

`method` `init`

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

`property` automatic_optimization

If set to False you are responsible for calling .backward(), .step(), .zero_grad().

`property` current_epoch

The current epoch in the Trainer, or 0 if not attached.

`property` device

`property` device_mesh

Strategies like ModelParallelStrategy will create a device mesh that can be accessed in the :meth:~pytorch_lightning.core.hooks.ModelHooks.configure_model hook to parallelize the LightningModule.

`property` dtype

`property` example_input_array

The example input array is a specification of what the module can consume in the :meth:forward method. The return type is interpreted as follows:

Single tensor: It is assumed the model takes a single argument, i.e., model.forward(model.example_input_array)
Tuple: The input array should be interpreted as a sequence of positional arguments, i.e., model.forward(*model.example_input_array)
Dict: The input array represents named keyword arguments, i.e., model.forward(**model.example_input_array)

`property` fabric

`property` global_rank

The index of the current process across all nodes and devices.

`property` global_step

Total training batches seen across all epochs. If no Trainer is attached, this property is 0.

`property` hparams

`property` hparams_initial

AttributeDict: immutable initial hyperparameters

`property` local_rank

The index of the current process within a single node.

`property` logger

Reference to the logger object in the Trainer.

`property` loggers

Reference to the list of loggers in the Trainer.

`property` on_gpu

Returns True if this model is currently located on a GPU. Useful to set flags around the LightningModule for different CPU vs GPU behavior.

`property` strict_loading

Determines how Lightning loads this model using .load_state_dict(..., strict=model.strict_loading).

`property` trainer

`classmethod` `get_default_config`

get_default_config(h, backend, n_series=None)

`class` `AutoNLinear`

`method` `init`

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

`property` automatic_optimization

If set to False you are responsible for calling .backward(), .step(), .zero_grad().

`property` current_epoch

The current epoch in the Trainer, or 0 if not attached.

`property` device

`property` device_mesh

Strategies like ModelParallelStrategy will create a device mesh that can be accessed in the :meth:~pytorch_lightning.core.hooks.ModelHooks.configure_model hook to parallelize the LightningModule.

`property` dtype

`property` example_input_array

The example input array is a specification of what the module can consume in the :meth:forward method. The return type is interpreted as follows:

Single tensor: It is assumed the model takes a single argument, i.e., model.forward(model.example_input_array)
Tuple: The input array should be interpreted as a sequence of positional arguments, i.e., model.forward(*model.example_input_array)
Dict: The input array represents named keyword arguments, i.e., model.forward(**model.example_input_array)

`property` fabric

`property` global_rank

The index of the current process across all nodes and devices.

`property` global_step

Total training batches seen across all epochs. If no Trainer is attached, this property is 0.

`property` hparams

`property` hparams_initial

AttributeDict: immutable initial hyperparameters

`property` local_rank

The index of the current process within a single node.

`property` logger

Reference to the logger object in the Trainer.

`property` loggers

Reference to the list of loggers in the Trainer.

`property` on_gpu

Returns True if this model is currently located on a GPU. Useful to set flags around the LightningModule for different CPU vs GPU behavior.

`property` strict_loading

Determines how Lightning loads this model using .load_state_dict(..., strict=model.strict_loading).

`property` trainer

`classmethod` `get_default_config`

get_default_config(h, backend, n_series=None)

`class` `AutoTiDE`

`method` `init`

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

`property` automatic_optimization

If set to False you are responsible for calling .backward(), .step(), .zero_grad().

`property` current_epoch

The current epoch in the Trainer, or 0 if not attached.

`property` device

`property` device_mesh

Strategies like ModelParallelStrategy will create a device mesh that can be accessed in the :meth:~pytorch_lightning.core.hooks.ModelHooks.configure_model hook to parallelize the LightningModule.

`property` dtype

`property` example_input_array

The example input array is a specification of what the module can consume in the :meth:forward method. The return type is interpreted as follows:

Single tensor: It is assumed the model takes a single argument, i.e., model.forward(model.example_input_array)
Tuple: The input array should be interpreted as a sequence of positional arguments, i.e., model.forward(*model.example_input_array)
Dict: The input array represents named keyword arguments, i.e., model.forward(**model.example_input_array)

`property` fabric

`property` global_rank

The index of the current process across all nodes and devices.

`property` global_step

Total training batches seen across all epochs. If no Trainer is attached, this property is 0.

`property` hparams

`property` hparams_initial

AttributeDict: immutable initial hyperparameters

`property` local_rank

The index of the current process within a single node.

`property` logger

Reference to the logger object in the Trainer.

`property` loggers

Reference to the list of loggers in the Trainer.

`property` on_gpu

Returns True if this model is currently located on a GPU. Useful to set flags around the LightningModule for different CPU vs GPU behavior.

`property` strict_loading

Determines how Lightning loads this model using .load_state_dict(..., strict=model.strict_loading).

`property` trainer

`classmethod` `get_default_config`

get_default_config(h, backend, n_series=None)

`class` `AutoDeepNPTS`

`method` `init`

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

`property` automatic_optimization

If set to False you are responsible for calling .backward(), .step(), .zero_grad().

`property` current_epoch

The current epoch in the Trainer, or 0 if not attached.

`property` device

`property` device_mesh

Strategies like ModelParallelStrategy will create a device mesh that can be accessed in the :meth:~pytorch_lightning.core.hooks.ModelHooks.configure_model hook to parallelize the LightningModule.

`property` dtype

`property` example_input_array

The example input array is a specification of what the module can consume in the :meth:forward method. The return type is interpreted as follows:

Single tensor: It is assumed the model takes a single argument, i.e., model.forward(model.example_input_array)
Tuple: The input array should be interpreted as a sequence of positional arguments, i.e., model.forward(*model.example_input_array)
Dict: The input array represents named keyword arguments, i.e., model.forward(**model.example_input_array)

`property` fabric

`property` global_rank

The index of the current process across all nodes and devices.

`property` global_step

Total training batches seen across all epochs. If no Trainer is attached, this property is 0.

`property` hparams

`property` hparams_initial

AttributeDict: immutable initial hyperparameters

`property` local_rank

The index of the current process within a single node.

`property` logger

Reference to the logger object in the Trainer.

`property` loggers

Reference to the list of loggers in the Trainer.

`property` on_gpu

Returns True if this model is currently located on a GPU. Useful to set flags around the LightningModule for different CPU vs GPU behavior.

`property` strict_loading

Determines how Lightning loads this model using .load_state_dict(..., strict=model.strict_loading).

`property` trainer

`classmethod` `get_default_config`

get_default_config(h, backend, n_series=None)

`class` `AutoKAN`

`method` `init`

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

`property` automatic_optimization

If set to False you are responsible for calling .backward(), .step(), .zero_grad().

`property` current_epoch

The current epoch in the Trainer, or 0 if not attached.

`property` device

`property` device_mesh

Strategies like ModelParallelStrategy will create a device mesh that can be accessed in the :meth:~pytorch_lightning.core.hooks.ModelHooks.configure_model hook to parallelize the LightningModule.

`property` dtype

`property` example_input_array

The example input array is a specification of what the module can consume in the :meth:forward method. The return type is interpreted as follows:

Single tensor: It is assumed the model takes a single argument, i.e., model.forward(model.example_input_array)
Tuple: The input array should be interpreted as a sequence of positional arguments, i.e., model.forward(*model.example_input_array)
Dict: The input array represents named keyword arguments, i.e., model.forward(**model.example_input_array)

`property` fabric

`property` global_rank

The index of the current process across all nodes and devices.

`property` global_step

Total training batches seen across all epochs. If no Trainer is attached, this property is 0.

`property` hparams

`property` hparams_initial

AttributeDict: immutable initial hyperparameters

`property` local_rank

The index of the current process within a single node.

`property` logger

Reference to the logger object in the Trainer.

`property` loggers

Reference to the list of loggers in the Trainer.

`property` on_gpu

Returns True if this model is currently located on a GPU. Useful to set flags around the LightningModule for different CPU vs GPU behavior.

`property` strict_loading

Determines how Lightning loads this model using .load_state_dict(..., strict=model.strict_loading).

`property` trainer

`classmethod` `get_default_config`

get_default_config(h, backend, n_series=None)

`class` `AutoTFT`

`method` `init`

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

`property` automatic_optimization

If set to False you are responsible for calling .backward(), .step(), .zero_grad().

`property` current_epoch

The current epoch in the Trainer, or 0 if not attached.

`property` device

`property` device_mesh

Strategies like ModelParallelStrategy will create a device mesh that can be accessed in the :meth:~pytorch_lightning.core.hooks.ModelHooks.configure_model hook to parallelize the LightningModule.

`property` dtype

`property` example_input_array

The example input array is a specification of what the module can consume in the :meth:forward method. The return type is interpreted as follows:

Single tensor: It is assumed the model takes a single argument, i.e., model.forward(model.example_input_array)
Tuple: The input array should be interpreted as a sequence of positional arguments, i.e., model.forward(*model.example_input_array)
Dict: The input array represents named keyword arguments, i.e., model.forward(**model.example_input_array)

`property` fabric

`property` global_rank

The index of the current process across all nodes and devices.

`property` global_step

Total training batches seen across all epochs. If no Trainer is attached, this property is 0.

`property` hparams

`property` hparams_initial

AttributeDict: immutable initial hyperparameters

`property` local_rank

The index of the current process within a single node.

`property` logger

Reference to the logger object in the Trainer.

`property` loggers

Reference to the list of loggers in the Trainer.

`property` on_gpu

Returns True if this model is currently located on a GPU. Useful to set flags around the LightningModule for different CPU vs GPU behavior.

`property` strict_loading

Determines how Lightning loads this model using .load_state_dict(..., strict=model.strict_loading).

`property` trainer

`classmethod` `get_default_config`

get_default_config(h, backend, n_series=None)

`class` `AutoVanillaTransformer`

`method` `init`

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

`property` automatic_optimization

If set to False you are responsible for calling .backward(), .step(), .zero_grad().

`property` current_epoch

The current epoch in the Trainer, or 0 if not attached.

`property` device

`property` device_mesh

Strategies like ModelParallelStrategy will create a device mesh that can be accessed in the :meth:~pytorch_lightning.core.hooks.ModelHooks.configure_model hook to parallelize the LightningModule.

`property` dtype

`property` example_input_array

The example input array is a specification of what the module can consume in the :meth:forward method. The return type is interpreted as follows:

Single tensor: It is assumed the model takes a single argument, i.e., model.forward(model.example_input_array)
Tuple: The input array should be interpreted as a sequence of positional arguments, i.e., model.forward(*model.example_input_array)
Dict: The input array represents named keyword arguments, i.e., model.forward(**model.example_input_array)

`property` fabric

`property` global_rank

The index of the current process across all nodes and devices.

`property` global_step

Total training batches seen across all epochs. If no Trainer is attached, this property is 0.

`property` hparams

`property` hparams_initial

AttributeDict: immutable initial hyperparameters

`property` local_rank

The index of the current process within a single node.

`property` logger

Reference to the logger object in the Trainer.

`property` loggers

Reference to the list of loggers in the Trainer.

`property` on_gpu

Returns True if this model is currently located on a GPU. Useful to set flags around the LightningModule for different CPU vs GPU behavior.

`property` strict_loading

Determines how Lightning loads this model using .load_state_dict(..., strict=model.strict_loading).

`property` trainer

`classmethod` `get_default_config`

get_default_config(h, backend, n_series=None)

`class` `AutoInformer`

`method` `init`

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

`property` automatic_optimization

If set to False you are responsible for calling .backward(), .step(), .zero_grad().

`property` current_epoch

The current epoch in the Trainer, or 0 if not attached.

`property` device

`property` device_mesh

Strategies like ModelParallelStrategy will create a device mesh that can be accessed in the :meth:~pytorch_lightning.core.hooks.ModelHooks.configure_model hook to parallelize the LightningModule.

`property` dtype

`property` example_input_array

The example input array is a specification of what the module can consume in the :meth:forward method. The return type is interpreted as follows:

Single tensor: It is assumed the model takes a single argument, i.e., model.forward(model.example_input_array)
Tuple: The input array should be interpreted as a sequence of positional arguments, i.e., model.forward(*model.example_input_array)
Dict: The input array represents named keyword arguments, i.e., model.forward(**model.example_input_array)

`property` fabric

`property` global_rank

The index of the current process across all nodes and devices.

`property` global_step

Total training batches seen across all epochs. If no Trainer is attached, this property is 0.

`property` hparams

`property` hparams_initial

AttributeDict: immutable initial hyperparameters

`property` local_rank

The index of the current process within a single node.

`property` logger

Reference to the logger object in the Trainer.

`property` loggers

Reference to the list of loggers in the Trainer.

`property` on_gpu

Returns True if this model is currently located on a GPU. Useful to set flags around the LightningModule for different CPU vs GPU behavior.

`property` strict_loading

Determines how Lightning loads this model using .load_state_dict(..., strict=model.strict_loading).

`property` trainer

`classmethod` `get_default_config`

get_default_config(h, backend, n_series=None)

`class` `AutoAutoformer`

`method` `init`

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

`property` automatic_optimization

If set to False you are responsible for calling .backward(), .step(), .zero_grad().

`property` current_epoch

The current epoch in the Trainer, or 0 if not attached.

`property` device

`property` device_mesh

Strategies like ModelParallelStrategy will create a device mesh that can be accessed in the :meth:~pytorch_lightning.core.hooks.ModelHooks.configure_model hook to parallelize the LightningModule.

`property` dtype

`property` example_input_array

The example input array is a specification of what the module can consume in the :meth:forward method. The return type is interpreted as follows:

Single tensor: It is assumed the model takes a single argument, i.e., model.forward(model.example_input_array)
Tuple: The input array should be interpreted as a sequence of positional arguments, i.e., model.forward(*model.example_input_array)
Dict: The input array represents named keyword arguments, i.e., model.forward(**model.example_input_array)

`property` fabric

`property` global_rank

The index of the current process across all nodes and devices.

`property` global_step

Total training batches seen across all epochs. If no Trainer is attached, this property is 0.

`property` hparams

`property` hparams_initial

AttributeDict: immutable initial hyperparameters

`property` local_rank

The index of the current process within a single node.

`property` logger

Reference to the logger object in the Trainer.

`property` loggers

Reference to the list of loggers in the Trainer.

`property` on_gpu

Returns True if this model is currently located on a GPU. Useful to set flags around the LightningModule for different CPU vs GPU behavior.

`property` strict_loading

Determines how Lightning loads this model using .load_state_dict(..., strict=model.strict_loading).

`property` trainer

`classmethod` `get_default_config`

get_default_config(h, backend, n_series=None)

`class` `AutoFEDformer`

`method` `init`

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

`property` automatic_optimization

If set to False you are responsible for calling .backward(), .step(), .zero_grad().

`property` current_epoch

The current epoch in the Trainer, or 0 if not attached.

`property` device

`property` device_mesh

Strategies like ModelParallelStrategy will create a device mesh that can be accessed in the :meth:~pytorch_lightning.core.hooks.ModelHooks.configure_model hook to parallelize the LightningModule.

`property` dtype

`property` example_input_array

The example input array is a specification of what the module can consume in the :meth:forward method. The return type is interpreted as follows:

Single tensor: It is assumed the model takes a single argument, i.e., model.forward(model.example_input_array)
Tuple: The input array should be interpreted as a sequence of positional arguments, i.e., model.forward(*model.example_input_array)
Dict: The input array represents named keyword arguments, i.e., model.forward(**model.example_input_array)

`property` fabric

`property` global_rank

The index of the current process across all nodes and devices.

`property` global_step

Total training batches seen across all epochs. If no Trainer is attached, this property is 0.

`property` hparams

`property` hparams_initial

AttributeDict: immutable initial hyperparameters

`property` local_rank

The index of the current process within a single node.

`property` logger

Reference to the logger object in the Trainer.

`property` loggers

Reference to the list of loggers in the Trainer.

`property` on_gpu

Returns True if this model is currently located on a GPU. Useful to set flags around the LightningModule for different CPU vs GPU behavior.

`property` strict_loading

Determines how Lightning loads this model using .load_state_dict(..., strict=model.strict_loading).

`property` trainer

`classmethod` `get_default_config`

get_default_config(h, backend, n_series=None)

`class` `AutoPatchTST`

`method` `init`

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

`property` automatic_optimization

If set to False you are responsible for calling .backward(), .step(), .zero_grad().

`property` current_epoch

The current epoch in the Trainer, or 0 if not attached.

`property` device

`property` device_mesh

Strategies like ModelParallelStrategy will create a device mesh that can be accessed in the :meth:~pytorch_lightning.core.hooks.ModelHooks.configure_model hook to parallelize the LightningModule.

`property` dtype

`property` example_input_array

The example input array is a specification of what the module can consume in the :meth:forward method. The return type is interpreted as follows:

Single tensor: It is assumed the model takes a single argument, i.e., model.forward(model.example_input_array)
Tuple: The input array should be interpreted as a sequence of positional arguments, i.e., model.forward(*model.example_input_array)
Dict: The input array represents named keyword arguments, i.e., model.forward(**model.example_input_array)

`property` fabric

`property` global_rank

The index of the current process across all nodes and devices.

`property` global_step

Total training batches seen across all epochs. If no Trainer is attached, this property is 0.

`property` hparams

`property` hparams_initial

AttributeDict: immutable initial hyperparameters

`property` local_rank

The index of the current process within a single node.

`property` logger

Reference to the logger object in the Trainer.

`property` loggers

Reference to the list of loggers in the Trainer.

`property` on_gpu

Returns True if this model is currently located on a GPU. Useful to set flags around the LightningModule for different CPU vs GPU behavior.

`property` strict_loading

Determines how Lightning loads this model using .load_state_dict(..., strict=model.strict_loading).

`property` trainer

`classmethod` `get_default_config`

get_default_config(h, backend, n_series=None)

`class` `AutoiTransformer`

`method` `init`

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

`property` automatic_optimization

If set to False you are responsible for calling .backward(), .step(), .zero_grad().

`property` current_epoch

The current epoch in the Trainer, or 0 if not attached.

`property` device

`property` device_mesh

Strategies like ModelParallelStrategy will create a device mesh that can be accessed in the :meth:~pytorch_lightning.core.hooks.ModelHooks.configure_model hook to parallelize the LightningModule.

`property` dtype

`property` example_input_array

The example input array is a specification of what the module can consume in the :meth:forward method. The return type is interpreted as follows:

Single tensor: It is assumed the model takes a single argument, i.e., model.forward(model.example_input_array)
Tuple: The input array should be interpreted as a sequence of positional arguments, i.e., model.forward(*model.example_input_array)
Dict: The input array represents named keyword arguments, i.e., model.forward(**model.example_input_array)

`property` fabric

`property` global_rank

The index of the current process across all nodes and devices.

`property` global_step

Total training batches seen across all epochs. If no Trainer is attached, this property is 0.

`property` hparams

`property` hparams_initial

AttributeDict: immutable initial hyperparameters

`property` local_rank

The index of the current process within a single node.

`property` logger

Reference to the logger object in the Trainer.

`property` loggers

Reference to the list of loggers in the Trainer.

`property` on_gpu

Returns True if this model is currently located on a GPU. Useful to set flags around the LightningModule for different CPU vs GPU behavior.

`property` strict_loading

Determines how Lightning loads this model using .load_state_dict(..., strict=model.strict_loading).

`property` trainer

`classmethod` `get_default_config`

get_default_config(h, backend, n_series)

`class` `AutoTimeXer`

`method` `init`

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

`property` automatic_optimization

If set to False you are responsible for calling .backward(), .step(), .zero_grad().

`property` current_epoch

The current epoch in the Trainer, or 0 if not attached.

`property` device

`property` device_mesh

Strategies like ModelParallelStrategy will create a device mesh that can be accessed in the :meth:~pytorch_lightning.core.hooks.ModelHooks.configure_model hook to parallelize the LightningModule.

`property` dtype

`property` example_input_array

The example input array is a specification of what the module can consume in the :meth:forward method. The return type is interpreted as follows:

Single tensor: It is assumed the model takes a single argument, i.e., model.forward(model.example_input_array)
Tuple: The input array should be interpreted as a sequence of positional arguments, i.e., model.forward(*model.example_input_array)
Dict: The input array represents named keyword arguments, i.e., model.forward(**model.example_input_array)

`property` fabric

`property` global_rank

The index of the current process across all nodes and devices.

`property` global_step

Total training batches seen across all epochs. If no Trainer is attached, this property is 0.

`property` hparams

`property` hparams_initial

AttributeDict: immutable initial hyperparameters

`property` local_rank

The index of the current process within a single node.

`property` logger

Reference to the logger object in the Trainer.

`property` loggers

Reference to the list of loggers in the Trainer.

`property` on_gpu

Returns True if this model is currently located on a GPU. Useful to set flags around the LightningModule for different CPU vs GPU behavior.

`property` strict_loading

Determines how Lightning loads this model using .load_state_dict(..., strict=model.strict_loading).

`property` trainer

`classmethod` `get_default_config`

get_default_config(h, backend, n_series)

`class` `AutoTimesNet`

`method` `init`

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

`property` automatic_optimization

If set to False you are responsible for calling .backward(), .step(), .zero_grad().

`property` current_epoch

The current epoch in the Trainer, or 0 if not attached.

`property` device

`property` device_mesh

Strategies like ModelParallelStrategy will create a device mesh that can be accessed in the :meth:~pytorch_lightning.core.hooks.ModelHooks.configure_model hook to parallelize the LightningModule.

`property` dtype

`property` example_input_array

The example input array is a specification of what the module can consume in the :meth:forward method. The return type is interpreted as follows:

Single tensor: It is assumed the model takes a single argument, i.e., model.forward(model.example_input_array)
Tuple: The input array should be interpreted as a sequence of positional arguments, i.e., model.forward(*model.example_input_array)
Dict: The input array represents named keyword arguments, i.e., model.forward(**model.example_input_array)

`property` fabric

`property` global_rank

The index of the current process across all nodes and devices.

`property` global_step

Total training batches seen across all epochs. If no Trainer is attached, this property is 0.

`property` hparams

`property` hparams_initial

AttributeDict: immutable initial hyperparameters

`property` local_rank

The index of the current process within a single node.

`property` logger

Reference to the logger object in the Trainer.

`property` loggers

Reference to the list of loggers in the Trainer.

`property` on_gpu

Returns True if this model is currently located on a GPU. Useful to set flags around the LightningModule for different CPU vs GPU behavior.

`property` strict_loading

Determines how Lightning loads this model using .load_state_dict(..., strict=model.strict_loading).

`property` trainer

`classmethod` `get_default_config`

get_default_config(h, backend, n_series=None)

`class` `AutoStemGNN`

`method` `init`

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

`property` automatic_optimization

If set to False you are responsible for calling .backward(), .step(), .zero_grad().

`property` current_epoch

The current epoch in the Trainer, or 0 if not attached.

`property` device

`property` device_mesh

Strategies like ModelParallelStrategy will create a device mesh that can be accessed in the :meth:~pytorch_lightning.core.hooks.ModelHooks.configure_model hook to parallelize the LightningModule.

`property` dtype

`property` example_input_array

The example input array is a specification of what the module can consume in the :meth:forward method. The return type is interpreted as follows:

Single tensor: It is assumed the model takes a single argument, i.e., model.forward(model.example_input_array)
Tuple: The input array should be interpreted as a sequence of positional arguments, i.e., model.forward(*model.example_input_array)
Dict: The input array represents named keyword arguments, i.e., model.forward(**model.example_input_array)

`property` fabric

`property` global_rank

The index of the current process across all nodes and devices.

`property` global_step

Total training batches seen across all epochs. If no Trainer is attached, this property is 0.

`property` hparams

`property` hparams_initial

AttributeDict: immutable initial hyperparameters

`property` local_rank

The index of the current process within a single node.

`property` logger

Reference to the logger object in the Trainer.

`property` loggers

Reference to the list of loggers in the Trainer.

`property` on_gpu

Returns True if this model is currently located on a GPU. Useful to set flags around the LightningModule for different CPU vs GPU behavior.

`property` strict_loading

Determines how Lightning loads this model using .load_state_dict(..., strict=model.strict_loading).

`property` trainer

`classmethod` `get_default_config`

get_default_config(h, backend, n_series)

`class` `AutoHINT`

`method` `init`

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

`property` automatic_optimization

If set to False you are responsible for calling .backward(), .step(), .zero_grad().

`property` current_epoch

The current epoch in the Trainer, or 0 if not attached.

`property` device

`property` device_mesh

Strategies like ModelParallelStrategy will create a device mesh that can be accessed in the :meth:~pytorch_lightning.core.hooks.ModelHooks.configure_model hook to parallelize the LightningModule.

`property` dtype

`property` example_input_array

The example input array is a specification of what the module can consume in the :meth:forward method. The return type is interpreted as follows:

Single tensor: It is assumed the model takes a single argument, i.e., model.forward(model.example_input_array)
Tuple: The input array should be interpreted as a sequence of positional arguments, i.e., model.forward(*model.example_input_array)
Dict: The input array represents named keyword arguments, i.e., model.forward(**model.example_input_array)

`property` fabric

`property` global_rank

The index of the current process across all nodes and devices.

`property` global_step

Total training batches seen across all epochs. If no Trainer is attached, this property is 0.

`property` hparams

`property` hparams_initial

AttributeDict: immutable initial hyperparameters

`property` local_rank

The index of the current process within a single node.

`property` logger

Reference to the logger object in the Trainer.

`property` loggers

Reference to the list of loggers in the Trainer.

`property` on_gpu

Returns True if this model is currently located on a GPU. Useful to set flags around the LightningModule for different CPU vs GPU behavior.

`property` strict_loading

Determines how Lightning loads this model using .load_state_dict(..., strict=model.strict_loading).

`property` trainer

`classmethod` `get_default_config`

get_default_config(h, backend, n_series=None)

`class` `AutoTSMixer`

`method` `init`

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

`property` automatic_optimization

If set to False you are responsible for calling .backward(), .step(), .zero_grad().

`property` current_epoch

The current epoch in the Trainer, or 0 if not attached.

`property` device

`property` device_mesh

Strategies like ModelParallelStrategy will create a device mesh that can be accessed in the :meth:~pytorch_lightning.core.hooks.ModelHooks.configure_model hook to parallelize the LightningModule.

`property` dtype

`property` example_input_array

The example input array is a specification of what the module can consume in the :meth:forward method. The return type is interpreted as follows:

Single tensor: It is assumed the model takes a single argument, i.e., model.forward(model.example_input_array)
Tuple: The input array should be interpreted as a sequence of positional arguments, i.e., model.forward(*model.example_input_array)
Dict: The input array represents named keyword arguments, i.e., model.forward(**model.example_input_array)

`property` fabric

`property` global_rank

The index of the current process across all nodes and devices.

`property` global_step

Total training batches seen across all epochs. If no Trainer is attached, this property is 0.

`property` hparams

`property` hparams_initial

AttributeDict: immutable initial hyperparameters

`property` local_rank

The index of the current process within a single node.

`property` logger

Reference to the logger object in the Trainer.

`property` loggers

Reference to the list of loggers in the Trainer.

`property` on_gpu

Returns True if this model is currently located on a GPU. Useful to set flags around the LightningModule for different CPU vs GPU behavior.

`property` strict_loading

Determines how Lightning loads this model using .load_state_dict(..., strict=model.strict_loading).

`property` trainer

`classmethod` `get_default_config`

get_default_config(h, backend, n_series)

`class` `AutoTSMixerx`

`method` `init`

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

`property` automatic_optimization

If set to False you are responsible for calling .backward(), .step(), .zero_grad().

`property` current_epoch

The current epoch in the Trainer, or 0 if not attached.

`property` device

`property` device_mesh

Strategies like ModelParallelStrategy will create a device mesh that can be accessed in the :meth:~pytorch_lightning.core.hooks.ModelHooks.configure_model hook to parallelize the LightningModule.

`property` dtype

`property` example_input_array

The example input array is a specification of what the module can consume in the :meth:forward method. The return type is interpreted as follows:

Single tensor: It is assumed the model takes a single argument, i.e., model.forward(model.example_input_array)
Tuple: The input array should be interpreted as a sequence of positional arguments, i.e., model.forward(*model.example_input_array)
Dict: The input array represents named keyword arguments, i.e., model.forward(**model.example_input_array)

`property` fabric

`property` global_rank

The index of the current process across all nodes and devices.

`property` global_step

Total training batches seen across all epochs. If no Trainer is attached, this property is 0.

`property` hparams

`property` hparams_initial

AttributeDict: immutable initial hyperparameters

`property` local_rank

The index of the current process within a single node.

`property` logger

Reference to the logger object in the Trainer.

`property` loggers

Reference to the list of loggers in the Trainer.

`property` on_gpu

Returns True if this model is currently located on a GPU. Useful to set flags around the LightningModule for different CPU vs GPU behavior.

`property` strict_loading

Determines how Lightning loads this model using .load_state_dict(..., strict=model.strict_loading).

`property` trainer

`classmethod` `get_default_config`

get_default_config(h, backend, n_series)

`class` `AutoMLPMultivariate`

`method` `init`

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

`property` automatic_optimization

If set to False you are responsible for calling .backward(), .step(), .zero_grad().

`property` current_epoch

The current epoch in the Trainer, or 0 if not attached.

`property` device

`property` device_mesh

Strategies like ModelParallelStrategy will create a device mesh that can be accessed in the :meth:~pytorch_lightning.core.hooks.ModelHooks.configure_model hook to parallelize the LightningModule.

`property` dtype

`property` example_input_array

The example input array is a specification of what the module can consume in the :meth:forward method. The return type is interpreted as follows:

Single tensor: It is assumed the model takes a single argument, i.e., model.forward(model.example_input_array)
Tuple: The input array should be interpreted as a sequence of positional arguments, i.e., model.forward(*model.example_input_array)
Dict: The input array represents named keyword arguments, i.e., model.forward(**model.example_input_array)

`property` fabric

`property` global_rank

The index of the current process across all nodes and devices.

`property` global_step

Total training batches seen across all epochs. If no Trainer is attached, this property is 0.

`property` hparams

`property` hparams_initial

AttributeDict: immutable initial hyperparameters

`property` local_rank

The index of the current process within a single node.

`property` logger

Reference to the logger object in the Trainer.

`property` loggers

Reference to the list of loggers in the Trainer.

`property` on_gpu

Returns True if this model is currently located on a GPU. Useful to set flags around the LightningModule for different CPU vs GPU behavior.

`property` strict_loading

Determines how Lightning loads this model using .load_state_dict(..., strict=model.strict_loading).

`property` trainer

`classmethod` `get_default_config`

get_default_config(h, backend, n_series)

`class` `AutoSOFTS`

`method` `init`

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

`property` automatic_optimization

If set to False you are responsible for calling .backward(), .step(), .zero_grad().

`property` current_epoch

The current epoch in the Trainer, or 0 if not attached.

`property` device

`property` device_mesh

Strategies like ModelParallelStrategy will create a device mesh that can be accessed in the :meth:~pytorch_lightning.core.hooks.ModelHooks.configure_model hook to parallelize the LightningModule.

`property` dtype

`property` example_input_array

The example input array is a specification of what the module can consume in the :meth:forward method. The return type is interpreted as follows:

Single tensor: It is assumed the model takes a single argument, i.e., model.forward(model.example_input_array)
Tuple: The input array should be interpreted as a sequence of positional arguments, i.e., model.forward(*model.example_input_array)
Dict: The input array represents named keyword arguments, i.e., model.forward(**model.example_input_array)

`property` fabric

`property` global_rank

The index of the current process across all nodes and devices.

`property` global_step

Total training batches seen across all epochs. If no Trainer is attached, this property is 0.

`property` hparams

`property` hparams_initial

AttributeDict: immutable initial hyperparameters

`property` local_rank

The index of the current process within a single node.

`property` logger

Reference to the logger object in the Trainer.

`property` loggers

Reference to the list of loggers in the Trainer.

`property` on_gpu

Returns True if this model is currently located on a GPU. Useful to set flags around the LightningModule for different CPU vs GPU behavior.

`property` strict_loading

Determines how Lightning loads this model using .load_state_dict(..., strict=model.strict_loading).

`property` trainer

`classmethod` `get_default_config`

get_default_config(h, backend, n_series)

`class` `AutoTimeMixer`

`method` `init`

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

`property` automatic_optimization

If set to False you are responsible for calling .backward(), .step(), .zero_grad().

`property` current_epoch

The current epoch in the Trainer, or 0 if not attached.

`property` device

`property` device_mesh

Strategies like ModelParallelStrategy will create a device mesh that can be accessed in the :meth:~pytorch_lightning.core.hooks.ModelHooks.configure_model hook to parallelize the LightningModule.

`property` dtype

`property` example_input_array

The example input array is a specification of what the module can consume in the :meth:forward method. The return type is interpreted as follows:

Single tensor: It is assumed the model takes a single argument, i.e., model.forward(model.example_input_array)
Tuple: The input array should be interpreted as a sequence of positional arguments, i.e., model.forward(*model.example_input_array)
Dict: The input array represents named keyword arguments, i.e., model.forward(**model.example_input_array)

`property` fabric

`property` global_rank

The index of the current process across all nodes and devices.

`property` global_step

Total training batches seen across all epochs. If no Trainer is attached, this property is 0.

`property` hparams

`property` hparams_initial

AttributeDict: immutable initial hyperparameters

`property` local_rank

The index of the current process within a single node.

`property` logger

Reference to the logger object in the Trainer.

`property` loggers

Reference to the list of loggers in the Trainer.

`property` on_gpu

Returns True if this model is currently located on a GPU. Useful to set flags around the LightningModule for different CPU vs GPU behavior.

`property` strict_loading

Determines how Lightning loads this model using .load_state_dict(..., strict=model.strict_loading).

`property` trainer

`classmethod` `get_default_config`

get_default_config(h, backend, n_series)

`class` `AutoRMoK`

`method` `init`

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

`property` automatic_optimization

If set to False you are responsible for calling .backward(), .step(), .zero_grad().

`property` current_epoch

The current epoch in the Trainer, or 0 if not attached.

`property` device

`property` device_mesh

Strategies like ModelParallelStrategy will create a device mesh that can be accessed in the :meth:~pytorch_lightning.core.hooks.ModelHooks.configure_model hook to parallelize the LightningModule.

`property` dtype

`property` example_input_array

The example input array is a specification of what the module can consume in the :meth:forward method. The return type is interpreted as follows:

Single tensor: It is assumed the model takes a single argument, i.e., model.forward(model.example_input_array)
Tuple: The input array should be interpreted as a sequence of positional arguments, i.e., model.forward(*model.example_input_array)
Dict: The input array represents named keyword arguments, i.e., model.forward(**model.example_input_array)

`property` fabric

`property` global_rank

The index of the current process across all nodes and devices.

`property` global_step

Total training batches seen across all epochs. If no Trainer is attached, this property is 0.

`property` hparams

`property` hparams_initial

AttributeDict: immutable initial hyperparameters

`property` local_rank

The index of the current process within a single node.

`property` logger

Reference to the logger object in the Trainer.

`property` loggers

Reference to the list of loggers in the Trainer.

`property` on_gpu

Returns True if this model is currently located on a GPU. Useful to set flags around the LightningModule for different CPU vs GPU behavior.

`property` strict_loading

Determines how Lightning loads this model using .load_state_dict(..., strict=model.strict_loading).

`property` trainer

`classmethod` `get_default_config`

get_default_config(h, backend, n_series)

Getting Started

Capabilities

Tutorials

Use cases

API Reference

​module neuralforecast.auto

​class AutoRNN

​method __init__

​property automatic_optimization

​property current_epoch

​property device

​property device_mesh

​property dtype

​property example_input_array

​property fabric

​property global_rank

​property global_step

​property hparams

​property hparams_initial

​property local_rank

​property logger

​property loggers

​property on_gpu

​property strict_loading

​property trainer

​classmethod get_default_config

​class AutoLSTM

​method __init__

​property automatic_optimization

​property current_epoch

​property device

​property device_mesh

​property dtype

​property example_input_array

​property fabric

​property global_rank

​property global_step

​property hparams

​property hparams_initial

​property local_rank

​property logger

​property loggers

​property on_gpu

​property strict_loading

​property trainer

​classmethod get_default_config

​class AutoGRU

​method __init__

​property automatic_optimization

​property current_epoch

​property device

​property device_mesh

​property dtype

​property example_input_array

​property fabric

​property global_rank

​property global_step

​property hparams

​property hparams_initial

​property local_rank

​property logger

​property loggers

​property on_gpu

​property strict_loading

​property trainer

​classmethod get_default_config

​class AutoTCN

​method __init__

​property automatic_optimization

​property current_epoch

​property device

​property device_mesh

​property dtype

​property example_input_array

​property fabric

​property global_rank

​property global_step

​property hparams

​property hparams_initial

​property local_rank

`module` `neuralforecast.auto`

`class` `AutoRNN`

`method` `init`

`property` automatic_optimization

`property` current_epoch

`property` device

`property` device_mesh

`property` dtype

`property` example_input_array

`property` fabric

`property` global_rank

`property` global_step

`property` hparams

`property` hparams_initial

`property` local_rank

`property` logger

`property` loggers

`property` on_gpu

`property` strict_loading

`property` trainer

`classmethod` `get_default_config`

`class` `AutoLSTM`

`method` `init`

`property` automatic_optimization

`property` current_epoch

`property` device

`property` device_mesh

`property` dtype

`property` example_input_array

`property` fabric

`property` global_rank

`property` global_step

`property` hparams

`property` hparams_initial

`property` local_rank

`property` logger

`property` loggers

`property` on_gpu

`property` strict_loading

`property` trainer

`classmethod` `get_default_config`

`class` `AutoGRU`

`method` `init`

`property` automatic_optimization

`property` current_epoch

`property` device

`property` device_mesh

`property` dtype

`property` example_input_array

`property` fabric

`property` global_rank

`property` global_step

`property` hparams

`property` hparams_initial

`property` local_rank

`property` logger

`property` loggers

`property` on_gpu

`property` strict_loading

`property` trainer

`classmethod` `get_default_config`

`class` `AutoTCN`

`method` `init`

`property` automatic_optimization

`property` current_epoch

`property` device

`property` device_mesh

`property` dtype

`property` example_input_array

`property` fabric

`property` global_rank

`property` global_step

`property` hparams

`property` hparams_initial

`property` local_rank

`property` logger

`property` loggers

`property` on_gpu

`property` strict_loading

`property` trainer