Hugging Face 的 LOGO

Transformers 文件

Transformer XL

Hugging Face's logo
加入 Hugging Face 社群

並獲得增強的文件體驗

開始使用

Transformer XL

PyTorch TensorFlow

此模型僅處於維護模式，因此我們不會接受任何更改其程式碼的新 PR。此模型由於與 pickle.load 相關的安全問題而被棄用。

我們建議切換到更新的模型以提高安全性。

如果您仍然希望在實驗中使用 TransfoXL，我們建議使用帶特定修訂版本的 Hub 檢查點，以確保您從 Hub 下載的檔案是安全的。

您需要將環境變數 TRUST_REMOTE_CODE 設定為 True 以允許使用 pickle.load()

import os
from transformers import TransfoXLTokenizer, TransfoXLLMHeadModel

os.environ["TRUST_REMOTE_CODE"] = "True"

checkpoint = 'transfo-xl/transfo-xl-wt103'
revision = '40a186da79458c9f9de846edfaea79c412137f97'

tokenizer = TransfoXLTokenizer.from_pretrained(checkpoint, revision=revision)
model = TransfoXLLMHeadModel.from_pretrained(checkpoint, revision=revision)

如果您在執行此模型時遇到任何問題，請重新安裝支援此模型的最後一個版本：v4.35.0。您可以透過執行以下命令來執行此操作：pip install -U transformers==4.35.0。

Models Spaces

概述

Transformer-XL 模型由 Zihang Dai、Zhilin Yang、Yiming Yang、Jaime Carbonell、Quoc V. Le、Ruslan Salakhutdinov 在 Transformer-XL: 超越固定長度上下文的注意力語言模型中提出。它是一個具有相對位置（正弦）嵌入的因果（單向）Transformer，可以重用先前計算的隱藏狀態來關注更長的上下文（記憶體）。此模型還使用自適應 softmax 輸入和輸出（繫結）。

論文摘要如下：

Transformer 有學習長期依賴的潛力，但在語言建模設定中受限於固定長度的上下文。我們提出了一種新穎的神經架構 Transformer-XL，它可以在不破壞時間連貫性的情況下學習超出固定長度的依賴關係。它由段級遞迴機制和新穎的位置編碼方案組成。我們的方法不僅能夠捕獲更長的依賴關係，而且還解決了上下文碎片問題。因此，Transformer-XL 學習的依賴關係比 RNN 長 80%，比普通 Transformer 長 450%，在短序列和長序列上都取得了更好的效能，並且在評估期間比普通 Transformer 快 1800+ 倍。值得注意的是，我們將 enwiki8 上的 bpc/困惑度提升到 0.99，text8 上提升到 1.08，WikiText-103 上提升到 18.3，One Billion Word 上提升到 21.8，Penn Treebank 上提升到 54.5（未經微調）。僅在 WikiText-103 上訓練時，Transformer-XL 能夠生成具有數千個標記的合理連貫的新穎文字文章。

此模型由 thomwolf 貢獻。原始程式碼可在此處找到。

使用技巧

  • Transformer-XL 使用相對正弦位置嵌入。填充可以在左側或右側進行。原始實現在 SQuAD 上使用左側填充進行訓練，因此填充預設為左側。
  • Transformer-XL 是少數沒有序列長度限制的模型之一。
  • 與常規 GPT 模型相同，但引入了兩個連續段的遞迴機制（類似於具有兩個連續輸入的常規 RNN）。在此上下文中，一個段是可能跨越多個文件的連續標記（例如 512）的數量，並且段按順序輸入到模型中。
  • 基本上，前一個段的隱藏狀態與當前輸入連線起來，以計算注意力分數。這允許模型關注前一個段以及當前段中的資訊。透過堆疊多個注意力層，感受野可以增加到多個以前的段。
  • 這將位置嵌入更改為位置相對嵌入（因為常規位置嵌入在給定位置的當前輸入和當前隱藏狀態中將產生相同的結果），並且需要對注意力分數的計算方式進行一些調整。

由於 PyTorch 中的一個錯誤，TransformerXL 不支援 torch.nn.DataParallel，請參閱問題 #36035

資源

TransfoXLConfig

class transformers.TransfoXLConfig

< >

( vocab_size = 267735 cutoffs = [20000, 40000, 200000] d_model = 1024 d_embed = 1024 n_head = 16 d_head = 64 d_inner = 4096 div_val = 4 pre_lnorm = False n_layer = 18 mem_len = 1600 clamp_len = 1000 same_length = True proj_share_all_but_first = True attn_type = 0 sample_softmax = -1 adaptive = True dropout = 0.1 dropatt = 0.0 untie_r = True init = 'normal' init_range = 0.01 proj_init_std = 0.01 init_std = 0.02 layer_norm_epsilon = 1e-05 eos_token_id = 0 **kwargs )

引數

  • vocab_size (int, 可選, 預設為 267735) — BERT 模型的詞彙量。定義了在呼叫 TransfoXLModel 或 TFTransfoXLModel 時可以透過 inputs_ids 表示的不同標記的數量。
  • cutoffs (list[int], 可選, 預設為 [20000, 40000, 200000]) — 自適應 softmax 的截止點。
  • d_model (int, 可選, 預設為 1024) — 模型隱藏狀態的維度。
  • d_embed (int, 可選, 預設為 1024) — 嵌入的維度
  • n_head (int, 可選, 預設為 16) — Transformer 編碼器中每個注意力層的注意力頭數量。
  • d_head (int, 可選, 預設為 64) — 模型頭的維度。
  • d_inner (int, 可選, 預設為 4096) — FF 中的內部維度
  • div_val (int, 可選, 預設為 4) — 自適應輸入和 softmax 的除數。
  • pre_lnorm (boolean, 可選, 預設為 False) — 是否在塊中對輸入而不是輸出應用 LayerNorm。
  • n_layer (int, 可選, 預設為 18) — Transformer 編碼器中隱藏層的數量。
  • mem_len (int, 可選, 預設為 1600) — 保留的先前頭的長度。
  • clamp_len (int, 可選, 預設為 1000) — clamp_len 後使用相同的 pos 嵌入。
  • same_length (boolean, 可選, 預設為 True) — 是否對所有標記使用相同的 attn 長度。
  • proj_share_all_but_first (boolean, 可選, 預設為 True) — True 為共享除第一個之外的所有 projs，False 為不共享。
  • attn_type (int, 可選, 預設為 0) — 注意力型別。0 表示 Transformer-XL，1 表示 Shaw et al，2 表示 Vaswani et al，3 表示 Al Rfou et al。
  • sample_softmax (int, 可選, 預設為 -1) — 抽樣 softmax 中的樣本數量。
  • adaptive (boolean, 可選, 預設為 True) — 是否使用自適應 softmax。
  • dropout (float, 可選, 預設為 0.1) — 嵌入、編碼器和池化器中所有全連線層的 dropout 機率。
  • dropatt (float, 可選, 預設為 0.0) — 注意力機率的 dropout 比率。
  • untie_r (boolean, 可選, 預設為 True) — 是否不解綁相對位置偏差。
  • init (str, 可選, 預設為 "normal") — 要使用的引數初始化器。
  • init_range (float, 可選, 預設為 0.01) — U(-init_range, init_range) 初始化的引數。
  • proj_init_std (float, 可選, 預設為 0.01) — N(0, init_std) 初始化的引數。
  • init_std (float, 可選, 預設為 0.02) — N(0, init_std) 初始化的引數。
  • layer_norm_epsilon (float, 可選, 預設為 1e-05) — 層歸一化層中使用的 epsilon。
  • eos_token_id (int, 可選, 預設為 0) — 流結束符的 ID。

這是一個配置類，用於儲存 TransfoXLModel 或 TFTransfoXLModel 的配置。它用於根據指定引數例項化 Transformer-XL 模型，定義模型架構。使用預設值例項化配置將生成與 TransfoXL transfo-xl/transfo-xl-wt103 架構相似的配置。

配置物件繼承自 PretrainedConfig，可用於控制模型輸出。有關詳細資訊，請參閱 PretrainedConfig 的文件。

示例

>>> from transformers import TransfoXLConfig, TransfoXLModel

>>> # Initializing a Transformer XL configuration
>>> configuration = TransfoXLConfig()

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

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

TransfoXL分詞器

類 transformers.TransfoXLTokenizer

< >

( special = None min_freq = 0 max_size = None lower_case = False delimiter = None vocab_file = None pretrained_vocab_file: typing.Optional[str] = None never_split = None unk_token = '<unk>' eos_token = '<eos>' additional_special_tokens = ['<formula>'] language = 'en' **kwargs )

引數

  • special (list[str], 可選) — 特殊標記列表（由該分詞器的原始實現處理）。
  • min_freq (int, 可選, 預設為 0) — 標記在詞彙表中必須出現的最小次數（否則它將被對映到 unk_token）。
  • max_size (int, 可選) — 詞彙表的最大大小。如果未設定，將預設為根據 min_freq 規則排除標記後找到的詞彙表大小。
  • lower_case (bool, 可選, 預設為 False) — 分詞時是否將輸入轉換為小寫。
  • delimiter (str, 可選) — 標記之間使用的分隔符。
  • vocab_file (str, 可選) — 包含詞彙表的檔案（來自原始實現）。
  • pretrained_vocab_file (str, 可選) — 包含使用 save_pretrained() 方法儲存的詞彙表的檔案。
  • never_split (list[str], 可選) — 永不拆分的標記列表。如果未指定列表，則僅使用現有特殊標記。
  • unk_token (str, 可選, 預設為 "<unk>") — 未知標記。不在詞彙表中的標記不能轉換為 ID，而是設定為此標記。
  • eos_token (str, 可選, 預設為 "<eos>") — 序列結束符。
  • additional_special_tokens (list[str], 可選, 預設為 ['<formula>']) — 其他特殊標記列表（用於 HuggingFace 功能）。
  • language (str, 可選, 預設為 "en") — 此分詞器的語言（用於預處理）。

從 原始程式碼 中的 Vocab 類改編的 Transformer-XL 分詞器。Transformer-XL 分詞器是詞級分詞器（無子詞分詞）。

此分詞器繼承自 PreTrainedTokenizer，其中包含大部分主要方法。使用者應參閱此超類以獲取有關這些方法的更多資訊。

儲存詞彙表

< >

( save_directory: str filename_prefix: typing.Optional[str] = None )

TransfoXL 特定輸出

類 transformers.models.deprecated.transfo_xl.modeling_transfo_xl.TransfoXLModelOutput

< >

( last_hidden_state: FloatTensor mems: list = None hidden_states: typing.Optional[tuple[torch.FloatTensor]] = None attentions: typing.Optional[tuple[torch.FloatTensor]] = None )

引數

  • last_hidden_state (torch.FloatTensor，形狀為 (batch_size, sequence_length, hidden_size)) — 模型最後一層輸出的隱藏狀態序列。
  • mems (list[torch.FloatTensor]，長度為 config.n_layers) — 包含預計算的隱藏狀態（注意力塊中的鍵和值）。可用於（參見 mems 輸入）加速順序解碼。已將其過去狀態提供給此模型的標記 ID 不應作為輸入 ID 傳遞，因為它們已被計算。
  • 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 後的注意力權重，用於計算自注意力頭中的加權平均值。

模型輸出的基類，也可能包含過去的鍵/值（以加速順序解碼）。

類 transformers.models.deprecated.transfo_xl.modeling_transfo_xl.TransfoXLLMHeadModelOutput

< >

( losses: typing.Optional[torch.FloatTensor] = None prediction_scores: typing.Optional[torch.FloatTensor] = None mems: list = None hidden_states: typing.Optional[tuple[torch.FloatTensor]] = None attentions: typing.Optional[tuple[torch.FloatTensor]] = None loss: typing.Optional[torch.FloatTensor] = None )

引數

  • losses (torch.FloatTensor，形狀為 (batch_size, sequence_length-1), 可選, 在提供 labels 時返回) — 語言建模損失（未減少）。
  • prediction_scores (torch.FloatTensor，形狀為 (batch_size, sequence_length, config.vocab_size)) — 語言建模頭的預測分數（SoftMax 後每個詞彙標記的分數）。
  • mems (list[torch.FloatTensor]，長度為 config.n_layers) — 包含預計算的隱藏狀態（注意力塊中的鍵和值）。可用於（參見 mems 輸入）加速順序解碼。已將其過去狀態提供給此模型的標記 ID 不應作為輸入 ID 傳遞，因為它們已被計算。
  • 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 後的注意力權重，用於計算自注意力頭中的加權平均值。

  • loss (torch.FloatTensor，形狀為 (), 可選, 在提供 labels 時返回) — 減少的語言建模損失。

模型輸出的基類，也可能包含過去的鍵/值（以加速順序解碼）。

類 transformers.models.deprecated.transfo_xl.modeling_tf_transfo_xl.TFTransfoXLModelOutput

< >

( last_hidden_state: Optional[tf.Tensor] = None mems: list[tf.Tensor] = None hidden_states: tuple[tf.Tensor] | None = None attentions: tuple[tf.Tensor] | None = None )

引數

  • last_hidden_state (tf.Tensor，形狀為 (batch_size, sequence_length, hidden_size)) — 模型最後一層輸出的隱藏狀態序列。
  • mems (list[tf.Tensor]，長度為 config.n_layers) — 包含預計算的隱藏狀態（注意力塊中的鍵和值）。可用於（參見 mems 輸入）加速順序解碼。已將其過去狀態提供給此模型的標記 ID 不應作為輸入 ID 傳遞，因為它們已被計算。
  • hidden_states (tuple(tf.Tensor), 可選, 在傳遞 output_hidden_states=True 或 config.output_hidden_states=True 時返回) — tf.Tensor 的元組（一個用於嵌入輸出 + 一個用於每層輸出），形狀為 (batch_size, sequence_length, hidden_size)。

    模型每層輸出的隱藏狀態加上初始嵌入輸出。

  • attentions (tuple(tf.Tensor), 可選, 在傳遞 output_attentions=True 或 config.output_attentions=True 時返回) — tf.Tensor 的元組（每層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    注意力 softmax 後的注意力權重，用於計算自注意力頭中的加權平均值。

模型輸出的基類，也可能包含過去的鍵/值（以加速順序解碼）。

類 transformers.models.deprecated.transfo_xl.modeling_tf_transfo_xl.TFTransfoXLLMHeadModelOutput

< >

( prediction_scores: Optional[tf.Tensor] = None mems: list[tf.Tensor] = None hidden_states: tuple[tf.Tensor] | None = None attentions: tuple[tf.Tensor] | None = None )

引數

  • losses (tf.Tensor，形狀為 (batch_size, sequence_length-1), 可選, 在提供 labels 時返回) — 語言建模損失（未減少）。
  • prediction_scores (tf.Tensor，形狀為 (batch_size, sequence_length, config.vocab_size)) — 語言建模頭的預測分數（SoftMax 後每個詞彙標記的分數）。
  • mems (list[tf.Tensor]，長度為 config.n_layers) — 包含預計算的隱藏狀態（注意力塊中的鍵和值）。可用於（參見 mems 輸入）加速順序解碼。已將其過去狀態提供給此模型的標記 ID 不應作為輸入 ID 傳遞，因為它們已被計算。
  • hidden_states (tuple(tf.Tensor), 可選, 在傳遞 output_hidden_states=True 或 config.output_hidden_states=True 時返回) — tf.Tensor 的元組（一個用於嵌入輸出 + 一個用於每層輸出），形狀為 (batch_size, sequence_length, hidden_size)。

    模型每層輸出的隱藏狀態加上初始嵌入輸出。

  • attentions (tuple(tf.Tensor), 可選, 在傳遞 output_attentions=True 或 config.output_attentions=True 時返回) — tf.Tensor 的元組（每層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    注意力 softmax 後的注意力權重，用於計算自注意力頭中的加權平均值。

模型輸出的基類，也可能包含過去的鍵/值（以加速順序解碼）。

PyTorch
隱藏 Pytorch 內容

TransfoXL模型

類 transformers.TransfoXLModel

< >

( config )

引數

  • config (TransfoXLConfig) — 包含模型所有引數的模型配置類。使用配置檔案初始化不載入與模型關聯的權重，僅載入配置。請檢視 from_pretrained() 方法以載入模型權重。

裸 BERT 模型 Transformer 輸出原始隱藏狀態，頂部沒有任何特定頭。

此模型繼承自 PreTrainedModel。請檢視超類文件，瞭解庫為其所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪頭部等）。

此模型也是 PyTorch torch.nn.Module 的子類。將其作為常規 PyTorch 模組使用，並參閱 PyTorch 文件以獲取所有與通用用法和行為相關的事項。

前向

< >

( input_ids: typing.Optional[torch.LongTensor] = None mems: typing.Optional[list[torch.FloatTensor]] = None head_mask: typing.Optional[torch.FloatTensor] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.models.deprecated.transfo_xl.modeling_transfo_xl.TransfoXLModelOutput 或 tuple(torch.FloatTensor)

引數

  • input_ids (torch.LongTensor，形狀為 (batch_size, sequence_length)) — 輸入序列標記在詞彙表中的索引。

    索引可以透過 AutoTokenizer 獲取。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

    什麼是輸入 ID？

  • mems (list[torch.FloatTensor]，長度為 config.n_layers) — 包含模型計算的預計算隱藏狀態（注意力塊中的鍵和值）（請參閱下面的 mems 輸出）。可用於加速順序解碼。已將其 mems 提供給此模型的標記 ID 不應作為 input_ids 傳遞，因為它們已被計算。
  • head_mask (torch.FloatTensor，形狀為 (num_heads,) 或 (num_layers, num_heads), 可選) — 用於使自注意力模組的選定頭部無效的掩碼。掩碼值在 [0, 1] 中選擇：

    • 1 表示頭部未被掩碼,
    • 0 表示頭部被掩碼。
  • inputs_embeds (torch.FloatTensor，形狀為 (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.models.deprecated.transfo_xl.modeling_transfo_xl.TransfoXLModelOutput 或 tuple(torch.FloatTensor)

一個 transformers.models.deprecated.transfo_xl.modeling_transfo_xl.TransfoXLModelOutput 或一個 torch.FloatTensor 元組（如果傳遞了 return_dict=False 或 config.return_dict=False），包含根據配置 (TransfoXLConfig) 和輸入的不同元素。

  • last_hidden_state (torch.FloatTensor, 形狀為 (batch_size, sequence_length, hidden_size)) — 模型最後一層輸出的隱藏狀態序列。

  • mems (list[torch.FloatTensor]，長度為 config.n_layers) — 包含預計算的隱藏狀態（注意力塊中的鍵和值）。可用於（參見 mems 輸入）加速順序解碼。已將其過去狀態提供給此模型的標記 ID 不應作為輸入 ID 傳遞，因為它們已被計算。

  • 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 後的注意力權重，用於計算自注意力頭中的加權平均值。

TransfoXLModel 前向方法，覆蓋 __call__ 特殊方法。

儘管前向傳遞的配方需要在此函式中定義，但此後應呼叫 Module 例項而不是此函式，因為前者負責執行預處理和後處理步驟，而後者則默默地忽略它們。

示例

>>> from transformers import AutoTokenizer, TransfoXLModel
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("transfo-xl/transfo-xl-wt103")
>>> model = TransfoXLModel.from_pretrained("transfo-xl/transfo-xl-wt103")

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

>>> last_hidden_states = outputs.last_hidden_state

TransfoXLLMHeadModel

class transformers.TransfoXLLMHeadModel

< >

( config )

引數

  • config (TransfoXLConfig) — 模型配置類，包含模型的所有引數。用配置檔案初始化不會載入與模型相關的權重，只會載入配置。要載入模型權重，請檢視 from_pretrained() 方法。

帶有語言模型頭的 Transformer-XL 模型（自適應 softmax，權重與自適應輸入嵌入繫結）

此模型繼承自 PreTrainedModel。請檢視超類文件，瞭解庫為其所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪頭部等）。

此模型也是 PyTorch torch.nn.Module 的子類。將其作為常規 PyTorch 模組使用，並參閱 PyTorch 文件以獲取所有與通用用法和行為相關的事項。

前向

< >

( input_ids: typing.Optional[torch.LongTensor] = None mems: typing.Optional[list[torch.FloatTensor]] = None head_mask: typing.Optional[torch.FloatTensor] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None labels: typing.Optional[torch.LongTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.models.deprecated.transfo_xl.modeling_transfo_xl.TransfoXLLMHeadModelOutput or tuple(torch.FloatTensor)

引數

  • input_ids (torch.LongTensor 形狀為 (batch_size, sequence_length)) — 詞彙表中輸入序列 token 的索引。

    索引可以使用 AutoTokenizer 獲取。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

    什麼是輸入 ID？

  • mems (list[torch.FloatTensor] 長度為 config.n_layers) — 包含模型計算的預計算隱藏狀態（注意力塊中的鍵和值）（請參閱下面的 mems 輸出）。可用於加速順序解碼。已將其 mems 提供給此模型的 token ID 不應作為 input_ids 傳遞，因為它們已被計算。
  • head_mask (torch.FloatTensor 形狀為 (num_heads,) 或 (num_layers, num_heads), 可選) — 用於使自注意力模組的選定頭部無效的掩碼。掩碼值選擇在 [0, 1] 中：

    • 1 表示頭部未被遮蔽，
    • 0 表示頭部被遮蔽。
  • inputs_embeds (torch.FloatTensor 形狀為 (batch_size, sequence_length, hidden_size), 可選) — 可選地，您可以選擇直接傳遞嵌入表示，而不是傳遞 input_ids。如果您希望對如何將 input_ids 索引轉換為關聯向量具有比模型內部嵌入查詢矩陣更多的控制，這會很有用。
  • output_attentions (bool, 可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊，請參閱返回張量下的 attentions。
  • output_hidden_states (bool, 可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊，請參閱返回張量下的 hidden_states。
  • return_dict (bool, 可選) — 是否返回 ModelOutput 而不是普通元組。
  • labels (torch.LongTensor 形狀為 (batch_size, sequence_length), 可選) — 語言模型標籤。請注意，標籤在模型內部已偏移，即您可以設定 labels = input_ids。索引選擇在 [-100, 0, ..., config.vocab_size] 中。所有設定為 -100 的標籤都將被忽略（遮蔽），損失只針對 [0, ..., config.vocab_size] 中的標籤計算。

返回

transformers.models.deprecated.transfo_xl.modeling_transfo_xl.TransfoXLLMHeadModelOutput 或 tuple(torch.FloatTensor)

一個 transformers.models.deprecated.transfo_xl.modeling_transfo_xl.TransfoXLLMHeadModelOutput 或 torch.FloatTensor 的元組（如果傳遞了 return_dict=False 或當 config.return_dict=False 時），根據配置（TransfoXLConfig）和輸入包含各種元素。

  • losses (torch.FloatTensor 形狀為 (batch_size, sequence_length-1), 可選, 當提供 labels 時返回) — 語言模型損失（未減少）。

  • prediction_scores (torch.FloatTensor 形狀為 (batch_size, sequence_length, config.vocab_size)) — 語言模型頭的預測分數（SoftMax 後每個詞彙 token 的分數）。

  • mems (list[torch.FloatTensor]，長度為 config.n_layers) — 包含預計算的隱藏狀態（注意力塊中的鍵和值）。可用於（參見 mems 輸入）加速順序解碼。已將其過去狀態提供給此模型的標記 ID 不應作為輸入 ID 傳遞，因為它們已被計算。

  • 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 後的注意力權重，用於計算自注意力頭中的加權平均值。

  • loss (torch.FloatTensor 形狀為 (), 可選, 當提供 labels 時返回) 縮減後的語言模型損失。

TransfoXLLMHeadModel 的 forward 方法，覆蓋了 __call__ 特殊方法。

儘管前向傳遞的配方需要在此函式中定義，但此後應呼叫 Module 例項而不是此函式，因為前者負責執行預處理和後處理步驟，而後者則默默地忽略它們。

示例

>>> import torch
>>> from transformers import AutoTokenizer, TransfoXLLMHeadModel

>>> tokenizer = AutoTokenizer.from_pretrained("transfo-xl/transfo-xl-wt103")
>>> model = TransfoXLLMHeadModel.from_pretrained("transfo-xl/transfo-xl-wt103")

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

TransfoXLForSequenceClassification

class transformers.TransfoXLForSequenceClassification

< >

( config )

引數

  • config (TransfoXLConfig) — 模型配置類，包含模型的所有引數。用配置檔案初始化不會載入與模型相關的權重，只會載入配置。要載入模型權重，請檢視 from_pretrained() 方法。

Transformer-XL 模型，頂部帶有一個序列分類頭（線性層）。

TransfoXLForSequenceClassification 使用最後一個 token 進行分類，與其他因果模型（例如 GPT-1）一樣。

由於它對最後一個 token 進行分類，因此需要知道最後一個 token 的位置。如果配置中定義了 pad_token_id，它會找到每行中不是填充 token 的最後一個 token。如果未定義 pad_token_id，它只取批處理中每行的最後一個值。由於當傳遞 inputs_embeds 而不是 input_ids 時無法猜測填充 token，因此它執行相同的操作（取批處理中每行的最後一個值）。

此模型繼承自 PreTrainedModel。請檢視超類文件，瞭解庫為其所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪頭部等）。

此模型也是 PyTorch torch.nn.Module 的子類。將其作為常規 PyTorch 模組使用，並參閱 PyTorch 文件以獲取所有與通用用法和行為相關的事項。

前向

< >

( input_ids: typing.Optional[torch.LongTensor] = None mems: typing.Optional[list[torch.FloatTensor]] = None head_mask: typing.Optional[torch.FloatTensor] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None labels: typing.Optional[torch.LongTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.models.deprecated.transfo_xl.modeling_transfo_xl.TransfoXLSequenceClassifierOutputWithPast 或 tuple(torch.FloatTensor)

引數

  • input_ids (torch.LongTensor 形狀為 (batch_size, sequence_length)) — 詞彙表中輸入序列 token 的索引。

    索引可以使用 AutoTokenizer 獲取。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

    什麼是輸入 ID？

  • mems (list[torch.FloatTensor] 長度為 config.n_layers) — 包含模型計算的預計算隱藏狀態（注意力塊中的鍵和值）（請參閱下面的 mems 輸出）。可用於加速順序解碼。已將其 mems 提供給此模型的 token ID 不應作為 input_ids 傳遞，因為它們已被計算。
  • head_mask (torch.FloatTensor 形狀為 (num_heads,) 或 (num_layers, num_heads), 可選) — 用於使自注意力模組的選定頭部無效的掩碼。掩碼值選擇在 [0, 1] 中：

    • 1 表示頭部未被遮蔽，
    • 0 表示頭部被遮蔽。
  • inputs_embeds (torch.FloatTensor 形狀為 (batch_size, sequence_length, hidden_size), 可選) — 可選地，您可以選擇直接傳遞嵌入表示，而不是傳遞 input_ids。如果您希望對如何將 input_ids 索引轉換為關聯向量具有比模型內部嵌入查詢矩陣更多的控制，這會很有用。
  • output_attentions (bool, 可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊，請參閱返回張量下的 attentions。
  • output_hidden_states (bool, 可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊，請參閱返回張量下的 hidden_states。
  • return_dict (bool, 可選) — 是否返回 ModelOutput 而不是普通元組。
  • labels (torch.LongTensor 形狀為 (batch_size,), 可選) — 用於計算序列分類/迴歸損失的標籤。索引應在 [0, ..., config.num_labels - 1] 之間。如果 config.num_labels == 1，則計算迴歸損失（均方損失），如果 config.num_labels > 1，則計算分類損失（交叉熵）。

返回

transformers.models.deprecated.transfo_xl.modeling_transfo_xl.TransfoXLSequenceClassifierOutputWithPast 或 tuple(torch.FloatTensor)

一個 transformers.models.deprecated.transfo_xl.modeling_transfo_xl.TransfoXLSequenceClassifierOutputWithPast 或一個 torch.FloatTensor 的元組（如果傳遞了 return_dict=False 或當 config.return_dict=False 時），根據配置（TransfoXLConfig）和輸入包含各種元素。

  • loss (形狀為 (1,) 的 torch.FloatTensor，可選，當提供 labels 時返回) — 分類損失（如果 config.num_labels==1，則為迴歸損失）。

  • logits (形狀為 (batch_size, config.num_labels) 的 torch.FloatTensor) — 分類（如果 config.num_labels==1，則為迴歸）分數（SoftMax 之前）。

  • mems (list[torch.FloatTensor]，長度為 config.n_layers) — 包含預計算的隱藏狀態（注意力塊中的鍵和值）。可用於（參見 mems 輸入）加速順序解碼。已將其過去狀態提供給此模型的標記 ID 不應作為輸入 ID 傳遞，因為它們已被計算。

  • 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 後的注意力權重，用於計算自注意力頭中的加權平均值。

TransfoXLForSequenceClassification 的 forward 方法，覆蓋了 __call__ 特殊方法。

儘管前向傳遞的配方需要在此函式中定義，但此後應呼叫 Module 例項而不是此函式，因為前者負責執行預處理和後處理步驟，而後者則默默地忽略它們。

單標籤分類示例

>>> import torch
>>> from transformers import AutoTokenizer, TransfoXLForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("transfo-xl/transfo-xl-wt103")
>>> model = TransfoXLForSequenceClassification.from_pretrained("transfo-xl/transfo-xl-wt103")

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

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_class_id = logits.argmax().item()

>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = TransfoXLForSequenceClassification.from_pretrained("transfo-xl/transfo-xl-wt103", num_labels=num_labels)

>>> labels = torch.tensor([1])
>>> loss = model(**inputs, labels=labels).loss

多標籤分類示例

>>> import torch
>>> from transformers import AutoTokenizer, TransfoXLForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("transfo-xl/transfo-xl-wt103")
>>> model = TransfoXLForSequenceClassification.from_pretrained("transfo-xl/transfo-xl-wt103", problem_type="multi_label_classification")

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

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_class_ids = torch.arange(0, logits.shape[-1])[torch.sigmoid(logits).squeeze(dim=0) > 0.5]

>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = TransfoXLForSequenceClassification.from_pretrained(
...     "transfo-xl/transfo-xl-wt103", num_labels=num_labels, problem_type="multi_label_classification"
... )

>>> labels = torch.sum(
...     torch.nn.functional.one_hot(predicted_class_ids[None, :].clone(), num_classes=num_labels), dim=1
... ).to(torch.float)
>>> loss = model(**inputs, labels=labels).loss
TensorFlow
隱藏 TensorFlow 內容

TFTransfoXLModel

class transformers.TFTransfoXLModel

< >

( config *inputs **kwargs )

引數

  • config (TransfoXLConfig) — 模型配置類，包含模型的所有引數。用配置檔案初始化不會載入與模型相關的權重，只會載入配置。要載入模型權重，請檢視 from_pretrained() 方法。

裸 BERT 模型 Transformer 輸出原始隱藏狀態，頂部沒有任何特定頭。

此模型繼承自 TFPreTrainedModel。請檢視超類文件，瞭解庫為其所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪頭等）

此模型也是 keras.Model 的子類。將其作為常規 TF 2.0 Keras 模型使用，並參考 TF 2.0 文件瞭解所有與通用用法和行為相關的事項。

transformers 中的 TensorFlow 模型和層接受兩種輸入格式

  • 所有輸入作為關鍵字引數（如 PyTorch 模型），或
  • 所有輸入作為第一個位置引數中的列表、元組或字典。

支援第二種格式的原因是 Keras 方法在將輸入傳遞給模型和層時更喜歡這種格式。由於此支援，在使用 model.fit() 等方法時，一切都應該“正常工作”——只需以 model.fit() 支援的任何格式傳遞您的輸入和標籤即可！但是，如果您想在 fit() 和 predict() 等 Keras 方法之外使用第二種格式，例如在使用 Keras Functional API 建立自己的層或模型時，您可以使用三種可能性來收集第一個位置引數中的所有輸入張量

  • 只有一個 input_ids 的單個張量，沒有其他：model(input_ids)
  • 長度可變的列表，包含一個或多個輸入張量，按文件字串中給出的順序：model([input_ids, attention_mask]) 或 model([input_ids, attention_mask, token_type_ids])
  • 一個字典，其中包含一個或多個與文件字串中給出的輸入名稱關聯的輸入張量：model({"input_ids": input_ids, "token_type_ids": token_type_ids})

請注意，當使用 子類化 建立模型和層時，您無需擔心這些，因為您可以像傳遞給任何其他 Python 函式一樣傳遞輸入！

呼叫

< >

( input_ids: TFModelInputType | None = None mems: list[tf.Tensor] | None = None head_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None output_attentions: bool | None = None output_hidden_states: bool | None = None return_dict: bool | None = None training: bool = False ) → transformers.models.deprecated.transfo_xl.modeling_tf_transfo_xl.TFTransfoXLModelOutput 或 tuple(tf.Tensor)

引數

  • input_ids (tf.Tensor 或 Numpy 陣列，形狀為 (batch_size, sequence_length)) — 詞彙表中輸入序列 token 的索引。

    索引可以使用 AutoTokenizer 獲取。有關詳細資訊，請參閱 PreTrainedTokenizer.call() 和 PreTrainedTokenizer.encode()。

    什麼是輸入 ID？

  • mems (list[tf.Tensor] 長度為 config.n_layers) — 包含模型計算的預計算隱藏狀態（注意力塊中的鍵和值）（請參閱下面的 mems 輸出）。可用於加速順序解碼。已將其 mems 提供給此模型的 token ID 不應作為 input_ids 傳遞，因為它們已被計算。
  • head_mask (tf.Tensor 或 Numpy 陣列，形狀為 (num_heads,) 或 (num_layers, num_heads), 可選) — 用於使自注意力模組的選定頭部無效的掩碼。掩碼值選擇在 [0, 1] 中：

    • 1 表示頭部未被遮蔽，
    • 0 表示頭部被遮蔽。
  • inputs_embeds (tf.Tensor 或 Numpy 陣列，形狀為 (batch_size, sequence_length, hidden_size), 可選) — 可選地，您可以選擇直接傳遞嵌入表示，而不是傳遞 input_ids。如果您希望對如何將 input_ids 索引轉換為關聯向量具有比模型內部嵌入查詢矩陣更多的控制，這會很有用。
  • output_attentions (bool, 可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊，請參閱返回張量下的 attentions。此引數只能在 eager 模式下使用，在圖模式下將使用配置中的值。
  • output_hidden_states (bool, 可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊，請參閱返回張量下的 hidden_states。此引數只能在 eager 模式下使用，在圖模式下將使用配置中的值。
  • return_dict (bool, 可選) — 是否返回 ModelOutput 而不是普通元組。此引數只能在 eager 模式下使用，在圖模式下將始終設定為 True。
  • training (bool, 可選, 預設為 False) — 是否在訓練模式下使用模型（某些模組如 dropout 模組在訓練和評估之間的行為不同）。

返回

transformers.models.deprecated.transfo_xl.modeling_tf_transfo_xl.TFTransfoXLModelOutput 或 tuple(tf.Tensor)

一個 transformers.models.deprecated.transfo_xl.modeling_tf_transfo_xl.TFTransfoXLModelOutput 或一個 tf.Tensor 的元組（如果傳遞了 return_dict=False 或當 config.return_dict=False 時），根據配置（TransfoXLConfig）和輸入包含各種元素。

  • last_hidden_state (tf.Tensor of shape (batch_size, sequence_length, hidden_size)) — 模型最後一層輸出的隱藏狀態序列。

  • mems (list[tf.Tensor] 長度為 config.n_layers) — 包含預計算的隱藏狀態（注意力塊中的鍵和值）。可用於（參見 mems 輸入）加速順序解碼。已將其過去資訊提供給此模型的 token ID 不應作為輸入 ID 傳遞，因為它們已被計算。

  • hidden_states (tuple(tf.Tensor), 可選, 當傳遞 output_hidden_states=True 或 config.output_hidden_states=True 時返回) — tf.Tensor 的元組（一個用於嵌入輸出 + 一個用於每層輸出），形狀為 (batch_size, sequence_length, hidden_size)。

    模型在每個層輸出的隱藏狀態加上初始嵌入輸出。

  • attentions (tuple(tf.Tensor), 可選, 當傳遞 output_attentions=True 或 config.output_attentions=True 時返回) — tf.Tensor 的元組（每層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    注意力 softmax 後的注意力權重，用於計算自注意力頭中的加權平均值。

TFTransfoXLModel 的 forward 方法，覆蓋了 __call__ 特殊方法。

儘管前向傳遞的配方需要在此函式中定義，但此後應呼叫 Module 例項而不是此函式，因為前者負責執行預處理和後處理步驟，而後者則默默地忽略它們。

示例

>>> from transformers import AutoTokenizer, TFTransfoXLModel
>>> import tensorflow as tf

>>> tokenizer = AutoTokenizer.from_pretrained("transfo-xl/transfo-xl-wt103")
>>> model = TFTransfoXLModel.from_pretrained("transfo-xl/transfo-xl-wt103")

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

>>> last_hidden_states = outputs.last_hidden_state

TFTransfoXLLMHeadModel

class transformers.TFTransfoXLLMHeadModel

< >

( config )

引數

  • config (TransfoXLConfig) — 模型配置類，包含模型的所有引數。用配置檔案初始化不會載入與模型相關的權重，只會載入配置。要載入模型權重，請檢視 from_pretrained() 方法。

帶有語言模型頭的 Transformer-XL 模型（自適應 softmax，權重與自適應輸入嵌入繫結）

此模型繼承自 TFPreTrainedModel。請檢視超類文件，瞭解庫為其所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪頭等）

此模型也是 keras.Model 的子類。將其作為常規 TF 2.0 Keras 模型使用，並參考 TF 2.0 文件瞭解所有與通用用法和行為相關的事項。

transformers 中的 TensorFlow 模型和層接受兩種輸入格式

  • 所有輸入作為關鍵字引數（如 PyTorch 模型），或
  • 所有輸入作為第一個位置引數中的列表、元組或字典。

支援第二種格式的原因是 Keras 方法在將輸入傳遞給模型和層時更喜歡這種格式。由於此支援，在使用 model.fit() 等方法時，一切都應該“正常工作”——只需以 model.fit() 支援的任何格式傳遞您的輸入和標籤即可！但是，如果您想在 fit() 和 predict() 等 Keras 方法之外使用第二種格式，例如在使用 Keras Functional API 建立自己的層或模型時，您可以使用三種可能性來收集第一個位置引數中的所有輸入張量

  • 只有一個 input_ids 的單個張量，沒有其他：model(input_ids)
  • 長度可變的列表，包含一個或多個輸入張量，按文件字串中給出的順序：model([input_ids, attention_mask]) 或 model([input_ids, attention_mask, token_type_ids])
  • 一個字典，其中包含一個或多個與文件字串中給出的輸入名稱關聯的輸入張量：model({"input_ids": input_ids, "token_type_ids": token_type_ids})

請注意，當使用 子類化 建立模型和層時，您無需擔心這些，因為您可以像傳遞給任何其他 Python 函式一樣傳遞輸入！

呼叫

< >

( input_ids: TFModelInputType | None = None mems: list[tf.Tensor] | None = None head_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None output_attentions: bool | None = None output_hidden_states: bool | None = None return_dict: bool | None = None labels: np.ndarray | tf.Tensor | None = None training: bool = False ) → transformers.models.deprecated.transfo_xl.modeling_tf_transfo_xl.TFTransfoXLLMHeadModelOutput 或 tuple(tf.Tensor)

引數

  • input_ids (tf.Tensor 或 Numpy 陣列，形狀為 (batch_size, sequence_length)) — 詞彙表中輸入序列 token 的索引。

    索引可以使用 AutoTokenizer 獲取。有關詳細資訊，請參閱 PreTrainedTokenizer.call() 和 PreTrainedTokenizer.encode()。

    什麼是輸入 ID？

  • mems (list[tf.Tensor] 長度為 config.n_layers) — 包含模型計算的預計算隱藏狀態（注意力塊中的鍵和值）（請參閱下面的 mems 輸出）。可用於加速順序解碼。已將其 mems 提供給此模型的 token ID 不應作為 input_ids 傳遞，因為它們已被計算。
  • head_mask (tf.Tensor 或 Numpy 陣列，形狀為 (num_heads,) 或 (num_layers, num_heads), 可選) — 用於使自注意力模組的選定頭部無效的掩碼。掩碼值選擇在 [0, 1] 中：

    • 1 表示頭部未被遮蔽，
    • 0 表示頭部被遮蔽。
  • inputs_embeds (tf.Tensor 或 Numpy 陣列，形狀為 (batch_size, sequence_length, hidden_size), 可選) — 可選地，您可以選擇直接傳遞嵌入表示，而不是傳遞 input_ids。如果您希望對如何將 input_ids 索引轉換為關聯向量具有比模型內部嵌入查詢矩陣更多的控制，這會很有用。
  • output_attentions (bool, 可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊，請參閱返回張量下的 attentions。此引數只能在 eager 模式下使用，在圖模式下將使用配置中的值。
  • output_hidden_states (bool, 可選) — 是否返回所有層的隱藏狀態。更多詳情請參閱返回張量下的hidden_states。此引數只能在即時模式下使用，在圖模式下將使用配置中的值。
  • return_dict (bool, 可選) — 是否返回ModelOutput而不是普通元組。此引數可在即時模式下使用，在圖模式下該值將始終設定為 True。
  • training (bool, 可選, 預設為False) — 是否在訓練模式下使用模型（某些模組如 dropout 模組在訓練和評估之間有不同的行為）。

返回

transformers.models.deprecated.transfo_xl.modeling_tf_transfo_xl.TFTransfoXLLMHeadModelOutput 或 tuple(tf.Tensor)

一個 transformers.models.deprecated.transfo_xl.modeling_tf_transfo_xl.TFTransfoXLLMHeadModelOutput 或一個 tf.Tensor 元組（如果傳遞了 return_dict=False 或 config.return_dict=False 時），根據配置（TransfoXLConfig）和輸入包含各種元素。

  • losses (形狀為 (batch_size, sequence_length-1) 的tf.Tensor，可選，當提供 labels 時返回) — 語言模型損失（未減少）。

  • prediction_scores (形狀為 (batch_size, sequence_length, config.vocab_size) 的tf.Tensor) — 語言模型頭部的預測分數（SoftMax 後每個詞彙標記的分數）。

  • mems (list[tf.Tensor] 長度為 config.n_layers) — 包含預計算的隱藏狀態（注意力塊中的鍵和值）。可用於（參見 mems 輸入）加速順序解碼。已將其過去資訊提供給此模型的 token ID 不應作為輸入 ID 傳遞，因為它們已被計算。

  • hidden_states (tuple(tf.Tensor), 可選, 當傳遞 output_hidden_states=True 或 config.output_hidden_states=True 時返回) — tf.Tensor 的元組（一個用於嵌入輸出 + 一個用於每層輸出），形狀為 (batch_size, sequence_length, hidden_size)。

    模型在每個層輸出的隱藏狀態加上初始嵌入輸出。

  • attentions (tuple(tf.Tensor), 可選, 當傳遞 output_attentions=True 或 config.output_attentions=True 時返回) — tf.Tensor 的元組（每層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    注意力 softmax 後的注意力權重，用於計算自注意力頭中的加權平均值。

TFTransfoXLLMHeadModel 的 forward 方法，覆蓋了 __call__ 特殊方法。

儘管前向傳遞的配方需要在此函式中定義，但此後應呼叫 Module 例項而不是此函式，因為前者負責執行預處理和後處理步驟，而後者則默默地忽略它們。

示例

>>> from transformers import AutoTokenizer, TFTransfoXLLMHeadModel
>>> import tensorflow as tf

>>> tokenizer = AutoTokenizer.from_pretrained("transfo-xl/transfo-xl-wt103")
>>> model = TFTransfoXLLMHeadModel.from_pretrained("transfo-xl/transfo-xl-wt103")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="tf")
>>> outputs = model(inputs)
>>> logits = outputs.logits

TFTransfoXLForSequenceClassification

class transformers.TFTransfoXLForSequenceClassification

< >

( config *inputs **kwargs )

引數

  • config (TransfoXLConfig) — 模型的配置類，包含模型的所有引數。使用配置檔案初始化並不會載入與模型相關的權重，只加載配置。請檢視 from_pretrained() 方法來載入模型權重。

Transfo XL 模型 Transformer，頂部帶有一個序列分類頭（線性層）。

TFTransfoXLForSequenceClassification 使用最後一個標記進行分類，就像其他因果模型（如 GPT-1、GPT-2）一樣。

由於它對最後一個 token 進行分類，因此需要知道最後一個 token 的位置。如果配置中定義了 pad_token_id，它會找到每行中不是填充 token 的最後一個 token。如果未定義 pad_token_id，它只取批處理中每行的最後一個值。由於當傳遞 inputs_embeds 而不是 input_ids 時無法猜測填充 token，因此它執行相同的操作（取批處理中每行的最後一個值）。

此模型繼承自 TFPreTrainedModel。請檢視超類文件，瞭解庫為其所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪頭等）

此模型也是 keras.Model 的子類。將其作為常規 TF 2.0 Keras 模型使用，並參考 TF 2.0 文件瞭解所有與通用用法和行為相關的事項。

transformers 中的 TensorFlow 模型和層接受兩種輸入格式

  • 所有輸入作為關鍵字引數（如 PyTorch 模型），或
  • 所有輸入作為第一個位置引數中的列表、元組或字典。

支援第二種格式的原因是 Keras 方法在將輸入傳遞給模型和層時更喜歡這種格式。由於此支援，在使用 model.fit() 等方法時，一切都應該“正常工作”——只需以 model.fit() 支援的任何格式傳遞您的輸入和標籤即可！但是，如果您想在 fit() 和 predict() 等 Keras 方法之外使用第二種格式，例如在使用 Keras Functional API 建立自己的層或模型時，您可以使用三種可能性來收集第一個位置引數中的所有輸入張量

  • 只有一個 input_ids 的單個張量，沒有其他：model(input_ids)
  • 長度可變的列表，包含一個或多個輸入張量，按文件字串中給出的順序：model([input_ids, attention_mask]) 或 model([input_ids, attention_mask, token_type_ids])
  • 一個字典，其中包含一個或多個與文件字串中給出的輸入名稱關聯的輸入張量：model({"input_ids": input_ids, "token_type_ids": token_type_ids})

請注意，當使用 子類化 建立模型和層時，您無需擔心這些，因為您可以像傳遞給任何其他 Python 函式一樣傳遞輸入！

呼叫

< >

( input_ids: TFModelInputType | None = None mems: list[tf.Tensor] | None = None head_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None labels: np.ndarray | tf.Tensor | None = None training: Optional[bool] = False ) → transformers.models.deprecated.transfo_xl.modeling_tf_transfo_xl.TFTransfoXLSequenceClassifierOutputWithPast 或 tuple(tf.Tensor)

引數

  • input_ids (形狀為 (batch_size, sequence_length) 的tf.Tensor 或 Numpy array) — 詞彙表中輸入序列標記的索引。

    索引可以使用 AutoTokenizer 獲取。詳情請參閱 PreTrainedTokenizer.call() 和 PreTrainedTokenizer.encode()。

    什麼是 input IDs？

  • mems (長度為 config.n_layers 的 list[tf.Tensor]) — 包含模型計算的預計算隱藏狀態（注意力塊中的鍵和值）（參見下面的 mems 輸出）。可用於加速順序解碼。已將 mems 提供給該模型的標記 ID 不應作為 input_ids 傳遞，因為它們已被計算。
  • head_mask (形狀為 (num_heads,) 或 (num_layers, num_heads) 的 tf.Tensor 或 Numpy array，可選) — 用於使自注意力模組的選定頭部無效的掩碼。掩碼值選擇在 [0, 1] 之間：

    • 1 表示頭部未被掩碼，
    • 0 表示頭部被掩碼。
  • inputs_embeds (形狀為 (batch_size, sequence_length, hidden_size) 的tf.Tensor 或 Numpy array，可選) — 可選地，您可以選擇直接傳遞嵌入表示，而不是傳遞 input_ids。如果您希望對 input_ids 索引如何轉換為關聯向量有比模型內部嵌入查詢矩陣更多的控制，這會很有用。
  • output_attentions (bool, 可選) — 是否返回所有注意力層的注意力張量。更多詳情請參閱返回張量下的attentions。此引數只能在即時模式下使用，在圖模式下將使用配置中的值。
  • output_hidden_states (bool, 可選) — 是否返回所有層的隱藏狀態。更多詳情請參閱返回張量下的hidden_states。此引數只能在即時模式下使用，在圖模式下將使用配置中的值。
  • return_dict (bool, 可選) — 是否返回ModelOutput而不是普通元組。此引數可在即時模式下使用，在圖模式下該值將始終設定為 True。
  • training (bool, 可選, 預設為False) — 是否在訓練模式下使用模型（某些模組如 dropout 模組在訓練和評估之間有不同的行為）。
  • labels (形狀為 (batch_size, sequence_length) 的tf.Tensor，可選) — 用於計算交叉熵分類損失的標籤。索引應在 [0, ..., config.vocab_size - 1] 之間。

返回

transformers.models.deprecated.transfo_xl.modeling_tf_transfo_xl.TFTransfoXLSequenceClassifierOutputWithPast 或 tuple(tf.Tensor)

一個 transformers.models.deprecated.transfo_xl.modeling_tf_transfo_xl.TFTransfoXLSequenceClassifierOutputWithPast 或一個 tf.Tensor 元組（如果傳遞了 return_dict=False 或 config.return_dict=False 時），根據配置（TransfoXLConfig）和輸入包含各種元素。

  • loss (形狀為 (1,) 的 tf.Tensor，可選，當提供 labels 時返回) — 分類（如果 config.num_labels==1，則為迴歸）損失。

  • logits (tf.Tensor，形狀為 (batch_size, config.num_labels)) — 分類（或迴歸，如果 config.num_labels==1）分數（SoftMax 之前）。

  • mems (list[tf.Tensor] 長度為 config.n_layers) — 包含預計算的隱藏狀態（注意力塊中的鍵和值）。可用於（參見 mems 輸入）加速順序解碼。已將其過去資訊提供給此模型的 token ID 不應作為輸入 ID 傳遞，因為它們已被計算。

  • hidden_states (tuple(tf.Tensor), 可選, 當傳遞 output_hidden_states=True 或 config.output_hidden_states=True 時返回) — tf.Tensor 的元組（一個用於嵌入輸出 + 一個用於每層輸出），形狀為 (batch_size, sequence_length, hidden_size)。

    模型在每個層輸出的隱藏狀態加上初始嵌入輸出。

  • attentions (tuple(tf.Tensor), 可選, 當傳遞 output_attentions=True 或 config.output_attentions=True 時返回) — tf.Tensor 的元組（每層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    注意力 softmax 後的注意力權重，用於計算自注意力頭中的加權平均值。

TFTransfoXLForSequenceClassification 的 forward 方法，覆蓋了 __call__ 特殊方法。

儘管前向傳遞的配方需要在此函式中定義，但此後應呼叫 Module 例項而不是此函式，因為前者負責執行預處理和後處理步驟，而後者則默默地忽略它們。

示例

>>> from transformers import AutoTokenizer, TFTransfoXLForSequenceClassification
>>> import tensorflow as tf

>>> tokenizer = AutoTokenizer.from_pretrained("transfo-xl/transfo-xl-wt103")
>>> model = TFTransfoXLForSequenceClassification.from_pretrained("transfo-xl/transfo-xl-wt103")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="tf")

>>> logits = model(**inputs).logits

>>> predicted_class_id = int(tf.math.argmax(logits, axis=-1)[0])
>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = TFTransfoXLForSequenceClassification.from_pretrained("transfo-xl/transfo-xl-wt103", num_labels=num_labels)

>>> labels = tf.constant(1)
>>> loss = model(**inputs, labels=labels).loss

內部層

class transformers.AdaptiveEmbedding

< >

( n_token d_embed d_proj cutoffs div_val = 1 sample_softmax = False )

class transformers.TFAdaptiveEmbedding

< >

( n_token d_embed d_proj cutoffs div_val = 1 init_std = 0.02 sample_softmax = False **kwargs )

< > 在 GitHub 上更新

←TAPEX UL2→
© . This site is unofficial and not affiliated with Hugging Face, Inc.