Transformers 文件
mT5
並獲得增強的文件體驗
開始使用
mT5
概述
mT5 模型由 Linting Xue、Noah Constant、Adam Roberts、Mihir Kale、Rami Al-Rfou、Aditya Siddhant、Aditya Barua、Colin Raffel 在論文 mT5：一個大規模多語言預訓練文字到文字轉換器 中提出。
論文摘要如下：
最近，“文字到文字遷移轉換器”（T5）利用統一的文字到文字格式和規模，在各種英語自然語言處理任務上取得了最先進的結果。在本文中，我們介紹了 mT5，它是 T5 的一個多語言變體，它在一個基於 Common Crawl 的新資料集上進行了預訓練，該資料集涵蓋了 101 種語言。我們詳細介紹了 mT5 的設計和改進的訓練方法，並展示了其在許多多語言基準測試中的最先進效能。我們還描述了一種簡單的技術，用於在零樣本設定下防止“意外翻譯”，即生成模型選擇（部分）將其預測翻譯成錯誤的語言。本工作中使用的所有程式碼和模型檢查點都已公開可用。
注意：mT5 僅在 mC4 上進行了預訓練，不包含任何有監督的訓練。因此，與原始的 T5 模型不同，該模型在使用於下游任務之前必須進行微調。由於 mT5 是無監督預訓練的，因此在單任務微調期間使用任務字首並沒有實際的好處。如果您正在進行多工微調，則應使用字首。
Google 釋出了以下變體：
該模型由 patrickvonplaten 貢獻。原始程式碼可以在這裡找到。
資源
MT5Config
class transformers.MT5Config
< 源 >( vocab_size = 250112 d_model = 512 d_kv = 64 d_ff = 1024 num_layers = 8 num_decoder_layers = None num_heads = 6 relative_attention_num_buckets = 32 relative_attention_max_distance = 128 dropout_rate = 0.1 layer_norm_epsilon = 1e-06 initializer_factor = 1.0 feed_forward_proj = 'gated-gelu' is_encoder_decoder = True use_cache = True tokenizer_class = 'T5Tokenizer' tie_word_embeddings = False pad_token_id = 0 eos_token_id = 1 decoder_start_token_id = 0 classifier_dropout = 0.0 **kwargs )
引數
- vocab_size (
int, 可選, 預設為 250112) — T5 模型的詞彙表大小。定義了在呼叫 T5Model 或 TFT5Model 時，可以透過inputs_ids表示的不同 token 的數量。 - d_model (
int, 可選, 預設為 512) — 編碼器層和池化層的大小。 - d_kv (
int, 可選, 預設為 64) — 每個注意力頭中鍵、查詢、值投影的大小。在傳統情況下，通常期望 `d_kv` 等於 `d_model // num_heads`。但在 mt5-small 的架構中，`d_kv` 不等於 `d_model // num_heads`。投影層的 `inner_dim` 將定義為 `num_heads * d_kv`。 - d_ff (
int, 可選, 預設為 1024) — 每個 `T5Block` 中中間前饋層的大小。 - num_layers (
int, 可選, 預設為 8) — Transformer 編碼器中的隱藏層數量。 - num_decoder_layers (
int, 可選) — Transformer 解碼器中的隱藏層數量。如果未設定，將使用與 `num_layers` 相同的值。 - num_heads (
int, 可選, 預設為 6) — Transformer 編碼器中每個注意力層的注意力頭數量。 - relative_attention_num_buckets (
int, 可選, 預設為 32) — 用於每個注意力層的桶（bucket）的數量。 - relative_attention_max_distance (
int, 可選, 預設為 128) — 用於桶分離的較長序列的最大距離。 - dropout_rate (
float, 可選, 預設為 0.1) — 所有 dropout 層的比率。 - classifier_dropout (
float, 可選, 預設為 0.0) — 分類器的 dropout 比率。 - layer_norm_eps (
float, 可選, 預設為 1e-6) — 層歸一化層使用的 epsilon 值。 - initializer_factor (
float, 可選, 預設為 1) — 用於初始化所有權重矩陣的因子（應保持為 1，內部用於初始化測試）。 - feed_forward_proj (
string, 可選, 預設為"gated-gelu") — 要使用的前饋層型別。應為"relu"或"gated-gelu"之一。 - use_cache (
bool, 可選, 預設為True) — 模型是否應返回最後一個鍵/值注意力（並非所有模型都使用）。
這是一個用於儲存 MT5Model 或 TFMT5Model 配置的配置類。它用於根據指定的引數例項化一個 mT5 模型，定義模型架構。使用預設值例項化一個配置將產生與 mT5 google/mt5-small 架構相似的配置。
配置物件繼承自 PretrainedConfig，可用於控制模型輸出。有關更多資訊，請閱讀 PretrainedConfig 的文件。
MT5Tokenizer
class transformers.MT5Tokenizer
< 源 >( vocab_file eos_token = '</s>' unk_token = '<unk>' pad_token = '<pad>' extra_ids = 100 additional_special_tokens = None sp_model_kwargs: typing.Optional[dict[str, typing.Any]] = None legacy = None add_prefix_space = True **kwargs )
檢視 T5Tokenizer 瞭解所有詳細資訊。
MT5TokenizerFast
class transformers.MT5TokenizerFast
< 源 >( vocab_file = None tokenizer_file = None eos_token = '</s>' unk_token = '<unk>' pad_token = '<pad>' extra_ids = 100 additional_special_tokens = None add_prefix_space = None **kwargs )
有關所有詳細資訊，請參閱 T5TokenizerFast。
MT5Model
class transformers.MT5Model
< 來源 >( config: MT5Config )
引數
- config (MT5Config) — 包含模型所有引數的模型配置類。使用配置檔案進行初始化不會載入與模型相關的權重，只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。
裸的Mt5模型，輸出原始的隱藏狀態，頂部沒有任何特定的頭。
此模型繼承自 PreTrainedModel。請檢視超類文件，瞭解該庫為其所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪注意力頭等）。
該模型也是一個 PyTorch torch.nn.Module 的子類。可以像常規的 PyTorch 模組一樣使用它，並參考 PyTorch 文件瞭解所有與通用用法和行為相關的事項。
將模型從模型並行狀態移至 CPU。
示例
# On a 4 GPU machine with mt5-xl:
model = MT5ForConditionalGeneration.from_pretrained("Mt5-xl")
device_map = {
0: [0, 1, 2],
1: [3, 4, 5, 6, 7, 8, 9],
2: [10, 11, 12, 13, 14, 15, 16],
3: [17, 18, 19, 20, 21, 22, 23],
}
model.parallelize(device_map) # Splits the model across several devices
model.deparallelize() # Put the model back on cpu and cleans memory by calling torch.cuda.empty_cache()forward
< 來源 >( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.FloatTensor] = None decoder_input_ids: typing.Optional[torch.LongTensor] = None decoder_attention_mask: typing.Optional[torch.BoolTensor] = None head_mask: typing.Optional[torch.FloatTensor] = None decoder_head_mask: typing.Optional[torch.FloatTensor] = None cross_attn_head_mask: typing.Optional[torch.Tensor] = None encoder_outputs: typing.Optional[tuple[tuple[torch.FloatTensor]]] = None past_key_values: typing.Optional[tuple[tuple[torch.FloatTensor]]] = 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 cache_position: typing.Optional[torch.LongTensor] = None ) → transformers.modeling_outputs.Seq2SeqModelOutput or tuple(torch.FloatTensor)
引數
- input_ids (
torch.LongTensor，形狀為(batch_size, sequence_length)) — 詞彙表中輸入序列標記的索引。MT5 是一個具有相對位置嵌入的模型，因此您應該能夠在輸入的左側和右側進行填充。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
要了解更多關於如何為預訓練準備
input_ids的資訊，請檢視 MT5 訓練。 - attention_mask (
torch.FloatTensor，形狀為(batch_size, sequence_length), 可選) — 用於避免對填充標記索引執行注意力操作的掩碼。掩碼值在[0, 1]中選擇：- 1 表示標記未被掩碼，
- 0 表示標記已被掩碼。
- decoder_input_ids (
torch.LongTensor，形狀為(batch_size, target_sequence_length), 可選) — 詞彙表中解碼器輸入序列標記的索引。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
MT5 使用
pad_token_id作為生成decoder_input_ids的起始標記。如果使用past_key_values，則可以選擇只輸入最後一個decoder_input_ids（參見past_key_values）。要了解更多關於如何為預訓練準備
decoder_input_ids的資訊，請檢視 MT5 訓練。 - decoder_attention_mask (
torch.BoolTensor，形狀為(batch_size, target_sequence_length), 可選) — 預設行為：生成一個忽略decoder_input_ids中填充標記的張量。預設情況下也會使用因果掩碼。 - head_mask (
torch.FloatTensor，形狀為(num_heads,)或(num_layers, num_heads), 可選) — 用於置零自注意力模組中選定頭的掩碼。掩碼值在[0, 1]中選擇：- 1 表示該頭未被掩碼，
- 0 表示該頭已被掩碼。
- decoder_head_mask (
torch.FloatTensor，形狀為(num_heads,)或(num_layers, num_heads), 可選) — 用於置零解碼器中自注意力模組選定頭的掩碼。掩碼值在[0, 1]中選擇：- 1 表示該頭未被掩碼，
- 0 表示該頭已被掩碼。
- cross_attn_head_mask (
torch.Tensor，形狀為(num_heads,)或(num_layers, num_heads), 可選) — 用於置零解碼器中交叉注意力模組選定頭的掩碼。掩碼值在[0, 1]中選擇：- 1 表示該頭未被掩碼，
- 0 表示該頭已被掩碼。
- encoder_outputs (
tuple[tuple[torch.FloatTensor]], 可選) — 元組包含 (last_hidden_state, 可選:hidden_states, 可選:attentions)last_hidden_state形狀為(batch_size, sequence_length, hidden_size)，可選) 是編碼器最後一層輸出的隱藏狀態序列。用於解碼器的交叉注意力。 - past_key_values (
tuple[tuple[torch.FloatTensor]], 可選) — 預先計算的隱藏狀態（自注意力和交叉注意力塊中的鍵和值），可用於加速順序解碼。這通常是在解碼的前一個階段，當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（那些沒有給出其過去鍵值狀態的 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 而不是一個普通的元組。 - cache_position (
torch.LongTensor，形狀為(sequence_length), 可選) — 描繪輸入序列標記在序列中位置的索引。與position_ids相反，此張量不受填充影響。它用於在正確的位置更新快取並推斷完整的序列長度。
返回
transformers.modeling_outputs.Seq2SeqModelOutput 或 tuple(torch.FloatTensor)
一個 transformers.modeling_outputs.Seq2SeqModelOutput 或一個 torch.FloatTensor 元組（如果傳遞了 return_dict=False 或當 config.return_dict=False 時），根據配置 (MT5Config) 和輸入包含各種元素。
-
last_hidden_state (
torch.FloatTensor，形狀為(batch_size, sequence_length, hidden_size)) — 模型解碼器最後一層輸出的隱藏狀態序列。如果使用了
past_key_values，則只輸出形狀為(batch_size, 1, hidden_size)的序列的最後一個隱藏狀態。 -
past_key_values (
EncoderDecoderCache, 可選, 當傳遞use_cache=True或config.use_cache=True時返回) — 這是一個 EncoderDecoderCache 例項。更多詳情，請參閱我們的 kv 快取指南。包含預先計算的隱藏狀態（自注意力塊和交叉注意力塊中的鍵和值），可用於（參見
past_key_values輸入）加速順序解碼。 -
decoder_hidden_states (
tuple(torch.FloatTensor), 可選, 當傳遞output_hidden_states=True或config.output_hidden_states=True時返回) — 形狀為(batch_size, sequence_length, hidden_size)的torch.FloatTensor元組（一個用於嵌入層的輸出，如果模型有嵌入層，+ 一個用於每層的輸出）。解碼器在每個層輸出的隱藏狀態，加上可選的初始嵌入輸出。
-
decoder_attentions (
tuple(torch.FloatTensor), 可選, 當傳遞output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元組（每層一個）。解碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均。
-
cross_attentions (
tuple(torch.FloatTensor), 可選, 當傳遞output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元組（每層一個）。解碼器交叉注意力層的注意力權重，在注意力 softmax 之後，用於計算交叉注意力頭中的加權平均。
-
encoder_last_hidden_state (
torch.FloatTensor，形狀為(batch_size, sequence_length, hidden_size)，可選) — 模型編碼器最後一層輸出的隱藏狀態序列。 -
encoder_hidden_states (
tuple(torch.FloatTensor), 可選, 當傳遞output_hidden_states=True或config.output_hidden_states=True時返回) — 形狀為(batch_size, sequence_length, hidden_size)的torch.FloatTensor元組（一個用於嵌入層的輸出，如果模型有嵌入層，+ 一個用於每層的輸出）。編碼器在每個層輸出的隱藏狀態，加上可選的初始嵌入輸出。
-
encoder_attentions (
tuple(torch.FloatTensor), 可選, 當傳遞output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元組（每層一個）。編碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均。
MT5Model 的 forward 方法重寫了 __call__ 特殊方法。
雖然前向傳播的流程需要在此函式內定義，但之後應該呼叫 `Module` 例項而不是此函式，因為前者會處理執行前處理和後處理步驟，而後者會靜默地忽略它們。
示例
>>> from transformers import AutoTokenizer, MT5Model
>>> tokenizer = AutoTokenizer.from_pretrained("google/mt5-small")
>>> model = MT5Model.from_pretrained("google/mt5-small")
>>> 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
>>> # preprocess: Prepend decoder_input_ids with start token which is pad token for MT5Model.
>>> # This is not needed for torch's MT5ForConditionalGeneration as it does this internally using labels arg.
>>> decoder_input_ids = model._shift_right(decoder_input_ids)
>>> # forward pass
>>> outputs = model(input_ids=input_ids, decoder_input_ids=decoder_input_ids)
>>> last_hidden_states = outputs.last_hidden_stateparallelize
< 來源 >( device_map = None )
這是一個實驗性功能，隨時可能更改。
使用裝置對映將模型的注意力模組分佈到多個裝置上。如果沒有給出裝置對映，它將均勻地將塊分佈到所有裝置上。
示例
# Here is an example of a device map on a machine with 4 GPUs using mt5-xl, which has a total of 24 attention modules:
model = MT5ForConditionalGeneration.from_pretrained("mt5-xl")
device_map = {
0: [0, 1, 2],
1: [3, 4, 5, 6, 7, 8, 9],
2: [10, 11, 12, 13, 14, 15, 16],
3: [17, 18, 19, 20, 21, 22, 23],
}
model.parallelize(device_map)MT5ForConditionalGeneration
class transformers.MT5ForConditionalGeneration
< 來源 >( config: MT5Config )
引數
- config (MT5Config) — 包含模型所有引數的模型配置類。使用配置檔案進行初始化不會載入與模型相關的權重，只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。
MT5 模型，頂部帶有一個 `語言建模` 頭。
此模型繼承自 PreTrainedModel。請檢視超類文件，瞭解該庫為其所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪注意力頭等）。
該模型也是一個 PyTorch torch.nn.Module 的子類。可以像常規的 PyTorch 模組一樣使用它，並參考 PyTorch 文件瞭解所有與通用用法和行為相關的事項。
將模型從模型並行狀態移至 CPU。
示例
# On a 4 GPU machine with mt5-xl:
model = MT5ForConditionalGeneration.from_pretrained("Mt5-xl")
device_map = {
0: [0, 1, 2],
1: [3, 4, 5, 6, 7, 8, 9],
2: [10, 11, 12, 13, 14, 15, 16],
3: [17, 18, 19, 20, 21, 22, 23],
}
model.parallelize(device_map) # Splits the model across several devices
model.deparallelize() # Put the model back on cpu and cleans memory by calling torch.cuda.empty_cache()forward
< 來源 >( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.FloatTensor] = None decoder_input_ids: typing.Optional[torch.LongTensor] = None decoder_attention_mask: typing.Optional[torch.BoolTensor] = None head_mask: typing.Optional[torch.FloatTensor] = None decoder_head_mask: typing.Optional[torch.FloatTensor] = None cross_attn_head_mask: typing.Optional[torch.Tensor] = None encoder_outputs: typing.Optional[tuple[tuple[torch.Tensor]]] = None past_key_values: typing.Optional[tuple[tuple[torch.Tensor]]] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None decoder_inputs_embeds: typing.Optional[torch.FloatTensor] = None labels: typing.Optional[torch.LongTensor] = 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 cache_position: typing.Optional[torch.LongTensor] = None ) → transformers.modeling_outputs.Seq2SeqLMOutput or tuple(torch.FloatTensor)
引數
- input_ids (
torch.LongTensor，形狀為(batch_size, sequence_length)) — 詞彙表中輸入序列標記的索引。MT5 是一個具有相對位置嵌入的模型，因此您應該能夠在輸入的左側和右側進行填充。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
要了解更多關於如何為預訓練準備
input_ids的資訊，請檢視 MT5 訓練。 - attention_mask (
torch.FloatTensor，形狀為(batch_size, sequence_length), 可選) — 用於避免對填充標記索引執行注意力操作的掩碼。掩碼值在[0, 1]中選擇：- 1 表示標記未被掩碼，
- 0 表示標記已被掩碼。
- decoder_input_ids (
torch.LongTensor，形狀為(batch_size, target_sequence_length), 可選) — 詞彙表中解碼器輸入序列標記的索引。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
MT5 使用
pad_token_id作為生成decoder_input_ids的起始標記。如果使用past_key_values，則可以選擇只輸入最後一個decoder_input_ids（參見past_key_values）。要了解更多關於如何為預訓練準備
decoder_input_ids的資訊，請檢視 MT5 訓練。 - decoder_attention_mask (
torch.BoolTensor，形狀為(batch_size, target_sequence_length), 可選) — 預設行為：生成一個忽略decoder_input_ids中填充標記的張量。預設情況下也會使用因果掩碼。 - head_mask (
torch.FloatTensor，形狀為(num_heads,)或(num_layers, num_heads), 可選) — 用於置零自注意力模組中選定頭的掩碼。掩碼值在[0, 1]中選擇：- 1 表示該頭未被掩碼，
- 0 表示該頭已被掩碼。
- decoder_head_mask (
torch.FloatTensor，形狀為(num_heads,)或(num_layers, num_heads), 可選) — 用於置零解碼器中自注意力模組選定頭的掩碼。掩碼值在[0, 1]中選擇：- 1 表示該頭未被掩碼，
- 0 表示該頭已被掩碼。
- cross_attn_head_mask (
torch.Tensor，形狀為(num_heads,)或(num_layers, num_heads), 可選) — 用於置零解碼器中交叉注意力模組選定頭的掩碼。掩碼值在[0, 1]中選擇：- 1 表示該頭未被掩碼，
- 0 表示該頭已被掩碼。
- encoder_outputs (
tuple[tuple[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（那些沒有給出其過去鍵值狀態的 ID），形狀為(batch_size, 1)，而不是所有形狀為(batch_size, sequence_length)的input_ids。 - inputs_embeds (
torch.FloatTensor，形狀為(batch_size, sequence_length, hidden_size), 可選) — 或者，您可以選擇直接傳遞嵌入表示，而不是傳遞input_ids。如果您想比模型內部的嵌入查詢矩陣更好地控制如何將input_ids索引轉換為關聯向量，這會很有用。 - decoder_inputs_embeds (
torch.FloatTensor，形狀為(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，形狀為(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。 - return_dict (
bool, 可選) — 是否返回一個 ModelOutput 而不是一個普通的元組。 - cache_position (
torch.LongTensor，形狀為(sequence_length), 可選) — 描繪輸入序列標記在序列中位置的索引。與position_ids相反，此張量不受填充影響。它用於在正確的位置更新快取並推斷完整的序列長度。
返回
transformers.modeling_outputs.Seq2SeqLMOutput 或 tuple(torch.FloatTensor)
一個 transformers.modeling_outputs.Seq2SeqLMOutput 或一個 torch.FloatTensor 元組（如果傳遞了 return_dict=False 或當 config.return_dict=False 時），根據配置 (MT5Config) 和輸入包含各種元素。
-
loss (
torch.FloatTensor，形狀為(1,)，可選，當提供labels時返回) — 語言建模損失。 -
logits (形狀為
(batch_size, sequence_length, config.vocab_size)的torch.FloatTensor) — 語言建模頭部的預測分數（SoftMax 之前的每個詞彙標記的分數）。 -
past_key_values (
EncoderDecoderCache, 可選, 當傳遞use_cache=True或config.use_cache=True時返回) — 這是一個 EncoderDecoderCache 例項。更多詳情，請參閱我們的 kv 快取指南。包含預先計算的隱藏狀態（自注意力塊和交叉注意力塊中的鍵和值），可用於（參見
past_key_values輸入）加速順序解碼。 -
decoder_hidden_states (
tuple(torch.FloatTensor), 可選, 當傳遞output_hidden_states=True或config.output_hidden_states=True時返回) — 形狀為(batch_size, sequence_length, hidden_size)的torch.FloatTensor元組（一個用於嵌入層的輸出，如果模型有嵌入層，+ 一個用於每層的輸出）。解碼器在每一層輸出時的隱藏狀態以及初始嵌入輸出。
-
decoder_attentions (
tuple(torch.FloatTensor), 可選, 當傳遞output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元組（每層一個）。解碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均。
-
cross_attentions (
tuple(torch.FloatTensor), 可選, 當傳遞output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元組（每層一個）。解碼器交叉注意力層的注意力權重，在注意力 softmax 之後，用於計算交叉注意力頭中的加權平均。
-
encoder_last_hidden_state (
torch.FloatTensor，形狀為(batch_size, sequence_length, hidden_size)，可選) — 模型編碼器最後一層輸出的隱藏狀態序列。 -
encoder_hidden_states (
tuple(torch.FloatTensor), 可選, 當傳遞output_hidden_states=True或config.output_hidden_states=True時返回) — 形狀為(batch_size, sequence_length, hidden_size)的torch.FloatTensor元組（一個用於嵌入層的輸出，如果模型有嵌入層，+ 一個用於每層的輸出）。編碼器在每一層輸出時的隱藏狀態以及初始嵌入輸出。
-
encoder_attentions (
tuple(torch.FloatTensor), 可選, 當傳遞output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元組（每層一個）。編碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均。
MT5ForConditionalGeneration 的 forward 方法重寫了 __call__ 特殊方法。
雖然前向傳播的流程需要在此函式內定義，但之後應該呼叫 `Module` 例項而不是此函式，因為前者會處理執行前處理和後處理步驟，而後者會靜默地忽略它們。
示例
>>> from transformers import AutoTokenizer, MT5ForConditionalGeneration
>>> tokenizer = AutoTokenizer.from_pretrained("google/mt5-small")
>>> model = MT5ForConditionalGeneration.from_pretrained("google/mt5-small")
>>> # training
>>> input_ids = tokenizer("The <extra_id_0> walks in <extra_id_1> park", return_tensors="pt").input_ids
>>> labels = tokenizer("<extra_id_0> cute dog <extra_id_1> the <extra_id_2>", return_tensors="pt").input_ids
>>> outputs = model(input_ids=input_ids, labels=labels)
>>> loss = outputs.loss
>>> logits = outputs.logits
>>> # inference
>>> input_ids = tokenizer(
... "summarize: studies have shown that owning a dog is good for you", return_tensors="pt"
... ).input_ids # Batch size 1
>>> outputs = model.generate(input_ids)
>>> print(tokenizer.decode(outputs[0], skip_special_tokens=True))
>>> # studies have shown that owning a dog is good for you.parallelize
< 原始碼 >( device_map = None )
這是一個實驗性功能，隨時可能更改。
使用裝置對映將模型的注意力模組分佈到多個裝置上。如果沒有給出裝置對映，它將均勻地將塊分佈到所有裝置上。
示例
# Here is an example of a device map on a machine with 4 GPUs using mt5-xl, which has a total of 24 attention modules:
model = MT5ForConditionalGeneration.from_pretrained("mt5-xl")
device_map = {
0: [0, 1, 2],
1: [3, 4, 5, 6, 7, 8, 9],
2: [10, 11, 12, 13, 14, 15, 16],
3: [17, 18, 19, 20, 21, 22, 23],
}
model.parallelize(device_map)MT5EncoderModel
class transformers.MT5EncoderModel
< 原始碼 >( config: MT5Config )
引數
- config (MT5Config) — 包含模型所有引數的模型配置類。使用配置檔案進行初始化不會載入與模型相關的權重，只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。
裸的Mt5模型，輸出原始的隱藏狀態，頂部沒有任何特定的頭。
此模型繼承自 PreTrainedModel。請檢視超類文件，瞭解該庫為其所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪注意力頭等）。
該模型也是一個 PyTorch torch.nn.Module 的子類。可以像常規的 PyTorch 模組一樣使用它，並參考 PyTorch 文件瞭解所有與通用用法和行為相關的事項。
將模型從模型並行狀態移至 CPU。
示例
# On a 4 GPU machine with mt5-xl:
model = MT5ForConditionalGeneration.from_pretrained("Mt5-xl")
device_map = {
0: [0, 1, 2],
1: [3, 4, 5, 6, 7, 8, 9],
2: [10, 11, 12, 13, 14, 15, 16],
3: [17, 18, 19, 20, 21, 22, 23],
}
model.parallelize(device_map) # Splits the model across several devices
model.deparallelize() # Put the model back on cpu and cleans memory by calling torch.cuda.empty_cache()forward
< 原始碼 >( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[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.modeling_outputs.BaseModelOutput 或 tuple(torch.FloatTensor)
引數
- input_ids (
torch.LongTensor，形狀為(batch_size, sequence_length)) — 詞彙表中輸入序列標記的索引。MT5 是一個具有相對位置嵌入的模型，因此您應該能夠在輸入的左右兩側進行填充。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
要了解如何為預訓練準備
input_ids，請參閱 MT5 訓練。 - attention_mask (
torch.FloatTensor，形狀為(batch_size, sequence_length)，可選) — 用於避免對填充標記索引執行注意力的掩碼。掩碼值選自[0, 1]：- 1 表示標記未被遮蔽，
- 0 表示標記被遮蔽。
- 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.modeling_outputs.BaseModelOutput 或 tuple(torch.FloatTensor)
一個 transformers.modeling_outputs.BaseModelOutput 或一個 torch.FloatTensor 元組（如果傳遞了 return_dict=False 或 config.return_dict=False），包含根據配置（MT5Config）和輸入的不同元素。
-
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 後的注意力權重，用於計算自注意力頭中的加權平均值。
MT5EncoderModel 的前向方法，覆蓋了 __call__ 特殊方法。
雖然前向傳播的流程需要在此函式內定義，但之後應該呼叫 `Module` 例項而不是此函式，因為前者會處理執行前處理和後處理步驟，而後者會靜默地忽略它們。
示例
>>> from transformers import AutoTokenizer, MT5EncoderModel
>>> tokenizer = AutoTokenizer.from_pretrained("google/mt5-small")
>>> model = MT5EncoderModel.from_pretrained("google/mt5-small")
>>> input_ids = tokenizer(
... "Studies have been shown that owning a dog is good for you", return_tensors="pt"
... ).input_ids # Batch size 1
>>> outputs = model(input_ids=input_ids)
>>> last_hidden_states = outputs.last_hidden_stateparallelize
< 原始碼 >( device_map = None )
這是一個實驗性功能，隨時可能更改。
使用裝置對映將模型的注意力模組分佈到多個裝置上。如果沒有給出裝置對映，它將均勻地將塊分佈到所有裝置上。
示例
# Here is an example of a device map on a machine with 4 GPUs using mt5-xl, which has a total of 24 attention modules:
model = MT5ForConditionalGeneration.from_pretrained("mt5-xl")
device_map = {
0: [0, 1, 2],
1: [3, 4, 5, 6, 7, 8, 9],
2: [10, 11, 12, 13, 14, 15, 16],
3: [17, 18, 19, 20, 21, 22, 23],
}
model.parallelize(device_map)MT5ForSequenceClassification
class transformers.MT5ForSequenceClassification
< 原始碼 >( config: MT5Config )
引數
- config (MT5Config) — 包含模型所有引數的模型配置類。使用配置檔案進行初始化不會載入與模型相關的權重，只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。
帶序列分類/頭的 MT5 模型（在池化輸出之上加一個線性層），例如用於 GLUE 任務。
此模型繼承自 PreTrainedModel。請檢視超類文件，瞭解該庫為其所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪注意力頭等）。
該模型也是一個 PyTorch torch.nn.Module 的子類。可以像常規的 PyTorch 模組一樣使用它，並參考 PyTorch 文件瞭解所有與通用用法和行為相關的事項。
forward
< 原始碼 >( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.Tensor] = None decoder_input_ids: typing.Optional[torch.LongTensor] = None decoder_attention_mask: typing.Optional[torch.LongTensor] = 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[list[torch.FloatTensor]] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None decoder_inputs_embeds: typing.Optional[torch.FloatTensor] = None labels: typing.Optional[torch.LongTensor] = 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.modeling_outputs.Seq2SeqSequenceClassifierOutput 或 tuple(torch.FloatTensor)
引數
- input_ids (
torch.LongTensor，形狀為(batch_size, sequence_length)) — 詞彙表中輸入序列標記的索引。MT5 是一個具有相對位置嵌入的模型，因此您應該能夠在輸入的左右兩側進行填充。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
要了解如何為預訓練準備
input_ids，請參閱 MT5 訓練。 - 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()。
MT5 使用
pad_token_id作為生成decoder_input_ids的起始標記。如果使用past_key_values，可以選擇只輸入最後一個decoder_input_ids（請參閱past_key_values）。要了解如何為預訓練準備
decoder_input_ids，請參閱 MT5 訓練。 - 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.FloatTensor，形狀為(num_heads,)或(num_layers, num_heads)，可選) — 用於置零解碼器中自注意力模組選定頭的掩碼。掩碼值選自[0, 1]：- 1 表示頭未被遮蔽，
- 0 表示頭被遮蔽。
- cross_attn_head_mask (
torch.Tensor，形狀為(num_heads,)或(num_layers, num_heads)，可選) — 用於置零解碼器中交叉注意力模組選定頭的掩碼。掩碼值選自[0, 1]：- 1 表示頭未被遮蔽，
- 0 表示頭被遮蔽。
- encoder_outputs (
list[torch.FloatTensor]，可選) — 元組包含 (last_hidden_state，可選:hidden_states，可選:attentions)。last_hidden_state形狀為(batch_size, sequence_length, hidden_size)，可選) 是編碼器最後一層輸出的隱藏狀態序列。用於解碼器的交叉注意力。 - inputs_embeds (
torch.FloatTensor，形狀為(batch_size, sequence_length, hidden_size)，可選) — 可選地，您可以選擇直接傳遞嵌入表示，而不是傳遞input_ids。如果您想比模型的內部嵌入查詢矩陣更多地控制如何將input_ids索引轉換為關聯向量，這將非常有用。 - decoder_inputs_embeds (
torch.FloatTensor，形狀為(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，形狀為(batch_size,)，可選) — 用於計算序列分類/迴歸損失的標籤。索引應在[0, ..., config.num_labels - 1]範圍內。如果config.num_labels > 1，則計算分類損失（交叉熵）。 - 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.modeling_outputs.Seq2SeqSequenceClassifierOutput 或 tuple(torch.FloatTensor)
一個 transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput 或一個 torch.FloatTensor 元組（如果傳遞了 return_dict=False 或 config.return_dict=False），包含根據配置（MT5Config）和輸入的不同元素。
-
loss (形狀為
(1,)的torch.FloatTensor，可選，當提供label時返回) — 分類 (如果 config.num_labels==1 則為迴歸) 損失。 -
logits (形狀為
(batch_size, config.num_labels)的torch.FloatTensor) — 分類（如果 config.num_labels==1，則為迴歸）分數（SoftMax 之前）。 -
past_key_values (
EncoderDecoderCache, 可選, 當傳遞use_cache=True或config.use_cache=True時返回) — 這是一個 EncoderDecoderCache 例項。更多詳情，請參閱我們的 kv 快取指南。包含預先計算的隱藏狀態（自注意力塊和交叉注意力塊中的鍵和值），可用於（參見
past_key_values輸入）加速順序解碼。 -
decoder_hidden_states (
tuple(torch.FloatTensor), 可選, 當傳遞output_hidden_states=True或config.output_hidden_states=True時返回) — 形狀為(batch_size, sequence_length, hidden_size)的torch.FloatTensor元組（一個用於嵌入層的輸出，如果模型有嵌入層，+ 一個用於每層的輸出）。解碼器在每一層輸出時的隱藏狀態以及初始嵌入輸出。
-
decoder_attentions (
tuple(torch.FloatTensor), 可選, 當傳遞output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元組（每層一個）。解碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均。
-
cross_attentions (
tuple(torch.FloatTensor), 可選, 當傳遞output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元組（每層一個）。解碼器交叉注意力層的注意力權重，在注意力 softmax 之後，用於計算交叉注意力頭中的加權平均。
-
encoder_last_hidden_state (
torch.FloatTensor，形狀為(batch_size, sequence_length, hidden_size)，可選) — 模型編碼器最後一層輸出的隱藏狀態序列。 -
encoder_hidden_states (
tuple(torch.FloatTensor), 可選, 當傳遞output_hidden_states=True或config.output_hidden_states=True時返回) — 形狀為(batch_size, sequence_length, hidden_size)的torch.FloatTensor元組（一個用於嵌入層的輸出，如果模型有嵌入層，+ 一個用於每層的輸出）。編碼器在每一層輸出時的隱藏狀態以及初始嵌入輸出。
-
encoder_attentions (
tuple(torch.FloatTensor), 可選, 當傳遞output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元組（每層一個）。編碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均。
MT5ForSequenceClassification 的前向方法，覆蓋了 __call__ 特殊方法。
雖然前向傳播的流程需要在此函式內定義，但之後應該呼叫 `Module` 例項而不是此函式，因為前者會處理執行前處理和後處理步驟，而後者會靜默地忽略它們。
單標籤分類示例
>>> import torch
>>> from transformers import AutoTokenizer, MT5ForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("google/mt5-small")
>>> model = MT5ForSequenceClassification.from_pretrained("google/mt5-small")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> predicted_class_id = logits.argmax().item()
>>> model.config.id2label[predicted_class_id]
...
>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = MT5ForSequenceClassification.from_pretrained("google/mt5-small", num_labels=num_labels)
>>> labels = torch.tensor([1])
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
...多標籤分類示例
>>> import torch
>>> from transformers import AutoTokenizer, MT5ForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("google/mt5-small")
>>> model = MT5ForSequenceClassification.from_pretrained("google/mt5-small", 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 = MT5ForSequenceClassification.from_pretrained(
... "google/mt5-small", 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).lossMT5ForTokenClassification
class transformers.MT5ForTokenClassification
< 原始碼 >( config: MT5Config )
引數
- config (MT5Config) — 包含模型所有引數的模型配置類。使用配置檔案進行初始化不會載入與模型相關的權重，只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。
帶標記分類頭的 Mt5 transformer 模型（在隱藏狀態輸出之上加一個線性層），例如用於命名實體識別（NER）任務。
此模型繼承自 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 labels: 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.TokenClassifierOutput 或 tuple(torch.FloatTensor)
引數
- input_ids (
torch.LongTensor，形狀為(batch_size, sequence_length)) — 詞彙表中輸入序列標記的索引。MT5 是一個具有相對位置嵌入的模型，因此您應該能夠在輸入的左右兩側進行填充。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
要了解如何為預訓練準備
input_ids，請參閱 MT5 訓練。 - 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索引轉換為關聯向量，這將非常有用。 - labels (
torch.LongTensor，形狀為(batch_size, sequence_length)，可選) — 用於計算標記分類損失的標籤。索引應在[0, ..., config.num_labels - 1]範圍內。 - output_attentions (
bool，可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊，請參閱返回張量下的attentions。 - output_hidden_states (
bool，可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊，請參閱返回張量下的hidden_states。 - return_dict (
bool, 可選) — 是否返回一個 ModelOutput 而不是一個普通的元組。
返回
transformers.modeling_outputs.TokenClassifierOutput 或 tuple(torch.FloatTensor)
一個 transformers.modeling_outputs.TokenClassifierOutput 或一個 torch.FloatTensor 的元組（如果傳遞了 return_dict=False 或當 config.return_dict=False 時），包含根據配置（MT5Config）和輸入而異的各種元素。
-
loss (形狀為
(1,)的torch.FloatTensor，可選，當提供labels時返回) — 分類損失。 -
logits (形狀為
(batch_size, sequence_length, config.num_labels)的torch.FloatTensor) — 分類分數（SoftMax 之前）。 -
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 後的注意力權重，用於計算自注意力頭中的加權平均值。
MT5ForTokenClassification 的 forward 方法會覆蓋 __call__ 特殊方法。
雖然前向傳播的流程需要在此函式內定義，但之後應該呼叫 `Module` 例項而不是此函式，因為前者會處理執行前處理和後處理步驟，而後者會靜默地忽略它們。
示例
>>> from transformers import AutoTokenizer, MT5ForTokenClassification
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("google/mt5-small")
>>> model = MT5ForTokenClassification.from_pretrained("google/mt5-small")
>>> inputs = tokenizer(
... "HuggingFace is a company based in Paris and New York", add_special_tokens=False, return_tensors="pt"
... )
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> predicted_token_class_ids = logits.argmax(-1)
>>> # Note that tokens are classified rather then input words which means that
>>> # there might be more predicted token classes than words.
>>> # Multiple token classes might account for the same word
>>> predicted_tokens_classes = [model.config.id2label[t.item()] for t in predicted_token_class_ids[0]]
>>> predicted_tokens_classes
...
>>> labels = predicted_token_class_ids
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
...MT5ForQuestionAnswering
class transformers.MT5ForQuestionAnswering
< 來源 >( config: MT5Config )
引數
- config (MT5Config) — 包含模型所有引數的模型配置類。使用配置檔案進行初始化不會載入與模型關聯的權重，只會載入配置。請檢視 from_pretrained() 方法以載入模型權重。
Mt5 transformer，頂部帶有一個用於抽取式問答任務（如 SQuAD）的片段分類頭（一個位於隱藏狀態輸出之上的線性層，用於計算 `span start logits` 和 `span end logits`）。
此模型繼承自 PreTrainedModel。請檢視超類文件，瞭解該庫為其所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪注意力頭等）。
該模型也是一個 PyTorch torch.nn.Module 的子類。可以像常規的 PyTorch 模組一樣使用它，並參考 PyTorch 文件瞭解所有與通用用法和行為相關的事項。
forward
< 來源 >( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.FloatTensor] = None decoder_input_ids: typing.Optional[torch.LongTensor] = None decoder_attention_mask: typing.Optional[torch.BoolTensor] = None head_mask: typing.Optional[torch.FloatTensor] = None decoder_head_mask: typing.Optional[torch.FloatTensor] = None cross_attn_head_mask: typing.Optional[torch.Tensor] = None encoder_outputs: typing.Optional[tuple[tuple[torch.Tensor]]] = None start_positions: typing.Optional[torch.LongTensor] = None end_positions: typing.Optional[torch.LongTensor] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None decoder_inputs_embeds: typing.Optional[torch.FloatTensor] = 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.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput 或 tuple(torch.FloatTensor)
引數
- input_ids (
torch.LongTensor，形狀為(batch_size, sequence_length)) — 詞彙表中輸入序列標記的索引。T5 是一個帶有相對位置嵌入的模型，因此你應該能夠對輸入的左右兩側進行填充。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
要了解更多關於如何為預訓練準備
input_ids的資訊，請參閱 T5 訓練。 - attention_mask (
torch.FloatTensor，形狀為(batch_size, sequence_length)，可選) — 掩碼，用於避免對填充標記索引執行注意力操作。掩碼值選自[0, 1]：- 1 表示標記未被遮蓋，
- 0 表示標記被遮蓋。
- decoder_input_ids (
torch.LongTensor，形狀為(batch_size, target_sequence_length)，可選) — 詞彙表中解碼器輸入序列標記的索引。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
T5 使用 `pad_token_id` 作為生成 `decoder_input_ids` 的起始標記。如果使用了 `past_key_values`，則可以選擇只輸入最後的 `decoder_input_ids`（參見 `past_key_values`）。
要了解更多關於如何為預訓練準備 `decoder_input_ids` 的資訊，請參閱 T5 訓練。
- decoder_attention_mask (
torch.BoolTensor，形狀為(batch_size, target_sequence_length)，可選) — 預設行為：生成一個忽略 `decoder_input_ids` 中填充標記的張量。預設情況下也會使用因果掩碼。 - head_mask (
torch.FloatTensor，形狀為(num_heads,)或(num_layers, num_heads)，可選) — 掩碼，用於將自注意力模組中選定的頭置零。掩碼值選自[0, 1]：- 1 表示頭未被遮蓋，
- 0 表示頭被遮蓋。
- decoder_head_mask (
torch.FloatTensor，形狀為(num_heads,)或(num_layers, num_heads)，可選) — 掩碼，用於將解碼器中自注意力模組的選定頭置零。掩碼值選自[0, 1]：- 1 表示頭未被遮蓋，
- 0 表示頭被遮蓋。
- cross_attn_head_mask (
torch.Tensor，形狀為(num_heads,)或(num_layers, num_heads)，可選) — 掩碼，用於將解碼器中交叉注意力模組的選定頭置零。掩碼值選自[0, 1]：- 1 表示頭未被遮蓋，
- 0 表示頭被遮蓋。
- encoder_outputs (
tuple[tuple[torch.Tensor]], 可選) — 元組包含 (last_hidden_state, 可選:hidden_states, 可選:attentions)。形狀為(batch_size, sequence_length, hidden_size)的 `last_hidden_state` 是編碼器最後一層輸出的隱藏狀態序列。用於解碼器的交叉注意力機制中。 - start_positions (
torch.LongTensor，形狀為(batch_size,)，可選) — 標記片段開始位置（索引）的標籤，用於計算標記分類損失。位置被限制在序列長度（sequence_length）範圍內。序列之外的位置不計入損失計算。 - end_positions (
torch.LongTensor，形狀為(batch_size,)，可選) — 標記片段結束位置（索引）的標籤，用於計算標記分類損失。位置被限制在序列長度（sequence_length）範圍內。序列之外的位置不計入損失計算。 - inputs_embeds (
torch.FloatTensor，形狀為(batch_size, sequence_length, hidden_size)，可選) — 可選地，你可以選擇直接傳遞嵌入表示而不是傳遞input_ids。如果你希望對如何將input_ids索引轉換為關聯向量進行更多控制，而不是使用模型的內部嵌入查詢矩陣，這會很有用。 - decoder_inputs_embeds (
torch.FloatTensor，形狀為(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.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput 或 tuple(torch.FloatTensor)
一個 transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput 或一個 torch.FloatTensor 的元組（如果傳遞了 return_dict=False 或當 config.return_dict=False 時），包含根據配置（MT5Config）和輸入而異的各種元素。
-
loss (
torch.FloatTensorof shape(1,), 可選, 當提供labels時返回) — 總範圍提取損失是起始位置和結束位置的交叉熵之和。 -
start_logits (
torch.FloatTensorof shape(batch_size, sequence_length)) — 範圍起始分數（SoftMax 之前）。 -
end_logits (
torch.FloatTensorof shape(batch_size, sequence_length)) — 範圍結束分數（SoftMax 之前）。 -
past_key_values (
EncoderDecoderCache, 可選, 當傳遞use_cache=True或config.use_cache=True時返回) — 這是一個 EncoderDecoderCache 例項。更多詳情，請參閱我們的 kv 快取指南。包含預先計算的隱藏狀態（自注意力塊和交叉注意力塊中的鍵和值），可用於（參見
past_key_values輸入）加速順序解碼。 -
decoder_hidden_states (
tuple(torch.FloatTensor), 可選, 當傳遞output_hidden_states=True或config.output_hidden_states=True時返回) — 形狀為(batch_size, sequence_length, hidden_size)的torch.FloatTensor元組（一個用於嵌入層的輸出，如果模型有嵌入層，+ 一個用於每層的輸出）。解碼器在每一層輸出時的隱藏狀態以及初始嵌入輸出。
-
decoder_attentions (
tuple(torch.FloatTensor), 可選, 當傳遞output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元組（每層一個）。解碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均。
-
cross_attentions (
tuple(torch.FloatTensor), 可選, 當傳遞output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元組（每層一個）。解碼器交叉注意力層的注意力權重，在注意力 softmax 之後，用於計算交叉注意力頭中的加權平均。
-
encoder_last_hidden_state (
torch.FloatTensor，形狀為(batch_size, sequence_length, hidden_size)，可選) — 模型編碼器最後一層輸出的隱藏狀態序列。 -
encoder_hidden_states (
tuple(torch.FloatTensor), 可選, 當傳遞output_hidden_states=True或config.output_hidden_states=True時返回) — 形狀為(batch_size, sequence_length, hidden_size)的torch.FloatTensor元組（一個用於嵌入層的輸出，如果模型有嵌入層，+ 一個用於每層的輸出）。編碼器在每一層輸出時的隱藏狀態以及初始嵌入輸出。
-
encoder_attentions (
tuple(torch.FloatTensor), 可選, 當傳遞output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元組（每層一個）。編碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均。
MT5ForQuestionAnswering 的 forward 方法會覆蓋 __call__ 特殊方法。
雖然前向傳播的流程需要在此函式內定義，但之後應該呼叫 `Module` 例項而不是此函式，因為前者會處理執行前處理和後處理步驟，而後者會靜默地忽略它們。
示例
>>> from transformers import AutoTokenizer, MT5ForQuestionAnswering
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("google/mt5-small")
>>> model = MT5ForQuestionAnswering.from_pretrained("google/mt5-small")
>>> question, text = "Who was Jim Henson?", "Jim Henson was a nice puppet"
>>> inputs = tokenizer(question, text, return_tensors="pt")
>>> with torch.no_grad():
... outputs = model(**inputs)
>>> answer_start_index = outputs.start_logits.argmax()
>>> answer_end_index = outputs.end_logits.argmax()
>>> predict_answer_tokens = inputs.input_ids[0, answer_start_index : answer_end_index + 1]
>>> tokenizer.decode(predict_answer_tokens, skip_special_tokens=True)
...
>>> # target is "nice puppet"
>>> target_start_index = torch.tensor([14])
>>> target_end_index = torch.tensor([15])
>>> outputs = model(**inputs, start_positions=target_start_index, end_positions=target_end_index)
>>> loss = outputs.loss
>>> round(loss.item(), 2)
...TFMT5Model
此類覆蓋了 TFT5Model。請查閱父類文件以獲取相應的文件和用法示例。
示例
>>> from transformers import TFMT5Model, AutoTokenizer
>>> model = TFMT5Model.from_pretrained("google/mt5-small")
>>> tokenizer = AutoTokenizer.from_pretrained("google/mt5-small")
>>> article = "UN Offizier sagt, dass weiter verhandelt werden muss in Syrien."
>>> summary = "Weiter Verhandlung in Syrien."
>>> inputs = tokenizer(article, return_tensors="tf")
>>> labels = tokenizer(text_target=summary, return_tensors="tf")
>>> outputs = model(input_ids=inputs["input_ids"], decoder_input_ids=labels["input_ids"])
>>> hidden_states = outputs.last_hidden_stateTFMT5ForConditionalGeneration
此類覆蓋了 TFT5ForConditionalGeneration。請查閱父類文件以獲取相應的文件和用法示例。
示例
>>> from transformers import TFMT5ForConditionalGeneration, AutoTokenizer
>>> model = TFMT5ForConditionalGeneration.from_pretrained("google/mt5-small")
>>> tokenizer = AutoTokenizer.from_pretrained("google/mt5-small")
>>> article = "UN Offizier sagt, dass weiter verhandelt werden muss in Syrien."
>>> summary = "Weiter Verhandlung in Syrien."
>>> inputs = tokenizer(article, text_target=summary, return_tensors="tf")
>>> outputs = model(**inputs)
>>> loss = outputs.lossTFMT5EncoderModel
此類覆蓋了 TFT5EncoderModel。請查閱父類文件以獲取相應的文件和用法示例。
示例
>>> from transformers import TFMT5EncoderModel, AutoTokenizer
>>> model = TFMT5EncoderModel.from_pretrained("google/mt5-small")
>>> tokenizer = AutoTokenizer.from_pretrained("google/mt5-small")
>>> article = "UN Offizier sagt, dass weiter verhandelt werden muss in Syrien."
>>> input_ids = tokenizer(article, return_tensors="tf").input_ids
>>> outputs = model(input_ids)
>>> hidden_state = outputs.last_hidden_stateFlaxMT5Model
class transformers.FlaxMT5Model
< 來源 >( config: T5Config input_shape: tuple = (1, 1) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True gradient_checkpointing: bool = False **kwargs )
此類覆蓋了 FlaxT5Model。請查閱父類文件以獲取相應的文件和用法示例。
示例
>>> from transformers import FlaxMT5Model, AutoTokenizer
>>> model = FlaxMT5Model.from_pretrained("google/mt5-small")
>>> tokenizer = AutoTokenizer.from_pretrained("google/mt5-small")
>>> article = "UN Offizier sagt, dass weiter verhandelt werden muss in Syrien."
>>> summary = "Weiter Verhandlung in Syrien."
>>> inputs = tokenizer(article, return_tensors="np")
>>> decoder_input_ids = tokenizer(text_target=summary, return_tensors="np").input_ids
>>> outputs = model(input_ids=inputs["input_ids"], decoder_input_ids=decoder_input_ids)
>>> hidden_states = outputs.last_hidden_stateFlaxMT5ForConditionalGeneration
class transformers.FlaxMT5ForConditionalGeneration
< 來源 >( config: T5Config input_shape: tuple = (1, 1) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True gradient_checkpointing: bool = False **kwargs )
此類覆蓋了 FlaxT5ForConditionalGeneration。請查閱父類文件以獲取相應的文件和用法示例。
示例
>>> from transformers import FlaxMT5ForConditionalGeneration, AutoTokenizer
>>> model = FlaxMT5ForConditionalGeneration.from_pretrained("google/mt5-small")
>>> tokenizer = AutoTokenizer.from_pretrained("google/mt5-small")
>>> article = "UN Offizier sagt, dass weiter verhandelt werden muss in Syrien."
>>> summary = "Weiter Verhandlung in Syrien."
>>> inputs = tokenizer(article, return_tensors="np")
>>> decoder_input_ids = tokenizer(text_target=summary, return_tensors="np").input_ids
>>> outputs = model(**inputs, decoder_input_ids=decoder_input_ids)
>>> logits = outputs.logitsFlaxMT5EncoderModel
class transformers.FlaxMT5EncoderModel
< 來源 >( config: T5Config input_shape: tuple = (1, 1) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True gradient_checkpointing: bool = False **kwargs )
此類覆蓋了 FlaxT5EncoderModel。請查閱父類文件以獲取相應的文件和用法示例。
示例
>>> from transformers import FlaxT5EncoderModel, AutoTokenizer
>>> model = FlaxT5EncoderModel.from_pretrained("google/mt5-small")
>>> tokenizer = AutoTokenizer.from_pretrained("google/mt5-small")
>>> article = "UN Offizier sagt, dass weiter verhandelt werden muss in Syrien."
>>> summary = "Weiter Verhandlung in Syrien."
>>> inputs = tokenizer(article, return_tensors="np")
>>> decoder_input_ids = tokenizer(text_target=summary, return_tensors="np").input_ids
>>> outputs = model(input_ids=inputs["input_ids"])
>>> hidden_states = outputs.last_hidden_state