Transformers 文件

OPT

Hugging Face's logo
加入 Hugging Face 社群

並獲得增強的文件體驗

開始使用

OPT

PyTorch TensorFlow Flax FlashAttention SDPA

概述

OPT 模型由 Meta AI 在論文 《Open Pre-trained Transformer Language Models》 中提出。OPT 是一系列開源的大型因果語言模型,其效能與 GPT3 相似。

論文摘要如下:

大型語言模型通常需要數十萬個計算日進行訓練,在零樣本和少樣本學習方面展現了卓越的能力。鑑於其巨大的計算成本,沒有雄厚資本很難復現這些模型。對於少數透過 API 提供的模型,也無法訪問完整的模型權重,這使得研究它們變得困難。我們推出了開放預訓練變換器(OPT),這是一套僅包含解碼器的預訓練變換器,引數範圍從 1.25 億到 1750 億,我們希望與感興趣的研究人員完全且負責任地共享。我們證明了 OPT-175B 的效能與 GPT-3 相當,而開發所需的碳足跡僅為其七分之一。我們還發布了我們的日誌,詳細記錄了我們面臨的基礎設施挑戰,以及用於實驗所有已釋出模型的程式碼。

該模型由 Arthur ZuckerYounes BelkadaPatrick Von Platen 貢獻。原始程式碼可以在此處找到。

技巧

  • OPT 具有與 BartDecoder 相同的架構。
  • 與 GPT2 不同,OPT 在每個提示的開頭添加了 EOS 標記 </s>

[!NOTE] 當使用除“eager”之外的所有注意力實現時,head_mask 引數會被忽略。如果你有一個 head_mask 並且希望它生效,請使用 XXXModel.from_pretrained(model_id, attn_implementation="eager") 載入模型。

資源

一份官方 Hugging Face 和社群(由 🌎 標誌表示)資源的列表,幫助您開始使用 OPT。如果您有興趣提交資源並希望將其包含在此處,請隨時發起一個 Pull Request,我們會進行稽核。提交的資源最好能展示一些新的內容,而不是重複現有的資源。

文字生成
文字分類
問答

⚡️ 推理

結合 OPT 與 Flash Attention 2

首先,請確保安裝最新版本的 Flash Attention 2,以包含滑動視窗注意力功能。

pip install -U flash-attn --no-build-isolation

請確保您擁有與 Flash-Attention 2 相容的硬體。更多資訊請參閱 flash-attn 倉庫的官方文件。同時,請確保以半精度(例如 `torch.float16`)載入您的模型。

要載入並使用 Flash Attention 2 執行模型,請參考以下程式碼片段

>>> import torch
>>> from transformers import OPTForCausalLM, GPT2Tokenizer
>>> device = "cuda" # the device to load the model onto

>>> model = OPTForCausalLM.from_pretrained("facebook/opt-350m", torch_dtype=torch.float16, attn_implementation="flash_attention_2")
>>> tokenizer = GPT2Tokenizer.from_pretrained("facebook/opt-350m")

>>> prompt = ("A chat between a curious human and the Statue of Liberty.\n\nHuman: What is your name?\nStatue: I am the "
              "Statue of Liberty.\nHuman: Where do you live?\nStatue: New York City.\nHuman: How long have you lived "
              "there?")

>>> model_inputs = tokenizer([prompt], return_tensors="pt").to(device)
>>> model.to(device)

>>> generated_ids = model.generate(**model_inputs, max_new_tokens=30, do_sample=False)
>>> tokenizer.batch_decode(generated_ids)[0]
'</s>A chat between a curious human and the Statue of Liberty.\n\nHuman: What is your name?\nStatue: I am the Statue of Liberty.\nHuman: Where do you live?\nStatue: New York City.\nHuman: How long have you lived there?\nStatue: I have lived here for about a year.\nHuman: What is your favorite place to eat?\nStatue: I love'

預期加速效果

下圖是一個預期加速圖,比較了使用 `facebook/opt-2.7b` 檢查點時,transformers 中的原生實現與 Flash Attention 2 版本的模型在兩種不同序列長度下的純推理時間。

下圖是一個預期加速圖,比較了使用 `facebook/opt-350m` 檢查點時,transformers 中的原生實現與 Flash Attention 2 版本的模型在兩種不同序列長度下的純推理時間。

使用縮放點積注意力 (SDPA)

PyTorch 在 `torch.nn.functional` 中包含一個原生的縮放點積注意力 (SDPA) 運算元。該函式包含多種實現,可根據輸入和使用的硬體進行應用。更多資訊請參閱官方文件GPU 推理頁面。

當實現可用時,SDPA 預設用於 `torch>=2.1.1`,但你也可以在 `from_pretrained()` 中設定 `attn_implementation="sdpa"` 來明確請求使用 SDPA。

from transformers import OPTForCausalLM
model = OPTForCausalLM.from_pretrained("facebook/opt-350m", torch_dtype=torch.float16, attn_implementation="sdpa")
...

為了獲得最佳加速效果,我們建議以半精度(例如 `torch.float16` 或 `torch.bfloat16`)載入模型。

在本地基準測試(L40S-45GB, PyTorch 2.4.0, OS Debian GNU/Linux 11)中使用 `float16` 和 facebook/opt-350m,我們在訓練和推理過程中觀察到以下加速效果。

訓練

批處理大小 序列長度 每批次時間(Eager - 秒) 每批次時間(SDPA - 秒) 加速(%) Eager 峰值記憶體(MB) sdpa 峰值記憶體 (MB) 記憶體節省(%)
1 128 0.047 0.037 26.360 1474.611 1474.32 0.019
1 256 0.046 0.037 24.335 1498.541 1499.49 -0.063
1 512 0.046 0.037 24.959 1973.544 1551.35 27.215
1 1024 0.062 0.038 65.135 4867.113 1698.35 186.578
1 2048 0.230 0.039 483.933 15662.224 2715.75 476.718
2 128 0.045 0.037 20.455 1498.164 1499.49 -0.089
2 256 0.046 0.037 24.027 1569.367 1551.35 1.161
2 512 0.045 0.037 20.965 3257.074 1698.35 91.778
2 1024 0.122 0.038 225.958 9054.405 2715.75 233.403
2 2048 0.464 0.067 593.646 30572.058 4750.55 543.548
4 128 0.045 0.037 21.918 1549.448 1551.35 -0.123
4 256 0.044 0.038 18.084 2451.768 1698.35 44.361
4 512 0.069 0.037 84.421 5833.180 2715.75 114.791
4 1024 0.262 0.062 319.475 17427.842 4750.55 266.860
4 2048 記憶體不足 0.062 Eager 記憶體不足 記憶體不足 4750.55 Eager 記憶體不足
8 128 0.044 0.037 18.436 2049.115 1697.78 20.694
8 256 0.048 0.036 32.887 4222.567 2715.75 55.484
8 512 0.153 0.06 154.862 10985.391 4750.55 131.245
8 1024 0.526 0.122 330.697 34175.763 8821.18 287.428
8 2048 記憶體不足 0.122 Eager 記憶體不足 記憶體不足 8821.18 Eager 記憶體不足

推理

批處理大小 序列長度 Eager 每詞元延遲 (ms) SDPA 每詞元延遲 (ms) 加速(%) Eager 記憶體 (MB) BT 記憶體 (MB) 記憶體節省 (%)
1 128 11.634 8.647 34.546 717.676 717.674 0
1 256 11.593 8.86 30.851 742.852 742.845 0.001
1 512 11.515 8.816 30.614 798.232 799.593 -0.17
1 1024 11.556 8.915 29.628 917.265 895.538 2.426
2 128 12.724 11.002 15.659 762.434 762.431 0
2 256 12.704 11.063 14.83 816.809 816.733 0.009
2 512 12.757 10.947 16.535 917.383 918.339 -0.104
2 1024 13.018 11.018 18.147 1162.65 1114.81 4.291
4 128 12.739 10.959 16.243 856.335 856.483 -0.017
4 256 12.718 10.837 17.355 957.298 957.674 -0.039
4 512 12.813 10.822 18.393 1158.44 1158.45 -0.001
4 1024 13.416 11.06 21.301 1653.42 1557.19 6.18
8 128 12.763 10.891 17.193 1036.13 1036.51 -0.036
8 256 12.89 11.104 16.085 1236.98 1236.87 0.01
8 512 13.327 10.939 21.836 1642.29 1641.78 0.031
8 1024 15.181 11.175 35.848 2634.98 2443.35 7.843

OPTConfig

class transformers.OPTConfig

< >

( vocab_size = 50272 hidden_size = 768 num_hidden_layers = 12 ffn_dim = 3072 max_position_embeddings = 2048 do_layer_norm_before = True _remove_final_layer_norm = False word_embed_proj_dim = None dropout = 0.1 attention_dropout = 0.0 num_attention_heads = 12 activation_function = 'relu' layerdrop = 0.0 init_std = 0.02 use_cache = True pad_token_id = 1 bos_token_id = 2 eos_token_id = 2 enable_bias = True layer_norm_elementwise_affine = True **kwargs )

引數

  • vocab_size (int, 可選, 預設為 50272) — OPT 模型的詞彙表大小。定義了在呼叫 OPTModel 時傳入的 `inputs_ids` 可以表示的不同標記的數量。
  • hidden_size (int, 可選, 預設為 768) — 層和池化層的維度。
  • num_hidden_layers (int, 可選, 預設為 12) — 解碼器層的數量。
  • ffn_dim (int, 可選, 預設為 3072) — 解碼器中“中間”(通常稱為前饋)層的維度。
  • num_attention_heads (int, 可選, 預設為 12) — Transformer 解碼器中每個注意力層的注意力頭數量。
  • activation_function (strfunction, 可選, 預設為 "relu") — 編碼器和池化層中的非線性啟用函式(函式或字串)。如果為字串,支援 "gelu""relu""silu""gelu_new"
  • max_position_embeddings (int, 可選, 預設為 2048) — 該模型可能使用的最大序列長度。通常將其設定為一個較大的值以備不時之需(例如 512、1024 或 2048)。
  • do_layer_norm_before (bool, 可選, 預設為 True) — 是否在注意力塊之前執行層歸一化。
  • word_embed_proj_dim (int, 可選) — `word_embed_proj_dim` 可用於下投影詞嵌入,例如 `opt-350m`。預設為 `hidden_size`。
  • dropout (float, 可選, 預設為 0.1) — 嵌入、編碼器和池化層中所有全連線層的 dropout 機率。
  • attention_dropout (float, 可選, 預設為 0.0) — 注意力機率的 dropout 比率。
  • layerdrop (float, 可選, 預設為 0.0) — LayerDrop 機率。更多細節請參閱 [LayerDrop 論文](https://huggingface.co/papers/1909.11556)。
  • init_std (float, 可選, 預設為 0.02) — 用於初始化所有權重矩陣的 truncated_normal_initializer 的標準差。
  • use_cache (bool, 可選, 預設為 True) — 模型是否應返回最後一個鍵/值注意力(並非所有模型都使用)。
  • enable_bias (bool, 可選, 預設為 True) — 注意力塊中的線性層是否應使用偏置項。
  • layer_norm_elementwise_affine (bool, 可選, 預設為 True) — 層歸一化是否應具有可學習的引數。

這是一個用於儲存 OPTModel 配置的配置類。它根據指定的引數例項化一個 OPT 模型,定義模型架構。使用預設值例項化配置將產生與 OPT facebook/opt-350m 架構類似的配置。

配置物件繼承自 PretrainedConfig,可用於控制模型輸出。請閱讀 PretrainedConfig 的文件以獲取更多資訊。

示例

>>> from transformers import OPTConfig, OPTModel

>>> # Initializing a OPT facebook/opt-large style configuration
>>> configuration = OPTConfig()

>>> # Initializing a model (with random weights) from the facebook/opt-large style configuration
>>> model = OPTModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config
Pytorch
隱藏 Pytorch 內容

OPTModel

class transformers.OPTModel

< >

( config: OPTConfig )

引數

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

無任何特定頭部的原始 Opt 模型,輸出原始的隱藏狀態。

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

該模型也是 PyTorch torch.nn.Module 的子類。可以像常規 PyTorch 模組一樣使用它,並參考 PyTorch 文件瞭解所有與通用用法和行為相關的事項。

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.Tensor] = None head_mask: typing.Optional[torch.Tensor] = None past_key_values: typing.Union[transformers.cache_utils.Cache, list[torch.FloatTensor], NoneType] = None 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 position_ids: typing.Optional[torch.LongTensor] = None cache_position: typing.Optional[torch.Tensor] = None **kwargs: typing_extensions.Unpack[transformers.modeling_flash_attention_utils.FlashAttentionKwargs] ) transformers.modeling_outputs.BaseModelOutputWithPasttuple(torch.FloatTensor)

引數

  • input_ids (torch.LongTensor,形狀為 (batch_size, sequence_length)可選) — 詞彙表中輸入序列標記的索引。預設情況下,填充將被忽略。

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

    什麼是輸入 ID?

  • 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 表示頭部已被掩碼
  • past_key_values (Union[~cache_utils.Cache, list[torch.FloatTensor], NoneType]) — 預先計算的隱藏狀態(自注意力塊和交叉注意力塊中的鍵和值),可用於加速序列解碼。這通常包括模型在先前解碼階段返回的 past_key_values,當 use_cache=Trueconfig.use_cache=True 時。

    允許兩種格式:

    • 一個 Cache 例項,請參閱我們的 kv 快取指南
    • 長度為 config.n_layerstuple(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 索引轉換為相關向量,這會很有用。
  • use_cache (bool可選) — 如果設定為 True,則返回 past_key_values 鍵值狀態,可用於加速解碼(請參閱 past_key_values)。
  • output_attentions (bool可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊,請參閱返回張量下的 attentions
  • output_hidden_states (bool可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊,請參閱返回張量下的 hidden_states
  • return_dict (bool可選) — 是否返回一個 ModelOutput 而不是一個普通的元組。
  • position_ids (torch.LongTensor,形狀為 (batch_size, sequence_length)可選) — 每個輸入序列標記在位置嵌入中的位置索引。選自 [0, config.n_positions - 1] 範圍。

    什麼是位置 ID?

  • cache_position (torch.Tensor,形狀為 (sequence_length)可選) — 描述輸入序列標記在序列中位置的索引。與 position_ids 相反,此張量不受填充影響。它用於在正確的位置更新快取並推斷完整的序列長度。

返回

transformers.modeling_outputs.BaseModelOutputWithPasttuple(torch.FloatTensor)

一個 transformers.modeling_outputs.BaseModelOutputWithPast 或一個 `torch.FloatTensor` 元組(如果傳遞了 `return_dict=False` 或 `config.return_dict=False`),根據配置(OPTConfig)和輸入包含各種元素。

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

    如果使用了 past_key_values,則只輸出形狀為 (batch_size, 1, hidden_size) 的序列的最後一個隱藏狀態。

  • past_key_values (Cache可選,當傳遞 use_cache=Trueconfig.use_cache=True 時返回) — 這是一個 Cache 例項。更多詳情,請參閱我們的 kv 快取指南

    包含預計算的隱藏狀態(自注意力塊中的鍵和值,如果 `config.is_encoder_decoder=True`,則還包括交叉注意力塊中的鍵和值),可用於(參見 `past_key_values` 輸入)加速序列解碼。

  • hidden_states (tuple(torch.FloatTensor)可選,當傳遞 output_hidden_states=Trueconfig.output_hidden_states=True 時返回) — torch.FloatTensor 元組(一個用於嵌入層的輸出,如果模型有嵌入層,+ 一個用於每層輸出),形狀為 (batch_size, sequence_length, hidden_size)

    模型在每個層輸出的隱藏狀態以及可選的初始嵌入輸出。

  • attentions (tuple(torch.FloatTensor)可選,當傳遞 output_attentions=Trueconfig.output_attentions=True 時返回) — torch.FloatTensor 元組(每層一個),形狀為 (batch_size, num_heads, sequence_length, sequence_length)

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

OPTModel 的 forward 方法,覆蓋了 `__call__` 特殊方法。

雖然前向傳播的流程需要在此函式內定義,但之後應呼叫 `Module` 例項而不是此函式,因為前者會處理執行前處理和後處理步驟,而後者會靜默地忽略它們。

OPTForCausalLM

class transformers.OPTForCausalLM

< >

( config )

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.Tensor] = None head_mask: typing.Optional[torch.Tensor] = None past_key_values: typing.Union[transformers.cache_utils.Cache, list[torch.FloatTensor], NoneType] = None 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 position_ids: typing.Optional[torch.LongTensor] = None cache_position: typing.Optional[torch.Tensor] = None **kwargs: typing_extensions.Unpack[transformers.models.opt.modeling_opt.KwargsForCausalLM] ) transformers.modeling_outputs.CausalLMOutputWithPasttuple(torch.FloatTensor)

引數

  • input_ids (torch.LongTensor,形狀為 (batch_size, sequence_length)可選) — 詞彙表中輸入序列標記的索引。預設情況下,填充將被忽略。

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

    什麼是輸入 ID?

  • 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 表示頭部已被掩碼
  • past_key_values (Union[~cache_utils.Cache, list[torch.FloatTensor], NoneType]) — 預先計算的隱藏狀態(自注意力塊和交叉注意力塊中的鍵和值),可用於加速序列解碼。這通常包括模型在先前解碼階段返回的 past_key_values,當 use_cache=Trueconfig.use_cache=True 時。

    允許兩種格式:

    • 一個 Cache 例項,請參閱我們的 kv 快取指南
    • 長度為 config.n_layerstuple(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 索引轉換為相關向量,這會很有用。
  • labels (torch.LongTensor,形狀為 (batch_size, sequence_length)可選) — 用於計算掩碼語言建模損失的標籤。索引應在 [0, ..., config.vocab_size] 或 -100 之間(請參閱 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 而不是一個普通的元組。
  • position_ids (torch.LongTensor,形狀為 (batch_size, sequence_length)可選) — 每個輸入序列標記在位置嵌入中的位置索引。選自 [0, config.n_positions - 1] 範圍。

    什麼是位置 ID?

  • cache_position (torch.Tensor,形狀為 (sequence_length)可選) — 描述輸入序列標記在序列中位置的索引。與 position_ids 相反,此張量不受填充影響。它用於在正確的位置更新快取並推斷完整的序列長度。

返回

transformers.modeling_outputs.CausalLMOutputWithPasttuple(torch.FloatTensor)

一個 transformers.modeling_outputs.CausalLMOutputWithPast 或一個 `torch.FloatTensor` 元組(如果傳遞了 `return_dict=False` 或 `config.return_dict=False`),根據配置(OPTConfig)和輸入包含各種元素。

  • loss (torch.FloatTensor 形狀為 (1,)可選,當提供 labels 時返回) — 語言建模損失(用於下一個 token 預測)。

  • logits (形狀為 (batch_size, sequence_length, config.vocab_size)torch.FloatTensor) — 語言建模頭部的預測分數(SoftMax 之前的每個詞彙標記的分數)。

  • past_key_values (Cache可選,當傳遞 use_cache=Trueconfig.use_cache=True 時返回) — 這是一個 Cache 例項。更多詳情,請參閱我們的 kv 快取指南

    包含預計算的隱藏狀態(自注意力塊中的鍵和值),可用於(參見 past_key_values 輸入)加速順序解碼。

  • hidden_states (tuple(torch.FloatTensor)可選,當傳遞 output_hidden_states=Trueconfig.output_hidden_states=True 時返回) — torch.FloatTensor 元組(一個用於嵌入層的輸出,如果模型有嵌入層,+ 一個用於每層輸出),形狀為 (batch_size, sequence_length, hidden_size)

    模型在每個層輸出的隱藏狀態以及可選的初始嵌入輸出。

  • attentions (tuple(torch.FloatTensor)可選,當傳遞 output_attentions=Trueconfig.output_attentions=True 時返回) — torch.FloatTensor 元組(每層一個),形狀為 (batch_size, num_heads, sequence_length, sequence_length)

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

OPTForCausalLM 的 forward 方法,覆蓋了 `__call__` 特殊方法。

雖然前向傳播的流程需要在此函式內定義,但之後應呼叫 `Module` 例項而不是此函式,因為前者會處理執行前處理和後處理步驟,而後者會靜默地忽略它們。

示例

>>> from transformers import AutoTokenizer, OPTForCausalLM

>>> model = OPTForCausalLM.from_pretrained("facebook/opt-350m")
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/opt-350m")

>>> prompt = "Hey, are you conscious? Can you talk to me?"
>>> inputs = tokenizer(prompt, return_tensors="pt")

>>> # Generate
>>> generate_ids = model.generate(inputs.input_ids, max_length=30)
>>> tokenizer.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
"Hey, are you conscious? Can you talk to me?\nI'm not conscious. I'm just a little bit of a weirdo."

OPTForSequenceClassification

class transformers.OPTForSequenceClassification

< >

( config: OPTConfig )

引數

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

在 OPT 模型轉換器之上帶有一個序列分類頭部(線性層)。

OPTForSequenceClassification 使用最後一個標記進行分類,與其他因果模型(如 GPT-2)一樣。

由於它對最後一個標記進行分類,因此需要知道最後一個標記的位置。如果配置中定義了 pad_token_id,它會找到每行中不是填充標記的最後一個標記。如果沒有定義 pad_token_id,它會簡單地取批次中每行的最後一個值。由於當傳遞 inputs_embeds 而不是 input_ids 時它無法猜測填充標記,因此它會做同樣的事情(取批次中每行的最後一個值)。

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

該模型也是 PyTorch torch.nn.Module 的子類。可以像常規 PyTorch 模組一樣使用它,並參考 PyTorch 文件瞭解所有與通用用法和行為相關的事項。

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.FloatTensor] = None head_mask: typing.Optional[torch.FloatTensor] = None past_key_values: typing.Union[transformers.cache_utils.Cache, list[torch.FloatTensor], NoneType] = None 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 position_ids: typing.Optional[torch.LongTensor] = None ) transformers.modeling_outputs.SequenceClassifierOutputWithPasttuple(torch.FloatTensor)

引數

  • input_ids (torch.LongTensor,形狀為 (batch_size, sequence_length)可選) — 詞彙表中輸入序列標記的索引。預設情況下,填充將被忽略。

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

    什麼是輸入 ID?

  • 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 表示頭部已被掩碼
  • past_key_values (Union[~cache_utils.Cache, list[torch.FloatTensor], NoneType]) — 預先計算的隱藏狀態(自注意力塊和交叉注意力塊中的鍵和值),可用於加速序列解碼。這通常包括模型在先前解碼階段返回的 past_key_values,當 use_cache=Trueconfig.use_cache=True 時。

    允許兩種格式:

    • 一個 Cache 例項,請參閱我們的 kv 快取指南
    • 長度為 config.n_layerstuple(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 索引轉換為相關聯的向量,這會很有用。
  • labels (torch.LongTensor,形狀為 (batch_size,)可選) — 用於計算序列分類/迴歸損失的標籤。索引應在 [0, ..., config.num_labels - 1] 範圍內。如果 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 而不是一個普通的元組。
  • position_ids (torch.LongTensor,形狀為 (batch_size, sequence_length)可選) — 每個輸入序列詞元在位置嵌入中的位置索引。在 [0, config.n_positions - 1] 範圍內選擇。

    什麼是位置ID?

返回

transformers.modeling_outputs.SequenceClassifierOutputWithPasttuple(torch.FloatTensor)

一個 transformers.modeling_outputs.SequenceClassifierOutputWithPast 或一個 torch.FloatTensor 元組(如果傳遞了 return_dict=Falseconfig.return_dict=False),根據配置(OPTConfig)和輸入包含不同的元素。

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

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

  • past_key_values (Cache可選,當傳遞 use_cache=Trueconfig.use_cache=True 時返回) — 這是一個 Cache 例項。更多詳情,請參閱我們的 kv 快取指南

    包含預計算的隱藏狀態(自注意力塊中的鍵和值),可用於(參見 past_key_values 輸入)加速順序解碼。

  • hidden_states (tuple(torch.FloatTensor)可選,當傳遞 output_hidden_states=Trueconfig.output_hidden_states=True 時返回) — torch.FloatTensor 元組(一個用於嵌入層的輸出,如果模型有嵌入層,+ 一個用於每層輸出),形狀為 (batch_size, sequence_length, hidden_size)

    模型在每個層輸出的隱藏狀態以及可選的初始嵌入輸出。

  • attentions (tuple(torch.FloatTensor)可選,當傳遞 output_attentions=Trueconfig.output_attentions=True 時返回) — torch.FloatTensor 元組(每層一個),形狀為 (batch_size, num_heads, sequence_length, sequence_length)

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

OPTForSequenceClassification 的 forward 方法重寫了 __call__ 特殊方法。

雖然前向傳播的流程需要在此函式內定義,但之後應呼叫 `Module` 例項而不是此函式,因為前者會處理執行前處理和後處理步驟,而後者會靜默地忽略它們。

單標籤分類示例

>>> import torch
>>> from transformers import AutoTokenizer, OPTForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("facebook/opt-350m")
>>> model = OPTForSequenceClassification.from_pretrained("facebook/opt-350m")

>>> 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 = OPTForSequenceClassification.from_pretrained("facebook/opt-350m", num_labels=num_labels)

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

多標籤分類示例

>>> import torch
>>> from transformers import AutoTokenizer, OPTForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("facebook/opt-350m")
>>> model = OPTForSequenceClassification.from_pretrained("facebook/opt-350m", 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 = OPTForSequenceClassification.from_pretrained(
...     "facebook/opt-350m", 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

OPTForQuestionAnswering

class transformers.OPTForQuestionAnswering

< >

( config: OPTConfig )

引數

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

帶有片段分類頭的 Opt Transformer,用於像 SQuAD 這樣的抽取式問答任務(在 hidden-states 輸出之上加一個線性層來計算 `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 head_mask: typing.Optional[torch.FloatTensor] = None past_key_values: typing.Union[transformers.cache_utils.Cache, list[torch.FloatTensor], NoneType] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None start_positions: typing.Optional[torch.LongTensor] = None end_positions: 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 position_ids: typing.Optional[torch.LongTensor] = None ) transformers.modeling_outputs.QuestionAnsweringModelOutputtuple(torch.FloatTensor)

引數

  • input_ids (torch.LongTensor,形狀為 (batch_size, sequence_length)可選) — 詞彙表中輸入序列詞元的索引。預設情況下,填充將被忽略。

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

    什麼是輸入ID?

  • 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 表示頭部被掩碼
  • past_key_values (Union[~cache_utils.Cache, list[torch.FloatTensor], NoneType]) — 預先計算的隱藏狀態(自注意力塊和交叉注意力塊中的鍵和值),可用於加速順序解碼。這通常包括模型在解碼的先前階段返回的 past_key_values,當 use_cache=Trueconfig.use_cache=True 時。

    允許兩種格式:

    • 一個 Cache 例項,請參閱我們的 kv 快取指南
    • 一個長度為 config.n_layerstuple(torch.FloatTensor) 元組,每個元組包含 2 個形狀為 (batch_size, num_heads, sequence_length, embed_size_per_head) 的張量。這也稱為舊版快取格式。

    模型將輸出與輸入相同的快取格式。如果沒有傳遞 past_key_values,將返回舊版快取格式。

    如果使用 past_key_values,使用者可以選擇只輸入最後一個 input_ids(那些沒有給出過去鍵值狀態的詞元),形狀為 (batch_size, 1),而不是所有形狀為 (batch_size, sequence_length)input_ids

  • inputs_embeds (torch.FloatTensor,形狀為 (batch_size, sequence_length, hidden_size)可選) — 可選地,你可以選擇直接傳遞嵌入式表示,而不是傳遞 input_ids。如果你想比模型內部的嵌入查詢矩陣更好地控制如何將 input_ids 索引轉換為相關聯的向量,這會很有用。
  • start_positions (torch.LongTensor,形狀為 (batch_size,)可選) — 標記片段開始位置(索引)的標籤,用於計算詞元分類損失。位置被限制在序列長度(sequence_length)內。超出序列的位置不計入損失計算。
  • end_positions (torch.LongTensor,形狀為 (batch_size,)可選) — 標記片段結束位置(索引)的標籤,用於計算詞元分類損失。位置被限制在序列長度(sequence_length)內。超出序列的位置不計入損失計算。
  • use_cache (bool可選) — 如果設定為 True,將返回 past_key_values 鍵值狀態,可用於加速解碼(參見 past_key_values)。
  • output_attentions (bool可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊,請參閱返回張量下的 attentions
  • output_hidden_states (bool可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊,請參閱返回張量下的 hidden_states
  • return_dict (bool可選) — 是否返回一個 ModelOutput 而不是一個普通的元組。
  • position_ids (torch.LongTensor,形狀為 (batch_size, sequence_length)可選) — 每個輸入序列詞元在位置嵌入中的位置索引。在 [0, config.n_positions - 1] 範圍內選擇。

    什麼是位置ID?

返回

transformers.modeling_outputs.QuestionAnsweringModelOutputtuple(torch.FloatTensor)

一個 transformers.modeling_outputs.QuestionAnsweringModelOutput 或一個 torch.FloatTensor 元組(如果傳遞了 return_dict=Falseconfig.return_dict=False),根據配置(OPTConfig)和輸入包含不同的元素。

  • loss (torch.FloatTensor of shape (1,), 可選, 當提供 labels 時返回) — 總範圍提取損失是起始位置和結束位置的交叉熵之和。

  • start_logits (torch.FloatTensor of shape (batch_size, sequence_length)) — 範圍起始分數(SoftMax 之前)。

  • end_logits (torch.FloatTensor of shape (batch_size, sequence_length)) — 範圍結束分數(SoftMax 之前)。

  • hidden_states (tuple(torch.FloatTensor)可選,當傳遞 output_hidden_states=Trueconfig.output_hidden_states=True 時返回) — torch.FloatTensor 元組(一個用於嵌入層的輸出,如果模型有嵌入層,+ 一個用於每層輸出),形狀為 (batch_size, sequence_length, hidden_size)

    模型在每個層輸出的隱藏狀態以及可選的初始嵌入輸出。

  • attentions (tuple(torch.FloatTensor)可選,當傳遞 output_attentions=Trueconfig.output_attentions=True 時返回) — torch.FloatTensor 元組(每層一個),形狀為 (batch_size, num_heads, sequence_length, sequence_length)

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

OPTForQuestionAnswering 的 forward 方法重寫了 __call__ 特殊方法。

雖然前向傳播的流程需要在此函式內定義,但之後應呼叫 `Module` 例項而不是此函式,因為前者會處理執行前處理和後處理步驟,而後者會靜默地忽略它們。

示例

>>> from transformers import AutoTokenizer, OPTForQuestionAnswering
>>> import torch

>>> torch.manual_seed(4)
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/opt-350m")

>>> # note: we are loading a OPTForQuestionAnswering from the hub here,
>>> # so the head will be randomly initialized, hence the predictions will be random
>>> model = OPTForQuestionAnswering.from_pretrained("facebook/opt-350m")

>>> 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()

>>> answer_offset = len(tokenizer(question)[0])

>>> predict_answer_tokens = inputs.input_ids[
...     0, answer_offset + answer_start_index : answer_offset + answer_end_index + 1
... ]
>>> predicted = tokenizer.decode(predict_answer_tokens)
>>> predicted
' a nice puppet'
TensorFlow
隱藏 TensorFlow 內容

TFOPTModel

class transformers.TFOPTModel

< >

( config: OPTConfig **kwargs )

引數

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

基礎的 TF OPT 模型,輸出原始的隱藏狀態,沒有任何特定的頭部。此模型繼承自 TFPreTrainedModel。請查閱超類文件以瞭解庫為所有模型實現的通用方法(如下載或儲存、調整輸入嵌入大小、修剪頭部等)。

該模型也是 keras.Model 的子類。可以像常規的 TF 2.0 Keras 模型一樣使用它,並參考 TF 2.0 文件瞭解所有與通用用法和行為相關的事項。

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

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

支援第二種格式的原因是,Keras 方法在向模型和層傳遞輸入時更喜歡這種格式。由於這種支援,當使用像 `model.fit()` 這樣的方法時,一切都應該“正常工作”——只需以 `model.fit()` 支援的任何格式傳遞您的輸入和標籤!但是,如果您想在 Keras 方法(如 `fit()` 和 `predict()`)之外使用第二種格式,例如在使用 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 attention_mask: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None past_key_values: Optional[tuple[tuple[Union[np.ndarray, tf.Tensor]]]] = None inputs_embeds: np.ndarray | tf.Tensor | None = None use_cache: Optional[bool] = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: Optional[bool] = False **kwargs ) transformers.modeling_tf_outputs.TFBaseModelOutputWithPasttuple(tf.Tensor)

引數

  • input_ids (tf.Tensor,形狀為 ({0})) — 詞彙表中輸入序列詞元的索引。

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

    什麼是輸入ID?

  • attention_mask (tf.Tensor,形狀為 ({0})可選) — 用於避免在填充詞元索引上執行注意力的掩碼。掩碼值在 [0, 1] 中選擇:

    • 1 表示詞元未被掩碼
    • 0 表示詞元被掩碼

    什麼是注意力掩碼?

  • head_mask (tf.Tensor,形狀為 (encoder_layers, encoder_attention_heads)可選) — 用於置零編碼器中注意力模組選定頭部的掩碼。掩碼值在 [0, 1] 中選擇:

    • 1 表示頭部未被掩碼
    • 0 表示頭部被掩碼
  • past_key_values (長度為 config.n_layerstuple[tuple[tf.Tensor]]) — 包含預先計算的注意力塊的鍵和值隱藏狀態。可用於加速解碼。如果使用 past_key_values,使用者可以選擇只輸入最後一個 decoder_input_ids(那些沒有給出過去鍵值狀態的詞元),形狀為 (batch_size, 1),而不是所有形狀為 (batch_size, sequence_length)decoder_input_ids
  • use_cache (bool可選,預設為 True) — 如果設定為 True,將返回 past_key_values 鍵值狀態,可用於加速解碼(參見 past_key_values)。在訓練期間設定為 False,在生成期間設定為 True
  • output_attentions (bool可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊,請參閱返回張量下的 attentions。此引數只能在即時執行模式下使用,在圖模式下將使用配置中的值。
  • output_hidden_states (bool可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊,請參閱返回張量下的 hidden_states。此引數只能在即時執行模式下使用,在圖模式下將使用配置中的值。
  • return_dict (bool可選) — 是否返回一個 ModelOutput 而不是一個普通的元組。此引數可以在即時執行模式下使用,在圖模式下該值將始終設定為 True。
  • training (bool可選,預設為 False) — 是否以訓練模式使用模型(某些模組如 dropout 模組在訓練和評估之間有不同的行為)。

返回

transformers.modeling_tf_outputs.TFBaseModelOutputWithPasttuple(tf.Tensor)

一個 transformers.modeling_tf_outputs.TFBaseModelOutputWithPast 或一個 tf.Tensor 元組(如果傳遞了 return_dict=Falseconfig.return_dict=False),根據配置(OPTConfig)和輸入包含不同的元素。

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

    如果使用了 past_key_values,則只輸出形狀為 (batch_size, 1, hidden_size) 的序列的最後一個隱藏狀態。

  • past_key_values (list[tf.Tensor]可選,在傳遞 use_cache=Trueconfig.use_cache=True 時返回) — 長度為 config.n_layerstf.Tensor 列表,每個張量的形狀為 (2, batch_size, num_heads, sequence_length, embed_size_per_head))。

    包含預先計算的隱藏狀態(注意力塊中的鍵和值),可用於(參見 past_key_values 輸入)加速順序解碼。

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

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

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

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

TFOPTModel 的 forward 方法重寫了 __call__ 特殊方法。

雖然前向傳播的流程需要在此函式內定義,但之後應呼叫 `Module` 例項而不是此函式,因為前者會處理執行前處理和後處理步驟,而後者會靜默地忽略它們。

示例

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

>>> tokenizer = AutoTokenizer.from_pretrained("facebook/opt-350m")
>>> model = TFOPTModel.from_pretrained("facebook/opt-350m")

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

>>> last_hidden_states = outputs.last_hidden_state

TFOPTForCausalLM

class transformers.TFOPTForCausalLM

< >

( config: OPTConfig **kwargs )

引數

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

帶有語言建模頭的 OPT 模型 Transformer。

此模型繼承自 TFPreTrainedModel。請查閱超類文件以瞭解庫為所有模型實現的通用方法(如下載或儲存、調整輸入嵌入大小、修剪頭部等)。

該模型也是 keras.Model 的子類。可以像常規的 TF 2.0 Keras 模型一樣使用它,並參考 TF 2.0 文件瞭解所有與通用用法和行為相關的事項。

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

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

支援第二種格式的原因是,Keras 方法在向模型和層傳遞輸入時更喜歡這種格式。由於這種支援,當使用像 `model.fit()` 這樣的方法時,一切都應該“正常工作”——只需以 `model.fit()` 支援的任何格式傳遞您的輸入和標籤!但是,如果您想在 Keras 方法(如 `fit()` 和 `predict()`)之外使用第二種格式,例如在使用 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 past_key_values: Optional[tuple[tuple[Union[np.ndarray, tf.Tensor]]]] = None attention_mask: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None labels: np.ndarray | tf.Tensor | None = None use_cache: Optional[bool] = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: Optional[bool] = False **kwargs ) transformers.modeling_tf_outputs.TFCausalLMOutputWithPasttuple(tf.Tensor)

引數

  • input_ids (torch.LongTensor,形狀為 (batch_size, sequence_length)) — 詞彙表中輸入序列詞元的索引。如果你提供了填充,預設情況下它會被忽略。

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

    什麼是輸入ID?

  • attention_mask (torch.Tensor,形狀為 (batch_size, sequence_length)可選) — 用於避免在填充詞元索引上執行注意力的掩碼。掩碼值在 [0, 1] 中選擇:

    • 1 表示詞元未被掩碼
    • 0 表示詞元被掩碼

    什麼是注意力掩碼?

  • head_mask (torch.Tensor,形狀為 (num_hidden_layers, num_attention_heads)可選) — 用於置零注意力模組中選定頭部的掩碼。掩碼值在 [0, 1] 中選擇:

    • 1 表示頭部未被掩碼
    • 0 表示頭部被掩碼
  • past_key_values (tuple(tuple(torch.FloatTensor))可選,在傳遞 use_cache=Trueconfig.use_cache=True 時返回) — 長度為 config.n_layerstuple(torch.FloatTensor) 元組,每個元組包含 2 個形狀為 (batch_size, num_heads, sequence_length, embed_size_per_head) 的張量和 2 個額外的形狀為 (batch_size, num_heads, encoder_sequence_length, embed_size_per_head) 的張量。只有當模型用作序列到序列模型中的解碼器時,才需要這兩個額外的張量。

    包含預先計算的隱藏狀態(自注意力塊和交叉注意力塊中的鍵和值),可用於(參見 past_key_values 輸入)加速順序解碼。

    如果使用 past_key_values,使用者可以選擇只輸入最後一個 input_ids(那些沒有給出過去鍵值狀態的詞元),形狀為 (batch_size, 1),而不是所有形狀為 (batch_size, sequence_length)decoder_input_ids

  • inputs_embeds (torch.FloatTensor,形狀為 (batch_size, sequence_length, hidden_size)可選) — 可選地,你可以選擇直接傳遞嵌入式表示,而不是傳遞 input_ids。如果你想比模型內部的嵌入查詢矩陣更好地控制如何將 input_ids 索引轉換為相關聯的向量,這會很有用。
  • labels (torch.LongTensor,形狀為 (batch_size, sequence_length)可選) — 用於計算掩碼語言建模損失的標籤。索引應在 [0, ..., config.vocab_size] 或 -100 之間(參見 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.modeling_tf_outputs.TFCausalLMOutputWithPasttuple(tf.Tensor)

transformers.modeling_tf_outputs.TFCausalLMOutputWithPast 或一個 `tf.Tensor` 元組(如果傳遞了 `return_dict=False` 或 `config.return_dict=False`),包含的各種元素取決於配置 (OPTConfig) 和輸入。

  • loss (形狀為(n,)tf.Tensor可選,其中n是非掩碼標籤的數量,當提供了labels時返回) — 語言建模損失(用於下一標記預測)。

  • logits (tf.Tensor of shape (batch_size, sequence_length, config.vocab_size)) — 語言模型頭部的預測分數(SoftMax 之前每個詞彙標記的分數)。

  • past_key_values (list[tf.Tensor]可選,在傳遞 use_cache=Trueconfig.use_cache=True 時返回) — 長度為 config.n_layerstf.Tensor 列表,每個張量的形狀為 (2, batch_size, num_heads, sequence_length, embed_size_per_head))。

    包含預先計算的隱藏狀態(注意力塊中的鍵和值),可用於(參見 past_key_values 輸入)加速順序解碼。

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

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

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

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

transformers.modeling_tf_outputs.TFCausalLMOutputWithPasttuple(tf.Tensor):一個 transformers.modeling_tf_outputs.TFCausalLMOutputWithPast 或一個 `tf.Tensor` 元組(如果傳遞了 `return_dict=False` 或 `config.return_dict=False`),包含的各種元素取決於配置 (OPTConfig) 和輸入。

  • loss (形狀為(n,)tf.Tensor可選,其中n是非掩碼標籤的數量,當提供了labels時返回) — 語言建模損失(用於下一標記預測)。

  • logits (tf.Tensor of shape (batch_size, sequence_length, config.vocab_size)) — 語言模型頭部的預測分數(SoftMax 之前每個詞彙標記的分數)。

  • past_key_values (list[tf.Tensor]可選,在傳遞 use_cache=Trueconfig.use_cache=True 時返回) — 長度為 config.n_layerstf.Tensor 列表,每個張量的形狀為 (2, batch_size, num_heads, sequence_length, embed_size_per_head))。

    包含預先計算的隱藏狀態(注意力塊中的鍵和值),可用於(參見 past_key_values 輸入)加速順序解碼。

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

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

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

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

示例

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

>>> tokenizer = AutoTokenizer.from_pretrained("facebook/opt-350m")
>>> model = TFOPTForCausalLM.from_pretrained("facebook/opt-350m")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="tf")
>>> outputs = model(inputs)
>>> logits = outputs.logits
JAX
隱藏 JAX 內容

FlaxOPTModel

class transformers.FlaxOPTModel

< >

( config: OPTConfig input_shape: tuple = (1, 1) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )

__call__

< >

( input_ids: Array attention_mask: typing.Optional[jax.Array] = None position_ids: typing.Optional[jax.Array] = None params: typing.Optional[dict] = None past_key_values: typing.Optional[dict] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None dropout_rng: <function PRNGKey at 0x7effc7ad3a30> = None deterministic: bool = True ) transformers.modeling_flax_outputs.FlaxBaseModelOutputtuple(torch.FloatTensor)

返回

transformers.modeling_flax_outputs.FlaxBaseModelOutputtuple(torch.FloatTensor)

一個 transformers.modeling_flax_outputs.FlaxBaseModelOutput 或一個 `torch.FloatTensor` 元組(如果傳遞了 `return_dict=False` 或 `config.return_dict=False`),包含的各種元素取決於配置 (OPTConfig) 和輸入。

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

  • hidden_states (tuple(jnp.ndarray), 可選, 當傳遞 `output_hidden_states=True` 或 `config.output_hidden_states=True` 時返回) — `jnp.ndarray` 的元組(一個用於詞嵌入的輸出,另一個用於每層的輸出),形狀為 `(batch_size, sequence_length, hidden_size)`。

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

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

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

示例

>>> from transformers import AutoTokenizer, FlaxOPTModel

>>> tokenizer = AutoTokenizer.from_pretrained("facebook/opt-350m")
>>> model = FlaxOPTModel.from_pretrained("facebook/opt-350m")

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

>>> last_hidden_states = outputs.last_hidden_state

FlaxOPTForCausalLM

class transformers.FlaxOPTForCausalLM

< >

( config: OPTConfig input_shape: tuple = (1, 1) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )

引數

  • config (OPTConfig) — 模型配置類,包含模型的所有引數。使用配置檔案進行初始化不會載入與模型相關的權重,只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。
  • dtype (jax.numpy.dtype, 可選, 預設為 `jax.numpy.float32`) — 計算的資料型別。可以是 `jax.numpy.float32`、`jax.numpy.float16` (在 GPU 上) 和 `jax.numpy.bfloat16` (在 TPU 上) 之一。

    這可用於在 GPU 或 TPU 上啟用混合精度訓練或半精度推理。如果指定,所有計算都將使用給定的 `dtype` 執行。

    請注意,這僅指定計算的 dtype,不影響模型引數的 dtype。

    如果你希望更改模型引數的 dtype,請參閱 to_fp16()to_bf16()

帶有一個語言建模頭的 OPT 模型(線性層,其權重與輸入嵌入層繫結),例如用於自迴歸任務。

該模型繼承自 FlaxPreTrainedModel。查閱超類文件,瞭解該庫為其所有模型實現的通用方法(例如下載或儲存、調整輸入嵌入大小、修剪頭等)。

該模型也是 Flax Linen flax.nn.Module 的子類。可將其用作常規的 Flax 模組,並參考 Flax 文件瞭解所有與常規用法和行為相關的事項。

最後,此模型支援固有的 JAX 功能,例如

__call__

< >

( input_ids: Array attention_mask: typing.Optional[jax.Array] = None position_ids: typing.Optional[jax.Array] = None params: typing.Optional[dict] = None past_key_values: typing.Optional[dict] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None dropout_rng: <function PRNGKey at 0x7effc7ad3a30> = None deterministic: bool = True ) transformers.modeling_flax_outputs.FlaxBaseModelOutputtuple(torch.FloatTensor)

返回

transformers.modeling_flax_outputs.FlaxBaseModelOutputtuple(torch.FloatTensor)

一個 transformers.modeling_flax_outputs.FlaxBaseModelOutput 或一個 `torch.FloatTensor` 元組(如果傳遞了 `return_dict=False` 或 `config.return_dict=False`),包含的各種元素取決於配置 (OPTConfig) 和輸入。

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

  • hidden_states (tuple(jnp.ndarray), 可選, 當傳遞 `output_hidden_states=True` 或 `config.output_hidden_states=True` 時返回) — `jnp.ndarray` 的元組(一個用於詞嵌入的輸出,另一個用於每層的輸出),形狀為 `(batch_size, sequence_length, hidden_size)`。

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

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

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

示例

>>> from transformers import AutoTokenizer, FlaxOPTForCausalLM

>>> tokenizer = AutoTokenizer.from_pretrained("facebook/opt-350m")
>>> model = FlaxOPTForCausalLM.from_pretrained("facebook/opt-350m")

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

>>> # retrieve logts for next token
>>> next_token_logits = outputs.logits[:, -1]
< > 在 GitHub 上更新

© . This site is unofficial and not affiliated with Hugging Face, Inc.