# Đầu ra của mô hình

Tất cả các model đều có outputs là các instance của các subclass của [ModelOutput](/docs/transformers/main/vi/main_classes/output#transformers.utils.ModelOutput). Đó là các cấu trúc dữ liệu chứa toàn bộ thông tin được trả về bởi model, nhưng cũng có thể được sử dụng như các tuple hoặc dictionary.

Hãy xem cách nó trông như thế nào trong một ví dụ:

```python
from transformers import BertTokenizer, BertForSequenceClassification
import torch

tokenizer = BertTokenizer.from_pretrained("google-bert/bert-base-uncased")
model = BertForSequenceClassification.from_pretrained("google-bert/bert-base-uncased")

inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
labels = torch.tensor([1]).unsqueeze(0)  # Batch size 1
outputs = model(**inputs, labels=labels)
```

Đối tượng `outputs` là một [SequenceClassifierOutput](/docs/transformers/main/vi/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput), như chúng ta có thể thấy trong tài liệu của lớp đó bên dưới, điều này có nghĩa là nó có một `loss` tùy chọn, một `logits`, một `hidden_states` tùy chọn và một thuộc tính `attentions` tùy chọn. Ở đây chúng ta có `loss` vì chúng ta đã truyền `labels`, nhưng chúng ta không có `hidden_states` và `attentions` vì chúng ta không truyền `output_hidden_states=True` hoặc `output_attentions=True`.

> [!TIP]
> Với `output_hidden_states=True`, `outputs.hidden_states[-1]` không phải lúc nào cũng là cùng một tensor với `outputs.last_hidden_state`. Nhiều bộ mã hóa thị giác và âm thanh, chẳng hạn như ViT, DINOv2, CLIP và Wav2Vec2, trả về đầu ra của lớp cuối *trước* khi áp dụng layernorm cuối cùng trong `hidden_states[-1]`, và đầu ra đã được chuẩn hóa trong `last_hidden_state`. Hãy sử dụng `last_hidden_state` cho các đặc trưng cuối cùng của mô hình. Để `hidden_states[-1]` khớp với `last_hidden_state`, hãy đặt `tie_last_hidden_states=True` trong cấu hình mô hình.

Bạn có thể truy cập từng thuộc tính như bình thường, và nếu thuộc tính đó không được mô hình trả về, bạn sẽ nhận được `None`. Ví dụ, `outputs.loss` là loss được tính bởi mô hình, và `outputs.attentions` là `None`.

Khi xem xét đối tượng `outputs` của chúng ta dưới dạng tuple, nó chỉ xem xét các thuộc tính không có giá trị `None`. Ví dụ ở đây, nó có hai phần tử, `loss` rồi đến `logits`, vì vậy

```python
outputs[:2]
```

sẽ trả về bộ ba `(outputs.loss, outputs.logits)`, chẳng hạn.

Khi xem xét đối tượng `outputs` của chúng ta như một từ điển, nó chỉ xem xét các thuộc tính không có giá trị `None`. Ví dụ, ở đây nó có hai khóa là `loss` và `logits`.

Chúng tôi tài liệu hóa tại đây các đầu ra mô hình chung được sử dụng bởi nhiều hơn một loại mô hình. Các loại đầu ra cụ thể được tài liệu hóa trên trang mô hình tương ứng của chúng.

## ModelOutput[[transformers.utils.ModelOutput]]

#### transformers.utils.ModelOutput[[transformers.utils.ModelOutput]]

```python
transformers.utils.ModelOutput(*args, **kwargs)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/generic.py#L469)

Lớp cơ sở cho tất cả các đầu ra của mô hình dưới dạng dataclass. Có `__getitem__` cho phép chỉ mục bằng số nguyên hoặc slice (giống như tuple) hoặc chuỗi (giống như từ điển), sẽ bỏ qua các thuộc tính `None`. Ngoài ra, hoạt động giống như một từ điển python thông thường.

Bạn không thể giải nén trực tiếp một `ModelOutput`. Hãy sử dụng phương thức [to_tuple()](/docs/transformers/main/vi/main_classes/output#transformers.utils.ModelOutput.to_tuple) để chuyển đổi nó thành một tuple trước.

#### to_tuple[[transformers.utils.ModelOutput.to_tuple]]

```python
to_tuple()
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/generic.py#L628)

Chuyển đổi self thành một tuple chứa tất cả các thuộc tính/khóa không phải là `None`.

## BaseModelOutput[[transformers.modeling_outputs.BaseModelOutput]]

#### transformers.modeling_outputs.BaseModelOutput[[transformers.modeling_outputs.BaseModelOutput]]

```python
transformers.modeling_outputs.BaseModelOutput(last_hidden_state: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L24)

**Tham số:**

last_hidden_state (`torch.Tensor` có hình dạng `(batch_size, sequence_length, hidden_size)`) : Chuỗi các hidden-states tại đầu ra của lớp cuối cùng của mô hình.

hidden_states (`tuple(torch.Tensor)`, *tùy chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) : Tuple của `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)`.  Hidden-states 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)`, *tùy chọn*, được trả về khi `output_attentions=True` được truyền vào hoặc khi `config.output_attentions=True`) : 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 chú ý, được sử dụng để tính trung bình có trọng số trong các đầu chú ý tự (self-attention heads).

Lớp cơ sở cho đầu ra của mô hình, có thể bao gồm trạng thái ẩn và chú ý.

## BaseModelOutputWithPooling[[transformers.modeling_outputs.BaseModelOutputWithPooling]]

#### transformers.modeling_outputs.BaseModelOutputWithPooling[[transformers.modeling_outputs.BaseModelOutputWithPooling]]

```python
transformers.modeling_outputs.BaseModelOutputWithPooling(last_hidden_state: typing.Optional[torch.Tensor] = None, pooler_output: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L69)

**Tham số:**

last_hidden_state (`torch.Tensor` có hình dạng `(batch_size, sequence_length, hidden_size)`) : Chuỗi các hidden-states tại đầu ra của lớp cuối cùng của mô hình.

pooler_output (`torch.Tensor` có shape `(batch_size, hidden_size)`) : Hidden-state của lớp cuối cùng cho token đầu tiên của chuỗi (token phân loại) sau khi được xử lý tiếp qua các lớp dùng cho tác vụ tiền huấn luyện bổ trợ. Ví dụ, đối với các mô hình thuộc họ BERT, giá trị này trả về token phân loại sau khi được xử lý qua một lớp tuyến tính và một hàm kích hoạt tanh. Trọng số của lớp tuyến tính được huấn luyện từ mục tiêu dự đoán câu tiếp theo (phân loại) trong quá trình tiền huấn luyện.

hidden_states (`tuple(torch.Tensor)`, *tùy chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) : Tuple của `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)`.  Hidden-states 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)`, *tùy chọn*, được trả về khi `output_attentions=True` được truyền vào hoặc khi `config.output_attentions=True`) : 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 chú ý, được sử dụng để tính trung bình có trọng số trong các đầu chú ý tự (self-attention heads).

Lớp cơ sở cho đầu ra của mô hình, đồng thời chứa phép pooling của các trạng thái ẩn cuối cùng.

## BaseModelOutputWithCrossAttentions[[transformers.modeling_outputs.BaseModelOutputWithCrossAttentions]]

#### transformers.modeling_outputs.BaseModelOutputWithCrossAttentions[[transformers.modeling_outputs.BaseModelOutputWithCrossAttentions]]

```python
transformers.modeling_outputs.BaseModelOutputWithCrossAttentions(last_hidden_state: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None, cross_attentions: tuple[torch.Tensor, ...] | None = None)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L159)

**Tham số:**

last_hidden_state (`torch.Tensor` có hình dạng `(batch_size, sequence_length, hidden_size)`) : Chuỗi các hidden-states tại đầu ra của lớp cuối cùng của mô hình.

hidden_states (`tuple(torch.Tensor)`, *tùy chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) : Tuple của `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)`.  Hidden-states 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)`, *tùy chọn*, được trả về khi `output_attentions=True` được truyền vào hoặc khi `config.output_attentions=True`) : 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 chú ý, được sử dụng để tính trung bình có trọng số trong các đầu chú ý tự (self-attention heads).

cross_attentions (`tuple(torch.Tensor)`, *tùy chọn*, được trả về khi `output_attentions=True` và `config.add_cross_attention=True` được truyền vào hoặc khi `config.output_attentions=True`) : 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 decoder, sau softmax chú ý, được sử dụng để tính trung bình có trọng số trong các đầu chú ý cross-attention.

Lớp cơ sở cho đầu ra của mô hình, có thể bao gồm trạng thái ẩn và chú ý.

## BaseModelOutputWithPoolingAndCrossAttentions[[transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions]]

#### transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions[[transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions]]

```python
transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions(last_hidden_state: typing.Optional[torch.Tensor] = None, pooler_output: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, cache: transformers.cache_utils.Cache | None = None, attentions: tuple[torch.Tensor, ...] | None = None, cross_attentions: tuple[torch.Tensor, ...] | None = None)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L192)

**Tham số:**

last_hidden_state (`torch.Tensor` có hình dạng `(batch_size, sequence_length, hidden_size)`) : Chuỗi các hidden-states tại đầu ra của lớp cuối cùng của mô hình.

pooler_output (`torch.Tensor` có shape `(batch_size, hidden_size)`) : Hidden-state của lớp cuối cùng cho token đầu tiên của chuỗi (token phân loại) sau khi được xử lý tiếp qua các lớp dùng cho tác vụ tiền huấn luyện bổ trợ. Ví dụ, đối với các mô hình thuộc họ BERT, giá trị này trả về token phân loại sau khi được xử lý qua một lớp tuyến tính và một hàm kích hoạt tanh. Trọng số của lớp tuyến tính được huấn luyện từ mục tiêu dự đoán câu tiếp theo (phân loại) trong quá trình tiền huấn luyện.

hidden_states (`tuple(torch.Tensor)`, *tùy chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) : Tuple của `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)`.  Hidden-states 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)`, *tùy chọn*, được trả về khi `output_attentions=True` được truyền vào hoặc khi `config.output_attentions=True`) : 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 chú ý, được sử dụng để tính trung bình có trọng số trong các đầu chú ý tự (self-attention heads).

cross_attentions (`tuple(torch.Tensor)`, *tùy chọn*, được trả về khi `output_attentions=True` và `config.add_cross_attention=True` được truyền vào hoặc khi `config.output_attentions=True`) : 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 decoder, sau softmax chú ý, được sử dụng để tính trung bình có trọng số trong các đầu chú ý cross-attention.

cache (`Cache`, *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 [Cache](/docs/transformers/main/vi/internal/generation_utils#transformers.Cache). Để 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 toán trước (key và values trong các khối self-attention và tùy chọn nếu `config.is_encoder_decoder=True` trong các khối cross-attention) có thể được sử dụng (xem đầu vào `cache`) để tăng tốc độ giải mã tuần tự.

Lớp cơ sở cho đầu ra của mô hình, đồng thời chứa phép pooling của các trạng thái ẩn cuối cùng.

## BaseModelOutputWithPast[[transformers.modeling_outputs.BaseModelOutputWithPast]]

#### transformers.modeling_outputs.BaseModelOutputWithPast[[transformers.modeling_outputs.BaseModelOutputWithPast]]

```python
transformers.modeling_outputs.BaseModelOutputWithPast(last_hidden_state: typing.Optional[torch.Tensor] = None, cache: transformers.cache_utils.Cache | None = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L123)

**Tham số:**

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. Nếu `cache` được sử dụng, chỉ có hidden-state cuối cùng của các chuỗi với hình dạng `(batch_size, 1, hidden_size)` được đưa ra.

cache (`Cache`, *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 [Cache](/docs/transformers/main/vi/internal/generation_utils#transformers.Cache). Để 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 toán trước (key và values trong các khối self-attention và tùy chọn nếu `config.is_encoder_decoder=True` trong các khối cross-attention) có thể được sử dụng (xem đầu vào `cache`) để tăng tốc độ giải mã tuần tự.

hidden_states (`tuple(torch.Tensor)`, *tùy chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) : Tuple của `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)`.  Hidden-states 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)`, *tùy chọn*, được trả về khi `output_attentions=True` được truyền vào hoặc khi `config.output_attentions=True`) : 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 chú ý, được sử dụng để tính trung bình có trọng số trong các đầu chú ý tự (self-attention heads).

Lớp cơ sở cho đầu ra của mô hình, có thể bao gồm cả các khóa/giá trị trong quá khứ (để tăng tốc giải mã tuần tự).

## BaseModelOutputWithPastAndCrossAttentions[[transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions]]

#### transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions[[transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions]]

```python
transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions(last_hidden_state: typing.Optional[torch.Tensor] = None, cache: transformers.cache_utils.Cache | None = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None, cross_attentions: tuple[torch.Tensor, ...] | None = None)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L238)

**Tham số:**

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. Nếu `cache` được sử dụng, chỉ có hidden-state cuối cùng của các chuỗi với hình dạng `(batch_size, 1, hidden_size)` được đưa ra.

cache (`Cache`, *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 [Cache](/docs/transformers/main/vi/internal/generation_utils#transformers.Cache). Để 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 toán trước (key và values trong các khối self-attention và tùy chọn nếu `config.is_encoder_decoder=True` trong các khối cross-attention) có thể được sử dụng (xem đầu vào `cache`) để tăng tốc độ giải mã tuần tự.

hidden_states (`tuple(torch.Tensor)`, *tùy chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) : Tuple của `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)`.  Hidden-states 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)`, *tùy chọn*, được trả về khi `output_attentions=True` được truyền vào hoặc khi `config.output_attentions=True`) : 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 chú ý, được sử dụng để tính trung bình có trọng số trong các đầu chú ý tự (self-attention heads).

cross_attentions (`tuple(torch.Tensor)`, *tùy chọn*, được trả về khi `output_attentions=True` và `config.add_cross_attention=True` được truyền vào hoặc khi `config.output_attentions=True`) : 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 decoder, sau softmax chú ý, được sử dụng để tính trung bình có trọng số trong các đầu chú ý cross-attention.

Lớp cơ sở cho đầu ra của mô hình, có thể bao gồm cả các khóa/giá trị trong quá khứ (để tăng tốc giải mã tuần tự).

## Seq2SeqModelOutput[[transformers.modeling_outputs.Seq2SeqModelOutput]]

#### transformers.modeling_outputs.Seq2SeqModelOutput[[transformers.modeling_outputs.Seq2SeqModelOutput]]

```python
transformers.modeling_outputs.Seq2SeqModelOutput(last_hidden_state: typing.Optional[torch.Tensor] = None, cache: transformers.cache_utils.EncoderDecoderCache | None = None, decoder_hidden_states: tuple[torch.Tensor, ...] | None = None, decoder_attentions: tuple[torch.Tensor, ...] | None = None, cross_attentions: tuple[torch.Tensor, ...] | None = None, encoder_last_hidden_state: typing.Optional[torch.Tensor] = None, encoder_hidden_states: tuple[torch.Tensor, ...] | None = None, encoder_attentions: tuple[torch.Tensor, ...] | None = None)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L454)

**Tham số:**

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 bộ giải mã của mô hình. Nếu `cache` được sử dụng, chỉ có hidden-state cuối cùng của các chuỗi với hình dạng `(batch_size, 1, hidden_size)` được đưa ra.

cache (`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/main/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 toán trước (key và values trong các khối self-attention và cross-attention) có thể được sử dụng (xem đầu vào `cache`) để tăng tốc độ giải mã tuần tự.

decoder_hidden_states (`tuple(torch.Tensor)`, *tùy chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) : Tuple của `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)`.  Hidden-states của decoder 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.

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

cross_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`) : 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 decoder, sau softmax chú ý, được sử dụng để tính trung bình có trọng số trong các đầu chú ý cross-attention.

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 hidden-states tại đầu ra của lớp cuối cùng của encoder trong mô hình.

encoder_hidden_states (`tuple(torch.Tensor)`, *tùy chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) : Tuple của `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)`.  Hidden-states của encoder 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.

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`) : 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ự (self-attention).

Lớp cơ sở cho đầu ra của bộ mã hóa mô hình, đồng thời chứa: các trạng thái ẩn đã được tính trước, có thể tăng tốc độ giải mã tuần tự.

## CausalLMOutput[[transformers.modeling_outputs.CausalLMOutput]]

#### transformers.modeling_outputs.CausalLMOutput[[transformers.modeling_outputs.CausalLMOutput]]

```python
transformers.modeling_outputs.CausalLMOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L583)

**Tham số:**

loss (`torch.Tensor` có hình dạng `(1,)`, *tùy chọn*, được trả về khi `labels` được cung cấp) : Tổn mô hình hóa ngôn ngữ (cho dự đoán token tiếp theo).

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

hidden_states (`tuple(torch.Tensor)`, *tùy chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) : Tuple của `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)`.  Hidden-states 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)`, *tùy chọn*, được trả về khi `output_attentions=True` được truyền vào hoặc khi `config.output_attentions=True`) : 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 chú ý, được sử dụng để tính trung bình có trọng số trong các đầu chú ý tự (self-attention heads).

Lớp cơ sở cho đầu ra của mô hình ngôn ngữ nhân quả (hoặc tự hồi quy).

## CausalLMOutputWithCrossAttentions[[transformers.modeling_outputs.CausalLMOutputWithCrossAttentions]]

#### transformers.modeling_outputs.CausalLMOutputWithCrossAttentions[[transformers.modeling_outputs.CausalLMOutputWithCrossAttentions]]

```python
transformers.modeling_outputs.CausalLMOutputWithCrossAttentions(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, cache: transformers.cache_utils.Cache | None = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None, cross_attentions: tuple[torch.Tensor, ...] | None = None)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L647)

**Tham số:**

loss (`torch.Tensor` có hình dạng `(1,)`, *tùy chọn*, được trả về khi `labels` được cung cấp) : Tổn mô hình hóa ngôn ngữ (cho dự đoán token tiếp theo).

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

hidden_states (`tuple(torch.Tensor)`, *tùy chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) : Tuple của `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)`.  Hidden-states 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)`, *tùy chọn*, được trả về khi `output_attentions=True` được truyền vào hoặc khi `config.output_attentions=True`) : 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 chú ý, được sử dụng để tính trung bình có trọng số trong các đầu chú ý tự (self-attention heads).

cross_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)`.  Các trọng số chú ý chéo sau softmax của chú ý, được sử dụng để tính trung bình có trọng số trong các đầu chú ý chéo.

cache (`Cache`, *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 [Cache](/docs/transformers/main/vi/internal/generation_utils#transformers.Cache). Để 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 toán trước (key và values trong các khối attention) có thể được sử dụng (xem đầu vào `cache`) để tăng tốc độ giải mã tuần tự.

Lớp cơ sở cho đầu ra của mô hình ngôn ngữ nhân quả (hoặc tự hồi quy).

## CausalLMOutputWithPast[[transformers.modeling_outputs.CausalLMOutputWithPast]]

#### transformers.modeling_outputs.CausalLMOutputWithPast[[transformers.modeling_outputs.CausalLMOutputWithPast]]

```python
transformers.modeling_outputs.CausalLMOutputWithPast(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, cache: transformers.cache_utils.Cache | None = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L612)

**Tham số:**

loss (`torch.Tensor` có hình dạng `(1,)`, *tùy chọn*, được trả về khi `labels` được cung cấp) : Tổn mô hình hóa ngôn ngữ (cho dự đoán token tiếp theo).

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 (`Cache`, *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 [Cache](/docs/transformers/main/vi/internal/generation_utils#transformers.Cache). Để 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 toán trước (key và values trong các khối self-attention) có thể được sử dụng (xem đầu vào `cache`) để tăng tốc độ giải mã tuần tự.

hidden_states (`tuple(torch.Tensor)`, *tùy chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) : Tuple của `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)`.  Hidden-states 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)`, *tùy chọn*, được trả về khi `output_attentions=True` được truyền vào hoặc khi `config.output_attentions=True`) : 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 chú ý, được sử dụng để tính trung bình có trọng số trong các đầu chú ý tự (self-attention heads).

Lớp cơ sở cho đầu ra của mô hình ngôn ngữ nhân quả (hoặc tự hồi quy).

## MaskedLMOutput[[transformers.modeling_outputs.MaskedLMOutput]]

#### transformers.modeling_outputs.MaskedLMOutput[[transformers.modeling_outputs.MaskedLMOutput]]

```python
transformers.modeling_outputs.MaskedLMOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L724)

**Tham số:**

loss (`torch.Tensor` có hình dạng `(1,)`, *tùy chọn*, được trả về khi `labels` được cung cấp) : Tổn thất mô hình hóa ngôn ngữ có mặt nạ (MLM).

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

hidden_states (`tuple(torch.Tensor)`, *tùy chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) : Tuple của `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)`.  Hidden-states 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)`, *tùy chọn*, được trả về khi `output_attentions=True` được truyền vào hoặc khi `config.output_attentions=True`) : 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 chú ý, được sử dụng để tính trung bình có trọng số trong các đầu chú ý tự (self-attention heads).

Lớp cơ sở cho đầu ra của các mô hình ngôn ngữ có mặt nạ.

## Seq2SeqLMOutput[[transformers.modeling_outputs.Seq2SeqLMOutput]]

#### transformers.modeling_outputs.Seq2SeqLMOutput[[transformers.modeling_outputs.Seq2SeqLMOutput]]

```python
transformers.modeling_outputs.Seq2SeqLMOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, cache: transformers.cache_utils.EncoderDecoderCache | None = None, decoder_hidden_states: tuple[torch.Tensor, ...] | None = None, decoder_attentions: tuple[torch.Tensor, ...] | None = None, cross_attentions: tuple[torch.Tensor, ...] | None = None, encoder_last_hidden_state: typing.Optional[torch.Tensor] = None, encoder_hidden_states: tuple[torch.Tensor, ...] | None = None, encoder_attentions: tuple[torch.Tensor, ...] | None = None)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L753)

**Tham số:**

loss (`torch.Tensor` có hình dạng `(1,)`, *tùy chọn*, được trả về khi `labels` được cung cấp) : Tổn mô hình hóa ngôn ngữ.

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 (`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/main/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 toán trước (key và values trong các khối self-attention và cross-attention) có thể được sử dụng (xem đầu vào `cache`) để tăng tốc độ giải mã tuần tự.

decoder_hidden_states (`tuple(torch.Tensor)`, *tùy chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) : Tuple của `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)`.  Hidden-states của decoder tại đầu ra của mỗi lớp cùng với đầu ra embedding 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`) : 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).

cross_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`) : 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 decoder, sau softmax chú ý, được sử dụng để tính trung bình có trọng số trong các đầu chú ý cross-attention.

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 hidden-states tại đầu ra của lớp cuối cùng của encoder trong mô hình.

encoder_hidden_states (`tuple(torch.Tensor)`, *tùy 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 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 (hidden-states) của encoder tại đầu ra của mỗi lớp cùng với đầu ra embedding 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`) : 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ự (self-attention).

Lớp cơ sở cho đầu ra của các mô hình ngôn ngữ tuần tự-đến-tuần tự.

## NextSentencePredictorOutput[[transformers.modeling_outputs.NextSentencePredictorOutput]]

#### transformers.modeling_outputs.NextSentencePredictorOutput[[transformers.modeling_outputs.NextSentencePredictorOutput]]

```python
transformers.modeling_outputs.NextSentencePredictorOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L884)

**Tham số:**

loss (`torch.Tensor` có shape `(1,)`, *tùy chọn*, được trả về khi `next_sentence_label` được cung cấp) : Loss dự đoán chuỗi tiếp theo (phân loại).

logits (`torch.Tensor` có hình dạng `(batch_size, 2)`) : Điểm dự đoán của đầu dự đoán chuỗi tiếp theo (phân loại) (điểm của tiếp nối True/False trước SoftMax).

hidden_states (`tuple(torch.Tensor)`, *tùy chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) : Tuple của `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)`.  Hidden-states 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)`, *tùy chọn*, được trả về khi `output_attentions=True` được truyền vào hoặc khi `config.output_attentions=True`) : 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 chú ý, được sử dụng để tính trung bình có trọng số trong các đầu chú ý tự (self-attention heads).

Lớp cơ sở cho các đầu ra của các mô hình dự đoán xem hai câu có liên tiếp hay không.

## SequenceClassifierOutput[[transformers.modeling_outputs.SequenceClassifierOutput]]

#### transformers.modeling_outputs.SequenceClassifierOutput[[transformers.modeling_outputs.SequenceClassifierOutput]]

```python
transformers.modeling_outputs.SequenceClassifierOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L914)

**Tham số:**

loss (`torch.Tensor` có shape `(1,)`, *tùy chọn*, được trả về khi `labels` được cung cấp) : Loss phân loại (hoặc hồi quy nếu config.num_labels==1).

logits (`torch.Tensor` có hình dạng `(batch_size, config.num_labels)`) : Điểm phân loại (hoặc hồi quy nếu config.num_labels==1) (trước SoftMax).

hidden_states (`tuple(torch.Tensor)`, *tùy chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) : Tuple của `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)`.  Hidden-states 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)`, *tùy chọn*, được trả về khi `output_attentions=True` được truyền vào hoặc khi `config.output_attentions=True`) : 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 chú ý, được sử dụng để tính trung bình có trọng số trong các đầu chú ý tự (self-attention heads).

Lớp cơ sở cho đầu ra của các mô hình phân loại câu.

## Seq2SeqSequenceClassifierOutput[[transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput]]

#### transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput[[transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput]]

```python
transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, cache: transformers.cache_utils.EncoderDecoderCache | None = None, decoder_hidden_states: tuple[torch.Tensor, ...] | None = None, decoder_attentions: tuple[torch.Tensor, ...] | None = None, cross_attentions: tuple[torch.Tensor, ...] | None = None, encoder_last_hidden_state: typing.Optional[torch.Tensor] = None, encoder_hidden_states: tuple[torch.Tensor, ...] | None = None, encoder_attentions: tuple[torch.Tensor, ...] | None = None)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L943)

**Tham số:**

loss (`torch.Tensor` có shape `(1,)`, *tùy chọn*, được trả về khi `label` được cung cấp) : Loss phân loại (hoặc hồi quy nếu config.num_labels==1).

logits (`torch.Tensor` có hình dạng `(batch_size, config.num_labels)`) : Điểm phân loại (hoặc hồi quy nếu config.num_labels==1) (trước SoftMax).

cache (`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/main/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 toán trước (key và values trong các khối self-attention và cross-attention) có thể được sử dụng (xem đầu vào `cache`) để tăng tốc độ giải mã tuần tự.

decoder_hidden_states (`tuple(torch.Tensor)`, *tùy chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) : Tuple của `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)`.  Hidden-states của decoder tại đầu ra của mỗi lớp cùng với đầu ra embedding 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`) : 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).

cross_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`) : 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 decoder, sau softmax chú ý, được sử dụng để tính trung bình có trọng số trong các đầu chú ý cross-attention.

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 hidden-states tại đầu ra của lớp cuối cùng của encoder trong mô hình.

encoder_hidden_states (`tuple(torch.Tensor)`, *tùy 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 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 (hidden-states) của encoder tại đầu ra của mỗi lớp cùng với đầu ra embedding 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`) : 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ự (self-attention).

Lớp cơ sở cho đầu ra của các mô hình phân loại câu sequence-to-sequence.

## MultipleChoiceModelOutput[[transformers.modeling_outputs.MultipleChoiceModelOutput]]

#### transformers.modeling_outputs.MultipleChoiceModelOutput[[transformers.modeling_outputs.MultipleChoiceModelOutput]]

```python
transformers.modeling_outputs.MultipleChoiceModelOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L1001)

**Tham số:**

loss (`torch.Tensor` có hình dạng *(1,)*, *tùy chọn*, được trả về khi `labels` được cung cấp) : Tổn phân loại.

logits (`torch.Tensor` có shape `(batch_size, num_choices)`) : *num_choices* là chiều thứ hai của các tensor đầu vào. (xem *input_ids* ở trên). Điểm phân loại (trước SoftMax).

hidden_states (`tuple(torch.Tensor)`, *tùy chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) : Tuple của `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)`.  Hidden-states 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)`, *tùy chọn*, được trả về khi `output_attentions=True` được truyền vào hoặc khi `config.output_attentions=True`) : 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 chú ý, được sử dụng để tính trung bình có trọng số trong các đầu chú ý tự (self-attention heads).

Lớp cơ sở cho đầu ra của các mô hình lựa chọn nhiều phương án.

## TokenClassifierOutput[[transformers.modeling_outputs.TokenClassifierOutput]]

#### transformers.modeling_outputs.TokenClassifierOutput[[transformers.modeling_outputs.TokenClassifierOutput]]

```python
transformers.modeling_outputs.TokenClassifierOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L1032)

**Tham số:**

loss (`torch.Tensor` có hình dạng `(1,)`, *tùy chọn*, được trả về khi `labels` được cung cấp) : Tổn phân loại.

logits (`torch.Tensor` có hình dạng `(batch_size, sequence_length, config.num_labels)`) : Điểm phân loại (trước SoftMax).

hidden_states (`tuple(torch.Tensor)`, *tùy chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) : Tuple của `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)`.  Hidden-states 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)`, *tùy chọn*, được trả về khi `output_attentions=True` được truyền vào hoặc khi `config.output_attentions=True`) : 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 chú ý, được sử dụng để tính trung bình có trọng số trong các đầu chú ý tự (self-attention heads).

Lớp cơ sở cho đầu ra của các mô hình phân loại token.

## QuestionAnsweringModelOutput[[transformers.modeling_outputs.QuestionAnsweringModelOutput]]

#### transformers.modeling_outputs.QuestionAnsweringModelOutput[[transformers.modeling_outputs.QuestionAnsweringModelOutput]]

```python
transformers.modeling_outputs.QuestionAnsweringModelOutput(loss: typing.Optional[torch.Tensor] = None, start_logits: typing.Optional[torch.Tensor] = None, end_logits: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L1061)

**Tham số:**

loss (`torch.Tensor` có shape `(1,)`, *tùy chọn*, được trả về khi `labels` được cung cấp) : Tổng loss trích xuất span là tổng của Cross-Entropy cho các vị trí bắt đầu và kết thúc.

start_logits (`torch.Tensor` có hình dạng `(batch_size, sequence_length)`) : Điểm bắt đầu span (trước SoftMax).

end_logits (`torch.Tensor` có hình dạng `(batch_size, sequence_length)`) : Điểm kết thúc span (trước SoftMax).

hidden_states (`tuple(torch.Tensor)`, *tùy chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) : Tuple của `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)`.  Hidden-states 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)`, *tùy chọn*, được trả về khi `output_attentions=True` được truyền vào hoặc khi `config.output_attentions=True`) : 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 chú ý, được sử dụng để tính trung bình có trọng số trong các đầu chú ý tự (self-attention heads).

Lớp cơ sở cho đầu ra của các mô hình trả lời câu hỏi.

## Seq2SeqQuestionAnsweringModelOutput[[transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput]]

#### transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput[[transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput]]

```python
transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput(loss: typing.Optional[torch.Tensor] = None, start_logits: typing.Optional[torch.Tensor] = None, end_logits: typing.Optional[torch.Tensor] = None, cache: transformers.cache_utils.EncoderDecoderCache | None = None, decoder_hidden_states: tuple[torch.Tensor, ...] | None = None, decoder_attentions: tuple[torch.Tensor, ...] | None = None, cross_attentions: tuple[torch.Tensor, ...] | None = None, encoder_last_hidden_state: typing.Optional[torch.Tensor] = None, encoder_hidden_states: tuple[torch.Tensor, ...] | None = None, encoder_attentions: tuple[torch.Tensor, ...] | None = None)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L1093)

**Tham số:**

loss (`torch.Tensor` có shape `(1,)`, *tùy chọn*, được trả về khi `labels` được cung cấp) : Tổng loss trích xuất span là tổng của Cross-Entropy cho các vị trí bắt đầu và kết thúc.

start_logits (`torch.Tensor` có hình dạng `(batch_size, sequence_length)`) : Điểm bắt đầu span (trước SoftMax).

end_logits (`torch.Tensor` có hình dạng `(batch_size, sequence_length)`) : Điểm kết thúc span (trước SoftMax).

cache (`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/main/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 toán trước (key và values trong các khối self-attention và cross-attention) có thể được sử dụng (xem đầu vào `cache`) để tăng tốc độ giải mã tuần tự.

decoder_hidden_states (`tuple(torch.Tensor)`, *tùy chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) : Tuple của `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)`.  Hidden-states của decoder tại đầu ra của mỗi lớp cùng với đầu ra embedding 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`) : 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).

cross_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`) : 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 decoder, sau softmax chú ý, được sử dụng để tính trung bình có trọng số trong các đầu chú ý cross-attention.

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 hidden-states tại đầu ra của lớp cuối cùng của encoder trong mô hình.

encoder_hidden_states (`tuple(torch.Tensor)`, *tùy 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 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 (hidden-states) của encoder tại đầu ra của mỗi lớp cùng với đầu ra embedding 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`) : 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ự (self-attention).

Lớp cơ sở cho đầu ra của các mô hình trả lời câu hỏi theo kiểu chuỗi-sang-chuỗi.

## Seq2SeqSpectrogramOutput[[transformers.modeling_outputs.Seq2SeqSpectrogramOutput]]

#### transformers.modeling_outputs.Seq2SeqSpectrogramOutput[[transformers.modeling_outputs.Seq2SeqSpectrogramOutput]]

```python
transformers.modeling_outputs.Seq2SeqSpectrogramOutput(loss: typing.Optional[torch.Tensor] = None, spectrogram: typing.Optional[torch.Tensor] = None, cache: transformers.cache_utils.EncoderDecoderCache | None = None, decoder_hidden_states: tuple[torch.Tensor, ...] | None = None, decoder_attentions: tuple[torch.Tensor, ...] | None = None, cross_attentions: tuple[torch.Tensor, ...] | None = None, encoder_last_hidden_state: typing.Optional[torch.Tensor] = None, encoder_hidden_states: tuple[torch.Tensor, ...] | None = None, encoder_attentions: tuple[torch.Tensor, ...] | None = None)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L1424)

**Tham số:**

loss (`torch.Tensor` có hình dạng `(1,)`, *tùy chọn*, được trả về khi `labels` được cung cấp) : Tổn thất tạo phổ âm (spectrogram).

spectrogram (`torch.Tensor` có hình dạng `(batch_size, sequence_length, num_bins)`) : Phổ âm (spectrogram) được dự đoán.

cache (`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/main/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 toán trước (key và values trong các khối self-attention và cross-attention) có thể được sử dụng (xem đầu vào `cache`) để tăng tốc độ giải mã tuần tự.

decoder_hidden_states (`tuple(torch.Tensor)`, *tùy chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) : Tuple của `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)`.  Hidden-states của decoder tại đầu ra của mỗi lớp cùng với đầu ra embedding 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`) : 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).

cross_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`) : 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 decoder, sau softmax chú ý, được sử dụng để tính trung bình có trọng số trong các đầu chú ý cross-attention.

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 hidden-states tại đầu ra của lớp cuối cùng của encoder trong mô hình.

encoder_hidden_states (`tuple(torch.Tensor)`, *tùy 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 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 (hidden-states) của encoder tại đầu ra của mỗi lớp cùng với đầu ra embedding 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`) : 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ự (self-attention).

Lớp cơ sở cho đầu ra phổ đồ của mô hình sequence-to-sequence.

## SemanticSegmenterOutput[[transformers.modeling_outputs.SemanticSegmenterOutput]]

#### transformers.modeling_outputs.SemanticSegmenterOutput[[transformers.modeling_outputs.SemanticSegmenterOutput]]

```python
transformers.modeling_outputs.SemanticSegmenterOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L1154)

**Tham số:**

loss (`torch.Tensor` có shape `(1,)`, *tùy chọn*, được trả về khi `labels` được cung cấp) : Loss phân loại (hoặc hồi quy nếu config.num_labels==1).

logits (`torch.Tensor` có shape `(batch_size, config.num_labels, logits_height, logits_width)`) : Điểm phân loại cho từng pixel.    Các logits được trả về không nhất thiết có cùng kích thước với `pixel_values` được truyền vào. Điều này nhằm tránh thực hiện hai lần nội suy và mất một phần chất lượng khi người dùng cần điều chỉnh kích thước logits về kích thước ảnh gốc như một bước xử lý hậu kỳ. Bạn luôn nên kiểm tra shape của logits và điều chỉnh kích thước khi cần.

hidden_states (`tuple(torch.Tensor)`, *tùy chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) : Tuple của `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, patch_size, hidden_size)`.  Hidden-states 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)`, *tùy chọn*, được trả về khi `output_attentions=True` được truyền vào hoặc khi `config.output_attentions=True`) : Tuple của `torch.Tensor` (một cho mỗi lớp) có hình dạng `(batch_size, num_heads, patch_size, sequence_length)`.  Các trọng số chú ý sau softmax chú ý, được sử dụng để tính trung bình có trọng số trong các đầu chú ý tự (self-attention).

Lớp cơ sở cho đầu ra của các mô hình phân đoạn ngữ nghĩa.

## ImageClassifierOutput[[transformers.modeling_outputs.ImageClassifierOutput]]

#### transformers.modeling_outputs.ImageClassifierOutput[[transformers.modeling_outputs.ImageClassifierOutput]]

```python
transformers.modeling_outputs.ImageClassifierOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L1192)

**Tham số:**

loss (`torch.Tensor` có shape `(1,)`, *tùy chọn*, được trả về khi `labels` được cung cấp) : Loss phân loại (hoặc hồi quy nếu config.num_labels==1).

logits (`torch.Tensor` có hình dạng `(batch_size, config.num_labels)`) : Điểm phân loại (hoặc hồi quy nếu config.num_labels==1) (trước SoftMax).

hidden_states (`tuple(torch.Tensor)`, *tùy chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) : Tuple của `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 giai đoạn) có hình dạng `(batch_size, sequence_length, hidden_size)`. Hidden-states (còn gọi là feature maps) của mô hình tại đầu ra của mỗi giai đoạn.

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`) : Tuple của `torch.Tensor` (một cho mỗi lớp) có hình dạng `(batch_size, num_heads, patch_size, sequence_length)`.  Các trọng số chú ý sau softmax chú ý, được sử dụng để tính trung bình có trọng số trong các đầu chú ý tự (self-attention).

Lớp cơ sở cho đầu ra của các mô hình phân loại hình ảnh.

## ImageClassifierOutputWithNoAttention[[transformers.modeling_outputs.ImageClassifierOutputWithNoAttention]]

#### transformers.modeling_outputs.ImageClassifierOutputWithNoAttention[[transformers.modeling_outputs.ImageClassifierOutputWithNoAttention]]

```python
transformers.modeling_outputs.ImageClassifierOutputWithNoAttention(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L1220)

**Tham số:**

loss (`torch.Tensor` có shape `(1,)`, *tùy chọn*, được trả về khi `labels` được cung cấp) : Loss phân loại (hoặc hồi quy nếu config.num_labels==1).

logits (`torch.Tensor` có hình dạng `(batch_size, config.num_labels)`) : Điểm phân loại (hoặc hồi quy nếu config.num_labels==1) (trước SoftMax).

hidden_states (`tuple(torch.Tensor)`, *tùy chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) : Tuple của `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 giai đoạn) có hình dạng `(batch_size, num_channels, height, width)`. Hidden-states (còn gọi là feature maps) của mô hình tại đầu ra của mỗi giai đoạn.

Lớp cơ sở cho đầu ra của các mô hình phân loại hình ảnh.

## DepthEstimatorOutput[[transformers.modeling_outputs.DepthEstimatorOutput]]

#### transformers.modeling_outputs.DepthEstimatorOutput[[transformers.modeling_outputs.DepthEstimatorOutput]]

```python
transformers.modeling_outputs.DepthEstimatorOutput(loss: typing.Optional[torch.Tensor] = None, predicted_depth: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L1241)

**Tham số:**

loss (`torch.Tensor` có shape `(1,)`, *tùy chọn*, được trả về khi `labels` được cung cấp) : Loss phân loại (hoặc hồi quy nếu config.num_labels==1).

predicted_depth (`torch.Tensor` có hình dạng `(batch_size, height, width)`) : Độ sâu dự đoán cho từng pixel.

hidden_states (`tuple(torch.Tensor)`, *tùy chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) : Tuple của `torch.Tensor` (một cho đầu ra của embeddings, nếu model có lớp embedding, + một cho đầu ra của mỗi lớp) có shape `(batch_size, num_channels, height, width)`.  Hidden-states của model tại đầu ra của mỗi lớp cùng với đầu ra embedding ban đầu tùy chọn.

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`) : Tuple của `torch.Tensor` (một cho mỗi lớp) có hình dạng `(batch_size, num_heads, patch_size, sequence_length)`.  Các trọng số chú ý sau softmax chú ý, được sử dụng để tính trung bình có trọng số trong các đầu chú ý tự (self-attention).

Lớp cơ sở cho đầu ra của các mô hình ước lượng độ sâu.

## Wav2Vec2BaseModelOutput[[transformers.modeling_outputs.Wav2Vec2BaseModelOutput]]

#### transformers.modeling_outputs.Wav2Vec2BaseModelOutput[[transformers.modeling_outputs.Wav2Vec2BaseModelOutput]]

```python
transformers.modeling_outputs.Wav2Vec2BaseModelOutput(last_hidden_state: typing.Optional[torch.Tensor] = None, extract_features: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L1299)

**Tham số:**

last_hidden_state (`torch.Tensor` có hình dạng `(batch_size, sequence_length, hidden_size)`) : Chuỗi các hidden-states tại đầu ra của lớp cuối cùng của mô hình.

extract_features (`torch.Tensor` có hình dạng `(batch_size, sequence_length, conv_dim[-1])`) : Chuỗi các vector đặc trưng được trích xuất từ lớp tích chập cuối cùng của mô hình.

hidden_states (`tuple(torch.Tensor)`, *tùy chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) : Tuple của `torch.Tensor` (một cho đầu ra của embeddings + một cho đầu ra của mỗi lớp) có hình dạng `(batch_size, sequence_length, hidden_size)`.  Hidden-states của mô hình tại đầu ra của mỗi lớp cùng với đầu ra embedding ban đầu.

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`) : 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 chú ý, được sử dụng để tính trung bình có trọng số trong các đầu chú ý tự (self-attention heads).

Lớp cơ sở cho các mô hình đã được huấn luyện với mục tiêu tổn thất Wav2Vec2.

## XVectorOutput[[transformers.modeling_outputs.XVectorOutput]]

#### transformers.modeling_outputs.XVectorOutput[[transformers.modeling_outputs.XVectorOutput]]

```python
transformers.modeling_outputs.XVectorOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, embeddings: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L1328)

**Tham số:**

loss (`torch.Tensor` có hình dạng `(1,)`, *tùy chọn*, được trả về khi `labels` được cung cấp) : Tổn phân loại.

logits (`torch.Tensor` có shape `(batch_size, config.xvector_output_dim)`) : Trạng thái ẩn phân loại trước AMSoftmax.

embeddings (`torch.Tensor` có hình dạng `(batch_size, config.xvector_output_dim)`) : Các embedding câu nói được sử dụng cho việc truy xuất dựa trên độ tương tự vector.

hidden_states (`tuple(torch.Tensor)`, *tùy chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) : Tuple của `torch.Tensor` (một cho đầu ra của embeddings + một cho đầu ra của mỗi lớp) có hình dạng `(batch_size, sequence_length, hidden_size)`.  Hidden-states của mô hình tại đầu ra của mỗi lớp cùng với đầu ra embedding ban đầu.

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`) : 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 chú ý, được sử dụng để tính trung bình có trọng số trong các đầu chú ý tự (self-attention heads).

Loại đầu ra của [Wav2Vec2ForXVector](/docs/transformers/main/vi/model_doc/wav2vec2#transformers.Wav2Vec2ForXVector).

## Seq2SeqTSModelOutput[[transformers.modeling_outputs.Seq2SeqTSModelOutput]]

#### transformers.modeling_outputs.Seq2SeqTSModelOutput[[transformers.modeling_outputs.Seq2SeqTSModelOutput]]

```python
transformers.modeling_outputs.Seq2SeqTSModelOutput(last_hidden_state: typing.Optional[torch.Tensor] = None, cache: transformers.cache_utils.EncoderDecoderCache | None = None, decoder_hidden_states: tuple[torch.Tensor, ...] | None = None, decoder_attentions: tuple[torch.Tensor, ...] | None = None, cross_attentions: tuple[torch.Tensor, ...] | None = None, encoder_last_hidden_state: typing.Optional[torch.Tensor] = None, encoder_hidden_states: tuple[torch.Tensor, ...] | None = None, encoder_attentions: tuple[torch.Tensor, ...] | None = None, loc: typing.Optional[torch.Tensor] = None, scale: typing.Optional[torch.Tensor] = None, static_features: typing.Optional[torch.Tensor] = None)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L1482)

**Tham số:**

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 bộ giải mã của mô hình. Nếu `cache` được sử dụng, chỉ có hidden-state cuối cùng của các chuỗi với hình dạng `(batch_size, 1, hidden_size)` được đưa ra.

cache (`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/main/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 toán trước (key và values trong các khối self-attention và cross-attention) có thể được sử dụng (xem đầu vào `cache`) để tăng tốc độ giải mã tuần tự.

decoder_hidden_states (`tuple(torch.Tensor)`, *tùy chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) : Tuple của `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)`.  Hidden-states của decoder 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.

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

cross_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`) : 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 decoder, sau softmax chú ý, được sử dụng để tính trung bình có trọng số trong các đầu chú ý cross-attention.

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 hidden-states tại đầu ra của lớp cuối cùng của encoder trong mô hình.

encoder_hidden_states (`tuple(torch.Tensor)`, *tùy chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) : Tuple của `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)`.  Hidden-states của encoder 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.

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`) : 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ự (self-attention).

loc (`torch.Tensor` có shape `(batch_size,)` hoặc `(batch_size, input_size)`, *tuỳ chọn*) : Các giá trị dịch chuyển của cửa sổ ngữ cảnh cho mỗi chuỗi thời gian, được dùng để cung cấp cho mô hình các đầu vào có cùng độ lớn, sau đó dùng để dịch chuyển ngược lại về độ lớn ban đầu.

scale (`torch.Tensor` có shape `(batch_size,)` hoặc `(batch_size, input_size)`, *tuỳ chọn*) : Các giá trị scale của context window cho mỗi chuỗi thời gian, được dùng để đưa đầu vào của mô hình về cùng một bậc độ lớn, sau đó dùng để scale ngược lại về độ lớn gốc.

static_features (`torch.Tensor` có shape `(batch_size, feature size)`, *tùy chọn*) : Các đặc trưng tĩnh của mỗi chuỗi thời gian trong một batch, được sao chép sang các biến ngoại sinh (covariates) tại thời điểm suy luận.

Lớp cơ sở cho đầu ra của bộ mã hóa mô hình chuỗi thời gian, đồng thời chứa các trạng thái ẩn đã được tính trước, có thể tăng tốc độ giải mã tuần tự.

## Seq2SeqTSPredictionOutput[[transformers.modeling_outputs.Seq2SeqTSPredictionOutput]]

#### transformers.modeling_outputs.Seq2SeqTSPredictionOutput[[transformers.modeling_outputs.Seq2SeqTSPredictionOutput]]

```python
transformers.modeling_outputs.Seq2SeqTSPredictionOutput(loss: typing.Optional[torch.Tensor] = None, params: tuple[torch.Tensor, ...] | None = None, cache: transformers.cache_utils.EncoderDecoderCache | None = None, decoder_hidden_states: tuple[torch.Tensor, ...] | None = None, decoder_attentions: tuple[torch.Tensor, ...] | None = None, cross_attentions: tuple[torch.Tensor, ...] | None = None, encoder_last_hidden_state: typing.Optional[torch.Tensor] = None, encoder_hidden_states: tuple[torch.Tensor, ...] | None = None, encoder_attentions: tuple[torch.Tensor, ...] | None = None, loc: typing.Optional[torch.Tensor] = None, scale: typing.Optional[torch.Tensor] = None, static_features: typing.Optional[torch.Tensor] = None)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L1552)

**Tham số:**

loss (`torch.Tensor` có hình dạng `(1,)`, *tùy chọn*, được trả về khi cung cấp `future_values`) : Tổn phân phối.

params (`torch.Tensor` có hình dạng `(batch_size, num_samples, num_params)`) : Tham số của phân phối được chọn.

cache (`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/main/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 toán trước (key và values trong các khối self-attention và cross-attention) có thể được sử dụng (xem đầu vào `cache`) để tăng tốc độ giải mã tuần tự.

decoder_hidden_states (`tuple(torch.Tensor)`, *tùy chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) : Tuple của `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)`.  Hidden-states của decoder tại đầu ra của mỗi lớp cùng với đầu ra embedding 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`) : 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).

cross_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`) : 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 decoder, sau softmax chú ý, được sử dụng để tính trung bình có trọng số trong các đầu chú ý cross-attention.

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 hidden-states tại đầu ra của lớp cuối cùng của encoder trong mô hình.

encoder_hidden_states (`tuple(torch.Tensor)`, *tùy 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 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 (hidden-states) của encoder tại đầu ra của mỗi lớp cùng với đầu ra embedding 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`) : 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ự (self-attention).

loc (`torch.Tensor` có shape `(batch_size,)` hoặc `(batch_size, input_size)`, *tuỳ chọn*) : Các giá trị dịch chuyển của cửa sổ ngữ cảnh cho mỗi chuỗi thời gian, được dùng để cung cấp cho mô hình các đầu vào có cùng độ lớn, sau đó dùng để dịch chuyển ngược lại về độ lớn ban đầu.

scale (`torch.Tensor` có shape `(batch_size,)` hoặc `(batch_size, input_size)`, *tuỳ chọn*) : Các giá trị scale của context window cho mỗi chuỗi thời gian, được dùng để đưa đầu vào của mô hình về cùng một bậc độ lớn, sau đó dùng để scale ngược lại về độ lớn gốc.

static_features (`torch.Tensor` có shape `(batch_size, feature size)`, *tùy chọn*) : Các đặc trưng tĩnh của mỗi chuỗi thời gian trong một batch, được sao chép sang các biến ngoại sinh (covariates) tại thời điểm suy luận.

Lớp cơ sở cho đầu ra của bộ giải mã mô hình chuỗi thời gian, bao gồm cả tổn thất và các tham số của phân phối được chọn.

## SampleTSPredictionOutput[[transformers.modeling_outputs.SampleTSPredictionOutput]]

#### transformers.modeling_outputs.SampleTSPredictionOutput[[transformers.modeling_outputs.SampleTSPredictionOutput]]

```python
transformers.modeling_outputs.SampleTSPredictionOutput(sequences: typing.Optional[torch.Tensor] = None)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L1622)

**Tham số:**

sequences (`torch.Tensor` có hình dạng `(batch_size, num_samples, prediction_length)` hoặc `(batch_size, num_samples, prediction_length, input_size)`) : Các giá trị được lấy mẫu từ phân phối đã chọn.

Lớp cơ sở cho đầu ra dự đoán của mô hình chuỗi thời gian, chứa các giá trị được lấy mẫu từ phân phối đã chọn.