# ELECTRA

[ELECTRA](https://huggingface.co/papers/2003.10555)는 BERT와 같은 전통적인 마스킹 언어 모델의 사전 학습 목표를 수정합니다. 토큰을 마스킹한 후 모델이 이를 예측하도록 하는 것 대신, ELECTRA는 생성기(generator)와 판별기(discriminator)라는 두 모델을 학습시킵니다. 생성기는 일부 토큰을 그럴듯한 대안으로 교체하고, 판별기(실제로 사용할 모델)는 어떤 토큰이 원본이고 어떤 토큰이 교체되었는지 감지하는 것을 학습합니다. 이 학습 방식은 매우 효율적이며, 훨씬 적은 컴퓨트 리소스를 사용하면서도 더 큰 모델로 확장할 수 있습니다.

이 접근 방식은 ELECTRA가 마스킹된 토큰뿐만 아니라 입력의 모든 토큰에서 학습하기 때문에 매우 효율적입니다. 따라서 작은 ELECTRA 모델도 훨씬 더 적은 컴퓨팅 리소스를 사용하면서 훨씬 더 큰 모델과匹敵하거나 더 나은 성능을 낼 수 있습니다.

모든 원본 ELECTRA 체크포인트는 [ELECTRA](https://huggingface.co/collections/google/electra-release-64ff6e8b18830fabea30a1ab) 릴리스에서 찾을 수 있습니다.

> [!TIP]
> 오른쪽 사이드바를 클릭하여 시퀀스 분류, 토큰 분류, 질문 답변 등 다양한 언어 작업에 ELECTRA를 사용하는 방법에 대한 추가 예제를 확인하세요.

아래 예제는 [Pipeline](/docs/transformers/v5.23.0/ko/main_classes/pipelines#transformers.Pipeline) 또는 [AutoModel](/docs/transformers/v5.23.0/ko/model_doc/auto#transformers.AutoModel) 클래스를 사용하여 텍스트를 분류하는 방법을 보여줍니다.

```python
from transformers import pipeline

classifier = pipeline(
    task="text-classification",
    model="bhadresh-savani/electra-base-emotion",
    device=0
)
classifier("This restaurant has amazing food!")
```

```python
import torch

from transformers import AutoModelForSequenceClassification, AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained(
    "bhadresh-savani/electra-base-emotion",
)
model = AutoModelForSequenceClassification.from_pretrained(
    "bhadresh-savani/electra-base-emotion", device_map="auto",
)
inputs = tokenizer("ELECTRA is more efficient than BERT", return_tensors="pt").to(model.device)

with torch.no_grad():
    outputs = model(**inputs)
    logits = outputs.logits
    predicted_class_id = logits.argmax(dim=-1).item()
    predicted_label = model.config.id2label[predicted_class_id]
print(f"Predicted label: {predicted_label}")
```

## The input is a single word "Notes".

참고

- ELECTRA는 생성기(G)와 판별기(D)라는 두 개의 transformer 모델로 구성됩니다. 대부분의 다운스트림 작업에서는 생성기가 아닌 판별기 모델(이름에 `*-discriminator`로 표시됨)을 사용하세요.
- ELECTRA는 small(14M 파라미터), base(110M 파라미터), large(335M 파라미터)의 세 가지 크기로 제공됩니다.
- ELECTRA는 효율성을 위해 hidden size보다 작은 embedding size를 사용할 수 있습니다. 설정에서 `embedding_size`가 `hidden_size`보다 작으면, 이 둘을 연결하는 projection layer가 사용됩니다.
- 패딩이 포함된 배치 입력을 사용할 때는 attention mask를 사용하여 모델이 패딩 토큰에 주의를 기울이지 않도록 하세요.

    ```py
    # Example of properly handling padding with attention masks
    inputs = tokenizer(["Short text", "This is a much longer text that needs padding"],
                    padding=True,
                    return_tensors="pt")
    outputs = model(**inputs)  # automatically uses the attention_mask
    ```

- 하위 작업에 discriminator를 사용할 때, 이를 ELECTRA 모델 클래스([ElectraForSequenceClassification](/docs/transformers/v5.23.0/ko/model_doc/electra#transformers.ElectraForSequenceClassification), [ElectraForTokenClassification](/docs/transformers/v5.23.0/ko/model_doc/electra#transformers.ElectraForTokenClassification) 등) 중 하나로 로드할 수 있습니다.

## ElectraConfig[[transformers.ElectraConfig]]

#### transformers.ElectraConfig[[transformers.ElectraConfig]]

```python
transformers.ElectraConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, vocab_size: int = 30522, embedding_size: int = 128, hidden_size: int = 256, num_hidden_layers: int = 12, num_attention_heads: int = 4, intermediate_size: int = 1024, 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, summary_type: str = 'first', summary_use_proj: bool = True, summary_activation: str = 'gelu', summary_last_dropout: float | int = 0.1, pad_token_id: int | None = 0, use_cache: bool = True, classifier_dropout: float | int | None = None, is_decoder: bool = False, add_cross_attention: bool = False, bos_token_id: int | None = None, eos_token_id: int | list[int] | None = None, tie_word_embeddings: bool = True)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/electra/configuration_electra.py#L25)

**매개변수:**

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

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

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

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

num_attention_heads (`int`, *선택 사항*, 기본값 `4`) : Transformer 디코더의 각 어텐션 레이어에 사용할 어텐션 헤드 수입니다.

intermediate_size (`int`, *선택 사항*, 기본값 `1024`) : 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 값입니다.

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

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

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

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

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

use_cache (`bool`, *선택 사항*, 기본값 `True`) : 모델이 마지막 key/values attention을 반환할지 여부입니다(모든 모델에서 사용되지 않음). `config.is_decoder=True`인 경우 또는 모델이 decoder-only 생성 모델인 경우에만 관련이 있습니다.

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

is_decoder (`bool`, *선택 사항*, 기본값 `False`) : 모델이 디코더로 사용되는지 여부를 나타냅니다. `False`인 경우 모델은 인코더로 사용됩니다.

add_cross_attention (`bool`, *선택 사항*, 기본값 `False`) : 모델에 cross-attention 레이어를 추가할지 여부.

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

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

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

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

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 ElectraConfig, ElectraModel

>>> # Initializing a ELECTRA electra-base-uncased style configuration
>>> configuration = ElectraConfig()

>>> # Initializing a model (with random weights) from the electra-base-uncased style configuration
>>> model = ElectraModel(configuration)

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

## ElectraTokenizer[[transformers.BertTokenizer]]

#### transformers.BertTokenizer[[transformers.BertTokenizer]]

```python
transformers.BertTokenizer(vocab: str | dict[str, int] | None = None, do_lower_case: bool = True, unk_token: str = '[UNK]', sep_token: str = '[SEP]', pad_token: str = '[PAD]', cls_token: str = '[CLS]', mask_token: str = '[MASK]', tokenize_chinese_chars: bool = True, strip_accents: bool | None = None, **kwargs)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/bert/tokenization_bert.py#L41)

**매개변수:**

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

do_lower_case (`bool`, *선택 사항*, 기본값 `True`) : 토큰화할 때 입력을 소문자로 변환할지 여부입니다.

unk_token (`str`, *선택 사항*, 기본값 `"[UNK]"`) : 알려지지 않은 토큰입니다. 어휘에 없는 토큰은 ID로 변환할 수 없으므로 대신 이 토큰으로 설정됩니다.

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

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

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

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

tokenize_chinese_chars (`bool`, *선택 사항*, 기본값 `True`) : 중국어 문자를 토큰화할지 여부.

strip_accents (`bool`, *선택 사항*) : 모든 악센트를 제거할지 여부입니다. 이 옵션이 지정되지 않으면 `lowercase`의 값에 의해 결정됩니다(원본 BERT와 동일).

HuggingFace의 tokenizers 라이브러리를 기반으로 하는 BERT 토크나이저를 구성합니다. WordPiece 기반입니다.

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

## Electra 전용 출력[[transformers.models.electra.modeling_electra.ElectraForPreTrainingOutput]]

#### transformers.models.electra.modeling_electra.ElectraForPreTrainingOutput[[transformers.models.electra.modeling_electra.ElectraForPreTrainingOutput]]

```python
transformers.models.electra.modeling_electra.ElectraForPreTrainingOutput(loss: typing.Optional[torch.Tensor] = None, 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/electra/modeling_electra.py#L530)

**매개변수:**

loss (`*optional*`, `labels`이 제공된 경우 반환, shape `(1,)`의 `torch.Tensor`) : ELECTRA 목적 함수의 총 손실.

logits (`torch.Tensor`, shape `(batch_size, sequence_length)`) : head의 예측 점수(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`의 튜플(레이어당 하나), shape은 `(batch_size, num_heads, sequence_length, sequence_length)`입니다. attention softmax 이후의 attention 가중치로, self-attention 헤드에서 가중 평균을 계산하는 데 사용됩니다.

[ElectraForPreTraining](/docs/transformers/v5.23.0/ko/model_doc/electra#transformers.ElectraForPreTraining)의 출력 유형입니다.

## ElectraModel[[transformers.ElectraModel]]

#### transformers.ElectraModel[[transformers.ElectraModel]]

```python
transformers.ElectraModel(config: ElectraConfig)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/electra/modeling_electra.py#L545)

**매개변수:**

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

특정 헤드가 위에 없는 Electra 모델의 기본 출력으로, 원시 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.ElectraModel.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, encoder_hidden_states: typing.Optional[torch.Tensor] = None, encoder_attention_mask: typing.Optional[torch.Tensor] = None, past_key_values: list[torch.Tensor] | None = None, use_cache: bool | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/electra/modeling_electra.py#L565)

**매개변수:**

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)

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)

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

encoder_hidden_states (`torch.Tensor`, shape `(batch_size, sequence_length, hidden_size)`, *선택 사항*) : 인코더의 마지막 레이어 출력에서 생성된 hidden-states 시퀀스입니다. 모델이 디코더로 구성된 경우 cross-attention에 사용됩니다.

encoder_attention_mask (`torch.Tensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 인코더 입력의 패딩 토큰 인덱스에 대한 어텐션을 수행하지 않도록 하는 마스크입니다. 모델이 디코더로 구성된 경우 크로스 어텐션에서 이 마스크가 사용됩니다. `[0, 1]`에서 선택된 마스크 값: - **마스크되지 않은** 토큰은 1, - **마스크된** 토큰은 0.

past_key_values (`list[torch.Tensor]`, *선택 사항*) : 순차적 디코딩을 가속화할 수 있는 사전 계산된 hidden-states(self-attention 블록과 cross-attention 블록의 key 및 value)입니다. 이는 일반적으로 `use_cache=True` 또는 `config.use_cache=True`일 때 모델이 이전 디코딩 단계에서 반환한 `past_key_values`로 구성됩니다. 입력으로 [Cache](/docs/transformers/v5.23.0/ko/internal/generation_utils#transformers.Cache) 인스턴스만 허용되며, [kv cache 가이드](https://huggingface.co/docs/transformers/en/kv_cache)를 참조하세요. `past_key_values`가 전달되지 않으면 기본적으로 [DynamicCache](/docs/transformers/v5.23.0/ko/internal/generation_utils#transformers.DynamicCache)가 초기화됩니다. 모델은 입력으로 제공된 것과 동일한 캐시 형식을 출력합니다. `past_key_values`를 사용하는 경우, 이 모델에 과거 key value 상태가 제공되지 않은 `input_ids`(처리되지 않은 항목)만 `(batch_size, unprocessed_length)` 형식으로 입력해야 하며, `(batch_size, sequence_length)` 형식의 모든 `input_ids`를 입력하지 않습니다.

use_cache (`bool`, *선택 사항*) : `True`로 설정하면 `past_key_values` 키 값 상태가 반환되며, 디코딩 속도를 높이는 데 사용할 수 있습니다(`past_key_values` 참조).

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

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

[ElectraModel](/docs/transformers/v5.23.0/ko/model_doc/electra#transformers.ElectraModel)의 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 가중치입니다.
- **cross_attentions** (`tuple(torch.Tensor)`, *선택*, `output_attentions=True` 또는 `config.add_cross_attention=True`가 전달되거나 `config.output_attentions=True`인 경우 반환) -- 각 레이어당 하나씩, shape가 `(batch_size, num_heads, sequence_length, sequence_length)`인 `torch.Tensor`의 튜플.

  decoder의 cross-attention 레이어에서 attention softmax를 적용한 후, cross-attention 헤드에서 가중 평균을 계산하는 데 사용되는 attention 가중치입니다.

## ElectraForPreTraining[[transformers.ElectraForPreTraining]]

#### transformers.ElectraForPreTraining[[transformers.ElectraForPreTraining]]

```python
transformers.ElectraForPreTraining(config: ElectraConfig)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/electra/modeling_electra.py#L867)

**매개변수:**

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

Electra 모델로, 사전 학습 시 생성된 토큰을 식별하기 위해 상단에 이진 분류 헤드를 사용한 형태입니다.

해당 모델에 discriminator 체크포인트를 로드하는 것이 권장됩니다.

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

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/electra/modeling_electra.py#L876)

**매개변수:**

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)

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)

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

labels (`torch.LongTensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : ELECTRA 손실을 계산하기 위한 라벨. 입력은 토큰의 시퀀스여야 합니다(`input_ids` 문서 참조). 인덱스는 `[0, 1]` 범위여야 합니다: - 0은 해당 토큰이 원래의 토큰임을 나타냅니다. - 1은 해당 토큰이 교체되었음을 나타냅니다.

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

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

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

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

- **loss** (`*optional*`, `labels`가 제공될 때 반환됨, `(1,)` 형태의 `torch.Tensor`) -- ELECTRA 목적 함수의 총 손실.
- **logits** (`torch.Tensor`, shape `(batch_size, sequence_length)`) -- head의 예측 점수(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 ElectraForPreTraining, AutoTokenizer
>>> import torch

>>> discriminator = ElectraForPreTraining.from_pretrained("google/electra-base-discriminator")
>>> tokenizer = AutoTokenizer.from_pretrained("google/electra-base-discriminator")

>>> sentence = "The quick brown fox jumps over the lazy dog"
>>> fake_sentence = "The quick brown fox fake over the lazy dog"

>>> fake_tokens = tokenizer.tokenize(fake_sentence, add_special_tokens=True)
>>> fake_inputs = tokenizer.encode(fake_sentence, return_tensors="pt")
>>> discriminator_outputs = discriminator(fake_inputs)
>>> predictions = torch.round((torch.sign(discriminator_outputs[0]) + 1) / 2)

>>> fake_tokens
['[CLS]', 'the', 'quick', 'brown', 'fox', 'fake', 'over', 'the', 'lazy', 'dog', '[SEP]']

>>> predictions.squeeze().tolist()
[0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0]
```

## ElectraForCausalLM[[transformers.ElectraForCausalLM]]

#### transformers.ElectraForCausalLM[[transformers.ElectraForCausalLM]]

```python
transformers.ElectraForCausalLM(config: ElectraConfig)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/electra/modeling_electra.py#L1245)

**매개변수:**

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

CLM 미세 조정용 `language modeling` 헤드가 위에 있는 ELECTRA 모델.

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

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, encoder_hidden_states: typing.Optional[torch.Tensor] = None, encoder_attention_mask: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, use_cache: bool | None = None, logits_to_keep: typing.Union[int, torch.Tensor] = 0, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/electra/modeling_electra.py#L1266)

**매개변수:**

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)

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)

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

encoder_hidden_states (`torch.Tensor`, shape `(batch_size, sequence_length, hidden_size)`, *선택 사항*) : 인코더의 마지막 레이어 출력에서 생성된 hidden-states 시퀀스입니다. 모델이 디코더로 구성된 경우 cross-attention에 사용됩니다.

encoder_attention_mask (`torch.Tensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 인코더 입력의 패딩 토큰 인덱스에 대한 어텐션을 수행하지 않도록 하는 마스크입니다. 모델이 디코더로 구성된 경우 크로스 어텐션에서 이 마스크가 사용됩니다. `[0, 1]`에서 선택된 마스크 값: - **마스크되지 않은** 토큰은 1, - **마스크된** 토큰은 0.

labels (`torch.LongTensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 왼쪽에서 오른쪽으로 언어 모델링 손실(다음 단어 예측)을 계산하는 데 사용되는 라벨. 인덱스는 `[-100, 0, ..., config.vocab_size]` 범위여야 합니다(`input_ids` docstring 참조). 인덱스가 `-100`으로 설정된 토큰은 무시(마스크)되며, 손실은 라벨이 `[0, ..., config.vocab_size]` 범위에 있는 토큰에 대해서만 계산됩니다.

past_key_values (`~cache_utils.Cache`, *선택*) : 순차적 디코딩을 가속화할 수 있는 사전 계산된 hidden-states(셀프 어텐션 블록과 크로스 어텐션 블록의 key 및 value)입니다. 일반적으로 `use_cache=True` 또는 `config.use_cache=True`일 때 모델이 디코딩의 이전 단계에서 반환한 `past_key_values`로 구성됩니다. 입력으로 [Cache](/docs/transformers/v5.23.0/ko/internal/generation_utils#transformers.Cache) 인스턴스만 허용되며, [kv cache 가이드](https://huggingface.co/docs/transformers/en/kv_cache)를 참조하세요. `past_key_values`가 전달되지 않으면 기본적으로 [DynamicCache](/docs/transformers/v5.23.0/ko/internal/generation_utils#transformers.DynamicCache)가 초기화됩니다. 모델은 입력으로 제공된 것과 동일한 캐시 형식을 출력합니다. `past_key_values`를 사용하는 경우, 이 모델에 과거 key value 상태가 제공되지 않은 `input_ids`(처리되지 않은 항목)만 `(batch_size, unprocessed_length)` 형식으로 입력해야 하며, `(batch_size, sequence_length)` 형식의 모든 `input_ids`를 입력하지 않습니다.

use_cache (`bool`, *선택 사항*) : `True`로 설정하면 `past_key_values` 키 값 상태가 반환되며, 디코딩 속도를 높이는 데 사용할 수 있습니다(`past_key_values` 참조).

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

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

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

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

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

- **loss** (`torch.Tensor`, shape `(1,)`, *선택 사항*, `labels`가 제공될 때 반환됨) -- 언어 모델링 손실(다음 토큰 예측용).
- **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 가중치입니다.
- **cross_attentions** (`tuple(torch.Tensor)`, *선택*, `output_attentions=True`가 전달되거나 `config.output_attentions=True`인 경우 반환) -- 각 레이어마다 하나씩 포함된 `torch.Tensor`의 튜플로, shape는 `(batch_size, num_heads, sequence_length, sequence_length)`입니다.

  Attention softmax 이후의 cross attention 가중치로, cross-attention 헤드에서 가중 평균을 계산하는 데 사용됩니다.
- **past_key_values** (`Cache`, *선택 사항*, `use_cache=True`가 전달되었거나 `config.use_cache=True`인 경우 반환됨) -- [Cache](/docs/transformers/v5.23.0/ko/internal/generation_utils#transformers.Cache) 인스턴스입니다. 자세한 내용은 [kv cache 가이드](https://huggingface.co/docs/transformers/en/kv_cache)를 참조하세요.

  순차적 디코딩을 가속화하는 데 사용할 수 있는 사전 계산된 hidden-states(attention 블록의 key와 value)를 포함합니다(입력 `past_key_values` 참조).

예:

```python
>>> from transformers import AutoTokenizer, ElectraForCausalLM, ElectraConfig
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("google/electra-base-generator")
>>> config = ElectraConfig.from_pretrained("google/electra-base-generator")
>>> config.is_decoder = True
>>> model = ElectraForCausalLM.from_pretrained("google/electra-base-generator", config=config)

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs)

>>> prediction_logits = outputs.logits
```

## ElectraForMaskedLM[[transformers.ElectraForMaskedLM]]

#### transformers.ElectraForMaskedLM[[transformers.ElectraForMaskedLM]]

```python
transformers.ElectraForMaskedLM(config: ElectraConfig)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/electra/modeling_electra.py#L959)

**매개변수:**

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

언어 모델링 헤드가 위에 있는 Electra 모델.

discriminator와 generator 모두 이 모델에 로드될 수 있지만, masked language modeling 작업을 위해 학습된 모델은 generator뿐입니다.

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

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/electra/modeling_electra.py#L978)

**매개변수:**

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)

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)

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

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]` 범위의 라벨을 가진 토큰에 대해서만 계산됩니다.

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

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

[ElectraForMaskedLM](/docs/transformers/v5.23.0/ko/model_doc/electra#transformers.ElectraForMaskedLM)의 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
>>> from transformers import AutoTokenizer, ElectraForMaskedLM
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("google/electra-small-discriminator")
>>> model = ElectraForMaskedLM.from_pretrained("google/electra-small-discriminator")

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

## ElectraForSequenceClassification[[transformers.ElectraForSequenceClassification]]

#### transformers.ElectraForSequenceClassification[[transformers.ElectraForSequenceClassification]]

```python
transformers.ElectraForSequenceClassification(config: ElectraConfig)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/electra/modeling_electra.py#L793)

**매개변수:**

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

ELECTRA 모델 변환기입니다. 풀링된 출력 위에 선형 레이어를 배치한 시퀀스 분류/회귀 헤드를 포함하며, 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.ElectraForSequenceClassification.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/electra/modeling_electra.py#L804)

**매개변수:**

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)

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)

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`인 경우 분류 손실(교차 엔트로피)이 계산됩니다.

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

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

[ElectraForSequenceClassification](/docs/transformers/v5.23.0/ko/model_doc/electra#transformers.ElectraForSequenceClassification)의 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, ElectraForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("google/electra-small-discriminator")
>>> model = ElectraForSequenceClassification.from_pretrained("google/electra-small-discriminator")

>>> 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 = ElectraForSequenceClassification.from_pretrained("google/electra-small-discriminator", 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, ElectraForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("google/electra-small-discriminator")
>>> model = ElectraForSequenceClassification.from_pretrained("google/electra-small-discriminator", 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 = ElectraForSequenceClassification.from_pretrained(
...     "google/electra-small-discriminator", 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
```

## ElectraForMultipleChoice[[transformers.ElectraForMultipleChoice]]

#### transformers.ElectraForMultipleChoice[[transformers.ElectraForMultipleChoice]]

```python
transformers.ElectraForMultipleChoice(config: ElectraConfig)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/electra/modeling_electra.py#L1150)

**매개변수:**

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

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

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

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/electra/modeling_electra.py#L1161)

**매개변수:**

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)

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

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

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

[ElectraForMultipleChoice](/docs/transformers/v5.23.0/ko/model_doc/electra#transformers.ElectraForMultipleChoice)의 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, ElectraForMultipleChoice
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("google/electra-small-discriminator")
>>> model = ElectraForMultipleChoice.from_pretrained("google/electra-small-discriminator")

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

## ElectraForTokenClassification[[transformers.ElectraForTokenClassification]]

#### transformers.ElectraForTokenClassification[[transformers.ElectraForTokenClassification]]

```python
transformers.ElectraForTokenClassification(config: ElectraConfig)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/electra/modeling_electra.py#L1025)

**매개변수:**

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

토큰 분류 헤드가 위에 있는 Electra 모델.

discriminator와 generator 모두 이 모델에 로드될 수 있습니다.

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

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/electra/modeling_electra.py#L1039)

**매개변수:**

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)

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)

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]` 범위에 있어야 합니다.

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

[TokenClassifierOutput](/docs/transformers/v5.23.0/ko/main_classes/output#transformers.modeling_outputs.TokenClassifierOutput) 또는 `torch.Tensor` 튜플(`return_dict=False`이 전달되거나 `config.return_dict=False`인 경우)로, [ElectraConfig](/docs/transformers/v5.23.0/ko/model_doc/electra#transformers.ElectraConfig) 구성 및 입력에 따라 다양한 요소를 포함합니다.

[ElectraForTokenClassification](/docs/transformers/v5.23.0/ko/model_doc/electra#transformers.ElectraForTokenClassification)의 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, ElectraForTokenClassification
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("google/electra-small-discriminator")
>>> model = ElectraForTokenClassification.from_pretrained("google/electra-small-discriminator")

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

## ElectraForQuestionAnswering[[transformers.ElectraForQuestionAnswering]]

#### transformers.ElectraForQuestionAnswering[[transformers.ElectraForQuestionAnswering]]

```python
transformers.ElectraForQuestionAnswering(config: ElectraConfig)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/electra/modeling_electra.py#L1079)

**매개변수:**

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

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

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, start_positions: typing.Optional[torch.Tensor] = None, end_positions: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/electra/modeling_electra.py#L1093)

**매개변수:**

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)

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)

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`)로 클램프됩니다. 시퀀스 범위를 벗어난 위치는 손실 계산에 반영되지 않습니다.

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

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

[ElectraForQuestionAnswering](/docs/transformers/v5.23.0/ko/model_doc/electra#transformers.ElectraForQuestionAnswering)의 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, ElectraForQuestionAnswering
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("google/electra-small-discriminator")
>>> model = ElectraForQuestionAnswering.from_pretrained("google/electra-small-discriminator")

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