Transformers 文件
ProphetNet
並獲得增強的文件體驗
開始使用
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 中提出。
ProphetNet 是一個編碼器-解碼器模型，可以為“n-gram”語言建模預測 n 個未來的詞元（token），而不僅僅是下一個詞元。
論文摘要如下：
在本文中，我們提出了一種新的序列到序列預訓練模型，名為 ProphetNet，它引入了一種新穎的自監督目標——未來 n-gram 預測，以及所提出的 n-stream 自注意力機制。與傳統序列到序列模型中最佳化一步預測不同，ProphetNet 透過 n 步預測進行最佳化，即在每個時間步根據之前的上下文詞元同時預測接下來的 n 個詞元。未來 n-gram 預測明確鼓勵模型為未來的詞元進行規劃，並防止對強區域性相關性過擬合。我們分別使用基礎規模資料集（16GB）和大規模資料集（160GB）對 ProphetNet 進行預訓練。然後，我們在 CNN/DailyMail、Gigaword 和 SQuAD 1.1 基準上進行了摘要生成和問題生成任務的實驗。實驗結果表明，與使用相同規模預訓練語料庫的模型相比，ProphetNet 在所有這些資料集上都取得了新的最佳結果。
作者的程式碼可以在這裡找到。
使用技巧
- ProphetNet 是一個使用絕對位置嵌入的模型，因此通常建議在輸入的右側而不是左側進行填充。
- 該模型架構基於原始的 Transformer，但在解碼器中用主自注意力機制以及自注意力和 n-stream（預測）自注意力機制取代了“標準”的自注意力機制。
資源
ProphetNetConfig
class transformers.ProphetNetConfig
< 源 >( activation_dropout: typing.Optional[float] = 0.1 activation_function: typing.Union[str, typing.Callable, NoneType] = 'gelu' vocab_size: typing.Optional[int] = 30522 hidden_size: typing.Optional[int] = 1024 encoder_ffn_dim: typing.Optional[int] = 4096 num_encoder_layers: typing.Optional[int] = 12 num_encoder_attention_heads: typing.Optional[int] = 16 decoder_ffn_dim: typing.Optional[int] = 4096 num_decoder_layers: typing.Optional[int] = 12 num_decoder_attention_heads: typing.Optional[int] = 16 attention_dropout: typing.Optional[float] = 0.1 dropout: typing.Optional[float] = 0.1 max_position_embeddings: typing.Optional[int] = 512 init_std: typing.Optional[float] = 0.02 is_encoder_decoder: typing.Optional[bool] = True add_cross_attention: typing.Optional[bool] = True decoder_start_token_id: typing.Optional[int] = 0 ngram: typing.Optional[int] = 2 num_buckets: typing.Optional[int] = 32 relative_max_distance: typing.Optional[int] = 128 disable_ngram_loss: typing.Optional[bool] = False eps: typing.Optional[float] = 0.0 use_cache: typing.Optional[bool] = True pad_token_id: typing.Optional[int] = 0 bos_token_id: typing.Optional[int] = 1 eos_token_id: typing.Optional[int] = 2 **kwargs )
引數
- activation_dropout (
float, 可選, 預設為 0.1) — 全連線層內啟用函式的 dropout 比率。 - activation_function (
str或function, 可選, 預設為"gelu") — 編碼器和池化層中的非線性啟用函式（函式或字串）。如果為字串，支援"gelu"、"relu"、"silu"和"gelu_new"。 - vocab_size (
int, 可選, 預設為 30522) — ProphetNET 模型的詞彙表大小。定義了呼叫 ProphetNetModel 時傳入的inputs_ids可以表示的不同詞元的數量。 - hidden_size (
int, 可選, 預設為 1024) — 層和池化層的維度。 - encoder_ffn_dim (
int, 可選, 預設為 4096) — 解碼器中“中間”（通常稱為前饋）層的維度。 - num_encoder_layers (
int, 可選, 預設為 12) — 編碼器層數。 - num_encoder_attention_heads (
int, 可選, 預設為 16) — Transformer 編碼器中每個注意力層的注意力頭數量。 - decoder_ffn_dim (
int, 可選, 預設為 4096) — 解碼器中“中間”（通常稱為前饋）層的維度。 - num_decoder_layers (
int, 可選, 預設為 12) — 解碼器層數。 - num_decoder_attention_heads (
int, 可選, 預設為 16) — Transformer 解碼器中每個注意力層的注意力頭數量。 - attention_dropout (
float, 可選, 預設為 0.1) — 注意力機率的 dropout 比率。 - dropout (
float, 可選, 預設為 0.1) — 嵌入層、編碼器和池化層中所有全連線層的 dropout 機率。 - max_position_embeddings (
int, 可選, 預設為 512) — 此模型可能使用的最大序列長度。通常將其設定為較大的值以防萬一（例如 512、1024 或 2048）。 - init_std (
float, 可選, 預設為 0.02) — 用於初始化所有權重矩陣的 truncated_normal_initializer 的標準差。 - add_cross_attention (
bool, 可選, 預設為True) — 是否應向模型新增交叉注意力層。 - is_encoder_decoder (
bool, 可選, 預設為True) — 這是否是一個編碼器/解碼器模型。 - pad_token_id (
int, 可選, 預設為 1) — 填充詞元的 ID。 - bos_token_id (
int, 可選, 預設為 0) — 序列開始詞元的 ID。 - eos_token_id (
int, 可選, 預設為 2) — 序列結束詞元的 ID。 - ngram (
int, 可選, 預設為 2) — 要預測的未來詞元數量。設定為 1 則與傳統語言模型相同，只預測下一個詞元。 - num_buckets (
int, 可選, 預設為 32) — 每個注意力層使用的桶數。用於相對位置計算。更多細節請參閱 [T5 論文](請參閱 https://huggingface.co/papers/1910.10683)。 - relative_max_distance (
int, 可選, 預設為 128) — 大於此值的相對距離將被放入最後一個相同的桶中。用於相對位置計算。更多細節請參閱 [T5 論文](請參閱 https://huggingface.co/papers/1910.10683)。 - disable_ngram_loss (
bool, 可選, 預設為False) — 是否僅透過預測下一個詞元進行訓練。 - eps (
float, 可選, 預設為 0.0) — 控制損失計算中標籤平滑的epsilon引數值。如果設定為 0，則不執行標籤平滑。 - use_cache (
bool, optional, defaults toTrue) — 模型是否應返回最後一個鍵/值注意力（並非所有模型都使用）。
這是用於儲存 ProphetNetModel 配置的配置類。它根據指定的引數例項化 ProphetNet 模型，定義模型架構。使用預設值例項化配置將產生與 ProphetNet microsoft/prophetnet-large-uncased 架構相似的配置。
配置物件繼承自 PretrainedConfig，可用於控制模型輸出。有關更多資訊，請閱讀 PretrainedConfig 的文件。
ProphetNetTokenizer
class transformers.ProphetNetTokenizer
< source >( vocab_file: str do_lower_case: typing.Optional[bool] = True do_basic_tokenize: typing.Optional[bool] = True never_split: typing.Optional[collections.abc.Iterable] = None unk_token: typing.Optional[str] = '[UNK]' sep_token: typing.Optional[str] = '[SEP]' x_sep_token: typing.Optional[str] = '[X_SEP]' pad_token: typing.Optional[str] = '[PAD]' mask_token: typing.Optional[str] = '[MASK]' tokenize_chinese_chars: typing.Optional[bool] = True strip_accents: typing.Optional[bool] = None clean_up_tokenization_spaces: bool = True **kwargs )
引數
- vocab_file (
str) — 包含詞彙表的檔案。 - do_lower_case (
bool, optional, defaults toTrue) — 是否在分詞時將輸入轉換為小寫。 - do_basic_tokenize (
bool, optional, defaults toTrue) — 是否在 WordPiece 之前進行基本分詞。 - never_split (
Iterable, optional) — 在分詞過程中永遠不會被分割的詞元集合。僅在 `do_basic_tokenize=True` 時生效。 - unk_token (
str, optional, defaults to"[UNK]") — 未知詞元。不在詞彙表中的詞元無法轉換為 ID，將被設定為此詞元。 - sep_token (
str, optional, defaults to"[SEP]") — 分隔符詞元，用於從多個序列構建一個序列，例如用於序列分類的兩個序列，或用於問答的文字和問題。它也用作使用特殊詞元構建的序列的最後一個詞元。 - x_sep_token (
str, optional, defaults to"[X_SEP]") — 特殊的第二個分隔符詞元，可由 ProphetNetForConditionalGeneration 生成。它用於在摘要任務中分隔專案符號式的句子，例如。 - pad_token (
str, optional, defaults to"[PAD]") — 用於填充的詞元，例如在批處理不同長度的序列時使用。 - mask_token (
str, optional, defaults to"[MASK]") — 用於掩碼值的詞元。這是在使用掩碼語言建模訓練此模型時使用的詞元。這是模型將嘗試預測的詞元。 - tokenize_chinese_chars (
bool, optional, defaults toTrue) — 是否對中文字元進行分詞。對於日語，此選項可能應被停用（請參閱此問題）。
- strip_accents (
bool, optional) — 是否去除所有重音符號。如果未指定此選項，則將由 `lowercase` 的值確定（與原始 BERT 一樣）。 - clean_up_tokenization_spaces (
bool, optional, defaults toTrue) — 是否在解碼後清理空格，清理包括移除可能的多餘空格等偽影。
構建一個 ProphetNetTokenizer。基於 WordPiece。
此分詞器繼承自 PreTrainedTokenizer，其中包含大多數主要方法。使用者應參考此超類以獲取有關這些方法的更多資訊。
build_inputs_with_special_tokens
< source >( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None ) → List[int]
透過連線和新增特殊標記，從一個序列或一對序列構建用於序列分類任務的模型輸入。BERT 序列的格式如下：
- 單個序列：
[CLS] X [SEP] - 序列對：
[CLS] A [SEP] B [SEP]
將標記序列（字串）轉換為單個字串。
get_special_tokens_mask
< source >( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None already_has_special_tokens: typing.Optional[bool] = False ) → List[int]
從沒有新增特殊標記的標記列表中檢索序列ID。此方法在使用分詞器prepare_for_model方法新增特殊標記時呼叫。
ProphetNet 特定輸出
class transformers.models.prophetnet.modeling_prophetnet.ProphetNetSeq2SeqLMOutput
< source >( loss: typing.Optional[torch.FloatTensor] = None logits: typing.Optional[torch.FloatTensor] = None logits_ngram: typing.Optional[torch.FloatTensor] = None past_key_values: typing.Optional[tuple[torch.FloatTensor]] = None decoder_hidden_states: typing.Optional[tuple[torch.FloatTensor]] = None decoder_ngram_hidden_states: typing.Optional[tuple[torch.FloatTensor]] = None decoder_attentions: typing.Optional[tuple[torch.FloatTensor]] = None decoder_ngram_attentions: typing.Optional[tuple[torch.FloatTensor]] = None cross_attentions: typing.Optional[tuple[torch.FloatTensor]] = None encoder_last_hidden_state: typing.Optional[torch.FloatTensor] = None encoder_hidden_states: typing.Optional[tuple[torch.FloatTensor]] = None encoder_attentions: typing.Optional[tuple[torch.FloatTensor]] = None )
引數
- loss (
torch.FloatTensorof shape(1,), optional, returned whenlabelsis provided) — 語言建模損失。 - logits (
torch.FloatTensorof shape(batch_size, decoder_sequence_length, config.vocab_size)) — 主流語言建模頭的預測分數（SoftMax 前每個詞彙詞元的分數）。 - logits_ngram (
torch.FloatTensorof shape(batch_size, ngram * decoder_sequence_length, config.vocab_size)) — 預測流語言建模頭的預測分數（SoftMax 前每個詞彙詞元的分數）。 - past_key_values (
list[torch.FloatTensor], optional, returned whenuse_cache=Trueis passed or whenconfig.use_cache=True) — 長度為 `config.n_layers` 的 `torch.FloatTensor` 列表，每個張量的形狀為 `(2, batch_size, num_attn_heads, decoder_sequence_length, embed_size_per_head)`。包含解碼器注意力塊中預先計算的隱藏狀態（鍵和值），可用於（參見 `past_key_values` 輸入）加速序列解碼。
- decoder_hidden_states (
tuple[torch.FloatTensor], optional, returned whenoutput_hidden_states=Trueis passed or whenconfig.output_hidden_states=True) — `torch.FloatTensor` 的元組（如果模型有嵌入層，則一個用於嵌入層的輸出，+ 每個層的輸出一個），形狀為 `(batch_size, sequence_length, hidden_size)`。解碼器在每個層輸出的隱藏狀態以及初始嵌入輸出。
- decoder_ngram_hidden_states (
tuple(torch.FloatTensor), optional, returned whenoutput_hidden_states=Trueis passed or whenconfig.output_hidden_states=True) — `torch.FloatTensor` 的元組（一個用於嵌入層的輸出 + 每個層的輸出一個），形狀為 `(batch_size, ngram * decoder_sequence_length, hidden_size)`。解碼器預測流在每個層輸出的隱藏狀態以及初始嵌入輸出。
- decoder_attentions (
tuple[torch.FloatTensor], optional, returned whenoutput_attentions=Trueis passed or whenconfig.output_attentions=True) — `torch.FloatTensor` 的元組（每層一個），形狀為 `(batch_size, num_heads, sequence_length, sequence_length)`。解碼器的注意力權重，經過注意力 softmax 後，用於在自注意力頭中計算加權平均值。
- decoder_ngram_attentions (
tuple(torch.FloatTensor), optional, returned whenoutput_attentions=Trueis passed or whenconfig.output_attentions=True) — `torch.FloatTensor` 的元組（每層一個），形狀為 `(batch_size, num_attn_heads, decoder_sequence_length, decoder_sequence_length)`。解碼器預測流的注意力權重，經過注意力 softmax 後，用於在自注意力頭中計算加權平均值。
- cross_attentions (
tuple[torch.FloatTensor], optional, returned whenoutput_attentions=Trueis passed or whenconfig.output_attentions=True) — `torch.FloatTensor` 的元組（每層一個），形狀為 `(batch_size, num_heads, sequence_length, sequence_length)`。解碼器交叉注意力層的注意力權重，經過注意力 softmax 後，用於在交叉注意力頭中計算加權平均值。
- encoder_last_hidden_state (
torch.FloatTensorof shape(batch_size, encoder_sequence_length, hidden_size), optional) — 模型編碼器最後一層輸出的隱藏狀態序列。 - encoder_hidden_states (
tuple[torch.FloatTensor], optional, returned whenoutput_hidden_states=Trueis passed or whenconfig.output_hidden_states=True) — `torch.FloatTensor` 的元組（如果模型有嵌入層，則一個用於嵌入層的輸出，+ 每個層的輸出一個），形狀為 `(batch_size, sequence_length, hidden_size)`。編碼器在每個層輸出的隱藏狀態以及初始嵌入輸出。
- encoder_attentions (
tuple[torch.FloatTensor], optional, returned whenoutput_attentions=Trueis passed or whenconfig.output_attentions=True) — `torch.FloatTensor` 的元組（每層一個），形狀為 `(batch_size, num_heads, sequence_length, sequence_length)`。編碼器的注意力權重，經過注意力 softmax 後，用於在自注意力頭中計算加權平均值。
序列到序列語言模型輸出的基類。
class transformers.models.prophetnet.modeling_prophetnet.ProphetNetSeq2SeqModelOutput
< source >( last_hidden_state: FloatTensor last_hidden_state_ngram: typing.Optional[torch.FloatTensor] = None past_key_values: typing.Optional[tuple[torch.FloatTensor]] = None decoder_hidden_states: typing.Optional[tuple[torch.FloatTensor]] = None decoder_ngram_hidden_states: typing.Optional[tuple[torch.FloatTensor]] = None decoder_attentions: typing.Optional[tuple[torch.FloatTensor]] = None decoder_ngram_attentions: typing.Optional[tuple[torch.FloatTensor]] = None cross_attentions: typing.Optional[tuple[torch.FloatTensor]] = None encoder_last_hidden_state: typing.Optional[torch.FloatTensor] = None encoder_hidden_states: typing.Optional[tuple[torch.FloatTensor]] = None encoder_attentions: typing.Optional[tuple[torch.FloatTensor]] = None )
引數
- last_hidden_state (
torch.FloatTensorof shape(batch_size, decoder_sequence_length, hidden_size)) — 模型解碼器最後一層輸出的主流隱藏狀態序列。如果使用 `past_key_values`，則只輸出形狀為 `(batch_size, 1, hidden_size)` 的序列的最後一個隱藏狀態。
- last_hidden_state_ngram (
torch.FloatTensorof shape(batch_size,ngram * decoder_sequence_length, config.vocab_size), optional) — 模型解碼器最後一層輸出的預測流隱藏狀態序列。 - past_key_values (
list[torch.FloatTensor], optional, returned whenuse_cache=Trueis passed or whenconfig.use_cache=True) — 長度為 `config.n_layers` 的 `torch.FloatTensor` 列表，每個張量的形狀為 `(2, batch_size, num_attn_heads, decoder_sequence_length, embed_size_per_head)`。包含解碼器注意力塊中預先計算的隱藏狀態（鍵和值），可用於（參見 `past_key_values` 輸入）加速序列解碼。
- decoder_hidden_states (
tuple[torch.FloatTensor], optional, returned whenoutput_hidden_states=Trueis passed or whenconfig.output_hidden_states=True) — `torch.FloatTensor` 的元組（如果模型有嵌入層，則一個用於嵌入層的輸出，+ 每個層的輸出一個），形狀為 `(batch_size, sequence_length, hidden_size)`。解碼器在每個層輸出的隱藏狀態以及初始嵌入輸出。
- decoder_ngram_hidden_states (
tuple(torch.FloatTensor), 可選, 當傳遞output_hidden_states=True或config.output_hidden_states=True時返回) —torch.FloatTensor的元組（一個用於嵌入層的輸出，另一個用於每層的輸出），形狀為(batch_size, ngram * decoder_sequence_length, hidden_size)。解碼器預測流在每層輸出處的隱藏狀態，以及初始的嵌入輸出。
- decoder_attentions (
tuple[torch.FloatTensor], 可選, 當傳遞output_attentions=True或config.output_attentions=True時返回) —torch.FloatTensor的元組（每層一個），形狀為(batch_size, num_heads, sequence_length, sequence_length)。解碼器的注意力權重，經過注意力 softmax 之後，用於在自注意力頭中計算加權平均值。
- decoder_ngram_attentions (
tuple(torch.FloatTensor), 可選, 當傳遞output_attentions=True或config.output_attentions=True時返回) —torch.FloatTensor的元組（每層一個），形狀為(batch_size, num_attn_heads, decoder_sequence_length, decoder_sequence_length)。解碼器預測流的注意力權重，經過注意力 softmax 之後，用於計算加權平均值。
- cross_attentions (
tuple[torch.FloatTensor], 可選, 當傳遞output_attentions=True或config.output_attentions=True時返回) —torch.FloatTensor的元組（每層一個），形狀為(batch_size, num_heads, sequence_length, sequence_length)。解碼器交叉注意力層的注意力權重，經過注意力 softmax 之後，用於在交叉注意力頭中計算加權平均值。
- encoder_last_hidden_state (
torch.FloatTensor, 形狀為(batch_size, encoder_sequence_length, hidden_size), 可選) — 模型編碼器最後一層輸出的隱藏狀態序列。 - encoder_hidden_states (
tuple[torch.FloatTensor], 可選, 當傳遞output_hidden_states=True或config.output_hidden_states=True時返回) —torch.FloatTensor的元組（如果模型有嵌入層，則一個用於嵌入層的輸出，+ 每層一個輸出），形狀為(batch_size, sequence_length, hidden_size)。編碼器在每層輸出處的隱藏狀態，以及初始的嵌入輸出。
- encoder_attentions (
tuple[torch.FloatTensor], 可選, 當傳遞output_attentions=True或config.output_attentions=True時返回) —torch.FloatTensor的元組（每層一個），形狀為(batch_size, num_heads, sequence_length, sequence_length)。編碼器的注意力權重，經過注意力 softmax 之後，用於在自注意力頭中計算加權平均值。
模型編碼器輸出的基類，也包含：可加速順序解碼的預計算隱藏狀態。
class transformers.models.prophetnet.modeling_prophetnet.ProphetNetDecoderModelOutput
< 原始碼 >( last_hidden_state: FloatTensor last_hidden_state_ngram: typing.Optional[torch.FloatTensor] = None past_key_values: typing.Optional[tuple[torch.FloatTensor]] = None hidden_states: typing.Optional[tuple[torch.FloatTensor]] = None hidden_states_ngram: typing.Optional[tuple[torch.FloatTensor]] = None attentions: typing.Optional[tuple[torch.FloatTensor]] = None ngram_attentions: typing.Optional[tuple[torch.FloatTensor]] = None cross_attentions: typing.Optional[tuple[torch.FloatTensor]] = None )
引數
- last_hidden_state (
torch.FloatTensor, 形狀為(batch_size, decoder_sequence_length, hidden_size)) — 模型解碼器最後一層輸出的主流隱藏狀態序列。如果使用
past_key_values，則只輸出形狀為(batch_size, 1, hidden_size)的序列的最後一個隱藏狀態。 - last_hidden_state_ngram (
torch.FloatTensor, 形狀為(batch_size, ngram * decoder_sequence_length, config.vocab_size)) — 模型解碼器最後一層輸出的預測流隱藏狀態序列。 - past_key_values (
list[torch.FloatTensor], 可選, 當傳遞use_cache=True或config.use_cache=True時返回) — 長度為config.n_layers的torch.FloatTensor列表，其中每個張量的形狀為(2, batch_size, num_attn_heads, decoder_sequence_length, embed_size_per_head)。包含預先計算的解碼器隱藏狀態（注意力塊中的鍵和值），可用於（參見
past_key_values輸入）加速序列解碼。 - hidden_states (
tuple[torch.FloatTensor], 可選, 當傳遞output_hidden_states=True或config.output_hidden_states=True時返回) —torch.FloatTensor的元組（如果模型有嵌入層，則一個用於嵌入層的輸出，+ 每層一個輸出），形狀為(batch_size, sequence_length, hidden_size)。模型在每層輸出處的隱藏狀態，以及可選的初始嵌入輸出。
- hidden_states_ngram (
tuple(torch.FloatTensor), 可選, 當傳遞output_hidden_states=True或config.output_hidden_states=True時返回) —torch.FloatTensor的元組（一個用於嵌入層的輸出，另一個用於每層的輸出），形狀為(batch_size, ngram * decoder_sequence_length, hidden_size)。解碼器預測流在每層輸出處的隱藏狀態，以及初始的嵌入輸出。
- attentions (
tuple[torch.FloatTensor], 可選, 當傳遞output_attentions=True或config.output_attentions=True時返回) —torch.FloatTensor的元組（每層一個），形狀為(batch_size, num_heads, sequence_length, sequence_length)。經過注意力 softmax 之後的注意力權重，用於在自注意力頭中計算加權平均值。
- ngram_attentions (
tuple(torch.FloatTensor), 可選, 當傳遞output_attentions=True或config.output_attentions=True時返回) —torch.FloatTensor的元組（每層一個），形狀為(batch_size, num_attn_heads, decoder_sequence_length, decoder_sequence_length)。解碼器預測流的注意力權重，經過注意力 softmax 之後，用於計算加權平均值。
- cross_attentions (
tuple[torch.FloatTensor], 可選, 當傳遞output_attentions=True或config.output_attentions=True時返回) —torch.FloatTensor的元組（每層一個），形狀為(batch_size, num_heads, sequence_length, sequence_length)。解碼器交叉注意力層的注意力權重，經過注意力 softmax 之後，用於在交叉注意力頭中計算加權平均值。
模型輸出的基類，也可能包含過去的鍵/值（以加速順序解碼）。
class transformers.models.prophetnet.modeling_prophetnet.ProphetNetDecoderLMOutput
< 原始碼 >( loss: typing.Optional[torch.FloatTensor] = None logits: typing.Optional[torch.FloatTensor] = None logits_ngram: typing.Optional[torch.FloatTensor] = None past_key_values: typing.Optional[tuple[torch.FloatTensor]] = None hidden_states: typing.Optional[tuple[torch.FloatTensor]] = None hidden_states_ngram: typing.Optional[tuple[torch.FloatTensor]] = None attentions: typing.Optional[tuple[torch.FloatTensor]] = None ngram_attentions: typing.Optional[tuple[torch.FloatTensor]] = None cross_attentions: typing.Optional[tuple[torch.FloatTensor]] = None )
引數
- loss (
torch.FloatTensor, 形狀為(1,), 可選, 當提供了labels時返回) — 語言建模損失。 - logits (
torch.FloatTensor, 形狀為(batch_size, decoder_sequence_length, config.vocab_size)) — 主流語言建模頭的預測分數（在 SoftMax 之前每個詞彙表標記的分數）。 - logits_ngram (
torch.FloatTensor, 形狀為(batch_size, ngram * decoder_sequence_length, config.vocab_size)) — 預測流語言建模頭的預測分數（在 SoftMax 之前每個詞彙表標記的分數）。 - past_key_values (
list[torch.FloatTensor], 可選, 當傳遞use_cache=True或config.use_cache=True時返回) — 長度為config.n_layers的torch.FloatTensor列表，其中每個張量的形狀為(2, batch_size, num_attn_heads, decoder_sequence_length, embed_size_per_head)。包含預先計算的解碼器隱藏狀態（注意力塊中的鍵和值），可用於（參見
past_key_values輸入）加速序列解碼。 - hidden_states (
tuple[torch.FloatTensor], 可選, 當傳遞output_hidden_states=True或config.output_hidden_states=True時返回) —torch.FloatTensor的元組（如果模型有嵌入層，則一個用於嵌入層的輸出，+ 每層一個輸出），形狀為(batch_size, sequence_length, hidden_size)。模型在每層輸出處的隱藏狀態，以及可選的初始嵌入輸出。
- hidden_states_ngram (
tuple(torch.FloatTensor), 可選, 當傳遞output_hidden_states=True或config.output_hidden_states=True時返回) —torch.FloatTensor的元組（一個用於嵌入層的輸出，另一個用於每層的輸出），形狀為(batch_size, ngram * decoder_sequence_length, hidden_size)。解碼器預測流在每層輸出處的隱藏狀態，以及初始的嵌入輸出。
- attentions (
tuple[torch.FloatTensor], 可選, 當傳遞output_attentions=True或config.output_attentions=True時返回) —torch.FloatTensor的元組（每層一個），形狀為(batch_size, num_heads, sequence_length, sequence_length)。經過注意力 softmax 之後的注意力權重，用於在自注意力頭中計算加權平均值。
- ngram_attentions (
tuple(torch.FloatTensor), 可選, 當傳遞output_attentions=True或config.output_attentions=True時返回) —torch.FloatTensor的元組（每層一個），形狀為(batch_size, num_attn_heads, decoder_sequence_length, decoder_sequence_length)。解碼器預測流的注意力權重，經過注意力 softmax 之後，用於計算加權平均值。
- cross_attentions (
tuple[torch.FloatTensor], 可選, 當傳遞output_attentions=True或config.output_attentions=True時返回) —torch.FloatTensor的元組（每層一個），形狀為(batch_size, num_heads, sequence_length, sequence_length)。解碼器交叉注意力層的注意力權重，經過注意力 softmax 之後，用於在交叉注意力頭中計算加權平均值。
模型輸出的基類，也可能包含過去的鍵/值（以加速順序解碼）。
ProphetNetModel
class transformers.ProphetNetModel
< 原始碼 >( config: ProphetNetConfig )
引數
- config (ProphetNetConfig) — 模型配置類，包含模型的所有引數。使用配置檔案初始化不會載入與模型相關的權重，只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。
基礎的 ProphetNet 模型，輸出原始的隱藏狀態，頂部沒有任何特定的頭。
該模型繼承自 PreTrainedModel。檢視超類文件以瞭解庫為所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪頭等）。
該模型也是一個 PyTorch torch.nn.Module 子類。可以像常規的 PyTorch 模組一樣使用它，並參考 PyTorch 文件瞭解所有與通用用法和行為相關的事項。
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 head_mask: typing.Optional[torch.Tensor] = None decoder_head_mask: typing.Optional[torch.Tensor] = None cross_attn_head_mask: typing.Optional[torch.Tensor] = None encoder_outputs: typing.Optional[tuple] = None past_key_values: typing.Optional[tuple[tuple[torch.Tensor]]] = None inputs_embeds: typing.Optional[torch.Tensor] = None decoder_inputs_embeds: typing.Optional[torch.Tensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.models.prophetnet.modeling_prophetnet.ProphetNetSeq2SeqModelOutput 或 tuple(torch.FloatTensor)
引數
- input_ids (
torch.Tensor, 形狀為(batch_size, sequence_length), 可選) — 詞彙表中輸入序列標記的索引。預設情況下，填充將被忽略。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor, 形狀為(batch_size, sequence_length), 可選) — 用於避免對填充標記索引執行注意力的掩碼。掩碼值在[0, 1]中選擇：- 1 表示標記未被遮蓋，
- 0 表示標記已被遮蓋。
- decoder_input_ids (
torch.LongTensor, 形狀為(batch_size, target_sequence_length), 可選) — 詞彙表中解碼器輸入序列標記的索引。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
ProphetNet 使用
eos_token_id作為生成decoder_input_ids的起始標記。如果使用past_key_values，可以選擇只輸入最後的decoder_input_ids（參見past_key_values）。 - decoder_attention_mask (
torch.BoolTensor, 形狀為(batch_size, target_sequence_length), 可選) — 預設行為：生成一個忽略decoder_input_ids中填充標記的張量。預設情況下也會使用因果掩碼。 - head_mask (
torch.Tensor, 形狀為(num_heads,)或(num_layers, num_heads), 可選) — 用於置零自注意力模組中選定頭的掩碼。掩碼值在[0, 1]中選擇：- 1 表示頭未被遮蓋，
- 0 表示頭已被遮蓋。
- decoder_head_mask (
torch.Tensor, 形狀為(decoder_layers, decoder_attention_heads), 可選) — 用於置零解碼器中注意力模組選定頭的掩碼。掩碼值在[0, 1]中選擇：- 1 表示頭未被遮蓋，
- 0 表示頭已被遮蓋。
- cross_attn_head_mask (
torch.Tensor, 形狀為(decoder_layers, decoder_attention_heads), 可選) — 用於置零交叉注意力模組中選定頭的掩碼。掩碼值在[0, 1]中選擇：- 1 表示頭未被遮蓋，
- 0 表示頭已被遮蓋。
- encoder_outputs (
tuple, 可選) — 元組包含 (last_hidden_state, 可選:hidden_states, 可選:attentions)last_hidden_state的形狀為(batch_size, sequence_length, hidden_size)，可選）是編碼器最後一層輸出的隱藏狀態序列。用於解碼器的交叉注意力。 - past_key_values (
tuple[tuple[torch.Tensor]], 可選) — 預先計算的隱藏狀態（自注意力塊和交叉注意力塊中的鍵和值），可用於加速序列解碼。這通常包括模型在解碼的先前階段返回的past_key_values，當use_cache=True或config.use_cache=True時。允許兩種格式：
- 一個 Cache 例項，請參閱我們的 kv 快取指南；
- 長度為
config.n_layers的tuple(torch.FloatTensor)的元組，每個元組包含 2 個形狀為(batch_size, num_heads, sequence_length, embed_size_per_head)的張量。這也稱為舊版快取格式。
模型將輸出與輸入相同的快取格式。如果未傳遞
past_key_values，將返回舊版快取格式。如果使用
past_key_values，使用者可以選擇只輸入最後的input_ids（那些沒有提供其過去鍵值狀態給此模型的 ID），形狀為(batch_size, 1)，而不是所有形狀為(batch_size, sequence_length)的input_ids。 - inputs_embeds (
torch.Tensor, 形狀為(batch_size, sequence_length, hidden_size), 可選) — 可選地，您可以選擇直接傳遞嵌入表示，而不是傳遞input_ids。如果您希望比模型的內部嵌入查詢矩陣更多地控制如何將input_ids索引轉換為關聯向量，這將非常有用。 - decoder_inputs_embeds (
torch.Tensor, 形狀為(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。 - return_dict (
bool, 可選) — 是否返回一個 ModelOutput 物件，而不是一個普通的元組。
返回
transformers.models.prophetnet.modeling_prophetnet.ProphetNetSeq2SeqModelOutput 或 tuple(torch.FloatTensor)
一個 transformers.models.prophetnet.modeling_prophetnet.ProphetNetSeq2SeqModelOutput 或一個 torch.FloatTensor 的元組（如果傳入 return_dict=False 或 config.return_dict=False），包含根據配置（ProphetNetConfig）和輸入決定的各種元素。
-
last_hidden_state (
torch.FloatTensor，形狀為(batch_size, decoder_sequence_length, hidden_size)) — 模型解碼器最後一層輸出的主流（main stream）隱藏狀態序列。如果使用了
past_key_values，則只輸出形狀為(batch_size, 1, hidden_size)的序列的最後一個隱藏狀態。 -
last_hidden_state_ngram (
torch.FloatTensor，形狀為(batch_size,ngram * decoder_sequence_length, config.vocab_size), 可選) — 模型解碼器最後一層輸出的預測流（predict stream）隱藏狀態序列。 -
past_key_values (
list[torch.FloatTensor], 可選，當傳入use_cache=True或config.use_cache=True時返回) — 長度為config.n_layers的torch.FloatTensor列表，其中每個張量的形狀為(2, batch_size, num_attn_heads, decoder_sequence_length, embed_size_per_head)。包含解碼器注意力塊的預計算隱藏狀態（鍵和值），可用於（參見
past_key_values輸入）加速順序解碼。 -
decoder_hidden_states (
tuple[torch.FloatTensor], 可選，當傳入output_hidden_states=True或config.output_hidden_states=True時返回) —torch.FloatTensor的元組（如果模型有嵌入層，則第一個是嵌入層的輸出，之後是每一層的輸出），形狀為(batch_size, sequence_length, hidden_size)。解碼器在每一層輸出時的隱藏狀態以及初始嵌入輸出。
-
decoder_ngram_hidden_states (
tuple(torch.FloatTensor), 可選，當傳入output_hidden_states=True或config.output_hidden_states=True時返回) —torch.FloatTensor的元組（第一個是嵌入層的輸出，之後是每一層的輸出），形狀為(batch_size, ngram * decoder_sequence_length, hidden_size)。解碼器預測流在每一層輸出的隱藏狀態，加上初始的嵌入輸出。
-
decoder_attentions (
tuple[torch.FloatTensor], 可選，當傳入output_attentions=True或config.output_attentions=True時返回) —torch.FloatTensor的元組（每一層一個），形狀為(batch_size, num_heads, sequence_length, sequence_length)。解碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均。
-
decoder_ngram_attentions (
tuple(torch.FloatTensor), 可選，當傳入output_attentions=True或config.output_attentions=True時返回) —torch.FloatTensor的元組（每一層一個），形狀為(batch_size, num_attn_heads, decoder_sequence_length, decoder_sequence_length)。解碼器預測流的注意力權重，經過注意力 softmax 之後，用於計算加權平均值。
-
cross_attentions (
tuple[torch.FloatTensor], 可選，當傳入output_attentions=True或config.output_attentions=True時返回) —torch.FloatTensor的元組（每一層一個），形狀為(batch_size, num_heads, sequence_length, sequence_length)。解碼器交叉注意力層的注意力權重，在注意力 softmax 之後，用於計算交叉注意力頭中的加權平均。
-
encoder_last_hidden_state (
torch.FloatTensor，形狀為(batch_size, encoder_sequence_length, hidden_size), 可選) — 模型編碼器最後一層輸出的隱藏狀態序列。 -
encoder_hidden_states (
tuple[torch.FloatTensor], 可選，當傳入output_hidden_states=True或config.output_hidden_states=True時返回) —torch.FloatTensor的元組（如果模型有嵌入層，則第一個是嵌入層的輸出，之後是每一層的輸出），形狀為(batch_size, sequence_length, hidden_size)。編碼器在每一層輸出時的隱藏狀態以及初始嵌入輸出。
-
encoder_attentions (
tuple[torch.FloatTensor], 可選，當傳入output_attentions=True或config.output_attentions=True時返回) —torch.FloatTensor的元組（每一層一個），形狀為(batch_size, num_heads, sequence_length, sequence_length)。編碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均。
ProphetNetModel 的 forward 方法重寫了 __call__ 特殊方法。
雖然前向傳播的邏輯需要在這個函式中定義，但之後應該呼叫 `Module` 例項而不是這個函式，因為前者會處理前處理和後處理步驟，而後者會靜默地忽略它們。
示例
>>> 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 statesProphetNetEncoder
class transformers.ProphetNetEncoder
< 來源 >( config: ProphetNetConfig word_embeddings: Embedding = None )
引數
- config (ProphetNetConfig) — 包含模型所有引數的模型配置類。使用配置檔案初始化不會載入與模型相關的權重，只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。
- word_embeddings (
torch.nn.Embeddings，形狀為(config.vocab_size, config.hidden_size), 可選) — 詞嵌入引數。這可用於使用預定義的詞嵌入初始化 ProphetNetEncoder，而不是隨機初始化的詞嵌入。
ProphetNetModel 的獨立編碼器部分。
該模型繼承自 PreTrainedModel。檢視超類文件以瞭解庫為所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪頭等）。
該模型也是一個 PyTorch torch.nn.Module 子類。可以像常規的 PyTorch 模組一樣使用它，並參考 PyTorch 文件瞭解所有與通用用法和行為相關的事項。
forward
< 來源 >( input_ids: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None head_mask: typing.Optional[torch.Tensor] = None inputs_embeds: typing.Optional[torch.Tensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.modeling_outputs.BaseModelOutput 或 tuple(torch.FloatTensor)
引數
- input_ids (
torch.Tensor，形狀為(batch_size, sequence_length), 可選) — 詞彙表中輸入序列詞元的索引。預設情況下，填充（Padding）將被忽略。索引可以使用 AutoTokenizer 獲得。詳情請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor，形狀為(batch_size, sequence_length), 可選) — 用於避免對填充詞元索引執行注意力的掩碼。掩碼值選自[0, 1]：- 1 表示詞元未被掩碼，
- 0 表示詞元被掩碼。
- head_mask (
torch.Tensor，形狀為(num_heads,)或(num_layers, num_heads), 可選) — 用於使自注意力模組中選定的頭無效的掩碼。掩碼值選自[0, 1]：- 1 表示頭未被掩碼，
- 0 表示頭被掩碼。
- inputs_embeds (
torch.Tensor，形狀為(batch_size, sequence_length, hidden_size), 可選) — 可選地，你可以不傳遞input_ids，而是直接傳遞一個嵌入表示。這在你想要對如何將input_ids索引轉換為相關向量進行更多控制時很有用，而不是使用模型的內部嵌入查詢矩陣。 - output_attentions (
bool, 可選) — 是否返回所有注意力層的注意力張量。更多細節請參見返回張量下的 `attentions`。 - output_hidden_states (
bool, 可選) — 是否返回所有層的隱藏狀態。更多細節請參見返回張量下的 `hidden_states`。 - return_dict (
bool, 可選) — 是否返回一個 ModelOutput 物件，而不是一個普通的元組。
返回
transformers.modeling_outputs.BaseModelOutput 或 tuple(torch.FloatTensor)
一個 transformers.modeling_outputs.BaseModelOutput 或一個 torch.FloatTensor 的元組（如果傳入 return_dict=False 或 config.return_dict=False），包含根據配置（ProphetNetConfig）和輸入決定的各種元素。
-
last_hidden_state (
torch.FloatTensor, 形狀為(batch_size, sequence_length, hidden_size)) — 模型最後一層輸出的隱藏狀態序列。 -
hidden_states (
tuple(torch.FloatTensor), 可選，當傳入output_hidden_states=True或config.output_hidden_states=True時返回) —torch.FloatTensor的元組（如果模型有嵌入層，則第一個是嵌入層的輸出，之後是每一層的輸出），形狀為(batch_size, sequence_length, hidden_size)。模型在每個層輸出的隱藏狀態以及可選的初始嵌入輸出。
-
attentions (
tuple(torch.FloatTensor), 可選，當傳入output_attentions=True或config.output_attentions=True時返回) —torch.FloatTensor的元組（每一層一個），形狀為(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 後的注意力權重，用於計算自注意力頭中的加權平均值。
ProphetNetEncoder 的 forward 方法重寫了 __call__ 特殊方法。
雖然前向傳播的邏輯需要在這個函式中定義，但之後應該呼叫 `Module` 例項而不是這個函式，因為前者會處理前處理和後處理步驟，而後者會靜默地忽略它們。
示例
>>> 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_stateProphetNetDecoder
class transformers.ProphetNetDecoder
< 來源 >( config: ProphetNetConfig word_embeddings: typing.Optional[torch.nn.modules.sparse.Embedding] = None )
引數
- config (ProphetNetConfig) — 包含模型所有引數的模型配置類。使用配置檔案初始化不會載入與模型相關的權重，只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。
- word_embeddings (
torch.nn.Embeddings，形狀為(config.vocab_size, config.hidden_size), 可選) — 詞嵌入引數。這可用於使用預定義的詞嵌入初始化 ProphetNetEncoder，而不是隨機初始化的詞嵌入。
ProphetNetModel 的獨立解碼器部分。
該模型繼承自 PreTrainedModel。檢視超類文件以瞭解庫為所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪頭等）。
該模型也是一個 PyTorch torch.nn.Module 子類。可以像常規的 PyTorch 模組一樣使用它，並參考 PyTorch 文件瞭解所有與通用用法和行為相關的事項。
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 head_mask: typing.Optional[torch.Tensor] = None cross_attn_head_mask: typing.Optional[torch.Tensor] = None past_key_values: typing.Optional[tuple[tuple[torch.Tensor]]] = None inputs_embeds: typing.Optional[torch.Tensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.models.prophetnet.modeling_prophetnet.ProphetNetDecoderModelOutput 或 tuple(torch.FloatTensor)
引數
- input_ids (
torch.Tensor，形狀為(batch_size, sequence_length), 可選) — 詞彙表中輸入序列詞元的索引。預設情況下，填充（Padding）將被忽略。索引可以使用 AutoTokenizer 獲得。詳情請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor，形狀為(batch_size, sequence_length), 可選) — 用於避免對填充詞元索引執行注意力的掩碼。掩碼值選自[0, 1]：- 1 表示詞元未被掩碼，
- 0 表示詞元被掩碼。
- encoder_hidden_states (
torch.Tensor，形狀為(batch_size, sequence_length, hidden_size), 可選) — 編碼器最後一層輸出的隱藏狀態序列。如果模型被配置為解碼器，則在交叉注意力中使用。 - encoder_attention_mask (
torch.Tensor，形狀為(batch_size, sequence_length), 可選) — 用於避免對編碼器輸入的填充詞元索引執行注意力的掩碼。如果模型被配置為解碼器，則此掩碼用於交叉注意力。掩碼值選自[0, 1]：- 1 表示詞元未被掩碼，
- 0 表示詞元被掩碼。
- head_mask (
torch.Tensor，形狀為(num_heads,)或(num_layers, num_heads), 可選) — 用於使自注意力模組中選定的頭無效的掩碼。掩碼值選自[0, 1]：- 1 表示頭未被掩碼，
- 0 表示頭被掩碼。
- cross_attn_head_mask (
torch.Tensor，形狀為(decoder_layers, decoder_attention_heads), 可選) — 用於使交叉注意力模組中選定的頭無效的掩碼。掩碼值選自[0, 1]：- 1 表示頭未被掩碼，
- 0 表示頭被掩碼。
- past_key_values (
tuple[tuple[torch.Tensor]], 可選) — 預先計算的隱藏狀態（自注意力塊和交叉注意力塊中的鍵和值），可用於加速序列解碼。這通常包括模型在解碼的先前階段返回的 `past_key_values`，當 `use_cache=True` 或 `config.use_cache=True` 時。允許兩種格式：
- 一個 Cache 例項，請參閱我們的 kv 快取指南；
- 長度為 `config.n_layers` 的 `tuple(torch.FloatTensor)` 元組，其中每個元組包含 2 個形狀為 `(batch_size, num_heads, sequence_length, embed_size_per_head)` 的張量。這也稱為舊版快取格式。
模型將輸出與輸入相同的快取格式。如果沒有傳遞 `past_key_values`，將返回舊版快取格式。
如果使用 `past_key_values`，使用者可以選擇只輸入最後一個 `input_ids`（那些沒有為其提供過去鍵值狀態的 `input_ids`），形狀為 `(batch_size, 1)`，而不是所有形狀為 `(batch_size, sequence_length)` 的 `input_ids`。
- inputs_embeds (
torch.Tensor，形狀為(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`。 - return_dict (
bool, 可選) — 是否返回一個 ModelOutput 物件，而不是一個普通的元組。
返回
transformers.models.prophetnet.modeling_prophetnet.ProphetNetDecoderModelOutput 或 tuple(torch.FloatTensor)
一個 transformers.models.prophetnet.modeling_prophetnet.ProphetNetDecoderModelOutput 或一個 torch.FloatTensor 的元組（如果傳入 return_dict=False 或 config.return_dict=False），包含根據配置（ProphetNetConfig）和輸入決定的各種元素。
-
last_hidden_state (
torch.FloatTensor，形狀為(batch_size, decoder_sequence_length, hidden_size)) — 模型解碼器最後一層輸出的主流（main stream）隱藏狀態序列。如果使用了
past_key_values，則只輸出形狀為(batch_size, 1, hidden_size)的序列的最後一個隱藏狀態。 -
last_hidden_state_ngram (
torch.FloatTensor，形狀為(batch_size, ngram * decoder_sequence_length, config.vocab_size)) — 模型解碼器最後一層輸出的預測流（predict stream）隱藏狀態序列。 -
past_key_values (
list[torch.FloatTensor], 可選，當傳入use_cache=True或config.use_cache=True時返回) — 長度為config.n_layers的torch.FloatTensor列表，其中每個張量的形狀為(2, batch_size, num_attn_heads, decoder_sequence_length, embed_size_per_head)。包含解碼器注意力塊的預計算隱藏狀態（鍵和值），可用於（參見
past_key_values輸入）加速順序解碼。 -
hidden_states (
tuple[torch.FloatTensor], 可選，當傳入output_hidden_states=True或config.output_hidden_states=True時返回) —torch.FloatTensor的元組（如果模型有嵌入層，則第一個是嵌入層的輸出，之後是每一層的輸出），形狀為(batch_size, sequence_length, hidden_size)。模型在每個層輸出的隱藏狀態以及可選的初始嵌入輸出。
-
hidden_states_ngram (
tuple(torch.FloatTensor), 可選，當傳入output_hidden_states=True或config.output_hidden_states=True時返回) —torch.FloatTensor的元組（第一個是嵌入層的輸出，之後是每一層的輸出），形狀為(batch_size, ngram * decoder_sequence_length, hidden_size)。解碼器預測流在每一層輸出的隱藏狀態，加上初始的嵌入輸出。
-
attentions (
tuple[torch.FloatTensor], 可選，當傳入output_attentions=True或config.output_attentions=True時返回) —torch.FloatTensor的元組（每一層一個），形狀為(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 後的注意力權重，用於計算自注意力頭中的加權平均值。
-
ngram_attentions (
tuple(torch.FloatTensor), 可選，當傳入output_attentions=True或config.output_attentions=True時返回) —torch.FloatTensor的元組（每一層一個），形狀為(batch_size, num_attn_heads, decoder_sequence_length, decoder_sequence_length)。解碼器預測流的注意力權重，經過注意力 softmax 之後，用於計算加權平均值。
-
cross_attentions (
tuple[torch.FloatTensor], 可選，當傳入output_attentions=True或config.output_attentions=True時返回) —torch.FloatTensor的元組（每一層一個），形狀為(batch_size, num_heads, sequence_length, sequence_length)。解碼器交叉注意力層的注意力權重，在注意力 softmax 之後，用於計算交叉注意力頭中的加權平均。
ProphetNetDecoder 的 forward 方法重寫了 __call__ 特殊方法。
雖然前向傳播的邏輯需要在這個函式中定義，但之後應該呼叫 `Module` 例項而不是這個函式，因為前者會處理前處理和後處理步驟，而後者會靜默地忽略它們。
示例
>>> 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_stateProphetNetForConditionalGeneration
class transformers.ProphetNetForConditionalGeneration
< 來源 >( config: ProphetNetConfig )
引數
- config (ProphetNetConfig) — 包含模型所有引數的模型配置類。使用配置檔案初始化不會載入與模型相關的權重，只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。
帶有語言建模頭的 ProphetNet 模型。可用於序列生成任務。
該模型繼承自 PreTrainedModel。檢視超類文件以瞭解庫為所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪頭等）。
該模型也是一個 PyTorch torch.nn.Module 子類。可以像常規的 PyTorch 模組一樣使用它，並參考 PyTorch 文件瞭解所有與通用用法和行為相關的事項。
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 head_mask: typing.Optional[torch.Tensor] = None decoder_head_mask: typing.Optional[torch.Tensor] = None cross_attn_head_mask: typing.Optional[torch.Tensor] = None encoder_outputs: typing.Optional[torch.Tensor] = None past_key_values: typing.Optional[tuple[tuple[torch.Tensor]]] = None inputs_embeds: typing.Optional[torch.Tensor] = None decoder_inputs_embeds: typing.Optional[torch.Tensor] = None labels: typing.Optional[torch.Tensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.models.prophetnet.modeling_prophetnet.ProphetNetSeq2SeqLMOutput 或 tuple(torch.FloatTensor)
引數
- input_ids (
torch.Tensor，形狀為(batch_size, sequence_length), 可選) — 詞彙表中輸入序列詞元的索引。預設情況下，填充（Padding）將被忽略。索引可以使用 AutoTokenizer 獲得。詳情請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor，形狀為(batch_size, sequence_length), 可選) — 用於避免對填充詞元索引執行注意力的掩碼。掩碼值選自[0, 1]：- 1 表示詞元未被掩碼，
- 0 表示詞元被掩碼。
- decoder_input_ids (
torch.LongTensor，形狀為(batch_size, target_sequence_length), 可選) — 詞彙表中解碼器輸入序列詞元的索引。索引可以使用 AutoTokenizer 獲得。詳情請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
ProphetNet 使用 `eos_token_id` 作為 `decoder_input_ids` 生成的起始詞元。如果使用 `past_key_values`，可以選擇只輸入最後一個 `decoder_input_ids`（參見 `past_key_values`）。
- decoder_attention_mask (
torch.BoolTensor，形狀為(batch_size, target_sequence_length), 可選) — 預設行為：生成一個忽略 `decoder_input_ids` 中填充詞元的張量。預設情況下也會使用因果掩碼。 - head_mask (
torch.Tensor，形狀為(num_heads,)或(num_layers, num_heads), 可選) — 用於使自注意力模組中選定的頭無效的掩碼。掩碼值選自[0, 1]：- 1 表示頭未被掩碼，
- 0 表示頭被掩碼。
- decoder_head_mask (
torch.Tensor，形狀為(decoder_layers, decoder_attention_heads), 可選) — 用於使解碼器中注意力模組選定的頭無效的掩碼。掩碼值選自[0, 1]：- 1 表示頭未被掩碼，
- 0 表示頭被掩碼。
- cross_attn_head_mask (
torch.Tensor，形狀為(decoder_layers, decoder_attention_heads), 可選) — 用於使交叉注意力模組中選定的頭無效的掩碼。掩碼值選自[0, 1]：- 1 表示頭未被掩碼，
- 0 表示頭被掩碼。
- encoder_outputs (
torch.Tensor, 可選) — 元組包含（`last_hidden_state`, 可選: `hidden_states`, 可選: `attentions`）`last_hidden_state` 形狀為 `(batch_size, sequence_length, hidden_size)`，可選）是編碼器最後一層輸出的隱藏狀態序列。用於解碼器的交叉注意力。 - past_key_values (
tuple[tuple[torch.Tensor]], 可選) — 預計算的隱藏狀態（自注意力塊和交叉注意力塊中的鍵和值），可用於加速序列解碼。這通常包含在解碼的前一個階段，當 `use_cache=True` 或 `config.use_cache=True` 時，模型返回的 `past_key_values`。允許兩種格式：
- Cache 例項，請參閱我們的 kv 快取指南；
- 長度為 `config.n_layers` 的 `tuple(torch.FloatTensor)` 元組，每個元組包含 2 個形狀為 `(batch_size, num_heads, sequence_length, embed_size_per_head)` 的張量）。這也稱為舊版快取格式。
模型將輸出與輸入相同的快取格式。如果沒有傳遞 `past_key_values`，將返回舊版快取格式。
如果使用 `past_key_values`，使用者可以選擇只輸入最後一個 `input_ids`（那些沒有將其過去的鍵值狀態提供給此模型的 `input_ids`），形狀為 `(batch_size, 1)`，而不是所有形狀為 `(batch_size, sequence_length)` 的 `input_ids`。
- inputs_embeds (形狀為 `(batch_size, sequence_length, hidden_size)` 的 `torch.Tensor`，可選) — 可選地，你可以選擇直接傳遞嵌入表示，而不是傳遞 `input_ids`。如果你想比模型內部的嵌入查詢矩陣更好地控制如何將 `input_ids` 索引轉換為關聯向量，這會很有用。
- decoder_inputs_embeds (形狀為 `(batch_size, target_sequence_length, hidden_size)` 的 `torch.Tensor`，可選) — 可選地，你可以選擇直接傳遞嵌入表示，而不是傳遞 `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 (形狀為 `(batch_size,)` 的 `torch.LongTensor`，可選) — 用於計算序列分類/迴歸損失的標籤。索引應在 `[-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`。
- return_dict (`bool`, 可選) — 是否返回一個 ModelOutput 而不是一個普通的元組。
返回
transformers.models.prophetnet.modeling_prophetnet.ProphetNetSeq2SeqLMOutput 或 tuple(torch.FloatTensor)
一個 transformers.models.prophetnet.modeling_prophetnet.ProphetNetSeq2SeqLMOutput 或一個 `torch.FloatTensor` 的元組（如果傳遞了 `return_dict=False` 或 `config.return_dict=False`），根據配置 (ProphetNetConfig) 和輸入，包含各種元素。
-
loss (
torch.FloatTensor，形狀為(1,)，可選，當提供labels時返回) — 語言建模損失。 -
logits (形狀為 `(batch_size, decoder_sequence_length, config.vocab_size)` 的 `torch.FloatTensor`) — 主流語言建模頭的預測分數（SoftMax 之前的每個詞彙標記的分數）。
-
logits_ngram (形狀為 `(batch_size, ngram * decoder_sequence_length, config.vocab_size)` 的 `torch.FloatTensor`) — 預測流語言建模頭的預測分數（SoftMax 之前的每個詞彙標記的分數）。
-
past_key_values (
list[torch.FloatTensor], 可選，當傳入use_cache=True或config.use_cache=True時返回) — 長度為config.n_layers的torch.FloatTensor列表，其中每個張量的形狀為(2, batch_size, num_attn_heads, decoder_sequence_length, embed_size_per_head)。包含解碼器注意力塊的預計算隱藏狀態（鍵和值），可用於（參見
past_key_values輸入）加速順序解碼。 -
decoder_hidden_states (
tuple[torch.FloatTensor], 可選，當傳入output_hidden_states=True或config.output_hidden_states=True時返回) —torch.FloatTensor的元組（如果模型有嵌入層，則第一個是嵌入層的輸出，之後是每一層的輸出），形狀為(batch_size, sequence_length, hidden_size)。解碼器在每一層輸出時的隱藏狀態以及初始嵌入輸出。
-
decoder_ngram_hidden_states (
tuple(torch.FloatTensor), 可選，當傳入output_hidden_states=True或config.output_hidden_states=True時返回) —torch.FloatTensor的元組（第一個是嵌入層的輸出，之後是每一層的輸出），形狀為(batch_size, ngram * decoder_sequence_length, hidden_size)。解碼器預測流在每一層輸出的隱藏狀態，加上初始的嵌入輸出。
-
decoder_attentions (
tuple[torch.FloatTensor], 可選，當傳入output_attentions=True或config.output_attentions=True時返回) —torch.FloatTensor的元組（每一層一個），形狀為(batch_size, num_heads, sequence_length, sequence_length)。解碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均。
-
decoder_ngram_attentions (
tuple(torch.FloatTensor), 可選，當傳入output_attentions=True或config.output_attentions=True時返回) —torch.FloatTensor的元組（每一層一個），形狀為(batch_size, num_attn_heads, decoder_sequence_length, decoder_sequence_length)。解碼器預測流的注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均值。
-
cross_attentions (
tuple[torch.FloatTensor], 可選，當傳入output_attentions=True或config.output_attentions=True時返回) —torch.FloatTensor的元組（每一層一個），形狀為(batch_size, num_heads, sequence_length, sequence_length)。解碼器交叉注意力層的注意力權重，在注意力 softmax 之後，用於計算交叉注意力頭中的加權平均。
-
encoder_last_hidden_state (
torch.FloatTensor，形狀為(batch_size, encoder_sequence_length, hidden_size), 可選) — 模型編碼器最後一層輸出的隱藏狀態序列。 -
encoder_hidden_states (
tuple[torch.FloatTensor], 可選，當傳入output_hidden_states=True或config.output_hidden_states=True時返回) —torch.FloatTensor的元組（如果模型有嵌入層，則第一個是嵌入層的輸出，之後是每一層的輸出），形狀為(batch_size, sequence_length, hidden_size)。編碼器在每一層輸出時的隱藏狀態以及初始嵌入輸出。
-
encoder_attentions (
tuple[torch.FloatTensor], 可選，當傳入output_attentions=True或config.output_attentions=True時返回) —torch.FloatTensor的元組（每一層一個），形狀為(batch_size, num_heads, sequence_length, sequence_length)。編碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均。
ProphetNetForConditionalGeneration 的 forward 方法，覆蓋了 `__call__` 特殊方法。
雖然前向傳播的邏輯需要在這個函式中定義，但之後應該呼叫 `Module` 例項而不是這個函式，因為前者會處理前處理和後處理步驟，而後者會靜默地忽略它們。
示例
>>> 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 tokensProphetNetForCausalLM
class transformers.ProphetNetForCausalLM
< 原始碼 >( config: ProphetNetConfig )
引數
- config (ProphetNetConfig) — 包含模型所有引數的模型配置類。使用配置檔案進行初始化不會載入與模型關聯的權重，只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。
ProphetNetModel 的獨立解碼器部分，頂部帶有一個 lm 頭。該模型可用於因果
該模型繼承自 PreTrainedModel。檢視超類文件以瞭解庫為所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪頭等）。
該模型也是一個 PyTorch torch.nn.Module 子類。可以像常規的 PyTorch 模組一樣使用它，並參考 PyTorch 文件瞭解所有與通用用法和行為相關的事項。
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 head_mask: typing.Optional[torch.Tensor] = None cross_attn_head_mask: typing.Optional[torch.Tensor] = None past_key_values: typing.Optional[tuple[tuple[torch.Tensor]]] = None inputs_embeds: typing.Optional[torch.Tensor] = None labels: typing.Optional[torch.Tensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.models.prophetnet.modeling_prophetnet.ProphetNetDecoderLMOutput 或 tuple(torch.FloatTensor)
引數
- input_ids (形狀為 `(batch_size, sequence_length)` 的 `torch.Tensor`，可選) — 詞彙表中輸入序列標記的索引。預設情況下將忽略填充。
可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (形狀為 `(batch_size, sequence_length)` 的 `torch.Tensor`，可選) — 用於避免對填充標記索引執行注意力的掩碼。掩碼值在 `[0, 1]` 中選擇：
- 1 表示標記未被遮蔽，
- 0 表示標記被遮蔽。
- encoder_hidden_states (形狀為 `(batch_size, sequence_length, hidden_size)` 的 `torch.Tensor`，可選) — 編碼器最後一層輸出的隱藏狀態序列。如果模型被配置為解碼器，則在交叉注意力中使用。
- encoder_attention_mask (形狀為 `(batch_size, sequence_length)` 的 `torch.Tensor`，可選) — 用於避免對編碼器輸入的填充標記索引執行注意力的掩碼。如果模型被配置為解碼器，則在交叉注意力中使用此掩碼。掩碼值在 `[0, 1]` 中選擇：
- 1 表示標記未被遮蔽，
- 0 表示標記被遮蔽。
- head_mask (形狀為 `(num_heads,)` 或 `(num_layers, num_heads)` 的 `torch.Tensor`，可選) — 用於置零自注意力模組中選定頭的掩碼。掩碼值在 `[0, 1]` 中選擇：
- 1 表示頭未被遮蔽，
- 0 表示頭被遮蔽。
- cross_attn_head_mask (形狀為 `(decoder_layers, decoder_attention_heads)` 的 `torch.Tensor`，可選) — 用於置零交叉注意力模組中選定頭的掩碼。掩碼值在 `[0, 1]` 中選擇：
- 1 表示頭未被遮蔽，
- 0 表示頭被遮蔽。
- past_key_values (
tuple[tuple[torch.Tensor]], 可選) — 預計算的隱藏狀態（自注意力塊和交叉注意力塊中的鍵和值），可用於加速序列解碼。這通常包含在解碼的前一個階段，當 `use_cache=True` 或 `config.use_cache=True` 時，模型返回的 `past_key_values`。允許兩種格式：
- Cache 例項，請參閱我們的 kv 快取指南；
- 長度為 `config.n_layers` 的 `tuple(torch.FloatTensor)` 元組，每個元組包含 2 個形狀為 `(batch_size, num_heads, sequence_length, embed_size_per_head)` 的張量）。這也稱為舊版快取格式。
模型將輸出與輸入相同的快取格式。如果沒有傳遞 `past_key_values`，將返回舊版快取格式。
如果使用 `past_key_values`，使用者可以選擇只輸入最後一個 `input_ids`（那些沒有將其過去的鍵值狀態提供給此模型的 `input_ids`），形狀為 `(batch_size, 1)`，而不是所有形狀為 `(batch_size, sequence_length)` 的 `input_ids`。
- inputs_embeds (形狀為 `(batch_size, sequence_length, hidden_size)` 的 `torch.Tensor`，可選) — 可選地，你可以選擇直接傳遞嵌入表示，而不是傳遞 `input_ids`。如果你想比模型內部的嵌入查詢矩陣更好地控制如何將 `input_ids` 索引轉換為關聯向量，這會很有用。
- labels (形狀為 `(batch_size, sequence_length)` 的 `torch.LongTensor`，可選) — 用於計算從左到右語言建模損失（下一個詞預測）的標籤。索引應在 `[-100, 0, ..., config.vocab_size]` 範圍內（參見 `input_ids` 文件字串）。索引設定為 `-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`。
- return_dict (`bool`, 可選) — 是否返回一個 ModelOutput 而不是一個普通的元組。
返回
transformers.models.prophetnet.modeling_prophetnet.ProphetNetDecoderLMOutput 或 tuple(torch.FloatTensor)
一個 transformers.models.prophetnet.modeling_prophetnet.ProphetNetDecoderLMOutput 或一個 `torch.FloatTensor` 的元組（如果傳遞了 `return_dict=False` 或 `config.return_dict=False`），根據配置 (ProphetNetConfig) 和輸入，包含各種元素。
-
loss (
torch.FloatTensor，形狀為(1,)，可選，當提供labels時返回) — 語言建模損失。 -
logits (形狀為 `(batch_size, decoder_sequence_length, config.vocab_size)` 的 `torch.FloatTensor`) — 主流語言建模頭的預測分數（SoftMax 之前的每個詞彙標記的分數）。
-
logits_ngram (形狀為 `(batch_size, ngram * decoder_sequence_length, config.vocab_size)` 的 `torch.FloatTensor`) — 預測流語言建模頭的預測分數（SoftMax 之前的每個詞彙標記的分數）。
-
past_key_values (
list[torch.FloatTensor], 可選，當傳入use_cache=True或config.use_cache=True時返回) — 長度為config.n_layers的torch.FloatTensor列表，其中每個張量的形狀為(2, batch_size, num_attn_heads, decoder_sequence_length, embed_size_per_head)。包含解碼器注意力塊的預計算隱藏狀態（鍵和值），可用於（參見
past_key_values輸入）加速順序解碼。 -
hidden_states (
tuple[torch.FloatTensor], 可選，當傳入output_hidden_states=True或config.output_hidden_states=True時返回) —torch.FloatTensor的元組（如果模型有嵌入層，則第一個是嵌入層的輸出，之後是每一層的輸出），形狀為(batch_size, sequence_length, hidden_size)。模型在每個層輸出的隱藏狀態以及可選的初始嵌入輸出。
-
hidden_states_ngram (
tuple(torch.FloatTensor), 可選，當傳入output_hidden_states=True或config.output_hidden_states=True時返回) —torch.FloatTensor的元組（第一個是嵌入層的輸出，之後是每一層的輸出），形狀為(batch_size, ngram * decoder_sequence_length, hidden_size)。解碼器預測流在每一層輸出的隱藏狀態，加上初始的嵌入輸出。
-
attentions (
tuple[torch.FloatTensor], 可選，當傳入output_attentions=True或config.output_attentions=True時返回) —torch.FloatTensor的元組（每一層一個），形狀為(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 後的注意力權重，用於計算自注意力頭中的加權平均值。
-
ngram_attentions (
tuple(torch.FloatTensor), 可選，當傳入output_attentions=True或config.output_attentions=True時返回) —torch.FloatTensor的元組（每一層一個），形狀為(batch_size, num_attn_heads, decoder_sequence_length, decoder_sequence_length)。解碼器預測流的注意力權重，經過注意力 softmax 之後，用於計算加權平均值。
-
cross_attentions (
tuple[torch.FloatTensor], 可選，當傳入output_attentions=True或config.output_attentions=True時返回) —torch.FloatTensor的元組（每一層一個），形狀為(batch_size, num_heads, sequence_length, sequence_length)。解碼器交叉注意力層的注意力權重，在注意力 softmax 之後，用於計算交叉注意力頭中的加權平均。
ProphetNetForCausalLM 的 forward 方法，覆蓋了 `__call__` 特殊方法。
雖然前向傳播的邏輯需要在這個函式中定義，但之後應該呼叫 `Module` 例項而不是這個函式，因為前者會處理前處理和後處理步驟，而後者會靜默地忽略它們。
示例
>>> 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