# Data2Vec ## Ikhtisar Model Data2Vec diusulkan dalam [data2vec: A General Framework for Self-supervised Learning in Speech, Vision and Language](https://huggingface.co/papers/2202.03555) oleh Alexei Baevski, Wei-Ning Hsu, Qiantong Xu, Arun Babu, Jiatao Gu, dan Michael Auli. Data2Vec mengusulkan kerangka kerja terpadu untuk pembelajaran tanpa pengawasan (self-supervised learning) di berbagai modalitas data - teks, audio, dan gambar. Pentingnya, target prediksi untuk pra-pelatihan adalah representasi laten yang terkontekstualisasi dari input, bukan target yang spesifik modalitas dan tidak bergantung pada konteks. Abstrak dari makalah tersebut adalah sebagai berikut: *Walaupun ide umum dari pembelajaran tanpa pengawasan (self-supervised learning) identik di seluruh modalitas, algoritma dan tujuan yang sebenarnya sangat berbeda karena dikembangkan dengan mempertimbangkan satu modalitas. Untuk mendekatkan diri pada pembelajaran tanpa pengawasan yang lebih umum, kami memperkenalkan data2vec, sebuah kerangka kerja yang menggunakan metode pembelajaran yang sama untuk audio, NLP, atau computer vision. Ide intinya adalah memprediksi representasi laten dari data input penuh berdasarkan tampilan input yang dimasking dalam pengaturan self-distillation menggunakan arsitektur Transformer standar. Alih-alih memprediksi target yang spesifik untuk modalitas tertentu seperti kata, token visual, atau unit ucapan manusia yang bersifat lokal, data2vec memprediksi representasi laten yang terkontekstualisasi yang mengandung informasi dari seluruh input. Eksperimen pada benchmark utama untuk pengenalan ucapan, klasifikasi gambar, dan pemahaman bahasa alami menunjukkan state of the art baru atau kinerja yang kompetitif dibandingkan pendekatan yang dominan. Model dan kode tersedia di www.github.com/pytorch/fairseq/tree/master/examples/data2vec.* Model ini disumbangkan oleh [edugp](https://huggingface.co/edugp) dan [patrickvonplaten](https://huggingface.co/patrickvonplaten). Kode asli (untuk NLP dan Speech) dapat ditemukan [di sini](https://github.com/pytorch/fairseq/tree/main/examples/data2vec). Kode asli untuk vision dapat ditemukan [di sini](https://github.com/facebookresearch/data2vec_vision/tree/main/beit). ## Tips penggunaan - Data2VecAudio, Data2VecText, dan Data2VecVision semuanya telah dilatih menggunakan metode pembelajaran tanpa pengawasan (self-supervised learning) yang sama. - Untuk Data2VecAudio, pra-pemrosesan identik dengan [Wav2Vec2Model](/docs/transformers/v5.23.0/id/model_doc/wav2vec2#transformers.Wav2Vec2Model), termasuk ekstraksi fitur - Untuk Data2VecText, pra-pemrosesan identik dengan [RobertaModel](/docs/transformers/v5.23.0/id/model_doc/roberta#transformers.RobertaModel), termasuk tokenisasi. - Untuk Data2VecVision, pra-pemrosesan identik dengan [BeitModel](/docs/transformers/v5.23.0/id/model_doc/beit#transformers.BeitModel), termasuk ekstraksi fitur. ### Menggunakan Scaled Dot Product Attention (SDPA) PyTorch menyertakan operator scaled dot-product attention (SDPA) native sebagai bagian dari `torch.nn.functional`. Fungsi ini mencakup beberapa implementasi yang dapat diterapkan tergantung pada input dan perangkat keras yang digunakan. Lihat [dokumentasi resmi](https://pytorch.org/docs/stable/generated/torch.nn.functional.scaled_dot_product_attention.html) atau halaman [GPU Inference](https://huggingface.co/docs/transformers/main/en/perf_infer_gpu_one#pytorch-scaled-dot-product-attention) untuk informasi lebih lanjut. SDPA digunakan secara default untuk `torch>=2.1.1` ketika implementasi tersedia, tetapi Anda juga dapat mengatur `attn_implementation="sdpa"` di `from_pretrained()` untuk secara eksplisit meminta penggunaan SDPA. Implementasi SDPA saat ini tersedia untuk model Data2VecAudio dan Data2VecVision. ```python from transformers import Data2VecVisionForImageClassification model = Data2VecVisionForImageClassification.from_pretrained("facebook/data2vec-vision-base", attn_implementation="sdpa", device_map="auto") ... ``` Untuk percepatan terbaik, kami merekomendasikan memuat model dalam presisi setengah (misalnya `torch.float16` atau `torch.bfloat16`). Untuk model Data2VecVision, pada benchmark lokal (NVIDIA GeForce RTX 2060-8GB, PyTorch 2.5.1, OS Ubuntu 20.04) dengan `float16` dan model `facebook/data2vec-vision-base`, kami melihat peningkatan berikut selama pelatihan dan inferensi: #### Pelatihan | num_training_steps | batch_size | image_size | is_cuda | Waktu per batch (eager - s) | Waktu per batch (sdpa - s) | Percepatan (%) | Puncak memori Eager (MB) | Mem puncak SDPA (MB) | Penghematan memori (%) | |--------------------|------------|--------------|---------|----------------------------|---------------------------|-------------|----------------------|--------------------|----------------| | 50 | 2 | (1048, 640) | Benar | 0.996 | 0.754 | 32.147 | 6722.198 | 4264.653 | 57.626 | #### Inferensi | Ukuran batch gambar | Eager (s/iterasi) | Eager CI, % | Memori Eager (MB) | SDPA (s/iter) | SDPA CI, % | Memori SDPA (MB) | Percepatan SDPA | Memori SDPA yang dihemat | |-------------------:|-----------------:|:--------------|--------------------:|----------------:|:-------------|-------------------:|---------------:|--------------------:| | 1 | 0.011 | ±0.3% | 3.76143e+08 | 0.01 | ±0.3% | 3.74397e+08 | 1.101 | 0.466 | | 4 | 0.014 | ±0.1% | 4.02756e+08 | 0.012 | ±0.2% | 3.91373e+08 | 1.219 | 2.909 | | 16 | 0.046 | ±0.3% | 4.96482e+08 | 0.035 | ±0.2% | 4.51017e+08 | 1.314 | 10.081 | | 32 | 0.088 | ±0.1% | 6.23903e+08 | 0.067 | ±0.1% | 5.32974e+08 | 1.33 | 17.061 | ## Sumber daya Daftar sumber resmi Hugging Face dan komunitas (ditandai dengan 🌎) untuk membantu Anda memulai dengan Data2Vec. - [Data2VecVisionForImageClassification](/docs/transformers/v5.23.0/id/model_doc/data2vec#transformers.Data2VecVisionForImageClassification) didukung oleh [notebook](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/image_classification.ipynb) ini. **Sumber dokumentasi Data2VecText** - [Panduan tugas klasifikasi teks](../tasks/sequence_classification) - [Panduan tugas klasifikasi token](../tasks/token_classification) - [Panduan tugas question answering](../tasks/question_answering) - [Panduan tugas pemodelan bahasa kausal](../tasks/language_modeling) - [Panduan tugas pemodelan bahasa tersembunyi](../tasks/masked_language_modeling) - [Panduan tugas pilihan ganda](../tasks/multiple_choice) **Sumber dokumentasi Data2VecAudio** - [Panduan tugas klasifikasi audio](../tasks/audio_classification) - [Panduan tugas pengenalan ucapan otomatis](../tasks/asr) **Sumber dokumentasi Data2VecVision** - [Klasifikasi gambar](../tasks/image_classification) - [Segmentasi semantik](../tasks/semantic_segmentation) Jika Anda tertarik untuk mengirimkan sumber daya agar disertakan di sini, silakan buka Pull Request dan kami akan meninjaunya! Sumber daya tersebut sebaiknya mendemonstrasikan sesuatu yang baru, bukan menduplikasi sumber daya yang sudah ada. ## Data2VecTextConfig[[transformers.Data2VecTextConfig]] #### transformers.Data2VecTextConfig[[transformers.Data2VecTextConfig]] ```python transformers.Data2VecTextConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, vocab_size: int = 30522, hidden_size: int = 768, num_hidden_layers: int = 12, num_attention_heads: int = 12, intermediate_size: int = 3072, hidden_act: str = 'gelu', hidden_dropout_prob: float | int = 0.1, attention_probs_dropout_prob: float | int = 0.1, max_position_embeddings: int = 512, type_vocab_size: int = 2, initializer_range: float = 0.02, layer_norm_eps: float = 1e-12, pad_token_id: int | None = 1, bos_token_id: int | None = 0, eos_token_id: int | list[int] | None = 2, use_cache: bool = True, classifier_dropout: float | int | None = None, is_decoder: bool = False, add_cross_attention: bool = False, tie_word_embeddings: bool = True) ``` [Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/data2vec/configuration_data2vec_text.py#L24) **Parameter:** vocab_size (`int`, *opsional*, defaultnya `30522`) : Ukuran kosakata model. Menentukan jumlah token berbeda yang dapat direpresentasikan oleh `input_ids`. hidden_size (`int`, *opsional*, defaultnya `768`) : Dimensi dari representasi tersembunyi. num_hidden_layers (`int`, *opsional*, defaultnya `12`) : Jumlah lapisan tersembunyi dalam decoder Transformer. num_attention_heads (`int`, *opsional*, defaultnya `12`) : Jumlah kepala perhatian untuk setiap lapisan perhatian dalam decoder Transformer. intermediate_size (`int`, *opsional*, defaultnya `3072`) : Dimensi dari representasi MLP. hidden_act (`str`, *opsional*, defaultnya `gelu`) : Fungsi aktivasi non-linear (fungsi atau string) di decoder. Misalnya, `"gelu"`, `"relu"`, `"silu"`, dan sebagainya. hidden_dropout_prob (`Union[float, int]`, *opsional*, defaultnya `0.1`) : Probabilitas dropout untuk semua lapisan fully connected di embeddings, encoder, dan pooler. attention_probs_dropout_prob (`Union[float, int]`, *opsional*, defaultnya `0.1`) : Rasio dropout untuk probabilitas perhatian. max_position_embeddings (`int`, *opsional*, defaultnya `512`) : Panjang urutan maksimum yang mungkin digunakan oleh model ini. type_vocab_size (`int`, *opsional*, defaultnya `2`) : Ukuran kosakata dari `token_type_ids`. initializer_range (`float`, *opsional*, defaultnya `0.02`) : Deviasi standar dari truncated_normal_initializer untuk menginisialisasi semua matriks bobot. layer_norm_eps (`float`, *opsional*, defaultnya `1e-12`) : Epsilon yang digunakan oleh lapisan normalisasi lapisan. pad_token_id (`int`, *opsional*, defaultnya `1`) : ID token yang digunakan untuk padding dalam kosakata. bos_token_id (`int`, *opsional*, defaultnya `0`) : Token id yang digunakan untuk awal-stream dalam kosakata. eos_token_id (`Union[int, list[int]]`, *opsional*, defaultnya `2`) : Token id yang digunakan untuk end-of-stream dalam kosakata. use_cache (`bool`, *opsional*, defaultnya `True`) : Apakah model harus mengembalikan perhatian kunci/nilai terakhir (tidak digunakan oleh semua model). Hanya relevan jika `config.is_decoder=True` atau ketika model adalah model generatif yang hanya decoder. classifier_dropout (`Union[float, int]`, *opsional*) : Rasio dropout untuk klasifikator. is_decoder (`bool`, *opsional*, defaultnya `False`) : Apakah model digunakan sebagai decoder atau tidak. Jika `False`, model digunakan sebagai encoder. add_cross_attention (`bool`, *opsional*, defaultnya `False`) : Apakah lapisan cross-attention harus ditambahkan ke model. tie_word_embeddings (`bool`, *opsional*, defaultnya `True`) : Apakah mengikat embedding bobot sesuai dengan pemetaan `tied_weights_keys` model. Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari Data2Vec TextModel. Kelas ini digunakan untuk membuat instans model Data2Vec Text sesuai dengan argumen yang ditentukan, yang mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari [facebook/data2vec-text-base](https://huggingface.co/facebook/data2vec-text-base) Objek konfigurasi mewarisi dari [PreTrainedConfig](/docs/transformers/v5.23.0/id/main_classes/configuration#transformers.PreTrainedConfig) dan dapat digunakan untuk mengontrol keluaran model. Baca dokumentasi dari [PreTrainedConfig](/docs/transformers/v5.23.0/id/main_classes/configuration#transformers.PreTrainedConfig) untuk informasi lebih lanjut. Contoh: ```python >>> from transformers import Data2VecTextConfig, Data2VecTextModel >>> # Initializing a Data2VecText facebook/data2vec-text-base style configuration >>> configuration = Data2VecTextConfig() >>> # Initializing a model (with random weights) from the facebook/data2vec-text-base style configuration >>> model = Data2VecTextModel(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## Data2VecAudioConfig[[transformers.Data2VecAudioConfig]] #### transformers.Data2VecAudioConfig[[transformers.Data2VecAudioConfig]] ```python transformers.Data2VecAudioConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, vocab_size: int = 32, hidden_size: int = 768, num_hidden_layers: int = 12, num_attention_heads: int = 12, intermediate_size: int = 3072, hidden_act: str = 'gelu', hidden_dropout: float | int = 0.1, activation_dropout: float | int = 0.1, attention_dropout: float | int = 0.1, feat_proj_dropout: float | int = 0.0, final_dropout: float | int = 0.1, layerdrop: float | int = 0.1, initializer_range: float = 0.02, layer_norm_eps: float = 1e-05, feat_extract_activation: str = 'gelu', conv_dim: list[int] | tuple[int, ...] = (512, 512, 512, 512, 512, 512, 512), conv_stride: list[int] | tuple[int, ...] = (5, 2, 2, 2, 2, 2, 2), conv_kernel: list[int] | tuple[int, ...] = (10, 3, 3, 3, 3, 2, 2), conv_bias: bool = False, num_conv_pos_embedding_groups: int = 16, conv_pos_kernel_size: int = 19, num_conv_pos_embeddings: int = 5, mask_time_prob: float | int = 0.05, mask_time_length: int = 10, mask_time_min_masks: int = 2, mask_feature_prob: float | int = 0.0, mask_feature_length: int = 10, mask_feature_min_masks: int = 0, ctc_loss_reduction: str = 'sum', ctc_zero_infinity: bool = False, use_weighted_layer_sum: bool = False, classifier_proj_size: int = 256, tdnn_dim: list[int] | tuple[int, ...] = (512, 512, 512, 512, 1500), tdnn_kernel: list[int] | tuple[int, ...] = (5, 3, 3, 1, 1), tdnn_dilation: list[int] | tuple[int, ...] = (1, 2, 3, 1, 1), xvector_output_dim: int = 512, pad_token_id: int | None = 0, bos_token_id: int | None = 1, eos_token_id: int | list[int] | None = 2, add_adapter: bool = False, adapter_kernel_size: int = 3, adapter_stride: int = 2, num_adapter_layers: int = 3, output_hidden_size: int | None = None) ``` [Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/data2vec/configuration_data2vec_audio.py#L26) **Parameter:** vocab_size (`int`, *opsional*, defaultnya `32`) : Ukuran kosakata model. Menentukan jumlah token berbeda yang dapat direpresentasikan oleh `input_ids`. hidden_size (`int`, *opsional*, defaultnya `768`) : Dimensi dari representasi tersembunyi. num_hidden_layers (`int`, *opsional*, defaultnya `12`) : Jumlah lapisan tersembunyi dalam decoder Transformer. num_attention_heads (`int`, *opsional*, defaultnya `12`) : Jumlah kepala perhatian untuk setiap lapisan perhatian dalam decoder Transformer. intermediate_size (`int`, *opsional*, defaultnya `3072`) : Dimensi dari representasi MLP. hidden_act (`str`, *opsional*, defaultnya `gelu`) : Fungsi aktivasi non-linear (fungsi atau string) di decoder. Misalnya, `"gelu"`, `"relu"`, `"silu"`, dan sebagainya. hidden_dropout (`Union[float, int]`, *opsional*, defaultnya `0.1`) : Probabilitas dropout untuk semua lapisan fully connected di embeddings, encoder, dan pooler. activation_dropout (`Union[float, int]`, *opsional*, defaultnya `0.1`) : Rasio dropout untuk aktivasi di dalam lapisan fully connected. attention_dropout (`Union[float, int]`, *opsional*, defaultnya `0.1`) : Rasio dropout untuk probabilitas perhatian. feat_proj_dropout (`float`, *opsional*, default 0.0) : Probabilitas dropout untuk output dari feature encoder. final_dropout (`float`, *opsional*, default 0.1) : Probabilitas dropout untuk lapisan proyeksi akhir dari [Data2VecAudioForCTC](/docs/transformers/v5.23.0/id/model_doc/data2vec#transformers.Data2VecAudioForCTC). layerdrop (`Union[float, int]`, *opsional*, defaultnya `0.1`) : Probabilitas LayerDrop. Lihat [makalah LayerDrop](see https://huggingface.co/papers/1909.11556) untuk detail lebih lanjut. initializer_range (`float`, *opsional*, defaultnya `0.02`) : Deviasi standar dari truncated_normal_initializer untuk menginisialisasi semua matriks bobot. layer_norm_eps (`float`, *opsional*, defaultnya `1e-05`) : Epsilon yang digunakan oleh lapisan normalisasi lapisan. feat_extract_activation (`str, `optional`, defaults to `"gelu"`) : The non-linear activation function (function or string) in the 1D convolutional layers of the feature extractor. If string, `"gelu"`, `"relu"`, `"selu"` and `"gelu_new"` are supported. conv_dim (`tuple[int]` atau `list[int]`, *opsional*, defaultnya `(512, 512, 512, 512, 512, 512, 512)`) : Tuple dari bilangan bulat yang mendefinisikan jumlah saluran input dan output dari setiap lapisan konvolusional 1D dalam feature encoder. Panjang dari *conv_dim* mendefinisikan jumlah lapisan konvolusional 1D. conv_stride (`tuple[int]` atau `list[int]`, *opsional*, defaultnya `(5, 2, 2, 2, 2, 2, 2)`) : Tuple dari bilangan bulat yang mendefinisikan stride dari setiap lapisan konvolusional 1D dalam feature encoder. Panjang dari *conv_stride* mendefinisikan jumlah lapisan konvolusional dan harus sesuai dengan panjang dari *conv_dim*. conv_kernel (`Union[list[int], tuple[int, ...]]`, *opsional*, defaultnya `(10, 3, 3, 3, 3, 2, 2)`) : Ukuran kernel konvolusional. conv_bias (`bool`, *opsional*, defaultnya `False`) : Apakah lapisan konvolusional 1D memiliki bias. num_conv_pos_embedding_groups (`int`, *opsional*, default 16) : Jumlah grup dari lapisan embedding posisional konvolusional 1D. conv_pos_kernel_size (`int`, *opsional*, defaultnya `19`) : Ukuran kernel dari modul konvolusi posisional. num_conv_pos_embeddings (`int`, *opsional*, default 128) : Jumlah embedding posisi konvolusional. Menentukan ukuran kernel dari lapisan embedding posisi konvolusional 1D. mask_time_prob (`float`, *opsional*, default 0.05) : Persentase (antara 0 dan 1) dari semua vektor fitur sepanjang sumbu waktu yang akan dimasker. Prosedur masking menghasilkan ''mask_time_prob*len(time_axis)/mask_time_length'' mask independen di sepanjang sumbu tersebut. Jika beralasan dari probabilitas setiap vektor fitur untuk dipilih sebagai awal dari rentang vektor yang akan dimasker, *mask_time_prob* seharusnya `prob_vector_start*mask_time_length`. Perhatikan bahwa tumpang tindih dapat mengurangi mask_time_length (`int`, *opsional*, default 10) : Panjang rentang vektor sepanjang sumbu waktu. mask_time_min_masks (`int`, *opsional*, default 2), : Jumlah minimum masker dengan panjang `mask_feature_length` yang dihasilkan sepanjang sumbu waktu, setiap langkah waktu, terlepas dari `mask_feature_prob`. Hanya relevan jika ''mask_time_prob*len(time_axis)/mask_time_length < mask_time_min_masks'' mask_feature_prob (`float`, *opsional*, default 0.0) : Persentase (antara 0 dan 1) dari semua vektor fitur di sepanjang sumbu fitur yang akan dimasker. Prosedur masking menghasilkan ''mask_feature_prob*len(feature_axis)/mask_time_length'' mask independen di sepanjang sumbu tersebut. Jika beralasan dari probabilitas setiap vektor fitur untuk dipilih sebagai awal dari rentang vektor yang akan dimasker, *mask_feature_prob* seharusnya `prob_vector_start*mask_feature_length`. Perhatikan bahwa tumpang tindih dapat mengurangi persentase vektor yang sebenarnya dimasker. Ini hanya relevan jika `apply_spec_augment is True`. mask_feature_prob (`Union[float, int]`, *opsional*, defaultnya `0.0`) : Persentase (antara 0 dan 1) dari semua vektor fitur di sepanjang sumbu fitur yang akan dimasker. Prosedur masking menghasilkan `mask_feature_prob*len(feature_axis)/mask_time_length` mask independen di sepanjang sumbu. Jika beralasan dari probabilitas setiap vektor fitur untuk dipilih sebagai awal dari rentang vektor yang akan dimasker, *mask_feature_prob* seharusnya `prob_vector_start*mask_feature_length`. Perhatikan bahwa tumpang tindih dapat mengurangi persentase vektor yang sebenarnya dimasker. Ini hanya relevan jika `apply_spec_augment` adalah `True`. mask_feature_length (`int`, *opsional*, default 10) : Panjang rentang vektor di sepanjang sumbu fitur. mask_feature_min_masks (`int`, *opsional*, default 0) : Jumlah minimum masker dengan panjang `mask_feature_length` yang dihasilkan di sepanjang sumbu fitur, setiap langkah waktu, terlepas dari `mask_feature_prob`. Hanya relevan jika ''mask_feature_prob*len(feature_axis)/mask_feature_length < mask_feature_min_masks'' ctc_loss_reduction (`str`, *opsional*, defaultnya `"sum"`) : Menentukan reduksi yang diterapkan pada output dari `torch.nn.CTCLoss`. Hanya relevan saat melatih instance dari [Data2VecAudioForCTC](/docs/transformers/v5.23.0/id/model_doc/data2vec#transformers.Data2VecAudioForCTC). ctc_zero_infinity (`bool`, *opsional*, defaultnya `False`) : Apakah akan menolkan kerugian tak hingga dan gradien terkait dari `torch.nn.CTCLoss`. Kerugian tak hingga terutama terjadi ketika input terlalu pendek untuk diselaraskan dengan target. Hanya relevan saat melatih instance dari [Data2VecAudioForCTC](/docs/transformers/v5.23.0/id/model_doc/data2vec#transformers.Data2VecAudioForCTC). use_weighted_layer_sum (`bool`, *opsional*, defaultnya `False`) : Apakah akan menggunakan rata-rata berbobot dari output lapisan dengan bobot yang dipelajari. Hanya relevan saat menggunakan instance dari [Data2VecAudioForSequenceClassification](/docs/transformers/v5.23.0/id/model_doc/data2vec#transformers.Data2VecAudioForSequenceClassification). classifier_proj_size (`int`, *opsional*, default 256) : Dimensi proyeksi sebelum token mean-pooling untuk klasifikasi. tdnn_dim (`tuple[int]` atau `list[int]`, *opsional*, defaultnya `(512, 512, 512, 512, 1500)`) : Tuple dari bilangan bulat yang mendefinisikan jumlah kanal output dari setiap lapisan konvolusional 1D dalam modul *TDNN* dari model *XVector*. Panjang dari *tdnn_dim* mendefinisikan jumlah lapisan *TDNN*. tdnn_kernel (`tuple[int]` atau `list[int]`, *opsional*, defaultnya `(5, 3, 3, 1, 1)`) : Tuple dari bilangan bulat yang mendefinisikan ukuran kernel dari setiap lapisan konvolusional 1D dalam modul *TDNN* dari model *XVector*. Panjang *tdnn_kernel* harus sesuai dengan panjang *tdnn_dim*. tdnn_dilation (`tuple[int]` atau `list[int]`, *opsional*, defaultnya `(1, 2, 3, 1, 1)`) : Tuple bilangan bulat yang mendefinisikan faktor dilatasi dari setiap lapisan konvolusional 1D dalam modul *TDNN* dari model *XVector*. Panjang *tdnn_dilation* harus sesuai dengan panjang *tdnn_dim*. xvector_output_dim (`int`, *opsional*, default 512) : Dimensi dari vektor embedding *XVector*. pad_token_id (`int`, *opsional*, defaultnya `0`) : ID token yang digunakan untuk padding dalam kosakata. bos_token_id (`int`, *opsional*, defaultnya `1`) : Token id yang digunakan untuk awal-stream dalam kosakata. eos_token_id (`Union[int, list[int]]`, *opsional*, defaultnya `2`) : Token id yang digunakan untuk end-of-stream dalam kosakata. add_adapter (`bool`, *opsional*, defaultnya `False`) : Apakah jaringan konvolusional harus ditumpuk di atas Data2VecAudio Encoder. Dapat sangat berguna untuk memulai Data2VecAudio dengan hangat untuk model SpeechEncoderDecoder. adapter_kernel_size (`int`, *opsional*, default 3) : Ukuran kernel dari lapisan konvolusional dalam jaringan adapter. Hanya relevan jika `add_adapter is True`. adapter_stride (`int`, *opsional*, defaultnya 2) : Stride dari lapisan konvolusional dalam jaringan adapter. Hanya relevan jika `add_adapter is True`. num_adapter_layers (`int`, *opsional*, default 3) : Jumlah lapisan konvolusional yang harus digunakan dalam jaringan adapter. Hanya relevan jika `add_adapter is True`. output_hidden_size (`int`, *opsional*) : Dimensi dari lapisan output encoder. Jika tidak didefinisikan, ini secara default menjadi *hidden-size*. Hanya relevan jika `add_adapter is True`. Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari Data2Vec AudioModel. Kelas ini digunakan untuk membuat instans model Data2Vec Audio sesuai dengan argumen yang ditentukan, yang mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari [facebook/data2vec-audio-base-960h](https://huggingface.co/facebook/data2vec-audio-base-960h) Objek konfigurasi mewarisi dari [PreTrainedConfig](/docs/transformers/v5.23.0/id/main_classes/configuration#transformers.PreTrainedConfig) dan dapat digunakan untuk mengontrol keluaran model. Baca dokumentasi dari [PreTrainedConfig](/docs/transformers/v5.23.0/id/main_classes/configuration#transformers.PreTrainedConfig) untuk informasi lebih lanjut. Contoh: ```python >>> from transformers import Data2VecAudioConfig, Data2VecAudioModel >>> # Initializing a Data2VecAudio facebook/data2vec-audio-base-960h style configuration >>> configuration = Data2VecAudioConfig() >>> # Initializing a model (with random weights) from the facebook/data2vec-audio-base-960h style configuration >>> model = Data2VecAudioModel(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## Data2VecVisionConfig[[transformers.Data2VecVisionConfig]] #### transformers.Data2VecVisionConfig[[transformers.Data2VecVisionConfig]] ```python transformers.Data2VecVisionConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, hidden_size: int = 768, num_hidden_layers: int = 12, num_attention_heads: int = 12, intermediate_size: int = 3072, hidden_act: str = 'gelu', hidden_dropout_prob: float | int = 0.0, attention_probs_dropout_prob: float | int = 0.0, initializer_range: float = 0.02, layer_norm_eps: float = 1e-12, image_size: int | list[int] | tuple[int, int] = 224, patch_size: int | list[int] | tuple[int, int] = 16, num_channels: int = 3, use_mask_token: bool = False, use_absolute_position_embeddings: bool = False, use_relative_position_bias: bool = False, use_shared_relative_position_bias: bool = False, layer_scale_init_value: float = 0.1, drop_path_rate: float | int = 0.1, use_mean_pooling: bool = True, out_indices: list[int] | tuple[int, ...] = (3, 5, 7, 11), pool_scales: list[int] | tuple[int, ...] = (1, 2, 3, 6), use_auxiliary_head: bool = True, auxiliary_loss_weight: float = 0.4, auxiliary_channels: int = 256, auxiliary_num_convs: int = 1, auxiliary_concat_input: bool = False, semantic_loss_ignore_index: int = 255) ``` [Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/data2vec/configuration_data2vec_vision.py#L24) **Parameter:** hidden_size (`int`, *opsional*, defaultnya `768`) : Dimensi dari representasi tersembunyi. num_hidden_layers (`int`, *opsional*, defaultnya `12`) : Jumlah lapisan tersembunyi dalam decoder Transformer. num_attention_heads (`int`, *opsional*, defaultnya `12`) : Jumlah kepala perhatian untuk setiap lapisan perhatian dalam decoder Transformer. intermediate_size (`int`, *opsional*, defaultnya `3072`) : Dimensi dari representasi MLP. hidden_act (`str`, *opsional*, defaultnya `gelu`) : Fungsi aktivasi non-linear (fungsi atau string) di decoder. Misalnya, `"gelu"`, `"relu"`, `"silu"`, dan sebagainya. hidden_dropout_prob (`Union[float, int]`, *opsional*, defaultnya `0.0`) : Probabilitas dropout untuk semua lapisan fully connected di embeddings, encoder, dan pooler. attention_probs_dropout_prob (`Union[float, int]`, *opsional*, defaultnya `0.0`) : Rasio dropout untuk probabilitas perhatian. initializer_range (`float`, *opsional*, defaultnya `0.02`) : Deviasi standar dari truncated_normal_initializer untuk menginisialisasi semua matriks bobot. layer_norm_eps (`float`, *opsional*, defaultnya `1e-12`) : Epsilon yang digunakan oleh lapisan normalisasi lapisan. image_size (`Union[int, list[int], tuple[int, int]]`, *opsional*, defaultnya `224`) : Ukuran (resolusi) dari setiap gambar. patch_size (`Union[int, list[int], tuple[int, int]]`, *opsional*, defaultnya `16`) : Ukuran (resolusi) dari setiap patch. num_channels (`int`, *opsional*, default `3`) : Jumlah saluran input. use_mask_token (`bool`, *opsional*, defaultnya `False`) : Apakah akan menggunakan token masker untuk pemodelan gambar tersembunyi (masked image modeling). use_absolute_position_embeddings (`bool`, *opsional*, defaultnya `False`) : Apakah akan menggunakan embedding posisi absolut. use_relative_position_bias (`bool`, *opsional*, defaultnya `False`) : Apakah akan menggunakan bias posisi relatif pada lapisan self-attention. use_shared_relative_position_bias (`bool`, *opsional*, defaultnya `False`) : Apakah akan menggunakan embedding posisi relatif yang sama di semua lapisan self-attention dari Transformer. layer_scale_init_value (`float`, *opsional*, default `0.1`) : Skala yang digunakan pada lapisan self-attention. 0.1 untuk base, 1e-6 untuk large. Setel 0 untuk menonaktifkan layer scale. drop_path_rate (`Union[float, int]`, *opsional*, defaultnya `0.1`) : Tingkat drop path untuk fusi patch. use_mean_pooling (`bool`, *opsional*, defaultnya `True`) : Apakah akan melakukan mean pooling pada hidden state akhir dari patch-patch, alih-alih menggunakan hidden state akhir dari token CLS, sebelum menerapkan kepala klasifikasi. out_indices (`Union[list[int], tuple[int, ...]]`, *opsional*, defaultnya `(3, 5, 7, 11)`) : Indeks dari hidden states (feature maps) antara yang akan dikembalikan dari backbone. Setiap indeks sesuai dengan satu tahap model. pool_scales (`tuple[int]`, *opsional*, defaultnya `[1, 2, 3, 6]`) : Skala pooling yang digunakan dalam Pooling Pyramid Module yang diterapkan pada peta fitur terakhir. use_auxiliary_head (`bool`, *opsional*, defaultnya `True`) : Apakah akan menggunakan kepala bantu selama pelatihan. auxiliary_loss_weight (`float`, *opsional*, default 0.4) : Bobot dari cross-entropy loss dari auxiliary head. auxiliary_channels (`int`, *opsional*, default 256) : Jumlah channel yang digunakan di kepala bantu. auxiliary_num_convs (`int`, *opsional*, default 1) : Jumlah lapisan konvolusional yang digunakan di kepala bantu. auxiliary_concat_input (`bool`, *opsional*, defaultnya `False`) : Apakah akan menggabungkan output dari kepala bantu dengan input sebelum lapisan klasifikasi. semantic_loss_ignore_index (`int`, *opsional*, defaultnya `255`) : Indeks yang diabaikan oleh fungsi loss dari model segmentasi semantik. Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari Data2Vec VisionModel. Kelas ini digunakan untuk membuat instans model Data2Vec Vision sesuai dengan argumen yang ditentukan, yang mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari [facebook/data2vec-vision-base](https://huggingface.co/facebook/data2vec-vision-base) Objek konfigurasi mewarisi dari [PreTrainedConfig](/docs/transformers/v5.23.0/id/main_classes/configuration#transformers.PreTrainedConfig) dan dapat digunakan untuk mengontrol keluaran model. Baca dokumentasi dari [PreTrainedConfig](/docs/transformers/v5.23.0/id/main_classes/configuration#transformers.PreTrainedConfig) untuk informasi lebih lanjut. Contoh: ```python >>> from transformers import Data2VecVisionConfig, Data2VecVisionModel >>> # Initializing a Data2VecVision data2vec_vision-base-patch16-224-in22k style configuration >>> configuration = Data2VecVisionConfig() >>> # Initializing a model (with random weights) from the data2vec_vision-base-patch16-224-in22k style configuration >>> model = Data2VecVisionModel(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## Data2VecAudioModel[[transformers.Data2VecAudioModel]] #### transformers.Data2VecAudioModel[[transformers.Data2VecAudioModel]] ```python transformers.Data2VecAudioModel(config: Data2VecAudioConfig) ``` [Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/data2vec/modeling_data2vec_audio.py#L670) **Parameter:** config ([Data2VecAudioConfig](/docs/transformers/v5.23.0/id/model_doc/data2vec#transformers.Data2VecAudioConfig)) : Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya. Lihat metode [from_pretrained()](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk memuat bobot model. Model Data2Vec Audio polos yang menghasilkan hidden-states mentah tanpa head spesifik di atasnya. Model ini mewarisi dari [PreTrainedModel](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel). Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka ini untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran input embeddings, memangkas heads, dll.) Model ini juga merupakan subclass dari [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#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[[transformers.Data2VecAudioModel.forward]] ```python forward(input_values: typing.Optional[torch.Tensor], attention_mask: typing.Optional[torch.Tensor] = None, mask_time_indices: typing.Optional[torch.Tensor] = None, **kwargs: *) ``` [Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/data2vec/modeling_data2vec_audio.py#L741) **Parameter:** input_values (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Nilai float dari waveform ucapan mentah yang diinputkan. Nilai dapat diperoleh dengan memuat file audio `.flac` atau `.wav` ke dalam array bertipe `list[float]`, `numpy.ndarray`, atau `torch.Tensor`, *misalnya* melalui pustaka torchcodec (`pip install torchcodec`) atau pustaka soundfile (`pip install soundfile`). Untuk menyiapkan array menjadi `input_values`, gunakan [AutoProcessor](/docs/transformers/v5.23.0/id/model_doc/auto#transformers.AutoProcessor) untuk padding dan konversi menjadi tensor bertipe `torch.Tensor`. Lihat `processor_class.__call__` untuk detailnya. attention_mask (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Mask untuk menghindari pelaksanaan attention pada indeks token padding. Nilai mask dipilih dalam `[0, 1]`: - 1 untuk token yang **tidak di-mask**, - 0 untuk token yang **di-mask**. [Apa itu attention masks?](../glossary#attention-mask) mask_time_indices (`torch.BoolTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Indeks untuk memasker fitur yang diekstrak untuk kerugian kontrastif. Saat dalam mode pelatihan, model belajar memprediksi fitur yang diekstrak dan dimasker dalam ruang *config.proj_codevector_dim*. **Mengembalikan:** [Wav2Vec2BaseModelOutput](/docs/transformers/v5.23.0/id/model_doc/wav2vec2#transformers.modeling_outputs.Wav2Vec2BaseModelOutput) atau `tuple(torch.Tensor)` Sebuah [Wav2Vec2BaseModelOutput](/docs/transformers/v5.23.0/id/model_doc/wav2vec2#transformers.modeling_outputs.Wav2Vec2BaseModelOutput) atau tuple dari `torch.Tensor` (jika `return_dict=False` diteruskan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([Data2VecAudioConfig](/docs/transformers/v5.23.0/id/model_doc/data2vec#transformers.Data2VecAudioConfig)) dan input. Metode forward dari [Data2VecAudioModel](/docs/transformers/v5.23.0/id/model_doc/data2vec#transformers.Data2VecAudioModel) menimpa metode khusus `__call__`. Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance `Module` setelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam. - **last_hidden_state** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`) -- Urutan hidden-states pada keluaran lapisan terakhir model. - **extract_features** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, conv_dim[-1])`) -- Urutan vektor fitur yang diekstrak dari lapisan konvolusional terakhir model. - **hidden_states** (`tuple(torch.Tensor)`, *opsional*, dikembalikan saat `output_hidden_states=True` dilewatkan atau saat `config.output_hidden_states=True`) -- Tuple dari `torch.Tensor` (satu untuk output embeddings + satu untuk output setiap layer) dengan bentuk `(batch_size, sequence_length, hidden_size)`. Hidden-states model pada output setiap layer ditambah output embedding awal. - **attentions** (`tuple(torch.Tensor)`, *opsional*, dikembalikan ketika `output_attentions=True` dilewatkan atau ketika `config.output_attentions=True`) -- Tuple dari `torch.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 self-attention. ## Data2VecAudioForAudioFrameClassification[[transformers.Data2VecAudioForAudioFrameClassification]] #### transformers.Data2VecAudioForAudioFrameClassification[[transformers.Data2VecAudioForAudioFrameClassification]] ```python transformers.Data2VecAudioForAudioFrameClassification(config: Data2VecAudioConfig) ``` [Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/data2vec/modeling_data2vec_audio.py#L978) **Parameter:** config ([Data2VecAudioConfig](/docs/transformers/v5.23.0/id/model_doc/data2vec#transformers.Data2VecAudioConfig)) : Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya. Lihat metode [from_pretrained()](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk memuat bobot model. Model Data2Vec Audio dengan kepala klasifikasi frame di atasnya untuk tugas seperti Speaker Diarization. Model ini mewarisi dari [PreTrainedModel](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel). Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka ini untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran input embeddings, memangkas heads, dll.) Model ini juga merupakan subclass dari [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#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[[transformers.Data2VecAudioForAudioFrameClassification.forward]] ```python forward(input_values: typing.Optional[torch.Tensor], attention_mask: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, **kwargs: *) ``` [Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/data2vec/modeling_data2vec_audio.py#L1010) **Parameter:** input_values (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`) : Nilai float dari waveform ucapan mentah input. Nilai dapat diperoleh dengan memuat file audio `.flac` atau `.wav` ke dalam array bertipe `list[float]`, `numpy.ndarray`, atau `torch.Tensor`, *misalnya* melalui pustaka torchcodec (`pip install torchcodec`) atau pustaka soundfile (`pip install soundfile`). Untuk menyiapkan array menjadi `input_values`, gunakan [AutoProcessor](/docs/transformers/v5.23.0/id/model_doc/auto#transformers.AutoProcessor) untuk padding dan konversi menjadi tensor bertipe `torch.Tensor`. Lihat `Data2VecAudioProcessor.__call__` untuk detailnya. attention_mask (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Mask untuk menghindari pelaksanaan attention pada indeks token padding. Nilai mask dipilih dalam `[0, 1]`: - 1 untuk token yang **tidak di-mask**, - 0 untuk token yang **di-mask**. [Apa itu attention masks?](../glossary#attention-mask) labels (`torch.LongTensor` dengan bentuk `(batch_size,)`, *opsional*) : Label untuk menghitung loss klasifikasi/regresi urutan. Indeks harus berada dalam `[0, ..., config.num_labels - 1]`. Jika `config.num_labels == 1`, loss regresi dihitung (Mean-Square loss). Jika `config.num_labels > 1`, loss klasifikasi dihitung (Cross-Entropy). **Mengembalikan:** [TokenClassifierOutput](/docs/transformers/v5.23.0/id/main_classes/output#transformers.modeling_outputs.TokenClassifierOutput) atau `tuple(torch.Tensor)` [TokenClassifierOutput](/docs/transformers/v5.23.0/id/main_classes/output#transformers.modeling_outputs.TokenClassifierOutput) atau tuple dari `torch.Tensor` (jika `return_dict=False` diteruskan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([Data2VecAudioConfig](/docs/transformers/v5.23.0/id/model_doc/data2vec#transformers.Data2VecAudioConfig)) dan input. Metode forward dari [Data2VecAudioForAudioFrameClassification](/docs/transformers/v5.23.0/id/model_doc/data2vec#transformers.Data2VecAudioForAudioFrameClassification) menimpa metode khusus `__call__`. Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance `Module` setelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam. - **loss** (`torch.Tensor` dengan bentuk `(1,)`, *opsional*, dikembalikan ketika `labels` disediakan) -- Loss klasifikasi. - **logits** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, config.num_labels)`) -- Skor klasifikasi (sebelum SoftMax). - **hidden_states** (`tuple(torch.Tensor)`, *opsional*, dikembalikan saat `output_hidden_states=True` dilewatkan atau saat `config.output_hidden_states=True`) -- Tuple dari `torch.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 ketika `output_attentions=True` dilewatkan atau ketika `config.output_attentions=True`) -- Tuple dari `torch.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 self-attention. Contoh: ```python >>> from transformers import AutoFeatureExtractor, Data2VecAudioForAudioFrameClassification >>> from datasets import load_dataset >>> import torch >>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation") >>> dataset = dataset.sort("id") >>> sampling_rate = dataset.features["audio"].sampling_rate >>> feature_extractor = AutoFeatureExtractor.from_pretrained("facebook/data2vec-audio-base-960h") >>> model = Data2VecAudioForAudioFrameClassification.from_pretrained("facebook/data2vec-audio-base-960h") >>> # audio file is decoded on the fly >>> inputs = feature_extractor(dataset[0]["audio"]["array"], return_tensors="pt", sampling_rate=sampling_rate) >>> with torch.no_grad(): ... logits = model(**inputs).logits >>> probabilities = torch.sigmoid(logits[0]) >>> # labels is a one-hot array of shape (num_frames, num_speakers) >>> labels = (probabilities > 0.5).long() >>> labels[0].tolist() ... ``` ## Data2VecAudioForCTC[[transformers.Data2VecAudioForCTC]] #### transformers.Data2VecAudioForCTC[[transformers.Data2VecAudioForCTC]] ```python transformers.Data2VecAudioForCTC(config: Data2VecAudioConfig) ``` [Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/data2vec/modeling_data2vec_audio.py#L792) **Parameter:** config ([Data2VecAudioConfig](/docs/transformers/v5.23.0/id/model_doc/data2vec#transformers.Data2VecAudioConfig)) : Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya. Lihat metode [from_pretrained()](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk memuat bobot model. Model Data2VecAudio dengan kepala `language modeling` di atasnya untuk Connectionist Temporal Classification (CTC). Model ini mewarisi dari [PreTrainedModel](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel). Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka ini untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran input embeddings, memangkas heads, dll.) Model ini juga merupakan subclass dari [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#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[[transformers.Data2VecAudioForCTC.forward]] ```python forward(input_values: typing.Optional[torch.Tensor], attention_mask: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, **kwargs: *) ``` [Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/data2vec/modeling_data2vec_audio.py#L827) **Parameter:** input_values (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Nilai float dari waveform ucapan mentah yang diinputkan. Nilai dapat diperoleh dengan memuat file audio `.flac` atau `.wav` ke dalam array bertipe `list[float]`, `numpy.ndarray`, atau `torch.Tensor`, *misalnya* melalui pustaka torchcodec (`pip install torchcodec`) atau pustaka soundfile (`pip install soundfile`). Untuk menyiapkan array menjadi `input_values`, gunakan [AutoProcessor](/docs/transformers/v5.23.0/id/model_doc/auto#transformers.AutoProcessor) untuk padding dan konversi menjadi tensor bertipe `torch.Tensor`. Lihat `processor_class.__call__` untuk detailnya. attention_mask (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Mask untuk menghindari pelaksanaan attention pada indeks token padding. Nilai mask dipilih dalam `[0, 1]`: - 1 untuk token yang **tidak di-mask**, - 0 untuk token yang **di-mask**. [Apa itu attention masks?](../glossary#attention-mask) labels (`torch.LongTensor` dengan bentuk `(batch_size, target_length)`, *opsional*) : Label untuk klasifikasi temporal koneksionis. Perhatikan bahwa `target_length` harus lebih kecil atau sama dengan panjang sekuens dari logit output. Indeks dipilih dalam `[-100, 0, ..., config.vocab_size - 1]`. Semua label yang disetel ke `-100` diabaikan (dipertahankan), loss hanya dihitung untuk label dalam `[0, ..., config.vocab_size - 1]`. **Mengembalikan:** [CausalLMOutput](/docs/transformers/v5.23.0/id/main_classes/output#transformers.modeling_outputs.CausalLMOutput) atau `tuple(torch.Tensor)` A [CausalLMOutput](/docs/transformers/v5.23.0/id/main_classes/output#transformers.modeling_outputs.CausalLMOutput) atau tuple dari `torch.Tensor` (jika `return_dict=False` dilewatkan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([Data2VecAudioConfig](/docs/transformers/v5.23.0/id/model_doc/data2vec#transformers.Data2VecAudioConfig)) dan input. Metode forward dari [Data2VecAudioForCTC](/docs/transformers/v5.23.0/id/model_doc/data2vec#transformers.Data2VecAudioForCTC) menimpa metode khusus `__call__`. Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance `Module` setelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam. - **loss** (`torch.Tensor` dengan bentuk `(1,)`, *opsional*, dikembalikan saat `labels` disediakan) -- Loss pemodelan bahasa (untuk prediksi token berikutnya). - **logits** (`torch.Tensor` dengan 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 saat `output_hidden_states=True` dilewatkan atau saat `config.output_hidden_states=True`) -- Tuple dari `torch.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 ketika `output_attentions=True` dilewatkan atau ketika `config.output_attentions=True`) -- Tuple dari `torch.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 self-attention. Contoh: ```python >>> from transformers import AutoProcessor, Data2VecAudioForCTC >>> from datasets import load_dataset >>> import torch >>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation") >>> dataset = dataset.sort("id") >>> sampling_rate = dataset.features["audio"].sampling_rate >>> processor = AutoProcessor.from_pretrained("facebook/data2vec-audio-base-960h") >>> model = Data2VecAudioForCTC.from_pretrained("facebook/data2vec-audio-base-960h") >>> # audio file is decoded on the fly >>> inputs = processor(dataset[0]["audio"]["array"], sampling_rate=sampling_rate, return_tensors="pt") >>> with torch.no_grad(): ... logits = model(**inputs).logits >>> predicted_ids = torch.argmax(logits, dim=-1) >>> # transcribe speech >>> transcription = processor.batch_decode(predicted_ids) >>> transcription[0] ... >>> inputs["labels"] = processor(text=dataset[0]["text"], return_tensors="pt").input_ids >>> # compute loss >>> loss = model(**inputs).loss >>> round(loss.item(), 2) ... ``` ## Data2VecAudioForSequenceClassification[[transformers.Data2VecAudioForSequenceClassification]] #### transformers.Data2VecAudioForSequenceClassification[[transformers.Data2VecAudioForSequenceClassification]] ```python transformers.Data2VecAudioForSequenceClassification(config: Data2VecAudioConfig) ``` [Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/data2vec/modeling_data2vec_audio.py#L885) **Parameter:** config ([Data2VecAudioConfig](/docs/transformers/v5.23.0/id/model_doc/data2vec#transformers.Data2VecAudioConfig)) : Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya. Lihat metode [from_pretrained()](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk memuat bobot model. Model Data2VecAudio dengan kepala klasifikasi urutan di atasnya (lapisan linear di atas output yang dipool) untuk tugas seperti SUPERB Keyword Spotting. Model ini mewarisi dari [PreTrainedModel](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel). Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka ini untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran input embeddings, memangkas heads, dll.) Model ini juga merupakan subclass dari [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#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[[transformers.Data2VecAudioForSequenceClassification.forward]] ```python forward(input_values: typing.Optional[torch.Tensor], attention_mask: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, **kwargs: *) ``` [Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/data2vec/modeling_data2vec_audio.py#L918) **Parameter:** input_values (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`) : Nilai float dari waveform ucapan mentah input. Nilai dapat diperoleh dengan memuat file audio `.flac` atau `.wav` ke dalam array bertipe `list[float]`, `numpy.ndarray`, atau `torch.Tensor`, *misalnya* melalui pustaka torchcodec (`pip install torchcodec`) atau pustaka soundfile (`pip install soundfile`). Untuk menyiapkan array menjadi `input_values`, gunakan [AutoProcessor](/docs/transformers/v5.23.0/id/model_doc/auto#transformers.AutoProcessor) untuk padding dan konversi menjadi tensor bertipe `torch.Tensor`. Lihat `Data2VecAudioProcessor.__call__` untuk detailnya. attention_mask (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Mask untuk menghindari pelaksanaan attention pada indeks token padding. Nilai mask dipilih dalam `[0, 1]`: - 1 untuk token yang **tidak di-mask**, - 0 untuk token yang **di-mask**. [Apa itu attention masks?](../glossary#attention-mask) labels (`torch.LongTensor` dengan bentuk `(batch_size,)`, *opsional*) : Label untuk menghitung loss klasifikasi/regresi urutan. Indeks harus berada dalam `[0, ..., config.num_labels - 1]`. Jika `config.num_labels == 1`, loss regresi dihitung (Mean-Square loss). Jika `config.num_labels > 1`, loss klasifikasi dihitung (Cross-Entropy). **Mengembalikan:** [SequenceClassifierOutput](/docs/transformers/v5.23.0/id/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput) atau `tuple(torch.Tensor)` [SequenceClassifierOutput](/docs/transformers/v5.23.0/id/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput) atau tuple dari `torch.Tensor` (jika `return_dict=False` diteruskan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([Data2VecAudioConfig](/docs/transformers/v5.23.0/id/model_doc/data2vec#transformers.Data2VecAudioConfig)) dan input. Metode forward dari [Data2VecAudioForSequenceClassification](/docs/transformers/v5.23.0/id/model_doc/data2vec#transformers.Data2VecAudioForSequenceClassification) menimpa metode khusus `__call__`. Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance `Module` setelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam. - **loss** (`torch.Tensor` dengan bentuk `(1,)`, *opsional*, dikembalikan saat `labels` disediakan) -- Loss klasifikasi (atau regresi jika config.num_labels==1). - **logits** (`torch.Tensor` dengan bentuk `(batch_size, config.num_labels)`) -- Skor klasifikasi (atau regresi jika config.num_labels==1) (sebelum SoftMax). - **hidden_states** (`tuple(torch.Tensor)`, *opsional*, dikembalikan saat `output_hidden_states=True` dilewatkan atau saat `config.output_hidden_states=True`) -- Tuple dari `torch.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 ketika `output_attentions=True` dilewatkan atau ketika `config.output_attentions=True`) -- Tuple dari `torch.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 self-attention. Contoh klasifikasi label tunggal: ```python >>> import torch >>> from transformers import AutoTokenizer, Data2VecAudioForSequenceClassification >>> tokenizer = AutoTokenizer.from_pretrained("facebook/data2vec-audio-base-960h") >>> model = Data2VecAudioForSequenceClassification.from_pretrained("facebook/data2vec-audio-base-960h") >>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt") >>> with torch.no_grad(): ... logits = model(**inputs).logits >>> predicted_class_id = logits.argmax().item() >>> model.config.id2label[predicted_class_id] ... >>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)` >>> num_labels = len(model.config.id2label) >>> model = Data2VecAudioForSequenceClassification.from_pretrained("facebook/data2vec-audio-base-960h", num_labels=num_labels) >>> labels = torch.tensor([1]) >>> loss = model(**inputs, labels=labels).loss >>> round(loss.item(), 2) ... ``` Contoh klasifikasi multi-label: ```python >>> import torch >>> from transformers import AutoTokenizer, Data2VecAudioForSequenceClassification >>> tokenizer = AutoTokenizer.from_pretrained("facebook/data2vec-audio-base-960h") >>> model = Data2VecAudioForSequenceClassification.from_pretrained("facebook/data2vec-audio-base-960h", problem_type="multi_label_classification") >>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt") >>> with torch.no_grad(): ... logits = model(**inputs).logits >>> predicted_class_ids = torch.arange(0, logits.shape[-1])[torch.sigmoid(logits).squeeze(dim=0) > 0.5] >>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)` >>> num_labels = len(model.config.id2label) >>> model = Data2VecAudioForSequenceClassification.from_pretrained( ... "facebook/data2vec-audio-base-960h", num_labels=num_labels, problem_type="multi_label_classification" ... ) >>> labels = torch.sum( ... torch.nn.functional.one_hot(predicted_class_ids[None, :].clone(), num_classes=num_labels), dim=1 ... ).to(torch.float) >>> loss = model(**inputs, labels=labels).loss ``` ## Data2VecAudioForXVector[[transformers.Data2VecAudioForXVector]] #### transformers.Data2VecAudioForXVector[[transformers.Data2VecAudioForXVector]] ```python transformers.Data2VecAudioForXVector(config: Data2VecAudioConfig) ``` [Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/data2vec/modeling_data2vec_audio.py#L1103) **Parameter:** config ([Data2VecAudioConfig](/docs/transformers/v5.23.0/id/model_doc/data2vec#transformers.Data2VecAudioConfig)) : Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya. Lihat metode [from_pretrained()](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk memuat bobot model. Model Data2VecAudio dengan kepala ekstraksi fitur XVector di atasnya untuk tugas seperti Verifikasi Pembicara. Model ini mewarisi dari [PreTrainedModel](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel). Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka ini untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran input embeddings, memangkas heads, dll.) Model ini juga merupakan subclass dari [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#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[[transformers.Data2VecAudioForXVector.forward]] ```python forward(input_values: typing.Optional[torch.Tensor], attention_mask: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, **kwargs: *) ``` [Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/data2vec/modeling_data2vec_audio.py#L1153) **Parameter:** input_values (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`) : Nilai float dari waveform ucapan mentah input. Nilai dapat diperoleh dengan memuat file audio `.flac` atau `.wav` ke dalam array bertipe `list[float]`, `numpy.ndarray`, atau `torch.Tensor`, *misalnya* melalui pustaka torchcodec (`pip install torchcodec`) atau pustaka soundfile (`pip install soundfile`). Untuk menyiapkan array menjadi `input_values`, gunakan [AutoProcessor](/docs/transformers/v5.23.0/id/model_doc/auto#transformers.AutoProcessor) untuk padding dan konversi menjadi tensor bertipe `torch.Tensor`. Lihat `Data2VecAudioProcessor.__call__` untuk detailnya. attention_mask (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Mask untuk menghindari pelaksanaan attention pada indeks token padding. Nilai mask dipilih dalam `[0, 1]`: - 1 untuk token yang **tidak di-mask**, - 0 untuk token yang **di-mask**. [Apa itu attention masks?](../glossary#attention-mask) labels (`torch.LongTensor` dengan bentuk `(batch_size,)`, *opsional*) : Label untuk menghitung loss klasifikasi/regresi urutan. Indeks harus berada dalam `[0, ..., config.num_labels - 1]`. Jika `config.num_labels == 1`, loss regresi dihitung (Mean-Square loss). Jika `config.num_labels > 1`, loss klasifikasi dihitung (Cross-Entropy). **Mengembalikan:** [XVectorOutput](/docs/transformers/v5.23.0/id/main_classes/output#transformers.modeling_outputs.XVectorOutput) atau `tuple(torch.Tensor)` [XVectorOutput](/docs/transformers/v5.23.0/id/main_classes/output#transformers.modeling_outputs.XVectorOutput) atau tuple dari `torch.Tensor` (jika `return_dict=False` dilewatkan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([Data2VecAudioConfig](/docs/transformers/v5.23.0/id/model_doc/data2vec#transformers.Data2VecAudioConfig)) dan input. Metode forward dari [Data2VecAudioForXVector](/docs/transformers/v5.23.0/id/model_doc/data2vec#transformers.Data2VecAudioForXVector) menimpa metode khusus `__call__`. Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance `Module` setelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam. - **loss** (`torch.Tensor` dengan bentuk `(1,)`, *opsional*, dikembalikan ketika `labels` disediakan) -- Loss klasifikasi. - **logits** (`torch.Tensor` dengan bentuk `(batch_size, config.xvector_output_dim)`) -- Hidden state klasifikasi sebelum AMSoftmax. - **embeddings** (`torch.Tensor` dengan bentuk `(batch_size, config.xvector_output_dim)`) -- Embedding ucapan yang digunakan untuk pengambilan berbasis kemiripan vektor. - **hidden_states** (`tuple(torch.Tensor)`, *opsional*, dikembalikan saat `output_hidden_states=True` dilewatkan atau saat `config.output_hidden_states=True`) -- Tuple dari `torch.Tensor` (satu untuk output embeddings + satu untuk output setiap layer) dengan bentuk `(batch_size, sequence_length, hidden_size)`. Hidden-states model pada output setiap layer ditambah output embedding awal. - **attentions** (`tuple(torch.Tensor)`, *opsional*, dikembalikan ketika `output_attentions=True` dilewatkan atau ketika `config.output_attentions=True`) -- Tuple dari `torch.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 self-attention. Contoh: ```python >>> from transformers import AutoFeatureExtractor, Data2VecAudioForXVector >>> from datasets import load_dataset >>> import torch >>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation") >>> dataset = dataset.sort("id") >>> sampling_rate = dataset.features["audio"].sampling_rate >>> feature_extractor = AutoFeatureExtractor.from_pretrained("facebook/data2vec-audio-base-960h") >>> model = Data2VecAudioForXVector.from_pretrained("facebook/data2vec-audio-base-960h") >>> # audio file is decoded on the fly >>> inputs = feature_extractor( ... [d["array"] for d in dataset[:2]["audio"]], sampling_rate=sampling_rate, return_tensors="pt", padding=True ... ) >>> with torch.no_grad(): ... embeddings = model(**inputs).embeddings >>> embeddings = torch.nn.functional.normalize(embeddings, dim=-1).cpu() >>> # the resulting embeddings can be used for cosine similarity-based retrieval >>> cosine_sim = torch.nn.CosineSimilarity(dim=-1) >>> similarity = cosine_sim(embeddings[0], embeddings[1]) >>> threshold = 0.7 # the optimal threshold is dataset-dependent >>> if similarity < threshold: ... print("Speakers are not the same!") >>> round(similarity.item(), 2) ... ``` ## Data2VecTextModel[[transformers.Data2VecTextModel]] #### transformers.Data2VecTextModel[[transformers.Data2VecTextModel]] ```python transformers.Data2VecTextModel(config: Data2VecTextConfig, add_pooling_layer = True) ``` [Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/data2vec/modeling_data2vec_text.py#L536) **Parameter:** config ([Data2VecTextConfig](/docs/transformers/v5.23.0/id/model_doc/data2vec#transformers.Data2VecTextConfig)) : Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya. Lihat metode [from_pretrained()](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk memuat bobot model. add_pooling_layer (`bool`, *opsional*, defaultnya `True`) : Apakah akan menambahkan lapisan pooling Model Data2Vec Text polos yang menghasilkan hidden-states mentah tanpa head spesifik di atasnya. Model ini mewarisi dari [PreTrainedModel](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel). Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka ini untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran input embeddings, memangkas heads, dll.) Model ini juga merupakan subclass dari [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#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[[transformers.Data2VecTextModel.forward]] ```python forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, encoder_hidden_states: typing.Optional[torch.Tensor] = None, encoder_attention_mask: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, use_cache: bool | None = None, **kwargs: *) ``` [Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/data2vec/modeling_data2vec_text.py#L562) **Parameter:** input_ids (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Indeks token dari urutan input dalam kosakata. Padding akan diabaikan secara default. Indeks dapat diperoleh menggunakan [AutoTokenizer](/docs/transformers/v5.23.0/id/model_doc/auto#transformers.AutoTokenizer). Lihat [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) dan [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) untuk detailnya. [Apa itu input IDs?](../glossary#input-ids) attention_mask (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Mask untuk menghindari pelaksanaan attention pada indeks token padding. Nilai mask dipilih dalam `[0, 1]`: - 1 untuk token yang **tidak di-mask**, - 0 untuk token yang **di-mask**. [Apa itu attention masks?](../glossary#attention-mask) token_type_ids (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Indeks token segmen untuk menunjukkan bagian pertama dan kedua dari input. Indeks dipilih dalam `[0, 1]`: - 0 sesuai dengan token *sentence A*, - 1 sesuai dengan token *sentence B*. [Apa itu token type IDs?](../glossary#token-type-ids) position_ids (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Indeks posisi token dari setiap urutan input dalam embedding posisi. Dipilih dalam rentang `[0, config.n_positions - 1]`. [Apa itu position ID?](../glossary#position-ids) inputs_embeds (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`, *opsional*) : Secara opsional, alih-alih meneruskan `input_ids`, Anda dapat memilih untuk langsung meneruskan representasi tertanam. Ini berguna jika Anda ingin lebih banyak kendali atas cara mengonversi indeks `input_ids` menjadi vektor terkait daripada matriks pencarian penanaman internal model. encoder_hidden_states (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`, *opsional*) : Urutan hidden-states pada keluaran lapisan terakhir encoder. Digunakan dalam cross-attention jika model dikonfigurasi sebagai decoder. encoder_attention_mask (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Mask untuk menghindari pelaksanaan attention pada indeks token padding dari input encoder. Mask ini digunakan dalam cross-attention jika model dikonfigurasi sebagai decoder. Nilai mask yang dipilih dalam `[0, 1]`: - 1 untuk token yang **tidak di-mask**, - 0 untuk token yang **di-mask**. past_key_values (`~cache_utils.Cache`, *opsional*) : Hidden-states yang telah dihitung sebelumnya (key dan values di blok self-attention dan di blok cross-attention) yang dapat digunakan untuk mempercepat decoding berurutan. Ini biasanya terdiri dari `past_key_values` yang dikembalikan oleh model pada tahap decoding sebelumnya, ketika `use_cache=True` atau `config.use_cache=True`. Hanya instance [Cache](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.Cache) yang diizinkan sebagai input, lihat [panduan kv cache](https://huggingface.co/docs/transformers/en/kv_cache) kami. Jika tidak ada `past_key_values` yang diteruskan, [DynamicCache](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.DynamicCache) akan diinisialisasi secara default. Model akan mengoutput format cache yang sama dengan yang diberikan sebagai input. Jika `past_key_values` digunakan, pengguna diharapkan untuk hanya menginput `input_ids` yang belum diproses (yang tidak memiliki state past key value mereka diberikan ke model ini) dengan bentuk `(batch_size, unprocessed_length)` alih-alih semua `input_ids` dengan bentuk `(batch_size, sequence_length)`. use_cache (`bool`, *opsional*) : Jika diatur ke `True`, state kunci-nilai `past_key_values` akan dikembalikan dan dapat digunakan untuk mempercepat decoding (lihat `past_key_values`). **Mengembalikan:** [BaseModelOutputWithPoolingAndCrossAttentions](/docs/transformers/v5.23.0/id/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions) atau `tuple(torch.Tensor)` A [BaseModelOutputWithPoolingAndCrossAttentions](/docs/transformers/v5.23.0/id/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions) atau tuple dari `torch.Tensor` (jika `return_dict=False` diteruskan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([Data2VecTextConfig](/docs/transformers/v5.23.0/id/model_doc/data2vec#transformers.Data2VecTextConfig)) dan input. Metode forward dari [Data2VecTextModel](/docs/transformers/v5.23.0/id/model_doc/data2vec#transformers.Data2VecTextModel) menimpa metode khusus `__call__`. Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance `Module` setelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam. - **last_hidden_state** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`) -- Urutan hidden-states pada keluaran lapisan terakhir model. - **pooler_output** (`torch.Tensor` dengan bentuk `(batch_size, hidden_size)`) -- Hidden-state lapisan terakhir dari token pertama dalam urutan (token klasifikasi) setelah diproses lebih lanjut melalui lapisan yang digunakan untuk tugas pra-pelatihan tambahan. Misalnya, untuk keluarga model BERT, ini mengembalikan token klasifikasi setelah diproses melalui lapisan linear dan fungsi aktivasi tanh. Bobot lapisan linear dilatih dari tujuan prediksi kalimat berikutnya (klasifikasi) selama pra-pelatihan. - **hidden_states** (`tuple(torch.Tensor)`, *opsional*, dikembalikan saat `output_hidden_states=True` dilewatkan atau saat `config.output_hidden_states=True`) -- Tuple dari `torch.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 ketika `output_attentions=True` dilewatkan atau ketika `config.output_attentions=True`) -- Tuple dari `torch.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 self-attention. - **cross_attentions** (`tuple(torch.Tensor)`, *opsional*, dikembalikan ketika `output_attentions=True` dan `config.add_cross_attention=True` diteruskan atau ketika `config.output_attentions=True`) -- Tuple dari `torch.Tensor` (satu untuk setiap lapisan) 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. - **past_key_values** (`Cache`, *opsional*, dikembalikan saat `use_cache=True` dilewatkan atau saat `config.use_cache=True`) -- Ini adalah instance [Cache](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.Cache). Untuk detail lebih lanjut, lihat [panduan kv cache](https://huggingface.co/docs/transformers/en/kv_cache) kami. Berisi hidden-states yang telah dihitung sebelumnya (key dan values di blok self-attention, dan secara opsional jika `config.is_encoder_decoder=True` di blok cross-attention) yang dapat digunakan (lihat input `past_key_values`) untuk mempercepat decoding berurutan. ## Data2VecTextForCausalLM[[transformers.Data2VecTextForCausalLM]] #### transformers.Data2VecTextForCausalLM[[transformers.Data2VecTextForCausalLM]] ```python transformers.Data2VecTextForCausalLM(config: Data2VecTextConfig) ``` [Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/data2vec/modeling_data2vec_text.py#L712) **Parameter:** config ([Data2VecTextConfig](/docs/transformers/v5.23.0/id/model_doc/data2vec#transformers.Data2VecTextConfig)) : Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya. Lihat metode [from_pretrained()](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk memuat bobot model. Model Data2VecText dengan kepala `language modeling` di atasnya untuk fine-tuning CLM. Model ini mewarisi dari [PreTrainedModel](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel). Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka ini untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran input embeddings, memangkas heads, dll.) Model ini juga merupakan subclass dari [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#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[[transformers.Data2VecTextForCausalLM.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, encoder_hidden_states: typing.Optional[torch.Tensor] = None, encoder_attention_mask: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, past_key_values: tuple[tuple[torch.Tensor]] | None = None, use_cache: bool | None = None, logits_to_keep: typing.Union[int, torch.Tensor] = 0, **kwargs: *) ``` [Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/data2vec/modeling_data2vec_text.py#L736) **Parameter:** input_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Indeks token dari urutan input dalam kosakata. Padding akan diabaikan secara default. Indeks dapat diperoleh menggunakan [AutoTokenizer](/docs/transformers/v5.23.0/id/model_doc/auto#transformers.AutoTokenizer). Lihat [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) dan [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) untuk detailnya. [Apa itu input IDs?](../glossary#input-ids) attention_mask (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Mask untuk menghindari pelaksanaan attention pada indeks token padding. Nilai mask dipilih dalam `[0, 1]`: - 1 untuk token yang **tidak di-mask**, - 0 untuk token yang **di-mask**. [Apa itu attention masks?](../glossary#attention-mask) token_type_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Indeks token segmen untuk menunjukkan bagian pertama dan kedua dari input. Indeks dipilih dalam `[0, 1]`: - 0 sesuai dengan token *sentence A*, - 1 sesuai dengan token *sentence B*. [Apa itu token type IDs?](../glossary#token-type-ids) position_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Indeks posisi token dari setiap urutan input dalam embedding posisi. Dipilih dalam rentang `[0, config.n_positions - 1]`. [Apa itu position ID?](../glossary#position-ids) inputs_embeds (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`, *opsional*) : Secara opsional, alih-alih meneruskan `input_ids`, Anda dapat memilih untuk langsung meneruskan representasi tertanam. Ini berguna jika Anda ingin lebih banyak kendali atas cara mengonversi indeks `input_ids` menjadi vektor terkait daripada matriks pencarian penanaman internal model. encoder_hidden_states (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`, *opsional*) : Urutan hidden-states pada keluaran lapisan terakhir encoder. Digunakan dalam cross-attention jika model dikonfigurasi sebagai decoder. encoder_attention_mask (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Mask untuk menghindari pelaksanaan attention pada indeks token padding dari input encoder. Mask ini digunakan dalam cross-attention jika model dikonfigurasi sebagai decoder. Nilai mask yang dipilih dalam `[0, 1]`: - 1 untuk token yang **tidak di-mask**, - 0 untuk token yang **di-mask**. labels (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Label untuk menghitung kerugian pemodelan bahasa kiri-ke-kanan (prediksi kata berikutnya). Indeks harus berada dalam `[-100, 0, ..., config.vocab_size]` (lihat docstring `input_ids`) Token dengan indeks yang disetel ke `-100` diabaikan (dimasker), kerugian hanya dihitung untuk token dengan label dalam `[0, ..., config.vocab_size]` past_key_values (`tuple[tuple[torch.Tensor]]`, *opsional*) : Hidden-states yang sudah dihitung sebelumnya (key dan values di blok self-attention dan di blok cross-attention) yang dapat digunakan untuk mempercepat decoding berurutan. Ini biasanya terdiri dari `past_key_values` yang dikembalikan oleh model pada tahap decoding sebelumnya, ketika `use_cache=True` atau `config.use_cache=True`. Hanya instance [Cache](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.Cache) yang diizinkan sebagai input, lihat [panduan kv cache](https://huggingface.co/docs/transformers/en/kv_cache) kami. Jika tidak ada `past_key_values` yang diberikan, [DynamicCache](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.DynamicCache) akan diinisialisasi secara default. Model akan mengoutput format cache yang sama dengan yang diberikan sebagai input. Jika `past_key_values` digunakan, pengguna diharapkan untuk hanya menginput `input_ids` yang belum diproses (yang tidak memiliki state key value sebelumnya yang diberikan ke model ini) dengan bentuk `(batch_size, unprocessed_length)` alih-alih semua `input_ids` dengan bentuk `(batch_size, sequence_length)`. use_cache (`bool`, *opsional*) : Jika diatur ke `True`, state kunci-nilai `past_key_values` akan dikembalikan dan dapat digunakan untuk mempercepat decoding (lihat `past_key_values`). logits_to_keep (`Union[int, torch.Tensor]`, *opsional*, defaultnya `0`) : Jika berupa `int`, hitung logits untuk `logits_to_keep` token terakhir. Jika `0`, hitung logits untuk semua `input_ids` (kasus khusus). Hanya logits token terakhir yang diperlukan untuk generasi, dan menghitungnya hanya untuk token tersebut dapat menghemat memori, yang menjadi cukup signifikan untuk urutan panjang atau ukuran kosakata besar. Jika berupa `torch.Tensor`, harus 1D yang sesuai dengan indeks yang akan dipertahankan pada dimensi panjang urutan. Ini berguna saat menggunakan format tensor terpadu (satu dimensi untuk batch dan panjang urutan). **Mengembalikan:** [CausalLMOutputWithCrossAttentions](/docs/transformers/v5.23.0/id/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithCrossAttentions) atau `tuple(torch.Tensor)` A [CausalLMOutputWithCrossAttentions](/docs/transformers/v5.23.0/id/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithCrossAttentions) atau tuple dari `torch.Tensor` (jika `return_dict=False` diteruskan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([Data2VecTextConfig](/docs/transformers/v5.23.0/id/model_doc/data2vec#transformers.Data2VecTextConfig)) dan input. Metode forward dari [Data2VecTextForCausalLM](/docs/transformers/v5.23.0/id/model_doc/data2vec#transformers.Data2VecTextForCausalLM) menimpa metode khusus `__call__`. Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance `Module` setelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam. - **loss** (`torch.Tensor` dengan bentuk `(1,)`, *opsional*, dikembalikan saat `labels` disediakan) -- Loss pemodelan bahasa (untuk prediksi token berikutnya). - **logits** (`torch.Tensor` dengan 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 saat `output_hidden_states=True` dilewatkan atau saat `config.output_hidden_states=True`) -- Tuple dari `torch.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 ketika `output_attentions=True` dilewatkan atau ketika `config.output_attentions=True`) -- Tuple dari `torch.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 self-attention. - **cross_attentions** (`tuple(torch.Tensor)`, *opsional*, dikembalikan ketika `output_attentions=True` dilewatkan atau ketika `config.output_attentions=True`) -- Tuple dari `torch.Tensor` (satu untuk setiap layer) dengan bentuk `(batch_size, num_heads, sequence_length, sequence_length)`. Bobot cross attention setelah softmax attention, digunakan untuk menghitung rata-rata berbobot di kepala cross-attention. - **past_key_values** (`Cache`, *opsional*, dikembalikan saat `use_cache=True` dilewatkan atau saat `config.use_cache=True`) -- Ini adalah instance [Cache](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.Cache). Untuk detail lebih lanjut, lihat [panduan kv cache](https://huggingface.co/docs/transformers/en/kv_cache) kami. Berisi hidden-states yang telah dihitung sebelumnya (key dan values di blok attention) yang dapat digunakan (lihat input `past_key_values`) untuk mempercepat decoding berurutan. Contoh: ```python >>> from transformers import AutoTokenizer, Data2VecTextForCausalLM, Data2VecTextConfig >>> import torch >>> tokenizer = AutoTokenizer.from_pretrained("facebook/data2vec-text-base") >>> config = Data2VecTextConfig.from_pretrained("facebook/data2vec-text-base") >>> config.is_decoder = True >>> model = Data2VecTextForCausalLM.from_pretrained("facebook/data2vec-text-base", config=config) >>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt") >>> outputs = model(**inputs) >>> prediction_logits = outputs.logits ``` ## Data2VecTextForMaskedLM[[transformers.Data2VecTextForMaskedLM]] #### transformers.Data2VecTextForMaskedLM[[transformers.Data2VecTextForMaskedLM]] ```python transformers.Data2VecTextForMaskedLM(config: Data2VecTextConfig) ``` [Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/data2vec/modeling_data2vec_text.py#L811) **Parameter:** config ([Data2VecTextConfig](/docs/transformers/v5.23.0/id/model_doc/data2vec#transformers.Data2VecTextConfig)) : Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya. Lihat metode [from_pretrained()](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk memuat bobot model. Model Data2Vec Text dengan kepala `language modeling` di atasnya." Model ini mewarisi dari [PreTrainedModel](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel). Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka ini untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran input embeddings, memangkas heads, dll.) Model ini juga merupakan subclass dari [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#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[[transformers.Data2VecTextForMaskedLM.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, encoder_hidden_states: typing.Optional[torch.Tensor] = None, encoder_attention_mask: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, **kwargs: *) ``` [Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/data2vec/modeling_data2vec_text.py#L838) **Parameter:** input_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Indeks token dari urutan input dalam kosakata. Padding akan diabaikan secara default. Indeks dapat diperoleh menggunakan [AutoTokenizer](/docs/transformers/v5.23.0/id/model_doc/auto#transformers.AutoTokenizer). Lihat [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) dan [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) untuk detailnya. [Apa itu input IDs?](../glossary#input-ids) attention_mask (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Mask untuk menghindari pelaksanaan attention pada indeks token padding. Nilai mask dipilih dalam `[0, 1]`: - 1 untuk token yang **tidak di-mask**, - 0 untuk token yang **di-mask**. [Apa itu attention masks?](../glossary#attention-mask) token_type_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Indeks token segmen untuk menunjukkan bagian pertama dan kedua dari input. Indeks dipilih dalam `[0, 1]`: - 0 sesuai dengan token *sentence A*, - 1 sesuai dengan token *sentence B*. [Apa itu token type IDs?](../glossary#token-type-ids) position_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Indeks posisi token dari setiap urutan input dalam embedding posisi. Dipilih dalam rentang `[0, config.n_positions - 1]`. [Apa itu position ID?](../glossary#position-ids) inputs_embeds (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`, *opsional*) : Secara opsional, alih-alih meneruskan `input_ids`, Anda dapat memilih untuk langsung meneruskan representasi tertanam. Ini berguna jika Anda ingin lebih banyak kendali atas cara mengonversi indeks `input_ids` menjadi vektor terkait daripada matriks pencarian penanaman internal model. encoder_hidden_states (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`, *opsional*) : Urutan hidden-states pada keluaran lapisan terakhir encoder. Digunakan dalam cross-attention jika model dikonfigurasi sebagai decoder. encoder_attention_mask (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Mask untuk menghindari pelaksanaan attention pada indeks token padding dari input encoder. Mask ini digunakan dalam cross-attention jika model dikonfigurasi sebagai decoder. Nilai mask yang dipilih dalam `[0, 1]`: - 1 untuk token yang **tidak di-mask**, - 0 untuk token yang **di-mask**. labels (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Label untuk menghitung kerugian pemodelan bahasa yang disamarkan. Indeks harus berada dalam `[-100, 0, ..., config.vocab_size]` (lihat docstring `input_ids`) Token dengan indeks yang diset ke `-100` diabaikan (disamarkan), kerugian hanya dihitung untuk token dengan label dalam `[0, ..., config.vocab_size]`. **Mengembalikan:** [MaskedLMOutput](/docs/transformers/v5.23.0/id/main_classes/output#transformers.modeling_outputs.MaskedLMOutput) atau `tuple(torch.Tensor)` [MaskedLMOutput](/docs/transformers/v5.23.0/id/main_classes/output#transformers.modeling_outputs.MaskedLMOutput) atau tuple dari `torch.Tensor` (jika `return_dict=False` diteruskan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([Data2VecTextConfig](/docs/transformers/v5.23.0/id/model_doc/data2vec#transformers.Data2VecTextConfig)) dan input. Metode forward dari [Data2VecTextForMaskedLM](/docs/transformers/v5.23.0/id/model_doc/data2vec#transformers.Data2VecTextForMaskedLM) menimpa metode khusus `__call__`. Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance `Module` setelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam. - **loss** (`torch.Tensor` dengan bentuk `(1,)`, *opsional*, dikembalikan ketika `labels` diberikan) -- Masked language modeling (MLM) loss. - **logits** (`torch.Tensor` dengan 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 saat `output_hidden_states=True` dilewatkan atau saat `config.output_hidden_states=True`) -- Tuple dari `torch.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 ketika `output_attentions=True` dilewatkan atau ketika `config.output_attentions=True`) -- Tuple dari `torch.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 self-attention. Contoh: ```python >>> from transformers import AutoTokenizer, Data2VecTextForMaskedLM >>> import torch >>> tokenizer = AutoTokenizer.from_pretrained("facebook/data2vec-text-base") >>> model = Data2VecTextForMaskedLM.from_pretrained("facebook/data2vec-text-base") >>> inputs = tokenizer("The capital of France is .", return_tensors="pt") >>> with torch.no_grad(): ... logits = model(**inputs).logits >>> # retrieve index of >>> mask_token_index = (inputs.input_ids == tokenizer.mask_token_id)[0].nonzero(as_tuple=True)[0] >>> predicted_token_id = logits[0, mask_token_index].argmax(axis=-1) >>> tokenizer.decode(predicted_token_id) ... >>> labels = tokenizer("The capital of France is Paris.", return_tensors="pt")["input_ids"] >>> # mask labels of non- tokens >>> labels = torch.where(inputs.input_ids == tokenizer.mask_token_id, labels, -100) >>> outputs = model(**inputs, labels=labels) >>> round(outputs.loss.item(), 2) ... ``` ## Data2VecTextForSequenceClassification[[transformers.Data2VecTextForSequenceClassification]] #### transformers.Data2VecTextForSequenceClassification[[transformers.Data2VecTextForSequenceClassification]] ```python transformers.Data2VecTextForSequenceClassification(config: Data2VecTextConfig) ``` [Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/data2vec/modeling_data2vec_text.py#L887) **Parameter:** config ([Data2VecTextConfig](/docs/transformers/v5.23.0/id/model_doc/data2vec#transformers.Data2VecTextConfig)) : Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya. Lihat metode [from_pretrained()](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk memuat bobot model. Data2VecText Model transformer dengan kepala klasifikasi/regresi urutan di atasnya (lapisan linear di atas output yang dipool) misalnya untuk tugas GLUE. Model ini mewarisi dari [PreTrainedModel](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel). Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka ini untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran input embeddings, memangkas heads, dll.) Model ini juga merupakan subclass dari [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#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[[transformers.Data2VecTextForSequenceClassification.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, **kwargs: *) ``` [Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/data2vec/modeling_data2vec_text.py#L899) **Parameter:** input_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Indeks token dari urutan input dalam kosakata. Padding akan diabaikan secara default. Indeks dapat diperoleh menggunakan [AutoTokenizer](/docs/transformers/v5.23.0/id/model_doc/auto#transformers.AutoTokenizer). Lihat [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) dan [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) untuk detailnya. [Apa itu input IDs?](../glossary#input-ids) attention_mask (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Mask untuk menghindari pelaksanaan attention pada indeks token padding. Nilai mask dipilih dalam `[0, 1]`: - 1 untuk token yang **tidak di-mask**, - 0 untuk token yang **di-mask**. [Apa itu attention masks?](../glossary#attention-mask) token_type_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Indeks token segmen untuk menunjukkan bagian pertama dan kedua dari input. Indeks dipilih dalam `[0, 1]`: - 0 sesuai dengan token *sentence A*, - 1 sesuai dengan token *sentence B*. [Apa itu token type IDs?](../glossary#token-type-ids) position_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Indeks posisi token dari setiap urutan input dalam embedding posisi. Dipilih dalam rentang `[0, config.n_positions - 1]`. [Apa itu position ID?](../glossary#position-ids) inputs_embeds (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`, *opsional*) : Secara opsional, alih-alih meneruskan `input_ids`, Anda dapat memilih untuk langsung meneruskan representasi tertanam. Ini berguna jika Anda ingin lebih banyak kendali atas cara mengonversi indeks `input_ids` menjadi vektor terkait daripada matriks pencarian penanaman internal model. labels (`torch.LongTensor` dengan bentuk `(batch_size,)`, *opsional*) : Label untuk menghitung loss klasifikasi/regresi urutan. Indeks harus berada dalam `[0, ..., config.num_labels - 1]`. Jika `config.num_labels == 1`, loss regresi dihitung (Mean-Square loss). Jika `config.num_labels > 1`, loss klasifikasi dihitung (Cross-Entropy). **Mengembalikan:** [SequenceClassifierOutput](/docs/transformers/v5.23.0/id/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput) atau `tuple(torch.Tensor)` [SequenceClassifierOutput](/docs/transformers/v5.23.0/id/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput) atau tuple dari `torch.Tensor` (jika `return_dict=False` diteruskan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([Data2VecTextConfig](/docs/transformers/v5.23.0/id/model_doc/data2vec#transformers.Data2VecTextConfig)) dan input. Metode forward dari [Data2VecTextForSequenceClassification](/docs/transformers/v5.23.0/id/model_doc/data2vec#transformers.Data2VecTextForSequenceClassification) menimpa metode khusus `__call__`. Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance `Module` setelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam. - **loss** (`torch.Tensor` dengan bentuk `(1,)`, *opsional*, dikembalikan saat `labels` disediakan) -- Loss klasifikasi (atau regresi jika config.num_labels==1). - **logits** (`torch.Tensor` dengan bentuk `(batch_size, config.num_labels)`) -- Skor klasifikasi (atau regresi jika config.num_labels==1) (sebelum SoftMax). - **hidden_states** (`tuple(torch.Tensor)`, *opsional*, dikembalikan saat `output_hidden_states=True` dilewatkan atau saat `config.output_hidden_states=True`) -- Tuple dari `torch.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 ketika `output_attentions=True` dilewatkan atau ketika `config.output_attentions=True`) -- Tuple dari `torch.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 self-attention. Contoh klasifikasi label tunggal: ```python >>> import torch >>> from transformers import AutoTokenizer, Data2VecTextForSequenceClassification >>> tokenizer = AutoTokenizer.from_pretrained("facebook/data2vec-text-base") >>> model = Data2VecTextForSequenceClassification.from_pretrained("facebook/data2vec-text-base") >>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt") >>> with torch.no_grad(): ... logits = model(**inputs).logits >>> predicted_class_id = logits.argmax().item() >>> model.config.id2label[predicted_class_id] ... >>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)` >>> num_labels = len(model.config.id2label) >>> model = Data2VecTextForSequenceClassification.from_pretrained("facebook/data2vec-text-base", num_labels=num_labels) >>> labels = torch.tensor([1]) >>> loss = model(**inputs, labels=labels).loss >>> round(loss.item(), 2) ... ``` Contoh klasifikasi multi-label: ```python >>> import torch >>> from transformers import AutoTokenizer, Data2VecTextForSequenceClassification >>> tokenizer = AutoTokenizer.from_pretrained("facebook/data2vec-text-base") >>> model = Data2VecTextForSequenceClassification.from_pretrained("facebook/data2vec-text-base", problem_type="multi_label_classification") >>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt") >>> with torch.no_grad(): ... logits = model(**inputs).logits >>> predicted_class_ids = torch.arange(0, logits.shape[-1])[torch.sigmoid(logits).squeeze(dim=0) > 0.5] >>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)` >>> num_labels = len(model.config.id2label) >>> model = Data2VecTextForSequenceClassification.from_pretrained( ... "facebook/data2vec-text-base", num_labels=num_labels, problem_type="multi_label_classification" ... ) >>> labels = torch.sum( ... torch.nn.functional.one_hot(predicted_class_ids[None, :].clone(), num_classes=num_labels), dim=1 ... ).to(torch.float) >>> loss = model(**inputs, labels=labels).loss ``` ## Data2VecTextForMultipleChoice[[transformers.Data2VecTextForMultipleChoice]] #### transformers.Data2VecTextForMultipleChoice[[transformers.Data2VecTextForMultipleChoice]] ```python transformers.Data2VecTextForMultipleChoice(config: Data2VecTextConfig) ``` [Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/data2vec/modeling_data2vec_text.py#L957) **Parameter:** config ([Data2VecTextConfig](/docs/transformers/v5.23.0/id/model_doc/data2vec#transformers.Data2VecTextConfig)) : Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya. Lihat metode [from_pretrained()](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk memuat bobot model. Model Data2Vec Text dengan kepala klasifikasi pilihan ganda di atasnya (lapisan linear di atas output yang dipool dan softmax), misalnya untuk tugas RocStories/SWAG. Model ini mewarisi dari [PreTrainedModel](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel). Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka ini untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran input embeddings, memangkas heads, dll.) Model ini juga merupakan subclass dari [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#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[[transformers.Data2VecTextForMultipleChoice.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, **kwargs: *) ``` [Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/data2vec/modeling_data2vec_text.py#L968) **Parameter:** input_ids (`torch.LongTensor` dengan bentuk `(batch_size, num_choices, sequence_length)`) : Indeks token dari urutan input dalam kosakata. Indeks dapat diperoleh menggunakan [AutoTokenizer](/docs/transformers/v5.23.0/id/model_doc/auto#transformers.AutoTokenizer). Lihat [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) dan [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) untuk detailnya. [Apa itu input ID?](../glossary#input-ids) token_type_ids (`torch.LongTensor` dengan bentuk `(batch_size, num_choices, sequence_length)`, *opsional*) : Indeks token segmen untuk menunjukkan bagian pertama dan kedua dari input. Indeks dipilih dalam `[0, 1]`: - 0 sesuai dengan token *sentence A*, - 1 sesuai dengan token *sentence B*. [Apa itu token type IDs?](../glossary#token-type-ids) attention_mask (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Mask untuk menghindari pelaksanaan attention pada indeks token padding. Nilai mask dipilih dalam `[0, 1]`: - 1 untuk token yang **tidak di-mask**, - 0 untuk token yang **di-mask**. [Apa itu attention masks?](../glossary#attention-mask) labels (`torch.LongTensor` dengan bentuk `(batch_size,)`, *opsional*) : Label untuk menghitung kerugian klasifikasi pilihan ganda. Indeks harus berada dalam `[0, ..., num_choices-1]` di mana `num_choices` adalah ukuran dimensi kedua dari tensor input. (Lihat `input_ids` di atas) position_ids (`torch.LongTensor` dengan bentuk `(batch_size, num_choices, sequence_length)`, *opsional*) : Indeks posisi token dari setiap urutan input dalam embedding posisi. Dipilih dalam rentang `[0, config.max_position_embeddings - 1]`. [Apa itu ID posisi?](../glossary#position-ids) inputs_embeds (`torch.Tensor` dengan bentuk `(batch_size, num_choices, sequence_length, hidden_size)`, *opsional*) : Secara opsional, alih-alih meneruskan `input_ids`, Anda dapat memilih untuk langsung meneruskan representasi tertanam. Ini berguna jika Anda ingin lebih banyak kendali atas cara mengonversi indeks `input_ids` menjadi vektor terkait, dibandingkan dengan matriks pencarian embedding internal model. **Mengembalikan:** [MultipleChoiceModelOutput](/docs/transformers/v5.23.0/id/main_classes/output#transformers.modeling_outputs.MultipleChoiceModelOutput) atau `tuple(torch.Tensor)` [MultipleChoiceModelOutput](/docs/transformers/v5.23.0/id/main_classes/output#transformers.modeling_outputs.MultipleChoiceModelOutput) atau tuple dari `torch.Tensor` (jika `return_dict=False` diteruskan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([Data2VecTextConfig](/docs/transformers/v5.23.0/id/model_doc/data2vec#transformers.Data2VecTextConfig)) dan input. Metode forward dari [Data2VecTextForMultipleChoice](/docs/transformers/v5.23.0/id/model_doc/data2vec#transformers.Data2VecTextForMultipleChoice) menimpa metode khusus `__call__`. Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance `Module` setelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam. - **loss** (`torch.Tensor` dengan bentuk *(1,)*, *opsional*, dikembalikan ketika `labels` disediakan) -- Loss klasifikasi. - **logits** (`torch.Tensor` dengan bentuk `(batch_size, num_choices)`) -- *num_choices* adalah dimensi kedua dari tensor input. (lihat *input_ids* di atas). Skor klasifikasi (sebelum SoftMax). - **hidden_states** (`tuple(torch.Tensor)`, *opsional*, dikembalikan saat `output_hidden_states=True` dilewatkan atau saat `config.output_hidden_states=True`) -- Tuple dari `torch.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 ketika `output_attentions=True` dilewatkan atau ketika `config.output_attentions=True`) -- Tuple dari `torch.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 self-attention. Contoh: ```python >>> from transformers import AutoTokenizer, Data2VecTextForMultipleChoice >>> import torch >>> tokenizer = AutoTokenizer.from_pretrained("facebook/data2vec-text-base") >>> model = Data2VecTextForMultipleChoice.from_pretrained("facebook/data2vec-text-base") >>> prompt = "In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced." >>> choice0 = "It is eaten with a fork and a knife." >>> choice1 = "It is eaten while held in the hand." >>> labels = torch.tensor(0).unsqueeze(0) # choice0 is correct (according to Wikipedia ;)), batch size 1 >>> encoding = tokenizer([prompt, prompt], [choice0, choice1], return_tensors="pt", padding=True) >>> outputs = model(**{k: v.unsqueeze(0) for k, v in encoding.items()}, labels=labels) # batch size is 1 >>> # the linear classifier still needs to be trained >>> loss = outputs.loss >>> logits = outputs.logits ``` ## Data2VecTextForTokenClassification[[transformers.Data2VecTextForTokenClassification]] #### transformers.Data2VecTextForTokenClassification[[transformers.Data2VecTextForTokenClassification]] ```python transformers.Data2VecTextForTokenClassification(config: Data2VecTextConfig) ``` [Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/data2vec/modeling_data2vec_text.py#L1049) **Parameter:** config ([Data2VecTextConfig](/docs/transformers/v5.23.0/id/model_doc/data2vec#transformers.Data2VecTextConfig)) : Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya. Lihat metode [from_pretrained()](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk memuat bobot model. Transformer Data2Vec Text dengan kepala klasifikasi token di atasnya (lapisan linear di atas keluaran hidden-states), misalnya untuk tugas Named-Entity-Recognition (NER). Model ini mewarisi dari [PreTrainedModel](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel). Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka ini untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran input embeddings, memangkas heads, dll.) Model ini juga merupakan subclass dari [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#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[[transformers.Data2VecTextForTokenClassification.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, **kwargs: *) ``` [Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/data2vec/modeling_data2vec_text.py#L1064) **Parameter:** input_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Indeks token dari urutan input dalam kosakata. Padding akan diabaikan secara default. Indeks dapat diperoleh menggunakan [AutoTokenizer](/docs/transformers/v5.23.0/id/model_doc/auto#transformers.AutoTokenizer). Lihat [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) dan [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) untuk detailnya. [Apa itu input IDs?](../glossary#input-ids) attention_mask (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Mask untuk menghindari pelaksanaan attention pada indeks token padding. Nilai mask dipilih dalam `[0, 1]`: - 1 untuk token yang **tidak di-mask**, - 0 untuk token yang **di-mask**. [Apa itu attention masks?](../glossary#attention-mask) token_type_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Indeks token segmen untuk menunjukkan bagian pertama dan kedua dari input. Indeks dipilih dalam `[0, 1]`: - 0 sesuai dengan token *sentence A*, - 1 sesuai dengan token *sentence B*. [Apa itu token type IDs?](../glossary#token-type-ids) position_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Indeks posisi token dari setiap urutan input dalam embedding posisi. Dipilih dalam rentang `[0, config.n_positions - 1]`. [Apa itu position ID?](../glossary#position-ids) inputs_embeds (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`, *opsional*) : Secara opsional, alih-alih meneruskan `input_ids`, Anda dapat memilih untuk langsung meneruskan representasi tertanam. Ini berguna jika Anda ingin lebih banyak kendali atas cara mengonversi indeks `input_ids` menjadi vektor terkait daripada matriks pencarian penanaman internal model. labels (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Label untuk menghitung kerugian klasifikasi token. Indeks harus berada dalam `[0, ..., config.num_labels - 1]`. **Mengembalikan:** [TokenClassifierOutput](/docs/transformers/v5.23.0/id/main_classes/output#transformers.modeling_outputs.TokenClassifierOutput) atau `tuple(torch.Tensor)` [TokenClassifierOutput](/docs/transformers/v5.23.0/id/main_classes/output#transformers.modeling_outputs.TokenClassifierOutput) atau tuple dari `torch.Tensor` (jika `return_dict=False` diteruskan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([Data2VecTextConfig](/docs/transformers/v5.23.0/id/model_doc/data2vec#transformers.Data2VecTextConfig)) dan input. Metode forward dari [Data2VecTextForTokenClassification](/docs/transformers/v5.23.0/id/model_doc/data2vec#transformers.Data2VecTextForTokenClassification) menimpa metode khusus `__call__`. Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance `Module` setelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam. - **loss** (`torch.Tensor` dengan bentuk `(1,)`, *opsional*, dikembalikan ketika `labels` disediakan) -- Loss klasifikasi. - **logits** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, config.num_labels)`) -- Skor klasifikasi (sebelum SoftMax). - **hidden_states** (`tuple(torch.Tensor)`, *opsional*, dikembalikan saat `output_hidden_states=True` dilewatkan atau saat `config.output_hidden_states=True`) -- Tuple dari `torch.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 ketika `output_attentions=True` dilewatkan atau ketika `config.output_attentions=True`) -- Tuple dari `torch.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 self-attention. Contoh: ```python >>> from transformers import AutoTokenizer, Data2VecTextForTokenClassification >>> import torch >>> tokenizer = AutoTokenizer.from_pretrained("facebook/data2vec-text-base") >>> model = Data2VecTextForTokenClassification.from_pretrained("facebook/data2vec-text-base") >>> inputs = tokenizer( ... "HuggingFace is a company based in Paris and New York", add_special_tokens=False, return_tensors="pt" ... ) >>> with torch.no_grad(): ... logits = model(**inputs).logits >>> predicted_token_class_ids = logits.argmax(-1) >>> # Note that tokens are classified rather then input words which means that >>> # there might be more predicted token classes than words. >>> # Multiple token classes might account for the same word >>> predicted_tokens_classes = [model.config.id2label[t.item()] for t in predicted_token_class_ids[0]] >>> predicted_tokens_classes ... >>> labels = predicted_token_class_ids >>> loss = model(**inputs, labels=labels).loss >>> round(loss.item(), 2) ... ``` ## Data2VecTextForQuestionAnswering[[transformers.Data2VecTextForQuestionAnswering]] #### transformers.Data2VecTextForQuestionAnswering[[transformers.Data2VecTextForQuestionAnswering]] ```python transformers.Data2VecTextForQuestionAnswering(config: Data2VecTextConfig) ``` [Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/data2vec/modeling_data2vec_text.py#L1107) **Parameter:** config ([Data2VecTextConfig](/docs/transformers/v5.23.0/id/model_doc/data2vec#transformers.Data2VecTextConfig)) : Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya. Lihat metode [from_pretrained()](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk memuat bobot model. Transformer Data2Vec Text dengan kepala klasifikasi span di atasnya untuk tugas tanya-jawab ekstraktif seperti SQuAD (lapisan linear di atas keluaran hidden-states untuk menghitung `span start logits` dan `span end logits`). Model ini mewarisi dari [PreTrainedModel](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel). Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka ini untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran input embeddings, memangkas heads, dll.) Model ini juga merupakan subclass dari [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#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[[transformers.Data2VecTextForQuestionAnswering.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, start_positions: typing.Optional[torch.LongTensor] = None, end_positions: typing.Optional[torch.LongTensor] = None, **kwargs: *) ``` [Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/data2vec/modeling_data2vec_text.py#L1118) **Parameter:** input_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Indeks token dari urutan input dalam kosakata. Padding akan diabaikan secara default. Indeks dapat diperoleh menggunakan [AutoTokenizer](/docs/transformers/v5.23.0/id/model_doc/auto#transformers.AutoTokenizer). Lihat [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) dan [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) untuk detailnya. [Apa itu input IDs?](../glossary#input-ids) attention_mask (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Mask untuk menghindari pelaksanaan attention pada indeks token padding. Nilai mask dipilih dalam `[0, 1]`: - 1 untuk token yang **tidak di-mask**, - 0 untuk token yang **di-mask**. [Apa itu attention masks?](../glossary#attention-mask) token_type_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Indeks token segmen untuk menunjukkan bagian pertama dan kedua dari input. Indeks dipilih dalam `[0, 1]`: - 0 sesuai dengan token *sentence A*, - 1 sesuai dengan token *sentence B*. [Apa itu token type IDs?](../glossary#token-type-ids) position_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Indeks posisi token dari setiap urutan input dalam embedding posisi. Dipilih dalam rentang `[0, config.n_positions - 1]`. [Apa itu position ID?](../glossary#position-ids) inputs_embeds (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`, *opsional*) : Secara opsional, alih-alih meneruskan `input_ids`, Anda dapat memilih untuk langsung meneruskan representasi tertanam. Ini berguna jika Anda ingin lebih banyak kendali atas cara mengonversi indeks `input_ids` menjadi vektor terkait daripada matriks pencarian penanaman internal model. start_positions (`torch.LongTensor` dengan bentuk `(batch_size,)`, *opsional*) : Label untuk posisi (indeks) awal span berlabel untuk menghitung kerugian klasifikasi token. Posisi di-clamp ke panjang sekuens (`sequence_length`). Posisi di luar sekuens tidak diperhitungkan dalam perhitungan kerugian. end_positions (`torch.LongTensor` dengan bentuk `(batch_size,)`, *opsional*) : Label untuk posisi (indeks) akhir span berlabel untuk menghitung kerugian klasifikasi token. Posisi di-clamp ke panjang sekuens (`sequence_length`). Posisi di luar sekuens tidak diperhitungkan dalam perhitungan kerugian. **Mengembalikan:** [QuestionAnsweringModelOutput](/docs/transformers/v5.23.0/id/main_classes/output#transformers.modeling_outputs.QuestionAnsweringModelOutput) atau `tuple(torch.Tensor)` Sebuah [QuestionAnsweringModelOutput](/docs/transformers/v5.23.0/id/main_classes/output#transformers.modeling_outputs.QuestionAnsweringModelOutput) atau tuple dari `torch.Tensor` (jika `return_dict=False` diteruskan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([Data2VecTextConfig](/docs/transformers/v5.23.0/id/model_doc/data2vec#transformers.Data2VecTextConfig)) dan input. Metode forward dari [Data2VecTextForQuestionAnswering](/docs/transformers/v5.23.0/id/model_doc/data2vec#transformers.Data2VecTextForQuestionAnswering) menimpa metode khusus `__call__`. Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance `Module` setelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam. - **loss** (`torch.Tensor` dengan bentuk `(1,)`, *opsional*, dikembalikan saat `labels` disediakan) -- Total span extraction loss adalah jumlah dari Cross-Entropy untuk posisi awal dan akhir. - **start_logits** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`) -- Skor awal span (sebelum SoftMax). - **end_logits** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`) -- Skor akhir span (sebelum SoftMax). - **hidden_states** (`tuple(torch.Tensor)`, *opsional*, dikembalikan saat `output_hidden_states=True` dilewatkan atau saat `config.output_hidden_states=True`) -- Tuple dari `torch.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 ketika `output_attentions=True` dilewatkan atau ketika `config.output_attentions=True`) -- Tuple dari `torch.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 self-attention. Contoh: ```python >>> from transformers import AutoTokenizer, Data2VecTextForQuestionAnswering >>> import torch >>> tokenizer = AutoTokenizer.from_pretrained("facebook/data2vec-text-base") >>> model = Data2VecTextForQuestionAnswering.from_pretrained("facebook/data2vec-text-base") >>> question, text = "Who was Jim Henson?", "Jim Henson was a nice puppet" >>> inputs = tokenizer(question, text, return_tensors="pt") >>> with torch.no_grad(): ... outputs = model(**inputs) >>> answer_start_index = outputs.start_logits.argmax() >>> answer_end_index = outputs.end_logits.argmax() >>> predict_answer_tokens = inputs.input_ids[0, answer_start_index : answer_end_index + 1] >>> tokenizer.decode(predict_answer_tokens, skip_special_tokens=True) ... >>> # target is "nice puppet" >>> target_start_index = torch.tensor([14]) >>> target_end_index = torch.tensor([15]) >>> outputs = model(**inputs, start_positions=target_start_index, end_positions=target_end_index) >>> loss = outputs.loss >>> round(loss.item(), 2) ... ``` ## Data2VecVisionModel[[transformers.Data2VecVisionModel]] #### transformers.Data2VecVisionModel[[transformers.Data2VecVisionModel]] ```python transformers.Data2VecVisionModel(config: Data2VecVisionConfig, add_pooling_layer: bool = False) ``` [Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/data2vec/modeling_data2vec_vision.py#L684) **Parameter:** config ([Data2VecVisionConfig](/docs/transformers/v5.23.0/id/model_doc/data2vec#transformers.Data2VecVisionConfig)) : Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya. Lihat metode [from_pretrained()](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk memuat bobot model. add_pooling_layer (`bool`, *opsional*, defaultnya `False`) : Apakah akan menambahkan lapisan pooling Model Data2Vec Vision polos yang menghasilkan hidden-states mentah tanpa head spesifik di atasnya. Model ini mewarisi dari [PreTrainedModel](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel). Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka ini untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran input embeddings, memangkas heads, dll.) Model ini juga merupakan subclass dari [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#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[[transformers.Data2VecVisionModel.forward]] ```python forward(pixel_values: Tensor, bool_masked_pos: typing.Optional[torch.BoolTensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, interpolate_pos_encoding: bool = False, return_dict: bool | None = None, **kwargs) ``` [Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/data2vec/modeling_data2vec_vision.py#L707) **Parameter:** pixel_values (`torch.Tensor` dengan bentuk `(batch_size, num_channels, image_size, image_size)`) : Tensor yang sesuai dengan gambar input. Nilai piksel dapat diperoleh menggunakan [BeitImageProcessor](/docs/transformers/v5.23.0/id/model_doc/beit#transformers.BeitImageProcessor). Lihat [BeitImageProcessor.__call__()](/docs/transformers/v5.23.0/id/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) untuk detailnya (`processor_class` menggunakan [BeitImageProcessor](/docs/transformers/v5.23.0/id/model_doc/beit#transformers.BeitImageProcessor) untuk memproses gambar). bool_masked_pos (`torch.BoolTensor` dengan bentuk `(batch_size, num_patches)`, *opsional*) : Posisi yang dimask secara boolean. Menunjukkan patch mana yang dimask (1) dan mana yang tidak (0). output_attentions (`bool`, *opsional*) : Apakah akan mengembalikan tensor perhatian dari semua lapisan perhatian. Lihat `attentions` di bawah tensor yang dikembalikan untuk detail lebih lanjut. output_hidden_states (`bool`, *opsional*) : Apakah akan mengembalikan hidden states dari semua lapisan. Lihat `hidden_states` di bawah tensor yang dikembalikan untuk detail lebih lanjut. interpolate_pos_encoding (`bool`, *opsional*, defaultnya `False`) : Apakah akan menginterpolasi enkoding posisi yang telah dilatih sebelumnya. return_dict (`bool`, *opsional*) : Apakah akan mengembalikan [ModelOutput](/docs/transformers/v5.23.0/id/main_classes/output#transformers.utils.ModelOutput) alih-alih tuple biasa. **Mengembalikan:** `Data2VecVisionModelOutputWithPooling` atau `tuple(torch.Tensor)` Sebuah `Data2VecVisionModelOutputWithPooling` atau tuple dari `torch.Tensor` (jika `return_dict=False` dilewatkan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([Data2VecVisionConfig](/docs/transformers/v5.23.0/id/model_doc/data2vec#transformers.Data2VecVisionConfig)) dan input. Metode forward dari [Data2VecVisionModel](/docs/transformers/v5.23.0/id/model_doc/data2vec#transformers.Data2VecVisionModel) menimpa metode khusus `__call__`. Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance `Module` setelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam. - **last_hidden_state** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`) -- Urutan hidden-states pada keluaran lapisan terakhir model. - **pooler_output** (`torch.Tensor` dengan bentuk `(batch_size, hidden_size)`) -- Rata-rata dari hidden states lapisan terakhir dari token patch (tidak termasuk token *[CLS]*) jika *config.use_mean_pooling* diatur ke True. Jika diatur ke False, maka hidden state akhir dari token *[CLS]* akan dikembalikan. - **hidden_states** (`tuple(torch.Tensor)`, *opsional*, dikembalikan saat `output_hidden_states=True` dilewatkan atau saat `config.output_hidden_states=True`) -- Tuple dari `torch.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 ketika `output_attentions=True` dilewatkan atau ketika `config.output_attentions=True`) -- Tuple dari `torch.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 self-attention. Contoh: ```python ``` ## Data2VecVisionForImageClassification[[transformers.Data2VecVisionForImageClassification]] #### transformers.Data2VecVisionForImageClassification[[transformers.Data2VecVisionForImageClassification]] ```python transformers.Data2VecVisionForImageClassification(config: Data2VecVisionConfig) ``` [Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/data2vec/modeling_data2vec_vision.py#L775) **Parameter:** config ([Data2VecVisionConfig](/docs/transformers/v5.23.0/id/model_doc/data2vec#transformers.Data2VecVisionConfig)) : Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya. Lihat metode [from_pretrained()](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk memuat bobot model. Data2VecVision Model transformer dengan kepala klasifikasi gambar di atasnya (lapisan linear di atas rata-rata dari keadaan tersembunyi akhir dari token patch) misalnya untuk ImageNet. Model ini mewarisi dari [PreTrainedModel](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel). Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka ini untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran input embeddings, memangkas heads, dll.) Model ini juga merupakan subclass dari [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#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[[transformers.Data2VecVisionForImageClassification.forward]] ```python forward(pixel_values: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, interpolate_pos_encoding: bool = False, return_dict: bool | None = None, **kwargs) ``` [Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/data2vec/modeling_data2vec_vision.py#L788) **Parameter:** pixel_values (`torch.Tensor` dengan bentuk `(batch_size, num_channels, image_size, image_size)`, *opsional*) : Tensor yang sesuai dengan gambar input. Nilai piksel dapat diperoleh menggunakan [BeitImageProcessor](/docs/transformers/v5.23.0/id/model_doc/beit#transformers.BeitImageProcessor). Lihat [BeitImageProcessor.__call__()](/docs/transformers/v5.23.0/id/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) untuk detailnya (`processor_class` menggunakan [BeitImageProcessor](/docs/transformers/v5.23.0/id/model_doc/beit#transformers.BeitImageProcessor) untuk memproses gambar). labels (`torch.LongTensor` dengan bentuk `(batch_size,)`, *opsional*) : Label untuk menghitung loss klasifikasi/regresi gambar. Indeks harus berada dalam `[0, ..., config.num_labels - 1]`. Jika `config.num_labels == 1`, loss regresi dihitung (Mean-Square loss). Jika `config.num_labels > 1`, loss klasifikasi dihitung (Cross-Entropy). output_attentions (`bool`, *opsional*) : Apakah akan mengembalikan tensor perhatian dari semua lapisan perhatian. Lihat `attentions` di bawah tensor yang dikembalikan untuk detail lebih lanjut. output_hidden_states (`bool`, *opsional*) : Apakah akan mengembalikan hidden states dari semua lapisan. Lihat `hidden_states` di bawah tensor yang dikembalikan untuk detail lebih lanjut. interpolate_pos_encoding (`bool`, *opsional*, defaultnya `False`) : Apakah akan menginterpolasi enkoding posisi yang telah dilatih sebelumnya. return_dict (`bool`, *opsional*) : Apakah akan mengembalikan [ModelOutput](/docs/transformers/v5.23.0/id/main_classes/output#transformers.utils.ModelOutput) alih-alih tuple biasa. **Mengembalikan:** [ImageClassifierOutput](/docs/transformers/v5.23.0/id/main_classes/output#transformers.modeling_outputs.ImageClassifierOutput) atau `tuple(torch.Tensor)` [ImageClassifierOutput](/docs/transformers/v5.23.0/id/main_classes/output#transformers.modeling_outputs.ImageClassifierOutput) atau tuple dari `torch.Tensor` (jika `return_dict=False` dilewatkan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([Data2VecVisionConfig](/docs/transformers/v5.23.0/id/model_doc/data2vec#transformers.Data2VecVisionConfig)) dan input. Metode forward dari [Data2VecVisionForImageClassification](/docs/transformers/v5.23.0/id/model_doc/data2vec#transformers.Data2VecVisionForImageClassification) menimpa metode khusus `__call__`. Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance `Module` setelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam. - **loss** (`torch.Tensor` dengan bentuk `(1,)`, *opsional*, dikembalikan saat `labels` disediakan) -- Loss klasifikasi (atau regresi jika config.num_labels==1). - **logits** (`torch.Tensor` dengan bentuk `(batch_size, config.num_labels)`) -- Skor klasifikasi (atau regresi jika config.num_labels==1) (sebelum SoftMax). - **hidden_states** (`tuple(torch.Tensor)`, *opsional*, dikembalikan saat `output_hidden_states=True` dilewatkan atau saat `config.output_hidden_states=True`) -- Tuple dari `torch.Tensor` (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap tahap) dengan bentuk `(batch_size, sequence_length, hidden_size)`. Hidden-states (juga disebut feature maps) dari model pada output dari setiap tahap. - **attentions** (`tuple(torch.Tensor)`, *opsional*, dikembalikan ketika `output_attentions=True` dilewatkan atau ketika `config.output_attentions=True`) -- Tuple dari `torch.Tensor` (satu untuk setiap layer) dengan bentuk `(batch_size, num_heads, patch_size, sequence_length)`. Bobot perhatian setelah softmax perhatian, digunakan untuk menghitung rata-rata berbobot di kepala self-attention. Contoh: ```python >>> from transformers import AutoImageProcessor, Data2VecVisionForImageClassification >>> import torch >>> from datasets import load_dataset >>> dataset = load_dataset("huggingface/cats-image") >>> image = dataset["test"]["image"][0] >>> image_processor = AutoImageProcessor.from_pretrained("facebook/data2vec-vision-base") >>> model = Data2VecVisionForImageClassification.from_pretrained("facebook/data2vec-vision-base") >>> inputs = image_processor(image, return_tensors="pt") >>> with torch.no_grad(): ... logits = model(**inputs).logits >>> # model predicts one of the 1000 ImageNet classes >>> predicted_label = logits.argmax(-1).item() >>> print(model.config.id2label[predicted_label]) ... ``` ## Data2VecVisionForSemanticSegmentation[[transformers.Data2VecVisionForSemanticSegmentation]] #### transformers.Data2VecVisionForSemanticSegmentation[[transformers.Data2VecVisionForSemanticSegmentation]] ```python transformers.Data2VecVisionForSemanticSegmentation(config: Data2VecVisionConfig) ``` [Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/data2vec/modeling_data2vec_vision.py#L1058) **Parameter:** config ([Data2VecVisionConfig](/docs/transformers/v5.23.0/id/model_doc/data2vec#transformers.Data2VecVisionConfig)) : Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya. Lihat metode [from_pretrained()](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk memuat bobot model. Model Data2Vec Vision dengan kepala segmentasi semantik di atasnya, misalnya untuk ADE20K, CityScapes. Model ini mewarisi dari [PreTrainedModel](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel). Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka ini untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran input embeddings, memangkas heads, dll.) Model ini juga merupakan subclass dari [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#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[[transformers.Data2VecVisionForSemanticSegmentation.forward]] ```python forward(pixel_values: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, interpolate_pos_encoding: bool = False, return_dict: bool | None = None, **kwargs) ``` [Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/data2vec/modeling_data2vec_vision.py#L1110) **Parameter:** pixel_values (`torch.Tensor` dengan bentuk `(batch_size, num_channels, image_size, image_size)`, *opsional*) : Tensor yang sesuai dengan gambar input. Nilai piksel dapat diperoleh menggunakan [BeitImageProcessor](/docs/transformers/v5.23.0/id/model_doc/beit#transformers.BeitImageProcessor). Lihat [BeitImageProcessor.__call__()](/docs/transformers/v5.23.0/id/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) untuk detailnya (`processor_class` menggunakan [BeitImageProcessor](/docs/transformers/v5.23.0/id/model_doc/beit#transformers.BeitImageProcessor) untuk memproses gambar). labels (`torch.LongTensor` dengan bentuk `(batch_size, height, width)`, *opsional*) : Peta segmentasi semantik ground truth untuk menghitung loss. Indeks harus berada dalam `[0, ..., config.num_labels - 1]`. Jika `config.num_labels > 1`, loss klasifikasi dihitung (Cross-Entropy). output_attentions (`bool`, *opsional*) : Apakah akan mengembalikan tensor perhatian dari semua lapisan perhatian. Lihat `attentions` di bawah tensor yang dikembalikan untuk detail lebih lanjut. output_hidden_states (`bool`, *opsional*) : Apakah akan mengembalikan hidden states dari semua lapisan. Lihat `hidden_states` di bawah tensor yang dikembalikan untuk detail lebih lanjut. interpolate_pos_encoding (`bool`, *opsional*, defaultnya `False`) : Apakah akan menginterpolasi enkoding posisi yang telah dilatih sebelumnya. return_dict (`bool`, *opsional*) : Apakah akan mengembalikan [ModelOutput](/docs/transformers/v5.23.0/id/main_classes/output#transformers.utils.ModelOutput) alih-alih tuple biasa. **Mengembalikan:** [SemanticSegmenterOutput](/docs/transformers/v5.23.0/id/main_classes/output#transformers.modeling_outputs.SemanticSegmenterOutput) atau `tuple(torch.Tensor)` A [SemanticSegmenterOutput](/docs/transformers/v5.23.0/id/main_classes/output#transformers.modeling_outputs.SemanticSegmenterOutput) atau tuple dari `torch.Tensor` (jika `return_dict=False` dilewatkan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([Data2VecVisionConfig](/docs/transformers/v5.23.0/id/model_doc/data2vec#transformers.Data2VecVisionConfig)) dan input. Metode forward dari [Data2VecVisionForSemanticSegmentation](/docs/transformers/v5.23.0/id/model_doc/data2vec#transformers.Data2VecVisionForSemanticSegmentation) menimpa metode khusus `__call__`. Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance `Module` setelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam. - **loss** (`torch.Tensor` dengan bentuk `(1,)`, *opsional*, dikembalikan saat `labels` disediakan) -- Loss klasifikasi (atau regresi jika config.num_labels==1). - **logits** (`torch.Tensor` dengan bentuk `(batch_size, config.num_labels, logits_height, logits_width)`) -- Skor klasifikasi untuk setiap piksel. Logits yang dikembalikan tidak selalu memiliki ukuran yang sama dengan `pixel_values` yang diberikan sebagai input. Hal ini dilakukan untuk menghindari dua kali interpolasi dan kehilangan kualitas ketika pengguna perlu mengubah ukuran logits ke ukuran gambar asli sebagai pascapemrosesan. Anda harus selalu memeriksa bentuk logits Anda dan mengubah ukurannya sesuai kebutuhan. - **hidden_states** (`tuple(torch.Tensor)`, *opsional*, dikembalikan saat `output_hidden_states=True` dilewatkan atau saat `config.output_hidden_states=True`) -- Tuple dari `torch.Tensor` (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk `(batch_size, patch_size, hidden_size)`. Hidden-states model pada output setiap layer ditambah output embedding awal yang opsional. - **attentions** (`tuple(torch.Tensor)`, *opsional*, dikembalikan ketika `output_attentions=True` dilewatkan atau ketika `config.output_attentions=True`) -- Tuple dari `torch.Tensor` (satu untuk setiap layer) dengan bentuk `(batch_size, num_heads, patch_size, sequence_length)`. Bobot perhatian setelah softmax perhatian, digunakan untuk menghitung rata-rata berbobot di kepala self-attention. Contoh: ```python >>> from transformers import AutoImageProcessor, Data2VecVisionForSemanticSegmentation >>> 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("facebook/data2vec-vision-base") >>> model = Data2VecVisionForSemanticSegmentation.from_pretrained("facebook/data2vec-vision-base") >>> inputs = image_processor(images=image, return_tensors="pt") >>> outputs = model(**inputs) >>> # logits are of shape (batch_size, num_labels, height, width) >>> logits = outputs.logits ```