# xLSTM

## Tổng quan

Mô hình xLSTM được đề xuất trong [xLSTM: Extended Long Short-Term Memory](https://huggingface.co/papers/2405.04517) bởi Maximilian Beck*, Korbinian Pöppel*, Markus Spanring, Andreas Auer, Oleksandra Prudnikova, Michael Kopp, Günter Klambauer, Johannes Brandstetter và Sepp Hochreiter. xLSTM cập nhật kiến trúc LSTM gốc để cạnh tranh với các mô hình Transformer bằng cách giới thiệu exponential gating, mở rộng bộ nhớ ma trận, cũng như huấn luyện và nạp dữ liệu song song hóa.

Biến thể [mô hình 7B](https://huggingface.co/NX-AI/xLSTM-7b) được huấn luyện bởi nhóm xLSTM gồm Maximilian Beck, Korbinian Pöppel, Phillip Lippe, Richard Kurle, Patrick Blies, Sebastian Böck và Sepp Hochreiter tại NXAI.

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

*Vào những năm 1990, vòng băng chuyền lỗi không đổi và cổng đóng mở (gating) đã được giới thiệu như những ý tưởng trung tâm của bộ nhớ dài ngắn hạn (Long Short-Term Memory - LSTM). Kể từ đó, LSTM đã đứng vững qua thời gian và đóng góp vào nhiều câu chuyện thành công của học sâu, đặc biệt là chúng đã cấu thành những Mô hình Ngôn ngữ Lớn (Large Language Models - LLM) đầu tiên. Tuy nhiên, sự ra đời của công nghệ Transformer với cơ chế tự chú ý (self-attention) có thể song song hóa ở cốt lõi đã đánh dấu sự khởi đầu của một kỷ nguyên mới, vượt trội hơn LSTM khi mở rộng quy mô. Chúng tôi giờ đây đặt ra một câu hỏi đơn giản: Chúng ta có thể đạt được bao xa trong việc mô hình hóa ngôn ngữ khi mở rộng LSTM lên hàng tỷ tham số, tận dụng các kỹ thuật mới nhất từ các LLM hiện đại, nhưng đồng thời giảm thiểu các hạn chế đã biết của LSTM? Trước tiên, chúng tôi giới thiệu cổng đóng mở mũ (exponential gating) kèm theo các kỹ thuật chuẩn hóa và ổn định phù hợp. Thứ hai, chúng tôi sửa đổi cấu trúc bộ nhớ của LSTM, thu được: (i) sLSTM với bộ nhớ vô hướng, cập nhật vô hướng và trộn bộ nhớ mới, (ii) mLSTM hoàn toàn có thể song song hóa với bộ nhớ ma trận và quy tắc cập nhật hiệp phương sai. Việc tích hợp các phần mở rộng LSTM này vào các khung xương khối dư (residual block backbones) tạo ra các khối xLSTM, sau đó được xếp chồng dư (residually stacked) thành các kiến trúc xLSTM. Cổng đóng mở mũ và các cấu trúc bộ nhớ đã sửa đổi nâng cao khả năng của xLSTM để thực hiện tốt khi so sánh với các Transformer và Mô hình Không gian Trạng thái (State Space Models) tiên tiến nhất, cả về hiệu suất lẫn khả năng mở rộng.*

Mô hình này được đóng góp bởi [NX-AI](https://huggingface.co/NX-AI). Mã gốc có thể được tìm thấy [tại đây](https://github.com/NX-AI/xlstm).

## Ghi chú

- Sử dụng left padding cho việc tạo batched. Xem [Padding side](../llm_tutorial#padding-side).

## xLSTMConfig[[transformers.xLSTMConfig]]

#### transformers.xLSTMConfig[[transformers.xLSTMConfig]]

```python
transformers.xLSTMConfig(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, vocab_size: int = 50304, hidden_size: int = 4096, embedding_dim: int | None = None, num_hidden_layers: int = 32, num_blocks: int | None = None, num_heads: int = 8, use_bias: bool = False, norm_reduction_force_float32: bool = True, tie_word_embeddings: bool = False, add_out_norm: bool = True, norm_eps: float = 1e-06, qk_dim_factor: float = 0.5, v_dim_factor: float = 1.0, chunkwise_kernel: typing.Literal['chunkwise--native_autograd', 'parallel--native_autograd'] = 'chunkwise--native_autograd', sequence_kernel: typing.Literal['native_sequence__native'] = 'native_sequence__native', step_kernel: typing.Literal['native'] = 'native', mode: typing.Literal['train', 'train_with_padding', 'inference'] = 'inference', chunk_size: int = 64, return_last_states: bool = True, autocast_kernel_dtype: typing.Literal['float32', 'bfloat16', 'float16'] = 'bfloat16', eps: float = 1e-06, inference_state_dtype: typing.Literal['float32', 'bfloat16', 'float16'] = 'float32', ffn_proj_factor: float = 2.667, ffn_round_up_to_multiple_of: int = 64, gate_soft_cap: float = 15.0, output_logit_soft_cap: float = 30.0, weight_mode: typing.Literal['single', 'fused'] = 'single', use_cache: bool = True, pad_token_id: int | None = 1, bos_token_id: int | None = 0, eos_token_id: int | list[int] | None = 2, max_inference_chunksize: int = 16384)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/xlstm/configuration_xlstm.py#L58)

**Tham số:**

vocab_size (`int`, *tùy chọn*, mặc định là `50304`) : Kích thước từ vựng của mô hình. Xác định số lượng token khác nhau có thể được biểu diễn bởi `input_ids`.

hidden_size (`int`, *tuỳ chọn*, mặc định là `4096`) : Kích thước của các biểu diễn ẩn.

embedding_dim (`int`, *tùy chọn*) : Độ chiều của các embedding và trạng thái ẩn.

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

num_blocks (`int`, tùy chọn, *tùy chọn*, mặc định là 32) : Số lượng khối của mô hình xLSTM, sử dụng num_hidden_layers nếu là None.

num_heads (`int`, tùy chọn, *tùy chọn*, mặc định là 8) : Số lượng đầu cho Lớp/Ô xLSTM.

use_bias (`bool`, tùy chọn, *tùy chọn*, mặc định là `False`) : Có sử dụng bias trong mô hình xLSTM hay không.

norm_reduction_force_float32 (`bool`, tùy chọn, *tùy chọn*, mặc định là `True`) : Xác định có bắt buộc phép toán giảm chuẩn float32 được thực hiện ở độ chính xác fp32 hay không.

tie_word_embeddings (`bool`, *tùy chọn*, mặc định là `False`) : Có nên gắn kết các nhúng trọng số theo ánh xạ `tied_weights_keys` của mô hình hay không.

add_out_norm (`bool`, tùy chọn, *tùy chọn*, mặc định là `True`) : Có thêm một lớp chuẩn hóa đầu ra sau các khối trước LMHead hay không.

norm_eps (`float`, *tuỳ chọn*, mặc định là `1e-06`) : Epsilon được sử dụng bởi các lớp chuẩn hóa lớp (layer normalization).

qk_dim_factor (`float`, tùy chọn, *tùy chọn*, mặc định là 0.5) : Hệ số tỷ lệ cho chiều của query và key.

v_dim_factor (`float`, tùy chọn, *tùy chọn*, mặc định là 1.0) : Hệ số tỷ lệ cho chiều giá trị.

chunkwise_kernel (`ChunkwiseKernelType`, tùy chọn, *optional*, mặc định là `"chunkwise--native_autograd"`) : Kiểu kernel cho chế độ xử lý theo chunk.

sequence_kernel (`SequenceKernelType`, tùy chọn, *optional*, mặc định là `"native_sequence__native"`) : Kiểu kernel cho chế độ xử lý chuỗi.

step_kernel (`StepKernelType`, tùy chọn, *optional*, mặc định là `"native"`) : Kiểu kernel cho chế độ xử lý bước.

mode (`BackendModeType`, tùy chọn, *optional*, mặc định là `"inference"`) : Chế độ hoạt động (cần inference để tạo ra nội dung).

chunk_size (`int`, tùy chọn, *tùy chọn*, mặc định là 64) : Kích thước chunk nội bộ.

return_last_states (`bool`, tùy chọn, *tùy chọn*, mặc định là `True`) : Xác định có trả về các trạng thái / bộ nhớ đệm cuối cùng bên trong hay không. Cần đặt là True cho quá trình sinh.

autocast_kernel_dtype (`DtypeType`, tùy chọn, *tùy chọn*, mặc định là `"bfloat16"`) : Kiểu dữ liệu của kernel cho các trạng thái.

eps (`float`, *tuỳ chọn*, mặc định là `1e-06`) : Epsilon được sử dụng bởi các lớp chuẩn hóa lớp (layer normalization).

inference_state_dtype (`DtypeType`, tùy chọn, *tùy chọn*, mặc định là `"float32"`) : Kiểu dtype của kernel cho các trạng thái trong suy luận.

ffn_proj_factor (`float`, tùy chọn, *tùy chọn*, mặc định là 2.667) : Hệ số kích thước của mạng Feed Forward có cổng sau phép chiếu mở rộng (post-up projection).

ffn_round_up_to_multiple_of (`int`, tùy chọn, *optional*, mặc định là 64) : Hệ số kích thước làm tròn của mạng Feed Forward có cổng sau khi chiếu lên.

gate_soft_cap (`float`, tùy chọn, *tùy chọn*, mặc định là 15.0) : Thang độ mềm của cổng (gate soft cap scale).

output_logit_soft_cap (`float`, tùy chọn, *tùy chọn*, mặc định là 30.0) : Thang độ mềm (soft cap) cho logit đầu ra.

weight_mode (`Literal`, *tùy chọn*, mặc định là `"single"`) : Xác định xem các lớp tuyến tính song song có được tách riêng hay hợp nhất (single) không.

use_cache (`bool`, *tùy chọn*, mặc định là `True`) : Xác định xem mô hình có nên trả về các chú ý key/values cuối cùng hay không (không được sử dụng bởi tất cả các mô hình). Chỉ liên quan nếu `config.is_decoder=True` hoặc khi mô hình là mô hình sinh chỉ có decoder.

pad_token_id (`int`, *tuỳ chọn*, mặc định là `1`) : Id của token được sử dụng để đệm (padding) trong từ vựng.

bos_token_id (`int`, *tuỳ chọn*, mặc định là `0`) : Id của token được dùng cho đầu luồng (beginning-of-stream) trong từ vựng.

eos_token_id (`Union[int, list[int]]`, *tùy chọn*, mặc định là `2`) : Id của token được sử dụng cho end-of-stream trong bảng từ vựng.

max_inference_chunksize (`int`, tùy chọn, *optional*, mặc định là 16384) : Giới hạn kích thước chunk cho suy luận để tiết kiệm bộ nhớ.

Đây là lớp cấu hình để lưu trữ cấu hình của một xLSTMModel. Nó được sử dụng để khởi tạo một mô hình Xlstm 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 [NX-AI/xLSTM-7b](https://huggingface.co/NX-AI/xLSTM-7b)

Các đối tượng cấu hình kế thừa từ [PreTrainedConfig](/docs/transformers/main/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/main/vi/main_classes/configuration#transformers.PreTrainedConfig) để biết thêm thông tin.

Ví dụ:

```python
>>> from transformers import xLSTMConfig, xLSTMModel

>>> # Initializing a xLSTM configuration
>>> configuration = xLSTMConfig()

>>> # Initializing a model (with random weights) from the configuration
>>> model = xLSTMModel(configuration)

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

## xLSTMModel[[transformers.xLSTMModel]]

#### transformers.xLSTMModel[[transformers.xLSTMModel]]

```python
transformers.xLSTMModel(config: xLSTMConfig)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/xlstm/modeling_xlstm.py#L1394)

**Tham số:**

config ([xLSTMConfig](/docs/transformers/main/vi/model_doc/xlstm#transformers.xLSTMConfig)) : 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/main/vi/main_classes/model#transformers.PreTrainedModel.from_pretrained) để tải trọng số mô hình.

Mô hình Xlstm cơ bản, xuất ra các trạng thái ẩn thô mà không có bất kỳ đầu (head) cụ thể nào ở phía trên.

Mô hình này kế thừa từ [PreTrainedModel](/docs/transformers/main/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.xLSTMModel.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.LongTensor] = None, cache_params: transformers.models.xlstm.modeling_xlstm.xLSTMCache | None = None, use_cache: bool | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/xlstm/modeling_xlstm.py#L1411)

**Tham số:**

input_ids (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Chỉ số của các token trong chuỗi đầu vào theo từ vựng. Mặc định, các token đệm (padding) sẽ bị bỏ qua. Có thể lấy chỉ số bằng cách sử dụng [AutoTokenizer](/docs/transformers/main/vi/model_doc/auto#transformers.AutoTokenizer). Xem [PreTrainedTokenizer.encode()](/docs/transformers/main/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) và [PreTrainedTokenizer.__call__()](/docs/transformers/main/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) để biết chi tiết. [ID đầu vào là gì?](../glossary#input-ids)

inputs_embeds (`torch.LongTensor` có hình dạng `(batch_size, sequence_length, hidden_size)`, *tùy chọn*) : Tùy chọn, thay vì truyền `input_ids`, bạn có thể chọn truyền trực tiếp một biểu diễn nhúng. Điều này hữu ích nếu bạn muốn kiểm soát nhiều hơn cách chuyển đổi các chỉ số `input_ids` thành các vector liên quan so với ma trận tra cứu nhúng nội bộ của mô hình.

cache_params (`xLSTMCache`, *tùy chọn*) : xLSTMCache mang các trạng thái RNN.

use_cache (`bool`, *tùy chọn*) : Nếu được đặt thành `True`, các trạng thái khóa và giá trị `past_key_values` sẽ được trả về và có thể được sử dụng để tăng tốc quá trình giải mã (xem `past_key_values`).

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

Một `xLSTMOutput` 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 thành phần khác nhau tùy thuộc vào cấu hình ([xLSTMConfig](/docs/transformers/main/vi/model_doc/xlstm#transformers.xLSTMConfig)) và đầu vào.

Phương thức forward của [xLSTMModel](/docs/transformers/main/vi/model_doc/xlstm#transformers.xLSTMModel) 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.

- **last_hidden_state** (`torch.Tensor` có hình dạng `(batch_size, sequence_length, hidden_size)`, *tùy chọn*) -- Chuỗi các hidden-state tại đầu ra của lớp cuối cùng của mô hình.
- **cache_params** (`~models.xlstm.modeling_xlstm.xLSTMCache`, *tuỳ chọn*) -- Trạng thái của mô hình tại bước thời gian cuối cùng. Có thể được sử dụng trong phương thức forward với `input_ids` tiếp theo để tránh việc cung cấp lại `input_ids` cũ.
- **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.

## xLSTMLMHeadModel[[transformers.xLSTMForCausalLM]]

#### transformers.xLSTMForCausalLM[[transformers.xLSTMForCausalLM]]

```python
transformers.xLSTMForCausalLM(config: xLSTMConfig)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/xlstm/modeling_xlstm.py#L1517)

**Tham số:**

config ([xLSTMConfig](/docs/transformers/main/vi/model_doc/xlstm#transformers.xLSTMConfig)) : 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/main/vi/main_classes/model#transformers.PreTrainedModel.from_pretrained) để tải trọng số mô hình.

Mô hình Xlstm cho mô hình hóa ngôn ngữ nhân quả.

Mô hình này kế thừa từ [PreTrainedModel](/docs/transformers/main/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.xLSTMForCausalLM.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, cache_params: transformers.models.xlstm.modeling_xlstm.xLSTMCache | None = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/xlstm/modeling_xlstm.py#L1537)

**Tham số:**

input_ids (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Chỉ số của các token trong chuỗi đầu vào theo từ vựng. Mặc định, các token đệm (padding) sẽ bị bỏ qua. Có thể lấy chỉ số bằng cách sử dụng [AutoTokenizer](/docs/transformers/main/vi/model_doc/auto#transformers.AutoTokenizer). Xem [PreTrainedTokenizer.encode()](/docs/transformers/main/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) và [PreTrainedTokenizer.__call__()](/docs/transformers/main/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) để biết chi tiết. [ID đầu vào là gì?](../glossary#input-ids)

inputs_embeds (`torch.Tensor` có hình dạng `(batch_size, sequence_length, hidden_size)`, *tùy chọn*) : Tùy chọn, thay vì truyền `input_ids`, bạn có thể chọn cách truyền trực tiếp một biểu diễn nhúng. Điều này hữu ích nếu bạn muốn kiểm soát nhiều hơn cách chuyển đổi các chỉ số `input_ids` thành các vector liên quan so với ma trận tra cứu nhúng nội bộ của mô hình.

cache_params (`xLSTMCache`, *tùy chọn*) : xLSTMCache mang các trạng thái RNN.

labels (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Nhãn để tính toán tổn thất mô hình hóa ngôn ngữ có mặt nạ. Chỉ số phải nằm trong `[0, ..., config.vocab_size]` hoặc -100 (xem docstring của `input_ids`). Các token có chỉ số được đặt thành `-100` sẽ bị bỏ qua (mặt nạ), tổn thất chỉ được tính cho các token có nhãn nằm trong `[0, ..., config.vocab_size]`.

use_cache (`bool`, *tùy chọn*) : Nếu được đặt thành `True`, các trạng thái khóa và giá trị `past_key_values` sẽ được trả về và có thể được sử dụng để tăng tốc quá trình giải mã (xem `past_key_values`).

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

Một `xLSTMCausalLMOutput` 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 thành phần khác nhau tùy thuộc vào cấu hình ([xLSTMConfig](/docs/transformers/main/vi/model_doc/xlstm#transformers.xLSTMConfig)) và đầu vào.

Phương thức forward của [xLSTMForCausalLM](/docs/transformers/main/vi/model_doc/xlstm#transformers.xLSTMForCausalLM) 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** (`torch.Tensor` có shape `(1,)`, *optional*, được trả về khi `labels` được cung cấp) -- Loss của language modeling (cho next-token prediction).
- **logits** (`torch.Tensor` có hình dạng `(batch_size, sequence_length, config.vocab_size)`) -- Điểm dự đoán của đầu mô hình hóa ngôn ngữ (điểm cho mỗi token từ vựng trước SoftMax).
- **cache_params** (`xLSTMCache`, *tùy chọn*, mang các trạng thái RNN) -- Trạng thái của mô hình tại bước thời gian cuối cùng. Có thể được sử dụng trong một phương thức forward với `input_ids` tiếp theo để tránh việc cung cấp lại các `input_ids` cũ.
- **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.

Ví dụ:

```python
```