Transformers documentation
Perceiver
Model ini dipublikasikan di HF papers pada 2021-07-30 dan disumbangkan ke Hugging Face Transformers pada 2021-12-08.
Perceiver
Ikhtisar
Model Perceiver IO diusulkan dalam Perceiver IO: A General Architecture for Structured Inputs & Outputs oleh 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 adalah generalisasi dari Perceiver untuk menangani output arbitrer di samping input arbitrer. Perceiver asli hanya menghasilkan satu label klasifikasi. Selain label klasifikasi, Perceiver IO dapat menghasilkan (misalnya) bahasa, optical flow, dan video multimodal dengan audio. Hal ini dilakukan menggunakan blok bangunan yang sama dengan Perceiver asli. Kompleksitas komputasi Perceiver IO bersifat linear terhadap ukuran input dan output, dan sebagian besar pemrosesan terjadi di ruang laten, sehingga memungkinkan kami memproses input dan output yang jauh lebih besar daripada yang dapat ditangani oleh Transformers standar. Artinya, misalnya, Perceiver IO dapat melakukan pemodelan bahasa ber-mask ala BERT secara langsung menggunakan byte alih-alih input yang ditokenisasi.
Abstrak dari makalah tersebut adalah sebagai berikut:
Model Perceiver yang baru saja diusulkan menghasilkan kinerja yang baik di beberapa domain (gambar, audio, multimodal, awan titik) sambil berskala secara linear dalam komputasi dan memori seiring dengan ukuran input. Meskipun Perceiver mendukung banyak jenis input, model ini hanya dapat menghasilkan output yang sangat sederhana seperti skor kelas. Perceiver IO mengatasi keterbatasan ini tanpa mengorbankan sifat-sifat menarik dari model aslinya dengan mempelajari cara melakukan kueri secara fleksibel terhadap ruang laten model untuk menghasilkan output dengan ukuran dan semantik yang arbitrer. Perceiver IO tetap memisahkan kedalaman model dari ukuran data dan tetap berskala linear terhadap ukuran data, tetapi kini dengan mempertimbangkan ukuran input dan output. Model Perceiver IO lengkap mencapai hasil yang kuat pada tugas-tugas dengan ruang output yang sangat terstruktur, seperti pemahaman bahasa alami dan visual, StarCraft II, serta domain multi-tugas dan multimodal. Sebagai sorotan, Perceiver IO menyamai baseline BERT berbasis Transformer pada benchmark bahasa GLUE tanpa memerlukan tokenisasi input dan mencapai kinerja state-of-the-art pada estimasi optical flow Sintel.
Berikut adalah TLDR yang menjelaskan cara kerja Perceiver:
Masalah utama dengan mekanisme self-attention pada Transformer adalah bahwa kebutuhan waktu dan memori berskala kuadratik terhadap panjang sekuens. Oleh karena itu, model seperti BERT dan RoBERTa dibatasi pada panjang sekuens maksimum 512 token. Perceiver bertujuan untuk menyelesaikan masalah ini dengan, alih-alih melakukan self-attention pada input, melakukannya pada seperangkat variabel laten, dan hanya menggunakan input untuk cross-attention. Dengan cara ini, kebutuhan waktu dan memori tidak lagi bergantung pada panjang input, karena digunakan sejumlah variabel laten yang tetap, seperti 256 atau 512. Variabel ini diinisialisasi secara acak, setelah itu dilatih end-to-end menggunakan backpropagation.
Secara internal, PerceiverModel akan membuat latents, yaitu tensor dengan bentuk (batch_size, num_latents, d_latents). Anda harus menyediakan inputs (yang bisa berupa teks, gambar, audio, apa pun!) ke model, yang akan digunakan untuk melakukan cross-attention dengan latents. Output dari Perceiver encoder adalah tensor dengan bentuk yang sama. Kemudian, serupa dengan BERT, Anda dapat mengonversi last hidden states dari latents menjadi logits klasifikasi dengan melakukan rata-rata sepanjang dimensi sequence, dan menempatkan linear layer di atasnya untuk memproyeksikan d_latents ke num_labels.
Ini adalah ide dari paper Perceiver asli. Namun, model tersebut hanya dapat menghasilkan logits klasifikasi. Dalam karya lanjutan, PerceiverIO, mereka menggeneralisasikannya agar model juga dapat menghasilkan output dengan ukuran arbitrer. Bagaimana caranya, mungkin Anda bertanya? Idenya sebenarnya relatif sederhana: seseorang mendefinisikan output dengan ukuran arbitrer, lalu menerapkan cross-attention dengan hidden states terakhir dari latents, menggunakan output sebagai queries, dan latents sebagai keys dan values.
Jadi, misalkan seseorang ingin melakukan pemodelan bahasa bermasker (gaya BERT) dengan Perceiver. Karena panjang input Perceiver tidak akan memengaruhi waktu komputasi lapisan self-attention, seseorang dapat menyediakan byte mentah, dengan memberikan inputs sepanjang 2048 ke model. Jika sekarang seseorang memmasker sebagian dari 2048 token tersebut, seseorang dapat mendefinisikan outputs sebagai bentuk: (batch_size, 2048, 768). Selanjutnya, seseorang melakukan cross-attention dengan hidden states akhir dari latents untuk memperbarui tensor outputs. Setelah cross-attention, seseorang masih memiliki tensor dengan bentuk (batch_size, 2048, 768). Seseorang kemudian dapat menempatkan kepala pemodelan bahasa reguler di atasnya, untuk memproyeksikan dimensi terakhir ke ukuran kosakata model, yaitu membuat logits dengan bentuk (batch_size, 2048, 262) (karena Perceiver menggunakan ukuran kosakata 262 ID byte).
Perceiver IO architecture. Taken from the original paper Model ini disumbangkan oleh nielsr. Kode aslinya dapat ditemukan di sini.
Perceiver tidak berfungsi dengan
torch.nn.DataParallelkarena bug di PyTorch, lihat issue #36035
Sumber daya
- Cara tercepat untuk memulai dengan Perceiver adalah dengan memeriksa notebook tutorial.
- Lihat artikel blog jika Anda ingin memahami sepenuhnya bagaimana model bekerja dan diimplementasikan di dalam pustaka. Perhatikan bahwa model yang tersedia di pustaka hanya menampilkan beberapa contoh dari apa yang dapat Anda lakukan dengan Perceiver. Ada banyak kasus penggunaan lainnya, termasuk question answering, named-entity recognition, object detection, audio classification, video classification, dan sebagainya.
- Panduan tugas klasifikasi teks
- Panduan tugas pemodelan bahasa tersembunyi
- Panduan tugas klasifikasi gambar
Output khusus Perceiver
kelas transformers.models.perceiver.modeling_perceiver.PerceiverModelOutput
< source >( logits: typing.Optional[torch.Tensor] = Nonelast_hidden_state: typing.Optional[torch.Tensor] = Nonehidden_states: tuple[torch.Tensor] | None = Noneattentions: tuple[torch.Tensor] | None = Nonecross_attentions: tuple[torch.Tensor] | None = None )
Parameter
- logits (
torch.Tensordengan bentuk(batch_size, num_labels)) — Skor klasifikasi (atau regresi jika config.num_labels==1) (sebelum SoftMax). - last_hidden_state (
torch.Tensordengan bentuk(batch_size, sequence_length, hidden_size), opsional) — Urutan hidden-states pada keluaran lapisan terakhir model. - hidden_states (
tuple[torch.Tensor], opsional, dikembalikan ketikaoutput_hidden_states=Truedilewatkan atau ketikaconfig.output_hidden_states=True) — Tuple daritorch.Tensor(satu untuk output embeddings, jika model memiliki lapisan embedding, + satu untuk output setiap lapisan) dengan bentuk(batch_size, sequence_length, hidden_size).Hidden-states model pada output setiap layer ditambah output embedding awal yang opsional.
- attentions (
tuple[torch.Tensor], opsional, dikembalikan ketikaoutput_attentions=Truedilewatkan atau ketikaconfig.output_attentions=True) — Tuple daritorch.Tensor(satu untuk setiap layer) dengan bentuk(batch_size, num_heads, sequence_length, sequence_length).Bobot perhatian setelah softmax perhatian, digunakan untuk menghitung rata-rata berbobot di kepala perhatian diri (self-attention).
- cross_attentions (
tuple[torch.Tensor], opsional, dikembalikan ketikaoutput_attentions=Truedilewatkan atau ketikaconfig.output_attentions=True) — Tuple daritorch.Tensor(satu untuk setiap layer) dengan bentuk(batch_size, num_heads, sequence_length, sequence_length).Bobot perhatian dari lapisan cross-attention decoder, setelah softmax perhatian, yang digunakan untuk menghitung rata-rata berbobot di kepala cross-attention.
Kelas dasar untuk keluaran model dasar Perceiver, dengan potensi hidden states, attentions, dan cross-attentions.
kelas transformers.models.perceiver.modeling_perceiver.PerceiverDecoderOutput
< source >( logits: typing.Optional[torch.Tensor] = Nonecross_attentions: tuple[torch.Tensor] | None = None )
Parameter
- logits (
torch.Tensordengan bentuk(batch_size, num_labels)) — Output dari decoder dasar. - cross_attentions (
tuple[torch.Tensor], opsional, dikembalikan ketikaoutput_attentions=Truedilewatkan atau ketikaconfig.output_attentions=True) — Tuple daritorch.Tensor(satu untuk setiap layer) dengan bentuk(batch_size, num_heads, sequence_length, sequence_length).Bobot perhatian dari lapisan cross-attention decoder, setelah softmax perhatian, yang digunakan untuk menghitung rata-rata berbobot di kepala cross-attention.
Kelas dasar untuk keluaran decoder Perceiver, dengan potensi cross-attentions.
kelas transformers.models.perceiver.modeling_perceiver.PerceiverMaskedLMOutput
< source >( loss: typing.Optional[torch.Tensor] = Nonelogits: typing.Optional[torch.Tensor] = Nonehidden_states: tuple[torch.Tensor] | None = Noneattentions: tuple[torch.Tensor] | None = Nonecross_attentions: tuple[torch.Tensor] | None = None )
Parameter
- loss (
torch.Tensordengan bentuk(1,), opsional, dikembalikan saatlabelsdisediakan) — Loss masked language modeling (MLM). - logits (
torch.Tensordengan bentuk(batch_size, sequence_length, config.vocab_size)) — Skor prediksi dari kepala pemodelan bahasa (skor untuk setiap token kosakata sebelum SoftMax). - hidden_states (
tuple[torch.Tensor], opsional, dikembalikan ketikaoutput_hidden_states=Truedilewatkan atau ketikaconfig.output_hidden_states=True) — Tuple daritorch.Tensor(satu untuk output embeddings, jika model memiliki lapisan embedding, + satu untuk output setiap lapisan) dengan bentuk(batch_size, sequence_length, hidden_size).Hidden-states model pada output setiap layer ditambah output embedding awal yang opsional.
- attentions (
tuple[torch.Tensor], opsional, dikembalikan ketikaoutput_attentions=Truedilewatkan atau ketikaconfig.output_attentions=True) — Tuple daritorch.Tensor(satu untuk setiap layer) dengan bentuk(batch_size, num_heads, sequence_length, sequence_length).Bobot perhatian setelah softmax perhatian, digunakan untuk menghitung rata-rata berbobot di kepala perhatian diri (self-attention).
- cross_attentions (
tuple[torch.Tensor], opsional, dikembalikan ketikaoutput_attentions=Truedilewatkan atau ketikaconfig.output_attentions=True) — Tuple daritorch.Tensor(satu untuk setiap layer) dengan bentuk(batch_size, num_heads, sequence_length, sequence_length).Bobot perhatian dari lapisan cross-attention decoder, setelah softmax perhatian, yang digunakan untuk menghitung rata-rata berbobot di kepala cross-attention.
Kelas dasar untuk keluaran model bahasa bermasker Perceiver.
kelas transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput
< source >( loss: typing.Optional[torch.Tensor] = Nonelogits: typing.Optional[torch.Tensor] = Nonehidden_states: tuple[torch.Tensor] | None = Noneattentions: tuple[torch.Tensor] | None = Nonecross_attentions: tuple[torch.Tensor] | None = None )
Parameter
- loss (
torch.Tensordengan bentuk(1,), opsional, dikembalikan saatlabelsdisediakan) — Loss klasifikasi (atau regresi jika config.num_labels==1). - logits (
torch.Tensordengan bentuk(batch_size, config.num_labels)) — Skor klasifikasi (atau regresi jika config.num_labels==1) (sebelum SoftMax). - hidden_states (
tuple[torch.Tensor], opsional, dikembalikan ketikaoutput_hidden_states=Truedilewatkan atau ketikaconfig.output_hidden_states=True) — Tuple daritorch.Tensor(satu untuk output embeddings, jika model memiliki lapisan embedding, + satu untuk output setiap lapisan) dengan bentuk(batch_size, sequence_length, hidden_size).Hidden-states model pada output setiap layer ditambah output embedding awal yang opsional.
- attentions (
tuple[torch.Tensor], opsional, dikembalikan ketikaoutput_attentions=Truedilewatkan atau ketikaconfig.output_attentions=True) — Tuple daritorch.Tensor(satu untuk setiap layer) dengan bentuk(batch_size, num_heads, sequence_length, sequence_length).Bobot perhatian setelah softmax perhatian, digunakan untuk menghitung rata-rata berbobot di kepala perhatian diri (self-attention).
- cross_attentions (
tuple[torch.Tensor], opsional, dikembalikan ketikaoutput_attentions=Truedilewatkan atau ketikaconfig.output_attentions=True) — Tuple daritorch.Tensor(satu untuk setiap layer) dengan bentuk(batch_size, num_heads, sequence_length, sequence_length).Bobot perhatian dari lapisan cross-attention decoder, setelah softmax perhatian, yang digunakan untuk menghitung rata-rata berbobot di kepala cross-attention.
Kelas dasar untuk keluaran Perceiver dari model klasifikasi urutan/gambar, aliran optik, dan autoencoding multimodal.
PerceiverConfig
kelas transformers.PerceiverConfig
< source >( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonenum_latents: int = 256d_latents: int = 1280d_model: int = 768num_blocks: int = 1num_self_attends_per_block: int = 26num_self_attention_heads: int = 8num_cross_attention_heads: int = 8qk_channels: int | None = Nonev_channels: int | None = Nonecross_attention_shape_for_attention: str = 'kv'self_attention_widening_factor: int = 1cross_attention_widening_factor: int = 1hidden_act: str = 'gelu'attention_probs_dropout_prob: float | int = 0.1initializer_range: float = 0.02layer_norm_eps: float = 1e-12use_query_residual: bool = Truevocab_size: int = 262max_position_embeddings: int = 2048image_size: int | list[int] | tuple[int, int] = 56train_size: list[int] | tuple[int, ...] = (368, 496)num_frames: int = 16audio_samples_per_frame: int = 1920samples_per_patch: int = 16output_shape: list[int] | tuple[int, ...] = (1, 16, 224, 224)output_num_channels: int = 512_label_trainable_num_channels: int = 1024 )
Parameter
- num_latents (
int, opsional, default 256) — Jumlah latens. - d_latents (
int, opsional, default 1280) — Dimensi dari latent embeddings. - d_model (
int, opsional, default768) — Ukuran lapisan encoder dan lapisan pooler. - num_blocks (
int, opsional, default 1) — Jumlah blok dalam encoder Transformer. - num_self_attends_per_block (
int, opsional, defaultnya 26) — Jumlah lapisan self-attention per blok. - num_self_attention_heads (
int, opsional, default 8) — Jumlah kepala perhatian untuk setiap lapisan self-attention dalam encoder Transformer. - num_cross_attention_heads (
int, opsional, default 8) — Jumlah kepala perhatian untuk setiap lapisan cross-attention dalam encoder Transformer. - qk_channels (
int, opsional) — Dimensi untuk memproyeksikan query + key sebelum menerapkan attention pada lapisan cross-attention dan self-attention dari encoder. Akan secara default mempertahankan dimensi query jika tidak ditentukan. - v_channels (
int, opsional) — Dimensi untuk memproyeksikan nilai sebelum menerapkan perhatian pada lapisan cross-attention dan self-attention dari encoder. Akan secara default mempertahankan dimensi dari query jika tidak ditentukan. - cross_attention_shape_for_attention (
str, opsional, default"kv") — Dimensi yang digunakan saat downsampling queries dan keys pada lapisan cross-attention dari encoder. - self_attention_widening_factor (
int, opsional, default 1) — Dimensi lapisan feed-forward pada lapisan cross-attention dari encoder Transformer. - cross_attention_widening_factor (
int, opsional, default 1) — Dimensi lapisan feed-forward pada lapisan self-attention dari encoder Transformer. - hidden_act (
str, opsional, defaultnyagelu) — Fungsi aktivasi non-linear (fungsi atau string) di decoder. Misalnya,"gelu","relu","silu", dan sebagainya. - attention_probs_dropout_prob (
Union[float, int], opsional, default0.1) — Rasio dropout untuk probabilitas perhatian. - initializer_range (
float, opsional, defaultnya0.02) — Standar deviasi dari truncated_normal_initializer untuk menginisialisasi semua matriks bobot. - layer_norm_eps (
float, opsional, defaultnya1e-12) — Epsilon yang digunakan oleh lapisan normalisasi lapisan. - use_query_residual (
float, opsional, defaultnyaTrue) — Apakah akan menambahkan residual query pada lapisan cross-attention dari encoder. - vocab_size (
int, opsional, default262) — Ukuran kosakata model. Menentukan jumlah token berbeda yang dapat direpresentasikan olehinput_ids. - max_position_embeddings (
int, opsional, default2048) — Panjang maksimum urutan yang mungkin digunakan dengan model ini. - image_size (
int, opsional, default 56) — Ukuran gambar setelah pra-pemrosesan, untuk PerceiverForImageClassificationLearned. - train_size (
list[int], opsional, default[368, 496]) — Ukuran pelatihan gambar untuk model optical flow. - num_frames (
int, opsional, default 16) — Jumlah bingkai video yang digunakan untuk model autoencoding multimodal. - audio_samples_per_frame (
int, opsional, default 1920) — Jumlah sampel audio per frame untuk model autoencoding multimodal. - samples_per_patch (
int, opsional, default 16) — Jumlah sampel audio per patch saat prapemrosesan audio untuk model autoencoding multimodal. - output_shape (
list[int], opsional, default[1, 16, 224, 224]) — Bentuk output (batch_size, num_frames, height, width) untuk query dekode video dari model autoencoding multimodal. Ini tidak mencakup dimensi channel. - output_num_channels (
int, opsional, default 512) — Jumlah kanal output untuk setiap decoder modalitas.
Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari PerceiverModel. Kelas ini digunakan untuk membuat instans model Perceiver sesuai dengan argumen yang ditentukan, sehingga mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari deepmind/language-perceiver
Objek konfigurasi mewarisi dari PreTrainedConfig dan dapat digunakan untuk mengontrol output model. Baca dokumentasi dari PreTrainedConfig untuk informasi lebih lanjut.
Contoh:
>>> 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.configPerceiverTokenizer
kelas transformers.PerceiverTokenizer
< source >( pad_token = '[PAD]'bos_token = '[BOS]'eos_token = '[EOS]'mask_token = '[MASK]'cls_token = '[CLS]'sep_token = '[SEP]'model_max_length = 2048**kwargs )
Parameter
- pad_token (
str, opsional, defaultnya"[PAD]") — Token yang digunakan untuk padding, misalnya saat membatching urutan dengan panjang yang berbeda. - bos_token (
str, opsional, default"[BOS]") — Token BOS (dicadangkan dalam vocab, tetapi tidak benar-benar digunakan). - eos_token (
str, opsional, defaultnya"[EOS]") — Token akhir urutan (dicadangkan dalam vocab, tetapi tidak benar-benar digunakan). Saat membangun urutan menggunakan token khusus, ini bukan token yang digunakan untuk akhir urutan. Token yang digunakan adalah sep_token.Saat membangun sebuah urutan menggunakan token khusus, token ini bukan yang digunakan untuk akhir urutan. Token yang digunakan adalah
sep_token. - mask_token (
str, opsional, default"[MASK]") — Token MASK, berguna untuk pemodelan bahasa tersembunyi (masked language modeling). - cls_token (
str, opsional, default"[CLS]") — Token CLS (dicadangkan dalam vocab, tetapi tidak benar-benar digunakan). - sep_token (
str, opsional, default"[SEP]") — Token pemisah, yang digunakan saat membangun urutan dari dua urutan.
Konstruksi tokenizer Perceiver. Perceiver secara sederhana menggunakan encoding byte mentah utf-8.
Tokenizer ini mewarisi dari PreTrainedTokenizer yang berisi sebagian besar metode utama. Pengguna harus merujuk ke superclass ini untuk informasi lebih lanjut mengenai metode-metode tersebut.
__call__
< source >( text: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = Nonetext_pair: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = Nonetext_target: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = Nonetext_pair_target: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = Noneadd_special_tokens: bool = Truepadding: bool | str | PaddingStrategy = Falsetruncation: bool | str | TruncationStrategy | None = Nonemax_length: int | None = Nonestride: int = 0is_split_into_words: bool = Falsepad_to_multiple_of: int | None = Nonepadding_side: str | None = Nonereturn_tensors: str | TensorType | None = Nonereturn_token_type_ids: bool | None = Nonereturn_attention_mask: bool | None = Nonereturn_overflowing_tokens: bool = Falsereturn_special_tokens_mask: bool = Falsereturn_offsets_mapping: bool = Falsereturn_length: bool = Falseverbose: bool = Truetokenizer_kwargs: dict[str, Any] | None = None**kwargs ) → BatchEncoding
Parameter
- text (
str,list[str],list[list[str]], opsional) — Sequens atau batch dari sequens yang akan dienkod. Setiap sequens dapat berupa string atau daftar string (string yang sudah dipretokenisasi). Jika sequens diberikan sebagai daftar string (pretokenized), Anda harus mengaturis_split_into_words=True(untuk menghilangkan ambiguitas dengan batch dari sequens). - text_pair (
str,list[str],list[list[str]], opsional) — Urutan atau batch dari urutan yang akan dienkod. Setiap urutan dapat berupa string atau daftar string (string yang sudah dipretokenisasi). Jika urutan diberikan sebagai daftar string (pretokenized), Anda harus mengaturis_split_into_words=True(untuk menghilangkan ambiguitas dengan batch dari urutan). - text_target (
str,list[str],list[list[str]], opsional) — Sequens atau batch sequens yang akan dikodekan sebagai teks target. Setiap sequens dapat berupa string atau daftar string (string pretokenized). Jika sequens diberikan sebagai daftar string (pretokenized), Anda harus mengaturis_split_into_words=True(untuk menghilangkan ambiguitas dengan batch sequens). - text_pair_target (
str,list[str],list[list[str]], opsional) — Urutan atau batch urutan yang akan dikodekan sebagai teks target. Setiap urutan dapat berupa string atau daftar string (string pretokenized). Jika urutan diberikan sebagai daftar string (pretokenized), Anda harus mengaturis_split_into_words=True(untuk menghilangkan ambiguitas dengan batch urutan). - tokenizer_kwargs (
dict[str, Any], opsional) — Kwargs tambahan untuk diteruskan ke tokenizer. Kwargs ini akan digabungkan dengan parameter eksplisit dan kwargs lainnya, dengan parameter eksplisit memiliki prioritas lebih tinggi. - add_special_tokens (
bool, opsional, defaultTrue) — Apakah akan menambahkan token khusus saat meng-encode urutan. Ini akan menggunakan fungsiPretrainedTokenizerBase.build_inputs_with_special_tokensyang mendasarinya, yang mendefinisikan token mana yang ditambahkan secara otomatis ke input ids. Ini berguna jika Anda ingin menambahkan tokenbosataueossecara otomatis. - padding (
bool,stratau PaddingStrategy, opsional, defaultnyaFalse) — Mengaktifkan dan mengontrol padding. Menerima nilai-nilai berikut:Trueatau'longest': Pad hingga urutan terpanjang dalam batch (atau tanpa padding jika hanya satu urutan yang diberikan).'max_length': Pad hingga panjang maksimum yang ditentukan dengan argumenmax_lengthatau hingga panjang input maksimum yang dapat diterima oleh model jika argumen tersebut tidak diberikan.Falseatau'do_not_pad'(default): Tidak ada padding (yaitu, dapat menghasilkan batch dengan urutan yang panjangnya berbeda).
- truncation (
bool,stratau TruncationStrategy, opsional, defaultnyaFalse) — Mengaktifkan dan mengontrol pemotongan. Menerima nilai-nilai berikut:Trueatau'longest_first': Memotong hingga panjang maksimum yang ditentukan dengan argumenmax_lengthatau hingga panjang input maksimum yang dapat diterima oleh model jika argumen tersebut tidak diberikan. Ini akan memotong per token, dengan menghapus satu token dari urutan terpanjang dalam pasangan jika sepasang urutan (atau batch pasangan) diberikan.'only_first': Potong hingga panjang maksimum yang ditentukan dengan argumenmax_lengthatau hingga panjang input maksimum yang dapat diterima oleh model jika argumen tersebut tidak diberikan. Ini hanya akan memotong urutan pertama dari sebuah pasangan jika sepasang urutan (atau batch dari pasangan) diberikan.'only_second': Potong hingga panjang maksimum yang ditentukan dengan argumenmax_lengthatau hingga panjang input maksimum yang dapat diterima oleh model jika argumen tersebut tidak diberikan. Ini hanya akan memotong urutan kedua dari sebuah pasangan jika sepasang urutan (atau batch dari pasangan) diberikan.Falseatau'do_not_truncate'(default): Tidak ada pemotongan (yaitu, dapat menghasilkan batch dengan panjang sekuens yang lebih besar dari ukuran input maksimum yang diizinkan model).
- max_length (
int, opsional) — Mengontrol panjang maksimum yang digunakan oleh salah satu parameter truncation/padding.Jika tidak disetel atau disetel ke
None, ini akan menggunakan panjang maksimum model yang telah didefinisikan sebelumnya jika panjang maksimum diperlukan oleh salah satu parameter truncation/padding. Jika model tidak memiliki panjang input maksimum yang spesifik (seperti XLNet), truncation/padding ke panjang maksimum akan dinonaktifkan. - stride (
int, opsional, default 0) — Jika diatur ke sebuah angka bersama denganmax_length, token yang meluap yang dikembalikan saatreturn_overflowing_tokens=Trueakan berisi beberapa token dari akhir urutan terpotong yang dikembalikan untuk menyediakan beberapa tumpang tindih antara urutan terpotong dan urutan yang meluap. Nilai argumen ini menentukan jumlah token yang tumpang tindih. - is_split_into_words (
bool, opsional, defaultFalse) — Apakah input sudah di-pre-tokenisasi (misalnya, dipecah menjadi kata). Jika disetel keTrue, tokenizer mengasumsikan input sudah dipecah menjadi kata (misalnya, dengan memisahkannya berdasarkan spasi) yang akan ditokenisasi. Ini berguna untuk NER atau klasifikasi token. - pad_to_multiple_of (
int, opsional) — Jika diset, akan melakukanpaddingpada urutan hingga menjadi kelipatan dari nilai yang diberikan. Memerlukanpaddinguntuk diaktifkan. Ini sangat berguna untuk memungkinkan penggunaan Tensor Cores pada perangkat keras NVIDIA dengan kemampuan komputasi>= 7.5(Volta). - padding_side (
str, opsional) — Sisi tempat model harus menerapkan padding. Harus dipilih antara [‘right’, ‘left’]. Nilai default diambil dari atribut kelas dengan nama yang sama. - return_tensors (
stratau TensorType, opsional) — Jika diset, akan mengembalikan tensor alih-alih daftar integer Python. Nilai yang dapat diterima adalah:'pt': Mengembalikan objek PyTorchtorch.Tensor.'np': Mengembalikan objek Numpynp.ndarray.
- return_token_type_ids (
bool, opsional) — Apakah akan mengembalikan token type ID. Jika dibiarkan pada nilai default, akan mengembalikan token type ID sesuai dengan default tokenizer tertentu, yang ditentukan olehreturn_outputsatribut. - return_attention_mask (
bool, opsional) — Apakah akan mengembalikan attention mask. Jika dibiarkan pada nilai default, akan mengembalikan attention mask sesuai dengan default tokenizer tertentu, yang didefinisikan olehreturn_outputsatribut. - return_overflowing_tokens (
bool, opsional, defaultFalse) — Apakah akan mengembalikan urutan token yang meluap. Jika sepasang urutan id input (atau batch dari pasangan) diberikan dengantruncation_strategy = longest_firstatauTrue, error akan dilemparkan alih-alih mengembalikan token yang meluap. - return_special_tokens_mask (
bool, opsional, defaultFalse) — Apakah akan mengembalikan informasi mask token khusus. - return_offsets_mapping (
bool, opsional, defaultnyaFalse) — Apakah akan mengembalikan(char_start, char_end)untuk setiap token.Ini hanya tersedia pada fast tokenizer yang mewarisi dari PreTrainedTokenizerFast, jika menggunakan tokenizer Python, metode ini akan memicu
NotImplementedError. - return_length (
bool, opsional, defaultFalse) — Apakah akan mengembalikan panjang dari input yang dikodekan. - verbose (
bool, opsional, defaultnyaTrue) — Apakah akan mencetak lebih banyak informasi dan peringatan. - **kwargs — diteruskan ke metode
self.tokenize()
Mengembalikan
BatchEncoding dengan bidang berikut:
-
input_ids — Daftar id token yang akan diberikan ke model.
-
token_type_ids — Daftar token type id yang akan diberikan ke model (ketika
return_token_type_ids=Trueatau jika “token_type_ids” ada diself.model_input_names). -
attention_mask — Daftar indeks yang menentukan token mana yang harus diperhatikan oleh model (ketika
return_attention_mask=Trueatau jika “attention_mask” ada diself.model_input_names). -
overflowing_tokens — Daftar sekuens token yang meluap (ketika
max_lengthditentukan danreturn_overflowing_tokens=True). -
num_truncated_tokens — Jumlah token yang dipangkas (ketika
max_lengthditentukan danreturn_overflowing_tokens=True). -
special_tokens_mask — Daftar angka 0 dan 1, di mana 1 menandakan token khusus yang ditambahkan dan 0 menandakan token urutan reguler (ketika
add_special_tokens=Truedanreturn_special_tokens_mask=True). -
length — Panjang dari input (ketika
return_length=True)
Metode utama untuk melakukan tokenisasi dan persiapan satu atau beberapa urutan atau satu atau beberapa pasangan urutan untuk model.
PerceiverImageProcessor
kelas transformers.PerceiverImageProcessor
< source >( **kwargs: *<class 'transformers.processing_utils.ImagesKwargs'> )
Parameter
- do_convert_rgb (
bool, kwargs, opsional) — Apakah akan mengonversi gambar ke RGB. - do_resize (
bool, kwargs, opsional, defaultTrue) — Apakah akan mengubah ukuran gambar. - size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs, defaultnya{'height' -- 224, 'width': 224}): Menggambarkan dimensi input maksimum untuk model. - default_to_square (
bool, kwargs, opsional, defaultnyaTrue) — Apakah akan menggunakan gambar persegi sebagai default saat melakukan resize, jika size berupa int. - crop_size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs, defaultnya{'height' -- 256, 'width': 256}): Ukuran gambar keluaran setelah menerapkancenter_crop. - resample (
Annotated[Union[int, PILImageResampling, NoneType], None], kwargs, defaultnya3) — Filter resampling yang digunakan jika mengubah ukuran gambar. Ini bisa berupa salah satu enumPILImageResampling. Hanya berpengaruh jikado_resizediatur keTrue. - do_rescale (
bool, kwargs, opsional, defaultTrue) — Apakah akan melakukan penskalaan ulang pada gambar. - rescale_factor (
float, kwargs, opsional, default0.00392156862745098) — Faktor rescale untuk menskalakan ulang gambar jikado_rescalediatur keTrue. - do_normalize (
bool, kwargs, opsional, defaultTrue) — Apakah akan menormalisasi gambar. - image_mean (
Union[float, list[float], tuple[float, ...]], kwargs, opsional, defaultnya[0.485, 0.456, 0.406]) — Rata-rata gambar yang digunakan untuk normalisasi. Hanya berpengaruh jikado_normalizediatur keTrue. - image_std (
Union[float, list[float], tuple[float, ...]], kwargs, opsional, defaultnya[0.229, 0.224, 0.225]) — Standar deviasi gambar yang digunakan untuk normalisasi. Hanya berpengaruh jikado_normalizediatur keTrue. - do_pad (
bool, kwargs, opsional) — Apakah akan melakukan padding pada gambar. Padding dilakukan ke ukuran terbesar dalam batch atau ke ukuran persegi tetap per gambar. Strategi padding yang tepat bergantung pada model. - pad_size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Ukuran dalam{"height": int, "width" int}untuk melakukan padding pada gambar. Harus lebih besar dari ukuran gambar mana pun yang disediakan untuk pra-pemrosesan. Jikapad_sizetidak disediakan, gambar akan di-pad hingga tinggi dan lebar terbesar dalam batch. Diterapkan hanya ketikado_pad=True. - do_center_crop (
bool, kwargs, opsional, defaultTrue) — Apakah akan melakukan center crop pada gambar. - data_format (
Union[str, ~image_utils.ChannelDimension], kwargs, opsional) — HanyaChannelDimension.FIRSTyang didukung. Ditambahkan untuk kompatibilitas dengan prosesor lambat. - input_data_format (
Union[str, ~image_utils.ChannelDimension], kwargs, opsional) — Format dimensi channel untuk gambar input. Jika tidak diset, format dimensi channel akan disimpulkan dari gambar input. Bisa berupa salah satu dari:"channels_first"atauChannelDimension.FIRST: gambar dalam format (num_channels, height, width)."channels_last"atauChannelDimension.LAST: gambar dalam format (height, width, num_channels)."none"atauChannelDimension.NONE: gambar dalam format (height, width).
- device (
Annotated[Union[str, torch.device, NoneType], None], kwargs) — Perangkat untuk memproses video. Jika tidak disetel, perangkat akan disimpulkan dari video input. - return_tensors (
Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Mengembalikan tensor bertumpuk jika diset ke'pt', selain itu mengembalikan daftar tensor. - disable_grouping (
bool, kwargs, opsional) — Apakah akan menonaktifkan pengelompokan gambar berdasarkan ukuran untuk memprosesnya secara individual dan bukan dalam batch. Jika None, akan diatur ke True jika gambar berada di CPU, dan False selain itu. Pilihan ini didasarkan pada pengamatan empiris, seperti yang dijelaskan di sini: https://github.com/huggingface/transformers/pull/38157 - image_seq_length (
int, kwargs, opsional) — Jumlah token gambar yang akan digunakan untuk setiap gambar dalam input. Ditambahkan untuk kompatibilitas mundur, tetapi ini seharusnya diatur sebagai atribut prosesor pada model-model mendatang.
Membangun pemroses gambar PerceiverImageProcessor.
praproses
< source >( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']]*argsimage_like_kwargs: dict[str, typing.Any] | None = None**kwargs: *<class 'transformers.processing_utils.ImagesKwargs'> ) → ~image_processing_base.BatchFeature
Parameter
- images (
Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]) — Gambar yang akan dipreprocess. Mengharapkan satu gambar atau batch gambar dengan nilai piksel berkisar dari 0 hingga 255. Jika mengirimkan gambar dengan nilai piksel antara 0 dan 1, aturdo_rescale=False. - image_like_kwargs (
dict[str, Any], opsional) — Flag pengembang untuk input tambahan yang mirip gambar yang juga akan dipreprocess. Gunakan ini hanya jika melewati input sebagai kwarg tidak berhasil. Misalnya,preprocess(images, masks=masks)adalah opsi yang lebih disukai, tetapi menyebabkan masalah prioritas argumen untuk beberapa model. Dalam kasus tersebut,preprocess(images, image_like_inputs={"masks": masks})dapat digunakan sebagai gantinya. - do_convert_rgb (
bool, kwargs, opsional) — Apakah akan mengonversi gambar ke RGB. - do_resize (
bool, kwargs, opsional) — Apakah akan mengubah ukuran gambar. - size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Menggambarkan dimensi input maksimum untuk model. - default_to_square (
bool, kwargs, opsional) — Apakah akan menggunakan gambar persegi sebagai default saat mengubah ukuran, jika size berupa int. - crop_size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Ukuran gambar keluaran setelah menerapkancenter_crop. - resample (
Annotated[Union[int, PILImageResampling, NoneType], None], kwargs) — Filter resampling yang digunakan jika mengubah ukuran gambar. Ini dapat berupa salah satu enumPILImageResampling. Hanya berpengaruh jikado_resizediatur keTrue. - do_rescale (
bool, kwargs, opsional) — Apakah akan melakukan penskalaan ulang pada gambar. - rescale_factor (
float, kwargs, opsional) — Faktor rescale untuk menskalakan ulang gambar jikado_rescalediatur keTrue. - do_normalize (
bool, kwargs, opsional) — Apakah akan menormalisasi gambar. - image_mean (
Union[float, list[float], tuple[float, ...]], kwargs, opsional) — Rata-rata gambar yang digunakan untuk normalisasi. Hanya berpengaruh jikado_normalizediatur keTrue. - image_std (
Union[float, list[float], tuple[float, ...]], kwargs, opsional) — Standar deviasi gambar yang digunakan untuk normalisasi. Hanya berpengaruh jikado_normalizediatur keTrue. - do_pad (
bool, kwargs, opsional) — Apakah akan melakukan padding pada gambar. Padding dilakukan ke ukuran terbesar dalam batch atau ke ukuran persegi tetap per gambar. Strategi padding yang tepat bergantung pada model. - pad_size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Ukuran dalam{"height": int, "width" int}untuk melakukan padding pada gambar. Harus lebih besar dari ukuran gambar mana pun yang disediakan untuk pra-pemrosesan. Jikapad_sizetidak disediakan, gambar akan di-pad hingga tinggi dan lebar terbesar dalam batch. Diterapkan hanya ketikado_pad=True. - do_center_crop (
bool, kwargs, opsional) — Apakah akan melakukan center crop pada gambar. - data_format (
Union[str, ~image_utils.ChannelDimension], kwargs, opsional) — HanyaChannelDimension.FIRSTyang didukung. Ditambahkan untuk kompatibilitas dengan prosesor lambat. - input_data_format (
Union[str, ~image_utils.ChannelDimension], kwargs, opsional) — Format dimensi channel untuk gambar input. Jika tidak diset, format dimensi channel akan disimpulkan dari gambar input. Bisa berupa salah satu dari:"channels_first"atauChannelDimension.FIRST: gambar dalam format (num_channels, height, width)."channels_last"atauChannelDimension.LAST: gambar dalam format (height, width, num_channels)."none"atauChannelDimension.NONE: gambar dalam format (height, width).
- device (
Annotated[Union[str, torch.device, NoneType], None], kwargs) — Perangkat untuk memproses video. Jika tidak disetel, perangkat akan disimpulkan dari video input. - return_tensors (
Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Mengembalikan tensor bertumpuk jika diset ke'pt', selain itu mengembalikan daftar tensor. - disable_grouping (
bool, kwargs, opsional) — Apakah akan menonaktifkan pengelompokan gambar berdasarkan ukuran untuk memprosesnya secara individual dan bukan dalam batch. Jika None, akan diatur ke True jika gambar berada di CPU, dan False selain itu. Pilihan ini didasarkan pada pengamatan empiris, seperti yang dijelaskan di sini: https://github.com/huggingface/transformers/pull/38157 - image_seq_length (
int, kwargs, opsional) — Jumlah token gambar yang akan digunakan untuk setiap gambar dalam input. Ditambahkan untuk kompatibilitas mundur, tetapi ini seharusnya diatur sebagai atribut prosesor pada model-model mendatang.
Mengembalikan
~image_processing_base.BatchFeature
- data (
dict) — Kamus berisi daftar/array/tensor yang dikembalikan oleh metode call (‘pixel_values’, dll.). - tensor_type (
Union[None, str, TensorType], opsional) — Anda dapat memberikan tensor_type di sini untuk mengonversi daftar bilangan bulat menjadi Tensor PyTorch/Numpy saat inisialisasi.
Praproses sebuah gambar atau kumpulan gambar.
PerceiverImageProcessorPil
kelas transformers.PerceiverImageProcessorPil
< source >( **kwargs: *<class 'transformers.processing_utils.ImagesKwargs'> )
Parameter
- do_convert_rgb (
bool, kwargs, opsional) — Apakah akan mengonversi gambar ke RGB. - do_resize (
bool, kwargs, opsional, defaultTrue) — Apakah akan mengubah ukuran gambar. - size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs, defaultnya{'height' -- 224, 'width': 224}): Menggambarkan dimensi input maksimum untuk model. - default_to_square (
bool, kwargs, opsional, defaultnyaTrue) — Apakah akan menggunakan gambar persegi sebagai default saat melakukan resize, jika size berupa int. - crop_size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs, defaultnya{'height' -- 256, 'width': 256}): Ukuran gambar keluaran setelah menerapkancenter_crop. - resample (
Annotated[Union[int, PILImageResampling, NoneType], None], kwargs, defaultnya3) — Filter resampling yang digunakan jika mengubah ukuran gambar. Ini bisa berupa salah satu enumPILImageResampling. Hanya berpengaruh jikado_resizediatur keTrue. - do_rescale (
bool, kwargs, opsional, defaultTrue) — Apakah akan melakukan penskalaan ulang pada gambar. - rescale_factor (
float, kwargs, opsional, default0.00392156862745098) — Faktor rescale untuk menskalakan ulang gambar jikado_rescalediatur keTrue. - do_normalize (
bool, kwargs, opsional, defaultTrue) — Apakah akan menormalisasi gambar. - image_mean (
Union[float, list[float], tuple[float, ...]], kwargs, opsional, defaultnya[0.485, 0.456, 0.406]) — Rata-rata gambar yang digunakan untuk normalisasi. Hanya berpengaruh jikado_normalizediatur keTrue. - image_std (
Union[float, list[float], tuple[float, ...]], kwargs, opsional, defaultnya[0.229, 0.224, 0.225]) — Standar deviasi gambar yang digunakan untuk normalisasi. Hanya berpengaruh jikado_normalizediatur keTrue. - do_pad (
bool, kwargs, opsional) — Apakah akan melakukan padding pada gambar. Padding dilakukan ke ukuran terbesar dalam batch atau ke ukuran persegi tetap per gambar. Strategi padding yang tepat bergantung pada model. - pad_size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Ukuran dalam{"height": int, "width" int}untuk melakukan padding pada gambar. Harus lebih besar dari ukuran gambar mana pun yang disediakan untuk pra-pemrosesan. Jikapad_sizetidak disediakan, gambar akan di-pad hingga tinggi dan lebar terbesar dalam batch. Diterapkan hanya ketikado_pad=True. - do_center_crop (
bool, kwargs, opsional, defaultTrue) — Apakah akan melakukan center crop pada gambar. - data_format (
Union[str, ~image_utils.ChannelDimension], kwargs, opsional) — HanyaChannelDimension.FIRSTyang didukung. Ditambahkan untuk kompatibilitas dengan prosesor lambat. - input_data_format (
Union[str, ~image_utils.ChannelDimension], kwargs, opsional) — Format dimensi channel untuk gambar input. Jika tidak diset, format dimensi channel akan disimpulkan dari gambar input. Bisa berupa salah satu dari:"channels_first"atauChannelDimension.FIRST: gambar dalam format (num_channels, height, width)."channels_last"atauChannelDimension.LAST: gambar dalam format (height, width, num_channels)."none"atauChannelDimension.NONE: gambar dalam format (height, width).
- device (
Annotated[Union[str, torch.device, NoneType], None], kwargs) — Perangkat untuk memproses video. Jika tidak disetel, perangkat akan disimpulkan dari video input. - return_tensors (
Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Mengembalikan tensor bertumpuk jika diset ke'pt', selain itu mengembalikan daftar tensor. - disable_grouping (
bool, kwargs, opsional) — Apakah akan menonaktifkan pengelompokan gambar berdasarkan ukuran untuk memprosesnya secara individual dan bukan dalam batch. Jika None, akan diatur ke True jika gambar berada di CPU, dan False selain itu. Pilihan ini didasarkan pada pengamatan empiris, seperti yang dijelaskan di sini: https://github.com/huggingface/transformers/pull/38157 - image_seq_length (
int, kwargs, opsional) — Jumlah token gambar yang akan digunakan untuk setiap gambar dalam input. Ditambahkan untuk kompatibilitas mundur, tetapi ini seharusnya diatur sebagai atribut prosesor pada model-model mendatang.
Membangun pemroses gambar PerceiverImageProcessor.
praproses
< source >( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']]*argsimage_like_kwargs: dict[str, typing.Any] | None = None**kwargs: *<class 'transformers.processing_utils.ImagesKwargs'> ) → ~image_processing_base.BatchFeature
Parameter
- images (
Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]) — Gambar yang akan dipreprocess. Mengharapkan satu gambar atau batch gambar dengan nilai piksel berkisar dari 0 hingga 255. Jika mengirimkan gambar dengan nilai piksel antara 0 dan 1, aturdo_rescale=False. - image_like_kwargs (
dict[str, Any], opsional) — Flag pengembang untuk input tambahan yang mirip gambar yang juga akan dipreprocess. Gunakan ini hanya jika melewati input sebagai kwarg tidak berhasil. Misalnya,preprocess(images, masks=masks)adalah opsi yang lebih disukai, tetapi menyebabkan masalah prioritas argumen untuk beberapa model. Dalam kasus tersebut,preprocess(images, image_like_inputs={"masks": masks})dapat digunakan sebagai gantinya. - do_convert_rgb (
bool, kwargs, opsional) — Apakah akan mengonversi gambar ke RGB. - do_resize (
bool, kwargs, opsional) — Apakah akan mengubah ukuran gambar. - size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Menggambarkan dimensi input maksimum untuk model. - default_to_square (
bool, kwargs, opsional) — Apakah akan menggunakan gambar persegi sebagai default saat mengubah ukuran, jika size berupa int. - crop_size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Ukuran gambar keluaran setelah menerapkancenter_crop. - resample (
Annotated[Union[int, PILImageResampling, NoneType], None], kwargs) — Filter resampling yang digunakan jika mengubah ukuran gambar. Ini dapat berupa salah satu enumPILImageResampling. Hanya berpengaruh jikado_resizediatur keTrue. - do_rescale (
bool, kwargs, opsional) — Apakah akan melakukan penskalaan ulang pada gambar. - rescale_factor (
float, kwargs, opsional) — Faktor rescale untuk menskalakan ulang gambar jikado_rescalediatur keTrue. - do_normalize (
bool, kwargs, opsional) — Apakah akan menormalisasi gambar. - image_mean (
Union[float, list[float], tuple[float, ...]], kwargs, opsional) — Rata-rata gambar yang digunakan untuk normalisasi. Hanya berpengaruh jikado_normalizediatur keTrue. - image_std (
Union[float, list[float], tuple[float, ...]], kwargs, opsional) — Standar deviasi gambar yang digunakan untuk normalisasi. Hanya berpengaruh jikado_normalizediatur keTrue. - do_pad (
bool, kwargs, opsional) — Apakah akan melakukan padding pada gambar. Padding dilakukan ke ukuran terbesar dalam batch atau ke ukuran persegi tetap per gambar. Strategi padding yang tepat bergantung pada model. - pad_size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Ukuran dalam{"height": int, "width" int}untuk melakukan padding pada gambar. Harus lebih besar dari ukuran gambar mana pun yang disediakan untuk pra-pemrosesan. Jikapad_sizetidak disediakan, gambar akan di-pad hingga tinggi dan lebar terbesar dalam batch. Diterapkan hanya ketikado_pad=True. - do_center_crop (
bool, kwargs, opsional) — Apakah akan melakukan center crop pada gambar. - data_format (
Union[str, ~image_utils.ChannelDimension], kwargs, opsional) — HanyaChannelDimension.FIRSTyang didukung. Ditambahkan untuk kompatibilitas dengan prosesor lambat. - input_data_format (
Union[str, ~image_utils.ChannelDimension], kwargs, opsional) — Format dimensi channel untuk gambar input. Jika tidak diset, format dimensi channel akan disimpulkan dari gambar input. Bisa berupa salah satu dari:"channels_first"atauChannelDimension.FIRST: gambar dalam format (num_channels, height, width)."channels_last"atauChannelDimension.LAST: gambar dalam format (height, width, num_channels)."none"atauChannelDimension.NONE: gambar dalam format (height, width).
- device (
Annotated[Union[str, torch.device, NoneType], None], kwargs) — Perangkat untuk memproses video. Jika tidak disetel, perangkat akan disimpulkan dari video input. - return_tensors (
Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Mengembalikan tensor bertumpuk jika diset ke'pt', selain itu mengembalikan daftar tensor. - disable_grouping (
bool, kwargs, opsional) — Apakah akan menonaktifkan pengelompokan gambar berdasarkan ukuran untuk memprosesnya secara individual dan bukan dalam batch. Jika None, akan diatur ke True jika gambar berada di CPU, dan False selain itu. Pilihan ini didasarkan pada pengamatan empiris, seperti yang dijelaskan di sini: https://github.com/huggingface/transformers/pull/38157 - image_seq_length (
int, kwargs, opsional) — Jumlah token gambar yang akan digunakan untuk setiap gambar dalam input. Ditambahkan untuk kompatibilitas mundur, tetapi ini seharusnya diatur sebagai atribut prosesor pada model-model mendatang.
Mengembalikan
~image_processing_base.BatchFeature
- data (
dict) — Kamus berisi daftar/array/tensor yang dikembalikan oleh metode call (‘pixel_values’, dll.). - tensor_type (
Union[None, str, TensorType], opsional) — Anda dapat memberikan tensor_type di sini untuk mengonversi daftar bilangan bulat menjadi Tensor PyTorch/Numpy saat inisialisasi.
Praproses sebuah gambar atau kumpulan gambar.
PerceiverTextPreprocessor
kelas transformers.models.perceiver.modeling_perceiver.PerceiverTextPreprocessor
< source >( config: PerceiverConfig )
Parameter
- config (PerceiverConfig) — Konfigurasi model.
Prapemrosesan teks untuk Perceiver Encoder. Dapat digunakan untuk menyematkan inputs dan menambahkan pengkodean posisi.
Dimensi dari embedding ditentukan oleh atribut d_model dari konfigurasi.
PerceiverImagePreprocessor
kelas transformers.models.perceiver.modeling_perceiver.PerceiverImagePreprocessor
< source >( configprep_type = 'conv'spatial_downsample: int = 4temporal_downsample: int = 1position_encoding_type: str = 'fourier'in_channels: int = 3out_channels: int = 64conv_after_patching: bool = Falseconv_after_patching_in_channels: int = 54conv2d_use_batchnorm: bool = Trueconcat_or_add_pos: str = 'concat'project_pos_dim: int = -1**position_encoding_kwargs )
Parameter
- config ([PerceiverConfig]) — Konfigurasi model.
- prep_type (
str, opsional, defaultnya"conv") — Jenis pra-pemrosesan. Bisa berupa “conv1x1”, “conv”, “patches”, “pixels”. - spatial_downsample (
int, opsional, default 4) — Faktor downsampling spasial. - temporal_downsample (
int, opsional, default 1) — Faktor downsampling temporal (hanya relevan jika dimensi waktu ada). - position_encoding_type (
str, opsional, default"fourier") — Jenis position encoding. Bisa berupa “fourier” atau “trainable”. - in_channels (
int, opsional, default 3) — Jumlah channel pada input. - out_channels (
int, opsional, default 64) — Jumlah channel pada output. - conv_after_patching (
bool, opsional, defaultFalse) — Apakah akan menerapkan lapisan konvolusional setelah patching. - conv_after_patching_in_channels (
int, opsional, defaultnya 54) — Jumlah channel pada input lapisan konvolusional setelah patching. - conv2d_use_batchnorm (
bool, opsional, defaultTrue) — Apakah akan menggunakan batch normalization pada lapisan konvolusional. - concat_or_add_pos (
str, opsional, default"concat") — Cara menggabungkan position encoding ke input. Bisa berupa “concat” atau “add”. - project_pos_dim (
int, opsional, default -1) — Dimensi dari position encoding yang akan diproyeksikan. Jika -1, tidak ada proyeksi yang diterapkan. - **position_encoding_kwargs (
Dict, opsional) — Argumen kata kunci untuk position encoding.
Prapemrosesan gambar untuk Perceiver Encoder.
Catatan: argumen out_channels merujuk pada saluran keluar dari lapisan konvolusional, jika prep_type diatur ke “conv1x1” atau “conv”. Jika seseorang menambahkan embedding posisi absolut, seseorang harus memastikan bahwa num_channels dari kwargs encoding posisi diset sama dengan out_channels.
PerceiverOneHotPreprocessor
kelas transformers.models.perceiver.modeling_perceiver.PerceiverOneHotPreprocessor
< source >( config: PerceiverConfig )
Parameter
- config (PerceiverConfig) — Konfigurasi model.
Preprocessor one-hot untuk Perceiver Encoder. Dapat digunakan untuk menambahkan dimensi indeks dummy ke input.
PerceiverAudioPreprocessor
kelas transformers.models.perceiver.modeling_perceiver.PerceiverAudioPreprocessor
< source >( configprep_type: str = 'patches'samples_per_patch: int = 96position_encoding_type: str = 'fourier'concat_or_add_pos: str = 'concat'out_channels = 64project_pos_dim = -1**position_encoding_kwargs )
Parameter
- config ([PerceiverConfig]) — Konfigurasi model.
- prep_type (
str, opsional, defaultnya"patches") — Jenis preprocessor yang akan digunakan. Hanya “patches” yang didukung. - samples_per_patch (
int, opsional, default 96) — Jumlah sampel per patch. - position_encoding_type (
str, opsional, default"fourier") — Jenis position encoding yang akan digunakan. Bisa berupa “trainable” atau “fourier”. - concat_or_add_pos (
str, opsional, default"concat") — Cara menggabungkan position encoding ke input. Bisa berupa “concat” atau “add”. - out_channels (
int, opsional, default 64) — Jumlah channel pada output. - project_pos_dim (
int, opsional, default -1) — Dimensi dari position encoding yang akan diproyeksikan. Jika -1, tidak ada proyeksi yang diterapkan. - **position_encoding_kwargs (
Dict, opsional) — Argumen kata kunci untuk position encoding.
Pra-pemrosesan audio untuk Perceiver Encoder.
PerceiverMultimodalPreprocessor
kelas transformers.models.perceiver.modeling_perceiver.PerceiverMultimodalPreprocessor
< source >( modalities: Mappingmask_probs: collections.abc.Mapping[str, float] | None = Nonemin_padding_size: int = 2 )
Parameter
- modalities (
Mapping[str, PreprocessorType]) — Dict yang memetakan nama modalitas ke preprocessor. - mask_probs (
dict[str, float]) — Dict yang memetakan nama modalitas ke probabilitas masking dari modalitas tersebut. - min_padding_size (
int, opsional, default 2) — Ukuran padding minimum untuk semua modalitas. Output akhir akan memiliki num_channels yang sama dengan jumlah channel maksimum di antara semua modalitas ditambah min_padding_size.
Pra-pemrosesan multimodal untuk Perceiver Encoder.
Input untuk setiap modalitas dipreproses, kemudian di-pad dengan position embeddings yang dapat dilatih agar memiliki jumlah channel yang sama.
PerceiverProjectionDecoder
kelas transformers.models.perceiver.modeling_perceiver.PerceiverProjectionDecoder
< source >( config )
Parameter
- config (PerceiverConfig) — Konfigurasi model.
Decoder proyeksi baseline (tanpa cross-attention).
PerceiverBasicDecoder
kelas transformers.models.perceiver.modeling_perceiver.PerceiverBasicDecoder
< source >( config: PerceiverConfigoutput_num_channels: intposition_encoding_type: str | None = 'trainable'output_index_dims: int | None = Nonenum_channels: int | None = 128subsampled_index_dims: int | None = Noneqk_channels: int | None = Nonev_channels: int | None = Nonenum_heads: int | None = 1widening_factor: int | None = 1use_query_residual: bool | None = Falseconcat_preprocessed_input: bool | None = Falsefinal_project: bool | None = Trueposition_encoding_only: bool | None = False**position_encoding_kwargs )
Parameter
- config ([PerceiverConfig]) — Konfigurasi model.
- output_num_channels (
int, opsional) — Jumlah channel pada output. Hanya akan digunakan jika final_project diatur keTrue. - position_encoding_type (
str, opsional, default “trainable”) — Jenis position encoding yang akan digunakan. Bisa berupa “trainable”, “fourier”, atau “none”. - output_index_dims (
int, opsional) — Jumlah dimensi dari query output. Diabaikan jika ‘position_encoding_type’ == ‘none’. - num_channels (
int, opsional, default 128) — Jumlah channel dari query decoder. Diabaikan jika ‘position_encoding_type’ == ‘none’. - qk_channels (
int, opsional) — Jumlah channel dari query dan key pada lapisan cross-attention. - v_channels (
int, opsional) — Jumlah channel dari nilai pada lapisan cross-attention. - num_heads (
int, opsional, default 1) — Jumlah kepala perhatian pada lapisan cross-attention. - widening_factor (
int, opsional, default 1) — Faktor pelebaran dari lapisan cross-attention. - use_query_residual (
bool, opsional, defaultnyaFalse) — Apakah akan menggunakan koneksi residual antara query dan output dari lapisan cross-attention. - concat_preprocessed_input (
bool, opsional, defaultnyaFalse) — Apakah akan menggabungkan input yang telah diproses ke dalam query. - final_project (
bool, opsional, defaultnyaTrue) — Apakah akan memproyeksikan output dari lapisan cross-attention ke dimensi target. - position_encoding_only (
bool, opsional, defaultFalse) — Apakah hanya menggunakan kelas ini untuk mendefinisikan kueri output.
Decoder berbasis cross-attention. Kelas ini dapat digunakan untuk mendekode hidden states akhir dari latents menggunakan operasi cross-attention, di mana latents menghasilkan keys dan values.
Bentuk output dari kelas ini bergantung pada bagaimana query output (juga disebut query decoder) didefinisikan.
PerceiverClassificationDecoder
kelas transformers.models.perceiver.modeling_perceiver.PerceiverClassificationDecoder
< source >( config**decoder_kwargs )
Parameter
- config (PerceiverConfig) — Konfigurasi model.
Decoder klasifikasi berbasis cross-attention. Pembungkus ringan dari PerceiverBasicDecoder untuk output logit.
Akan mengubah output dari encoder Perceiver yang berbentuk (batch_size, num_latents, d_latents) menjadi tensor
berbentuk (batch_size, num_labels). Query berbentuk (batch_size, 1, num_labels).
PerceiverOpticalFlowDecoder
kelas transformers.models.perceiver.modeling_perceiver.PerceiverOpticalFlowDecoder
< source >( configoutput_image_shapeoutput_num_channels = 2rescale_factor = 100.0**decoder_kwargs )
Dekoder aliran optik berbasis cross-attention.
PerceiverBasicVideoAutoencodingDecoder
kelas transformers.models.perceiver.modeling_perceiver.PerceiverBasicVideoAutoencodingDecoder
< source >( config: PerceiverConfigoutput_shape: listposition_encoding_type: str**decoder_kwargs )
Dekoder video-autoencoding berbasis cross-attention. Pembungkus ringan dari [PerceiverBasicDecoder] dengan logika pembentukan ulang video.
PerceiverMultimodalDecoder
kelas transformers.models.perceiver.modeling_perceiver.PerceiverMultimodalDecoder
< source >( config: PerceiverConfigmodalities: dictnum_outputs: intoutput_num_channels: intmin_padding_size: int | None = 2subsampled_index_dims: dict[str, transformers.models.perceiver.modeling_perceiver.PerceiverAbstractDecoder] | None = None**decoder_kwargs )
Parameter
- config ([PerceiverConfig]) — Konfigurasi model.
- modalities (
dict[str, PerceiverAbstractDecoder]) — Kamus yang memetakan nama modalitas ke decoder dari modalitas tersebut. - num_outputs (
int) — Jumlah output dari decoder. - output_num_channels (
int) — Jumlah channel pada output. - min_padding_size (
int, opsional, default 2) — Ukuran padding minimum untuk semua modalitas. Output akhir akan memiliki num_channels yang sama dengan jumlah channel maksimum di antara semua modalitas ditambah min_padding_size. - subsampled_index_dims (
dict[str, PerceiverAbstractDecoder], opsional) — Kamus yang memetakan nama modalitas ke dimensi indeks subsampled yang akan digunakan untuk query decoder dari modalitas tersebut.
Dekoding multimodal dengan menyusun dekoder unimodal. Argumen modalities dari konstruktor adalah kamus yang memetakan nama modalitas ke dekoder dari modalitas tersebut. Dekoder itu akan digunakan untuk membangun query untuk modalitas tersebut. Query yang spesifik untuk modalitas dipad dengan parameter yang dapat dilatih dan spesifik untuk modalitas, setelah itu digabungkan sepanjang dimensi waktu.
Selanjutnya, terdapat operasi cross attention bersama di antara semua modalitas.
PerceiverProjectionPostprocessor
kelas transformers.models.perceiver.modeling_perceiver.PerceiverProjectionPostprocessor
< source >( in_channels: intout_channels: int )
Postprocessing proyeksi untuk Perceiver. Dapat digunakan untuk memproyeksikan saluran dari output decoder ke dimensi yang lebih rendah.
PerceiverAudioPostprocessor
kelas transformers.models.perceiver.modeling_perceiver.PerceiverAudioPostprocessor
< source >( config: PerceiverConfigin_channels: intpostproc_type: str = 'patches' )
Postprocessing audio untuk Perceiver. Dapat digunakan untuk mengonversi output decoder menjadi fitur audio.
PerceiverClassificationPostprocessor
kelas transformers.models.perceiver.modeling_perceiver.PerceiverClassificationPostprocessor
< source >( config: PerceiverConfigin_channels: int )
Postprocessing klasifikasi untuk Perceiver. Dapat digunakan untuk mengonversi output decoder menjadi logits klasifikasi.
PerceiverMultimodalPostprocessor
kelas transformers.models.perceiver.modeling_perceiver.PerceiverMultimodalPostprocessor
< source >( modalities: Mappinginput_is_dict: bool = False )
Parameter
- modalities (
Mapping[str, PostprocessorType]) — Kamus yang memetakan nama modalitas ke kelas postprocessor untuk modalitas tersebut. - input_is_dict (
bool, opsional, defaultFalse) — Jika True, input diasumsikan berstruktur dictionary, dan output mempertahankan bentuk dictionary yang sama. Jika False, input adalah tensor yang dipotong-potong selama postprocessing oleh modality_sizes.
Postprocessing multimodal untuk Perceiver. Dapat digunakan untuk menggabungkan postprocessor yang spesifik untuk setiap modalitas menjadi satu postprocessor.
PerceiverModel
kelas transformers.PerceiverModel
< source >( config: PerceiverConfigdecoder: typing.Optional[ForwardRef('PerceiverAbstractDecoder')] = Noneinput_preprocessor: Callable = Noneoutput_postprocessor: Callable = None )
Parameter
- config (PerceiverConfig) — Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya. Lihat metode from_pretrained() untuk memuat bobot model.
- decoder (
PerceiverDecoder, opsional) — Modul yang mengubah representasi laten menjadi prediksi tugas. - input_preprocessor (
PreprocessorType, opsional) — Preprocessor yang mengkodekan input mentah menjadi tensor untuk model. - output_postprocessor (
PostprocessorType, opsional) — Postprocessor yang mengubah output model menjadi prediksi akhir.
Perceiver: arsitektur yang dapat diskalakan dan sepenuhnya berbasis perhatian.
Perlu dicatat bahwa Perceiver dapat dihaluskan (fine-tune) pada gambar dengan resolusi lebih tinggi daripada yang digunakan saat pelatihan, dengan mengatur
interpolate_pos_encodingmenjadiTruepada forward model. Hal ini akan menginterpolasi position embeddings yang telah dilatih ke resolusi yang lebih tinggi.
Model ini mewarisi dari PreTrainedModel. Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran embedding input, memangkas kepala, dll.)
Model ini juga merupakan subclass dari torch.nn.Module PyTorch. Gunakan sebagai PyTorch Module biasa dan merujuk ke dokumentasi PyTorch untuk semua hal yang berkaitan dengan penggunaan dan perilaku umum.
forward
< source >( inputs: Tensorattention_mask: typing.Optional[torch.Tensor] = Nonesubsampled_output_points: dict[str, torch.Tensor] | None = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Noneinterpolate_pos_encoding: bool = Falsereturn_dict: bool | None = None**kwargs ) → PerceiverModelOutput or tuple(torch.Tensor)
Parameter
- inputs (
torch.Tensor) — Input untuk perceiver. Bisa berupa apa saja: gambar, teks, audio, video, dll. - attention_mask (
torch.Tensordengan bentuk(batch_size, sequence_length), opsional) — Mask untuk menghindari eksekusi attention pada indeks token padding. Nilai mask dipilih dari[0, 1]:- 1 untuk token yang tidak dimasker,
- 0 untuk token yang dimasker.
- subsampled_output_points (
dict[str, torch.Tensor], opsional) — Kamus tensor yang digunakan sebagai query untuk decoder. Decoder memetakan query ini ke representasi laten dari model. Digunakan untuk decoding subsampled, misalnya ketika hanya mendekode patch gambar tertentu. - output_attentions (
bool, opsional) — Apakah akan mengembalikan tensor attentions dari semua lapisan attention. Lihatattentionsdi bawah tensor yang dikembalikan untuk detail lebih lanjut. - output_hidden_states (
bool, opsional) — Apakah akan mengembalikan hidden states dari semua lapisan. Lihathidden_statesdi bawah tensor yang dikembalikan untuk detail lebih lanjut. - interpolate_pos_encoding (
bool, opsional, defaultFalse) — Apakah akan menginterpolasi posisi encoding yang telah dilatih sebelumnya. - return_dict (
bool, opsional) — Apakah akan mengembalikan ModelOutput alih-alih tuple biasa.
Mengembalikan
PerceiverModelOutput atau tuple(torch.Tensor)
A PerceiverModelOutput atau tuple dari
torch.Tensor (jika return_dict=False dilewatkan atau ketika config.return_dict=False) yang terdiri dari berbagai
elemen tergantung pada konfigurasi (PerceiverConfig) dan input.
Metode forward dari PerceiverModel menimpa metode khusus __call__.
Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance
Modulesetelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam.
logits (
torch.Tensordengan bentuk(batch_size, num_labels)) — Skor klasifikasi (atau regresi jika config.num_labels==1) (sebelum SoftMax).last_hidden_state (
torch.Tensordengan bentuk(batch_size, sequence_length, hidden_size), opsional) — Urutan hidden-states pada keluaran lapisan terakhir model.hidden_states (
tuple[torch.Tensor], opsional, dikembalikan saatoutput_hidden_states=Truedilewatkan atau saatconfig.output_hidden_states=True) — Tuple daritorch.Tensor(satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk(batch_size, sequence_length, hidden_size).Hidden-states model pada output setiap layer ditambah output embedding awal yang opsional.
attentions (
tuple[torch.Tensor], opsional, dikembalikan saatoutput_attentions=Truedilewatkan atau saatconfig.output_attentions=True) — Tuple daritorch.Tensor(satu untuk setiap layer) dengan bentuk(batch_size, num_heads, sequence_length, sequence_length).Bobot perhatian setelah softmax perhatian, digunakan untuk menghitung rata-rata berbobot di kepala perhatian diri (self-attention).
cross_attentions (
tuple[torch.Tensor], opsional, dikembalikan saatoutput_attentions=Truedilewatkan atau saatconfig.output_attentions=True) — Tuple daritorch.Tensor(satu untuk setiap layer) dengan bentuk(batch_size, num_heads, sequence_length, sequence_length).Bobot perhatian dari lapisan cross-attention decoder, setelah softmax perhatian, yang digunakan untuk menghitung rata-rata berbobot di kepala cross-attention.
Contoh:
>>> 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
kelas transformers.PerceiverForMaskedLM
< source >( config: PerceiverConfig )
Parameter
- config (PerceiverConfig) — Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya. Lihat metode from_pretrained() untuk memuat bobot model.
Contoh penggunaan Perceiver untuk pemodelan bahasa yang disamarkan.
Model ini mewarisi dari PreTrainedModel. Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran embedding input, memangkas kepala, dll.)
Model ini juga merupakan subclass dari torch.nn.Module PyTorch. Gunakan sebagai PyTorch Module biasa dan merujuk ke dokumentasi PyTorch untuk semua hal yang berkaitan dengan penggunaan dan perilaku umum.
forward
< source >( inputs: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonelabels: typing.Optional[torch.Tensor] = Nonereturn_dict: bool | None = Noneinput_ids: typing.Optional[torch.Tensor] = None**kwargs ) → PerceiverMaskedLMOutput or tuple(torch.Tensor)
Parameter
- inputs (
torch.Tensor, opsional) — Input untuk perceiver. Bisa berupa apa saja: gambar, teks, audio, video, dll. - attention_mask (
torch.Tensordengan bentuk(batch_size, sequence_length), opsional) — Mask untuk menghindari eksekusi attention pada indeks token padding. Nilai mask dipilih dari[0, 1]:- 1 untuk token yang tidak dimasker,
- 0 untuk token yang dimasker.
- output_attentions (
bool, opsional) — Apakah akan mengembalikan tensor attentions dari semua lapisan attention. Lihatattentionsdi bawah tensor yang dikembalikan untuk detail lebih lanjut. - output_hidden_states (
bool, opsional) — Apakah akan mengembalikan hidden states dari semua lapisan. Lihathidden_statesdi bawah tensor yang dikembalikan untuk detail lebih lanjut. - labels (
torch.LongTensordengan bentuk(batch_size, sequence_length), opsional) — Label untuk menghitung kerugian pemodelan bahasa yang disamarkan (masked language modeling). Indeks harus berada dalam[-100, 0, ..., config.vocab_size](lihat docstringinput_ids). Token dengan indeks yang disetel ke-100diabaikan (disamarkan), kerugian hanya dihitung untuk token dengan label dalam[0, ..., config.vocab_size]. - return_dict (
bool, opsional) — Apakah akan mengembalikan ModelOutput alih-alih tuple biasa. - input_ids (
torch.Tensordengan bentuk(batch_size, sequence_length), opsional) — Indeks token dari urutan input dalam kosakata. Padding akan diabaikan secara default.Indeks dapat diperoleh menggunakan AutoTokenizer. Lihat PreTrainedTokenizer.encode() dan PreTrainedTokenizer.call() untuk detailnya.
Mengembalikan
PerceiverMaskedLMOutput atau tuple(torch.Tensor)
A PerceiverMaskedLMOutput atau tuple dari
torch.Tensor (jika return_dict=False dilewatkan atau ketika config.return_dict=False) yang terdiri dari berbagai
elemen tergantung pada konfigurasi (PerceiverConfig) dan input.
Metode forward dari PerceiverForMaskedLM menimpa metode khusus __call__.
Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance
Modulesetelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam.
loss (
torch.Tensordengan bentuk(1,), opsional, dikembalikan ketikalabelsdisediakan) — Masked language modeling (MLM) loss.logits (
torch.Tensordengan bentuk(batch_size, sequence_length, config.vocab_size)) — Skor prediksi dari kepala pemodelan bahasa (skor untuk setiap token kosakata sebelum SoftMax).hidden_states (
tuple[torch.Tensor], opsional, dikembalikan saatoutput_hidden_states=Truedilewatkan atau saatconfig.output_hidden_states=True) — Tuple daritorch.Tensor(satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk(batch_size, sequence_length, hidden_size).Hidden-states model pada output setiap layer ditambah output embedding awal yang opsional.
attentions (
tuple[torch.Tensor], opsional, dikembalikan saatoutput_attentions=Truedilewatkan atau saatconfig.output_attentions=True) — Tuple daritorch.Tensor(satu untuk setiap layer) dengan bentuk(batch_size, num_heads, sequence_length, sequence_length).Bobot perhatian setelah softmax perhatian, digunakan untuk menghitung rata-rata berbobot di kepala perhatian diri (self-attention).
cross_attentions (
tuple[torch.Tensor], opsional, dikembalikan saatoutput_attentions=Truedilewatkan atau saatconfig.output_attentions=True) — Tuple daritorch.Tensor(satu untuk setiap layer) dengan bentuk(batch_size, num_heads, sequence_length, sequence_length).Bobot perhatian dari lapisan cross-attention decoder, setelah softmax perhatian, yang digunakan untuk menghitung rata-rata berbobot di kepala cross-attention.
Contoh:
>>> 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
kelas transformers.PerceiverForSequenceClassification
< source >( config: PerceiverConfig )
Parameter
- config (PerceiverConfig) — Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya. Lihat metode from_pretrained() untuk memuat bobot model.
Contoh penggunaan Perceiver untuk klasifikasi teks.
Model ini mewarisi dari PreTrainedModel. Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran embedding input, memangkas kepala, dll.)
Model ini juga merupakan subclass dari torch.nn.Module PyTorch. Gunakan sebagai PyTorch Module biasa dan merujuk ke dokumentasi PyTorch untuk semua hal yang berkaitan dengan penggunaan dan perilaku umum.
forward
< source >( inputs: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonelabels: typing.Optional[torch.Tensor] = Nonereturn_dict: bool | None = Noneinput_ids: typing.Optional[torch.Tensor] = None**kwargs ) → PerceiverClassifierOutput or tuple(torch.Tensor)
Parameter
- inputs (
torch.Tensor, opsional) — Input untuk perceiver. Bisa berupa apa saja: gambar, teks, audio, video, dll. - attention_mask (
torch.Tensordengan bentuk(batch_size, sequence_length), opsional) — Mask untuk menghindari eksekusi attention pada indeks token padding. Nilai mask dipilih dari[0, 1]:- 1 untuk token yang tidak dimasker,
- 0 untuk token yang dimasker.
- output_attentions (
bool, opsional) — Apakah akan mengembalikan tensor attentions dari semua lapisan attention. Lihatattentionsdi bawah tensor yang dikembalikan untuk detail lebih lanjut. - output_hidden_states (
bool, opsional) — Apakah akan mengembalikan hidden states dari semua lapisan. Lihathidden_statesdi bawah tensor yang dikembalikan untuk detail lebih lanjut. - labels (
torch.LongTensordengan bentuk(batch_size,), opsional) — Label untuk menghitung loss klasifikasi/regresi. Indeks harus berada dalam[0, ..., config.num_labels - 1]. Jikaconfig.num_labels == 1, loss regresi dihitung (Mean-Square loss). Jikaconfig.num_labels > 1, loss klasifikasi dihitung (Cross-Entropy). - return_dict (
bool, opsional) — Apakah akan mengembalikan ModelOutput alih-alih tuple biasa. - input_ids (
torch.Tensordengan bentuk(batch_size, sequence_length), opsional) — Indeks token dari urutan input dalam kosakata. Padding akan diabaikan secara default.Indeks dapat diperoleh menggunakan AutoTokenizer. Lihat PreTrainedTokenizer.encode() dan PreTrainedTokenizer.call() untuk detailnya.
Mengembalikan
PerceiverClassifierOutput atau tuple(torch.Tensor)
A PerceiverClassifierOutput atau tuple dari
torch.Tensor (jika return_dict=False dilewatkan atau ketika config.return_dict=False) yang terdiri dari berbagai
elemen tergantung pada konfigurasi (PerceiverConfig) dan input.
Metode forward dari PerceiverForSequenceClassification menimpa metode khusus __call__.
Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance
Modulesetelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam.
loss (
torch.Tensordengan bentuk(1,), opsional, dikembalikan saatlabelsdisediakan) — Loss klasifikasi (atau regresi jika config.num_labels==1).logits (
torch.Tensordengan bentuk(batch_size, config.num_labels)) — Skor klasifikasi (atau regresi jika config.num_labels==1) (sebelum SoftMax).hidden_states (
tuple[torch.Tensor], opsional, dikembalikan saatoutput_hidden_states=Truedilewatkan atau saatconfig.output_hidden_states=True) — Tuple daritorch.Tensor(satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk(batch_size, sequence_length, hidden_size).Hidden-states model pada output setiap layer ditambah output embedding awal yang opsional.
attentions (
tuple[torch.Tensor], opsional, dikembalikan saatoutput_attentions=Truedilewatkan atau saatconfig.output_attentions=True) — Tuple daritorch.Tensor(satu untuk setiap layer) dengan bentuk(batch_size, num_heads, sequence_length, sequence_length).Bobot perhatian setelah softmax perhatian, digunakan untuk menghitung rata-rata berbobot di kepala perhatian diri (self-attention).
cross_attentions (
tuple[torch.Tensor], opsional, dikembalikan saatoutput_attentions=Truedilewatkan atau saatconfig.output_attentions=True) — Tuple daritorch.Tensor(satu untuk setiap layer) dengan bentuk(batch_size, num_heads, sequence_length, sequence_length).Bobot perhatian dari lapisan cross-attention decoder, setelah softmax perhatian, yang digunakan untuk menghitung rata-rata berbobot di kepala cross-attention.
Contoh:
>>> 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
kelas transformers.PerceiverForImageClassificationLearned
< source >( config: PerceiverConfig )
Parameter
- config (PerceiverConfig) — Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya. Lihat metode from_pretrained() untuk memuat bobot model.
Contoh penggunaan Perceiver untuk klasifikasi gambar, untuk tugas seperti ImageNet.
Model ini menggunakan posisi embedding yang dipelajari. Dengan kata lain, model ini tidak diberikan informasi istimewa apa pun tentang struktur gambar. Seperti yang ditunjukkan dalam makalah, model ini dapat mencapai akurasi top-1 sebesar 72,7 pada ImageNet.
PerceiverForImageClassificationLearned menggunakan PerceiverImagePreprocessor (dengan prep_type="conv1x1") untuk memproses prapenanganan gambar input, dan PerceiverClassificationDecoder untuk mendekode representasi laten dari PerceiverModel menjadi logits klasifikasi.
Model ini mewarisi dari PreTrainedModel. Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran embedding input, memangkas kepala, dll.)
Model ini juga merupakan subclass dari torch.nn.Module PyTorch. Gunakan sebagai PyTorch Module biasa dan merujuk ke dokumentasi PyTorch untuk semua hal yang berkaitan dengan penggunaan dan perilaku umum.
forward
< source >( inputs: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonelabels: typing.Optional[torch.Tensor] = Noneinterpolate_pos_encoding: bool = Falsereturn_dict: bool | None = Nonepixel_values: typing.Optional[torch.Tensor] = None**kwargs ) → PerceiverClassifierOutput or tuple(torch.Tensor)
Parameter
- inputs (
torch.Tensor, opsional) — Input untuk perceiver. Bisa berupa apa saja: gambar, teks, audio, video, dll. - attention_mask (
torch.Tensordengan bentuk(batch_size, sequence_length), opsional) — Mask untuk menghindari eksekusi attention pada indeks token padding. Nilai mask dipilih dari[0, 1]:- 1 untuk token yang tidak dimasker,
- 0 untuk token yang dimasker.
- output_attentions (
bool, opsional) — Apakah akan mengembalikan tensor attentions dari semua lapisan attention. Lihatattentionsdi bawah tensor yang dikembalikan untuk detail lebih lanjut. - output_hidden_states (
bool, opsional) — Apakah akan mengembalikan hidden states dari semua lapisan. Lihathidden_statesdi bawah tensor yang dikembalikan untuk detail lebih lanjut. - labels (
torch.LongTensordengan bentuk(batch_size,), opsional) — Label untuk menghitung loss klasifikasi/regresi gambar. Indeks harus berada dalam[0, ..., config.num_labels - 1]. Jikaconfig.num_labels == 1, loss regresi dihitung (Mean-Square loss). Jikaconfig.num_labels > 1, loss klasifikasi dihitung (Cross-Entropy). - interpolate_pos_encoding (
bool, opsional, defaultFalse) — Apakah akan menginterpolasi posisi encoding yang telah dilatih sebelumnya. - return_dict (
bool, opsional) — Apakah akan mengembalikan ModelOutput alih-alih tuple biasa. - pixel_values (
torch.Tensordengan bentuk(batch_size, num_channels, image_size, image_size), opsional) — Tensor yang sesuai dengan gambar input. Nilai piksel dapat diperoleh menggunakan PerceiverImageProcessor. Lihat PerceiverImageProcessor.call() untuk detailnya (processor_classmenggunakan PerceiverImageProcessor untuk memproses gambar).
Mengembalikan
PerceiverClassifierOutput atau tuple(torch.Tensor)
A PerceiverClassifierOutput atau tuple dari
torch.Tensor (jika return_dict=False dilewatkan atau ketika config.return_dict=False) yang terdiri dari berbagai
elemen tergantung pada konfigurasi (PerceiverConfig) dan input.
Metode forward dari PerceiverForImageClassificationLearned menimpa metode khusus __call__.
Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance
Modulesetelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam.
loss (
torch.Tensordengan bentuk(1,), opsional, dikembalikan saatlabelsdisediakan) — Loss klasifikasi (atau regresi jika config.num_labels==1).logits (
torch.Tensordengan bentuk(batch_size, config.num_labels)) — Skor klasifikasi (atau regresi jika config.num_labels==1) (sebelum SoftMax).hidden_states (
tuple[torch.Tensor], opsional, dikembalikan saatoutput_hidden_states=Truedilewatkan atau saatconfig.output_hidden_states=True) — Tuple daritorch.Tensor(satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk(batch_size, sequence_length, hidden_size).Hidden-states model pada output setiap layer ditambah output embedding awal yang opsional.
attentions (
tuple[torch.Tensor], opsional, dikembalikan saatoutput_attentions=Truedilewatkan atau saatconfig.output_attentions=True) — Tuple daritorch.Tensor(satu untuk setiap layer) dengan bentuk(batch_size, num_heads, sequence_length, sequence_length).Bobot perhatian setelah softmax perhatian, digunakan untuk menghitung rata-rata berbobot di kepala perhatian diri (self-attention).
cross_attentions (
tuple[torch.Tensor], opsional, dikembalikan saatoutput_attentions=Truedilewatkan atau saatconfig.output_attentions=True) — Tuple daritorch.Tensor(satu untuk setiap layer) dengan bentuk(batch_size, num_heads, sequence_length, sequence_length).Bobot perhatian dari lapisan cross-attention decoder, setelah softmax perhatian, yang digunakan untuk menghitung rata-rata berbobot di kepala cross-attention.
Contoh:
>>> 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 catPerceiverForImageClassificationFourier
kelas transformers.PerceiverForImageClassificationFourier
< source >( config: PerceiverConfig )
Parameter
- config (PerceiverConfig) — Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya. Lihat metode from_pretrained() untuk memuat bobot model.
Contoh penggunaan Perceiver untuk klasifikasi gambar, untuk tugas seperti ImageNet.
Model ini menggunakan penanam posisi Fourier 2D tetap. Seperti yang ditunjukkan dalam makalah, model ini dapat mencapai akurasi top-1 sebesar 79,0 pada ImageNet, dan 84,5 ketika dilatih sebelumnya pada dataset berskala besar (yaitu JFT).
PerceiverForImageClassificationLearned menggunakan PerceiverImagePreprocessor (dengan prep_type="pixels") untuk memproses prapenanganan gambar input, dan PerceiverClassificationDecoder untuk mendekode representasi laten dari PerceiverModel menjadi logits klasifikasi.
Model ini mewarisi dari PreTrainedModel. Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran embedding input, memangkas kepala, dll.)
Model ini juga merupakan subclass dari torch.nn.Module PyTorch. Gunakan sebagai PyTorch Module biasa dan merujuk ke dokumentasi PyTorch untuk semua hal yang berkaitan dengan penggunaan dan perilaku umum.
forward
< source >( inputs: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonelabels: typing.Optional[torch.Tensor] = Nonereturn_dict: bool | None = Nonepixel_values: typing.Optional[torch.Tensor] = None**kwargs ) → PerceiverClassifierOutput or tuple(torch.Tensor)
Parameter
- inputs (
torch.Tensor, opsional) — Input untuk perceiver. Bisa berupa apa saja: gambar, teks, audio, video, dll. - attention_mask (
torch.Tensordengan bentuk(batch_size, sequence_length), opsional) — Mask untuk menghindari eksekusi attention pada indeks token padding. Nilai mask dipilih dari[0, 1]:- 1 untuk token yang tidak dimasker,
- 0 untuk token yang dimasker.
- output_attentions (
bool, opsional) — Apakah akan mengembalikan tensor attentions dari semua lapisan attention. Lihatattentionsdi bawah tensor yang dikembalikan untuk detail lebih lanjut. - output_hidden_states (
bool, opsional) — Apakah akan mengembalikan hidden states dari semua lapisan. Lihathidden_statesdi bawah tensor yang dikembalikan untuk detail lebih lanjut. - labels (
torch.LongTensordengan bentuk(batch_size,), opsional) — Label untuk menghitung loss klasifikasi/regresi gambar. Indeks harus berada dalam[0, ..., config.num_labels - 1]. Jikaconfig.num_labels == 1, loss regresi dihitung (Mean-Square loss). Jikaconfig.num_labels > 1, loss klasifikasi dihitung (Cross-Entropy). - return_dict (
bool, opsional) — Apakah akan mengembalikan ModelOutput alih-alih tuple biasa. - pixel_values (
torch.Tensordengan bentuk(batch_size, num_channels, image_size, image_size), opsional) — Tensor yang sesuai dengan gambar input. Nilai piksel dapat diperoleh menggunakan PerceiverImageProcessor. Lihat PerceiverImageProcessor.call() untuk detailnya (processor_classmenggunakan PerceiverImageProcessor untuk memproses gambar).
Mengembalikan
PerceiverClassifierOutput atau tuple(torch.Tensor)
A PerceiverClassifierOutput atau tuple dari
torch.Tensor (jika return_dict=False dilewatkan atau ketika config.return_dict=False) yang terdiri dari berbagai
elemen tergantung pada konfigurasi (PerceiverConfig) dan input.
Metode forward dari PerceiverForImageClassificationFourier menimpa metode khusus __call__.
Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance
Modulesetelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam.
loss (
torch.Tensordengan bentuk(1,), opsional, dikembalikan saatlabelsdisediakan) — Loss klasifikasi (atau regresi jika config.num_labels==1).logits (
torch.Tensordengan bentuk(batch_size, config.num_labels)) — Skor klasifikasi (atau regresi jika config.num_labels==1) (sebelum SoftMax).hidden_states (
tuple[torch.Tensor], opsional, dikembalikan saatoutput_hidden_states=Truedilewatkan atau saatconfig.output_hidden_states=True) — Tuple daritorch.Tensor(satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk(batch_size, sequence_length, hidden_size).Hidden-states model pada output setiap layer ditambah output embedding awal yang opsional.
attentions (
tuple[torch.Tensor], opsional, dikembalikan saatoutput_attentions=Truedilewatkan atau saatconfig.output_attentions=True) — Tuple daritorch.Tensor(satu untuk setiap layer) dengan bentuk(batch_size, num_heads, sequence_length, sequence_length).Bobot perhatian setelah softmax perhatian, digunakan untuk menghitung rata-rata berbobot di kepala perhatian diri (self-attention).
cross_attentions (
tuple[torch.Tensor], opsional, dikembalikan saatoutput_attentions=Truedilewatkan atau saatconfig.output_attentions=True) — Tuple daritorch.Tensor(satu untuk setiap layer) dengan bentuk(batch_size, num_heads, sequence_length, sequence_length).Bobot perhatian dari lapisan cross-attention decoder, setelah softmax perhatian, yang digunakan untuk menghitung rata-rata berbobot di kepala cross-attention.
Contoh:
>>> 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 catPerceiverForImageClassificationConvProcessing
kelas transformers.PerceiverForImageClassificationConvProcessing
< source >( config: PerceiverConfig )
Parameter
- config (PerceiverConfig) — Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya. Lihat metode from_pretrained() untuk memuat bobot model.
Contoh penggunaan Perceiver untuk klasifikasi gambar, untuk tugas seperti ImageNet.
Model ini menggunakan jaringan pra-pemrosesan 2D conv+maxpool. Seperti yang ditunjukkan dalam makalah, model ini dapat mencapai akurasi top-1 sebesar 82,1 pada ImageNet.
PerceiverForImageClassificationLearned menggunakan PerceiverImagePreprocessor (dengan prep_type="conv") untuk memproses prapenanganan gambar input, dan PerceiverClassificationDecoder untuk mendekode representasi laten dari PerceiverModel menjadi logits klasifikasi.
Model ini mewarisi dari PreTrainedModel. Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran embedding input, memangkas kepala, dll.)
Model ini juga merupakan subclass dari torch.nn.Module PyTorch. Gunakan sebagai PyTorch Module biasa dan merujuk ke dokumentasi PyTorch untuk semua hal yang berkaitan dengan penggunaan dan perilaku umum.
forward
< source >( inputs: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonelabels: typing.Optional[torch.Tensor] = Nonereturn_dict: bool | None = Nonepixel_values: typing.Optional[torch.Tensor] = None**kwargs ) → PerceiverClassifierOutput or tuple(torch.Tensor)
Parameter
- inputs (
torch.Tensor, opsional) — Input untuk perceiver. Bisa berupa apa saja: gambar, teks, audio, video, dll. - attention_mask (
torch.Tensordengan bentuk(batch_size, sequence_length), opsional) — Mask untuk menghindari eksekusi attention pada indeks token padding. Nilai mask dipilih dari[0, 1]:- 1 untuk token yang tidak dimasker,
- 0 untuk token yang dimasker.
- output_attentions (
bool, opsional) — Apakah akan mengembalikan tensor attentions dari semua lapisan attention. Lihatattentionsdi bawah tensor yang dikembalikan untuk detail lebih lanjut. - output_hidden_states (
bool, opsional) — Apakah akan mengembalikan hidden states dari semua lapisan. Lihathidden_statesdi bawah tensor yang dikembalikan untuk detail lebih lanjut. - labels (
torch.LongTensordengan bentuk(batch_size,), opsional) — Label untuk menghitung loss klasifikasi/regresi gambar. Indeks harus berada dalam[0, ..., config.num_labels - 1]. Jikaconfig.num_labels == 1, loss regresi dihitung (Mean-Square loss). Jikaconfig.num_labels > 1, loss klasifikasi dihitung (Cross-Entropy). - return_dict (
bool, opsional) — Apakah akan mengembalikan ModelOutput alih-alih tuple biasa. - pixel_values (
torch.Tensordengan bentuk(batch_size, num_channels, image_size, image_size), opsional) — Tensor yang sesuai dengan gambar input. Nilai piksel dapat diperoleh menggunakan PerceiverImageProcessor. Lihat PerceiverImageProcessor.call() untuk detailnya (processor_classmenggunakan PerceiverImageProcessor untuk memproses gambar).
Mengembalikan
PerceiverClassifierOutput atau tuple(torch.Tensor)
A PerceiverClassifierOutput atau tuple dari
torch.Tensor (jika return_dict=False dilewatkan atau ketika config.return_dict=False) yang terdiri dari berbagai
elemen tergantung pada konfigurasi (PerceiverConfig) dan input.
Metode forward dari PerceiverForImageClassificationConvProcessing menimpa metode khusus __call__.
Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance
Modulesetelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam.
loss (
torch.Tensordengan bentuk(1,), opsional, dikembalikan saatlabelsdisediakan) — Loss klasifikasi (atau regresi jika config.num_labels==1).logits (
torch.Tensordengan bentuk(batch_size, config.num_labels)) — Skor klasifikasi (atau regresi jika config.num_labels==1) (sebelum SoftMax).hidden_states (
tuple[torch.Tensor], opsional, dikembalikan saatoutput_hidden_states=Truedilewatkan atau saatconfig.output_hidden_states=True) — Tuple daritorch.Tensor(satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk(batch_size, sequence_length, hidden_size).Hidden-states model pada output setiap layer ditambah output embedding awal yang opsional.
attentions (
tuple[torch.Tensor], opsional, dikembalikan saatoutput_attentions=Truedilewatkan atau saatconfig.output_attentions=True) — Tuple daritorch.Tensor(satu untuk setiap layer) dengan bentuk(batch_size, num_heads, sequence_length, sequence_length).Bobot perhatian setelah softmax perhatian, digunakan untuk menghitung rata-rata berbobot di kepala perhatian diri (self-attention).
cross_attentions (
tuple[torch.Tensor], opsional, dikembalikan saatoutput_attentions=Truedilewatkan atau saatconfig.output_attentions=True) — Tuple daritorch.Tensor(satu untuk setiap layer) dengan bentuk(batch_size, num_heads, sequence_length, sequence_length).Bobot perhatian dari lapisan cross-attention decoder, setelah softmax perhatian, yang digunakan untuk menghitung rata-rata berbobot di kepala cross-attention.
Contoh:
>>> 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 catPerceiverForOpticalFlow
kelas transformers.PerceiverForOpticalFlow
< source >( config: PerceiverConfig )
Parameter
- config (PerceiverConfig) — Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya. Lihat metode from_pretrained() untuk memuat bobot model.
Contoh penggunaan Perceiver untuk optical flow, untuk tugas seperti Sintel dan KITTI. PerceiverForOpticalFlow menggunakan PerceiverImagePreprocessor (dengan prep_type=“patches”) untuk memproses prapenanganan gambar input, dan PerceiverOpticalFlowDecoder untuk mendekode representasi laten dari PerceiverModel.
Sebagai input, dua frame berurutan digabungkan sepanjang dimensi channel dan sebuah patch 3 x 3 diekstrak di sekitar setiap piksel (menghasilkan 3 x 3 x 3 x 2 = 54 nilai untuk setiap piksel). Enkoding posisi Fourier tetap digunakan untuk mengenkod posisi setiap piksel dalam patch. Selanjutnya, encoder Perceiver diterapkan. Untuk mendekode, representasi laten dikueri menggunakan enkoding yang sama dengan yang digunakan untuk input.
Model ini mewarisi dari PreTrainedModel. Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran embedding input, memangkas kepala, dll.)
Model ini juga merupakan subclass dari torch.nn.Module PyTorch. Gunakan sebagai PyTorch Module biasa dan merujuk ke dokumentasi PyTorch untuk semua hal yang berkaitan dengan penggunaan dan perilaku umum.
forward
< source >( inputs: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonelabels: typing.Optional[torch.Tensor] = Nonereturn_dict: bool | None = None**kwargs ) → PerceiverClassifierOutput or tuple(torch.Tensor)
Parameter
- inputs (
torch.Tensor, opsional) — Input untuk perceiver. Bisa berupa apa saja: gambar, teks, audio, video, dll. - attention_mask (
torch.Tensordengan bentuk(batch_size, sequence_length), opsional) — Mask untuk menghindari eksekusi attention pada indeks token padding. Nilai mask dipilih dari[0, 1]:- 1 untuk token yang tidak dimasker,
- 0 untuk token yang dimasker.
- output_attentions (
bool, opsional) — Apakah akan mengembalikan tensor attentions dari semua lapisan attention. Lihatattentionsdi bawah tensor yang dikembalikan untuk detail lebih lanjut. - output_hidden_states (
bool, opsional) — Apakah akan mengembalikan hidden states dari semua lapisan. Lihathidden_statesdi bawah tensor yang dikembalikan untuk detail lebih lanjut. - labels (
torch.LongTensordengan bentuk(batch_size,), opsional) — Label untuk menghitung kerugian aliran optik. Indeks harus berada dalam[0, ..., config.num_labels - 1]. - return_dict (
bool, opsional) — Apakah akan mengembalikan ModelOutput alih-alih tuple biasa.
Mengembalikan
PerceiverClassifierOutput atau tuple(torch.Tensor)
A PerceiverClassifierOutput atau tuple dari
torch.Tensor (jika return_dict=False dilewatkan atau ketika config.return_dict=False) yang terdiri dari berbagai
elemen tergantung pada konfigurasi (PerceiverConfig) dan input.
Metode forward dari PerceiverForOpticalFlow menimpa metode khusus __call__.
Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance
Modulesetelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam.
loss (
torch.Tensordengan bentuk(1,), opsional, dikembalikan saatlabelsdisediakan) — Loss klasifikasi (atau regresi jika config.num_labels==1).logits (
torch.Tensordengan bentuk(batch_size, config.num_labels)) — Skor klasifikasi (atau regresi jika config.num_labels==1) (sebelum SoftMax).hidden_states (
tuple[torch.Tensor], opsional, dikembalikan saatoutput_hidden_states=Truedilewatkan atau saatconfig.output_hidden_states=True) — Tuple daritorch.Tensor(satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk(batch_size, sequence_length, hidden_size).Hidden-states model pada output setiap layer ditambah output embedding awal yang opsional.
attentions (
tuple[torch.Tensor], opsional, dikembalikan saatoutput_attentions=Truedilewatkan atau saatconfig.output_attentions=True) — Tuple daritorch.Tensor(satu untuk setiap layer) dengan bentuk(batch_size, num_heads, sequence_length, sequence_length).Bobot perhatian setelah softmax perhatian, digunakan untuk menghitung rata-rata berbobot di kepala perhatian diri (self-attention).
cross_attentions (
tuple[torch.Tensor], opsional, dikembalikan saatoutput_attentions=Truedilewatkan atau saatconfig.output_attentions=True) — Tuple daritorch.Tensor(satu untuk setiap layer) dengan bentuk(batch_size, num_heads, sequence_length, sequence_length).Bobot perhatian dari lapisan cross-attention decoder, setelah softmax perhatian, yang digunakan untuk menghitung rata-rata berbobot di kepala cross-attention.
Contoh:
>>> 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
kelas transformers.PerceiverForMultimodalAutoencoding
< source >( config: PerceiverConfig )
Parameter
- config (PerceiverConfig) — Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya. Lihat metode from_pretrained() untuk memuat bobot model.
Contoh penggunaan Perceiver untuk autoencoding multimodal (video), untuk tugas-tugas seperti Kinetics-700.
PerceiverForMultimodalAutoencoding menggunakan PerceiverMultimodalPreprocessor untuk mempreproses 3 modalitas: gambar, audio, dan label kelas. Preprocessor ini menggunakan preprocessor yang spesifik untuk setiap modalitas guna mempreproses setiap modalitas secara terpisah, kemudian hasil-hasilnya digabungkan. Position embeddings yang dapat dilatih digunakan untuk mengisi (padding) setiap modalitas hingga memiliki jumlah channel yang sama, sehingga penggabungan (concatenation) sepanjang dimensi waktu dapat dilakukan. Selanjutnya, encoder Perceiver diterapkan.
PerceiverMultimodalDecoder digunakan untuk mendekode representasi laten dari PerceiverModel. Dekoder ini menggunakan dekoder spesifik untuk setiap modalitas guna membangun query. Query dekoder dibuat berdasarkan input setelah pra-pemrosesan. Namun, melakukan autoencoding seluruh video dalam satu langkah maju (forward pass) secara komputasi tidak layak, sehingga hanya sebagian dari query dekoder yang digunakan untuk melakukan cross-attention dengan representasi laten. Hal ini ditentukan oleh indeks subsampled untuk setiap modalitas, yang dapat diberikan sebagai input tambahan ke langkah maju (forward pass) dari PerceiverForMultimodalAutoencoding.
PerceiverMultimodalDecoder juga melakukan padding pada decoder queries dari berbagai modalitas ke jumlah channel yang sama, agar dapat digabungkan sepanjang dimensi waktu. Selanjutnya, cross-attention dilakukan dengan representasi laten dari PerceiverModel.
Terakhir, ~models.perceiver.modeling_perceiver.PerceiverMultiModalPostprocessor digunakan untuk mengubah tensor ini menjadi video yang sebenarnya. Pertama, output dipecah menjadi modalitas yang berbeda, kemudian postprocessor yang sesuai diterapkan untuk setiap modalitas.
Perhatikan bahwa, dengan mem-mask label klasifikasi selama evaluasi (yaitu cukup menyediakan tensor berisi nol untuk modalitas “label”), model auto-encoding ini menjadi klasifikator video Kinetics 700.
Model ini mewarisi dari PreTrainedModel. Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran embedding input, memangkas kepala, dll.)
Model ini juga merupakan subclass dari torch.nn.Module PyTorch. Gunakan sebagai PyTorch Module biasa dan merujuk ke dokumentasi PyTorch untuk semua hal yang berkaitan dengan penggunaan dan perilaku umum.
forward
< source >( inputs: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonesubsampled_output_points: dict[str, torch.Tensor] | None = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonelabels: typing.Optional[torch.Tensor] = Nonereturn_dict: bool | None = None**kwargs ) → PerceiverClassifierOutput or tuple(torch.Tensor)
Parameter
- inputs (
torch.Tensor, opsional) — Input untuk perceiver. Bisa berupa apa saja: gambar, teks, audio, video, dll. - attention_mask (
torch.Tensordengan bentuk(batch_size, sequence_length), opsional) — Mask untuk menghindari eksekusi attention pada indeks token padding. Nilai mask dipilih dari[0, 1]:- 1 untuk token yang tidak dimasker,
- 0 untuk token yang dimasker.
- subsampled_output_points (
dict[str, torch.Tensor], opsional) — Kamus tensor yang digunakan sebagai query untuk decoder. Decoder memetakan query ini ke representasi laten dari model. Digunakan untuk decoding subsampled, misalnya ketika hanya mendekode patch gambar tertentu. - output_attentions (
bool, opsional) — Apakah akan mengembalikan tensor attentions dari semua lapisan attention. Lihatattentionsdi bawah tensor yang dikembalikan untuk detail lebih lanjut. - output_hidden_states (
bool, opsional) — Apakah akan mengembalikan hidden states dari semua lapisan. Lihathidden_statesdi bawah tensor yang dikembalikan untuk detail lebih lanjut. - labels (
torch.LongTensordengan bentuk(batch_size,), opsional) — Label untuk menghitung loss klasifikasi/regresi gambar. Indeks harus berada dalam[0, ..., config.num_labels - 1]. Jikaconfig.num_labels == 1, loss regresi dihitung (Mean-Square loss). Jikaconfig.num_labels > 1, loss klasifikasi dihitung (Cross-Entropy). - return_dict (
bool, opsional) — Apakah akan mengembalikan ModelOutput alih-alih tuple biasa.
Mengembalikan
PerceiverClassifierOutput atau tuple(torch.Tensor)
A PerceiverClassifierOutput atau tuple dari
torch.Tensor (jika return_dict=False dilewatkan atau ketika config.return_dict=False) yang terdiri dari berbagai
elemen tergantung pada konfigurasi (PerceiverConfig) dan input.
Metode forward dari PerceiverForMultimodalAutoencoding menimpa metode khusus __call__.
Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance
Modulesetelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam.
loss (
torch.Tensordengan bentuk(1,), opsional, dikembalikan saatlabelsdisediakan) — Loss klasifikasi (atau regresi jika config.num_labels==1).logits (
torch.Tensordengan bentuk(batch_size, config.num_labels)) — Skor klasifikasi (atau regresi jika config.num_labels==1) (sebelum SoftMax).hidden_states (
tuple[torch.Tensor], opsional, dikembalikan saatoutput_hidden_states=Truedilewatkan atau saatconfig.output_hidden_states=True) — Tuple daritorch.Tensor(satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk(batch_size, sequence_length, hidden_size).Hidden-states model pada output setiap layer ditambah output embedding awal yang opsional.
attentions (
tuple[torch.Tensor], opsional, dikembalikan saatoutput_attentions=Truedilewatkan atau saatconfig.output_attentions=True) — Tuple daritorch.Tensor(satu untuk setiap layer) dengan bentuk(batch_size, num_heads, sequence_length, sequence_length).Bobot perhatian setelah softmax perhatian, digunakan untuk menghitung rata-rata berbobot di kepala perhatian diri (self-attention).
cross_attentions (
tuple[torch.Tensor], opsional, dikembalikan saatoutput_attentions=Truedilewatkan atau saatconfig.output_attentions=True) — Tuple daritorch.Tensor(satu untuk setiap layer) dengan bentuk(batch_size, num_heads, sequence_length, sequence_length).Bobot perhatian dari lapisan cross-attention decoder, setelah softmax perhatian, yang digunakan untuk menghitung rata-rata berbobot di kepala cross-attention.
Contoh:
>>> 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]