# LUKE

## 개요

LUKE 모델은 Ikuya Yamada, Akari Asai, Hiroyuki Shindo, Hideaki Takeda, Yuji Matsumoto가 발표한 [LUKE: Deep Contextualized Entity Representations with Entity-aware Self-attention](https://huggingface.co/papers/2010.01057)에서 제안되었습니다. 이 모델은 RoBERTa를 기반으로 하며, 엔티티 임베딩과 엔티티 인식 셀프-어텐션 메커니즘을 추가하여, named entity recognition, extractive 및 cloze-style question answering, entity typing, relation classification과 같이 엔티티에 대한 추론이 필요한 다양한 다운스트림 작업의 성능을 향상시킵니다.

해당 논문의 초록은 다음과 같습니다:

*엔티티 표현은 엔티티가 포함된 자연어 작업에서 유용합니다. 이 논문에서는 양방향 transformer를 기반으로 한 단어와 엔티티의 새로운 사전학습된 문맥 표현을 제안합니다. 제안된 모델은 주어진 텍스트의 단어와 엔티티를 독립적인 토큰으로 취급하고, 이들의 문맥 표현을 출력합니다. 우리의 모델은 BERT의 masked language model에 기반한 새로운 사전학습 작업을 사용하여 학습됩니다. 이 작업은 Wikipedia에서 수집된 대규모 엔티티 어노테이션 코퍼스에서 무작위로 마스킹된 단어와 엔티티를 예측하는 것을 포함합니다. 또한 transformer의 self-attention 메커니즘을 확장한 엔티티 인식 self-attention 메커니즘을 제안하며, 이는 attention score을 계산할 때 토큰의 유형(단어 또는 엔티티)을 고려합니다. 제안된 모델은 다양한 엔티티 관련 작업에서 인상적인 실증적 성능을 달성합니다. 특히, 다섯 가지 잘 알려진 데이터셋에서 최첨단(state-of-the-art) 결과를 얻습니다: Open Entity(엔티티 타이핑), TACRED(관계 분류), CoNLL-2003(명명된 엔티티 인식), ReCoRD(cloze 스타일 질의응답), SQuAD 1.1(추출형 질의응답).*

이 모델은 [ikuyamada](https://huggingface.co/ikuyamada)와 [nielsr](https://huggingface.co/nielsr)가 기여했습니다. 원본 코드는 [여기](https://github.com/studio-ousia/luke)에서 찾을 수 있습니다.

## 사용 팁

- 이 구현은 [RobertaModel](/docs/transformers/v5.23.0/ko/model_doc/roberta#transformers.RobertaModel)과 동일하며, 엔티티 임베딩과 엔티티 인식 셀프 어텐션 메커니즘을 추가하여 엔티티에 대한 추론이 필요한 작업의 성능을 향상시킵니다.
- LUKE는 엔티티를 입력 토큰으로 취급하므로, `entity_ids`, `entity_attention_mask`, `entity_token_type_ids`, `entity_position_ids`를 추가 입력으로 받습니다. [LukeTokenizer](/docs/transformers/v5.23.0/ko/model_doc/luke#transformers.LukeTokenizer)를 사용하면 이 값들을 얻을 수 있습니다.
- [LukeTokenizer](/docs/transformers/v5.23.0/ko/model_doc/luke#transformers.LukeTokenizer)는 `entities`와 `entity_spans`(입력 텍스트에서 엔티티의 문자 기반 시작 및 끝 위치)를 추가 입력으로 받습니다. `entities`는 일반적으로 [MASK] 엔티티 또는 Wikipedia 엔티티로 구성됩니다. 이러한 엔티티를 입력할 때의 간단한 설명은 다음과 같습니다:

  - *[MASK] 엔티티를 입력하여 엔티티 표현을 계산*: [MASK] 엔티티는 사전 학습 중에 예측할 엔티티를 마스킹하는 데 사용됩니다. LUKE가 [MASK] 엔티티를 수신하면, 입력 텍스트에서 해당 엔티티에 대한 정보를 수집하여 원래의 엔티티를 예측하려고 합니다. 따라서 [MASK] 엔티티는 텍스트 내 엔티티 정보가 필요한 엔티티 타이핑, 관계 분류, 개체명 인식과 같은 다운스트림 작업을 처리하는 데 사용할 수 있습니다.
  - *Wikipedia 엔티티를 입력하여 지식 강화 토큰 표현을 계산*: LUKE는 사전 학습 과정에서 Wikipedia 엔티티에 대한 풍부한 정보(또는 지식)를 학습하여 이를 엔티티 임베딩에 저장합니다. Wikipedia 엔티티를 입력 토큰으로 사용하면, 해당 엔티티의 임베딩에 저장된 정보로 강화된 토큰 표현을 출력합니다. 이는 질의응답과 같이 실제 세계의 지식이 필요한 작업에서 특히 효과적입니다.

- 이전 사용 사례에는 세 가지 헤드 모델이 있습니다:

  - [LukeForEntityClassification](/docs/transformers/v5.23.0/ko/model_doc/luke#transformers.LukeForEntityClassification)는 [Open Entity dataset](https://www.cs.utexas.edu/~eunsol/html_pages/open_entity.html)과 같이 입력 텍스트의 단일 엔티티를 분류하는 엔티티 타이핑 등의 작업에 사용됩니다. 이 모델은 출력된 엔티티 표현 위에 선형 헤드를 배치합니다.
  - [LukeForEntityPairClassification](/docs/transformers/v5.23.0/ko/model_doc/luke#transformers.LukeForEntityPairClassification)는 관계 분류와 같이 두 개체 간의 관계를 분류하는 작업에 사용되며, 예를 들어 [TACRED dataset](https://nlp.stanford.edu/projects/tacred/)이 있습니다. 이 모델은 주어진 개체 쌍의 연결된 출력 표현 위에 선형 헤드를 배치합니다.
  - [LukeForEntitySpanClassification](/docs/transformers/v5.23.0/ko/model_doc/luke#transformers.LukeForEntitySpanClassification)는 named entity recognition(NER)과 같이 엔티티 스팬의 시퀀스를 분류하는 작업에 사용됩니다. 이 모델은 출력된 엔티티 표현 위에 선형 헤드를 배치합니다. 이 모델을 사용하여 NER 문제를 해결하려면 텍스트 내의 모든 가능한 엔티티 스팬을 모델에 입력하면 됩니다.

  [LukeTokenizer](/docs/transformers/v5.23.0/ko/model_doc/luke#transformers.LukeTokenizer)에는 `task` 인수가 있어 `task="entity_classification"`, `task="entity_pair_classification"`, 또는 `task="entity_span_classification"`를 지정하여 해당 헤드 모델의 입력을 쉽게 생성할 수 있습니다. 각 헤드 모델의 예제 코드를 참고하세요.

사용 예시:

```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])
```

## 리소스

- [[LukeForEntityPairClassification](/docs/transformers/v5.23.0/ko/model_doc/luke#transformers.LukeForEntityPairClassification)을 관계 분류에 맞게 미세 조정하는 방법에 대한 데모 노트북](https://github.com/NielsRogge/Transformers-Tutorials/tree/master/LUKE)
- [LUKE의 HuggingFace 구현으로 논문에서 보고된 결과를 재현하는 방법을 보여주는 노트북](https://github.com/studio-ousia/luke/tree/master/notebooks)
- [텍스트 분류 작업 가이드](../tasks/sequence_classification)
- [토큰 분류 작업 가이드](../tasks/token_classification)
- [질문 답변 작업 가이드](../tasks/question_answering)
- [마스크 언어 모델링 작업 가이드](../tasks/masked_language_modeling)
- [다중 선택 작업 가이드](../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)
```

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

**매개변수:**

vocab_size (`int`, *선택 사항*, 기본값 `50267`) : 모델의 어휘 크기입니다. `input_ids`로 표현할 수 있는 서로 다른 토큰의 수를 정의합니다.

entity_vocab_size (`int`, *선택 사항*, 기본값 500000) : LUKE 모델의 엔티티 어휘 크기입니다. [LukeModel](/docs/transformers/v5.23.0/ko/model_doc/luke#transformers.LukeModel)을 호출할 때 전달하는 `entity_ids`로 표현할 수 있는 서로 다른 엔티티의 수를 정의합니다.

hidden_size (`int`, *선택 사항*, 기본값 `768`) : 숨겨진 표현의 차원.

entity_emb_size (`int`, *선택 사항*, 기본값 256) : 엔티티 임베딩의 차원 수입니다.

num_hidden_layers (`int`, *선택 사항*, 기본값 `12`) : Transformer decoder의 숨겨진 레이어 수입니다.

num_attention_heads (`int`, *선택 사항*, 기본값 `12`) : Transformer decoder의 각 attention layer에 사용되는 attention head의 수입니다.

intermediate_size (`int`, *선택 사항*, 기본값 `3072`) : MLP 표현의 차원.

hidden_act (`str`, *선택 사항*, 기본값 `gelu`) : 디코더에서 사용되는 비선형 활성화 함수(함수 또는 문자열). 예를 들어, `"gelu"`, `"relu"`, `"silu"` 등이 있습니다.

hidden_dropout_prob (`Union[float, int]`, *선택 사항*, 기본값 `0.1`) : 임베딩, 인코더, 풀러의 모든 완전 연결 계층에 적용되는 dropout 확률입니다.

attention_probs_dropout_prob (`Union[float, int]`, *선택 사항*, 기본값 `0.1`) : attention 확률에 적용할 dropout 비율입니다.

max_position_embeddings (`int`, *선택 사항*, 기본값 `512`) : 이 모델이 사용될 수 있는 최대 시퀀스 길이입니다.

type_vocab_size (`int`, *선택 사항*, 기본값 `2`) : `token_type_ids`의 어휘 크기입니다.

initializer_range (`float`, *선택 사항*, 기본값 `0.02`) : 모든 가중치 행렬을 초기화하는 truncated_normal_initializer의 표준 편차입니다.

layer_norm_eps (`float`, *선택 사항*, 기본값 `1e-12`) : layer normalization 레이어에서 사용되는 epsilon 값입니다.

use_entity_aware_attention (`bool`, *선택 사항*, 기본값 `True`) : [LUKE: Deep Contextualized Entity Representations with Entity-aware Self-attention (Yamada et al.)](https://huggingface.co/papers/2010.01057)에서 제안된 엔티티 인식 셀프 어텐션 메커니즘을 모델이 사용할지 여부.

classifier_dropout (`Union[float, int]`, *선택*) : 분류기의 dropout 비율입니다.

pad_token_id (`int`, *선택 사항*, 기본값 `1`) : 어휘에서 패딩에 사용되는 토큰 ID입니다.

bos_token_id (`int`, *선택 사항*, 기본값 `0`) : 어휘에서 스트림 시작에 사용되는 토큰 ID입니다.

eos_token_id (`Union[int, list[int]]`, *선택*, 기본값 `2`) : 어휘에서 스트림 종료에 사용되는 토큰 ID입니다.

tie_word_embeddings (`bool`, *선택 사항*, 기본값 `True`) : 모델의 `tied_weights_keys` 매핑에 따라 가중치 임베딩을 묶을지 여부.

이것은 LukeModel의 구성을 저장하기 위한 구성 클래스입니다. 지정된 인자에 따라 Luke 모델을 초기화하여 모델 아키텍처를 정의하는 데 사용됩니다. 기본값으로 구성을 초기화하면 [studio-ousia/luke-base](https://huggingface.co/studio-ousia/luke-base)와 유사한 구성이 생성됩니다.

Configuration 객체는 [PreTrainedConfig](/docs/transformers/v5.23.0/ko/main_classes/configuration#transformers.PreTrainedConfig)를 상속하며, 모델 출력을 제어하는 데 사용할 수 있습니다. 자세한 내용은 [PreTrainedConfig](/docs/transformers/v5.23.0/ko/main_classes/configuration#transformers.PreTrainedConfig)의 문서를 참고하세요.

예:

```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)
```

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

**매개변수:**

vocab_file (`str`) : 어휘 파일 경로.

merges_file (`str`) : merges 파일 경로.

vocab (`str` 또는 `dict[str, int]`, *선택 사항*) : 사용자 정의 어휘 사전입니다. 제공되지 않으면 `vocab_file`에서 어휘가 로드됩니다.

merges (`str` 또는 `list[str]`, *선택 사항*) : 사용자 정의 병합 목록입니다. 제공되지 않으면 `merges_file`에서 병합을 로드합니다.

entity_vocab_file (`str`) : 엔티티 어휘 파일 경로.

task (`str`, *선택 사항*) : 시퀀스를 준비하려는 작업입니다. `"entity_classification"`, `"entity_pair_classification"`, `"entity_span_classification"` 중 하나여야 합니다. 이 인수를 지정하면 주어진 엔티티 스팬에 기반하여 엔티티 시퀀스가 자동으로 생성됩니다.

max_entity_length (`int`, *선택 사항*, 기본값 32) : `entity_ids`의 최대 길이입니다.

max_mention_length (`int`, *선택 사항*, 기본값 30) : 엔티티 스팬 안의 최대 토큰 수입니다.

entity_1_token (`str`, *선택 사항*, 기본값 `<ent>`) : 워드 토큰 시퀀스에서 엔티티 스팬을 나타내는 데 사용되는 특수 토큰입니다. 이 토큰은 `task`가 `"entity_classification"` 또는 `"entity_pair_classification"`으로 설정된 경우에만 사용됩니다.

entity_2_token (`str`, *선택 사항*, 기본값 `<ent2>`) : 워드 토큰 시퀀스에서 엔티티 스팬을 나타내는 데 사용되는 특수 토큰입니다. 이 토큰은 `task`가 `"entity_pair_classification"`으로 설정된 경우에만 사용됩니다.

errors (`str`, *선택 사항*, 기본값 `"replace"`) : 바이트를 UTF-8로 디코딩할 때 따를 패러다임입니다. 자세한 내용은 [bytes.decode](https://docs.python.org/3/library/stdtypes.html#bytes.decode)를 참조하세요.

bos_token (`str`, *선택 사항*, 기본값 `"<s>"`) : 사전 학습 시 사용된 시퀀스 시작 토큰입니다. 시퀀스 분류기 토큰으로 사용할 수 있습니다. 특수 토큰을 사용하여 시퀀스를 구성할 때, 시퀀스 시작에 사용되는 토큰은 이 토큰이 아닙니다. 사용되는 토큰은 `cls_token`입니다.

eos_token (`str`, *선택 사항*, 기본값 `"</s>"`) : 시퀀스 종료 토큰. 특수 토큰을 사용하여 시퀀스를 구성할 때, 시퀀스 종료에 사용되는 토큰은 이 토큰이 아닙니다. 사용되는 토큰은 `sep_token`입니다.

sep_token (`str`, *선택 사항*, 기본값 `"</s>"`) : 여러 시퀀스로 시퀀스를 구성할 때 사용되는 구분자 토큰입니다. 예를 들어 시퀀스 분류를 위한 두 시퀀스나 질의응답을 위한 텍스트와 질문 등에 사용됩니다. 특수 토큰으로 구성된 시퀀스의 마지막 토큰으로도 사용됩니다.

cls_token (`str`, *선택 사항*, 기본값 `"<s>"`) : 시퀀스 분류(토큰별 분류가 아닌 전체 시퀀스 분류) 수행 시 사용되는 분류기 토큰입니다. 특수 토큰을 사용하여 시퀀스를 구성할 때 시퀀스의 첫 번째 토큰입니다.

unk_token (`str`, *선택*, 기본값 `"<unk>"`) : 알 수 없는 토큰. 어휘에 없는 토큰은 ID로 변환할 수 없으므로 이 토큰으로 설정됩니다.

pad_token (`str`, *선택 사항*, 기본값 `"<pad>"`) : 패딩에 사용되는 토큰입니다. 예를 들어 길이가 다른 시퀀스를 배치할 때 사용됩니다.

mask_token (`str`, *선택 사항*, 기본값 `"<mask>"`) : 값을 마스킹하는 데 사용되는 토큰입니다. 이는 masked language modeling으로 이 모델을 학습할 때 사용되는 토큰입니다. 모델이 예측을 시도하는 대상이 되는 토큰입니다.

add_prefix_space (`bool`, *선택 사항*, 기본값 `False`) : 입력에 공백을 추가할지 여부입니다. 이를 통해 첫 번째 단어를 다른 단어와 동일하게 처리할 수 있습니다. (LUKE 토크나이저는 앞선 공백을 통해 단어의 시작을 감지합니다).

byte-level Byte-Pair-Encoding을 사용하여 GPT-2 토크나이저에서 파생된 LUKE 토크나이저를 생성합니다.

이 토크나이저는 공백을 토큰의 일부로 취급하도록 학습되었습니다(sentencepiece와 유사한 방식) 따라서 한 단어는

문장의 시작(공백 없이)에 위치하는 경우와 그렇지 않은 경우에 따라 다르게 인코딩됩니다:

```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]
```

`add_prefix_space=True`를 전달하여 이 토크나이저를 인스턴스화하거나 특정 텍스트에 호출할 때 해당 동작을 우회할 수 있지만, 모델이 이러한 방식으로 사전 학습되지 않았으므로 성능이 저하될 수 있습니다.

`is_split_into_words=True`와 함께 사용할 경우, 이 토크나이저는 각 단어(첫 번째 단어를 포함하여) 앞에 공백을 추가합니다.

이 토크나이저는 대부분의 주요 메서드를 포함하는 [PreTrainedTokenizer](/docs/transformers/v5.23.0/ko/main_classes/tokenizer#transformers.PythonBackend)를 상속받습니다. 해당 메서드에 대한 자세한 정보는 이 상위 클래스를 참고하세요. 또한 LUKE 모델에서 사용될 엔티티 시퀀스, 즉 `entity_ids`, `entity_attention_mask`, `entity_token_type_ids`, `entity_position_ids`를 생성합니다.

#### __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)
```

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

**반환값:** [BatchEncoding](/docs/transformers/v5.23.0/ko/main_classes/tokenizer#transformers.BatchEncoding)

다음 필드를 가진 [BatchEncoding](/docs/transformers/v5.23.0/ko/main_classes/tokenizer#transformers.BatchEncoding):

- **input_ids** -- 모델에 입력할 토큰 ID 목록.

  [입력 ID란 무엇인가요?](../glossary#input-ids)

- **token_type_ids** -- 모델에 입력할 토큰 유형 ID 목록(`return_token_type_ids=True`인 경우 또는 `self.model_input_names`에 *"token_type_ids"*가 포함된 경우).

  [토큰 타입 ID란 무엇인가요?](../glossary#token-type-ids)

- **attention_mask** -- 모델이 어떤 토큰에 주의를 기울여야 하는지 지정하는 인덱스 목록(`return_attention_mask=True`인 경우 또는 `self.model_input_names`에 *"attention_mask"*가 포함된 경우).

  [어텐션 마스크란 무엇인가요?](../glossary#attention-mask)

- **entity_ids** -- 모델에 전달할 엔티티 ID 목록.

  [입력 ID란 무엇인가요?](../glossary#input-ids)

- **entity_position_ids** -- 모델에 입력될 입력 시퀀스 내 엔티티 위치 목록.

- **entity_token_type_ids** -- 모델에 입력할 엔티티 토큰 타입 ID 목록 (`return_token_type_ids=True`이거나 `self.model_input_names`에 *"entity_token_type_ids"*가 포함된 경우).

  [토큰 타입 ID란 무엇인가요?](../glossary#token-type-ids)

- **entity_attention_mask** -- 모델이 어떤 엔티티에 주의를 기울여야 하는지 지정하는 인덱스 목록 (`return_attention_mask=True`인 경우 또는 `self.model_input_names`에 *"entity_attention_mask"*가 포함된 경우).

  [어텐션 마스크란 무엇인가요?](../glossary#attention-mask)

- **entity_start_positions** -- 워드 토큰 시퀀스에서 엔티티의 시작 위치 목록(`task="entity_span_classification"`인 경우).
- **entity_end_positions** -- 워드 토큰 시퀀스에서 엔티티의 끝 위치 목록(`task="entity_span_classification"`인 경우).
- **overflowing_tokens** -- 넘친 토큰 시퀀스 목록(`max_length`이 지정되고 `return_overflowing_tokens=True`인 경우).
- **num_truncated_tokens** -- 잘림된 토큰의 개수(`max_length`가 지정되고 `return_overflowing_tokens=True`인 경우).
- **special_tokens_mask** -- 0과 1의 목록으로, 1은 추가된 특수 토큰을, 0은 일반 시퀀스 토큰을 나타냅니다(`add_special_tokens=True`이고 `return_special_tokens_mask=True`인 경우).
- **length** -- 입력의 길이 (`return_length=True`인 경우)

add_special_tokens (`bool`, *선택 사항*, 기본값 `True`): 시퀀스를 인코딩할 때 특수 토큰을 추가할지 여부입니다. 이는 입력 ID에 자동으로 추가되는 토큰을 정의하는 기반 `PretrainedTokenizerBase.build_inputs_with_special_tokens` 함수를 사용합니다. `bos` 또는 `eos` 토큰을 자동으로 추가하려는 경우 유용합니다. padding (`bool`, `str` 또는 [PaddingStrategy](/docs/transformers/v5.23.0/ko/internal/file_utils#transformers.utils.PaddingStrategy), *선택 사항*, 기본값 `False`): 패딩을 활성화하고 제어합니다. 다음 값을 허용합니다:

- `True` 또는 `'longest'`: 배치 내 가장 긴 시퀀스 길이에 맞게 패딩을 수행합니다(단일 시퀀스만 제공된 경우 패딩을 하지 않음).
- `'max_length'`: `max_length` 인수로 지정된 최대 길이로 패딩하거나, 해당 인수가 제공되지 않으면 모델이 허용하는 최대 입력 길이로 패딩합니다.
- `False` 또는 `'do_not_pad'` (기본값): 패딩을 하지 않습니다(즉, 서로 다른 길이의 시퀀스로 구성된 배치 출력이 가능합니다).
truncation (`bool`, `str` 또는 [TruncationStrategy](/docs/transformers/v5.23.0/ko/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy), *선택 사항*, 기본값 `False`): 잘림을 활성화하고 제어합니다. 다음 값을 허용합니다:

- `True` 또는 `'longest_first'`: `max_length` 인수로 지정된 최대 길이로 잘라내거나, 해당 인수가 제공되지 않으면 모델이 허용하는 최대 입력 길이로 잘라냅니다. 이 경우 토큰 단위로 잘라내며, 시퀀스 쌍(또는 쌍의 배치)이 제공되면 쌍 중 가장 긴 시퀀스에서 토큰을 하나씩 제거합니다.
- `'only_first'`: `max_length` 인수로 지정된 최대 길이로 잘라내거나, 해당 인수가 제공되지 않은 경우 모델이 허용하는 최대 입력 길이로 잘라냅니다. 시퀀스 쌍(또는 쌍의 배치)이 제공된 경우, 이 옵션은 쌍의 첫 번째 시퀀스만 잘라냅니다.
- `'only_second'`: `max_length` 인수로 지정된 최대 길이로 잘라내거나, 해당 인수가 제공되지 않은 경우 모델이 허용하는 최대 입력 길이로 잘라냅니다. 이 옵션은 시퀀스 쌍(또는 쌍의 배치)이 제공된 경우에만 쌍의 두 번째 시퀀스를 잘라냅니다.
- `False` 또는 `'do_not_truncate'` (기본값): 잘라내기 없음(즉, 모델이 허용하는 최대 입력 크기보다 긴 시퀀스 길이를 가진 배치 출력 가능).
max_length (`int`, *선택 사항*): truncation/padding 매개변수 중 하나로 사용할 최대 길이를 제어합니다.

If left unset or set to `None`, this will use the predefined model maximum length if a maximum length is required by one of the truncation/padding parameters. If the model has no specific maximum input length (like XLNet) truncation/padding to a maximum length will be deactivated. stride (`int`, *optional*, defaults to 0): If set to a number along with `max_length`, the overflowing tokens returned when `return_overflowing_tokens=True` will contain some tokens from the end of the truncated sequence returned to provide some overlap between truncated and overflowing sequences. The value of this argument defines the number of overlapping tokens. is_split_into_words (`bool`, *optional*, defaults to `False`): Whether or not the input is already pre-tokenized (e.g., split into words). If set to `True`, the tokenizer assumes the input is already split into words (for instance, by splitting it on whitespace) which it will tokenize. This is useful for NER or token classification. pad_to_multiple_of (`int`, *optional*): If set will pad the sequence to a multiple of the provided value. Requires `padding` to be activated. This is especially useful to enable the use of Tensor Cores on NVIDIA hardware with compute capability `>= 7.5` (Volta). padding_side (`str`, *optional*): The side on which the model should have padding applied. Should be selected between ['right', 'left']. Default value is picked from the class attribute of the same name. return_tensors (`str` or [TensorType](/docs/transformers/v5.23.0/ko/internal/file_utils#transformers.TensorType), *optional*): If set, will return tensors instead of list of python integers. Acceptable values are:

- `'pt'`: PyTorch `torch.Tensor` 객체를 반환합니다.
- `'np'`: Numpy `np.ndarray` 객체를 반환합니다.

return_token_type_ids (`bool`, *선택 사항*): 토큰 유형 ID를 반환할지 여부입니다. 기본값으로 두면, `return_outputs` 속성으로 정의된 해당 토크나이저의 기본값에 따라 토큰 유형 ID를 반환합니다.

[토큰 타입 ID란 무엇인가요?](../glossary#token-type-ids) return_attention_mask (`bool`, *선택 사항*): 어텐션 마스크를 반환할지 여부입니다. 기본값으로 두면, `return_outputs` 속성으로 정의된 해당 토크나이저의 기본값에 따라 어텐션 마스크를 반환합니다.

[어텐션 마스크란 무엇인가요?](../glossary#attention-mask) return_overflowing_tokens (`bool`, *선택 사항*, 기본값 `False`): 넘치는 토큰 시퀀스를 반환할지 여부. 입력 ID의 시퀀스 쌍(또는 쌍의 배치)이 `truncation_strategy = longest_first` 또는 `True`와 함께 제공되면, 넘치는 토큰을 반환하는 대신 오류가 발생합니다. return_special_tokens_mask (`bool`, *선택 사항*, 기본값 `False`): 특수 토큰 마스크 정보를 반환할지 여부. return_offsets_mapping (`bool`, *선택 사항*, 기본값 `False`): 각 토큰에 대해 `(char_start, char_end)`를 반환할지 여부.

이 기능은 [PreTrainedTokenizerFast](/docs/transformers/v5.23.0/ko/main_classes/tokenizer#transformers.TokenizersBackend)를 상속하는 빠른 토크나이저에서만 사용할 수 있으며, Python의 토크나이저를 사용하는 경우 이 메서드는 `NotImplementedError`를 발생시킵니다. return_length (`bool`, *선택 사항*, 기본값 `False`): 인코딩된 입력의 길이를 반환할지 여부. verbose (`bool`, *선택 사항*, 기본값 `True`): 추가 정보와 경고를 출력할지 여부. **kwargs: `self.tokenize()` 메서드에 전달됩니다

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

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

[소스](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)
```

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

**매개변수:**

config ([LukeConfig](/docs/transformers/v5.23.0/ko/model_doc/luke#transformers.LukeConfig)) : 모델의 모든 매개변수를 포함하는 모델 구성 클래스입니다. 구성 파일로 초기화하는 것은 모델과 관련된 가중치를 로드하지 않으며, 구성 정보만 로드합니다. 모델 가중치를 로드하려면 [from_pretrained()](/docs/transformers/v5.23.0/ko/main_classes/model#transformers.PreTrainedModel.from_pretrained) 메서드를 확인하세요.

add_pooling_layer (`bool`, *선택 사항*, 기본값 `True`) : 풀링 레이어를 추가할지 여부

어떤 … 없이 워드 토큰과 엔티티 모두에 대해 원시 hidden-states를 출력하는 기본 LUKE 모델

이 모델은 [PreTrainedModel](/docs/transformers/v5.23.0/ko/main_classes/model#transformers.PreTrainedModel)에서 상속됩니다. 라이브러리가 모든 모델에 대해 구현하는 일반적 메서드(다운로드 또는 저장, 입력 임베딩 크기 조정, 헤드 프루닝 등)에 대해서는 상위 클래스 문서를 확인하세요.

이 모델은 또한 PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module)의 하위 클래스입니다. 일반적인 PyTorch Module처럼 사용하며, 일반적인 사용법과 동작에 관한 모든 사항은 PyTorch 문서를 참조하세요.

#### 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)
```

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

**매개변수:**

input_ids (`torch.LongTensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 어휘(input sequence tokens)의 인덱스입니다. 기본적으로 패딩은 무시됩니다. [AutoTokenizer](/docs/transformers/v5.23.0/ko/model_doc/auto#transformers.AutoTokenizer)를 사용하여 인덱스를 얻을 수 있습니다. 자세한 내용은 [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 및 [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)를 참조하세요. [입력 ID란 무엇인가요?](../glossary#input-ids)

attention_mask (`torch.Tensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 패딩 토큰 인덱스에 대한 attention을 수행하지 않도록 방지하는 마스크입니다. `[0, 1]`에서 선택된 마스크 값: - **마스크되지 않은** 토큰은 1, - **마스크된** 토큰은 0. [attention 마스크란?](../glossary#attention-mask)

token_type_ids (`torch.LongTensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 입력의 첫 번째 및 두 번째 부분을 나타내는 세그먼트 토큰 인덱스입니다. 인덱스는 `[0, 1]`에서 선택됩니다:  - 0은 *sentence A* 토큰에 해당하고, - 1은 *sentence B* 토큰에 해당합니다.  [토큰 타입 ID란 무엇인가요?](../glossary#token-type-ids)

position_ids (`torch.LongTensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 각 입력 시퀀스의 토큰 위치 인덱스입니다. `[0, config.n_positions - 1]` 범위에서 선택됩니다. [위치 ID란 무엇인가요?](../glossary#position-ids)

entity_ids (`torch.LongTensor`, shape `(batch_size, entity_length)`) : entity vocabulary에서 entity 토큰의 인덱스입니다. [AutoTokenizer](/docs/transformers/v5.23.0/ko/model_doc/auto#transformers.AutoTokenizer)를 사용하여 인덱스를 얻을 수 있습니다. 자세한 내용은 [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 및 [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)를 참조하세요.

entity_attention_mask (`torch.Tensor`, shape `(batch_size, entity_length)`, *선택 사항*) : 패딩 엔티티 토큰 인덱스에 대한 어텐션 수행을 방지하기 위한 마스크. `[0, 1]`에서 선택된 마스크 값: - **마스크되지 않은** 엔티티 토큰은 1, - **마스크된** 엔티티 토큰은 0.

entity_token_type_ids (`torch.LongTensor`, shape `(batch_size, entity_length)`, *선택 사항*) : 엔티티 토큰 입력의 첫 번째 및 두 번째 부분을 나타내는 세그먼트 토큰 인덱스입니다. 인덱스는 `[0, 1]`에서 선택됩니다: - 0은 *portion A* 엔티티 토큰에 해당하고, - 1은 *portion B* 엔티티 토큰에 해당합니다.

entity_position_ids (`torch.LongTensor`, shape `(batch_size, entity_length, max_mention_length)`, *선택 사항*) : 위치 임베딩에서 각 입력 엔티티의 위치 인덱스. `[0, config.max_position_embeddings - 1]` 범위에서 선택됩니다.

inputs_embeds (`torch.Tensor`, shape `(batch_size, sequence_length, hidden_size)`, *선택 사항*) : `input_ids`를 전달하는 대신 임베디드 표현을 직접 전달할 수 있습니다. 이는 모델의 내부 임베딩 조회 행렬보다 `input_ids` 인덱스를 관련 벡터로 변환하는 방식에 대해 더 많은 제어가 필요한 경우 유용합니다.

output_attentions (`bool`, *선택 사항*) : 모든 어텐션 레이어의 어텐션 텐서를 반환할지 여부. 자세한 내용은 반환 텐서 섹션의 `attentions`를 참조하세요.

output_hidden_states (`bool`, *선택 사항*) : 모든 레이어의 hidden states를 반환할지 여부. 자세한 내용은 반환되는 텐서 중 `hidden_states` 항목을 참조하세요.

return_dict (`bool`, *선택 사항*) : 일반 튜플 대신 [ModelOutput](/docs/transformers/v5.23.0/ko/main_classes/output#transformers.utils.ModelOutput)를 반환할지 여부.

**반환값:** `BaseLukeModelOutputWithPooling` 또는 `tuple(torch.Tensor)`

`BaseLukeModelOutputWithPooling` 또는 `torch.Tensor`의 튜플(`return_dict=False`가 전달되거나 `config.return_dict=False`인 경우)로, [LukeConfig](/docs/transformers/v5.23.0/ko/model_doc/luke#transformers.LukeConfig) 및 입력에 따라 다양한 요소를 포함합니다.

[LukeModel](/docs/transformers/v5.23.0/ko/model_doc/luke#transformers.LukeModel)의 forward 메서드는 `__call__` 특수 메서드를 오버라이드합니다.

`Module` 인스턴스는 전처리 및 후처리 단계를 실행하는 것을 처리하지만, 이 함수는 해당 단계를 조용히 무시하므로, 순전파(forward pass) 레시피를 이 함수 내에서 정의해야 하더라도 이후에는 이 함수 대신 `Module` 인스턴스를 호출해야 합니다.

- **last_hidden_state** (`torch.Tensor`, shape `(batch_size, sequence_length, hidden_size)`) -- 모델의 마지막 레이어 출력에서 생성된 hidden-state 시퀀스입니다.
- **pooler_output** (`torch.Tensor`, shape `(batch_size, hidden_size)`) -- 시퀀스의 첫 번째 토큰(분류 토큰)의 마지막 레이어 hidden-state를 Linear 레이어와 Tanh 활성화 함수로 추가로 처리한 값.
- **hidden_states** (`tuple(torch.Tensor)`, *선택 사항*, `output_hidden_states=True`가 전달되었거나 `config.output_hidden_states=True`인 경우 반환됨) -- `torch.Tensor`의 튜플(모델에 임베딩 레이어가 있는 경우 임베딩 출력 1개 + 각 레이어의 출력 1개)로, 형태는 `(batch_size, sequence_length, hidden_size)`입니다.

  각 레이어의 출력에서 모델의 Hidden-states와 선택적 초기 임베딩 출력을 포함합니다.
- **attentions** (`tuple(torch.Tensor)`, *선택 사항*, `output_attentions=True`가 전달되었거나 `config.output_attentions=True`인 경우 반환됨) -- 각 레이어마다 하나씩 포함된 `torch.Tensor`의 튜플로, 모양은 `(batch_size, num_heads, sequence_length, sequence_length)`입니다.

  self-attention 헤드에서 가중 평균을 계산하는 데 사용되는 attention softmax 이후의 attention 가중치입니다.
- **entity_last_hidden_state** (`torch.Tensor`, shape `(batch_size, entity_length, hidden_size)`) -- 모델의 마지막 레이어 출력에서 엔티티 히든 상태의 시퀀스입니다.
- **entity_hidden_states** (`tuple(torch.Tensor)`, *선택 사항*, `output_hidden_states=True`가 전달되었거나 `config.output_hidden_states=True`인 경우 반환됨) -- `torch.Tensor`의 튜플(임베딩 출력 1개 + 각 레이어의 출력 1개)로, 모양은 `(batch_size, entity_length, hidden_size)`입니다. 각 레이어의 출력에서 모델의 엔티티 히든 스테이트와 초기 엔티티 임베딩 출력을 포함합니다.

예:

```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)
```

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

**매개변수:**

config ([LukeConfig](/docs/transformers/v5.23.0/ko/model_doc/luke#transformers.LukeConfig)) : 모델의 모든 매개변수를 포함하는 모델 구성 클래스입니다. 구성 파일로 초기화하는 것은 모델과 관련된 가중치를 로드하지 않으며, 구성 정보만 로드합니다. 모델 가중치를 로드하려면 [from_pretrained()](/docs/transformers/v5.23.0/ko/main_classes/model#transformers.PreTrainedModel.from_pretrained) 메서드를 확인하세요.

마스크 언어 모델링과 마스크 엔티티 예측을 위해 언어 모델링 헤드와 엔티티 예측 헤드가 위에 있는 LUKE 모델.

이 모델은 [PreTrainedModel](/docs/transformers/v5.23.0/ko/main_classes/model#transformers.PreTrainedModel)에서 상속됩니다. 라이브러리가 모든 모델에 대해 구현하는 일반적 메서드(다운로드 또는 저장, 입력 임베딩 크기 조정, 헤드 프루닝 등)에 대해서는 상위 클래스 문서를 확인하세요.

이 모델은 또한 PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module)의 하위 클래스입니다. 일반적인 PyTorch Module처럼 사용하며, 일반적인 사용법과 동작에 관한 모든 사항은 PyTorch 문서를 참조하세요.

#### 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)
```

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

**매개변수:**

input_ids (`torch.LongTensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 어휘(input sequence tokens)의 인덱스입니다. 기본적으로 패딩은 무시됩니다. [AutoTokenizer](/docs/transformers/v5.23.0/ko/model_doc/auto#transformers.AutoTokenizer)를 사용하여 인덱스를 얻을 수 있습니다. 자세한 내용은 [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 및 [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)를 참조하세요. [입력 ID란 무엇인가요?](../glossary#input-ids)

attention_mask (`torch.Tensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 패딩 토큰 인덱스에 대한 attention을 수행하지 않도록 방지하는 마스크입니다. `[0, 1]`에서 선택된 마스크 값: - **마스크되지 않은** 토큰은 1, - **마스크된** 토큰은 0. [attention 마스크란?](../glossary#attention-mask)

token_type_ids (`torch.LongTensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 입력의 첫 번째 및 두 번째 부분을 나타내는 세그먼트 토큰 인덱스입니다. 인덱스는 `[0, 1]`에서 선택됩니다:  - 0은 *sentence A* 토큰에 해당하고, - 1은 *sentence B* 토큰에 해당합니다.  [토큰 타입 ID란 무엇인가요?](../glossary#token-type-ids)

position_ids (`torch.LongTensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 각 입력 시퀀스의 토큰 위치 인덱스입니다. `[0, config.n_positions - 1]` 범위에서 선택됩니다. [위치 ID란 무엇인가요?](../glossary#position-ids)

entity_ids (`torch.LongTensor`, shape `(batch_size, entity_length)`) : entity vocabulary에서 entity 토큰의 인덱스입니다. [AutoTokenizer](/docs/transformers/v5.23.0/ko/model_doc/auto#transformers.AutoTokenizer)를 사용하여 인덱스를 얻을 수 있습니다. 자세한 내용은 [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 및 [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)를 참조하세요.

entity_attention_mask (`torch.Tensor`, shape `(batch_size, entity_length)`, *선택 사항*) : 패딩 엔티티 토큰 인덱스에 대한 어텐션 수행을 방지하기 위한 마스크. `[0, 1]`에서 선택된 마스크 값: - **마스크되지 않은** 엔티티 토큰은 1, - **마스크된** 엔티티 토큰은 0.

entity_token_type_ids (`torch.LongTensor`, shape `(batch_size, entity_length)`, *선택 사항*) : 엔티티 토큰 입력의 첫 번째 및 두 번째 부분을 나타내는 세그먼트 토큰 인덱스입니다. 인덱스는 `[0, 1]`에서 선택됩니다: - 0은 *portion A* 엔티티 토큰에 해당하고, - 1은 *portion B* 엔티티 토큰에 해당합니다.

entity_position_ids (`torch.LongTensor`, shape `(batch_size, entity_length, max_mention_length)`, *선택 사항*) : 위치 임베딩에서 각 입력 엔티티의 위치 인덱스. `[0, config.max_position_embeddings - 1]` 범위에서 선택됩니다.

labels (`torch.LongTensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : masked language modeling loss를 계산하기 위한 라벨. 인덱스는 `[-100, 0, ..., config.vocab_size]` 범위여야 합니다(`input_ids` docstring 참조). 인덱스가 `-100`로 설정된 토큰은 무시(마스크)되며, loss는 `[0, ..., config.vocab_size]` 범위의 라벨을 가진 토큰에 대해서만 계산됩니다.

entity_labels (`torch.LongTensor`, shape `(batch_size, entity_length)`, *선택 사항*) : masked language modeling loss를 계산하기 위한 라벨. 인덱스는 `[-100, 0, ..., config.vocab_size]` 범위여야 합니다(`input_ids` docstring 참조). 인덱스가 `-100`로 설정된 토큰은 무시(마스크)되며, loss는 라벨이 `[0, ..., config.vocab_size]` 범위에 있는 토큰에 대해서만 계산됩니다.

inputs_embeds (`torch.Tensor`, shape `(batch_size, sequence_length, hidden_size)`, *선택 사항*) : `input_ids`를 전달하는 대신 임베디드 표현을 직접 전달할 수 있습니다. 이는 모델의 내부 임베딩 조회 행렬보다 `input_ids` 인덱스를 관련 벡터로 변환하는 방식에 대해 더 많은 제어가 필요한 경우 유용합니다.

output_attentions (`bool`, *선택 사항*) : 모든 어텐션 레이어의 어텐션 텐서를 반환할지 여부. 자세한 내용은 반환 텐서 섹션의 `attentions`를 참조하세요.

output_hidden_states (`bool`, *선택 사항*) : 모든 레이어의 hidden states를 반환할지 여부. 자세한 내용은 반환되는 텐서 중 `hidden_states` 항목을 참조하세요.

return_dict (`bool`, *선택 사항*) : 일반 튜플 대신 [ModelOutput](/docs/transformers/v5.23.0/ko/main_classes/output#transformers.utils.ModelOutput)를 반환할지 여부.

**반환값:** `LukeMaskedLMOutput` 또는 `tuple(torch.Tensor)`

`LukeMaskedLMOutput` 또는 `torch.Tensor`의 튜플(`return_dict=False`가 전달되거나 `config.return_dict=False`인 경우)로, [LukeConfig](/docs/transformers/v5.23.0/ko/model_doc/luke#transformers.LukeConfig) 및 입력에 따라 다양한 요소를 포함합니다.

[LukeForMaskedLM](/docs/transformers/v5.23.0/ko/model_doc/luke#transformers.LukeForMaskedLM)의 forward 메서드는 `__call__` 특수 메서드를 오버라이드합니다.

`Module` 인스턴스는 전처리 및 후처리 단계를 실행하는 것을 처리하지만, 이 함수는 해당 단계를 조용히 무시하므로, 순전파(forward pass) 레시피를 이 함수 내에서 정의해야 하더라도 이후에는 이 함수 대신 `Module` 인스턴스를 호출해야 합니다.

- **loss** (`torch.Tensor`, shape `(1,)`, *선택 사항*, `labels`이 제공될 때 반환됨) -- masked language modeling(MLM) 손실과 entity prediction 손실의 합입니다.
- **mlm_loss** (`torch.Tensor`, shape `(1,)`, *선택 사항*, `labels`가 제공될 때 반환됨) -- Masked language modeling(MLM) 손실.
- **mep_loss** (`torch.Tensor`, shape `(1,)`, *선택 사항*, `labels`이 제공될 때 반환됨) -- Masked entity prediction (MEP) loss.
- **logits** (`torch.Tensor`, shape `(batch_size, sequence_length, config.vocab_size)`) -- 언어 모델링 헤드에서 생성된 예측 점수(SoftMax 적용 전 각 어휘 토큰에 대한 점수).
- **entity_logits** (`torch.Tensor`, shape `(batch_size, sequence_length, config.vocab_size)`) -- 엔티티 예측 헤드의 예측 점수 (SoftMax 적용 전 각 엔티티 어휘 토큰에 대한 점수).
- **hidden_states** (`tuple[torch.Tensor]`, *선택*, `output_hidden_states=True`가 전달되었거나 `config.output_hidden_states=True`인 경우 반환됨) -- `torch.Tensor`의 튜플(모델에 임베딩 레이어가 있는 경우 임베딩 출력용 1개 + 각 레이어의 출력용 1개)로, 모양은 `(batch_size, sequence_length, hidden_size)`입니다.

  각 레이어의 출력에서 모델의 Hidden-states와 선택적 초기 임베딩 출력을 포함합니다.
- **entity_hidden_states** (`tuple(torch.Tensor)`, *선택 사항*, `output_hidden_states=True`가 전달되었거나 `config.output_hidden_states=True`인 경우 반환됨) -- `torch.Tensor`의 튜플(임베딩 출력 1개 + 각 레이어의 출력 1개)로, 모양은 `(batch_size, entity_length, hidden_size)`입니다. 각 레이어의 출력에서 모델의 엔티티 히든 스테이트와 초기 엔티티 임베딩 출력을 포함합니다.
- **attentions** (`tuple[torch.Tensor, ...]`, *선택*, `output_attentions=True`가 전달되었거나 `config.output_attentions=True`인 경우 반환) -- 각 레이어마다 하나씩 포함된 `torch.Tensor` 튜플로, shape는 `(batch_size, num_heads, sequence_length, sequence_length)`입니다.

  self-attention 헤드에서 가중 평균을 계산하는 데 사용되는 attention softmax 이후의 attention 가중치입니다.

예:

```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)
```

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

**매개변수:**

config ([LukeConfig](/docs/transformers/v5.23.0/ko/model_doc/luke#transformers.LukeConfig)) : 모델의 모든 매개변수를 포함하는 모델 구성 클래스입니다. 구성 파일로 초기화하는 것은 모델과 관련된 가중치를 로드하지 않으며, 구성 정보만 로드합니다. 모델 가중치를 로드하려면 [from_pretrained()](/docs/transformers/v5.23.0/ko/main_classes/model#transformers.PreTrainedModel.from_pretrained) 메서드를 확인하세요.

Open Entity와 같은 엔티티 분류 작업을 위해, 첫 번째 엔티티 토큰의 히든 상태 위에 선형 레이어를 올려놓은 분류 헤드가 있는 LUKE 모델.

이 모델은 [PreTrainedModel](/docs/transformers/v5.23.0/ko/main_classes/model#transformers.PreTrainedModel)에서 상속됩니다. 라이브러리가 모든 모델에 대해 구현하는 일반적 메서드(다운로드 또는 저장, 입력 임베딩 크기 조정, 헤드 프루닝 등)에 대해서는 상위 클래스 문서를 확인하세요.

이 모델은 또한 PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module)의 하위 클래스입니다. 일반적인 PyTorch Module처럼 사용하며, 일반적인 사용법과 동작에 관한 모든 사항은 PyTorch 문서를 참조하세요.

#### 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)
```

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

**매개변수:**

input_ids (`torch.LongTensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 어휘(input sequence tokens)의 인덱스입니다. 기본적으로 패딩은 무시됩니다. [AutoTokenizer](/docs/transformers/v5.23.0/ko/model_doc/auto#transformers.AutoTokenizer)를 사용하여 인덱스를 얻을 수 있습니다. 자세한 내용은 [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 및 [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)를 참조하세요. [입력 ID란 무엇인가요?](../glossary#input-ids)

attention_mask (`torch.Tensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 패딩 토큰 인덱스에 대한 attention을 수행하지 않도록 방지하는 마스크입니다. `[0, 1]`에서 선택된 마스크 값: - **마스크되지 않은** 토큰은 1, - **마스크된** 토큰은 0. [attention 마스크란?](../glossary#attention-mask)

token_type_ids (`torch.LongTensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 입력의 첫 번째 및 두 번째 부분을 나타내는 세그먼트 토큰 인덱스입니다. 인덱스는 `[0, 1]`에서 선택됩니다:  - 0은 *sentence A* 토큰에 해당하고, - 1은 *sentence B* 토큰에 해당합니다.  [토큰 타입 ID란 무엇인가요?](../glossary#token-type-ids)

position_ids (`torch.LongTensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 각 입력 시퀀스의 토큰 위치 인덱스입니다. `[0, config.n_positions - 1]` 범위에서 선택됩니다. [위치 ID란 무엇인가요?](../glossary#position-ids)

entity_ids (`torch.LongTensor`, shape `(batch_size, entity_length)`) : entity vocabulary에서 entity 토큰의 인덱스입니다. [AutoTokenizer](/docs/transformers/v5.23.0/ko/model_doc/auto#transformers.AutoTokenizer)를 사용하여 인덱스를 얻을 수 있습니다. 자세한 내용은 [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 및 [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)를 참조하세요.

entity_attention_mask (`torch.Tensor`, shape `(batch_size, entity_length)`, *선택 사항*) : 패딩 엔티티 토큰 인덱스에 대한 어텐션 수행을 방지하기 위한 마스크. `[0, 1]`에서 선택된 마스크 값: - **마스크되지 않은** 엔티티 토큰은 1, - **마스크된** 엔티티 토큰은 0.

entity_token_type_ids (`torch.LongTensor`, shape `(batch_size, entity_length)`, *선택 사항*) : 엔티티 토큰 입력의 첫 번째 및 두 번째 부분을 나타내는 세그먼트 토큰 인덱스입니다. 인덱스는 `[0, 1]`에서 선택됩니다: - 0은 *portion A* 엔티티 토큰에 해당하고, - 1은 *portion B* 엔티티 토큰에 해당합니다.

entity_position_ids (`torch.LongTensor`, shape `(batch_size, entity_length, max_mention_length)`, *선택 사항*) : 위치 임베딩에서 각 입력 엔티티의 위치 인덱스. `[0, config.max_position_embeddings - 1]` 범위에서 선택됩니다.

inputs_embeds (`torch.Tensor`, shape `(batch_size, sequence_length, hidden_size)`, *선택 사항*) : `input_ids`를 전달하는 대신 임베디드 표현을 직접 전달할 수 있습니다. 이는 모델의 내부 임베딩 조회 행렬보다 `input_ids` 인덱스를 관련 벡터로 변환하는 방식에 대해 더 많은 제어가 필요한 경우 유용합니다.

labels (`torch.LongTensor`, shape `(batch_size,)` 또는 `(batch_size, num_labels)`, *선택 사항*) : 분류 손실을 계산하는 데 사용되는 라벨. shape가 `(batch_size,)`인 경우, 단일 라벨 분류에 cross entropy loss가 사용됩니다. 이 경우, labels에는 `[0, ..., config.num_labels - 1]`에 있어야 하는 인덱스가 포함되어야 합니다. shape가 `(batch_size, num_labels)`인 경우, 다중 라벨 분류에 binary cross entropy loss가 사용됩니다. 이 경우, labels에는 0과 1이 각각 false와 true를 나타내도록 `[0, 1]`만 포함되어야 합니다.

output_attentions (`bool`, *선택 사항*) : 모든 어텐션 레이어의 어텐션 텐서를 반환할지 여부. 자세한 내용은 반환 텐서 섹션의 `attentions`를 참조하세요.

output_hidden_states (`bool`, *선택 사항*) : 모든 레이어의 hidden states를 반환할지 여부. 자세한 내용은 반환되는 텐서 중 `hidden_states` 항목을 참조하세요.

return_dict (`bool`, *선택 사항*) : 일반 튜플 대신 [ModelOutput](/docs/transformers/v5.23.0/ko/main_classes/output#transformers.utils.ModelOutput)를 반환할지 여부.

**반환값:** `EntityClassificationOutput` 또는 `tuple(torch.Tensor)`

`EntityClassificationOutput` 또는 `torch.Tensor`의 튜플(`return_dict=False`가 전달되거나 `config.return_dict=False`인 경우)로, [LukeConfig](/docs/transformers/v5.23.0/ko/model_doc/luke#transformers.LukeConfig) 및 입력에 따라 다양한 요소를 포함합니다.

[LukeForEntityClassification](/docs/transformers/v5.23.0/ko/model_doc/luke#transformers.LukeForEntityClassification)의 forward 메서드는 `__call__` 특수 메서드를 오버라이드합니다.

`Module` 인스턴스는 전처리 및 후처리 단계를 실행하는 것을 처리하지만, 이 함수는 해당 단계를 조용히 무시하므로, 순전파(forward pass) 레시피를 이 함수 내에서 정의해야 하더라도 이후에는 이 함수 대신 `Module` 인스턴스를 호출해야 합니다.

- **loss** (`torch.Tensor`, shape `(1,)`, *선택 사항*, `labels`가 제공될 때 반환됨) -- 분류 손실.
- **logits** (`torch.Tensor`, shape `(batch_size, config.num_labels)`) -- SoftMax 적용 전 분류 점수.
- **hidden_states** (`tuple[torch.Tensor, ...]`, *선택*, `output_hidden_states=True`가 전달되거나 `config.output_hidden_states=True`인 경우 반환) -- shape가 `(batch_size, sequence_length, hidden_size)`인 `torch.Tensor`의 튜플 (모델에 임베딩 레이어가 있는 경우 임베딩 출력 1개 + 각 레이어의 출력 1개).

  각 레이어의 출력에서 모델의 Hidden-states와 선택적 초기 임베딩 출력을 포함합니다.
- **entity_hidden_states** (`tuple(torch.Tensor)`, *선택 사항*, `output_hidden_states=True`가 전달되었거나 `config.output_hidden_states=True`인 경우 반환됨) -- `torch.Tensor`의 튜플(임베딩 출력 1개 + 각 레이어의 출력 1개)로, 모양은 `(batch_size, entity_length, hidden_size)`입니다. 각 레이어의 출력에서 모델의 엔티티 히든 스테이트와 초기 엔티티 임베딩 출력을 포함합니다.
- **attentions** (`tuple[torch.Tensor, ...]`, *선택*, `output_attentions=True`가 전달되었거나 `config.output_attentions=True`인 경우 반환) -- 각 레이어마다 하나씩 포함된 `torch.Tensor` 튜플로, shape는 `(batch_size, num_heads, sequence_length, sequence_length)`입니다.

  self-attention 헤드에서 가중 평균을 계산하는 데 사용되는 attention softmax 이후의 attention 가중치입니다.

예:

```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)
```

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

**매개변수:**

config ([LukeConfig](/docs/transformers/v5.23.0/ko/model_doc/luke#transformers.LukeConfig)) : 모델의 모든 매개변수를 포함하는 모델 구성 클래스입니다. 구성 파일로 초기화하는 것은 모델과 관련된 가중치를 로드하지 않으며, 구성 정보만 로드합니다. 모델 가중치를 로드하려면 [from_pretrained()](/docs/transformers/v5.23.0/ko/main_classes/model#transformers.PreTrainedModel.from_pretrained) 메서드를 확인하세요.

TACRED과 같은 엔티티 쌍 분류 작업을 위해, 두 엔티티 토큰의 히든 스테이트 위에 선형 레이어를 배치한 분류 헤드를 갖춘 LUKE 모델

이 모델은 [PreTrainedModel](/docs/transformers/v5.23.0/ko/main_classes/model#transformers.PreTrainedModel)에서 상속됩니다. 라이브러리가 모든 모델에 대해 구현하는 일반적 메서드(다운로드 또는 저장, 입력 임베딩 크기 조정, 헤드 프루닝 등)에 대해서는 상위 클래스 문서를 확인하세요.

이 모델은 또한 PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module)의 하위 클래스입니다. 일반적인 PyTorch Module처럼 사용하며, 일반적인 사용법과 동작에 관한 모든 사항은 PyTorch 문서를 참조하세요.

#### 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)
```

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

**매개변수:**

input_ids (`torch.LongTensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 어휘(input sequence tokens)의 인덱스입니다. 기본적으로 패딩은 무시됩니다. [AutoTokenizer](/docs/transformers/v5.23.0/ko/model_doc/auto#transformers.AutoTokenizer)를 사용하여 인덱스를 얻을 수 있습니다. 자세한 내용은 [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 및 [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)를 참조하세요. [입력 ID란 무엇인가요?](../glossary#input-ids)

attention_mask (`torch.Tensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 패딩 토큰 인덱스에 대한 attention을 수행하지 않도록 방지하는 마스크입니다. `[0, 1]`에서 선택된 마스크 값: - **마스크되지 않은** 토큰은 1, - **마스크된** 토큰은 0. [attention 마스크란?](../glossary#attention-mask)

token_type_ids (`torch.LongTensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 입력의 첫 번째 및 두 번째 부분을 나타내는 세그먼트 토큰 인덱스입니다. 인덱스는 `[0, 1]`에서 선택됩니다:  - 0은 *sentence A* 토큰에 해당하고, - 1은 *sentence B* 토큰에 해당합니다.  [토큰 타입 ID란 무엇인가요?](../glossary#token-type-ids)

position_ids (`torch.LongTensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 각 입력 시퀀스의 토큰 위치 인덱스입니다. `[0, config.n_positions - 1]` 범위에서 선택됩니다. [위치 ID란 무엇인가요?](../glossary#position-ids)

entity_ids (`torch.LongTensor`, shape `(batch_size, entity_length)`) : entity vocabulary에서 entity 토큰의 인덱스입니다. [AutoTokenizer](/docs/transformers/v5.23.0/ko/model_doc/auto#transformers.AutoTokenizer)를 사용하여 인덱스를 얻을 수 있습니다. 자세한 내용은 [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 및 [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)를 참조하세요.

entity_attention_mask (`torch.Tensor`, shape `(batch_size, entity_length)`, *선택 사항*) : 패딩 엔티티 토큰 인덱스에 대한 어텐션 수행을 방지하기 위한 마스크. `[0, 1]`에서 선택된 마스크 값: - **마스크되지 않은** 엔티티 토큰은 1, - **마스크된** 엔티티 토큰은 0.

entity_token_type_ids (`torch.LongTensor`, shape `(batch_size, entity_length)`, *선택 사항*) : 엔티티 토큰 입력의 첫 번째 및 두 번째 부분을 나타내는 세그먼트 토큰 인덱스입니다. 인덱스는 `[0, 1]`에서 선택됩니다: - 0은 *portion A* 엔티티 토큰에 해당하고, - 1은 *portion B* 엔티티 토큰에 해당합니다.

entity_position_ids (`torch.LongTensor`, shape `(batch_size, entity_length, max_mention_length)`, *선택 사항*) : 위치 임베딩에서 각 입력 엔티티의 위치 인덱스. `[0, config.max_position_embeddings - 1]` 범위에서 선택됩니다.

inputs_embeds (`torch.Tensor`, shape `(batch_size, sequence_length, hidden_size)`, *선택 사항*) : `input_ids`를 전달하는 대신 임베디드 표현을 직접 전달할 수 있습니다. 이는 모델의 내부 임베딩 조회 행렬보다 `input_ids` 인덱스를 관련 벡터로 변환하는 방식에 대해 더 많은 제어가 필요한 경우 유용합니다.

labels (`torch.LongTensor`, shape `(batch_size,)` 또는 `(batch_size, num_labels)`, *선택 사항*) : 분류 손실을 계산하는 데 사용되는 라벨. shape가 `(batch_size,)`인 경우, 단일 라벨 분류에 cross entropy loss가 사용됩니다. 이 경우, labels에는 `[0, ..., config.num_labels - 1]`에 있어야 하는 인덱스가 포함되어야 합니다. shape가 `(batch_size, num_labels)`인 경우, 다중 라벨 분류에 binary cross entropy loss가 사용됩니다. 이 경우, labels에는 0과 1이 각각 false와 true를 나타내도록 `[0, 1]`만 포함되어야 합니다.

output_attentions (`bool`, *선택 사항*) : 모든 어텐션 레이어의 어텐션 텐서를 반환할지 여부. 자세한 내용은 반환 텐서 섹션의 `attentions`를 참조하세요.

output_hidden_states (`bool`, *선택 사항*) : 모든 레이어의 hidden states를 반환할지 여부. 자세한 내용은 반환되는 텐서 중 `hidden_states` 항목을 참조하세요.

return_dict (`bool`, *선택 사항*) : 일반 튜플 대신 [ModelOutput](/docs/transformers/v5.23.0/ko/main_classes/output#transformers.utils.ModelOutput)를 반환할지 여부.

**반환값:** `EntityPairClassificationOutput` 또는 `tuple(torch.Tensor)`

`EntityPairClassificationOutput` 또는 `torch.Tensor`의 튜플(`return_dict=False`가 전달되거나 `config.return_dict=False`인 경우)로, 구성([LukeConfig](/docs/transformers/v5.23.0/ko/model_doc/luke#transformers.LukeConfig))과 입력에 따라 다양한 요소를 포함합니다.

[LukeForEntityPairClassification](/docs/transformers/v5.23.0/ko/model_doc/luke#transformers.LukeForEntityPairClassification)의 forward 메서드는 `__call__` 특수 메서드를 오버라이드합니다.

`Module` 인스턴스는 전처리 및 후처리 단계를 실행하는 것을 처리하지만, 이 함수는 해당 단계를 조용히 무시하므로, 순전파(forward pass) 레시피를 이 함수 내에서 정의해야 하더라도 이후에는 이 함수 대신 `Module` 인스턴스를 호출해야 합니다.

- **loss** (`torch.Tensor`, shape `(1,)`, *선택 사항*, `labels`가 제공될 때 반환됨) -- 분류 손실.
- **logits** (`torch.Tensor`, shape `(batch_size, config.num_labels)`) -- SoftMax 적용 전 분류 점수.
- **hidden_states** (`tuple[torch.Tensor, ...]`, *선택*, `output_hidden_states=True`가 전달되거나 `config.output_hidden_states=True`인 경우 반환) -- shape가 `(batch_size, sequence_length, hidden_size)`인 `torch.Tensor`의 튜플 (모델에 임베딩 레이어가 있는 경우 임베딩 출력 1개 + 각 레이어의 출력 1개).

  각 레이어의 출력에서 모델의 Hidden-states와 선택적 초기 임베딩 출력을 포함합니다.
- **entity_hidden_states** (`tuple(torch.Tensor)`, *선택 사항*, `output_hidden_states=True`가 전달되었거나 `config.output_hidden_states=True`인 경우 반환됨) -- `torch.Tensor`의 튜플(임베딩 출력 1개 + 각 레이어의 출력 1개)로, 모양은 `(batch_size, entity_length, hidden_size)`입니다. 각 레이어의 출력에서 모델의 엔티티 히든 스테이트와 초기 엔티티 임베딩 출력을 포함합니다.
- **attentions** (`tuple[torch.Tensor, ...]`, *선택*, `output_attentions=True`가 전달되었거나 `config.output_attentions=True`인 경우 반환) -- 각 레이어마다 하나씩 포함된 `torch.Tensor` 튜플로, shape는 `(batch_size, num_heads, sequence_length, sequence_length)`입니다.

  self-attention 헤드에서 가중 평균을 계산하는 데 사용되는 attention softmax 이후의 attention 가중치입니다.

예:

```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)
```

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

**매개변수:**

config ([LukeConfig](/docs/transformers/v5.23.0/ko/model_doc/luke#transformers.LukeConfig)) : 모델의 모든 매개변수를 포함하는 모델 구성 클래스입니다. 구성 파일로 초기화하는 것은 모델과 관련된 가중치를 로드하지 않으며, 구성 정보만 로드합니다. 모델 가중치를 로드하려면 [from_pretrained()](/docs/transformers/v5.23.0/ko/main_classes/model#transformers.PreTrainedModel.from_pretrained) 메서드를 확인하세요.

명명된 개체 인식과 같은 작업을 위해 숨겨진 상태 출력 위에 선형 레이어를 배치한 스팬 분류 헤드를 갖춘 LUKE 모델.

이 모델은 [PreTrainedModel](/docs/transformers/v5.23.0/ko/main_classes/model#transformers.PreTrainedModel)에서 상속됩니다. 라이브러리가 모든 모델에 대해 구현하는 일반적 메서드(다운로드 또는 저장, 입력 임베딩 크기 조정, 헤드 프루닝 등)에 대해서는 상위 클래스 문서를 확인하세요.

이 모델은 또한 PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module)의 하위 클래스입니다. 일반적인 PyTorch Module처럼 사용하며, 일반적인 사용법과 동작에 관한 모든 사항은 PyTorch 문서를 참조하세요.

#### 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)
```

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

**매개변수:**

input_ids (`torch.LongTensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 어휘(input sequence tokens)의 인덱스입니다. 기본적으로 패딩은 무시됩니다. [AutoTokenizer](/docs/transformers/v5.23.0/ko/model_doc/auto#transformers.AutoTokenizer)를 사용하여 인덱스를 얻을 수 있습니다. 자세한 내용은 [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 및 [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)를 참조하세요. [입력 ID란 무엇인가요?](../glossary#input-ids)

attention_mask (`torch.Tensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 패딩 토큰 인덱스에 대한 attention을 수행하지 않도록 방지하는 마스크입니다. `[0, 1]`에서 선택된 마스크 값: - **마스크되지 않은** 토큰은 1, - **마스크된** 토큰은 0. [attention 마스크란?](../glossary#attention-mask)

token_type_ids (`torch.LongTensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 입력의 첫 번째 및 두 번째 부분을 나타내는 세그먼트 토큰 인덱스입니다. 인덱스는 `[0, 1]`에서 선택됩니다:  - 0은 *sentence A* 토큰에 해당하고, - 1은 *sentence B* 토큰에 해당합니다.  [토큰 타입 ID란 무엇인가요?](../glossary#token-type-ids)

position_ids (`torch.LongTensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 각 입력 시퀀스의 토큰 위치 인덱스입니다. `[0, config.n_positions - 1]` 범위에서 선택됩니다. [위치 ID란 무엇인가요?](../glossary#position-ids)

entity_ids (`torch.LongTensor`, shape `(batch_size, entity_length)`) : entity vocabulary에서 entity 토큰의 인덱스입니다. [AutoTokenizer](/docs/transformers/v5.23.0/ko/model_doc/auto#transformers.AutoTokenizer)를 사용하여 인덱스를 얻을 수 있습니다. 자세한 내용은 [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 및 [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)를 참조하세요.

entity_attention_mask (`torch.Tensor`, shape `(batch_size, entity_length)`, *선택 사항*) : 패딩 엔티티 토큰 인덱스에 대한 어텐션 수행을 방지하기 위한 마스크. `[0, 1]`에서 선택된 마스크 값: - **마스크되지 않은** 엔티티 토큰은 1, - **마스크된** 엔티티 토큰은 0.

entity_token_type_ids (`torch.LongTensor`, shape `(batch_size, entity_length)`, *선택 사항*) : 엔티티 토큰 입력의 첫 번째 및 두 번째 부분을 나타내는 세그먼트 토큰 인덱스입니다. 인덱스는 `[0, 1]`에서 선택됩니다: - 0은 *portion A* 엔티티 토큰에 해당하고, - 1은 *portion B* 엔티티 토큰에 해당합니다.

entity_position_ids (`torch.LongTensor`, shape `(batch_size, entity_length, max_mention_length)`, *선택 사항*) : 위치 임베딩에서 각 입력 엔티티의 위치 인덱스. `[0, config.max_position_embeddings - 1]` 범위에서 선택됩니다.

entity_start_positions (`torch.LongTensor`, *선택 사항*) : 단어 토큰 시퀀스에서 엔티티의 시작 위치입니다.

entity_end_positions (`torch.LongTensor`, *선택 사항*) : 단어 토큰 시퀀스에서 엔티티의 끝 위치입니다.

inputs_embeds (`torch.Tensor`, shape `(batch_size, sequence_length, hidden_size)`, *선택 사항*) : `input_ids`를 전달하는 대신 임베디드 표현을 직접 전달할 수 있습니다. 이는 모델의 내부 임베딩 조회 행렬보다 `input_ids` 인덱스를 관련 벡터로 변환하는 방식에 대해 더 많은 제어가 필요한 경우 유용합니다.

labels (`torch.LongTensor`, shape `(batch_size, entity_length)` 또는 `(batch_size, entity_length, num_labels)`, *선택 사항*) : 분류 손실을 계산하는 데 사용되는 라벨. shape가 `(batch_size, entity_length)`인 경우, 단일 라벨 분류에 cross entropy loss가 사용됩니다. 이 경우, labels에는 `[0, ..., config.num_labels - 1]`에 있어야 하는 인덱스가 포함되어야 합니다. shape가 `(batch_size, entity_length, num_labels)`인 경우, 다중 라벨 분류에 binary cross entropy loss가 사용됩니다. 이 경우, labels에는 0과 1이 각각 false와 true를 나타내도록 `[0, 1]`만 포함되어야 합니다.

output_attentions (`bool`, *선택 사항*) : 모든 어텐션 레이어의 어텐션 텐서를 반환할지 여부. 자세한 내용은 반환 텐서 섹션의 `attentions`를 참조하세요.

output_hidden_states (`bool`, *선택 사항*) : 모든 레이어의 hidden states를 반환할지 여부. 자세한 내용은 반환되는 텐서 중 `hidden_states` 항목을 참조하세요.

return_dict (`bool`, *선택 사항*) : 일반 튜플 대신 [ModelOutput](/docs/transformers/v5.23.0/ko/main_classes/output#transformers.utils.ModelOutput)를 반환할지 여부.

**반환값:** `EntitySpanClassificationOutput` 또는 `tuple(torch.Tensor)`

`EntitySpanClassificationOutput` 또는 `torch.Tensor`의 튜플(`return_dict=False`가 전달되거나 `config.return_dict=False`인 경우). 구성([LukeConfig](/docs/transformers/v5.23.0/ko/model_doc/luke#transformers.LukeConfig)) 및 입력에 따라 다양한 요소를 포함합니다.

[LukeForEntitySpanClassification](/docs/transformers/v5.23.0/ko/model_doc/luke#transformers.LukeForEntitySpanClassification)의 forward 메서드는 `__call__` 특수 메서드를 오버라이드합니다.

`Module` 인스턴스는 전처리 및 후처리 단계를 실행하는 것을 처리하지만, 이 함수는 해당 단계를 조용히 무시하므로, 순전파(forward pass) 레시피를 이 함수 내에서 정의해야 하더라도 이후에는 이 함수 대신 `Module` 인스턴스를 호출해야 합니다.

- **loss** (`torch.Tensor`, shape `(1,)`, *선택 사항*, `labels`가 제공될 때 반환됨) -- 분류 손실.
- **logits** (`torch.Tensor`, shape `(batch_size, entity_length, config.num_labels)`) -- SoftMax 적용 전 분류 점수.
- **hidden_states** (`tuple[torch.Tensor, ...]`, *선택*, `output_hidden_states=True`가 전달되거나 `config.output_hidden_states=True`인 경우 반환) -- shape가 `(batch_size, sequence_length, hidden_size)`인 `torch.Tensor`의 튜플 (모델에 임베딩 레이어가 있는 경우 임베딩 출력 1개 + 각 레이어의 출력 1개).

  각 레이어의 출력에서 모델의 Hidden-states와 선택적 초기 임베딩 출력을 포함합니다.
- **entity_hidden_states** (`tuple(torch.Tensor)`, *선택 사항*, `output_hidden_states=True`가 전달되었거나 `config.output_hidden_states=True`인 경우 반환됨) -- `torch.Tensor`의 튜플(임베딩 출력 1개 + 각 레이어의 출력 1개)로, 모양은 `(batch_size, entity_length, hidden_size)`입니다. 각 레이어의 출력에서 모델의 엔티티 히든 스테이트와 초기 엔티티 임베딩 출력을 포함합니다.
- **attentions** (`tuple[torch.Tensor, ...]`, *선택*, `output_attentions=True`가 전달되었거나 `config.output_attentions=True`인 경우 반환) -- 각 레이어마다 하나씩 포함된 `torch.Tensor` 튜플로, shape는 `(batch_size, num_heads, sequence_length, sequence_length)`입니다.

  self-attention 헤드에서 가중 평균을 계산하는 데 사용되는 attention softmax 이후의 attention 가중치입니다.

예:

```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)
```

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

**매개변수:**

config ([LukeConfig](/docs/transformers/v5.23.0/ko/model_doc/luke#transformers.LukeConfig)) : 모델의 모든 매개변수를 포함하는 모델 구성 클래스입니다. 구성 파일로 초기화하는 것은 모델과 관련된 가중치를 로드하지 않으며, 구성 정보만 로드합니다. 모델 가중치를 로드하려면 [from_pretrained()](/docs/transformers/v5.23.0/ko/main_classes/model#transformers.PreTrainedModel.from_pretrained) 메서드를 확인하세요.

GLUE 작업과 같이, 풀링된 출력 위에 선형 레이어를 올려놓은 시퀀스 분류/회귀 헤드가 있는 LUKE Model transformer.

이 모델은 [PreTrainedModel](/docs/transformers/v5.23.0/ko/main_classes/model#transformers.PreTrainedModel)에서 상속됩니다. 라이브러리가 모든 모델에 대해 구현하는 일반적 메서드(다운로드 또는 저장, 입력 임베딩 크기 조정, 헤드 프루닝 등)에 대해서는 상위 클래스 문서를 확인하세요.

이 모델은 또한 PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module)의 하위 클래스입니다. 일반적인 PyTorch Module처럼 사용하며, 일반적인 사용법과 동작에 관한 모든 사항은 PyTorch 문서를 참조하세요.

#### 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)
```

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

**매개변수:**

input_ids (`torch.LongTensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 어휘(input sequence tokens)의 인덱스입니다. 기본적으로 패딩은 무시됩니다. [AutoTokenizer](/docs/transformers/v5.23.0/ko/model_doc/auto#transformers.AutoTokenizer)를 사용하여 인덱스를 얻을 수 있습니다. 자세한 내용은 [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 및 [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)를 참조하세요. [입력 ID란 무엇인가요?](../glossary#input-ids)

attention_mask (`torch.Tensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 패딩 토큰 인덱스에 대한 attention을 수행하지 않도록 방지하는 마스크입니다. `[0, 1]`에서 선택된 마스크 값: - **마스크되지 않은** 토큰은 1, - **마스크된** 토큰은 0. [attention 마스크란?](../glossary#attention-mask)

token_type_ids (`torch.LongTensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 입력의 첫 번째 및 두 번째 부분을 나타내는 세그먼트 토큰 인덱스입니다. 인덱스는 `[0, 1]`에서 선택됩니다:  - 0은 *sentence A* 토큰에 해당하고, - 1은 *sentence B* 토큰에 해당합니다.  [토큰 타입 ID란 무엇인가요?](../glossary#token-type-ids)

position_ids (`torch.LongTensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 각 입력 시퀀스의 토큰 위치 인덱스입니다. `[0, config.n_positions - 1]` 범위에서 선택됩니다. [위치 ID란 무엇인가요?](../glossary#position-ids)

entity_ids (`torch.LongTensor`, shape `(batch_size, entity_length)`) : entity vocabulary에서 entity 토큰의 인덱스입니다. [AutoTokenizer](/docs/transformers/v5.23.0/ko/model_doc/auto#transformers.AutoTokenizer)를 사용하여 인덱스를 얻을 수 있습니다. 자세한 내용은 [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 및 [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)를 참조하세요.

entity_attention_mask (`torch.Tensor`, shape `(batch_size, entity_length)`, *선택 사항*) : 패딩 엔티티 토큰 인덱스에 대한 어텐션 수행을 방지하기 위한 마스크. `[0, 1]`에서 선택된 마스크 값: - **마스크되지 않은** 엔티티 토큰은 1, - **마스크된** 엔티티 토큰은 0.

entity_token_type_ids (`torch.LongTensor`, shape `(batch_size, entity_length)`, *선택 사항*) : 엔티티 토큰 입력의 첫 번째 및 두 번째 부분을 나타내는 세그먼트 토큰 인덱스입니다. 인덱스는 `[0, 1]`에서 선택됩니다: - 0은 *portion A* 엔티티 토큰에 해당하고, - 1은 *portion B* 엔티티 토큰에 해당합니다.

entity_position_ids (`torch.LongTensor`, shape `(batch_size, entity_length, max_mention_length)`, *선택 사항*) : 위치 임베딩에서 각 입력 엔티티의 위치 인덱스. `[0, config.max_position_embeddings - 1]` 범위에서 선택됩니다.

inputs_embeds (`torch.Tensor`, shape `(batch_size, sequence_length, hidden_size)`, *선택 사항*) : `input_ids`를 전달하는 대신 임베디드 표현을 직접 전달할 수 있습니다. 이는 모델의 내부 임베딩 조회 행렬보다 `input_ids` 인덱스를 관련 벡터로 변환하는 방식에 대해 더 많은 제어가 필요한 경우 유용합니다.

labels (`torch.LongTensor`, shape `(batch_size,)`, *선택 사항*) : 시퀀스 분류/회귀 손실을 계산하는 데 사용되는 라벨. 인덱스는 `[0, ..., config.num_labels - 1]` 범위에 있어야 합니다. `config.num_labels == 1`인 경우 회귀 손실(평균 제곱 오차)이 계산되고, `config.num_labels > 1`인 경우 분류 손실(교차 엔트로피)이 계산됩니다.

output_attentions (`bool`, *선택 사항*) : 모든 어텐션 레이어의 어텐션 텐서를 반환할지 여부. 자세한 내용은 반환 텐서 섹션의 `attentions`를 참조하세요.

output_hidden_states (`bool`, *선택 사항*) : 모든 레이어의 hidden states를 반환할지 여부. 자세한 내용은 반환되는 텐서 중 `hidden_states` 항목을 참조하세요.

return_dict (`bool`, *선택 사항*) : 일반 튜플 대신 [ModelOutput](/docs/transformers/v5.23.0/ko/main_classes/output#transformers.utils.ModelOutput)를 반환할지 여부.

**반환값:** `LukeSequenceClassifierOutput` 또는 `tuple(torch.Tensor)`

`LukeSequenceClassifierOutput` 또는 `torch.Tensor`의 튜플(`return_dict=False`가 전달되거나 `config.return_dict=False`인 경우)로, [LukeConfig](/docs/transformers/v5.23.0/ko/model_doc/luke#transformers.LukeConfig) 및 입력에 따라 다양한 요소를 포함합니다.

[LukeForSequenceClassification](/docs/transformers/v5.23.0/ko/model_doc/luke#transformers.LukeForSequenceClassification)의 forward 메서드는 `__call__` 특수 메서드를 오버라이드합니다.

`Module` 인스턴스는 전처리 및 후처리 단계를 실행하는 것을 처리하지만, 이 함수는 해당 단계를 조용히 무시하므로, 순전파(forward pass) 레시피를 이 함수 내에서 정의해야 하더라도 이후에는 이 함수 대신 `Module` 인스턴스를 호출해야 합니다.

- **loss** (`torch.Tensor`, shape `(1,)`, *선택*, `labels`이 제공될 때 반환됨) -- 분류(또는 config.num_labels==1인 경우 회귀) 손실.
- **logits** (`torch.Tensor`, shape `(batch_size, config.num_labels)`) -- SoftMax 적용 전 분류(또는 config.num_labels==1인 경우 회귀) 점수.
- **hidden_states** (`tuple[torch.Tensor, ...]`, *선택*, `output_hidden_states=True`가 전달되거나 `config.output_hidden_states=True`인 경우 반환) -- shape가 `(batch_size, sequence_length, hidden_size)`인 `torch.Tensor`의 튜플 (모델에 임베딩 레이어가 있는 경우 임베딩 출력 1개 + 각 레이어의 출력 1개).

  각 레이어의 출력에서 모델의 Hidden-states와 선택적 초기 임베딩 출력을 포함합니다.
- **entity_hidden_states** (`tuple(torch.Tensor)`, *선택 사항*, `output_hidden_states=True`가 전달되었거나 `config.output_hidden_states=True`인 경우 반환됨) -- `torch.Tensor`의 튜플(임베딩 출력 1개 + 각 레이어의 출력 1개)로, 모양은 `(batch_size, entity_length, hidden_size)`입니다. 각 레이어의 출력에서 모델의 엔티티 히든 스테이트와 초기 엔티티 임베딩 출력을 포함합니다.
- **attentions** (`tuple[torch.Tensor, ...]`, *선택*, `output_attentions=True`가 전달되었거나 `config.output_attentions=True`인 경우 반환) -- 각 레이어마다 하나씩 포함된 `torch.Tensor` 튜플로, shape는 `(batch_size, num_heads, sequence_length, sequence_length)`입니다.

  self-attention 헤드에서 가중 평균을 계산하는 데 사용되는 attention softmax 이후의 attention 가중치입니다.

단일 레이블 분류의 예시:

```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)
...
```

다중 레이블 분류의 예시:

```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)
```

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

**매개변수:**

config ([LukeConfig](/docs/transformers/v5.23.0/ko/model_doc/luke#transformers.LukeConfig)) : 모델의 모든 매개변수를 포함하는 모델 구성 클래스입니다. 구성 파일로 초기화하는 것은 모델과 관련된 가중치를 로드하지 않으며, 구성 정보만 로드합니다. 모델 가중치를 로드하려면 [from_pretrained()](/docs/transformers/v5.23.0/ko/main_classes/model#transformers.PreTrainedModel.from_pretrained) 메서드를 확인하세요.

RocStories/SWAG 작업과 같이, 풀링된 출력 위에 선형 레이어와 softmax를 적용한 다중 선택 분류 헤드가 있는 Luke 모델.

이 모델은 [PreTrainedModel](/docs/transformers/v5.23.0/ko/main_classes/model#transformers.PreTrainedModel)에서 상속됩니다. 라이브러리가 모든 모델에 대해 구현하는 일반적 메서드(다운로드 또는 저장, 입력 임베딩 크기 조정, 헤드 프루닝 등)에 대해서는 상위 클래스 문서를 확인하세요.

이 모델은 또한 PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module)의 하위 클래스입니다. 일반적인 PyTorch Module처럼 사용하며, 일반적인 사용법과 동작에 관한 모든 사항은 PyTorch 문서를 참조하세요.

#### 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)
```

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

**매개변수:**

input_ids (`torch.LongTensor`, shape `(batch_size, num_choices, sequence_length)`) : 어휘 사전에서 입력 시퀀스 토큰의 인덱스입니다. [AutoTokenizer](/docs/transformers/v5.23.0/ko/model_doc/auto#transformers.AutoTokenizer)를 사용하여 인덱스를 얻을 수 있습니다. 자세한 내용은 [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 및 [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)를 참조하세요. [입력 ID란 무엇인가요?](../glossary#input-ids)

attention_mask (`torch.Tensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 패딩 토큰 인덱스에 대한 attention을 수행하지 않도록 방지하는 마스크입니다. `[0, 1]`에서 선택된 마스크 값: - **마스크되지 않은** 토큰은 1, - **마스크된** 토큰은 0. [attention 마스크란?](../glossary#attention-mask)

token_type_ids (`torch.LongTensor`, shape `(batch_size, num_choices, sequence_length)`, *선택 사항*) : 입력의 첫 번째와 두 번째 부분을 나타내는 세그먼트 토큰 인덱스입니다. 인덱스는 `[0, 1]`에서 선택됩니다: - 0은 *sentence A* 토큰에 해당하고, - 1은 *sentence B* 토큰에 해당합니다. [토큰 타입 ID란 무엇인가요?](../glossary#token-type-ids)

position_ids (`torch.LongTensor`, shape `(batch_size, num_choices, sequence_length)`, *선택 사항*) : 각 입력 시퀀스의 토큰 위치 인덱스입니다. `[0, config.max_position_embeddings - 1]` 범위에서 선택됩니다.  [위치 ID란 무엇인가요?](../glossary#position-ids)

entity_ids (`torch.LongTensor`, shape `(batch_size, entity_length)`) : entity vocabulary에서 entity 토큰의 인덱스입니다. [AutoTokenizer](/docs/transformers/v5.23.0/ko/model_doc/auto#transformers.AutoTokenizer)를 사용하여 인덱스를 얻을 수 있습니다. 자세한 내용은 [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 및 [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)를 참조하세요.

entity_attention_mask (`torch.Tensor`, shape `(batch_size, entity_length)`, *선택 사항*) : 패딩 엔티티 토큰 인덱스에 대한 어텐션 수행을 방지하기 위한 마스크. `[0, 1]`에서 선택된 마스크 값: - **마스크되지 않은** 엔티티 토큰은 1, - **마스크된** 엔티티 토큰은 0.

entity_token_type_ids (`torch.LongTensor`, shape `(batch_size, entity_length)`, *선택 사항*) : 엔티티 토큰 입력의 첫 번째 및 두 번째 부분을 나타내는 세그먼트 토큰 인덱스입니다. 인덱스는 `[0, 1]`에서 선택됩니다: - 0은 *portion A* 엔티티 토큰에 해당하고, - 1은 *portion B* 엔티티 토큰에 해당합니다.

entity_position_ids (`torch.LongTensor`, shape `(batch_size, entity_length, max_mention_length)`, *선택 사항*) : 위치 임베딩에서 각 입력 엔티티의 위치 인덱스. `[0, config.max_position_embeddings - 1]` 범위에서 선택됩니다.

inputs_embeds (`torch.Tensor`, shape `(batch_size, num_choices, sequence_length, hidden_size)`, *선택 사항*) : `input_ids`를 전달하는 대신 임베디드 표현을 직접 전달할 수 있습니다. 이는 모델의 내부 임베딩 조회 행렬보다 `input_ids` 인덱스를 관련 벡터로 변환하는 방식에 대한 더 세밀한 제어가 필요한 경우 유용합니다.

labels (`torch.LongTensor`, shape `(batch_size,)`, *선택 사항*) : 다중 선택 분류 손실을 계산하는 데 사용되는 라벨입니다. 인덱스는 `[0, ..., num_choices-1]` 범위에 있어야 하며, `num_choices`는 입력 텐서의 두 번째 차원의 크기입니다. (위 `input_ids` 참조)

output_attentions (`bool`, *선택 사항*) : 모든 어텐션 레이어의 어텐션 텐서를 반환할지 여부. 자세한 내용은 반환 텐서 섹션의 `attentions`를 참조하세요.

output_hidden_states (`bool`, *선택 사항*) : 모든 레이어의 hidden states를 반환할지 여부. 자세한 내용은 반환되는 텐서 중 `hidden_states` 항목을 참조하세요.

return_dict (`bool`, *선택 사항*) : 일반 튜플 대신 [ModelOutput](/docs/transformers/v5.23.0/ko/main_classes/output#transformers.utils.ModelOutput)를 반환할지 여부.

**반환값:** `LukeMultipleChoiceModelOutput` 또는 `tuple(torch.Tensor)`

구성([LukeConfig](/docs/transformers/v5.23.0/ko/model_doc/luke#transformers.LukeConfig))과 입력에 따라 다양한 요소를 포함하는 `LukeMultipleChoiceModelOutput` 또는 `torch.Tensor`의 튜플(`return_dict=False`가 전달되거나 `config.return_dict=False`인 경우).

[LukeForMultipleChoice](/docs/transformers/v5.23.0/ko/model_doc/luke#transformers.LukeForMultipleChoice)의 forward 메서드는 `__call__` 특수 메서드를 오버라이드합니다.

`Module` 인스턴스는 전처리 및 후처리 단계를 실행하는 것을 처리하지만, 이 함수는 해당 단계를 조용히 무시하므로, 순전파(forward pass) 레시피를 이 함수 내에서 정의해야 하더라도 이후에는 이 함수 대신 `Module` 인스턴스를 호출해야 합니다.

- **loss** (shape가 *(1,)*인 `torch.Tensor`, *선택 사항*, `labels`가 제공될 때 반환됨) -- 분류 손실.
- **logits** (`torch.Tensor`, shape `(batch_size, num_choices)`) -- *num_choices*는 입력 텐서의 두 번째 차원입니다. (위 *input_ids* 참조)

  SoftMax 적용 전 분류 점수.
- **hidden_states** (`tuple[torch.Tensor, ...]`, *선택*, `output_hidden_states=True`가 전달되거나 `config.output_hidden_states=True`인 경우 반환) -- shape가 `(batch_size, sequence_length, hidden_size)`인 `torch.Tensor`의 튜플 (모델에 임베딩 레이어가 있는 경우 임베딩 출력 1개 + 각 레이어의 출력 1개).

  각 레이어의 출력에서 모델의 Hidden-states와 선택적 초기 임베딩 출력을 포함합니다.
- **entity_hidden_states** (`tuple(torch.Tensor)`, *선택 사항*, `output_hidden_states=True`가 전달되었거나 `config.output_hidden_states=True`인 경우 반환됨) -- `torch.Tensor`의 튜플(임베딩 출력 1개 + 각 레이어의 출력 1개)로, 모양은 `(batch_size, entity_length, hidden_size)`입니다. 각 레이어의 출력에서 모델의 엔티티 히든 스테이트와 초기 엔티티 임베딩 출력을 포함합니다.
- **attentions** (`tuple[torch.Tensor, ...]`, *선택*, `output_attentions=True`가 전달되었거나 `config.output_attentions=True`인 경우 반환) -- 각 레이어마다 하나씩 포함된 `torch.Tensor` 튜플로, shape는 `(batch_size, num_heads, sequence_length, sequence_length)`입니다.

  self-attention 헤드에서 가중 평균을 계산하는 데 사용되는 attention softmax 이후의 attention 가중치입니다.

예:

```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)
```

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

**매개변수:**

config ([LukeConfig](/docs/transformers/v5.23.0/ko/model_doc/luke#transformers.LukeConfig)) : 모델의 모든 매개변수를 포함하는 모델 구성 클래스입니다. 구성 파일로 초기화하는 것은 모델과 관련된 가중치를 로드하지 않으며, 구성 정보만 로드합니다. 모델 가중치를 로드하려면 [from_pretrained()](/docs/transformers/v5.23.0/ko/main_classes/model#transformers.PreTrainedModel.from_pretrained) 메서드를 확인하세요.

토큰 분류 헤드가 위에 있는 LUKE 모델(히든 스테이트 출력 위에 선형 레이어가 있는 구조). LUKE를 사용하여 개체명 인식(NER) 작업을 해결하려면 이 클래스보다 `LukeForEntitySpanClassification`가 더 적합합니다.

이 모델은 [PreTrainedModel](/docs/transformers/v5.23.0/ko/main_classes/model#transformers.PreTrainedModel)에서 상속됩니다. 라이브러리가 모든 모델에 대해 구현하는 일반적 메서드(다운로드 또는 저장, 입력 임베딩 크기 조정, 헤드 프루닝 등)에 대해서는 상위 클래스 문서를 확인하세요.

이 모델은 또한 PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module)의 하위 클래스입니다. 일반적인 PyTorch Module처럼 사용하며, 일반적인 사용법과 동작에 관한 모든 사항은 PyTorch 문서를 참조하세요.

#### 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)
```

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

**매개변수:**

input_ids (`torch.LongTensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 어휘(input sequence tokens)의 인덱스입니다. 기본적으로 패딩은 무시됩니다. [AutoTokenizer](/docs/transformers/v5.23.0/ko/model_doc/auto#transformers.AutoTokenizer)를 사용하여 인덱스를 얻을 수 있습니다. 자세한 내용은 [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 및 [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)를 참조하세요. [입력 ID란 무엇인가요?](../glossary#input-ids)

attention_mask (`torch.Tensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 패딩 토큰 인덱스에 대한 attention을 수행하지 않도록 방지하는 마스크입니다. `[0, 1]`에서 선택된 마스크 값: - **마스크되지 않은** 토큰은 1, - **마스크된** 토큰은 0. [attention 마스크란?](../glossary#attention-mask)

token_type_ids (`torch.LongTensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 입력의 첫 번째 및 두 번째 부분을 나타내는 세그먼트 토큰 인덱스입니다. 인덱스는 `[0, 1]`에서 선택됩니다:  - 0은 *sentence A* 토큰에 해당하고, - 1은 *sentence B* 토큰에 해당합니다.  [토큰 타입 ID란 무엇인가요?](../glossary#token-type-ids)

position_ids (`torch.LongTensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 각 입력 시퀀스의 토큰 위치 인덱스입니다. `[0, config.n_positions - 1]` 범위에서 선택됩니다. [위치 ID란 무엇인가요?](../glossary#position-ids)

entity_ids (`torch.LongTensor`, shape `(batch_size, entity_length)`) : entity vocabulary에서 entity 토큰의 인덱스입니다. [AutoTokenizer](/docs/transformers/v5.23.0/ko/model_doc/auto#transformers.AutoTokenizer)를 사용하여 인덱스를 얻을 수 있습니다. 자세한 내용은 [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 및 [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)를 참조하세요.

entity_attention_mask (`torch.Tensor`, shape `(batch_size, entity_length)`, *선택 사항*) : 패딩 엔티티 토큰 인덱스에 대한 어텐션 수행을 방지하기 위한 마스크. `[0, 1]`에서 선택된 마스크 값: - **마스크되지 않은** 엔티티 토큰은 1, - **마스크된** 엔티티 토큰은 0.

entity_token_type_ids (`torch.LongTensor`, shape `(batch_size, entity_length)`, *선택 사항*) : 엔티티 토큰 입력의 첫 번째 및 두 번째 부분을 나타내는 세그먼트 토큰 인덱스입니다. 인덱스는 `[0, 1]`에서 선택됩니다: - 0은 *portion A* 엔티티 토큰에 해당하고, - 1은 *portion B* 엔티티 토큰에 해당합니다.

entity_position_ids (`torch.LongTensor`, shape `(batch_size, entity_length, max_mention_length)`, *선택 사항*) : 위치 임베딩에서 각 입력 엔티티의 위치 인덱스. `[0, config.max_position_embeddings - 1]` 범위에서 선택됩니다.

inputs_embeds (`torch.Tensor`, shape `(batch_size, sequence_length, hidden_size)`, *선택 사항*) : `input_ids`를 전달하는 대신 임베디드 표현을 직접 전달할 수 있습니다. 이는 모델의 내부 임베딩 조회 행렬보다 `input_ids` 인덱스를 관련 벡터로 변환하는 방식에 대해 더 많은 제어가 필요한 경우 유용합니다.

labels (`torch.LongTensor`, shape `(batch_size,)`, *선택 사항*) : 다중 선택 분류 손실을 계산하는 데 사용되는 라벨입니다. 인덱스는 `[0, ..., num_choices-1]` 범위에 있어야 하며, `num_choices`는 입력 텐서의 두 번째 차원의 크기입니다. (위 `input_ids` 참조)

output_attentions (`bool`, *선택 사항*) : 모든 어텐션 레이어의 어텐션 텐서를 반환할지 여부. 자세한 내용은 반환 텐서 섹션의 `attentions`를 참조하세요.

output_hidden_states (`bool`, *선택 사항*) : 모든 레이어의 hidden states를 반환할지 여부. 자세한 내용은 반환되는 텐서 중 `hidden_states` 항목을 참조하세요.

return_dict (`bool`, *선택 사항*) : 일반 튜플 대신 [ModelOutput](/docs/transformers/v5.23.0/ko/main_classes/output#transformers.utils.ModelOutput)를 반환할지 여부.

**반환값:** `LukeTokenClassifierOutput` 또는 `tuple(torch.Tensor)`

`LukeTokenClassifierOutput` 또는 `torch.Tensor`의 튜플(`return_dict=False`가 전달되거나 `config.return_dict=False`인 경우)로, [LukeConfig](/docs/transformers/v5.23.0/ko/model_doc/luke#transformers.LukeConfig) 및 입력에 따라 다양한 요소를 포함합니다.

[LukeForTokenClassification](/docs/transformers/v5.23.0/ko/model_doc/luke#transformers.LukeForTokenClassification)의 forward 메서드는 `__call__` 특수 메서드를 오버라이드합니다.

`Module` 인스턴스는 전처리 및 후처리 단계를 실행하는 것을 처리하지만, 이 함수는 해당 단계를 조용히 무시하므로, 순전파(forward pass) 레시피를 이 함수 내에서 정의해야 하더라도 이후에는 이 함수 대신 `Module` 인스턴스를 호출해야 합니다.

- **loss** (`torch.Tensor`, shape `(1,)`, *선택 사항*, `labels`가 제공될 때 반환됨) -- 분류 손실.
- **logits** (`torch.Tensor`, shape `(batch_size, sequence_length, config.num_labels)`) -- SoftMax 적용 전 분류 점수.
- **hidden_states** (`tuple[torch.Tensor, ...]`, *선택*, `output_hidden_states=True`가 전달되거나 `config.output_hidden_states=True`인 경우 반환) -- shape가 `(batch_size, sequence_length, hidden_size)`인 `torch.Tensor`의 튜플 (모델에 임베딩 레이어가 있는 경우 임베딩 출력 1개 + 각 레이어의 출력 1개).

  각 레이어의 출력에서 모델의 Hidden-states와 선택적 초기 임베딩 출력을 포함합니다.
- **entity_hidden_states** (`tuple(torch.Tensor)`, *선택 사항*, `output_hidden_states=True`가 전달되었거나 `config.output_hidden_states=True`인 경우 반환됨) -- `torch.Tensor`의 튜플(임베딩 출력 1개 + 각 레이어의 출력 1개)로, 모양은 `(batch_size, entity_length, hidden_size)`입니다. 각 레이어의 출력에서 모델의 엔티티 히든 스테이트와 초기 엔티티 임베딩 출력을 포함합니다.
- **attentions** (`tuple[torch.Tensor, ...]`, *선택*, `output_attentions=True`가 전달되었거나 `config.output_attentions=True`인 경우 반환) -- 각 레이어마다 하나씩 포함된 `torch.Tensor` 튜플로, shape는 `(batch_size, num_heads, sequence_length, sequence_length)`입니다.

  self-attention 헤드에서 가중 평균을 계산하는 데 사용되는 attention softmax 이후의 attention 가중치입니다.

예:

```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)
```

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

**매개변수:**

config ([LukeConfig](/docs/transformers/v5.23.0/ko/model_doc/luke#transformers.LukeConfig)) : 모델의 모든 매개변수를 포함하는 모델 구성 클래스입니다. 구성 파일로 초기화하는 것은 모델과 관련된 가중치를 로드하지 않으며, 구성 정보만 로드합니다. 모델 가중치를 로드하려면 [from_pretrained()](/docs/transformers/v5.23.0/ko/main_classes/model#transformers.PreTrainedModel.from_pretrained) 메서드를 확인하세요.

SQuAD와 같은 추출형 질의응답 작업을 위해 상단에 스팬 분류 헤드가 있는 Luke transformer (hidden-states 출력 위에 선형 레이어를 올려 `span start logits`과 `span end logits`을 계산).

이 모델은 [PreTrainedModel](/docs/transformers/v5.23.0/ko/main_classes/model#transformers.PreTrainedModel)에서 상속됩니다. 라이브러리가 모든 모델에 대해 구현하는 일반적 메서드(다운로드 또는 저장, 입력 임베딩 크기 조정, 헤드 프루닝 등)에 대해서는 상위 클래스 문서를 확인하세요.

이 모델은 또한 PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module)의 하위 클래스입니다. 일반적인 PyTorch Module처럼 사용하며, 일반적인 사용법과 동작에 관한 모든 사항은 PyTorch 문서를 참조하세요.

#### 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)
```

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

**매개변수:**

input_ids (`torch.LongTensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 어휘(input sequence tokens)의 인덱스입니다. 기본적으로 패딩은 무시됩니다. [AutoTokenizer](/docs/transformers/v5.23.0/ko/model_doc/auto#transformers.AutoTokenizer)를 사용하여 인덱스를 얻을 수 있습니다. 자세한 내용은 [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 및 [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)를 참조하세요. [입력 ID란 무엇인가요?](../glossary#input-ids)

attention_mask (`torch.Tensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 패딩 토큰 인덱스에 대한 attention을 수행하지 않도록 방지하는 마스크입니다. `[0, 1]`에서 선택된 마스크 값: - **마스크되지 않은** 토큰은 1, - **마스크된** 토큰은 0. [attention 마스크란?](../glossary#attention-mask)

token_type_ids (`torch.LongTensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 입력의 첫 번째 및 두 번째 부분을 나타내는 세그먼트 토큰 인덱스입니다. 인덱스는 `[0, 1]`에서 선택됩니다:  - 0은 *sentence A* 토큰에 해당하고, - 1은 *sentence B* 토큰에 해당합니다.  [토큰 타입 ID란 무엇인가요?](../glossary#token-type-ids)

position_ids (`torch.Tensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 각 입력 시퀀스의 토큰 위치 인덱스입니다. `[0, config.n_positions - 1]` 범위에서 선택됩니다.  [위치 ID란 무엇인가요?](../glossary#position-ids)

entity_ids (`torch.LongTensor`, shape `(batch_size, entity_length)`) : entity vocabulary에서 entity 토큰의 인덱스입니다. [AutoTokenizer](/docs/transformers/v5.23.0/ko/model_doc/auto#transformers.AutoTokenizer)를 사용하여 인덱스를 얻을 수 있습니다. 자세한 내용은 [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 및 [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)를 참조하세요.

entity_attention_mask (`torch.Tensor`, shape `(batch_size, entity_length)`, *선택 사항*) : 패딩 엔티티 토큰 인덱스에 대한 어텐션 수행을 방지하기 위한 마스크. `[0, 1]`에서 선택된 마스크 값: - **마스크되지 않은** 엔티티 토큰은 1, - **마스크된** 엔티티 토큰은 0.

entity_token_type_ids (`torch.LongTensor`, shape `(batch_size, entity_length)`, *선택 사항*) : 엔티티 토큰 입력의 첫 번째 및 두 번째 부분을 나타내는 세그먼트 토큰 인덱스입니다. 인덱스는 `[0, 1]`에서 선택됩니다: - 0은 *portion A* 엔티티 토큰에 해당하고, - 1은 *portion B* 엔티티 토큰에 해당합니다.

entity_position_ids (`torch.LongTensor`, shape `(batch_size, entity_length, max_mention_length)`, *선택 사항*) : 위치 임베딩에서 각 입력 엔티티의 위치 인덱스. `[0, config.max_position_embeddings - 1]` 범위에서 선택됩니다.

inputs_embeds (`torch.Tensor`, shape `(batch_size, sequence_length, hidden_size)`, *선택 사항*) : `input_ids`를 전달하는 대신 임베디드 표현을 직접 전달할 수 있습니다. 이는 모델의 내부 임베딩 조회 행렬보다 `input_ids` 인덱스를 관련 벡터로 변환하는 방식에 대해 더 많은 제어가 필요한 경우 유용합니다.

start_positions (`torch.LongTensor`, shape `(batch_size,)`, *선택 사항*) : 토큰 분류 손실을 계산하기 위해 라벨이 지정된 스팬의 시작 위치(인덱스)에 대한 라벨입니다. 위치는 시퀀스 길이(`sequence_length`)로 클램프됩니다. 시퀀스 범위를 벗어난 위치는 손실 계산에 반영되지 않습니다.

end_positions (`torch.LongTensor`, shape `(batch_size,)`, *선택 사항*) : 토큰 분류 손실을 계산하기 위해 라벨이 지정된 스팬의 끝 위치(인덱스)에 대한 라벨입니다. 위치는 시퀀스 길이(`sequence_length`)로 클램프됩니다. 시퀀스 범위를 벗어난 위치는 손실 계산에 반영되지 않습니다.

output_attentions (`bool`, *선택 사항*) : 모든 어텐션 레이어의 어텐션 텐서를 반환할지 여부. 자세한 내용은 반환 텐서 섹션의 `attentions`를 참조하세요.

output_hidden_states (`bool`, *선택 사항*) : 모든 레이어의 hidden states를 반환할지 여부. 자세한 내용은 반환되는 텐서 중 `hidden_states` 항목을 참조하세요.

return_dict (`bool`, *선택 사항*) : 일반 튜플 대신 [ModelOutput](/docs/transformers/v5.23.0/ko/main_classes/output#transformers.utils.ModelOutput)를 반환할지 여부.

**반환값:** `LukeQuestionAnsweringModelOutput` 또는 `tuple(torch.Tensor)`

구성([LukeConfig](/docs/transformers/v5.23.0/ko/model_doc/luke#transformers.LukeConfig))과 입력에 따라 다양한 요소를 포함하는 `LukeQuestionAnsweringModelOutput` 또는 `torch.Tensor`의 튜플(`return_dict=False`가 전달되거나 `config.return_dict=False`인 경우).

[LukeForQuestionAnswering](/docs/transformers/v5.23.0/ko/model_doc/luke#transformers.LukeForQuestionAnswering)의 forward 메서드는 `__call__` 특수 메서드를 오버라이드합니다.

`Module` 인스턴스는 전처리 및 후처리 단계를 실행하는 것을 처리하지만, 이 함수는 해당 단계를 조용히 무시하므로, 순전파(forward pass) 레시피를 이 함수 내에서 정의해야 하더라도 이후에는 이 함수 대신 `Module` 인스턴스를 호출해야 합니다.

- **loss** (`torch.Tensor`, shape `(1,)`인, *선택*, `labels`가 제공될 때 반환) -- 전체 스팬 추출 손실은 시작 및 끝 위치의 Cross-Entropy 합입니다.
- **start_logits** (`torch.Tensor`, shape `(batch_size, sequence_length)`, *선택 사항*) -- Span 시작 점수(SoftMax 적용 전).
- **end_logits** (`torch.Tensor`, shape `(batch_size, sequence_length)`, *선택 사항*) -- Span-end 점수 (SoftMax 적용 전).
- **hidden_states** (`tuple[torch.Tensor, ...]`, *선택*, `output_hidden_states=True`가 전달되거나 `config.output_hidden_states=True`인 경우 반환) -- shape가 `(batch_size, sequence_length, hidden_size)`인 `torch.Tensor`의 튜플 (모델에 임베딩 레이어가 있는 경우 임베딩 출력 1개 + 각 레이어의 출력 1개).

  각 레이어의 출력에서 모델의 Hidden-states와 선택적 초기 임베딩 출력을 포함합니다.
- **entity_hidden_states** (`tuple(torch.Tensor)`, *선택 사항*, `output_hidden_states=True`가 전달되었거나 `config.output_hidden_states=True`인 경우 반환됨) -- `torch.Tensor`의 튜플(임베딩 출력 1개 + 각 레이어의 출력 1개)로, 모양은 `(batch_size, entity_length, hidden_size)`입니다. 각 레이어의 출력에서 모델의 엔티티 히든 스테이트와 초기 엔티티 임베딩 출력을 포함합니다.
- **attentions** (`tuple[torch.Tensor, ...]`, *선택*, `output_attentions=True`가 전달되었거나 `config.output_attentions=True`인 경우 반환) -- 각 레이어마다 하나씩 포함된 `torch.Tensor` 튜플로, shape는 `(batch_size, num_heads, sequence_length, sequence_length)`입니다.

  self-attention 헤드에서 가중 평균을 계산하는 데 사용되는 attention softmax 이후의 attention 가중치입니다.

예:

```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)
...
```

