# Switch Transformers

[Switch Transformers](https://huggingface.co/papers/2101.03961) là một mô hình T5 thưa, trong đó lớp MLP được thay thế bằng Mixture-of-Experts (MoE). Cơ chế định tuyến gán mỗi token cho một chuyên gia, và mỗi chuyên gia là một MLP dày đặc. Tính thưa cho phép mở rộng quy mô tốt hơn, và cơ chế định tuyến cho phép mô hình chọn các trọng số liên quan theo thời gian thực, từ đó tăng dung lượng của mô hình.

Bạn có thể tìm thấy tất cả các checkpoint Switch Transformers gốc trong bộ sưu tập [Switch Transformer](https://huggingface.co/collections/google/switch-transformers-release-6548c35c6507968374b56d1f).

> [!TIP]
> Mô hình này được đóng góp bởi [ybelkada](https://huggingface.co/ybelkada) và [ArthurZ](https://huggingface.co/ArthurZ).
>
> Nhấp vào các mô hình Switch Transformers ở thanh bên phải để xem thêm các ví dụ về cách áp dụng Switch Transformers cho các tác vụ ngôn ngữ tự nhiên khác nhau.

Ví dụ dưới đây minh họa cách dự đoán token bị che bằng [Pipeline](/docs/transformers/v5.23.0/vi/main_classes/pipelines#transformers.Pipeline), [AutoModel](/docs/transformers/v5.23.0/vi/model_doc/auto#transformers.AutoModel) và từ dòng lệnh.

```python
from transformers import AutoModelForSeq2SeqLM, AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("google/switch-base-8")
model = AutoModelForSeq2SeqLM.from_pretrained("google/switch-base-8", device_map="auto")

input_text = "The capital of France is <extra_id_0>."
input_ids = tokenizer(input_text, return_tensors="pt").input_ids.to(0)

outputs = model.generate(input_ids)
print(tokenizer.decode(outputs[0]))
```

Quantization giảm gánh nặng bộ nhớ của các mô hình lớn bằng cách biểu diễn trọng số ở độ chính xác thấp hơn. Tham khảo tổng quan về [Quantization](../quantization/overview) để biết thêm các backend quantization khả dụng.

Ví dụ bên dưới sử dụng [bitsandbytes](../quantization/bitsandbytes) để chỉ lượng tử hóa trọng số xuống 8-bit.

```python
# pip install bitsandbytes
from transformers import AutoModelForSeq2SeqLM, AutoTokenizer, BitsAndBytesConfig

tokenizer = AutoTokenizer.from_pretrained("google/switch-base-8")
quantization_config = BitsAndBytesConfig(load_in_8bit=True)
model = AutoModelForSeq2SeqLM.from_pretrained("google/switch-base-8", device_map="auto", quantization_config=quantization_config)

input_text = "The capital of France is <extra_id_0>."
input_ids = tokenizer(input_text, return_tensors="pt").input_ids.to(0)

outputs = model.generate(input_ids)
print(tokenizer.decode(outputs[0]))
```

## SwitchTransformersConfig[[transformers.SwitchTransformersConfig]]

#### transformers.SwitchTransformersConfig[[transformers.SwitchTransformersConfig]]

```python
transformers.SwitchTransformersConfig(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, 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, is_encoder_decoder: bool = True, vocab_size: int = 32128, d_model: int = 768, d_kv: int = 64, d_ff: int = 2048, expert_capacity: int = 64, num_layers: int = 12, num_sparse_encoder_layers: int = 3, num_decoder_layers: int | None = 12, num_sparse_decoder_layers: int = 3, num_heads: int = 12, num_experts: int = 8, router_bias: bool = False, router_jitter_noise: int | float = 0.01, router_dtype: typing.Literal['float32', 'float16', 'bfloat16'] = 'float32', router_ignore_padding_tokens: bool = False, relative_attention_num_buckets: int = 32, relative_attention_max_distance: int = 128, dropout_rate: float | int = 0.1, layer_norm_epsilon: float = 1e-06, router_z_loss_coef: float = 0.001, router_aux_loss_coef: float = 0.001, initializer_factor: float = 1.0, dense_act_fn: str = 'relu', add_router_probs: bool = False, use_cache: bool = True, pad_token_id: int | None = 0, eos_token_id: int | list[int] | None = 1, bos_token_id: int | None = None, tie_word_embeddings: bool = True, is_decoder: bool = False, add_cross_attention: bool = False)
```

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/switch_transformers/configuration_switch_transformers.py#L26)

**Tham số:**

is_encoder_decoder (`bool`, *tùy chọn*, mặc định là `True`) : Xác định xem mô hình có được sử dụng như một bộ mã hóa/giải mã hay không.

vocab_size (`int`, *tùy chọn*, mặc định là `32128`) : 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`.

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

d_kv (`int`, *tuỳ chọn*, mặc định là `64`) : Kích thước của các phép chiếu key, query, value cho mỗi đầu chú ý. `inner_dim` của lớp chiếu sẽ được định nghĩa là `num_heads * d_kv`.

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

expert_capacity (`int`, *tuỳ chọn*, mặc định là `64`) : Số lượng token mà mỗi chuyên gia có thể xử lý. Nếu là `None`, `expert_capacity` sẽ được đặt thành `(sequence_length / num_experts) * capacity_factor`.

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

num_sparse_encoder_layers (`int`, *optional*, mặc định là 3) : Số lượng lớp ẩn dense (MoE) thưa trong lớp encoder Transformer. Lưu ý: Khi đặt thành 0 với `num_layers=1`, cài đặt hiện tại vẫn có thể tạo ra một lớp thưa do cách tính bước thưa. Trường hợp biên này không gặp phải trong các checkpoint hiện có.

num_decoder_layers (`int`, *tuỳ chọn*, mặc định là `12`) : Số lượng lớp ẩn trong bộ giải mã Transformer. Nếu không được đặt, giá trị này sẽ giống với `num_layers`.

num_sparse_decoder_layers (`int`, *optional*, mặc định là 3) : Số lượng lớp ẩn dense (MoE) thưa trong lớp decoder của Transformer. Lưu ý: Khi đặt thành 0 với `num_decoder_layers=1`, cài đặt hiện tại vẫn có thể tạo ra một lớp thưa do cách tính bước thưa. Trường hợp biên này không gặp phải trong các checkpoint hiện có.

num_heads (`int`, *tùy chọn*, mặc định là `12`) : Số lượng đầu chú ý cho mỗi lớp chú ý trong bộ giải mã Transformer.

num_experts (`int`, *tuỳ chọn*, mặc định là `8`) : Số lượng chuyên gia được định tuyến trong các lớp MoE.

router_bias (`bool`, *tùy chọn*, mặc định là `False`) : Có thêm bias vào router hay không.

router_jitter_noise (`Union[int, float]`, *tùy chọn*, mặc định là `0.01`) : Lượng nhiễu cần thêm vào các logits của router trong quá trình huấn luyện để cân bằng tải tốt hơn.

router_dtype (`str`, *tùy chọn*, mặc định là `"float32"`) : `dtype` được sử dụng cho các router. Nên giữ `dtype` ở mức `"float32"` như đã nêu trong phần thảo luận về *độ chính xác có chọn lọc* trong [bài báo](https://huggingface.co/papers/2101.03961).

router_ignore_padding_tokens (`bool`, *tùy chọn*, mặc định là `False`) : Có bỏ qua các token đệm khi định tuyến hay không.

relative_attention_num_buckets (`int`, *tuỳ chọn*, mặc định là 32) : Số lượng bucket được sử dụng cho mỗi lớp attention.

relative_attention_max_distance (`int`, *tuỳ chọn*, mặc định là 128) : Khoảng cách tối đa của các chuỗi dài hơn cho việc tách bucket.

dropout_rate (`Union[float, int]`, *tùy chọn*, mặc định là `0.1`) : Tỷ lệ cho tất cả các lớp dropout.

layer_norm_epsilon (`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).

router_z_loss_coef (`float`, *optional*, mặc định là `0.001`) : Hệ số cho z-loss của router, phạt các logits router lớn để cải thiện độ ổn định của quá trình huấn luyện.

router_aux_loss_coef (`float`, *tùy chọn*, mặc định là `0.001`) : Hệ số tổn thất cân bằng tải phụ. Được sử dụng để phạt việc định tuyến chuyên gia không đồng đều trong các mô hình MoE.

initializer_factor (`float`, *tuỳ chọn*, mặc định là `1.0`) : Hệ số để khởi tạo tất cả các ma trận trọng số (nên giữ ở mức 1, được sử dụng bên trong cho việc kiểm tra khởi tạo).

dense_act_fn (`string`, *tuỳ chọn*, mặc định là `"relu"`) : Loại lớp feed forward sẽ được sử dụng. Phải là một trong `"relu"` hoặc `"gated-gelu"`. SwitchTransformersv1.1 sử dụng phép chiếu feed forward `"gated-gelu"`. SwitchTransformers gốc sử dụng `"relu"`.

add_router_probs (`bool`, *tùy chọn*, mặc định là `False`) : Có xuất xác suất của router để tính tổn thất phụ trợ của router hay 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`, *tùy chọn*, mặc định là `0`) : Id của token được sử dụng để đệm (padding) trong từ vựng.

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

bos_token_id (`int`, *tùy chọn*) : Id của token được sử dụng cho đầu luồng trong bảng từ vựng.

tie_word_embeddings (`bool`, *tùy chọn*, mặc định là `True`) : 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.

is_decoder (`bool`, *tùy chọn*, mặc định là `False`) : Xác định xem mô hình có được sử dụng như một bộ giải mã (decoder) hay không. Nếu `False`, mô hình sẽ được sử dụng như một bộ mã hóa (encoder).

add_cross_attention (`bool`, *tùy chọn*, mặc định là `False`) : Xác định xem có nên thêm các lớp cross-attention vào mô hình hay không.

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

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.

## SwitchTransformersTop1Router[[transformers.SwitchTransformersTop1Router]]

#### transformers.SwitchTransformersTop1Router[[transformers.SwitchTransformersTop1Router]]

```python
transformers.SwitchTransformersTop1Router(config: SwitchTransformersConfig)
```

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/switch_transformers/modeling_switch_transformers.py#L52)

Router sử dụng token để chọn gán chuyên gia top-1.

Router này sử dụng cùng cơ chế như trong Switch Transformer (https://huggingface.co/papers/2101.03961) và V-MoE (https://huggingface.co/papers/2106.05974): các token tự chọn chuyên gia hàng đầu của chúng. Các mục được sắp xếp theo router_probs và sau đó được định tuyến đến chuyên gia mà chúng đã chọn cho đến khi đạt expert_capacity của chuyên gia đó. **Không có sự đảm bảo nào rằng mỗi token sẽ được xử lý bởi một chuyên gia**, hoặc rằng mỗi chuyên gia sẽ nhận được ít nhất một token.

#### forward[[transformers.SwitchTransformersTop1Router.forward]]

```python
forward(hidden_states: Tensor)
```

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/switch_transformers/modeling_switch_transformers.py#L72)

**Tham số:**

hidden_states (`torch.Tensor`) : (batch_size, sequence_length, hidden_dim) mà từ đó xác suất router được tính toán.

**Trả về:** expert_index (`torch.Tensor`)

Mặt nạ (mask) điều phối one-hot có hình dạng (batch_size, sequence_length, num_experts), trong đó các token được định tuyến đến một chuyên gia vượt quá dung lượng của chuyên gia đó sẽ bị che đi. router_probs (`torch.Tensor`): Tensor có hình dạng (batch_size, sequence_length, 1) chứa xác suất của chuyên gia được chọn cho mỗi token. Được sử dụng để điều chỉnh đầu ra của các chuyên gia. router_logits (`torch.Tensor`): Tensor logits có hình dạng (batch_size, sequence_length, num_experts) tương ứng với các logits thô của bộ định tuyến. Được sử dụng sau đó để tính toán z-loss của bộ định tuyến.

Tính toán xác suất router từ các trạng thái ẩn đầu vào.

## SwitchTransformersSparseMLP[[transformers.SwitchTransformersSparseMLP]]

#### transformers.SwitchTransformersSparseMLP[[transformers.SwitchTransformersSparseMLP]]

```python
transformers.SwitchTransformersSparseMLP(config: SwitchTransformersConfig)
```

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/switch_transformers/modeling_switch_transformers.py#L182)

#### forward[[transformers.SwitchTransformersSparseMLP.forward]]

```python
forward(hidden_states: Tensor)
```

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/switch_transformers/modeling_switch_transformers.py#L188)

## SwitchTransformersModel[[transformers.SwitchTransformersModel]]

#### transformers.SwitchTransformersModel[[transformers.SwitchTransformersModel]]

```python
transformers.SwitchTransformersModel(config: SwitchTransformersConfig)
```

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/switch_transformers/modeling_switch_transformers.py#L802)

**Tham số:**

config ([SwitchTransformersConfig](/docs/transformers/v5.23.0/vi/model_doc/switch_transformers#transformers.SwitchTransformersConfig)) : 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 Switch Transformers 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/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.SwitchTransformersModel.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.BoolTensor] = None, encoder_outputs: tuple[tuple[torch.Tensor]] | None = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, decoder_inputs_embeds: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/switch_transformers/modeling_switch_transformers.py#L830)

**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/v5.23.0/vi/model_doc/auto#transformers.AutoTokenizer). Xem [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) và [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) để biết chi tiết. [ID đầu vào là gì?](../glossary#input-ids)

attention_mask (`torch.Tensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Mặt nạ để tránh thực hiện chú ý trên các chỉ số token đệm. Các giá trị mặt nạ được chọn trong `[0, 1]`:  - 1 cho các token **không bị che**, - 0 cho các token **bị che**.  [Mặt nạ chú ý là gì?](../glossary#attention-mask)

decoder_input_ids (`torch.LongTensor` có shape `(batch_size, target_sequence_length)`, *tùy chọn*) : Chỉ số của các token trong chuỗi đầu vào của bộ giải mã trong từ vựng.  Các chỉ số có thể được lấy bằng cách sử dụng [AutoTokenizer](/docs/transformers/v5.23.0/vi/model_doc/auto#transformers.AutoTokenizer). Xem [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) và [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) để biết chi tiết.  [Các ID đầu vào của bộ giải mã là gì?](../glossary#decoder-input-ids)

decoder_attention_mask (`torch.BoolTensor` có shape `(batch_size, target_sequence_length)`, *tùy chọn*) : Mặt nạ để tránh thực hiện chú ý trên một số chỉ số token nhất định. Mặc định, một mặt nạ nhân quả sẽ được sử dụng, để đảm bảo mô hình chỉ có thể nhìn vào các đầu vào trước đó nhằm dự đoán tương lai.

encoder_outputs (`tuple[tuple[torch.Tensor]]`, *tùy chọn*) : Tuple bao gồm (`last_hidden_state`, *tùy chọn*: `hidden_states`, *tùy chọn*: `attentions`) `last_hidden_state` có hình dạng `(batch_size, sequence_length, hidden_size)`, *tùy chọn*) là một chuỗi các hidden-states tại đầu ra của lớp cuối cùng của encoder. Được sử dụng trong cross-attention của decoder.

past_key_values (`~cache_utils.Cache`, *tùy chọn*) : Các hidden-states đã tính trước (key và values trong các khối self-attention và cross-attention) có thể được sử dụng để tăng tốc giải mã tuần tự. Điều này thường bao gồm `past_key_values` do mô hình trả về ở một giai đoạn giải mã trước đó, khi `use_cache=True` hoặc `config.use_cache=True`.  Chỉ cho phép [Cache](/docs/transformers/v5.23.0/vi/internal/generation_utils#transformers.Cache) instance làm đầu vào, xem [hướng dẫn kv cache](https://huggingface.co/docs/transformers/en/kv_cache) của chúng tôi. Nếu không truyền `past_key_values`, [DynamicCache](/docs/transformers/v5.23.0/vi/internal/generation_utils#transformers.DynamicCache) sẽ được khởi tạo theo mặc định.  Mô hình sẽ xuất ra cùng định dạng cache được đưa vào làm đầu vào.  Nếu sử dụng `past_key_values`, người dùng được kỳ vọng chỉ nhập các `input_ids` chưa được xử lý (những phần chưa có trạng thái key value quá khứ được cung cấp cho mô hình này) có shape `(batch_size, unprocessed_length)` thay vì tất cả `input_ids` có shape `(batch_size, sequence_length)`.

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.

decoder_inputs_embeds (`torch.Tensor` có shape `(batch_size, target_sequence_length, hidden_size)`, *tùy chọn*) : Tùy chọn, thay vì truyền `decoder_input_ids`, bạn có thể chọn truyền trực tiếp một biểu diễn nhúng. Nếu `past_key_values` được sử dụng, tùy chọn chỉ cần nhập `decoder_inputs_embeds` cuối cùng (xem `past_key_values`). Đ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ố `decoder_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. Nếu cả `decoder_input_ids` và `decoder_inputs_embeds` đều không được đặt, `decoder_inputs_embeds` sẽ nhận giá trị của `inputs_embeds`.

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

Một `Seq2SeqMoEModelOutput` 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 (`None`) và đầu vào.

Phương thức forward của [SwitchTransformersModel](/docs/transformers/v5.23.0/vi/model_doc/switch_transformers#transformers.SwitchTransformersModel) 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)`) -- Chuỗi các trạng thái ẩn (hidden-states) tại đầu ra của lớp cuối cùng của bộ giải mã (decoder) của mô hình.

  Nếu `past_key_values` được sử dụng, chỉ có hidden-state cuối cùng của các chuỗi có shape `(batch_size, 1, hidden_size)` được xuất ra.
- **past_key_values** (`EncoderDecoderCache`, *tùy chọn*, được trả về khi `use_cache=True` được truyền vào hoặc khi `config.use_cache=True`) -- Đây là một instance của [EncoderDecoderCache](/docs/transformers/v5.23.0/vi/internal/generation_utils#transformers.EncoderDecoderCache). Để biết thêm chi tiết, hãy xem [hướng dẫn về kv cache](https://huggingface.co/docs/transformers/en/kv_cache) của chúng tôi.

  Chứa các hidden-states đã được tính trước (key và values trong các khối self-attention và trong các khối cross-attention) có thể được sử dụng (xem đầu vào `past_key_values`) để tăng tốc độ giải mã tuần tự.
- **decoder_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ủa `torch.Tensor` (một cho đầu ra của các embedding, 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 bộ giải mã tại đầu ra của mỗi lớp cùng với các đầu ra nhúng ban đầu tùy chọn.
- **decoder_attentions** (`tuple(torch.Tensor)`, *tùy 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ú ý của bộ giải mã, sau softmax chú ý, được sử dụng để tính trung bình có trọng số trong các đầu chú ý tự (self-attention).
- **decoder_router_logits** (`tuple(torch.Tensor)`, *tùy chọn*, được trả về khi truyền `output_router_logits=True` hoặc khi `config.add_router_probs=True`) -- Bộ ba `torch.Tensor` (một cho mỗi lớp) có hình dạng `(batch_size, sequence_length, num_experts)`.

  Logits của Router trong mô hình decoder, hữu ích để tính toán tổn thất phụ (auxiliary loss) cho các mô hình Mixture of Experts.
- **cross_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ú ý của lớp cross-attention của bộ giải mã, sau softmax chú ý, được sử dụng để tính trung bình có trọng số trong các đầu chú ý chéo.
- **encoder_last_hidden_state** (`torch.Tensor` có hình dạng `(batch_size, sequence_length, hidden_size)`, *tùy chọn*) -- Chuỗi các trạng thái ẩn tại đầu ra của lớp cuối cùng của bộ mã hóa trong mô hình.
- **encoder_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 các embedding, 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 bộ mã hóa tại đầu ra của mỗi lớp cùng với các đầu ra nhúng ban đầu tùy chọn.
- **encoder_attentions** (`tuple(torch.Tensor)`, *tùy 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ú ý của bộ mã hóa, sau softmax chú ý, được sử dụng để tính trung bình có trọng số trong các đầu chú ý tự thân.
- **encoder_router_logits** (`tuple(torch.Tensor)`, *tùy chọn*, được trả về khi truyền `output_router_logits=True` hoặc khi `config.add_router_probs=True`) -- Bộ ba `torch.Tensor` (một cho mỗi lớp) có hình dạng `(batch_size, sequence_length, num_experts)`.

  Logits của Router trong mô hình encoder, hữu ích để tính toán auxiliary loss và z_loss cho các module thưa.

## SwitchTransformersForConditionalGeneration[[transformers.SwitchTransformersForConditionalGeneration]]

#### transformers.SwitchTransformersForConditionalGeneration[[transformers.SwitchTransformersForConditionalGeneration]]

```python
transformers.SwitchTransformersForConditionalGeneration(config: SwitchTransformersConfig)
```

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/switch_transformers/modeling_switch_transformers.py#L944)

**Tham số:**

config ([SwitchTransformersConfig](/docs/transformers/v5.23.0/vi/model_doc/switch_transformers#transformers.SwitchTransformersConfig)) : 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 SWITCH_TRANSFORMERS với đầu `language modeling` ở 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.SwitchTransformersForConditionalGeneration.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.BoolTensor] = None, encoder_outputs: tuple[tuple[torch.Tensor]] | None = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, decoder_inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, output_router_logits: bool | None = False, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/switch_transformers/modeling_switch_transformers.py#L981)

**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/v5.23.0/vi/model_doc/auto#transformers.AutoTokenizer). Xem [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) và [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) để biết chi tiết. [ID đầu vào là gì?](../glossary#input-ids)

attention_mask (`torch.Tensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Mặt nạ để tránh thực hiện chú ý trên các chỉ số token đệm. Các giá trị mặt nạ được chọn trong `[0, 1]`:  - 1 cho các token **không bị che**, - 0 cho các token **bị che**.  [Mặt nạ chú ý là gì?](../glossary#attention-mask)

decoder_input_ids (`torch.LongTensor` có shape `(batch_size, target_sequence_length)`, *tùy chọn*) : Chỉ số của các token trong chuỗi đầu vào của bộ giải mã trong từ vựng.  Các chỉ số có thể được lấy bằng cách sử dụng [AutoTokenizer](/docs/transformers/v5.23.0/vi/model_doc/auto#transformers.AutoTokenizer). Xem [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) và [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) để biết chi tiết.  [Các ID đầu vào của bộ giải mã là gì?](../glossary#decoder-input-ids)

decoder_attention_mask (`torch.BoolTensor` có shape `(batch_size, target_sequence_length)`, *tùy chọn*) : Mặt nạ để tránh thực hiện chú ý trên một số chỉ số token nhất định. Mặc định, một mặt nạ nhân quả sẽ được sử dụng, để đảm bảo mô hình chỉ có thể nhìn vào các đầu vào trước đó nhằm dự đoán tương lai.

encoder_outputs (`tuple[tuple[torch.Tensor]]`, *tùy chọn*) : Tuple bao gồm (`last_hidden_state`, *tùy chọn*: `hidden_states`, *tùy chọn*: `attentions`) `last_hidden_state` có hình dạng `(batch_size, sequence_length, hidden_size)`, *tùy chọn*) là một chuỗi các hidden-states tại đầu ra của lớp cuối cùng của encoder. Được sử dụng trong cross-attention của decoder.

past_key_values (`~cache_utils.Cache`, *tùy chọn*) : Các hidden-states đã tính trước (key và values trong các khối self-attention và cross-attention) có thể được sử dụng để tăng tốc giải mã tuần tự. Điều này thường bao gồm `past_key_values` do mô hình trả về ở một giai đoạn giải mã trước đó, khi `use_cache=True` hoặc `config.use_cache=True`.  Chỉ cho phép [Cache](/docs/transformers/v5.23.0/vi/internal/generation_utils#transformers.Cache) instance làm đầu vào, xem [hướng dẫn kv cache](https://huggingface.co/docs/transformers/en/kv_cache) của chúng tôi. Nếu không truyền `past_key_values`, [DynamicCache](/docs/transformers/v5.23.0/vi/internal/generation_utils#transformers.DynamicCache) sẽ được khởi tạo theo mặc định.  Mô hình sẽ xuất ra cùng định dạng cache được đưa vào làm đầu vào.  Nếu sử dụng `past_key_values`, người dùng được kỳ vọng chỉ nhập các `input_ids` chưa được xử lý (những phần chưa có trạng thái key value quá khứ được cung cấp cho mô hình này) có shape `(batch_size, unprocessed_length)` thay vì tất cả `input_ids` có shape `(batch_size, sequence_length)`.

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.

decoder_inputs_embeds (`torch.Tensor` có shape `(batch_size, target_sequence_length, hidden_size)`, *tùy chọn*) : Tùy chọn, thay vì truyền `decoder_input_ids`, bạn có thể chọn truyền trực tiếp một biểu diễn nhúng. Nếu `past_key_values` được sử dụng, tùy chọn chỉ cần nhập `decoder_inputs_embeds` cuối cùng (xem `past_key_values`). Đ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ố `decoder_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. Nếu cả `decoder_input_ids` và `decoder_inputs_embeds` đều không được đặt, `decoder_inputs_embeds` sẽ nhận giá trị của `inputs_embeds`.

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

output_router_logits (`bool`, *tùy chọn*, mặc định là `False`) : Có trả về logits của tất cả các router hay không. Chúng hữu ích để tính toán router loss và không nên được trả về trong quá trình suy luận.

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

Một `Seq2SeqMoEOutput` 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 (`None`) và đầu vào.

Phương thức forward của [SwitchTransformersForConditionalGeneration](/docs/transformers/v5.23.0/vi/model_doc/switch_transformers#transformers.SwitchTransformersForConditionalGeneration) 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,)`, *tuỳ chọn*, được trả về khi `labels` được cung cấp) -- Loss của language modeling.
- **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).
- **past_key_values** (`EncoderDecoderCache`, *tùy chọn*, được trả về khi `use_cache=True` được truyền vào hoặc khi `config.use_cache=True`) -- Đây là một instance của [EncoderDecoderCache](/docs/transformers/v5.23.0/vi/internal/generation_utils#transformers.EncoderDecoderCache). Để biết thêm chi tiết, hãy xem [hướng dẫn về kv cache](https://huggingface.co/docs/transformers/en/kv_cache) của chúng tôi.

  Chứa các hidden-states đã được tính trước (key và values trong các khối self-attention và trong các khối cross-attention) có thể được sử dụng (xem đầu vào `past_key_values`) để tăng tốc độ giải mã tuần tự.
- **decoder_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ủa `torch.Tensor` (một cho đầu ra của các embedding, 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 bộ giải mã tại đầu ra của mỗi lớp cùng với đầu ra của nhúng ban đầu.
- **decoder_attentions** (`tuple(torch.Tensor)`, *tùy 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ú ý của bộ giải mã, sau softmax chú ý, được sử dụng để tính trung bình có trọng số trong các đầu chú ý tự (self-attention).
- **decoder_router_logits** (`tuple(torch.Tensor)`, *tùy chọn*, được trả về khi truyền `output_router_logits=True` hoặc khi `config.add_router_probs=True`) -- Bộ ba `torch.Tensor` (một cho mỗi lớp) có hình dạng `(batch_size, sequence_length, num_experts)`.

  Logits của Router trong mô hình decoder, hữu ích để tính toán tổn thất phụ (auxiliary loss) cho các mô hình Mixture of Experts.
- **cross_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ú ý của lớp cross-attention của bộ giải mã, sau softmax chú ý, được sử dụng để tính trung bình có trọng số trong các đầu chú ý chéo.
- **encoder_last_hidden_state** (`torch.Tensor` có hình dạng `(batch_size, sequence_length, hidden_size)`, *tùy chọn*) -- Chuỗi các trạng thái ẩn tại đầu ra của lớp cuối cùng của bộ mã hóa trong mô hình.
- **encoder_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 các embedding, 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 bộ mã hóa tại đầu ra của mỗi lớp cùng với đầu ra của nhúng ban đầu.
- **encoder_attentions** (`tuple(torch.Tensor)`, *tùy 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ú ý của bộ mã hóa, sau softmax chú ý, được sử dụng để tính trung bình có trọng số trong các đầu chú ý tự thân.
- **encoder_router_logits** (`tuple(torch.Tensor)`, *tùy chọn*, được trả về khi truyền `output_router_logits=True` hoặc khi `config.add_router_probs=True`) -- Bộ ba `torch.Tensor` (một cho mỗi lớp) có hình dạng `(batch_size, sequence_length, num_experts)`.

  Logits của Router trong mô hình encoder, hữu ích để tính toán auxiliary loss và z_loss cho các mô hình Mixture of Experts.

## SwitchTransformersEncoderModel[[transformers.SwitchTransformersEncoderModel]]

#### transformers.SwitchTransformersEncoderModel[[transformers.SwitchTransformersEncoderModel]]

```python
transformers.SwitchTransformersEncoderModel(config: SwitchTransformersConfig)
```

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/switch_transformers/modeling_switch_transformers.py#L1098)

#### forward[[transformers.SwitchTransformersEncoderModel.forward]]

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

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/switch_transformers/modeling_switch_transformers.py#L1120)

**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/v5.23.0/vi/model_doc/auto#transformers.AutoTokenizer). Xem [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) và [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) để biết chi tiết. [ID đầu vào là gì?](../glossary#input-ids)

attention_mask (`torch.Tensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Mặt nạ để tránh thực hiện chú ý trên các chỉ số token đệm. Các giá trị mặt nạ được chọn trong `[0, 1]`:  - 1 cho các token **không bị che**, - 0 cho các token **bị che**.  [Mặt nạ chú ý là gì?](../glossary#attention-mask)

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.

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ề:** `MoEModelOutput` hoặc `tuple(torch.Tensor)`

Một `MoEModelOutput` 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 (`None`) và đầu vào.

Phương thức forward của [SwitchTransformersEncoderModel](/docs/transformers/v5.23.0/vi/model_doc/switch_transformers#transformers.SwitchTransformersEncoderModel) 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)`) -- Chuỗi các hidden-state tại đầu ra của lớp cuối cùng của mô hình.
- **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ủa `torch.Tensor` (một cho đầu ra của các embedding, 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.
- **router_probs** (`tuple(torch.Tensor)`, *tuỳ chọn*, được trả về khi `output_router_probs=True` và `config.add_router_probs=True` được truyền vào, hoặc khi `config.output_router_probs=True`) -- Bộ ba `torch.Tensor` (một cho mỗi lớp) có hình dạng `(batch_size, sequence_length, num_experts)`.

  Xác suất thô của router được tính toán bởi các router MoE, các thuật ngữ này được sử dụng để tính toán auxiliary loss và z_loss cho các mô hình Mixture of Experts.

