# PatchTST

## Visão geral

O modelo PatchTST foi proposto em [A Time Series is Worth 64 Words: Long-term Forecasting with Transformers](https://huggingface.co/papers/2211.14730) por Yuqi Nie, Nam H. Nguyen, Phanwadee Sinthong e Jayant Kalagnanam.

Em alto nível, o modelo vetoriza séries temporais em patches de um tamanho definido e codifica a sequência resultante de vetores por meio de um Transformer, que então produz a previsão do comprimento definido por meio de um head apropriado. O modelo é ilustrado na figura a seguir:

![model](https://github.com/namctin/transformers/assets/8100/150af169-29de-419a-8d98-eb78251c21fa)

O resumo do artigo é o seguinte:

*Propomos um design eficiente de modelos baseados em Transformer para previsão de séries temporais multivariadas e aprendizado de representações auto-supervisionado. Ele é baseado em dois componentes-chave: (i) segmentação de séries temporais em patches de nível de sub-série, que são usados como tokens de entrada para o Transformer; (ii) independência de canal, em que cada canal contém uma única série temporal univariada que compartilha o mesmo embedding e pesos do Transformer entre todas as séries. O design de patching tem naturalmente três benefícios: a informação semântica local é retida no embedding; o uso de computação e memória dos mapas de atenção é reduzido quadraticamente dado a mesma janela de retrospectiva; e o modelo pode considerar um histórico mais longo. Nosso Transformer de séries temporais com patching independente de canal (PatchTST) pode melhorar significativamente a precisão da previsão de longo prazo em comparação com modelos baseados em Transformer SOTA. Também aplicamos nosso modelo a tarefas de pré-treinamento auto-supervisionado e alcançamos excelente desempenho de fine-tuning, superando o treinamento supervisionado em grandes conjuntos de dados. A transferência de representações pré-treinadas com máscara de um conjunto de dados para outros também produz precisão de previsão SOTA.*

Este modelo foi contribuído por [namctin](https://huggingface.co/namctin), [gsinthong](https://huggingface.co/gsinthong), [diepi](https://huggingface.co/diepi), [vijaye12](https://huggingface.co/vijaye12), [wmgifford](https://huggingface.co/wmgifford) e [kashif](https://huggingface.co/kashif). O código original pode ser encontrado [aqui](https://github.com/yuqinie98/PatchTST).

## Dicas de uso

O modelo também pode ser usado para classificação de séries temporais e regressão de séries temporais. Consulte as respectivas classes [PatchTSTForClassification](/docs/transformers/main/pt/model_doc/patchtst#transformers.PatchTSTForClassification) e [PatchTSTForRegression](/docs/transformers/main/pt/model_doc/patchtst#transformers.PatchTSTForRegression).

## Recursos

- Um post de blog explicando o PatchTST em profundidade pode ser encontrado [aqui](https://huggingface.co/blog/patchtst). O blog também pode ser aberto no Google Colab.

## PatchTSTConfig[[transformers.PatchTSTConfig]]

#### transformers.PatchTSTConfig[[transformers.PatchTSTConfig]]

```python
transformers.PatchTSTConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, num_input_channels: int = 1, context_length: int = 32, distribution_output: str = 'student_t', loss: str | None = 'mse', patch_length: int = 1, patch_stride: int = 1, num_hidden_layers: int = 3, d_model: int = 128, num_attention_heads: int = 4, share_embedding: bool = True, channel_attention: bool = False, ffn_dim: int = 512, norm_type: str = 'batchnorm', norm_eps: float = 1e-05, attention_dropout: float | int = 0.0, positional_dropout: float | int = 0.0, path_dropout: float | int = 0.0, ff_dropout: float | int = 0.0, bias: bool = True, activation_function: str = 'gelu', pre_norm: bool = True, positional_encoding_type: str = 'sincos', use_cls_token: bool = False, init_std: float = 0.02, share_projection: bool = True, scaling: str | bool | None = 'std', do_mask_input: bool | None = None, mask_type: str = 'random', random_mask_ratio: float = 0.5, num_forecast_mask_patches: list[int] | tuple[int, ...] | int | None = (2,), channel_consistent_masking: bool | None = False, unmasked_channel_indices: list[int] | None = None, mask_value: int = 0, pooling_type: str | None = 'mean', head_dropout: float | int = 0.0, prediction_length: int = 24, num_targets: int = 1, output_range: list | None = None, num_parallel_samples: int = 100)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/patchtst/configuration_patchtst.py#L24)

**Parâmetros:**

num_input_channels (`int`, *opcional*, padrão `1`) : O número de canais de entrada.

context_length (`int`, *opcional*, padrão 32) : O comprimento do contexto da sequência de entrada.

distribution_output (`str`, *opcional*, padrão `"student_t"`) : A cabeça de emissão de distribuição do modelo quando a perda é "nll". Pode ser "student_t", "normal" ou "negative_binomial".

loss (`str`, *opcional*, padrão `"mse"`) : A função de perda do modelo correspondente à cabeça `distribution_output`. Para distribuições paramétricas, é a log-verossimilhança negativa ("nll") e para estimativas pontuais, é o erro quadrático médio "mse".

patch_length (`int`, *opcional*, padrão 1) : Define o comprimento do patch do processo de patchificação.

patch_stride (`int`, *opcional*, padrão 1) : Define o stride do processo de patchification.

num_hidden_layers (`int`, *opcional*, padrão `3`) : Número de camadas ocultas no decodificador do Transformer.

d_model (`int`, *opcional*, padrão `128`) : Tamanho das camadas do codificador e da camada pooler.

num_attention_heads (`int`, *opcional*, padrão 4) : Número de cabeças de atenção para cada camada de atenção no codificador do Transformer.

share_embedding (`bool`, *opcional*, padrão `True`) : Compartilha o embedding de entrada entre todos os canais.

channel_attention (`bool`, *opcional*, padrão `False`) : Ativa o bloco de atenção de canal no Transformer para permitir que os canais prestem atenção uns aos outros.

ffn_dim (`int`, *opcional*, padrão 512) : Dimensão da camada "intermediária" (frequentemente chamada de feed-forward) no codificador do Transformer.

norm_type (`str` , *opcional*, padrão `"batchnorm"`) : Normalização em cada camada do Transformer. Pode ser `"batchnorm"` ou `"layernorm"`.

norm_eps (`float`, *opcional*, padrão 1e-05) : Um valor adicionado ao denominador para estabilidade numérica da normalização.

attention_dropout (`Union[float, int]`, *opcional*, padrão `0.0`) : A taxa de dropout para as probabilidades de atenção.

positional_dropout (`float`, *opcional*, padrão 0.0) : A probabilidade de dropout na camada de incorporação posicional.

path_dropout (`float`, *opcional*, padrão 0.0) : O caminho de dropout no bloco residual.

ff_dropout (`float`, *opcional*, padrão 0.0) : A probabilidade de dropout usada entre as duas camadas das redes feed-forward.

bias (`bool`, *opcional*, padrão `True`) : Se deve adicionar viés nas redes feed-forward.

activation_function (`str`, *opcional*, padrão `"gelu"`) : A função de ativação não linear (string) no Transformer.`"gelu"` e `"relu"` são suportadas.

pre_norm (`bool`, *opcional*, padrão `True`) : A normalização é aplicada antes da autoatenção se pre_norm estiver definido como `True`. Caso contrário, a normalização é aplicada após o bloco residual.

positional_encoding_type (`str`, *opcional*, padrão `"sincos"`) : Codificações posicionais. As opções `"random"` e `"sincos"` são suportadas.

use_cls_token (`bool`, *opcional*, padrão `False`) : Se o token cls é utilizado.

init_std (`float`, *opcional*, padrão 0.02) : O desvio padrão da distribuição de inicialização de pesos normal truncada.

share_projection (`bool`, *opcional*, padrão `True`) : Compartilha a camada de projeção entre diferentes canais na cabeça de previsão.

scaling (`Union`, *opcional*, padrão `"std"`) : Se os alvos de entrada devem ser escalados pelo escaler "mean", pelo escaler "std" ou sem escaler, se `None`. Se `True`, o escaler é definido como "mean".

do_mask_input (`bool`, *opcional*) : Aplicar mascaramento durante o pré-treinamento.

mask_type (`str`, *opcional*, padrão `"random"`) : Tipo de mascaramento. Atualmente, apenas `"random"` e `"forecast"` são suportados.

random_mask_ratio (`float`, *opcional*, padrão 0.5) : Razão de mascaramento aplicada para mascarar os dados de entrada durante o pré-treinamento aleatório.

num_forecast_mask_patches (`int` ou `list`, *opcional*, padrão `[2]`) : Número de patches a serem mascarados no final de cada amostra do lote. Se for um inteiro, todas as amostras no lote terão o mesmo número de patches mascarados. Se for uma lista, as amostras no lote serão mascaradas aleatoriamente pelos números definidos na lista. Este argumento é usado apenas para pré-treino de previsão.

channel_consistent_masking (`bool`, *opcional*, padrão `False`) : Se o mascaramento consistente por canal for True, todos os canais terão o mesmo padrão de mascaramento.

unmasked_channel_indices (`list`, *opcional*) : Índices dos canais que não são mascarados durante o pré-treinamento. Os valores na lista são números entre 1 e `num_input_channels`

mask_value (`int`, *opcional*, padrão 0) : Os valores nos patches mascarados serão preenchidos por `mask_value`.

pooling_type (`str`, *opcional*, padrão `"mean"`) : Pooling do embedding. `"mean"`, `"max"` e `None` são suportados.

head_dropout (`float`, *opcional*, padrão 0.0) : A probabilidade de dropout para a head.

prediction_length (`int`, *opcional*, padrão 24) : O horizonte de previsão que o modelo irá produzir.

num_targets (`int`, *opcional*, padrão 1) : Número de alvos para tarefas de regressão e classificação. Para classificação, é o número de classes.

output_range (`list`, *opcional*) : Intervalo de saída para a tarefa de regressão. O intervalo dos valores de saída pode ser definido para forçar o modelo a produzir valores dentro de um intervalo.

num_parallel_samples (`int`, *opcional*, padrão 100) : O número de amostras geradas em paralelo para a predição probabilística.

Esta é a classe de configuração para armazenar a configuração de um PatchTSTModel. Ela é usada para instanciar um modelo Patchtst de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do [ibm-granite/granite-timeseries-patchtst](https://huggingface.co/ibm-granite/granite-timeseries-patchtst)

Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações.

```python
>>> from transformers import PatchTSTConfig, PatchTSTModel

>>> # Initializing an PatchTST configuration with 12 time steps for prediction
>>> configuration = PatchTSTConfig(prediction_length=12)

>>> # Randomly initializing a model (with random weights) from the configuration
>>> model = PatchTSTModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config
```

## PatchTSTModel[[transformers.PatchTSTModel]]

#### transformers.PatchTSTModel[[transformers.PatchTSTModel]]

```python
transformers.PatchTSTModel(config: PatchTSTConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/patchtst/modeling_patchtst.py#L1066)

**Parâmetros:**

config ([PatchTSTConfig](/docs/transformers/main/pt/model_doc/patchtst#transformers.PatchTSTConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo.

O modelo Patchtst puro, que produz estados ocultos brutos sem nenhum cabeçalho específico no topo.

Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.).

Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais.

#### forward[[transformers.PatchTSTModel.forward]]

```python
forward(past_values: Tensor, past_observed_mask: typing.Optional[torch.Tensor] = None, future_values: typing.Optional[torch.Tensor] = None, output_hidden_states: bool | None = None, output_attentions: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/patchtst/modeling_patchtst.py#L1085)

**Parâmetros:**

past_values (`torch.Tensor` de forma `(bs, sequence_length, num_input_channels)`, *obrigatório*) : Sequência de entrada para o modelo

past_observed_mask (`torch.BoolTensor` de forma `(batch_size, sequence_length, num_input_channels)`, *opcional*) : Máscara booleana para indicar quais `past_values` foram observados e quais estão ausentes. Valores da máscara selecionados em `[0, 1]`: - 1 para valores que são **observados**, - 0 para valores que estão **ausentes** (ou seja, NaNs que foram substituídos por zeros).

future_values (`torch.BoolTensor` de forma `(batch_size, prediction_length, num_input_channels)`, *opcional*) : Valores futuros de destino associados aos `past_values`

output_hidden_states (`bool`, *opcional*) : Se deve ou não retornar os estados ocultos de todas as camadas

output_attentions (`bool`, *opcional*) : Se deve ou não retornar a saída de atenção de todas as camadas

return_dict (`bool`, *opcional*) : Se deve ou não retornar um `ModelOutput` em vez de uma tupla simples.

**Retorna:**

`PatchTSTModelOutput` ou tupla de `torch.Tensor` (se `return_dict`=False ou `config.return_dict`=False)

Exemplos:

```python
>>> from huggingface_hub import hf_hub_download
>>> import torch
>>> from transformers import PatchTSTModel

>>> file = hf_hub_download(
...     repo_id="hf-internal-testing/etth1-hourly-batch", filename="train-batch.pt", repo_type="dataset"
... )
>>> batch = torch.load(file)

>>> model = PatchTSTModel.from_pretrained("namctin/patchtst_etth1_pretrain")

>>> # during training, one provides both past and future values
>>> outputs = model(
...     past_values=batch["past_values"],
...     future_values=batch["future_values"],
... )

>>> last_hidden_state = outputs.last_hidden_state
```

## PatchTSTForPrediction[[transformers.PatchTSTForPrediction]]

#### transformers.PatchTSTForPrediction[[transformers.PatchTSTForPrediction]]

```python
transformers.PatchTSTForPrediction(config: PatchTSTConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/patchtst/modeling_patchtst.py#L1560)

**Parâmetros:**

config ([PatchTSTConfig](/docs/transformers/main/pt/model_doc/patchtst#transformers.PatchTSTConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo.

O modelo de previsão PatchTST.

Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.).

Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais.

#### forward[[transformers.PatchTSTForPrediction.forward]]

```python
forward(past_values: Tensor, past_observed_mask: typing.Optional[torch.Tensor] = None, future_values: typing.Optional[torch.Tensor] = None, output_hidden_states: bool | None = None, output_attentions: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/patchtst/modeling_patchtst.py#L1590)

**Parâmetros:**

past_values (`torch.Tensor` de forma `(bs, sequence_length, num_input_channels)`, *obrigatório*) : Sequência de entrada para o modelo

past_observed_mask (`torch.BoolTensor` de forma `(batch_size, sequence_length, num_input_channels)`, *opcional*) : Máscara booleana para indicar quais `past_values` foram observados e quais estão ausentes. Valores da máscara selecionados em `[0, 1]`: - 1 para valores que são **observados**, - 0 para valores que estão **ausentes** (ou seja, NaNs que foram substituídos por zeros).

future_values (`torch.Tensor` de forma `(bs, forecast_len, num_input_channels)`, *opcional*) : Valores de destino futuros associados aos `past_values`

output_hidden_states (`bool`, *opcional*) : Se deve ou não retornar os estados ocultos de todas as camadas

output_attentions (`bool`, *opcional*) : Se deve ou não retornar a saída de atenção de todas as camadas

return_dict (`bool`, *opcional*) : Se deve ou não retornar um `ModelOutput` em vez de uma tupla simples.

**Retorna:**

`PatchTSTForPredictionOutput` ou tupla de `torch.Tensor` (se `return_dict`=False ou `config.return_dict`=False)

Exemplos:

```python
>>> from huggingface_hub import hf_hub_download
>>> import torch
>>> from transformers import PatchTSTConfig, PatchTSTForPrediction

>>> file = hf_hub_download(
...     repo_id="hf-internal-testing/etth1-hourly-batch", filename="train-batch.pt", repo_type="dataset"
... )
>>> batch = torch.load(file)

>>> # Prediction task with 7 input channels and prediction length is 96
>>> model = PatchTSTForPrediction.from_pretrained("namctin/patchtst_etth1_forecast")

>>> # during training, one provides both past and future values
>>> outputs = model(
...     past_values=batch["past_values"],
...     future_values=batch["future_values"],
... )

>>> loss = outputs.loss
>>> loss.backward()

>>> # during inference, one only provides past values, the model outputs future values
>>> outputs = model(past_values=batch["past_values"])
>>> prediction_outputs = outputs.prediction_outputs
```

## PatchTSTForClassification[[transformers.PatchTSTForClassification]]

#### transformers.PatchTSTForClassification[[transformers.PatchTSTForClassification]]

```python
transformers.PatchTSTForClassification(config: PatchTSTConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/patchtst/modeling_patchtst.py#L1366)

**Parâmetros:**

config ([PatchTSTConfig](/docs/transformers/main/pt/model_doc/patchtst#transformers.PatchTSTConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo.

O modelo PatchTST para classificação.

Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.).

Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais.

#### forward[[transformers.PatchTSTForClassification.forward]]

```python
forward(past_values: Tensor, target_values: typing.Optional[torch.Tensor] = None, past_observed_mask: bool | None = None, output_hidden_states: bool | None = None, output_attentions: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/patchtst/modeling_patchtst.py#L1381)

**Parâmetros:**

past_values (`torch.Tensor` de forma `(bs, sequence_length, num_input_channels)`, *obrigatório*) : Sequência de entrada para o modelo

target_values (`torch.Tensor`, *opcional*) : Rótulos associados aos `past_values`

past_observed_mask (`torch.BoolTensor` de forma `(batch_size, sequence_length, num_input_channels)`, *opcional*) : Máscara booleana para indicar quais `past_values` foram observados e quais estão ausentes. Valores da máscara selecionados em `[0, 1]`: - 1 para valores que são **observados**, - 0 para valores que estão **ausentes** (ou seja, NaNs que foram substituídos por zeros).

output_hidden_states (`bool`, *opcional*) : Indica se os estados ocultos de todas as camadas devem ser retornados. Consulte `hidden_states` em tensores retornados para mais detalhes.

output_attentions (`bool`, *opcional*) : Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulte `attentions` nos tensores retornados para mais detalhes.

return_dict (`bool`, *opcional*) : Se deve ou não retornar um [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput) em vez de uma tupla simples.

**Retorna:** `PatchTSTForClassificationOutput` ou `tuple(torch.Tensor)`

Um `PatchTSTForClassificationOutput` ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos, dependendo da configuração ([PatchTSTConfig](/docs/transformers/main/pt/model_doc/patchtst#transformers.PatchTSTConfig)) e das entradas.

O método forward de [PatchTSTForClassification](/docs/transformers/main/pt/model_doc/patchtst#transformers.PatchTSTForClassification) substitui o método especial `__call__`.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

- **loss** (`*optional*`, returned when `labels` is provided, `torch.Tensor` of shape `(1,)`) -- Perda total como a soma da perda de modelagem de linguagem mascarada e da perda de previsão da próxima sequência (classificação).
- **prediction_logits** (`torch.Tensor` de forma `(batch_size, num_targets)`) -- Pontuações de previsão da cabeça de modelagem do PatchTST (pontuações antes do SoftMax).
- **hidden_states** (`tuple[torch.Tensor]`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.
- **attentions** (`tuple[torch.Tensor]`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.

Exemplos:

```python
>>> from transformers import PatchTSTConfig, PatchTSTForClassification

>>> # classification task with two input channel2 and 3 classes
>>> config = PatchTSTConfig(
...     num_input_channels=2,
...     num_targets=3,
...     context_length=512,
...     patch_length=12,
...     stride=12,
...     use_cls_token=True,
... )
>>> model = PatchTSTForClassification(config=config)

>>> # during inference, one only provides past values
>>> past_values = torch.randn(20, 512, 2)
>>> outputs = model(past_values=past_values)
>>> labels = outputs.prediction_logits
```

## PatchTSTForPretraining[[transformers.PatchTSTForPretraining]]

#### transformers.PatchTSTForPretraining[[transformers.PatchTSTForPretraining]]

```python
transformers.PatchTSTForPretraining(config: PatchTSTConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/patchtst/modeling_patchtst.py#L1212)

**Parâmetros:**

config ([PatchTSTConfig](/docs/transformers/main/pt/model_doc/patchtst#transformers.PatchTSTConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo.

O PatchTST para o modelo de pré-treinamento.

Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.).

Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais.

#### forward[[transformers.PatchTSTForPretraining.forward]]

```python
forward(past_values: Tensor, past_observed_mask: typing.Optional[torch.Tensor] = None, output_hidden_states: bool | None = None, output_attentions: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/patchtst/modeling_patchtst.py#L1223)

**Parâmetros:**

past_values (`torch.Tensor` de forma `(bs, sequence_length, num_input_channels)`, *obrigatório*) : Sequência de entrada para o modelo

past_observed_mask (`torch.BoolTensor` de forma `(batch_size, sequence_length, num_input_channels)`, *opcional*) : Máscara booleana para indicar quais `past_values` foram observados e quais estão ausentes. Valores da máscara selecionados em `[0, 1]`: - 1 para valores que são **observados**, - 0 para valores que estão **ausentes** (ou seja, NaNs que foram substituídos por zeros).

output_hidden_states (`bool`, *opcional*) : Se deve ou não retornar os estados ocultos de todas as camadas

output_attentions (`bool`, *opcional*) : Se deve ou não retornar a saída de atenção de todas as camadas

return_dict (`bool`, *opcional*) : Se deve ou não retornar um `ModelOutput` em vez de uma tupla simples.

**Retorna:**

`PatchTSTForPretrainingOutput` ou tupla de `torch.Tensor` (se `return_dict`=False ou `config.return_dict`=False)

Exemplos:

```python
>>> from huggingface_hub import hf_hub_download
>>> import torch
>>> from transformers import PatchTSTConfig, PatchTSTForPretraining

>>> file = hf_hub_download(
...     repo_id="hf-internal-testing/etth1-hourly-batch", filename="train-batch.pt", repo_type="dataset"
... )
>>> batch = torch.load(file)

>>> # Config for random mask pretraining
>>> config = PatchTSTConfig(
...     num_input_channels=7,
...     context_length=512,
...     patch_length=12,
...     stride=12,
...     mask_type='random',
...     random_mask_ratio=0.4,
...     use_cls_token=True,
... )
>>> # Config for forecast mask pretraining
>>> config = PatchTSTConfig(
...     num_input_channels=7,
...     context_length=512,
...     patch_length=12,
...     stride=12,
...     mask_type='forecast',
...     num_forecast_mask_patches=5,
...     use_cls_token=True,
... )
>>> model = PatchTSTForPretraining(config)

>>> # during training, one provides both past and future values
>>> outputs = model(past_values=batch["past_values"])

>>> loss = outputs.loss
>>> loss.backward()
```

## PatchTSTForRegression[[transformers.PatchTSTForRegression]]

#### transformers.PatchTSTForRegression[[transformers.PatchTSTForRegression]]

```python
transformers.PatchTSTForRegression(config: PatchTSTConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/patchtst/modeling_patchtst.py#L1809)

**Parâmetros:**

config ([PatchTSTConfig](/docs/transformers/main/pt/model_doc/patchtst#transformers.PatchTSTConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo.

O modelo PatchTST para regressão.

Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.).

Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais.

#### forward[[transformers.PatchTSTForRegression.forward]]

```python
forward(past_values: Tensor, target_values: typing.Optional[torch.Tensor] = None, past_observed_mask: typing.Optional[torch.Tensor] = None, output_hidden_states: bool | None = None, output_attentions: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/patchtst/modeling_patchtst.py#L1836)

**Parâmetros:**

past_values (`torch.Tensor` de forma `(bs, sequence_length, num_input_channels)`, *obrigatório*) : Sequência de entrada para o modelo

target_values (`torch.Tensor` de forma `(bs, num_input_channels)`) : Valores-alvo associados aos `past_values`

past_observed_mask (`torch.BoolTensor` de forma `(batch_size, sequence_length, num_input_channels)`, *opcional*) : Máscara booleana para indicar quais `past_values` foram observados e quais estavam ausentes. Valores da máscara selecionados em `[0, 1]`: - 1 para valores que são **observados**, - 0 para valores que estão **ausentes** (ou seja, NaNs que foram substituídos por zeros). Se deve ou não retornar um `ModelOutput` em vez de uma tupla simples.

output_hidden_states (`bool`, *opcional*) : Indica se os estados ocultos de todas as camadas devem ser retornados. Consulte `hidden_states` em tensores retornados para mais detalhes.

output_attentions (`bool`, *opcional*) : Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulte `attentions` nos tensores retornados para mais detalhes.

return_dict (`bool`, *opcional*) : Se deve ou não retornar um [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput) em vez de uma tupla simples.

**Retorna:** `PatchTSTForRegressionOutput` ou `tuple(torch.Tensor)`

Um `PatchTSTForRegressionOutput` ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos, dependendo da configuração ([PatchTSTConfig](/docs/transformers/main/pt/model_doc/patchtst#transformers.PatchTSTConfig)) e das entradas.

O método forward de [PatchTSTForRegression](/docs/transformers/main/pt/model_doc/patchtst#transformers.PatchTSTForRegression) substitui o método especial `__call__`.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

- **loss** (`*optional*`, returned when `labels` is provided, `torch.Tensor` of shape `(1,)`) -- MSE loss.
- **regression_outputs** (`torch.Tensor` de forma `(batch_size, num_targets)`) -- Saídas de regressão das cabeças de modelagem de séries temporais.
- **hidden_states** (`tuple[torch.Tensor]`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.
- **attentions** (`tuple[torch.Tensor]`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.

Exemplos:

```python
>>> from transformers import PatchTSTConfig, PatchTSTForRegression

>>> # Regression task with 6 input channels and regress 2 targets
>>> model = PatchTSTForRegression.from_pretrained("namctin/patchtst_etth1_regression")

>>> # during inference, one only provides past values, the model outputs future values
>>> past_values = torch.randn(20, 512, 6)
>>> outputs = model(past_values=past_values)
>>> regression_outputs = outputs.regression_outputs
```