# ProphetNet

## 개요

ProphetNet 모델은 Yu Yan, Weizhen Qi, Yeyun Gong, Dayiheng Liu, Nan Duan, Jiusheng Chen, Ruofei Zhang, Ming Zhou가 2020년 1월 13일에 [ProphetNet: Predicting Future N-gram for Sequence-to-Sequence Pre-training](https://huggingface.co/papers/2001.04063)에서 제안했습니다.

ProphetNet은 인코더-디코더 모델로, 다음 토큰 하나만 예측하는 대신 ngram 언어 모델링을 위해 n개의 미래 토큰을 예측할 수 있습니다.

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

*본 논문에서는 새로운 시퀀스-투-시퀀스 사전 학습 모델인 ProphetNet을 제시합니다. ProphetNet은 새로운 자기 감독 목적 함수인 future n-gram prediction과 제안된 n-stream self-attention 메커니즘을 도입합니다. 기존 시퀀스-투-시퀀스 모델의 1단계 앞 예측 최적화 방식과 달리, ProphetNet은 각 시간 단계에서 이전 컨텍스트 토큰을 기반으로 다음 n개의 토큰을 동시에 예측하는 n단계 앞 예측을 통해 최적화됩니다. future n-gram prediction은 모델이 미래 토큰을 계획하도록 명시적으로 장려하고, 강한 로컬 상관관계에 대한 과적합을 방지합니다. ProphetNet은 base 규모 데이터셋(16GB)과 large 규모 데이터셋(160GB)을 각각 사용하여 사전 학습했습니다. 이후 CNN/DailyMail, Gigaword, SQuAD 1.1 벤치마크에서 추상적 요약 및 질문 생성 작업을 대상으로 실험을 수행했습니다. 실험 결과, 동일한 규모의 사전 학습 코퍼스를 사용하는 모델들과 비교했을 때 ProphetNet이 모든 해당 데이터셋에서 새로운 최첨단(state-of-the-art) 결과를 달성하는 것으로 나타났습니다.*

저자들의 코드는 [여기](https://github.com/microsoft/ProphetNet)에서 찾을 수 있습니다.

## 사용 팁

- ProphetNet은 절대 위치 임베딩을 사용하는 모델이므로, 일반적으로 왼쪽이 아닌 오른쪽으로 입력을 패딩하는 것이 권장됩니다.
- 모델 아키텍처는 원래의 Transformer를 기반으로 하지만, 디코더의 “표준” self-attention 메커니즘을 main self-attention 메커니즘과 self 및 n-stream (predict) self-attention 메커니즘으로 대체합니다.

## 리소스

- [인과적 언어 모델링 작업 가이드](../tasks/language_modeling)
- [번역 작업 가이드](../tasks/translation)
- [요약 작업 가이드](../tasks/summarization)

## ProphetNetConfig[[transformers.ProphetNetConfig]]

#### transformers.ProphetNetConfig[[transformers.ProphetNetConfig]]

```python
transformers.ProphetNetConfig(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, 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, is_encoder_decoder: bool = True, activation_dropout: float | int = 0.1, activation_function: str = 'gelu', vocab_size: int = 30522, hidden_size: int = 1024, encoder_ffn_dim: int = 4096, num_encoder_layers: int = 12, num_encoder_attention_heads: int = 16, decoder_ffn_dim: int = 4096, num_decoder_layers: int = 12, num_decoder_attention_heads: int = 16, attention_dropout: float | int = 0.1, dropout: float | int = 0.1, max_position_embeddings: int = 512, init_std: float = 0.02, add_cross_attention: bool = True, decoder_start_token_id: int | None = 0, ngram: int = 2, num_buckets: int = 32, relative_max_distance: int = 128, disable_ngram_loss: bool = False, eps: float = 0.0, use_cache: bool = True, pad_token_id: int | None = 0, bos_token_id: int | None = 1, eos_token_id: int | list[int] | None = 2, is_decoder: bool = False, tie_word_embeddings: bool = True)
```

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/prophetnet/configuration_prophetnet.py#L24)

**매개변수:**

is_encoder_decoder (`bool`, *선택 사항*, 기본값 `True`) : 모델이 인코더/디코더로 사용되는지 여부.

activation_dropout (`Union[float, int]`, *선택 사항*, 기본값 `0.1`) : 완전 연결 계층 내부 활성화의 dropout 비율입니다.

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

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

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

encoder_ffn_dim (`int`, *선택 사항*, 기본값 `4096`) : 인코더의 "중간"(일반적으로 feed-forward라고도 함) 레이어의 차원.

num_encoder_layers (`int`, *선택 사항*, 기본값 `12`) : Transformer 인코더의 숨겨진 레이어 수입니다. 설정하지 않으면 `num_layers`와 동일한 값을 사용합니다.

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

decoder_ffn_dim (`int`, *선택 사항*, 기본값 `4096`) : 디코더의 "중간"(일반적으로 feed-forward라고도 함) 레이어의 차원.

num_decoder_layers (`int`, *선택 사항*, 기본값 `12`) : Transformer decoder의 숨겨진 레이어 수입니다. 설정하지 않으면 `num_layers`와 동일한 값을 사용합니다.

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

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

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

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

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

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

decoder_start_token_id (`int`, *선택 사항*, 기본값 `0`) : 인코더-디코더 모델이 `bos`와 다른 토큰으로 디코딩을 시작하는 경우, 해당 토큰의 id입니다.

ngram (`int`, *선택 사항*, 기본값 2) : 예측할 미래 토큰의 수입니다. 다음 첫 번째 토큰을 예측하는 전통적인 언어 모델과 동일하게 하려면 1로 설정하세요.

num_buckets (`int`, *선택 사항*, 기본값 32) : 각 attention layer에 사용할 버킷의 수입니다. 이는 상대 위치 계산에 사용됩니다. 자세한 내용은 [T5 논문](see https://huggingface.co/papers/1910.10683)을 참고하세요.

relative_max_distance (`int`, *선택 사항*, 기본값 128) : 이 값보다 큰 상대 거리는 마지막 동일한 버킷에 배치됩니다. 이는 상대 위치 계산에 사용됩니다. 자세한 내용은 [T5 논문](see https://huggingface.co/papers/1910.10683)을 참고하세요.

disable_ngram_loss (`bool`, *선택 사항*, 기본값 `False`) : 첫 번째 토큰만 예측하도록 학습할지 여부.

eps (`float`, *선택 사항*, 기본값 0.0) : 손실 계산에서 라벨 스무딩의 `epsilon` 파라미터 값을 제어합니다. 0으로 설정하면 라벨 스무딩이 수행되지 않습니다.

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

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

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

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

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

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

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

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

## ProphetNetTokenizer[[transformers.ProphetNetTokenizer]]

#### transformers.ProphetNetTokenizer[[transformers.ProphetNetTokenizer]]

```python
transformers.ProphetNetTokenizer(vocab_file: str, do_lower_case: bool | None = True, do_basic_tokenize: bool | None = True, never_split: collections.abc.Iterable | None = None, unk_token: str | None = '[UNK]', sep_token: str | None = '[SEP]', x_sep_token: str | None = '[X_SEP]', pad_token: str | None = '[PAD]', mask_token: str | None = '[MASK]', tokenize_chinese_chars: bool | None = True, strip_accents: bool | None = None, clean_up_tokenization_spaces: bool = True, **kwargs)
```

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/prophetnet/tokenization_prophetnet.py#L267)

**매개변수:**

vocab_file (`str`) : 어휘를 포함하는 파일.

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

do_basic_tokenize (`bool`, *선택 사항*, 기본값 `True`) : WordPiece를 수행하기 전에 기본 토큰화를 수행할지 여부.

never_split (`Iterable`, *선택 사항*) : 토큰화 과정에서 절대 분리되지 않는 토큰의 컬렉션입니다. `do_basic_tokenize=True`일 때만 효과가 있습니다.

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

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

x_sep_token (`str`, *선택 사항*, 기본값 `"[X_SEP]"`) : [ProphetNetForConditionalGeneration](/docs/transformers/main/ko/model_doc/prophetnet#transformers.ProphetNetForConditionalGeneration)에서 생성할 수 있는 특수한 두 번째 구분자 토큰입니다. 요약 작업에서 불릿 포인트 형태의 문장을 구분하는 데 사용되며, *예를 들어*.

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

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

tokenize_chinese_chars (`bool`, *선택 사항*, 기본값 `True`) : 중국어 문자를 토큰화할지 여부입니다. 일본어에는 비활성화하는 것이 좋습니다(이 [이슈](https://github.com/huggingface/transformers/issues/328) 참조).

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

clean_up_tokenization_spaces (`bool`, *선택 사항*, 기본값 `True`) : 디코딩 후 공백을 정리할지 여부입니다. 정리는 불필요한 공백과 같은 잠재적 아티팩트를 제거하는 작업을 포함합니다.

WordPiece 기반으로 ProphetNetTokenizer를 구성합니다.

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

#### build_inputs_with_special_tokens[[transformers.ProphetNetTokenizer.build_inputs_with_special_tokens]]

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

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/prophetnet/tokenization_prophetnet.py#L450)

**매개변수:**

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

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

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

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

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

- 단일 시퀀스: `[CLS] X [SEP]`
- 시퀀스 쌍: `[CLS] A [SEP] B [SEP]`

#### convert_tokens_to_string[[transformers.ProphetNetTokenizer.convert_tokens_to_string]]

```python
convert_tokens_to_string(tokens: str)
```

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/prophetnet/tokenization_prophetnet.py#L395)

단일 문자열 내 토큰(문자열) 시퀀스를 변환합니다.

#### get_special_tokens_mask[[transformers.ProphetNetTokenizer.get_special_tokens_mask]]

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

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/prophetnet/tokenization_prophetnet.py#L400)

**매개변수:**

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` 메서드를 사용하여 특수 토큰을 추가할 때 호출됩니다.

## ProphetNet 고유 출력[[transformers.models.prophetnet.modeling_prophetnet.ProphetNetSeq2SeqLMOutput]]

#### transformers.models.prophetnet.modeling_prophetnet.ProphetNetSeq2SeqLMOutput[[transformers.models.prophetnet.modeling_prophetnet.ProphetNetSeq2SeqLMOutput]]

```python
transformers.models.prophetnet.modeling_prophetnet.ProphetNetSeq2SeqLMOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, logits_ngram: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, decoder_hidden_states: tuple[torch.Tensor] | None = None, decoder_ngram_hidden_states: tuple[torch.Tensor] | None = None, decoder_attentions: tuple[torch.Tensor] | None = None, decoder_ngram_attentions: tuple[torch.Tensor] | None = None, cross_attentions: tuple[torch.Tensor] | None = None, encoder_last_hidden_state: typing.Optional[torch.Tensor] = None, encoder_hidden_states: tuple[torch.Tensor] | None = None, encoder_attentions: tuple[torch.Tensor] | None = None)
```

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/prophetnet/modeling_prophetnet.py#L122)

**매개변수:**

loss (`torch.Tensor`, shape `(1,)`, *선택*, `labels`이 제공될 때 반환됨) : 언어 모델링 손실.

logits (`torch.Tensor`, shape `(batch_size, decoder_sequence_length, config.vocab_size)`) : 메인 스트림 언어 모델링 헤드에 대한 예측 점수(SoftMax 적용 전 각 어휘 토큰의 점수).

logits_ngram (`torch.Tensor`, shape `(batch_size, ngram * decoder_sequence_length, config.vocab_size)`) : predict stream 언어 모델링 헤드에 대한 예측 점수(SoftMax 적용 전 각 어휘 토큰의 점수).

past_key_values (`Cache`, *선택 사항*, `use_cache=True`가 전달되거나 `config.use_cache=True`인 경우 반환됨) : [Cache](/docs/transformers/main/ko/internal/generation_utils#transformers.Cache) 인스턴스입니다. 자세한 내용은 [kv 캐시 가이드](https://huggingface.co/docs/transformers/en/kv_cache)를 참조하세요. 순차적 디코딩을 가속화하는 데 사용할 수 있는 디코더의 사전 계산된 hidden-states(attention 블록의 key와 value)를 포함합니다(입력 `past_key_values` 참조).

decoder_hidden_states (`tuple[torch.Tensor]`, *선택*, `output_hidden_states=True`가 전달되거나 `config.output_hidden_states=True`인 경우 반환) : shape가 `(batch_size, sequence_length, hidden_size)`인 `torch.Tensor`의 튜플 (모델에 embedding 레이어가 있는 경우 embedding 출력 1개 + 각 레이어 출력 1개). 각 레이어 출력 시점의 decoder hidden-states와 초기 embedding 출력을 포함합니다.

decoder_ngram_hidden_states (`tuple(torch.Tensor)`, *선택*, `output_hidden_states=True`가 전달되거나 `config.output_hidden_states=True`인 경우 반환됨) : `torch.Tensor`의 튜플(임베딩 출력용 1개 + 각 레이어 출력용 1개)로, 모양은 `(batch_size, ngram * decoder_sequence_length, hidden_size)`입니다. 디코더의 predict 스트림에서 각 레이어 출력 시점의 hidden-states와 초기 임베딩 출력을 포함합니다.

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

decoder_ngram_attentions (`tuple(torch.Tensor)`, *선택 사항*, `output_attentions=True`가 전달되거나 `config.output_attentions=True`인 경우 반환됨) : `torch.Tensor`의 튜플(레이어당 하나), shape은 `(batch_size, num_attn_heads, decoder_sequence_length, decoder_sequence_length)`입니다. attention softmax 이후의 decoder predict stream의 attention 가중치로, self-attention 헤드에서 가중 평균을 계산하는 데 사용됩니다.

cross_attentions (`tuple[torch.Tensor]`, *선택 사항*, `output_attentions=True`가 전달되었거나 `config.output_attentions=True`인 경우 반환됨) : `torch.Tensor`의 Tuple (각 레이어마다 하나), shape은 `(batch_size, num_heads, sequence_length, sequence_length)`. attention softmax를 거친 decoder의 cross-attention 레이어의 attention 가중치로, cross-attention heads에서 가중 평균을 계산하는 데 사용됩니다.

encoder_last_hidden_state (`torch.Tensor`, shape `(batch_size, encoder_sequence_length, hidden_size)`, *선택 사항*) : 모델 인코더의 마지막 레이어 출력에서 생성된 hidden-states 시퀀스.

encoder_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와 초기 임베딩 출력입니다.

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

시퀀스-투-시퀀스 언어 모델 출력을 위한 베이스 클래스

#### transformers.models.prophetnet.modeling_prophetnet.ProphetNetSeq2SeqModelOutput[[transformers.models.prophetnet.modeling_prophetnet.ProphetNetSeq2SeqModelOutput]]

```python
transformers.models.prophetnet.modeling_prophetnet.ProphetNetSeq2SeqModelOutput(last_hidden_state: Tensor, last_hidden_state_ngram: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, decoder_hidden_states: tuple[torch.Tensor] | None = None, decoder_ngram_hidden_states: tuple[torch.Tensor] | None = None, decoder_attentions: tuple[torch.Tensor] | None = None, decoder_ngram_attentions: tuple[torch.Tensor] | None = None, cross_attentions: tuple[torch.Tensor] | None = None, encoder_last_hidden_state: typing.Optional[torch.Tensor] = None, encoder_hidden_states: tuple[torch.Tensor] | None = None, encoder_attentions: tuple[torch.Tensor] | None = None)
```

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/prophetnet/modeling_prophetnet.py#L174)

**매개변수:**

last_hidden_state (`torch.Tensor`, shape `(batch_size, decoder_sequence_length, hidden_size)`) : 모델의 decoder 마지막 레이어 출력에서 주 스트림의 hidden-states 시퀀스입니다. `past_key_values`를 사용하는 경우 shape가 `(batch_size, 1, hidden_size)`인 시퀀스의 마지막 hidden-state만 출력됩니다.

last_hidden_state_ngram (`torch.Tensor`, shape `(batch_size,ngram * decoder_sequence_length, config.vocab_size)`, *선택 사항*) : 모델의 decoder 마지막 레이어 출력에서 예측 스트림의 hidden-states 시퀀스.

past_key_values (`Cache`, *선택 사항*, `use_cache=True`가 전달되거나 `config.use_cache=True`인 경우 반환됨) : [Cache](/docs/transformers/main/ko/internal/generation_utils#transformers.Cache) 인스턴스입니다. 자세한 내용은 [kv 캐시 가이드](https://huggingface.co/docs/transformers/en/kv_cache)를 참조하세요. 순차적 디코딩을 가속화하는 데 사용할 수 있는 디코더의 사전 계산된 hidden-states(attention 블록의 key와 value)를 포함합니다(입력 `past_key_values` 참조).

decoder_hidden_states (`tuple[torch.Tensor]`, *선택*, `output_hidden_states=True`가 전달되거나 `config.output_hidden_states=True`인 경우 반환) : shape가 `(batch_size, sequence_length, hidden_size)`인 `torch.Tensor`의 튜플 (모델에 embedding 레이어가 있는 경우 embedding 출력 1개 + 각 레이어 출력 1개). 각 레이어 출력 시점의 decoder hidden-states와 초기 embedding 출력을 포함합니다.

decoder_ngram_hidden_states (`tuple(torch.Tensor)`, *선택*, `output_hidden_states=True`가 전달되거나 `config.output_hidden_states=True`인 경우 반환됨) : `torch.Tensor`의 튜플(임베딩 출력용 1개 + 각 레이어 출력용 1개)로, 모양은 `(batch_size, ngram * decoder_sequence_length, hidden_size)`입니다. 디코더의 predict 스트림에서 각 레이어 출력 시점의 hidden-states와 초기 임베딩 출력을 포함합니다.

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

decoder_ngram_attentions (`tuple(torch.Tensor)`, *선택 사항*, `output_attentions=True`가 전달되거나 `config.output_attentions=True`인 경우 반환됨) : `torch.Tensor`의 튜플(레이어당 하나)로, 모양은 `(batch_size, num_attn_heads, decoder_sequence_length, decoder_sequence_length)`입니다. 디코더의 predict 스트림의 어텐션 가중치로, 어텐션 softmax 이후에 가중 평균을 계산하는 데

cross_attentions (`tuple[torch.Tensor]`, *선택 사항*, `output_attentions=True`가 전달되었거나 `config.output_attentions=True`인 경우 반환됨) : `torch.Tensor`의 Tuple (각 레이어마다 하나), shape은 `(batch_size, num_heads, sequence_length, sequence_length)`. attention softmax를 거친 decoder의 cross-attention 레이어의 attention 가중치로, cross-attention heads에서 가중 평균을 계산하는 데 사용됩니다.

encoder_last_hidden_state (`torch.Tensor`, shape `(batch_size, encoder_sequence_length, hidden_size)`, *선택 사항*) : 모델 인코더의 마지막 레이어 출력에서 생성된 hidden-states 시퀀스.

encoder_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와 초기 임베딩 출력입니다.

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

모델 인코더의 출력에 대한 기본 클래스로, 순차적 디코딩을 가속할 수 있는 사전 계산된 hidden states도 포함합니다.

#### transformers.models.prophetnet.modeling_prophetnet.ProphetNetDecoderModelOutput[[transformers.models.prophetnet.modeling_prophetnet.ProphetNetDecoderModelOutput]]

```python
transformers.models.prophetnet.modeling_prophetnet.ProphetNetDecoderModelOutput(last_hidden_state: Tensor, last_hidden_state_ngram: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, hidden_states: tuple[torch.Tensor] | None = None, hidden_states_ngram: tuple[torch.Tensor] | None = None, attentions: tuple[torch.Tensor] | None = None, ngram_attentions: tuple[torch.Tensor] | None = None, cross_attentions: tuple[torch.Tensor] | None = None)
```

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/prophetnet/modeling_prophetnet.py#L223)

**매개변수:**

last_hidden_state (`torch.Tensor`, shape `(batch_size, decoder_sequence_length, hidden_size)`) : 모델의 decoder 마지막 레이어 출력에서 주 스트림의 hidden-states 시퀀스입니다. `past_key_values`를 사용하는 경우 shape가 `(batch_size, 1, hidden_size)`인 시퀀스의 마지막 hidden-state만 출력됩니다.

last_hidden_state_ngram (`torch.Tensor`, shape `(batch_size, ngram * decoder_sequence_length, config.vocab_size)`) : 모델의 decoder 마지막 레이어 출력에서 생성된 predict stream hidden-states 시퀀스.

past_key_values (`Cache`, *선택 사항*, `use_cache=True`가 전달되거나 `config.use_cache=True`인 경우 반환됨) : [Cache](/docs/transformers/main/ko/internal/generation_utils#transformers.Cache) 인스턴스입니다. 자세한 내용은 [kv 캐시 가이드](https://huggingface.co/docs/transformers/en/kv_cache)를 참조하세요. 순차적 디코딩을 가속화하는 데 사용할 수 있는 디코더의 사전 계산된 hidden-states(attention 블록의 key와 value)를 포함합니다(입력 `past_key_values` 참조).

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와 선택적인 초기 임베딩 출력을 포함합니다.

hidden_states_ngram (`tuple(torch.Tensor)`, *선택*, `output_hidden_states=True`가 전달되거나 `config.output_hidden_states=True`인 경우 반환됨) : `torch.Tensor`의 튜플(임베딩 출력용 1개 + 각 레이어 출력용 1개)로, 모양은 `(batch_size, ngram * decoder_sequence_length, hidden_size)`입니다. 디코더의 predict 스트림에서 각 레이어 출력 시점의 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 헤드에서 가중 평균을 계산하는 데 사용됩니다.

ngram_attentions (`tuple(torch.Tensor)`, *선택 사항*, `output_attentions=True`가 전달되거나 `config.output_attentions=True`인 경우 반환됨) : `torch.Tensor`의 튜플(레이어당 하나)로, 모양은 `(batch_size, num_attn_heads, decoder_sequence_length, decoder_sequence_length)`입니다. 디코더의 predict 스트림의 어텐션 가중치로, 어텐션 softmax 이후에 가중 평균을 계산하는 데

cross_attentions (`tuple[torch.Tensor]`, *선택 사항*, `output_attentions=True`가 전달되었거나 `config.output_attentions=True`인 경우 반환됨) : `torch.Tensor`의 Tuple (각 레이어마다 하나), shape은 `(batch_size, num_heads, sequence_length, sequence_length)`. attention softmax를 거친 decoder의 cross-attention 레이어의 attention 가중치로, cross-attention heads에서 가중 평균을 계산하는 데 사용됩니다.

순차적 디코딩을 가속화하기 위해 과거의 키/값을 포함할 수도 있는 모델 출력의 기본 클래스입니다.

#### transformers.models.prophetnet.modeling_prophetnet.ProphetNetDecoderLMOutput[[transformers.models.prophetnet.modeling_prophetnet.ProphetNetDecoderLMOutput]]

```python
transformers.models.prophetnet.modeling_prophetnet.ProphetNetDecoderLMOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, logits_ngram: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, hidden_states: tuple[torch.Tensor] | None = None, hidden_states_ngram: tuple[torch.Tensor] | None = None, attentions: tuple[torch.Tensor] | None = None, ngram_attentions: tuple[torch.Tensor] | None = None, cross_attentions: tuple[torch.Tensor] | None = None)
```

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/prophetnet/modeling_prophetnet.py#L267)

**매개변수:**

loss (`torch.Tensor`, shape `(1,)`, *선택*, `labels`이 제공될 때 반환됨) : 언어 모델링 손실.

logits (`torch.Tensor`, shape `(batch_size, decoder_sequence_length, config.vocab_size)`) : 메인 스트림 언어 모델링 헤드에 대한 예측 점수(SoftMax 적용 전 각 어휘 토큰의 점수).

logits_ngram (`torch.Tensor`, shape `(batch_size, ngram * decoder_sequence_length, config.vocab_size)`) : predict stream 언어 모델링 헤드에 대한 예측 점수(SoftMax 적용 전 각 어휘 토큰의 점수).

past_key_values (`Cache`, *선택 사항*, `use_cache=True`가 전달되거나 `config.use_cache=True`인 경우 반환됨) : [Cache](/docs/transformers/main/ko/internal/generation_utils#transformers.Cache) 인스턴스입니다. 자세한 내용은 [kv 캐시 가이드](https://huggingface.co/docs/transformers/en/kv_cache)를 참조하세요. 순차적 디코딩을 가속화하는 데 사용할 수 있는 디코더의 사전 계산된 hidden-states(attention 블록의 key와 value)를 포함합니다(입력 `past_key_values` 참조).

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와 선택적인 초기 임베딩 출력을 포함합니다.

hidden_states_ngram (`tuple(torch.Tensor)`, *선택*, `output_hidden_states=True`가 전달되거나 `config.output_hidden_states=True`인 경우 반환됨) : `torch.Tensor`의 튜플(임베딩 출력용 1개 + 각 레이어 출력용 1개)로, 모양은 `(batch_size, ngram * decoder_sequence_length, hidden_size)`입니다. 디코더의 predict 스트림에서 각 레이어 출력 시점의 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 헤드에서 가중 평균을 계산하는 데 사용됩니다.

ngram_attentions (`tuple(torch.Tensor)`, *선택 사항*, `output_attentions=True`가 전달되거나 `config.output_attentions=True`인 경우 반환됨) : `torch.Tensor`의 튜플(레이어당 하나)로, 모양은 `(batch_size, num_attn_heads, decoder_sequence_length, decoder_sequence_length)`입니다. 디코더의 predict 스트림의 어텐션 가중치로, 어텐션 softmax 이후에 가중 평균을 계산하는 데

cross_attentions (`tuple[torch.Tensor]`, *선택 사항*, `output_attentions=True`가 전달되었거나 `config.output_attentions=True`인 경우 반환됨) : `torch.Tensor`의 Tuple (각 레이어마다 하나), shape은 `(batch_size, num_heads, sequence_length, sequence_length)`. attention softmax를 거친 decoder의 cross-attention 레이어의 attention 가중치로, cross-attention heads에서 가중 평균을 계산하는 데 사용됩니다.

순차적 디코딩을 가속화하기 위해 과거의 키/값을 포함할 수도 있는 모델 출력의 기본 클래스입니다.

## ProphetNetModel[[transformers.ProphetNetModel]]

#### transformers.ProphetNetModel[[transformers.ProphetNetModel]]

```python
transformers.ProphetNetModel(config: ProphetNetConfig)
```

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/prophetnet/modeling_prophetnet.py#L1354)

**매개변수:**

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

특정 헤드가 위에 없는 Prophetnet 모델로, 원시 hidden-states를 출력합니다.

이 모델은 [PreTrainedModel](/docs/transformers/main/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.ProphetNetModel.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, decoder_input_ids: typing.Optional[torch.Tensor] = None, decoder_attention_mask: typing.Optional[torch.BoolTensor] = None, encoder_outputs: tuple | None = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, decoder_inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/prophetnet/modeling_prophetnet.py#L1383)

**매개변수:**

input_ids (`torch.Tensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 어휘(input sequence tokens)의 인덱스입니다. 기본적으로 패딩은 무시됩니다. [AutoTokenizer](/docs/transformers/main/ko/model_doc/auto#transformers.AutoTokenizer)를 사용하여 인덱스를 얻을 수 있습니다. 자세한 내용은 [PreTrainedTokenizer.encode()](/docs/transformers/main/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 및 [PreTrainedTokenizer.__call__()](/docs/transformers/main/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)

decoder_input_ids (`torch.LongTensor`, shape `(batch_size, target_sequence_length)`, *선택 사항*) : 어휘에서 디코더 입력 시퀀스 토큰의 인덱스입니다. [AutoTokenizer](/docs/transformers/main/ko/model_doc/auto#transformers.AutoTokenizer)를 사용하여 인덱스를 얻을 수 있습니다. 자세한 내용은 [PreTrainedTokenizer.encode()](/docs/transformers/main/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 및 [PreTrainedTokenizer.__call__()](/docs/transformers/main/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)를 참조하세요. [디코더 입력 ID란 무엇인가요?](../glossary#decoder-input-ids) ProphetNet은 `decoder_input_ids` 생성의 시작 토큰으로 `eos_token_id`를 사용합니다. `past_key_values`를 사용하는 경우, 선택적으로 마지막 `decoder_input_ids`만 입력하면 됩니다(`past_key_values` 참조).

decoder_attention_mask (`torch.BoolTensor`, shape `(batch_size, target_sequence_length)`, *선택 사항*) : 기본 동작: `decoder_input_ids`의 pad 토큰을 무시하는 텐서를 생성합니다. 기본적으로 Causal mask도 사용됩니다.

encoder_outputs (`tuple`, *선택 사항*) : (`last_hidden_state`, *선택 사항*: `hidden_states`, *선택 사항*: `attentions`) `last_hidden_state`의 shape는 `(batch_size, sequence_length, hidden_size)`, *선택 사항*)이며, 인코더의 마지막 레이어 출력에서 생성된 hidden-states의 시퀀스입니다. 디코더의 cross-attention에 사용됩니다.

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

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

decoder_inputs_embeds (`torch.Tensor`, shape `(batch_size, target_sequence_length, hidden_size)`, *선택 사항*) : `decoder_input_ids`를 전달하는 대신 임베디드 표현을 직접 전달할 수 있습니다. `past_key_values`를 사용하는 경우, 선택적으로 마지막 `decoder_inputs_embeds`만 입력하면 됩니다(`past_key_values` 참조). 모델 내부 임베딩 조회 행렬보다 `decoder_input_ids` 인덱스를 관련 벡터로 변환하는 방식을 더 세밀하게 제어하려는 경우 유용합니다. `decoder_input_ids`와 `decoder_inputs_embeds`가 모두 설정되지 않은 경우, `decoder_inputs_embeds`는 `inputs_embeds`의 값을 취합니다.

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

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

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

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

**반환값:** [ProphetNetSeq2SeqModelOutput](/docs/transformers/main/ko/model_doc/prophetnet#transformers.models.prophetnet.modeling_prophetnet.ProphetNetSeq2SeqModelOutput) 또는 `tuple(torch.Tensor)`

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

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

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

- **last_hidden_state** (`torch.Tensor`, shape `(batch_size, decoder_sequence_length, hidden_size)`) -- 모델의 decoder 마지막 레이어 출력에서 주 스트림의 hidden-states 시퀀스입니다.

  `past_key_values`가 사용되면, `(batch_size, 1, hidden_size)` 형태의 시퀀스의 마지막 hidden-state만 출력됩니다.
- **last_hidden_state_ngram** (`torch.Tensor`, shape `(batch_size,ngram * decoder_sequence_length, config.vocab_size)`, *선택 사항*) -- 모델의 decoder 마지막 레이어 출력에서 예측 스트림의 hidden-state 시퀀스입니다.
- **past_key_values** (`Cache`, *선택 사항*, `use_cache=True`가 전달되었거나 `config.use_cache=True`인 경우 반환됨) -- [Cache](/docs/transformers/main/ko/internal/generation_utils#transformers.Cache) 인스턴스입니다. 자세한 내용은 [kv cache 가이드](https://huggingface.co/docs/transformers/en/kv_cache)를 참조하세요.

  순차적 디코딩을 가속화하기 위해 사용할 수 있는(입력 `past_key_values` 참조) 디코더의 사전 계산된 hidden-states(attention 블록의 key와 value)를 포함합니다.
- **decoder_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와 초기 임베딩 출력을 더한 값.
- **decoder_ngram_hidden_states** (`tuple(torch.Tensor)`, *선택 사항*, `output_hidden_states=True`가 전달되었거나 `config.output_hidden_states=True`인 경우 반환됨) -- `torch.Tensor`의 튜플(임베딩 출력 1개 + 각 레이어의 출력 1개)로, 모양은 `(batch_size, ngram * decoder_sequence_length, hidden_size)`입니다.

  각 레이어의 출력에서 디코더의 predict 스트림의 Hidden-states와 초기 임베딩 출력을 더한 값.
- **decoder_attentions** (`tuple[torch.Tensor]`, *선택 사항*, `output_attentions=True`가 전달되거나 `config.output_attentions=True`인 경우 반환) -- 각 레이어에 하나씩, shape가 `(batch_size, num_heads, sequence_length, sequence_length)`인 `torch.Tensor` 튜플.

  self-attention 헤드에서 가중 평균을 계산하는 데 사용되는, attention softmax 이후의 decoder의 attention 가중치입니다.
- **decoder_ngram_attentions** (`tuple(torch.Tensor)`, *선택 사항*, `output_attentions=True`가 전달되었거나 `config.output_attentions=True`인 경우 반환됨) -- 각 레이어마다 하나씩 포함된 `torch.Tensor`의 튜플로, 모양은 `(batch_size, num_attn_heads, decoder_sequence_length, decoder_sequence_length)`입니다.

  …에서 가중 평균을 계산하는 데 사용되는, 디코더의 predict 스트림의 어텐션 가중치, 어텐션 softmax 이후
- **cross_attentions** (`tuple[torch.Tensor]`, *선택*, `output_attentions=True`가 전달되거나 `config.output_attentions=True`일 때 반환) -- 각 레이어마다 하나씩 포함된 `torch.Tensor`의 튜플로, shape는 `(batch_size, num_heads, sequence_length, sequence_length)`입니다.

  decoder의 cross-attention 레이어에서 attention softmax를 적용한 후, cross-attention 헤드에서 가중 평균을 계산하는 데 사용되는 attention 가중치입니다.
- **encoder_last_hidden_state** (`torch.Tensor`, shape `(batch_size, encoder_sequence_length, hidden_size)`, *선택 사항*) -- 모델 인코더의 마지막 레이어 출력에서 생성된 hidden-state 시퀀스입니다.
- **encoder_hidden_states** (`tuple[torch.Tensor]`, *선택 사항*, `output_hidden_states=True`가 전달되거나 `config.output_hidden_states=True`일 때 반환됩니다) -- `torch.Tensor`의 튜플 (임베딩 레이어가 있는 경우 임베딩 출력용 1개 + 각 레이어의 출력용 1개)로, shape가 `(batch_size, sequence_length, hidden_size)`입니다.

  각 레이어의 출력에서 인코더의 Hidden-states와 초기 임베딩 출력을 더한 값.
- **encoder_attentions** (`tuple[torch.Tensor]`, *선택*, `output_attentions=True`가 전달되었거나 `config.output_attentions=True`인 경우 반환) -- 각 레이어에 하나씩 포함된 `torch.Tensor` 튜플이며, shape은 `(batch_size, num_heads, sequence_length, sequence_length)`입니다.

  인코더의 어텐션 가중치입니다. 어텐션 softmax 이후에 self-attention 헤드에서 가중 평균을 계산하는 데 사용됩니다.

예:

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

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/prophetnet-large-uncased")
>>> model = ProphetNetModel.from_pretrained("microsoft/prophetnet-large-uncased")

>>> input_ids = tokenizer(
...     "Studies have been shown that owning a dog is good for you", return_tensors="pt"
... ).input_ids  # Batch size 1
>>> decoder_input_ids = tokenizer("Studies show that", return_tensors="pt").input_ids  # Batch size 1
>>> outputs = model(input_ids=input_ids, decoder_input_ids=decoder_input_ids)

>>> last_hidden_states = outputs.last_hidden_state  # main stream hidden states
>>> last_hidden_states_ngram = outputs.last_hidden_state_ngram  # predict hidden states
```

## ProphetNetEncoder[[transformers.ProphetNetEncoder]]

#### transformers.ProphetNetEncoder[[transformers.ProphetNetEncoder]]

```python
transformers.ProphetNetEncoder(config: ProphetNetConfig)
```

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/prophetnet/modeling_prophetnet.py#L947)

**매개변수:**

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

ProphetNetModel의 독립형 인코더 부분입니다.

이 모델은 [PreTrainedModel](/docs/transformers/main/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.ProphetNetEncoder.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = 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/main/src/transformers/models/prophetnet/modeling_prophetnet.py#L967)

**매개변수:**

input_ids (`torch.Tensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 어휘(input sequence tokens)의 인덱스입니다. 기본적으로 패딩은 무시됩니다. [AutoTokenizer](/docs/transformers/main/ko/model_doc/auto#transformers.AutoTokenizer)를 사용하여 인덱스를 얻을 수 있습니다. 자세한 내용은 [PreTrainedTokenizer.encode()](/docs/transformers/main/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 및 [PreTrainedTokenizer.__call__()](/docs/transformers/main/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)

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/main/ko/main_classes/output#transformers.utils.ModelOutput)를 반환할지 여부.

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

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

[ProphetNetEncoder](/docs/transformers/main/ko/model_doc/prophetnet#transformers.ProphetNetEncoder)의 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 가중치입니다.

예:

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

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/prophetnet-large-uncased")
>>> model = ProphetNetEncoder.from_pretrained("patrickvonplaten/prophetnet-large-uncased-standalone")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs)

>>> last_hidden_states = outputs.last_hidden_state
```

## ProphetNetDecoder[[transformers.ProphetNetDecoder]]

#### transformers.ProphetNetDecoder[[transformers.ProphetNetDecoder]]

```python
transformers.ProphetNetDecoder(config: ProphetNetConfig)
```

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/prophetnet/modeling_prophetnet.py#L1054)

**매개변수:**

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

ProphetNetModel의 독립형(decoder) 부분입니다.

이 모델은 [PreTrainedModel](/docs/transformers/main/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.ProphetNetDecoder.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, encoder_hidden_states: typing.Optional[torch.Tensor] = None, encoder_attention_mask: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/prophetnet/modeling_prophetnet.py#L1083)

**매개변수:**

input_ids (`torch.Tensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 어휘(input sequence tokens)의 인덱스입니다. 기본적으로 패딩은 무시됩니다. [AutoTokenizer](/docs/transformers/main/ko/model_doc/auto#transformers.AutoTokenizer)를 사용하여 인덱스를 얻을 수 있습니다. 자세한 내용은 [PreTrainedTokenizer.encode()](/docs/transformers/main/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 및 [PreTrainedTokenizer.__call__()](/docs/transformers/main/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)

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

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

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

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

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

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

**반환값:** [ProphetNetDecoderModelOutput](/docs/transformers/main/ko/model_doc/prophetnet#transformers.models.prophetnet.modeling_prophetnet.ProphetNetDecoderModelOutput) 또는 `tuple(torch.Tensor)`

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

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

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

- **last_hidden_state** (`torch.Tensor`, shape `(batch_size, decoder_sequence_length, hidden_size)`) -- 모델의 decoder 마지막 레이어 출력에서 주 스트림의 hidden-states 시퀀스입니다.

  `past_key_values`가 사용되면, `(batch_size, 1, hidden_size)` 형태의 시퀀스의 마지막 hidden-state만 출력됩니다.
- **last_hidden_state_ngram** (`torch.Tensor`, shape `(batch_size, ngram * decoder_sequence_length, config.vocab_size)`) -- 모델의 decoder 마지막 레이어 출력에서 예측 스트림의 hidden-state 시퀀스입니다.
- **past_key_values** (`Cache`, *선택 사항*, `use_cache=True`가 전달되었거나 `config.use_cache=True`인 경우 반환됨) -- [Cache](/docs/transformers/main/ko/internal/generation_utils#transformers.Cache) 인스턴스입니다. 자세한 내용은 [kv cache 가이드](https://huggingface.co/docs/transformers/en/kv_cache)를 참조하세요.

  순차적 디코딩을 가속화하기 위해 사용할 수 있는(입력 `past_key_values` 참조) 디코더의 사전 계산된 hidden-states(attention 블록의 key와 value)를 포함합니다.
- **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와 선택적 초기 임베딩 출력을 포함합니다.
- **hidden_states_ngram** (`tuple(torch.Tensor)`, *선택 사항*, `output_hidden_states=True`가 전달되었거나 `config.output_hidden_states=True`인 경우 반환됨) -- `torch.Tensor`의 튜플(임베딩 출력 1개 + 각 레이어의 출력 1개)로, 모양은 `(batch_size, ngram * decoder_sequence_length, hidden_size)`입니다.

  각 레이어의 출력에서 디코더의 predict 스트림의 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 가중치입니다.
- **ngram_attentions** (`tuple(torch.Tensor)`, *선택 사항*, `output_attentions=True`가 전달되거나 `config.output_attentions=True`인 경우 반환됨) -- 각 레이어마다 하나씩 포함된 `torch.Tensor`의 튜플로, 모양은 `(batch_size, num_attn_heads, decoder_sequence_length, decoder_sequence_length)`입니다.

  …에서 가중 평균을 계산하는 데 사용되는, 디코더의 predict 스트림의 어텐션 가중치, 어텐션 softmax 이후
- **cross_attentions** (`tuple[torch.Tensor]`, *선택*, `output_attentions=True`가 전달되거나 `config.output_attentions=True`일 때 반환) -- 각 레이어마다 하나씩 포함된 `torch.Tensor`의 튜플로, shape는 `(batch_size, num_heads, sequence_length, sequence_length)`입니다.

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

예:

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

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/prophetnet-large-uncased")
>>> model = ProphetNetDecoder.from_pretrained("microsoft/prophetnet-large-uncased", add_cross_attention=False)
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs)

>>> last_hidden_states = outputs.last_hidden_state
```

## ProphetNetForConditionalGeneration[[transformers.ProphetNetForConditionalGeneration]]

#### transformers.ProphetNetForConditionalGeneration[[transformers.ProphetNetForConditionalGeneration]]

```python
transformers.ProphetNetForConditionalGeneration(config: ProphetNetConfig)
```

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/prophetnet/modeling_prophetnet.py#L1486)

**매개변수:**

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

언어 모델링 헤드를 갖춘 ProphetNet 모델입니다. 시퀀스 생성 작업에 사용할 수 있습니다.

이 모델은 [PreTrainedModel](/docs/transformers/main/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.ProphetNetForConditionalGeneration.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, decoder_input_ids: typing.Optional[torch.Tensor] = None, decoder_attention_mask: typing.Optional[torch.BoolTensor] = None, encoder_outputs: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, decoder_inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/prophetnet/modeling_prophetnet.py#L1505)

**매개변수:**

input_ids (`torch.Tensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 어휘(input sequence tokens)의 인덱스입니다. 기본적으로 패딩은 무시됩니다. [AutoTokenizer](/docs/transformers/main/ko/model_doc/auto#transformers.AutoTokenizer)를 사용하여 인덱스를 얻을 수 있습니다. 자세한 내용은 [PreTrainedTokenizer.encode()](/docs/transformers/main/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 및 [PreTrainedTokenizer.__call__()](/docs/transformers/main/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)

decoder_input_ids (`torch.LongTensor`, shape `(batch_size, target_sequence_length)`, *선택 사항*) : 어휘에서 디코더 입력 시퀀스 토큰의 인덱스입니다. [AutoTokenizer](/docs/transformers/main/ko/model_doc/auto#transformers.AutoTokenizer)를 사용하여 인덱스를 얻을 수 있습니다. 자세한 내용은 [PreTrainedTokenizer.encode()](/docs/transformers/main/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 및 [PreTrainedTokenizer.__call__()](/docs/transformers/main/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)를 참조하세요. [디코더 입력 ID란 무엇인가요?](../glossary#decoder-input-ids) ProphetNet은 `decoder_input_ids` 생성의 시작 토큰으로 `eos_token_id`를 사용합니다. `past_key_values`를 사용하는 경우, 선택적으로 마지막 `decoder_input_ids`만 입력하면 됩니다(`past_key_values` 참조).

decoder_attention_mask (`torch.BoolTensor`, shape `(batch_size, target_sequence_length)`, *선택 사항*) : 기본 동작: `decoder_input_ids`의 pad 토큰을 무시하는 텐서를 생성합니다. 기본적으로 Causal mask도 사용됩니다.

encoder_outputs (`torch.Tensor`, *선택 사항*) : (`last_hidden_state`, *선택 사항*: `hidden_states`, *선택 사항*: `attentions`) `last_hidden_state`의 shape은 `(batch_size, sequence_length, hidden_size)`, *선택 사항*)이며, 인코더의 마지막 레이어 출력에서 생성된 hidden-states의 시퀀스입니다. 디코더의 cross-attention에 사용됩니다.

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

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

decoder_inputs_embeds (`torch.Tensor`, shape `(batch_size, target_sequence_length, hidden_size)`, *선택 사항*) : `decoder_input_ids`를 전달하는 대신 임베디드 표현을 직접 전달할 수 있습니다. `past_key_values`를 사용하는 경우, 선택적으로 마지막 `decoder_inputs_embeds`만 입력하면 됩니다(`past_key_values` 참조). 모델 내부 임베딩 조회 행렬보다 `decoder_input_ids` 인덱스를 관련 벡터로 변환하는 방식을 더 세밀하게 제어하려는 경우 유용합니다. `decoder_input_ids`와 `decoder_inputs_embeds`가 모두 설정되지 않은 경우, `decoder_inputs_embeds`는 `inputs_embeds`의 값을 취합니다.

labels (`torch.LongTensor`, shape `(batch_size,)`, *선택 사항*) : 시퀀스 분류/회귀 손실을 계산하는 데 사용되는 라벨. 인덱스는 `[-100, 0, ..., config.vocab_size - 1]` 범위에 있어야 합니다. `-100`으로 설정된 모든 라벨은 무시(마스크)되며, 손실은 `[0, ..., config.vocab_size]` 범위의 라벨에 대해서만 계산됩니다.

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

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

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

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

**반환값:** [ProphetNetSeq2SeqLMOutput](/docs/transformers/main/ko/model_doc/prophetnet#transformers.models.prophetnet.modeling_prophetnet.ProphetNetSeq2SeqLMOutput) 또는 `tuple(torch.Tensor)`

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

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

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

- **loss** (`torch.Tensor`, shape `(1,)`, *선택*, `labels`이 제공될 때 반환됨) -- 언어 모델링 손실.
- **logits** (`torch.Tensor`, shape `(batch_size, decoder_sequence_length, config.vocab_size)`) -- 메인 스트림 언어 모델링 헤드에 대한 예측 점수(SoftMax 적용 전 각 어휘 토큰의 점수).
- **logits_ngram** (`torch.Tensor`, shape `(batch_size, ngram * decoder_sequence_length, config.vocab_size)`) -- predict stream 언어 모델링 헤드에 대한 예측 점수(SoftMax 적용 전 각 어휘 토큰의 점수).
- **past_key_values** (`Cache`, *선택 사항*, `use_cache=True`가 전달되었거나 `config.use_cache=True`인 경우 반환됨) -- [Cache](/docs/transformers/main/ko/internal/generation_utils#transformers.Cache) 인스턴스입니다. 자세한 내용은 [kv cache 가이드](https://huggingface.co/docs/transformers/en/kv_cache)를 참조하세요.

  순차적 디코딩을 가속화하기 위해 사용할 수 있는(입력 `past_key_values` 참조) 디코더의 사전 계산된 hidden-states(attention 블록의 key와 value)를 포함합니다.
- **decoder_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와 초기 임베딩 출력을 더한 값.
- **decoder_ngram_hidden_states** (`tuple(torch.Tensor)`, *선택 사항*, `output_hidden_states=True`가 전달되었거나 `config.output_hidden_states=True`인 경우 반환됨) -- `torch.Tensor`의 튜플(임베딩 출력 1개 + 각 레이어의 출력 1개)로, 모양은 `(batch_size, ngram * decoder_sequence_length, hidden_size)`입니다.

  각 레이어의 출력에서 디코더의 predict 스트림의 Hidden-states와 초기 임베딩 출력을 더한 값.
- **decoder_attentions** (`tuple[torch.Tensor]`, *선택 사항*, `output_attentions=True`가 전달되거나 `config.output_attentions=True`인 경우 반환) -- 각 레이어에 하나씩, shape가 `(batch_size, num_heads, sequence_length, sequence_length)`인 `torch.Tensor` 튜플.

  self-attention 헤드에서 가중 평균을 계산하는 데 사용되는, attention softmax 이후의 decoder의 attention 가중치입니다.
- **decoder_ngram_attentions** (`tuple(torch.Tensor)`, *선택 사항*, `output_attentions=True`가 전달되었거나 `config.output_attentions=True`인 경우 반환됨) -- 각 레이어마다 하나씩 포함된 `torch.Tensor`의 튜플로, 모양은 `(batch_size, num_attn_heads, decoder_sequence_length, decoder_sequence_length)`입니다.

  디코더의 predict 스트림에서 attention softmax 이후에 self-attention 헤드에서 가중 평균을 계산하는 데 사용되는 attention 가중치입니다.
- **cross_attentions** (`tuple[torch.Tensor]`, *선택*, `output_attentions=True`가 전달되거나 `config.output_attentions=True`일 때 반환) -- 각 레이어마다 하나씩 포함된 `torch.Tensor`의 튜플로, shape는 `(batch_size, num_heads, sequence_length, sequence_length)`입니다.

  decoder의 cross-attention 레이어에서 attention softmax를 적용한 후, cross-attention 헤드에서 가중 평균을 계산하는 데 사용되는 attention 가중치입니다.
- **encoder_last_hidden_state** (`torch.Tensor`, shape `(batch_size, encoder_sequence_length, hidden_size)`, *선택 사항*) -- 모델 인코더의 마지막 레이어 출력에서 생성된 hidden-state 시퀀스입니다.
- **encoder_hidden_states** (`tuple[torch.Tensor]`, *선택 사항*, `output_hidden_states=True`가 전달되거나 `config.output_hidden_states=True`일 때 반환됩니다) -- `torch.Tensor`의 튜플 (임베딩 레이어가 있는 경우 임베딩 출력용 1개 + 각 레이어의 출력용 1개)로, shape가 `(batch_size, sequence_length, hidden_size)`입니다.

  각 레이어의 출력에서 인코더의 Hidden-states와 초기 임베딩 출력을 더한 값.
- **encoder_attentions** (`tuple[torch.Tensor]`, *선택*, `output_attentions=True`가 전달되었거나 `config.output_attentions=True`인 경우 반환) -- 각 레이어에 하나씩 포함된 `torch.Tensor` 튜플이며, shape은 `(batch_size, num_heads, sequence_length, sequence_length)`입니다.

  인코더의 어텐션 가중치입니다. 어텐션 softmax 이후에 self-attention 헤드에서 가중 평균을 계산하는 데 사용됩니다.

예:

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

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/prophetnet-large-uncased")
>>> model = ProphetNetForConditionalGeneration.from_pretrained("microsoft/prophetnet-large-uncased")

>>> input_ids = tokenizer(
...     "Studies have been shown that owning a dog is good for you", return_tensors="pt"
... ).input_ids  # Batch size 1
>>> decoder_input_ids = tokenizer("Studies show that", return_tensors="pt").input_ids  # Batch size 1
>>> outputs = model(input_ids=input_ids, decoder_input_ids=decoder_input_ids)

>>> logits_next_token = outputs.logits  # logits to predict next token as usual
>>> logits_ngram_next_tokens = outputs.logits_ngram  # logits to predict 2nd, 3rd, ... next tokens
```

## ProphetNetForCausalLM[[transformers.ProphetNetForCausalLM]]

#### transformers.ProphetNetForCausalLM[[transformers.ProphetNetForCausalLM]]

```python
transformers.ProphetNetForCausalLM(config: ProphetNetConfig)
```

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/prophetnet/modeling_prophetnet.py#L1660)

**매개변수:**

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

lm head가 위에 있는 ProphetNetModel의 독립형 decoder 부분입니다. 이 모델은 causal

이 모델은 [PreTrainedModel](/docs/transformers/main/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.ProphetNetForCausalLM.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, encoder_hidden_states: typing.Optional[torch.Tensor] = None, encoder_attention_mask: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/prophetnet/modeling_prophetnet.py#L1688)

**매개변수:**

input_ids (`torch.Tensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 어휘(input sequence tokens)의 인덱스입니다. 기본적으로 패딩은 무시됩니다. [AutoTokenizer](/docs/transformers/main/ko/model_doc/auto#transformers.AutoTokenizer)를 사용하여 인덱스를 얻을 수 있습니다. 자세한 내용은 [PreTrainedTokenizer.encode()](/docs/transformers/main/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 및 [PreTrainedTokenizer.__call__()](/docs/transformers/main/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)

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

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

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

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

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

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

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

**반환값:** [ProphetNetDecoderLMOutput](/docs/transformers/main/ko/model_doc/prophetnet#transformers.models.prophetnet.modeling_prophetnet.ProphetNetDecoderLMOutput) 또는 `tuple(torch.Tensor)`

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

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

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

- **loss** (`torch.Tensor`, shape `(1,)`, *선택*, `labels`이 제공될 때 반환됨) -- 언어 모델링 손실.
- **logits** (`torch.Tensor`, shape `(batch_size, decoder_sequence_length, config.vocab_size)`) -- 메인 스트림 언어 모델링 헤드에 대한 예측 점수(SoftMax 적용 전 각 어휘 토큰의 점수).
- **logits_ngram** (`torch.Tensor`, shape `(batch_size, ngram * decoder_sequence_length, config.vocab_size)`) -- predict stream 언어 모델링 헤드에 대한 예측 점수(SoftMax 적용 전 각 어휘 토큰의 점수).
- **past_key_values** (`Cache`, *선택 사항*, `use_cache=True`가 전달되었거나 `config.use_cache=True`인 경우 반환됨) -- [Cache](/docs/transformers/main/ko/internal/generation_utils#transformers.Cache) 인스턴스입니다. 자세한 내용은 [kv cache 가이드](https://huggingface.co/docs/transformers/en/kv_cache)를 참조하세요.

  순차적 디코딩을 가속화하기 위해 사용할 수 있는(입력 `past_key_values` 참조) 디코더의 사전 계산된 hidden-states(attention 블록의 key와 value)를 포함합니다.
- **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와 선택적 초기 임베딩 출력을 포함합니다.
- **hidden_states_ngram** (`tuple(torch.Tensor)`, *선택 사항*, `output_hidden_states=True`가 전달되었거나 `config.output_hidden_states=True`인 경우 반환됨) -- `torch.Tensor`의 튜플(임베딩 출력 1개 + 각 레이어의 출력 1개)로, 모양은 `(batch_size, ngram * decoder_sequence_length, hidden_size)`입니다.

  각 레이어의 출력에서 디코더의 predict 스트림의 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 가중치입니다.
- **ngram_attentions** (`tuple(torch.Tensor)`, *선택 사항*, `output_attentions=True`가 전달되거나 `config.output_attentions=True`인 경우 반환됨) -- 각 레이어마다 하나씩 포함된 `torch.Tensor`의 튜플로, 모양은 `(batch_size, num_attn_heads, decoder_sequence_length, decoder_sequence_length)`입니다.

  …에서 가중 평균을 계산하는 데 사용되는, 디코더의 predict 스트림의 어텐션 가중치, 어텐션 softmax 이후
- **cross_attentions** (`tuple[torch.Tensor]`, *선택*, `output_attentions=True`가 전달되거나 `config.output_attentions=True`일 때 반환) -- 각 레이어마다 하나씩 포함된 `torch.Tensor`의 튜플로, shape는 `(batch_size, num_heads, sequence_length, sequence_length)`입니다.

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

예:

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

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/prophetnet-large-uncased")
>>> model = ProphetNetForCausalLM.from_pretrained("microsoft/prophetnet-large-uncased")
>>> assert model.config.is_decoder, f"{model.__class__} has to be configured as a decoder."
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs)

>>> logits = outputs.logits

>>> # Model can also be used with EncoderDecoder framework
>>> from transformers import BertTokenizer, EncoderDecoderModel, AutoTokenizer
>>> import torch

>>> tokenizer_enc = BertTokenizer.from_pretrained("google-bert/bert-large-uncased")
>>> tokenizer_dec = AutoTokenizer.from_pretrained("microsoft/prophetnet-large-uncased")
>>> model = EncoderDecoderModel.from_encoder_decoder_pretrained(
...     "google-bert/bert-large-uncased", "microsoft/prophetnet-large-uncased"
... )

>>> ARTICLE = (
...     "the us state department said wednesday it had received no "
...     "formal word from bolivia that it was expelling the us ambassador there "
...     "but said the charges made against him are `` baseless ."
... )
>>> input_ids = tokenizer_enc(ARTICLE, return_tensors="pt").input_ids
>>> labels = tokenizer_dec(
...     "us rejects charges against its ambassador in bolivia", return_tensors="pt"
... ).input_ids
>>> outputs = model(input_ids=input_ids, decoder_input_ids=labels[:, :-1], labels=labels[:, 1:])

>>> loss = outputs.loss
```