# BROS

## Ikhtisar

Model BROS diusulkan dalam [BROS: A Pre-trained Language Model Focusing on Text and Layout for Better Key Information Extraction from Documents](https://huggingface.co/papers/2108.04539) oleh Teakgyu Hong, Donghyun Kim, Mingi Ji, Wonseok Hwang, Daehyun Nam, Sungrae Park.

BROS merupakan singkatan dari *BERT Relying On Spatiality*. Ini adalah model Transformer yang hanya memiliki encoder, menerima urutan token dan bounding box-nya sebagai input, serta menghasilkan urutan hidden states. BROS mengkodekan informasi spasial relatif alih-alih menggunakan informasi spasial absolut.

Model ini dilatih sebelumnya dengan dua tujuan: tujuan pemodelan bahasa dengan token yang dimasker (TMLM) yang digunakan dalam BERT, dan tujuan pemodelan bahasa dengan area yang dimasker (AMLM) yang baru. Pada TMLM, token dimasker secara acak, dan model memprediksi token yang dimasker tersebut menggunakan informasi spasial dan token lain yang tidak dimasker. AMLM adalah versi 2D dari TMLM. AMLM secara acak memasker token teks dan memprediksinya dengan informasi yang sama seperti TMLM, tetapi AMLM memasker blok teks (area).

`BrosForTokenClassification` memiliki lapisan linear sederhana di atas BrosModel. Model ini memprediksi label untuk setiap token. `BrosSpadeEEForTokenClassification` memiliki `initial_token_classifier` dan `subsequent_token_classifier` di atas BrosModel. `initial_token_classifier` digunakan untuk memprediksi token pertama dari setiap entitas, sedangkan `subsequent_token_classifier` digunakan untuk memprediksi token berikutnya di dalam entitas. `BrosSpadeELForTokenClassification` memiliki `entity_linker` di atas BrosModel. `entity_linker` digunakan untuk memprediksi relasi antara dua entitas.

`BrosForTokenClassification` dan `BrosSpadeEEForTokenClassification` pada dasarnya melakukan pekerjaan yang sama. Namun, `BrosForTokenClassification` mengasumsikan token input telah diserialisasi dengan sempurna (yang merupakan tugas sangat menantang karena token tersebut berada dalam ruang 2D), sedangkan `BrosSpadeEEForTokenClassification` memberikan fleksibilitas lebih dalam menangani kesalahan serialisasi karena memprediksi token koneksi berikutnya dari satu token.

`BrosSpadeELForTokenClassification` menjalankan tugas intra-entity linking. Model ini memprediksi relasi dari satu token (dari satu entitas) ke token lain (dari entitas lain) jika kedua entitas tersebut berbagi relasi tertentu.

BROS mencapai hasil yang setara atau lebih baik pada benchmark Ekstraksi Informasi Kunci (KIE) seperti FUNSD, SROIE, CORD, dan SciTSR, tanpa bergantung pada fitur visual eksplisit.

Abstrak dari makalah tersebut adalah sebagai berikut:

*Ekstraksi informasi kunci (KIE) dari gambar dokumen memerlukan pemahaman tentang semantik kontekstual dan spasial teks dalam ruang dua dimensi (2D). Banyak studi terbaru mencoba menyelesaikan tugas ini dengan mengembangkan model bahasa pra-terlatih yang berfokus pada penggabungan fitur visual dari gambar dokumen dengan teks dan tata letaknya. Di sisi lain, makalah ini menangani masalah tersebut dengan kembali ke hal dasar: penggabungan teks dan tata letak yang efektif. Secara spesifik, kami mengusulkan model bahasa pra-terlatih bernama BROS (BERT Relying On Spatiality) yang mengkodekan posisi relatif teks dalam ruang 2D dan belajar dari dokumen tanpa label dengan strategi area-masking. Dengan skema pelatihan yang dioptimalkan ini untuk memahami teks dalam ruang 2D, BROS menunjukkan kinerja yang setara atau lebih baik dibandingkan metode sebelumnya pada empat benchmark KIE (FUNSD, SROIE*, CORD, dan SciTSR) tanpa bergantung pada fitur visual. Makalah ini juga mengungkap dua tantangan dunia nyata dalam tugas KIE—(1) meminimalkan kesalahan dari urutan teks yang salah dan (2) pembelajaran yang efisien dari contoh downstream yang lebih sedikit—dan mendemonstrasikan keunggulan BROS dibandingkan metode sebelumnya.*

Model ini disumbangkan oleh [jinho8345](https://huggingface.co/jinho8345). Kode aslinya dapat ditemukan [di sini](https://github.com/clovaai/bros).

## Tips dan contoh penggunaan

- [forward()](/docs/transformers/v5.24.0/id/model_doc/bros#transformers.BrosModel.forward) membutuhkan `input_ids` dan `bbox` (kotak pembatas). Setiap kotak pembatas harus dalam format (x0, y0, x1, y1) (sudut kiri atas, sudut kanan bawah). Perolehan kotak pembatas bergantung pada sistem OCR eksternal. Koordinat `x` harus dinormalisasi dengan lebar gambar dokumen, dan koordinat `y` harus dinormalisasi dengan tinggi gambar dokumen.

```python
def expand_and_normalize_bbox(bboxes, doc_width, doc_height):
    # here, bboxes are numpy array

    # Normalize bbox -> 0 ~ 1
    bboxes[:, [0, 2]] = bboxes[:, [0, 2]] / width
    bboxes[:, [1, 3]] = bboxes[:, [1, 3]] / height
```

- [`~transformers.BrosForTokenClassification.forward`, `~transformers.BrosSpadeEEForTokenClassification.forward`, `~transformers.BrosSpadeEEForTokenClassification.forward`] membutuhkan tidak hanya `input_ids` dan `bbox` tetapi juga `box_first_token_mask` untuk perhitungan loss. Ini adalah mask untuk menyaring token non-pertama dari setiap box. Anda dapat memperoleh mask ini dengan menyimpan indeks token awal dari bounding boxes saat membuat `input_ids` dari kata-kata. Anda dapat membuat `box_first_token_mask` dengan kode berikut,

```python
def make_box_first_token_mask(bboxes, words, tokenizer, max_seq_length=512):

    box_first_token_mask = np.zeros(max_seq_length, dtype=np.bool_)

    # encode(tokenize) each word from words (list[str])
    input_ids_list: list[list[int]] = [tokenizer.encode(e, add_special_tokens=False) for e in words]

    # get the length of each box
    tokens_length_list: list[int] = [len(l) for l in input_ids_list]

    box_end_token_indices = np.array(list(itertools.accumulate(tokens_length_list)))
    box_start_token_indices = box_end_token_indices - np.array(tokens_length_list)

    # filter out the indices that are out of max_seq_length
    box_end_token_indices = box_end_token_indices[box_end_token_indices < max_seq_length - 1]
    if len(box_start_token_indices) > len(box_end_token_indices):
        box_start_token_indices = box_start_token_indices[: len(box_end_token_indices)]

    # set box_start_token_indices to True
    box_first_token_mask[box_start_token_indices] = True

    return box_first_token_mask

```

## Sumber daya

- Skrip demo dapat ditemukan [di sini](https://github.com/clovaai/bros).

## BrosConfig[[transformers.BrosConfig]]

#### transformers.BrosConfig[[transformers.BrosConfig]]

```python
transformers.BrosConfig(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 = 0, dim_bbox: int = 8, bbox_scale: float = 100.0, n_relations: int = 1, classifier_dropout_prob: float | int = 0.1, is_decoder: bool = False, add_cross_attention: bool = False)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.24.0/src/transformers/models/bros/configuration_bros.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 `0`) : ID token yang digunakan untuk padding dalam kosakata.

dim_bbox (`int`, *opsional*, defaultnya 8) : Dimensi dari koordinat kotak pembatas. (x0, y1, x1, y0, x1, y1, x0, y1)

bbox_scale (`float`, *opsional*, default 100.0) : Faktor skala dari koordinat kotak pembatas.

n_relations (`int`, *opsional*, default 1) : Jumlah relasi untuk SpadeEE (ekstraksi entitas), SpadeEL (penautan entitas) head.

classifier_dropout_prob (`Union[float, int]`, *opsional*, defaultnya `0.1`) : 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.

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi BrosModel. Kelas ini digunakan untuk membuat instans model Bros sesuai dengan argumen yang ditentukan, sehingga mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi [jinho8345/bros-base-uncased](https://huggingface.co/jinho8345/bros-base-uncased)

Objek konfigurasi mewarisi dari [PreTrainedConfig](/docs/transformers/v5.24.0/id/main_classes/configuration#transformers.PreTrainedConfig) dan dapat digunakan untuk mengontrol keluaran model. Baca dokumentasi dari [PreTrainedConfig](/docs/transformers/v5.24.0/id/main_classes/configuration#transformers.PreTrainedConfig) untuk informasi lebih lanjut.

Contoh:

```python
>>> from transformers import BrosConfig, BrosModel

>>> # Initializing a BROS jinho8345/bros-base-uncased style configuration
>>> configuration = BrosConfig()

>>> # Initializing a model from the jinho8345/bros-base-uncased style configuration
>>> model = BrosModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config
```

## BrosProcessor[[transformers.BrosProcessor]]

#### transformers.BrosProcessor[[transformers.BrosProcessor]]

```python
transformers.BrosProcessor(tokenizer = None, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.24.0/src/transformers/models/bros/processing_bros.py#L24)

**Parameter:**

tokenizer (`BertTokenizer`) : Tokenizer adalah input yang wajib.

Membangun BrosProcessor yang membungkus tokenizer menjadi satu prosesor.

[BrosProcessor](/docs/transformers/v5.24.0/id/model_doc/bros#transformers.BrosProcessor) menyediakan semua fungsionalitas dari [BertTokenizer](/docs/transformers/v5.24.0/id/model_doc/lxmert#transformers.BertTokenizer). Lihat [~BertTokenizer](/docs/transformers/v5.24.0/id/model_doc/lxmert#transformers.BertTokenizer) untuk informasi lebih lanjut.

#### __call__[[transformers.BrosProcessor.__call__]]

```python
__call__(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = None, text: str | list[str] | list[list[str]] | None = None, videos: typing.Union[list['PIL.Image.Image'], numpy.ndarray, ForwardRef('torch.Tensor'), list[numpy.ndarray], list['torch.Tensor'], list[list['PIL.Image.Image']], list[list[numpy.ndarray]], list[list['torch.Tensor']], transformers.video_utils.URL, list[transformers.video_utils.URL], list[list[transformers.video_utils.URL]], transformers.video_utils.Path, list[transformers.video_utils.Path], list[list[transformers.video_utils.Path]], NoneType] = None, audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor'], NoneType] = None, **kwargs: *<class 'transformers.processing_utils.ProcessingKwargs'>)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.24.0/src/transformers/processing_utils.py#L671)

**Parameter:**

images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`, *opsional*) : Gambar untuk dipreprocess. Mengharapkan satu gambar atau batch gambar dengan nilai piksel berkisar dari 0 hingga 255. Jika memasukkan gambar dengan nilai piksel antara 0 dan 1, atur `do_rescale=False`.

text (`Union[str, list[str], list[list[str]]]`, *opsional*) : Urutan atau batch dari urutan yang akan dienkod. Setiap urutan dapat berupa string atau daftar string (string yang sudah dipretokenisasi). Jika Anda memasukkan input yang sudah dipretokenisasi, setel `is_split_into_words=True` untuk menghindari ambiguitas dengan input yang di-batch.

videos (`Union[list[PIL.Image.Image], numpy.ndarray, torch.Tensor, list[numpy.ndarray], list[torch.Tensor], list[list[PIL.Image.Image]], list[list[numpy.ndarray]], list[list[torch.Tensor]], ~video_utils.URL, list[~video_utils.URL], list[list[~video_utils.URL]], ~video_utils.Path, list[~video_utils.Path], list[list[~video_utils.Path]]]`, *opsional*) : Video yang akan dipreprocess. Mengharapkan satu video atau batch video dengan nilai piksel berkisar dari 0 hingga 255. Jika memasukkan video dengan nilai piksel antara 0 dan 1, atur `do_rescale=False`.

audio (`Union[numpy.ndarray, torch.Tensor, collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence[torch.Tensor]]`, *opsional*) : Audio atau batch audio yang akan disiapkan. Setiap audio dapat berupa array NumPy atau tensor PyTorch. Jika berupa array NumPy/tensor PyTorch, setiap audio harus memiliki bentuk (C, T), di mana C adalah jumlah channel, dan T adalah panjang sampel audio.

return_mm_token_type_ids (`bool`, *kwargs*) : Apakah akan mengembalikan id tipe token multimodal yang menunjukkan posisi token placeholder multimodal.

return_text_replacement_offsets (`bool`, *kwargs*) : Apakah akan mengembalikan offset karakter untuk setiap placeholder multimodal dan pengantinya.

return_tensors (`str` atau [TensorType](/docs/transformers/v5.24.0/id/internal/file_utils#transformers.TensorType), *opsional*) : Jika diatur, akan mengembalikan tensor dari framework tertentu. Nilai yang dapat diterima adalah:  - `'pt'`: Mengembalikan objek `torch.Tensor` PyTorch. - `'np'`: Mengembalikan objek `np.ndarray` NumPy.

- ****kwargs** ([ProcessingKwargs](/docs/transformers/v5.24.0/id/main_classes/processors#transformers.ProcessingKwargs), *opsional*) : Opsi pemrosesan tambahan untuk setiap modalitas (teks, gambar, video, audio). Parameter spesifik model tercantum di atas; lihat kelas TypedDict untuk daftar lengkap argumen yang didukung.

## BrosModel[[transformers.BrosModel]]

#### transformers.BrosModel[[transformers.BrosModel]]

```python
transformers.BrosModel(config: BrosConfig, add_pooling_layer = True)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.24.0/src/transformers/models/bros/modeling_bros.py#L499)

**Parameter:**

config ([BrosConfig](/docs/transformers/v5.24.0/id/model_doc/bros#transformers.BrosConfig)) : 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.24.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 Bros polos yang menghasilkan hidden-states mentah tanpa head spesifik di atasnya.

Model ini mewarisi dari [PreTrainedModel](/docs/transformers/v5.24.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.BrosModel.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, bbox: 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, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.24.0/src/transformers/models/bros/modeling_bros.py#L522)

**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.24.0/id/model_doc/auto#transformers.AutoTokenizer). Lihat [PreTrainedTokenizer.encode()](/docs/transformers/v5.24.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) dan [PreTrainedTokenizer.__call__()](/docs/transformers/v5.24.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) untuk detailnya. [Apa itu input IDs?](../glossary#input-ids)

bbox (`'torch.Tensor'` dengan bentuk '(batch_size, num_boxes, 4)') : Koordinat bounding box untuk setiap token dalam urutan input. Setiap bounding box adalah daftar dari empat nilai (x1, y1, x2, y2), di mana (x1, y1) adalah sudut kiri atas, dan (x2, y2) adalah sudut kanan bawah dari bounding box.

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

**Mengembalikan:** [BaseModelOutputWithPoolingAndCrossAttentions](/docs/transformers/v5.24.0/id/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions) atau `tuple(torch.Tensor)`

Sebuah [BaseModelOutputWithPoolingAndCrossAttentions](/docs/transformers/v5.24.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 ([BrosConfig](/docs/transformers/v5.24.0/id/model_doc/bros#transformers.BrosConfig)) dan input.

Metode forward dari [BrosModel](/docs/transformers/v5.24.0/id/model_doc/bros#transformers.BrosModel) 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.
- **cache** (`Cache`, *opsional*, dikembalikan saat `use_cache=True` dilewatkan atau saat `config.use_cache=True`) -- Ini adalah instance [Cache](/docs/transformers/v5.24.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 `cache`) untuk mempercepat decoding berurutan.

Contoh:

```python
>>> import torch
>>> from transformers import BrosProcessor, BrosModel

>>> processor = BrosProcessor.from_pretrained("jinho8345/bros-base-uncased")

>>> model = BrosModel.from_pretrained("jinho8345/bros-base-uncased")

>>> encoding = processor("Hello, my dog is cute", add_special_tokens=False, return_tensors="pt")
>>> bbox = torch.tensor([[[0, 0, 1, 1]]]).repeat(1, encoding["input_ids"].shape[-1], 1)
>>> encoding["bbox"] = bbox

>>> outputs = model(**encoding)
>>> last_hidden_states = outputs.last_hidden_state
```

## BrosForTokenClassification[[transformers.BrosForTokenClassification]]

#### transformers.BrosForTokenClassification[[transformers.BrosForTokenClassification]]

```python
transformers.BrosForTokenClassification(config: BrosConfig)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.24.0/src/transformers/models/bros/modeling_bros.py#L619)

**Parameter:**

config ([BrosConfig](/docs/transformers/v5.24.0/id/model_doc/bros#transformers.BrosConfig)) : 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.24.0/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk memuat bobot model.

Transformers Bros 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.24.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.BrosForTokenClassification.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, bbox: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, bbox_first_token_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, labels: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.24.0/src/transformers/models/bros/modeling_bros.py#L635)

**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.24.0/id/model_doc/auto#transformers.AutoTokenizer). Lihat [PreTrainedTokenizer.encode()](/docs/transformers/v5.24.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) dan [PreTrainedTokenizer.__call__()](/docs/transformers/v5.24.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) untuk detailnya. [Apa itu input IDs?](../glossary#input-ids)

bbox (`'torch.Tensor'` dengan bentuk '(batch_size, num_boxes, 4)') : Koordinat bounding box untuk setiap token dalam urutan input. Setiap bounding box adalah daftar dari empat nilai (x1, y1, x2, y2), di mana (x1, y1) adalah sudut kiri atas, dan (x2, y2) adalah sudut kanan bawah dari bounding box.

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)

bbox_first_token_mask (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Mask untuk menunjukkan token pertama dari setiap bounding box. Nilai mask dipilih dari `[0, 1]`:  - 1 untuk token yang **tidak di-mask**, - 0 untuk token yang **di-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.

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.24.0/id/main_classes/output#transformers.modeling_outputs.TokenClassifierOutput) atau `tuple(torch.Tensor)`

[TokenClassifierOutput](/docs/transformers/v5.24.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 ([BrosConfig](/docs/transformers/v5.24.0/id/model_doc/bros#transformers.BrosConfig)) dan input.

Metode forward dari [BrosForTokenClassification](/docs/transformers/v5.24.0/id/model_doc/bros#transformers.BrosForTokenClassification) 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
>>> import torch
>>> from transformers import BrosProcessor, BrosForTokenClassification

>>> processor = BrosProcessor.from_pretrained("jinho8345/bros-base-uncased")

>>> model = BrosForTokenClassification.from_pretrained("jinho8345/bros-base-uncased")

>>> encoding = processor("Hello, my dog is cute", add_special_tokens=False, return_tensors="pt")
>>> bbox = torch.tensor([[[0, 0, 1, 1]]]).repeat(1, encoding["input_ids"].shape[-1], 1)
>>> encoding["bbox"] = bbox

>>> outputs = model(**encoding)
```

## BrosSpadeEEForTokenClassification[[transformers.BrosSpadeEEForTokenClassification]]

#### transformers.BrosSpadeEEForTokenClassification[[transformers.BrosSpadeEEForTokenClassification]]

```python
transformers.BrosSpadeEEForTokenClassification(config: BrosConfig)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.24.0/src/transformers/models/bros/modeling_bros.py#L719)

**Parameter:**

config ([BrosConfig](/docs/transformers/v5.24.0/id/model_doc/bros#transformers.BrosConfig)) : 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.24.0/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk memuat bobot model.

Model Bros dengan kepala klasifikasi token di atasnya (initial_token_layers dan subsequent_token_layer di atas keluaran hidden-states), misalnya untuk tugas Named-Entity-Recognition (NER). initial_token_classifier digunakan untuk memprediksi token pertama dari setiap entitas, dan subsequent_token_classifier digunakan untuk memprediksi token berikutnya di dalam entitas. Dibandingkan dengan BrosForTokenClassification, model ini lebih tahan terhadap kesalahan serialisasi karena memprediksi token berikutnya dari satu token.

Model ini mewarisi dari [PreTrainedModel](/docs/transformers/v5.24.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.BrosSpadeEEForTokenClassification.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, bbox: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, bbox_first_token_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, initial_token_labels: typing.Optional[torch.Tensor] = None, subsequent_token_labels: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.24.0/src/transformers/models/bros/modeling_bros.py#L747)

**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.24.0/id/model_doc/auto#transformers.AutoTokenizer). Lihat [PreTrainedTokenizer.encode()](/docs/transformers/v5.24.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) dan [PreTrainedTokenizer.__call__()](/docs/transformers/v5.24.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) untuk detailnya. [Apa itu input IDs?](../glossary#input-ids)

bbox (`'torch.Tensor'` dengan bentuk '(batch_size, num_boxes, 4)') : Koordinat bounding box untuk setiap token dalam urutan input. Setiap bounding box adalah daftar dari empat nilai (x1, y1, x2, y2), di mana (x1, y1) adalah sudut kiri atas, dan (x2, y2) adalah sudut kanan bawah dari bounding box.

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)

bbox_first_token_mask (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Mask untuk menunjukkan token pertama dari setiap bounding box. Nilai mask dipilih dari `[0, 1]`:  - 1 untuk token yang **tidak di-mask**, - 0 untuk token yang **di-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.

initial_token_labels (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Label untuk klasifikasi token awal.

subsequent_token_labels (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Label untuk klasifikasi token berikutnya.

**Mengembalikan:** `BrosSpadeOutput` atau `tuple(torch.Tensor)`

Sebuah `BrosSpadeOutput` atau tuple dari `torch.Tensor` (jika `return_dict=False` diteruskan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([BrosConfig](/docs/transformers/v5.24.0/id/model_doc/bros#transformers.BrosConfig)) dan input.

Metode forward dari [BrosSpadeEEForTokenClassification](/docs/transformers/v5.24.0/id/model_doc/bros#transformers.BrosSpadeEEForTokenClassification) 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.
- **initial_token_logits** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, config.num_labels)`) -- Skor klasifikasi untuk token awal entitas (sebelum SoftMax).
- **subsequent_token_logits** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, sequence_length+1)`) -- Skor klasifikasi untuk token urutan entitas (sebelum SoftMax).
- **hidden_states** (`tuple[torch.Tensor]`, *opsional*, dikembalikan ketika `output_hidden_states=True` dilewatkan atau ketika `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
>>> import torch
>>> from transformers import BrosProcessor, BrosSpadeEEForTokenClassification

>>> processor = BrosProcessor.from_pretrained("jinho8345/bros-base-uncased")

>>> model = BrosSpadeEEForTokenClassification.from_pretrained("jinho8345/bros-base-uncased")

>>> encoding = processor("Hello, my dog is cute", add_special_tokens=False, return_tensors="pt")
>>> bbox = torch.tensor([[[0, 0, 1, 1]]]).repeat(1, encoding["input_ids"].shape[-1], 1)
>>> encoding["bbox"] = bbox

>>> outputs = model(**encoding)
```

## BrosSpadeELForTokenClassification[[transformers.BrosSpadeELForTokenClassification]]

#### transformers.BrosSpadeELForTokenClassification[[transformers.BrosSpadeELForTokenClassification]]

```python
transformers.BrosSpadeELForTokenClassification(config: BrosConfig)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.24.0/src/transformers/models/bros/modeling_bros.py#L862)

**Parameter:**

config ([BrosConfig](/docs/transformers/v5.24.0/id/model_doc/bros#transformers.BrosConfig)) : 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.24.0/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk memuat bobot model.

Model Bros dengan kepala klasifikasi token di atasnya (lapisan entity_linker di atas keluaran hidden-states), misalnya untuk Entity-Linking. entity_linker digunakan untuk memprediksi tautan intra-entitas (satu entitas ke entitas lain).

Model ini mewarisi dari [PreTrainedModel](/docs/transformers/v5.24.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.BrosSpadeELForTokenClassification.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, bbox: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, bbox_first_token_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, labels: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.24.0/src/transformers/models/bros/modeling_bros.py#L879)

**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.24.0/id/model_doc/auto#transformers.AutoTokenizer). Lihat [PreTrainedTokenizer.encode()](/docs/transformers/v5.24.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) dan [PreTrainedTokenizer.__call__()](/docs/transformers/v5.24.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) untuk detailnya. [Apa itu input IDs?](../glossary#input-ids)

bbox (`'torch.Tensor'` dengan bentuk '(batch_size, num_boxes, 4)') : Koordinat bounding box untuk setiap token dalam urutan input. Setiap bounding box adalah daftar dari empat nilai (x1, y1, x2, y2), di mana (x1, y1) adalah sudut kiri atas, dan (x2, y2) adalah sudut kanan bawah dari bounding box.

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)

bbox_first_token_mask (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Mask untuk menunjukkan token pertama dari setiap bounding box. Nilai mask dipilih dari `[0, 1]`:  - 1 untuk token yang **tidak di-mask**, - 0 untuk token yang **di-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.

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.24.0/id/main_classes/output#transformers.modeling_outputs.TokenClassifierOutput) atau `tuple(torch.Tensor)`

[TokenClassifierOutput](/docs/transformers/v5.24.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 ([BrosConfig](/docs/transformers/v5.24.0/id/model_doc/bros#transformers.BrosConfig)) dan input.

Metode forward dari [BrosSpadeELForTokenClassification](/docs/transformers/v5.24.0/id/model_doc/bros#transformers.BrosSpadeELForTokenClassification) 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
>>> import torch
>>> from transformers import BrosProcessor, BrosSpadeELForTokenClassification

>>> processor = BrosProcessor.from_pretrained("jinho8345/bros-base-uncased")

>>> model = BrosSpadeELForTokenClassification.from_pretrained("jinho8345/bros-base-uncased")

>>> encoding = processor("Hello, my dog is cute", add_special_tokens=False, return_tensors="pt")
>>> bbox = torch.tensor([[[0, 0, 1, 1]]]).repeat(1, encoding["input_ids"].shape[-1], 1)
>>> encoding["bbox"] = bbox

>>> outputs = model(**encoding)
```

