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→