# XLM

[XLM](https://huggingface.co/papers/1901.07291)은 두 가지 접근 방식을 통해 언어 간 사전 학습을 수행합니다. 하나는 단일 언어에 대한 비지도 학습이고, 다른 하나는 언어 간 언어 모델링 목적을 사용하여 두 개 이상의 언어에 대한 지도 학습입니다. XLM 모델은 인과 언어 모델링, 마스킹된 언어 모델링, 번역 언어 모델링(여러 언어 입력으로 확장된 [BERT](./bert)의 마스킹된 언어 모델링 목적)를 지원합니다.

모든 원본 XLM 체크포인트는 [Facebook AI community](https://huggingface.co/FacebookAI?search_models=xlm-mlm) 조직에서 찾을 수 있습니다.

> [!TIP]
> XLM 모델에 대한 더 많은 예제, 즉 분류, 번역, 질의응답과 같은 다양한 언어 간 작업에 XLM을 적용하는 방법을 확인하려면 오른쪽 사이드바의 XLM 모델을 클릭하세요.

아래 예제는 [Pipeline](/docs/transformers/v5.23.0/ko/main_classes/pipelines#transformers.Pipeline), [AutoModel](/docs/transformers/v5.23.0/ko/model_doc/auto#transformers.AutoModel) 및 명령줄을 사용하여 `<mask>` 토큰을 예측하는 방법을 보여줍니다.

```python
from transformers import pipeline

pipeline = pipeline(
    task="fill-mask",
    model="facebook/xlm-roberta-xl",
    device=0
)
pipeline("Bonjour, je suis un modèle <mask>.")
```

```python
import torch

from transformers import AutoModelForMaskedLM, AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained(
    "FacebookAI/xlm-mlm-en-2048",
)
model = AutoModelForMaskedLM.from_pretrained(
    "FacebookAI/xlm-mlm-en-2048",
    device_map="auto",
)
inputs = tokenizer("Hello, I'm a <mask> model.", return_tensors="pt").to(model.device)

with torch.no_grad():
    outputs = model(**inputs)
    predictions = outputs.logits.argmax(dim=-1)

predicted_token = tokenizer.decode(predictions[0][inputs["input_ids"][0] == tokenizer.mask_token_id])
print(f"Predicted token: {predicted_token}")
```

## XLMConfig[[transformers.XLMConfig]]

#### transformers.XLMConfig[[transformers.XLMConfig]]

```python
transformers.XLMConfig(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 = 30145, emb_dim: int = 2048, n_layers: int = 12, n_heads: int = 16, dropout: float | int = 0.1, attention_dropout: float | int = 0.1, gelu_activation: bool = True, sinusoidal_embeddings: bool = False, causal: bool = False, asm: bool = False, n_langs: int = 1, use_lang_emb: bool = True, max_position_embeddings: int = 512, embed_init_std: float = 0.02209708691207961, layer_norm_eps: float = 1e-12, init_std: float = 0.02, unk_index: int = 3, mask_index: int = 5, is_encoder: bool = True, summary_type: str = 'first', summary_use_proj: bool = True, summary_activation: str | None = None, summary_proj_to_labels: bool = True, summary_first_dropout: float | int = 0.1, start_n_top: int = 5, end_n_top: int = 5, mask_token_id: int | None = 0, lang_id: int = 0, pad_token_id: int | None = 2, bos_token_id: int | None = 0, eos_token_id: int | list[int] | None = 1, tie_word_embeddings: bool = True)
```

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

**매개변수:**

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

emb_dim (`int`, *선택 사항*, 기본값 `2048`) : 임베딩 및 숨겨진 상태의 차원.

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

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

dropout (`Union[float, int]`, *선택 사항*, 기본값 `0.1`) : 모든 dropout 레이어의 비율입니다.

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

gelu_activation (`bool`, *선택 사항*, 기본값 `True`) : *relu* 대신 활성화 함수로 *gelu*를 사용할지 여부.

sinusoidal_embeddings (`bool`, *선택 사항*, 기본값 `False`) : 절대 위치 임베딩 대신 사인 위치 임베딩을 사용할지 여부.

causal (`bool`, *선택 사항*, 기본값 `False`) : 모델이 인과적 방식으로 동작할지 여부입니다. 인과적 모델은 양방향 컨텍스트 대신 왼쪽 컨텍스트에만 주의를 기울이도록 삼각형 어텐션 마스크를 사용합니다.

asm (`bool`, *선택 사항*, 기본값 `False`) : 예측 계층에 선형 계층 대신 적응형 로그 소프트맥스 투영 계층을 사용할지 여부.

n_langs (`int`, *선택 사항*, 기본값 1) : 모델이 처리하는 언어의 수입니다. 단일 언어 모델의 경우 1로 설정합니다.

use_lang_emb (`bool`, *선택 사항*, 기본값 `True`) : 언어 임베딩을 사용할지 여부입니다. 일부 모델은 추가적인 언어 임베딩을 사용하며, 사용 방법은 [다국어 모델 페이지](http://huggingface.co/transformers/multilingual.html#xlm-language-embeddings)를 참고하세요.

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

embed_init_std (`float`, *선택 사항*, 기본값 2048^-0.5) : 임베딩 행렬을 초기화하기 위한 truncated_normal_initializer의 표준 편차입니다.

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

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

unk_index (`int`, *선택 사항*, 기본값 3) : 어휘에서 알려지지 않은 토큰의 인덱스입니다.

mask_index (`int`, *선택 사항*, 기본값 5) : 어휘에서 마스킹 토큰의 인덱스입니다.

is_encoder (`bool`, *선택 사항*, 기본값 `True`) : Vaswani et al.에서 확인된 바와 같이 초기화된 모델이 transformer 인코더인지 디코더인지 여부

summary_type (`string`, *선택 사항*, 기본값 "first") : 시퀀스 요약 시 사용되는 인자입니다. 시퀀스 분류 및 다중 선택 모델에서 사용됩니다. 다음 옵션 중 하나여야 합니다: - `"last"`: 마지막 토큰의 숨겨진 상태를 가져옵니다 (XLNet과 유사). - `"first"`: 첫 번째 토큰의 숨겨진 상태를 가져옵니다 (BERT와 유사). - `"mean"`: 모든 토큰의 숨겨진 상태의 평균을 가져옵니다. - `"cls_index"`: 분류 토큰 위치의 Tensor를 제공합니다 (GPT/GPT-2와 유사). - `"attn"`: 현재 구현되지 않았습니다. 멀티헤드 어텐션을 사용합니다.

summary_use_proj (`bool`, *선택 사항*, 기본값 `True`) : 시퀀스 요약 수행 시 사용되는 인자입니다. 시퀀스 분류 및 다중 선택 모델에서 사용됩니다. 벡터 추출 후 투영을 추가할지 여부를 지정합니다.

summary_activation (`str`, *선택 사항*) : 시퀀스 요약 시 사용되는 인자입니다. 시퀀스 분류 및 다중 선택 모델에서 사용됩니다. 출력을 tanh 활성화 함수로 처리하려면 `"tanh"`를 전달하고, 다른 값을 전달하면 활성화 함수가 적용되지 않습니다.

summary_proj_to_labels (`bool`, *선택 사항*, 기본값 `True`) : 시퀀스 분류 및 다중 선택 모델에서 사용됩니다. 투영 출력이 `config.num_labels`개 또는 `config.hidden_size`개의 클래스를 가져야 하는지 여부를 결정합니다.

summary_first_dropout (`float`, *선택 사항*, 기본값 0.1) : 시퀀스 분류 및 다중 선택 모델에서 사용됩니다. 투영 및 활성화 이후에 사용할 드롭아웃 비율입니다.

start_n_top (`int`, *선택 사항*, 기본값 5) : SQuAD 평가 스크립트에서 사용됩니다.

end_n_top (`int`, *선택 사항*, 기본값 5) : SQuAD 평가 스크립트에서 사용됩니다.

mask_token_id (`int`, *선택 사항*, 기본값 0) : MLM 컨텍스트에서 텍스트를 생성할 때 마스킹된 토큰을 식별하기 위한 모델 무관 파라미터입니다.

lang_id (`int`, *선택 사항*, 기본값 1) : 모델이 사용하는 언어의 ID입니다. 이 매개변수는 특정 언어로 텍스트를 생성할 때 사용됩니다.

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

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

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

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

이것은 XLMModel의 구성을 저장하기 위한 구성 클래스입니다. 지정된 인자에 따라 Xlm 모델을 인스턴스화하여 모델 아키텍처를 정의하는 데 사용됩니다. 기본값으로 구성을 인스턴스화하면 [FacebookAI/xlm-mlm-en-2048](https://huggingface.co/FacebookAI/xlm-mlm-en-2048)의 구성과 유사한 구성이 생성됩니다.

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 XLMConfig, XLMModel

>>> # Initializing a XLM configuration
>>> configuration = XLMConfig()

>>> # Initializing a model (with random weights) from the configuration
>>> model = XLMModel(configuration)

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

## XLMTokenizer[[transformers.XLMTokenizer]]

#### transformers.XLMTokenizer[[transformers.XLMTokenizer]]

```python
transformers.XLMTokenizer(vocab_file, merges_file, unk_token = '<unk>', bos_token = '<s>', sep_token = '</s>', pad_token = '<pad>', cls_token = '</s>', mask_token = '<special1>', additional_special_tokens = ['<special0>', '<special1>', '<special2>', '<special3>', '<special4>', '<special5>', '<special6>', '<special7>', '<special8>', '<special9>'], lang2id = None, id2lang = None, do_lowercase_and_remove_accent = True, **kwargs)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/xlm/tokenization_xlm.py#L134)

**매개변수:**

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

merges_file (`str`) : 파일을 병합합니다.

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

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

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

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

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

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

additional_special_tokens (`List[str]`, *선택 사항*, 기본값은 `['<special0>', '<special1>', '<special2>', '<special3>', '<special4>', '<special5>', '<special6>', '<special7>', '<special8>', '<special9>']`) : 추가 특수 토큰 목록.

lang2id (`Dict[str, int]`, *선택 사항*) : 언어 문자열 식별자를 해당 ID로 매핑하는 사전.

id2lang (`Dict[int, str]`, *선택 사항*) : 언어 ID를 해당 문자열 식별자로 매핑하는 사전.

do_lowercase_and_remove_accent (`bool`, *선택 사항*, 기본값 `True`) : 토큰화 시 소문자로 변환하고 악센트를 제거할지 여부.

XLM 토크나이저를 구성합니다. Byte-Pair Encoding에 기반합니다. 토크나이징 과정은 다음과 같습니다:

- 대부분의 지원 언어에 대한 Moses 전처리 및 토큰화.
- Chinese (Jieba), Japanese (KyTea), Thai (PyThaiNLP)에 대한 언어별 토큰화.
- 입력 텍스트를 모두 소문자로 변환하고 정규화합니다(선택 사항).
- `special_tokens` 인자와 `set_special_tokens` 함수를 사용하면 어휘에 추가 기호(예: "__classify__")를 추가할 수 있습니다.
- `lang2id` 속성은 제공된 경우 모델이 지원하는 언어를 해당 ID에 매핑합니다(사전 학습된 어휘의 경우 자동으로 설정됨).
- `id2lang` 속성이 제공되면 역 매핑을 수행합니다(사전 학습된 어휘의 경우 자동으로 설정됨).

이 토크나이저는 대부분의 주요 메서드를 포함하는 [PreTrainedTokenizer](/docs/transformers/v5.23.0/ko/main_classes/tokenizer#transformers.PythonBackend)를 상속합니다. 해당 메서드에 대한 자세한 정보는 이 상위 클래스를 참고하세요.

#### build_inputs_with_special_tokens[[transformers.XLMTokenizer.build_inputs_with_special_tokens]]

```python
build_inputs_with_special_tokens(token_ids_0: list[int], token_ids_1: list[int] | None = None)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/xlm/tokenization_xlm.py#L475)

**매개변수:**

token_ids_0 (`List[int]`) : 특수 토큰이 추가될 ID 목록.

token_ids_1 (`List[int]`, *선택 사항*) : 시퀀스 쌍을 위한 선택적 두 번째 ID 목록.

**반환값:** `List[int]`

적절한 특수 토큰이 포함된 [입력 ID](../glossary#input-ids) 목록

시퀀스 분류 작업을 위해 시퀀스 또는 시퀀스 쌍에서 모델 입력을 생성하려면 특수 토큰을 추가하고 연결합니다. XLM 시퀀스는 다음 형식을 가집니다:

- 단일 시퀀스: `<s> X </s>`
- 시퀀스 쌍: `<s> A </s> B </s>`

#### get_special_tokens_mask[[transformers.XLMTokenizer.get_special_tokens_mask]]

```python
get_special_tokens_mask(token_ids_0: list[int], token_ids_1: list[int] | None = None, already_has_special_tokens: bool = False)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/xlm/tokenization_xlm.py#L502)

**매개변수:**

token_ids_0 (`List[int]`) : ID 목록.

token_ids_1 (`List[int]`, *선택 사항*) : 시퀀스 쌍을 위한 선택적 두 번째 ID 목록.

already_has_special_tokens (`bool`, *선택 사항*, 기본값 `False`) : 토큰 목록이 이미 모델의 특수 토큰으로 포맷되어 있는지 여부.

**반환값:** `List[int]`

[0, 1] 범위의 정수 목록: 특수 토큰은 1, 시퀀스 토큰은 0.

특수 토큰이 추가되지 않은 토큰 목록에서 시퀀스 ID를 가져옵니다. 이 메서드는 토크나이저의 `prepare_for_model` 메서드를 사용하여 특수 토큰을 추가할 때 호출됩니다.

#### 시퀀스에서 토큰 타입 ID 생성[[transformers.XLMTokenizer.create_token_type_ids_from_sequences]]

```python
create_token_type_ids_from_sequences(token_ids_0: list[int], token_ids_1: list[int] | None = None)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_python.py#L1301)

**매개변수:**

token_ids_0 (`list[int]`) : ID 목록.

token_ids_1 (`list[int]`, *선택 사항*) : 시퀀스 쌍을 위한 선택적 두 번째 ID 목록.

**반환값:** `list[int]`

구성된 패턴에 따른 토큰 유형 ID입니다.

시퀀스-페어 분류 작업에 사용될 마스크를 전달된 두 시퀀스에서 생성합니다.

이 메서드는 토크나이저의 구성 속성을 기반으로 토큰 유형 ID를 동적으로 생성합니다:
- `token_type_ids_pattern`: 사용할 패턴("all_zeros" 또는 "bert_style")
- `token_type_ids_include_special_tokens`: 길이 계산에 특수 토큰을 포함할지 여부

예:
```python
# All zeros pattern (default, used by RoBERTa, BART, etc.)
tokenizer.token_type_ids_pattern = "all_zeros"
# Returns: [0, 0, 0, ...] for both sequences

# BERT-style pattern (first sequence gets 0s, second gets 1s)
tokenizer.token_type_ids_pattern = "bert_style"
# Returns: [0, 0, 0, ..., 1, 1, 1, ...] for sequence pairs
```

#### save_vocabulary[[transformers.XLMTokenizer.save_vocabulary]]

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

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/xlm/tokenization_xlm.py#L530)

## XLM 전용 출력[[transformers.models.xlm.modeling_xlm.XLMForQuestionAnsweringOutput]]

#### transformers.models.xlm.modeling_xlm.XLMForQuestionAnsweringOutput[[transformers.models.xlm.modeling_xlm.XLMForQuestionAnsweringOutput]]

```python
transformers.models.xlm.modeling_xlm.XLMForQuestionAnsweringOutput(loss: typing.Optional[torch.Tensor] = None, start_top_log_probs: typing.Optional[torch.Tensor] = None, start_top_index: typing.Optional[torch.LongTensor] = None, end_top_log_probs: typing.Optional[torch.Tensor] = None, end_top_index: typing.Optional[torch.LongTensor] = None, cls_logits: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/xlm/modeling_xlm.py#L638)

**매개변수:**

loss (`torch.Tensor`, shape `(1,)`, *선택 사항*, `start_positions`와 `end_positions`가 모두 제공된 경우 반환됨) : 시작 토큰, 종료 토큰(및 제공된 경우 is_impossible) 분류 손실의 합으로 계산된 분류 손실.

start_top_log_probs (`torch.Tensor`, shape `(batch_size, config.start_n_top)`, *선택 사항*, `start_positions` 또는 `end_positions`가 제공되지 않은 경우 반환됨) : beam-search에서 상위 config.start_n_top 개 시작 토큰 가능성에 대한 로그 확률.

start_top_index (`torch.LongTensor`, shape `(batch_size, config.start_n_top)`, *선택 사항*, `start_positions` 또는 `end_positions`가 제공되지 않은 경우 반환됨) : 상위 config.start_n_top 개 시작 토큰 후보의 인덱스(beam-search).

end_top_log_probs (`torch.Tensor`, shape `(batch_size, config.start_n_top * config.end_n_top)`, *선택 사항*, `start_positions` 또는 `end_positions`가 제공되지 않은 경우 반환됨) : 상위 `config.start_n_top * config.end_n_top` 개 종료 토큰 가능성에 대한 로그 확률(beam-search).

end_top_index (`torch.LongTensor`, shape `(batch_size, config.start_n_top * config.end_n_top)`, *선택 사항*, `start_positions` 또는 `end_positions`가 제공되지 않은 경우 반환됨) : 상위 `config.start_n_top * config.end_n_top` 개 end token 가능성의 인덱스(beam-search).

cls_logits (`torch.Tensor`, shape `(batch_size,)`, *선택 사항*, `start_positions` 또는 `end_positions`가 제공되지 않은 경우 반환됨) : 답변의 `is_impossible` 라벨에 대한 로그 확률.

hidden_states (`tuple[torch.Tensor, ...]`, *선택*, `output_hidden_states=True`가 전달되었거나 `config.output_hidden_states=True`인 경우 반환) : `(batch_size, sequence_length, hidden_size)` 형태의 `torch.Tensor` 튜플 (모델에 임베딩 레이어가 있는 경우 임베딩 출력 1개 + 각 레이어의 출력 1개). 각 레이어 출력 시점의 모델 hidden-states와 선택적인 초기 임베딩 출력입니다.

attentions (`tuple[torch.Tensor, ...]`, *optional*, `output_attentions=True`가 전달되었거나 `config.output_attentions=True`인 경우 반환) : 각 레이어마다 하나씩 포함된 `torch.Tensor`의 튜플로, shape이 `(batch_size, num_heads, sequence_length, sequence_length)`입니다. attention softmax 이후의 attention 가중치로, self-attention heads에서 가중 평균을 계산하는 데 사용됩니다.

`XLMSQuADHead`를 사용하는 질의응답 모델의 출력에 대한 기본 클래스입니다.

## XLMModel[[transformers.XLMModel]]

#### transformers.XLMModel[[transformers.XLMModel]]

```python
transformers.XLMModel(config: XLMConfig)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/xlm/modeling_xlm.py#L667)

**매개변수:**

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

특정 헤드가 위에 없는 상태에서 원시 hidden-states를 출력하는 기본 Xlm 모델입니다.

이 모델은 [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.XLMModel.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, langs: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, lengths: typing.Optional[torch.Tensor] = None, cache: dict[str, torch.Tensor] | None = 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/xlm/modeling_xlm.py#L735)

**매개변수:**

input_ids (`torch.Tensor`, 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)

langs (`torch.LongTensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 입력에서 각 토큰의 언어를 나타내는 데 사용되는 토큰의 병렬 시퀀스입니다. 인덱스는 모델 구성에서 제공되는 두 가지 변환 매핑을 사용하여 언어 이름에서 얻을 수 있는 언어 ID입니다(다국어 모델에만 제공됨). 보다 정확히 말하면, *언어 이름에서 언어 ID로*의 매핑은 `model.config.lang2id`(문자열에서 int로 변환하는 사전)에, *언어 ID에서 언어 이름으로*의 매핑은 `model.config.id2lang`(int에서 문자열로 변환하는 사전)에 있습니다. [다국어 문서](../multilingual)에 자세히 설명된 사용 예시를 참조하세요.

token_type_ids (`torch.Tensor`, 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)

lengths (`torch.LongTensor`, shape `(batch_size,)`, *선택 사항*) : 패딩 토큰 인덱스에 대한 어텐션을 수행하지 않도록 사용할 수 있는 각 문장의 길이입니다. 동일한 결과를 얻기 위해 *attention_mask*를 사용할 수도 있으며(위 참조), 호환성을 위해 여기에 유지되었습니다. `[0, ..., input_ids.size(-1)]`에서 선택된 인덱스입니다.

cache (`dict[str, torch.Tensor]`, *선택 사항*) : 사전 계산된 KV 상태를 포함하는 `EncoderDecoderCache`의 인스턴스입니다. 순차적 디코딩을 가속하는 데 사용할 수 있습니다.

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)를 반환할지 여부.

**반환값:** [BaseModelOutput](/docs/transformers/v5.23.0/ko/main_classes/output#transformers.modeling_outputs.BaseModelOutput) 또는 `tuple(torch.Tensor)`

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

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

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

- **last_hidden_state** (`torch.Tensor`, shape `(batch_size, sequence_length, hidden_size)`) -- 모델의 마지막 레이어 출력에서 생성된 hidden-state 시퀀스입니다.
- **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 가중치입니다.

## XLMWithLMHeadModel[[transformers.XLMWithLMHeadModel]]

#### transformers.XLMWithLMHeadModel[[transformers.XLMWithLMHeadModel]]

```python
transformers.XLMWithLMHeadModel(config: XLMConfig)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/xlm/modeling_xlm.py#L913)

**매개변수:**

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

입력 임베딩과 가중치가 연결된 선형 레이어로 구성된 언어 모델링 헤드가 위에 있는 XLM Model 트랜스포머입니다.

이 모델은 [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.XLMWithLMHeadModel.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, langs: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, lengths: typing.Optional[torch.Tensor] = None, cache: dict[str, torch.Tensor] | None = 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, logits_to_keep: typing.Union[int, torch.Tensor] = 0, **kwargs)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/xlm/modeling_xlm.py#L957)

**매개변수:**

input_ids (`torch.Tensor`, 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)

langs (`torch.LongTensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 입력에서 각 토큰의 언어를 나타내는 데 사용되는 토큰의 병렬 시퀀스입니다. 인덱스는 모델 구성에서 제공되는 두 가지 변환 매핑을 사용하여 언어 이름에서 얻을 수 있는 언어 ID입니다(다국어 모델에만 제공됨). 보다 정확히 말하면, *언어 이름에서 언어 ID로*의 매핑은 `model.config.lang2id`(문자열에서 int로 변환하는 사전)에, *언어 ID에서 언어 이름으로*의 매핑은 `model.config.id2lang`(int에서 문자열로 변환하는 사전)에 있습니다. [다국어 문서](../multilingual)에 자세히 설명된 사용 예시를 참조하세요.

token_type_ids (`torch.Tensor`, 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)

lengths (`torch.LongTensor`, shape `(batch_size,)`, *선택 사항*) : 패딩 토큰 인덱스에 대한 어텐션을 수행하지 않도록 사용할 수 있는 각 문장의 길이입니다. 동일한 결과를 얻기 위해 *attention_mask*를 사용할 수도 있으며(위 참조), 호환성을 위해 여기에 유지되었습니다. `[0, ..., input_ids.size(-1)]`에서 선택된 인덱스입니다.

cache (`dict[str, torch.Tensor]`, *선택 사항*) : 사전 계산된 KV 상태를 포함하는 `EncoderDecoderCache`의 인스턴스입니다. 순차적 디코딩을 가속하는 데 사용할 수 있습니다.

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

labels (`torch.LongTensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 언어 모델링을 위한 라벨. 모델 내부에서 라벨이 **시프트(shift)**되므로 `labels = input_ids`로 설정할 수 있습니다. 인덱스는 `[-100, 0, ..., config.vocab_size]` 범위에서 선택됩니다. `-100`으로 설정된 모든 라벨은 무시(마스크)되며, 손실은 `[0, ..., config.vocab_size]` 범위의 라벨에 대해서만 계산됩니다.

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)를 반환할지 여부.

logits_to_keep (`Union[int, torch.Tensor]`, *선택 사항*, 기본값 `0`) : `int`인 경우, 마지막 `logits_to_keep` 토큰에 대한 logits를 계산합니다. `0`인 경우, 모든 `input_ids`에 대한 logits를 계산합니다(특수한 경우). 생성에는 마지막 토큰의 logits만 필요하며, 해당 토큰에 대해서만 계산하면 메모리를 절약할 수 있습니다. 이는 긴 시퀀스나 큰 어휘 크기의 경우 상당한 이점을 제공합니다. `torch.Tensor`인 경우, 시퀀스 길이 차원에서 유지할 인덱스에 해당하는 1차원 텐서여야 합니다. 이는 packed tensor 형식(배치와 시퀀스 길이를 단일 차원으로 사용하는 경우)을 사용할 때 유용합니다.

**반환값:** [MaskedLMOutput](/docs/transformers/v5.23.0/ko/main_classes/output#transformers.modeling_outputs.MaskedLMOutput) 또는 `tuple(torch.Tensor)`

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

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

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

- **loss** (`torch.Tensor`, shape `(1,)`, *선택*, `labels`이 제공될 때 반환됨) -- Masked language modeling(MLM) loss.
- **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와 선택적 초기 임베딩 출력을 포함합니다.
- **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 가중치입니다.

예:

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

>>> tokenizer = AutoTokenizer.from_pretrained("FacebookAI/xlm-mlm-en-2048")
>>> model = XLMWithLMHeadModel.from_pretrained("FacebookAI/xlm-mlm-en-2048")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs, labels=inputs["input_ids"])
>>> loss = outputs.loss
>>> logits = outputs.logits
```

## XLMForSequenceClassification[[transformers.XLMForSequenceClassification]]

#### transformers.XLMForSequenceClassification[[transformers.XLMForSequenceClassification]]

```python
transformers.XLMForSequenceClassification(config: XLMConfig)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/xlm/modeling_xlm.py#L1038)

**매개변수:**

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

XLM 모델 위에 시퀀스 분류/회귀 헤드를 추가한 모델(풀링된 출력 위에 선형 레이어를 배치)로, 예를 들어 GLUE 작업에 사용됩니다.

이 모델은 [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.XLMForSequenceClassification.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, langs: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, lengths: typing.Optional[torch.Tensor] = None, cache: dict[str, torch.Tensor] | None = 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/xlm/modeling_xlm.py#L1050)

**매개변수:**

input_ids (`torch.Tensor`, 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)

langs (`torch.LongTensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 입력에서 각 토큰의 언어를 나타내는 데 사용되는 토큰의 병렬 시퀀스입니다. 인덱스는 모델 구성에서 제공되는 두 가지 변환 매핑을 사용하여 언어 이름에서 얻을 수 있는 언어 ID입니다(다국어 모델에만 제공됨). 보다 정확히 말하면, *언어 이름에서 언어 ID로*의 매핑은 `model.config.lang2id`(문자열에서 int로 변환하는 사전)에, *언어 ID에서 언어 이름으로*의 매핑은 `model.config.id2lang`(int에서 문자열로 변환하는 사전)에 있습니다. [다국어 문서](../multilingual)에 자세히 설명된 사용 예시를 참조하세요.

token_type_ids (`torch.Tensor`, 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)

lengths (`torch.LongTensor`, shape `(batch_size,)`, *선택 사항*) : 패딩 토큰 인덱스에 대한 어텐션을 수행하지 않도록 사용할 수 있는 각 문장의 길이입니다. 동일한 결과를 얻기 위해 *attention_mask*를 사용할 수도 있으며(위 참조), 호환성을 위해 여기에 유지되었습니다. `[0, ..., input_ids.size(-1)]`에서 선택된 인덱스입니다.

cache (`dict[str, torch.Tensor]`, *선택 사항*) : 사전 계산된 KV 상태를 포함하는 `EncoderDecoderCache`의 인스턴스입니다. 순차적 디코딩을 가속하는 데 사용할 수 있습니다.

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)를 반환할지 여부.

**반환값:** [SequenceClassifierOutput](/docs/transformers/v5.23.0/ko/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput) 또는 `tuple(torch.Tensor)`

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

[XLMForSequenceClassification](/docs/transformers/v5.23.0/ko/model_doc/xlm#transformers.XLMForSequenceClassification)의 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`인 경우 반환됨) -- `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 가중치입니다.

단일 레이블 분류의 예시:

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

>>> tokenizer = AutoTokenizer.from_pretrained("FacebookAI/xlm-mlm-en-2048")
>>> model = XLMForSequenceClassification.from_pretrained("FacebookAI/xlm-mlm-en-2048")

>>> 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 = XLMForSequenceClassification.from_pretrained("FacebookAI/xlm-mlm-en-2048", 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, XLMForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("FacebookAI/xlm-mlm-en-2048")
>>> model = XLMForSequenceClassification.from_pretrained("FacebookAI/xlm-mlm-en-2048", 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 = XLMForSequenceClassification.from_pretrained(
...     "FacebookAI/xlm-mlm-en-2048", 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
```

## XLMForMultipleChoice[[transformers.XLMForMultipleChoice]]

#### transformers.XLMForMultipleChoice[[transformers.XLMForMultipleChoice]]

```python
transformers.XLMForMultipleChoice(config: XLMConfig, *inputs, **kwargs)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/xlm/modeling_xlm.py#L1446)

**매개변수:**

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

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

이 모델은 [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.XLMForMultipleChoice.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, langs: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, lengths: typing.Optional[torch.Tensor] = None, cache: dict[str, torch.Tensor] | None = 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/xlm/modeling_xlm.py#L1457)

**매개변수:**

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)

langs (`torch.LongTensor`, shape `(batch_size, num_choices, sequence_length)`, *선택 사항*) : 입력에서 각 토큰의 언어를 나타내는 데 사용되는 토큰의 병렬 시퀀스입니다. 인덱스는 모델 구성에서 제공되는 두 가지 변환 매핑을 사용하여 언어 이름에서 얻을 수 있는 언어 ID입니다(다국어 모델에만 제공됨). 보다 정확히 말하면, *언어 이름에서 언어 ID로*의 매핑은 `model.config.lang2id`(문자열에서 int로 변환하는 사전)에, *언어 ID에서 언어 이름으로*의 매핑은 `model.config.id2lang`(int에서 문자열로 변환하는 사전)에 있습니다. [다국어 문서](../multilingual)에 자세히 설명된 사용 예시를 참조하세요.

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)

lengths (`torch.LongTensor`, shape `(batch_size,)`, *선택 사항*) : 패딩 토큰 인덱스에 대한 어텐션을 수행하지 않도록 사용할 수 있는 각 문장의 길이입니다. 동일한 결과를 얻기 위해 *attention_mask*를 사용할 수도 있으며(위 참조), 호환성을 위해 여기에 유지되었습니다. `[0, ..., input_ids.size(-1)]`에서 선택된 인덱스입니다.

cache (`dict[str, torch.Tensor]`, *선택 사항*) : 사전 계산된 KV 상태를 포함하는 `EncoderDecoderCache`의 인스턴스입니다. 순차적 디코딩을 가속하는 데 사용할 수 있습니다.

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)를 반환할지 여부.

**반환값:** [MultipleChoiceModelOutput](/docs/transformers/v5.23.0/ko/main_classes/output#transformers.modeling_outputs.MultipleChoiceModelOutput) 또는 `tuple(torch.Tensor)`

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

[XLMForMultipleChoice](/docs/transformers/v5.23.0/ko/model_doc/xlm#transformers.XLMForMultipleChoice)의 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`인 경우 반환됨) -- `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 가중치입니다.

예:

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

>>> tokenizer = AutoTokenizer.from_pretrained("FacebookAI/xlm-mlm-en-2048")
>>> model = XLMForMultipleChoice.from_pretrained("FacebookAI/xlm-mlm-en-2048")

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

## XLMForTokenClassification[[transformers.XLMForTokenClassification]]

#### transformers.XLMForTokenClassification[[transformers.XLMForTokenClassification]]

```python
transformers.XLMForTokenClassification(config: XLMConfig)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/xlm/modeling_xlm.py#L1361)

**매개변수:**

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

토큰 분류 헤드가 위에 있는 Xlm transformer(예: Named-Entity-Recognition(NER) 작업)입니다. hidden-states 출력 위에 선형 레이어가 있습니다.

이 모델은 [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.XLMForTokenClassification.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, langs: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, lengths: typing.Optional[torch.Tensor] = None, cache: dict[str, torch.Tensor] | None = 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/xlm/modeling_xlm.py#L1373)

**매개변수:**

input_ids (`torch.Tensor`, 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)

langs (`torch.LongTensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 입력에서 각 토큰의 언어를 나타내는 데 사용되는 토큰의 병렬 시퀀스입니다. 인덱스는 모델 구성에서 제공되는 두 가지 변환 매핑을 사용하여 언어 이름에서 얻을 수 있는 언어 ID입니다(다국어 모델에만 제공됨). 보다 정확히 말하면, *언어 이름에서 언어 ID로*의 매핑은 `model.config.lang2id`(문자열에서 int로 변환하는 사전)에, *언어 ID에서 언어 이름으로*의 매핑은 `model.config.id2lang`(int에서 문자열로 변환하는 사전)에 있습니다. [다국어 문서](../multilingual)에 자세히 설명된 사용 예시를 참조하세요.

token_type_ids (`torch.Tensor`, 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)

lengths (`torch.LongTensor`, shape `(batch_size,)`, *선택 사항*) : 패딩 토큰 인덱스에 대한 어텐션을 수행하지 않도록 사용할 수 있는 각 문장의 길이입니다. 동일한 결과를 얻기 위해 *attention_mask*를 사용할 수도 있으며(위 참조), 호환성을 위해 여기에 유지되었습니다. `[0, ..., input_ids.size(-1)]`에서 선택된 인덱스입니다.

cache (`dict[str, torch.Tensor]`, *선택 사항*) : 사전 계산된 KV 상태를 포함하는 `EncoderDecoderCache`의 인스턴스입니다. 순차적 디코딩을 가속하는 데 사용할 수 있습니다.

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

labels (`torch.LongTensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 토큰 분류 손실을 계산하기 위한 라벨. 인덱스는 `[0, ..., 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)를 반환할지 여부.

**반환값:** [TokenClassifierOutput](/docs/transformers/v5.23.0/ko/main_classes/output#transformers.modeling_outputs.TokenClassifierOutput) 또는 `tuple(torch.Tensor)`

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

[XLMForTokenClassification](/docs/transformers/v5.23.0/ko/model_doc/xlm#transformers.XLMForTokenClassification)의 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`인 경우 반환됨) -- `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 가중치입니다.

예:

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

>>> tokenizer = AutoTokenizer.from_pretrained("FacebookAI/xlm-mlm-en-2048")
>>> model = XLMForTokenClassification.from_pretrained("FacebookAI/xlm-mlm-en-2048")

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

## XLMForQuestionAnsweringSimple[[transformers.XLMForQuestionAnsweringSimple]]

#### transformers.XLMForQuestionAnsweringSimple[[transformers.XLMForQuestionAnsweringSimple]]

```python
transformers.XLMForQuestionAnsweringSimple(config: XLMConfig)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/xlm/modeling_xlm.py#L1144)

**매개변수:**

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

SQuAD와 같은 추출형 질의응답 작업을 위해 상단에 스팬 분류 헤드가 있는 XLM 모델(숨겨진 상태 출력 위에 선형 레이어를 올려 `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.XLMForQuestionAnsweringSimple.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, langs: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, lengths: typing.Optional[torch.Tensor] = None, cache: dict[str, torch.Tensor] | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, start_positions: typing.Optional[torch.Tensor] = None, end_positions: 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/xlm/modeling_xlm.py#L1154)

**매개변수:**

input_ids (`torch.Tensor`, 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)

langs (`torch.LongTensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 입력에서 각 토큰의 언어를 나타내는 데 사용되는 토큰의 병렬 시퀀스입니다. 인덱스는 모델 구성에서 제공되는 두 가지 변환 매핑을 사용하여 언어 이름에서 얻을 수 있는 언어 ID입니다(다국어 모델에만 제공됨). 보다 정확히 말하면, *언어 이름에서 언어 ID로*의 매핑은 `model.config.lang2id`(문자열에서 int로 변환하는 사전)에, *언어 ID에서 언어 이름으로*의 매핑은 `model.config.id2lang`(int에서 문자열로 변환하는 사전)에 있습니다. [다국어 문서](../multilingual)에 자세히 설명된 사용 예시를 참조하세요.

token_type_ids (`torch.Tensor`, 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)

lengths (`torch.LongTensor`, shape `(batch_size,)`, *선택 사항*) : 패딩 토큰 인덱스에 대한 어텐션을 수행하지 않도록 사용할 수 있는 각 문장의 길이입니다. 동일한 결과를 얻기 위해 *attention_mask*를 사용할 수도 있으며(위 참조), 호환성을 위해 여기에 유지되었습니다. `[0, ..., input_ids.size(-1)]`에서 선택된 인덱스입니다.

cache (`dict[str, torch.Tensor]`, *선택 사항*) : 사전 계산된 KV 상태를 포함하는 `EncoderDecoderCache`의 인스턴스입니다. 순차적 디코딩을 가속하는 데 사용할 수 있습니다.

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

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

end_positions (`torch.Tensor`, 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)를 반환할지 여부.

**반환값:** [QuestionAnsweringModelOutput](/docs/transformers/v5.23.0/ko/main_classes/output#transformers.modeling_outputs.QuestionAnsweringModelOutput) 또는 `tuple(torch.Tensor)`

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

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

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

- **loss** (`torch.Tensor`, shape `(1,)`인, *선택*, `labels`가 제공될 때 반환) -- 전체 스팬 추출 손실은 시작 및 끝 위치의 Cross-Entropy 합입니다.
- **start_logits** (`torch.Tensor`, shape `(batch_size, sequence_length)`) -- Span-start 점수 (SoftMax 적용 전).
- **end_logits** (shape `(batch_size, sequence_length)`의 `torch.Tensor`) -- Span-end 점수 (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와 선택적 초기 임베딩 출력을 포함합니다.
- **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 가중치입니다.

예:

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

>>> tokenizer = AutoTokenizer.from_pretrained("FacebookAI/xlm-mlm-en-2048")
>>> model = XLMForQuestionAnsweringSimple.from_pretrained("FacebookAI/xlm-mlm-en-2048")

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

## XLMForQuestionAnswering[[transformers.XLMForQuestionAnswering]]

#### transformers.XLMForQuestionAnswering[[transformers.XLMForQuestionAnswering]]

```python
transformers.XLMForQuestionAnswering(config: XLMConfig)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/xlm/modeling_xlm.py#L1243)

**매개변수:**

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

SQuAD와 같은 추출형 질의응답 작업을 위해 상단에 스팬 분류 헤드가 있는 Xlm 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.XLMForQuestionAnswering.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, langs: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, lengths: typing.Optional[torch.Tensor] = None, cache: dict[str, torch.Tensor] | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, start_positions: typing.Optional[torch.Tensor] = None, end_positions: typing.Optional[torch.Tensor] = None, is_impossible: typing.Optional[torch.Tensor] = None, cls_index: typing.Optional[torch.Tensor] = None, p_mask: 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/xlm/modeling_xlm.py#L1253)

**매개변수:**

input_ids (`torch.Tensor`, 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)

langs (`torch.LongTensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 입력에서 각 토큰의 언어를 나타내는 데 사용되는 토큰의 병렬 시퀀스입니다. 인덱스는 모델 구성에서 제공되는 두 가지 변환 매핑을 사용하여 언어 이름에서 얻을 수 있는 언어 ID입니다(다국어 모델에만 제공됨). 보다 정확히 말하면, *언어 이름에서 언어 ID로*의 매핑은 `model.config.lang2id`(문자열에서 int로 변환하는 사전)에, *언어 ID에서 언어 이름으로*의 매핑은 `model.config.id2lang`(int에서 문자열로 변환하는 사전)에 있습니다. [다국어 문서](../multilingual)에 자세히 설명된 사용 예시를 참조하세요.

token_type_ids (`torch.Tensor`, 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)

lengths (`torch.LongTensor`, shape `(batch_size,)`, *선택 사항*) : 패딩 토큰 인덱스에 대한 어텐션을 수행하지 않도록 사용할 수 있는 각 문장의 길이입니다. 동일한 결과를 얻기 위해 *attention_mask*를 사용할 수도 있으며(위 참조), 호환성을 위해 여기에 유지되었습니다. `[0, ..., input_ids.size(-1)]`에서 선택된 인덱스입니다.

cache (`dict[str, torch.Tensor]`, *선택 사항*) : 사전 계산된 KV 상태를 포함하는 `EncoderDecoderCache`의 인스턴스입니다. 순차적 디코딩을 가속하는 데 사용할 수 있습니다.

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

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

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

is_impossible (`torch.LongTensor`, shape `(batch_size,)`, *선택 사항*) : 질문이 답변을 가지는지 또는 답변이 없는지(SQuAD 2.0)를 나타내는 라벨

cls_index (`torch.LongTensor`, shape `(batch_size,)`, *선택 사항*) : 답변의 타당성을 계산하는 데 입력으로 사용할 분류 토큰의 위치(인덱스)에 대한 라벨.

p_mask (`torch.Tensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 답변에 포함될 수 없는 토큰의 선택적 마스크(예: [CLS], [PAD], ...). 1.0은 토큰이 마스킹되어야 함을 의미하고, 0.0은 토큰이 마스킹되지 않음을 의미합니다.

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)를 반환할지 여부.

**반환값:** [XLMForQuestionAnsweringOutput](/docs/transformers/v5.23.0/ko/model_doc/xlm#transformers.models.xlm.modeling_xlm.XLMForQuestionAnsweringOutput) 또는 `tuple(torch.Tensor)`

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

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

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

- **loss** (`torch.Tensor`, shape `(1,)`, *선택 사항*, `start_positions`와 `end_positions`가 모두 제공된 경우 반환됨) -- 시작 토큰, 끝 토큰(제공된 경우 is_impossible 포함) 분류 손실의 합으로 계산된 분류 손실입니다.
- **start_top_log_probs** (`torch.Tensor`, shape `(batch_size, config.start_n_top)`, *선택 사항*, `start_positions` 또는 `end_positions`이 제공되지 않은 경우 반환됨) -- beam-search에서 상위 config.start_n_top 개 시작 토큰 가능성에 대한 로그 확률.
- **start_top_index** (`torch.LongTensor`, shape `(batch_size, config.start_n_top)`, *선택 사항*, `start_positions` 또는 `end_positions`가 제공되지 않은 경우 반환됨) -- beam-search에서 상위 config.start_n_top 개 시작 토큰 가능성에 대한 인덱스.
- **end_top_log_probs** (`torch.Tensor`, shape `(batch_size, config.start_n_top * config.end_n_top)`, *선택 사항*, `start_positions` 또는 `end_positions`가 제공되지 않은 경우 반환됨) -- 상위 `config.start_n_top * config.end_n_top` 개 end token 가능성에 대한 로그 확률(beam-search).
- **end_top_index** (`torch.LongTensor`, shape `(batch_size, config.start_n_top * config.end_n_top)`, *선택 사항*, `start_positions` 또는 `end_positions`가 제공되지 않은 경우 반환됨) -- 상위 `config.start_n_top * config.end_n_top` 개 end token 가능성에 대한 인덱스(beam-search).
- **cls_logits** (`torch.Tensor`, shape `(batch_size,)`, *선택 사항*, `start_positions` 또는 `end_positions`이 제공되지 않은 경우 반환됨) -- 답변의 `is_impossible` 라벨에 대한 로그 확률입니다.
- **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와 선택적 초기 임베딩 출력을 포함합니다.
- **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, XLMForQuestionAnswering
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("FacebookAI/xlm-mlm-en-2048")
>>> model = XLMForQuestionAnswering.from_pretrained("FacebookAI/xlm-mlm-en-2048")

>>> input_ids = torch.tensor(tokenizer.encode("Hello, my dog is cute", add_special_tokens=True)).unsqueeze(
...     0
... )  # Batch size 1
>>> start_positions = torch.tensor([1])
>>> end_positions = torch.tensor([3])

>>> outputs = model(input_ids, start_positions=start_positions, end_positions=end_positions)
>>> loss = outputs.loss
```

