BROS

概述

BROS 模型在 BROS: A Pre-trained Language Model Focusing on Text and Layout for Better Key Information Extraction from Documents 这篇论文中被提出，作者是 Teakgyu Hong, Donghyun Kim, Mingi Ji, Wonseok Hwang, Daehyun Nam, Sungrae Park。

BROS 代表 BERT Relying On Spatiality。它是一个仅编码器 Transformer 模型，它接受 token 序列及其边界框作为输入，并输出隐藏状态序列。BROS 编码相对空间信息，而不是使用绝对空间信息。

它通过两个目标进行预训练：一个在 BERT 中使用的 token-masked 语言建模目标 (TMLM)，以及一个新的 area-masked 语言建模目标 (AMLM)。在 TMLM 中，token 被随机掩盖，模型使用空间信息和其他未掩盖的 token 预测被掩盖的 token。AMLM 是 TMLM 的 2D 版本。它随机掩盖文本 token，并使用与 TMLM 相同的信息进行预测，但它掩盖的是文本块（区域）。

BrosForTokenClassification 在 BrosModel 之上有一个简单的线性层。它预测每个 token 的标签。BrosSpadeEEForTokenClassification 在 BrosModel 之上有一个 initial_token_classifier 和 subsequent_token_classifier。initial_token_classifier 用于预测每个实体的第一个 token，subsequent_token_classifier 用于预测实体内的下一个 token。BrosSpadeELForTokenClassification 在 BrosModel 之上有一个 entity_linker。entity_linker 用于预测两个实体之间的关系。

BrosForTokenClassification 和 BrosSpadeEEForTokenClassification 本质上执行相同的工作。但是，BrosForTokenClassification 假设输入 token 被完美地序列化（这是一个非常具有挑战性的任务，因为它们存在于 2D 空间中），而 BrosSpadeEEForTokenClassification 在处理序列化错误时允许更大的灵活性，因为它从一个 token 预测下一个连接 token。

BrosSpadeELForTokenClassification 执行实体内链接任务。如果两个实体共享某些关系，它将预测从一个 token（一个实体的 token）到另一个 token（另一个实体的 token）的关系。

BROS 在关键信息提取 (KIE) 基准测试（如 FUNSD、SROIE、CORD 和 SciTSR）上取得了可比或更好的结果，而无需依赖显式的视觉特征。

该论文的摘要如下

从文档图像中提取关键信息 (KIE) 需要理解二维 (2D) 空间中文本的上下文和空间语义。许多最近的研究尝试通过开发预训练语言模型来解决该任务，这些模型侧重于将文档图像的视觉特征与文本及其布局相结合。另一方面，本文通过回归基本原理来解决这个问题：文本和布局的有效结合。具体来说，我们提出了一种预训练语言模型，名为 BROS (BERT Relying On Spatiality)，它编码 2D 空间中文本的相对位置，并通过区域掩码策略从无标签文档中学习。通过这种优化的训练方案来理解 2D 空间中的文本，BROS 在四个 KIE 基准测试（FUNSD、SROIE、CORD 和 SciTSR）上显示出与以前的方法相比具有可比或更好的性能，而无需依赖视觉特征。本文还揭示了 KIE 任务中的两个现实世界挑战——（1）最大限度地减少来自不正确文本排序的错误和（2）从较少的下游示例中高效学习——并证明了 BROS 相对于以前方法的优越性。*

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

使用提示和示例

forward() 需要 input_ids 和 bbox (边界框)。每个边界框应为 (x0, y0, x1, y1) 格式（左上角，右下角）。边界框的获取取决于外部 OCR 系统。x 坐标应通过文档图像宽度进行归一化，y 坐标应通过文档图像高度进行归一化。

def expand_and_normalize_bbox(bboxes, doc_width, doc_height):
    # here, bboxes are numpy array

    # Normalize bbox -> 0 ~ 1
    bboxes[:, [0, 2]] = bboxes[:, [0, 2]] / width
    bboxes[:, [1, 3]] = bboxes[:, [1, 3]] / height

[~transformers.BrosForTokenClassification.forward, ~transformers.BrosSpadeEEForTokenClassification.forward, ~transformers.BrosSpadeEEForTokenClassification.forward] 不仅需要 input_ids 和 bbox，还需要 box_first_token_mask 用于损失计算。它是一个用于过滤掉每个框的非第一个 token 的掩码。您可以通过在从单词创建 input_ids 时保存边界框的起始 token 索引来获得此掩码。您可以使用以下代码制作 box_first_token_mask，

def make_box_first_token_mask(bboxes, words, tokenizer, max_seq_length=512):

    box_first_token_mask = np.zeros(max_seq_length, dtype=np.bool_)

    # encode(tokenize) each word from words (List[str])
    input_ids_list: List[List[int]] = [tokenizer.encode(e, add_special_tokens=False) for e in words]

    # get the length of each box
    tokens_length_list: List[int] = [len(l) for l in input_ids_list]

    box_end_token_indices = np.array(list(itertools.accumulate(tokens_length_list)))
    box_start_token_indices = box_end_token_indices - np.array(tokens_length_list)

    # filter out the indices that are out of max_seq_length
    box_end_token_indices = box_end_token_indices[box_end_token_indices < max_seq_length - 1]
    if len(box_start_token_indices) > len(box_end_token_indices):
        box_start_token_indices = box_start_token_indices[: len(box_end_token_indices)]

    # set box_start_token_indices to True
    box_first_token_mask[box_start_token_indices] = True

    return box_first_token_mask

资源

演示脚本可以在这里找到。

BrosConfig

class transformers.BrosConfig

< 源代码 >

( vocab_size = 30522 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 = 512 type_vocab_size = 2 initializer_range = 0.02 layer_norm_eps = 1e-12 pad_token_id = 0 dim_bbox = 8 bbox_scale = 100.0 n_relations = 1 classifier_dropout_prob = 0.1 **kwargs )

参数

vocab_size (int, 可选, 默认为 30522) — Bros 模型的词汇表大小。定义了在调用 BrosModel 或 TFBrosModel 时传递的 inputs_ids 可以表示的不同 token 的数量。
hidden_size (int, optional, defaults to 768) — Encoder 层和池化层的维度。
num_hidden_layers (int, optional, defaults to 12) — Transformer Encoder 中隐藏层的数量。
num_attention_heads (int, optional, defaults to 12) — Transformer Encoder 中每个 attention 层的 attention heads 数量。
intermediate_size (int, optional, defaults to 3072) — Transformer Encoder 中 “intermediate”（通常被称为 feed-forward）层的维度。
hidden_act (str or Callable, optional, defaults to "gelu") — Encoder 和池化器中的非线性激活函数（函数或字符串）。如果为字符串，则支持 "gelu", "relu", "silu" 和 "gelu_new"。
hidden_dropout_prob (float, optional, defaults to 0.1) — embeddings、encoder 和池化器中所有全连接层的 dropout 概率。
attention_probs_dropout_prob (float, optional, defaults to 0.1) — attention 概率的 dropout 比率。
max_position_embeddings (int, optional, defaults to 512) — 此模型可能使用的最大序列长度。通常将其设置为较大的值以防万一（例如，512 或 1024 或 2048）。
type_vocab_size (int, optional, defaults to 2) — 调用 BrosModel 或 TFBrosModel 时传递的 token_type_ids 的词汇表大小。
initializer_range (float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
layer_norm_eps (float, optional, defaults to 1e-12) — layer normalization 层的 epsilon 值。
pad_token_id (int, optional, defaults to 0) — 词汇表中 padding token 的索引。
dim_bbox (int, optional, defaults to 8) — 边界框坐标的维度。 (x0, y1, x1, y0, x1, y1, x0, y1)
bbox_scale (float, optional, defaults to 100.0) — 边界框坐标的缩放因子。
n_relations (int, optional, defaults to 1) — SpadeEE（实体抽取）、SpadeEL（实体链接）头的关系数量。
classifier_dropout_prob (float, optional, defaults to 0.1) — 分类器头的 dropout 比率。

这是用于存储 BrosModel 或 TFBrosModel 配置的配置类。它用于根据指定的参数实例化 Bros 模型，定义模型架构。使用默认值实例化配置将产生与 Bros jinho8345/bros-base-uncased 架构类似的配置。

配置对象继承自 PretrainedConfig，可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。

示例

>>> from transformers import BrosConfig, BrosModel

>>> # Initializing a BROS jinho8345/bros-base-uncased style configuration
>>> configuration = BrosConfig()

>>> # Initializing a model from the jinho8345/bros-base-uncased style configuration
>>> model = BrosModel(configuration)

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

BrosProcessor

class transformers.BrosProcessor

< source >

( tokenizer = None **kwargs )

参数

tokenizer (BertTokenizerFast, optional) — [‘BertTokenizerFast`] 的实例。 tokenizer 是必需的输入。

构建一个 Bros processor，它包装了一个 BERT tokenizer。

BrosProcessor 提供了 BertTokenizerFast 的所有功能。有关更多信息，请参见 call() 和 decode() 的文档字符串。

call

< source >

( text: typing.Union[str, typing.List[str], typing.List[typing.List[str]]] = None add_special_tokens: bool = True padding: typing.Union[bool, str, transformers.utils.generic.PaddingStrategy] = False truncation: typing.Union[bool, str, transformers.tokenization_utils_base.TruncationStrategy] = None max_length: typing.Optional[int] = None stride: int = 0 pad_to_multiple_of: typing.Optional[int] = None return_token_type_ids: typing.Optional[bool] = None return_attention_mask: typing.Optional[bool] = None return_overflowing_tokens: bool = False return_special_tokens_mask: bool = False return_offsets_mapping: bool = False return_length: bool = False verbose: bool = True return_tensors: typing.Union[str, transformers.utils.generic.TensorType, NoneType] = None **kwargs )

此方法使用 BertTokenizerFast.call() 来准备模型的文本。

有关更多信息，请参考以上两种方法的文档字符串。

BrosModel

class transformers.BrosModel

< source >

( config add_pooling_layer = True )

参数

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

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

forward

< source >

( input_ids: typing.Optional[torch.Tensor] = None bbox: 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 encoder_hidden_states: typing.Optional[torch.Tensor] = None encoder_attention_mask: typing.Optional[torch.Tensor] = None past_key_values: typing.Optional[typing.List[torch.FloatTensor]] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions or tuple(torch.FloatTensor)

参数

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

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

什么是 input IDs？
bbox (‘torch.FloatTensor’ of shape ‘(batch_size, num_boxes, 4)’) — 输入序列中每个 token 的边界框坐标。每个边界框是四个值 (x1, y1, x2, y2) 的列表，其中 (x1, y1) 是左上角，(x2, y2) 是边界框的右下角。
attention_mask (torch.FloatTensor of shape (batch_size, sequence_length), optional) — 用于避免在 padding token 索引上执行 attention 的掩码。掩码值在 [0, 1] 中选择：
- 1 表示 token 未被掩盖，
- 0 表示 token 被掩盖。
什么是 attention 掩码？
bbox_first_token_mask (torch.FloatTensor of shape (batch_size, sequence_length), optional) — 用于指示每个边界框的第一个 token 的掩码。掩码值在 [0, 1] 中选择：
- 1 表示 token 未被掩盖，
- 0 表示 token 被掩盖。
token_type_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 用于指示输入的第一部分和第二部分的片段 token 索引。索引在 [0, 1] 中选择：
- 0 对应于 句子 A token，
- 1 对应于 句子 B token。
什么是 token 类型 ID？
position_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 每个输入序列 token 在位置嵌入中的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。

什么是位置 ID？
head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) — 用于 nullify 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。

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

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

last_hidden_state (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size)) — 模型最后一层的输出处的 hidden-states 序列。
pooler_output (torch.FloatTensor of shape (batch_size, hidden_size)) — 序列的第一个 token（分类 token）的最后一层 hidden-state，在通过用于辅助预训练任务的层进一步处理之后。例如，对于 BERT 系列模型，这返回通过线性层和 tanh 激活函数处理后的分类 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 weights，用于计算 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 weights，在 attention softmax 之后，用于计算 cross-attention heads 中的加权平均值。
past_key_values (tuple(tuple(torch.FloatTensor)), optional, 当传递 use_cache=True 或当 config.use_cache=True 时返回) — tuple(torch.FloatTensor) 的 tuple，长度为 config.n_layers，每个 tuple 有 2 个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head) 的 tensors，并且如果 config.is_encoder_decoder=True，则可选地有 2 个形状为 (batch_size, num_heads, encoder_sequence_length, embed_size_per_head) 的额外 tensors。

包含预先计算的 hidden-states（self-attention 块中的 key 和 values，以及可选地，如果 config.is_encoder_decoder=True，则在 cross-attention 块中），可以用于（参见 past_key_values 输入）加速顺序解码。

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

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

示例

>>> import torch
>>> from transformers import BrosProcessor, BrosModel

>>> processor = BrosProcessor.from_pretrained("jinho8345/bros-base-uncased")

>>> model = BrosModel.from_pretrained("jinho8345/bros-base-uncased")

>>> encoding = processor("Hello, my dog is cute", add_special_tokens=False, return_tensors="pt")
>>> bbox = torch.tensor([[[0, 0, 1, 1]]]).repeat(1, encoding["input_ids"].shape[-1], 1)
>>> encoding["bbox"] = bbox

>>> outputs = model(**encoding)
>>> last_hidden_states = outputs.last_hidden_state

BrosForTokenClassification

class transformers.BrosForTokenClassification

< source >

( config )

参数

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

Bros 模型，顶部带有一个 token 分类 head（hidden-states 输出顶部的线性层），例如用于命名实体识别 (NER) 任务。

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

forward

< source >

( input_ids: typing.Optional[torch.Tensor] = None bbox: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None bbox_first_token_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 or tuple(torch.FloatTensor)

参数

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

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

什么是输入 ID？
bbox (‘torch.FloatTensor’ of shape ‘(batch_size, num_boxes, 4)’) — 输入序列中每个 token 的边界框坐标。每个边界框是四个值 (x1, y1, x2, y2) 的列表，其中 (x1, y1) 是左上角，(x2, y2) 是边界框的右下角。
attention_mask (torch.FloatTensor of shape (batch_size, sequence_length), optional) — 用于避免在 padding token 索引上执行 attention 的掩码。掩码值在 [0, 1] 中选择：
- 1 表示 token 未被掩盖，
- 0 表示 token 被掩盖。
什么是 attention 掩码？
bbox_first_token_mask (torch.FloatTensor of shape (batch_size, sequence_length), optional) — 用于指示每个边界框的第一个 token 的掩码。掩码值在 [0, 1] 中选择：
- 1 表示 token 未被掩盖，
- 0 表示 token 被掩盖。
token_type_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 用于指示输入的第一部分和第二部分的片段 token 索引。索引在 [0, 1] 中选择：
- 0 对应于 句子 A token，
- 1 对应于 句子 B token。
什么是 token 类型 ID？
position_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 每个输入序列 token 在位置嵌入中的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。

什么是位置 ID？
head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) — 用于 nullify 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。
return_dict (bool, optional) — 是否返回 ModelOutput 而不是一个纯粹的元组。

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

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

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 weights，用于计算 self-attention heads 中的加权平均值。

BrosForTokenClassification 的 forward 方法，覆盖了 __call__ 特殊方法。

示例

>>> import torch
>>> from transformers import BrosProcessor, BrosForTokenClassification

>>> processor = BrosProcessor.from_pretrained("jinho8345/bros-base-uncased")

>>> model = BrosForTokenClassification.from_pretrained("jinho8345/bros-base-uncased")

>>> encoding = processor("Hello, my dog is cute", add_special_tokens=False, return_tensors="pt")
>>> bbox = torch.tensor([[[0, 0, 1, 1]]]).repeat(1, encoding["input_ids"].shape[-1], 1)
>>> encoding["bbox"] = bbox

>>> outputs = model(**encoding)

BrosSpadeEEForTokenClassification

class transformers.BrosSpadeEEForTokenClassification

< source >

( config )

参数

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

带有 token classification 头的 Bros 模型 (在隐藏状态输出之上的 initial_token_layers 和 subsequent_token_layer)，例如用于命名实体识别 (NER) 任务。 initial_token_classifier 用于预测每个实体的第一个 token，而 subsequent_token_classifier 用于预测实体内的后续 token。与 BrosForTokenClassification 相比，此模型对序列化错误更鲁棒，因为它从一个 token 预测下一个 token。

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

forward

< source >

( input_ids: typing.Optional[torch.Tensor] = None bbox: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None bbox_first_token_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 initial_token_labels: typing.Optional[torch.Tensor] = None subsequent_token_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.models.bros.modeling_bros.BrosSpadeOutput 或 tuple(torch.FloatTensor)

参数

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

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

什么是输入 ID？
bbox (‘torch.FloatTensor’，形状为 ‘(batch_size, num_boxes, 4)’) — 输入序列中每个 token 的边界框坐标。每个边界框是四个值 (x1, y1, x2, y2) 的列表，其中 (x1, y1) 是左上角，(x2, y2) 是边界框的右下角。
attention_mask (torch.FloatTensor，形状为 (batch_size, sequence_length)，可选) — 掩码，以避免在 padding token 索引上执行 attention。 Mask 值在 [0, 1] 中选择：
- 1 表示 token 未被掩码，
- 0 表示 token 被掩码。
什么是 attention 掩码？
bbox_first_token_mask (torch.FloatTensor，形状为 (batch_size, sequence_length)，可选) — 掩码，指示每个边界框的第一个 token。 Mask 值在 [0, 1] 中选择：
- 1 表示 token 未被掩码，
- 0 表示 token 被掩码。
token_type_ids (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — Segment token 索引以指示输入的第一部分和第二部分。索引在 [0, 1] 中选择：
- 0 对应于 sentence A token，
- 1 对应于 sentence B token。
什么是 token 类型 ID？
position_ids (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 每个输入序列 token 在位置嵌入中的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。

什么是位置 ID？
head_mask (torch.FloatTensor，形状为 (num_heads,) 或 (num_layers, num_heads)，可选) — 掩码，用于使 self-attention 模块的选定 head 无效。 Mask 值在 [0, 1] 中选择：
- 1 表示 head 未被掩码，
- 0 表示 head 被掩码。
inputs_embeds (torch.FloatTensor，形状为 (batch_size, sequence_length, hidden_size)，可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递 input_ids。如果您想要比模型的内部嵌入查找矩阵更精细地控制如何将 input_ids 索引转换为关联向量，这将非常有用。
output_attentions (bool, optional) — 是否返回所有 attention 层的 attention 张量。更多细节请查看返回张量下的 attentions。
output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。更多细节请查看返回张量下的 hidden_states。
return_dict (bool, optional) — 是否返回 ModelOutput 而不是一个纯粹的元组。

transformers.models.bros.modeling_bros.BrosSpadeOutput 或 tuple(torch.FloatTensor)

一个 transformers.models.bros.modeling_bros.BrosSpadeOutput 或一个 torch.FloatTensor 元组 (如果传递了 return_dict=False 或者当 config.return_dict=False 时)，其中包含各种元素，具体取决于配置 (BrosConfig) 和输入。

loss (torch.FloatTensor，形状为 (1,)，可选，当提供 labels 时返回) — 分类损失。
initial_token_logits (torch.FloatTensor，形状为 (batch_size, sequence_length, config.num_labels)) — 实体初始 token 的分类得分 (在 SoftMax 之前)。
subsequent_token_logits (torch.FloatTensor，形状为 (batch_size, sequence_length, sequence_length+1)) — 实体序列 token 的分类得分 (在 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 weights，用于计算 self-attention heads 中的加权平均值。

BrosSpadeEEForTokenClassification 的 forward 方法，覆盖了 __call__ 特殊方法。

示例

>>> import torch
>>> from transformers import BrosProcessor, BrosSpadeEEForTokenClassification

>>> processor = BrosProcessor.from_pretrained("jinho8345/bros-base-uncased")

>>> model = BrosSpadeEEForTokenClassification.from_pretrained("jinho8345/bros-base-uncased")

>>> encoding = processor("Hello, my dog is cute", add_special_tokens=False, return_tensors="pt")
>>> bbox = torch.tensor([[[0, 0, 1, 1]]]).repeat(1, encoding["input_ids"].shape[-1], 1)
>>> encoding["bbox"] = bbox

>>> outputs = model(**encoding)

BrosSpadeELForTokenClassification

class transformers.BrosSpadeELForTokenClassification

< source >

( config )

参数

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

带有 token classification 头的 Bros 模型 (在隐藏状态输出之上的 entity_linker 层)，例如用于实体链接。 entity_linker 用于预测实体内部链接 (一个实体到另一个实体)。

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

forward

< source >

参数

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

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

什么是输入 IDs？
bbox (torch.FloatTensor，形状为 (batch_size, num_boxes, 4)) — 输入序列中每个 token 的边界框坐标。每个边界框是四个值 (x1, y1, x2, y2) 的列表，其中 (x1, y1) 是左上角，(x2, y2) 是边界框的右下角。
attention_mask (torch.FloatTensor，形状为 (batch_size, sequence_length), 可选) — 用于避免在 padding token 索引上执行 attention 的 Mask。 Mask 值在 [0, 1] 中选择：
- 1 表示 token 未被 masking，
- 0 表示 token 已被 masking。
什么是 attention mask？
bbox_first_token_mask (torch.FloatTensor，形状为 (batch_size, sequence_length), 可选) — 用于指示每个边界框的第一个 token 的 Mask。 Mask 值在 [0, 1] 中选择：
- 1 表示 token 未被 masking，
- 0 表示 token 已被 masking。
token_type_ids (torch.LongTensor，形状为 (batch_size, sequence_length), 可选) — 分段 token 索引，用于指示输入的第一个和第二个部分。索引在 [0, 1] 中选择：
- 0 对应于 sentence A token，
- 1 对应于 sentence B token。
什么是 token type IDs？
position_ids (torch.LongTensor，形状为 (batch_size, sequence_length), 可选) — 位置嵌入中每个输入序列 token 的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。

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

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

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 weights，用于计算 self-attention heads 中的加权平均值。

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

示例

>>> import torch
>>> from transformers import BrosProcessor, BrosSpadeELForTokenClassification

>>> processor = BrosProcessor.from_pretrained("jinho8345/bros-base-uncased")

>>> model = BrosSpadeELForTokenClassification.from_pretrained("jinho8345/bros-base-uncased")

>>> encoding = processor("Hello, my dog is cute", add_special_tokens=False, return_tensors="pt")
>>> bbox = torch.tensor([[[0, 0, 1, 1]]]).repeat(1, encoding["input_ids"].shape[-1], 1)
>>> encoding["bbox"] = bbox

>>> outputs = model(**encoding)

< > 在 GitHub 上更新

Transformers

BROS

概述

使用提示和示例

资源

BrosConfig

class transformers.BrosConfig

BrosProcessor

class transformers.BrosProcessor

__call__

BrosModel

class transformers.BrosModel

forward

BrosForTokenClassification

class transformers.BrosForTokenClassification

forward

BrosSpadeEEForTokenClassification

class transformers.BrosSpadeEEForTokenClassification

forward

BrosSpadeELForTokenClassification

class transformers.BrosSpadeELForTokenClassification

forward

call