该模型于 2021-11-18 发布，并于 2022-01-26 添加到 Hugging Face Transformers 中。

YOSO

概述

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 模型的核心是自注意力机制，它捕捉输入序列中标记对（token pairs）的交互，并与序列长度呈平方相关。在较长序列上训练此类模型的成本非常高。在本文中，我们展示了一种基于局部敏感哈希 (LSH) 的伯努利采样注意力机制，将此类模型的平方复杂度降低为线性。我们通过将自注意力视为与伯努利随机变量相关的单个标记的总和，从而绕过了平方成本，原则上这些变量可以通过单次哈希同时采样（尽管在实践中，这个数字可能是一个较小的常数）。这导致了一种估计自注意力的有效采样方案，该方案依赖于 LSH 的特定修改（以实现在 GPU 架构上的部署）。我们在标准 512 序列长度的 GLUE 基准测试中评估了我们的算法，看到其性能优于标准的预训练 Transformer。在用于评估长序列性能的 Long Range Arena (LRA) 基准测试中，我们的方法取得了与 softmax 自注意力一致的结果，但显著提高了速度并节省了内存，且通常优于其他高效自注意力方法。我们的代码可在该 HTTP 链接处获取。

该模型由 novice03 贡献。原始代码可以在这里找到。

使用技巧

YOSO 注意力算法是通过自定义 CUDA 内核实现的，这些内核是用 CUDA C++ 编写的函数，可以在 GPU 上多次并行执行。
这些内核提供了一个 fast_hash 函数，它使用快速哈达玛变换（Fast Hadamard Transform）来近似查询（queries）和键（keys）的随机投影。利用这些哈希码，lsh_cumulation 函数通过基于 LSH 的伯努利采样来近似自注意力。
要使用自定义内核，用户应设置 config.use_expectation = False。为了确保内核编译成功，用户必须安装正确版本的 PyTorch 和 cudatoolkit。默认情况下，config.use_expectation = True，这将使用 YOSO-E，不需要编译 CUDA 内核。

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

资源

YosoConfig

class transformers.YosoConfig

< 源码 >

( 此处为配置参数列表，通常保持代码原样 )

参数

vocab_size (int, 可选, 默认为 50265) — YOSO 模型的词表大小。定义了调用 YosoModel 时传递的 inputs_ids 可以表示的不同标记的数量。
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) — 注意力概率的丢弃比例。
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 值。
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, 可选, 默认为 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 model_args: ~utils.generic.ModelArgs | None = None adapter_args: ~utils.generic.AdapterArgs | None = None lora_args: ~utils.generic.LoRAArgs | None = None tokenizer_args: ~utils.generic.TokenizerArgs | None = None dataset_args: ~utils.generic.DatasetArgs | None = None data_args: ~utils.generic.DataArgs | None = None training_args: ~utils.generic.TrainingArgs | None = None generation_args: ~utils.generic.GenerationArgs | None = None vision_tower_args: ~utils.generic.VisionTowerArgs | None = None qlora_args: ~utils.generic.QLoRAArgs | None = None vision_tower_template_args: ~utils.generic.VisionTowerTemplateArgs | None = None video_tower_args: ~utils.generic.VideoTowerArgs | None = None vision_config: ~utils.generic.VisionConfig | None = None video_config: ~utils.generic.VideoConfig | None = None load_dataset: bool | None = None load_data_collator: bool | None = None load_processor: bool | None = None load_lora_adapter: bool | None = None load_adapter: bool | None = None load_qlora_adapter: bool | None = None **kwargs: typing_extensions.Unpack[transformers.modeling_utils.PreTrainedModelKwargs] )

参数

config (YosoModel) — 包含模型所有参数的模型配置类。使用配置文件进行初始化不会加载模型相关的权重，只加载配置。请查看 from_pretrained() 方法来加载模型权重。

基础的 Yoso 模型，输出原始隐藏状态，顶部没有任何特定头。

此模型继承自 PreTrainedModel。查看其父类文档，了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪头等）。

此模型也是一个 PyTorch torch.nn.Module 子类。像普通的 PyTorch Module 一样使用它，并参考 PyTorch 文档了解一般用法和行为的所有相关信息。

forward

< 源码 >

( 此处为 forward 方法的参数定义，保持原样 )

参数

input_ids (形状为 (batch_size, sequence_length) 的 torch.Tensor，可选) — 词表中输入序列标记的索引。默认情况下将忽略填充。

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

什么是输入 ID？
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？
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 or 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), optional, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — torch.FloatTensor 的元组（一个用于嵌入层的输出，如果模型有嵌入层；+一个用于每个层的输出），形状为 (batch_size, sequence_length, hidden_size)。

模型在每个层输出的隐藏状态以及可选的初始嵌入输出。
attentions (tuple(torch.FloatTensor), optional, 当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — torch.FloatTensor 的元组（每个层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。
cross_attentions (tuple(torch.FloatTensor), optional, returned when output_attentions=True and config.add_cross_attention=True is passed or when config.output_attentions=True) — Tuple of torch.FloatTensor (one for each layer) of shape (batch_size, num_heads, sequence_length, sequence_length).

解码器交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均。

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

虽然 forward pass 的实现需要在此函数中定义，但你应该在之后调用 Module 实例而不是这个，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。

YosoForMaskedLM

class transformers.YosoForMaskedLM

< 源码 >

参数

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

顶部带有 语言建模 (language modeling) 头的 Yoso 模型。

此模型继承自 PreTrainedModel。查看其父类文档，了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪头等）。

此模型也是一个 PyTorch torch.nn.Module 子类。像普通的 PyTorch Module 一样使用它，并参考 PyTorch 文档了解一般用法和行为的所有相关信息。

forward

< 源码 >

( input_ids: torch.Tensor | None = None attention_mask: torch.Tensor | None = None token_type_ids: torch.Tensor | None = None position_ids: torch.Tensor | None = None inputs_embeds: torch.Tensor | None = None labels: torch.Tensor | None = None output_attentions: bool | None = None output_hidden_states: bool | None = None return_dict: bool | None = None **kwargs ) → transformers.modeling_outputs.MaskedLMOutput 或 tuple(torch.FloatTensor)

参数

input_ids (形状为 (batch_size, sequence_length) 的 torch.Tensor，可选) — 词汇表中输入序列标记的索引。默认情况下将忽略填充。

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

什么是输入 ID？
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？
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), optional, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — torch.FloatTensor 的元组（一个用于嵌入层的输出，如果模型有嵌入层；+一个用于每个层的输出），形状为 (batch_size, sequence_length, hidden_size)。

模型在每个层输出的隐藏状态以及可选的初始嵌入输出。
attentions (tuple(torch.FloatTensor), optional, 当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — torch.FloatTensor 的元组（每个层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

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

虽然 forward pass 的实现需要在此函数中定义，但你应该在之后调用 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 (YosoForSequenceClassification) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只加载配置。请查看 from_pretrained() 方法来加载模型权重。

顶部带有序列分类/回归头（池化输出之上的线性层）的 YOSO Transformer 模型，例如用于 GLUE 任务。

此模型继承自 PreTrainedModel。查看其父类文档，了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪头等）。

此模型也是一个 PyTorch torch.nn.Module 子类。像普通的 PyTorch Module 一样使用它，并参考 PyTorch 文档了解一般用法和行为的所有相关信息。

forward

< 源码 >

参数

input_ids (形状为 (batch_size, sequence_length) 的 torch.Tensor，可选) — 词汇表中输入序列标记的索引。默认情况下将忽略填充。

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

什么是输入 ID？
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？
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), optional, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — torch.FloatTensor 的元组（一个用于嵌入层的输出，如果模型有嵌入层；+一个用于每个层的输出），形状为 (batch_size, sequence_length, hidden_size)。

模型在每个层输出的隐藏状态以及可选的初始嵌入输出。
attentions (tuple(torch.FloatTensor), optional, 当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — torch.FloatTensor 的元组（每个层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

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

虽然 forward pass 的实现需要在此函数中定义，但你应该在之后调用 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 (YosoForMultipleChoice) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只加载配置。请查看 from_pretrained() 方法来加载模型权重。

顶部带有多项选择分类头的 Yoso 模型（池化输出之上的线性层和 softmax），例如用于 RocStories/SWAG 任务。

此模型继承自 PreTrainedModel。查看其父类文档，了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪头等）。

此模型也是一个 PyTorch torch.nn.Module 子类。像普通的 PyTorch Module 一样使用它，并参考 PyTorch 文档了解一般用法和行为的所有相关信息。

forward

< 源码 >

参数

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

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

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

什么是位置 ID？
inputs_embeds (形状为 (batch_size, num_choices, sequence_length, hidden_size) 的 torch.FloatTensor，可选) — 可选地，你可以选择直接传递嵌入表示，而不是传递 input_ids。如果你希望比模型内部的嵌入查找矩阵更自主地控制如何将 input_ids 索引转换为关联向量，这将非常有用。
labels (形状为 (batch_size,) 的 torch.LongTensor，可选) — 用于计算多项选择分类损失的标签。索引应在 [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), optional, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — torch.FloatTensor 的元组（一个用于嵌入层的输出，如果模型有嵌入层；+一个用于每个层的输出），形状为 (batch_size, sequence_length, hidden_size)。

模型在每个层输出的隐藏状态以及可选的初始嵌入输出。
attentions (tuple(torch.FloatTensor), optional, 当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — torch.FloatTensor 的元组（每个层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

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

虽然 forward pass 的实现需要在此函数中定义，但你应该在之后调用 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 (YosoForTokenClassification) — 包含模型所有参数的模型配置类。使用配置文件进行初始化不会加载与模型相关的权重，只加载配置。请查看 from_pretrained() 方法来加载模型权重。

Yoso Transformer 顶部带有标记分类头（隐藏状态输出之上的线性层），例如用于命名实体识别（NER）任务。

此模型继承自 PreTrainedModel。查看其父类文档，了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪头等）。

此模型也是一个 PyTorch torch.nn.Module 子类。像普通的 PyTorch Module 一样使用它，并参考 PyTorch 文档了解一般用法和行为的所有相关信息。

forward

< 源码 >

参数

input_ids (torch.Tensor，形状为 (batch_size, sequence_length)，可选) — 词汇表中输入序列标记的索引。默认情况下将忽略填充（Padding）。

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

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

什么是位置 ID？
inputs_embeds (torch.Tensor，形状为 (batch_size, sequence_length, hidden_size)，可选) — 可选地，你可以选择直接传递嵌入表示，而不是传递 input_ids。如果你想比模型内部的嵌入查找矩阵更自主地控制如何将 input_ids 索引转换为关联向量，这将非常有用。
labels (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 用于计算标记分类损失的标签。索引应在 [0, ..., config.num_labels - 1] 范围内。
output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。详情请参阅返回张量下的 attentions。
output_hidden_states (bool，可选) — 是否返回所有层级的隐藏状态。详情请参阅返回张量下的 hidden_states。
return_dict (bool，可选) — 是否返回 ModelOutput 而非普通元组。

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

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

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

模型在每个层输出的隐藏状态以及可选的初始嵌入输出。
attentions (tuple(torch.FloatTensor), optional, 当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — torch.FloatTensor 的元组（每个层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

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

虽然 forward pass 的实现需要在此函数中定义，但你应该在之后调用 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 (YosoForQuestionAnswering) — 包含模型所有参数的模型配置类。使用配置文件进行初始化不会加载与模型相关的权重，只加载配置。请查看 from_pretrained() 方法来加载模型权重。

Yoso Transformer 顶部带有跨度分类头，用于 SQuAD 等抽取式问答任务（在隐藏状态输出之上的线性层，用于计算 跨度起始对数几率 和 跨度结束对数几率）。

此模型继承自 PreTrainedModel。查看其父类文档，了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪头等）。

此模型也是一个 PyTorch torch.nn.Module 子类。像普通的 PyTorch Module 一样使用它，并参考 PyTorch 文档了解一般用法和行为的所有相关信息。

forward

< 源码 >

( input_ids: torch.Tensor | None = None attention_mask: torch.Tensor | None = None token_type_ids: torch.Tensor | None = None position_ids: torch.Tensor | None = None inputs_embeds: torch.Tensor | None = None start_positions: torch.Tensor | None = None end_positions: torch.Tensor | None = None output_attentions: bool | None = None output_hidden_states: bool | None = None return_dict: bool | None = None **kwargs ) → transformers.modeling_outputs.QuestionAnsweringModelOutput 或 tuple(torch.FloatTensor)

参数

input_ids (torch.Tensor，形状为 (batch_size, sequence_length)，可选) — 词汇表中输入序列标记的索引。默认情况下将忽略填充。

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

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

什么是位置 ID？
inputs_embeds (torch.Tensor，形状为 (batch_size, sequence_length, hidden_size)，可选) — 可选地，你可以选择直接传递嵌入表示，而不是传递 input_ids。如果你想比模型内部的嵌入查找矩阵更自主地控制如何将 input_ids 索引转换为关联向量，这将非常有用。
start_positions (torch.Tensor，形状为 (batch_size,)，可选) — 用于计算标记分类损失的标注跨度起始位置（索引）标签。位置会被限制在序列长度（sequence_length）范围内。序列以外的位置在计算损失时不予考虑。
end_positions (torch.Tensor，形状为 (batch_size,)，可选) — 用于计算标记分类损失的标注跨度结束位置（索引）标签。位置会被限制在序列长度（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), optional, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — torch.FloatTensor 的元组（一个用于嵌入层的输出，如果模型有嵌入层；+一个用于每个层的输出），形状为 (batch_size, sequence_length, hidden_size)。

模型在每个层输出的隐藏状态以及可选的初始嵌入输出。
attentions (tuple(torch.FloatTensor), optional, 当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — torch.FloatTensor 的元组（每个层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

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

虽然 forward pass 的实现需要在此函数中定义，但你应该在之后调用 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 上更新