# LUKE

## Tổng quan

Mô hình LUKE được đề xuất trong [LUKE: Deep Contextualized Entity Representations with Entity-aware Self-attention](https://huggingface.co/papers/2010.01057) bởi Ikuya Yamada, Akari Asai, Hiroyuki Shindo, Hideaki Takeda và Yuji Matsumoto. Nó dựa trên RoBERTa và bổ sung các embedding thực thể cùng với cơ chế self-attention nhận thức thực thể, giúp cải thiện hiệu suất trên nhiều tác vụ downstream khác nhau liên quan đến suy luận về thực thể, chẳng hạn như nhận diện thực thể có tên, trả lời câu hỏi dạng trích xuất và cloze, phân loại kiểu thực thể và phân loại quan hệ.

Tóm tắt từ bài báo như sau:

*Biểu diễn thực thể hữu ích trong các tác vụ ngôn ngữ tự nhiên liên quan đến thực thể. Trong bài báo này, chúng tôi đề xuất các biểu diễn ngữ cảnh hóa trước cho từ và thực thể dựa trên transformer hai chiều. Mô hình được đề xuất coi từ và thực thể trong một văn bản cho trước là các token độc lập, và đưa ra các biểu diễn ngữ cảnh hóa của chúng. Mô hình của chúng tôi được huấn luyện bằng một tác vụ tiền huấn luyện mới dựa trên mô hình ngôn ngữ bị che của BERT. Tác vụ này bao gồm việc dự đoán các từ và thực thể bị che ngẫu nhiên trong một tập dữ liệu lớn có chú thích thực thể được thu thập từ Wikipedia. Chúng tôi cũng đề xuất một cơ chế tự chú ý nhận thức thực thể, là sự mở rộng của cơ chế tự chú ý của transformer, và xem xét các loại token (từ hoặc thực thể) khi tính toán điểm chú ý. Mô hình được đề xuất đạt hiệu suất thực nghiệm ấn tượng trên một loạt các tác vụ liên quan đến thực thể. Cụ thể, nó đạt được kết quả tiên tiến trên năm tập dữ liệu nổi tiếng: Open Entity (phân loại thực thể), TACRED (phân loại quan hệ), CoNLL-2003 (nhận diện thực thể có tên), ReCoRD (trả lời câu hỏi dạng cloze), và SQuAD 1.1 (trả lời câu hỏi trích xuất).*

Mô hình này được đóng góp bởi [ikuyamada](https://huggingface.co/ikuyamada) và [nielsr](https://huggingface.co/nielsr). Mã gốc có thể được tìm thấy [tại đây](https://github.com/studio-ousia/luke).

## Mẹo sử dụng

- Cài đặt này giống với [RobertaModel](/docs/transformers/v5.23.0/vi/model_doc/roberta#transformers.RobertaModel) nhưng có thêm các embedding thực thể cũng như cơ chế self-attention nhận thức thực thể, giúp cải thiện hiệu suất trên các tác vụ liên quan đến suy luận về thực thể.
- LUKE coi các thực thể là các token đầu vào; do đó, nó nhận `entity_ids`, `entity_attention_mask`, `entity_token_type_ids` và `entity_position_ids` làm đầu vào bổ sung. Bạn có thể lấy được chúng bằng cách sử dụng [LukeTokenizer](/docs/transformers/v5.23.0/vi/model_doc/luke#transformers.LukeTokenizer).
- [LukeTokenizer](/docs/transformers/v5.23.0/vi/model_doc/luke#transformers.LukeTokenizer) nhận `entities` và `entity_spans` (vị trí bắt đầu và kết thúc dựa trên ký tự của các entity trong văn bản đầu vào) như các đầu vào bổ sung. `entities` thường bao gồm các entity [MASK] hoặc entity Wikipedia. Mô tả ngắn gọn khi nhập các entity này như sau:

  - *Đưa thực thể [MASK] vào để tính toán biểu diễn thực thể*: Thực thể [MASK] được dùng để che các thực thể cần dự đoán trong quá trình tiền huấn luyện. Khi LUKE nhận được thực thể [MASK], nó sẽ cố gắng dự đoán thực thể gốc bằng cách thu thập thông tin về thực thể đó từ văn bản đầu vào. Do đó, thực thể [MASK] có thể được dùng để giải quyết các tác vụ hạ nguồn cần thông tin về thực thể trong văn bản, chẳng hạn như phân loại kiểu thực thể, phân loại quan hệ và nhận diện thực thể có tên.
  - *Đưa thực thể Wikipedia vào để tính toán các biểu diễn token được tăng cường bằng tri thức*: LUKE học được thông tin (hoặc tri thức) phong phú về các thực thể Wikipedia trong quá trình tiền huấn luyện và lưu trữ thông tin đó trong embedding thực thể của nó. Bằng cách sử dụng các thực thể Wikipedia làm token đầu vào, LUKE tạo ra các biểu diễn token được làm giàu bởi thông tin lưu trữ trong embedding của các thực thể này. Điều này đặc biệt hiệu quả cho các tác vụ đòi hỏi tri thức thực tế, chẳng hạn như trả lời câu hỏi.

- Có ba mô hình đầu cho trường hợp sử dụng trước đó:

  - [LukeForEntityClassification](/docs/transformers/v5.23.0/vi/model_doc/luke#transformers.LukeForEntityClassification), dành cho các tác vụ phân loại một thực thể duy nhất trong văn bản đầu vào, chẳng hạn như phân loại kiểu thực thể, ví dụ như [bộ dữ liệu Open Entity](https://www.cs.utexas.edu/~eunsol/html_pages/open_entity.html). Mô hình này đặt một đầu tuyến tính (linear head) phía trên biểu diễn thực thể đầu ra.
  - [LukeForEntityPairClassification](/docs/transformers/v5.23.0/vi/model_doc/luke#transformers.LukeForEntityPairClassification), dành cho các tác vụ phân loại mối quan hệ giữa hai thực thể, chẳng hạn như phân loại quan hệ, ví dụ như [dataset TACRED](https://nlp.stanford.edu/projects/tacred/). Mô hình này đặt một đầu tuyến tính (linear head) trên biểu diễn đầu ra đã nối (concatenated) của cặp thực thể được cho.
  - [LukeForEntitySpanClassification](/docs/transformers/v5.23.0/vi/model_doc/luke#transformers.LukeForEntitySpanClassification), dành cho các tác vụ phân loại chuỗi các entity span, chẳng hạn như nhận thực thể có tên (NER). Mô hình này đặt một đầu tuyến tính (linear head) phía trên các biểu diễn entity đầu ra. Bạn có thể xử lý NER bằng mô hình này bằng cách đưa tất cả các entity span có thể có trong văn bản vào mô hình.

  [LukeTokenizer](/docs/transformers/v5.23.0/vi/model_doc/luke#transformers.LukeTokenizer) có tham số `task`, cho phép bạn dễ dàng tạo đầu vào cho các mô hình head bằng cách chỉ định `task="entity_classification"`, `task="entity_pair_classification"` hoặc `task="entity_span_classification"`. Vui lòng tham khảo mã ví dụ của từng mô hình head.

Ví dụ sử dụng:

```python
from transformers import LukeForEntityPairClassification, LukeModel, LukeTokenizer

model = LukeModel.from_pretrained("studio-ousia/luke-base", device_map="auto")
tokenizer = LukeTokenizer.from_pretrained("studio-ousia/luke-base")
# Example 1: Computing the contextualized entity representation corresponding to the entity mention "Beyoncé"

text = "Beyoncé lives in Los Angeles."
entity_spans = [(0, 7)]  # character-based entity span corresponding to "Beyoncé"
inputs = tokenizer(text, entity_spans=entity_spans, add_prefix_space=True, return_tensors="pt").to(model.device)
outputs = model(**inputs)
word_last_hidden_state = outputs.last_hidden_state
entity_last_hidden_state = outputs.entity_last_hidden_state
# Example 2: Inputting Wikipedia entities to obtain enriched contextualized representations

entities = [
    "Beyoncé",
    "Los Angeles",
]  # Wikipedia entity titles corresponding to the entity mentions "Beyoncé" and "Los Angeles"
entity_spans = [(0, 7), (17, 28)]  # character-based entity spans corresponding to "Beyoncé" and "Los Angeles"
inputs = tokenizer(text, entities=entities, entity_spans=entity_spans, add_prefix_space=True, return_tensors="pt").to(model.device)
outputs = model(**inputs)
word_last_hidden_state = outputs.last_hidden_state
entity_last_hidden_state = outputs.entity_last_hidden_state
# Example 3: Classifying the relationship between two entities using LukeForEntityPairClassification head model

model = LukeForEntityPairClassification.from_pretrained("studio-ousia/luke-large-finetuned-tacred", device_map="auto")
tokenizer = LukeTokenizer.from_pretrained("studio-ousia/luke-large-finetuned-tacred")
entity_spans = [(0, 7), (17, 28)]  # character-based entity spans corresponding to "Beyoncé" and "Los Angeles"
inputs = tokenizer(text, entity_spans=entity_spans, return_tensors="pt").to(model.device)
outputs = model(**inputs)
logits = outputs.logits
predicted_class_idx = int(logits[0].argmax())
print("Predicted class:", model.config.id2label[predicted_class_idx])
```

## Tài nguyên

- [Một notebook demo về cách tinh chỉnh [LukeForEntityPairClassification](/docs/transformers/v5.23.0/vi/model_doc/luke#transformers.LukeForEntityPairClassification) cho phân loại quan hệ](https://github.com/NielsRogge/Transformers-Tutorials/tree/master/LUKE)
- [Các notebook minh họa cách tái tạo các kết quả được báo cáo trong bài báo với việc triển khai LUKE của HuggingFace](https://github.com/studio-ousia/luke/tree/master/notebooks)
- [Hướng dẫn cho tác vụ phân loại văn bản](../tasks/sequence_classification)
- [Hướng dẫn cho tác vụ phân loại token](../tasks/token_classification)
- [Hướng dẫn nhiệm vụ trả lời câu hỏi](../tasks/question_answering)
- [Hướng dẫn cho tác vụ mô hình hóa ngôn ngữ có mặt nạ](../tasks/masked_language_modeling)
- [Hướng dẫn cho tác vụ chọn nhiều đáp án](../tasks/multiple_choice)

## LukeConfig[[transformers.LukeConfig]]

#### transformers.LukeConfig[[transformers.LukeConfig]]

```python
transformers.LukeConfig(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 = 50267, entity_vocab_size: int = 500000, hidden_size: int = 768, entity_emb_size: int = 256, 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, use_entity_aware_attention: bool = True, classifier_dropout: float | int | None = None, pad_token_id: int | None = 1, bos_token_id: int | None = 0, eos_token_id: int | list[int] | None = 2, tie_word_embeddings: bool = True)
```

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/luke/configuration_luke.py#L24)

**Tham số:**

vocab_size (`int`, *tùy chọn*, mặc định là `50267`) : Kích thước từ vựng của mô hình. Xác định số lượng token khác nhau có thể được biểu diễn bởi `input_ids`.

entity_vocab_size (`int`, *tuỳ chọn*, mặc định là 500000) : Kích thước từ vựng thực thể của mô hình LUKE. Xác định số lượng thực thể khác nhau có thể được biểu diễn bởi `entity_ids` được truyền khi gọi [LukeModel](/docs/transformers/v5.23.0/vi/model_doc/luke#transformers.LukeModel).

hidden_size (`int`, *optional*, mặc định là `768`) : Kích thước của các biểu diễn ẩn.

entity_emb_size (`int`, *tuỳ chọn*, mặc định là 256) : Số chiều của embedding thực thể.

num_hidden_layers (`int`, *tuỳ chọn*, mặc định là `12`) : Số lượng lớp ẩn trong bộ giải mã Transformer.

num_attention_heads (`int`, *tùy chọn*, mặc định là `12`) : Số lượng đầu chú ý cho mỗi lớp chú ý trong bộ giải mã Transformer.

intermediate_size (`int`, *tuỳ chọn*, mặc định là `3072`) : Kích thước của các biểu diễn MLP.

hidden_act (`str`, *tùy chọn*, mặc định là `gelu`) : Hàm kích hoạt phi tuyến (hàm hoặc chuỗi) trong bộ giải mã. Ví dụ, `"gelu"`, `"relu"`, `"silu"`, v.v.

hidden_dropout_prob (`Union[float, int]`, *tùy chọn*, mặc định là `0.1`) : Xác suất dropout cho tất cả các lớp fully connected trong embeddings, encoder và pooler.

attention_probs_dropout_prob (`Union[float, int]`, *tùy chọn*, mặc định là `0.1`) : Tỷ lệ dropout cho các xác suất chú ý.

max_position_embeddings (`int`, *tuỳ chọn*, mặc định là `512`) : Độ dài chuỗi tối đa mà mô hình này có thể được sử dụng.

type_vocab_size (`int`, *tùy chọn*, mặc định là `2`) : Kích thước từ vựng của `token_type_ids`.

initializer_range (`float`, *optional*, mặc định là `0.02`) : Độ lệch chuẩn của truncated_normal_initializer để khởi tạo tất cả các ma trận trọng số.

layer_norm_eps (`float`, *tuỳ chọn*, mặc định là `1e-12`) : Epsilon được sử dụng bởi các lớp chuẩn hóa lớp (layer normalization).

use_entity_aware_attention (`bool`, *tuỳ chọn*, mặc định là `True`) : Xác định xem mô hình có nên sử dụng cơ chế tự chú ý nhận thực thể (entity-aware self-attention) được đề xuất trong [LUKE: Deep Contextualized Entity Representations with Entity-aware Self-attention (Yamada et al.)](https://huggingface.co/papers/2010.01057) hay không.

classifier_dropout (`Union[float, int]`, *tùy chọn*) : Tỷ lệ dropout cho bộ phân loại.

pad_token_id (`int`, *tuỳ chọn*, mặc định là `1`) : Id của token được sử dụng để đệm (padding) trong từ vựng.

bos_token_id (`int`, *tuỳ chọn*, mặc định là `0`) : Id của token được dùng cho đầu luồng (beginning-of-stream) trong từ vựng.

eos_token_id (`Union[int, list[int]]`, *tùy chọn*, mặc định là `2`) : Id của token được sử dụng cho end-of-stream trong bảng từ vựng.

tie_word_embeddings (`bool`, *tùy chọn*, mặc định là `True`) : Có nên gắn kết các nhúng trọng số theo ánh xạ `tied_weights_keys` của mô hình hay không.

Đây là lớp cấu hình để lưu trữ cấu hình của một LukeModel. Nó được sử dụng để khởi tạo một mô hình Luke theo các đối số được chỉ định, xác định kiến trúc mô hình. Khởi tạo một cấu hình với các giá trị mặc định sẽ tạo ra một cấu hình tương tự như cấu hình của [studio-ousia/luke-base](https://huggingface.co/studio-ousia/luke-base)

Các đối tượng cấu hình kế thừa từ [PreTrainedConfig](/docs/transformers/v5.23.0/vi/main_classes/configuration#transformers.PreTrainedConfig) và có thể được sử dụng để kiểm soát đầu ra của mô hình. Đọc tài liệu từ [PreTrainedConfig](/docs/transformers/v5.23.0/vi/main_classes/configuration#transformers.PreTrainedConfig) để biết thêm thông tin.

Ví dụ:

```python
>>> from transformers import LukeConfig, LukeModel

>>> # Initializing a LUKE configuration
>>> configuration = LukeConfig()

>>> # Initializing a model from the configuration
>>> model = LukeModel(configuration)

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

## LukeTokenizer[[transformers.LukeTokenizer]]

#### transformers.LukeTokenizer[[transformers.LukeTokenizer]]

```python
transformers.LukeTokenizer(vocab: str | dict[str, int] | None = None, merges: str | list[str] | None = None, entity_vocab: str | dict | list | None = None, errors = 'replace', bos_token = '<s>', eos_token = '</s>', sep_token = '</s>', cls_token = '<s>', unk_token = '<unk>', pad_token = '<pad>', mask_token = '<mask>', add_prefix_space = False, task = None, max_entity_length = 32, max_mention_length = 30, entity_1_token = '<ent>', entity_2_token = '<ent2>', entity_unk_token = '[UNK]', entity_pad_token = '[PAD]', entity_mask_token = '[MASK]', entity_mask2_token = '[MASK2]', **kwargs)
```

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/luke/tokenization_luke.py#L131)

**Tham số:**

vocab_file (`str`) : Đường dẫn đến tệp từ vựng.

merges_file (`str`) : Đường dẫn đến tệp merges.

vocab (`str` hoặc `dict[str, int]`, *tùy chọn*) : Từ điển từ vựng tùy chỉnh. Nếu không được cung cấp, từ vựng sẽ được tải từ `vocab_file`.

merges (`str` hoặc `list[str]`, *tùy chọn*) : Danh sách gộp tùy chỉnh. Nếu không được cung cấp, các gộp sẽ được tải từ `merges_file`.

entity_vocab_file (`str`) : Đường dẫn đến tệp từ vựng thực thể.

task (`str`, *tùy chọn*) : Nhiệm vụ mà bạn muốn chuẩn bị các chuỗi. Một trong số `"entity_classification"`, `"entity_pair_classification"` hoặc `"entity_span_classification"`. Nếu bạn chỉ định đối số này, chuỗi thực thể sẽ được tạo tự động dựa trên các khoảng thực thể (entity span) được cung cấp.

max_entity_length (`int`, *tuỳ chọn*, mặc định là 32) : Độ dài tối đa của `entity_ids`.

max_mention_length (`int`, *tuỳ chọn*, mặc định là 30) : Số lượng token tối đa bên trong một khoảng thực thể.

entity_1_token (`str`, *tùy chọn*, mặc định là `<ent>`) : Token đặc biệt được dùng để biểu diễn một khoảng thực thể trong chuỗi token từ. Token này chỉ được sử dụng khi `task` được đặt thành `"entity_classification"` hoặc `"entity_pair_classification"`.

entity_2_token (`str`, *tùy chọn*, mặc định là `<ent2>`) : Token đặc biệt được sử dụng để đại diện cho một khoảng thực thể trong chuỗi token từ. Token này chỉ được sử dụng khi `task` được đặt thành `"entity_pair_classification"`.

errors (`str`, *tùy chọn*, mặc định là `"replace"`) : Quy tắc áp dụng khi giải mã bytes sang UTF-8. Xem [bytes.decode](https://docs.python.org/3/library/stdtypes.html#bytes.decode) để biết thêm thông tin.

bos_token (`str`, *tuỳ chọn*, mặc định là `"<s>"`) : Token bắt đầu chuỗi được sử dụng trong quá trình tiền huấn luyện. Có thể được dùng làm token phân loại chuỗi.    Khi xây dựng một chuỗi bằng các token đặc biệt, đây không phải là token được dùng cho phần bắt đầu của chuỗi. Token được dùng là `cls_token`.

eos_token (`str`, *tùy chọn*, mặc định là `"</s>"`) : Token kết thúc chuỗi. Khi xây dựng một chuỗi bằng các token đặc biệt, đây không phải là token được dùng cho việc kết thúc chuỗi. Token được dùng là `sep_token`.

sep_token (`str`, *tùy chọn*, mặc định là `"</s>"`) : Token phân cách, được sử dụng khi xây dựng một chuỗi từ nhiều chuỗi, ví dụ như hai chuỗi cho phân loại chuỗi hoặc một văn bản và một câu hỏi cho trả lời câu hỏi. Nó cũng được sử dụng làm token cuối cùng của một chuỗi được xây dựng với các token đặc biệt.

cls_token (`str`, *tùy chọn*, mặc định là `"<s>"`) : Token phân loại được sử dụng khi thực hiện phân loại chuỗi (phân loại toàn bộ chuỗi thay vì phân loại theo từng token). Đây là token đầu tiên của chuỗi khi được xây dựng với các token đặc biệt.

unk_token (`str`, *tùy chọn*, mặc định là `"<unk>"`) : Token không xác định. Một token không có trong từ vựng sẽ không thể được chuyển đổi thành ID và sẽ được gán thành token này thay thế.

pad_token (`str`, *tùy chọn*, mặc định là `"<pad>"`) : Token được sử dụng để đệm, chẳng hạn khi xử lý các lô (batch) các chuỗi có độ dài khác nhau.

mask_token (`str`, *tùy chọn*, mặc định là `"<mask>"`) : Token được sử dụng để che các giá trị. Đây là token được dùng khi huấn luyện mô hình này với mô hình hóa ngôn ngữ có che (masked language modeling). Đây là token mà mô hình sẽ cố gắng dự đoán.

add_prefix_space (`bool`, *tùy chọn*, mặc định là `False`) : Có thêm một khoảng trắng ban đầu vào đầu vào hay không. Điều này cho phép xử lý từ đầu tiên giống như bất kỳ từ nào khác. (Bộ phân tách LUKE phát hiện đầu từ bằng khoảng trắng phía trước).

Tạo một tokenizer LUKE, được phát triển từ tokenizer GPT-2, sử dụng Byte-Pair-Encoding ở mức byte.

Tokenizer này được huấn luyện để coi khoảng trắng như một phần của các token (tương tự như sentencepiece) nên một từ sẽ

sẽ được mã hóa khác nhau tùy thuộc vào việc nó nằm ở đầu câu (không có khoảng trắng) hay không:

```python
>>> from transformers import LukeTokenizer

>>> tokenizer = LukeTokenizer.from_pretrained("studio-ousia/luke-base")
>>> tokenizer("Hello world")["input_ids"]
[0, 31414, 232, 2]

>>> tokenizer(" Hello world")["input_ids"]
[0, 20920, 232, 2]
```

Bạn có thể tránh hành vi đó bằng cách truyền `add_prefix_space=True` khi khởi tạo tokenizer này hoặc khi gọi nó trên một số văn bản, nhưng vì mô hình không được tiền huấn luyện theo cách này, nó có thể dẫn đến giảm hiệu suất.

Khi được sử dụng với `is_split_into_words=True`, tokenizer này sẽ thêm một khoảng trắng trước mỗi từ (kể cả từ đầu tiên).

Tokenizer này kế thừa từ [PreTrainedTokenizer](/docs/transformers/v5.23.0/vi/main_classes/tokenizer#transformers.PythonBackend), lớp chứa hầu hết các phương thức chính. Người dùng nên tham khảo siêu lớp này để biết thêm thông tin về các phương thức đó. Nó cũng tạo ra các chuỗi thực thể, cụ thể là `entity_ids`, `entity_attention_mask`, `entity_token_type_ids` và `entity_position_ids`, để được sử dụng bởi mô hình LUKE.

#### __call__[[transformers.LukeTokenizer.__call__]]

```python
__call__(text: str | list[str], text_pair: str | list[str] | None = None, entity_spans: list[tuple[int, int]] | list[list[tuple[int, int]]] | None = None, entity_spans_pair: list[tuple[int, int]] | list[list[tuple[int, int]]] | None = None, entities: list[str] | list[list[str]] | None = None, entities_pair: list[str] | list[list[str]] | None = None, add_special_tokens: bool = True, padding: bool | str | transformers.utils.generic.PaddingStrategy = False, truncation: bool | str | transformers.tokenization_utils_base.TruncationStrategy | None = None, max_length: int | None = None, max_entity_length: int | None = None, stride: int = 0, is_split_into_words: bool | None = False, pad_to_multiple_of: int | None = None, padding_side: str | None = None, return_tensors: str | transformers.utils.generic.TensorType | None = None, return_token_type_ids: bool | None = None, return_attention_mask: bool | None = None, return_overflowing_tokens: bool = False, return_special_tokens_mask: bool = False, return_offsets_mapping: bool = False, return_length: bool = False, verbose: bool = True, **kwargs)
```

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/luke/tokenization_luke.py#L411)

**Trả về:** [BatchEncoding](/docs/transformers/v5.23.0/vi/main_classes/tokenizer#transformers.BatchEncoding)

Một [BatchEncoding](/docs/transformers/v5.23.0/vi/main_classes/tokenizer#transformers.BatchEncoding) với các trường sau:

- **input_ids** -- Danh sách các id token để đưa vào mô hình.

  [ID đầu vào là gì?](../glossary#input-ids)

- **token_type_ids** -- Danh sách các id loại token để đưa vào mô hình (khi `return_token_type_ids=True` hoặc nếu *"token_type_ids"* nằm trong `self.model_input_names`).

  [ID loại token là gì?](../glossary#token-type-ids)

- **attention_mask** -- Danh sách các chỉ số chỉ định những token nào nên được mô hình chú ý đến (khi `return_attention_mask=True` hoặc nếu *"attention_mask"* nằm trong `self.model_input_names`).

  [Mặt nạ chú ý là gì?](../glossary#attention-mask)

- **entity_ids** -- Danh sách các id thực thể để đưa vào mô hình.

  [ID đầu vào là gì?](../glossary#input-ids)

- **entity_position_ids** -- Danh sách các vị trí thực thể trong chuỗi đầu vào sẽ được đưa vào mô hình.

- **entity_token_type_ids** -- Danh sách các entity token type ids để đưa vào mô hình (khi `return_token_type_ids=True` hoặc nếu *"entity_token_type_ids"* nằm trong `self.model_input_names`).

  [ID loại token là gì?](../glossary#token-type-ids)

- **entity_attention_mask** -- Danh sách các chỉ số chỉ định thực thể nào nên được mô hình chú ý đến (khi `return_attention_mask=True` hoặc nếu *"entity_attention_mask"* nằm trong `self.model_input_names`).

  [Mặt nạ chú ý là gì?](../glossary#attention-mask)

- **entity_start_positions** -- Danh sách các vị trí bắt đầu của các thực thể trong chuỗi token từ (khi `task="entity_span_classification"`).
- **entity_end_positions** -- Danh sách các vị trí kết thúc của các thực thể trong chuỗi token từ (khi `task="entity_span_classification"`).
- **overflowing_tokens** -- Danh sách các chuỗi token bị tràn (khi `max_length` được chỉ định và `return_overflowing_tokens=True`).
- **num_truncated_tokens** -- Số lượng token bị cắt bỏ (khi chỉ định `max_length` và `return_overflowing_tokens=True`).
- **special_tokens_mask** -- Danh sách các số 0 và 1, trong đó 1 chỉ định các token đặc biệt đã thêm và 0 chỉ định các token chuỗi thông thường (khi `add_special_tokens=True` và `return_special_tokens_mask=True`).
- **length** -- Độ dài của các đầu vào (khi `return_length=True`)

add_special_tokens (`bool`, *tùy chọn*, mặc định là `True`): Có thêm các token đặc biệt khi mã hóa các chuỗi hay không. Điều này sẽ sử dụng hàm `PretrainedTokenizerBase.build_inputs_with_special_tokens` bên dưới, hàm này xác định các token nào được thêm tự động vào các id đầu vào. Điều này hữu ích nếu bạn muốn tự động thêm các token `bos` hoặc `eos`. padding (`bool`, `str` hoặc [PaddingStrategy](/docs/transformers/v5.23.0/vi/internal/file_utils#transformers.utils.PaddingStrategy), *tùy chọn*, mặc định là `False`): Kích hoạt và kiểm soát việc đệm. Chấp nhận các giá trị sau:

- `True` hoặc `'longest'`: Lấp đầy đến trình tự dài nhất trong lô (hoặc không lấp đầy nếu chỉ cung cấp một trình tự duy nhất).
- `'max_length'`: Đệm (pad) đến độ dài tối đa được chỉ định bằng tham số `max_length` hoặc đến độ dài đầu vào tối đa mà mô hình chấp nhận được nếu tham số đó không được cung cấp.
- `False` hoặc `'do_not_pad'` (mặc định): Không đệm (tức là có thể xuất ra một lô với các chuỗi có độ dài khác nhau).
truncation (`bool`, `str` hoặc [TruncationStrategy](/docs/transformers/v5.23.0/vi/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy), *tuỳ chọn*, mặc định là `False`): Kích hoạt và kiểm soát việc cắt ngắn. Chấp nhận các giá trị sau:

- `True` hoặc `'longest_first'`: Cắt ngắn xuống độ dài tối đa được chỉ định bằng tham số `max_length` hoặc xuống độ dài đầu vào tối đa chấp nhận được của mô hình nếu tham số đó không được cung cấp. Thao tác này sẽ cắt ngắn theo từng token, loại bỏ một token từ chuỗi dài nhất trong cặp nếu một cặp chuỗi (hoặc một lô các cặp) được cung cấp.
- `'only_first'`: Cắt ngắn xuống độ dài tối đa được chỉ định bằng tham số `max_length` hoặc xuống độ dài đầu vào tối đa mà mô hình chấp nhận được nếu tham số đó không được cung cấp. Thao tác này chỉ cắt ngắn chuỗi đầu tiên của một cặp nếu một cặp chuỗi (hoặc một lô các cặp) được cung cấp.
- `'only_second'`: Cắt ngắn xuống độ dài tối đa được chỉ định bằng tham số `max_length` hoặc xuống độ dài đầu vào tối đa mà mô hình chấp nhận được nếu tham số đó không được cung cấp. Thao tác này chỉ cắt ngắn chuỗi thứ hai của một cặp nếu một cặp chuỗi (hoặc một lô các cặp) được cung cấp.
- `False` hoặc `'do_not_truncate'` (mặc định): Không cắt bớt (tức là có thể xuất ra batch với độ dài chuỗi lớn hơn kích thước đầu vào tối đa được phép của mô hình).
max_length (`int`, *tuỳ chọn*): Kiểm soát độ dài tối đa được sử dụng bởi một trong các tham số cắt ngắn/lấp đầy.

Nếu không được đặt hoặc được đặt thành `None`, tham số này sẽ sử dụng độ dài tối đa định trước của mô hình nếu một trong các tham số cắt/giữ chỗ yêu cầu độ dài tối đa. Nếu mô hình không có độ dài đầu vào tối đa cụ thể (như XLNet), việc cắt/giữ chỗ đến độ dài tối đa sẽ bị vô hiệu hóa. stride (`int`, *tùy chọn*, mặc định là 0): Nếu được đặt thành một số cùng với `max_length`, các token tràn ra được trả về khi `return_overflowing_tokens=True` sẽ chứa một số token từ cuối của chuỗi bị cắt được trả về để tạo ra một phần chồng lấn giữa các chuỗi bị cắt và các chuỗi tràn ra. Giá trị của đối số này xác định số lượng token chồng lấn. is_split_into_words (`bool`, *tùy chọn*, mặc định là `False`): Cho biết đầu vào đã được tiền tách token (ví dụ: tách thành các từ) hay chưa. Nếu được đặt thành `True`, bộ tách token sẽ giả định rằng đầu vào đã được tách thành các từ (ví dụ, bằng cách tách theo khoảng trắng) và sẽ tách token chúng. Điều này hữu ích cho NER hoặc phân loại token. pad_to_multiple_of (`int`, *tùy chọn*): Nếu được đặt, sẽ giữ chỗ cho chuỗi đến một bội số của giá trị được cung cấp. Yêu cầu `padding` phải được kích hoạt. Điều này đặc biệt hữu ích để cho phép sử dụng Tensor Cores trên phần cứng NVIDIA có khả năng tính toán `>= 7.5` (Volta). padding_side (`str`, *tùy chọn*): Bên mà mô hình nên được áp dụng giữ chỗ. Nên được chọn giữa ['right', 'left']. Giá trị mặc định được chọn từ thuộc tính lớp có cùng tên. return_tensors (`str` hoặc [TensorType](/docs/transformers/v5.23.0/vi/internal/file_utils#transformers.TensorType), *tùy chọn*): Nếu được đặt, sẽ trả về các tensor thay vì danh sách các số nguyên python. Các giá trị chấp nhận được là:

- `'pt'`: Trả về các đối tượng `torch.Tensor` của PyTorch.
- `'np'`: Trả về các đối tượng Numpy `np.ndarray`.

return_token_type_ids (`bool`, *tùy chọn*): Xác định có trả về các ID loại token hay không. Nếu giữ nguyên giá trị mặc định, sẽ trả về các ID loại token theo mặc định của bộ phân tích token cụ thể, được định nghĩa bởi thuộc tính `return_outputs`.

[Token type IDs là gì?](../glossary#token-type-ids) return_attention_mask (`bool`, *tùy chọn*): Có trả về attention mask hay không. Nếu để mặc định, sẽ trả về attention mask theo mặc định của tokenizer cụ thể, được định nghĩa bởi thuộc tính `return_outputs`.

[Mặt nạ chú ý là gì?](../glossary#attention-mask) return_overflowing_tokens (`bool`, *tùy chọn*, mặc định là `False`): Có trả về các chuỗi token tràn hay không. Nếu một cặp các chuỗi id đầu vào (hoặc một lô các cặp) được cung cấp với `truncation_strategy = longest_first` hoặc `True`, một lỗi sẽ được ném thay vì trả về các token tràn. return_special_tokens_mask (`bool`, *tùy chọn*, mặc định là `False`): Có trả về thông tin mặt nạ token đặc biệt hay không. return_offsets_mapping (`bool`, *tùy chọn*, mặc định là `False`): Có trả về `(char_start, char_end)` cho mỗi token hay không.

Tính năng này chỉ khả dụng trên các bộ phân từ nhanh kế thừa từ [PreTrainedTokenizerFast](/docs/transformers/v5.23.0/vi/main_classes/tokenizer#transformers.TokenizersBackend); nếu sử dụng bộ phân từ của Python, phương thức này sẽ gây ra `NotImplementedError`. return_length (`bool`, *tùy chọn*, mặc định là `False`): Có trả về độ dài của các đầu vào đã mã hóa hay không. verbose (`bool`, *tùy chọn*, mặc định là `True`): Có in thêm thông tin và cảnh báo hay không. **kwargs: được truyền đến phương thức `self.tokenize()`

#### save_vocabulary[[transformers.LukeTokenizer.save_vocabulary]]

```python
save_vocabulary(save_directory: str, filename_prefix: str | None = None)
```

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_tokenizers.py#L547)

## LukeModel[[transformers.LukeModel]]

#### transformers.LukeModel[[transformers.LukeModel]]

```python
transformers.LukeModel(config: LukeConfig, add_pooling_layer: bool = True)
```

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/luke/modeling_luke.py#L788)

**Tham số:**

config ([LukeConfig](/docs/transformers/v5.23.0/vi/model_doc/luke#transformers.LukeConfig)) : Lớp cấu hình mô hình chứa tất cả các tham số của mô hình. Khởi tạo bằng tệp cấu hình sẽ không tải trọng số liên quan đến mô hình, chỉ tải cấu hình. Xem phương thức [from_pretrained()](/docs/transformers/v5.23.0/vi/main_classes/model#transformers.PreTrainedModel.from_pretrained) để tải trọng số mô hình.

add_pooling_layer (`bool`, *tùy chọn*, mặc định là `True`) : Có thêm một lớp pooling hay không

Mô hình transformer LUKE cơ bản, xuất ra các hidden-state thô cho cả token từ và thực thể mà không có

Mô hình này kế thừa từ [PreTrainedModel](/docs/transformers/v5.23.0/vi/main_classes/model#transformers.PreTrainedModel). Xem tài liệu của lớp cha để biết các phương thức chung mà thư viện triển khai cho tất cả các mô hình của nó (chẳng hạn như tải xuống hoặc lưu trữ, thay đổi kích thước các nhúng đầu vào, cắt tỉa các đầu ra, v.v.)

Mô hình này cũng là một lớp con của [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) trong PyTorch. Hãy sử dụng nó như một Module PyTorch thông thường và tham khảo tài liệu PyTorch cho mọi vấn đề liên quan đến cách sử dụng và hành vi chung.

#### forward[[transformers.LukeModel.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, entity_ids: typing.Optional[torch.LongTensor] = None, entity_attention_mask: typing.Optional[torch.Tensor] = None, entity_token_type_ids: typing.Optional[torch.LongTensor] = None, entity_position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/luke/modeling_luke.py#L818)

**Tham số:**

input_ids (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Chỉ số của các token trong chuỗi đầu vào theo từ vựng. Mặc định, các token đệm (padding) sẽ bị bỏ qua. Có thể lấy chỉ số bằng cách sử dụng [AutoTokenizer](/docs/transformers/v5.23.0/vi/model_doc/auto#transformers.AutoTokenizer). Xem [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) và [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) để biết chi tiết. [ID đầu vào là gì?](../glossary#input-ids)

attention_mask (`torch.Tensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Mặt nạ để tránh thực hiện chú ý trên các chỉ số token đệm. Các giá trị mặt nạ được chọn trong `[0, 1]`:  - 1 cho các token **không bị che**, - 0 cho các token **bị che**.  [Mặt nạ chú ý là gì?](../glossary#attention-mask)

token_type_ids (`torch.LongTensor` có shape `(batch_size, sequence_length)`, *tùy chọn*) : Các chỉ số token phân đoạn để chỉ định phần đầu và phần thứ hai của các đầu vào. Các chỉ số được chọn trong `[0, 1]`:  - 0 tương ứng với token *câu A*, - 1 tương ứng với token *câu B*.  [Các ID loại token là gì?](../glossary#token-type-ids)

position_ids (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Chỉ số của vị trí các token trong mỗi chuỗi đầu vào trong các embedding vị trí. Được chọn trong khoảng `[0, config.n_positions - 1]`.  [Position IDs là gì?](../glossary#position-ids)

entity_ids (`torch.LongTensor` có shape `(batch_size, entity_length)`) : Chỉ số của các token thực thể trong từ điển thực thể. Có thể lấy chỉ số bằng cách sử dụng [AutoTokenizer](/docs/transformers/v5.23.0/vi/model_doc/auto#transformers.AutoTokenizer). Xem [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) và [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) để biết thêm chi tiết.

entity_attention_mask (`torch.Tensor` có shape `(batch_size, entity_length)`, *tùy chọn*) : Mặt nạ để tránh thực hiện chú ý trên các chỉ số token entity padding. Các giá trị mặt nạ được chọn trong `[0, 1]`:  - 1 cho các token entity **không bị che**, - 0 cho các token entity **bị che**.

entity_token_type_ids (`torch.LongTensor` có shape `(batch_size, entity_length)`, *tùy chọn*) : Các chỉ số token phân đoạn để chỉ định phần đầu và phần thứ hai của đầu vào token thực thể. Các chỉ số được chọn trong `[0, 1]`:  - 0 tương ứng với token thực thể *phần A*, - 1 tương ứng với token thực thể *phần B*.

entity_position_ids (`torch.LongTensor` có shape `(batch_size, entity_length, max_mention_length)`, *tùy chọn*) : Chỉ số của các vị trí của mỗi entity đầu vào trong các position embeddings. Được chọn trong khoảng `[0, config.max_position_embeddings - 1]`.

inputs_embeds (`torch.Tensor` có hình dạng `(batch_size, sequence_length, hidden_size)`, *tùy chọn*) : Tùy chọn, thay vì truyền `input_ids`, bạn có thể chọn cách truyền trực tiếp một biểu diễn nhúng. Điều này hữu ích nếu bạn muốn kiểm soát nhiều hơn cách chuyển đổi các chỉ số `input_ids` thành các vector liên quan so với ma trận tra cứu nhúng nội bộ của mô hình.

output_attentions (`bool`, *tùy chọn*) : Có trả về các tensor chú ý của tất cả các lớp chú ý hay không. Xem `attentions` trong phần tensor trả về để biết thêm chi tiết.

output_hidden_states (`bool`, *tuỳ chọn*) : Có trả về trạng thái ẩn của tất cả các lớp hay không. Xem `hidden_states` trong phần tensor trả về để biết thêm chi tiết.

return_dict (`bool`, *tùy chọn*) : Có trả về [ModelOutput](/docs/transformers/v5.23.0/vi/main_classes/output#transformers.utils.ModelOutput) thay vì một tuple thông thường hay không.

**Trả về:** `BaseLukeModelOutputWithPooling` hoặc `tuple(torch.Tensor)`

Một `BaseLukeModelOutputWithPooling` hoặc một tuple của `torch.Tensor` (nếu `return_dict=False` được truyền hoặc khi `config.return_dict=False`) bao gồm các phần tử khác nhau tùy thuộc vào cấu hình ([LukeConfig](/docs/transformers/v5.23.0/vi/model_doc/luke#transformers.LukeConfig)) và đầu vào.

Phương thức forward của [LukeModel](/docs/transformers/v5.23.0/vi/model_doc/luke#transformers.LukeModel) ghi đè phương thức đặc biệt `__call__`.

Mặc dù công thức cho bước truyền tiến cần được định nghĩa bên trong hàm này, bạn nên gọi instance của `Module` sau đó thay vì gọi hàm này, vì instance `Module` sẽ đảm nhận việc thực hiện các bước tiền xử lý và hậu xử lý, trong khi hàm này sẽ bỏ qua chúng một cách im lặng.

- **last_hidden_state** (`torch.Tensor` có hình dạng `(batch_size, sequence_length, hidden_size)`) -- Chuỗi các hidden-state tại đầu ra của lớp cuối cùng của mô hình.
- **pooler_output** (`torch.Tensor` có shape `(batch_size, hidden_size)`) -- Trạng thái ẩn của lớp cuối cùng cho token đầu tiên của chuỗi (token phân loại), sau đó được xử lý thêm bởi một lớp Linear và hàm kích hoạt Tanh.
- **hidden_states** (`tuple(torch.Tensor)`, *tuỳ chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) -- Bộ tuple của `torch.Tensor` (một cho đầu ra của các embedding, nếu mô hình có lớp embedding, + một cho đầu ra của mỗi lớp) có hình dạng `(batch_size, sequence_length, hidden_size)`.

  Trạng thái ẩn của mô hình tại đầu ra của mỗi lớp cùng với các đầu ra embedding ban đầu tùy chọn.
- **attentions** (`tuple(torch.Tensor)`, *tuỳ chọn*, được trả về khi `output_attentions=True` được truyền vào hoặc khi `config.output_attentions=True`) -- Bộ tuple của `torch.Tensor` (một cho mỗi lớp) có hình dạng `(batch_size, num_heads, sequence_length, sequence_length)`.

  Trọng số chú ý sau softmax của attention, được sử dụng để tính trung bình có trọng số trong các đầu self-attention.
- **entity_last_hidden_state** (`torch.Tensor` có hình dạng `(batch_size, entity_length, hidden_size)`) -- Chuỗi các hidden-state của entity tại đầu ra của lớp cuối cùng của mô hình.
- **entity_hidden_states** (`tuple(torch.Tensor)`, *tùy chọn*, được trả về khi truyền `output_hidden_states=True` hoặc khi `config.output_hidden_states=True`) -- Tuple của `torch.Tensor` (một cho đầu ra của embeddings + một cho đầu ra của mỗi lớp) có shape `(batch_size, entity_length, hidden_size)`. Entity hidden-states của mô hình tại đầu ra của mỗi lớp cùng với đầu ra của entity embedding ban đầu.

Ví dụ:

```python
>>> from transformers import AutoTokenizer, LukeModel

>>> tokenizer = AutoTokenizer.from_pretrained("studio-ousia/luke-base")
>>> model = LukeModel.from_pretrained("studio-ousia/luke-base")
# Compute the contextualized entity representation corresponding to the entity mention "Beyoncé"

>>> text = "Beyoncé lives in Los Angeles."
>>> entity_spans = [(0, 7)]  # character-based entity span corresponding to "Beyoncé"

>>> encoding = tokenizer(text, entity_spans=entity_spans, add_prefix_space=True, return_tensors="pt")
>>> outputs = model(**encoding)
>>> word_last_hidden_state = outputs.last_hidden_state
>>> entity_last_hidden_state = outputs.entity_last_hidden_state
# Input Wikipedia entities to obtain enriched contextualized representations of word tokens

>>> text = "Beyoncé lives in Los Angeles."
>>> entities = [
...     "Beyoncé",
...     "Los Angeles",
... ]  # Wikipedia entity titles corresponding to the entity mentions "Beyoncé" and "Los Angeles"
>>> entity_spans = [
...     (0, 7),
...     (17, 28),
... ]  # character-based entity spans corresponding to "Beyoncé" and "Los Angeles"

>>> encoding = tokenizer(
...     text, entities=entities, entity_spans=entity_spans, add_prefix_space=True, return_tensors="pt"
... )
>>> outputs = model(**encoding)
>>> word_last_hidden_state = outputs.last_hidden_state
>>> entity_last_hidden_state = outputs.entity_last_hidden_state
```

## LukeForMaskedLM[[transformers.LukeForMaskedLM]]

#### transformers.LukeForMaskedLM[[transformers.LukeForMaskedLM]]

```python
transformers.LukeForMaskedLM(config: LukeConfig)
```

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/luke/modeling_luke.py#L1019)

**Tham số:**

config ([LukeConfig](/docs/transformers/v5.23.0/vi/model_doc/luke#transformers.LukeConfig)) : Lớp cấu hình mô hình chứa tất cả các tham số của mô hình. Khởi tạo bằng tệp cấu hình sẽ không tải trọng số liên quan đến mô hình, chỉ tải cấu hình. Xem phương thức [from_pretrained()](/docs/transformers/v5.23.0/vi/main_classes/model#transformers.PreTrainedModel.from_pretrained) để tải trọng số mô hình.

Mô hình LUKE với một đầu mô hình hóa ngôn ngữ và một đầu dự đoán thực thể phía trên, dùng cho mô hình hóa ngôn ngữ có che và dự đoán thực thể có che.

Mô hình này kế thừa từ [PreTrainedModel](/docs/transformers/v5.23.0/vi/main_classes/model#transformers.PreTrainedModel). Xem tài liệu của lớp cha để biết các phương thức chung mà thư viện triển khai cho tất cả các mô hình của nó (chẳng hạn như tải xuống hoặc lưu trữ, thay đổi kích thước các nhúng đầu vào, cắt tỉa các đầu ra, v.v.)

Mô hình này cũng là một lớp con của [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) trong PyTorch. Hãy sử dụng nó như một Module PyTorch thông thường và tham khảo tài liệu PyTorch cho mọi vấn đề liên quan đến cách sử dụng và hành vi chung.

#### forward[[transformers.LukeForMaskedLM.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, entity_ids: typing.Optional[torch.LongTensor] = None, entity_attention_mask: typing.Optional[torch.LongTensor] = None, entity_token_type_ids: typing.Optional[torch.LongTensor] = None, entity_position_ids: typing.Optional[torch.LongTensor] = None, labels: typing.Optional[torch.LongTensor] = None, entity_labels: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/luke/modeling_luke.py#L1044)

**Tham số:**

input_ids (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Chỉ số của các token trong chuỗi đầu vào theo từ vựng. Mặc định, các token đệm (padding) sẽ bị bỏ qua. Có thể lấy chỉ số bằng cách sử dụng [AutoTokenizer](/docs/transformers/v5.23.0/vi/model_doc/auto#transformers.AutoTokenizer). Xem [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) và [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) để biết chi tiết. [ID đầu vào là gì?](../glossary#input-ids)

attention_mask (`torch.Tensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Mặt nạ để tránh thực hiện chú ý trên các chỉ số token đệm. Các giá trị mặt nạ được chọn trong `[0, 1]`:  - 1 cho các token **không bị che**, - 0 cho các token **bị che**.  [Mặt nạ chú ý là gì?](../glossary#attention-mask)

token_type_ids (`torch.LongTensor` có shape `(batch_size, sequence_length)`, *tùy chọn*) : Các chỉ số token phân đoạn để chỉ định phần đầu và phần thứ hai của các đầu vào. Các chỉ số được chọn trong `[0, 1]`:  - 0 tương ứng với token *câu A*, - 1 tương ứng với token *câu B*.  [Các ID loại token là gì?](../glossary#token-type-ids)

position_ids (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Chỉ số của vị trí các token trong mỗi chuỗi đầu vào trong các embedding vị trí. Được chọn trong khoảng `[0, config.n_positions - 1]`.  [Position IDs là gì?](../glossary#position-ids)

entity_ids (`torch.LongTensor` có shape `(batch_size, entity_length)`) : Chỉ số của các token thực thể trong từ điển thực thể. Có thể lấy chỉ số bằng cách sử dụng [AutoTokenizer](/docs/transformers/v5.23.0/vi/model_doc/auto#transformers.AutoTokenizer). Xem [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) và [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) để biết thêm chi tiết.

entity_attention_mask (`torch.Tensor` có shape `(batch_size, entity_length)`, *tùy chọn*) : Mặt nạ để tránh thực hiện chú ý trên các chỉ số token entity padding. Các giá trị mặt nạ được chọn trong `[0, 1]`:  - 1 cho các token entity **không bị che**, - 0 cho các token entity **bị che**.

entity_token_type_ids (`torch.LongTensor` có shape `(batch_size, entity_length)`, *tùy chọn*) : Các chỉ số token phân đoạn để chỉ định phần đầu và phần thứ hai của đầu vào token thực thể. Các chỉ số được chọn trong `[0, 1]`:  - 0 tương ứng với token thực thể *phần A*, - 1 tương ứng với token thực thể *phần B*.

entity_position_ids (`torch.LongTensor` có shape `(batch_size, entity_length, max_mention_length)`, *tùy chọn*) : Chỉ số của các vị trí của mỗi entity đầu vào trong các position embeddings. Được chọn trong khoảng `[0, config.max_position_embeddings - 1]`.

labels (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Nhãn để tính toán tổn thất mô hình hóa ngôn ngữ có che (masked language modeling loss). Chỉ số phải nằm trong `[-100, 0, ..., config.vocab_size]` (xem docstring của `input_ids`). Các token có chỉ số được đặt thành `-100` sẽ bị bỏ qua (che), tổn thất chỉ được tính cho các token có nhãn nằm trong `[0, ..., config.vocab_size]`.

entity_labels (`torch.LongTensor` có hình dạng `(batch_size, entity_length)`, *tùy chọn*) : Nhãn để tính toán tổn thất mô hình hóa ngôn ngữ bị che. Chỉ số phải nằm trong `[-100, 0, ..., config.vocab_size]` (xem docstring của `input_ids`) Các token có chỉ số được đặt thành `-100` sẽ bị bỏ qua (bị che), tổn thất chỉ được tính cho các token có nhãn trong `[0, ..., config.vocab_size]`

inputs_embeds (`torch.Tensor` có hình dạng `(batch_size, sequence_length, hidden_size)`, *tùy chọn*) : Tùy chọn, thay vì truyền `input_ids`, bạn có thể chọn cách truyền trực tiếp một biểu diễn nhúng. Điều này hữu ích nếu bạn muốn kiểm soát nhiều hơn cách chuyển đổi các chỉ số `input_ids` thành các vector liên quan so với ma trận tra cứu nhúng nội bộ của mô hình.

output_attentions (`bool`, *tùy chọn*) : Có trả về các tensor chú ý của tất cả các lớp chú ý hay không. Xem `attentions` trong phần tensor trả về để biết thêm chi tiết.

output_hidden_states (`bool`, *tuỳ chọn*) : Có trả về trạng thái ẩn của tất cả các lớp hay không. Xem `hidden_states` trong phần tensor trả về để biết thêm chi tiết.

return_dict (`bool`, *tùy chọn*) : Có trả về [ModelOutput](/docs/transformers/v5.23.0/vi/main_classes/output#transformers.utils.ModelOutput) thay vì một tuple thông thường hay không.

**Trả về:** `LukeMaskedLMOutput` hoặc `tuple(torch.Tensor)`

Một `LukeMaskedLMOutput` hoặc một tuple của `torch.Tensor` (nếu `return_dict=False` được truyền hoặc khi `config.return_dict=False`) bao gồm các phần tử khác nhau tùy thuộc vào cấu hình ([LukeConfig](/docs/transformers/v5.23.0/vi/model_doc/luke#transformers.LukeConfig)) và đầu vào.

Phương thức forward của [LukeForMaskedLM](/docs/transformers/v5.23.0/vi/model_doc/luke#transformers.LukeForMaskedLM) ghi đè lên phương thức đặc biệt `__call__`.

Mặc dù công thức cho bước truyền tiến cần được định nghĩa bên trong hàm này, bạn nên gọi instance của `Module` sau đó thay vì gọi hàm này, vì instance `Module` sẽ đảm nhận việc thực hiện các bước tiền xử lý và hậu xử lý, trong khi hàm này sẽ bỏ qua chúng một cách im lặng.

- **loss** (`torch.Tensor` có shape `(1,)`, *optional*, được trả về khi `labels` được cung cấp) -- Tổng của masked language modeling (MLM) loss và entity prediction loss.
- **mlm_loss** (`torch.Tensor` có shape `(1,)`, *optional*, được trả về khi `labels` được cung cấp) -- Lỗi (loss) của masked language modeling (MLM).
- **mep_loss** (`torch.Tensor` có hình dạng `(1,)`, *tùy chọn*, được trả về khi `labels` được cung cấp) -- Tổn thất dự đoán thực thể có mặt nạ (MEP).
- **logits** (`torch.Tensor` có hình dạng `(batch_size, sequence_length, config.vocab_size)`) -- Điểm dự đoán của đầu mô hình hóa ngôn ngữ (điểm cho mỗi token từ vựng trước SoftMax).
- **entity_logits** (`torch.Tensor` có hình dạng `(batch_size, sequence_length, config.vocab_size)`) -- Điểm dự đoán của đầu dự đoán thực thể (điểm cho mỗi token từ vựng thực thể trước SoftMax).
- **hidden_states** (`tuple[torch.Tensor]`, *tuỳ chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) -- Bộ tuple các `torch.Tensor` (một cho đầu ra của embeddings, nếu mô hình có lớp embedding, + một cho đầu ra của mỗi lớp) có hình dạng `(batch_size, sequence_length, hidden_size)`.

  Trạng thái ẩn của mô hình tại đầu ra của mỗi lớp cùng với các đầu ra embedding ban đầu tùy chọn.
- **entity_hidden_states** (`tuple(torch.Tensor)`, *tùy chọn*, được trả về khi truyền `output_hidden_states=True` hoặc khi `config.output_hidden_states=True`) -- Tuple của `torch.Tensor` (một cho đầu ra của embeddings + một cho đầu ra của mỗi lớp) có shape `(batch_size, entity_length, hidden_size)`. Entity hidden-states của mô hình tại đầu ra của mỗi lớp cùng với đầu ra của entity embedding ban đầu.
- **attentions** (`tuple[torch.Tensor, ...]`, *tùy chọn*, được trả về khi `output_attentions=True` được truyền vào hoặc khi `config.output_attentions=True`) -- Bộ tuple của `torch.Tensor` (một cho mỗi lớp) có hình dạng `(batch_size, num_heads, sequence_length, sequence_length)`.

  Trọng số chú ý sau softmax của attention, được sử dụng để tính trung bình có trọng số trong các đầu self-attention.

Ví dụ:

```python
>>> from transformers import AutoTokenizer, LukeForMaskedLM
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("studio-ousia/luke-base")
>>> model = LukeForMaskedLM.from_pretrained("studio-ousia/luke-base")

>>> inputs = tokenizer("The capital of France is <mask>.", return_tensors="pt")

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> # retrieve index of <mask>
>>> 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-<mask> tokens
>>> labels = torch.where(inputs.input_ids == tokenizer.mask_token_id, labels, -100)

>>> outputs = model(**inputs, labels=labels)
>>> round(outputs.loss.item(), 2)
...
```

## LukeForEntityClassification[[transformers.LukeForEntityClassification]]

#### transformers.LukeForEntityClassification[[transformers.LukeForEntityClassification]]

```python
transformers.LukeForEntityClassification(config: LukeConfig)
```

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/luke/modeling_luke.py#L1162)

**Tham số:**

config ([LukeConfig](/docs/transformers/v5.23.0/vi/model_doc/luke#transformers.LukeConfig)) : Lớp cấu hình mô hình chứa tất cả các tham số của mô hình. Khởi tạo bằng tệp cấu hình sẽ không tải trọng số liên quan đến mô hình, chỉ tải cấu hình. Xem phương thức [from_pretrained()](/docs/transformers/v5.23.0/vi/main_classes/model#transformers.PreTrainedModel.from_pretrained) để tải trọng số mô hình.

Mô hình LUKE với một đầu phân loại phía trên (một lớp tuyến tính phía trên trạng thái ẩn của token thực thể đầu tiên) cho các tác vụ phân loại thực thể, chẳng hạn như Open Entity.

Mô hình này kế thừa từ [PreTrainedModel](/docs/transformers/v5.23.0/vi/main_classes/model#transformers.PreTrainedModel). Xem tài liệu của lớp cha để biết các phương thức chung mà thư viện triển khai cho tất cả các mô hình của nó (chẳng hạn như tải xuống hoặc lưu trữ, thay đổi kích thước các nhúng đầu vào, cắt tỉa các đầu ra, v.v.)

Mô hình này cũng là một lớp con của [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) trong PyTorch. Hãy sử dụng nó như một Module PyTorch thông thường và tham khảo tài liệu PyTorch cho mọi vấn đề liên quan đến cách sử dụng và hành vi chung.

#### forward[[transformers.LukeForEntityClassification.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, entity_ids: typing.Optional[torch.LongTensor] = None, entity_attention_mask: typing.Optional[torch.Tensor] = None, entity_token_type_ids: typing.Optional[torch.LongTensor] = None, entity_position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/luke/modeling_luke.py#L1175)

**Tham số:**

input_ids (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Chỉ số của các token trong chuỗi đầu vào theo từ vựng. Mặc định, các token đệm (padding) sẽ bị bỏ qua. Có thể lấy chỉ số bằng cách sử dụng [AutoTokenizer](/docs/transformers/v5.23.0/vi/model_doc/auto#transformers.AutoTokenizer). Xem [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) và [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) để biết chi tiết. [ID đầu vào là gì?](../glossary#input-ids)

attention_mask (`torch.Tensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Mặt nạ để tránh thực hiện chú ý trên các chỉ số token đệm. Các giá trị mặt nạ được chọn trong `[0, 1]`:  - 1 cho các token **không bị che**, - 0 cho các token **bị che**.  [Mặt nạ chú ý là gì?](../glossary#attention-mask)

token_type_ids (`torch.LongTensor` có shape `(batch_size, sequence_length)`, *tùy chọn*) : Các chỉ số token phân đoạn để chỉ định phần đầu và phần thứ hai của các đầu vào. Các chỉ số được chọn trong `[0, 1]`:  - 0 tương ứng với token *câu A*, - 1 tương ứng với token *câu B*.  [Các ID loại token là gì?](../glossary#token-type-ids)

position_ids (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Chỉ số của vị trí các token trong mỗi chuỗi đầu vào trong các embedding vị trí. Được chọn trong khoảng `[0, config.n_positions - 1]`.  [Position IDs là gì?](../glossary#position-ids)

entity_ids (`torch.LongTensor` có shape `(batch_size, entity_length)`) : Chỉ số của các token thực thể trong từ điển thực thể. Có thể lấy chỉ số bằng cách sử dụng [AutoTokenizer](/docs/transformers/v5.23.0/vi/model_doc/auto#transformers.AutoTokenizer). Xem [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) và [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) để biết thêm chi tiết.

entity_attention_mask (`torch.Tensor` có shape `(batch_size, entity_length)`, *tùy chọn*) : Mặt nạ để tránh thực hiện chú ý trên các chỉ số token entity padding. Các giá trị mặt nạ được chọn trong `[0, 1]`:  - 1 cho các token entity **không bị che**, - 0 cho các token entity **bị che**.

entity_token_type_ids (`torch.LongTensor` có shape `(batch_size, entity_length)`, *tùy chọn*) : Các chỉ số token phân đoạn để chỉ định phần đầu và phần thứ hai của đầu vào token thực thể. Các chỉ số được chọn trong `[0, 1]`:  - 0 tương ứng với token thực thể *phần A*, - 1 tương ứng với token thực thể *phần B*.

entity_position_ids (`torch.LongTensor` có shape `(batch_size, entity_length, max_mention_length)`, *tùy chọn*) : Chỉ số của các vị trí của mỗi entity đầu vào trong các position embeddings. Được chọn trong khoảng `[0, config.max_position_embeddings - 1]`.

inputs_embeds (`torch.Tensor` có hình dạng `(batch_size, sequence_length, hidden_size)`, *tùy chọn*) : Tùy chọn, thay vì truyền `input_ids`, bạn có thể chọn cách truyền trực tiếp một biểu diễn nhúng. Điều này hữu ích nếu bạn muốn kiểm soát nhiều hơn cách chuyển đổi các chỉ số `input_ids` thành các vector liên quan so với ma trận tra cứu nhúng nội bộ của mô hình.

labels (`torch.LongTensor` có shape `(batch_size,)` hoặc `(batch_size, num_labels)`, *tùy chọn*) : Nhãn để tính toán loss phân loại. Nếu shape là `(batch_size,)`, loss cross entropy sẽ được sử dụng cho phân loại đơn nhãn. Trong trường hợp này, labels nên chứa các chỉ số nằm trong `[0, ..., config.num_labels - 1]`. Nếu shape là `(batch_size, num_labels)`, loss binary cross entropy sẽ được sử dụng cho phân loại đa nhãn. Trong trường hợp này, labels chỉ nên chứa `[0, 1]`, trong đó 0 và 1 lần lượt chỉ định giá trị sai và đúng.

output_attentions (`bool`, *tùy chọn*) : Có trả về các tensor chú ý của tất cả các lớp chú ý hay không. Xem `attentions` trong phần tensor trả về để biết thêm chi tiết.

output_hidden_states (`bool`, *tuỳ chọn*) : Có trả về trạng thái ẩn của tất cả các lớp hay không. Xem `hidden_states` trong phần tensor trả về để biết thêm chi tiết.

return_dict (`bool`, *tùy chọn*) : Có trả về [ModelOutput](/docs/transformers/v5.23.0/vi/main_classes/output#transformers.utils.ModelOutput) thay vì một tuple thông thường hay không.

**Trả về:** `EntityClassificationOutput` hoặc `tuple(torch.Tensor)`

Một `EntityClassificationOutput` hoặc một tuple của `torch.Tensor` (nếu `return_dict=False` được truyền vào hoặc khi `config.return_dict=False`) bao gồm các thành phần khác nhau tùy thuộc vào cấu hình ([LukeConfig](/docs/transformers/v5.23.0/vi/model_doc/luke#transformers.LukeConfig)) và đầu vào.

Phương thức forward của [LukeForEntityClassification](/docs/transformers/v5.23.0/vi/model_doc/luke#transformers.LukeForEntityClassification) ghi đè lên phương thức đặc biệt `__call__`.

Mặc dù công thức cho bước truyền tiến cần được định nghĩa bên trong hàm này, bạn nên gọi instance của `Module` sau đó thay vì gọi hàm này, vì instance `Module` sẽ đảm nhận việc thực hiện các bước tiền xử lý và hậu xử lý, trong khi hàm này sẽ bỏ qua chúng một cách im lặng.

- **loss** (`torch.Tensor` có hình dạng `(1,)`, *tùy chọn*, được trả về khi `labels` được cung cấp) -- Tổn phân loại.
- **logits** (`torch.Tensor` có hình dạng `(batch_size, config.num_labels)`) -- Điểm phân loại (trước SoftMax).
- **hidden_states** (`tuple[torch.Tensor, ...]`, *tùy chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) -- Bộ tuple các `torch.Tensor` (một cho đầu ra của embeddings, nếu mô hình có lớp embedding, + một cho đầu ra của mỗi lớp) có hình dạng `(batch_size, sequence_length, hidden_size)`.

  Trạng thái ẩn của mô hình tại đầu ra của mỗi lớp cùng với các đầu ra embedding ban đầu tùy chọn.
- **entity_hidden_states** (`tuple(torch.Tensor)`, *tùy chọn*, được trả về khi truyền `output_hidden_states=True` hoặc khi `config.output_hidden_states=True`) -- Tuple của `torch.Tensor` (một cho đầu ra của embeddings + một cho đầu ra của mỗi lớp) có shape `(batch_size, entity_length, hidden_size)`. Entity hidden-states của mô hình tại đầu ra của mỗi lớp cùng với đầu ra của entity embedding ban đầu.
- **attentions** (`tuple[torch.Tensor, ...]`, *tùy chọn*, được trả về khi `output_attentions=True` được truyền vào hoặc khi `config.output_attentions=True`) -- Bộ tuple của `torch.Tensor` (một cho mỗi lớp) có hình dạng `(batch_size, num_heads, sequence_length, sequence_length)`.

  Trọng số chú ý sau softmax của attention, được sử dụng để tính trung bình có trọng số trong các đầu self-attention.

Ví dụ:

```python
>>> from transformers import AutoTokenizer, LukeForEntityClassification

>>> tokenizer = AutoTokenizer.from_pretrained("studio-ousia/luke-large-finetuned-open-entity")
>>> model = LukeForEntityClassification.from_pretrained("studio-ousia/luke-large-finetuned-open-entity")

>>> text = "Beyoncé lives in Los Angeles."
>>> entity_spans = [(0, 7)]  # character-based entity span corresponding to "Beyoncé"
>>> inputs = tokenizer(text, entity_spans=entity_spans, return_tensors="pt")
>>> outputs = model(**inputs)
>>> logits = outputs.logits
>>> predicted_class_idx = logits.argmax(-1).item()
>>> print("Predicted class:", model.config.id2label[predicted_class_idx])
Predicted class: person
```

## LukeForEntityPairClassification[[transformers.LukeForEntityPairClassification]]

#### transformers.LukeForEntityPairClassification[[transformers.LukeForEntityPairClassification]]

```python
transformers.LukeForEntityPairClassification(config: LukeConfig)
```

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/luke/modeling_luke.py#L1291)

**Tham số:**

config ([LukeConfig](/docs/transformers/v5.23.0/vi/model_doc/luke#transformers.LukeConfig)) : Lớp cấu hình mô hình chứa tất cả các tham số của mô hình. Khởi tạo bằng tệp cấu hình sẽ không tải trọng số liên quan đến mô hình, chỉ tải cấu hình. Xem phương thức [from_pretrained()](/docs/transformers/v5.23.0/vi/main_classes/model#transformers.PreTrainedModel.from_pretrained) để tải trọng số mô hình.

Mô hình LUKE với một đầu phân loại phía trên (một lớp tuyến tính phía trên các trạng thái ẩn của hai token thực thể) cho các tác vụ phân loại cặp thực thể, chẳng hạn như TACRED.

Mô hình này kế thừa từ [PreTrainedModel](/docs/transformers/v5.23.0/vi/main_classes/model#transformers.PreTrainedModel). Xem tài liệu của lớp cha để biết các phương thức chung mà thư viện triển khai cho tất cả các mô hình của nó (chẳng hạn như tải xuống hoặc lưu trữ, thay đổi kích thước các nhúng đầu vào, cắt tỉa các đầu ra, v.v.)

Mô hình này cũng là một lớp con của [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) trong PyTorch. Hãy sử dụng nó như một Module PyTorch thông thường và tham khảo tài liệu PyTorch cho mọi vấn đề liên quan đến cách sử dụng và hành vi chung.

#### forward[[transformers.LukeForEntityPairClassification.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, entity_ids: typing.Optional[torch.LongTensor] = None, entity_attention_mask: typing.Optional[torch.Tensor] = None, entity_token_type_ids: typing.Optional[torch.LongTensor] = None, entity_position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/luke/modeling_luke.py#L1304)

**Tham số:**

input_ids (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Chỉ số của các token trong chuỗi đầu vào theo từ vựng. Mặc định, các token đệm (padding) sẽ bị bỏ qua. Có thể lấy chỉ số bằng cách sử dụng [AutoTokenizer](/docs/transformers/v5.23.0/vi/model_doc/auto#transformers.AutoTokenizer). Xem [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) và [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) để biết chi tiết. [ID đầu vào là gì?](../glossary#input-ids)

attention_mask (`torch.Tensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Mặt nạ để tránh thực hiện chú ý trên các chỉ số token đệm. Các giá trị mặt nạ được chọn trong `[0, 1]`:  - 1 cho các token **không bị che**, - 0 cho các token **bị che**.  [Mặt nạ chú ý là gì?](../glossary#attention-mask)

token_type_ids (`torch.LongTensor` có shape `(batch_size, sequence_length)`, *tùy chọn*) : Các chỉ số token phân đoạn để chỉ định phần đầu và phần thứ hai của các đầu vào. Các chỉ số được chọn trong `[0, 1]`:  - 0 tương ứng với token *câu A*, - 1 tương ứng với token *câu B*.  [Các ID loại token là gì?](../glossary#token-type-ids)

position_ids (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Chỉ số của vị trí các token trong mỗi chuỗi đầu vào trong các embedding vị trí. Được chọn trong khoảng `[0, config.n_positions - 1]`.  [Position IDs là gì?](../glossary#position-ids)

entity_ids (`torch.LongTensor` có shape `(batch_size, entity_length)`) : Chỉ số của các token thực thể trong từ điển thực thể. Có thể lấy chỉ số bằng cách sử dụng [AutoTokenizer](/docs/transformers/v5.23.0/vi/model_doc/auto#transformers.AutoTokenizer). Xem [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) và [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) để biết thêm chi tiết.

entity_attention_mask (`torch.Tensor` có shape `(batch_size, entity_length)`, *tùy chọn*) : Mặt nạ để tránh thực hiện chú ý trên các chỉ số token entity padding. Các giá trị mặt nạ được chọn trong `[0, 1]`:  - 1 cho các token entity **không bị che**, - 0 cho các token entity **bị che**.

entity_token_type_ids (`torch.LongTensor` có shape `(batch_size, entity_length)`, *tùy chọn*) : Các chỉ số token phân đoạn để chỉ định phần đầu và phần thứ hai của đầu vào token thực thể. Các chỉ số được chọn trong `[0, 1]`:  - 0 tương ứng với token thực thể *phần A*, - 1 tương ứng với token thực thể *phần B*.

entity_position_ids (`torch.LongTensor` có shape `(batch_size, entity_length, max_mention_length)`, *tùy chọn*) : Chỉ số của các vị trí của mỗi entity đầu vào trong các position embeddings. Được chọn trong khoảng `[0, config.max_position_embeddings - 1]`.

inputs_embeds (`torch.Tensor` có hình dạng `(batch_size, sequence_length, hidden_size)`, *tùy chọn*) : Tùy chọn, thay vì truyền `input_ids`, bạn có thể chọn cách truyền trực tiếp một biểu diễn nhúng. Điều này hữu ích nếu bạn muốn kiểm soát nhiều hơn cách chuyển đổi các chỉ số `input_ids` thành các vector liên quan so với ma trận tra cứu nhúng nội bộ của mô hình.

labels (`torch.LongTensor` có shape `(batch_size,)` hoặc `(batch_size, num_labels)`, *tùy chọn*) : Nhãn để tính toán loss phân loại. Nếu shape là `(batch_size,)`, loss cross entropy sẽ được sử dụng cho phân loại đơn nhãn. Trong trường hợp này, labels nên chứa các chỉ số nằm trong `[0, ..., config.num_labels - 1]`. Nếu shape là `(batch_size, num_labels)`, loss binary cross entropy sẽ được sử dụng cho phân loại đa nhãn. Trong trường hợp này, labels chỉ nên chứa `[0, 1]`, trong đó 0 và 1 lần lượt chỉ định giá trị sai và đúng.

output_attentions (`bool`, *tùy chọn*) : Có trả về các tensor chú ý của tất cả các lớp chú ý hay không. Xem `attentions` trong phần tensor trả về để biết thêm chi tiết.

output_hidden_states (`bool`, *tuỳ chọn*) : Có trả về trạng thái ẩn của tất cả các lớp hay không. Xem `hidden_states` trong phần tensor trả về để biết thêm chi tiết.

return_dict (`bool`, *tùy chọn*) : Có trả về [ModelOutput](/docs/transformers/v5.23.0/vi/main_classes/output#transformers.utils.ModelOutput) thay vì một tuple thông thường hay không.

**Trả về:** `EntityPairClassificationOutput` hoặc `tuple(torch.Tensor)`

Một `EntityPairClassificationOutput` hoặc một tuple của `torch.Tensor` (nếu `return_dict=False` được truyền hoặc khi `config.return_dict=False`) bao gồm các phần tử khác nhau tùy thuộc vào cấu hình ([LukeConfig](/docs/transformers/v5.23.0/vi/model_doc/luke#transformers.LukeConfig)) và đầu vào.

Phương thức forward của [LukeForEntityPairClassification](/docs/transformers/v5.23.0/vi/model_doc/luke#transformers.LukeForEntityPairClassification) ghi đè lên phương thức đặc biệt `__call__`.

Mặc dù công thức cho bước truyền tiến cần được định nghĩa bên trong hàm này, bạn nên gọi instance của `Module` sau đó thay vì gọi hàm này, vì instance `Module` sẽ đảm nhận việc thực hiện các bước tiền xử lý và hậu xử lý, trong khi hàm này sẽ bỏ qua chúng một cách im lặng.

- **loss** (`torch.Tensor` có hình dạng `(1,)`, *tùy chọn*, được trả về khi `labels` được cung cấp) -- Tổn phân loại.
- **logits** (`torch.Tensor` có hình dạng `(batch_size, config.num_labels)`) -- Điểm phân loại (trước SoftMax).
- **hidden_states** (`tuple[torch.Tensor, ...]`, *tùy chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) -- Bộ tuple các `torch.Tensor` (một cho đầu ra của embeddings, nếu mô hình có lớp embedding, + một cho đầu ra của mỗi lớp) có hình dạng `(batch_size, sequence_length, hidden_size)`.

  Trạng thái ẩn của mô hình tại đầu ra của mỗi lớp cùng với các đầu ra embedding ban đầu tùy chọn.
- **entity_hidden_states** (`tuple(torch.Tensor)`, *tùy chọn*, được trả về khi truyền `output_hidden_states=True` hoặc khi `config.output_hidden_states=True`) -- Tuple của `torch.Tensor` (một cho đầu ra của embeddings + một cho đầu ra của mỗi lớp) có shape `(batch_size, entity_length, hidden_size)`. Entity hidden-states của mô hình tại đầu ra của mỗi lớp cùng với đầu ra của entity embedding ban đầu.
- **attentions** (`tuple[torch.Tensor, ...]`, *tùy chọn*, được trả về khi `output_attentions=True` được truyền vào hoặc khi `config.output_attentions=True`) -- Bộ tuple của `torch.Tensor` (một cho mỗi lớp) có hình dạng `(batch_size, num_heads, sequence_length, sequence_length)`.

  Trọng số chú ý sau softmax của attention, được sử dụng để tính trung bình có trọng số trong các đầu self-attention.

Ví dụ:

```python
>>> from transformers import AutoTokenizer, LukeForEntityPairClassification

>>> tokenizer = AutoTokenizer.from_pretrained("studio-ousia/luke-large-finetuned-tacred")
>>> model = LukeForEntityPairClassification.from_pretrained("studio-ousia/luke-large-finetuned-tacred")

>>> text = "Beyoncé lives in Los Angeles."
>>> entity_spans = [
...     (0, 7),
...     (17, 28),
... ]  # character-based entity spans corresponding to "Beyoncé" and "Los Angeles"
>>> inputs = tokenizer(text, entity_spans=entity_spans, return_tensors="pt")
>>> outputs = model(**inputs)
>>> logits = outputs.logits
>>> predicted_class_idx = logits.argmax(-1).item()
>>> print("Predicted class:", model.config.id2label[predicted_class_idx])
Predicted class: per:cities_of_residence
```

## LukeForEntitySpanClassification[[transformers.LukeForEntitySpanClassification]]

#### transformers.LukeForEntitySpanClassification[[transformers.LukeForEntitySpanClassification]]

```python
transformers.LukeForEntitySpanClassification(config: LukeConfig)
```

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/luke/modeling_luke.py#L1425)

**Tham số:**

config ([LukeConfig](/docs/transformers/v5.23.0/vi/model_doc/luke#transformers.LukeConfig)) : Lớp cấu hình mô hình chứa tất cả các tham số của mô hình. Khởi tạo bằng tệp cấu hình sẽ không tải trọng số liên quan đến mô hình, chỉ tải cấu hình. Xem phương thức [from_pretrained()](/docs/transformers/v5.23.0/vi/main_classes/model#transformers.PreTrainedModel.from_pretrained) để tải trọng số mô hình.

Mô hình LUKE với một đầu phân loại span phía trên (một lớp tuyến tính phía trên các trạng thái ẩn đầu ra) cho các tác vụ như nhận thực thể có tên.

Mô hình này kế thừa từ [PreTrainedModel](/docs/transformers/v5.23.0/vi/main_classes/model#transformers.PreTrainedModel). Xem tài liệu của lớp cha để biết các phương thức chung mà thư viện triển khai cho tất cả các mô hình của nó (chẳng hạn như tải xuống hoặc lưu trữ, thay đổi kích thước các nhúng đầu vào, cắt tỉa các đầu ra, v.v.)

Mô hình này cũng là một lớp con của [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) trong PyTorch. Hãy sử dụng nó như một Module PyTorch thông thường và tham khảo tài liệu PyTorch cho mọi vấn đề liên quan đến cách sử dụng và hành vi chung.

#### forward[[transformers.LukeForEntitySpanClassification.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, entity_ids: typing.Optional[torch.LongTensor] = None, entity_attention_mask: typing.Optional[torch.LongTensor] = None, entity_token_type_ids: typing.Optional[torch.LongTensor] = None, entity_position_ids: typing.Optional[torch.LongTensor] = None, entity_start_positions: typing.Optional[torch.LongTensor] = None, entity_end_positions: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/luke/modeling_luke.py#L1438)

**Tham số:**

input_ids (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Chỉ số của các token trong chuỗi đầu vào theo từ vựng. Mặc định, các token đệm (padding) sẽ bị bỏ qua. Có thể lấy chỉ số bằng cách sử dụng [AutoTokenizer](/docs/transformers/v5.23.0/vi/model_doc/auto#transformers.AutoTokenizer). Xem [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) và [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) để biết chi tiết. [ID đầu vào là gì?](../glossary#input-ids)

attention_mask (`torch.Tensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Mặt nạ để tránh thực hiện chú ý trên các chỉ số token đệm. Các giá trị mặt nạ được chọn trong `[0, 1]`:  - 1 cho các token **không bị che**, - 0 cho các token **bị che**.  [Mặt nạ chú ý là gì?](../glossary#attention-mask)

token_type_ids (`torch.LongTensor` có shape `(batch_size, sequence_length)`, *tùy chọn*) : Các chỉ số token phân đoạn để chỉ định phần đầu và phần thứ hai của các đầu vào. Các chỉ số được chọn trong `[0, 1]`:  - 0 tương ứng với token *câu A*, - 1 tương ứng với token *câu B*.  [Các ID loại token là gì?](../glossary#token-type-ids)

position_ids (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Chỉ số của vị trí các token trong mỗi chuỗi đầu vào trong các embedding vị trí. Được chọn trong khoảng `[0, config.n_positions - 1]`.  [Position IDs là gì?](../glossary#position-ids)

entity_ids (`torch.LongTensor` có shape `(batch_size, entity_length)`) : Chỉ số của các token thực thể trong từ điển thực thể. Có thể lấy chỉ số bằng cách sử dụng [AutoTokenizer](/docs/transformers/v5.23.0/vi/model_doc/auto#transformers.AutoTokenizer). Xem [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) và [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) để biết thêm chi tiết.

entity_attention_mask (`torch.Tensor` có shape `(batch_size, entity_length)`, *tùy chọn*) : Mặt nạ để tránh thực hiện chú ý trên các chỉ số token entity padding. Các giá trị mặt nạ được chọn trong `[0, 1]`:  - 1 cho các token entity **không bị che**, - 0 cho các token entity **bị che**.

entity_token_type_ids (`torch.LongTensor` có shape `(batch_size, entity_length)`, *tùy chọn*) : Các chỉ số token phân đoạn để chỉ định phần đầu và phần thứ hai của đầu vào token thực thể. Các chỉ số được chọn trong `[0, 1]`:  - 0 tương ứng với token thực thể *phần A*, - 1 tương ứng với token thực thể *phần B*.

entity_position_ids (`torch.LongTensor` có shape `(batch_size, entity_length, max_mention_length)`, *tùy chọn*) : Chỉ số của các vị trí của mỗi entity đầu vào trong các position embeddings. Được chọn trong khoảng `[0, config.max_position_embeddings - 1]`.

entity_start_positions (`torch.LongTensor`, *tùy chọn*) : Các vị trí bắt đầu của các thực thể trong chuỗi token từ.

entity_end_positions (`torch.LongTensor`, *tùy chọn*) : Các vị trí kết thúc của các thực thể trong chuỗi token từ.

inputs_embeds (`torch.Tensor` có hình dạng `(batch_size, sequence_length, hidden_size)`, *tùy chọn*) : Tùy chọn, thay vì truyền `input_ids`, bạn có thể chọn cách truyền trực tiếp một biểu diễn nhúng. Điều này hữu ích nếu bạn muốn kiểm soát nhiều hơn cách chuyển đổi các chỉ số `input_ids` thành các vector liên quan so với ma trận tra cứu nhúng nội bộ của mô hình.

labels (`torch.LongTensor` có shape `(batch_size, entity_length)` hoặc `(batch_size, entity_length, num_labels)`, *tùy chọn*) : Nhãn để tính toán loss phân loại. Nếu shape là `(batch_size, entity_length)`, loss entropy chéo sẽ được sử dụng cho phân loại đơn nhãn. Trong trường hợp này, labels nên chứa các chỉ số nằm trong `[0, ..., config.num_labels - 1]`. Nếu shape là `(batch_size, entity_length, num_labels)`, loss entropy chéo nhị phân sẽ được sử dụng cho phân loại đa nhãn. Trong trường hợp này, labels chỉ nên chứa `[0, 1]`, trong đó 0 và 1 lần lượt chỉ định giá trị sai và đúng.

output_attentions (`bool`, *tùy chọn*) : Có trả về các tensor chú ý của tất cả các lớp chú ý hay không. Xem `attentions` trong phần tensor trả về để biết thêm chi tiết.

output_hidden_states (`bool`, *tuỳ chọn*) : Có trả về trạng thái ẩn của tất cả các lớp hay không. Xem `hidden_states` trong phần tensor trả về để biết thêm chi tiết.

return_dict (`bool`, *tùy chọn*) : Có trả về [ModelOutput](/docs/transformers/v5.23.0/vi/main_classes/output#transformers.utils.ModelOutput) thay vì một tuple thông thường hay không.

**Trả về:** `EntitySpanClassificationOutput` hoặc `tuple(torch.Tensor)`

Một `EntitySpanClassificationOutput` hoặc một tuple của `torch.Tensor` (nếu `return_dict=False` được truyền hoặc khi `config.return_dict=False`) bao gồm các phần tử khác nhau tùy thuộc vào cấu hình ([LukeConfig](/docs/transformers/v5.23.0/vi/model_doc/luke#transformers.LukeConfig)) và đầu vào.

Phương thức forward của [LukeForEntitySpanClassification](/docs/transformers/v5.23.0/vi/model_doc/luke#transformers.LukeForEntitySpanClassification) ghi đè lên phương thức đặc biệt `__call__`.

Mặc dù công thức cho bước truyền tiến cần được định nghĩa bên trong hàm này, bạn nên gọi instance của `Module` sau đó thay vì gọi hàm này, vì instance `Module` sẽ đảm nhận việc thực hiện các bước tiền xử lý và hậu xử lý, trong khi hàm này sẽ bỏ qua chúng một cách im lặng.

- **loss** (`torch.Tensor` có hình dạng `(1,)`, *tùy chọn*, được trả về khi `labels` được cung cấp) -- Tổn phân loại.
- **logits** (`torch.Tensor` có hình dạng `(batch_size, entity_length, config.num_labels)`) -- Điểm phân loại (trước SoftMax).
- **hidden_states** (`tuple[torch.Tensor, ...]`, *tùy chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) -- Bộ tuple các `torch.Tensor` (một cho đầu ra của embeddings, nếu mô hình có lớp embedding, + một cho đầu ra của mỗi lớp) có hình dạng `(batch_size, sequence_length, hidden_size)`.

  Trạng thái ẩn của mô hình tại đầu ra của mỗi lớp cùng với các đầu ra embedding ban đầu tùy chọn.
- **entity_hidden_states** (`tuple(torch.Tensor)`, *tùy chọn*, được trả về khi truyền `output_hidden_states=True` hoặc khi `config.output_hidden_states=True`) -- Tuple của `torch.Tensor` (một cho đầu ra của embeddings + một cho đầu ra của mỗi lớp) có shape `(batch_size, entity_length, hidden_size)`. Entity hidden-states của mô hình tại đầu ra của mỗi lớp cùng với đầu ra của entity embedding ban đầu.
- **attentions** (`tuple[torch.Tensor, ...]`, *tùy chọn*, được trả về khi `output_attentions=True` được truyền vào hoặc khi `config.output_attentions=True`) -- Bộ tuple của `torch.Tensor` (một cho mỗi lớp) có hình dạng `(batch_size, num_heads, sequence_length, sequence_length)`.

  Trọng số chú ý sau softmax của attention, được sử dụng để tính trung bình có trọng số trong các đầu self-attention.

Ví dụ:

```python
>>> from transformers import AutoTokenizer, LukeForEntitySpanClassification

>>> tokenizer = AutoTokenizer.from_pretrained("studio-ousia/luke-large-finetuned-conll-2003")
>>> model = LukeForEntitySpanClassification.from_pretrained("studio-ousia/luke-large-finetuned-conll-2003")

>>> text = "Beyoncé lives in Los Angeles"
# List all possible entity spans in the text

>>> word_start_positions = [0, 8, 14, 17, 21]  # character-based start positions of word tokens
>>> word_end_positions = [7, 13, 16, 20, 28]  # character-based end positions of word tokens
>>> entity_spans = []
>>> for i, start_pos in enumerate(word_start_positions):
...     for end_pos in word_end_positions[i:]:
...         entity_spans.append((start_pos, end_pos))

>>> inputs = tokenizer(text, entity_spans=entity_spans, return_tensors="pt")
>>> outputs = model(**inputs)
>>> logits = outputs.logits
>>> predicted_class_indices = logits.argmax(-1).squeeze().tolist()
>>> for span, predicted_class_idx in zip(entity_spans, predicted_class_indices):
...     if predicted_class_idx != 0:
...         print(text[span[0] : span[1]], model.config.id2label[predicted_class_idx])
Beyoncé PER
Los Angeles LOC
```

## LukeForSequenceClassification[[transformers.LukeForSequenceClassification]]

#### transformers.LukeForSequenceClassification[[transformers.LukeForSequenceClassification]]

```python
transformers.LukeForSequenceClassification(config: LukeConfig)
```

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/luke/modeling_luke.py#L1583)

**Tham số:**

config ([LukeConfig](/docs/transformers/v5.23.0/vi/model_doc/luke#transformers.LukeConfig)) : Lớp cấu hình mô hình chứa tất cả các tham số của mô hình. Khởi tạo bằng tệp cấu hình sẽ không tải trọng số liên quan đến mô hình, chỉ tải cấu hình. Xem phương thức [from_pretrained()](/docs/transformers/v5.23.0/vi/main_classes/model#transformers.PreTrainedModel.from_pretrained) để tải trọng số mô hình.

Model transformer LUKE với đầu phân loại/hồi quy chuỗi ở trên (một lớp tuyến tính trên đầu ra đã được pool) ví dụ cho các tác vụ GLUE.

Mô hình này kế thừa từ [PreTrainedModel](/docs/transformers/v5.23.0/vi/main_classes/model#transformers.PreTrainedModel). Xem tài liệu của lớp cha để biết các phương thức chung mà thư viện triển khai cho tất cả các mô hình của nó (chẳng hạn như tải xuống hoặc lưu trữ, thay đổi kích thước các nhúng đầu vào, cắt tỉa các đầu ra, v.v.)

Mô hình này cũng là một lớp con của [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) trong PyTorch. Hãy sử dụng nó như một Module PyTorch thông thường và tham khảo tài liệu PyTorch cho mọi vấn đề liên quan đến cách sử dụng và hành vi chung.

#### forward[[transformers.LukeForSequenceClassification.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, entity_ids: typing.Optional[torch.LongTensor] = None, entity_attention_mask: typing.Optional[torch.Tensor] = None, entity_token_type_ids: typing.Optional[torch.LongTensor] = None, entity_position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/luke/modeling_luke.py#L1596)

**Tham số:**

input_ids (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Chỉ số của các token trong chuỗi đầu vào theo từ vựng. Mặc định, các token đệm (padding) sẽ bị bỏ qua. Có thể lấy chỉ số bằng cách sử dụng [AutoTokenizer](/docs/transformers/v5.23.0/vi/model_doc/auto#transformers.AutoTokenizer). Xem [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) và [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) để biết chi tiết. [ID đầu vào là gì?](../glossary#input-ids)

attention_mask (`torch.Tensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Mặt nạ để tránh thực hiện chú ý trên các chỉ số token đệm. Các giá trị mặt nạ được chọn trong `[0, 1]`:  - 1 cho các token **không bị che**, - 0 cho các token **bị che**.  [Mặt nạ chú ý là gì?](../glossary#attention-mask)

token_type_ids (`torch.LongTensor` có shape `(batch_size, sequence_length)`, *tùy chọn*) : Các chỉ số token phân đoạn để chỉ định phần đầu và phần thứ hai của các đầu vào. Các chỉ số được chọn trong `[0, 1]`:  - 0 tương ứng với token *câu A*, - 1 tương ứng với token *câu B*.  [Các ID loại token là gì?](../glossary#token-type-ids)

position_ids (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Chỉ số của vị trí các token trong mỗi chuỗi đầu vào trong các embedding vị trí. Được chọn trong khoảng `[0, config.n_positions - 1]`.  [Position IDs là gì?](../glossary#position-ids)

entity_ids (`torch.LongTensor` có shape `(batch_size, entity_length)`) : Chỉ số của các token thực thể trong từ điển thực thể. Có thể lấy chỉ số bằng cách sử dụng [AutoTokenizer](/docs/transformers/v5.23.0/vi/model_doc/auto#transformers.AutoTokenizer). Xem [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) và [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) để biết thêm chi tiết.

entity_attention_mask (`torch.Tensor` có shape `(batch_size, entity_length)`, *tùy chọn*) : Mặt nạ để tránh thực hiện chú ý trên các chỉ số token entity padding. Các giá trị mặt nạ được chọn trong `[0, 1]`:  - 1 cho các token entity **không bị che**, - 0 cho các token entity **bị che**.

entity_token_type_ids (`torch.LongTensor` có shape `(batch_size, entity_length)`, *tùy chọn*) : Các chỉ số token phân đoạn để chỉ định phần đầu và phần thứ hai của đầu vào token thực thể. Các chỉ số được chọn trong `[0, 1]`:  - 0 tương ứng với token thực thể *phần A*, - 1 tương ứng với token thực thể *phần B*.

entity_position_ids (`torch.LongTensor` có shape `(batch_size, entity_length, max_mention_length)`, *tùy chọn*) : Chỉ số của các vị trí của mỗi entity đầu vào trong các position embeddings. Được chọn trong khoảng `[0, config.max_position_embeddings - 1]`.

inputs_embeds (`torch.Tensor` có hình dạng `(batch_size, sequence_length, hidden_size)`, *tùy chọn*) : Tùy chọn, thay vì truyền `input_ids`, bạn có thể chọn cách truyền trực tiếp một biểu diễn nhúng. Điều này hữu ích nếu bạn muốn kiểm soát nhiều hơn cách chuyển đổi các chỉ số `input_ids` thành các vector liên quan so với ma trận tra cứu nhúng nội bộ của mô hình.

labels (`torch.LongTensor` có hình dạng `(batch_size,)`, *tùy chọn*) : Nhãn để tính toán tổn thất phân loại/hồi quy chuỗi. Chỉ số phải nằm trong `[0, ..., config.num_labels - 1]`. Nếu `config.num_labels == 1`, tổn thất hồi quy sẽ được tính toán (tổn thất Mean-Square). Nếu `config.num_labels > 1`, tổn thất phân loại sẽ được tính toán (Cross-Entropy).

output_attentions (`bool`, *tùy chọn*) : Có trả về các tensor chú ý của tất cả các lớp chú ý hay không. Xem `attentions` trong phần tensor trả về để biết thêm chi tiết.

output_hidden_states (`bool`, *tuỳ chọn*) : Có trả về trạng thái ẩn của tất cả các lớp hay không. Xem `hidden_states` trong phần tensor trả về để biết thêm chi tiết.

return_dict (`bool`, *tùy chọn*) : Có trả về [ModelOutput](/docs/transformers/v5.23.0/vi/main_classes/output#transformers.utils.ModelOutput) thay vì một tuple thông thường hay không.

**Trả về:** `LukeSequenceClassifierOutput` hoặc `tuple(torch.Tensor)`

Một `LukeSequenceClassifierOutput` hoặc một tuple của `torch.Tensor` (nếu `return_dict=False` được truyền hoặc khi `config.return_dict=False`) bao gồm các phần tử khác nhau tùy thuộc vào cấu hình ([LukeConfig](/docs/transformers/v5.23.0/vi/model_doc/luke#transformers.LukeConfig)) và đầu vào.

Phương thức forward của [LukeForSequenceClassification](/docs/transformers/v5.23.0/vi/model_doc/luke#transformers.LukeForSequenceClassification) ghi đè lên phương thức đặc biệt `__call__`.

Mặc dù công thức cho bước truyền tiến cần được định nghĩa bên trong hàm này, bạn nên gọi instance của `Module` sau đó thay vì gọi hàm này, vì instance `Module` sẽ đảm nhận việc thực hiện các bước tiền xử lý và hậu xử lý, trong khi hàm này sẽ bỏ qua chúng một cách im lặng.

- **loss** (`torch.Tensor` có shape `(1,)`, *optional*, được trả về khi `labels` được cung cấp) -- Loss phân loại (hoặc hồi quy nếu config.num_labels==1).
- **logits** (`torch.Tensor` có hình dạng `(batch_size, config.num_labels)`) -- Điểm phân loại (hoặc hồi quy nếu config.num_labels==1) (trước SoftMax).
- **hidden_states** (`tuple[torch.Tensor, ...]`, *tùy chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) -- Bộ tuple các `torch.Tensor` (một cho đầu ra của embeddings, nếu mô hình có lớp embedding, + một cho đầu ra của mỗi lớp) có hình dạng `(batch_size, sequence_length, hidden_size)`.

  Trạng thái ẩn của mô hình tại đầu ra của mỗi lớp cùng với các đầu ra embedding ban đầu tùy chọn.
- **entity_hidden_states** (`tuple(torch.Tensor)`, *tùy chọn*, được trả về khi truyền `output_hidden_states=True` hoặc khi `config.output_hidden_states=True`) -- Tuple của `torch.Tensor` (một cho đầu ra của embeddings + một cho đầu ra của mỗi lớp) có shape `(batch_size, entity_length, hidden_size)`. Entity hidden-states của mô hình tại đầu ra của mỗi lớp cùng với đầu ra của entity embedding ban đầu.
- **attentions** (`tuple[torch.Tensor, ...]`, *tùy chọn*, được trả về khi `output_attentions=True` được truyền vào hoặc khi `config.output_attentions=True`) -- Bộ tuple của `torch.Tensor` (một cho mỗi lớp) có hình dạng `(batch_size, num_heads, sequence_length, sequence_length)`.

  Trọng số chú ý sau softmax của attention, được sử dụng để tính trung bình có trọng số trong các đầu self-attention.

Ví dụ về phân loại nhãn đơn:

```python
>>> import torch
>>> from transformers import AutoTokenizer, LukeForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("studio-ousia/luke-base")
>>> model = LukeForSequenceClassification.from_pretrained("studio-ousia/luke-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 = LukeForSequenceClassification.from_pretrained("studio-ousia/luke-base", num_labels=num_labels)

>>> labels = torch.tensor([1])
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
...
```

Ví dụ về phân loại đa nhãn:

```python
>>> import torch
>>> from transformers import AutoTokenizer, LukeForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("studio-ousia/luke-base")
>>> model = LukeForSequenceClassification.from_pretrained("studio-ousia/luke-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 = LukeForSequenceClassification.from_pretrained(
...     "studio-ousia/luke-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
```

## LukeForMultipleChoice[[transformers.LukeForMultipleChoice]]

#### transformers.LukeForMultipleChoice[[transformers.LukeForMultipleChoice]]

```python
transformers.LukeForMultipleChoice(config: LukeConfig)
```

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/luke/modeling_luke.py#L1926)

**Tham số:**

config ([LukeConfig](/docs/transformers/v5.23.0/vi/model_doc/luke#transformers.LukeConfig)) : Lớp cấu hình mô hình chứa tất cả các tham số của mô hình. Khởi tạo bằng tệp cấu hình sẽ không tải trọng số liên quan đến mô hình, chỉ tải cấu hình. Xem phương thức [from_pretrained()](/docs/transformers/v5.23.0/vi/main_classes/model#transformers.PreTrainedModel.from_pretrained) để tải trọng số mô hình.

Mô hình Luke với đầu phân loại lựa chọn nhiều phương án ở trên (một lớp tuyến tính trên đầu ra đã được gộp và một softmax), ví dụ cho các tác vụ RocStories/SWAG.

Mô hình này kế thừa từ [PreTrainedModel](/docs/transformers/v5.23.0/vi/main_classes/model#transformers.PreTrainedModel). Xem tài liệu của lớp cha để biết các phương thức chung mà thư viện triển khai cho tất cả các mô hình của nó (chẳng hạn như tải xuống hoặc lưu trữ, thay đổi kích thước các nhúng đầu vào, cắt tỉa các đầu ra, v.v.)

Mô hình này cũng là một lớp con của [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) trong PyTorch. Hãy sử dụng nó như một Module PyTorch thông thường và tham khảo tài liệu PyTorch cho mọi vấn đề liên quan đến cách sử dụng và hành vi chung.

#### forward[[transformers.LukeForMultipleChoice.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, entity_ids: typing.Optional[torch.LongTensor] = None, entity_attention_mask: typing.Optional[torch.Tensor] = None, entity_token_type_ids: typing.Optional[torch.LongTensor] = None, entity_position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/luke/modeling_luke.py#L1939)

**Tham số:**

input_ids (`torch.LongTensor` có shape `(batch_size, num_choices, sequence_length)`) : Chỉ số của các token trong chuỗi đầu vào thuộc từ vựng.  Các chỉ số này có thể được lấy bằng cách sử dụng [AutoTokenizer](/docs/transformers/v5.23.0/vi/model_doc/auto#transformers.AutoTokenizer). Xem [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) và [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) để biết thêm chi tiết.  [Input IDs là gì?](../glossary#input-ids)

attention_mask (`torch.Tensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Mặt nạ để tránh thực hiện chú ý trên các chỉ số token đệm. Các giá trị mặt nạ được chọn trong `[0, 1]`:  - 1 cho các token **không bị che**, - 0 cho các token **bị che**.  [Mặt nạ chú ý là gì?](../glossary#attention-mask)

token_type_ids (`torch.LongTensor` có shape `(batch_size, num_choices, sequence_length)`, *tùy chọn*) : Chỉ số token phân đoạn để chỉ định phần đầu và phần thứ hai của đầu vào. Các chỉ số được chọn trong `[0, 1]`:  - 0 tương ứng với token *sentence A*, - 1 tương ứng với token *sentence B*.  [Token type IDs là gì?](../glossary#token-type-ids)

position_ids (`torch.LongTensor` có shape `(batch_size, num_choices, sequence_length)`, *tùy chọn*) : Chỉ số của vị trí các token trong mỗi chuỗi đầu vào trong các position embeddings. Được chọn trong khoảng `[0, config.max_position_embeddings - 1]`.  [Position IDs là gì?](../glossary#position-ids)

entity_ids (`torch.LongTensor` có shape `(batch_size, entity_length)`) : Chỉ số của các token thực thể trong từ điển thực thể. Có thể lấy chỉ số bằng cách sử dụng [AutoTokenizer](/docs/transformers/v5.23.0/vi/model_doc/auto#transformers.AutoTokenizer). Xem [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) và [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) để biết thêm chi tiết.

entity_attention_mask (`torch.Tensor` có shape `(batch_size, entity_length)`, *tùy chọn*) : Mặt nạ để tránh thực hiện chú ý trên các chỉ số token entity padding. Các giá trị mặt nạ được chọn trong `[0, 1]`:  - 1 cho các token entity **không bị che**, - 0 cho các token entity **bị che**.

entity_token_type_ids (`torch.LongTensor` có shape `(batch_size, entity_length)`, *tùy chọn*) : Các chỉ số token phân đoạn để chỉ định phần đầu và phần thứ hai của đầu vào token thực thể. Các chỉ số được chọn trong `[0, 1]`:  - 0 tương ứng với token thực thể *phần A*, - 1 tương ứng với token thực thể *phần B*.

entity_position_ids (`torch.LongTensor` có shape `(batch_size, entity_length, max_mention_length)`, *tùy chọn*) : Chỉ số của các vị trí của mỗi entity đầu vào trong các position embeddings. Được chọn trong khoảng `[0, config.max_position_embeddings - 1]`.

inputs_embeds (`torch.Tensor` có hình dạng `(batch_size, num_choices, sequence_length, hidden_size)`, *tùy chọn*) : Tùy chọn, thay vì truyền `input_ids`, bạn có thể chọn truyền trực tiếp một biểu diễn nhúng. Điều này hữu ích nếu bạn muốn kiểm soát nhiều hơn cách chuyển đổi các chỉ số `input_ids` thành các vector liên quan so với ma trận tra cứu nhúng nội bộ của mô hình.

labels (`torch.LongTensor` có hình dạng `(batch_size,)`, *tùy chọn*) : Nhãn để tính toán tổn thất phân loại lựa chọn nhiều. Chỉ số phải nằm trong `[0, ..., num_choices-1]` trong đó `num_choices` là kích thước của chiều thứ hai của các tensor đầu vào. (Xem `input_ids` ở trên)

output_attentions (`bool`, *tùy chọn*) : Có trả về các tensor chú ý của tất cả các lớp chú ý hay không. Xem `attentions` trong phần tensor trả về để biết thêm chi tiết.

output_hidden_states (`bool`, *tuỳ chọn*) : Có trả về trạng thái ẩn của tất cả các lớp hay không. Xem `hidden_states` trong phần tensor trả về để biết thêm chi tiết.

return_dict (`bool`, *tùy chọn*) : Có trả về [ModelOutput](/docs/transformers/v5.23.0/vi/main_classes/output#transformers.utils.ModelOutput) thay vì một tuple thông thường hay không.

**Trả về:** `LukeMultipleChoiceModelOutput` hoặc `tuple(torch.Tensor)`

Một `LukeMultipleChoiceModelOutput` hoặc một tuple của `torch.Tensor` (nếu `return_dict=False` được truyền hoặc khi `config.return_dict=False`) bao gồm các phần tử khác nhau tùy thuộc vào cấu hình ([LukeConfig](/docs/transformers/v5.23.0/vi/model_doc/luke#transformers.LukeConfig)) và đầu vào.

Phương thức forward của [LukeForMultipleChoice](/docs/transformers/v5.23.0/vi/model_doc/luke#transformers.LukeForMultipleChoice) ghi đè lên phương thức đặc biệt `__call__`.

Mặc dù công thức cho bước truyền tiến cần được định nghĩa bên trong hàm này, bạn nên gọi instance của `Module` sau đó thay vì gọi hàm này, vì instance `Module` sẽ đảm nhận việc thực hiện các bước tiền xử lý và hậu xử lý, trong khi hàm này sẽ bỏ qua chúng một cách im lặng.

- **loss** (`torch.Tensor` có hình dạng *(1,)*, *tùy chọn*, được trả về khi `labels` được cung cấp) -- Tổn phân loại.
- **logits** (`torch.Tensor` có shape `(batch_size, num_choices)`) -- *num_choices* là chiều thứ hai của các tensor đầu vào. (xem *input_ids* ở trên).

  Điểm phân loại (trước SoftMax).
- **hidden_states** (`tuple[torch.Tensor, ...]`, *tùy chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) -- Bộ tuple các `torch.Tensor` (một cho đầu ra của embeddings, nếu mô hình có lớp embedding, + một cho đầu ra của mỗi lớp) có hình dạng `(batch_size, sequence_length, hidden_size)`.

  Trạng thái ẩn của mô hình tại đầu ra của mỗi lớp cùng với các đầu ra embedding ban đầu tùy chọn.
- **entity_hidden_states** (`tuple(torch.Tensor)`, *tùy chọn*, được trả về khi truyền `output_hidden_states=True` hoặc khi `config.output_hidden_states=True`) -- Tuple của `torch.Tensor` (một cho đầu ra của embeddings + một cho đầu ra của mỗi lớp) có shape `(batch_size, entity_length, hidden_size)`. Entity hidden-states của mô hình tại đầu ra của mỗi lớp cùng với đầu ra của entity embedding ban đầu.
- **attentions** (`tuple[torch.Tensor, ...]`, *tùy chọn*, được trả về khi `output_attentions=True` được truyền vào hoặc khi `config.output_attentions=True`) -- Bộ tuple của `torch.Tensor` (một cho mỗi lớp) có hình dạng `(batch_size, num_heads, sequence_length, sequence_length)`.

  Trọng số chú ý sau softmax của attention, được sử dụng để tính trung bình có trọng số trong các đầu self-attention.

Ví dụ:

```python
>>> from transformers import AutoTokenizer, LukeForMultipleChoice
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("studio-ousia/luke-base")
>>> model = LukeForMultipleChoice.from_pretrained("studio-ousia/luke-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
```

## LukeForTokenClassification[[transformers.LukeForTokenClassification]]

#### transformers.LukeForTokenClassification[[transformers.LukeForTokenClassification]]

```python
transformers.LukeForTokenClassification(config: LukeConfig)
```

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/luke/modeling_luke.py#L1705)

**Tham số:**

config ([LukeConfig](/docs/transformers/v5.23.0/vi/model_doc/luke#transformers.LukeConfig)) : Lớp cấu hình mô hình chứa tất cả các tham số của mô hình. Khởi tạo bằng tệp cấu hình sẽ không tải trọng số liên quan đến mô hình, chỉ tải cấu hình. Xem phương thức [from_pretrained()](/docs/transformers/v5.23.0/vi/main_classes/model#transformers.PreTrainedModel.from_pretrained) để tải trọng số mô hình.

Mô hình LUKE với đầu phân loại token phía trên (một lớp tuyến tính phía trên đầu ra hidden-states). Để giải quyết tác vụ Nhận thực thể có tên (NER) bằng LUKE, `LukeForEntitySpanClassification` phù hợp hơn so với lớp này.

Mô hình này kế thừa từ [PreTrainedModel](/docs/transformers/v5.23.0/vi/main_classes/model#transformers.PreTrainedModel). Xem tài liệu của lớp cha để biết các phương thức chung mà thư viện triển khai cho tất cả các mô hình của nó (chẳng hạn như tải xuống hoặc lưu trữ, thay đổi kích thước các nhúng đầu vào, cắt tỉa các đầu ra, v.v.)

Mô hình này cũng là một lớp con của [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) trong PyTorch. Hãy sử dụng nó như một Module PyTorch thông thường và tham khảo tài liệu PyTorch cho mọi vấn đề liên quan đến cách sử dụng và hành vi chung.

#### forward[[transformers.LukeForTokenClassification.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, entity_ids: typing.Optional[torch.LongTensor] = None, entity_attention_mask: typing.Optional[torch.Tensor] = None, entity_token_type_ids: typing.Optional[torch.LongTensor] = None, entity_position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/luke/modeling_luke.py#L1719)

**Tham số:**

input_ids (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Chỉ số của các token trong chuỗi đầu vào theo từ vựng. Mặc định, các token đệm (padding) sẽ bị bỏ qua. Có thể lấy chỉ số bằng cách sử dụng [AutoTokenizer](/docs/transformers/v5.23.0/vi/model_doc/auto#transformers.AutoTokenizer). Xem [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) và [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) để biết chi tiết. [ID đầu vào là gì?](../glossary#input-ids)

attention_mask (`torch.Tensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Mặt nạ để tránh thực hiện chú ý trên các chỉ số token đệm. Các giá trị mặt nạ được chọn trong `[0, 1]`:  - 1 cho các token **không bị che**, - 0 cho các token **bị che**.  [Mặt nạ chú ý là gì?](../glossary#attention-mask)

token_type_ids (`torch.LongTensor` có shape `(batch_size, sequence_length)`, *tùy chọn*) : Các chỉ số token phân đoạn để chỉ định phần đầu và phần thứ hai của các đầu vào. Các chỉ số được chọn trong `[0, 1]`:  - 0 tương ứng với token *câu A*, - 1 tương ứng với token *câu B*.  [Các ID loại token là gì?](../glossary#token-type-ids)

position_ids (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Chỉ số của vị trí các token trong mỗi chuỗi đầu vào trong các embedding vị trí. Được chọn trong khoảng `[0, config.n_positions - 1]`.  [Position IDs là gì?](../glossary#position-ids)

entity_ids (`torch.LongTensor` có shape `(batch_size, entity_length)`) : Chỉ số của các token thực thể trong từ điển thực thể. Có thể lấy chỉ số bằng cách sử dụng [AutoTokenizer](/docs/transformers/v5.23.0/vi/model_doc/auto#transformers.AutoTokenizer). Xem [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) và [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) để biết thêm chi tiết.

entity_attention_mask (`torch.Tensor` có shape `(batch_size, entity_length)`, *tùy chọn*) : Mặt nạ để tránh thực hiện chú ý trên các chỉ số token entity padding. Các giá trị mặt nạ được chọn trong `[0, 1]`:  - 1 cho các token entity **không bị che**, - 0 cho các token entity **bị che**.

entity_token_type_ids (`torch.LongTensor` có shape `(batch_size, entity_length)`, *tùy chọn*) : Các chỉ số token phân đoạn để chỉ định phần đầu và phần thứ hai của đầu vào token thực thể. Các chỉ số được chọn trong `[0, 1]`:  - 0 tương ứng với token thực thể *phần A*, - 1 tương ứng với token thực thể *phần B*.

entity_position_ids (`torch.LongTensor` có shape `(batch_size, entity_length, max_mention_length)`, *tùy chọn*) : Chỉ số của các vị trí của mỗi entity đầu vào trong các position embeddings. Được chọn trong khoảng `[0, config.max_position_embeddings - 1]`.

inputs_embeds (`torch.Tensor` có hình dạng `(batch_size, sequence_length, hidden_size)`, *tùy chọn*) : Tùy chọn, thay vì truyền `input_ids`, bạn có thể chọn cách truyền trực tiếp một biểu diễn nhúng. Điều này hữu ích nếu bạn muốn kiểm soát nhiều hơn cách chuyển đổi các chỉ số `input_ids` thành các vector liên quan so với ma trận tra cứu nhúng nội bộ của mô hình.

labels (`torch.LongTensor` có hình dạng `(batch_size,)`, *tùy chọn*) : Nhãn để tính toán tổn thất phân loại lựa chọn nhiều. Chỉ số phải nằm trong `[0, ..., num_choices-1]` trong đó `num_choices` là kích thước của chiều thứ hai của các tensor đầu vào. (Xem `input_ids` ở trên)

output_attentions (`bool`, *tùy chọn*) : Có trả về các tensor chú ý của tất cả các lớp chú ý hay không. Xem `attentions` trong phần tensor trả về để biết thêm chi tiết.

output_hidden_states (`bool`, *tuỳ chọn*) : Có trả về trạng thái ẩn của tất cả các lớp hay không. Xem `hidden_states` trong phần tensor trả về để biết thêm chi tiết.

return_dict (`bool`, *tùy chọn*) : Có trả về [ModelOutput](/docs/transformers/v5.23.0/vi/main_classes/output#transformers.utils.ModelOutput) thay vì một tuple thông thường hay không.

**Trả về:** `LukeTokenClassifierOutput` hoặc `tuple(torch.Tensor)`

Một `LukeTokenClassifierOutput` hoặc một tuple của `torch.Tensor` (nếu `return_dict=False` được truyền hoặc khi `config.return_dict=False`) bao gồm các phần tử khác nhau tùy thuộc vào cấu hình ([LukeConfig](/docs/transformers/v5.23.0/vi/model_doc/luke#transformers.LukeConfig)) và đầu vào.

Phương thức forward của [LukeForTokenClassification](/docs/transformers/v5.23.0/vi/model_doc/luke#transformers.LukeForTokenClassification) ghi đè lên phương thức đặc biệt `__call__`.

Mặc dù công thức cho bước truyền tiến cần được định nghĩa bên trong hàm này, bạn nên gọi instance của `Module` sau đó thay vì gọi hàm này, vì instance `Module` sẽ đảm nhận việc thực hiện các bước tiền xử lý và hậu xử lý, trong khi hàm này sẽ bỏ qua chúng một cách im lặng.

- **loss** (`torch.Tensor` có hình dạng `(1,)`, *tùy chọn*, được trả về khi `labels` được cung cấp) -- Tổn phân loại.
- **logits** (`torch.Tensor` có hình dạng `(batch_size, sequence_length, config.num_labels)`) -- Điểm phân loại (trước SoftMax).
- **hidden_states** (`tuple[torch.Tensor, ...]`, *tùy chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) -- Bộ tuple các `torch.Tensor` (một cho đầu ra của embeddings, nếu mô hình có lớp embedding, + một cho đầu ra của mỗi lớp) có hình dạng `(batch_size, sequence_length, hidden_size)`.

  Trạng thái ẩn của mô hình tại đầu ra của mỗi lớp cùng với các đầu ra embedding ban đầu tùy chọn.
- **entity_hidden_states** (`tuple(torch.Tensor)`, *tùy chọn*, được trả về khi truyền `output_hidden_states=True` hoặc khi `config.output_hidden_states=True`) -- Tuple của `torch.Tensor` (một cho đầu ra của embeddings + một cho đầu ra của mỗi lớp) có shape `(batch_size, entity_length, hidden_size)`. Entity hidden-states của mô hình tại đầu ra của mỗi lớp cùng với đầu ra của entity embedding ban đầu.
- **attentions** (`tuple[torch.Tensor, ...]`, *tùy chọn*, được trả về khi `output_attentions=True` được truyền vào hoặc khi `config.output_attentions=True`) -- Bộ tuple của `torch.Tensor` (một cho mỗi lớp) có hình dạng `(batch_size, num_heads, sequence_length, sequence_length)`.

  Trọng số chú ý sau softmax của attention, được sử dụng để tính trung bình có trọng số trong các đầu self-attention.

Ví dụ:

```python
>>> from transformers import AutoTokenizer, LukeForTokenClassification
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("studio-ousia/luke-base")
>>> model = LukeForTokenClassification.from_pretrained("studio-ousia/luke-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)
...
```

## LukeForQuestionAnswering[[transformers.LukeForQuestionAnswering]]

#### transformers.LukeForQuestionAnswering[[transformers.LukeForQuestionAnswering]]

```python
transformers.LukeForQuestionAnswering(config: LukeConfig)
```

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/luke/modeling_luke.py#L1808)

**Tham số:**

config ([LukeConfig](/docs/transformers/v5.23.0/vi/model_doc/luke#transformers.LukeConfig)) : Lớp cấu hình mô hình chứa tất cả các tham số của mô hình. Khởi tạo bằng tệp cấu hình sẽ không tải trọng số liên quan đến mô hình, chỉ tải cấu hình. Xem phương thức [from_pretrained()](/docs/transformers/v5.23.0/vi/main_classes/model#transformers.PreTrainedModel.from_pretrained) để tải trọng số mô hình.

Transformer Luke với một đầu phân loại span phía trên cho các tác vụ trả lời câu hỏi trích xuất như SQuAD (một lớp tuyến tính phía trên đầu ra hidden-states để tính toán `span start logits` và `span end logits`).

Mô hình này kế thừa từ [PreTrainedModel](/docs/transformers/v5.23.0/vi/main_classes/model#transformers.PreTrainedModel). Xem tài liệu của lớp cha để biết các phương thức chung mà thư viện triển khai cho tất cả các mô hình của nó (chẳng hạn như tải xuống hoặc lưu trữ, thay đổi kích thước các nhúng đầu vào, cắt tỉa các đầu ra, v.v.)

Mô hình này cũng là một lớp con của [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) trong PyTorch. Hãy sử dụng nó như một Module PyTorch thông thường và tham khảo tài liệu PyTorch cho mọi vấn đề liên quan đến cách sử dụng và hành vi chung.

#### forward[[transformers.LukeForQuestionAnswering.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.Tensor] = None, entity_ids: typing.Optional[torch.LongTensor] = None, entity_attention_mask: typing.Optional[torch.Tensor] = None, entity_token_type_ids: typing.Optional[torch.LongTensor] = None, entity_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, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/luke/modeling_luke.py#L1820)

**Tham số:**

input_ids (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Chỉ số của các token trong chuỗi đầu vào theo từ vựng. Mặc định, các token đệm (padding) sẽ bị bỏ qua. Có thể lấy chỉ số bằng cách sử dụng [AutoTokenizer](/docs/transformers/v5.23.0/vi/model_doc/auto#transformers.AutoTokenizer). Xem [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) và [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) để biết chi tiết. [ID đầu vào là gì?](../glossary#input-ids)

attention_mask (`torch.Tensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Mặt nạ để tránh thực hiện chú ý trên các chỉ số token đệm. Các giá trị mặt nạ được chọn trong `[0, 1]`:  - 1 cho các token **không bị che**, - 0 cho các token **bị che**.  [Mặt nạ chú ý là gì?](../glossary#attention-mask)

token_type_ids (`torch.LongTensor` có shape `(batch_size, sequence_length)`, *tùy chọn*) : Các chỉ số token phân đoạn để chỉ định phần đầu và phần thứ hai của các đầu vào. Các chỉ số được chọn trong `[0, 1]`:  - 0 tương ứng với token *câu A*, - 1 tương ứng với token *câu B*.  [Các ID loại token là gì?](../glossary#token-type-ids)

position_ids (`torch.Tensor` có shape `(batch_size, sequence_length)`, *tùy chọn*) : Chỉ số của vị trí các token trong mỗi chuỗi đầu vào trong các position embeddings. Được chọn trong khoảng `[0, config.n_positions - 1]`.  [Position IDs là gì?](../glossary#position-ids)

entity_ids (`torch.LongTensor` có shape `(batch_size, entity_length)`) : Chỉ số của các token thực thể trong từ điển thực thể. Có thể lấy chỉ số bằng cách sử dụng [AutoTokenizer](/docs/transformers/v5.23.0/vi/model_doc/auto#transformers.AutoTokenizer). Xem [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) và [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) để biết thêm chi tiết.

entity_attention_mask (`torch.Tensor` có shape `(batch_size, entity_length)`, *tùy chọn*) : Mặt nạ để tránh thực hiện chú ý trên các chỉ số token entity padding. Các giá trị mặt nạ được chọn trong `[0, 1]`:  - 1 cho các token entity **không bị che**, - 0 cho các token entity **bị che**.

entity_token_type_ids (`torch.LongTensor` có shape `(batch_size, entity_length)`, *tùy chọn*) : Các chỉ số token phân đoạn để chỉ định phần đầu và phần thứ hai của đầu vào token thực thể. Các chỉ số được chọn trong `[0, 1]`:  - 0 tương ứng với token thực thể *phần A*, - 1 tương ứng với token thực thể *phần B*.

entity_position_ids (`torch.LongTensor` có shape `(batch_size, entity_length, max_mention_length)`, *tùy chọn*) : Chỉ số của các vị trí của mỗi entity đầu vào trong các position embeddings. Được chọn trong khoảng `[0, config.max_position_embeddings - 1]`.

inputs_embeds (`torch.Tensor` có hình dạng `(batch_size, sequence_length, hidden_size)`, *tùy chọn*) : Tùy chọn, thay vì truyền `input_ids`, bạn có thể chọn cách truyền trực tiếp một biểu diễn nhúng. Điều này hữu ích nếu bạn muốn kiểm soát nhiều hơn cách chuyển đổi các chỉ số `input_ids` thành các vector liên quan so với ma trận tra cứu nhúng nội bộ của mô hình.

start_positions (`torch.LongTensor` có hình dạng `(batch_size,)`, *tùy chọn*) : Nhãn cho vị trí (chỉ số) bắt đầu của đoạn được gắn nhãn để tính toán tổn thất phân loại token. Các vị trí được kẹp (clamp) theo độ dài của chuỗi (`sequence_length`). Các vị trí nằm ngoài chuỗi sẽ không được tính đến khi tính toán tổn thất.

end_positions (`torch.LongTensor` có hình dạng `(batch_size,)`, *tùy chọn*) : Nhãn cho vị trí (chỉ số) của điểm kết thúc của đoạn được gắn nhãn để tính toán tổn thất phân loại token. Các vị trí được kẹp (clamp) theo độ dài của chuỗi (`sequence_length`). Các vị trí nằm ngoài chuỗi sẽ không được tính đến khi tính toán tổn thất.

output_attentions (`bool`, *tùy chọn*) : Có trả về các tensor chú ý của tất cả các lớp chú ý hay không. Xem `attentions` trong phần tensor trả về để biết thêm chi tiết.

output_hidden_states (`bool`, *tuỳ chọn*) : Có trả về trạng thái ẩn của tất cả các lớp hay không. Xem `hidden_states` trong phần tensor trả về để biết thêm chi tiết.

return_dict (`bool`, *tùy chọn*) : Có trả về [ModelOutput](/docs/transformers/v5.23.0/vi/main_classes/output#transformers.utils.ModelOutput) thay vì một tuple thông thường hay không.

**Trả về:** `LukeQuestionAnsweringModelOutput` hoặc `tuple(torch.Tensor)`

Một `LukeQuestionAnsweringModelOutput` hoặc một tuple của `torch.Tensor` (nếu `return_dict=False` được truyền hoặc khi `config.return_dict=False`) bao gồm các phần tử khác nhau tùy thuộc vào cấu hình ([LukeConfig](/docs/transformers/v5.23.0/vi/model_doc/luke#transformers.LukeConfig)) và đầu vào.

Phương thức forward của [LukeForQuestionAnswering](/docs/transformers/v5.23.0/vi/model_doc/luke#transformers.LukeForQuestionAnswering) ghi đè lên phương thức đặc biệt `__call__`.

Mặc dù công thức cho bước truyền tiến cần được định nghĩa bên trong hàm này, bạn nên gọi instance của `Module` sau đó thay vì gọi hàm này, vì instance `Module` sẽ đảm nhận việc thực hiện các bước tiền xử lý và hậu xử lý, trong khi hàm này sẽ bỏ qua chúng một cách im lặng.

- **loss** (`torch.Tensor` có shape `(1,)`, *optional*, được trả về khi `labels` được cung cấp) -- Tổng loss trích xuất span là tổng của Cross-Entropy cho các vị trí bắt đầu và kết thúc.
- **start_logits** (`torch.Tensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) -- Điểm bắt đầu span (trước SoftMax).
- **end_logits** (`torch.Tensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) -- Điểm số kết thúc đoạn (trước SoftMax).
- **hidden_states** (`tuple[torch.Tensor, ...]`, *tùy chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) -- Bộ tuple các `torch.Tensor` (một cho đầu ra của embeddings, nếu mô hình có lớp embedding, + một cho đầu ra của mỗi lớp) có hình dạng `(batch_size, sequence_length, hidden_size)`.

  Trạng thái ẩn của mô hình tại đầu ra của mỗi lớp cùng với các đầu ra embedding ban đầu tùy chọn.
- **entity_hidden_states** (`tuple(torch.Tensor)`, *tùy chọn*, được trả về khi truyền `output_hidden_states=True` hoặc khi `config.output_hidden_states=True`) -- Tuple của `torch.Tensor` (một cho đầu ra của embeddings + một cho đầu ra của mỗi lớp) có shape `(batch_size, entity_length, hidden_size)`. Entity hidden-states của mô hình tại đầu ra của mỗi lớp cùng với đầu ra của entity embedding ban đầu.
- **attentions** (`tuple[torch.Tensor, ...]`, *tùy chọn*, được trả về khi `output_attentions=True` được truyền vào hoặc khi `config.output_attentions=True`) -- Bộ tuple của `torch.Tensor` (một cho mỗi lớp) có hình dạng `(batch_size, num_heads, sequence_length, sequence_length)`.

  Trọng số chú ý sau softmax của attention, được sử dụng để tính trung bình có trọng số trong các đầu self-attention.

Ví dụ:

```python
>>> from transformers import AutoTokenizer, LukeForQuestionAnswering
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("studio-ousia/luke-base")
>>> model = LukeForQuestionAnswering.from_pretrained("studio-ousia/luke-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)
...
```

