# PatchTST

## Tổng quan

Mô hình PatchTST được đề xuất trong [A Time Series is Worth 64 Words: Long-term Forecasting with Transformers](https://huggingface.co/papers/2211.14730) bởi Yuqi Nie, Nam H. Nguyen, Phanwadee Sinthong và Jayant Kalagnanam.

Ở cấp độ tổng quan, mô hình vector hóa chuỗi thời gian thành các patch có kích thước cho trước và mã hóa chuỗi vector kết quả thông qua một Transformer, sau đó đưa ra dự báo có độ dài dự đoán thông qua một head phù hợp. Mô hình được minh họa trong hình sau:

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

Tóm tắt từ bài báo như sau:

*Chúng tôi đề xuất một thiết kế hiệu quả cho các mô hình dựa trên Transformer dành cho dự báo chuỗi thời gian đa biến và học biểu diễn tự giám sát. Nó dựa trên hai thành phần chính: (i) phân đoạn chuỗi thời gian thành các patch ở cấp độ chuỗi con, đóng vai trò là các token đầu vào cho Transformer; (ii) tính độc lập theo kênh, trong đó mỗi kênh chứa một chuỗi thời gian đơn biến duy nhất và chia sẻ cùng một embedding cùng trọng số Transformer trên tất cả các chuỗi. Thiết kế patch mang lại ba lợi ích tự nhiên: thông tin ngữ nghĩa cục bộ được giữ lại trong embedding; chi phí tính toán và bộ nhớ sử dụng của các bản đồ chú ý giảm theo bậc hai khi giữ nguyên cửa sổ nhìn lại; và mô hình có thể chú ý đến lịch sử dài hơn. Mô hình Transformer chuỗi thời gian patch độc lập theo kênh (PatchTST) của chúng tôi có thể cải thiện đáng kể độ chính xác dự báo dài hạn so với các mô hình dựa trên Transformer SOTA. Chúng tôi cũng áp dụng mô hình của mình cho các nhiệm vụ tiền huấn luyện tự giám sát và đạt được hiệu suất tinh chỉnh xuất sắc, vượt trội hơn so với huấn luyện có giám sát trên các bộ dữ liệu lớn. Việc chuyển giao biểu diễn tiền huấn luyện có che (masked) từ một bộ dữ liệu sang các bộ dữ liệu khác cũng tạo ra độ chính xác dự báo SOTA.*

Mô hình này được đóng góp bởi [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) và [kashif](https://huggingface.co/kashif). Mã nguồn gốc có thể được tìm thấy [tại đây](https://github.com/yuqinie98/PatchTST).

## Mẹo sử dụng

Mô hình cũng có thể được sử dụng cho phân loại chuỗi thời gian và hồi quy chuỗi thời gian. Xem các lớp [PatchTSTForClassification](/docs/transformers/v5.23.0/vi/model_doc/patchtst#transformers.PatchTSTForClassification) và [PatchTSTForRegression](/docs/transformers/v5.23.0/vi/model_doc/patchtst#transformers.PatchTSTForRegression) tương ứng.

## Tài nguyên

- Một bài viết trên blog giải thích chi tiết về PatchTST có thể được tìm thấy [tại đây](https://huggingface.co/blog/patchtst). Bài viết này cũng có thể được mở trong 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)
```

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/patchtst/configuration_patchtst.py#L24)

**Tham số:**

num_input_channels (`int`, *tuỳ chọn*, mặc định là `1`) : Số lượng kênh đầu vào.

context_length (`int`, *tuỳ chọn*, mặc định là 32) : Độ dài ngữ cảnh của chuỗi đầu vào.

distribution_output (`str`, *tùy chọn*, mặc định là `"student_t"`) : Đầu phát phân phối cho mô hình khi loss là "nll". Có thể là "student_t", "normal" hoặc "negative_binomial".

loss (`str`, *tùy chọn*, mặc định là `"mse"`) : Hàm mất mát cho mô hình tương ứng với đầu `distribution_output`. Đối với các phân phối tham số, đây là âm log likelihood ("nll"), và đối với các ước lượng điểm, đây là sai số bình phương trung bình "mse".

patch_length (`int`, *tuỳ chọn*, mặc định là 1) : Xác định độ dài của patch trong quá trình patchification.

patch_stride (`int`, *optional*, mặc định là 1) : Xác định bước nhảy (stride) của quá trình patchification.

num_hidden_layers (`int`, *tuỳ chọn*, mặc định là `3`) : Số lượng lớp ẩn trong bộ giải mã Transformer.

d_model (`int`, *tuỳ chọn*, mặc định là `128`) : Kích thước của các lớp encoder và lớp pooler.

num_attention_heads (`int`, *tuỳ chọn*, mặc định là 4) : Số lượng đầu chú ý cho mỗi lớp chú ý trong bộ mã hóa Transformer.

share_embedding (`bool`, *tùy chọn*, mặc định là `True`) : Chia sẻ embedding đầu vào giữa tất cả các kênh.

channel_attention (`bool`, *tùy chọn*, mặc định là `False`) : Kích hoạt khối chú ý kênh trong Transformer để cho phép các kênh chú ý đến nhau.

ffn_dim (`int`, *tuỳ chọn*, mặc định là 512) : Kích thước của lớp "trung gian" (thường được gọi là lớp feed-forward) trong bộ mã hóa Transformer.

norm_type (`str` , *tùy chọn*, mặc định là `"batchnorm"`) : Chuẩn hóa ở mỗi lớp Transformer. Có thể là `"batchnorm"` hoặc `"layernorm"`.

norm_eps (`float`, *optional*, mặc định là 1e-05) : Một giá trị được cộng vào mẫu số để đảm bảo tính ổn định số học của phép chuẩn hóa.

attention_dropout (`Union[float, int]`, *tùy chọn*, mặc định là `0.0`) : Tỷ lệ dropout cho các xác suất chú ý.

positional_dropout (`float`, *tuỳ chọn*, mặc định là 0.0) : Xác suất dropout trong lớp nhúng vị trí.

path_dropout (`float`, *tuỳ chọn*, mặc định là 0.0) : Đường dẫn dropout trong khối dư (residual block).

ff_dropout (`float`, *optional*, mặc định là 0.0) : Xác suất dropout được sử dụng giữa hai lớp của mạng feed-forward.

bias (`bool`, *tùy chọn*, mặc định là `True`) : Có thêm bias trong các mạng feed-forward hay không.

activation_function (`str`, *tùy chọn*, mặc định là `"gelu"`) : Hàm kích hoạt phi tuyến tính (chuỗi) trong Transformer.`"gelu"` và `"relu"` được hỗ trợ.

pre_norm (`bool`, *tùy chọn*, mặc định là `True`) : Chuẩn hóa được áp dụng trước self-attention nếu pre_norm được đặt thành `True`. Ngược lại, chuẩn hóa được áp dụng sau khối residual.

positional_encoding_type (`str`, *tùy chọn*, mặc định là `"sincos"`) : Mã hóa vị trí. Các tùy chọn `"random"` và `"sincos"` được hỗ trợ.

use_cls_token (`bool`, *tùy chọn*, mặc định là `False`) : Cho biết có sử dụng cls token hay không.

init_std (`float`, *optional*, mặc định là 0.02) : Độ lệch chuẩn của phân phối khởi tạo trọng số chuẩn bị cắt.

share_projection (`bool`, *tuỳ chọn*, mặc định là `True`) : Chia sẻ lớp chiếu (projection layer) giữa các kênh khác nhau trong đầu dự báo (forecast head).

scaling (`Union`, *tùy chọn*, mặc định là `"std"`) : Xác định việc có mở rộng các mục tiêu đầu vào bằng bộ mở rộng "mean", bộ mở rộng "std" hay không mở rộng nếu là `None`. Nếu là `True`, bộ mở rộng sẽ được đặt thành "mean".

do_mask_input (`bool`, *tùy chọn*) : Áp dụng masking trong quá trình pretraining.

mask_type (`str`, *tùy chọn*, mặc định là `"random"`) : Kiểu che mặt. Hiện tại chỉ hỗ trợ `"random"` và `"forecast"`.

random_mask_ratio (`float`, *optional*, mặc định là 0.5) : Tỷ lệ che (masking ratio) được áp dụng để che dữ liệu đầu vào trong quá trình tiền huấn luyện ngẫu nhiên.

num_forecast_mask_patches (`int` hoặc `list`, *tùy chọn*, mặc định là `[2]`) : Số lượng patch cần được che ở cuối mỗi mẫu trong batch. Nếu là số nguyên, tất cả các mẫu trong batch sẽ có cùng số lượng patch bị che. Nếu là danh sách, các mẫu trong batch sẽ được che ngẫu nhiên theo các số được định nghĩa trong danh sách. Tham số này chỉ được sử dụng cho huấn luyện trước dự báo.

channel_consistent_masking (`bool`, *tùy chọn*, mặc định là `False`) : Nếu channel consistent masking là True, tất cả các kênh sẽ có cùng một mẫu masking.

unmasked_channel_indices (`list`, *tùy chọn*) : Chỉ số của các kênh không bị che mặt trong quá trình tiền huấn luyện. Các giá trị trong danh sách là số từ 1 đến `num_input_channels`

mask_value (`int`, *tuỳ chọn*, mặc định là 0) : Các giá trị trong các vùng bị che sẽ được điền bằng `mask_value`.

pooling_type (`str`, *tùy chọn*, mặc định là `"mean"`) : Pooling của embedding. Hỗ trợ `"mean"`, `"max"` và `None`.

head_dropout (`float`, *tuỳ chọn*, mặc định là 0.0) : Xác suất dropout cho head.

prediction_length (`int`, *optional*, mặc định là 24) : Khoảng dự báo mà mô hình sẽ đưa ra.

num_targets (`int`, *tuỳ chọn*, mặc định là 1) : Số lượng mục tiêu cho các tác vụ hồi quy và phân loại. Đối với phân loại, đây là số lượng lớp.

output_range (`list`, *optional*) : Khoảng đầu ra cho tác vụ hồi quy. Khoảng giá trị đầu ra có thể được thiết lập để buộc mô hình tạo ra các giá trị nằm trong một khoảng nhất định.

num_parallel_samples (`int`, *optional*, mặc định là 100) : Số lượng mẫu được tạo song song cho dự đoán xác suất.

Đây là lớp cấu hình để lưu trữ cấu hình của một PatchTSTModel. Nó được sử dụng để khởi tạo một mô hình Patchtst theo các đối số được chỉ định, xác định kiến trúc của mô hình. Khởi tạo một cấu hình với các giá trị mặc định sẽ tạo ra một cấu hình tương tự như cấu hình của [ibm-granite/granite-timeseries-patchtst](https://huggingface.co/ibm-granite/granite-timeseries-patchtst)

Các đối tượng cấu hình kế thừa từ [PreTrainedConfig](/docs/transformers/v5.23.0/vi/main_classes/configuration#transformers.PreTrainedConfig) và có thể được sử dụng để kiểm soát đầu ra của mô hình. Đọc tài liệu từ [PreTrainedConfig](/docs/transformers/v5.23.0/vi/main_classes/configuration#transformers.PreTrainedConfig) để biết thêm thông tin.

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

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/patchtst/modeling_patchtst.py#L1066)

**Tham số:**

config ([PatchTSTConfig](/docs/transformers/v5.23.0/vi/model_doc/patchtst#transformers.PatchTSTConfig)) : Lớp cấu hình mô hình chứa tất cả các tham số của mô hình. Khởi tạo bằng tệp cấu hình sẽ không tải trọng số liên quan đến mô hình, chỉ tải cấu hình. Xem phương thức [from_pretrained()](/docs/transformers/v5.23.0/vi/main_classes/model#transformers.PreTrainedModel.from_pretrained) để tải trọng số mô hình.

Mô hình Patchtst cơ bản, xuất ra các hidden-states thô mà không có head cụ thể nào ở phía trên.

Mô hình này kế thừa từ [PreTrainedModel](/docs/transformers/v5.23.0/vi/main_classes/model#transformers.PreTrainedModel). Xem tài liệu của lớp cha để biết các phương thức chung mà thư viện triển khai cho tất cả các mô hình của nó (chẳng hạn như tải xuống hoặc lưu trữ, thay đổi kích thước các nhúng đầu vào, cắt tỉa các đầu ra, v.v.)

Mô hình này cũng là một lớp con của [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) trong PyTorch. Hãy sử dụng nó như một Module PyTorch thông thường và tham khảo tài liệu PyTorch cho mọi vấn đề liên quan đến cách sử dụng và hành vi chung.

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

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/patchtst/modeling_patchtst.py#L1085)

**Tham số:**

past_values (`torch.Tensor` có hình dạng `(bs, sequence_length, num_input_channels)`, *bắt buộc*) : Dãy đầu vào cho mô hình

past_observed_mask (`torch.BoolTensor` có shape `(batch_size, sequence_length, num_input_channels)`, *tùy chọn*) : Mặt nạ Boolean để chỉ ra những `past_values` nào đã được quan sát và những cái nào bị thiếu. Giá trị mặt nạ được chọn trong `[0, 1]`: - 1 cho các giá trị **đã được quan sát**, - 0 cho các giá trị **bị thiếu** (tức là các NaN đã được thay thế bằng số không).

future_values (`torch.BoolTensor` có hình dạng `(batch_size, prediction_length, num_input_channels)`, *tùy chọn*) : Các giá trị mục tiêu trong tương lai liên quan đến `past_values`

output_hidden_states (`bool`, *tùy chọn*) : Có trả về trạng thái ẩn của tất cả các lớp hay không

output_attentions (`bool`, *tùy chọn*) : Có trả về đầu ra chú ý của tất cả các lớp hay không

return_dict (`bool`, *tùy chọn*) : Có trả về `ModelOutput` thay vì một tuple thông thường hay không.

**Trả về:**

`PatchTSTModelOutput` hoặc tuple của `torch.Tensor` (nếu `return_dict`=False hoặc `config.return_dict`=False)

Ví dụ:

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

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/patchtst/modeling_patchtst.py#L1560)

**Tham số:**

config ([PatchTSTConfig](/docs/transformers/v5.23.0/vi/model_doc/patchtst#transformers.PatchTSTConfig)) : Lớp cấu hình mô hình chứa tất cả các tham số của mô hình. Khởi tạo bằng tệp cấu hình sẽ không tải trọng số liên quan đến mô hình, chỉ tải cấu hình. Xem phương thức [from_pretrained()](/docs/transformers/v5.23.0/vi/main_classes/model#transformers.PreTrainedModel.from_pretrained) để tải trọng số mô hình.

Mô hình dự đoán PatchTST.

Mô hình này kế thừa từ [PreTrainedModel](/docs/transformers/v5.23.0/vi/main_classes/model#transformers.PreTrainedModel). Xem tài liệu của lớp cha để biết các phương thức chung mà thư viện triển khai cho tất cả các mô hình của nó (chẳng hạn như tải xuống hoặc lưu trữ, thay đổi kích thước các nhúng đầu vào, cắt tỉa các đầu ra, v.v.)

Mô hình này cũng là một lớp con của [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) trong PyTorch. Hãy sử dụng nó như một Module PyTorch thông thường và tham khảo tài liệu PyTorch cho mọi vấn đề liên quan đến cách sử dụng và hành vi chung.

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

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/patchtst/modeling_patchtst.py#L1590)

**Tham số:**

past_values (`torch.Tensor` có hình dạng `(bs, sequence_length, num_input_channels)`, *bắt buộc*) : Dãy đầu vào cho mô hình

past_observed_mask (`torch.BoolTensor` có shape `(batch_size, sequence_length, num_input_channels)`, *tùy chọn*) : Mặt nạ Boolean để chỉ ra những `past_values` nào đã được quan sát và những cái nào bị thiếu. Giá trị mặt nạ được chọn trong `[0, 1]`: - 1 cho các giá trị **đã được quan sát**, - 0 cho các giá trị **bị thiếu** (tức là các NaN đã được thay thế bằng số không).

future_values (`torch.Tensor` có hình dạng `(bs, forecast_len, num_input_channels)`, *tùy chọn*) : Các giá trị mục tiêu trong tương lai liên quan đến `past_values`

output_hidden_states (`bool`, *tùy chọn*) : Có trả về trạng thái ẩn của tất cả các lớp hay không

output_attentions (`bool`, *tùy chọn*) : Có trả về đầu ra chú ý của tất cả các lớp hay không

return_dict (`bool`, *tùy chọn*) : Có trả về `ModelOutput` thay vì một tuple thông thường hay không.

**Trả về:**

`PatchTSTForPredictionOutput` hoặc tuple của `torch.Tensor` (nếu `return_dict`=False hoặc `config.return_dict`=False)

Ví dụ:

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

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/patchtst/modeling_patchtst.py#L1366)

**Tham số:**

config ([PatchTSTConfig](/docs/transformers/v5.23.0/vi/model_doc/patchtst#transformers.PatchTSTConfig)) : Lớp cấu hình mô hình chứa tất cả các tham số của mô hình. Khởi tạo bằng tệp cấu hình sẽ không tải trọng số liên quan đến mô hình, chỉ tải cấu hình. Xem phương thức [from_pretrained()](/docs/transformers/v5.23.0/vi/main_classes/model#transformers.PreTrainedModel.from_pretrained) để tải trọng số mô hình.

Mô hình PatchTST cho phân loại.

Mô hình này kế thừa từ [PreTrainedModel](/docs/transformers/v5.23.0/vi/main_classes/model#transformers.PreTrainedModel). Xem tài liệu của lớp cha để biết các phương thức chung mà thư viện triển khai cho tất cả các mô hình của nó (chẳng hạn như tải xuống hoặc lưu trữ, thay đổi kích thước các nhúng đầu vào, cắt tỉa các đầu ra, v.v.)

Mô hình này cũng là một lớp con của [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) trong PyTorch. Hãy sử dụng nó như một Module PyTorch thông thường và tham khảo tài liệu PyTorch cho mọi vấn đề liên quan đến cách sử dụng và hành vi chung.

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

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/patchtst/modeling_patchtst.py#L1381)

**Tham số:**

past_values (`torch.Tensor` có hình dạng `(bs, sequence_length, num_input_channels)`, *bắt buộc*) : Dãy đầu vào cho mô hình

target_values (`torch.Tensor`, *tùy chọn*) : Nhãn liên kết với `past_values`

past_observed_mask (`torch.BoolTensor` có shape `(batch_size, sequence_length, num_input_channels)`, *tùy chọn*) : Mặt nạ Boolean để chỉ ra những `past_values` nào đã được quan sát và những cái nào bị thiếu. Giá trị mặt nạ được chọn trong `[0, 1]`: - 1 cho các giá trị **đã được quan sát**, - 0 cho các giá trị **bị thiếu** (tức là các NaN đã được thay thế bằng số không).

output_hidden_states (`bool`, *tuỳ chọn*) : Có trả về trạng thái ẩn của tất cả các lớp hay không. Xem `hidden_states` trong phần tensor trả về để biết thêm chi tiết.

output_attentions (`bool`, *tùy chọn*) : Có trả về các tensor chú ý của tất cả các lớp chú ý hay không. Xem `attentions` trong phần tensor trả về để biết thêm chi tiết.

return_dict (`bool`, *tùy chọn*) : Có trả về [ModelOutput](/docs/transformers/v5.23.0/vi/main_classes/output#transformers.utils.ModelOutput) thay vì một tuple thông thường hay không.

**Trả về:** `PatchTSTForClassificationOutput` hoặc `tuple(torch.Tensor)`

Một `PatchTSTForClassificationOutput` hoặc một tuple của `torch.Tensor` (nếu `return_dict=False` được truyền hoặc khi `config.return_dict=False`) bao gồm các phần tử khác nhau tùy thuộc vào cấu hình ([PatchTSTConfig](/docs/transformers/v5.23.0/vi/model_doc/patchtst#transformers.PatchTSTConfig)) và đầu vào.

Phương thức forward của [PatchTSTForClassification](/docs/transformers/v5.23.0/vi/model_doc/patchtst#transformers.PatchTSTForClassification) ghi đè lên phương thức đặc biệt `__call__`.

Mặc dù công thức cho bước truyền tiến cần được định nghĩa bên trong hàm này, bạn nên gọi instance của `Module` sau đó thay vì gọi hàm này, vì instance `Module` sẽ đảm nhận việc thực hiện các bước tiền xử lý và hậu xử lý, trong khi hàm này sẽ bỏ qua chúng một cách im lặng.

- **loss** (`*optional*`, được trả về khi `labels` được cung cấp, `torch.Tensor` có hình dạng `(1,)`) -- Tổng loss là tổng của loss masked language modeling và loss next sequence prediction (phân loại).
- **prediction_logits** (`torch.Tensor` có hình dạng `(batch_size, num_targets)`) -- Điểm dự đoán của đầu mô hình PatchTST (điểm trước SoftMax).
- **hidden_states** (`tuple[torch.Tensor]`, *tuỳ chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) -- Bộ tuple các `torch.Tensor` (một cho đầu ra của embeddings, nếu mô hình có lớp embedding, + một cho đầu ra của mỗi lớp) có hình dạng `(batch_size, sequence_length, hidden_size)`.

  Trạng thái ẩn của mô hình tại đầu ra của mỗi lớp cùng với các đầu ra embedding ban đầu tùy chọn.
- **attentions** (`tuple[torch.Tensor]`, *tuỳ chọn*, được trả về khi `output_attentions=True` được truyền vào hoặc khi `config.output_attentions=True`) -- Bộ tuple của `torch.Tensor` (một cho mỗi lớp) có hình dạng `(batch_size, num_heads, sequence_length, sequence_length)`.

  Trọng số chú ý sau softmax của attention, được sử dụng để tính trung bình có trọng số trong các đầu self-attention.

Ví dụ:

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

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/patchtst/modeling_patchtst.py#L1212)

**Tham số:**

config ([PatchTSTConfig](/docs/transformers/v5.23.0/vi/model_doc/patchtst#transformers.PatchTSTConfig)) : Lớp cấu hình mô hình chứa tất cả các tham số của mô hình. Khởi tạo bằng tệp cấu hình sẽ không tải trọng số liên quan đến mô hình, chỉ tải cấu hình. Xem phương thức [from_pretrained()](/docs/transformers/v5.23.0/vi/main_classes/model#transformers.PreTrainedModel.from_pretrained) để tải trọng số mô hình.

PatchTST cho mô hình pretrain.

Mô hình này kế thừa từ [PreTrainedModel](/docs/transformers/v5.23.0/vi/main_classes/model#transformers.PreTrainedModel). Xem tài liệu của lớp cha để biết các phương thức chung mà thư viện triển khai cho tất cả các mô hình của nó (chẳng hạn như tải xuống hoặc lưu trữ, thay đổi kích thước các nhúng đầu vào, cắt tỉa các đầu ra, v.v.)

Mô hình này cũng là một lớp con của [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) trong PyTorch. Hãy sử dụng nó như một Module PyTorch thông thường và tham khảo tài liệu PyTorch cho mọi vấn đề liên quan đến cách sử dụng và hành vi chung.

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

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/patchtst/modeling_patchtst.py#L1223)

**Tham số:**

past_values (`torch.Tensor` có hình dạng `(bs, sequence_length, num_input_channels)`, *bắt buộc*) : Dãy đầu vào cho mô hình

past_observed_mask (`torch.BoolTensor` có shape `(batch_size, sequence_length, num_input_channels)`, *tùy chọn*) : Mặt nạ Boolean để chỉ ra những `past_values` nào đã được quan sát và những cái nào bị thiếu. Giá trị mặt nạ được chọn trong `[0, 1]`: - 1 cho các giá trị **đã được quan sát**, - 0 cho các giá trị **bị thiếu** (tức là các NaN đã được thay thế bằng số không).

output_hidden_states (`bool`, *tùy chọn*) : Có trả về trạng thái ẩn của tất cả các lớp hay không

output_attentions (`bool`, *tùy chọn*) : Có trả về đầu ra chú ý của tất cả các lớp hay không

return_dict (`bool`, *tùy chọn*) : Có trả về `ModelOutput` thay vì một tuple thông thường hay không.

**Trả về:**

`PatchTSTForPretrainingOutput` hoặc tuple của `torch.Tensor` (nếu `return_dict`=False hoặc `config.return_dict`=False)

Ví dụ:

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

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/patchtst/modeling_patchtst.py#L1809)

**Tham số:**

config ([PatchTSTConfig](/docs/transformers/v5.23.0/vi/model_doc/patchtst#transformers.PatchTSTConfig)) : Lớp cấu hình mô hình chứa tất cả các tham số của mô hình. Khởi tạo bằng tệp cấu hình sẽ không tải trọng số liên quan đến mô hình, chỉ tải cấu hình. Xem phương thức [from_pretrained()](/docs/transformers/v5.23.0/vi/main_classes/model#transformers.PreTrainedModel.from_pretrained) để tải trọng số mô hình.

Mô hình PatchTST cho hồi quy.

Mô hình này kế thừa từ [PreTrainedModel](/docs/transformers/v5.23.0/vi/main_classes/model#transformers.PreTrainedModel). Xem tài liệu của lớp cha để biết các phương thức chung mà thư viện triển khai cho tất cả các mô hình của nó (chẳng hạn như tải xuống hoặc lưu trữ, thay đổi kích thước các nhúng đầu vào, cắt tỉa các đầu ra, v.v.)

Mô hình này cũng là một lớp con của [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) trong PyTorch. Hãy sử dụng nó như một Module PyTorch thông thường và tham khảo tài liệu PyTorch cho mọi vấn đề liên quan đến cách sử dụng và hành vi chung.

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

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/patchtst/modeling_patchtst.py#L1836)

**Tham số:**

past_values (`torch.Tensor` có hình dạng `(bs, sequence_length, num_input_channels)`, *bắt buộc*) : Dãy đầu vào cho mô hình

target_values (`torch.Tensor` có hình dạng `(bs, num_input_channels)`) : Các giá trị đích liên kết với `past_values`

past_observed_mask (`torch.BoolTensor` có shape `(batch_size, sequence_length, num_input_channels)`, *tùy chọn*) : Mặt nạ Boolean để chỉ ra những `past_values` nào đã được quan sát và những cái nào bị thiếu. Các giá trị mặt nạ được chọn trong `[0, 1]`: - 1 cho các giá trị **đã được quan sát**, - 0 cho các giá trị **bị thiếu** (tức là các NaN đã được thay thế bằng số không). Có nên trả về một `ModelOutput` thay vì một tuple đơn thuần hay không.

output_hidden_states (`bool`, *tuỳ chọn*) : Có trả về trạng thái ẩn của tất cả các lớp hay không. Xem `hidden_states` trong phần tensor trả về để biết thêm chi tiết.

output_attentions (`bool`, *tùy chọn*) : Có trả về các tensor chú ý của tất cả các lớp chú ý hay không. Xem `attentions` trong phần tensor trả về để biết thêm chi tiết.

return_dict (`bool`, *tùy chọn*) : Có trả về [ModelOutput](/docs/transformers/v5.23.0/vi/main_classes/output#transformers.utils.ModelOutput) thay vì một tuple thông thường hay không.

**Trả về:** `PatchTSTForRegressionOutput` hoặc `tuple(torch.Tensor)`

Một `PatchTSTForRegressionOutput` hoặc một tuple của `torch.Tensor` (nếu `return_dict=False` được truyền hoặc khi `config.return_dict=False`) bao gồm các phần tử khác nhau tùy thuộc vào cấu hình ([PatchTSTConfig](/docs/transformers/v5.23.0/vi/model_doc/patchtst#transformers.PatchTSTConfig)) và đầu vào.

Phương thức forward của [PatchTSTForRegression](/docs/transformers/v5.23.0/vi/model_doc/patchtst#transformers.PatchTSTForRegression) ghi đè lên phương thức đặc biệt `__call__`.

Mặc dù công thức cho bước truyền tiến cần được định nghĩa bên trong hàm này, bạn nên gọi instance của `Module` sau đó thay vì gọi hàm này, vì instance `Module` sẽ đảm nhận việc thực hiện các bước tiền xử lý và hậu xử lý, trong khi hàm này sẽ bỏ qua chúng một cách im lặng.

- **loss** (`*optional*`, được trả về khi cung cấp `labels`, `torch.Tensor` có shape `(1,)`) -- MSE loss.
- **regression_outputs** (`torch.Tensor` có hình dạng `(batch_size, num_targets)`) -- Đầu ra hồi quy của các đầu mô hình hóa chuỗi thời gian.
- **hidden_states** (`tuple[torch.Tensor]`, *tuỳ chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) -- Bộ tuple các `torch.Tensor` (một cho đầu ra của embeddings, nếu mô hình có lớp embedding, + một cho đầu ra của mỗi lớp) có hình dạng `(batch_size, sequence_length, hidden_size)`.

  Trạng thái ẩn của mô hình tại đầu ra của mỗi lớp cùng với các đầu ra embedding ban đầu tùy chọn.
- **attentions** (`tuple[torch.Tensor]`, *tuỳ chọn*, được trả về khi `output_attentions=True` được truyền vào hoặc khi `config.output_attentions=True`) -- Bộ tuple của `torch.Tensor` (một cho mỗi lớp) có hình dạng `(batch_size, num_heads, sequence_length, sequence_length)`.

  Trọng số chú ý sau softmax của attention, được sử dụng để tính trung bình có trọng số trong các đầu self-attention.

Ví dụ:

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

