# Perceiver
## Tổng quan
Mô hình Perceiver IO được đề xuất trong [Perceiver IO: A General Architecture for Structured Inputs & Outputs](https://huggingface.co/papers/2107.14795) bởi Andrew Jaegle, Sebastian Borgeaud, Jean-Baptiste Alayrac, Carl Doersch, Catalin Ionescu, David Ding, Skanda Koppula, Daniel Zoran, Andrew Brock, Evan Shelhamer, Olivier Hénaff, Matthew M. Botvinick, Andrew Zisserman, Oriol Vinyals, João Carreira.
Perceiver IO là một sự tổng quát hóa của [Perceiver](https://huggingface.co/papers/2103.03206) để xử lý các đầu ra tùy ý bên cạnh các đầu vào tùy ý. Perceiver ban đầu chỉ tạo ra một nhãn phân loại duy nhất. Ngoài các nhãn phân loại, Perceiver IO có thể tạo ra (ví dụ) ngôn ngữ, optical flow, và video đa phương thức có âm thanh. Điều này được thực hiện bằng cách sử dụng các khối xây dựng giống hệt với Perceiver ban đầu. Độ phức tạp tính toán của Perceiver IO là tuyến tính theo kích thước đầu vào và đầu ra, và phần lớn quá trình xử lý diễn ra trong không gian tiềm ẩn, cho phép chúng ta xử lý các đầu vào và đầu ra lớn hơn nhiều so với những gì có thể được xử lý bởi các Transformers tiêu chuẩn. Điều này có nghĩa là, ví dụ, Perceiver IO có thể thực hiện mô hình hóa ngôn ngữ bị che kiểu BERT trực tiếp bằng cách sử dụng các byte thay vì các đầu vào đã được token hóa.
Tóm tắt từ bài báo như sau:
*Mô hình Perceiver mới được đề xuất đạt được kết quả tốt trên nhiều lĩnh vực (ảnh, âm thanh, đa phương thức, đám mây điểm) trong khi mở rộng tuyến tính về tính toán và bộ nhớ theo kích thước đầu vào. Mặc dù Perceiver hỗ trợ nhiều loại đầu vào, nó chỉ có thể tạo ra các đầu vào rất đơn giản như điểm phân loại. Perceiver IO khắc phục hạn chế này mà không hy sinh các thuộc tính hấp dẫn của bản gốc bằng cách học cách truy vấn linh hoạt không gian ẩn của mô hình để tạo ra các đầu ra có kích thước và ngữ nghĩa tùy ý. Perceiver IO vẫn tách biệt độ sâu của mô hình khỏi kích thước dữ liệu và vẫn mở rộng tuyến tính theo kích thước dữ liệu, nhưng giờ đây là theo cả kích thước đầu vào và đầu ra. Mô hình Perceiver IO hoàn chỉnh đạt được kết quả mạnh mẽ trên các tác vụ có không gian đầu ra có cấu trúc cao, chẳng hạn như ngôn ngữ tự nhiên và hiểu thị giác, StarCraft II, và các lĩnh vực đa tác vụ và đa phương thức. Điểm nổi bật, Perceiver IO sánh ngang với đường cơ sở BERT dựa trên Transformer trên bộ chuẩn ngôn ngữ GLUE mà không cần phân tách token đầu vào và đạt hiệu suất tiên tiến trong ước lượng dòng quang Sintel.*
Dưới đây là bản tóm tắt ngắn gọn giải thích cách Perceiver hoạt động:
Vấn đề chính của cơ chế self-attention trong Transformer là yêu cầu về thời gian và bộ nhớ tăng theo bậc hai với độ dài chuỗi. Do đó, các mô hình như BERT và RoBERTa bị giới hạn ở độ dài chuỗi tối đa là 512 token. Perceiver hướng đến việc giải quyết vấn đề này bằng cách, thay vì thực hiện self-attention trên các đầu vào, thực hiện nó trên một tập các biến ẩn, và chỉ sử dụng các đầu vào cho cross-attention. Bằng cách này, yêu cầu về thời gian và bộ nhớ không còn phụ thuộc vào độ dài của các đầu vào nữa, vì người ta sử dụng một lượng cố định các biến ẩn, chẳng hạn như 256 hoặc 512. Các biến này được khởi tạo ngẫu nhiên, sau đó được huấn luyện end-to-end bằng backpropagation.
Bên trong, [PerceiverModel](/docs/transformers/main/vi/model_doc/perceiver#transformers.PerceiverModel) sẽ tạo ra các latents, là một tensor có hình dạng `(batch_size, num_latents, d_latents)`. Người dùng phải cung cấp `inputs` (có thể là văn bản, hình ảnh, âm thanh, bất cứ thứ gì bạn nghĩ đến!) cho mô hình, và mô hình sẽ sử dụng chúng để thực hiện cross-attention với các latents. Đầu ra của bộ mã hóa Perceiver là một tensor có cùng hình dạng. Sau đó, tương tự như BERT, ta có thể chuyển đổi các trạng thái ẩn cuối cùng của các latents thành các logits phân loại bằng cách lấy trung bình dọc theo chiều sequence, và đặt một lớp tuyến tính phía trên để chiếu `d_latents` sang `num_labels`.
Đây là ý tưởng của bài báo Perceiver ban đầu. Tuy nhiên, nó chỉ có thể xuất ra các logits phân loại. Trong một công trình tiếp theo, PerceiverIO, họ đã tổng quát hóa nó để cho phép mô hình cũng tạo ra các đầu ra có kích thước tùy ý. Bạn có thể tự hỏi làm thế nào? Ý tưởng thực ra khá đơn giản: ta định nghĩa các đầu ra có kích thước tùy ý, sau đó áp dụng cross-attention với các trạng thái ẩn cuối cùng của các latent, sử dụng các đầu ra làm queries, và các latent làm keys và values.
Giả sử một người muốn thực hiện mô hình hóa ngôn ngữ có che (masked language modeling, theo phong cách BERT) với Perceiver. Vì độ dài đầu vào của Perceiver sẽ không ảnh hưởng đến thời gian tính toán của các lớp self-attention, người đó có thể cung cấp các byte thô, bằng cách đưa vào mô hình `inputs` có độ dài 2048. Nếu bây giờ che đi một số trong 2048 token này, người ta có thể định nghĩa `outputs` có hình dạng: `(batch_size, 2048, 768)`. Tiếp theo, thực hiện cross-attention với các trạng thái ẩn cuối cùng của các latent để cập nhật tensor `outputs`. Sau cross-attention, vẫn có một tensor có hình dạng `(batch_size, 2048, 768)`. Sau đó, có thể đặt một đầu ngôn ngữ thông thường (regular language modeling head) lên trên, để chiếu chiều cuối cùng xuống kích thước từ điển của mô hình, tức là tạo ra các logits có hình dạng `(batch_size, 2048, 262)` (vì Perceiver sử dụng kích thước từ điển là 262 byte IDs).
Kiến trúc Perceiver IO. Được trích từ bài báo gốc
Mô hình này được đóng góp bởi [nielsr](https://huggingface.co/nielsr). Mã gốc có thể được tìm thấy [tại đây](https://github.com/deepmind/deepmind-research/tree/master/perceiver).
Perceiver **không** hoạt động với `torch.nn.DataParallel` do một lỗi trong PyTorch, xem [issue #36035](https://github.com/pytorch/pytorch/issues/36035)
## Tài nguyên
- Cách nhanh nhất để bắt đầu với Perceiver là xem các [notebook hướng dẫn](https://github.com/NielsRogge/Transformers-Tutorials/tree/master/Perceiver).
- Tham khảo [bài đăng trên blog](https://huggingface.co/blog/perceiver) nếu bạn muốn hiểu đầy đủ cách hoạt động của mô hình và
được triển khai trong thư viện. Lưu ý rằng các mô hình có sẵn trong thư viện chỉ minh họa một số ví dụ về những gì bạn có thể làm với Perceiver. Có rất nhiều trường hợp sử dụng khác, bao gồm trả lời câu hỏi, nhận thực thể có tên, phát hiện đối tượng, phân loại âm thanh, phân loại video, v.v.
- [Hướng dẫn cho tác vụ phân loại văn bản](../tasks/sequence_classification)
- [Hướng dẫn cho tác vụ mô hình hóa ngôn ngữ có mặt nạ](../tasks/masked_language_modeling)
- [Hướng dẫn tác vụ phân loại hình ảnh](../tasks/image_classification)
## Đầu ra cụ thể của Perceiver[[transformers.models.perceiver.modeling_perceiver.PerceiverModelOutput]]
#### transformers.models.perceiver.modeling_perceiver.PerceiverModelOutput[[transformers.models.perceiver.modeling_perceiver.PerceiverModelOutput]]
```python
transformers.models.perceiver.modeling_perceiver.PerceiverModelOutput(logits: typing.Optional[torch.Tensor] = None, 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/models/perceiver/modeling_perceiver.py#L53)
**Tham số:**
logits (`torch.Tensor` có shape `(batch_size, num_labels)`) : Điểm phân loại (hoặc hồi quy nếu config.num_labels==1) (trước SoftMax).
last_hidden_state (`torch.Tensor` có shape `(batch_size, sequence_length, hidden_size)`, *tùy chọn*) : Chuỗi hidden-states tại đầu ra của lớp cuối cùng của model.
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, sequence_length, hidden_size)`. 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, 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).
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 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ú ý cross-attention.
Lớp cơ sở cho đầu ra của mô hình Perceiver cơ sở, với các trạng thái ẩn, chú ý và chú ý chéo tiềm năng.
#### transformers.models.perceiver.modeling_perceiver.PerceiverDecoderOutput[[transformers.models.perceiver.modeling_perceiver.PerceiverDecoderOutput]]
```python
transformers.models.perceiver.modeling_perceiver.PerceiverDecoderOutput(logits: typing.Optional[torch.Tensor] = None, cross_attentions: tuple[torch.Tensor] | None = None)
```
[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L72)
**Tham số:**
logits (`torch.Tensor` có hình dạng `(batch_size, num_labels)`) : Đầu ra của bộ giải mã cơ bản.
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 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ú ý cross-attention.
Lớp cơ sở cho đầu ra của bộ giải mã Perceiver, với các cross-attention tiềm năng.
#### transformers.models.perceiver.modeling_perceiver.PerceiverMaskedLMOutput[[transformers.models.perceiver.modeling_perceiver.PerceiverMaskedLMOutput]]
```python
transformers.models.perceiver.modeling_perceiver.PerceiverMaskedLMOutput(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, cross_attentions: tuple[torch.Tensor] | None = None)
```
[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L88)
**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 model có lớp embedding, + một cho đầu ra của mỗi lớp) có shape `(batch_size, sequence_length, hidden_size)`. 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, 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).
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 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ú ý cross-attention.
Lớp cơ sở cho kết quả mô hình ngôn ngữ có che mặt của Perceiver.
#### transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput[[transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput]]
```python
transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput(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, cross_attentions: tuple[torch.Tensor] | None = None)
```
[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L110)
**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 model có lớp embedding, + một cho đầu ra của mỗi lớp) có shape `(batch_size, sequence_length, hidden_size)`. 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, 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).
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 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ú ý cross-attention.
Lớp cơ sở cho đầu ra của Perceiver trong các mô hình phân loại chuỗi/ảnh, luồng quang học và tự mã hóa đa phương tiện.
## PerceiverConfig[[transformers.PerceiverConfig]]
#### transformers.PerceiverConfig[[transformers.PerceiverConfig]]
```python
transformers.PerceiverConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, num_latents: int = 256, d_latents: int = 1280, d_model: int = 768, num_blocks: int = 1, num_self_attends_per_block: int = 26, num_self_attention_heads: int = 8, num_cross_attention_heads: int = 8, qk_channels: int | None = None, v_channels: int | None = None, cross_attention_shape_for_attention: str = 'kv', self_attention_widening_factor: int = 1, cross_attention_widening_factor: int = 1, hidden_act: str = 'gelu', attention_probs_dropout_prob: float | int = 0.1, initializer_range: float = 0.02, layer_norm_eps: float = 1e-12, use_query_residual: bool = True, vocab_size: int = 262, max_position_embeddings: int = 2048, image_size: int | list[int] | tuple[int, int] = 56, train_size: list[int] | tuple[int, ...] = (368, 496), num_frames: int = 16, audio_samples_per_frame: int = 1920, samples_per_patch: int = 16, output_shape: list[int] | tuple[int, ...] = (1, 16, 224, 224), output_num_channels: int = 512, _label_trainable_num_channels: int = 1024)
```
[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/configuration_perceiver.py#L24)
**Tham số:**
num_latents (`int`, *tùy chọn*, mặc định là 256) : Số lượng latents.
d_latents (`int`, *tuỳ chọn*, mặc định là 1280) : Kích thước của các embedding tiềm ẩn.
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.
num_blocks (`int`, *tuỳ chọn*, mặc định là 1) : Số lượng khối trong bộ mã hóa Transformer.
num_self_attends_per_block (`int`, *tuỳ chọn*, mặc định là 26) : Số lượng lớp self-attention trong mỗi khối.
num_self_attention_heads (`int`, *tuỳ chọn*, mặc định là 8) : Số lượng đầu chú ý cho mỗi lớp tự chú ý trong bộ mã hóa Transformer.
num_cross_attention_heads (`int`, *tuỳ chọn*, mặc định là 8) : Số lượng đầu chú ý cho mỗi lớp cross-attention trong bộ mã hóa Transformer.
qk_channels (`int`, *optional*) : Kích thước để chiếu các truy vấn + khóa trước khi áp dụng chú ý trong các lớp chú ý chéo và chú ý tự của bộ mã hóa. Nếu không được chỉ định, mặc định sẽ giữ nguyên kích thước của các truy vấn.
v_channels (`int`, *optional*) : Kích thước để chiếu các giá trị trước khi áp dụng attention trong các lớp cross-attention và self-attention của encoder. Nếu không được chỉ định, mặc định sẽ giữ nguyên kích thước của các truy vấn.
cross_attention_shape_for_attention (`str`, *tùy chọn*, mặc định là `"kv"`) : Chiều cần sử dụng khi giảm mẫu (downsampling) các truy vấn (queries) và khóa (keys) trong lớp cross-attention của encoder.
self_attention_widening_factor (`int`, *optional*, mặc định là 1) : Kích thước của lớp feed-forward trong lớp cross-attention của bộ mã hóa Transformer.
cross_attention_widening_factor (`int`, *tuỳ chọn*, mặc định là 1) : Kích thước của lớp feed-forward trong các lớp self-attention của bộ mã hóa Transformer.
hidden_act (`str`, *tùy chọn*, mặc định là `gelu`) : Hàm kích hoạt phi tuyến (hàm hoặc chuỗi) trong bộ giải mã. Ví dụ, `"gelu"`, `"relu"`, `"silu"`, v.v.
attention_probs_dropout_prob (`Union[float, int]`, *tùy chọn*, mặc định là `0.1`) : Tỷ lệ dropout cho các xác suất chú ý.
initializer_range (`float`, *optional*, mặc định là `0.02`) : Độ lệch chuẩn của truncated_normal_initializer để khởi tạo tất cả các ma trận trọng số.
layer_norm_eps (`float`, *tuỳ chọn*, mặc định là `1e-12`) : Epsilon được sử dụng bởi các lớp chuẩn hóa lớp (layer normalization).
use_query_residual (`float`, *optional*, mặc định là `True`) : Xác định có thêm phần dư truy vấn (query residual) vào lớp cross-attention của encoder hay không.
vocab_size (`int`, *tùy chọn*, mặc định là `262`) : 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`.
max_position_embeddings (`int`, *tuỳ chọn*, mặc định là `2048`) : Độ dài chuỗi tối đa mà mô hình này có thể được sử dụng.
image_size (`int`, *tuỳ chọn*, mặc định là 56) : Kích thước của các hình ảnh sau khi tiền xử lý, dành cho [PerceiverForImageClassificationLearned](/docs/transformers/main/vi/model_doc/perceiver#transformers.PerceiverForImageClassificationLearned).
train_size (`list[int]`, *tùy chọn*, mặc định là `[368, 496]`) : Kích thước ảnh khi huấn luyện cho mô hình dòng quang học.
num_frames (`int`, *tuỳ chọn*, mặc định là 16) : Số khung hình video được sử dụng cho mô hình tự mã hóa đa phương thức.
audio_samples_per_frame (`int`, *tuỳ chọn*, mặc định là 1920) : Số lượng mẫu âm thanh trên mỗi khung hình cho mô hình tự mã hóa đa phương thức.
samples_per_patch (`int`, *tuỳ chọn*, mặc định là 16) : Số lượng mẫu âm thanh trên mỗi patch khi tiền xử lý âm thanh cho mô hình tự mã hóa đa phương thức.
output_shape (`list[int]`, *optional*, mặc định là `[1, 16, 224, 224]`) : Hình dạng của đầu ra (batch_size, num_frames, height, width) cho các truy vấn bộ giải mã video của mô hình tự mã hóa đa phương tiện. Điều này không bao gồm chiều kênh.
output_num_channels (`int`, *optional*, mặc định là 512) : Số lượng kênh đầu ra cho mỗi bộ giải mã modalitiy.
Đây là lớp cấu hình để lưu trữ cấu hình của một PerceiverModel. Nó được sử dụng để khởi tạo một mô hình Perceiver 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 [deepmind/language-perceiver](https://huggingface.co/deepmind/language-perceiver)
Các đối tượng cấu hình kế thừa từ [PreTrainedConfig](/docs/transformers/main/vi/main_classes/configuration#transformers.PreTrainedConfig) và có thể được sử dụng để kiểm soát đầu ra của mô hình. Đọc tài liệu từ [PreTrainedConfig](/docs/transformers/main/vi/main_classes/configuration#transformers.PreTrainedConfig) để biết thêm thông tin.
Ví dụ:
```python
>>> from transformers import PerceiverModel, PerceiverConfig
>>> # Initializing a Perceiver deepmind/language-perceiver style configuration
>>> configuration = PerceiverConfig()
>>> # Initializing a model from the deepmind/language-perceiver style configuration
>>> model = PerceiverModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
```
## PerceiverTokenizer[[transformers.PerceiverTokenizer]]
#### transformers.PerceiverTokenizer[[transformers.PerceiverTokenizer]]
```python
transformers.PerceiverTokenizer(pad_token = '[PAD]', bos_token = '[BOS]', eos_token = '[EOS]', mask_token = '[MASK]', cls_token = '[CLS]', sep_token = '[SEP]', model_max_length = 2048, **kwargs)
```
[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/tokenization_perceiver.py#L23)
**Tham số:**
pad_token (`str`, *tùy chọn*, mặc định là `"[PAD]"`) : Token được sử dụng để đệm, chẳng hạn khi xử lý các lô (batch) các chuỗi có độ dài khác nhau.
bos_token (`str`, *tùy chọn*, mặc định là `"[BOS]"`) : Token BOS (được dành sẵn trong bảng từ vựng, nhưng thực tế không được sử dụng).
eos_token (`str`, *tùy chọn*, mặc định là `"[EOS]"`) : Token kết thúc chuỗi (được dành sẵn trong bảng từ vựng, nhưng thực tế không được sử dụng). Khi xây dựng một chuỗi bằng các token đặc biệt, đây không phải là token được dùng cho việc kết thúc chuỗi. Token được sử dụng là `sep_token`.
mask_token (`str`, *tùy chọn*, mặc định là `"[MASK]"`) : Token MASK, hữu ích cho mô hình hóa ngôn ngữ có che (masked language modeling).
cls_token (`str`, *tùy chọn*, mặc định là `"[CLS]"`) : Token CLS (được dành sẵn trong bảng từ vựng, nhưng thực tế không được sử dụng).
sep_token (`str`, *tùy chọn*, mặc định là `"[SEP]"`) : Token phân cách, được sử dụng khi xây dựng một chuỗi từ hai chuỗi.
Xây dựng một bộ mã hóa Perceiver. Perceiver đơn giản chỉ sử dụng mã hóa utf-8 của các byte thô.
Tokenizer này kế thừa từ [PreTrainedTokenizer](/docs/transformers/main/vi/main_classes/tokenizer#transformers.PythonBackend), lớp chứa hầu hết các phương thức chính. Người dùng nên tham khảo siêu lớp này để biết thêm thông tin về các phương thức đó.
#### __call__[[transformers.PerceiverTokenizer.__call__]]
```python
__call__(text: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None, text_pair: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None, text_target: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None, text_pair_target: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None, add_special_tokens: bool = True, padding: bool | str | PaddingStrategy = False, truncation: bool | str | TruncationStrategy | None = None, max_length: int | None = None, stride: int = 0, is_split_into_words: bool = False, pad_to_multiple_of: int | None = None, padding_side: str | None = None, return_tensors: str | TensorType | None = None, return_token_type_ids: bool | None = None, return_attention_mask: bool | None = None, return_overflowing_tokens: bool = False, return_special_tokens_mask: bool = False, return_offsets_mapping: bool = False, return_length: bool = False, verbose: bool = True, tokenizer_kwargs: dict[str, Any] | None = None, **kwargs)
```
[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_base.py#L2449)
**Tham số:**
text (`str`, `list[str]`, `list[list[str]]`, *tuỳ chọn*) : Chuỗi hoặc lô các chuỗi cần được mã hóa. Mỗi chuỗi có thể là một chuỗi ký tự hoặc một danh sách các chuỗi ký tự (chuỗi đã được tách token trước). Nếu các chuỗi được cung cấp dưới dạng danh sách các chuỗi ký tự (đã tách token trước), bạn phải đặt `is_split_into_words=True` (để loại bỏ sự mơ hồ với một lô các chuỗi).
text_pair (`str`, `list[str]`, `list[list[str]]`, *tuỳ chọn*) : Chuỗi hoặc lô các chuỗi cần được mã hóa. Mỗi chuỗi có thể là một chuỗi ký tự hoặc một danh sách các chuỗi ký tự (chuỗi đã được tách token trước). Nếu các chuỗi được cung cấp dưới dạng danh sách các chuỗi ký tự (đã tách token trước), bạn phải đặt `is_split_into_words=True` (để loại bỏ sự mơ hồ với một lô các chuỗi).
text_target (`str`, `list[str]`, `list[list[str]]`, *tuỳ chọn*) : Chuỗi hoặc lô các chuỗi cần được mã hóa dưới dạng văn bản đích. Mỗi chuỗi có thể là một chuỗi ký tự hoặc một danh sách các chuỗi ký tự (chuỗi đã được tách token trước). Nếu các chuỗi được cung cấp dưới dạng danh sách các chuỗi ký tự (đã tách token trước), bạn phải đặt `is_split_into_words=True` (để loại bỏ sự mơ hồ với một lô các chuỗi).
text_pair_target (`str`, `list[str]`, `list[list[str]]`, *tuỳ chọn*) : Chuỗi hoặc lô các chuỗi cần được mã hóa dưới dạng văn bản đích. Mỗi chuỗi có thể là một chuỗi ký tự hoặc một danh sách các chuỗi ký tự (chuỗi đã được tách token trước). Nếu các chuỗi được cung cấp dưới dạng danh sách các chuỗi ký tự (đã tách token trước), bạn phải đặt `is_split_into_words=True` (để loại bỏ sự mơ hồ với một lô các chuỗi).
tokenizer_kwargs (`dict[str, Any]`, *tùy chọn*) : Các kwargs bổ sung để truyền cho tokenizer. Chúng sẽ được gộp với các tham số tường minh và các kwargs khác, trong đó các tham số tường minh có độ ưu tiên cao hơn.
add_special_tokens (`bool`, *tùy chọn*, mặc định là `True`) : Có thêm các token đặc biệt khi mã hóa các chuỗi hay không. Điều này sẽ sử dụng hàm `PretrainedTokenizerBase.build_inputs_with_special_tokens` bên dưới, hàm này xác định các token nào được thêm tự động vào các id đầu vào. Điều này hữu ích nếu bạn muốn tự động thêm các token `bos` hoặc `eos`.
padding (`bool`, `str` hoặc [PaddingStrategy](/docs/transformers/main/vi/internal/file_utils#transformers.utils.PaddingStrategy), *tuỳ chọn*, mặc định là `False`) : Kích hoạt và kiểm soát việc đệm. Chấp nhận các giá trị sau: - `True` hoặc `'longest'`: Đệm đến độ dài của chuỗi dài nhất trong lô (hoặc không đệm nếu chỉ cung cấp một chuỗi duy nhất). - `'max_length'`: Đệm đến độ dài tối đa được chỉ định bằng tham số `max_length` hoặc đến độ dài đầu vào tối đa mà mô hình chấp nhận được nếu tham số đó không được cung cấp. - `False` hoặc `'do_not_pad'` (mặc định): Không đệm (tức là có thể xuất ra một lô với các chuỗi có độ dài khác nhau).
truncation (`bool`, `str` hoặc [TruncationStrategy](/docs/transformers/main/vi/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy), *optional*, mặc định là `False`) : Kích hoạt và kiểm soát việc cắt ngắn. Chấp nhận các giá trị sau: - `True` hoặc `'longest_first'`: Cắt ngắn đến độ dài tối đa được chỉ định bằng tham số `max_length` hoặc đến độ dài đầu vào tối đa mà mô hình chấp nhận được nếu tham số đó không được cung cấp. Thao tác này sẽ cắt ngắn theo từng token, loại bỏ một token từ chuỗi dài nhất trong cặp nếu một cặp chuỗi (hoặc một batch các cặp) được cung cấp. - `'only_first'`: Cắt ngắn đến độ dài tối đa được chỉ định bằng tham số `max_length` hoặc đến độ dài đầu vào tối đa mà mô hình chấp nhận được nếu tham số đó không được cung cấp. Thao tác này chỉ cắt ngắn chuỗi đầu tiên của một cặp nếu một cặp chuỗi (hoặc một batch các cặp) được cung cấp. - `'only_second'`: Cắt ngắn đến độ dài tối đa được chỉ định bằng tham số `max_length` hoặc đến độ dài đầu vào tối đa mà mô hình chấp nhận được nếu tham số đó không được cung cấp. Thao tác này chỉ cắt ngắn chuỗi thứ hai của một cặp nếu một cặp chuỗi (hoặc một batch các cặp) được cung cấp. - `False` hoặc `'do_not_truncate'` (mặc định): Không cắt ngắn (tức là có thể xuất ra batch với độ dài chuỗi lớn hơn kích thước đầu vào tối đa được phép của mô hình).
max_length (`int`, *optional*) : Kiểm soát độ dài tối đa được sử dụng bởi một trong các tham số cắt/giữ chỗ. Nếu không được đặt hoặc được đặt thành `None`, tham số này sẽ sử dụng độ dài tối đa định trước của mô hình nếu một trong các tham số cắt/giữ chỗ yêu cầu độ dài tối đa. Nếu mô hình không có độ dài đầu vào tối đa cụ thể (như XLNet), việc cắt/giữ chỗ đến độ dài tối đa sẽ bị vô hiệu hóa.
stride (`int`, *optional*, mặc định là 0) : Nếu được đặt thành một số cùng với `max_length`, các token tràn được trả về khi `return_overflowing_tokens=True` sẽ chứa một số token từ cuối của chuỗi bị cắt ngắn được trả về để tạo ra một phần chồng lấn giữa các chuỗi bị cắt ngắn và các chuỗi tràn. Giá trị của đối số này xác định số lượng token chồng lấn.
is_split_into_words (`bool`, *tùy chọn*, mặc định là `False`) : Xác định xem đầu vào đã được tiền xử lý token hay chưa (ví dụ: đã được tách thành các từ). Nếu đặt thành `True`, bộ phân từ sẽ giả định rằng đầu vào đã được tách thành các từ (chẳng hạn, bằng cách tách theo khoảng trắng) và sẽ tiến hành phân từ chúng. Điều này hữu ích cho NER hoặc phân loại token.
pad_to_multiple_of (`int`, *optional*) : Nếu được đặt, sẽ đệm (pad) chuỗi đến một bội số của giá trị được cung cấp. Yêu cầu `padding` phải được kích hoạt. Điều này đặc biệt hữu ích để cho phép sử dụng Tensor Cores trên phần cứng NVIDIA có khả năng tính toán `>= 7.5` (Volta).
padding_side (`str`, *tùy chọn*) : Bên mà mô hình cần được áp dụng padding. Nên chọn trong ['right', 'left']. Giá trị mặc định được lấy từ thuộc tính lớp có cùng tên.
return_tensors (`str` hoặc [TensorType](/docs/transformers/main/vi/internal/file_utils#transformers.TensorType), *optional*) : Nếu được đặt, sẽ trả về các tensor thay vì danh sách các số nguyên python. Các giá trị chấp nhận được là: - `'pt'`: Trả về các đối tượng `torch.Tensor` của PyTorch. - `'np'`: Trả về các đối tượng `np.ndarray` của Numpy.
return_token_type_ids (`bool`, *tuỳ chọn*) : Có trả về các ID loại token hay không. Nếu để mặc định, sẽ trả về các ID loại token theo mặc định của bộ phân tích token cụ thể, được định nghĩa bởi thuộc tính `return_outputs`. [ID loại token là gì?](../glossary#token-type-ids)
return_attention_mask (`bool`, *tuỳ chọn*) : Có trả về attention mask hay không. Nếu để mặc định, sẽ trả về attention mask theo mặc định của tokenizer cụ thể, được định nghĩa bởi thuộc tính `return_outputs`. [Attention mask là gì?](../glossary#attention-mask)
return_overflowing_tokens (`bool`, *tùy chọn*, mặc định là `False`) : Có trả về các chuỗi token bị tràn hay không. Nếu một cặp chuỗi id đầu vào (hoặc một lô các cặp) được cung cấp với `truncation_strategy = longest_first` hoặc `True`, một lỗi sẽ được ném thay vì trả về các token bị tràn.
return_special_tokens_mask (`bool`, *tùy chọn*, mặc định là `False`) : Có trả về thông tin mặt nạ token đặc biệt hay không.
return_offsets_mapping (`bool`, *tùy chọn*, mặc định là `False`) : Có nên trả về `(char_start, char_end)` cho từng token hay không. Tính năng này chỉ khả dụng trên các fast tokenizer kế thừa từ [PreTrainedTokenizerFast](/docs/transformers/main/vi/main_classes/tokenizer#transformers.TokenizersBackend); nếu sử dụng tokenizer của Python, phương thức này sẽ gây ra `NotImplementedError`.
return_length (`bool`, *tùy chọn*, mặc định là `False`) : Có trả về độ dài của các đầu vào đã mã hóa hay không.
verbose (`bool`, *tùy chọn*, mặc định là `True`) : Có in thêm thông tin và cảnh báo hay không.
- ****kwargs** : được truyền vào phương thức `self.tokenize()`
**Trả về:** [BatchEncoding](/docs/transformers/main/vi/main_classes/tokenizer#transformers.BatchEncoding)
Một [BatchEncoding](/docs/transformers/main/vi/main_classes/tokenizer#transformers.BatchEncoding) với các trường sau:
- **input_ids** -- Danh sách các id token để đưa vào mô hình.
[ID đầu vào là gì?](../glossary#input-ids)
- **token_type_ids** -- Danh sách các id loại token để đưa vào mô hình (khi `return_token_type_ids=True` hoặc nếu *"token_type_ids"* nằm trong `self.model_input_names`).
[ID loại token là gì?](../glossary#token-type-ids)
- **attention_mask** -- Danh sách các chỉ số chỉ định những token nào nên được mô hình chú ý đến (khi `return_attention_mask=True` hoặc nếu *"attention_mask"* nằm trong `self.model_input_names`).
[Mặt nạ chú ý là gì?](../glossary#attention-mask)
- **overflowing_tokens** -- Danh sách các chuỗi token bị tràn (khi `max_length` được chỉ định và `return_overflowing_tokens=True`).
- **num_truncated_tokens** -- Số lượng token bị cắt bỏ (khi chỉ định `max_length` và `return_overflowing_tokens=True`).
- **special_tokens_mask** -- Danh sách các số 0 và 1, trong đó 1 chỉ định các token đặc biệt đã thêm và 0 chỉ định các token chuỗi thông thường (khi `add_special_tokens=True` và `return_special_tokens_mask=True`).
- **length** -- Độ dài của các đầu vào (khi `return_length=True`)
Phương thức chính để mã hóa token và chuẩn bị cho mô hình một hoặc nhiều chuỗi, hoặc một hoặc nhiều cặp chuỗi.
## PerceiverImageProcessor[[transformers.PerceiverImageProcessor]]
#### transformers.PerceiverImageProcessor[[transformers.PerceiverImageProcessor]]
```python
transformers.PerceiverImageProcessor(**kwargs: *)
```
[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/image_processing_perceiver.py#L33)
**Tham số:**
do_convert_rgb (`bool`, *kwargs*, *optional*) : Có chuyển đổi hình ảnh sang RGB hay không.
do_resize (`bool`, *kwargs*, *tuỳ chọn*, mặc định là `True`) : Xác định có thay đổi kích thước ảnh hay không.
size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, mặc định là `{'height' : 224, 'width': 224}`): Mô tả kích thước đầu vào tối đa cho mô hình.
default_to_square (`bool`, *kwargs*, *tuỳ chọn*, mặc định là `True`) : Có nên mặc định sử dụng ảnh vuông khi thay đổi kích thước hay không, nếu size là một số nguyên.
crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, mặc định là `{'height' : 256, 'width': 256}`): Kích thước của ảnh đầu ra sau khi áp dụng `center_crop`.
resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, mặc định là `3`) : Bộ lọc lấy mẫu lại (resampling filter) được sử dụng khi thay đổi kích thước ảnh. Giá trị này có thể là một trong các hằng số liệt kê (enum) của `PILImageResampling`. Chỉ có hiệu lực khi `do_resize` được đặt thành `True`.
do_rescale (`bool`, *kwargs*, *tuỳ chọn*, mặc định là `True`) : Xác định có nên điều chỉnh lại tỷ lệ ảnh hay không.
rescale_factor (`float`, *kwargs*, *optional*, mặc định là `0.00392156862745098`) : Hệ số để điều chỉnh lại kích thước ảnh nếu `do_rescale` được đặt thành `True`.
do_normalize (`bool`, *kwargs*, *tuỳ chọn*, mặc định là `True`) : Có chuẩn hóa hình ảnh hay không.
image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *optional*, mặc định là `[0.485, 0.456, 0.406]`) : Giá trị trung bình của ảnh để sử dụng cho việc chuẩn hóa. Chỉ có hiệu lực nếu `do_normalize` được đặt thành `True`.
image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *optional*, mặc định là `[0.229, 0.224, 0.225]`) : Độ lệch chuẩn của ảnh để sử dụng cho việc chuẩn hóa. Chỉ có hiệu lực nếu `do_normalize` được đặt thành `True`.
do_pad (`bool`, *kwargs*, *optional*) : Xác định có chèn padding cho ảnh hay không. Padding được thực hiện đến kích thước lớn nhất trong batch hoặc đến một kích thước vuông cố định cho mỗi ảnh. Chiến lược padding cụ thể phụ thuộc vào model.
pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Kích thước ở dạng `{"height": int, "width" int}` để đệm (pad) các ảnh. Phải lớn hơn kích thước của bất kỳ ảnh nào được cung cấp cho tiền xử lý. Nếu `pad_size` không được cung cấp, các ảnh sẽ được đệm đến chiều cao và chiều rộng lớn nhất trong batch. Chỉ được áp dụng khi `do_pad=True.`
do_center_crop (`bool`, *kwargs*, *optional*, mặc định là `True`) : Xác định có cắt ảnh theo kiểu căn giữa hay không.
data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *tuỳ chọn*) : Chỉ hỗ trợ `ChannelDimension.FIRST`. Được thêm vào để tương thích với các bộ xử lý chậm.
input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *optional*) : Định dạng chiều kênh cho ảnh đầu vào. Nếu không được đặt, định dạng chiều kênh sẽ được suy ra từ ảnh đầu vào. Có thể là một trong các giá trị sau: - `"channels_first"` hoặc `ChannelDimension.FIRST`: ảnh ở định dạng (num_channels, height, width). - `"channels_last"` hoặc `ChannelDimension.LAST`: ảnh ở định dạng (height, width, num_channels). - `"none"` hoặc `ChannelDimension.NONE`: ảnh ở định dạng (height, width).
device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : Thiết bị để xử lý các video. Nếu không được đặt, thiết bị sẽ được suy ra từ các video đầu vào.
return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Trả về các tensor đã xếp chồng nếu được đặt thành `'pt'`, ngược lại trả về một danh sách các tensor.
disable_grouping (`bool`, *kwargs*, *optional*) : Xác định có vô hiệu hóa việc nhóm các hình ảnh theo kích thước để xử lý chúng riêng lẻ thay vì theo lô hay không. Nếu là None, giá trị sẽ được đặt thành True nếu các hình ảnh nằm trên CPU, và False trong các trường hợp khác. Lựa chọn này dựa trên các quan sát thực nghiệm, chi tiết tại đây: https://github.com/huggingface/transformers/pull/38157
image_seq_length (`int`, *kwargs*, *tuỳ chọn*) : Số lượng token hình ảnh sẽ được sử dụng cho mỗi hình ảnh trong đầu vào. Được thêm vào để đảm bảo tương thích ngược, nhưng trong các mô hình tương lai, giá trị này nên được đặt như một thuộc tính của bộ xử lý.
Tạo bộ xử lý ảnh PerceiverImageProcessor.
#### preprocess[[transformers.PerceiverImageProcessor.preprocess]]
```python
preprocess(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']], *args, image_like_kwargs: dict[str, typing.Any] | None = None, **kwargs: *)
```
[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_utils.py#L382)
**Tham số:**
images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`) : Ảnh cần tiền xử lý. Kỳ vọng một ảnh đơn hoặc một lô ảnh có giá trị pixel từ 0 đến 255. Nếu truyền vào các ảnh có giá trị pixel từ 0 đến 1, hãy đặt `do_rescale=False`.
image_like_kwargs (`dict[str, Any]`, *tùy chọn*) : Cờ dành cho nhà phát triển cho các đầu vào dạng ảnh bổ sung cũng sẽ được tiền xử lý. Chỉ sử dụng cờ này nếu việc truyền các đầu vào dưới dạng kwarg không hoạt động. Ví dụ, `preprocess(images, masks=masks)` là tùy chọn được ưu tiên nhưng có thể gây ra các vấn đề về thứ tự ưu tiên của đối số đối với một số mô hình. Trong những trường hợp đó, có thể sử dụng `preprocess(images, image_like_inputs={"masks": masks})` thay thế.
do_convert_rgb (`bool`, *kwargs*, *optional*) : Có chuyển đổi hình ảnh sang RGB hay không.
do_resize (`bool`, *kwargs*, *optional*) : Xác định có nên thay đổi kích thước ảnh hay không.
size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*): Mô tả các kích thước đầu vào tối đa của mô hình.
default_to_square (`bool`, *kwargs*, *tuỳ chọn*) : Có mặc định dùng ảnh vuông khi thay đổi kích thước hay không, nếu size là một số nguyên.
crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Kích thước của ảnh đầu ra sau khi áp dụng `center_crop`.
resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*) : Bộ lọc resampling để sử dụng khi thay đổi kích thước ảnh. Giá trị này có thể là một trong các enum `PILImageResampling`. Chỉ có hiệu lực khi `do_resize` được đặt thành `True`.
do_rescale (`bool`, *kwargs*, *tuỳ chọn*) : Xác định có nên điều chỉnh lại tỷ lệ hình ảnh hay không.
rescale_factor (`float`, *kwargs*, *optional*) : Hệ số để thay đổi tỷ lệ ảnh nếu `do_rescale` được đặt thành `True`.
do_normalize (`bool`, *kwargs*, *tuỳ chọn*) : Xác định có chuẩn hóa hình ảnh hay không.
image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *optional*) : Giá trị trung bình của ảnh để sử dụng cho việc chuẩn hóa. Chỉ có hiệu lực nếu `do_normalize` được đặt thành `True`.
image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *optional*) : Độ lệch chuẩn của ảnh để sử dụng cho việc chuẩn hóa. Chỉ có hiệu lực nếu `do_normalize` được đặt thành `True`.
do_pad (`bool`, *kwargs*, *optional*) : Xác định có chèn padding cho ảnh hay không. Padding được thực hiện đến kích thước lớn nhất trong batch hoặc đến một kích thước vuông cố định cho mỗi ảnh. Chiến lược padding cụ thể phụ thuộc vào model.
pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Kích thước ở dạng `{"height": int, "width" int}` để đệm (pad) các ảnh. Phải lớn hơn kích thước của bất kỳ ảnh nào được cung cấp cho tiền xử lý. Nếu `pad_size` không được cung cấp, các ảnh sẽ được đệm đến chiều cao và chiều rộng lớn nhất trong batch. Chỉ được áp dụng khi `do_pad=True.`
do_center_crop (`bool`, *kwargs*, *optional*) : Có nên cắt ảnh theo kiểu căn giữa hay không.
data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *tuỳ chọn*) : Chỉ hỗ trợ `ChannelDimension.FIRST`. Được thêm vào để tương thích với các bộ xử lý chậm.
input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *optional*) : Định dạng chiều kênh cho ảnh đầu vào. Nếu không được đặt, định dạng chiều kênh sẽ được suy ra từ ảnh đầu vào. Có thể là một trong các giá trị sau: - `"channels_first"` hoặc `ChannelDimension.FIRST`: ảnh ở định dạng (num_channels, height, width). - `"channels_last"` hoặc `ChannelDimension.LAST`: ảnh ở định dạng (height, width, num_channels). - `"none"` hoặc `ChannelDimension.NONE`: ảnh ở định dạng (height, width).
device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : Thiết bị để xử lý các video. Nếu không được đặt, thiết bị sẽ được suy ra từ các video đầu vào.
return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Trả về các tensor đã xếp chồng nếu được đặt thành `'pt'`, ngược lại trả về một danh sách các tensor.
disable_grouping (`bool`, *kwargs*, *optional*) : Xác định có vô hiệu hóa việc nhóm các hình ảnh theo kích thước để xử lý chúng riêng lẻ thay vì theo lô hay không. Nếu là None, giá trị sẽ được đặt thành True nếu các hình ảnh nằm trên CPU, và False trong các trường hợp khác. Lựa chọn này dựa trên các quan sát thực nghiệm, chi tiết tại đây: https://github.com/huggingface/transformers/pull/38157
image_seq_length (`int`, *kwargs*, *tuỳ chọn*) : Số lượng token hình ảnh sẽ được sử dụng cho mỗi hình ảnh trong đầu vào. Được thêm vào để đảm bảo tương thích ngược, nhưng trong các mô hình tương lai, giá trị này nên được đặt như một thuộc tính của bộ xử lý.
**Trả về:** `~image_processing_base.BatchFeature`
- **data** (`dict`) -- Từ điển chứa các danh sách/mảng/tensor được trả về bởi phương thức __call__ ('pixel_values', v.v.).
- **tensor_type** (`Union[None, str, TensorType]`, *tùy chọn*) -- Bạn có thể cung cấp tensor_type tại đây để chuyển đổi các danh sách số nguyên trong Tensor PyTorch/Numpy khi khởi tạo.
Tiền xử lý một hình ảnh hoặc một lô hình ảnh.
## PerceiverImageProcessorPil[[transformers.PerceiverImageProcessorPil]]
#### transformers.PerceiverImageProcessorPil[[transformers.PerceiverImageProcessorPil]]
```python
transformers.PerceiverImageProcessorPil(**kwargs: *)
```
[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/image_processing_pil_perceiver.py#L31)
**Tham số:**
do_convert_rgb (`bool`, *kwargs*, *optional*) : Có chuyển đổi hình ảnh sang RGB hay không.
do_resize (`bool`, *kwargs*, *tuỳ chọn*, mặc định là `True`) : Xác định có thay đổi kích thước ảnh hay không.
size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, mặc định là `{'height' : 224, 'width': 224}`): Mô tả kích thước đầu vào tối đa cho mô hình.
default_to_square (`bool`, *kwargs*, *tuỳ chọn*, mặc định là `True`) : Có nên mặc định sử dụng ảnh vuông khi thay đổi kích thước hay không, nếu size là một số nguyên.
crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, mặc định là `{'height' : 256, 'width': 256}`): Kích thước của ảnh đầu ra sau khi áp dụng `center_crop`.
resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, mặc định là `3`) : Bộ lọc lấy mẫu lại (resampling filter) được sử dụng khi thay đổi kích thước ảnh. Giá trị này có thể là một trong các hằng số liệt kê (enum) của `PILImageResampling`. Chỉ có hiệu lực khi `do_resize` được đặt thành `True`.
do_rescale (`bool`, *kwargs*, *tuỳ chọn*, mặc định là `True`) : Xác định có nên điều chỉnh lại tỷ lệ ảnh hay không.
rescale_factor (`float`, *kwargs*, *optional*, mặc định là `0.00392156862745098`) : Hệ số để điều chỉnh lại kích thước ảnh nếu `do_rescale` được đặt thành `True`.
do_normalize (`bool`, *kwargs*, *tuỳ chọn*, mặc định là `True`) : Có chuẩn hóa hình ảnh hay không.
image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *optional*, mặc định là `[0.485, 0.456, 0.406]`) : Giá trị trung bình của ảnh để sử dụng cho việc chuẩn hóa. Chỉ có hiệu lực nếu `do_normalize` được đặt thành `True`.
image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *optional*, mặc định là `[0.229, 0.224, 0.225]`) : Độ lệch chuẩn của ảnh để sử dụng cho việc chuẩn hóa. Chỉ có hiệu lực nếu `do_normalize` được đặt thành `True`.
do_pad (`bool`, *kwargs*, *optional*) : Xác định có chèn padding cho ảnh hay không. Padding được thực hiện đến kích thước lớn nhất trong batch hoặc đến một kích thước vuông cố định cho mỗi ảnh. Chiến lược padding cụ thể phụ thuộc vào model.
pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Kích thước ở dạng `{"height": int, "width" int}` để đệm (pad) các ảnh. Phải lớn hơn kích thước của bất kỳ ảnh nào được cung cấp cho tiền xử lý. Nếu `pad_size` không được cung cấp, các ảnh sẽ được đệm đến chiều cao và chiều rộng lớn nhất trong batch. Chỉ được áp dụng khi `do_pad=True.`
do_center_crop (`bool`, *kwargs*, *optional*, mặc định là `True`) : Xác định có cắt ảnh theo kiểu căn giữa hay không.
data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *tuỳ chọn*) : Chỉ hỗ trợ `ChannelDimension.FIRST`. Được thêm vào để tương thích với các bộ xử lý chậm.
input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *optional*) : Định dạng chiều kênh cho ảnh đầu vào. Nếu không được đặt, định dạng chiều kênh sẽ được suy ra từ ảnh đầu vào. Có thể là một trong các giá trị sau: - `"channels_first"` hoặc `ChannelDimension.FIRST`: ảnh ở định dạng (num_channels, height, width). - `"channels_last"` hoặc `ChannelDimension.LAST`: ảnh ở định dạng (height, width, num_channels). - `"none"` hoặc `ChannelDimension.NONE`: ảnh ở định dạng (height, width).
device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : Thiết bị để xử lý các video. Nếu không được đặt, thiết bị sẽ được suy ra từ các video đầu vào.
return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Trả về các tensor đã xếp chồng nếu được đặt thành `'pt'`, ngược lại trả về một danh sách các tensor.
disable_grouping (`bool`, *kwargs*, *optional*) : Xác định có vô hiệu hóa việc nhóm các hình ảnh theo kích thước để xử lý chúng riêng lẻ thay vì theo lô hay không. Nếu là None, giá trị sẽ được đặt thành True nếu các hình ảnh nằm trên CPU, và False trong các trường hợp khác. Lựa chọn này dựa trên các quan sát thực nghiệm, chi tiết tại đây: https://github.com/huggingface/transformers/pull/38157
image_seq_length (`int`, *kwargs*, *tuỳ chọn*) : Số lượng token hình ảnh sẽ được sử dụng cho mỗi hình ảnh trong đầu vào. Được thêm vào để đảm bảo tương thích ngược, nhưng trong các mô hình tương lai, giá trị này nên được đặt như một thuộc tính của bộ xử lý.
Tạo bộ xử lý ảnh PerceiverImageProcessor.
#### preprocess[[transformers.PerceiverImageProcessorPil.preprocess]]
```python
preprocess(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']], *args, image_like_kwargs: dict[str, typing.Any] | None = None, **kwargs: *)
```
[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_utils.py#L382)
**Tham số:**
images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`) : Ảnh cần tiền xử lý. Kỳ vọng một ảnh đơn hoặc một lô ảnh có giá trị pixel từ 0 đến 255. Nếu truyền vào các ảnh có giá trị pixel từ 0 đến 1, hãy đặt `do_rescale=False`.
image_like_kwargs (`dict[str, Any]`, *tùy chọn*) : Cờ dành cho nhà phát triển cho các đầu vào dạng ảnh bổ sung cũng sẽ được tiền xử lý. Chỉ sử dụng cờ này nếu việc truyền các đầu vào dưới dạng kwarg không hoạt động. Ví dụ, `preprocess(images, masks=masks)` là tùy chọn được ưu tiên nhưng có thể gây ra các vấn đề về thứ tự ưu tiên của đối số đối với một số mô hình. Trong những trường hợp đó, có thể sử dụng `preprocess(images, image_like_inputs={"masks": masks})` thay thế.
do_convert_rgb (`bool`, *kwargs*, *optional*) : Có chuyển đổi hình ảnh sang RGB hay không.
do_resize (`bool`, *kwargs*, *optional*) : Xác định có nên thay đổi kích thước ảnh hay không.
size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*): Mô tả các kích thước đầu vào tối đa của mô hình.
default_to_square (`bool`, *kwargs*, *tuỳ chọn*) : Có mặc định dùng ảnh vuông khi thay đổi kích thước hay không, nếu size là một số nguyên.
crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Kích thước của ảnh đầu ra sau khi áp dụng `center_crop`.
resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*) : Bộ lọc resampling để sử dụng khi thay đổi kích thước ảnh. Giá trị này có thể là một trong các enum `PILImageResampling`. Chỉ có hiệu lực khi `do_resize` được đặt thành `True`.
do_rescale (`bool`, *kwargs*, *tuỳ chọn*) : Xác định có nên điều chỉnh lại tỷ lệ hình ảnh hay không.
rescale_factor (`float`, *kwargs*, *optional*) : Hệ số để thay đổi tỷ lệ ảnh nếu `do_rescale` được đặt thành `True`.
do_normalize (`bool`, *kwargs*, *tuỳ chọn*) : Xác định có chuẩn hóa hình ảnh hay không.
image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *optional*) : Giá trị trung bình của ảnh để sử dụng cho việc chuẩn hóa. Chỉ có hiệu lực nếu `do_normalize` được đặt thành `True`.
image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *optional*) : Độ lệch chuẩn của ảnh để sử dụng cho việc chuẩn hóa. Chỉ có hiệu lực nếu `do_normalize` được đặt thành `True`.
do_pad (`bool`, *kwargs*, *optional*) : Xác định có chèn padding cho ảnh hay không. Padding được thực hiện đến kích thước lớn nhất trong batch hoặc đến một kích thước vuông cố định cho mỗi ảnh. Chiến lược padding cụ thể phụ thuộc vào model.
pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Kích thước ở dạng `{"height": int, "width" int}` để đệm (pad) các ảnh. Phải lớn hơn kích thước của bất kỳ ảnh nào được cung cấp cho tiền xử lý. Nếu `pad_size` không được cung cấp, các ảnh sẽ được đệm đến chiều cao và chiều rộng lớn nhất trong batch. Chỉ được áp dụng khi `do_pad=True.`
do_center_crop (`bool`, *kwargs*, *optional*) : Có nên cắt ảnh theo kiểu căn giữa hay không.
data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *tuỳ chọn*) : Chỉ hỗ trợ `ChannelDimension.FIRST`. Được thêm vào để tương thích với các bộ xử lý chậm.
input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *optional*) : Định dạng chiều kênh cho ảnh đầu vào. Nếu không được đặt, định dạng chiều kênh sẽ được suy ra từ ảnh đầu vào. Có thể là một trong các giá trị sau: - `"channels_first"` hoặc `ChannelDimension.FIRST`: ảnh ở định dạng (num_channels, height, width). - `"channels_last"` hoặc `ChannelDimension.LAST`: ảnh ở định dạng (height, width, num_channels). - `"none"` hoặc `ChannelDimension.NONE`: ảnh ở định dạng (height, width).
device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : Thiết bị để xử lý các video. Nếu không được đặt, thiết bị sẽ được suy ra từ các video đầu vào.
return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Trả về các tensor đã xếp chồng nếu được đặt thành `'pt'`, ngược lại trả về một danh sách các tensor.
disable_grouping (`bool`, *kwargs*, *optional*) : Xác định có vô hiệu hóa việc nhóm các hình ảnh theo kích thước để xử lý chúng riêng lẻ thay vì theo lô hay không. Nếu là None, giá trị sẽ được đặt thành True nếu các hình ảnh nằm trên CPU, và False trong các trường hợp khác. Lựa chọn này dựa trên các quan sát thực nghiệm, chi tiết tại đây: https://github.com/huggingface/transformers/pull/38157
image_seq_length (`int`, *kwargs*, *tuỳ chọn*) : Số lượng token hình ảnh sẽ được sử dụng cho mỗi hình ảnh trong đầu vào. Được thêm vào để đảm bảo tương thích ngược, nhưng trong các mô hình tương lai, giá trị này nên được đặt như một thuộc tính của bộ xử lý.
**Trả về:** `~image_processing_base.BatchFeature`
- **data** (`dict`) -- Từ điển chứa các danh sách/mảng/tensor được trả về bởi phương thức __call__ ('pixel_values', v.v.).
- **tensor_type** (`Union[None, str, TensorType]`, *tùy chọn*) -- Bạn có thể cung cấp tensor_type tại đây để chuyển đổi các danh sách số nguyên trong Tensor PyTorch/Numpy khi khởi tạo.
Tiền xử lý một hình ảnh hoặc một lô hình ảnh.
## PerceiverTextPreprocessor[[transformers.models.perceiver.modeling_perceiver.PerceiverTextPreprocessor]]
#### transformers.models.perceiver.modeling_perceiver.PerceiverTextPreprocessor[[transformers.models.perceiver.modeling_perceiver.PerceiverTextPreprocessor]]
```python
transformers.models.perceiver.modeling_perceiver.PerceiverTextPreprocessor(config: PerceiverConfig)
```
[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L2662)
**Tham số:**
config ([PerceiverConfig](/docs/transformers/main/vi/model_doc/perceiver#transformers.PerceiverConfig)) : Cấu hình mô hình.
Tiền xử lý văn bản cho Perceiver Encoder. Có thể được sử dụng để nhúng `inputs` và thêm mã hóa vị trí.
Kích thước của các embedding được xác định bởi thuộc tính `d_model` của cấu hình.
## PerceiverImagePreprocessor[[transformers.models.perceiver.modeling_perceiver.PerceiverImagePreprocessor]]
#### transformers.models.perceiver.modeling_perceiver.PerceiverImagePreprocessor[[transformers.models.perceiver.modeling_perceiver.PerceiverImagePreprocessor]]
```python
transformers.models.perceiver.modeling_perceiver.PerceiverImagePreprocessor(config, prep_type = 'conv', spatial_downsample: int = 4, temporal_downsample: int = 1, position_encoding_type: str = 'fourier', in_channels: int = 3, out_channels: int = 64, conv_after_patching: bool = False, conv_after_patching_in_channels: int = 54, conv2d_use_batchnorm: bool = True, concat_or_add_pos: str = 'concat', project_pos_dim: int = -1, **position_encoding_kwargs)
```
[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L2825)
**Tham số:**
config ([*PerceiverConfig*]) : Cấu hình mô hình.
prep_type (`str`, *tùy chọn*, mặc định là `"conv"`) : Kiểu tiền xử lý. Có thể là "conv1x1", "conv", "patches", "pixels".
spatial_downsample (`int`, *tuỳ chọn*, mặc định là 4) : Hệ số giảm mẫu không gian.
temporal_downsample (`int`, *optional*, mặc định là 1) : Hệ số giảm mẫu theo thời gian (chỉ liên quan khi có chiều thời gian).
position_encoding_type (`str`, *tùy chọn*, mặc định là `"fourier"`) : Kiểu mã hóa vị trí. Có thể là "fourier" hoặc "trainable".
in_channels (`int`, *tuỳ chọn*, mặc định là 3) : Số kênh trong đầu vào.
out_channels (`int`, *tuỳ chọn*, mặc định là 64) : Số kênh trong đầu ra.
conv_after_patching (`bool`, *tùy chọn*, mặc định là `False`) : Có áp dụng một lớp tích chập sau khi chia patch hay không.
conv_after_patching_in_channels (`int`, *tuỳ chọn*, mặc định là 54) : Số kênh trong đầu vào của lớp tích chập sau khi patching.
conv2d_use_batchnorm (`bool`, *tùy chọn*, mặc định là `True`) : Có sử dụng chuẩn hóa lô (batch normalization) trong lớp tích chập hay không.
concat_or_add_pos (`str`, *tùy chọn*, mặc định là `"concat"`) : Cách nối mã hóa vị trí vào đầu vào. Có thể là "concat" hoặc "add".
project_pos_dim (`int`, *optional*, mặc định là -1) : Kích thước của mã hóa vị trí để chiếu tới. Nếu là -1, không áp dụng phép chiếu.
- ****position_encoding_kwargs** (`Dict`, *tùy chọn*) : Các đối số từ khóa cho position encoding.
Tiền xử lý ảnh cho Perceiver Encoder.
Lưu ý: đối số *out_channels* đề cập đến số kênh đầu ra của một lớp tích chập, nếu *prep_type* được đặt thành "conv1x1" hoặc "conv". Nếu thêm các nhúng vị trí tuyệt đối, bạn phải đảm bảo rằng *num_channels* của các kwargs mã hóa vị trí được đặt bằng với *out_channels*.
## PerceiverOneHotPreprocessor[[transformers.models.perceiver.modeling_perceiver.PerceiverOneHotPreprocessor]]
#### transformers.models.perceiver.modeling_perceiver.PerceiverOneHotPreprocessor[[transformers.models.perceiver.modeling_perceiver.PerceiverOneHotPreprocessor]]
```python
transformers.models.perceiver.modeling_perceiver.PerceiverOneHotPreprocessor(config: PerceiverConfig)
```
[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L3063)
**Tham số:**
config ([PerceiverConfig](/docs/transformers/main/vi/model_doc/perceiver#transformers.PerceiverConfig)) : Cấu hình mô hình.
Bộ tiền xử lý one-hot cho Perceiver Encoder. Có thể được sử dụng để thêm một chiều chỉ mục giả vào đầu vào.
## PerceiverAudioPreprocessor[[transformers.models.perceiver.modeling_perceiver.PerceiverAudioPreprocessor]]
#### transformers.models.perceiver.modeling_perceiver.PerceiverAudioPreprocessor[[transformers.models.perceiver.modeling_perceiver.PerceiverAudioPreprocessor]]
```python
transformers.models.perceiver.modeling_perceiver.PerceiverAudioPreprocessor(config, prep_type: str = 'patches', samples_per_patch: int = 96, position_encoding_type: str = 'fourier', concat_or_add_pos: str = 'concat', out_channels = 64, project_pos_dim = -1, **position_encoding_kwargs)
```
[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L3089)
**Tham số:**
config ([*PerceiverConfig*]) : Cấu hình mô hình.
prep_type (`str`, *tùy chọn*, mặc định là `"patches"`) : Kiểu bộ tiền xử lý cần sử dụng. Chỉ hỗ trợ "patches".
samples_per_patch (`int`, *tuỳ chọn*, mặc định là 96) : Số lượng mẫu trên mỗi patch.
position_encoding_type (`str`, *tùy chọn*, mặc định là `"fourier"`) : Loại mã hóa vị trí cần sử dụng. Có thể là "trainable" hoặc "fourier".
concat_or_add_pos (`str`, *tùy chọn*, mặc định là `"concat"`) : Cách nối mã hóa vị trí vào đầu vào. Có thể là "concat" hoặc "add".
out_channels (`int`, *tuỳ chọn*, mặc định là 64) : Số kênh trong đầu ra.
project_pos_dim (`int`, *optional*, mặc định là -1) : Kích thước của mã hóa vị trí để chiếu tới. Nếu là -1, không áp dụng phép chiếu.
- ****position_encoding_kwargs** (`Dict`, *tùy chọn*) : Các đối số từ khóa cho position encoding.
Tiền xử lý âm thanh cho Perceiver Encoder.
## PerceiverMultimodalPreprocessor[[transformers.models.perceiver.modeling_perceiver.PerceiverMultimodalPreprocessor]]
#### transformers.models.perceiver.modeling_perceiver.PerceiverMultimodalPreprocessor[[transformers.models.perceiver.modeling_perceiver.PerceiverMultimodalPreprocessor]]
```python
transformers.models.perceiver.modeling_perceiver.PerceiverMultimodalPreprocessor(modalities: Mapping, mask_probs: collections.abc.Mapping[str, float] | None = None, min_padding_size: int = 2)
```
[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L3192)
**Tham số:**
modalities (`Mapping[str, PreprocessorType]`) : Từ điển ánh xạ tên chế độ nhận thức (modality) sang bộ tiền xử lý (preprocessor).
mask_probs (`dict[str, float]`) : Từ điển ánh xạ tên phương thức (modality) sang xác suất che (masking) của phương thức đó.
min_padding_size (`int`, *optional*, mặc định là 2) : Kích thước padding tối thiểu cho tất cả các modalities. Đầu ra cuối cùng sẽ có num_channels bằng số kênh lớn nhất trên tất cả các modalities cộng với min_padding_size.
Tiền xử lý đa phương thức cho Perceiver Encoder.
Đầu vào cho mỗi phương thức được tiền xử lý, sau đó được đệm bằng các nhúng vị trí có thể huấn luyện để có cùng số kênh.
## PerceiverProjectionDecoder[[transformers.models.perceiver.modeling_perceiver.PerceiverProjectionDecoder]]
#### transformers.models.perceiver.modeling_perceiver.PerceiverProjectionDecoder[[transformers.models.perceiver.modeling_perceiver.PerceiverProjectionDecoder]]
```python
transformers.models.perceiver.modeling_perceiver.PerceiverProjectionDecoder(config)
```
[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L1839)
**Tham số:**
config ([PerceiverConfig](/docs/transformers/main/vi/model_doc/perceiver#transformers.PerceiverConfig)) : Cấu hình mô hình.
Bộ giải mã dự đoán baseline (không có cross-attention).
## PerceiverBasicDecoder[[transformers.models.perceiver.modeling_perceiver.PerceiverBasicDecoder]]
#### transformers.models.perceiver.modeling_perceiver.PerceiverBasicDecoder[[transformers.models.perceiver.modeling_perceiver.PerceiverBasicDecoder]]
```python
transformers.models.perceiver.modeling_perceiver.PerceiverBasicDecoder(config: PerceiverConfig, output_num_channels: int, position_encoding_type: str | None = 'trainable', output_index_dims: int | None = None, num_channels: int | None = 128, subsampled_index_dims: int | None = None, qk_channels: int | None = None, v_channels: int | None = None, num_heads: int | None = 1, widening_factor: int | None = 1, use_query_residual: bool | None = False, concat_preprocessed_input: bool | None = False, final_project: bool | None = True, position_encoding_only: bool | None = False, **position_encoding_kwargs)
```
[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L1863)
**Tham số:**
config ([*PerceiverConfig*]) : Cấu hình mô hình.
output_num_channels (`int`, *tuỳ chọn*) : Số lượng kênh trong đầu ra. Chỉ được sử dụng khi *final_project* được đặt thành `True`.
position_encoding_type (`str`, *tùy chọn*, mặc định là "trainable") : Kiểu mã hóa vị trí cần sử dụng. Có thể là "trainable", "fourier" hoặc "none".
output_index_dims (`int`, *optional*) : Số chiều của các truy vấn đầu ra. Bị bỏ qua nếu 'position_encoding_type' == 'none'.
num_channels (`int`, *tuỳ chọn*, mặc định là 128) : Số kênh của các truy vấn bộ giải mã. Bị bỏ qua nếu 'position_encoding_type' == 'none'.
qk_channels (`int`, *tùy chọn*) : Số lượng kênh của các truy vấn và khóa trong lớp chú ý chéo.
v_channels (`int`, *tùy chọn*) : Số lượng kênh của các giá trị trong lớp cross-attention.
num_heads (`int`, *tuỳ chọn*, mặc định là 1) : Số lượng đầu chú ý trong lớp chú ý chéo.
widening_factor (`int`, *tuỳ chọn*, mặc định là 1) : Hệ số mở rộng của lớp cross-attention.
use_query_residual (`bool`, *tùy chọn*, mặc định là `False`) : Có sử dụng kết nối phần dư giữa query và đầu ra của lớp cross-attention hay không.
concat_preprocessed_input (`bool`, *tùy chọn*, mặc định là `False`) : Có nối đầu vào đã tiền xử lý với truy vấn hay không.
final_project (`bool`, *tùy chọn*, mặc định là `True`) : Có dự chiếu đầu ra của lớp cross-attention sang một chiều mục tiêu hay không.
position_encoding_only (`bool`, *tùy chọn*, mặc định là `False`) : Có chỉ sử dụng lớp này để định nghĩa các truy vấn đầu ra hay không.
Decoder dựa trên cross-attention. Lớp này có thể được sử dụng để giải mã các trạng thái ẩn cuối cùng của các biến tiềm ẩn (latents) bằng một thao tác cross-attention, trong đó các biến tiềm ẩn tạo ra các khóa (keys) và giá trị (values).
Hình dạng của đầu ra của lớp này phụ thuộc vào cách định nghĩa các truy vấn đầu ra (còn được gọi là các truy vấn giải mã).
## PerceiverClassificationDecoder[[transformers.models.perceiver.modeling_perceiver.PerceiverClassificationDecoder]]
#### transformers.models.perceiver.modeling_perceiver.PerceiverClassificationDecoder[[transformers.models.perceiver.modeling_perceiver.PerceiverClassificationDecoder]]
```python
transformers.models.perceiver.modeling_perceiver.PerceiverClassificationDecoder(config, **decoder_kwargs)
```
[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L2048)
**Tham số:**
config ([PerceiverConfig](/docs/transformers/main/vi/model_doc/perceiver#transformers.PerceiverConfig)) : Cấu hình mô hình.
Bộ giải mã phân loại dựa trên cross-attention. Lớp bọc nhẹ của `PerceiverBasicDecoder` cho đầu ra logit. Sẽ chuyển đổi đầu ra của bộ mã hóa Perceiver có hình dạng (batch_size, num_latents, d_latents) thành một tensor có hình dạng (batch_size, num_labels). Các truy vấn có hình dạng (batch_size, 1, num_labels).
## PerceiverOpticalFlowDecoder[[transformers.models.perceiver.modeling_perceiver.PerceiverOpticalFlowDecoder]]
#### transformers.models.perceiver.modeling_perceiver.PerceiverOpticalFlowDecoder[[transformers.models.perceiver.modeling_perceiver.PerceiverOpticalFlowDecoder]]
```python
transformers.models.perceiver.modeling_perceiver.PerceiverOpticalFlowDecoder(config, output_image_shape, output_num_channels = 2, rescale_factor = 100.0, **decoder_kwargs)
```
[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L2094)
Bộ giải mã dòng quang học dựa trên cross-attention.
## PerceiverBasicVideoAutoencodingDecoder[[transformers.models.perceiver.modeling_perceiver.PerceiverBasicVideoAutoencodingDecoder]]
#### transformers.models.perceiver.modeling_perceiver.PerceiverBasicVideoAutoencodingDecoder[[transformers.models.perceiver.modeling_perceiver.PerceiverBasicVideoAutoencodingDecoder]]
```python
transformers.models.perceiver.modeling_perceiver.PerceiverBasicVideoAutoencodingDecoder(config: PerceiverConfig, output_shape: list, position_encoding_type: str, **decoder_kwargs)
```
[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L2129)
**Tham số:**
config ([*PerceiverConfig*]) : Cấu hình mô hình.
output_shape (`list[int]`) : Hình dạng của đầu ra là (batch_size, num_frames, height, width), không bao gồm chiều kênh.
position_encoding_type (`str`) : Kiểu mã hóa vị trí cần sử dụng. Có thể là "trainable", "fourier" hoặc "none".
Bộ giải mã video tự mã hóa dựa trên cross-attention. Lớp bọc nhẹ của [*PerceiverBasicDecoder*] với logic định dạng lại video.
## PerceiverMultimodalDecoder[[transformers.models.perceiver.modeling_perceiver.PerceiverMultimodalDecoder]]
#### transformers.models.perceiver.modeling_perceiver.PerceiverMultimodalDecoder[[transformers.models.perceiver.modeling_perceiver.PerceiverMultimodalDecoder]]
```python
transformers.models.perceiver.modeling_perceiver.PerceiverMultimodalDecoder(config: PerceiverConfig, modalities: dict, num_outputs: int, output_num_channels: int, min_padding_size: int | None = 2, subsampled_index_dims: dict[str, transformers.models.perceiver.modeling_perceiver.PerceiverAbstractDecoder] | None = None, **decoder_kwargs)
```
[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L2206)
**Tham số:**
config ([*PerceiverConfig*]) : Cấu hình mô hình.
modalities (`dict[str, PerceiverAbstractDecoder]`) : Từ điển ánh xạ tên chế độ (modality) đến bộ giải mã (decoder) của chế độ đó.
num_outputs (`int`) : Số lượng đầu ra của bộ giải mã.
output_num_channels (`int`) : Số lượng kênh trong đầu ra.
min_padding_size (`int`, *optional*, mặc định là 2) : Kích thước padding tối thiểu cho tất cả các modalities. Đầu ra cuối cùng sẽ có num_channels bằng số kênh lớn nhất trên tất cả các modalities cộng với min_padding_size.
subsampled_index_dims (`dict[str, PerceiverAbstractDecoder]`, *tùy chọn*) : Từ điển ánh xạ tên chế độ (modality) sang các chiều chỉ số đã lấy mẫu con (subsampled index dimensions) cần dùng cho truy vấn (query) của bộ giải mã (decoder) tương ứng với chế độ đó.
Giải mã đa phương thức bằng cách kết hợp các bộ giải mã đơn phương thức. Tham số *modalities* của hàm khởi tạo là một từ điển ánh xạ tên phương thức tới bộ giải mã của phương thức đó. Bộ giải mã này sẽ được dùng để xây dựng các truy vấn cho phương thức tương ứng. Các truy vấn riêng cho từng phương thức được đệm bằng các tham số riêng cho từng phương thức có thể huấn luyện, sau đó chúng được nối với nhau dọc theo chiều thời gian.
Tiếp theo, có một thao tác cross attention được chia sẻ giữa tất cả các modalities.
## PerceiverProjectionPostprocessor[[transformers.models.perceiver.modeling_perceiver.PerceiverProjectionPostprocessor]]
#### transformers.models.perceiver.modeling_perceiver.PerceiverProjectionPostprocessor[[transformers.models.perceiver.modeling_perceiver.PerceiverProjectionPostprocessor]]
```python
transformers.models.perceiver.modeling_perceiver.PerceiverProjectionPostprocessor(in_channels: int, out_channels: int)
```
[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L2804)
**Tham số:**
in_channels (`int`) : Số kênh trong đầu vào.
out_channels (`int`) : Số lượng kênh trong đầu ra.
Xử lý hậu xử lý chiếu cho Perceiver. Có thể được sử dụng để chiếu các kênh của đầu ra bộ giải mã xuống một chiều thấp hơn.
## PerceiverAudioPostprocessor[[transformers.models.perceiver.modeling_perceiver.PerceiverAudioPostprocessor]]
#### transformers.models.perceiver.modeling_perceiver.PerceiverAudioPostprocessor[[transformers.models.perceiver.modeling_perceiver.PerceiverAudioPostprocessor]]
```python
transformers.models.perceiver.modeling_perceiver.PerceiverAudioPostprocessor(config: PerceiverConfig, in_channels: int, postproc_type: str = 'patches')
```
[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L2777)
**Tham số:**
config ([*PerceiverConfig*]) : Cấu hình mô hình.
in_channels (`int`) : Số kênh trong đầu vào.
postproc_type (`str`, *tùy chọn*, mặc định là `"patches"`) : Kiểu postprocessor cần sử dụng. Hiện tại, chỉ hỗ trợ "patches".
Xử lý hậu kỳ âm thanh cho Perceiver. Có thể được sử dụng để chuyển đổi đầu ra của bộ giải mã thành các đặc trưng âm thanh.
## PerceiverClassificationPostprocessor[[transformers.models.perceiver.modeling_perceiver.PerceiverClassificationPostprocessor]]
#### transformers.models.perceiver.modeling_perceiver.PerceiverClassificationPostprocessor[[transformers.models.perceiver.modeling_perceiver.PerceiverClassificationPostprocessor]]
```python
transformers.models.perceiver.modeling_perceiver.PerceiverClassificationPostprocessor(config: PerceiverConfig, in_channels: int)
```
[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L2757)
**Tham số:**
config ([*PerceiverConfig*]) : Cấu hình mô hình.
in_channels (`int`) : Số kênh trong đầu vào.
Xử lý hậu phân loại cho Perceiver. Có thể được sử dụng để chuyển đổi đầu ra của bộ giải mã thành logits phân loại.
## PerceiverMultimodalPostprocessor[[transformers.models.perceiver.modeling_perceiver.PerceiverMultimodalPostprocessor]]
#### transformers.models.perceiver.modeling_perceiver.PerceiverMultimodalPostprocessor[[transformers.models.perceiver.modeling_perceiver.PerceiverMultimodalPostprocessor]]
```python
transformers.models.perceiver.modeling_perceiver.PerceiverMultimodalPostprocessor(modalities: Mapping, input_is_dict: bool = False)
```
[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L2723)
**Tham số:**
modalities (`Mapping[str, PostprocessorType]`) : Từ điển ánh xạ tên modality đến lớp postprocessor cho modality đó.
input_is_dict (`bool`, *tùy chọn*, mặc định là `False`) : Nếu là True, đầu vào được giả định có cấu trúc từ điển và các đầu ra giữ nguyên hình dạng từ điển đó. Nếu là False, đầu vào là một tensor, sẽ được cắt nhỏ trong quá trình xử lý hậu kỳ bởi *modality_sizes*.
Xử lý hậu kỳ đa phương thức cho Perceiver. Có thể được sử dụng để kết hợp các bộ xử lý hậu kỳ riêng cho từng phương thức thành một bộ xử lý hậu kỳ duy nhất.
## PerceiverModel[[transformers.PerceiverModel]]
#### transformers.PerceiverModel[[transformers.PerceiverModel]]
```python
transformers.PerceiverModel(config: PerceiverConfig, decoder: typing.Optional[ForwardRef('PerceiverAbstractDecoder')] = None, input_preprocessor: Callable = None, output_postprocessor: Callable = None)
```
[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L561)
**Tham số:**
config ([PerceiverConfig](/docs/transformers/main/vi/model_doc/perceiver#transformers.PerceiverConfig)) : Lớp cấu hình mô hình chứa tất cả các tham số của mô hình. Khởi tạo bằng tệp cấu hình sẽ không tải trọng số liên quan đến mô hình, chỉ tải cấu hình. Xem phương thức [from_pretrained()](/docs/transformers/main/vi/main_classes/model#transformers.PreTrainedModel.from_pretrained) để tải trọng số mô hình.
decoder (`PerceiverDecoder`, *tùy chọn*) : Module giải mã biến đổi các biểu diễn ẩn thành dự đoán cho tác vụ.
input_preprocessor (`PreprocessorType`, *tùy chọn*) : Bộ tiền xử lý mã hóa các đầu vào thô thành tensor cho mô hình.
output_postprocessor (`PostprocessorType`, *tùy chọn*) : Postprocessor biến đổi đầu ra của mô hình thành các dự đoán cuối cùng.
Perceiver: một kiến trúc hoàn toàn dựa trên chú ý, có khả năng mở rộng.
Lưu ý rằng bạn có thể tinh chỉnh Perceiver trên các hình ảnh có độ phân giải cao hơn so với những hình ảnh mà nó đã được huấn luyện, bằng cách đặt `interpolate_pos_encoding` thành `True` trong forward của mô hình. Thao tác này sẽ nội suy các position embeddings đã được huấn luyện trước lên độ phân giải cao hơn.
Mô hình này kế thừa từ [PreTrainedModel](/docs/transformers/main/vi/main_classes/model#transformers.PreTrainedModel). Xem tài liệu của lớp cha để biết các phương thức chung mà thư viện triển khai cho tất cả các mô hình của nó (chẳng hạn như tải xuống hoặc lưu trữ, thay đổi kích thước các nhúng đầu vào, cắt tỉa các đầu ra, v.v.)
Mô hình này cũng là một lớp con của [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) trong PyTorch. Hãy sử dụng nó như một Module PyTorch thông thường và tham khảo tài liệu PyTorch cho mọi vấn đề liên quan đến cách sử dụng và hành vi chung.
#### forward[[transformers.PerceiverModel.forward]]
```python
forward(inputs: Tensor, attention_mask: typing.Optional[torch.Tensor] = None, subsampled_output_points: dict[str, torch.Tensor] | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, interpolate_pos_encoding: bool = False, return_dict: bool | None = None, **kwargs)
```
[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L597)
**Tham số:**
inputs (`torch.Tensor`) : Đầu vào cho perceiver. Có thể là bất kỳ thứ gì: hình ảnh, văn bản, âm thanh, video, v.v.
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)
subsampled_output_points (`dict[str, torch.Tensor]`, *tùy chọn*) : Từ điển các tensor được dùng làm truy vấn cho bộ giải mã. Bộ giải mã ánh xạ các truy vấn này vào biểu diễn ẩn của mô hình. Được dùng cho việc giải mã lấy mẫu con, ví dụ khi chỉ giải mã một số mảng ảnh nhất định.
output_attentions (`bool`, *tùy chọn*) : Có trả về các tensor chú ý của tất cả các lớp chú ý hay không. Xem `attentions` trong phần tensor trả về để biết thêm chi tiết.
output_hidden_states (`bool`, *tuỳ chọn*) : Có trả về trạng thái ẩn của tất cả các lớp hay không. Xem `hidden_states` trong phần tensor trả về để biết thêm chi tiết.
interpolate_pos_encoding (`bool`, *tùy chọn*, mặc định là `False`) : Có nội suy các mã hóa vị trí được huấn luyện trước hay không.
return_dict (`bool`, *tùy chọn*) : Có trả về [ModelOutput](/docs/transformers/main/vi/main_classes/output#transformers.utils.ModelOutput) thay vì một tuple thông thường hay không.
**Trả về:** [PerceiverModelOutput](/docs/transformers/main/vi/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverModelOutput) hoặc `tuple(torch.Tensor)`
Một [PerceiverModelOutput](/docs/transformers/main/vi/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverModelOutput) hoặc một tuple của `torch.Tensor` (nếu `return_dict=False` được truyền hoặc khi `config.return_dict=False`) bao gồm các thành phần khác nhau tùy thuộc vào cấu hình ([PerceiverConfig](/docs/transformers/main/vi/model_doc/perceiver#transformers.PerceiverConfig)) và đầu vào.
Phương thức forward của [PerceiverModel](/docs/transformers/main/vi/model_doc/perceiver#transformers.PerceiverModel) 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.
- **logits** (`torch.Tensor` có hình dạng `(batch_size, num_labels)`) -- Điểm phân loại (hoặc hồi quy nếu config.num_labels==1) (trước SoftMax).
- **last_hidden_state** (`torch.Tensor` có hình dạng `(batch_size, sequence_length, hidden_size)`, *tùy chọn*) -- Chuỗi các hidden-state tại đầu ra của lớp cuối cùng của mô hình.
- **hidden_states** (`tuple[torch.Tensor]`, *tuỳ chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) -- Bộ tuple các `torch.Tensor` (một cho đầu ra của embeddings, nếu mô hình có lớp embedding, + một cho đầu ra của mỗi lớp) có hình dạng `(batch_size, sequence_length, hidden_size)`.
Trạng thái ẩn của mô hình tại đầu ra của mỗi lớp cùng với các đầu ra embedding ban đầu tùy chọn.
- **attentions** (`tuple[torch.Tensor]`, *tuỳ chọn*, được trả về khi `output_attentions=True` được truyền vào hoặc khi `config.output_attentions=True`) -- Bộ tuple của `torch.Tensor` (một cho mỗi lớp) có hình dạng `(batch_size, num_heads, sequence_length, sequence_length)`.
Trọng số chú ý sau softmax của attention, được sử dụng để tính trung bình có trọng số trong các đầu self-attention.
- **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.
Ví dụ:
```python
>>> from transformers import PerceiverConfig, PerceiverTokenizer, PerceiverImageProcessor, PerceiverModel
>>> from transformers.models.perceiver.modeling_perceiver import (
... PerceiverTextPreprocessor,
... PerceiverImagePreprocessor,
... PerceiverClassificationDecoder,
... )
>>> import torch
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO
>>> from PIL import Image
>>> # EXAMPLE 1: using the Perceiver to classify texts
>>> # - we define a TextPreprocessor, which can be used to embed tokens
>>> # - we define a ClassificationDecoder, which can be used to decode the
>>> # final hidden states of the latents to classification logits
>>> # using trainable position embeddings
>>> config = PerceiverConfig()
>>> preprocessor = PerceiverTextPreprocessor(config)
>>> decoder = PerceiverClassificationDecoder(
... config,
... num_channels=config.d_latents,
... trainable_position_encoding_kwargs=dict(num_channels=config.d_latents, index_dims=1),
... use_query_residual=True,
... )
>>> model = PerceiverModel(config, input_preprocessor=preprocessor, decoder=decoder)
>>> # you can then do a forward pass as follows:
>>> tokenizer = PerceiverTokenizer()
>>> text = "hello world"
>>> inputs = tokenizer(text, return_tensors="pt").input_ids
>>> with torch.no_grad():
... outputs = model(inputs=inputs)
>>> logits = outputs.logits
>>> list(logits.shape)
[1, 2]
>>> # to train, one can train the model using standard cross-entropy:
>>> criterion = torch.nn.CrossEntropyLoss()
>>> labels = torch.tensor([1])
>>> loss = criterion(logits, labels)
>>> # EXAMPLE 2: using the Perceiver to classify images
>>> # - we define an ImagePreprocessor, which can be used to embed images
>>> config = PerceiverConfig(image_size=224)
>>> preprocessor = PerceiverImagePreprocessor(
... config,
... prep_type="conv1x1",
... spatial_downsample=1,
... out_channels=256,
... position_encoding_type="trainable",
... concat_or_add_pos="concat",
... project_pos_dim=256,
... trainable_position_encoding_kwargs=dict(
... num_channels=256,
... index_dims=config.image_size**2,
... ),
... )
>>> model = PerceiverModel(
... config,
... input_preprocessor=preprocessor,
... decoder=PerceiverClassificationDecoder(
... config,
... num_channels=config.d_latents,
... trainable_position_encoding_kwargs=dict(num_channels=config.d_latents, index_dims=1),
... use_query_residual=True,
... ),
... )
>>> # you can then do a forward pass as follows:
>>> image_processor = PerceiverImageProcessor()
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> with httpx.stream("GET", url) as response:
... image = Image.open(BytesIO(response.read()))
>>> inputs = image_processor(image, return_tensors="pt").pixel_values
>>> with torch.no_grad():
... outputs = model(inputs=inputs)
>>> logits = outputs.logits
>>> list(logits.shape)
[1, 2]
>>> # to train, one can train the model using standard cross-entropy:
>>> criterion = torch.nn.CrossEntropyLoss()
>>> labels = torch.tensor([1])
>>> loss = criterion(logits, labels)
```
## PerceiverForMaskedLM[[transformers.PerceiverForMaskedLM]]
#### transformers.PerceiverForMaskedLM[[transformers.PerceiverForMaskedLM]]
```python
transformers.PerceiverForMaskedLM(config: PerceiverConfig)
```
[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L807)
**Tham số:**
config ([PerceiverConfig](/docs/transformers/main/vi/model_doc/perceiver#transformers.PerceiverConfig)) : Lớp cấu hình mô hình chứa tất cả các tham số của mô hình. Khởi tạo bằng tệp cấu hình sẽ không tải trọng số liên quan đến mô hình, chỉ tải cấu hình. Xem phương thức [from_pretrained()](/docs/transformers/main/vi/main_classes/model#transformers.PreTrainedModel.from_pretrained) để tải trọng số mô hình.
Ví dụ sử dụng Perceiver cho mô hình hóa ngôn ngữ có che (masked language modeling).
Mô hình này kế thừa từ [PreTrainedModel](/docs/transformers/main/vi/main_classes/model#transformers.PreTrainedModel). Xem tài liệu của lớp cha để biết các phương thức chung mà thư viện triển khai cho tất cả các mô hình của nó (chẳng hạn như tải xuống hoặc lưu trữ, thay đổi kích thước các nhúng đầu vào, cắt tỉa các đầu ra, v.v.)
Mô hình này cũng là một lớp con của [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) trong PyTorch. Hãy sử dụng nó như một Module PyTorch thông thường và tham khảo tài liệu PyTorch cho mọi vấn đề liên quan đến cách sử dụng và hành vi chung.
#### forward[[transformers.PerceiverForMaskedLM.forward]]
```python
forward(inputs: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, labels: typing.Optional[torch.Tensor] = None, return_dict: bool | None = None, input_ids: typing.Optional[torch.Tensor] = None, **kwargs)
```
[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L839)
**Tham số:**
inputs (`torch.Tensor`, *tùy chọn*) : Đầu vào cho perceiver. Có thể là bất kỳ thứ gì: hình ảnh, văn bản, âm thanh, video, v.v.
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)
output_attentions (`bool`, *tùy chọn*) : Có trả về các tensor chú ý của tất cả các lớp chú ý hay không. Xem `attentions` trong phần tensor trả về để biết thêm chi tiết.
output_hidden_states (`bool`, *tuỳ chọn*) : Có trả về trạng thái ẩn của tất cả các lớp hay không. Xem `hidden_states` trong phần tensor trả về để biết thêm chi tiết.
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ó che (masked language modeling loss). Chỉ số phải nằm trong `[-100, 0, ..., config.vocab_size]` (xem docstring của `input_ids`). Các token có chỉ số được đặt thành `-100` sẽ bị bỏ qua (che), tổn thất chỉ được tính cho các token có nhãn nằm trong `[0, ..., config.vocab_size]`.
return_dict (`bool`, *tùy chọn*) : Có trả về [ModelOutput](/docs/transformers/main/vi/main_classes/output#transformers.utils.ModelOutput) thay vì một tuple thông thường hay không.
input_ids (`torch.Tensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Chỉ số của các token trong chuỗi đầu vào theo từ vựng. Mặc định, các token đệm (padding) sẽ bị bỏ qua. Có thể lấy chỉ số bằng cách sử dụng [AutoTokenizer](/docs/transformers/main/vi/model_doc/auto#transformers.AutoTokenizer). Xem [PreTrainedTokenizer.encode()](/docs/transformers/main/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) và [PreTrainedTokenizer.__call__()](/docs/transformers/main/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) để biết thêm chi tiết. [ID đầu vào là gì?](../glossary#input-ids)
**Trả về:** [PerceiverMaskedLMOutput](/docs/transformers/main/vi/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverMaskedLMOutput) hoặc `tuple(torch.Tensor)`
Một [PerceiverMaskedLMOutput](/docs/transformers/main/vi/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverMaskedLMOutput) 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 ([PerceiverConfig](/docs/transformers/main/vi/model_doc/perceiver#transformers.PerceiverConfig)) và đầu vào.
Phương thức forward của [PerceiverForMaskedLM](/docs/transformers/main/vi/model_doc/perceiver#transformers.PerceiverForMaskedLM) 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ó 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]`, *tuỳ chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) -- Bộ tuple các `torch.Tensor` (một cho đầu ra của embeddings, nếu mô hình có lớp embedding, + một cho đầu ra của mỗi lớp) có hình dạng `(batch_size, sequence_length, hidden_size)`.
Trạng thái ẩn của mô hình tại đầu ra của mỗi lớp cùng với các đầu ra embedding ban đầu tùy chọn.
- **attentions** (`tuple[torch.Tensor]`, *tuỳ chọn*, được trả về khi `output_attentions=True` được truyền vào hoặc khi `config.output_attentions=True`) -- Bộ tuple của `torch.Tensor` (một cho mỗi lớp) có hình dạng `(batch_size, num_heads, sequence_length, sequence_length)`.
Trọng số chú ý sau softmax của attention, được sử dụng để tính trung bình có trọng số trong các đầu self-attention.
- **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.
Ví dụ:
```python
>>> from transformers import AutoTokenizer, PerceiverForMaskedLM
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("deepmind/language-perceiver")
>>> model = PerceiverForMaskedLM.from_pretrained("deepmind/language-perceiver")
>>> # training
>>> text = "This is an incomplete sentence where some words are missing."
>>> inputs = tokenizer(text, padding="max_length", return_tensors="pt")
>>> # mask " missing."
>>> inputs["input_ids"][0, 52:61] = tokenizer.mask_token_id
>>> labels = tokenizer(text, padding="max_length", return_tensors="pt").input_ids
>>> outputs = model(**inputs, labels=labels)
>>> loss = outputs.loss
>>> round(loss.item(), 2)
19.87
>>> logits = outputs.logits
>>> list(logits.shape)
[1, 2048, 262]
>>> # inference
>>> text = "This is an incomplete sentence where some words are missing."
>>> encoding = tokenizer(text, padding="max_length", return_tensors="pt")
>>> # mask bytes corresponding to " missing.". Note that the model performs much better if the masked span starts with a space.
>>> encoding["input_ids"][0, 52:61] = tokenizer.mask_token_id
>>> # forward pass
>>> with torch.no_grad():
... outputs = model(**encoding)
>>> logits = outputs.logits
>>> list(logits.shape)
[1, 2048, 262]
>>> masked_tokens_predictions = logits[0, 52:61].argmax(dim=-1).tolist()
>>> tokenizer.decode(masked_tokens_predictions)
' missing.'
```
## PerceiverForSequenceClassification[[transformers.PerceiverForSequenceClassification]]
#### transformers.PerceiverForSequenceClassification[[transformers.PerceiverForSequenceClassification]]
```python
transformers.PerceiverForSequenceClassification(config: PerceiverConfig)
```
[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L940)
**Tham số:**
config ([PerceiverConfig](/docs/transformers/main/vi/model_doc/perceiver#transformers.PerceiverConfig)) : Lớp cấu hình mô hình chứa tất cả các tham số của mô hình. Khởi tạo bằng tệp cấu hình sẽ không tải trọng số liên quan đến mô hình, chỉ tải cấu hình. Xem phương thức [from_pretrained()](/docs/transformers/main/vi/main_classes/model#transformers.PreTrainedModel.from_pretrained) để tải trọng số mô hình.
Ví dụ sử dụng Perceiver cho phân loại văn bản.
Mô hình này kế thừa từ [PreTrainedModel](/docs/transformers/main/vi/main_classes/model#transformers.PreTrainedModel). Xem tài liệu của lớp cha để biết các phương thức chung mà thư viện triển khai cho tất cả các mô hình của nó (chẳng hạn như tải xuống hoặc lưu trữ, thay đổi kích thước các nhúng đầu vào, cắt tỉa các đầu ra, v.v.)
Mô hình này cũng là một lớp con của [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) trong PyTorch. Hãy sử dụng nó như một Module PyTorch thông thường và tham khảo tài liệu PyTorch cho mọi vấn đề liên quan đến cách sử dụng và hành vi chung.
#### forward[[transformers.PerceiverForSequenceClassification.forward]]
```python
forward(inputs: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, labels: typing.Optional[torch.Tensor] = None, return_dict: bool | None = None, input_ids: typing.Optional[torch.Tensor] = None, **kwargs)
```
[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L961)
**Tham số:**
inputs (`torch.Tensor`, *tùy chọn*) : Đầu vào cho perceiver. Có thể là bất kỳ thứ gì: hình ảnh, văn bản, âm thanh, video, v.v.
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)
output_attentions (`bool`, *tùy chọn*) : Có trả về các tensor chú ý của tất cả các lớp chú ý hay không. Xem `attentions` trong phần tensor trả về để biết thêm chi tiết.
output_hidden_states (`bool`, *tuỳ chọn*) : Có trả về trạng thái ẩn của tất cả các lớp hay không. Xem `hidden_states` trong phần tensor trả về để biết thêm chi tiết.
labels (`torch.LongTensor` có hình dạng `(batch_size,)`, *tùy chọn*) : Nhãn để tính toán tổn thất phân loại/hồi quy. Chỉ số phải nằm trong `[0, ..., config.num_labels - 1]`. Nếu `config.num_labels == 1`, tổn thất hồi quy sẽ được tính toán (tổn thất Mean-Square), nếu `config.num_labels > 1`, tổn thất phân loại sẽ được tính toán (Cross-Entropy).
return_dict (`bool`, *tùy chọn*) : Có trả về [ModelOutput](/docs/transformers/main/vi/main_classes/output#transformers.utils.ModelOutput) thay vì một tuple thông thường hay không.
input_ids (`torch.Tensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Chỉ số của các token trong chuỗi đầu vào theo từ vựng. Mặc định, các token đệm (padding) sẽ bị bỏ qua. Có thể lấy chỉ số bằng cách sử dụng [AutoTokenizer](/docs/transformers/main/vi/model_doc/auto#transformers.AutoTokenizer). Xem [PreTrainedTokenizer.encode()](/docs/transformers/main/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) và [PreTrainedTokenizer.__call__()](/docs/transformers/main/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) để biết thêm chi tiết. [ID đầu vào là gì?](../glossary#input-ids)
**Trả về:** [PerceiverClassifierOutput](/docs/transformers/main/vi/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput) hoặc `tuple(torch.Tensor)`
Một [PerceiverClassifierOutput](/docs/transformers/main/vi/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput) hoặc một tuple của `torch.Tensor` (nếu `return_dict=False` được truyền hoặc khi `config.return_dict=False`) bao gồm các thành phần khác nhau tùy thuộc vào cấu hình ([PerceiverConfig](/docs/transformers/main/vi/model_doc/perceiver#transformers.PerceiverConfig)) và đầu vào.
Phương thức forward của [PerceiverForSequenceClassification](/docs/transformers/main/vi/model_doc/perceiver#transformers.PerceiverForSequenceClassification) ghi đè lên phương thức đặc biệt `__call__`.
Mặc dù công thức cho bước truyền tiến cần được định nghĩa bên trong hàm này, bạn nên gọi instance của `Module` sau đó thay vì gọi hàm này, vì instance `Module` sẽ đảm nhận việc thực hiện các bước tiền xử lý và hậu xử lý, trong khi hàm này sẽ bỏ qua chúng một cách im lặng.
- **loss** (`torch.Tensor` có shape `(1,)`, *optional*, được trả về khi `labels` được cung cấp) -- Loss 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]`, *tuỳ chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) -- Bộ tuple các `torch.Tensor` (một cho đầu ra của embeddings, nếu mô hình có lớp embedding, + một cho đầu ra của mỗi lớp) có hình dạng `(batch_size, sequence_length, hidden_size)`.
Trạng thái ẩn của mô hình tại đầu ra của mỗi lớp cùng với các đầu ra embedding ban đầu tùy chọn.
- **attentions** (`tuple[torch.Tensor]`, *tuỳ chọn*, được trả về khi `output_attentions=True` được truyền vào hoặc khi `config.output_attentions=True`) -- Bộ tuple của `torch.Tensor` (một cho mỗi lớp) có hình dạng `(batch_size, num_heads, sequence_length, sequence_length)`.
Trọng số chú ý sau softmax của attention, được sử dụng để tính trung bình có trọng số trong các đầu self-attention.
- **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.
Ví dụ:
```python
>>> from transformers import AutoTokenizer, PerceiverForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("deepmind/language-perceiver")
>>> model = PerceiverForSequenceClassification.from_pretrained("deepmind/language-perceiver")
>>> text = "hello world"
>>> inputs = tokenizer(text, return_tensors="pt").input_ids
>>> outputs = model(inputs=inputs)
>>> logits = outputs.logits
>>> list(logits.shape)
[1, 2]
```
## PerceiverForImageClassificationLearned[[transformers.PerceiverForImageClassificationLearned]]
#### transformers.PerceiverForImageClassificationLearned[[transformers.PerceiverForImageClassificationLearned]]
```python
transformers.PerceiverForImageClassificationLearned(config: PerceiverConfig)
```
[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L1062)
**Tham số:**
config ([PerceiverConfig](/docs/transformers/main/vi/model_doc/perceiver#transformers.PerceiverConfig)) : Lớp cấu hình mô hình chứa tất cả các tham số của mô hình. Khởi tạo bằng tệp cấu hình sẽ không tải trọng số liên quan đến mô hình, chỉ tải cấu hình. Xem phương thức [from_pretrained()](/docs/transformers/main/vi/main_classes/model#transformers.PreTrainedModel.from_pretrained) để tải trọng số mô hình.
Ví dụ sử dụng Perceiver cho phân loại ảnh, cho các tác vụ như ImageNet.
Mô hình này sử dụng các vị trí nhúng (position embeddings) được học. Nói cách khác, mô hình này không nhận được bất kỳ thông tin đặc quyền nào về cấu trúc của hình ảnh. Như đã trình bày trong bài báo, mô hình này có thể đạt độ chính xác top-1 là 72.7 trên ImageNet.
[PerceiverForImageClassificationLearned](/docs/transformers/main/vi/model_doc/perceiver#transformers.PerceiverForImageClassificationLearned) sử dụng [PerceiverImagePreprocessor](/docs/transformers/main/vi/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverImagePreprocessor) (với `prep_type="conv1x1"`) để tiền xử lý các ảnh đầu vào, và [PerceiverClassificationDecoder](/docs/transformers/main/vi/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverClassificationDecoder) để giải mã biểu diễn ẩn của [PerceiverModel](/docs/transformers/main/vi/model_doc/perceiver#transformers.PerceiverModel) thành các logits phân loại.
Mô hình này kế thừa từ [PreTrainedModel](/docs/transformers/main/vi/main_classes/model#transformers.PreTrainedModel). Xem tài liệu của lớp cha để biết các phương thức chung mà thư viện triển khai cho tất cả các mô hình của nó (chẳng hạn như tải xuống hoặc lưu trữ, thay đổi kích thước các nhúng đầu vào, cắt tỉa các đầu ra, v.v.)
Mô hình này cũng là một lớp con của [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) trong PyTorch. Hãy sử dụng nó như một Module PyTorch thông thường và tham khảo tài liệu PyTorch cho mọi vấn đề liên quan đến cách sử dụng và hành vi chung.
#### forward[[transformers.PerceiverForImageClassificationLearned.forward]]
```python
forward(inputs: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, labels: typing.Optional[torch.Tensor] = None, interpolate_pos_encoding: bool = False, return_dict: bool | None = None, pixel_values: typing.Optional[torch.Tensor] = None, **kwargs)
```
[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L1093)
**Tham số:**
inputs (`torch.Tensor`, *tùy chọn*) : Đầu vào cho perceiver. Có thể là bất kỳ thứ gì: hình ảnh, văn bản, âm thanh, video, v.v.
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)
output_attentions (`bool`, *tùy chọn*) : Có trả về các tensor chú ý của tất cả các lớp chú ý hay không. Xem `attentions` trong phần tensor trả về để biết thêm chi tiết.
output_hidden_states (`bool`, *tuỳ chọn*) : Có trả về trạng thái ẩn của tất cả các lớp hay không. Xem `hidden_states` trong phần tensor trả về để biết thêm chi tiết.
labels (`torch.LongTensor` có hình dạng `(batch_size,)`, *tùy chọn*) : Nhãn để tính toán tổn thất phân loại/hồi quy hình ảnh. Chỉ số phải nằm trong `[0, ..., config.num_labels - 1]`. Nếu `config.num_labels == 1`, tổn thất hồi quy sẽ được tính toán (tổn thất Mean-Square). Nếu `config.num_labels > 1`, tổn thất phân loại sẽ được tính toán (Cross-Entropy).
interpolate_pos_encoding (`bool`, *tùy chọn*, mặc định là `False`) : Có nội suy các mã hóa vị trí được huấn luyện trước hay không.
return_dict (`bool`, *tùy chọn*) : Có trả về [ModelOutput](/docs/transformers/main/vi/main_classes/output#transformers.utils.ModelOutput) thay vì một tuple thông thường hay không.
pixel_values (`torch.Tensor` có shape `(batch_size, num_channels, image_size, image_size)`, *optional*) : Các tensor tương ứng với các ảnh đầu vào. Giá trị pixel có thể được lấy bằng cách sử dụng [PerceiverImageProcessor](/docs/transformers/main/vi/model_doc/perceiver#transformers.PerceiverImageProcessor). Xem [PerceiverImageProcessor.__call__()](/docs/transformers/main/vi/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) để biết chi tiết (`processor_class` sử dụng [PerceiverImageProcessor](/docs/transformers/main/vi/model_doc/perceiver#transformers.PerceiverImageProcessor) để xử lý ảnh).
**Trả về:** [PerceiverClassifierOutput](/docs/transformers/main/vi/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput) hoặc `tuple(torch.Tensor)`
Một [PerceiverClassifierOutput](/docs/transformers/main/vi/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput) hoặc một tuple của `torch.Tensor` (nếu `return_dict=False` được truyền hoặc khi `config.return_dict=False`) bao gồm các thành phần khác nhau tùy thuộc vào cấu hình ([PerceiverConfig](/docs/transformers/main/vi/model_doc/perceiver#transformers.PerceiverConfig)) và đầu vào.
Phương thức forward của [PerceiverForImageClassificationLearned](/docs/transformers/main/vi/model_doc/perceiver#transformers.PerceiverForImageClassificationLearned) ghi đè lên phương thức đặc biệt `__call__`.
Mặc dù công thức cho bước truyền tiến cần được định nghĩa bên trong hàm này, bạn nên gọi instance của `Module` sau đó thay vì gọi hàm này, vì instance `Module` sẽ đảm nhận việc thực hiện các bước tiền xử lý và hậu xử lý, trong khi hàm này sẽ bỏ qua chúng một cách im lặng.
- **loss** (`torch.Tensor` có shape `(1,)`, *optional*, được trả về khi `labels` được cung cấp) -- Loss 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]`, *tuỳ chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) -- Bộ tuple các `torch.Tensor` (một cho đầu ra của embeddings, nếu mô hình có lớp embedding, + một cho đầu ra của mỗi lớp) có hình dạng `(batch_size, sequence_length, hidden_size)`.
Trạng thái ẩn của mô hình tại đầu ra của mỗi lớp cùng với các đầu ra embedding ban đầu tùy chọn.
- **attentions** (`tuple[torch.Tensor]`, *tuỳ chọn*, được trả về khi `output_attentions=True` được truyền vào hoặc khi `config.output_attentions=True`) -- Bộ tuple của `torch.Tensor` (một cho mỗi lớp) có hình dạng `(batch_size, num_heads, sequence_length, sequence_length)`.
Trọng số chú ý sau softmax của attention, được sử dụng để tính trung bình có trọng số trong các đầu self-attention.
- **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.
Ví dụ:
```python
>>> from transformers import AutoImageProcessor, PerceiverForImageClassificationLearned
>>> from PIL import Image
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> with httpx.stream("GET", url) as response:
... image = Image.open(BytesIO(response.read()))
>>> image_processor = AutoImageProcessor.from_pretrained("deepmind/vision-perceiver-learned")
>>> model = PerceiverForImageClassificationLearned.from_pretrained("deepmind/vision-perceiver-learned")
>>> inputs = image_processor(images=image, return_tensors="pt").pixel_values
>>> outputs = model(inputs=inputs)
>>> logits = outputs.logits
>>> list(logits.shape)
[1, 1000]
>>> # model predicts one of the 1000 ImageNet classes
>>> predicted_class_idx = logits.argmax(-1).item()
>>> print("Predicted class:", model.config.id2label[predicted_class_idx])
Predicted class: tabby, tabby cat
```
## PerceiverForImageClassificationFourier[[transformers.PerceiverForImageClassificationFourier]]
#### transformers.PerceiverForImageClassificationFourier[[transformers.PerceiverForImageClassificationFourier]]
```python
transformers.PerceiverForImageClassificationFourier(config: PerceiverConfig)
```
[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L1187)
**Tham số:**
config ([PerceiverConfig](/docs/transformers/main/vi/model_doc/perceiver#transformers.PerceiverConfig)) : Lớp cấu hình mô hình chứa tất cả các tham số của mô hình. Khởi tạo bằng tệp cấu hình sẽ không tải trọng số liên quan đến mô hình, chỉ tải cấu hình. Xem phương thức [from_pretrained()](/docs/transformers/main/vi/main_classes/model#transformers.PreTrainedModel.from_pretrained) để tải trọng số mô hình.
Ví dụ sử dụng Perceiver cho phân loại ảnh, cho các tác vụ như ImageNet.
Mô hình này sử dụng nhúng vị trí Fourier 2D cố định. Như đã trình bày trong bài báo, mô hình này có thể đạt độ chính xác top-1 là 79.0 trên ImageNet, và 84.5 khi được huấn luyện trước trên một tập dữ liệu quy mô lớn (tức là JFT).
[PerceiverForImageClassificationLearned](/docs/transformers/main/vi/model_doc/perceiver#transformers.PerceiverForImageClassificationLearned) sử dụng [PerceiverImagePreprocessor](/docs/transformers/main/vi/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverImagePreprocessor) (với `prep_type="pixels"`) để tiền xử lý các ảnh đầu vào, và [PerceiverClassificationDecoder](/docs/transformers/main/vi/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverClassificationDecoder) để giải mã biểu diễn ẩn của [PerceiverModel](/docs/transformers/main/vi/model_doc/perceiver#transformers.PerceiverModel) thành các logits phân loại.
Mô hình này kế thừa từ [PreTrainedModel](/docs/transformers/main/vi/main_classes/model#transformers.PreTrainedModel). Xem tài liệu của lớp cha để biết các phương thức chung mà thư viện triển khai cho tất cả các mô hình của nó (chẳng hạn như tải xuống hoặc lưu trữ, thay đổi kích thước các nhúng đầu vào, cắt tỉa các đầu ra, v.v.)
Mô hình này cũng là một lớp con của [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) trong PyTorch. Hãy sử dụng nó như một Module PyTorch thông thường và tham khảo tài liệu PyTorch cho mọi vấn đề liên quan đến cách sử dụng và hành vi chung.
#### forward[[transformers.PerceiverForImageClassificationFourier.forward]]
```python
forward(inputs: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, labels: typing.Optional[torch.Tensor] = None, return_dict: bool | None = None, pixel_values: typing.Optional[torch.Tensor] = None, **kwargs)
```
[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L1219)
**Tham số:**
inputs (`torch.Tensor`, *tùy chọn*) : Đầu vào cho perceiver. Có thể là bất kỳ thứ gì: hình ảnh, văn bản, âm thanh, video, v.v.
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)
output_attentions (`bool`, *tùy chọn*) : Có trả về các tensor chú ý của tất cả các lớp chú ý hay không. Xem `attentions` trong phần tensor trả về để biết thêm chi tiết.
output_hidden_states (`bool`, *tuỳ chọn*) : Có trả về trạng thái ẩn của tất cả các lớp hay không. Xem `hidden_states` trong phần tensor trả về để biết thêm chi tiết.
labels (`torch.LongTensor` có hình dạng `(batch_size,)`, *tùy chọn*) : Nhãn để tính toán tổn thất phân loại/hồi quy hình ảnh. Chỉ số phải nằm trong `[0, ..., config.num_labels - 1]`. Nếu `config.num_labels == 1`, tổn thất hồi quy sẽ được tính toán (tổn thất Mean-Square). Nếu `config.num_labels > 1`, tổn thất phân loại sẽ được tính toán (Cross-Entropy).
return_dict (`bool`, *tùy chọn*) : Có trả về [ModelOutput](/docs/transformers/main/vi/main_classes/output#transformers.utils.ModelOutput) thay vì một tuple thông thường hay không.
pixel_values (`torch.Tensor` có shape `(batch_size, num_channels, image_size, image_size)`, *optional*) : Các tensor tương ứng với các ảnh đầu vào. Giá trị pixel có thể được lấy bằng cách sử dụng [PerceiverImageProcessor](/docs/transformers/main/vi/model_doc/perceiver#transformers.PerceiverImageProcessor). Xem [PerceiverImageProcessor.__call__()](/docs/transformers/main/vi/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) để biết chi tiết (`processor_class` sử dụng [PerceiverImageProcessor](/docs/transformers/main/vi/model_doc/perceiver#transformers.PerceiverImageProcessor) để xử lý ảnh).
**Trả về:** [PerceiverClassifierOutput](/docs/transformers/main/vi/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput) hoặc `tuple(torch.Tensor)`
Một [PerceiverClassifierOutput](/docs/transformers/main/vi/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput) hoặc một tuple của `torch.Tensor` (nếu `return_dict=False` được truyền hoặc khi `config.return_dict=False`) bao gồm các thành phần khác nhau tùy thuộc vào cấu hình ([PerceiverConfig](/docs/transformers/main/vi/model_doc/perceiver#transformers.PerceiverConfig)) và đầu vào.
Phương thức forward của [PerceiverForImageClassificationFourier](/docs/transformers/main/vi/model_doc/perceiver#transformers.PerceiverForImageClassificationFourier) ghi đè lên phương thức đặc biệt `__call__`.
Mặc dù công thức cho bước truyền tiến cần được định nghĩa bên trong hàm này, bạn nên gọi instance của `Module` sau đó thay vì gọi hàm này, vì instance `Module` sẽ đảm nhận việc thực hiện các bước tiền xử lý và hậu xử lý, trong khi hàm này sẽ bỏ qua chúng một cách im lặng.
- **loss** (`torch.Tensor` có shape `(1,)`, *optional*, được trả về khi `labels` được cung cấp) -- Loss 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]`, *tuỳ chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) -- Bộ tuple các `torch.Tensor` (một cho đầu ra của embeddings, nếu mô hình có lớp embedding, + một cho đầu ra của mỗi lớp) có hình dạng `(batch_size, sequence_length, hidden_size)`.
Trạng thái ẩn của mô hình tại đầu ra của mỗi lớp cùng với các đầu ra embedding ban đầu tùy chọn.
- **attentions** (`tuple[torch.Tensor]`, *tuỳ chọn*, được trả về khi `output_attentions=True` được truyền vào hoặc khi `config.output_attentions=True`) -- Bộ tuple của `torch.Tensor` (một cho mỗi lớp) có hình dạng `(batch_size, num_heads, sequence_length, sequence_length)`.
Trọng số chú ý sau softmax của attention, được sử dụng để tính trung bình có trọng số trong các đầu self-attention.
- **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.
Ví dụ:
```python
>>> from transformers import AutoImageProcessor, PerceiverForImageClassificationFourier
>>> from PIL import Image
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> with httpx.stream("GET", url) as response:
... image = Image.open(BytesIO(response.read()))
>>> image_processor = AutoImageProcessor.from_pretrained("deepmind/vision-perceiver-fourier")
>>> model = PerceiverForImageClassificationFourier.from_pretrained("deepmind/vision-perceiver-fourier")
>>> inputs = image_processor(images=image, return_tensors="pt").pixel_values
>>> outputs = model(inputs=inputs)
>>> logits = outputs.logits
>>> list(logits.shape)
[1, 1000]
>>> # model predicts one of the 1000 ImageNet classes
>>> predicted_class_idx = logits.argmax(-1).item()
>>> print("Predicted class:", model.config.id2label[predicted_class_idx])
Predicted class: tabby, tabby cat
```
## PerceiverForImageClassificationConvProcessing[[transformers.PerceiverForImageClassificationConvProcessing]]
#### transformers.PerceiverForImageClassificationConvProcessing[[transformers.PerceiverForImageClassificationConvProcessing]]
```python
transformers.PerceiverForImageClassificationConvProcessing(config: PerceiverConfig)
```
[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L1310)
**Tham số:**
config ([PerceiverConfig](/docs/transformers/main/vi/model_doc/perceiver#transformers.PerceiverConfig)) : Lớp cấu hình mô hình chứa tất cả các tham số của mô hình. Khởi tạo bằng tệp cấu hình sẽ không tải trọng số liên quan đến mô hình, chỉ tải cấu hình. Xem phương thức [from_pretrained()](/docs/transformers/main/vi/main_classes/model#transformers.PreTrainedModel.from_pretrained) để tải trọng số mô hình.
Ví dụ sử dụng Perceiver cho phân loại ảnh, cho các tác vụ như ImageNet.
Mô hình này sử dụng mạng tiền xử lý conv+maxpool 2D. Như đã trình bày trong bài báo, mô hình này có thể đạt độ chính xác top-1 là 82,1 trên ImageNet.
[PerceiverForImageClassificationLearned](/docs/transformers/main/vi/model_doc/perceiver#transformers.PerceiverForImageClassificationLearned) sử dụng [PerceiverImagePreprocessor](/docs/transformers/main/vi/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverImagePreprocessor) (với `prep_type="conv"`) để tiền xử lý các ảnh đầu vào, và [PerceiverClassificationDecoder](/docs/transformers/main/vi/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverClassificationDecoder) để giải mã biểu diễn ẩn của [PerceiverModel](/docs/transformers/main/vi/model_doc/perceiver#transformers.PerceiverModel) thành các logits phân loại.
Mô hình này kế thừa từ [PreTrainedModel](/docs/transformers/main/vi/main_classes/model#transformers.PreTrainedModel). Xem tài liệu của lớp cha để biết các phương thức chung mà thư viện triển khai cho tất cả các mô hình của nó (chẳng hạn như tải xuống hoặc lưu trữ, thay đổi kích thước các nhúng đầu vào, cắt tỉa các đầu ra, v.v.)
Mô hình này cũng là một lớp con của [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) trong PyTorch. Hãy sử dụng nó như một Module PyTorch thông thường và tham khảo tài liệu PyTorch cho mọi vấn đề liên quan đến cách sử dụng và hành vi chung.
#### forward[[transformers.PerceiverForImageClassificationConvProcessing.forward]]
```python
forward(inputs: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, labels: typing.Optional[torch.Tensor] = None, return_dict: bool | None = None, pixel_values: typing.Optional[torch.Tensor] = None, **kwargs)
```
[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L1343)
**Tham số:**
inputs (`torch.Tensor`, *tùy chọn*) : Đầu vào cho perceiver. Có thể là bất kỳ thứ gì: hình ảnh, văn bản, âm thanh, video, v.v.
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)
output_attentions (`bool`, *tùy chọn*) : Có trả về các tensor chú ý của tất cả các lớp chú ý hay không. Xem `attentions` trong phần tensor trả về để biết thêm chi tiết.
output_hidden_states (`bool`, *tuỳ chọn*) : Có trả về trạng thái ẩn của tất cả các lớp hay không. Xem `hidden_states` trong phần tensor trả về để biết thêm chi tiết.
labels (`torch.LongTensor` có hình dạng `(batch_size,)`, *tùy chọn*) : Nhãn để tính toán tổn thất phân loại/hồi quy hình ảnh. Chỉ số phải nằm trong `[0, ..., config.num_labels - 1]`. Nếu `config.num_labels == 1`, tổn thất hồi quy sẽ được tính toán (tổn thất Mean-Square). Nếu `config.num_labels > 1`, tổn thất phân loại sẽ được tính toán (Cross-Entropy).
return_dict (`bool`, *tùy chọn*) : Có trả về [ModelOutput](/docs/transformers/main/vi/main_classes/output#transformers.utils.ModelOutput) thay vì một tuple thông thường hay không.
pixel_values (`torch.Tensor` có shape `(batch_size, num_channels, image_size, image_size)`, *optional*) : Các tensor tương ứng với các ảnh đầu vào. Giá trị pixel có thể được lấy bằng cách sử dụng [PerceiverImageProcessor](/docs/transformers/main/vi/model_doc/perceiver#transformers.PerceiverImageProcessor). Xem [PerceiverImageProcessor.__call__()](/docs/transformers/main/vi/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) để biết chi tiết (`processor_class` sử dụng [PerceiverImageProcessor](/docs/transformers/main/vi/model_doc/perceiver#transformers.PerceiverImageProcessor) để xử lý ảnh).
**Trả về:** [PerceiverClassifierOutput](/docs/transformers/main/vi/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput) hoặc `tuple(torch.Tensor)`
Một [PerceiverClassifierOutput](/docs/transformers/main/vi/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput) hoặc một tuple của `torch.Tensor` (nếu `return_dict=False` được truyền hoặc khi `config.return_dict=False`) bao gồm các thành phần khác nhau tùy thuộc vào cấu hình ([PerceiverConfig](/docs/transformers/main/vi/model_doc/perceiver#transformers.PerceiverConfig)) và đầu vào.
Phương thức forward của [PerceiverForImageClassificationConvProcessing](/docs/transformers/main/vi/model_doc/perceiver#transformers.PerceiverForImageClassificationConvProcessing) ghi đè lên phương thức đặc biệt `__call__`.
Mặc dù công thức cho bước truyền tiến cần được định nghĩa bên trong hàm này, bạn nên gọi instance của `Module` sau đó thay vì gọi hàm này, vì instance `Module` sẽ đảm nhận việc thực hiện các bước tiền xử lý và hậu xử lý, trong khi hàm này sẽ bỏ qua chúng một cách im lặng.
- **loss** (`torch.Tensor` có shape `(1,)`, *optional*, được trả về khi `labels` được cung cấp) -- Loss 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]`, *tuỳ chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) -- Bộ tuple các `torch.Tensor` (một cho đầu ra của embeddings, nếu mô hình có lớp embedding, + một cho đầu ra của mỗi lớp) có hình dạng `(batch_size, sequence_length, hidden_size)`.
Trạng thái ẩn của mô hình tại đầu ra của mỗi lớp cùng với các đầu ra embedding ban đầu tùy chọn.
- **attentions** (`tuple[torch.Tensor]`, *tuỳ chọn*, được trả về khi `output_attentions=True` được truyền vào hoặc khi `config.output_attentions=True`) -- Bộ tuple của `torch.Tensor` (một cho mỗi lớp) có hình dạng `(batch_size, num_heads, sequence_length, sequence_length)`.
Trọng số chú ý sau softmax của attention, được sử dụng để tính trung bình có trọng số trong các đầu self-attention.
- **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.
Ví dụ:
```python
>>> from transformers import AutoImageProcessor, PerceiverForImageClassificationConvProcessing
>>> from PIL import Image
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> with httpx.stream("GET", url) as response:
... image = Image.open(BytesIO(response.read()))
>>> image_processor = AutoImageProcessor.from_pretrained("deepmind/vision-perceiver-conv")
>>> model = PerceiverForImageClassificationConvProcessing.from_pretrained("deepmind/vision-perceiver-conv")
>>> inputs = image_processor(images=image, return_tensors="pt").pixel_values
>>> outputs = model(inputs=inputs)
>>> logits = outputs.logits
>>> list(logits.shape)
[1, 1000]
>>> # model predicts one of the 1000 ImageNet classes
>>> predicted_class_idx = logits.argmax(-1).item()
>>> print("Predicted class:", model.config.id2label[predicted_class_idx])
Predicted class: tabby, tabby cat
```
## PerceiverForOpticalFlow[[transformers.PerceiverForOpticalFlow]]
#### transformers.PerceiverForOpticalFlow[[transformers.PerceiverForOpticalFlow]]
```python
transformers.PerceiverForOpticalFlow(config: PerceiverConfig)
```
[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L1434)
**Tham số:**
config ([PerceiverConfig](/docs/transformers/main/vi/model_doc/perceiver#transformers.PerceiverConfig)) : Lớp cấu hình mô hình chứa tất cả các tham số của mô hình. Khởi tạo bằng tệp cấu hình sẽ không tải trọng số liên quan đến mô hình, chỉ tải cấu hình. Xem phương thức [from_pretrained()](/docs/transformers/main/vi/main_classes/model#transformers.PreTrainedModel.from_pretrained) để tải trọng số mô hình.
Ví dụ sử dụng Perceiver cho optical flow, cho các tác vụ như Sintel và KITTI. [PerceiverForOpticalFlow](/docs/transformers/main/vi/model_doc/perceiver#transformers.PerceiverForOpticalFlow) sử dụng [PerceiverImagePreprocessor](/docs/transformers/main/vi/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverImagePreprocessor) (với *prep_type="patches"*) để tiền xử lý các ảnh đầu vào, và [PerceiverOpticalFlowDecoder](/docs/transformers/main/vi/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverOpticalFlowDecoder) để giải mã biểu diễn ẩn của [PerceiverModel](/docs/transformers/main/vi/model_doc/perceiver#transformers.PerceiverModel).
Đầu vào là việc nối 2 khung hình liên tiếp theo chiều kênh và trích xuất một vùng 3 x 3 xung quanh mỗi pixel (dẫn đến 3 x 3 x 3 x 2 = 54 giá trị cho mỗi pixel). Các mã hóa vị trí Fourier cố định được sử dụng để mã hóa vị trí của mỗi pixel trong vùng. Tiếp theo, người ta áp dụng bộ mã hóa Perceiver. Để giải mã, người ta truy vấn biểu diễn ẩn bằng cùng mã hóa đã dùng cho đầu vào.
Mô hình này kế thừa từ [PreTrainedModel](/docs/transformers/main/vi/main_classes/model#transformers.PreTrainedModel). Xem tài liệu của lớp cha để biết các phương thức chung mà thư viện triển khai cho tất cả các mô hình của nó (chẳng hạn như tải xuống hoặc lưu trữ, thay đổi kích thước các nhúng đầu vào, cắt tỉa các đầu ra, v.v.)
Mô hình này cũng là một lớp con của [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) trong PyTorch. Hãy sử dụng nó như một Module PyTorch thông thường và tham khảo tài liệu PyTorch cho mọi vấn đề liên quan đến cách sử dụng và hành vi chung.
#### forward[[transformers.PerceiverForOpticalFlow.forward]]
```python
forward(inputs: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, labels: typing.Optional[torch.Tensor] = None, return_dict: bool | None = None, **kwargs)
```
[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L1484)
**Tham số:**
inputs (`torch.Tensor`, *tùy chọn*) : Đầu vào cho perceiver. Có thể là bất kỳ thứ gì: hình ảnh, văn bản, âm thanh, video, v.v.
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)
output_attentions (`bool`, *tùy chọn*) : Có trả về các tensor chú ý của tất cả các lớp chú ý hay không. Xem `attentions` trong phần tensor trả về để biết thêm chi tiết.
output_hidden_states (`bool`, *tuỳ chọn*) : Có trả về trạng thái ẩn của tất cả các lớp hay không. Xem `hidden_states` trong phần tensor trả về để biết thêm chi tiết.
labels (`torch.LongTensor` có hình dạng `(batch_size,)`, *tùy chọn*) : Nhãn để tính toán tổn thất dòng quang học. Chỉ số phải nằm trong `[0, ..., config.num_labels - 1]`.
return_dict (`bool`, *tùy chọn*) : Có trả về [ModelOutput](/docs/transformers/main/vi/main_classes/output#transformers.utils.ModelOutput) thay vì một tuple thông thường hay không.
**Trả về:** [PerceiverClassifierOutput](/docs/transformers/main/vi/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput) hoặc `tuple(torch.Tensor)`
Một [PerceiverClassifierOutput](/docs/transformers/main/vi/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput) hoặc một tuple của `torch.Tensor` (nếu `return_dict=False` được truyền hoặc khi `config.return_dict=False`) bao gồm các thành phần khác nhau tùy thuộc vào cấu hình ([PerceiverConfig](/docs/transformers/main/vi/model_doc/perceiver#transformers.PerceiverConfig)) và đầu vào.
Phương thức forward của [PerceiverForOpticalFlow](/docs/transformers/main/vi/model_doc/perceiver#transformers.PerceiverForOpticalFlow) ghi đè lên phương thức đặc biệt `__call__`.
Mặc dù công thức cho bước truyền tiến cần được định nghĩa bên trong hàm này, bạn nên gọi instance của `Module` sau đó thay vì gọi hàm này, vì instance `Module` sẽ đảm nhận việc thực hiện các bước tiền xử lý và hậu xử lý, trong khi hàm này sẽ bỏ qua chúng một cách im lặng.
- **loss** (`torch.Tensor` có shape `(1,)`, *optional*, được trả về khi `labels` được cung cấp) -- Loss 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]`, *tuỳ chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) -- Bộ tuple các `torch.Tensor` (một cho đầu ra của embeddings, nếu mô hình có lớp embedding, + một cho đầu ra của mỗi lớp) có hình dạng `(batch_size, sequence_length, hidden_size)`.
Trạng thái ẩn của mô hình tại đầu ra của mỗi lớp cùng với các đầu ra embedding ban đầu tùy chọn.
- **attentions** (`tuple[torch.Tensor]`, *tuỳ chọn*, được trả về khi `output_attentions=True` được truyền vào hoặc khi `config.output_attentions=True`) -- Bộ tuple của `torch.Tensor` (một cho mỗi lớp) có hình dạng `(batch_size, num_heads, sequence_length, sequence_length)`.
Trọng số chú ý sau softmax của attention, được sử dụng để tính trung bình có trọng số trong các đầu self-attention.
- **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.
Ví dụ:
```python
>>> from transformers import PerceiverForOpticalFlow
>>> import torch
>>> model = PerceiverForOpticalFlow.from_pretrained("deepmind/optical-flow-perceiver")
>>> # in the Perceiver IO paper, the authors extract a 3 x 3 patch around each pixel,
>>> # leading to 3 x 3 x 3 = 27 values for each pixel (as each pixel also has 3 color channels)
>>> # patches have shape (batch_size, num_frames, num_channels, height, width)
>>> # the authors train on resolutions of 368 x 496
>>> patches = torch.randn(1, 2, 27, 368, 496)
>>> outputs = model(inputs=patches)
>>> logits = outputs.logits
>>> list(logits.shape)
[1, 368, 496, 2]
```
## PerceiverForMultimodalAutoencoding[[transformers.PerceiverForMultimodalAutoencoding]]
#### transformers.PerceiverForMultimodalAutoencoding[[transformers.PerceiverForMultimodalAutoencoding]]
```python
transformers.PerceiverForMultimodalAutoencoding(config: PerceiverConfig)
```
[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L1576)
**Tham số:**
config ([PerceiverConfig](/docs/transformers/main/vi/model_doc/perceiver#transformers.PerceiverConfig)) : Lớp cấu hình mô hình chứa tất cả các tham số của mô hình. Khởi tạo bằng tệp cấu hình sẽ không tải trọng số liên quan đến mô hình, chỉ tải cấu hình. Xem phương thức [from_pretrained()](/docs/transformers/main/vi/main_classes/model#transformers.PreTrainedModel.from_pretrained) để tải trọng số mô hình.
Ví dụ sử dụng Perceiver cho tự mã hóa đa phương thức (video), cho các tác vụ như Kinetics-700.
[PerceiverForMultimodalAutoencoding](/docs/transformers/main/vi/model_doc/perceiver#transformers.PerceiverForMultimodalAutoencoding) sử dụng [PerceiverMultimodalPreprocessor](/docs/transformers/main/vi/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverMultimodalPreprocessor) để tiền xử lý 3 loại dữ liệu: hình ảnh, âm thanh và nhãn lớp. Bộ tiền xử lý này sử dụng các bộ tiền xử lý riêng cho từng loại dữ liệu để tiền xử lý từng loại một cách độc lập, sau đó ghép chúng lại với nhau. Các vector vị trí có thể huấn luyện được dùng để đệm mỗi loại dữ liệu về cùng một số kênh, cho phép ghép nối dọc theo chiều thời gian. Tiếp theo, ta áp dụng bộ mã hóa Perceiver.
[PerceiverMultimodalDecoder](/docs/transformers/main/vi/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverMultimodalDecoder) được sử dụng để giải mã biểu diễn ẩn của [PerceiverModel](/docs/transformers/main/vi/model_doc/perceiver#transformers.PerceiverModel). Bộ giải mã này sử dụng bộ giải mã riêng cho từng phương thức (modality) để xây dựng các truy vấn (queries). Các truy vấn của bộ giải mã được tạo ra dựa trên các đầu vào sau khi tiền xử lý. Tuy nhiên, việc tự mã hóa (autoencoding) toàn bộ một video trong một lần truyền tiến (forward pass) là không khả thi về mặt tính toán, do đó người ta chỉ sử dụng một phần của các truy vấn bộ giải mã để thực hiện chú ý chéo (cross-attention) với biểu diễn ẩn. Điều này được xác định bởi các chỉ số lấy mẫu con (subsampled indices) cho từng phương thức, có thể được cung cấp như đầu vào bổ sung cho lần truyền tiến của [PerceiverForMultimodalAutoencoding](/docs/transformers/main/vi/model_doc/perceiver#transformers.PerceiverForMultimodalAutoencoding).
[PerceiverMultimodalDecoder](/docs/transformers/main/vi/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverMultimodalDecoder) cũng đệm các decoder queries của các modalities khác nhau để có cùng số kênh, nhằm ghép chúng lại theo chiều thời gian. Tiếp theo, cross-attention được thực hiện với biểu diễn latent của [PerceiverModel](/docs/transformers/main/vi/model_doc/perceiver#transformers.PerceiverModel).
Cuối cùng, `~models.perceiver.modeling_perceiver.PerceiverMultiModalPostprocessor` được sử dụng để chuyển tensor này thành video thực tế. Trước tiên, nó tách output thành các modalities khác nhau, sau đó áp dụng postprocessor tương ứng cho từng modality.
Lưu ý rằng, bằng cách che nhãn phân loại trong quá trình đánh giá (tức là chỉ cần cung cấp một tensor gồm các số 0 cho chế độ "label"), mô hình tự mã hóa này sẽ trở thành bộ phân loại video Kinetics 700.
Mô hình này kế thừa từ [PreTrainedModel](/docs/transformers/main/vi/main_classes/model#transformers.PreTrainedModel). Xem tài liệu của lớp cha để biết các phương thức chung mà thư viện triển khai cho tất cả các mô hình của nó (chẳng hạn như tải xuống hoặc lưu trữ, thay đổi kích thước các nhúng đầu vào, cắt tỉa các đầu ra, v.v.)
Mô hình này cũng là một lớp con của [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) trong PyTorch. Hãy sử dụng nó như một Module PyTorch thông thường và tham khảo tài liệu PyTorch cho mọi vấn đề liên quan đến cách sử dụng và hành vi chung.
#### forward[[transformers.PerceiverForMultimodalAutoencoding.forward]]
```python
forward(inputs: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, subsampled_output_points: dict[str, torch.Tensor] | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, labels: typing.Optional[torch.Tensor] = None, return_dict: bool | None = None, **kwargs)
```
[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L1692)
**Tham số:**
inputs (`torch.Tensor`, *tùy chọn*) : Đầu vào cho perceiver. Có thể là bất kỳ thứ gì: hình ảnh, văn bản, âm thanh, video, v.v.
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)
subsampled_output_points (`dict[str, torch.Tensor]`, *tùy chọn*) : Từ điển các tensor được dùng làm truy vấn cho bộ giải mã. Bộ giải mã ánh xạ các truy vấn này vào biểu diễn ẩn của mô hình. Được dùng cho việc giải mã lấy mẫu con, ví dụ khi chỉ giải mã một số mảng ảnh nhất định.
output_attentions (`bool`, *tùy chọn*) : Có trả về các tensor chú ý của tất cả các lớp chú ý hay không. Xem `attentions` trong phần tensor trả về để biết thêm chi tiết.
output_hidden_states (`bool`, *tuỳ chọn*) : Có trả về trạng thái ẩn của tất cả các lớp hay không. Xem `hidden_states` trong phần tensor trả về để biết thêm chi tiết.
labels (`torch.LongTensor` có hình dạng `(batch_size,)`, *tùy chọn*) : Nhãn để tính toán tổn thất phân loại/hồi quy hình ảnh. Chỉ số phải nằm trong `[0, ..., config.num_labels - 1]`. Nếu `config.num_labels == 1`, tổn thất hồi quy sẽ được tính toán (tổn thất Mean-Square). Nếu `config.num_labels > 1`, tổn thất phân loại sẽ được tính toán (Cross-Entropy).
return_dict (`bool`, *tùy chọn*) : Có trả về [ModelOutput](/docs/transformers/main/vi/main_classes/output#transformers.utils.ModelOutput) thay vì một tuple thông thường hay không.
**Trả về:** [PerceiverClassifierOutput](/docs/transformers/main/vi/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput) hoặc `tuple(torch.Tensor)`
Một [PerceiverClassifierOutput](/docs/transformers/main/vi/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput) hoặc một tuple của `torch.Tensor` (nếu `return_dict=False` được truyền hoặc khi `config.return_dict=False`) bao gồm các thành phần khác nhau tùy thuộc vào cấu hình ([PerceiverConfig](/docs/transformers/main/vi/model_doc/perceiver#transformers.PerceiverConfig)) và đầu vào.
Phương thức forward của [PerceiverForMultimodalAutoencoding](/docs/transformers/main/vi/model_doc/perceiver#transformers.PerceiverForMultimodalAutoencoding) ghi đè lên phương thức đặc biệt `__call__`.
Mặc dù công thức cho bước truyền tiến cần được định nghĩa bên trong hàm này, bạn nên gọi instance của `Module` sau đó thay vì gọi hàm này, vì instance `Module` sẽ đảm nhận việc thực hiện các bước tiền xử lý và hậu xử lý, trong khi hàm này sẽ bỏ qua chúng một cách im lặng.
- **loss** (`torch.Tensor` có shape `(1,)`, *optional*, được trả về khi `labels` được cung cấp) -- Loss 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]`, *tuỳ chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) -- Bộ tuple các `torch.Tensor` (một cho đầu ra của embeddings, nếu mô hình có lớp embedding, + một cho đầu ra của mỗi lớp) có hình dạng `(batch_size, sequence_length, hidden_size)`.
Trạng thái ẩn của mô hình tại đầu ra của mỗi lớp cùng với các đầu ra embedding ban đầu tùy chọn.
- **attentions** (`tuple[torch.Tensor]`, *tuỳ chọn*, được trả về khi `output_attentions=True` được truyền vào hoặc khi `config.output_attentions=True`) -- Bộ tuple của `torch.Tensor` (một cho mỗi lớp) có hình dạng `(batch_size, num_heads, sequence_length, sequence_length)`.
Trọng số chú ý sau softmax của attention, được sử dụng để tính trung bình có trọng số trong các đầu self-attention.
- **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.
Ví dụ:
```python
>>> from transformers import PerceiverForMultimodalAutoencoding
>>> import torch
>>> import numpy as np
>>> # create multimodal inputs
>>> images = torch.randn((1, 16, 3, 224, 224))
>>> audio = torch.randn((1, 30720, 1))
>>> inputs = dict(image=images, audio=audio, label=torch.zeros((images.shape[0], 700)))
>>> model = PerceiverForMultimodalAutoencoding.from_pretrained("deepmind/multimodal-perceiver")
>>> # in the Perceiver IO paper, videos are auto-encoded in chunks
>>> # each chunk subsamples different index dimensions of the image and audio modality decoder queries
>>> nchunks = 128
>>> image_chunk_size = np.prod((16, 224, 224)) // nchunks
>>> audio_chunk_size = audio.shape[1] // model.config.samples_per_patch // nchunks
>>> # process the first chunk
>>> chunk_idx = 0
>>> subsampling = {
... "image": torch.arange(image_chunk_size * chunk_idx, image_chunk_size * (chunk_idx + 1)),
... "audio": torch.arange(audio_chunk_size * chunk_idx, audio_chunk_size * (chunk_idx + 1)),
... "label": None,
... }
>>> outputs = model(inputs=inputs, subsampled_output_points=subsampling)
>>> logits = outputs.logits
>>> list(logits["audio"].shape)
[1, 240]
>>> list(logits["image"].shape)
[1, 6272, 3]
>>> list(logits["label"].shape)
[1, 700]
```