Hugging Face 的 LOGO

Transformers 文件

YOSO

Hugging Face's logo
加入 Hugging Face 社群

並獲得增強的文件體驗

開始使用

YOSO

PyTorch

概述

YOSO 模型在 You Only Sample (Almost) Once: Linear Cost Self-Attention Via Bernoulli Sampling 中提出，
作者是 Zhanpeng Zeng, Yunyang Xiong, Sathya N. Ravi, Shailesh Acharya, Glenn Fung, Vikas Singh。YOSO 透過基於區域性敏感雜湊 (LSH) 的伯努利取樣方案近似標準 softmax 自注意力。原則上，所有伯努利隨機變數都可以透過一次雜湊取樣。

論文摘要如下：

基於 Transformer 的模型在自然語言處理 (NLP) 中被廣泛使用。Transformer 模型的核心是自注意力機制，它捕獲輸入序列中令牌對的互動，並且其計算成本與序列長度呈二次關係。在較長序列上訓練此類模型成本高昂。在本文中，我們展示了基於區域性敏感雜湊 (LSH) 的伯努利取樣注意力機制，將此類模型的二次複雜度降低到線性。我們透過將自注意力視為與伯努利隨機變數相關的單個令牌之和來繞過二次成本，這些隨機變數原則上可以透過一次雜湊取樣（儘管在實踐中，這個數字可能是一個小的常數）。這導致了一種高效的取樣方案來估計自注意力，該方案依賴於 LSH 的特定修改（以實現 GPU 架構上的部署）。我們在 GLUE 基準上評估了我們的演算法，使用標準 512 序列長度，我們看到了相對於標準預訓練 Transformer 的良好效能。在 Long Range Arena (LRA) 基準上，為了評估長序列的效能，我們的方法實現了與 softmax 自注意力一致的結果，但具有顯著的加速和記憶體節省，並且通常優於其他高效的自注意力方法。我們的程式碼可在 https URL 上獲取

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

使用技巧

  • YOSO 注意力演算法透過自定義 CUDA 核心實現，這些函式用 CUDA C++ 編寫，可以在 GPU 上並行執行多次。
  • 這些核心提供了一個 fast_hash 函式，該函式使用快速哈達瑪變換近似查詢和鍵的隨機投影。使用這些雜湊碼，lsh_cumulation 函式透過基於 LSH 的伯努利取樣近似自注意力。
  • 要使用自定義核心，使用者應設定 config.use_expectation = False。為確保核心成功編譯，使用者必須安裝正確版本的 PyTorch 和 cudatoolkit。預設情況下，config.use_expectation = True，這將使用 YOSO-E 並且不需要編譯 CUDA 核心。
drawing YOSO 注意力演算法。取自原始論文。

資源

YosoConfig

class transformers.YosoConfig

< >

( vocab_size = 50265 hidden_size = 768 num_hidden_layers = 12 num_attention_heads = 12 intermediate_size = 3072 hidden_act = 'gelu' hidden_dropout_prob = 0.1 attention_probs_dropout_prob = 0.1 max_position_embeddings = 4096 type_vocab_size = 1 initializer_range = 0.02 layer_norm_eps = 1e-12 position_embedding_type = 'absolute' use_expectation = True hash_code_len = 9 num_hash = 64 conv_window = None use_fast_hash = True lsh_backward = True pad_token_id = 1 bos_token_id = 0 eos_token_id = 2 **kwargs )

引數

  • vocab_size (int, 可選, 預設為 50265) — YOSO 模型的詞彙表大小。定義了呼叫 YosoModel 時可以表示的不同令牌數量。
  • hidden_size (int, 可選, 預設為 768) — 編碼器層和池化層的大小。
  • num_hidden_layers (int, 可選, 預設為 12) — Transformer 編碼器中隱藏層的數量。
  • num_attention_heads (int, 可選, 預設為 12) — Transformer 編碼器中每個注意力層的注意力頭數量。
  • intermediate_size (int, 可選, 預設為 3072) — Transformer 編碼器中“中間”（即前饋）層的大小。
  • hidden_act (str 或 function, 可選, 預設為 "gelu") — 編碼器和池化層中的非線性啟用函式（函式或字串）。如果是字串，支援 "gelu"、"relu"、"selu" 和 "gelu_new"。
  • hidden_dropout_prob (float, 可選, 預設為 0.1) — 嵌入層、編碼器和池化層中所有全連線層的 dropout 機率。
  • attention_probs_dropout_prob (float, 可選, 預設為 0.1) — 注意力機率的 dropout 比率。
  • max_position_embeddings (int, 可選, 預設為 512) — 此模型可能使用的最大序列長度。通常設定為較大值以防萬一（例如，512、1024 或 2048）。
  • type_vocab_size (int, 可選, 預設為 2) — 呼叫 YosoModel 時傳入的 token_type_ids 的詞彙表大小。
  • initializer_range (float, 可選, 預設為 0.02) — 用於初始化所有權重矩陣的 truncated_normal_initializer 的標準差。
  • layer_norm_eps (float, 可選, 預設為 1e-12) — 層歸一化層使用的 epsilon 值。
  • position_embedding_type (str, 可選, 預設為 "absolute") — 位置嵌入的型別。選擇 "absolute"、"relative_key"、"relative_key_query" 之一。
  • use_expectation (bool, 可選, 預設為 True) — 是否使用 YOSO 期望值。會覆蓋 num_hash 的任何影響。
  • hash_code_len (int, 可選, 預設為 9) — 雜湊函式生成的雜湊碼的長度。
  • num_hash (int, 可選, 預設為 64) — YosoSelfAttention 中使用的雜湊函式的數量。
  • conv_window (int, 可選) — 深度卷積的核大小。
  • use_fast_hash (bool, 可選, 預設為 False) — 是否使用自定義 cuda 核心，該核心透過哈達瑪變換執行快速隨機投影。
  • lsh_backward (bool, optional, 預設為 True) — 是否使用區域性敏感雜湊進行反向傳播。

這是用於儲存 YosoModel 配置的配置類。它用於根據指定引數例項化 YOSO 模型，定義模型架構。使用預設值例項化配置將產生與 YOSO uw-madison/yoso-4096 架構相似的配置。

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

示例

>>> from transformers import YosoConfig, YosoModel

>>> # Initializing a YOSO uw-madison/yoso-4096 style configuration
>>> configuration = YosoConfig()

>>> # Initializing a model (with random weights) from the uw-madison/yoso-4096 style configuration
>>> model = YosoModel(configuration)

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

YosoModel

class transformers.YosoModel

< >

( config )

引數

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

裸 Yoso 模型，直接輸出原始隱藏狀態，不帶任何特定頭部。

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

此模型也是 PyTorch torch.nn.Module 子類。將其作為常規 PyTorch 模組使用，並參考 PyTorch 文件瞭解所有與一般用法和行為相關的事項。

forward

< >

( input_ids: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None token_type_ids: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.Tensor] = None head_mask: typing.Optional[torch.Tensor] = None inputs_embeds: typing.Optional[torch.Tensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None → transformers.modeling_outputs.BaseModelOutputWithCrossAttentions or tuple(torch.FloatTensor)

引數

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

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

    什麼是 input IDs？

  • attention_mask (形狀為 (batch_size, sequence_length) 的 torch.Tensor, 可選) — 用於避免對填充標記索引執行注意力操作的掩碼。掩碼值選擇範圍為 [0, 1]：

    • 1 表示未被掩蓋的標記，
    • 0 表示被掩蓋的標記。

    什麼是注意力掩碼？

  • token_type_ids (形狀為 (batch_size, sequence_length) 的 torch.Tensor, 可選) — 表示輸入第一部分和第二部分的段落標記索引。索引選擇範圍為 [0, 1]：

    • 0 對應於一個句子 A 標記，
    • 1 對應於一個句子 B 標記。

    什麼是標記型別 ID？

  • position_ids (形狀為 (batch_size, sequence_length) 的 torch.Tensor, 可選) — 每個輸入序列標記在位置嵌入中的位置索引。選擇範圍為 [0, config.n_positions - 1]。

    什麼是位置 ID？

  • head_mask (形狀為 (num_heads,) 或 (num_layers, num_heads) 的 torch.Tensor, 可選) — 用於使自注意力模組的選定頭部無效的掩碼。掩碼值選擇範圍為 [0, 1]：

    • 1 表示頭部未被掩蓋，
    • 0 表示頭部被掩蓋。
  • inputs_embeds (形狀為 (batch_size, sequence_length, hidden_size) 的 torch.Tensor, 可選) — 可選地，您可以直接傳遞嵌入表示，而不是傳遞 input_ids。如果您希望對 input_ids 索引如何轉換為相關向量有更多控制，而不是使用模型的內部嵌入查詢矩陣，這將非常有用。
  • output_attentions (bool, 可選) — 是否返回所有注意力層的注意力張量。更多詳情請參見返回張量下的 attentions。
  • output_hidden_states (bool, 可選) — 是否返回所有層的隱藏狀態。更多詳情請參見返回張量下的 hidden_states。
  • return_dict (bool, 可選) — 是否返回 ModelOutput 而不是普通的元組。

返回

transformers.modeling_outputs.BaseModelOutputWithCrossAttentions 或 tuple(torch.FloatTensor)

一個 transformers.modeling_outputs.BaseModelOutputWithCrossAttentions 或一個 torch.FloatTensor 元組（如果傳遞 return_dict=False 或 config.return_dict=False），包含根據配置（YosoConfig）和輸入的不同元素。

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

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

    解碼器交叉注意力層的注意力權重，在注意力 softmax 之後，用於計算交叉注意力頭中的加權平均。

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

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

YosoForMaskedLM

class transformers.YosoForMaskedLM

< >

( config )

引數

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

帶有 語言建模 頭部在頂部的 Yoso 模型。”

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

此模型也是 PyTorch torch.nn.Module 子類。將其作為常規 PyTorch 模組使用，並參考 PyTorch 文件瞭解所有與一般用法和行為相關的事項。

forward

< >

( input_ids: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None token_type_ids: typing.Optional[torch.Tensor] = None position_ids: 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.MaskedLMOutput 或 tuple(torch.FloatTensor)

引數

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

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

    什麼是 input IDs？

  • attention_mask (形狀為 (batch_size, sequence_length) 的 torch.Tensor, 可選) — 用於避免對填充標記索引執行注意力操作的掩碼。掩碼值選擇範圍為 [0, 1]：

    • 1 表示未被掩蓋的標記，
    • 0 表示被掩蓋的標記。

    什麼是注意力掩碼？

  • token_type_ids (形狀為 (batch_size, sequence_length) 的 torch.Tensor, 可選) — 表示輸入第一部分和第二部分的段落標記索引。索引選擇範圍為 [0, 1]：

    • 0 對應於一個句子 A 標記，
    • 1 對應於一個句子 B 標記。

    什麼是標記型別 ID？

  • position_ids (形狀為 (batch_size, sequence_length) 的 torch.Tensor, 可選) — 每個輸入序列標記在位置嵌入中的位置索引。選擇範圍為 [0, config.n_positions - 1]。

    什麼是位置 ID？

  • head_mask (形狀為 (num_heads,) 或 (num_layers, num_heads) 的 torch.Tensor, 可選) — 用於使自注意力模組的選定頭部無效的掩碼。掩碼值選擇範圍為 [0, 1]：

    • 1 表示頭部未被掩蓋，
    • 0 表示頭部被掩蓋。
  • inputs_embeds (形狀為 (batch_size, sequence_length, hidden_size) 的 torch.Tensor, 可選) — 可選地，您可以直接傳遞嵌入表示，而不是傳遞 input_ids。如果您希望對 input_ids 索引如何轉換為相關向量有更多控制，而不是使用模型的內部嵌入查詢矩陣，這將非常有用。
  • labels (形狀為 (batch_size, sequence_length) 的 torch.LongTensor, 可選) — 用於計算掩碼語言建模損失的標籤。索引應在 [-100, 0, ..., config.vocab_size] 範圍內（參見 input_ids 文件字串）索引設定為 -100 的標記將被忽略（掩碼），損失僅針對標籤在 [0, ..., config.vocab_size] 中的標記計算。
  • output_attentions (bool, 可選) — 是否返回所有注意力層的注意力張量。更多詳情請參見返回張量下的 attentions。
  • output_hidden_states (bool, 可選) — 是否返回所有層的隱藏狀態。更多詳情請參見返回張量下的 hidden_states。
  • return_dict (bool, 可選) — 是否返回 ModelOutput 而不是普通的元組。

返回

transformers.modeling_outputs.MaskedLMOutput 或 tuple(torch.FloatTensor)

一個 transformers.modeling_outputs.MaskedLMOutput 或一個 torch.FloatTensor 元組（如果傳遞 return_dict=False 或 config.return_dict=False），包含根據配置（YosoConfig）和輸入的不同元素。

  • loss (形狀為 (1,) 的 torch.FloatTensor，可選，當提供 labels 時返回) — 掩碼語言建模 (MLM) 損失。

  • logits (形狀為 (batch_size, sequence_length, config.vocab_size) 的 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 後的注意力權重，用於計算自注意力頭中的加權平均值。

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

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

示例

>>> from transformers import AutoTokenizer, YosoForMaskedLM
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("uw-madison/yoso-4096")
>>> model = YosoForMaskedLM.from_pretrained("uw-madison/yoso-4096")

>>> inputs = tokenizer("The capital of France is <mask>.", return_tensors="pt")

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

>>> # retrieve index of <mask>
>>> mask_token_index = (inputs.input_ids == tokenizer.mask_token_id)[0].nonzero(as_tuple=True)[0]

>>> predicted_token_id = logits[0, mask_token_index].argmax(axis=-1)
>>> tokenizer.decode(predicted_token_id)
...

>>> labels = tokenizer("The capital of France is Paris.", return_tensors="pt")["input_ids"]
>>> # mask labels of non-<mask> tokens
>>> labels = torch.where(inputs.input_ids == tokenizer.mask_token_id, labels, -100)

>>> outputs = model(**inputs, labels=labels)
>>> round(outputs.loss.item(), 2)
...

YosoForSequenceClassification

class transformers.YosoForSequenceClassification

< >

( config )

引數

YOSO 模型轉換器，頂部帶有一個序列分類/迴歸頭部（池化輸出頂部的一個線性層），例如用於 GLUE 任務。

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

此模型也是 PyTorch torch.nn.Module 子類。將其作為常規 PyTorch 模組使用，並參考 PyTorch 文件瞭解所有與一般用法和行為相關的事項。

forward

< >

( input_ids: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None token_type_ids: typing.Optional[torch.Tensor] = None position_ids: 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.SequenceClassifierOutput 或 tuple(torch.FloatTensor)

引數

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

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

    什麼是 input IDs？

  • attention_mask (形狀為 (batch_size, sequence_length) 的 torch.Tensor, 可選) — 用於避免對填充標記索引執行注意力操作的掩碼。掩碼值選擇範圍為 [0, 1]：

    • 1 表示未被掩蓋的標記，
    • 0 表示被掩蓋的標記。

    什麼是注意力掩碼？

  • token_type_ids (形狀為 (batch_size, sequence_length) 的 torch.Tensor, 可選) — 表示輸入第一部分和第二部分的段落標記索引。索引選擇範圍為 [0, 1]：

    • 0 對應於一個句子 A 標記，
    • 1 對應於一個句子 B 標記。

    什麼是標記型別 ID？

  • position_ids (形狀為 (batch_size, sequence_length) 的 torch.Tensor, 可選) — 每個輸入序列標記在位置嵌入中的位置索引。選擇範圍為 [0, config.n_positions - 1]。

    什麼是位置 ID？

  • head_mask (形狀為 (num_heads,) 或 (num_layers, num_heads) 的 torch.Tensor, 可選) — 用於使自注意力模組的選定頭部無效的掩碼。掩碼值選擇範圍為 [0, 1]：

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

返回

transformers.modeling_outputs.SequenceClassifierOutput 或 tuple(torch.FloatTensor)

一個 transformers.modeling_outputs.SequenceClassifierOutput 或一個 torch.FloatTensor 元組（如果傳遞 return_dict=False 或 config.return_dict=False），包含根據配置（YosoConfig）和輸入的不同元素。

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

  • logits (形狀為 (batch_size, config.num_labels) 的 torch.FloatTensor) — 分類（如果 config.num_labels==1，則為迴歸）分數（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 後的注意力權重，用於計算自注意力頭中的加權平均值。

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

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

單標籤分類示例

>>> import torch
>>> from transformers import AutoTokenizer, YosoForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("uw-madison/yoso-4096")
>>> model = YosoForSequenceClassification.from_pretrained("uw-madison/yoso-4096")

>>> 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 = YosoForSequenceClassification.from_pretrained("uw-madison/yoso-4096", num_labels=num_labels)

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

多標籤分類示例

>>> import torch
>>> from transformers import AutoTokenizer, YosoForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("uw-madison/yoso-4096")
>>> model = YosoForSequenceClassification.from_pretrained("uw-madison/yoso-4096", 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 = YosoForSequenceClassification.from_pretrained(
...     "uw-madison/yoso-4096", 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

YosoForMultipleChoice

class transformers.YosoForMultipleChoice

< >

( config )

引數

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

Yoso 模型，頂部帶有多項選擇分類頭部（池化輸出頂部的一個線性層和 softmax），例如用於 RocStories/SWAG 任務。

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

此模型也是 PyTorch torch.nn.Module 子類。將其作為常規 PyTorch 模組使用，並參考 PyTorch 文件瞭解所有與一般用法和行為相關的事項。

forward

< >

( input_ids: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None token_type_ids: typing.Optional[torch.Tensor] = None position_ids: 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.MultipleChoiceModelOutput 或 tuple(torch.FloatTensor)

引數

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

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

    什麼是 input ID？

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

    • 1 表示 未被掩碼 的 token，
    • 0 表示 被掩碼 的 token。

    什麼是注意力掩碼？

  • token_type_ids (torch.LongTensor，形狀為 (batch_size, num_choices, sequence_length), 可選) — 分段 token 索引，用於指示輸入的第一個和第二個部分。索引選擇在 [0, 1] 之間：

    • 0 對應於 句子 A 的 token，
    • 1 對應於 句子 B 的 token。

    什麼是 token type ID？

  • position_ids (torch.LongTensor，形狀為 (batch_size, num_choices, sequence_length), 可選) — 每個輸入序列 token 在位置嵌入中的位置索引。選擇範圍在 [0, config.max_position_embeddings - 1] 之間。

    什麼是位置 ID？

  • head_mask (torch.Tensor，形狀為 (num_heads,) 或 (num_layers, num_heads), 可選) — 用於使自注意力模組的選定頭無效的掩碼。掩碼值選擇在 [0, 1] 之間：

    • 1 表示頭部 未被掩碼，
    • 0 表示頭部 被掩碼。
  • inputs_embeds (torch.FloatTensor，形狀為 (batch_size, num_choices, sequence_length, hidden_size), 可選) — 可選地，除了傳遞 input_ids，您還可以直接傳遞嵌入表示。如果您希望對如何將 input_ids 索引轉換為相關向量有比模型內部嵌入查詢矩陣更多的控制，這將非常有用。
  • labels (torch.LongTensor，形狀為 (batch_size,), 可選) — 用於計算多項選擇分類損失的標籤。索引應在 [0, ..., num_choices-1] 之間，其中 num_choices 是輸入張量第二維度的大小。（請參閱上面的 input_ids）
  • output_attentions (bool, 可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊，請參閱返回張量下的 attentions。
  • output_hidden_states (bool, 可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊，請參閱返回張量下的 hidden_states。
  • return_dict (bool, 可選) — 是否返回 ModelOutput 而不是普通的元組。

返回

transformers.modeling_outputs.MultipleChoiceModelOutput 或 tuple(torch.FloatTensor)

一個 transformers.modeling_outputs.MultipleChoiceModelOutput 或一個 torch.FloatTensor 元組（如果傳遞 return_dict=False 或當 config.return_dict=False 時），包含根據配置 (YosoConfig) 和輸入而變化的各種元素。

  • loss (形狀為 (1,) 的 torch.FloatTensor，可選，當提供 labels 時返回) — 分類損失。

  • logits (形狀為 (batch_size, num_choices) 的 torch.FloatTensor) — num_choices 是輸入張量的第二維大小。（請參閱上面的 input_ids）。

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

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

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

示例

>>> from transformers import AutoTokenizer, YosoForMultipleChoice
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("uw-madison/yoso-4096")
>>> model = YosoForMultipleChoice.from_pretrained("uw-madison/yoso-4096")

>>> prompt = "In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced."
>>> choice0 = "It is eaten with a fork and a knife."
>>> choice1 = "It is eaten while held in the hand."
>>> labels = torch.tensor(0).unsqueeze(0)  # choice0 is correct (according to Wikipedia ;)), batch size 1

>>> encoding = tokenizer([prompt, prompt], [choice0, choice1], return_tensors="pt", padding=True)
>>> outputs = model(**{k: v.unsqueeze(0) for k, v in encoding.items()}, labels=labels)  # batch size is 1

>>> # the linear classifier still needs to be trained
>>> loss = outputs.loss
>>> logits = outputs.logits

YosoForTokenClassification

class transformers.YosoForTokenClassification

< >

( config )

引數

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

Yoso 變換器，頂部帶有一個 token 分類頭（位於隱藏狀態輸出頂部的線性層），例如用於命名實體識別 (NER) 任務。

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

此模型也是 PyTorch torch.nn.Module 子類。將其作為常規 PyTorch 模組使用，並參考 PyTorch 文件瞭解所有與一般用法和行為相關的事項。

forward

 < >

( input_ids: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None token_type_ids: typing.Optional[torch.Tensor] = None position_ids: 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.Tensor，形狀為 (batch_size, sequence_length), 可選) — 詞彙表中輸入序列 token 的索引。填充預設會被忽略。

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

    什麼是 input ID？

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

    • 1 表示 未被掩碼 的 token，
    • 0 表示 被掩碼 的 token。

    什麼是注意力掩碼？

  • token_type_ids (torch.Tensor，形狀為 (batch_size, sequence_length), 可選) — 分段 token 索引，用於指示輸入的第一個和第二個部分。索引選擇在 [0, 1] 之間：

    • 0 對應於 句子 A 的 token，
    • 1 對應於 句子 B 的 token。

    什麼是 token type ID？

  • position_ids (torch.Tensor，形狀為 (batch_size, sequence_length), 可選) — 每個輸入序列 token 在位置嵌入中的位置索引。選擇範圍在 [0, config.n_positions - 1] 之間。

    什麼是位置 ID？

  • 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), 可選) — 用於計算 token 分類損失的標籤。索引應在 [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 時），包含根據配置 (YosoConfig) 和輸入而變化的各種元素。

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

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

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

示例

>>> from transformers import AutoTokenizer, YosoForTokenClassification
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("uw-madison/yoso-4096")
>>> model = YosoForTokenClassification.from_pretrained("uw-madison/yoso-4096")

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

YosoForQuestionAnswering

class transformers.YosoForQuestionAnswering

< >

( config )

引數

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

Yoso 變換器，頂部帶有一個 span 分類頭，用於 SQuAD 等抽取式問答任務（位於隱藏狀態輸出頂部的線性層，用於計算 span start logits 和 span end logits）。

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

此模型也是 PyTorch torch.nn.Module 子類。將其作為常規 PyTorch 模組使用，並參考 PyTorch 文件瞭解所有與一般用法和行為相關的事項。

forward

 < >

( input_ids: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None token_type_ids: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.Tensor] = None head_mask: typing.Optional[torch.Tensor] = None inputs_embeds: typing.Optional[torch.Tensor] = None start_positions: typing.Optional[torch.Tensor] = None end_positions: 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.QuestionAnsweringModelOutput 或 tuple(torch.FloatTensor)

引數

  • input_ids (torch.Tensor，形狀為 (batch_size, sequence_length), 可選) — 詞彙表中輸入序列 token 的索引。填充預設會被忽略。

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

    什麼是 input ID？

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

    • 1 表示 未被掩碼 的 token，
    • 0 表示 被掩碼 的 token。

    什麼是注意力掩碼？

  • token_type_ids (torch.Tensor，形狀為 (batch_size, sequence_length), 可選) — 分段 token 索引，用於指示輸入的第一個和第二個部分。索引選擇在 [0, 1] 之間：

    • 0 對應於 句子 A 的 token，
    • 1 對應於 句子 B 的 token。

    什麼是 token type ID？

  • position_ids (torch.Tensor，形狀為 (batch_size, sequence_length), 可選) — 每個輸入序列 token 在位置嵌入中的位置索引。選擇範圍在 [0, config.n_positions - 1] 之間。

    什麼是位置 ID？

  • 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 索引轉換為相關向量有比模型內部嵌入查詢矩陣更多的控制，這將非常有用。
  • start_positions (torch.Tensor，形狀為 (batch_size,), 可選) — 用於計算 token 分類損失的已標記 span 起始位置（索引）的標籤。位置被限制在序列長度（sequence_length）範圍內。序列外的位置不計入損失計算。
  • end_positions (torch.Tensor，形狀為 (batch_size,), 可選) — 用於計算 token 分類損失的已標記 span 結束位置（索引）的標籤。位置被限制在序列長度（sequence_length）範圍內。序列外的位置不計入損失計算。
  • output_attentions (bool, 可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊，請參閱返回張量下的 attentions。
  • output_hidden_states (bool, 可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊，請參閱返回張量下的 hidden_states。
  • return_dict (bool, 可選) — 是否返回 ModelOutput 而不是普通的元組。

返回

transformers.modeling_outputs.QuestionAnsweringModelOutput 或 tuple(torch.FloatTensor)

一個 transformers.modeling_outputs.QuestionAnsweringModelOutput 或一個 torch.FloatTensor 元組（如果傳遞 return_dict=False 或當 config.return_dict=False 時），包含根據配置 (YosoConfig) 和輸入而變化的各種元素。

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

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

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

示例

>>> from transformers import AutoTokenizer, YosoForQuestionAnswering
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("uw-madison/yoso-4096")
>>> model = YosoForQuestionAnswering.from_pretrained("uw-madison/yoso-4096")

>>> 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)
...
< > 在 GitHub 上更新

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