# PatchTSMixer ## Visão geral O modelo PatchTSMixer foi proposto em [TSMixer: Lightweight MLP-Mixer Model for Multivariate Time Series Forecasting](https://huggingface.co/papers/2306.09364) por Vijay Ekambaram, Arindam Jati, Nam Nguyen, Phanwadee Sinthong e Jayant Kalagnanam. PatchTSMixer é uma abordagem leve de modelagem de séries temporais baseada na arquitetura MLP-Mixer. Nesta implementação do HuggingFace, oferecemos as capacidades do PatchTSMixer para facilitar de forma simples a mistura leve entre patches, canais e recursos ocultos, visando uma modelagem eficaz de séries temporais multivariadas. Ele também suporta diversos mecanismos de atenção, desde uma atenção simples com gate até blocos de autoatenção mais complexos, que podem ser personalizados conforme necessário. O modelo pode ser pré-treinado e, em seguida, utilizado para diversas tarefas de nível inferior, como previsão, classificação e regressão. O resumo do artigo é o seguinte: *O TSMixer é uma arquitetura neural leve composta exclusivamente por módulos de perceptron multicamadas (MLP), projetada para previsão multivariada e aprendizado de representação em séries temporais segmentadas. Nosso modelo se inspira no sucesso dos modelos MLP-Mixer na visão computacional. Demonstramos os desafios envolvidos na adaptação do Vision MLP-Mixer para séries temporais e introduzimos componentes validados empiricamente para melhorar a precisão. Isso inclui um novo paradigma de design que acopla cabeças de reconciliação online ao backbone do MLP-Mixer, para modelar explicitamente propriedades de séries temporais, como hierarquia e correlações entre canais. Também propomos uma abordagem híbrida de modelagem de canais para lidar eficazmente com interações ruidosas entre canais e generalização em conjuntos de dados diversos, um desafio comum em métodos existentes de mistura de canais por segmento. Além disso, um mecanismo simples de atenção com gate é introduzido no backbone para priorizar recursos importantes. Ao incorporar esses componentes leves, aprimoramos significativamente a capacidade de aprendizado de estruturas MLP simples, superando modelos Transformer complexos com uso mínimo de computação. Além disso, o design modular do TSMixer permite compatibilidade com métodos de aprendizado supervisionado e auto-supervisionado mascarado, tornando-o um bloco de construção promissor para Modelos Fundamentais de séries temporais. O TSMixer supera modelos MLP e Transformer de última geração em previsão por uma margem considerável de 8-60%. Ele também supera os benchmarks mais recentes e fortes de modelos Patch-Transformer (por 1-2%) com uma redução significativa em memória e tempo de execução (2-3X).* Este modelo foi contribuído por [ajati](https://huggingface.co/ajati), [vijaye12](https://huggingface.co/vijaye12), [gsinthong](https://huggingface.co/gsinthong), [namctin](https://huggingface.co/namctin), [wmgifford](https://huggingface.co/wmgifford), [kashif](https://huggingface.co/kashif). ## Exemplo de uso O trecho de código abaixo mostra como inicializar aleatoriamente um modelo PatchTSMixer. O modelo é compatível com a [Trainer API](../trainer). ```python from transformers import PatchTSMixerConfig, PatchTSMixerForPrediction from transformers import Trainer, TrainingArguments, config = PatchTSMixerConfig(context_length = 512, prediction_length = 96) model = PatchTSMixerForPrediction(config) trainer = Trainer(model=model, args=training_args, train_dataset=train_dataset, eval_dataset=valid_dataset) trainer.train() results = trainer.evaluate(test_dataset) ``` ## 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 [PatchTSMixerForTimeSeriesClassification](/docs/transformers/main/pt/model_doc/patchtsmixer#transformers.PatchTSMixerForTimeSeriesClassification) e [PatchTSMixerForRegression](/docs/transformers/main/pt/model_doc/patchtsmixer#transformers.PatchTSMixerForRegression). ## Recursos - Um post de blog explicando o PatchTSMixer em profundidade pode ser encontrado [aqui](https://huggingface.co/blog/patchtsmixer). O blog também pode ser aberto no Google Colab. ## PatchTSMixerConfig[[transformers.PatchTSMixerConfig]] #### transformers.PatchTSMixerConfig[[transformers.PatchTSMixerConfig]] ```python transformers.PatchTSMixerConfig(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, context_length: int = 32, patch_length: int = 8, num_input_channels: int = 1, patch_stride: int = 8, num_parallel_samples: int = 100, d_model: int = 8, expansion_factor: int = 2, num_layers: int = 3, dropout: float | int = 0.2, mode: str = 'common_channel', gated_attn: bool = True, norm_mlp: str = 'LayerNorm', self_attn: bool = False, self_attn_heads: int = 1, use_positional_encoding: bool = False, positional_encoding_type: str = 'sincos', scaling: str | bool | None = 'std', loss: str = 'mse', init_std: float = 0.02, norm_eps: float = 1e-05, mask_type: str = 'random', random_mask_ratio: float = 0.5, num_forecast_mask_patches: list[int] | tuple[int, ...] | int | None = (2,), mask_value: int = 0, masked_loss: bool = True, channel_consistent_masking: bool = True, unmasked_channel_indices: list[int] | None = None, head_dropout: float | int = 0.2, distribution_output: str = 'student_t', prediction_length: int = 16, prediction_channel_indices: list | None = None, num_targets: int = 3, output_range: list | None = None, head_aggregation: str | None = 'max_pool') ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/patchtsmixer/configuration_patchtsmixer.py#L24) **Parâmetros:** context_length (`int`, *opcional*, padrão 32) : O comprimento do contexto/histórico para a sequência de entrada. patch_length (`int`, *opcional*, padrão 8) : O comprimento do patch para a sequência de entrada. num_input_channels (`int`, *opcional*, padrão `1`) : O número de canais de entrada. patch_stride (`int`, *opcional*, padrão 8) : Determina a sobreposição entre dois patches consecutivos. Defina-o como patch_length (ou maior), se quisermos patches sem sobreposição. num_parallel_samples (`int`, *opcional*, padrão 100) : O número de amostras a serem geradas em paralelo para a previsão probabilística. d_model (`int`, *opcional*, padrão `8`) : Tamanho das camadas do codificador e da camada pooler. expansion_factor (`int`, *opcional*, padrão 2) : Fator de expansão a ser usado dentro do MLP. Faixa recomendada é 2-5. Um valor maior indica um modelo mais complexo. num_layers (`int`, *opcional*, padrão `3`) : Número de camadas ocultas no decodificador do Transformer. dropout (`Union[float, int]`, *opcional*, padrão `0.2`) : A proporção para todas as camadas de dropout. mode (`str`, *opcional*, padrão `"common_channel"`) : Modo do Mixer. Determina como processar os canais. Valores permitidos: "common_channel", "mix_channel". No modo "common_channel", seguimos a modelagem independente de canais, sem mistura explícita de canais. A mistura de canais ocorre de forma implícita por meio de pesos compartilhados entre os canais. (abordagem preferida inicialmente) No modo "mix_channel", seguimos a mistura explícita de canais, além do mixer de patches e de recursos. (abordagem preferida quando as correlações entre canais são muito importantes para o modelo) gated_attn (`bool`, *opcional*, padrão `True`) : Ativa a Gated Attention. norm_mlp (`str`, *opcional*, padrão `"LayerNorm"`) : Camada de normalização (BatchNorm ou LayerNorm). self_attn (`bool`, *opcional*, padrão `False`) : Ativa a autoatenção Tiny entre patches. Isso pode ser ativado quando a saída do Vanilla PatchTSMixer com atenção com gate não for satisfatória. A ativação disso leva a uma atenção explícita par a par e modelagem entre patches. self_attn_heads (`int`, *opcional*, padrão 1) : Número de cabeças de autoatenção. Funciona apenas quando `self_attn` está definido como `True`. use_positional_encoding (`bool`, *opcional*, padrão `False`) : Ativa o uso de incorporação posicional para as camadas de autoatenção minúsculas. Funciona apenas quando `self_attn` está definido como `True`. positional_encoding_type (`str`, *opcional*, padrão `"sincos"`) : Codificações posicionais. As opções `"random"` e `"sincos"` são suportadas. Funciona apenas quando `use_positional_encoding` está definido como `True` scaling (`string` ou `bool`, *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". loss (`string`, *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". init_std (`float`, *opcional*, padrão `0.02`) : O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos. norm_eps (`float`, *opcional*, padrão 1e-05) : Um valor adicionado ao denominador para estabilidade numérica da normalização. mask_type (`str`, *opcional*, padrão `"random"`) : Tipo de mascaramento a ser usado no modo de Pré-treinamento com Máscara. Os valores permitidos são "random" e "forecast". No mascaramento aleatório, os pontos são mascarados aleatoriamente. No mascaramento de previsão, os pontos são mascarados em direção ao final. random_mask_ratio (`float`, *opcional*, padrão 0.5) : Proporção de mascaramento a ser usada quando `mask_type` é `random`. Um valor maior indica mais mascaramento. 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. mask_value (`float`, *opcional*, padrão `0.0`) : Valor da máscara a ser usado. masked_loss (`bool`, *opcional*, padrão `True`) : Se deve calcular a perda de pré-treino apenas nas porções mascaradas ou em toda a saída. channel_consistent_masking (`bool`, *opcional*, padrão `True`) : Quando verdadeiro, a máscara será a mesma em todos os canais de uma série temporal. Caso contrário, as posições de máscara variarão entre os canais. unmasked_channel_indices (`list`, *opcional*) : Canais que não são mascarados durante o pré-treinamento. head_dropout (`float`, *opcional*, padrão 0.2) : A probabilidade de dropout do cabeçalho `PatchTSMixer`. distribution_output (`string`, *opcional*, padrão `"student_t"`) : A cabeça de emissão da distribuição para o modelo quando a perda é "nll". Pode ser "student_t", "normal" ou "negative_binomial". prediction_length (`int`, *opcional*, padrão 16) : Número de passos de tempo para prever em uma tarefa de previsão. Também conhecido como Horizonte de Previsão. prediction_channel_indices (`list`, *opcional*) : Lista de índices de canais a serem previstos. Se for None, todos os canais serão previstos. Os dados de destino devem conter todos os canais e filtramos explicitamente os canais na previsão e no destino antes do cálculo da perda. num_targets (`int`, *opcional*, padrão 3) : Número de alvos (dimensionalidade da variável regressada) para uma tarefa de regressão. output_range (`list`, *opcional*) : Faixa de saída para restringir a tarefa de regressão. O padrão é None. head_aggregation (`str`, *opcional*, padrão `"max_pool"`) : Modo de agregação a ser habilitado para tarefas de classificação ou regressão. Os valores permitidos são `None`, "use_last", "max_pool", "avg_pool". Esta é a classe de configuração para armazenar a configuração de um PatchTSMixerModel. Ela é usada para instanciar um modelo Patchtsmixer 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/patchtsmixer-etth1-pretrain](https://huggingface.co/ibm/patchtsmixer-etth1-pretrain) 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. Exemplo: ```python >>> from transformers import PatchTSMixerConfig, PatchTSMixerModel >>> # Initializing a default PatchTSMixer configuration >>> configuration = PatchTSMixerConfig() >>> # Randomly initializing a model (with random weights) from the configuration >>> model = PatchTSMixerModel(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## PatchTSMixerModel[[transformers.PatchTSMixerModel]] #### transformers.PatchTSMixerModel[[transformers.PatchTSMixerModel]] ```python transformers.PatchTSMixerModel(config: PatchTSMixerConfig, mask_input: bool = False) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/patchtsmixer/modeling_patchtsmixer.py#L1200) **Parâmetros:** config ([PatchTSMixerConfig](/docs/transformers/main/pt/model_doc/patchtsmixer#transformers.PatchTSMixerConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. Inicializar 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. mask_input (`bool`, *opcional*, padrão `False`) : Se deve mascarar a entrada usando o módulo `PatchTSMixerMasking`. O modelo PatchTSMixer para previsão de séries temporais. 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.PatchTSMixerModel.forward]] ```python forward(past_values: Tensor, observed_mask: typing.Optional[torch.Tensor] = None, output_hidden_states: bool | None = None, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/patchtsmixer/modeling_patchtsmixer.py#L1226) **Parâmetros:** past_values (`torch.Tensor` de forma `(batch_size, seq_length, num_input_channels)`) : Valores de contexto da série temporal. Para uma tarefa de pré-treinamento, isso denota a série temporal de entrada para prever a porção mascarada. Para uma tarefa de previsão, isso denota os valores históricos/passados da série temporal. Da mesma forma, para tarefas de classificação ou regressão, denota os valores de contexto apropriados da série temporal. Para séries temporais univariadas, a dimensão `num_input_channels` deve ser 1. Para séries temporais multivariadas, é maior que 1. observed_mask (`torch.Tensor` 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. **Retorna:** `PatchTSMixerModelOutput` ou `tuple(torch.Tensor)` Um `PatchTSMixerModelOutput` 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 ([PatchTSMixerConfig](/docs/transformers/main/pt/model_doc/patchtsmixer#transformers.PatchTSMixerConfig)) e das entradas. O método forward do [PatchTSMixerModel](/docs/transformers/main/pt/model_doc/patchtsmixer#transformers.PatchTSMixerModel) 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. - **last_hidden_state** (`torch.Tensor` de forma `(batch_size, num_channels, num_patches, d_model)`) -- Estado oculto na saída da última camada do modelo. - **hidden_states** (`tuple(torch.Tensor)`, *opcional*) -- Estados ocultos do modelo na saída de cada camada. - **patch_input** (`torch.Tensor` de forma `(batch_size, num_channels, num_patches, patch_length)`) -- Dados de entrada do modelo em formato de patches. - **mask** (`torch.Tensor` de forma `(batch_size, num_channels, num_patches)`, *opcional*) -- Tensor Bool indicando True nos patches mascarados e False nos demais. - **loc** (`torch.Tensor` de forma `(batch_size, 1, num_channels)`, *opcional*) -- Fornece a média da janela de contexto por canal. Usado para a desnornalização do revin fora do modelo, se o revin estiver habilitado. - **scale** (`torch.Tensor` de forma `(batch_size, 1, num_channels)`, *opcional*) -- Fornece o desvio padrão da janela de contexto por canal. Usado para a desnornalização do revin fora do modelo, se o revin estiver habilitado. ## PatchTSMixerForPrediction[[transformers.PatchTSMixerForPrediction]] #### transformers.PatchTSMixerForPrediction[[transformers.PatchTSMixerForPrediction]] ```python transformers.PatchTSMixerForPrediction(config: PatchTSMixerConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/patchtsmixer/modeling_patchtsmixer.py#L1481) **Parâmetros:** config (`PatchTSMixerConfig`) : Configuração. **Retorna:** `None`. `PatchTSMixer` para aplicações de previsão. #### forward[[transformers.PatchTSMixerForPrediction.forward]] ```python forward(past_values: Tensor, observed_mask: typing.Optional[torch.Tensor] = None, future_values: typing.Optional[torch.Tensor] = None, output_hidden_states: bool | None = None, return_loss: bool = True, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/patchtsmixer/modeling_patchtsmixer.py#L1523) **Parâmetros:** past_values (`torch.Tensor` de forma `(batch_size, seq_length, num_input_channels)`) : Valores de contexto da série temporal. Para uma tarefa de pré-treinamento, isso denota a série temporal de entrada para prever a porção mascarada. Para uma tarefa de previsão, isso denota os valores históricos/passados da série temporal. Da mesma forma, para tarefas de classificação ou regressão, denota os valores de contexto apropriados da série temporal. Para séries temporais univariadas, a dimensão `num_input_channels` deve ser 1. Para séries temporais multivariadas, é maior que 1. observed_mask (`torch.Tensor` 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 `(batch_size, target_len, num_input_channels)` para previsão, : `(batch_size, num_targets)` para regressão, ou `(batch_size,)` para classificação, *opcional*): Valores-alvo da série temporal, que servem como rótulos para o modelo. O `future_values` é o que o Transformer precisa durante o treinamento para aprender a produzir, dado o `past_values`. Observe que isso NÃO é necessário para uma tarefa de pré-treinamento. Para uma tarefa de previsão, a forma deve ser `(batch_size, target_len, num_input_channels)`. Mesmo que queiramos prever apenas canais específicos definindo os índices no parâmetro `prediction_channel_indices`, passe os dados-alvo com todos os canais, pois a filtragem de canais para ambas a previsão e o alvo será aplicada manualmente antes do cálculo da perda. 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. return_loss (`bool`, *opcional*) : Se deve retornar a perda na chamada `forward`. **Retorna:** `PatchTSMixerForPredictionOutput` ou `tuple(torch.Tensor)` Um `PatchTSMixerForPredictionOutput` 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 ([PatchTSMixerConfig](/docs/transformers/main/pt/model_doc/patchtsmixer#transformers.PatchTSMixerConfig)) e das entradas. O método forward da [PatchTSMixerForPrediction](/docs/transformers/main/pt/model_doc/patchtsmixer#transformers.PatchTSMixerForPrediction) 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 `y` is provided, `torch.Tensor` of shape `()`) -- Total loss. - **prediction_outputs** (`torch.Tensor` de forma `(batch_size, prediction_length, num_input_channels)`) -- Saída de previsão da cabeça de previsão. - **last_hidden_state** (`torch.Tensor` de forma `(batch_size, num_input_channels, num_patches, d_model)`) -- Embeddings do backbone antes de passar pelo head. - **hidden_states** (`tuple(torch.Tensor)`, *opcional*) -- Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial. - **loc** (`torch.Tensor`, *opcional* de forma `(batch_size, 1, num_input_channels)`) -- Média de entrada - **scale** (`torch.Tensor`, *opcional* de forma `(batch_size, 1, num_input_channels)`) -- Desvio padrão da entrada ## PatchTSMixerForTimeSeriesClassification[[transformers.PatchTSMixerForTimeSeriesClassification]] #### transformers.PatchTSMixerForTimeSeriesClassification[[transformers.PatchTSMixerForTimeSeriesClassification]] ```python transformers.PatchTSMixerForTimeSeriesClassification(config: PatchTSMixerConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/patchtsmixer/modeling_patchtsmixer.py#L1707) **Parâmetros:** config (`PatchTSMixerConfig`) : Configuração. **Retorna:** `None`. `PatchTSMixer` para aplicação de classificação. #### forward[[transformers.PatchTSMixerForTimeSeriesClassification.forward]] ```python forward(past_values: Tensor, target_values: typing.Optional[torch.Tensor] = None, output_hidden_states: bool | None = None, return_loss: bool = True, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/patchtsmixer/modeling_patchtsmixer.py#L1734) **Parâmetros:** past_values (`torch.Tensor` de forma `(batch_size, seq_length, num_input_channels)`) : Valores de contexto da série temporal. Para uma tarefa de pré-treinamento, isso denota a série temporal de entrada para prever a porção mascarada. Para uma tarefa de previsão, isso denota os valores históricos/passados da série temporal. Da mesma forma, para tarefas de classificação ou regressão, denota os valores de contexto apropriados da série temporal. Para séries temporais univariadas, a dimensão `num_input_channels` deve ser 1. Para séries temporais multivariadas, é maior que 1. target_values (`torch.Tensor` de forma `(batch_size, target_len, num_input_channels)` para previsão, : `(batch_size, num_targets)` para regressão, ou `(batch_size,)` para classificação, *opcional*): Valores-alvo da série temporal, que servem como rótulos para o modelo. O `target_values` é o que o Transformer precisa durante o treinamento para aprender a produzir, dado o `past_values`. Observe que isso NÃO é necessário para uma tarefa de pré-treinamento. Para uma tarefa de previsão, a forma deve ser `(batch_size, target_len, num_input_channels)`. Mesmo que queiramos prever apenas canais específicos definindo os índices no parâmetro `prediction_channel_indices`, passe os dados-alvo com todos os canais, pois a filtragem de canais para ambas a previsão e o alvo será aplicada manualmente antes do cálculo da perda. Para uma tarefa de classificação, a forma é `(batch_size,)`. Para uma tarefa de regressão, a forma é `(batch_size, num_targets)`. 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. return_loss (`bool`, *opcional*) : Se deve retornar a perda na chamada `forward`. **Retorna:** `PatchTSMixerForTimeSeriesClassificationOutput` ou `tuple(torch.Tensor)` Um `PatchTSMixerForTimeSeriesClassificationOutput` 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 ([PatchTSMixerConfig](/docs/transformers/main/pt/model_doc/patchtsmixer#transformers.PatchTSMixerConfig)) e das entradas. O método forward da [PatchTSMixerForTimeSeriesClassification](/docs/transformers/main/pt/model_doc/patchtsmixer#transformers.PatchTSMixerForTimeSeriesClassification) 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 `y` is provided, `torch.Tensor` of shape `()`) -- Total loss. - **prediction_outputs** (`torch.Tensor` de forma `(batch_size, num_labels)`) -- Saída de previsão da cabeça de classificação. - **last_hidden_state** (`torch.Tensor` de forma `(batch_size, num_input_channels, num_patches, d_model)`) -- Embeddings do backbone antes de passar pelo head. - **hidden_states** (`tuple(torch.Tensor)`, *opcional*) -- Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial. ## PatchTSMixerForPretraining[[transformers.PatchTSMixerForPretraining]] #### transformers.PatchTSMixerForPretraining[[transformers.PatchTSMixerForPretraining]] ```python transformers.PatchTSMixerForPretraining(config: PatchTSMixerConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/patchtsmixer/modeling_patchtsmixer.py#L1313) **Parâmetros:** config ([PatchTSMixerConfig](/docs/transformers/main/pt/model_doc/patchtsmixer#transformers.PatchTSMixerConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. Inicializar 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. `PatchTSMixer` para pré-treino com máscara. 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.PatchTSMixerForPretraining.forward]] ```python forward(past_values: Tensor, observed_mask: typing.Optional[torch.Tensor] = None, output_hidden_states: bool | None = None, return_loss: bool = True, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/patchtsmixer/modeling_patchtsmixer.py#L1323) **Parâmetros:** past_values (`torch.Tensor` de forma `(batch_size, seq_length, num_input_channels)`) : Valores de contexto da série temporal. Para uma tarefa de pré-treinamento, isso denota a série temporal de entrada para prever a porção mascarada. Para uma tarefa de previsão, isso denota os valores históricos/passados da série temporal. Da mesma forma, para tarefas de classificação ou regressão, denota os valores de contexto apropriados da série temporal. Para séries temporais univariadas, a dimensão `num_input_channels` deve ser 1. Para séries temporais multivariadas, é maior que 1. observed_mask (`torch.Tensor` 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. return_loss (`bool`, *opcional*) : Se deve retornar a perda na chamada `forward`. **Retorna:** `PatchTSMixerForPreTrainingOutput` ou `tuple(torch.Tensor)` Um `PatchTSMixerForPreTrainingOutput` 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 ([PatchTSMixerConfig](/docs/transformers/main/pt/model_doc/patchtsmixer#transformers.PatchTSMixerConfig)) e das entradas. O método forward de [PatchTSMixerForPretraining](/docs/transformers/main/pt/model_doc/patchtsmixer#transformers.PatchTSMixerForPretraining) 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 `y` is provided, `torch.Tensor` of shape `()`) -- Total loss - **prediction_outputs** (`torch.Tensor` de forma `(batch_size, num_input_channels, num_patches, patch_length)`) -- Saída de previsão do cabeçalho de pré-treino. - **last_hidden_state** (`torch.Tensor` de forma `(batch_size, num_input_channels, num_patches, d_model)`) -- Embeddings do backbone antes de passar pelo head. - **hidden_states** (`tuple(torch.Tensor)`, *opcional*) -- Estados ocultos do modelo na saída de cada camada. ## PatchTSMixerForRegression[[transformers.PatchTSMixerForRegression]] #### transformers.PatchTSMixerForRegression[[transformers.PatchTSMixerForRegression]] ```python transformers.PatchTSMixerForRegression(config: PatchTSMixerConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/patchtsmixer/modeling_patchtsmixer.py#L1875) **Parâmetros:** config ([PatchTSMixerConfig](/docs/transformers/main/pt/model_doc/patchtsmixer#transformers.PatchTSMixerConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. Inicializar 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. `PatchTSMixer` para aplicação de 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.PatchTSMixerForRegression.forward]] ```python forward(past_values: Tensor, target_values: typing.Optional[torch.Tensor] = None, output_hidden_states: bool | None = None, return_loss: bool = True, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/patchtsmixer/modeling_patchtsmixer.py#L1913) **Parâmetros:** past_values (`torch.Tensor` de forma `(batch_size, seq_length, num_input_channels)`) : Valores de contexto da série temporal. Para uma tarefa de pré-treinamento, isso denota a série temporal de entrada para prever a porção mascarada. Para uma tarefa de previsão, isso denota os valores históricos/passados da série temporal. Da mesma forma, para tarefas de classificação ou regressão, denota os valores de contexto apropriados da série temporal. Para séries temporais univariadas, a dimensão `num_input_channels` deve ser 1. Para séries temporais multivariadas, é maior que 1. target_values (`torch.Tensor` de forma `(batch_size, target_len, num_input_channels)` para previsão, : `(batch_size, num_targets)` para regressão, ou `(batch_size,)` para classificação, *opcional*): Valores-alvo da série temporal, que servem como rótulos para o modelo. O `target_values` é o que o Transformer precisa durante o treinamento para aprender a produzir, dado o `past_values`. Observe que isso NÃO é necessário para uma tarefa de pré-treinamento. Para uma tarefa de previsão, a forma deve ser `(batch_size, target_len, num_input_channels)`. Mesmo que queiramos prever apenas canais específicos definindo os índices no parâmetro `prediction_channel_indices`, passe os dados-alvo com todos os canais, pois a filtragem de canais para ambas a previsão e o alvo será aplicada manualmente antes do cálculo da perda. Para uma tarefa de classificação, a forma é `(batch_size,)`. Para uma tarefa de regressão, a forma é `(batch_size, num_targets)`. 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. return_loss (`bool`, *opcional*) : Se deve retornar a perda na chamada `forward`. **Retorna:** `PatchTSMixerForRegressionOutput` ou `tuple(torch.Tensor)` Um `PatchTSMixerForRegressionOutput` 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 ([PatchTSMixerConfig](/docs/transformers/main/pt/model_doc/patchtsmixer#transformers.PatchTSMixerConfig)) e das entradas. O método forward de [PatchTSMixerForRegression](/docs/transformers/main/pt/model_doc/patchtsmixer#transformers.PatchTSMixerForRegression) sobrescreve 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 `y` is provided, `torch.Tensor` of shape `()`) -- Total loss. - **regression_outputs** (`torch.Tensor` de forma `(batch_size, num_targets)`) -- Saída de previsão da cabeça de regressão. - **last_hidden_state** (`torch.Tensor` de forma `(batch_size, num_input_channels, num_patches, d_model)`) -- Embeddings do backbone antes de passar pelo head. - **hidden_states** (`tuple(torch.Tensor)`, *opcional*) -- Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.