Transformers 文档

YOSO

Transformers

加入 Hugging Face 社区

并获得增强的文档体验

协作处理模型、数据集和 Spaces

通过加速推理获得更快的示例

切换文档主题

开始使用

YOSO

概述

YOSO 模型在 Zhanpeng Zeng、Yunyang Xiong、Sathya N. Ravi、Shailesh Acharya、Glenn Fung、Vikas Singh 的论文《You Only Sample (Almost) Once: Linear Cost Self-Attention Via Bernoulli Sampling》中提出。
YOSO 通过基于局部敏感哈希 (LSH) 的伯努利抽样方案来近似标准 softmax 自注意力。原则上，所有伯努利随机变量都可以通过单个哈希进行采样。

该论文的摘要如下：

基于 Transformer 的模型广泛应用于自然语言处理 (NLP) 领域。Transformer 模型的核心是自注意力机制，它捕获输入序列中 token 对之间的交互作用，并且其复杂度与序列长度呈二次方关系。在较长序列上训练此类模型的成本很高。在本文中，我们证明了基于局部敏感哈希 (LSH) 的伯努利抽样注意力机制，可以将此类模型的二次方复杂度降低到线性复杂度。我们通过将自注意力视为与伯努利随机变量相关的单个 token 的总和来绕过二次方成本，原则上，这些变量可以通过单个哈希一次性采样（尽管在实践中，这个数字可能是一个小的常数）。这产生了一种有效的抽样方案来估计自注意力，该方案依赖于 LSH 的特定修改（以实现在 GPU 架构上的部署）。我们在 GLUE 基准测试中使用标准的 512 序列长度评估了我们的算法，结果表明，相对于标准的预训练 Transformer，我们的算法表现出良好的性能。在长程竞技场 (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 内核。

YOSO 注意力算法。取自原始论文。

资源

YosoConfig

class transformers.YosoConfig

< source >

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

Parameters

vocab_size (int, optional, 默认为 50265) — YOSO 模型的词汇表大小。定义了在调用 YosoModel 时传递的 inputs_ids 可以表示的不同 token 的数量。
hidden_size (int, optional, 默认为 768) — 编码器层和池化器层的维度。
num_hidden_layers (int, optional, 默认为 12) — Transformer 编码器中隐藏层的数量。
num_attention_heads (int, optional, 默认为 12) — Transformer 编码器中每个注意力层的注意力头的数量。
intermediate_size (int, optional, 默认为 3072) — Transformer 编码器中“中间”层（即，前馈层）的维度。
hidden_act (str 或 function, optional, 默认为 "gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果为字符串，则支持 "gelu"、"relu"、"selu" 和 "gelu_new"。
hidden_dropout_prob (float, optional, 默认为 0.1) — 嵌入层、编码器和池化器中所有全连接层的 dropout 概率。
attention_probs_dropout_prob (float, optional, 默认为 0.1) — 注意力概率的 dropout 比率。
max_position_embeddings (int, optional, 默认为 512) — 此模型可能使用的最大序列长度。通常将其设置为较大的值以防万一（例如，512 或 1024 或 2048）。
type_vocab_size (int, optional, 默认为 2) — 调用 YosoModel 时传递的 token_type_ids 的词汇表大小。
initializer_range (float, optional, 默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
layer_norm_eps (float, optional, 默认为 1e-12) — 层归一化层使用的 epsilon 值。
position_embedding_type (str, optional, 默认为 "absolute") — 位置嵌入的类型。从 "absolute", "relative_key", "relative_key_query" 中选择一个。
use_expectation (bool, optional, 默认为 True) — 是否使用 YOSO Expectation。覆盖 num_hash 的任何效果。
hash_code_len (int, optional, 默认为 9) — 哈希函数生成的哈希码的长度。
num_hash (int, optional, 默认为 64) — 在 YosoSelfAttention 中使用的哈希函数的数量。
conv_window (int, optional) — 深度卷积的内核大小。
use_fast_hash (bool, optional, 默认为 False) — 是否使用自定义 cuda 内核，通过 hadamard 变换执行快速随机投影。
lsh_backward (bool, optional, 默认为 True) — 是否使用局部敏感哈希 (Locality Sensitive Hashing) 执行反向传播。

这是用于存储 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

< source >

( config )

Parameters

config (YosoConfig) — 带有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。

裸 YOSO 模型 Transformer 输出原始隐藏状态，顶部没有任何特定的 head。此模型是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参阅 PyTorch 文档以了解与常规用法和行为相关的所有事项。

forward

< source >

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

Parameters

input_ids (torch.LongTensor of shape (batch_size, sequence_length)) — 词汇表中输入序列 tokens 的索引。

索引可以使用 AutoTokenizer 获得。请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call() 以了解详情。

什么是输入 IDs？
attention_mask (torch.FloatTensor of shape (batch_size, sequence_length), optional) — 掩码，用于避免在 padding token 索引上执行 attention。掩码值在 [0, 1] 中选择：
- 1 表示 tokens 未被掩码，
- 0 表示 tokens 被掩码。
什么是 attention 掩码？
token_type_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 段落 token 索引，用于指示输入的第一部分和第二部分。索引在 [0, 1] 中选择：
- 0 对应于 句子 A token，
- 1 对应于 句子 B token。
什么是 token type IDs？
position_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 位置嵌入中每个输入序列 tokens 的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。

什么是 position IDs？
head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) — 用于使 self-attention 模块的选定 head 无效的掩码。掩码值在 [0, 1] 中选择：
- 1 表示 head 未被掩码，
- 0 表示 head 被掩码。
inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选地，您可以选择直接传递嵌入表示，而不是传递 input_ids。如果您希望比模型的内部嵌入查找矩阵更精确地控制如何将 input_ids 索引转换为关联的向量，这将非常有用。
output_attentions (bool, optional) — 是否返回所有 attention 层的 attention tensors。有关更多详细信息，请参阅返回 tensors 下的 attentions。
output_hidden_states (bool, optional) — 是否返回所有层的 hidden states。有关更多详细信息，请参阅返回 tensors 下的 hidden_states。
return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通的 tuple。

Returns

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

一个 transformers.modeling_outputs.BaseModelOutputWithCrossAttentions 或一个 torch.FloatTensor 的 tuple（如果传递了 return_dict=False 或当 config.return_dict=False 时），包含各种元素，具体取决于配置 (YosoConfig) 和输入。

last_hidden_state (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size)) — 模型最后一层的输出端的 hidden-states 序列。
hidden_states (tuple(torch.FloatTensor), optional, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — torch.FloatTensor 的 Tuple (如果模型具有嵌入层，则为嵌入输出 + 每个层的输出各一个)，形状为 (batch_size, sequence_length, hidden_size)。

模型在每一层输出端的 Hidden-states，加上可选的初始嵌入输出。
attentions (tuple(torch.FloatTensor), optional, 当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — torch.FloatTensor 的 Tuple（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

attention softmax 后的 Attention 权重，用于计算 self-attention heads 中的加权平均值。
cross_attentions (tuple(torch.FloatTensor), optional, 当传递 output_attentions=True 和 config.add_cross_attention=True 或当 config.output_attentions=True 时返回) — torch.FloatTensor 的 Tuple（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

decoder 的 cross-attention 层的 Attention 权重，在 attention softmax 之后，用于计算 cross-attention heads 中的加权平均值。

YosoModel 前向传播方法，覆盖了 __call__ 特殊方法。

虽然前向传播的配方需要在该函数内定义，但应该在之后调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。

示例

>>> from transformers import AutoTokenizer, YosoModel
>>> import torch

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

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

>>> last_hidden_states = outputs.last_hidden_state

YosoForMaskedLM

class transformers.YosoForMaskedLM

< source >

( config )

Parameters

config (YosoConfig) — 带有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，而只会加载配置。查看 from_pretrained() 方法以加载模型权重。

带有 language modeling head 的 YOSO 模型。该模型是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch Module，并参考 PyTorch 文档，了解与常规用法和行为相关的所有事项。

forward

< source >

( 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 or tuple(torch.FloatTensor)

Parameters

input_ids (torch.LongTensor of shape (batch_size, sequence_length)) — 词汇表中输入序列 tokens 的索引。

索引可以使用 AutoTokenizer 获得。请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call() 以了解详情。

什么是输入 IDs？
attention_mask (torch.FloatTensor of shape (batch_size, sequence_length), optional) — 掩码，用于避免在 padding token 索引上执行 attention。掩码值在 [0, 1] 中选择：
- 1 表示 tokens 未被掩码，
- 0 表示 tokens 被掩码。
什么是 attention 掩码？
token_type_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 段落 token 索引，用于指示输入的第一部分和第二部分。索引在 [0, 1] 中选择：
- 0 对应于 句子 A token，
- 1 对应于 句子 B token。
什么是 token type IDs？
position_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 位置嵌入中每个输入序列 tokens 的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。

什么是 position IDs？
head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) — 用于使 self-attention 模块的选定 head 无效的掩码。掩码值在 [0, 1] 中选择：
- 1 表示 head 未被掩码，
- 0 表示 head 被掩码。
inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选地，您可以选择直接传递嵌入表示，而不是传递 input_ids。如果您希望比模型的内部嵌入查找矩阵更精确地控制如何将 input_ids 索引转换为关联的向量，这将非常有用。
output_attentions (bool, optional) — 是否返回所有 attention 层的 attention tensors。有关更多详细信息，请参阅返回 tensors 下的 attentions。
output_hidden_states (bool, optional) — 是否返回所有层的 hidden states。有关更多详细信息，请参阅返回 tensors 下的 hidden_states。
return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通的 tuple。
labels (torch.LongTensor of shape (batch_size, sequence_length), optional) — 用于计算 masked language modeling loss 的标签。索引应在 [-100, 0, ..., config.vocab_size] 中（请参阅 input_ids 文档字符串）。索引设置为 -100 的 Tokens 将被忽略（掩码），损失仅针对标签在 [0, ..., config.vocab_size] 中的 tokens 计算。

Returns

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

一个 transformers.modeling_outputs.MaskedLMOutput 或一个 torch.FloatTensor 的 tuple（如果传递了 return_dict=False 或当 config.return_dict=False 时），包含各种元素，具体取决于配置 (YosoConfig) 和输入。

loss (torch.FloatTensor of shape (1,), optional, 当提供 labels 时返回) — Masked language modeling (MLM) 损失。
logits (torch.FloatTensor of shape (batch_size, sequence_length, config.vocab_size)) — 语言建模 head 的预测分数（SoftMax 之前每个词汇表 token 的分数）。
hidden_states (tuple(torch.FloatTensor), optional, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — torch.FloatTensor 的 Tuple (如果模型具有嵌入层，则为嵌入输出 + 每个层的输出各一个)，形状为 (batch_size, sequence_length, hidden_size)。

模型在每一层输出端的 Hidden-states，加上可选的初始嵌入输出。
attentions (tuple(torch.FloatTensor), optional, 当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — torch.FloatTensor 的 Tuple（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

attention softmax 后的 Attention 权重，用于计算 self-attention heads 中的加权平均值。

YosoForMaskedLM 前向传播方法，覆盖了 __call__ 特殊方法。

示例

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

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

YosoForSequenceClassification

class transformers.YosoForSequenceClassification

< source >

( config )

Parameters

config (YosoConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 from_pretrained() 方法来加载模型权重。

YOSO 模型转换器，顶部带有一个序列分类/回归头（池化输出顶部的线性层），例如用于 GLUE 任务。此模型是 PyTorch torch.nn.Module 子类。像常规 PyTorch 模块一样使用它，并参阅 PyTorch 文档以了解与通用用法和行为相关的所有事项。

forward

< source >

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

Parameters

input_ids (torch.LongTensor，形状为 (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。

可以使用 AutoTokenizer 获取索引。有关详细信息，请参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

什么是输入 IDs？
attention_mask (torch.FloatTensor，形状为 (batch_size, sequence_length), 可选) — 避免在填充标记索引上执行 attention 的掩码。掩码值在 [0, 1] 中选择：
- 1 表示标记未被掩蔽，
- 0 表示标记被掩蔽。
什么是 attention 掩码？
token_type_ids (torch.LongTensor，形状为 (batch_size, sequence_length), 可选) — 分段标记索引，用于指示输入的第一部分和第二部分。索引在 [0, 1] 中选择：
- 0 对应于 句子 A 标记，
- 1 对应于 句子 B 标记。
什么是标记类型 IDs？
position_ids (torch.LongTensor，形状为 (batch_size, sequence_length), 可选) — 位置嵌入中每个输入序列标记的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。

什么是位置 IDs？
head_mask (torch.FloatTensor，形状为 (num_heads,) 或 (num_layers, num_heads), 可选) — 用于使 self-attention 模块的选定头无效的掩码。掩码值在 [0, 1] 中选择：
- 1 表示头未被掩蔽，
- 0 表示头被掩蔽。
inputs_embeds (torch.FloatTensor，形状为 (batch_size, sequence_length, hidden_size), 可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递 input_ids。如果您希望比模型的内部嵌入查找矩阵更好地控制如何将 input_ids 索引转换为关联的向量，这将非常有用。
output_attentions (bool, 可选) — 是否返回所有 attention 层的 attention 张量。有关更多详细信息，请参见返回张量下的 attentions。
output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的 hidden_states。
return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。
labels (torch.LongTensor，形状为 (batch_size,), 可选) — 用于计算序列分类/回归损失的标签。索引应在 [0, ..., config.num_labels - 1] 中。如果 config.num_labels == 1，则计算回归损失（均方损失）。如果 config.num_labels > 1，则计算分类损失（交叉熵）。

Returns

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

一个 transformers.modeling_outputs.SequenceClassifierOutput 或一个 torch.FloatTensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），其中包含各种元素，具体取决于配置 (YosoConfig) 和输入。

loss (torch.FloatTensor，形状为 (1,), 可选，当提供 labels 时返回) — 分类（或回归，如果 config.num_labels==1）损失。
logits (torch.FloatTensor，形状为 (batch_size, config.num_labels)) — 分类（或回归，如果 config.num_labels==1）分数（在 SoftMax 之前）。
hidden_states (tuple(torch.FloatTensor), optional, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — torch.FloatTensor 的 Tuple (如果模型具有嵌入层，则为嵌入输出 + 每个层的输出各一个)，形状为 (batch_size, sequence_length, hidden_size)。

模型在每一层输出端的 Hidden-states，加上可选的初始嵌入输出。
attentions (tuple(torch.FloatTensor), optional, 当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — torch.FloatTensor 的 Tuple（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

attention softmax 后的 Attention 权重，用于计算 self-attention heads 中的加权平均值。

YosoForSequenceClassification 前向传播方法，覆盖了 __call__ 特殊方法。

单标签分类示例

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

>>> # 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

多标签分类示例

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

< source >

( config )

Parameters

config (YosoConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 from_pretrained() 方法来加载模型权重。

YOSO 模型，顶部带有多项选择分类头（池化输出顶部的线性层和一个 softmax），例如用于 RocStories/SWAG 任务。此模型是 PyTorch torch.nn.Module 子类。像常规 PyTorch 模块一样使用它，并参阅 PyTorch 文档以了解与通用用法和行为相关的所有事项。

forward

< source >

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

Parameters

input_ids (torch.LongTensor，形状为 (batch_size, num_choices, sequence_length)) — 词汇表中输入序列标记的索引。

可以使用 AutoTokenizer 获取索引。有关详细信息，请参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

什么是输入 IDs？
attention_mask (torch.FloatTensor，形状为 (batch_size, num_choices, sequence_length), 可选) — 避免在填充标记索引上执行 attention 的掩码。掩码值在 [0, 1] 中选择：
- 1 表示标记未被掩蔽，
- 0 表示标记被掩蔽。
什么是 attention 掩码？
token_type_ids (torch.LongTensor，形状为 (batch_size, num_choices, sequence_length), 可选) — 分段标记索引，用于指示输入的第一部分和第二部分。索引在 [0, 1] 中选择：
- 0 对应于 句子 A 标记，
- 1 对应于 句子 B 标记。
什么是标记类型 IDs？
position_ids (torch.LongTensor，形状为 (batch_size, num_choices, sequence_length), 可选) — 位置嵌入中每个输入序列标记的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。

什么是位置 IDs？
head_mask (torch.FloatTensor，形状为 (num_heads,) 或 (num_layers, num_heads), 可选) — 用于使 self-attention 模块的选定头无效的掩码。掩码值在 [0, 1] 中选择：
- 1 表示头未被掩蔽，
- 0 表示头被掩蔽。
inputs_embeds (torch.FloatTensor, 形状为 (batch_size, num_choices, sequence_length, hidden_size), 可选) — (可选) 您可以选择直接传递嵌入表示，而不是传递 input_ids。如果您希望比模型的内部嵌入查找矩阵更精细地控制如何将 input_ids 索引转换为关联向量，这将非常有用。
output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的 attentions。
output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的 hidden_states。
return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通的元组。
labels (torch.LongTensor, 形状为 (batch_size,), 可选) — 用于计算多项选择分类损失的标签。索引应在 [0, ..., num_choices-1] 中，其中 num_choices 是输入张量的第二个维度的大小。（请参阅上面的 input_ids）

Returns

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

一个 transformers.modeling_outputs.MultipleChoiceModelOutput 或 torch.FloatTensor 的元组（如果传递了 return_dict=False 或者当 config.return_dict=False 时），其中包含各种元素，具体取决于配置 (YosoConfig) 和输入。

loss (torch.FloatTensor, 形状为 (1,), 可选, 当提供 labels 时返回) — 分类损失。
logits (torch.FloatTensor, 形状为 (batch_size, num_choices)) — num_choices 是输入张量的第二个维度。（请参阅上面的 input_ids）。

分类得分（在 SoftMax 之前）。
hidden_states (tuple(torch.FloatTensor), optional, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — torch.FloatTensor 的 Tuple (如果模型具有嵌入层，则为嵌入输出 + 每个层的输出各一个)，形状为 (batch_size, sequence_length, hidden_size)。

模型在每一层输出端的 Hidden-states，加上可选的初始嵌入输出。
attentions (tuple(torch.FloatTensor), optional, 当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — torch.FloatTensor 的 Tuple（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

attention softmax 后的 Attention 权重，用于计算 self-attention heads 中的加权平均值。

YosoForMultipleChoice 前向方法，覆盖了 __call__ 特殊方法。

示例

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

< source >

( config )

Parameters

config (YosoConfig) — 带有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。

YOSO 模型，顶部带有 token 分类头（隐藏状态输出顶部的线性层），例如用于命名实体识别 (NER) 任务。此模型是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参阅 PyTorch 文档以获取与通用用法和行为相关的所有事项。

forward

< source >

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

Parameters

input_ids (torch.LongTensor, 形状为 (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。

可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

什么是输入 ID？
attention_mask (torch.FloatTensor, 形状为 (batch_size, sequence_length), 可选) — 掩码，以避免对 padding 标记索引执行注意力机制。掩码值在 [0, 1] 中选择：
- 1 表示标记未被掩盖，
- 0 表示标记被掩盖。
什么是注意力掩码？
token_type_ids (torch.LongTensor, 形状为 (batch_size, sequence_length), 可选) — 分段标记索引，用于指示输入的第一个和第二个部分。索引在 [0, 1] 中选择：
- 0 对应于 句子 A 标记，
- 1 对应于 句子 B 标记。
什么是标记类型 ID？
position_ids (torch.LongTensor, 形状为 (batch_size, sequence_length), 可选) — 每个输入序列标记在位置嵌入中的位置索引。在 [0, config.max_position_embeddings - 1] 范围内选择。

什么是位置 ID？
head_mask (torch.FloatTensor, 形状为 (num_heads,) 或 (num_layers, num_heads), 可选) — 掩码，用于使自注意力模块的选定头无效。掩码值在 [0, 1] 中选择：
- 1 表示头未被掩盖，
- 0 表示头被掩盖。
inputs_embeds (torch.FloatTensor, 形状为 (batch_size, sequence_length, hidden_size), 可选) — (可选) 您可以选择直接传递嵌入表示，而不是传递 input_ids。如果您希望比模型的内部嵌入查找矩阵更精细地控制如何将 input_ids 索引转换为关联向量，这将非常有用。
output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的 attentions。
output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的 hidden_states。
return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通的元组。
labels (torch.LongTensor, 形状为 (batch_size, sequence_length), 可选) — 用于计算 token 分类损失的标签。索引应在 [0, ..., config.num_labels - 1] 中。

Returns

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

一个 transformers.modeling_outputs.TokenClassifierOutput 或 torch.FloatTensor 的元组（如果传递了 return_dict=False 或者当 config.return_dict=False 时），其中包含各种元素，具体取决于配置 (YosoConfig) 和输入。

loss (torch.FloatTensor, 形状为 (1,), 可选, 当提供 labels 时返回) — 分类损失。
logits (torch.FloatTensor, 形状为 (batch_size, sequence_length, config.num_labels)) — 分类得分（在 SoftMax 之前）。
hidden_states (tuple(torch.FloatTensor), optional, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — torch.FloatTensor 的 Tuple (如果模型具有嵌入层，则为嵌入输出 + 每个层的输出各一个)，形状为 (batch_size, sequence_length, hidden_size)。

模型在每一层输出端的 Hidden-states，加上可选的初始嵌入输出。
attentions (tuple(torch.FloatTensor), optional, 当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — torch.FloatTensor 的 Tuple（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

attention softmax 后的 Attention 权重，用于计算 self-attention heads 中的加权平均值。

YosoForTokenClassification 前向方法，覆盖了 __call__ 特殊方法。

示例

>>> 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]]

>>> labels = predicted_token_class_ids
>>> loss = model(**inputs, labels=labels).loss

YosoForQuestionAnswering

class transformers.YosoForQuestionAnswering

< source >

( config )

Parameters

config (YosoConfig) — 带有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。

YOSO 模型，顶部带有跨度分类头，用于抽取式问答任务，如 SQuAD（隐藏状态输出顶部的线性层，用于计算 span start logits 和 span end logits）。此模型是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参阅 PyTorch 文档以获取与通用用法和行为相关的所有事项。

forward

< source >

( 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 or tuple(torch.FloatTensor)

Parameters

input_ids (torch.LongTensor，形状为 (batch_size, sequence_length)) — 词汇表中输入序列 tokens 的索引。

索引可以使用 AutoTokenizer 获得。参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call() 以了解详情。

什么是输入 IDs？
attention_mask (torch.FloatTensor，形状为 (batch_size, sequence_length)，可选) — 用于避免在 padding token 索引上执行 attention 的掩码。掩码值在 [0, 1] 中选择：
- 1 表示 tokens 未被掩码，
- 0 表示 tokens 已被掩码。
什么是注意力掩码？
token_type_ids (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — Segment token 索引，用于指示输入的第一部分和第二部分。索引在 [0, 1] 中选择：
- 0 对应于 句子 A token，
- 1 对应于 句子 B token。
什么是 token 类型 IDs？
position_ids (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 位置嵌入中每个输入序列 tokens 的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。

什么是位置 IDs？
head_mask (torch.FloatTensor，形状为 (num_heads,) 或 (num_layers, num_heads)，可选) — 用于 nullify self-attention 模块的选定 head 的掩码。掩码值在 [0, 1] 中选择：
- 1 表示 head 未被掩码，
- 0 表示 head 已被掩码。
inputs_embeds (torch.FloatTensor，形状为 (batch_size, sequence_length, hidden_size)，可选) — （可选）您可以选择直接传递嵌入表示而不是传递 input_ids。如果您希望比模型的内部嵌入查找矩阵更精细地控制如何将 input_ids 索引转换为关联的向量，这将非常有用。
output_attentions (bool，可选) — 是否返回所有 attention 层的 attentions 张量。有关更多详细信息，请参阅返回张量下的 attentions。
output_hidden_states (bool，可选) — 是否返回所有层的 hidden states。有关更多详细信息，请参阅返回张量下的 hidden_states。
return_dict (bool，可选) — 是否返回 ModelOutput 而不是普通元组。
start_positions (torch.LongTensor，形状为 (batch_size,)，可选) — 用于计算 token 分类损失的标签 span 起始位置（索引）。位置被钳制到序列的长度 (sequence_length)。序列之外的位置不计入损失计算。
end_positions (torch.LongTensor，形状为 (batch_size,)，可选) — 用于计算 token 分类损失的标签 span 结束位置（索引）。位置被钳制到序列的长度 (sequence_length)。序列之外的位置不计入损失计算。

Returns

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

一个 transformers.modeling_outputs.QuestionAnsweringModelOutput 或 torch.FloatTensor 的元组 (如果传递 return_dict=False 或当 config.return_dict=False 时)，包含各种元素，具体取决于配置 (YosoConfig) 和输入。

loss (torch.FloatTensor，形状为 (1,)，可选，当提供 labels 时返回) — 总 span 抽取损失是起始位置和结束位置的交叉熵之和。
start_logits (torch.FloatTensor，形状为 (batch_size, sequence_length)) — Span-start scores（SoftMax 之前）。
end_logits (torch.FloatTensor，形状为 (batch_size, sequence_length)) — Span-end scores（SoftMax 之前）。
hidden_states (tuple(torch.FloatTensor), optional, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — torch.FloatTensor 的 Tuple (如果模型具有嵌入层，则为嵌入输出 + 每个层的输出各一个)，形状为 (batch_size, sequence_length, hidden_size)。

模型在每一层输出端的 Hidden-states，加上可选的初始嵌入输出。
attentions (tuple(torch.FloatTensor), optional, 当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — torch.FloatTensor 的 Tuple（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

attention softmax 后的 Attention 权重，用于计算 self-attention heads 中的加权平均值。

YosoForQuestionAnswering forward 方法，覆盖了 __call__ 特殊方法。

示例

>>> 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]

>>> # 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

< > 在 GitHub 上更新

←XLNet Zamba→